_{Ceci est tangentiellement lié à ma quête pour inventer un langage de programmation ésotérique .}

Un tableau des nombres binaires 0 à 15 peut être utilisé pour implémenter une fonction binaire universelle à l'aide d'opérations d'indexation. Étant donné deux entrées X et Y 1 bit, les 16 fonctions possibles peuvent être encodées dans un opcode 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

Donc, cet ensemble de 16 fonctions peut être appliqué aux entrées binaires comme fonction

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

ou

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

ou avec indexation ou partitionnement matriciel.

Il sera utile de connaître la manière la plus compacte de représenter ou de générer une telle table de valeurs pour tout langage possible à construire sur ce type d'opération binaire.

Le but:

Générez cette sortie de texte exacte:

0101010101010101
0011001100110011
0000111100001111
0000000011111111

C'est ça! Le code le plus court gagne.

J, 10 (13?) Caractères

|.|:#:i.16

Liste des numéros:

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

en binaire:

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

Transposer:

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

Sens inverse:

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

Faut-il supprimer les espaces? En regardant l'autre réponse J il semble que nous le faisons , nous aurons besoin d'ajouter 3 caractères et emprunter la 1":de la réponse de Jan .

Python 2, 40

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

APL (14)

En supposant ⎕IO=0(c'est un paramètre):

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

Explication:

• ⍳16: nombres [0,16)
• (4⍴2)⊤: encoder chaque numéro de la base 2 en utilisant 4 chiffres
• ⊖: marche arrière horizontale (donc le MSB se retrouve en haut)
• ⎕D[... ]: sélectionnez ces valeurs à partir ⎕Ddesquelles se trouve la chaîne 0123456789. (Une matrice numérique est affichée avec des espaces entre les valeurs, une matrice de caractères ne l'est pas. Donc, cela convertit chaque bit numérique en l'un des caractères '0' '1').

Gelée , 42 7 octets (non concurrent)

⁴ḶBUz0Y

Essayez-le en ligne!

Merci à Dennis pour son aide. Voici le premier message, voici le dernier (d'autres discussions ont également eu lieu). Avec son aide, j'ai apparemment (presque) enraciné la partition.

/// , 51 octets

Essayez-le en ligne

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

GolfScript ( 18 17 15 caractères)

(Avec merci à Howard)

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

Je ne comprends pas pourquoi le 10 caractères

16,zip{n}/

ne fonctionne pas; Je soupçonne qu'un bogue dans l'interpréteur standard entraîne des types non pris en charge sur la pile.

Une alternative à 18 caractères que je comprends bien est:

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

Une approche plus mathématique est un peu plus longue, à 28 caractères:

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

Une grande partie de cela concerne la conversion de base et le remplissage nul. Sans ceux-ci, il tombe à 19 caractères,

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

avec sortie

21845
13107
3855
255

CJam - 16

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

Code java équivalent (comme explication):

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

Pour l'utiliser, appelez

s(255,8)

Bitshift!
Et aussi XOR et un peu de récursivité.

La première chose à noter est que si nous prenons une ligne et que vous la décalez (# de 0 continus) / 2 à gauche, nous obtenons un joli XOR pour obtenir la ligne suivante.

Par exemple,

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

XOR ces bits nous donnent

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

qui est la ligne suivante (ligne 3).
En appliquant le même processus pour la ligne 3, décalez 2 à gauche et nous obtenons ...

0000111100001111
0011110000111100

XOR'ed donne

0011001100110011

qui est la ligne 2.
Notez que le montant que nous décalons diminue de moitié à chaque fois.
Maintenant, nous appelons simplement cette fonction récursivement, avec 2 arguments. La valeur entière de cette ligne, et N, qui est la quantité que nous devons déplacer. Quand nous faisons récursif juste passer la valeur XOR décalée et n / 2.

"0".repeat(n)

consiste à ajouter des 0 au début de chaque ligne, car toString supprime les 0 au début.

J, 21 caractères

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

• i.16 est une liste de 0..15
• 2^i.4 est une liste (1,2,4,8)
• %~/ produit le tableau des divisions où l'argument de gauche forme des lignes mais est l'argument de droite pour la division
• 2| calcule le reste après avoir divisé [chaque cellule] par deux
• <. étages dont la valeur est 0 ou 1
• 1": formate le tableau avec un caractère par cellule

GolfScript, 19 caractères

Une autre approche GolfScript

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

Rubis (44)

Ennuyeux et long: Il suffit d'imprimer les représentations binaires 0-rembourrées des nombres.

[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

Inversée les valeurs d'une simple mo- de méthode.

151 131 119

Appliquer une approche plus APL -ish. edit: remplacement du hachage de chaîne et du zippage du tableau par l'indexation et les boucles 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

Dentelé:

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

Réimplémenter les fonctions utilisées dans la réponse J gagnante conduit à cela (avec beaucoup de code de support ).

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

ivoici un vecteur basé sur 1 décrit dans les fonctions élémentaires d'Iverson , d'où le -1 ... +produire 0 .. 15.

Perl (36 + 1)

+1 pour say, comme d'habitude. le double 0n'est pas une faute de frappe :)

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

JavaScript (ECMA6), 108

Essayer une approche différente ici. Même s'il a été encouragé à utiliser des opérateurs binaires, je me suis permis de soumettre cette solution car le défi est également kolmogorov-complexité et je me demandais - comment puis-je réduire la quantité de code représentant ces valeurs ...? Bases .

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

(Saut de ligne pour plus de commodité).

C'est dommage que j'ai dû jouer avec le remplissage avec des zéros en tête, mais le point de ce code représente simplement le résultat binaire cible en Base 36, qui sont exactement ces gut, a43, 2z3, 73valeurs.

Remarque: Je me rends compte que ce ne sera pas loin de la réponse gagnante, mais juste pour le plaisir de l'idée ...

Sprects , 44 octets

 aaaa
bbbb
zozo
zzoo o1111 z0000 b0011 a0101

La réponse de Cédric portée à Sprects.

MATL ( non concurrent ), 8 octets

16:qYB!P

Essayez-le en ligne!

Explication

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 ( non concurrent ), 10 9 octets

Merci à @Dennis pour 1 octet de moins!

Y4m*zW%N*

Essayez-le en ligne!

Explication

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 octets

Construit la chaîne récursivement.

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

Comment ça fonctionne

Cette récursivité est basée sur le fait que le motif est fait de la représentation binaire verticale des quartets 0x0 à 0xF:

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

Par conséquent, chaque position (X, Y) dans ce modèle peut être exprimé comme le Y-ième bit de X: X & (1 << Y). Nous pouvons également isoler ce bit avec: (X >> Y) & 1. Plutôt que de garder une trace de X et Y, nous itérer sur une seule variable nallant de 0 à 63. Ainsi, la formule devient: (n >> (n >> 4)) & 1. Il est en fait plus facile d'itérer de 63 à 0, donc la chaîne est construite dans l'ordre inverse. En d'autres termes, le caractère n-1 est ajouté à gauche du caractère n .

En remarque, la récursivité n'apporte rien ici sauf du code plus court.

Sans les sauts de ligne, le code fait 35 octets:

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

Nous avons besoin de 17 octets supplémentaires pour insérer les sauts de ligne. Cela pourrait être raccourci à 14 octets si un saut de ligne de tête est acceptable.

Démo

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

console.log(f());

Bash + coreutils, 65 octets

Pas le plus court, mais pas le plus long non plus:

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

(Le dernier caractère est un espace)

Essayez-le en ligne .

NARS2000 APL, 22

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

Dérivé de la réponse APL de marinus, qui ne semble pas fonctionner sur NARS2000.

Générer un vecteur

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

Passer à la base zéro

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

Générer une forme pour encoder

      (4⍴2)
2 2 2 2

Encoder

      (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

Ajuster pour une indexation basée sur 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

Inverser l'axe primaire

      ⊖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

Indice

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

C, 73 caractères

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

Il s'agit simplement d'une solution générale pour la sortie de 64 bits dans quatre blocs de 16 bits; il vous suffit de changer le nombre 0xFF0F0F33335555pour sortir une autre séquence de bits.

simplifié & non 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

Oui, 73 caractères! Je ne peux pas, pour l'amour de Dieu, réduire cela.

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

Le plus triste à ce sujet est que si vous deviez faire écho à la sortie en utilisant bash, vous n'auriez besoin que de 74 caractères.

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

Ceci est basé sur la réponse de Jan Dvorak . inca2 est capable d'exécuter cela à partir des corrections de bugs d'hier. Techniquement invalide puisque la langue a été inventée après la question, mais l' invention d'une langue faisait partie de mon objectif en posant la question. Voici donc un retour sur investissement en remerciement pour les autres réponses. :)

Explication:

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

Certaines des parenthèses ne devraient pas être nécessaires, mais apparemment, il reste quelques problèmes avec mon interprétation de la grammaire. Et "ravel => map => remodeler" est vraiment maladroit: la carte doit être plus intelligente. Edit: les corrections de bugs permettent l'élimination des parens.

La factorisation de la conversion de base dans une fonction distincte N:x|y%.x^~1+[]/x.ydonne ceci19 Version 16 caractères .

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

Et bien que je triche de toute façon ici, j'ai continué et en ai fait une fonction intégrée. Mais, même s'il s'agit d'une fonction niladique (ne nécessitant pas d'argument), les fonctions niladiques ne sont pas prises en charge et doivent être fournies avec un argument factice.

inca2, 2

U0

Pyth 24/26

La méthode la plus courte était la réponse de grc traduite en Pyth que je trouvais bon marché alors j'ai fait ma propre méthode:

Mine: 26 caractères

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

grc's: 24 caractères

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

C ++ 130

Convertit hex en binaire

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

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

Un peu cheaty car il utilise la transposition de Data.List et replicateM de Control.Monad, cependant les deux sont chargés par défaut depuis Lambdabot.

De plus, je suis sûr qu'il y a place à amélioration, je voulais juste partager l'idée

Julia (39 octets)

Deuxième script que j'ai jamais écrit en Julia, je dois admettre que j'aime Julia, c'est une jolie bête.

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

Retour

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

Explication:

• bin(x,4) - Convertissez int en entier binaire avec un remplissage à 4 caractères.
• collect(_) - Fractionner la chaîne en tableau de caractères.
• map(x->_,0:15) - Procédez ainsi pour les 16 premiers chiffres de la plage.
• hcat(_...) - Splat et concaténation horizontale dans une matrice.

C 83 77 76 74 71

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

Assez simple.

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

R, 53 41 octets

Une traduction de la réponse python de @ grc. Réduit 12 octets de la traduction originale en utilisant des rep()s eachet des lengtharguments (et une correspondance partielle des arguments), et en se souvenant que 0:1c'est équivalent à 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))

Vous pouvez également essayer une traduction de la réponse J de @ Gareth, quelque chose comme ceci (34 octets):

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

Cependant, il utilise une fonction qui ne fait pas partie de la base R et génère une matrice qui est difficile à formater en texte imprimé exact comme dans la spécification.