Антиферромагнетизм - это то, что исследователи IBM использовали для перехода от 1 терабайтного диска к 100 терабайтному диску с тем же количеством атомов.

В материалах, которые проявляют антиферромагнетизм, магнитные моменты атомов или молекул, обычно связанные со спинами электронов, равномерно выравниваются с соседними спинами (на разных подрешетках), указывающими в противоположных направлениях.

Ваша задача - написать программу, которая рисует порядок расположения антиферромагнитных атомов, как показано на рисунке выше. Вы должны иметь как минимум четыре пары пар, хотя их может быть больше.

Каждая пара должна быть показана следующим образом, хотя они должны быть действительными стрелками :

 вверх вниз
вниз до
 вверх вниз

Ваш вывод может быть в ascii art или в графическом виде.

Вы можете создать только функцию или целую программу, но для этого нужно ввести и нарисовать столько пар. Примеры только с словами :

Вход: 1

 вверх вниз
вниз до
 вверх вниз

Вход: 2

 вверх вниз вверх вниз 
вниз вверх вниз вверх  
 вверх вниз вверх вниз

Допустимые стрелки:

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

Пожалуйста, поместите ваши ответы в язык, формат X байтов , так как это легко читать. Наименьшее количество байтов выигрывает!

APL, 18 12 байт

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

Это создает матрицу 2n x 3, где n - это input ( ⎕), заполненная символами ↑и ↓. Транспонирование ( ⍉) этой матрицы затем печатается.

Вы можете попробовать это онлайн .

Pyth, 15 байтов (11 символов)

V3.>*Q"↑↓"N

Попробуйте онлайн: демонстрация

Объяснение:

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

Ява, 313 296 байт

Вот пример, который отображает стрелки графически:

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

В более читаемом формате:

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

Дисплей для 5 в качестве входа:

Вам придется изменить размер окна, которое появляется, чтобы увидеть стрелки. Я попытался сделать так, чтобы ни один из них не казался «отрубленным» внутренней границей окна, но на некоторых платформах это может выглядеть так.

CJam, 18 байтов (14 символов)

ri3*"↑↓"*3/zN*

Создайте столбцы (которые образуют повторяющийся шаблон), затем транспонируйте.

Попробуйте онлайн .

Альтернатива 18 байт:

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

Поверните строку "↑↓"*n0, 1 или 2 раза.

CJam (15 символов, 19 байтов)

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

Онлайн демо

Befunge, 71 байт

Мой первый ответ, поэтому, пожалуйста, будьте нежны со мной: о)

Раздражающие проблемы с выравниванием привели к потере нескольких байтов, если у вас есть какие-то улучшения для меня, я бы хотел их услышать!

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

Вход: 4

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

CJam, 14 байтов

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

Для этого требуется поддерживающий терминал, который отображает кодовую страницу 850 следующим образом:

Не заостренная часть кода оказалась идентичной альтернативной версии @ Sp3000 .

CJam, 17 байт

ri"⇅⇵⇅"f*N*

Читерская версия с двумя стрелками, с кредитами на @DigitalTrauma.

Попробуйте онлайн.

Pyth, 16 байтов (12 символов)

J"↑↓"V3*~_JQ

Пример:

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

Python 2, 131 122 байта

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

Ну ... я бью C Java, я думаю?

Я выбрал высоту 32для стрелок, которая довольно большая, поэтому через некоторое время черепаха начинает рисовать за кадром. Если вы хотите, чтобы все подходило для больших входов, вы можете либо уменьшить стрелки, заменив 32s, либо использовать screensize()(я не уверен, есть ли мета-пост на выводе за пределы экрана ...)

GNU sed, 25 байт

Я нашел символы стрелок ⇅и ⇵unicode, которые допускают большее сокращение, и они были разрешены этим комментарием :

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

Ввод одинарный , например, 4 1111:

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

Предыдущий ответ в случае ⇅и⇵ не разрешено:

GNU sed, 39 байт

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

Swift 2, 66 байт

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

Если бы Swift был бы чуть менее многословным, он даже не был бы таким плохим для игры в гольф (я смотрю на тебя, названный параметр appendNewline )

Ruby 39 (или 44) символов, 43 (или 48) байта

Согласно https://mothereff.in/byte-counter символы со стрелками по 3 байта каждый!

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

Анонимная функция, которая возвращает массив. Если функция должна напечатать массив, она должна заканчиваться еще puts aна 5 байтов.

Пример использования

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

puts f.call(6)

дает

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

J, 41 35 32 байта (28 символов)

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

Я никогда ничего не программировал на J, так что это заняло у меня некоторое время, и это определенно не лучший способ сделать это.

Это ждет, когда вы введете число при запуске, прежде чем выводить стрелки.

Javascript (ES6), 66 63 53 47 байтов ( 62 55 49 41 символов)

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

Перейдем к Digital Trauma, чтобы найти символы ⇅ и ⇵ и позволить мне сбрить больше байтов.

J, 30 байт

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

C 169 170 162 125 123 105 119 107 байт

Так что, хотя я мог бы попробовать, даже если это явно не победитель :)

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

Пример:

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

Обновить:

Смотрите, бегите сюда

Октава, 37 байт

РЕДАКТИРОВАТЬ: исправлено из более ранней полосой антиферромагнитной версии. Спасибо @ beta-decay за то, что поймали мою ошибку.

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

Определяет функцию f(n). Образец вывода:

octave:4> f(1)
ans =

⇅
⇵
⇅

octave:5> f(5)
ans =

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

CoffeeScript, 60 байтов (58 символов)

Понимание облегчает без рекурсии:

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

Рубин, 33 байта

Как функция:

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

Пример:

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

Рубин, 37 байт

Полная программа, которая принимает входные данные от стандартного ввода:

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

> <>, 55 байт

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

Попробуйте онлайн здесь , введя желаемую длину в качестве начального значения стека.

Non ⇅⇵ решение, 59 байт:

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

BBC BASIC, 70 байт

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

Это, вероятно, может быть в гольф больше

C 97 байтов

Принимает ввод из первого параметра командной строки, например main 4. Поддерживает до 357913940пар. В C вы не можете использовать многобайтовые символы как chars, но они отлично работают как строки.

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

Это меньше как функция, но другие ответы C были полными программами, поэтому я тоже это сделал. Было бы 69 байтов:

i;f(n){for(i=6*n+3;i--;)printf("%s",i%(2*n+1)?i%2?"↓":"↑":"\n");}

Python 2, 47 байт

Порт моего BBC BASIC ответа , используя преимущества того, как Python может легко переворачивать строки.

n=r"/|\\|/"*input();print n+"\n"+n[::-1]+"\n"+n

C 117 89 85 байт

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 байт (62 символа)

Это включает в себя символ Unicode, который считается по три байта каждый, а также обязательный символ новой строки, который считается одним байтом.

Использует рекурсию, вдохновленную этим ответом . Я попробовал это не рекурсивно, но генерация определенного массива заняла слишком много символов, хотя кто-то другой мог бы знать, как сделать это лучше меня.

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

демонстрация

Как и во всех ответах ES6, они демонстрируются в Firefox, Edge и Safari 9 только во время написания:

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 байт

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

Выход g(2):

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

Python 2, 45 55 байт

редактировать: измененные стрелки

Довольно простой подход. Однако не работает со стрелками Юникода.

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

R, 60 62 байта

Принимает ввод из STDIN и выводит в STDOUT. Создает массив 3 x (2 * input) , добавляет столбец возвратов каретки и затем выводит транспонированный массив.

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

Тестовый забег

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

Tcl 49 байт

Нет победителя, но, по крайней мере, он конкурентоспособен:

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

Swift 2.0, 79 байт

Ничего умного ...

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