Антиферромагнетизм - це те, що дослідники IBM використовували для переходу з 1 терабайтного диска на 100 терабайтний диск у тій же кількості атомів.

У матеріалах, що виявляють антиферромагнетизм, магнітні моменти атомів чи молекул, як правило, пов'язані зі спінами електронів, вирівнюються за регулярною схемою із сусідніми спінами (на різних підрешітках), спрямованими у протилежні сторони.

Ваше завдання - написати програму, яка малює впорядкування антиферромагнітних атомів, як на малюнку, показаному вище. Ви повинні мати можливість принаймні чотири набори пар, хоча ви можете мати більше.

Кожна пара повинна бути показана наступним чином, хоча вони повинні бути фактичними стрілками :

 вверх вниз
вниз вгору
 вверх вниз

Ваш вихід може бути в мистецтві ascii або графічному виведенні.

Ви можете зробити лише функцію або всю програму, але вона повинна взяти вклад і намалювати стільки пар. Приклади, що містять лише слова :

Вхід: 1

 вверх вниз
вниз вгору
 вверх вниз

Вхід: 2

 вгору вниз вгору вниз 
вниз вгору вниз вгору  
 вгору вниз вгору вниз

Допустимі стрілки:

• ↑ і ↓
• ⇅ і ⇵
• /|\ і \|/

Будь ласка, введіть свої відповіді у форматі Мова, X байт , оскільки це легко читати. Найменша кількість байтів виграє!

APL, 18 12 байт

⍉(2×⎕)3⍴'↑↓'

Це будує матрицю 2n x 3, де n - вхід ( ⎕), заповнений символами ↑та ↓. Потім транспонується ( ⍉) цієї матриці друкується.

Ви можете спробувати в Інтернеті .

Pyth, 15 байт (11 символів)

V3.>*Q"↑↓"N

Спробуйте в Інтернеті: Демонстрація

Пояснення:

              implicit: Q = input number
V3            for N in [0, 1, 2]:
      "↑↓"       string "↑↓"
    *Q           repeat Q times
  .>      N      rotate the string by N

Java, 313 296 байт

Ось приклад, який відображає стрілки графічно:

import java.awt.*;void f(int n){new Frame(){public void paint(Graphics g){for(int k=0,l,m,o;k<n*6;o=k%6,l=o/2*10+32,m=k/6*20+(k++%2==0?19:29),g.fillPolygon(new int[]{m+4,m,m+4,m+4,m+6,m+6,m+10},o==1|o==2|o==5?new int[]{l+9,l+5,l+5,l,l,l+5,l+5}:new int[]{l,l+5,l+5,l+9,l+9,l+5,l+5},7));}}.show();}

У більш читаному форматі:

import java.awt.*;
void f(int n) {
    new Frame() {
        public void paint(Graphics g) {
            for (int k = 0, l, m, o; k < n*6;){
                o = k % 6;
                l = o / 2 * 10 + 32;
                m = k / 6 * 20 + (k++ % 2 == 0 ? 19 : 29);
                g.fillPolygon(new int[] {m+4,m,m+4,m+4,m+6,m+6,m+10},
                              o == 1 || o == 2 || o == 5 ?
                                  new int[] {l+9,l+5,l+5,l,l,l+5,l+5} :
                                  new int[] {l,l+5,l+5,l+9,l+9,l+5,l+5},
                              7);
            }
        }
    }.show();
}

Дисплей для 5 як вхід:

Вам доведеться змінити розмір вікна, яке відображається, щоб побачити стрілки. Я намагався зробити так, щоб жодна з них не виглядала «порубаною» внутрішньою межею вікна, але це може відображатися таким чином на певних платформах.

CJam, 18 байт (14 символів)

ri3*"↑↓"*3/zN*

Створіть стовпці (які утворюють повторюваний візерунок), потім перекладіть.

Спробуйте в Інтернеті .

Альтернативно 18 байт:

3,ri"↑↓"*fm>N*

Оберніть рядок "↑↓"*nна 0, 1 або 2 рази.

CJam (15 символів, 19 байт)

ri"↑↓"*_(+1$]N*

Демонстрація в Інтернеті

Befunge, 71 байт

Моя перша відповідь, тому будь ласка, будь ласка зі мною: o)

Набридливі проблеми з вирівнюванням призвели до кількох марних байтів, якщо у вас є якісь покращення для мене, я хотів би їх почути!

&::3>:2% #v_0#v" \|/ "<
  >\^,*52<> 0#v" /|\ "<
:#^_$1-:#^_@  >:#,_$\1-

Вхід: 4

 /|\  \|/  /|\  \|/  /|\  \|/  /|\  \|/ 
 \|/  /|\  \|/  /|\  \|/  /|\  \|/  /|\ 
 /|\  \|/  /|\  \|/  /|\  \|/  /|\  \|/ 

CJam, 14 байт

0000000: 332c 7269 2218 1922 2a66 6d3e 4e2a       3,ri".."*fm>N*

Для цього потрібен підтримуючий термінал, який надає кодову сторінку 850 так:

Неточна частина коду виявилася ідентичною альтернативній версії @ Sp3000 .

CJam, 17 байт

ri"⇅⇵⇅"f*N*

Варіант подвійної стрілки з подвійною стрілкою, з кредитами на @DigitalTrauma.

Спробуйте в Інтернеті.

Pyth, 16 байт (12 символів)

J"↑↓"V3*~_JQ

Приклад:

Input: 4
Output:
↑↓↑↓↑↓↑↓
↓↑↓↑↓↑↓↑
↑↓↑↓↑↓↑↓

Python 2, 131 122 байт

from turtle import*
for k in range(input()*6):z=k/3+k%3&1;pu();goto(k/3*32,z*32^k%3*64);pd();seth(z*180+90);fd(32);stamp()

Ну ... я обіграв C Java, мабуть?

Я вибрав висоту 32для стрілок, яка досить велика, тому через деякий час черепаха починає малювати екрани. Якщо ви хочете, щоб усе підходило для великих входів, ви можете або зменшити стрілки, замінивши 32s, або скористатися screensize()(я не впевнений, чи є мета-повідомлення на екранній вихід…)

GNU sed, 25 байт

Я знайшов символи стрілок ⇅і ⇵unicode, які дозволяють більше скоротити, і цей коментар був дозволений :

h
s/1/⇅/g
H
G
s/1/⇵/g

Введення не одиничне , тому, наприклад, 4 1111:

$ echo 1 | sed -f antiferro.sed
⇅
⇵
⇅
$ echo 1111 | sed -f antiferro.sed
⇅⇅⇅⇅
⇵⇵⇵⇵
⇅⇅⇅⇅
$ 

Попередня відповідь у випадку ⇅та⇵ не допускається:

GNU sed, 39 байт

s/1/↑↓/g
s/.*/&a&↑\n&/
s/a↑/\n/

Швидкий 2, 66 байт

let f={n in(0..<n*3).map{print("↑↓",appendNewline:$0%n==n-1)}}

Якби Swift був би просто ліііітле трохи менш багатослівним, це не було б навіть погано для гольфу (я дивлюся на вас, названий параметр appendNewline)

Рубі 39 (або 44) символів, 43 (або 48) байт

Згідно з https://mothereff.in/byte-counter, символи стрілки мають по 3 байти!

->(n){a=['↑↓'*n]*3;a[1]=a[1].reverse;a}

Анонімна функція, яка повертає масив. Якщо функція має друкувати масив, він повинен закінчуватисяputs a на 5 байтів.

Приклад використання

f=->(n){a=['↑↓'*n]*3;a[1]=a[1].reverse;a}

puts f.call(6)

Дає

↑↓↑↓↑↓↑↓
↓↑↓↑↓↑↓↑
↑↓↑↓↑↓↑↓

J, 41 35 32 байти (28 символів)

3$(,:|.)(2*".1!:1[1)$ucp'↑↓'

Я ніколи нічого не програмував у J, тому це зайняло у мене час, і це, безумовно, не найкращий спосіб зробити це.

Це чекає, коли ви введете число під час запуску, перш ніж вивести стрілки.

Javascript (ES6), 66 63 53 47 байт ( 62 55 49 41 символ)

f=n=>`⇅
⇵
⇅`.replace(/./g,'$&'.repeat(n))

Реквізит цифрової травми для пошуку знаків ⇅ і and і дозволяє мені відголити більше байтів.

J, 30 байт

|:((2*".1!:1<1),3)$ucp'↑↓'

C, 169 170 162 125 123 105 119 107 байт

Тож я хоч би і міг би сказати це, хоча це, очевидно, не переможець :)

Гольф:

n,i,j;main(){n=getchar();n=atoi(&n);for(;j++<3;){for(i=0;i++<n;)printf("%.3s ","⇅⇵"+(j%2)*3);puts("");}}

Безголівки:

#include <stdio.h>
#include <stdlib.h>

/* n -> Number of columns, i & j -> Loop counters */
n,i,j;

main()
{
    /* Get the number of iterations from stdin */
    n = getchar();
    n = atoi(&n); /* Thanks @AndreaBiondo */

    for (; j++ < 3;)
    {
        /* Print rows of arrows */
        for (i = 0; i++ < n;)
            printf("%.3s ","⇅⇵" + (j % 2) * 3);

        /* Print a newline */
        puts("");
    }
}

Приклад:

Input: 4
⇵ ⇵ ⇵ ⇵ 
⇅ ⇅ ⇅ ⇅ 
⇵ ⇵ ⇵ ⇵ 

Оновлення:

Дивіться, як воно працює тут

Октава, 37 байт

EDIT: виправлено з попередньої смугасто-антиферромагнітної версії. Дякую @ бета-розпад за те, що я зрозумів мою помилку.

f=@(n)repmat(["⇅";"⇵";"⇅"],1,n)

Визначає функцію f(n). Вибірка зразка:

octave:4> f(1)
ans =

⇅
⇵
⇅

octave:5> f(5)
ans =

⇅⇅⇅⇅⇅
⇵⇵⇵⇵⇵
⇅⇅⇅⇅⇅

CoffeeScript, 60 bytes (58 chars)

Comprehensions make it easy without recursion:

f=(n,x='')->x+='\n⇵⇅'[i%(n+1)&&1+i%2]for i in[1..n*3+2];x

Ruby, 33 bytes

As a function:

f=->n{[s="↑↓"*n,s.reverse,s]}

Example:

> puts f[3]
↑↓↑↓↑↓
↓↑↓↑↓↑
↑↓↑↓↑↓

Ruby, 37 bytes

Full program which takes input from stdin:

puts s="↑↓"*gets.to_i,s.reverse,s

><>, 55 Bytes

"⇅⇵⇅"{:&3*1-:0(?;\
|.!09v!?%&:&:{o:}/
oa{~}/|.!09

Try it online here, inputting the desired length as initial stack value.

Non ⇅⇵ solution, 59 Bytes:

"↓↑"{:&3*>1-:0(?;{:{\
 |.!09v!?%&:&:oo}}@:/
9oa{$}/|.!0

BBC BASIC, 70 bytes

INPUTx:n$=STRING$(x,"/|\\|/"):PRINTn$:PRINTSTRING$(x,"\|//|\"):PRINTn$

This can probably be golfed more

C, 97 bytes

Takes the input from the first command-line parameter, e.g. main 4. Supports up to 357913940 pairs. In C you can't use multibyte characters as chars but they work fine as strings.

i,n;main(c,v)char**v;{n=atoi(v[1]);for(i=6*n+3;i--;)printf("%s",i%(2*n+1)?i%2?"↓":"↑":"\n");}

It is smaller as a function, but the other C answers were complete programs so I did that too. It would be 69 bytes:

i;f(n){for(i=6*n+3;i--;)printf("%s",i%(2*n+1)?i%2?"↓":"↑":"\n");}

Python 2, 47 bytes

Port of my BBC BASIC answer, taking advantage of how Python can easily reverse strings.

n=r"/|\\|/"*input();print n+"\n"+n[::-1]+"\n"+n

C, 117 89 85 bytes

i;main(j,v)char**v;{j=2*atol(v[1])+1;for(;i++<3*j;)printf(i%j?i%2?"↑":"↓":"\n");}

Ungolfed:

i;
main(j,v)
char**v; // Credit to @AndreaBiondo for brilliant idea that I will use a lot in future golfed programs :)
{
    j = 2*atol(v[1])+1;
    for(;i++<3*j;)
        printf(i%j?i%2?"↑":"↓":"\n");
}

JavaScript (ES6), 66 bytes (62 chars)

That includes the Unicode character counted as three bytes each as well as the mandatory newline counted as one byte.

Uses recursion as inspired by this answer. I tried it non-recursively but generating a defined array took too many characters, although someone else might know how to do it better than me.

f=n=>(g=(a,i)=>i?g(`
↓↑`[i%(n*2+1)&&1+i%2]+a,i-1):a)('',n*6+2)

Demo

As with all ES6 answers, they are demonstrable in Firefox, Edge, and Safari 9 only at time of writing:

f = n => (g = (a, i) => i ? g(`
↓↑` [i % (n * 2 + 1) && 1 + i % 2] + a, i - 1) : a)('', n * 6 + 2)

console.log = x => document.getElementById('O').innerHTML += x + '\n';

console.log(f(1));
console.log(f(2));
console.log(f(4));
console.log(f(32));

<pre><output id=O></output></pre>

Java, 150 bytes

static void g(int n){n*=2;f(n,0);f(n,1);f(n,0);}static void f(int n,int d){String l="";for(n+=d;n-->d;)l+=(n%2==0)?"↓":"↑";System.out.println(l);}

Output of g(2):

↑↓↑↓
↓↑↓↑
↑↓↑↓

Python 2, 45 55 bytes

edit: modified arrows

Pretty straightforward approach. Doesn't work with unicode arrows, though.

def f(n):x=" /|\\ \\|/"*n;print x+"\n "+x[::-1]+"\n"+x

R, 60 62 bytes

Takes input from STDIN and outputs to STDOUT. Creates a 3 x (2 * input) array, adds a column of carriage returns and then outputs the transposed array.

cat(t(cbind(array(c('↑','↓'),c(3,2*scan())),'\n')),sep='')

Test run

cat(t(cbind(array(c('↑','↓'),c(3,2*scan())),'\n')),sep='')
1: 25
2: 
Read 1 item
↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓
↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑
↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓

Tcl 49 bytes

No winner but at least it's competitive:

foreach x {⇅ ⇵ ⇅} {puts [string repeat $x $argv]}

Swift 2.0, 79 bytes

Nothing clever...

let p=3;for x in 0...2{print((0..<p*2).reduce(""){$0+["↑","↓"][($1+x)%2]})}