L'antiferromagnetismo è ciò che i ricercatori IBM usavano per passare da un disco da 1 terabyte a un disco da 100 terabyte nella stessa quantità di atomi.

Nei materiali che presentano antiferromagnetismo, i momenti magnetici di atomi o molecole, generalmente correlati agli spin degli elettroni, si allineano in modo regolare con spin vicini (su diverse sottigliezze) che puntano in direzioni opposte.

Il tuo compito è quello di scrivere un programma che disegna l'ordinamento di atomi antiferromagnetici come l'immagine mostrata sopra. Devi essere in grado di avere almeno quattro serie di coppie, anche se potresti averne di più.

Ogni coppia deve essere mostrata come segue, sebbene debbano essere frecce effettive :

 sottosopra
giù su
 sottosopra

L'output può essere in arte ascii o output grafico.

Puoi fare solo una funzione o un intero programma, ma deve prendere un input e disegnare tante coppie. Esempi con solo parole :

Ingresso: 1

 sottosopra
giù su
 sottosopra

Ingresso: 2

 su giù su giù 
giù su giù su  
 su giù su giù

Frecce accettabili:

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

Inserisci le risposte in lingua, formato X byte , poiché è facile da leggere. Vince il minor numero di byte!

APL, 18 12 byte

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

Questo costruisce una matrice 2n x 3, dove n è l'input ( ⎕), riempito con i caratteri ↑e ↓. Il transpose ( ⍉) di questa matrice viene quindi stampato.

Puoi provarlo online .

Pyth, 15 byte (11 caratteri)

V3.>*Q"↑↓"N

Provalo online: dimostrazione

Spiegazione:

              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

Ecco un esempio che visualizza graficamente le frecce:

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

In un formato più leggibile:

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

Il display per 5 come input:

Dovrai ridimensionare la finestra che appare per vedere le frecce. Ho provato a farlo in modo che nessuno di loro sembrasse "tagliato" dal bordo interno della finestra, ma potrebbe apparire così su alcune piattaforme.

CJam, 18 byte (14 caratteri)

ri3*"↑↓"*3/zN*

Generare le colonne (che formano uno schema ripetuto) quindi trasporre.

Provalo online .

18 byte alternativi:

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

Ruota la stringa "↑↓"*ndi 0, 1 o 2 volte.

CJam (15 caratteri, 19 byte)

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

Demo online

Befunge, 71 byte

La mia prima risposta, quindi per favore sii gentile con me: o)

I fastidiosi problemi di allineamento hanno comportato una perdita di byte, se hai qualche miglioramento per me mi piacerebbe ascoltarli!

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

Ingresso: 4

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

CJam, 14 byte

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

Ciò richiede un terminale di supporto che esegua il rendering della code page 850 in questo modo:

La parte non appuntita del codice si è rivelata identica alla versione alternativa di @ Sp3000 .

CJam, 17 byte

ri"⇅⇵⇅"f*N*

Cheaty versione a doppia freccia, con crediti a @DigitalTrauma.

Provalo online.

Pyth, 16 byte (12 caratteri)

J"↑↓"V3*~_JQ

Esempio:

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

Beh ... ho battuto C Java immagino?

Ho scelto l'altezza 32per le frecce, che è piuttosto grande, quindi dopo un po 'la tartaruga inizia a disegnare fuori dallo schermo. Se vuoi che tutto si adatti a input di grandi dimensioni, puoi rimpicciolire le frecce sostituendo la 32s, oppure usare screensize()(Non sono sicuro che ci sia un meta post sull'output fuori schermo ...)

GNU sed, 25 byte

Ho trovato i simboli freccia ⇅e ⇵unicode, che consentono un accorciamento maggiore e sono stati ammessi da questo commento :

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

L'input è in unario , quindi ad esempio 4 è 1111:

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

Risposta precedente nel caso ⇅e ⇵non sono consentiti:

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

Se Swift fosse solo un po 'meno prolisso, non sarebbe nemmeno così male per il golf (ti sto guardando, chiamato parametro appendNewline)

Ruby 39 (o 44) caratteri, 43 (o 48) byte

Secondo https://mothereff.in/byte-counter i caratteri freccia sono 3 byte ciascuno!

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

Una funzione anonima che restituisce un array. Se la funzione deve stampare l'array, dovrebbe terminare conputs a altri 5 byte.

Esempio di utilizzo

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

puts f.call(6)

dà

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

J, 41 35 32 byte (28 caratteri)

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

Non ho mai programmato nulla in J, quindi mi ci è voluto un po 'di tempo, e sicuramente non è il modo migliore per farlo.

Questo ti aspetta per inserire un numero quando eseguito prima di emettere le frecce.

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

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

Puntelli per Digital Trauma per trovare il ⇅ e personaggi ⇵ e che mi permette di radersi più byte.

J, 30 byte

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

C, 169 170 162 125 123 105 119 107 byte

Quindi, anche se potrei anche provarlo, anche se questo ovviamente non è il vincitore :)

golfed:

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

Esempio:

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

Aggiornare:

Guardalo correre qui

Ottava, 37 byte

EDIT: corretto dalla precedente versione antiferromagnetica di banda. Grazie @ beta-decadimento per aver colto il mio errore.

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

Definisce una funzione f(n). Uscita campione:

octave:4> f(1)
ans =

⇅
⇵
⇅

octave:5> f(5)
ans =

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

CoffeeScript, 60 byte (58 caratteri)

Le comprensioni lo rendono facile senza ricorsione:

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

Rubino, 33 byte

Come una funzione:

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

Esempio:

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

Rubino, 37 byte

Programma completo che accetta input da 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]})}