El antiferromagnetismo es lo que los investigadores de IBM utilizaron para saltar de un disco de 1 terabyte a un disco de 100 terabytes en la misma cantidad de átomos.

En los materiales que exhiben antiferromagnetismo, los momentos magnéticos de los átomos o moléculas, generalmente relacionados con los espines de los electrones, se alinean en un patrón regular con los espines vecinos (en diferentes subredes) que apuntan en direcciones opuestas.

Su trabajo es escribir un programa que dibuje el orden de los átomos antiferromagnéticos como la imagen que se muestra arriba. Debe poder tener al menos cuatro conjuntos de pares, aunque puede tener más.

Cada par debe mostrarse de la siguiente manera, aunque deben ser flechas reales :

 arriba abajo
abajo arriba
 arriba abajo

Su salida puede ser en arte ascii o salida gráfica.

Puede hacer solo una función o un programa completo, pero debe tomar una entrada y dibujar tantos pares. Ejemplos con solo palabras :

Entrada: 1

 arriba abajo
abajo arriba
 arriba abajo

Entrada: 2

 arriba abajo arriba abajo 
abajo arriba abajo arriba  
 arriba abajo arriba abajo

Flechas aceptables

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

Ponga sus respuestas en Idioma, formato X bytes , ya que es fácil de leer. ¡La menor cantidad de bytes gana!

APL, 18 12 bytes

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

Esto construye una matriz de 2n x 3, donde n es la entrada ( ⎕), llena con los caracteres ↑y ↓. ⍉Luego se imprime la transposición ( ) de esta matriz.

Puedes probarlo en línea .

Pyth, 15 bytes (11 caracteres)

V3.>*Q"↑↓"N

Pruébelo en línea: demostración

Explicació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 bytes

Aquí hay un ejemplo que muestra flechas gráficamente:

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

En un formato más legible:

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

La pantalla para 5 como entrada:

Tendrá que cambiar el tamaño de la ventana que aparece para ver las flechas. Traté de hacerlo para que ninguno de ellos apareciera "cortado" por el borde interior de la ventana, pero puede parecer así en ciertas plataformas.

CJam, 18 bytes (14 caracteres)

ri3*"↑↓"*3/zN*

Genere las columnas (que forman un patrón repetitivo) y luego transponga.

Pruébalo en línea .

Alternativa 18 bytes:

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

Gire la cadena "↑↓"*n0, 1 o 2 veces.

CJam (15 caracteres, 19 bytes)

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

Demostración en línea

Befunge, 71 bytes

Mi primera respuesta, así que por favor sé amable conmigo: o)

Problemas de alineación molestos resultaron en algunos bytes desperdiciados, si tiene alguna mejora para mí, ¡me encantaría escucharlos!

&::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*

Esto requiere un terminal de soporte que muestre la página de códigos 850 de esta manera:

La parte no puntiaguda del código resultó ser idéntica a la versión alternativa de @ Sp3000 .

CJam, 17 bytes

ri"⇅⇵⇅"f*N*

Cheaty versión de doble flecha, con créditos para @DigitalTrauma.

Pruébalo en línea.

Pyth, 16 bytes (12 caracteres)

J"↑↓"V3*~_JQ

Ejemplo:

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

Python 2, 131122 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()

Bueno ... supongo que vencí a C Java.

Elegí la altura 32de las flechas, que es bastante grande, así que después de un tiempo la tortuga comienza a dibujar fuera de la pantalla. Si desea que todo se ajuste a entradas grandes, puede hacer que las flechas sean más pequeñas reemplazando el 32s, o usar screensize()(no estoy seguro de si hay una meta publicación en la salida fuera de pantalla ...)

GNU sed, 25 bytes

Encontré los símbolos de flecha ⇅y ⇵unicode, que permiten más acortamiento y este comentario los ha permitido :

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

La entrada está en unario , por lo que, por ejemplo, 4 es 1111:

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

Respuesta previa en caso ⇅y⇵ no están permitidos:

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

Si Swift fuera solo un poco menos detallado, ni siquiera sería tan malo para el golf (te estoy mirando, parámetro con nombre appendNewline )

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

De acuerdo con https://mothereff.in/byte-counter, los caracteres de flecha son de 3 bytes cada uno.

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

Una función anónima que devuelve una matriz. Si la función tiene que imprimir la matriz, debería terminar con puts a5 bytes más.

Ejemplo de uso

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

puts f.call(6)

Da

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

J, 41 35 32 bytes (28 caracteres)

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

Nunca he programado nada en J, así que esto me llevó un tiempo, y definitivamente no es la mejor manera de hacerlo.

Esto espera a que ingrese un número cuando se ejecuta antes de mostrar las flechas.

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

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

Props to Digital Trauma para encontrar los caracteres ⇅ y ⇵ y permitirme eliminar más bytes.

J, 30 bytes

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

C, 169 170 162 125 123 105 119 107 bytes

Entonces, creo que podría intentarlo, aunque obviamente este no es el ganador :)

Golfizado:

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

Sin golf:

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

Ejemplo:

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

Actualizar:

Véalo correr aquí

Octava, 37 bytes

EDITAR: corregido de la versión anterior antiperomagnética de rayas. Gracias @ beta-decay por descubrir mi error.

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

Define una función f(n). Salida de muestra:

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