L'antiferromagnétisme est ce que les chercheurs d'IBM utilisaient pour passer d'un disque de 1 téraoctet à un disque de 100 téraoctet dans la même quantité d'atomes.

Dans les matériaux qui présentent un antiferromagnétisme, les moments magnétiques des atomes ou des molécules, généralement liés aux spins d'électrons, s'alignent de façon régulière avec les spins voisins (sur différents sous-réseaux) pointant dans des directions opposées.

Votre travail consiste à écrire un programme qui dessine l'ordre des atomes antiferromagnétiques comme l'image ci-dessus. Vous devez être en mesure d'avoir au moins quatre ensembles de paires, bien que vous puissiez en avoir plus.

Chaque paire doit être représentée comme suit, bien qu'il s'agisse de flèches réelles :

 de haut en bas
en bas
 de haut en bas

Votre sortie peut être en art ascii ou en sortie graphique.

Vous ne pouvez créer qu'une fonction ou un programme entier, mais il doit prendre une entrée et dessiner autant de paires. Exemples avec seulement des mots :

Entrée: 1

 de haut en bas
en bas
 de haut en bas

Entrée: 2

 haut bas bas 
vers le bas vers le haut  
 haut bas bas

Flèches acceptables:

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

Veuillez mettre vos réponses au format Langue, X octets , car elles sont faciles à lire. Le moins d'octets gagne!

APL, 18 12 octets

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

Cela construit une matrice 2n x 3, où n est l'entrée (⎕ ), remplie des caractères ↑et ↓. La transposition ( ⍉) de cette matrice est ensuite imprimée.

Vous pouvez l' essayer en ligne .

Pyth, 15 octets (11 caractères)

V3.>*Q"↑↓"N

Essayez-le en ligne: Démonstration

Explication:

              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 octets

Voici un exemple qui affiche graphiquement des flèches:

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

Dans un format plus lisible:

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

L'affichage pour 5 en entrée:

Vous devrez redimensionner la fenêtre qui apparaît pour voir les flèches. J'ai essayé de faire en sorte qu'aucun d'entre eux n'apparaisse "coupé" par la bordure intérieure de la fenêtre, mais cela peut apparaître de cette façon sur certaines plates-formes.

CJam, 18 octets (14 caractères)

ri3*"↑↓"*3/zN*

Générez les colonnes (qui forment un motif répétitif) puis transposez.

Essayez-le en ligne .

Alternative 18 octets:

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

Faites pivoter la chaîne "↑↓"*nde 0, 1 ou 2 fois.

CJam (15 caractères, 19 octets)

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

Démo en ligne

Befunge, 71 octets

Ma première réponse, alors soyez gentil avec moi: o)

Des problèmes d'alignement ennuyeux ont entraîné quelques octets gaspillés, si vous avez des améliorations pour moi, j'aimerais les entendre!

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

Entrée: 4

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

CJam, 14 octets

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

Cela nécessite un terminal de support qui rend la page de codes 850 comme ceci:

La partie non pointue du code s'est avérée être identique à la version alternative de @ Sp3000 .

CJam, 17 octets

ri"⇅⇵⇅"f*N*

Version à double flèche tricheuse, avec des crédits à @DigitalTrauma.

Essayez-le en ligne.

Pyth, 16 octets (12 caractères)

J"↑↓"V3*~_JQ

Exemple:

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

Python 2, 131 122 octets

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

Eh bien ... j'ai battu C Java je suppose?

J'ai choisi la hauteur 32des flèches, qui est assez grande, donc après un certain temps, la tortue commence à dessiner hors écran. Si vous voulez que tout convienne à de grandes entrées, vous pouvez soit réduire les flèches en remplaçant les 32s, soit utiliser screensize()(je ne suis pas sûr qu'il y ait un méta post sur la sortie hors écran ...)

GNU sed, 25 octets

J'ai trouvé les symboles de flèche ⇅et ⇵unicode, qui permettent plus de raccourcissement et ils ont été autorisés par ce commentaire :

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

L'entrée est unaire , donc par exemple 4 est 1111:

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

Réponse précédente au cas où ⇅et⇵ refusée:

GNU sed, 39 octets

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

Swift 2, 66 octets

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

Si Swift était juste un peu moins verbeux, ce ne serait même pas si mal pour le golf (je vous regarde, paramètre nommé appendNewline)

Ruby 39 (ou 44) caractères, 43 (ou 48) octets

Selon https://mothereff.in/byte-counter, les flèches sont de 3 octets chacune!

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

Une fonction anonyme qui renvoie un tableau. Si la fonction doit imprimer le tableau, elle doit se terminer par puts a5 octets supplémentaires.

Exemple d'utilisation

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

puts f.call(6)

Donne

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

J, 41 35 32 octets (28 caractères)

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

Je n'ai jamais rien programmé en J, donc cela m'a pris du temps, et ce n'est certainement pas la meilleure façon de le faire.

Cela attend que vous saisissiez un nombre lors de l'exécution avant de sortir les flèches.

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

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

Props to Digital Trauma for finding the ⇅ and ⇵ characters and allowing me to shave off more bytes.

J, 30 bytes

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

C, 169 170 162 125 123 105 119 107 bytes

So, I though I might as well give this a go, even though this is obviously not the winner :)

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

Example:

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

Update:

See it run here

Octave, 37 bytes

EDIT: corrected from the earlier stripe-antiferromagnetic version. Thanks @beta-decay for catching my mistake.

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

Defines a function f(n). Sample output:

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