La langue anglaise et la plupart des langages de programmation sont écrits et lus de gauche à droite, de haut en bas, mais ce n'est pas nécessairement le cas .

En fait pour le bloc de texte

ABC
DEF

Je peux penser à huit manières connexes de le lire:

1. De gauche à droite, de haut en bas (LTR-TTB): ABCDEF
2. De haut en bas, de gauche à droite (TTB-LTR): ADBECF
3. De gauche à droite, de bas en haut (LTR-BTT): DEFABC
4. De bas en haut, de gauche à droite (BTT-LTR): DAEBFC
5. De droite à gauche, de haut en bas (RTL-TTB): CBAFED
6. De haut en bas, de droite à gauche (TTB-RTL): CFBEAD
7. De droite à gauche, de bas en haut (RTL-BTT): FEDCBA
8. De bas en haut, de droite à gauche (BTT-RTL): FCEBDA

Défi

Écrivez un bloc de texte rectangulaire qui peut être lu dans chacune des huit façons ci-dessus comme huit programmes à ligne unique dans la langue de votre choix. Chacun de ces programmes doit produire un entier différent de un à huit.

Peu importe le sens de lecture qui sort quel numéro, ils n'ont pas à correspondre aux chiffres ci-dessus. Par exemple, si votre bloc de texte était encore

ABC
DEF

puis le programme de ABCDEFsortie de puissance 5et de FEDCBAsortie de puissance 2, et les six autres programmes génèrerait 1, 3, 4, 6, 7et 8dans un certain ordre.

Le bloc de texte peut contenir n'importe quel caractère à l'exception des terminateurs de ligne .

La sortie devrait aller vers stdout ou une alternative similaire si votre langue n'a pas de stdout appropriée. Il n'y a aucune entrée. Vous pouvez supposer que les programmes sont exécutés dans un environnement REPL.

Pietu1998 a charitablement écrit un JSFiddle qui donne aux 8 programmes différents sur une seule ligne lorsqu'ils reçoivent un bloc de texte. Je l'ai transformé en extrait de pile:

<script>function f(n){n=n.split("\n");var e=n.map(function(n){return n.length}).sort()[n.length-1];n=n.map(function(n){return(n+Array(e+1).join(" ")).substring(0,e)});var t=n[0].split("").map(function(e,t){return n.map(function(n){return n[t]}).join("")});n=[n.join(""),n.reverse().join(""),t.join(""),t.reverse().join("")],n=n.concat(n.map(function(n){return n.split("").reverse().join("")})),document.getElementById("a").innerHTML=n.map(function(n,e){return document.getElementById("b").checked?n+"   "+"LLTTRRBB"[e]+"T"+"RRBBLLTT"[e]+"-"+"TBLRBTRL"[e]+"T"+"BTRLTBLR"[e]:n}).join("\n")}</script><textarea onkeyup="f(this.value)" id="c" placeholder="Code"></textarea><br/><input type="checkbox" id="b" onchange="f(document.getElementById('c').value)" checked/>&nbsp;<label for="b">Show directions</label><br/><pre id="a"></pre>

^{Vous pouvez toujours trouver la version CJam de Martin ici .}

Notation

Votre score est la zone de votre bloc de texte (la largeur multipliée par la hauteur). La soumission avec le score le plus bas gagne. (Essentiellement, le plus petit code gagne, d'où la balise code-golf .) Tiebreaker revient à la soumission publiée précédemment.

L'exemple est 2 par 3, donc son score est 6. Un score inférieur à 4 (2 par 2) est impossible car alors certains des 8 programmes seraient identiques et ne pourraient pas produire deux valeurs différentes.

J, 3 * 3 = 9

1[2
+2+
2+2

Exécuter toutes les directions:

       ". '1[2+2+2+2','2+2+2+1[2','1+2[2+2+2','2+2[2+1+2','2+2+2+2[1','2[1+2+2+2','2+2+2[2+1',:'2+1+2[2+2'
1 7 3 4 8 2 6 5

Explication:

• En J, l'exécution va de droite à gauche et il n'y a pas de priorité d'opérateur.
• Le [( left) prend le côté gauche de ses deux opérandes, donc il annule essentiellement tout le côté droit de notre expression, par exemple 1+2[2+2+2devient 1+2[6et puis 1+2.
• Les expressions de gauche sont des ajouts avec un total de 1, 2, 3 et 4 opérandes. Il existe deux nexpressions-opérande, une avec le nombre 1et une avec seulement 2s. Les ajouts avec 1génèrent les nombres impairs et les autres génèrent les nombres pairs.

Befunge-98 ,5x5 = 25 5x3 = 15

1+4+2
$.@.$
3+4+4

J'ai écrit un petit script qui a trouvé les bons chiffres pour moi. Cela a pris du temps, mais bon, je viens de battre GolfScript! :RÉ

Les scripts que j'ai utilisés sont ici et ici , mais je ne suggère pas de les regarder car le style de code est extrêmement cancérigène.

Sous-programmes

1+4+2$.@.$3+4+4   LTR-TTB   5
3+4+4$.@.$1+4+2   LTR-BTT   7
1$3+.+4@4+.+2$4   TTB-LTR   3
2$4+.+4@4+.+1$3   TTB-RTL   4
4+4+3$.@.$2+4+1   RTL-BTT   8
2+4+1$.@.$4+4+3   RTL-TTB   6
4$2+.+4@4+.+3$1   BTT-RTL   2
3$1+.+4@4+.+4$2   BTT-LTR   1

Ancienne version

 1.6
3 @ 4
.@ @.
8 @ 7
 2.5

Sous-programmes

Sortez les nombres 1-8 respectivement.

 1.6 3 @ 4.@ @.8 @ 7 2.5    LTR-TTB
 2.5 8 @ 7.@ @.3 @ 4 1.6    LTR-BTT
 3.8 1 @ 2.@ @.6 @ 5 4.7    TTB-LTR
 4.7 6 @ 5.@ @.1 @ 2 3.8    TTB-RTL
 5.2 7 @ 8.@ @.4 @ 3 6.1    RTL-BTT
 6.1 4 @ 3.@ @.7 @ 8 5.2    RTL-TTB
 7.4 5 @ 6.@ @.2 @ 1 8.3    BTT-RTL
 8.3 2 @ 1.@ @.5 @ 6 7.4    BTT-LTR

Brainfuck $ , 4x3 = 12

Brainfuck $ est très similaire à Brainfuck , mais a quelques commandes supplémentaires, y compris une commande pour sortir la valeur actuelle de la cellule sous forme de sortie numérique, ce qui était très utile pour ce défi.

++:+
  ++
++++

Commandes sur une ligne:

++:+  ++++++   LTR-TTB, outputs 2
++++  ++++:+   LTR-BTT, outputs 8
+ ++ +:+++++   TTB-LTR, outputs 4
+++:+++ ++ +   TTB-RTL, outputs 3
++++++  +:++   RTL-BTT, outputs 7
+:++++  ++++   RTL-TTB, outputs 1
+++++:+ ++ +   BTT-RTL, outputs 5
+ ++ +++:+++   BTT-LTR, outputs 6

TECO, 3 * 5 = 15

 +4 5
+2=4 
 +1 \

=imprime la valeur de la dernière expression numérique. \est utilisé pour lire ou écrire des nombres à partir de chaînes, mais je ne l'utilise que comme défausse ici.

• +4 5+2=4 +1 \ 7
• + +2+4=1 4 5 \ 6
• + +2+1=4 4 \ 5 3
• +1 \+2=4 +4 5 2
• \ 1+ 4=2+5 4+ 5
• \ 5 4 1=4+2+ + 1
• 5 \ 4 4=1+2+ + 4
• 5 4+ 4=2+\ 1+ 8

piet - 12x12 = 144

Puisqu'un programme d'une ligne ne peut jamais se terminer, supposez qu'il se termine après la première sortie.

8 sous-programmes dans une seule image:

GolfScript, 4x4 = 16

1})7
)  }
}  )
3)}5

Utilise le bon vieux "super commentaire": un inégalé }ignore le reste du code (en fait, dans ce cas, un commentaire normal #aurait tout aussi bien fonctionné, puisque tout le code est exécuté sur une seule ligne). Donc, de chaque coin, il n'y a qu'un seul numéro ou (dans l'autre sens) ce nombre incrémenté de 1, car l'exécution se termine et le contenu de la pile est imprimé. Les 8 programmes sont

1})7)  }}  )3)}5  # LTR-TTB
1)}3}  ))  }7})5  # TTB-LTR
3})1)  }}  )5)}7  # BTT-LTR
3)}5}  ))  }1})7  # LTR-BTT
5})3)  }}  )7)}1  # RTL-BTT
5)}7}  ))  }3})1  # BTT-RTL
7})5)  }}  )1)}3  # TTB-RTL
7)}1}  ))  }5})3  # RTL-BTT

Haskell, 26x26 = 676

Utilise les commentaires ( --) pour masquer les bits arrière et latéral. Cela le rend terriblement long

main=print 1--2 tnirp=niam
a                        a
i                        i
n                        n
=                        =
p                        p
r                        r
i                        i
n                        n
t                        t

3                        4
-                        -
-                        -
5                        6

t                        t
n                        n
i                        i
r                        r
p                        p
=                        =
n                        n
i                        i
a                        a
main=print 7--8 tnirp=niam

Prélude , 5x3 = 15

12 34
  !  
56 78

Cela suppose l' interpréteur Python , qui imprime les valeurs sous forme de nombres au lieu de codes de caractères.

Cela ne bat pas Befunge $, mais il bat ma soumission GolfScript, et j'aime sa simplicité. Notez également qu'il n'utilise que 9 caractères non-espace, ce qui est inférieur à toute autre soumission jusqu'à présent (J frappe à nouveau :)). Dans Prelude, chaque chiffre est poussé sur la pile individuellement, et selon le chemin, il y a un chiffre différent juste avant le !, qui imprime simplement l'élément supérieur de la pile. Les 8 programmes sont:

12 34  !  56 78   LTR-TTB   4
56 78  !  12 34   LTR-BTT   8
1 52 6 ! 3 74 8   TTB-LTR   6
4 83 7 ! 2 61 5   TTB-RTL   7
87 65  !  43 21   RTL-BTT   5
43 21  !  87 65   RTL-TTB   1
8 47 3 ! 6 25 1   BTT-RTL   3
5 16 2 ! 7 38 4   BTT-LTR   2

Alternativement, il y a aussi

 1 3 
1+!+1
 5 7 

Ce qui pousse les nombres impairs sur les chemins verticaux, et les incrémente de 1sur les chemins horizontaux:

 1 3 1+!+1 5 7    LTR-TTB   4
 5 7 1+!+1 1 3    LTR-BTT   8
 1 1+5 ! 3+7 1    TTB-LTR   5
 1 3+7 ! 1+5 1    TTB-RTL   7
 7 5 1+!+1 3 1    RTL-BTT   6
 3 1 1+!+1 7 5    RTL-TTB   2
 1 7+3 ! 5+1 1    BTT-RTL   3
 1 5+1 ! 7+3 1    BTT-LTR   1

CJam - 7 × 7

Pas impressionnant, mais il n'y a pas eu de réponse CJam et j'aime son apparence :)

 8;];1 
7     2
;  0  ;
] 0 0 ]
;  0  ;
6     3
 5;];4 

Il utilise principalement le fait qui ];efface la pile.

Essayez-le en ligne

Rubis - 7x7

Pas impressionnant non plus, même tactique que la réponse de Haskell.

p 1#2 p

3     7
#     #
4     8

p 5#6 p

R, 9x9

Pas d'espace blanc, pas de commentaires.

75%%99299
99%%99699
%%299%%41
%%699%%06
995999997
11%%999%%
99%%799%%
39719%%99
59519%%16

Je suppose que cela pourrait être étendu à la taille que vous souhaitez. Je pensais que l'opérateur modulo était le plus flexible des opérateurs disponibles, car il empêche les valeurs d'être trop grandes quelle que soit la taille des données, et il n'y a aucun effet d'avoir de très grands nombres entre les deux.

75%%9929999%%99699%%299%%41%%699%%0699599999711%%999%%99%%799%%39719%%9959519%%16   LTR-TTB  2
59519%%1639719%%9999%%799%%11%%999%%995999997%%699%%06%%299%%4199%%9969975%%99299   LTR-BTT  3
79%%9193559%%91999%%265%%75%%999%%1199999979999%%999%%26%%999%%99409%%9199167%%96   TTB-LTR  4
99167%%9699409%%9126%%999%%99%%999%%999999799%%999%%11%%265%%7559%%9199979%%91935   TTB-RTL  1
61%%9159599%%91793%%997%%99%%999%%1179999959960%%996%%14%%992%%99699%%9999299%%57   RTL-BTT  5
99299%%5799699%%9914%%992%%60%%996%%799999599%%999%%11%%997%%9999%%9179361%%91595   RTL-TTB  6
69%%7619919%%90499%%999%%62%%999%%9999799999911%%999%%57%%562%%99919%%9553919%%97   BTT-RTL  7
53919%%9799919%%9557%%562%%11%%999%%997999999%%999%%99%%999%%6219%%9049969%%76199   BTT-LTR  8

Ce langage de programmation, 5 * 9 = 45

1i;i2
2   2
+   +
i   i
;   ;
i   i
+   +
2   2
5i;i6

Ce qui se traduit par ceci:

1i;i22   2+   +i   i;   ;i   i+   +2   25i;i6
5i;i62   2+   +i   i;   ;i   i+   +2   21i;i2
12+i;i+25i       i;       ;i       i22+i;i+26
22+i;i+26i       i;       ;i       i12+i;i+25
6i;i52   2+   +i   i;   ;i   i+   +2   22i;i1
2i;i12   2+   +i   i;   ;i   i+   +2   26i;i5
62+i;i+22i       i;       ;i       i52+i;i+21
52+i;i+21i       i;       ;i       i62+i;i+22

Depuis la ;fin du programme, ce qui précède se traduit par ceci:

1i;   - outputs 1
5i;   - outputs 5
12+i; - outputs 3
22+i; - outputs 4
6i;   - outputs 6
2i;   - outputs 2
62+i; - outputs 8
52+i; - outputs 7

Explication: n'importe quel nombre de 0à 9pousse le chiffre correspondant sur la pile. +saute les deux premières valeurs xet yhors de la pile et pousse x + ysur la pile. irenvoie la pile sous forme d'entier.