Antiferromagnetism là thứ mà các nhà nghiên cứu của IBM đã sử dụng để nhảy từ đĩa 1 terabyte sang đĩa 100 terabyte trong cùng một lượng nguyên tử.

Trong các vật liệu thể hiện tính chống phản xạ, các khoảnh khắc từ tính của các nguyên tử hoặc phân tử, thường liên quan đến spin của các electron, sắp xếp theo một mô hình thông thường với các spin lân cận (trên các mạng con khác nhau) chỉ theo hai hướng ngược nhau.

Công việc của bạn là viết một chương trình rút ra thứ tự các nguyên tử chống từ như hình ảnh trên. Bạn phải có thể có ít nhất bốn bộ cặp, mặc dù bạn có thể có nhiều hơn.

Mỗi cặp phải được hiển thị như sau, mặc dù chúng phải là mũi tên thực tế :

 lên xuống
xuống lên
 lên xuống

Đầu ra của bạn có thể là nghệ thuật ascii hoặc đầu ra đồ họa.

Bạn chỉ có thể tạo một hàm hoặc toàn bộ chương trình, nhưng nó phải lấy một đầu vào và vẽ nhiều cặp đó. Ví dụ chỉ có từ :

Đầu vào: 1

 lên xuống
xuống lên
 lên xuống

Đầu vào: 2

 lên xuống 
xuống lên xuống  
 lên xuống

Mũi tên chấp nhận được:

• ↑ và ↓
• ⇅ và ⇵
• /|\ và \|/

Vui lòng đặt câu trả lời của bạn ở định dạng Ngôn ngữ, X byte , vì nó dễ đọc. Số lượng byte ít nhất sẽ thắng!

APL, 18 12 byte

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

Điều này xây dựng một ma trận 2n x 3, trong đó n là đầu vào ( ⎕), chứa đầy các ký tự ↑và ↓. Transpose ( ⍉) của ma trận này sau đó được in.

Bạn có thể thử nó trực tuyến .

Pyth, 15 byte (11 ký tự)

V3.>*Q"↑↓"N

Dùng thử trực tuyến: Trình diễn

Giải trình:

              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

Dưới đây là một ví dụ hiển thị mũi tên bằng đồ họa:

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

Trong một định dạng dễ đọc hơn:

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

Màn hình hiển thị cho 5 là đầu vào:

Bạn sẽ phải thay đổi kích thước cửa sổ xuất hiện để nhìn thấy mũi tên. Tôi đã cố gắng làm cho nó để không ai trong số họ xuất hiện "bị chặt" bởi đường viền bên trong của cửa sổ, nhưng nó có thể xuất hiện theo cách đó trên các nền tảng nhất định.

CJam, 18 byte (14 ký tự)

ri3*"↑↓"*3/zN*

Tạo các cột (tạo thành một mẫu lặp lại) sau đó hoán vị.

Hãy thử trực tuyến .

18 byte thay thế:

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

Xoay chuỗi "↑↓"*nbằng 0, 1 hoặc 2 lần.

CJam (15 ký tự, 19 byte)

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

Bản demo trực tuyến

Befunge, 71 byte

Câu trả lời đầu tiên của tôi, vì vậy hãy nhẹ nhàng với tôi: o)

Các vấn đề liên kết gây phiền nhiễu dẫn đến một vài byte bị lãng phí, nếu bạn có bất kỳ cải tiến nào đối với tôi, tôi rất muốn nghe chúng!

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

Đầu vào: 4

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

CJam, 14 byte

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

Điều này đòi hỏi một thiết bị đầu cuối hỗ trợ hiển thị mã trang 850 như thế này:

Phần không nhọn của mã hóa ra giống hệt với phiên bản thay thế của @ Sp3000 .

CJam, 17 byte

ri"⇅⇵⇅"f*N*

Phiên bản mũi tên kép gian lận, với các khoản tín dụng cho @DigitalTrauma.

Hãy thử trực tuyến.

Pyth, 16 byte (12 ký tự)

J"↑↓"V3*~_JQ

Thí dụ:

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

Chà ... tôi đoán C Java tôi đoán vậy?

Tôi đã chọn chiều cao 32cho các mũi tên, khá lớn, vì vậy sau một thời gian, con rùa bắt đầu vẽ ngoài màn hình. Nếu bạn muốn mọi thứ phù hợp với đầu vào lớn, bạn có thể làm cho mũi tên nhỏ hơn bằng cách thay thế 32s hoặc sử dụng screensize()(Tôi không chắc có bài đăng meta trên đầu ra ngoài màn hình không ...)

GNU sed, 25 byte

Tôi đã tìm thấy các ký hiệu mũi tên ⇅và ⇵unicode, cho phép rút ngắn nhiều hơn và chúng đã được cho phép bởi nhận xét này :

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

Đầu vào là unary , vì vậy, ví dụ 4 là 1111:

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

Câu trả lời trước trong trường hợp ⇅và⇵ không được phép:

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

Nếu Swift chỉ là một liiiitle ít dài dòng hơn, thì nó thậm chí sẽ không tệ cho việc chơi gôn (Tôi đang nhìn bạn, tham số được đặt tên appendNewline)

Ruby 39 (hoặc 44) ký tự, 43 (hoặc 48) byte

Dựa theo https://otherseff.in/byte-count các ký tự mũi tên là 3 byte mỗi ký tự!

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

Một hàm ẩn danh trả về một mảng. Nếu hàm phải in mảng, nó sẽ kết thúc với puts a5 byte nữa.

Ví dụ sử dụng

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

puts f.call(6)

Tặng

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

J, 41 35 32 byte (28 ký tự)

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

Tôi chưa bao giờ lập trình bất cứ điều gì trong J vì vậy điều này làm tôi mất một thời gian, và đó chắc chắn không phải là cách tốt nhất để làm điều đó.

Điều này chờ bạn nhập số khi chạy trước khi xuất mũi tên.

Javascript (ES6), 66 63 53 47 byte ( 62 55 49 41 ký tự)

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

Đạo cụ cho Chấn thương kỹ thuật số để tìm các ký tự ⇅ và and và cho phép tôi cạo thêm byte.

J, 30 byte

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

C, 169 170 162 125 123 105 119 107 byte

Vì vậy, tôi mặc dù tôi cũng có thể cho nó đi, mặc dù đây rõ ràng không phải là người chiến thắng :)

Chơi gôn

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

Ung dung:

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

Thí dụ:

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

Cập nhật:

Xem nó chạy ở đây

Octave, 37 byte

EDIT: được sửa từ phiên bản chống sọc từ trước đó. Cảm ơn @ beta-decay vì đã bắt lỗi của tôi.

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

Xác định một hàm f(n). Đầu ra mẫu:

octave:4> f(1)
ans =

⇅
⇵
⇅

octave:5> f(5)
ans =

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

CoffeeScript, 60 byte (58 ký tự)

Hiểu được làm cho nó dễ dàng mà không cần đệ quy:

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

Ruby, 33 byte

Là một chức năng:

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

Thí dụ:

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

Ruby, 37 byte

Chương trình đầy đủ lấy đầu vào từ 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]})}