_{Isso está relacionado tangencialmente à minha busca por inventar uma linguagem de programação esotérica .}

Uma tabela dos números binários 0 .. 15 pode ser usada para implementar uma Função Binária Universal usando operações de indexação. Dadas duas entradas de 1 bit X e Y, todas as 16 funções possíveis podem ser codificadas em um código de operação de 4 bits.

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

Portanto, este conjunto de 16 funções pode ser aplicado a entradas binárias como a função

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

ou

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

ou com indexação ou particionamento de matriz.

Será útil conhecer a maneira mais compacta de representar ou gerar uma tabela de valores para quaisquer idiomas possíveis a serem construídos sobre esse tipo de operação binária.

O objetivo:

Gere esta saída de texto exata:

0101010101010101
0011001100110011
0000111100001111
0000000011111111

É isso aí! O código mais curto vence.

J, 10 (13?) Caracteres

|.|:#:i.16

Lista de números:

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

para binário:

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

Transpor:

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

Marcha ré:

   |.|:#: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

Precisamos remover os espaços? Olhando para a outra resposta J parece que não por isso vamos precisar adicionar 3 caracteres e emprestar o 1":da resposta de Jan .

Python 2, 40

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

APL (14)

Supondo ⎕IO=0(essa é uma configuração):

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

Explicação:

• ⍳16: números [0,16)
• (4⍴2)⊤: codifique cada número na base 2 usando 4 dígitos
• ⊖: reverso horizontal (para que o MSB fique no topo)
• ⎕D[... ]: selecione esses valores a partir dos ⎕Dquais é a sequência 0123456789. (Uma matriz numérica é exibida com espaços entre os valores, uma matriz de caracteres não é. Portanto, isso converte cada bit numérico em um dos caracteres '0' '1').

Gelatina , 42 7 bytes (não concorrente)

⁴ḶBUz0Y

Experimente online!

Agradeço ao Dennis por sua ajuda. Aqui está a primeira mensagem, aqui está a última (outras discussões também ocorreram). Com a ajuda dele, aparentemente (quase) enraíze a pontuação.

/// , 51 bytes

Experimente online

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

GolfScript ( 18 17 15 caracteres)

(Com agradecimentos a Howard)

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

Eu não entendo por que o 10-char

16,zip{n}/

não funciona; Suspeito que um erro no intérprete padrão esteja resultando em tipos não suportados na pilha.

Uma alternativa de 18 caracteres que eu entendo completamente é:

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

Uma abordagem mais matemática é um pouco mais longa, com 28 caracteres:

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

Muito disso é para conversão de base e preenchimento zero. Sem eles, cai para 19 caracteres,

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

com saída

21845
13107
3855
255

CJam - 16

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

Código java equivalente (como explicação):

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

Para usar isso, ligue

s(255,8)

Bitshift!
E também XOR e um pouco de recursão.

A primeira coisa a notar é que, se pegarmos qualquer linha e você a deslocar (# de 0's contínuos) / 2 restantes, obteremos um bom XOR para obter a próxima linha.

Por exemplo,

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

XOR estes bit a bit nos dão

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

qual é a próxima formação (linha 3).
Aplicando o mesmo processo para a linha 3, mude 2 para a esquerda e obteremos ...

0000111100001111
0011110000111100

XOR'ed dá

0011001100110011

que é a linha 2.
Observe que a quantidade que mudamos diminui pela metade a cada vez.
Agora, simplesmente chamamos essa função recursivamente, com 2 argumentos. O valor inteiro dessa linha, e N, que é quanto precisamos mudar. Quando repetimos, apenas passamos o valor XOR'ed alterado e n / 2.

"0".repeat(n)

é preencher 0's no início de cada linha, porque toString remove 0's iniciais.

J, 21 caracteres

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

• i.16 é uma lista de 0..15
• 2^i.4 é uma lista (1,2,4,8)
• %~/ produz a tabela de divisões onde o argumento esquerdo forma linhas, mas é o argumento certo para divisão
• 2| calcula o restante depois de dividir [cada célula] por dois
• <. pisos com valor 0 ou 1
• 1": formata a tabela com um caractere por célula

GolfScript, 19 caracteres

Outra abordagem GolfScript

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

Rubi (44)

Aborrecido e longo: basta imprimir as representações binárias preenchidas com 0 dos números.

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

Postscript 108 177 126 77 74 70

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

Reverteu os valores para um simples mo- off método.

151 131 119

Aplicando uma abordagem mais APL . edit: substituição de corte de cordas e fechamento de array por indexação e for-loops.

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

Recuado:

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

Reimplementar as funções usadas na resposta J vencedora leva a isso (com muito código de suporte ).

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

iAqui está o vetor baseado em 1 descrito nas Funções Elementares de Iverson , daí o -1 ... +para produzir 0 .. 15.

Perl (36 + 1)

+1 para say, como sempre. o duplo 0não é um erro de digitação :)

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

JavaScript (ECMA6), 108

Tentando uma abordagem diferente aqui. Embora tenha sido incentivado a usar operadores binários, me permiti enviar essa solução, pois o desafio também é de complexidade kolmogorov e eu estava pensando - como posso reduzir a quantidade de código que representa esses valores ...? Bases .

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

(Quebra de linha por conveniência).

É uma pena que tive que mexer no preenchimento com zeros à esquerda, mas o ponto desse código é simplesmente representar o resultado binário de destino na Base 36, que são exatamente esses gut, a43, 2z3, 73valores.

Nota: Sei que não chegará nem perto da resposta vencedora, mas apenas por uma questão de idéia ...

Sprects , 44 bytes

 aaaa
bbbb
zozo
zzoo o1111 z0000 b0011 a0101

A resposta de Cedric foi enviada para Sprects.

MATL ( não concorrente ), 8 bytes

16:qYB!P

Experimente online!

Explicação

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 ( não concorrente ), 10 9 bytes

Obrigado a @Dennis por 1 byte de desconto!

Y4m*zW%N*

Experimente online!

Explicação

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 bytes

Constrói a string recursivamente.

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

Como funciona

Essa recursão é baseada no fato de que o padrão é feito da representação binária vertical dos nibbles 0x0 a 0xF:

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

Portanto, cada posição (X, Y) em este padrão pode ser expressa como o Y-th pouco de X: X & (1 << Y). Nós também podemos isolar este bit com: (X >> Y) & 1. Ao invés de manter o rasto dos símbolos X e Y, iteramos em uma única variável nque varia de 0 a 63. Assim, torna-se a fórmula: (n >> (n >> 4)) & 1. Na verdade, é mais fácil iterar de 63 para 0, para que a sequência seja construída na ordem inversa. Em outras palavras, o caractere n-1 é anexado à esquerda do caractere n .

Como uma observação lateral, a recursão não traz nada aqui, exceto código mais curto.

Sem as quebras de linha, o código tem 35 bytes:

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

Precisamos de mais 17 bytes para inserir as quebras de linha. Isso pode ser reduzido para 14 bytes se uma quebra de linha principal for aceitável.

Demo

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

console.log(f());

Bash + coreutils, 65 bytes

Não é o mais curto, mas também o mais longo:

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

(O último caractere é um espaço)

Experimente online .

NARS2000 APL, 22

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

Derivado da resposta do APL de marinus, que parece não funcionar no NARS2000.

Gerar vetor

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

Alterar para baseado em zero

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

Gerar forma para codificação

      (4⍴2)
2 2 2 2

Codificar

      (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

Ajustar para indexação baseada em 1

      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

Eixo primário reverso

      ⊖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

Índice

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

C, 73 caracteres

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

Esta é apenas uma solução geral para gerar 64 bits em quatro blocos de 16 bits; você só precisa alterar o número 0xFF0F0F33335555para gerar uma outra sequência de bits.

simplificado e não destruído:

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

Caramba, 73 caracteres! Não posso, pelo amor de Deus, diminuir ainda mais isso.

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

A parte realmente triste disso é que, se você repetir a saída usando o bash, precisará apenas de 74 caracteres.

JavaScript (ES5) 69

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

inca2 ,33 27 24

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

Isso se baseia na resposta de Jan Dvorak . O inca2 pode executar isso a partir das correções de ontem. Tecnicamente inválido, pois a linguagem foi inventada após a pergunta, mas a invenção de uma língua fazia parte do meu objetivo em fazer a pergunta. Então, aqui está uma recompensa em gratidão pelas outras respostas. :)

Explicação:

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

Alguns dos parênteses devem ser desnecessários, mas, aparentemente, ainda existem alguns problemas com minha interpretação da gramática. E "ravel => map => remodelar" é realmente desajeitado: o mapa precisa ser mais inteligente. Edit: correções de erros permitem a eliminação de parênteses.

Fatorar a conversão de base em uma função separada N:x|y%.x^~1+[]/x.yproduz esse19 Versão de 16 caracteres.

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

E, embora eu esteja trapaceando de qualquer maneira aqui, fui adiante e tornei isso uma função interna. Mas, mesmo que seja uma função niládica (sem exigir um argumento), não há suporte para funções niládicas e ela deve ser fornecida com um argumento fictício.

inca2, 2

U0

Pitão 24/26

O método mais curto foi a resposta do grc traduzida para Pyth, que achei barata, então fiz o meu próprio método:

Minas: 26 caracteres

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

grc: 24 caracteres

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

C ++ 130

Converte hexadecimal em binário

#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 bytes

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

Meio barato porque usa transpose de Data.List e replicateM de Control.Monad, no entanto, ambos são carregados por padrão no Lambdabot.

Além disso, tenho certeza de que há espaço para melhorias, só queria compartilhar a ideia

Julia (39 bytes)

Segundo roteiro que já escrevi em Julia, tenho que admitir que estou gostando de Julia, ela é uma fera bonita.

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

Devoluções

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

Explicação:

• bin(x,4) - Converter int em número inteiro binário com preenchimento para 4 caracteres.
• collect(_) - Dividir string em matriz de caracteres.
• map(x->_,0:15) - Faça isso pelos 16 primeiros dígitos do intervalo.
• hcat(_...) - Splat e concatenar horizontalmente em uma matriz.

C 83 77 76 74 71

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

Bem direto.

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

R, 53 41 bytes

Uma tradução da resposta python do @ grc. Retirou 12 bytes da tradução original através do uso de rep()'s eache lengthargumentos (e correspondência parcial de argumentos) e lembrando que isso 0:1é equivalente a 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))

Você também pode tentar uma tradução da resposta J de @ Gareth, algo como isto (34 bytes):

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

No entanto, ele usa uma função que não faz parte da base R e gera uma matriz que é difícil de formatar no texto impresso exato, como na especificação.