O antiferromagnetismo é o que os pesquisadores da IBM costumavam pular de um disco de 1 terabyte para um disco de 100 terabytes na mesma quantidade de átomos.

Em materiais que exibem antiferromagnetismo, os momentos magnéticos de átomos ou moléculas, geralmente relacionados aos spins dos elétrons, alinham-se em um padrão regular com os spins vizinhos (em diferentes sub-redes) apontando em direções opostas.

Seu trabalho é escrever um programa que desenhe a ordem dos átomos antiferromagnéticos, como na figura acima. Você deve ter pelo menos quatro conjuntos de pares, embora possa ter mais.

Cada par deve ser mostrado da seguinte maneira, embora devam ser setas reais :

 cima baixo
baixo cima
 cima baixo

Sua saída pode estar em arte gráfica ou saída gráfica.

Você pode criar apenas uma função ou um programa inteiro, mas deve receber uma entrada e desenhar muitos pares. Exemplos com apenas palavras :

Entrada: 1

 cima baixo
baixo cima
 cima baixo

Entrada: 2

 para cima para baixo 
desce desce  
 para cima para baixo

Setas aceitáveis:

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

Coloque suas respostas no idioma, no formato X bytes , pois é fácil de ler. A menor quantidade de bytes ganha!

APL, 18 12 bytes

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

Isso constrói uma matriz 2n x 3, em que n é a entrada ( ⎕), preenchida com os caracteres ↑e ↓. A transposição ( ⍉) dessa matriz é então impressa.

Você pode experimentá-lo online .

Pitão, 15 bytes (11 caracteres)

V3.>*Q"↑↓"N

Experimente online: Demonstração

Explicação:

              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 bytes

Aqui está um exemplo que exibe setas graficamente:

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

Em um formato mais legível:

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

O visor para 5 como entrada:

Você precisará redimensionar a janela que aparece para ver as setas. Tentei fazer com que nenhum deles aparecesse "cortado" pela borda interna da janela, mas pode parecer assim em certas plataformas.

CJam, 18 bytes (14 caracteres)

ri3*"↑↓"*3/zN*

Gere as colunas (que formam um padrão repetitivo) e transponha.

Experimente online .

Alternativa 18 bytes:

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

Gire a corda "↑↓"*n0, 1 ou 2 vezes.

CJam (15 caracteres, 19 bytes)

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

Demonstração online

Befunge, 71 bytes

Minha primeira resposta, por favor, seja gentil comigo: o)

Problemas de alinhamento irritantes resultaram em alguns bytes desperdiçados, se você tiver alguma melhoria para mim, eu adoraria ouvi-los!

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

Entrada: 4

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

CJam, 14 bytes

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

Isso requer um terminal de suporte que renderize a página de código 850 como esta:

A parte não pontiaguda do código acabou sendo idêntica à versão alternativa do @ Sp3000 .

CJam, 17 bytes

ri"⇅⇵⇅"f*N*

Versão Cheaty de seta dupla, com créditos para @DigitalTrauma.

Experimente online.

Pitão, 16 bytes (12 caracteres)

J"↑↓"V3*~_JQ

Exemplo:

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

Python 2, 131 122 bytes

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

Bem ... eu bati C Java, eu acho?

Eu escolhi a altura 32das flechas, que são bem grandes, então, depois de um tempo, a tartaruga começa a desenhar fora da tela. Se você quiser que tudo se encaixe em entradas grandes, você pode reduzir as setas substituindo os 32ou usar screensize()(não tenho certeza se há uma meta postagem na saída fora da tela ...)

GNU sed, 25 bytes

Encontrei os símbolos de seta unicode ⇅e ⇵, que permitem mais encurtamento e foram permitidos por este comentário :

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

A entrada é unária , por exemplo, 4 é 1111:

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

Resposta anterior no caso ⇅e⇵ não é permitida:

GNU sed, 39 bytes

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

Swift 2, 66 bytes

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

Se o Swift fosse um pouco menos detalhado, não seria tão ruim para o golfe (estou olhando para você, chamado parameter appendNewline)

Ruby 39 (ou 44) caracteres, 43 (ou 48) bytes

De acordo com https://mothereff.in/byte-counter os caracteres das setas têm 3 bytes cada!

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

Uma função anônima que retorna uma matriz. Se a função precisar imprimir a matriz, ela deverá terminar com puts amais 5 bytes.

Exemplo de uso

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

puts f.call(6)

Dá

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

J, 41 35 32 bytes (28 caracteres)

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

Eu nunca programei nada em J, então isso me levou um tempo, e definitivamente não é a melhor maneira de fazê-lo.

Isso espera que você insira um número ao executar antes de exibir as setas.

Javascript (ES6), 66 63 53 47 bytes ( 62 55 49 41 caracteres)

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

Adereços para o Digital Trauma para encontrar os caracteres ⇅ e ⇵ e permitir que eu corte mais bytes.

J, 30 bytes

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

C, 169 170 162 125 123 105 119 107 bytes

Então, eu acho que é melhor tentar, mesmo que esse obviamente não seja o vencedor :)

Golfe:

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

Ungolfed:

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

Exemplo:

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

Atualizar:

Veja correr aqui

Oitava, 37 bytes

EDIT: corrigido da versão antiferromagnética da faixa anterior. Obrigado @ beta-decay por pegar meu erro.

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

Define uma função f(n). Saída de amostra:

octave:4> f(1)
ans =

⇅
⇵
⇅

octave:5> f(5)
ans =

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

CoffeeScript, 60 bytes (58 caracteres)

As compreensões facilitam sem recursão:

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

Ruby, 33 bytes

Como uma função:

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

Exemplo:

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

Ruby, 37 bytes

Programa completo que recebe a entrada de stdin:

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

> <>, 55 bytes

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

Experimente online aqui , inserindo o comprimento desejado como valor inicial da pilha.

Solução não,, 59 bytes:

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

BBC BASIC, 70 bytes

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

Provavelmente isso pode ser jogado mais

C, 97 bytes

Toma a entrada do primeiro parâmetro da linha de comando, por exemplo main 4. Suporta até 357913940pares. Em C, você não pode usar caracteres multibyte como chars, mas eles funcionam bem como 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");}

É menor como uma função, mas as outras respostas C eram programas completos, então eu fiz isso também. Seriam 69 bytes:

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

Python 2, 47 bytes

Porta da minha resposta BBC BASIC , aproveitando como o Python pode reverter facilmente as 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 caracteres)

Isso inclui o caractere Unicode contado como três bytes cada, bem como a nova linha obrigatória contada como um byte.

Usa recursão como inspirado por esta resposta . Eu tentei de forma não recursiva, mas a geração de uma matriz definida levou muitos caracteres, embora alguém saiba como fazê-lo melhor do que eu.

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

Demo

Como em todas as respostas do ES6, elas são demonstráveis ​​no Firefox, Edge e Safari 9 somente no momento da escrita:

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

Saída de g(2):

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

Python 2, 45 55 bytes

editar: setas modificadas

Abordagem bastante direta. Porém, não funciona com setas unicode.

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

R, 60 62 bytes

Leva a entrada de STDIN e sai para STDOUT. Cria uma matriz de 3 x (2 * entradas) , adiciona uma coluna de retornos de carro e, em seguida, gera a matriz transposta.

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

Execução de teste

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

Tcl 49 bytes

Nenhum vencedor, mas pelo menos é competitivo:

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

Swift 2.0, 79 bytes

Nada inteligente ...

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