反铁磁性是什么IBM研究人员使用从跳1个TB的磁盘至100兆兆字节盘以相同的量的原子。

在具有反铁磁性的材料中，通常与电子自旋相关的原子或分子的磁矩以规则的方向排列，相邻的自旋（在不同的子晶格上）指向相反的方向。

您的工作是编写一个程序，以绘制反铁磁原子的顺序，如上图所示。尽管您可能有更多对，但您必须至少能够有四对。

每对必须显示如下，尽管它们必须是实际的箭头：

 上下
下来
 上下

您的输出可以是ascii art或图形输出。

您只能创建一个函数或整个程序，但必须输入并绘制那么多对。仅带单词的示例：

输入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*

将字符串旋转"↑↓"*n0、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/

Swift 2，66位元组

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

如果Swift只是一点点的冗长，那么它对打高尔夫球甚至没有那么糟糕（我在看着你，命名为parameter appendNewline）

Ruby 39（或44）个字符，43（或48）个字节

根据https://mothereff.in/byte-counter，箭头字符各为3个字节！

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

返回数组的匿名函数。如果函数必须打印数组，则应该以puts a5个字节为结尾。

使用范例

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

支持Digital Trauma查找finding和⇵字符并允许我剃除更多字节的道具。

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字节

编辑：从早期的条纹反磁版本中更正。感谢@ beta-decay抓住我的错误。

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

定义一个函数f(n)。样本输出：

octave:4> f(1)
ans =

⇅
⇵
⇅

octave:5> f(5)
ans =

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

CoffeeScript，60个字节（58个字符）

理解使无需递归变得容易：

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

Ruby，33个字节

作为功​​能：

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

例：

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

Ruby，37个字节

完整程序，从stdin输入：

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

> <>，​​55字节

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

在这里在线尝试, inputting the desired length as initial stack value.

非⇅⇵解决方案，59字节：

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

BBC BASIC，70个字节

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

这可能会打更多

C，97字节

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