El idioma inglés y la mayoría de los lenguajes de programación se escriben y leen de izquierda a derecha, de arriba a abajo, pero ese no es necesariamente el caso .

De hecho para el bloque de texto

ABC
DEF

Puedo pensar en ocho formas relacionadas en que podría leerse:

1. De izquierda a derecha, de arriba a abajo (LTR-TTB): ABCDEF
2. De arriba a abajo, de izquierda a derecha (TTB-LTR): ADBECF
3. De izquierda a derecha, de abajo hacia arriba (LTR-BTT): DEFABC
4. De abajo hacia arriba, de izquierda a derecha (BTT-LTR): DAEBFC
5. De derecha a izquierda, de arriba a abajo (RTL-TTB): CBAFED
6. De arriba a abajo, de derecha a izquierda (TTB-RTL): CFBEAD
7. De derecha a izquierda, de abajo hacia arriba (RTL-BTT): FEDCBA
8. De abajo hacia arriba, de derecha a izquierda (BTT-RTL): FCEBDA

Reto

Escriba un bloque rectangular de texto que se pueda leer en cada una de las ocho formas anteriores como ocho programas de una sola línea en el idioma que elija. Cada uno de estos programas debe generar un número entero diferente de uno a ocho.

No importa en qué dirección de lectura salga qué número, no tienen que coincidir con los números anteriores. Por ejemplo, si su bloque de texto todavía

ABC
DEF

entonces el programa de ABCDEFsalida de fuerza 5y FEDCBAde salida de fuerza 2, y los otros seis programas emitiría 1, 3, 4, 6, 7, y 8en algún orden.

El bloque de texto puede contener cualquier carácter, excepto los terminadores de línea .

La salida debería ir a stdout o una alternativa similar si su idioma no tiene una stdout adecuada. No hay entrada Puede suponer que los programas se ejecutan en un entorno REPL.

Pietu1998 escribió caritativamente un JSFiddle que le da a los 8 programas diferentes de una sola línea cuando se le da un bloque de texto. Lo he convertido en un fragmento de pila:

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

^{Todavía puedes encontrar la versión de Martin CJam aquí .}

Tanteo

Su puntaje es el área de su bloque de texto (el ancho multiplicado por el alto). La presentación con la puntuación más baja gana. (Esencialmente, el código más pequeño gana, de ahí la etiqueta de código de golf ). Tiebreaker va al envío publicado anteriormente.

El ejemplo es 2 por 3, por lo que su puntaje es 6. Un puntaje menor a 4 (2 por 2) es imposible porque algunos de los 8 programas serían idénticos y no podrían generar dos valores diferentes.

J, 3 * 3 = 9

1[2
+2+
2+2

Ejecutando todas las direcciones:

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

Explicación:

• En J la ejecución va de derecha a izquierda y no hay precedencia del operador.
• El [( left) toma el lado izquierdo de sus dos operandos, por lo que esencialmente cancela todo el lado derecho de nuestra expresión, por ejemplo, se 1+2[2+2+2convierte en 1+2[6y luego 1+2.
• Las expresiones de la izquierda son adiciones con un total de 1, 2, 3 y 4 operandos. Hay dos nexpresiones de cada operación y una con el número 1y una con solo 2s. Las adiciones con 1generan los números impares y los otros generan los pares.

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

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

Escribí un pequeño guión que encontró los números correctos para mí. Me tomó un tiempo, pero bueno, ¡acabo de vencer a GolfScript! :RE

Los scripts que utilicé están aquí y aquí , pero no sugiero mirarlos ya que el estilo del código es extremadamente cancerígeno.

Subprogramas

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

Versión antigua

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

Subprogramas

Salida de los números 1-8 respectivamente.

 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 $ es muy similar a Brainfuck , pero tiene algunos comandos más, incluido un comando para generar el valor actual de la celda como salida numérica, lo cual fue muy útil para este desafío.

++:+
  ++
++++

Comandos de una línea:

++:+  ++++++   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 el valor de la última expresión numérica. \se usa para leer o escribir números de cadenas, pero lo uso solo como un descarte aquí.

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

piet - 12x12 = 144

Dado que un programa de una línea nunca puede terminar, suponga que termina después de la primera salida.

8 subprogramas en una sola imagen:

GolfScript, 4x4 = 16

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

Hace uso del buen viejo "super comentario": un incomparable }ignora el resto del código (de hecho, en este caso un comentario normal #habría funcionado igual de bien, ya que todo el código se ejecuta como una sola línea). Entonces, en cada esquina hay un solo número o (en la otra dirección) ese número se incrementa en 1, porque la ejecución termina y se imprime el contenido de la pila. Los 8 programas son

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

Utiliza comentarios ( --) para ocultar los bits hacia atrás y hacia los lados. Esto lo hace terriblemente largo

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

Esto supone el intérprete de Python , que imprime los valores como números en lugar de códigos de caracteres.

Esto no supera a Befunge $, pero supera mi presentación de GolfScript, y me gusta su simplicidad. Tenga en cuenta también que utiliza solo 9 caracteres que no son espacios, lo que es menos que cualquier otro envío hasta el momento (J golpea de nuevo :)). En Prelude, cada dígito se inserta en la pila individualmente, y dependiendo de la ruta, hay un dígito diferente justo antes del !, que solo imprime el elemento superior de la pila. Los 8 programas son:

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

Alternativamente, también hay

 1 3 
1+!+1
 5 7 

Lo que empuja los números impares en las rutas verticales, y los incrementa 1en las rutas horizontales:

 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

No es impresionante, pero no hubo respuesta de CJam y me gusta cómo se ve :)

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

Utiliza principalmente el hecho de que ];borra la pila.

Pruébalo en línea

Rubí - 7x7

Tampoco es impresionante, la misma táctica que la respuesta de Haskell.

p 1#2 p

3     7
#     #
4     8

p 5#6 p

R, 9x9

Sin espacios en blanco, sin comentarios.

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

Supongo que esto podría ampliarse al tamaño que desee. Pensé que el operador de módulo era el más flexible de los operadores disponibles, ya que evita que los valores sean demasiado grandes, independientemente del tamaño de los datos, y no tiene ningún efecto tener números realmente grandes en el medio.

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

Este lenguaje de programación, 5 * 9 = 45

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

Lo que se traduce en esto:

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

Como ;termina el programa, lo anterior se traduce en esto:

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

Explicación: cualquier número desde 0hasta 9empuja el dígito correspondiente a la pila. +saca los dos valores superiores xy ysale de la pila y empuja x + ya la pila. isaca la pila como un entero.