Aquí hay una fuente pixelada de 5 por 7 para los dígitos del 0 al 9:

.███.
█...█
█...█
█...█
█...█
█...█
.███.

..█..
███..
..█..
..█..
..█..
..█..
█████

.███.
█...█
....█
...█.
..█..
.█...
█████

.███.
█...█
....█
..██.
....█
█...█
.███.

█..█.
█..█.
█..█.
█████
...█.
...█.
...█.

█████
█....
█....
.███.
....█
█...█
.███.

.███.
█...█
█....
████.
█...█
█...█
.███.

█████
....█
....█
...█.
...█.
..█..
..█..

.███.
█...█
█...█
.███.
█...█
█...█
.███.

.███.
█...█
█...█
.████
....█
█...█
.███.

(Esta fuente y esta página probablemente se verán mejor si ejecuta este código JavaScipt en la consola de su navegador o en la barra de URL con el prefijo javascript::. $('#question pre,.answer pre').css('line-height',1))

Escriba dos bloques de texto rectangulares del mismo tamaño, uno para representar los espacios vacíos ( .) en la fuente de arriba y otro para representar los espacios rellenos ( █).

Cuando estos dos bloques de texto están dispuestos en el mismo patrón de 5 × 7 que uno de los dígitos anteriores, entonces el bloque de texto grande resultante debe ser un programa que imprima ese dígito en stdout. Esto debería funcionar para los 10 dígitos.

Por ejemplo, si su .bloque de texto era

---
'''

y tu █bloque de texto era

ABC
123

entonces el programa

---ABCABCABC---
'''123123123'''
ABC---------ABC
123'''''''''123
ABC---------ABC
123'''''''''123
ABC---------ABC
123'''''''''123
ABC---------ABC
123'''''''''123
ABC---------ABC
123'''''''''123
---ABCABCABC---
'''123123123'''

debería salir 0. Del mismo modo, el programa

------ABC------
''''''123''''''
ABCABCABC------
123123123''''''
------ABC------
''''''123''''''
------ABC------
''''''123''''''
------ABC------
''''''123''''''
------ABC------
''''''123''''''
ABCABCABCABCABC
123123123123123

debería salir 1, y así sucesivamente hasta el programa para 9.

Puede usar este fragmento de pila para crear los programas con forma de dígitos:

<style>textarea{font-family:monospace;}</style><script>function go(){var t=parseInt(document.getElementById("digit").value[0]);if(isNaN(t))return void alert("Invalid digit.");for(var e=document.getElementById("empty").value.split("\n"),n=document.getElementById("filled").value.split("\n"),l=[],o=0;o<7*e.length;o++){l[o]="";for(var d=0;5>d;d++)l[o]+=font[t][Math.floor(o/e.length)][d]?n[o%n.length]:e[o%e.length]}document.getElementById("output").value=l.join("\n")}font=[[[0,1,1,1,0],[1,0,0,0,1],[1,0,0,0,1],[1,0,0,0,1],[1,0,0,0,1],[1,0,0,0,1],[0,1,1,1,0]],[[0,0,1,0,0],[1,1,1,0,0],[0,0,1,0,0],[0,0,1,0,0],[0,0,1,0,0],[0,0,1,0,0],[1,1,1,1,1]],[[0,1,1,1,0],[1,0,0,0,1],[0,0,0,0,1],[0,0,0,1,0],[0,0,1,0,0],[0,1,0,0,0],[1,1,1,1,1]],[[0,1,1,1,0],[1,0,0,0,1],[0,0,0,0,1],[0,0,1,1,0],[0,0,0,0,1],[1,0,0,0,1],[0,1,1,1,0]],[[1,0,0,1,0],[1,0,0,1,0],[1,0,0,1,0],[1,1,1,1,1],[0,0,0,1,0],[0,0,0,1,0],[0,0,0,1,0]],[[1,1,1,1,1],[1,0,0,0,0],[1,0,0,0,0],[0,1,1,1,0],[0,0,0,0,1],[1,0,0,0,1],[0,1,1,1,0]],[[0,1,1,1,0],[1,0,0,0,1],[1,0,0,0,0],[1,1,1,1,0],[1,0,0,0,1],[1,0,0,0,1],[0,1,1,1,0]],[[1,1,1,1,1],[0,0,0,0,1],[0,0,0,0,1],[0,0,0,1,0],[0,0,0,1,0],[0,0,1,0,0],[0,0,1,0,0]],[[0,1,1,1,0],[1,0,0,0,1],[1,0,0,0,1],[0,1,1,1,0],[1,0,0,0,1],[1,0,0,0,1],[0,1,1,1,0]],[[0,1,1,1,0],[1,0,0,0,1],[1,0,0,0,1],[0,1,1,1,1],[0,0,0,0,1],[1,0,0,0,1],[0,1,1,1,0]]]</script><textarea id='empty' rows='8' cols='32' placeholder='empty space text block...'></textarea><textarea id='filled' rows='8' cols='32' placeholder='filled space text block...'></textarea><br>Digit <input id='digit' type='text' value='0'> <button type='button' onclick='go()'>Generate</button><br><br><textarea id='output' rows='16' cols='64' placeholder='output...' style='background-color: #eee;' readonly></textarea>

Detalles

• Ninguno de los 10 programas de bloques de texto grandes debe requerir entrada. Solo genera el dígito único más una nueva línea final opcional. Salida a stdout o una alternativa similar.
• Ninguno de los programas puede leer o acceder a su propio código fuente. Trate esto como un estricto desafío de quine .
• Los bloques de texto pueden no ser idénticos y deben tener dimensiones distintas de cero.
• Los bloques de texto pueden contener caracteres, excepto los terminadores de línea .
• Los 10 programas deben ser programas completos escritos en el mismo idioma, no son fragmentos REPL . Opcionalmente, puede agregar una nueva línea final a todos o ninguno de ellos.

Tanteo

Su puntaje es el área (ancho por alto) de uno de sus bloques de texto. (Son del mismo tamaño, por lo que no tiene sentido contar ambos bloques). El área del ejemplo es 3 por 2, para un puntaje de 6.

El puntaje más bajo gana. En caso de empate, gana la respuesta más votada.

CJam, 20 18 14 13 12 * 1 = 12

Pruébelo en línea: 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9

Bloque vacío

];BG*K+ :BD%

Bloque sólido

];B9+33%:B4/

Explicación

Usé una estrategia similar a la solución de Sp3000 , de modo que cada bloque realiza una multiplicación, una suma y (posiblemente) una operación de módulo en una variable y guarda el valor nuevamente. Para encontrar una solución óptima, usé una buena fuerza bruta. Escribí un programa que busca el espacio de todos los valores iniciales posibles (los valores iniciales de las variables CJam) y muchos millones de pares posibles de funciones de transformación, de modo que la salida para cada forma de dígitos sea única. Luego, filtré los resultados para obtener resultados que permitan que el resultado final para formularios de dígitos que terminan en un bloque vacío, de los cuales hay 8, pueda asignarse nuevamente al resultado correcto mediante otra fórmula de multiplicación, suma y módulo.

¡Después de un par de días de tiempo de búsqueda de CPU, el mejor resultado hasta ahora es de 12! Esta solución comienza con un valor de 11, la función de transformación de bloque vacío es x * 16 + 20, la función de resultado de bloque vacío es x % 13, la función de transformación de bloque sólido es (x + 9) % 33y la función de resultado de bloque sólido es x / 4.

> <> (Pez) , 5 * 10 = 50

Bloque vacío

   \   !9 
4n;    n/ 
1n;\      
       \  
0n;n7\\\  

Bloque sólido

   \; n8/ 
     /!/!v
     \  ;6
3n;\ ! /nn
2n;n5<  8;

Este código no contiene lógica ni aritmética, solo usa redireccionamientos estáticos del puntero de instrucción 2D (IP) de> <> con 'espejos' ( /y \) y dos 'flechas' (< y v). El único otro controlador de flujo es el 'trampolín' ( !) que salta al siguiente personaje.

La IP comienza desde la esquina superior izquierda en dirección Este. Después de algunas redirecciones, alcanza un número, se empuja a la pila y se imprime conn y el programa termina con ;.

El flujo del programa

Un bloque 'reconoce' el estado actual del programa por el hecho de en qué punto entró la IP y, en función del estado, decide en qué dirección debería soltar el puntero (qué bloque debe ejecutarse a continuación) y en qué posición exacta el puntero debe dejarse (que será el nuevo estado). Por supuesto, los bloques no tienen ninguna lógica, todo este comportamiento proviene de los redireccionadores.

CJam, 23 22 19 * 1 = 19

Bloque vacío:

];G)B%:G"73860594"=

Bloque sólido:

];GW*B+3*D%:G    7-

Pruébalo en línea .

Estoy tratando de tener suerte con las coincidencias matemáticas y el fracaso, así que aquí hay un enfoque ligeramente diferente al mapeo de la unicidad de la solución de Martin.

Comience con 16. Los bloques vacíos suman 1 y toman el módulo 11. Los bloques sólidos se multiplican por -1, suman 11, se multiplican por 3 y luego toman el módulo 13. Esto se mapea mágicamente 03456789(los dígitos que terminan en un bloque vacío) 41753026, a los cuales usamos indexación para hacerlo bien 12mapas perfectamente 89, que podemos remediar restando 7.

CJam, 28 27 x 1 = 27

Aquí hay un comienzo.

Bloque vacío

U):U;                       

Bloque sólido

];U):UW+:WF%"1302986_7_54"=

Pruébalo aquí. No puedo darle un enlace permanente con el código, porque el código es demasiado largo, por lo que tendrá que copiarlo manualmente desde el fragmento en el desafío.

La idea es cortar la forma de la siguiente manera:

• Por cada "píxel", incremente un contador U.
• Para cada "píxel" negro, agregue Ua un total acumulado W(que comienza en -1). Al final, tomamos este módulo 15, que da resultados únicos, que se utilizan para indexar en una cadena de búsqueda.