_{Esto está relacionado tangencialmente con mi búsqueda para inventar un lenguaje de programación esotérico .}

Se puede usar una tabla de los números binarios 0 .. 15 para implementar una función binaria universal mediante operaciones de indexación. Dadas dos entradas de 1 bit X e Y, las 16 funciones posibles se pueden codificar en un código de operación 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

Entonces este conjunto de 16 funciones se puede aplicar a entradas binarias como la función

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

o

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

o con indexación o partición matricial.

Será útil conocer la forma más compacta de representar o generar dicha tabla de valores para cualquier lenguaje posible que se construya sobre este tipo de operación binaria.

La meta:

Genere esta salida de texto exacta:

0101010101010101
0011001100110011
0000111100001111
0000000011111111

¡Eso es! El código más corto gana.

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`

a binario:

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

Transponer:

   |:#: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 atrás:

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

¿Necesitamos eliminar los espacios? En cuanto a la otra respuesta J parece que sí, así que tendrá que añadir 3 caracteres y tomar prestado el 1":de la respuesta de Jan .

Pitón 2, 40

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

APL (14)

Suponiendo ⎕IO=0(que es un ajuste):

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

Explicación:

• ⍳16: números [0,16)
• (4⍴2)⊤: codifica cada número en la base 2 con 4 dígitos
• ⊖: retroceso horizontal (para que el MSB termine arriba)
• ⎕D[... ]: seleccione estos valores de los ⎕Dcuales es la cadena 0123456789. (Se muestra una matriz numérica con espacios entre los valores, una matriz de caracteres no. Así que esto convierte cada bit numérico en uno de los caracteres '0' '1').

Gelatina , 42 7 bytes (no competitiva)

⁴ḶBUz0Y

Pruébalo en línea!

Gracias a Dennis por su ayuda. Aquí está el primer mensaje, aquí está el último (también hubo otras discusiones). Con su ayuda, aparentemente (casi) arraigé el puntaje.

/// , 51 bytes

Pruébalo en línea

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

GolfScript ( 18 17 15 caracteres)

(Con agradecimiento a Howard)

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

No entiendo por qué el 10-char

16,zip{n}/

no funciona Sospecho que un error en el intérprete estándar está dando como resultado tipos no compatibles en la pila.

Una alternativa de 18 caracteres que entiendo completamente es:

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

Un enfoque más matemático es un poco más largo, con 28 caracteres:

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

Mucho de eso es para la conversión de base y el relleno cero. Sin esos, se reduce a 19 caracteres,

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

con salida

21845
13107
3855
255

CJam - 16

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

Código equivalente de Java (como explicación):

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 esto, llame

s(255,8)

Bitshift!
Y también XOR y un poco de recursión.

Lo primero que debe notar es que si tomamos cualquier línea y la cambia (# de ceros continuos) / 2 hacia la izquierda, obtenemos un buen XOR para obtener la siguiente línea.

Por ejemplo,

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

XOR estos bitwise nos dan

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

cuál es la siguiente línea (línea 3).
Aplicando el mismo proceso para la línea 3, desplaza 2 a la izquierda y obtenemos ...

0000111100001111
0011110000111100

XOR'ed da

0011001100110011

que es la línea 2.
Observe que la cantidad que cambiamos se reduce a la mitad cada vez.
Ahora simplemente llamamos a esta función de forma recursiva, con 2 argumentos. El valor entero de esta línea, y N, que es cuánto necesitamos cambiar. Cuando hagamos recursivos, simplemente pase el valor XOR desplazado y n / 2.

"0".repeat(n)

es rellenar los 0 al comienzo de cada línea porque toString elimina los 0 iniciales.

J, 21 caracteres

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

• i.16 es una lista de 0..15
• 2^i.4 es una lista (1,2,4,8)
• %~/ produce la tabla de divisiones donde el argumento izquierdo forma filas pero es el argumento correcto para la división
• 2| calcula el resto después de dividir [cada celda] por dos
• <. pisos que valen 0 o 1
• 1": formatea la tabla con un carácter por celda

GolfScript, 19 caracteres

Otro enfoque de GolfScript

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

Rubí (44)

Aburrido y largo: solo imprime las representaciones binarias con relleno de 0 de los números.

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

Posdata 108 177 126 77 74 70

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

Invierte los valores para un método de modificación más simple .

151 131 119

Aplicando un enfoque más APL -ish. editar: reemplazó el corte de cadenas y la compresión de matrices con indexación y bucles for.

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

Sangrado:

[[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 las funciones utilizadas en la respuesta J ganadora conduce a esto (con mucho código de soporte ).

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

iaquí hay un vector basado en 1 descrito en las funciones elementales de Iverson , de ahí el -1 ... +para producir 0 .. 15.

Perl (36 + 1)

+1 para say, como siempre. el doble 0no es un error tipográfico :)

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

JavaScript (ECMA6), 108

Intentando un enfoque diferente aquí. Aunque me animaron a usar operadores binarios, me permití enviar esta solución ya que el desafío también es complejidad kolmogorov y estaba pensando: ¿cómo puedo reducir la cantidad de código que representa esos valores ...? Bases .

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

(Salto de línea por conveniencia).

Es una lástima que tuve que meterme con el relleno con ceros a la izquierda, pero el objetivo de este código es simplemente representar el resultado binario de destino en Base 36, que son exactamente esos gut, a43, 2z3, 73valores.

Nota: Me doy cuenta de que no estará cerca de la respuesta ganadora, pero solo por el bien de la idea ...

Sprects , 44 bytes

 aaaa
bbbb
zozo
zzoo o1111 z0000 b0011 a0101

La respuesta de Cedric fue portada a Sprects.

MATL ( no competidor ), 8 bytes

16:qYB!P

Pruébalo en línea!

Explicación

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 ( no competidor ), 10 9 bytes

¡Gracias a @Dennis por 1 byte de descuento!

Y4m*zW%N*

Pruébalo en línea!

Explicación

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

Construye la cadena recursivamente.

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

Cómo funciona

Esta recursión se basa en el hecho de que el patrón está hecho de la representación binaria vertical de 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

Por lo tanto, cada posición (X, Y) en este modelo se puede expresar como la Y-ésimo bit de X: X & (1 << Y). También podemos aislar este bit con: (X >> Y) & 1. En lugar de hacer el seguimiento de X e Y, que iterate en una única variable nque va de 0 a 63. Por lo tanto, la fórmula se convierte en: (n >> (n >> 4)) & 1. En realidad, es más fácil iterar de 63 a 0, por lo que la cadena se construye en orden inverso. En otras palabras, el carácter n-1 se agrega a la izquierda del carácter n .

Como nota al margen, la recursión no trae nada aquí excepto un código más corto.

Sin los saltos de línea, el código tiene una longitud de 35 bytes:

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

Necesitamos 17 bytes más para insertar los saltos de línea. Esto podría acortarse a 14 bytes si un salto de línea inicial es aceptable.

Manifestación

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

console.log(f());

Bash + coreutils, 65 bytes

No es el más corto, pero tampoco el más largo:

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

(El último personaje es un espacio)

Pruébalo en línea .

NARS2000 APL, 22

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

Derivado de la respuesta APL de marinus, que no parece funcionar en NARS2000.

Generar vector

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

Cambiar a cero

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

Generar forma para codificar

      (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

Ajuste para indexación basada en 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

Eje primario inverso

      ⊖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 es solo una solución general para generar 64 bits en cuatro bloques de 16 bits; solo necesitas cambiar el número0xFF0F0F33335555 para generar otra secuencia de bits.

simplificado y sin golf:

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

¡Ay, 73 caracteres! Sin embargo, no puedo por el amor de Dios hacer esto más pequeño.

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

La verdadera parte triste de esto es que si hiciera eco de la salida usando bash, solo necesitaría 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

Esto se basa en la respuesta de Jan Dvorak . inca2 puede ejecutar esto a partir de las correcciones de errores de ayer. Técnicamente inválido ya que el idioma fue inventado después de la pregunta, pero la invención de un idioma fue parte de mi objetivo al plantear la pregunta. Así que aquí hay algo de recuperación en agradecimiento a las otras respuestas. :)

Explicación:

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

Algunos de los paréntesis deberían ser innecesarios, pero aparentemente hay algunos problemas pendientes con mi interpretación de la gramática. Y "ravel => map => rehape" es realmente torpe: el mapa debe ser más inteligente. Editar: las correcciones de errores permiten la eliminación de parens.

Factorizando la conversión de base en una función separada N:x|y%.x^~1+[]/x.y produce esto19 Versión de 16 caracteres .

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

Y aunque estoy haciendo trampa de todos modos aquí, seguí adelante e hice de esto una función incorporada. Pero, aunque es una función niládica (que no requiere un argumento), no hay soporte para funciones niládicas, y debe suministrarse con un argumento ficticio.

inca2, 2

U0

Pyth 24/26

El método más corto fue la respuesta de grc traducida a Pyth, que me pareció barata, así que hice mi propio método:

Mina: 26 caracteres.

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

grc: 24 caracteres

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

C ++ 130

Convierte hexadecimal a binario

#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']

Un poco engañoso porque usa transposición de Data.List y replicateM de Control.Monad, sin embargo, ambos se cargan de forma predeterminada desde Lambdabot.

Además, estoy seguro de que hay margen de mejora, solo quería compartir la idea

Julia (39 bytes)

Segundo guión que escribí en Julia, debo admitir que me gusta Julia, es una bestia bonita.

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

Devoluciones

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

Explicación:

• bin(x,4) - Convierte int a entero binario con relleno a 4 caracteres.
• collect(_) - Dividir la cadena en una matriz de caracteres.
• map(x->_,0:15) - Haga esto para los primeros 16 dígitos en el rango.
• hcat(_...) - Splat y concatenar horizontalmente en una 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)));}

Muy claro.

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

R, 53 41 bytes

Una traducción de la respuesta de Python de @ grc. Afeitó 12 bytes a partir de la traducción original mediante el uso de rep()'s eachy lengthargumentos (y coincidente argumento parcial), y recordando que 0:1es 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))

También puede intentar una traducción de la respuesta J de @ Gareth, algo como esto (34 bytes):

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

Sin embargo, utiliza una función que no forma parte de la base R y genera una matriz que es difícil de formatear en texto impreso exacto como en la especificación.