Antiferromagnetic ordering

Question

Antiferromagnetism is what IBM researchers used to jump from a 1 terabyte disk to a 100 terabyte disk in the same amount of atoms.

In materials that exhibit antiferromagnetism, the magnetic moments of atoms or molecules, usually related to the spins of electrons, align in a regular pattern with neighboring spins (on different sublattices) pointing in opposite directions.

Your job is to write a program that draws the ordering of antiferromagnetic atoms like the picture shown above. You must be able to have at least four sets of pairs, though you may have more.

Each pair must be shown as follows, though they must be actual arrows:

 up  down
down  up
 up  down

Your output can be in ascii art or graphical output.

You can make only a function or a whole program, but it must take an input and draw that many pairs. Examples with only words:

Input: 1

 up  down
down  up
 up  down

Input: 2

 up  down  up  down 
down  up  down  up  
 up  down  up  down

Acceptable arrows:

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

Please put your answers in Language, X bytes format, as it's easy to read. The least amount of bytes wins!

Answer 1

APL, 18 12 bytes

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

This constructs a 2n x 3 matrix, where n is the input (⎕), filled with the characters ↑ and ↓. The transpose (⍉) of this matrix is then printed.

You can try it online.

Answer 2

Pyth, 15 bytes (11 chars)

V3.>*Q"↑↓"N

Try it online: Demonstration

Explanation:

              implicit: Q = input number
V3            for N in [0, 1, 2]:
      "↑↓"       string "↑↓"
    *Q           repeat Q times
  .>      N      rotate the string by N

Answer 3

Java, 313 296 bytes

Here's an example that displays arrows graphically:

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

The display for 5 as input:

You'll have to resize the window that appears to see the arrows. I tried to make it so that none of them would appear "chopped off" by the window's inside border, but it may appear that way on certain platforms.

Answer 4

CJam, 18 bytes (14 chars)

ri3*"↑↓"*3/zN*

Generate the columns (which form a repeating pattern) then transpose.

Try it online.

---

Alternative 18 bytes:

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

Rotate the string "↑↓"*n by 0, 1 or 2 times.

Answer 5

CJam (15 chars, 19 bytes)

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

Online demo

Answer 6

Befunge, 71 bytes

My first answer, so please be gentle with me :o)

Annoying alignment issues resulted in a few wasted bytes, if you have any improvements for me I'd love to hear them!

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

Input: 4

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

Answer 7

CJam, 14 bytes

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

This requires a supporting terminal that renders code page 850 like this:

The non-pointy part of the code turned out to be identical to @Sp3000's alternative version.

---

CJam, 17 bytes

ri"⇅⇵⇅"f*N*

Cheaty double arrow version, with credits to @DigitalTrauma.

Try it online.

Answer 8

Pyth, 16 bytes (12 chars)

J"↑↓"V3*~_JQ

Example:

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

Answer 9

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

Well... I beat C Java I guess?

---

I've chosen height 32 for the arrows, which is pretty large, so after a while the turtle starts drawing offscreen. If you want everything to fit for large inputs, you can either make the arrows smaller by replacing the 32s, or use screensize() (I'm not sure if there's a meta post on offscreen output...)

Answer 10

GNU sed, 25 bytes

I found the ⇅ and ⇵ unicode arrow symbols, which allow more shortening and they have been allowed by this comment:

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

Input is in unary, so e.g. 4 is 1111:

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

---

Previous answer in case ⇅ and ⇵ are disallowed:

GNU sed, 39 bytes

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

Answer 11

Swift 2, 66 bytes

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

If Swift would be just a liiiitle bit less verbose, it wouldn't even be that bad for golfing (I'm looking at you, named parameter appendNewline)

Answer 12

Ruby 39 (or 44) characters, 43 (or 48) bytes

According to https://mothereff.in/byte-counter the arrow characters are 3 bytes each!

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

An anonymous function which returns an array. If the function has to print the array, it should end with puts a for 5 more bytes.

Example use

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

puts f.call(6)

Gives

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

Answer 13

J, 41 35 32 bytes (28 characters)

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

I have never programmed anything in J so this took me a while, and it's most definitely not the best way to do it.

This waits for you to input a number when run before outputing the arrows.

Answer 14

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.

Answer 15

J, 30 bytes

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

Answer 16

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

Answer 17

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 =

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

Answer 18

05AB1E, 17 11 bytes

ƵηSnŽXæ+ç×»

Bug-fixed and -6 bytes thanks to @ovs.

Uses ⇅ and ⇵.

Try it online or verify some more test cases.

Slightly larger simplified approach - 15 bytes in UTF-8 (8 characters):

"⇅⇵"ĆS×»

Try it online or verify some more test cases.

Explanation:

Unfortunately the 05AB1E codepage doesn't contain the arrow characters, so we have to create them ourselves or use UTF-8 encoding for the entire program.

Ƶη           # Push compressed integer 171
  S          # Convert it to a list of digits: [1,7,1]
   n         # Square each: [1,49,1]
    ŽXæ+     # Add compressed integer 8644 to each: [8645,8693,8645]
        ç    # Convert them to characters with these codepoints: ["⇅","⇵","⇅"]
         ×   # Repeat each character the (implicit) input amount of times as strings
          »  # And join this list of strings by newlines
             # (after which it is output implicitly as result)

"⇅⇵"        # Push string "⇅⇵"
     Ć       # Enclose, appending it's own head: "⇅⇵⇅"
      S      # Convert it to a list of characters: ["⇅","⇵","⇅"]
       ×»    # Same as above

See this 05AB1E tip of mine (section How to compress large integers?) to understand why Ƶη is 171 and ŽXæ is 8644.

Answer 19

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

Answer 20

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

Answer 21

><>, 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

Answer 22

BBC BASIC, 70 bytes

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

This can probably be golfed more

Answer 23

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

Answer 24

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

Answer 25

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

Answer 26

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>

Answer 27

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

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

Answer 28

Japt -R, 13 bytes

Went through a good few different methods but couldn't do better than 16 then I realised a port of Kevin's solution would come in a bit shorter.

#«ì £çX²d8644

Try it

Answer 29

Vyxal Dj, 11 bytes

‛↑↓3*½ÞTvṅ*

Try it Online!

-1 thanks to Aaron Miller

Answer 30

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