반 강자성은 IBM의 연구자가에서 이동하는 데 사용되는 것입니다 1 테라 바이트의 디스크 A와 100 테라 바이트의 디스크 원자의 같은 양.

반 강자성을 나타내는 물질에서, 일반적으로 전자의 스핀과 관련된 원자 또는 분자의 자기 모멘트는 반대 방향을 가리키는 인접한 스핀 (다른 서브 격자)과 규칙적인 패턴으로 정렬됩니다.

당신의 임무는 위의 그림과 같은 반 강자성 원자의 순서를 그리는 프로그램을 작성하는 것입니다. 더 많은 세트를 가질 수 있지만 최소한 네 쌍의 세트를 가질 수 있어야합니다.

각 쌍은 실제 화살표 여야하지만 다음과 같이 표시되어야합니다 .

 위아래
아래로
 위아래

출력은 ASCII 또는 그래픽 출력 일 수 있습니다.

함수 또는 전체 프로그램 만 만들 수 있지만 입력을 받아서 많은 쌍을 가져와야합니다. 단어 만있는 예 :

입력 : 1

 위아래
아래로
 위아래

입력 : 2

 up down up down 
아래로 위로  
 up down up down

허용되는 화살표 :

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

읽기 쉬운 언어로 X 바이트 형식으로 답을 입력하십시오 . 가장 적은 양의 바이트가 이깁니다!

APL, 18 12 바이트

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

이렇게 구성하는 2N × 3 행렬, N은 입력 (여기서 ⎕문자 충전), ↑및 ↓. ⍉그런 다음이 행렬 의 조옮김 ( )이 인쇄됩니다.

당신은 할 수 있습니다 온라인으로보십시오 .

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*

문자열 "↑↓"*n을 0, 1 또는 2 번 회전시킵니다 .

CJam (15 자, 19 바이트)

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

온라인 데모

Befunge, 71 바이트

나의 첫 번째 대답은, 나와 함께 부드럽게 해주세요 : o)

성가신 정렬 문제로 인해 몇 바이트가 낭비되었습니다. 개선이 있다면 듣고 싶습니다!

&::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에 크레딧을 제공하는 Cheaty 이중 화살표 버전.

온라인으로 사용해보십시오.

Pyth, 16 바이트 (12 자)

J"↑↓"V3*~_JQ

예:

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

파이썬 2, 131122 바이트

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 자바를 이길 것 같아?

나는 32꽤 큰 화살표의 높이 를 선택 했으므로 잠시 후 거북이가 화면 밖으로 그리기 시작합니다. 큰 입력에 모든 것을 맞추려면 32s 를 교체하여 화살표를 작게 만들 거나 사용할 수 있습니다 screensize()(오프 스크린 출력에 메타 포스트가 있는지 확실하지 않습니다 ...)

GNU sed, 25 바이트

나는 발견 ⇅하고 ⇵더 단축 허용 유니 코드 화살표 기호, 그들은이 댓글에 의해 허용 된을 :

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/

스위프트 2, 66 바이트

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

스위프트가 조금 덜 장황한 것이라면 골프를 치기에는 나쁘지 않을 것입니다 (파라미터라는 당신을보고 있습니다 appendNewline)

루비 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에서 아무것도 프로그래밍하지 않았으므로 시간이 오래 걸렸으며 가장 좋은 방법은 아닙니다.

화살표를 출력하기 전에 실행시 숫자를 입력 할 때까지 기다립니다.

자바 스크립트 (ES6), 66 63 53 47 바이트 ( 62 55 49 41 자)

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

에 소품 디지털 외상 ⇅ 및 ⇵ 문자를 발견하고 좀 더 바이트를 면도 할 수 있도록합니다.

J, 30 바이트

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

C, 169 170 162 125 123 105 119 107 바이트

그래서, 비록 이것이 분명히 승자가 아니더라도 나는 이것을 갈 수 있지만

골프 :

n,i,j;main(){n=getchar();n=atoi(&n);for(;j++<3;){for(i=0;i++<n;)printf("%.3s ","⇅⇵"+(j%2)*3);puts("");}}

언 골프 드 :

#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 바이트

편집하다: 이전의 반 강자성 버전에서 수정되었습니다. 내 실수를 잡아 주셔서 감사합니다.

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 바이트

stdin에서 입력을받는 전체 프로그램 :

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

> <>, 55 바이트

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

원하는 길이를 초기 스택 값으로 입력하여 여기서 온라인으로 시도 하십시오 .

비 ⇅⇵ 솔루션, 59 바이트 :

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

BBC 기본, 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");}

파이썬 2, 47 바이트

파이썬이 문자열을 쉽게 뒤집을 수있는 방법을 활용 한 BBC BASIC answer 포트 .

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

언 골프 드 :

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

자바 스크립트 (ES6), 66 바이트 (62 자)

여기에는 각각 3 바이트로 계산 된 유니 코드 문자와 1 바이트로 계산 된 필수 줄 바꿈이 포함됩니다.

이 답변에서 영감을 얻은 재귀를 사용합니다 . 비 재귀 적으로 시도했지만 정의 된 배열을 생성하는 데 너무 많은 문자가 필요했지만 다른 사람이 나보다 더 잘 수행하는 방법을 알 수 있습니다.

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>

자바, 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):

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

파이썬 2, 45 55 바이트

편집 : 수정 된 화살표

매우 간단한 접근법. 그러나 유니 코드 화살표로는 작동하지 않습니다.

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

R, 60 62 바이트

STDIN에서 입력을 가져 와서 STDOUT으로 출력합니다. 3 x (2 * 입력) 배열을 만들고 캐리지 리턴 열을 추가 한 다음 조옮김 배열을 출력합니다.

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

스위프트 2.0, 79 바이트

영리한 아무것도 ...

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