Antiferromagnetismus ist das, was IBM-Forscher benutzten, um von einer 1-Terabyte-Festplatte auf eine 100-Terabyte-Festplatte mit der gleichen Anzahl von Atomen zu springen .

In Materialien, die Antiferromagnetismus aufweisen, richten sich die magnetischen Momente von Atomen oder Molekülen, die normalerweise mit den Spins von Elektronen zusammenhängen, in einem regelmäßigen Muster aus, wobei benachbarte Spins (auf verschiedenen Untergittern) in entgegengesetzte Richtungen weisen.

Ihre Aufgabe ist es, ein Programm zu schreiben, das die Reihenfolge der antiferromagnetischen Atome wie im obigen Bild darstellt. Sie müssen in der Lage sein, mindestens vier Sätze von Paaren zu haben, obwohl Sie möglicherweise mehr haben.

Jedes Paar muss wie folgt dargestellt werden, obwohl es sich um tatsächliche Pfeile handeln muss :

 oben unten
runter rauf
 oben unten

Ihre Ausgabe kann in ASCII-Grafik oder grafisch erfolgen.

Sie können nur eine Funktion oder ein ganzes Programm erstellen, aber es muss eine Eingabe nehmen und so viele Paare zeichnen. Beispiele mit nur Worten :

Eingabe: 1

 oben unten
runter rauf
 oben unten

Eingabe: 2

 hoch runter hoch runter 
runter rauf runter rauf  
 hoch runter hoch runter

Akzeptable Pfeile:

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

Bitte geben Sie Ihre Antworten im Format Sprache (X Byte) ein , da sie leicht zu lesen sind. Die geringste Anzahl von Bytes gewinnt!

APL, 18 12 Bytes

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

Dadurch wird eine 2n x 3-Matrix erstellt, wobei n die Eingabe ( ⎕) ist, die mit den Zeichen ↑und gefüllt ist ↓. Die transponierte ( ⍉) dieser Matrix wird dann gedruckt.

Sie können es online ausprobieren .

Pyth, 15 Bytes (11 Zeichen)

V3.>*Q"↑↓"N

Probieren Sie es online aus: Demonstration

Erläuterung:

              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

Hier ist ein Beispiel, in dem Pfeile grafisch dargestellt werden:

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 einem besser lesbaren Format:

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

Die Anzeige für 5 als Eingabe:

Sie müssen die Größe des angezeigten Fensters ändern, um die Pfeile sehen zu können. Ich habe versucht, es so zu gestalten, dass keines von ihnen am inneren Rand des Fensters "abgehackt" erscheint, aber auf bestimmten Plattformen kann es so aussehen.

CJam, 18 Bytes (14 Zeichen)

ri3*"↑↓"*3/zN*

Generieren Sie die Spalten (die ein sich wiederholendes Muster bilden) und transponieren Sie sie.

Probieren Sie es online aus .

Alternative 18 Bytes:

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

Drehen Sie die Zeichenfolge "↑↓"*num 0, 1 oder 2 Mal.

CJam (15 Zeichen, 19 Bytes)

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

Online-Demo

Befunge, 71 Bytes

Meine erste Antwort, also sei bitte sanft mit mir: o)

Ärgerliche Ausrichtungsprobleme führten zu ein paar verschwendeten Bytes. Wenn Sie Verbesserungen für mich haben, würde ich sie gerne hören!

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

Eingabe: 4

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

CJam, 14 Bytes

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

Dies erfordert ein unterstützendes Terminal, das die Codepage 850 wie folgt darstellt:

Der nicht spitze Teil des Codes entpuppte sich als identisch mit der alternativen Version von @ Sp3000 .

CJam, 17 Bytes

ri"⇅⇵⇅"f*N*

Cheaty Doppelpfeil-Version, mit Credits zu @DigitalTrauma.

Probieren Sie es online aus.

Pyth, 16 Bytes (12 Zeichen)

J"↑↓"V3*~_JQ

Beispiel:

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

Nun ... ich habe C Java geschlagen, denke ich?

Ich habe die Höhe 32für die Pfeile gewählt, die ziemlich groß ist. Nach einer Weile beginnt die Schildkröte, außerhalb des Bildschirms zu zeichnen. Wenn Sie möchten, dass alles für große Eingaben passt, können Sie entweder die Pfeile verkleinern, indem Sie das 32s ersetzen , oder verwenden screensize()(ich bin nicht sicher, ob es einen Meta-Post auf der Offscreen-Ausgabe gibt ...).

GNU sed, 25 Bytes

Ich habe die ⇅und ⇵Unicode-Pfeilsymbole gefunden, die mehr Kürzung ermöglichen und die durch diesen Kommentar zugelassen wurden :

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

Die Eingabe ist unär , also ist zB 4 1111:

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

Vorherige Antwort für den Fall ⇅und ⇵sind nicht erlaubt:

GNU sed, 39 Bytes

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

Schnelle 2, 66 Bytes

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

Wenn Swift nur ein bisschen weniger wortreich wäre, wäre es nicht mal so schlimm zum Golfen (ich sehe dich an, benannter Parameter appendNewline)

Ruby 39 (oder 44) Zeichen, 43 (oder 48) Bytes

Laut https://mothereff.in/byte-counter sind die Pfeilzeichen jeweils 3 Bytes!

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

Eine anonyme Funktion, die ein Array zurückgibt. Wenn die Funktion das Array drucken muss, sollte es mit puts a5 weiteren Bytes enden .

Beispielgebrauch

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

puts f.call(6)

Gibt

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

J, 41 35 32 Bytes (28 Zeichen)

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

Ich habe noch nie etwas in J programmiert, daher habe ich eine Weile gebraucht, und es ist definitiv nicht der beste Weg, dies zu tun.

Dies wartet darauf, dass Sie beim Ausführen eine Zahl eingeben, bevor Sie die Pfeile ausgeben.

Javascript (ES6), 66 63 53 47 Bytes ( 62 55 49 41 Zeichen)

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

Props to Digital Trauma, um die Zeichen ⇅ und ⇵ zu finden und mehr Bytes zu entfernen.

J, 30 Bytes

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

C 169 170 162 125 123 105 119 107 Bytes

Also, ich denke, ich könnte es genauso gut versuchen, auch wenn dies offensichtlich nicht der Gewinner ist :)

Golf gespielt:

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

Beispiel:

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

Aktualisieren:

Sehen Sie es hier laufen

Oktave, 37 Bytes

BEARBEITEN: korrigiert von der früheren streifenantiferromagnetischen Version. Danke @ beta-decay, dass du meinen Fehler aufgefangen hast.

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

Definiert eine Funktion f(n). Beispielausgabe:

octave:4> f(1)
ans =

⇅
⇵
⇅

octave:5> f(5)
ans =

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

CoffeeScript, 60 Bytes (58 Zeichen)

Verständnis macht es einfach, ohne Rekursion:

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

Ruby, 33 Bytes

Als eine Funktion:

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

Beispiel:

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

Ruby, 37 Bytes

Volles Programm, das Eingaben von stdin übernimmt:

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

> <>, 55 Bytes

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

Probieren Sie es hier online aus und geben Sie die gewünschte Länge als Anfangsstapelwert ein.

Nicht ⇅⇵-Lösung, 59 Bytes:

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

BBC BASIC, 70 Bytes

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

Damit kann wohl mehr golfen werden

C 97 Bytes

Übernimmt die Eingabe vom ersten Befehlszeilenparameter, z main 4. Unterstützt bis zu 357913940Paare. In C können Sie keine Multibyte-Zeichen als chars verwenden, aber sie funktionieren gut als Zeichenfolgen.

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

Es ist kleiner als eine Funktion, aber die anderen C-Antworten waren vollständige Programme, also habe ich das auch getan. Es wären 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 meiner BBC-BASIC-Antwort , die ausnutzt, wie Python Strings leicht umkehren kann.

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 Byte (62 Zeichen)

Dazu gehören das jeweils drei Byte lange Unicode-Zeichen sowie die ein Byte lange obligatorische Newline.

Verwendet die von dieser Antwort inspirierte Rekursion . Ich habe es nicht rekursiv versucht, aber das Generieren eines definierten Arrays hat zu viele Zeichen gedauert, obwohl vielleicht jemand anderes es besser kann als ich.

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

Demo

Wie bei allen ES6-Antworten sind sie in Firefox, Edge und Safari 9 nur zum Zeitpunkt des Schreibens nachweisbar:

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

Ausgabe von g(2):

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

Python 2, 45 55 Bytes

Bearbeiten: Geänderte Pfeile

Ziemlich unkomplizierter Ansatz. Funktioniert allerdings nicht mit Unicode-Pfeilen.

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

R 60 62 Bytes

Übernimmt die Eingabe von STDIN und gibt sie an STDOUT aus. Erstellt ein 3 x (2 * Eingabe) -Array, fügt eine Spalte mit Zeilenumbrüchen hinzu und gibt dann das transponierte Array aus.

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

Testlauf

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

Tcl 49 Bytes

Kein Gewinner, aber immerhin ist es wettbewerbsfähig:

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

Swift 2.0, 79 Bytes

Nichts Schlaues ...

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