Quello che voglio:

Molto semplicemente, voglio un display basato su testo, che richiede un input n, quindi mostra quel valore sul display! Ma c'è un problema. Ciascuno dei "veri" "pixel" (quelli inseriti) deve essere rappresentato da quel numero n.

Esempio :

Ti viene dato un input n. Puoi presumere nche sarà una singola cifra

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

Sfida:

Fai quanto sopra nel minor numero di byte possibile.

Accetterò solo risposte che soddisfino tutti i requisiti.

Lo spazio bianco circostante è facoltativo, purché la cifra sia visualizzata correttamente.

Inoltre, <75 byte è un mio voto, il più basso accetta, ma potrei sempre cambiare la risposta accettata, quindi non scoraggiarti a rispondere.

SOGL V0.12 , 30 byte

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

Provalo qui! La stringa compressa ■'τč▲Β►║⁰ΡāQšJ┘tXdnοO¹‘è

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

che è (che inizia con 1, termina con 0) i numeri, riga per riga, numero per numero. Il riposo

...‘             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 byte

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>

I numeri che codificano quali quadrati contengono spazi per una determinata cifra, ad es. L'angolo in basso a sinistra ha un valore di 146 perché 1, 4 e 7 non lo usano e 146 = 2¹ + 2⁴ + 2⁷.

05AB1E , 40 39 38 byte

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

Provalo online!

Spiegazione

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

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

Contiene alcuni non stampabili. Provalo online!

Tallies: 13 byte di dati compressi, 9 byte per decomprimerlo e 21 byte per formare l'output.

Spiegazione

Codice non golfato:

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

Esistono esattamente 4 diverse possibilità di riga: ( #rappresenta una cifra)

#  
  #
# #
###

Pertanto, ogni numero può essere memorizzato come un insieme di cinque cifre di base 4. Poiché ogni numero può quindi essere memorizzato in 10 bit, il totale è 100 bit, che corrisponde a 13 byte. Salterò il processo di compressione e spiegherò invece la decompressione.

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.

Dopo la decompressione, la stringa compressa da 13 byte si presenta così:

3131332333332111200122213333313321011121213133133133

Notare che ciò non avrebbe esito positivo se si iniziasse una delle corse a 4 cifre 0, poiché gli zero iniziali verrebbero interrotti quando s4viene eseguita. Possiamo risolvere questo problema 0rappresentando #  , che appare solo tre volte, e nessuno di questi cade all'inizio di una corsa di 4 cifre.

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

Ok, quindi per far sì che la nostra stringa di 50 cifre si comprimesse bene in blocchi di 4, abbiamo dovuto aggiungere due cifre extra. Aggiungerli all'inizio della stringa significa che possiamo tagliarli con l'uno-byte ¤.

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

In modo imbarazzante, Japt non ha un built-in per dividere una stringa in sezioni di lunghezza X. Ha un built-in per ottenere ogni carattere Xth, tuttavia, quindi possiamo archiviare tutti i dati codificando prima tutte le prime righe, quindi tutte le seconde file, ecc.

Quindi ora abbiamo la stringa di 5 cifre che codifica la cifra che vogliamo creare, ad esempio 32223per 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.

Per spiegare il numero magico, fare riferimento alle quattro righe distinte. Se si sostituisce #con 1e  con 0, si ottiene

100
001
101
111

Trasporre questo e poi unirci in una singola stringa ci dà 101100010111. Converti in decimale e, voilà, hai 2839. L'inversione del processo mappa le cifre 0123nelle quattro righe binarie mostrate sopra.

Quasi fatto! Ora non resta che aggiungere spazi e cifre:

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

E presto, l'output implicito si prende cura di tutto il resto. Mi dispiace che questa spiegazione sia così lunga, ma non vedo alcun modo reale di giocarla senza renderla meno comprensibile (se comprensibile ...)

JavaScript (ES6), 115 111 byte

Accetta l'input come stringa.

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)+`
`)

Come funziona

Codifica del modello

I quattro distinti modelli "XXX", "X..", "..X"e "X.X"possono essere compressi "XXX...X.X"ed estratti in questo modo:

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

Sostituendo la cifra di ingresso nper l' "X"e l'utilizzo di spazi reali, questo dà l'espressione:

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

Codifica cifre

Utilizzando gli identificatori di modello definiti sopra, ogni cifra può essere rappresentata da una quantità 5 * 2 = 10 bit.

Per esempio:

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

L'elenco completo è:

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

Tuttavia, la divisione di questi valori per 2 consente di salvare due byte. Quindi invece memorizziamo:

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

dimostrazione

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

Utilità Bash + GNU, 114

• 2 byte salvati grazie a @SophiaLechner

Probabilmente ci sono altre opportunità di compressione qui, ma ecco un inizio:

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

Spiegazione

Ogni riga di ogni cifra è uno di questi quattro schemi:

  x
x
x x
xxx

Etichettando questi 0-3, ogni cifra può essere rappresentata da 5 cifre di base 4. Ad esempio 0 sarebbe 32223, e l'elenco completo delle cifre è codificato in base-4 come 32223000003031330303223003130331323300003232332303. Questo codificato in esadecimale come EAC00CDF33AC373DEF00EEFB3.

• dcconverte hex EAC00CDF33AC373DEF00EEFB3in base-4.
• fold mette 5 cifre di base 4 su ogni riga
• sed:
  • elimina tutte le righe di input oltre al numero di riga n + 1 (sed 1-indexes lines)
  • traduce le cifre di base 4 nel modello (di xes) per ogni riga della cifra indicata, insieme a una nuova riga per la fine di ogni riga
  • traduce gli xes nella cifra n.

Provalo online .

MATL , 45 43 byte

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

Provalo online!

Spiegazione

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

Due spazi sulla terza riga dal basso

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}
$+¶

Provalo online!

Una versione migliorata della soluzione di @ Okx

Pyth 82 85 91 100 byte

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

Molto golf probabilmente possibile, la mia prima sfida.

File batch, 8 + 184 byte

Ecco la mia soluzione batch obbligatoria. Sfortunatamente il metodo standard per ottenere questo risultato è di oltre 300 byte in batch, quindi ricorrere a tattiche molto più economiche.

@type %1

Nella directory corrente, ho 10 file impostati, denominati da 0 a 9. In ognuno di questi è la rispettiva griglia 5x3 di pixel. Per esempio:

I conteggi dei byte per questi sono:

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

Batti ancora Java.

Rubino, 94 byte

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

Non registrato nel programma di test

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 byte

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

Provalo online!

allargato

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

Codifica Provalo online!

Retina , 125 byte

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

Provalo online! (Elimina la suite di test nell'intestazione per testare le singole cifre di input.) L'ultima riga contiene due spazi.

PowerShell, 126 120 113 109 101

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

Unicode è divertente. I personaggi sono anche molto più corti dei numeri. Il codice sopra contiene U + 0000 due volte, quindi non può essere copiato direttamente (funziona bene in un file, però). È possibile copiare il seguente codice:

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

Perdiamo tre byte perché all'inizio abbiamo bisogno della firma UTF-8. Altrimenti la stringa non funzionerà.

Retina , 190 byte

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
  

Ci sono due spazi sull'ultima riga ma SE non vuole renderlo: / Risolto!

Provalo online!

Java 8, 278 214 210 204 byte

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]","  ")

Port of @Neil 's Retina answer . Prende l'input come a String.

Provalo qui.

Python 2 , 174 125 byte

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

Provalo online!

PowerShell , 159 135 128 118 byte

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

Risposta attuale: rimozione della denominazione variabile estranea

Provalo online!

Dovrò vedere se riesco a ottenere alcuni trucchi dalle altre risposte: P

EDIT Diventa più intelligente con la chiamata della mega stringa

EDIT2 Passato all'utilizzo di una stringa di numeri in cui indicizzare $aper salvare 7 byte. Anche se mi sono piaciute le mie precedenti chiamate con nome di variabile dinamica nel codice seguente (135 byte)

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

Carbone di legna , 61 38 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Nota: spazio finale. Spiegazione:

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

Dividi la stringa (compressa) in gruppi di 5, prendi quella nell'indice fornito dall'input e mappa sui caratteri del gruppo (che sono sempre 1, 4, 5 o 7).

⭆421⎇＆ＩιＩλθ 

Converti il ​​carattere dalla base 10 alla base 2 a 3 cifre utilizzando il carattere di input e lo spazio come cifre. I 5 risultati vengono quindi stampati implicitamente su righe separate.

Una porta generica è un po 'noiosa, quindi ecco una risposta più idiomatica a 61 byte:

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

Provalo online! Nessuna versione dettagliata in quanto il deverbosificatore non comprende elenchi di direzioni o persino multidirezionali all'interno di poligoni ordinari. Spiegazione:

     ⟦...⟧      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

Ogni percorso è specificato usando un elenco di direzioni ( ←↑→↓). Quattro scorciatoie utilizzabili salvano i byte: Lrappresenta ↑→, ¬rappresenta ↓←, Trappresenta →↓←mentre +rappresenta →↓←↑, anche se deve rimanere almeno una freccia affinché l'elenco venga riconosciuto come elenco di direzione (quindi ad esempio TTnon può essere utilizzato per 3).

Gelatina , 35 32 byte

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

Provalo online! o vederli tutti .

Come il metodo di dzaima.

Perl 5 -Mbigint -pa , 101 byte

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

Provalo online!

Python 3 , 119 byte

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]],)

Provalo online!

Ogni 'pixel' è rappresentato come un numero intero in cui ogni potenza di due indica se il pixel è solido. Questo sfrutta il fatto che i tre angoli di destra sono sempre la cifra.

JavaScript (ES8), 87 byte

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)