Als ich neulich auf quadratischem Papier herumgekritzelt habe, habe ich die oben genannte Negativschrift für Ziffern gefunden. Falls Sie es noch nicht entdeckt haben, ergeben die Zwischenräume zwischen den obigen Formen den goldenen Schnitt 1.618033988749 . In dieser Herausforderung besteht Ihre Aufgabe darin, eine Zahl als Eingabe zu verwenden und genau so zu rendern, wie im obigen Beispiel gezeigt.

So entstehen diese. Alle Zeilen befinden sich in einem regelmäßigen Raster, sodass die einzelnen Ziffern aus einer kleinen Anzahl von Rasterzellen bestehen. Hier sind die Formen der 10 Ziffern (der Dezimalpunkt wird bei dieser Herausforderung ignoriert):

^{Ja, die 7 unterscheidet sich vom Beispiel mit dem goldenen Schnitt oben. Ich habe das irgendwie durcheinander gebracht. Wir werden mit diesem gehen.}

Beachten Sie, dass jede Ziffer fünf Zellen hoch und drei Zellen breit ist. Um eine Zahl zu rendern, können Sie sich vorstellen, alle ihre Ziffern nebeneinander zu platzieren, sodass genau eine leere Spalte zwischen jedem Ziffernpaar vorhanden ist. Zum Beispiel nimmt 319als Eingabe, würden wir schreiben:

Beachten Sie, dass wir eine führende und eine nachfolgende leere Spalte hinzufügen. Nun kehren wir die Zellen um:

Die Ausgabe sollte dann die Grenzen der resultierenden Polygone sein:

Natürlich können Sie das Ergebnis auch auf andere Weise generieren, solange die gerenderte Ausgabe gleich aussieht.

Eingang

• Sie können ein Programm oder eine Funktion schreiben, indem Sie eine Eingabe über STDIN (oder die nächstgelegene Alternative), ein Befehlszeilenargument oder ein Funktionsargument als Zeichenfolge oder eine Ziffernliste vornehmen. (Sie können keine Zahl verwenden, da Sie damit keine führenden Nullen unterstützen können.)
• Sie können davon ausgehen, dass die Eingabe keine weiteren 16 Stellen enthält.

Ausgabe

• Die Ausgabe kann entweder auf dem Bildschirm angezeigt oder in einem gemeinsamen Bildformat in eine Datei geschrieben werden.
• Sie können sowohl Raster- als auch Vektorgrafiken verwenden.
• In beiden Fällen muss das Seitenverhältnis der Zellen des zugrunde liegenden Rasters 1 sein (dh die Zellen sollten Quadrate sein).
• Bei Raster-Grafiken sollte jede Zelle mindestens 20 x 20 Pixel umfassen.
• Die Linien dürfen nicht breiter als 10% der Zellengröße sein. Ich bin bereit, aufgrund von Aliasing hier ein oder zwei Pixel Spielraum einzuräumen.
• Linien und Hintergrund können zwei klar unterscheidbare Farben sein, aber die Formen, die durch die Linien erzeugt werden, dürfen nicht ausgefüllt werden (dh die Innenseiten sollten auch die Hintergrundfarbe sein).
• In jedem geschlossenen Regelkreis dürfen keine Lücken vorhanden sein.
• Natürlich muss das gesamte Ergebnis sichtbar sein.

Testfälle

Hier sind 10 Eingänge, die zusammen alle möglichen Paare benachbarter Ziffern sowie jede mögliche führende und nachfolgende Ziffer abdecken:

07299361548
19887620534
21456837709
39284106657
49085527316
59178604432
69471338025
79581224630
89674235011
97518264003

Und hier sind die erwarteten Ergebnisse für diejenigen:

Stellen Sie sicher, dass Ihr Code auch bei einer einzelnen Ziffer funktioniert (ich möchte die erwarteten Ergebnisse hier nicht einschließen, da sie offensichtlich sein sollten und der Testfallabschnitt so aufgebläht ist, wie er ist).

BBC BASIC, 182 ASCII-Zeichen (tokenisierte Dateigröße 175 Byte)

Laden Sie den Interpreter unter http://www.bbcbasic.co.uk/bbcwin/bbcwin.html herunter

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.

Bewertung: Wenn das obige Programm in den Editor eingefügt und ausgeführt wird, erweitert der Editor die abgekürzten Schlüsselwörter auf dem Bildschirm zu vollständigen Schlüsselwörtern, obwohl sie tatsächlich nur 1 Byte nach der Tokenisierung sind. (Beispiel I.= INPUTSpeicherplatz 1 Byte.)

Erläuterung

Ich werde nur erklären, was die VDU-Linie tut: Sie zeichnet einen Rahmen, indem sie die aktuelle Pixelfarbe auf dem Bildschirm bitweise spiegelt. Dies bedeutet, dass (mit ein wenig Sorgfalt mit den Ecken) es möglich ist, einfach eine Zelle nebeneinander zu zeichnen, und die dazwischen liegende Kante sich aufhebt und aufgrund des Doppelziehens verschwindet.

Eine genaue Untersuchung zeigt, dass die oberen rechten und unteren linken Ecken einer Zelle gezeichnet sind, aber die oberen linken und unteren rechten Ecken fehlen ("gerundet"), damit dies funktioniert.

Nachdem die Zelle gezeichnet wurde, wird der Grafikcursor um 32 Pixel nach oben bewegt, um für die nächste zu zeichnende Zelle bereit zu sein.

Der Rest des Programms ist eine ziemlich einfache ASCII-Bitmap-Dekomprimierung. Die Abmessungen der Zelle betragen 64 x 64 Einheiten, um die Kompatibilität mit der Art und Weise, wie die Bitmap dekomprimiert wird, zu gewährleisten. qSteuert die Größe der gezeichneten Zelle: 64 x 64 Einheiten für eine vorhandene Zelle, 0x0 für eine Zelle, die nicht vorhanden ist.

Ungolfed Code

  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

Ausgabe

Die MOVEs bringen die Ausgabe einfach auf die entsprechende Höhe auf dem Bildschirm. BBC basic verwendet in diesem Modus 2 Einheiten = 1 Pixel, sodass die Zellen 32 x 32 Pixel groß sind.

Octave, 233 225 216 213 Bytes

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)

Hier der erste Testfall (von einem verkleinerten Screenshot, der zu meinem Monitor passt =):

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)

Die Eingabe kann beliebig lang sein, wie z '07299361548'

Faltung ist der Schlüssel zum Erfolg.

Javascript ES6, 506 Bytes

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

Es wird davon ausgegangen, dass die Zeichenfläche <body>angehängt werden kann, getestet in Firefox 46.

Beispiellauf (Zuweisen einer anonymen Funktion zu f):

f([1,0,3])

ergibt:

HTML + JavaScript ES6, 352

Testen Sie das folgende Snippet

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

Weniger golfen

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

Java, 768 Bytes

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"));
    }
}

Anmerkungen

• Die Eingabe ist eine einzelne Zeichenfolge als Argument. Wie zu verwenden: javac G.java,java G 80085

• Ich beginne mit einer schwarzen Leinwand und addiere dann die Zahlen als weiße Positive. Ich erstelle eine Kopie des Bildes und drehe dann jedes schwarze Pixel um, das 4 schwarze Nachbarn auf dem Originalbild hat.

Ausgänge

Einige einzelne Ziffern:

R, zu viele Bytes zum Golfen ( 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))

lol beim Schreiben auf die Festplatte, dann das Lesen von der Festplatte entfernt die schwarze Füllung.

Python 3, 326 325 Bytes

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

C #, 768 773 776 Bytes

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");}}}

Nimmt die Nummer als Kommandozeilenargument. Gibt ein nettes, sauberes, nicht verfälschtes BMP-Bild mit der Nummer als Namen aus.

Original vor dem Golfen:

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");
        }
    }
}

Mathematica 328 Bytes

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

Erläuterung

Für jede eingegebene Ziffer werden vier Bits in jeweils fünf Zellenzeilen verwendet.

"75557262277174771717557117471774757711117575775717"repräsentiert 0 bis 9 als Bitmaps.

Die ersten 5 Ziffern der obigen großen Ganzzahl 75557geben an, wie jede Array-Zeile für Null angezeigt werden soll. 7wird {0,1,1,1}eine weiße Zelle darstellen, auf die rechts drei schwarze Zellen folgen; Das führende 0Zeichen ist ein Leerzeichen, um die angezeigten Ziffern zu trennen. 5entspricht {0,1,0,1}, das heißt weißen, schwarzen, weißen, schwarzen Zellen.

Das Folgende erzeugt eine Liste von Ersetzungsregeln:

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}

Beachten Sie, dass bei der 3Eingabe 71717 diese Darstellung durch die folgende Binärdarstellung ersetzt wird:

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

Das Schwarz-Weiß-Inverse wird durch einfaches Austauschen von 1s und 0s gefunden.

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

Mal sehen , was pund qaussehen wie bei der Anzeige von ArrayPlot:

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

Dies verbindet einfach die Arrays von Nullen und Einsen für jede Ziffer, bevor das große Array über gerendert wird ArrayPlot. *ist definiert jals der letzte vertikale Abstand nach der letzten Ziffer.

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