Antiferromanyetizma IBM araştırmacılar atlamak için kullanılan bir 1 terabayt diski a 100 terabayt diskin atomların aynı miktarda uygulanır.

Antiferromanyetizma sergileyen malzemelerde, genellikle elektronların spinleri ile ilişkili olan atomların veya moleküllerin manyetik momentleri, zıt yönlere işaret eden komşu spinler (farklı alt kapaklarda) ile düzenli bir şekilde hizalanır.

İşiniz, yukarıda gösterilen resim gibi antiferromanyetik atomların sırasını çizen bir program yazmaktır. Daha fazlasına sahip olsanız da, en az dört çift kümeye sahip olmanız gerekir.

Her çift gerçek oklar olsa da aşağıdaki gibi gösterilmelidir :

 yukarı aşağı
Aşağı
 yukarı aşağı

Çıktınız ascii sanatında veya grafik çıktısında olabilir.

Sadece bir işlev veya bütün bir program yapabilirsiniz, ancak bir girdi almalı ve o çiftleri çizmelidir. Yalnızca kelimeler içeren örnekler :

Giriş: 1

 yukarı aşağı
Aşağı
 yukarı aşağı

Giriş: 2

 yukarı aşağı yukarı aşağı 
aşağı yukarı aşağı yukarı  
 yukarı aşağı yukarı aşağı

Kabul edilebilir oklar:

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

Okuması kolay olduğu için lütfen cevaplarınızı Dil, X bayt formatında girin. En az bayt miktarı kazanır!

APL, 18 12 bayt

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

Bu yapılar, bir 2n x 3 matris n girişi (burada ⎕karakterlerle dolu), ↑ve ↓. ⍉Bu matrisin transpozisyonu ( ) yazdırılır.

Şunları yapabilirsiniz çevrimiçi denemek .

Pyth, 15 bayt (11 karakter)

V3.>*Q"↑↓"N

Çevrimiçi deneyin: Gösteri

Açıklama:

              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 bayt

Okları grafiksel olarak gösteren bir örnek:

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

Daha okunabilir bir biçimde:

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

Giriş olarak 5 için ekran:

Okları görmek için görünen pencereyi yeniden boyutlandırmanız gerekir. Ben hiçbiri pencerenin iç sınır tarafından "kesilmiş" görünmeyecek şekilde yapmaya çalıştım, ama bazı platformlarda bu şekilde görünebilir.

CJam, 18 bayt (14 karakter)

ri3*"↑↓"*3/zN*

Sütunları oluşturun (yinelenen bir desen oluşturur) ve sonra dönüştürün.

Çevrimiçi deneyin .

Alternatif 18 bayt:

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

Dizeyi "↑↓"*n0, 1 veya 2 kez döndürün .

CJam (15 karakter, 19 bayt)

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

Çevrimiçi demo

Befunge, 71 bayt

İlk cevabım, bu yüzden lütfen bana karşı nazik ol: o)

Can sıkıcı hizalama sorunları birkaç boşa boşa sonuçlandı, eğer benim için herhangi bir gelişmeniz varsa onları duymak isterim!

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

Giriş: 4

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

CJam, 14 bayt

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

Bu, kod sayfasını 850'yi aşağıdaki gibi gösteren bir destekleyici terminal gerektirir :

Kodun sivri olmayan kısmının @ Sp3000'in alternatif sürümü ile aynı olduğu ortaya çıktı .

CJam, 17 bayt

ri"⇅⇵⇅"f*N*

@DigitalTrauma kredileri ile ucuz çift ok versiyonu.

Çevrimiçi deneyin.

Pyth, 16 bayt (12 karakter)

J"↑↓"V3*~_JQ

Misal:

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

Python 2, 131122 bayt

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

Şey ... C Java'yı yendim sanırım?

32Oklar için yükseklik seçtim , bu oldukça büyük, bu yüzden bir süre sonra kaplumbağa ekrandan çekilmeye başlıyor. Her şeyin büyük girdilere sığmasını istiyorsanız, 32s'yi değiştirerek okları küçültebilir veya kullanabilirsiniz screensize()(ekran dışı çıktıda meta yazı olup olmadığından emin değilim ...)

GNU sed, 25 bayt

Daha kısalmaya izin veren ⇅ve ⇵unicode ok simgelerini buldum ve bu yoruma izin verildi :

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

Giriş tekli , yani 4 1111:

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

Önceki yanıt durumunda ⇅ve ⇵izin verilmiyorsa:

GNU sed, 39 bayt

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

Swift 2, 66 bayt

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

Swift sadece biraz daha az ayrıntılı bir ayrıntı olsa bile, golf oynamak için o kadar da kötü olmazdı (Sana bakıyorum, adlandırılmış parametre appendNewline)

Ruby 39 (veya 44) karakter, 43 (veya 48) bayt

Https://mothereff.in/byte-counter'a göre ok karakterlerinin her biri 3 bayttır!

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

Dizi döndüren anonim bir işlev. İşlev diziyi yazdırmak zorundaysa, puts a5 bayt daha sona ermelidir.

Örnek kullanım

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

puts f.call(6)

verir

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

J, 41 35 32 bayt (28 karakter)

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

J'de hiçbir şey programlamadım, bu yüzden bu biraz zamanımı aldı ve bunu yapmanın kesinlikle en iyi yolu değil.

Bu, oklar çıkmadan önce çalıştırıldığında bir sayı girmenizi bekler.

Javascript (ES6), 66 63 53 47 bayt ( 62 55 49 41 karakter)

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

Tra ve ⇵ karakterlerini bulmak ve daha fazla bayt tıraş etmemi sağlamak için Dijital Travma desteği.

J, 30 bayt

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

Cı, 169 170 162 125 123 105 119 107 bayt

Açıkçası kazanan olmasa da, bunu da deneyebilirim :)

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

Misal:

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

Güncelleme:

Bak burada koş

Oktav, 37 bayt

EDIT: önceki şerit-antiferromanyetik versiyondan düzeltildi. Hatamı yakaladığınız için @ beta-bozunumuna teşekkürler.

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

Bir işlevi tanımlar f(n). Örnek çıktı:

octave:4> f(1)
ans =

⇅
⇵
⇅

octave:5> f(5)
ans =

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

CoffeeScript, 60 bayt (58 karakter)

Anlamalar, özyineleme olmadan kolaylaştırır:

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

Ruby, 33 bayt

İşlev olarak:

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

Misal:

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

Ruby, 37 bayt

Stdin'den girdi alan tam program:

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

> <>, 55 Bayt

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

İstediğiniz uzunluğu ilk yığın değeri olarak girerek burada çevrimiçi deneyin .

Çözüm olmayan, 59 Bayt:

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

BBC BASIC, 70 bayt

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

Bu muhtemelen daha fazla golf edilebilir

C, 97 bayt

İlk komut satırı parametresinden girişi alır, örn main 4. Çiftlere kadar destekler 357913940. C'de çok baytlı karakterleri chars olarak kullanamazsınız, ancak dize olarak iyi çalışırlar.

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

Bir işlev olarak daha küçüktür, ancak diğer C cevapları tam programlardır, bu yüzden ben de yaptım. 69 bayt olur:

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

Python 2, 47 bayt

Python'un dizeleri nasıl kolayca tersine çevirebileceğinden yararlanarak BBC BASIC cevabımın limanı .

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

C, 117 89 85 bayt

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 bayt (62 karakter)

Bu, her biri üç bayt olarak sayılan Unicode karakterinin yanı sıra bir bayt olarak sayılan zorunlu yeni satırı içerir.

Özyinelemeyi bu yanıttan esinlenerek kullanır . Ben özyinelemesiz denedim ama bir başkası benden daha iyi yapmak nasıl biliyor olabilir, ancak tanımlanmış bir dizi oluşturmak çok fazla karakter aldı.

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

gösteri

Tüm ES6 yanıtlarında olduğu gibi, Firefox, Edge ve Safari 9'da yalnızca yazma sırasında gösterilebilirler:

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 bayt

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

Çıktı g(2):

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

Python 2, 45 55 bayt

düzenleme: değiştirilmiş oklar

Oldukça basit bir yaklaşım. Yine de unicode oklarla çalışmaz.

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

R, 60 62 bayt

STDIN'den girdi alır ve STDOUT'a çıktılar. 3 x (2 * giriş) dizi oluşturur, satır başı sütununu ekler ve sonra aktarılan diziyi çıkarır.

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

Test sürüşü

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

Tcl 49 bayt

Kazanan yok ama en azından rekabetçi:

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

Swift 2.0, 79 bayt

Akıllıca bir şey yok ...

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