Ce que je veux:

Tout simplement, je veux un affichage basé sur du texte, qui demande une entrée n, puis affiche cette valeur sur l'affichage! Mais il y a un hic. Chacun des «vrais» «pixels» (ceux remplis) doit être représenté par ce nombre n.

Exemple :

On vous donne une entrée n. Vous pouvez supposer qu'il ns'agira d'un seul chiffre

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

Défi:

Faites-le ci-dessus en aussi peu d'octets que possible.

Je n'accepterai que des réponses qui répondent à toutes les exigences.

L'espace blanc environnant est facultatif, tant que le chiffre s'affiche correctement.

En outre, <75 octets est un vote de ma part, le plus bas accepte, mais je pourrais toujours changer la réponse acceptée, alors ne vous découragez pas de répondre.

SOGL V0.12 , 30 octets

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

Essayez-le ici! La chaîne compressée ■'τč▲Β►║⁰ΡāQšJ┘tXdnοO¹‘est

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

qui est (commençant par 1, se terminant par 0) les nombres, ligne par ligne, numéro à numéro. Le reste

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

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>

Les nombres codent quels carrés contiennent des espaces pour un chiffre donné, par exemple le coin inférieur gauche a une valeur de 146 car les 1, 4 et 7 ne l'utilisent pas et 146 = 2¹ + 2⁴ + 2⁷.

05AB1E , 40 39 38 octets

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

Essayez-le en ligne!

Explication

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

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

Contient certains non imprimables. Essayez-le en ligne!

Correspondances: 13 octets de données compressées, 9 octets pour les décompresser et 21 octets pour former la sortie.

Explication

Code non golfé:

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

Il y a exactement 4 possibilités de lignes différentes: ( #représente un chiffre)

#  
  #
# #
###

Ainsi, chaque numéro peut être stocké sous la forme d'un ensemble de cinq chiffres de base 4. Étant donné que chaque numéro peut ensuite être stocké sur 10 bits, le total est de 100 bits, ce qui correspond à 13 octets. Je vais sauter le processus de compression et expliquer à la place la décompression.

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.

Après la décompression, la chaîne compressée de 13 octets ressemble à ceci:

3131332333332111200122213333313321011121213133133133

Notez que cela échouerait si l'une des exécutions à 4 chiffres commençait par 0, car les zéros de tête seraient laissés de côté lors de l' s4exécution. Nous pouvons résoudre ce problème en ayant 0represent #  , qui n'apparaît que trois fois, et aucun de ceux-ci ne tombe au début d'une exécution à 4 chiffres.

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

D'accord, donc pour que notre chaîne de 50 chiffres se comprime bien en morceaux de 4, nous avons dû ajouter deux chiffres supplémentaires. Les ajouter au début de la chaîne signifie que nous pouvons les couper avec un octet ¤.

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

De manière embarrassante, Japt n'a pas de fonction intégrée pour diviser une chaîne en tranches de longueur X. Cependant, il a une fonction intégrée pour obtenir chaque Xème caractère, afin que nous puissions stocker toutes les données en codant d'abord toutes les lignes supérieures, puis toutes les deuxièmes rangées, etc.

Nous avons donc maintenant la chaîne à 5 chiffres codant le chiffre que nous voulons créer, par exemple 32223pour 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.

Pour expliquer le nombre magique, reportez-vous aux quatre lignes distinctes. Si vous remplacez #par 1et  par 0, vous obtenez

100
001
101
111

Transposer cela et ensuite se joindre à une seule chaîne nous donne 101100010111. Convertissez en décimal et, voilà, vous avez 2839. Inverser le processus mappe les chiffres0123 dans les quatre lignes binaires indiquées ci-dessus.

Presque fini! Il ne reste plus qu'à ajouter les espaces et les chiffres:

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

Et hop, la sortie implicite s'occupe du reste. Je suis désolé que cette explication soit si longue, mais je ne vois aucun moyen réel de la jouer au golf sans la rendre moins compréhensible (si elle est compréhensible ...)

JavaScript (ES6), 115 111 octets

Prend l'entrée sous forme de chaîne.

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

Comment ça fonctionne

Encodage de motif

Les quatre modèles distincts "XXX", "X..", "..X"et "X.X"peuvent être compressés comme "XXX...X.X"et extraits de cette façon:

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

En remplaçant le chiffre d'entrée npour "X"et l' utilisation des espaces réels, ce qui donne l'expression:

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

Encodage numérique

En utilisant les identificateurs de modèle définis ci-dessus, chaque chiffre peut être représenté par une quantité 5 * 2 = 10 bits.

Par exemple:

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

La liste complète est:

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

Cependant, la division de ces valeurs par 2 permet d'économiser deux octets. Au lieu de cela, nous stockons:

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

Démo

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

Utilitaires Bash + GNU, 114

• 2 octets économisés grâce à @SophiaLechner

Il existe probablement d'autres possibilités de compression ici, mais voici un début:

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

Explication

Chaque ligne de chaque chiffre est l'un de ces quatre modèles:

  x
x
x x
xxx

En étiquetant ces 0-3, chaque chiffre peut être représenté par 5 chiffres de base 4. Par exemple, 0 serait 32223, et la liste complète des chiffres est codée en base 4 comme 32223000003031330303223003130331323300003232332303. Ce codé en hexadécimal comme EAC00CDF33AC373DEF00EEFB3.

• dcconvertit hex EAC00CDF33AC373DEF00EEFB3en base-4.
• fold met 5 chiffres de base 4 sur chaque ligne
• sed:
  • supprime toutes les lignes d'entrée à l'exception du numéro de ligne n + 1 (sed 1-indexe les lignes)
  • traduit les chiffres de la base 4 en motif (de xes) pour chaque ligne du chiffre donné, avec une nouvelle ligne pour la fin de chaque ligne
  • translittère le xes au chiffre n.

Essayez-le en ligne .

MATL , 45 43 octets

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

Essayez-le en ligne!

Explication

'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

Rétine, 166 164 163 octets

Deux espaces sur la troisième ligne à partir du bas

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

Essayez-le en ligne!

Une version améliorée de la solution @ Okx

Pyth 82 85 91 100 octets

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

Beaucoup de golf probablement possible, mon premier défi.

Fichier de commandes, 8 + 184 octets

Voici ma solution batch obligatoire. Malheureusement, la méthode standard pour y parvenir est de plus de 300 octets par lot, nous avons donc recours à des tactiques beaucoup moins chères.

@type %1

Dans le répertoire actuel, j'ai 10 fichiers configurés, nommés de 0 à 9. Dans chacun d'eux se trouve la grille de pixels 5x3 respective. Par exemple:

Les octets comptent pour ceux-ci:

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

Toujours battre Java.

Rubis, 94 octets

->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 testé dans le programme de 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 octets

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

Essayez-le en ligne!

Étendu

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

Encodage Essayez-le en ligne!

Rétine , 125 octets

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

Essayez-le en ligne! (Supprimez la suite de tests dans l'en-tête pour tester les chiffres d'entrée individuels.) La dernière ligne contient deux espaces.

PowerShell, 126 120 113 109 101

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

Unicode est amusant. Les caractères sont également beaucoup plus courts que les chiffres. Le code ci-dessus contient deux fois U + 0000, il ne peut donc pas être copié directement (fonctionne bien dans un fichier, cependant). Le code suivant peut être copié:

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

Nous perdons trois octets car nous avons besoin de la signature UTF-8 au début. Sinon, la chaîne ne fonctionnera pas.

Rétine , 190 octets

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
  

Il y a deux espaces sur la dernière ligne mais SE ne veut pas le rendre: / Fixed!

Essayez-le en ligne!

Java 8, 278 214 210 210 204 octets

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

Réponse de Port of @Neil Retina . Prend l'entrée comme un String.

Essayez-le ici.

Python 2 , 174 125 octets

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

Essayez-le en ligne!

PowerShell , 159 135 128 118 octets

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

Réponse actuelle: suppression de la dénomination des variables superflues

Essayez-le en ligne!

Je vais devoir voir si je peux obtenir quelques astuces des autres réponses: P

EDIT Pour devenir plus intelligent en appelant la méga chaîne

EDIT2 Passé à l'utilisation d'une chaîne de nombres à indexer $apour économiser 7 octets. Bien que j'aie aimé mes appels de nom de variable dynamique précédents dans le code ci-dessous (135 octets)

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

Fusain , 61 38 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Remarque: Espace de fin. Explication:

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

Divisez la chaîne (compressée) en groupes de 5, prenez celle de l'index donné par l'entrée et mappez sur les caractères du groupe (qui sont toujours 1, 4, 5 ou 7).

⭆421⎇＆ＩιＩλθ 

Convertissez le caractère de la base 10 en base 2 à 3 chiffres en utilisant le caractère saisi et l'espace comme chiffres. Les 5 résultats sont ensuite imprimés implicitement sur des lignes distinctes.

Un port générique est un peu ennuyeux, alors voici une réponse plus idiomatique de 61 octets:

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

Essayez-le en ligne! Pas de version verbeuse car le déverbosificateur ne comprend pas les listes de directions ou même multidirectionnelles à l'intérieur des polygones ordinaires. Explication:

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

Chaque chemin est spécifié à l'aide d'une liste de directions ( ←↑→↓). Quatre raccourcis utilisables permettent d'économiser des octets: Lreprésente ↑→, ¬représente ↓←, Treprésente →↓←tandis que +représente →↓←↑, bien qu'au moins une flèche doit rester pour que la liste soit reconnue comme une liste de directions (donc, par exemple, TTne peut pas être utilisée pour 3).

Gelée , 35 32 octets

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

Essayez-le en ligne! ou voir tous .

Identique à la méthode de dzaima.

Perl 5 -Mbigint -pa , 101 octets

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

Essayez-le en ligne!

Python 3 , 119 octets

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

Essayez-le en ligne!

Chaque «pixel» est représenté comme un entier où chaque puissance de deux indique si le pixel est solide. Cela profite du fait que les trois coins à droite sont toujours le chiffre.

JavaScript (ES8), 87 octets

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)