_{Bu teğetsel olarak ezoterik bir programlama dili icat etme arayışımla ilgilidir .}

İndeksleme işlemleri kullanılarak bir Evrensel İkili Fonksiyon uygulamak için 0 .. 15 ikili sayılarının bir tablosu kullanılabilir. İki adet 1 bitlik X ve Y girişi verildiğinde, 16 olası işlevin tümü 4 bitlik bir kodda kodlanabilir.

X Y  F|0 1 2 3 4 5 6 7 8 9 A B C D E F
- -    - - - - - - - - - - - - - - - -  
0 0    0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
0 1    0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1
1 0    0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1
1 1    0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
       -     -   - -   -   -   -   - -
       0    ~X  ~Y ^   &   Y   X   | 1
      ZERO    NOT-Y   AND         OR
          NOT-X   XOR              ONE

Böylece bu 16 işlev kümesi ikili girişlere işlev olarak uygulanabilir

U (f, x, y): (f >> ((x << 1) | y)) & 1 ,

veya

U (f, x, y): (f / 2 ^ (x × 2 + y))% 2 ,

veya indeksleme veya matris bölümleme ile.

Bu tür bir ikili işlem üzerine inşa edilecek olası dilleri temsil etmek veya üretmek için en kompakt yolu bilmek faydalı olacaktır.

Amaç:

Bu tam metin çıktısını oluşturun:

0101010101010101
0011001100110011
0000111100001111
0000000011111111

Bu kadar! En kısa kod kazanır.

J, 10 (13?) Karakter

|.|:#:i.16

Numara listesi:

   i.16
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15`

ikiliye:

   #:i.16
0 0 0 0
0 0 0 1
0 0 1 0
0 0 1 1
0 1 0 0
0 1 0 1
0 1 1 0
0 1 1 1
1 0 0 0
1 0 0 1
1 0 1 0
1 0 1 1
1 1 0 0
1 1 0 1
1 1 1 0
1 1 1 1

devrik:

   |:#:i.16
0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1
0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1
0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1

Ters:

   |.|:#:i.16
0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1
0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1
0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1

Boşlukları kaldırmamız gerekiyor mu? Yüzden biz 3 karakterler eklemek ve ödünç gerekir mi görünüyor diğer J cevap baktığımızda 1":dan Jan'ın cevap .

Python 2, 40

for n in 1,2,4,8:print 8/n*('0'*n+'1'*n)

APL (14)

Varsayım ⎕IO=0(bu bir ayardır):

⎕D[⊖(4⍴2)⊤⍳16]

Açıklama:

• ⍳16: sayılar [0,16)
• (4⍴2)⊤: 2 basamaktaki her sayıyı 4 basamak kullanarak kodlayın
• ⊖: yatay ters (böylece MSB en üste çıkar)
• ⎕D[... ]: ⎕Ddizeden bu değerleri seçin 0123456789. (Değerler arasındaki boşluklarla sayısal bir matris görüntülenir, bir karakter matrisi değildir. Böylece bu, her sayısal biti karakterlerden birine dönüştürür '0' '1').

Jöle , 42 7 bayt (rakip olmayan)

⁴ḶBUz0Y

Çevrimiçi deneyin!

Dennis'e yardımları için teşekkürler. Buraya , ilk mesajdır burada son (diğer tartışmalar da oluştu) 'dir. Onun yardımıyla, görünüşe göre (neredeyse) skoru kök salmıştım.

/// , 51 bayt

Çevrimiçi deneyin

/a/0101/aaaa
/b/0011/bbbb
/z/0000//o/1111/zozo
zzoo

GolfScript ( 18 17 15 karakter)

(Howard sayesinde)

16,zip{','-~n}%

Neden 10 karakterlik

16,zip{n}/

çalışmıyor; Standart yorumlayıcıdaki bir hatanın yığın üzerinde desteklenmeyen türlere yol açtığından şüpheleniyorum.

Tam olarak anladığım 18 karakterlik bir alternatif:

4,{2\?.2,*$8@/*n}%

Daha matematiksel bir yaklaşım 28 karakterden biraz daha uzun:

4,{2.@??)2.4??.@/+2base(;n}/

Bunların çoğu temel dönüşüm ve sıfır dolgu içindir. Bunlar olmadan 19 karaktere düşer,

4,{2.@??)2.4??\/n}/

çıktı ile

21845
13107
3855
255

CJam - 16

4,{G,f{\m>2%}N}/

Eşdeğer java kodu (açıklama olarak):

public class Lookup {
    public static void main(final String... args) {
        for (int i = 0; i < 4; ++i) {
            for (int j = 0; j < 16; ++j) {
                System.out.print((j >> i) % 2);
            }
            System.out.println();
        }
    }
}

Javascript (ECMA6), 67

s=(k,n)=>n-.5?s((k<<n/2)^k,n/2)+"0".repeat(n)+k.toString(2)+"\n":"" 

Bunu kullanmak için arayın

s(255,8)

Bitshift!
Ve ayrıca XOR ve biraz özyineleme.

Dikkat edilmesi gereken ilk şey, herhangi bir satır alırsak ve onu (sürekli 0'ların sayısı) / 2 sola kaydırırsanız, bir sonraki satırı almak için güzel bir XOR alırız.

Örneğin,

0000000011111111 //line 4
0000111111110000 //shifted 4 to the left

XOR bunlar bitsel olarak bize

0000111100001111 //XOR'ed. This is line 3!

ki bu bir sonraki satırdır (satır 3).
Aynı işlemi hat 3, shift 2 sola uyguladığınızda ...

0000111100001111
0011110000111100

XOR'ed verir

0011001100110011

hangi satır 2'dir
miktarı biz Yarıları her zaman kayması Bildirimi söyledi.
Şimdi bu işlevi 2 argümanla özyinelemeli olarak adlandırıyoruz. Bu çizginin tamsayı değeri ve N, ne kadar kaydırmamız gerektiği. Tekrarlama yaptığımızda sadece kaydırılan XOR'ed değerini ve n / 2'yi geçin.

"0".repeat(n)

her satırın başına 0'ları doldurmaktır çünkü toString baştaki 0'ları alır.

J, 21 karakter

1":<.2|(2^i.4)%~/i.16

• i.16 bir 0..15 listesidir
• 2^i.4 bir liste (1,2,4,8)
• %~/ sol argümanın satırlar oluşturduğu ancak bölünme için doğru argüman olduğu bölümler tablosu üretir
• 2| [her hücre] ikiye bölündükten sonra kalanını hesaplar
• <. 0 veya 1 değerinde kat sayısı
• 1": tabloyu hücre başına bir karakterle biçimlendirir

GolfScript, 19 karakter

Başka bir GolfScript yaklaşımı

4,{2\?{&!!}+16,%n}%

Yakut (44)

Sıkıcı ve uzun: Sadece sayıların 0 dolgulu ikili sunumlarını yazdırmak.

[21845,13107,3855,255].map{|i|puts"%016b"%i}

dipnot 108 177 126 77 74 70

[43690 52428 61680 65280]
{16{dup 2 mod =only 2 idiv}repeat<>=}forall

Daha basit bir değiştirme yöntemi için değerleri tersine çevirdi .

151 131 119

Daha APL -ish yaklaşımı uygulamak. edit: dizgi doğrama ve dizi sıkıştırma ile indeksleme ve for-loop'ları değiştirildi

[[0 1 15{}for]{16 add 2 5 string cvrs}forall]4 
-1 1{0 1 15{2 index exch get 1 index 1
getinterval =only}for pop<>=}for

Girintili'ye:

[[0 1 15{}for]{16 add 2 5 string cvrs}forall]
4 -1 1{ % [] i
    0 1 15{ % [] i j
        2 index exch get % [] i [](j)
        1 index 1  % [] i [](j) i 
        getinterval  % [] i [](j)<i>
        =only  % [] i
    }for 
    pop<>= % []
}for

Kazanan J cevabında kullanılan fonksiyonların yeniden uygulanması buna yol açar (birçok destek kodu ile ).

-1 16 i + #: |: |.{{==only}forall()=}forall

iİşte Iverson'ın Temel Fonksiyonlarında tarif edilen 1 tabanlı vektör , dolayısıyla -1 ... +üretmek 0 .. 15.

Perl (36 + 1)

sayHer zamanki gibi +1 . çift 0bir yazım hatası değil :)

map say((00x$_,1x$_)x(8/$_)),1,2,4,8

JavaScript (ECMA6), 108

Burada farklı bir yaklaşım denemek. İkili operatörleri kullanmaya teşvik edilmiş olsa da, meydan okuma da kolmogorov karmaşıklığı olduğu için kendime bu çözümü sunmaya izin verdim ve düşünüyordum - bu değerleri temsil eden kod miktarını nasıl azaltabilirim ...? Bazlar .

['gut','a43','2z3','73'].forEach(n=>{a=parseInt(n,36).toString(2);
alert(('00000000'+a).substr(a.length-8))})

(Kolaylık sağlamak için satır sonu).

Önde gelen sıfırlarla doldurmak zorunda kaldığım bir utanç, ama bu kodun noktası sadece tam olarak bu gut, a43, 2z3, 73değerler olan Base 36'daki hedef ikili sonucu temsil etmektir .

Not: Bunun kazanan cevaba yakın bir yerde olmayacağını anlıyorum, sadece fikir uğruna ...

Sprects , 44 bayt

 aaaa
bbbb
zozo
zzoo o1111 z0000 b0011 a0101

Cedric'in cevabı Sprects'e taşındı.

MATL ( rakip olmayan ), 8 bayt

16:qYB!P

Çevrimiçi deneyin!

açıklama

16:    % Generate range [1 2 ... 16]
q      % Subtract 1, element-wise
YB     % Convert to binary. Gives a 16×4 char array. Each original number is a row
!      % Transpose
P      % Reverse vertically. Implicitly display

CJam ( rakip olmayan ), 10 9 bayt

@Dennis'e 1 bayt kapalı için teşekkürler!

Y4m*zW%N*

Çevrimiçi deneyin!

açıklama

Y     e# Push 2
4     e# Push 4
m*    e# Cartesian power of 2 (interpreted as [0 1]) with exponent 4
z     e# Zip
W%    e# Reverse the order of rows
N*    e# Join with newlines. Implicitly display

JavaScript (ES6), 58 52 bayt

Dizeyi özyinelemeli olarak oluşturur.

f=(n=64)=>n--?f(n)+(!n|n&15?'':`
`)+(n>>(n>>4)&1):''

Nasıl çalışır

Bu özyineleme, desenin 0x0 ila 0xF nibble'larının dikey ikili gösteriminden yapıldığı gerçeğine dayanmaktadır:

  0101010101010101 bit #0 <- Y = 0
  0011001100110011 bit #1
  0000111100001111 bit #2
  0000000011111111 bit #3 <- Y = 3
  ----------------
  0123456789ABCDEF
  ^              ^
X = 0          X = 15

Bu nedenle, bu örüntüdeki her pozisyon (X, Y), X'in Y-bit biti olarak ifade edilebilir X & (1 << Y). Biz de bu biraz izole edebilir: (X >> Y) & 1. Aksine X ve Y takip yerine, yinelerler tek bir değişken üzerinde n0 ile 63. So değişen formül olur: (n >> (n >> 4)) & 1. Aslında 63'ten 0'a yineleme yapmak daha kolaydır, bu nedenle dize ters sırada oluşturulur. Başka bir deyişle, n-1 karakteri n karakterinin soluna eklenir .

Bir yan not olarak, özyineleme, kısa kod dışında buraya hiçbir şey getirmez.

Satır çizgileri olmadan, kod 35 bayt uzunluğundadır:

f=(n=64)=>n--?f(n)+(n>>(n>>4)&1):''

Satır çizgilerini eklemek için 17 bayta daha ihtiyacımız var. Önde gelen bir satır kırılması kabul edilebilirse bu, 14 bayta kadar kısaltılabilir.

gösteri

f=(n=64)=>n--?f(n)+(!n|n&15?'':`
`)+(n>>(n>>4)&1):''

console.log(f());

Bash + coreutils, 65 bayt

En kısa değil, en uzun değil:

for i in {1,2,4,8};{ eval echo \$\[\({0..15}\&$i\)/$i];}|tr -d \ 

(Son karakter boşluktur)

Çevrimiçi deneyin .

NARS2000 APL, 22

"01"[⊖1+(4⍴2)⊤(⍳16)-1]

Marinus'un NARS2000'de çalışmıyor gibi görünen APL cevabından türetilmiştir.

Vektör oluştur

      ⍳16
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

Sıfır tabanlı olarak değiştir

      (⍳16)-1
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Kodlama için şekil oluşturma

      (4⍴2)
2 2 2 2

kodlamak

      (4⍴2)⊤(⍳16)-1
0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1
0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1
0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1

1 tabanlı dizine ekleme için ayarlama

      1+(4⍴2)⊤(⍳16)-1
1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2
1 1 1 1 2 2 2 2 1 1 1 1 2 2 2 2
1 1 2 2 1 1 2 2 1 1 2 2 1 1 2 2
1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2

Ters birincil eksen

      ⊖1+(4⍴2)⊤(⍳16)-1
1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2
1 1 2 2 1 1 2 2 1 1 2 2 1 1 2 2
1 1 1 1 2 2 2 2 1 1 1 1 2 2 2 2
1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2

indeks

      "01"[⊖1+(4⍴2)⊤(⍳16)-1]
0101010101010101
0011001100110011
0000111100001111
0000000011111111

C, 73 karakter

i;main(){for(;i<64;)i&15||puts(""),putchar(48|1&~0xFF0F0F33335555>>i++);}

Bu sadece 16 bitlik dört blokta 64 bit çıkışı için genel bir çözümdür; sadece 0xFF0F0F33335555başka bir bit dizisi çıkışı için sayıyı değiştirmeniz yeterlidir .

basitleştirilmiş ve çözülmemiş:

int main() {
    int i;
    for(i = 0; i < 64; i++) {
        if(i % 16 == 0) {
            puts("");
        }
        int bit = ~0xFF0F0F33335555 >> i;
        bit &= 1;
        putchar('0' + bit);
    }
}

Haskell, 73

Yikes, 73 karakter! Tanrı aşkına bunu daha da küçültemem.

r=replicate
f n=r(div 8n)("01">>=r n)>>=id
main=mapM(putStrLn.f)[1,2,4,8]

Bunun gerçek üzücü yanı, çıktıyı bash kullanarak yankılayacak olsaydınız, sadece 74 karaktere ihtiyacınız olurdu.

JavaScript (ES5) 69

for(x="";4>x;x++){z="";for(n=0;16>n;)z+=1-!(n++&1<<x);console.log(z)}

Ca2 ,33 27 24

4 16#(,`2|(~16)%.2^~4){D

Bu, Jan Dvorak'ın cevabına dayanıyor . inca2 bunu dünün hata düzeltmelerinden itibaren yürütebilir. Dil sorudan sonra icat edildiğinden teknik olarak geçersiz, ancak bir dilin icadı soru sorma hedefimin bir parçasıydı. İşte diğer cevaplara şükranla bir miktar geri ödeme. :)

Açıklama:

4 16#(,`2|(~16)%.2^~4){D
          (~16)               integers 0 .. 15 
                 2^~4         first 4 powers of 2: 1 2 4 8
          (~16)%.2^~4         division table
        2|                    mod 2 (and floor)
       `                      transpose
      ,                       ravel
     (               ){D      map to chars '0'..'9'
4 16#                         reshape to 4x16

Bazı parantezler gereksiz olmalı, ancak görünüşe göre gramer hakkındaki yorumumda kalan bazı sorunlar var. Ve "ravel => map => yeniden şekillendirme" gerçekten beceriksiz: haritanın daha akıllı olması gerekiyor. Düzenleme: hata düzeltmeleri parenlerin ortadan kaldırılmasına izin verir.

Baz dönüşümünü ayrı bir fonksiyona N:x|y%.x^~1+[]/x.yçarpanlara ayırmak bunu verir19 16 karakter sürümü.

4 16#(,`2N~16){D

Ve yine de burada hile yaparken, devam ettim ve bunu yerleşik bir işlev haline getirdim. Ancak, niladik bir işlev olsa da (argüman gerektirmeyen), niladik işlevler için destek yoktur ve kukla bir argümanla sağlanmalıdır.

inca2, 2

U0

24/26 Pyth

En kısa yöntem, kendi yöntemimi yaptım bu yüzden ucuz hissettim Pyth tercüme grc cevap oldu:

Mine: 26 karakter

 mpbjk*/8dS*d[0 1)[1 2 4 8

grc's: 24 karakter

Fd[1 2 4 8)*/8d+*\0d*\1d

C ++ 130

Onaltılık ifadeyi ikiliye dönüştürür

#define B std::bitset<16>
#define C(x) cout<<x<<endl;
void main(){
B a(0xFF),b(0xF0F),c(0x3333),d(0x5555);
C(d)C(c)C(b)C(a)
}

Haskell (Lambdabot), 47 bayt

unlines$reverse$transpose$replicateM 4['1','0']

Biraz daha ucuz çünkü Data.Menad'den transposate kullanıyor ve Control.Monad'dan replicateM kullanıyor , ancak her ikisi de varsayılan olarak Lambdabot'tan yükleniyor.

Ayrıca, iyileştirme için yer olduğuna eminim, sadece fikri paylaşmak istedim

Julia (39 Bayt)

Julia'da yazdığım ikinci senaryo, Julia'yı sevdiğimi itiraf etmeliyim, o çok sevimli bir canavar.

hcat(map(x->collect(bin(x,4)),0:15)...)

İadeler

[0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 
 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 
 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1
 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1]  

Açıklama:

• bin(x,4) - int 4 karakterli dolgu ile ikili tamsayıya dönüştürün.
• collect(_) - Karakter dizisini karakter dizisine ayır.
• map(x->_,0:15) - Bunu aralıktaki ilk 16 basamak için yapın.
• hcat(_...) - Splat ve yatay olarak bir matrise birleştirin.

C 83 77 76 74 71

x;f(n){for(;x<4;x++,puts(""))for(n=0;n<16;)putchar(49-!(n++&(1<<x)));}

Oldukça basit.

x;
f(n){
    for(;x<4;x++,puts(""))
        for(n=0;n<16;)
            putchar(49-!(n++&(1<<x)));
}

R, 53 41 bayt

@ Grc'nin python cevabının çevirisi. rep()'S eachve lengthargümanlarını (ve kısmi argüman eşleşmesini) kullanarak ve 0:1bunun eşdeğer olduğunu hatırlayarak orijinal çeviriden 12 bayt çıkarıldı c(0,1).

for(n in 2^(0:3))print(rep(0:1,e=n,l=16))

for(n in 2^(0:3))print(rep(c(rep(0,n),rep(1,n)),8/n))

Ayrıca, aşağıdaki gibi bir şey @ @ Gareth'in J cevabının çevirisini deneyebilirsiniz (34 bayt):

t(e1071::bincombinations(4))[4:1,]

Bununla birlikte, R tabanının parçası olmayan bir işlev kullanır ve belirtimdeki gibi tam basılı metne biçimlendirilmesi zor olan bir matris çıkarır.