Entre les lignes

31

entrez la description de l'image ici

En griffonnant sur du papier quadrillé l'autre jour, j'ai trouvé la police à espace négatif ci-dessus pour les chiffres. Au cas où vous ne l'auriez pas encore repéré, les espaces entre les formes ci-dessus donnent le nombre d'or de 1,618033988749 . Dans ce défi, votre tâche consiste à prendre un nombre en entrée et à le rendre exactement comme le montre l'exemple ci-dessus.

Voici comment ceux-ci sont créés. Toutes les lignes seront sur une grille régulière, de sorte que les chiffres individuels sont constitués d'un petit nombre de cellules de grille. Voici les formes des 10 chiffres (nous ignorerons le point décimal pour ce défi):

entrez la description de l'image ici
Oui, le 7 diffère de l'exemple du nombre d'or en haut. J'ai un peu gâché ça. Nous irons avec celui-ci.

Notez que chaque chiffre mesure cinq cellules de haut et trois cellules de large. Pour rendre un nombre, vous pouvez imaginer placer tous ses chiffres l'un à côté de l'autre, de sorte qu'il y ait exactement une colonne vide entre chaque paire de chiffres. Par exemple, en prenant 319comme entrée, nous écririons:

entrez la description de l'image ici

Notez que nous ajoutons une colonne vide de début et de fin. Maintenant, nous inversons les cellules:

entrez la description de l'image ici

La sortie doit alors être les limites des polygones résultants:

entrez la description de l'image ici

Bien sûr, vous pouvez générer le résultat de toute autre manière, tant que la sortie rendue est identique.

Contribution

  • Vous pouvez écrire un programme ou une fonction, en prenant une entrée via STDIN (ou l'alternative la plus proche), un argument de ligne de commande ou un argument de fonction, sous forme de chaîne ou de liste de chiffres. (Vous ne pouvez pas prendre un nombre car cela ne vous permettrait pas de prendre en charge les zéros non significatifs.)
  • Vous pouvez supposer qu'il n'y aura plus de 16 chiffres dans l'entrée.

Sortie

  • La sortie peut être affichée à l'écran ou écrite dans un fichier dans un format d'image commun.
  • Vous pouvez utiliser des graphiques raster et vectoriels.
  • Dans les deux cas, le rapport d'aspect des cellules de la grille sous-jacente doit être 1 (c'est-à-dire que les cellules doivent être des carrés).
  • Dans le cas de graphiques raster, chaque cellule doit couvrir au moins 20 x 20 pixels.
  • Les lignes ne doivent pas dépasser 10% de la taille des cellules. Je suis prêt à donner un ou deux pixels de latitude en raison de l'aliasing ici.
  • Les lignes et l'arrière-plan peuvent être deux couleurs clairement distinctes, mais les formes créées par les lignes ne doivent pas être remplies (c'est-à-dire que l'intérieur doit également être la couleur d'arrière-plan).
  • Il ne doit y avoir aucun espace dans chaque boucle fermée.
  • Bien sûr, le résultat entier doit être visible.

Cas de test

Voici 10 entrées, qui couvrent ensemble toutes les paires possibles de chiffres adjacents, ainsi que tous les chiffres avant et arrière possibles:

07299361548
19887620534
21456837709
39284106657
49085527316
59178604432
69471338025
79581224630
89674235011
97518264003

Et voici les résultats attendus pour ceux-ci:

entrez la description de l'image ici entrez la description de l'image ici entrez la description de l'image ici entrez la description de l'image ici entrez la description de l'image ici entrez la description de l'image ici entrez la description de l'image ici entrez la description de l'image ici entrez la description de l'image ici entrez la description de l'image ici

Assurez-vous que votre code fonctionne également lorsqu'il est donné un seul chiffre (je ne veux pas inclure les résultats attendus ici, car ils devraient être évidents, et la section de cas de test est assez gonflée telle quelle).

Martin Ender
la source
L'art ASCII serait-il accepté?
Bleu
2
@Blue Je pense que cela ferait une tâche très différente, et les réponses seraient difficilement comparables, donc non, désolé. Je ne suis généralement pas fan de mélanger la sortie graphique et l'art ASCII dans un seul défi.
Martin Ender
bien, merci pour la réponse rapide
Bleu
Est-il autorisé d'importer des polices?
Marv
@Marv hm, question intéressante. Je dirais que vous devriez compter la taille du fichier de police dans ce cas.
Martin Ender

Réponses:

1

BBC BASIC, 182 caractères ASCII (taille de fichier à jetons 175 octets)

Téléchargez l'interprète sur http://www.bbcbasic.co.uk/bbcwin/bbcwin.html

I.n$
F.j=0TOLENn$*4p=ASCM."?@\@?[@_?DTP?TT@?pv@?PTD?@TD?||@?@T@?PT@",VALM.n$,j/4+1,1)*4+1+j MOD4)F.k=0TO4p*=2q=64A.p
V.537;q;0;2585;0;q;537;-q;0;2585;0;-q;25;0;64;
N.MOVEBY 64,-320N.

Scoring: Lorsque le programme ci-dessus est collé dans l'éditeur et exécuté, l'éditeur étendra les mots clés abrégés en mots clés complets à l'écran, bien qu'ils ne soient en réalité que 1 octet après la tokenisation. (Exemple I.= INPUTespace de stockage 1 octet.)

Explication

Je vais simplement expliquer ce que fait la ligne VDU: elle dessine une boîte en inversant la couleur actuelle des pixels à l'écran. Cela signifie que (avec un peu de soin avec les coins), il est possible de simplement dessiner une cellule à côté de l'autre, et le bord intermédiaire s'annulera et disparaîtra en raison d'un double dessin.

Un examen attentif révèlera que les coins supérieur droit et inférieur gauche d'une cellule sont dessinés mais que les coins supérieur gauche et inférieur droit sont manquants ("arrondis") pour que cela fonctionne.

Une fois la cellule dessinée, le curseur graphique est déplacé de 32 pixels vers le haut pour que la cellule suivante soit dessinée.

Le reste du programme est une décompression bitmap ASCII assez simple. Les dimensions de la cellule sont de 64x64 unités pour le golf / la compatibilité avec la façon dont le bitmap est décompressé. qcontrôle la taille de la cellule tracée: 64x64 unités pour une cellule présente, 0x0 pour une cellule absente.

Code non golfé

  m$="?@\@?[@_?DTP?TT@?pv@?PTD?@TD?||@?@T@?PT@" :REM bitmap for digits, including column of filled cells at left. BBC strings are 1-indexed
  INPUTn$                                       :REM user input
  FORj=0 TO LENn$*4                             :REM iterate 4 times per input digit, plus once more (plot column 0 of imaginary digit to finish)
    d=VAL MID$(n$,j/4+1,1)                      :REM extract digit from n$ (1-character string). VAL of empty string = 0, so 123->1,1,1,1,2,2,2,2,3,3,3,3,0
    p=ASC MID$(m$,d*4+1+j MOD4)                 :REM get column bitmap from m$ d*4 selects digit, j MOD4 selects correct column of digit, add 1 to convert to 1-index
    FORk=0TO4                                   :REM for each cell in the column
      p*=2                                      :REM bitshift p
      q=64ANDp                                  :REM find size of cell to draw. 64 for a filled cell, 0 for an absent cell.
      VDU537;q;0;                               :REM line q units right, inverting existing screen colour. Draw last pixel (will be inverted next line)
      VDU2585;0;q;                              :REM line q units up, inverting existing screen colour. Dont draw last pixel (will be filled in next line)
      VDU537;-q;0;                              :REM line q units left, inverting existing screen colour. Draw last pixel (will be inverted next line)
      VDU2585;0;-q;                             :REM line q units down, inverting existing screen colour. Dont draw last pixel (avoid inverting 1st pixel of 1st line)
      VDU25;0;64;                               :REM move up 64 units for cell above
    NEXT
    MOVEBY 64,-320                              :REM move right and down for next column.
  NEXT

Sortie

Les MOVEs sont simplement obtenir la sortie à des hauteurs appropriées sur l'écran. BBC basic utilise 2 unités = 1 pixel dans ce mode, donc les cellules sont en fait 32x32 pixels.

entrez la description de l'image ici

Level River St
la source
10

Octave, 233 225 216 213 octets

o=@ones;l=z=o(5,1);for k=input('')-47;l=[l,reshape(dec2bin([448,22558,8514,10560,3936,2376,328,15840,320,2368](k),15),5,[])-48,z];end;L=~o(size(l)+2);L(2:6,2:end-1)=l;O=o(3);O(5)=-8;M=~conv2(kron(L,o(25)),O);imshow(M)

Voici le premier cas de test (à partir d'une capture d'écran redimensionnée, il correspond à mon moniteur =): entrez la description de l'image ici

o=@ones;
l=z=o(5,1);                   %spacer matrices
for k=input('')-47;           %go throu all input digis
                              %decode the matrices for each digit from decimal
l=[l,reshape(dec2bin([448,22558,8514,10560,3936,2376,328,15840,320,2368](k),15),5,[])-48,z];
end
L=~o(size(l)+2);           %pad the image
L(2:6,2:end-1)=l;
O=o(3);O(5)=-8;               %create edge detection filter
imshow(~conv2(kron(L,o(25)),O)) %image resizing /edge detection (change 25 to any cell size you like)

L'entrée peut être de longueur arbitraire, comme par exemple '07299361548'

La convolution est la clé du succès.

flawr
la source
Merci @LuisMendo d'avoir amélioré le score d'un tas d'octets =)
flawr
2
Je ne pourrais pas être plus d'accord avec Convolution est la clé du succès :-)
Luis Mendo
D'une certaine manière, c'est toujours la devise de mes réponses réussies en matlab / octave: D
flawr
5

Javascript ES6, 506 octets

a=>{with(document)with(body.appendChild(createElement`canvas`))with(getContext`2d`){width=height=(a.length+2)*80;scale(20,20);translate(1,1);lineWidth=0.1;beginPath();["oint",...a.map(i=>"05|7agd7|oint 067128a45|oicgmnt 01de25|oil9amnt 01de23fg45|oint 03fh5|68ec6|oint 03fg45|oij78knt 05|9agf9|oij78knt 01dh5|oint 05|78ed7|9agf9|oint 03fg45|78ed7|oint".split` `[i]),"05"].map(i=>{i.split`|`.map(i=>[...i].map((e,i,_,p=parseInt(e,36),l=~~(p/6),r=p%6)=>i?lineTo(l,r):moveTo(l,r)));translate(4,0)});stroke()}}

Ungolfed:

a=>{                                            // anonymous function declaration, accepts array of numbers
  with(document)                                // bring document into scope
  with(body.appendChild(createElement`canvas`)) // create canvas, drop into html body, bring into scope
  with(getContext`2d`){                         // bring graphics context into scope
    width=height=(a.length+2)*80;               // set width and height
    scale(20,20);                               // scale everything to 20x
    translate(1,1);                             // add padding so outline doesn't touch edge of canvas
    lineWidth=0.1;                              // have to scale line width since we scaled 20x
    beginPath();                                // start drawing lines
    ["oint",                                    // beginning "glyph", draws left end of negative space, see below
     ...a.map(i=>`05|7agd7|oint                 // glyphs 0-9 encoded as vertices
                  067128a45|oicgmnt             //   glyphs seperated by " "
                  01de25|oil9amnt               //   lines within each glyph seperated by "|"
                  01de23fg45|oint               //   a single vertex is stored as a base36 char
                  03fh5|68ec6|oint              //     where a number corresponds to one of the verts shown below:
                  03fg45|oij78knt               //        0  6 12 18 24
                  05|9agf9|oij78knt             //        1  7 13 19 25
                  01dh5|oint                    //        2  8 14 20 26
                  05|78ed7|9agf9|oint           //        3  9 15 21 27
                  03fg45|78ed7|oint`            //        4 10 16 22 28
       .split` `[i]),                           //        5 11 17 23 29
     "05"]                                      // end "glyph", draws right end of negative space, see above
      .map(i=>{                                 // for each glyph string
        i.split`|`                              // seperate into list of line strings
          .map(i=>[...i]                        // convert each line string into list of chars
            .map((e,i,_,p=parseInt(e,36),       // convert base36 char to number
                  l=~~(p/6),r=p%6)=>            // compute x y coords of vertex
              i?lineTo(l,r):moveTo(l,r)));      // draw segment
        translate(4,0)});                       // translate origin 4 units to right
    stroke()}}                                  // draw all lines to canvas

Suppose qu'il y a un <body>pour ajouter le canevas, testé dans Firefox 46.

Exemple d'exécution (affectation d'une fonction anonyme à f):

f([1,0,3])

rendements:

Exemple de sortie

Dendrobium
la source
5

Html + JavaScript ES6, 352

Testez l'exécution de l'extrait ci-dessous

<canvas id=C></canvas><script>s=prompt(),C.width=-~s.length*80,c=C.getContext("2d"),[...s].map(d=>[30,d*=3,++d,++d].map(w=a=>{for(a=parseInt("vhvivgtlnllv74vnltvlt11vvlvnlv0"[a],36)*2+1,p=1,y=100,i=64;i>>=1;p=b,y-=20)c.moveTo(x+20,y),b=a&i?1:0,c[b-p?'lineTo':'moveTo'](x,y),(a^q)&i&&c.lineTo(x,y-20);q=a,x+=20}),q=63,x=0),w(30),w(0),c.stroke()</script>

Moins golfé

s=prompt(),C.width=-~s.length*80,c=C.getContext("2d"),
w=a=>{
  a=parseInt("vhvivgtlnllv74vnltvlt11vvlvnlv0"[i],36)*2+1
  for(p=1,y=100,i=32;i;p=b,y-=20,i>>=1)
    c.moveTo(x+20,y),
    b=a&i?1:0,
    c[b-p?'lineTo':'moveTo'](x,y),
    (a^q)&i&&c.lineTo(x,y-20)
  q=a 
  x+=20
},
[...s].map(d=>[30,d*=3,++d,++d].map(w),q=63,x=0),
w(30),w(0)
c.stroke()
edc65
la source
1
Je ne pense pas que vous ayez besoin de la balise de script de fermeture ...
Mama Fun Roll
3

Java, 768 octets

import java.awt.*;import java.awt.image.*;class G{public static void main(String[]v)throws Exception{int s=20,n=v[0].length(),i=0,j,w=(n*3+n+1)*s,h=5*s,a[][]={{6,7,8},{0,2,3,10,11,12,13},{1,6,8,13},{1,3,6,8},{3,4,5,6,8,9},{3,6,8,11},{6,8,11},{1,2,3,4,6,7,8,9},{6,8},{3,6,8}};BufferedImage o,b=new BufferedImage(w,h,1);Graphics g=b.getGraphics();g.setColor(Color.WHITE);for(;i<n;i++)for(j=0;j<15;j++){int c=j;if(java.util.Arrays.stream(a[v[0].charAt(i)-48]).noneMatch(e->e==c))g.fillRect((1+i*4+j/5)*s,j%5*s,s,s);}o=new BufferedImage(b.getColorModel(),b.copyData(null),0>1,null);for(i=1;i<h-1;i++)for(j=1;j<w-1;j++)if((b.getRGB(j+1,i)|b.getRGB(j-1,i)|b.getRGB(j,i+1)|b.getRGB(j,i-1))<-1)o.setRGB(j,i,-1);javax.imageio.ImageIO.write(o,"png",new java.io.File("a.png"));}}

Ungolfed

import java.awt.*;
        import java.awt.image.BufferedImage;

class Q79261 {
    public static void main(String[] v) throws Exception {
        int scale = 20, n = v[0].length(), i = 0, j, width = (n * 3 + n + 1) * scale, height = 5 * scale, values[][] = {{6, 7, 8}, {0, 2, 3, 10, 11, 12, 13}, {1, 6, 8, 13}, {1, 3, 6, 8}, {3, 4, 5, 6, 8, 9}, {3, 6, 8, 11}, {6, 8, 11}, {1, 2, 3, 4, 6, 7, 8, 9}, {6, 8}, {3, 6, 8}};
        BufferedImage output, temp = new BufferedImage(width, height, 1);
        Graphics g = temp.getGraphics();
        g.setColor(Color.WHITE);
        for (; i < n; i++)
            for (j = 0; j < 15; j++) {
                int finalJ = j;
                if (java.util.Arrays.stream(values[v[0].charAt(i) - 48]).noneMatch(e -> e == finalJ))
                    g.fillRect((1 + i * 4 + j / 5) * scale, j % 5 * scale, scale, scale);
            }
        output = new BufferedImage(temp.getColorModel(), temp.copyData(null), 0 > 1, null);
        for (i = 1; i < height - 1; i++)
            for (j = 1; j < width - 1; j++)
                if ((temp.getRGB(j + 1, i) | temp.getRGB(j - 1, i) | temp.getRGB(j, i + 1) | temp.getRGB(j, i - 1)) < -1)
                    output.setRGB(j, i, -1);
        javax.imageio.ImageIO.write(output, "png", new java.io.File("a.png"));
    }
}

Remarques

  • L'entrée est une seule chaîne comme argument. Comment utiliser: javac G.java,java G 80085

  • Je commence avec une toile noire, puis j'ajoute les nombres en tant que positifs blancs. Je crée une copie de l'image puis retourne chaque pixel noir qui a 4 voisins noirs sur l'image d'origine.

Les sorties

0 1 2 3 4 5 6 7 8 9

Quelques chiffres simples:

entrez la description de l'image ici entrez la description de l'image ici

Marv
la source
java.awt. * ne contient pas java.awt.image.BufferedImage?
Element118
@ Element118 ce n'est pas le cas.
Marv
2

R, trop d'octets pour le golf ( 1530+ 1115)

library(reshape2);library(ggplot2);library(png)
M=matrix(1,5,3)
M=lapply(list(c(7:9),c(1,3,4,11:14),c(2,7,9,14),c(2,4,7,9),c(4:7,9,10),c(4,7,9,12),c(7,9,12),c(2:5,7:10),c(7,9),c(4,7,9)),function(x){M[x]=0;M})
g=function(P){
S=matrix(0,5,1)
R=NULL
for(N in P){R=Reduce(cbind2,list(R,S,M[[N+1]]))}
cbind(R,S)}
p=function(P){
o=t(apply(g(P),1,rev))
ggplot(melt(o),aes(x=Var1,y=Var2))+geom_raster(aes(fill=value))+coord_flip()+scale_fill_continuous(guide=FALSE,high="#FFFFFF",low="#000000")+scale_y_reverse()+scale_x_reverse()+theme_bw()+theme(panel.grid=element_blank(),panel.border=element_blank(),panel.background=element_blank(),axis.title=element_blank(),axis.text=element_blank(),axis.ticks=element_blank(),plot.margin=unit(c(0,0,0,0),"mm"))+ggsave("t.png",width=dim(o)[2]/2.5,height=2,units="in",dpi=99)
q=readPNG("t.png")
k=q[,,1]
b=replace(k,k==1,0)
for(i in 1:nrow(k)){
for(j in 1:ncol(k)){
u=(i==nrow(k))
v=(j==ncol(k))
if(u&v){b[i,j]=1;break}
if((i==1)|u|(j==1)|v){b[i,j]=1;next}else{if(all(k[c((i-1):(i+1)),c((j-1):(j+1))])){b[i,j]=1}else{b[i,j]=0}}}}
q[,,1:3]=abs(replace(k,b==1,0)-1)
writePNG(q,"t.png")}

# run p(c(0,1,2,3,4,5))

entrez la description de l'image ici entrez la description de l'image ici entrez la description de l'image ici entrez la description de l'image ici entrez la description de l'image ici entrez la description de l'image ici entrez la description de l'image ici entrez la description de l'image ici entrez la description de l'image ici entrez la description de l'image ici

lol à l'écriture sur le disque, puis à la lecture du disque, modifiez le remplissage noir.

Vlo
la source
2

Python 3, 326 325 octets

import numpy
from skimage import io,transform as t,filters as f
r=[[1]*5,[0]*5]
for c in map(int,input()):r+=[map(float,bin(0x3f1fa7e1bd7b5aff84ff6b7fd6f087ff5ff6bf)[2:][15*c+5*i:15*c+5*-~i])for i in[0,1,2]]+[[0]*5]
r+=[[1]*5]
p=[[1]*len(r)]
r=p+list(zip(*r))+p
io.imsave("o.png",1-f.sobel((t.rescale(numpy.array(r),16,0))))
orlp
la source
2
J'allais commenter cela sur l'une de vos autres réponses l'autre jour, mais cela range(3)n'en vaut jamais la peine.
Sp3000
1

C #, 768 773 776 octets

namespace System.Drawing{class P{static void Main(string[]a){uint[]l={0xEBFBFFFC,0xB89B21B4,0xABFFF9FC,0xAA1269A4,0xFFF3F9FC};var w=a[0].Length*80+20;var b=new Bitmap(w,100);var g=Graphics.FromImage(b);g.FillRectangle(Brushes.Black,0,0,w,100);for(int i=0;i<a[0].Length;i++)for(int r=0;r<5;r++)for(int c=0;c<3;c++)if((l[r]&((uint)1<<(175-a[0][i]*3-c)))>0)g.FillRectangle(Brushes.White,20*(1+i*4+c),20*r,20,20);for(int x=1;x<w-1;x++)for(int y=1;y<99;y++)if(b.GetPixel(x,y).B+b.GetPixel(x+1,y).B+b.GetPixel(x,y+1).B+b.GetPixel(x,y-1).B+b.GetPixel(x+1,y-1).B+b.GetPixel(x+1,y+1).B+b.GetPixel(x-1,y+1).B+b.GetPixel(x-1,y-1).B==0)b.SetPixel(x,y,Color.Red);for(int x=1;x<w-1;x++)for(int y=1;y<99;y++)if(b.GetPixel(x,y).R>0)b.SetPixel(x,y,Color.White);b.Save(a[0]+".bmp");}}}

Prend le nombre comme argument de ligne de commande. Génère une image BMP agréable, propre et sans alias avec le numéro comme nom.

Original avant de jouer au golf:

namespace System.Drawing
{
    class P
    {
        static void Main(string[] args)
        {
            var numbers = args[0];
            uint[] lines = {
                0xEBFBFFFC, // 111 010 111 111 101 111 111 111 111 111 00
                0xB89B21B4, // 101 110 001 001 101 100 100 001 101 101 00
                0xABFFF9FC, // 101 010 111 111 111 111 111 001 111 111 00
                0xAA1269A4, // 101 010 100 001 001 001 101 001 101 001 00
                0xFFF3F9FC  // 111 111 111 111 001 111 111 001 111 111 00
            };
            var width = numbers.Length*4 + 1;
            var bmp = new Bitmap(width*20, 5*20);
            using (var gfx = Graphics.FromImage(bmp))
            {
                gfx.FillRectangle(Brushes.Black, 0, 0, width*20+2, 5*20+2);
                // Process all numbers
                for (int i = 0; i < numbers.Length; i++)
                {
                    var number = numbers[i]-'0';
                    for (int line = 0; line < 5; line++)
                    {
                        for (int col = 0; col < 3; col++)
                        {
                            if ((lines[line] & ((uint)1<<(31-number*3-col))) >0)
                                gfx.FillRectangle(Brushes.White, 20*(1 + i * 4 + col), 20*line, 20 , 20 );
                        }
                    }
                }
                // Edge detection
                for (int x = 1; x < width*20-1; x++)
                {
                    for (int y = 1; y < 5*20-1 ; y++)
                    {
                        if (bmp.GetPixel(x,y).B +
                            bmp.GetPixel(x + 1, y).B +
                                bmp.GetPixel(x, y + 1).B +
                                bmp.GetPixel(x, y - 1).B +
                                bmp.GetPixel(x + 1, y - 1).B +
                                bmp.GetPixel(x + 1, y + 1).B + 
                                bmp.GetPixel(x - 1, y + 1).B + 
                                bmp.GetPixel(x - 1, y - 1).B == 0)
                                bmp.SetPixel(x, y, Color.Red);
                    }
                }
                // Convert red to white
                for (int x = 1; x < width * 20 - 1; x++)
                {
                    for (int y = 1; y < 5 * 20 - 1; y++)
                    {
                        if (bmp.GetPixel(x, y).R>0)
                            bmp.SetPixel(x, y, Color.White);
                    }
                }
            }
            bmp.Save(@"c:\tmp\test.bmp");
        }
    }
}
Thomas Weller
la source
1

Mathematica 328 octets

j@d_:=Partition[IntegerDigits[FromDigits[d/.Thread[ToString/@Range[0,9]->StringPartition["75557262277174771717557117471774757711117575775717",5]],16],2, 20]/.{0->1,1->0},4];j@"*"=Array[{1}&,5];
w@s_:=  ColorNegate@EdgeDetect@Rasterize@ArrayPlot[Thread[Join@@Transpose/@j/@Characters@(s<>"*")],Frame->False,ImageSize->Large]

w["07299361548"]
w["19887620534"]

pic


Explication

Quatre bits seront utilisés dans chacune des 5 lignes de cellules pour chaque chiffre d'entrée.

"75557262277174771717557117471774757711117575775717"représente 0 à 9 sous forme de bitmaps.

Les 5 premiers chiffres du grand entier ci-dessus, à savoir 75557indiquent comment chaque ligne du tableau pour zéro doit être affichée. 7représentera {0,1,1,1}, c'est-à-dire un globule blanc, suivi, à sa droite, de 3 globules noirs; l'interligne 0est un espace vide pour séparer les chiffres affichés. 5correspond à {0,1,0,1}, c'est à dire des cellules blanches, noires, blanches, noires.

Ce qui suit produit une liste de règles de remplacement:

Thread[ToString /@ Range[0, 9] -> StringPartition["75557262277174771717557117471774757711117575775717", 5]]

{"0" -> "75557", "1" -> "26227", "2" -> "71747", "3" -> "71717", "4" -> "55711", "5" - > "74717", "6" -> "74757", "7" -> "71111", "8" -> "75757", "9" -> "75717"}

Notez que quand 3est entré, il sera remplacé par 71717 Cette représentation est exprimée en binaire:

p = Partition[IntegerDigits[FromDigits["3" /. {"3" -> "71717"}, 16], 2, 20], 4]

{{0, 1, 1, 1}, {0, 0, 0, 1}, {0, 1, 1, 1}, {0, 0, 0, 1}, {0, 1, 1, 1} }

Son inverse noir-blanc est trouvé en échangeant simplement le 1s et le 0s.

q = p /. {0 -> 1, 1 -> 0}

{{1, 0, 0, 0}, {1, 1, 1, 0}, {1, 0, 0, 0}, {1, 1, 1, 0}, {1, 0, 0, 0} }


Voyons à quoi pet qressemblons lorsqu'ils sont affichés par ArrayPlot:

ArrayPlot[#, Mesh -> True, ImageSize -> Small, PlotLegends -> Automatic] & /@ {p, q}

pis


Cela rejoint simplement les tableaux de zéros et de uns pour chaque chiffre avant de rendre le grand tableau via ArrayPlot. *est défini jcomme l'espace vertical final après le dernier chiffre.

Thread[Join @@ Transpose /@ j /@ Characters@(s <> "*")]
DavidC
la source