La lingua inglese e la maggior parte dei linguaggi di programmazione sono scritti e letti da sinistra a destra, dall'alto verso il basso, ma non è necessario .

In effetti per il blocco di testo

ABC
DEF

Posso pensare a otto modi correlati in cui potrebbe essere letto:

1. Da sinistra a destra, dall'alto verso il basso (LTR-TTB): ABCDEF
2. Dall'alto verso il basso, da sinistra a destra (TTB-LTR): ADBECF
3. Da sinistra a destra, dal basso verso l'alto (LTR-BTT): DEFABC
4. Dal basso verso l'alto, da sinistra a destra (BTT-LTR): DAEBFC
5. Da destra a sinistra, dall'alto verso il basso (RTL-TTB): CBAFED
6. Dall'alto verso il basso, da destra a sinistra (TTB-RTL): CFBEAD
7. Da destra a sinistra, dal basso verso l'alto (RTL-BTT): FEDCBA
8. Dal basso verso l'alto, da destra a sinistra (BTT-RTL): FCEBDA

Sfida

Scrivi un blocco rettangolare di testo che può essere letto in ciascuno degli otto modi sopra indicati come otto programmi a riga singola nella tua lingua preferita. Ognuno di questi programmi dovrebbe generare un numero intero diverso da uno a otto.

Non importa quale direzione di lettura genera quale numero, non devono corrispondere ai numeri sopra. Ad esempio, se il blocco di testo fosse fermo

ABC
DEF

quindi il programma ABCDEFdi uscita potenza 5e FEDCBAuscita potenza 2, e gli altri sei programmi sarebbe uscita 1, 3, 4, 6, 7, e 8in un certo ordine.

Il blocco di testo può contenere qualsiasi carattere tranne i terminatori di riga .

L'output dovrebbe andare su stdout o un'alternativa simile se la tua lingua non ha uno stdout corretto. Non ci sono input. Si può presumere che i programmi siano eseguiti in un ambiente REPL.

Pietu1998 ha scritto caritatevolmente un JSFiddle che fornisce agli 8 diversi programmi a riga singola quando viene dato un blocco di testo. L'ho trasformato in uno snippet di stack:

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

^{Puoi ancora trovare la versione CJam di Martin qui .}

punteggio

Il tuo punteggio è l'area del tuo blocco di testo (la larghezza per l'altezza). Vince l'invio con il punteggio più basso. (In sostanza vince il codice più piccolo, da cui il tag code-golf .) Tiebreaker va alla precedente presentazione pubblicata.

L'esempio è 2 per 3, quindi il suo punteggio è 6. Un punteggio inferiore a 4 (2 per 2) è impossibile perché alcuni degli 8 programmi sarebbero identici e non potrebbero generare due valori diversi.

J, 3 * 3 = 9

1[2
+2+
2+2

Eseguendo tutte le direzioni:

       ". '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

Spiegazione:

• In esecuzione J va da destra a sinistra e non c'è precedenza dell'operatore.
• Il [( left) prende il lato sinistro dei suoi due operandi, quindi essenzialmente cancella l'intero lato destro della nostra espressione, ad esempio 1+2[2+2+2diventa 1+2[6e poi 1+2.
• Le espressioni di sinistra sono aggiunte con un totale di 1, 2, 3 e 4 operandi. Esistono due nespressioni di ogni operando una con il numero1 e una con solo 2s. Le aggiunte con 1generano i numeri dispari e gli altri generano quelli pari.

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

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

Ho scritto una piccola sceneggiatura che ha trovato i numeri giusti per me. Ci è voluto un po ', ma ehi, ho appena battuto GolfScript! : D

Gli script che ho usato sono qui e qui , ma non suggerisco di guardarli poiché lo stile del codice è estremamente cancerogeno.

sottoprogrammi

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

Vecchia versione

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

sottoprogrammi

Emetti i numeri 1-8 rispettivamente.

 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 $ è molto simile a Brainfuck , ma ha alcuni altri comandi, incluso un comando per generare il valore attuale della cella come output numerico, che è stato molto utile per questa sfida.

++:+
  ++
++++

Comandi a una riga:

++:+  ++++++   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 \

=stampa il valore dell'ultima espressione numerica. \è usato per leggere o scrivere numeri da stringhe, ma lo uso solo come scarto qui.

• +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

Poiché un programma a una riga non può mai terminare, si supponga che termina dopo il primo output.

8 sottoprogrammi in una singola immagine:

GolfScript, 4x4 = 16

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

Fa uso del buon vecchio "super commento": un ineguagliato }ignora il resto del codice (in effetti, in questo caso un normale commento #avrebbe funzionato altrettanto bene, poiché tutto il codice viene eseguito come una singola riga). Quindi da ogni angolo c'è un solo numero o (nell'altra direzione) quel numero incrementato di 1, perché l'esecuzione termina e il contenuto dello stack viene stampato. Gli 8 programmi sono

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

Utilizza i commenti ( --) per nascondere i bit indietro e lateralmente. Questo lo rende terribilmente lungo

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

Preludio , 5x3 = 15

12 34
  !  
56 78

Questo presuppone l' interprete Python , che stampa i valori come numeri anziché come codici carattere.

Questo non batte Befunge $, ma batte la mia presentazione GolfScript e mi piace la sua semplicità. Si noti inoltre che utilizza solo 9 caratteri non spaziali, che è inferiore a qualsiasi altra presentazione finora (J colpisce ancora :)). In Prelude, ogni cifra viene inserita nello stack individualmente e, a seconda del percorso, c'è una cifra diversa proprio prima di !, che stampa solo l'elemento superiore dello stack. Gli 8 programmi sono:

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

In alternativa, c'è anche

 1 3 
1+!+1
 5 7 

Che spinge i numeri dispari sui percorsi verticali e li incrementa 1sui percorsi orizzontali:

 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

Non è impressionante, ma non c'era una risposta CJam e mi piace come appare :)

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

Utilizza principalmente il fatto che ];cancella lo stack.

Provalo online

Rubino - 7x7

Neanche impressionante, stessa tattica della risposta di Haskell.

p 1#2 p

3     7
#     #
4     8

p 5#6 p

R, 9x9

Nessuno spazio bianco, nessun commento.

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

Immagino che questo potrebbe essere ampliato a qualsiasi dimensione desideri. Ho pensato che l'operatore modulo fosse il più flessibile degli operatori disponibili, poiché impedisce ai valori di essere troppo grandi a prescindere dalle dimensioni dei dati, e non vi è alcun effetto di avere numeri molto grandi in mezzo.

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

Questo linguaggio di programmazione, 5 * 9 = 45

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

Il che si traduce in questo:

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

Poiché ;termina il programma, quanto sopra si traduce in questo:

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

Spiegazione: qualsiasi numero da 0a 9spinge la cifra corrispondente nello stack. +estrae i primi due valori xe viene yrimosso dallo stack e viene inserito x + ynello stack. igenera lo stack come intero.