Antiferromagnetisme adalah apa yang para peneliti IBM gunakan untuk melompat dari disk 1 terabyte ke disk 100 terabyte dalam jumlah atom yang sama.

Dalam bahan yang menunjukkan antiferromagnetisme, momen magnetik atom atau molekul, biasanya terkait dengan spin elektron, sejajar dalam pola reguler dengan putaran yang berdekatan (pada sublattice yang berbeda) menunjuk ke arah yang berlawanan.

Tugas Anda adalah menulis program yang menggambarkan urutan atom antiferromagnetik seperti gambar di atas. Anda harus dapat memiliki setidaknya empat pasang pasangan, meskipun Anda mungkin memiliki lebih banyak.

Setiap pasangan harus ditunjukkan sebagai berikut, meskipun mereka harus panah yang sebenarnya :

 naik ke bawah
turun hingga
 naik ke bawah

Output Anda dapat berupa output grafis atau ascii.

Anda hanya dapat membuat fungsi atau keseluruhan program, tetapi harus mengambil input dan menggambar banyak pasangan. Contoh hanya dengan kata-kata :

Input: 1

 naik ke bawah
turun hingga
 naik ke bawah

Input: 2

 naik turun ke bawah 
turun ke bawah ke atas  
 naik turun ke bawah

Panah yang bisa diterima:

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

Masukkan jawaban Anda dalam Bahasa, format X byte , karena mudah dibaca. Jumlah byte terkecil menang!

APL, 18 12 byte

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

Ini membangun 2n x 3 matriks, di mana n adalah input ( ⎕), diisi dengan karakter ↑dan ↓. Transpos ( ⍉) dari matriks ini kemudian dicetak.

Anda dapat mencobanya secara online .

Pyth, 15 byte (11 karakter)

V3.>*Q"↑↓"N

Cobalah online: Demonstrasi

Penjelasan:

              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 byte

Berikut ini contoh yang menampilkan panah secara grafis:

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();}

Dalam format yang lebih mudah dibaca:

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();
}

Layar untuk 5 sebagai input:

Anda harus mengubah ukuran jendela yang muncul untuk melihat panah. Saya mencoba membuatnya sehingga tidak satupun dari mereka akan muncul "dipotong" oleh batas dalam jendela, tetapi mungkin terlihat seperti itu pada platform tertentu.

CJam, 18 byte (14 karakter)

ri3*"↑↓"*3/zN*

Hasilkan kolom (yang membentuk pola berulang) kemudian transpos.

Cobalah online .

Alternatif 18 byte:

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

Putar string "↑↓"*nsebanyak 0, 1 atau 2 kali.

CJam (15 karakter, 19 byte)

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

Demo online

Befunge, 71 byte

Jawaban pertama saya, jadi harap lembut dengan saya: o)

Masalah penyelarasan yang mengganggu menghasilkan beberapa byte yang terbuang, jika Anda memiliki perbaikan untuk saya, saya ingin mendengarnya!

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

Input: 4

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

CJam, 14 byte

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

Ini membutuhkan terminal pendukung yang membuat kode halaman 850 seperti ini:

Bagian non-runcing dari kode tersebut ternyata identik dengan versi alternatif @ Sp3000 .

CJam, 17 byte

ri"⇅⇵⇅"f*N*

Versi panah ganda Cheaty, dengan kredit ke @DigitalTrauma.

Cobalah online.

Pyth, 16 byte (12 karakter)

J"↑↓"V3*~_JQ

Contoh:

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

Python 2, 131 122 byte

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()

Yah ... saya mengalahkan C Java saya kira?

Saya telah memilih ketinggian 32untuk panah, yang cukup besar, jadi setelah beberapa saat kura-kura mulai menggambar di layar. Jika Anda ingin semuanya sesuai untuk input besar, Anda dapat membuat panah lebih kecil dengan mengganti 32s, atau menggunakan screensize()(Saya tidak yakin apakah ada meta pos pada output offscreen ...)

GNU sed, 25 byte

Saya menemukan ⇅dan ⇵simbol panah unicode, yang memungkinkan lebih banyak shortening dan mereka telah diizinkan oleh komentar ini :

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

Input dalam bentuk unary , jadi misal 4 adalah 1111:

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

Jawaban sebelumnya dalam kasus ⇅dan ⇵tidak diizinkan:

GNU sed, 39 byte

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

Swift 2, 66 byte

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

Jika Swift akan hanya sedikit lebih sedikit verbose, itu bahkan tidak akan seburuk itu untuk bermain golf (saya sedang melihat Anda, bernama parameter appendNewline)

Ruby 39 (atau 44) karakter, 43 (atau 48) byte

Menurut https://mothereff.in/byte-counter karakter panah masing-masing 3 byte!

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

Fungsi anonim yang mengembalikan array. Jika fungsi tersebut harus mencetak array, itu harus diakhiri dengan puts a5 byte lebih.

Contoh penggunaan

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

puts f.call(6)

Memberi

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

J, 41 35 32 byte (28 karakter)

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

Saya belum pernah memprogram apa pun dalam J jadi ini butuh beberapa saat, dan itu jelas bukan cara terbaik untuk melakukannya.

Ini menunggu Anda untuk memasukkan angka ketika dijalankan sebelum mengeluarkan panah.

Javascript (ES6), 66 63 53 47 byte ( 62 55 49 41 karakter)

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

Alat peraga untuk Digital Trauma untuk menemukan karakter ⇅ dan ⇵ dan memungkinkan saya untuk mencukur lebih banyak byte.

J, 30 byte

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

C, 169 170 162 125 123 105 119 107 byte

Jadi, saya pikir saya bisa mencobanya, meskipun ini jelas bukan pemenangnya :)

Golf:

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

Tidak Terkumpul:

#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("");
    }
}

Contoh:

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

Memperbarui:

Lihat lari di sini

Oktaf, 37 byte

EDIT: dikoreksi dari versi strip-antiferromagnetik sebelumnya. Terima kasih @ beta-decay karena menangkap kesalahan saya.

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

Menentukan fungsi f(n). Output sampel:

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

Cobalah online di sini , dengan memasukkan panjang yang diinginkan sebagai nilai tumpukan awal.

Non ⇅⇵ solusi, 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]})}