O que eu quero:

Simplesmente, quero uma exibição baseada em texto, que solicite uma entrada ne mostre esse valor na exibição! Mas há um problema. Cada um dos pixels 'verdadeiros' (os preenchidos) deve ser representado por esse número n.

Exemplo:

Você recebe uma entrada n. Você pode assumir nque será um único 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

Desafio:

Faça isso acima no menor número possível de bytes.

Aceitarei apenas respostas que atendam a todos os requisitos.

O espaço em branco circundante é opcional, desde que o dígito seja exibido corretamente.

Além disso, <75 bytes é um voto meu, o menor aceita, mas eu sempre posso alterar a resposta aceita, portanto, não desanime em responder.

Sogl V0.12 , 30 bytes

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

Experimente aqui! A cadeia compactada ■'τč▲Β►║⁰ΡāQšJ┘tXdnοO¹‘é

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

que é (começando com 1, terminando com 0) os números, linha por linha, número para número. O 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>

Os números codificam quais quadrados contêm espaços para um determinado dígito, por exemplo, o canto inferior esquerdo tem um valor de 146 porque os 1, 4 e 7 não o usam e 146 = 2¹ + 2⁴ + 2⁷.

05AB1E , 40 39 38 bytes

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

Experimente online!

Explicação

•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

Japonês , 43 bytes

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

Contém alguns imprimíveis. Experimente online!

Contagens: 13 bytes de dados compactados, 9 bytes para descompactá-los e 21 bytes para formar a saída.

Explicação

Código não destruído:

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

Existem exatamente 4 possibilidades de linhas diferentes: ( #representa um dígito)

#  
  #
# #
###

Assim, cada número pode ser armazenado como um conjunto de cinco dígitos de base 4. Como cada número pode ser armazenado em 10 bits, o total é de 100 bits, o que corresponde a 13 bytes. Vou pular o processo de compactação e explicar a descompactação.

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.

Após a descompactação, a cadeia compactada de 13 bytes fica assim:

3131332333332111200122213333313321011121213133133133

Observe que isso falharia se qualquer uma das execuções de quatro dígitos 0fosse iniciada , pois os zeros à esquerda seriam deixados de fora quando s4executados. Podemos consertar isso tendo 0represent #  , que aparece apenas três vezes, e nenhum deles cai no início de uma execução de quatro dígitos.

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

Ok, então, para fazer com que nossa string de 50 dígitos seja compactada bem em pedaços de 4, tivemos que adicionar dois dígitos extras. Adicioná-los ao início da string significa que podemos cortá-los com o one-byter ¤.

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

Embaraçosamente, o Japt não possui um built-in para dividir uma string em fatias de comprimento X. No entanto, ele possui um built-in para obter todos os caracteres X, para que possamos armazenar todos os dados codificando todas as linhas principais primeiro, depois todas as segundas linhas etc.

Então agora temos a sequência de 5 dígitos que codifica o dígito que queremos criar, por exemplo, 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 o número mágico, consulte as quatro linhas distintas. Se você substituir #por 1e  com 0, obtém

100
001
101
111

Transpor isso e depois juntar-se a uma única string nos dá 101100010111. Converta em decimal e, voilà, você tem 2839. A reversão do processo mapeia os dígitos0123 nas quatro linhas binárias mostradas acima.

Quase pronto! Agora tudo o que resta a fazer é adicionar os espaços e dígitos:

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

E pronto, a saída implícita cuida do resto. Sinto muito que essa explicação seja longa, mas não vejo nenhuma maneira real de jogar golfe sem torná-la menos compreensível (se for compreensível ...)

JavaScript (ES6), 115 111 bytes

Recebe a entrada como uma sequência.

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

Como funciona

Codificação de padrão

Os quatro padrões distintos "XXX", "X..", "..X"e "X.X"pode ser comprimido como "XXX...X.X"e extraído desta forma:

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

Ao substituir o dígito de entrada npara "X"e usando espaços reais, o que dá a expressão:

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

Codificação de dígitos

Usando os identificadores de padrão definidos acima, cada dígito pode ser representado por uma quantidade de 5 * 2 = 10 bits.

Por exemplo:

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

A lista completa é:

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

No entanto, dividir esses valores por 2 permite salvar dois bytes. Então, em vez disso, armazenamos:

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

Demo

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ários Bash + GNU, 114

• 2 bytes salvos graças a @SophiaLechner

Provavelmente existem mais oportunidades de compactação aqui, mas aqui está um começo:

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

Explicação

Cada linha de cada dígito é um desses quatro padrões:

  x
x
x x
xxx

Ao rotular esses 0-3, cada dígito pode ser representado por 5 dígitos base-4. Por exemplo, 0 seria 32223e a lista completa de dígitos é codificada na base-4 como 32223000003031330303223003130331323300003232332303. Este codificado em hexadecimal como EAC00CDF33AC373DEF00EEFB3.

• dcconverte hexadecimal EAC00CDF33AC373DEF00EEFB3em base-4.
• fold coloca 5 dígitos base-4 em cada linha
• sed:
  • exclui todas as linhas de entrada além do número de linha n + 1 (linhas com índices 1 sed)
  • converte os dígitos da base 4 no padrão ( xes) de cada linha do dígito fornecido, junto com uma nova linha no final de cada linha
  • translitera xes para o dígito n.

Experimente online .

MATL , 45 43 bytes

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

Experimente online!

Explicação

'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

Dois espaços na terceira linha da parte inferior

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

Experimente Online!

Uma versão aprimorada da solução da @ Okx

Pitão 82 85 91 100 bytes

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

Provavelmente, é possível praticar muito golfe, meu primeiro desafio.

Arquivo em lote, 8 + 184 bytes

Aqui está minha solução obrigatória em lote. Infelizmente, o método padrão de fazer isso é superior a 300 bytes em lote, por isso recorremos a táticas muito mais baratas.

@type %1

No diretório atual, tenho 10 arquivos configurados, nomeados de 0 a 9. Em cada um desses, há a respectiva grade 5x3 de pixels. Por exemplo:

A contagem de bytes para eles é:

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

Ainda vença o 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]}}

Ungolfed in program program

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

Experimente online!

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

Codificação Experimente online!

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]
  

Experimente online! (Exclua o conjunto de testes no cabeçalho para testar dígitos de entrada individuais.) A última linha contém dois espaços.

PowerShell, 126 120 113 109 101

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

Unicode é divertido. Os caracteres também são muito mais curtos que os números. O código acima contém U + 0000 duas vezes, portanto, não pode ser copiado diretamente (embora funcione bem em um arquivo). O seguinte código pode ser copiado:

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

Perdemos três bytes porque precisamos da assinatura UTF-8 no início. Caso contrário, a string não 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
  

Existem dois espaços na última linha, mas o SE não deseja renderizá-la: / Corrigido!

Experimente online!

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

Porto da resposta Retina de @Neil . Toma a entrada como a String.

Experimente aqui.

Python 2 , 174 125 bytes

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

Experimente online!

PowerShell , 159 135 128 118 bytes

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

Resposta atual: nomeação de variável externa removida

Experimente online!

Vou ter que ver se consigo obter alguns truques das outras respostas: P

EDIT Ficando mais esperto ao chamar a mega string

EDIT2 Alternou para usar uma sequência de números para indexar $ae salvar 7 bytes. Embora eu tenha gostado das chamadas de nome de variável dinâmica anterior no código abaixo (135 bytes)

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

Carvão , 61 38 bytes

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

Experimente online! Link é a versão detalhada do código. Nota: Espaço à direita. Explicação:

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

Divida a sequência (compactada) em grupos de 5, pegue a que está no índice fornecido pela entrada e mapeie os caracteres no grupo (que são sempre 1, 4, 5 ou 7).

⭆421⎇＆ＩιＩλθ 

Converta o caractere da base 10 para a base 2 de 3 dígitos, usando o caractere de entrada e o espaço como dígitos. Os 5 resultados são impressos implicitamente em linhas separadas.

Uma porta genérica é um pouco chata, então aqui está uma resposta mais idiomática de 61 bytes:

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

Experimente online! Nenhuma versão detalhada, pois o deverbosifier não entende listas de direções ou mesmo multidirecionais dentro de polígonos comuns. Explicação:

     ⟦...⟧      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 caminho é especificado usando uma lista de direções ( ←↑→↓). Quatro atalhos utilizáveis ​​salvam bytes: Lrepresenta ↑→, ¬representa ↓←, Trepresenta →↓←enquanto +representa →↓←↑, embora pelo menos uma seta deva permanecer para que a lista seja reconhecida como uma lista de direção (por exemplo, TTnão pode ser usada para 3).

Geléia , 35 32 bytes

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

Experimente online! ou vê-los todos .

O mesmo que o método de dzaima.

Perl 5 -Mbigint -pa , 101 bytes

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

Experimente online!

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

Experimente online!

Cada 'pixel' é representado como um número inteiro, onde cada potência de dois indica se o pixel é sólido. Isso tira vantagem do fato de que os três cantos do lado direito são sempre o 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)