Lo que quiero:

En pocas palabras, quiero una pantalla basada en texto, que solicite una entrada ny luego muestre ese valor en la pantalla. Pero hay una trampa. Cada uno de los "verdaderos" píxeles "(los completados) tiene que estar representado por ese número n.

Ejemplo:

Te dan una entrada n. Puede suponer nque será un solo dígito

Input: 0
Output:
000
0 0
0 0
0 0
000

Input: 1
Output:
  1
  1 
  1
  1
  1

Input: 2
Output:
222
  2
222
2
222

Input: 3
Output:
333
  3
333
  3
333

Input: 4
Output:
4 4
4 4
444
  4
  4

Input: 5
Output:
555
5  
555
  5
555

Input: 6
Output:
666
6    
666
6 6
666

Input: 7
Output:
777
  7
  7
  7
  7

Input: 8
Output:
888
8 8
888
8 8
888

Input: 9
Output:
999
9 9
999
  9
999

Desafío:

Haga lo anterior en la menor cantidad de bytes posible.

Solo aceptaré respuestas que cumplan con todos los requisitos.

El espacio en blanco circundante es opcional, siempre que el dígito se muestre correctamente.

Además, <75 bytes es un voto mío, el más bajo lo acepta, pero siempre podría cambiar la respuesta aceptada, así que no se desanime a responder.

SOGL V0.12 , 30 bytes

■'τč▲Β►║⁰ΡāQšJ┘tXdnοO¹‘'¹n.w3n

Pruébalo aquí! La cadena comprimida ■'τč▲Β►║⁰ΡāQšJ┘tXdnοO¹‘es

  ŗ  ŗ  ŗ  ŗ  ŗŗŗŗ  ŗŗŗŗŗ  ŗŗŗŗŗŗ  ŗŗŗŗ  ŗŗŗŗŗ ŗŗ ŗŗŗŗ  ŗ  ŗŗŗŗŗ  ŗŗŗ  ŗŗŗŗŗŗŗŗ  ŗŗŗŗ ŗŗŗŗŗŗŗ  ŗ  ŗ  ŗ  ŗŗŗŗŗ ŗŗŗŗŗ ŗŗŗŗŗŗŗŗ ŗŗŗŗ  ŗŗŗŗŗŗŗŗ ŗŗ ŗŗ ŗŗŗŗ

que es (comenzando con 1, terminando con 0) los números, línea por línea, número a número. El resto

...‘             push the compressed string, replacing the ŗs with pop - the input
    '¹n          split into chunks of 15
       .w        push the (1-indexed, wrapping) input-th item of that array
             3n  split into chunks of 3
                 implicitly output the array, line by line

JavaScript (ES6), 88 bytes

f=
n=>`019
2 3
459
6 7
889`.replace(/\d/g,c=>[2,18,142,96,130,131,698,4,146][c]>>n&1?` `:n)

<input type=number min=0 max=9 oninput=o.textContent=f(this.value)><pre id=o>

Los números codifican qué cuadrados contienen espacios para un dígito dado, por ejemplo, la esquina inferior izquierda tiene un valor de 146 porque 1, 4 y 7 no lo usan y 146 = 2¹ + 2⁴ + 2⁷.

05AB1E , 40 39 38 bytes

•Y¤ŸèK'¦ú’ò™^N•4B5ô¹èvð¹«5714yè8+b¦Sè,

Pruébalo en línea!

Explicación

•Y¤ŸèK'¦ú’ò™^N•            # the compressed string "318975565561233953387608032537"

4B                         # convert to base-4
  5ô                       # split into strings of size 5
    ¹è                     # get the string at index <input>
      v                    # for each digit y in string
          5714yè           # get the digit in 5714 at index y
                8+         # add 8
                  b        # convert to binary
                   ¦       # remove the leading 1
       𹫠         Sè     # with each digit in the binary number, 
                           # index into the string " <input>"   
                      ,    # print with newline

Japt , 43 bytes

"Ýûÿ©ÿßY÷ß"®c s4äëAU ¬£2839¤ë4X÷d0S1U

Contiene algunos no imprimibles. Pruébalo en línea!

Recuento: 13 bytes de datos comprimidos, 9 bytes para descomprimirlos y 21 bytes para formar la salida.

Explicación

Código sin golf:

"Ýûÿ©ÿßY÷ß"®   c s4à ¤  ëAU ¬ £  2839¤  ë4Xà ·  d0S1U
"Ýûÿ©ÿßY÷ß"mZ{Zc s4} s2 ëAU q mX{2839s2 ë4X} qR d0S1U

Hay exactamente 4 posibilidades de fila diferentes: ( #representa un dígito)

#  
  #
# #
###

Por lo tanto, cada número se puede almacenar como un conjunto de cinco dígitos de base 4. Como cada número puede almacenarse en 10 bits, el total es de 100 bits, lo que corresponde a 13 bytes. Omitiré el proceso de compresión y en su lugar explicaré la descompresión.

mZ{Zc s4} 

mZ{     }  // Replace each character Z in the compressed string with the following:
   Zc      //   Take the char-code of Z.
      s4   //   Convert to a base-4 string.

Después de la descompresión, la cadena comprimida de 13 bytes se ve así:

3131332333332111200122213333313321011121213133133133

Tenga en cuenta que esto fallaría si alguna de las ejecuciones de 4 dígitos comenzara 0, ya que los ceros iniciales se dejarían de lado cuando s4se ejecute. Podemos arreglar esto al tener 0representar #  , que solo aparece tres veces, y ninguno de ellos cae al comienzo de una carrera de 4 dígitos.

s2         // Slice off the first two chars of the result.

De acuerdo, para que nuestra cadena de 50 dígitos se comprima bien en trozos de 4, tuvimos que agregar dos dígitos adicionales. Agregarlos al comienzo de la cadena significa que podemos cortarlos con un byte ¤.

ëAU        // Take every 10th (A) char in this string, starting at index <input> (U).

De manera vergonzosa, Japt carece de una función integrada para dividir una cadena en segmentos de longitud X. Sin embargo, tiene una función incorporada para obtener cada carácter Xth, por lo que podemos almacenar todos los datos codificando primero todas las filas superiores, luego todas las segundas filas, etc.

Así que ahora tenemos la cadena de 5 dígitos que codifica el dígito que queremos crear, por ejemplo, 32223para 0.

q mX{2839s2 ë4X} qR
q                    // Split the resulting string into chars.
  mX{          }     // Replace each char X with the result of this function:
     2839s2          //   Convert the magic number 2839 to a binary string.
            ë4X      //   Take every 4th char of this string, starting at index X.
                 qR  // Join the result with newlines.

Para explicar el número mágico, consulte las cuatro filas distintas. Si reemplazas #con 1y  con 0, obtienes

100
001
101
111

Transponer esto y luego unirnos en una sola cadena nos da 101100010111. Convierte a decimal y, voilà, tienes 2839. Invertir el proceso asigna los dígitos 0123en las cuatro filas binarias que se muestran arriba.

¡Casi termino! Ahora todo lo que queda por hacer es agregar los espacios y dígitos:

d0S1U      // In the resulting string, replace 0 with " " (S) and 1 with <input> (U).

Y listo, la salida implícita se encarga del resto. Lamento que esta explicación sea tan larga, pero no veo ninguna forma real de jugar golf sin que sea menos comprensible (si es comprensible ...)

JavaScript (ES6), 115 111 bytes

Toma la entrada como una cadena.

n=>'02468'.replace(/./g,c=>(n+n+n+`   ${n} `+n).substr([126,341,36,68,327.5,66,98,340,102,70][n]*4>>c&6,3)+`
`)

Cómo funciona

Codificación de patrones

Los cuatro patrones distintos "XXX", "X..", "..X"y "X.X"se pueden comprimir como "XXX...X.X"y se extrajeron de esta manera:

XXX...X.X
^^^        --> XXX  (id = 0 / pointer = 0)
  ^^^      --> X..  (id = 1 / pointer = 2)
    ^^^    --> ..X  (id = 2 / pointer = 4)
      ^^^  --> X.X  (id = 3 / pointer = 6)

Al sustituir el dígito de entrada npor "X"y usar espacios reales, esto da la expresión:

n+n+n+`   ${n} `+n

Codificación de dígitos

Usando los identificadores de patrón definidos anteriormente, cada dígito puede ser representado por una cantidad de 5 * 2 = 10 bits.

Por ejemplo:

XXX  -->  0 *   1 =   0
X.X  -->  3 *   4 =  12
XXX  -->  0 *  16 =   0
..X  -->  2 *  64 = 128
XXX  -->  0 * 256 =   0
                    ---
                    140

La lista completa es:

[252, 682, 72, 136, 655, 132, 196, 680, 204, 140]

Sin embargo, dividir estos valores entre 2 permite guardar dos bytes. Entonces, en su lugar, almacenamos:

[126, 341, 36, 68, 327.5, 66, 98, 340, 102, 70]

Manifestación

let f =

n=>'02468'.replace(/./g,c=>(n+n+n+`   ${n} `+n).substr([126,341,36,68,327.5,66,98,340,102,70][n]*4>>c&6,3)+`
`)

console.log(f('0'))
console.log(f('1'))
console.log(f('2'))
console.log(f('3'))
console.log(f('4'))
console.log(f('5'))
console.log(f('6'))
console.log(f('7'))
console.log(f('8'))
console.log(f('9'))

Bash + GNU utils, 114

• 2 bytes guardados gracias a @SophiaLechner

Probablemente hay algunas oportunidades más para la compresión aquí, pero aquí hay un comienzo:

dc<<<4o16iEAC00CDF33AC373DEF00EEFB3p|fold -5|sed "$[$1+1]!d
s/0/  x\n/g
s/1/x\n/g
s/2/x x\n/g
s/3/xxx\n/g
y/x/$1/"

Explicación

Cada fila de cada dígito es uno de estos cuatro patrones:

  x
x
x x
xxx

Al etiquetar estos 0-3, cada dígito se puede representar con 5 dígitos de base 4. Por ejemplo, 0 sería 32223, y la lista completa de dígitos está codificada en base-4 como 32223000003031330303223003130331323300003232332303. Esta codificado en hexadecimal como EAC00CDF33AC373DEF00EEFB3.

• dcconvierte hexadecimal EAC00CDF33AC373DEF00EEFB3a base-4.
• fold pone 5 dígitos de base 4 en cada línea
• sed:
  • elimina todas las líneas de entrada aparte del número de línea n + 1 (líneas sed 1-indexes)
  • traduce los dígitos de base 4 al patrón (de xes) para cada línea del dígito dado, junto con una nueva línea para el final de cada fila
  • translitera los xes al dígito n.

Pruébalo en línea .

MATL , 45 43 bytes

'V~4;LR`I-D2q (z%eI)P-nc'F TFZa15eiZ)5eGV*c

Pruébalo en línea!

Explicación

'V~4;LR`I-D2q (z%eI)P-nc' % Compressed string using printable ASCII except '
F TFZa                    % Decompress (change of base) into alphabet [1 0]
15e                       % Reshape into 15-row matrix. Each column contains the
                          % art for one digit, packed in column-major order
iZ)                       % Take input number and pick the corresponding column.
                          % Indexing is 1-based and modular, so 0 is at the end
5e                        % Reshape into a 5-row matrix. This already looks like
                          % the number, with active pixels as 1 and inactive as 0
GV                        % Push input number again. Convert to string, of one char
*                         % Multiply, element-wise. The previous char is
                          % interpreted as its ASCII code. This changes 1 into the 
                          % ASCII code of the input digit, and leaves 0 as is
c                         % Convert to char. Implicitly display. Char 0 is shown as
                          % a space

Retina, 166 164 163 bytes

Dos espacios en la tercera línea desde abajo

0
0addda
d
0 0
1
1b1b1b1b1b1
2
2ab2a2b222
3
3ab3ab3a
4
44 44 4ab4b4
5
55ab555b5a
6
66ab6a 6a
7
7ab7b7b7b7
8
88a 8a8 8a
9
99a 9ab9a
(\d)a
$1$1$1$1
^.

b
  
.{3}
$+¶

Pruébalo en línea!

Una versión mejorada de la solución de @ Okx

Pyth 82 85 91 100 bytes

Km?dC+48Q\ m.&C@"w$kn<^_d\x7f~"Qdj1906486293414135453684485070928 128V5p.)Kp.)K.)K

Probablemente sea posible mucho golf, mi primer desafío.

Archivo por lotes, 8 + 184 bytes

Aquí está mi solución por lotes obligatoria. Desafortunadamente, el método estándar para lograr esto es más de 300 bytes en lote, por lo que recurrimos a tácticas mucho más baratas.

@type %1

En el directorio actual, tengo 10 archivos configurados, nombrados del 0 al 9. En cada uno de estos está la respectiva cuadrícula de píxeles de 5x3. Por ejemplo:

El byte cuenta para estos son:

19 0
19 1
17 2
19 3
19 4
17 5
17 6
19 7
19 8
19 9
Total - 184

Todavía venció a Java.

Ruby, 94 bytes

->n{20.times{|i|print i%4>2?$/:[" ",n]["_Q_@@_]UWUU_GD_WU]_U]AA__U_WU_"[n*3+i%4].ord>>i/4&1]}}

Sin golf en el programa de prueba

f=->n{
  20.times{|i|                           #4 characters * 5 rows = 20
    print i%4>2?$/:                      #If i%4=3 print a newline else
    [" ",n][                             #either a space if the expression below is 0 or the digit n if 1.
      "_Q_@@_]UWUU_GD_WU]_U]AA__U_WU_"[  #bitmap data for digits, one character for each column
        n*3+i%4].ord>>i/4&1              #Select the correct character for the column, convert to ascii code,
    ]                                    #rightshift to find the correct bit for the row, 
  }                                      #use & to isolate the bit: 0 or 1
}

f[gets.to_i]

PHP, 115 bytes

for(;$i<5;)echo strtr(sprintf("%03b\n","1754"[[425,0,465,273,26,285,413,1,409,281][$argn]/4**$i++%4]),[" ",$argn]);

Pruébalo en línea!

Expandido

for(;$i<5;)
  echo strtr(
    sprintf("%03b\n",  # make a binary
      "1754"[[425,0,465,273,26,285,413,1,409,281][$argn]/4**$i++%4])
    ,[" ",$argn]); # replace 0 with space and 1 with the input

Codificación ¡ Pruébelo en línea!

Retina , 125 bytes

.
A$&¶B$&¶C$&¶D$&¶E$&
([ACE][235689]|A0|E0|C4|A7)(?<=(.))
$2$2$2
(B[0489]|D[068]|A4|C0)(?<=(.))
$2 $2
D2
2
B5
5
B6
6
[A-E]
  

Pruébalo en línea! (Elimine el conjunto de pruebas en el encabezado para probar dígitos de entrada individuales). La última línea contiene dos espacios.

PowerShell, 126 120 113 109 101

$n="$args"
-split'ϽϭϿ·ͱ Ο·ͽͼϿ·Ņ ϻ·ͭͭϿ'|%{-join($_[0..2]|%{"$n·"[!($_-band1-shl$n)]})}

Unicode es divertido. Los caracteres también son mucho más cortos que los números. El código anterior contiene U + 0000 dos veces, por lo que no se puede copiar directamente (aunque funciona bien en un archivo). Se puede copiar el siguiente código:

$n="$args"
-split"ϽϭϿ ͱ`0Ο ͽͼϿ Ņ`0ϻ ͭͭϿ"|%{-join($_[0..2]|%{"$n "[!($_-band1-shl$n)]})}

Perdemos tres bytes porque necesitamos la firma UTF-8 al comienzo. De lo contrario, la cadena no funcionará.

Retina , 190 bytes

0
000¶aaa000
a
0 0¶
1
aaaaa
a
b1¶
2
ab2¶a2¶a
a
222¶
3
ab3¶ab3¶a
a
333¶
4
4 4¶4 4¶444¶b4¶b4
5
a5b¶ab5¶a
a
555¶
6
a6¶a6 6¶a
a
666¶
7
777aaaa
a
¶b7
8
a8 8¶a8 8¶a
a
888¶
9
a9 9¶ab9¶a
a
999¶
b
  

Hay dos espacios en la última línea, pero SE no quiere representarlo: / ¡Solucionado!

Pruébalo en línea!

Java 8, 278 214 210 204 bytes

n->("A"+n+"\nB"+n+"\nC"+n+"\nD"+n+"\nE"+n).replaceAll("([ACE][235689]|A0|E0|C4|A7)(?<=(.))","$2$2$2").replaceAll("(B[0489]|D[068]|A4|C0)(?<=(.))","$2 $2").replaceAll("D2|B5|B6",n).replaceAll("[A-E]","  ")

Puerto de la respuesta de Retina de @Neil . Toma la entrada como unString .

Pruébalo aquí

Python 2 , 174125 bytes

lambda n:'\n'.join('xxx  x x'[int(i):][:3]for i in oct(0x3028000adba93b6b0000c0ad36ebac30180c0)[:-1][n::10]).replace('x',`n`)

Pruébalo en línea!

PowerShell , 159 135 128 118 bytes

param($n);0..4|%{("$n$n$n","$n $n","  $n","$n  ")['01110333330203002020110220302003010022220101001020'[$_+($n*5)]-48]}

Respuesta actual: eliminación de nombres de variables extrañas

Pruébalo en línea!

Tendré que ver si puedo obtener algunos trucos de las otras respuestas: P

EDITAR Ser más inteligente llamando a la megacadena

EDIT2 Cambió a usar una cadena de números para indexar $ay guardar 7 bytes. Aunque me gustaron mis llamadas de nombres de variables dinámicas anteriores en el siguiente código (135 bytes)

param($n);$a="$n$n$n";$b="$n $n";$c="  $n";$d="$n  ";$r="abbbadddddacadaacacabbaccadacaadabaaccccababaabaca";0..4|%{gv $r[$_+($n*5)]-v}

Carbón , 61 38 bytes

Ｅ§⪪”{⊞¶↙⬤\→*'K«-aRＱ¹νÀ⁰”⁵Ｎ⭆421⎇＆ＩιＩλθ 

Pruébalo en línea!El enlace es a la versión detallada del código. Nota: espacio final. Explicación:

Ｅ§⪪”{⊞¶↙⬤\→*'K«-aRＱ¹νÀ⁰”⁵Ｎ

Divida la cadena (comprimida) en grupos de 5, tome la que está en el índice dado por la entrada y asigne los caracteres del grupo (que siempre son 1, 4, 5 o 7).

⭆421⎇＆ＩιＩλθ 

Convierta el carácter de la base 10 en la base 2 de 3 dígitos utilizando el carácter de entrada y el espacio como dígitos. Los 5 resultados se imprimen implícitamente en líneas separadas.

Un puerto genérico es un poco aburrido, así que aquí hay una respuesta más idiomática de 61 bytes:

ＧＨ✳✳§⟦⟦↑L↓¬⟧⟦↓↓⟧⟦T↓→⟧⟦T→¬⟧⟦↑↑¬↑⟧⟦←↓T⟧⟦T↑L⟧⟦→↓↓⟧⟦+L↓⟧⟦+↓T⟧⟧Ｎ³θ

Pruébalo en línea! No hay una versión detallada ya que el desverbosificador no comprende listas de direcciones o incluso multidireccionales dentro de polígonos ordinarios. Explicación:

     ⟦...⟧      Array of paths, see below
          Ｎ     Input as an integer
    §           Index into the array
  ✳✳            Treat the element as direction data
           ³    Length of each segment (including 1 character overlap)
            θ   Draw using the input character
ＧＨ              Draw a path

Cada ruta se especifica utilizando una lista de direcciones ( ←↑→↓). Cuatro atajos utilizables guardan bytes: Lrepresenta ↑→, ¬representa ↓←, Trepresenta →↓←mientras +representa →↓←↑, aunque al menos una flecha debe permanecer para que la lista sea reconocida como una lista de direcciones (por lo que, por ejemplo TT, no se puede usar 3).

Jalea , 35 32 bytes

Ṿ⁶,“SÐ~ẈoI9Ẇ¦Y./,0&Ƥɓ€ọ’ṃs15ị@s3

Pruébalo en línea! o verlos a todos .

Igual que el método de dzaima.

Perl 5 -Mbigint -pa , 101 bytes

$_=sprintf"%16b",0xf79ef7dee492f3def39eb792e79ee7ce4924f6de>>16*$_&65535;eval"y/01/ @F/";s/...\K/\n/g

Pruébalo en línea!

Python 3 , 119 bytes

lambda n:(3*f"%s%s{n}\n%s %s\n")[:30]%(*[n if i//(2**n)%2else" "for i in[1021,1005,881,927,893,892,325,1019,877,877]],)

Pruébalo en línea!

Cada 'píxel' se representa como un número entero donde cada potencia de dos indica si el píxel es sólido. Esto aprovecha el hecho de que las tres esquinas de la derecha son siempre el dígito.

JavaScript (ES8), 87 bytes

n=>`019
2 3
459
6 7
889`.replace(/\d/g,c=>[2,18,142,96,130,131,698,4,146][c]>>n&1?' ':n)