Schreiben Sie ein Programm, das eine nicht leere Zeichenfolge mit den Ziffern 0 bis 9 eingibt und mit Schrägstrichen ( , ) ausgibt , wie sie auf einer Siebensegmentanzeige angezeigt würden ./\

Dies sind die genauen Ziffernformen:

/\  
\ \
 \/

 \
  \


/\
 /
 \/

/\
 /\
  /

 \
\/\

/
\/\
  /

/
\/\
 \/

/\
  \

/\
\/\
 \/

/\
\/\
  /

Wenn eine Ziffer nach der anderen vorkommt, werden sie diagonal nach rechts mit einem diagonalen Abstand dazwischen verkettet. So 203würde zum Beispiel dies werden:

    /\
     /\
  /\  /
  \ \
/\ \/
 / 
 \/

Beachten Sie, dass der 1Charakter den gleichen Platz wie die anderen einnimmt. Die zwei Zeilen von 1befinden sich auf der rechten Seite des Displays, nicht auf der linken.

So 159114würde das werden:

           \
          \/\
         \
          \
       \
        \
    /\
    \/\
  /   /
  \/\
 \  /
  \

Die Ausgabe kann eine beliebige Anzahl und Kombination von führenden / nachfolgenden Zeilen oder Leerzeichen enthalten, sofern sich die Ziffern in der richtigen Position zueinander befinden.

Also für 159114diese wäre auch gültig:

          \        
         \/\     
        \
         \
      \    
       \          
   /\     
   \/\
 /   /
 \/\         
\  /
 \    

Nehmen Sie Eingaben von stdin oder der Befehlszeile entgegen oder schreiben Sie eine Funktion, die eine Zeichenfolge akzeptiert. Drucken Sie das Ergebnis auf stdout oder geben Sie es als Zeichenfolge zurück, wenn Sie eine Funktion schreiben.

Jede nicht-leere Zeichenkette der Ziffern 0 bis 9 sollte funktionieren, einschließlich einstelligen Strings (zB 8) und Zeichenfolge mit führenden Nullen (zB in 007den Nullen haben müssen gedruckt werden).

Der kürzeste Code in Bytes gewinnt.

CJam, 77 71 70 69 63 62 Bytes

r_,5*_Sa*a*\{~"÷Ðëúܾ¿ðÿþ"=i2bS"\/"4*W<+.*3/..e>2fm>2m>}/Wf%N*

Alle Zeichen können ausgedruckt werden, sodass Kopieren und Einfügen problemlos funktionieren sollten.

Probieren Sie es online im CJam-Interpreter aus .

Idee

Wir beginnen damit, die Anzahl der Stellen n in der Eingabe zu untersuchen und ein Quadrat mit Leerzeichen zu verschieben, das groß genug ist, um die Ausgabe abzudecken. In der Implementierung wird dieses Quadrat als zweidimensionales Array von Zeichenfolgen mit einem Zeichen codiert.

Ein Quadrat der Länge 2n + 1 wäre für eine einfache Implementierung genau das Richtige (dh kein umgebendes Leerzeichen), aber wir verwenden ein Quadrat der Länge 5n , um ein paar Bytes zu sparen. Glücklicherweise ist das Umgeben von Leerzeichen erlaubt.

Wenn wir die Zeilen der Darstellung mit sieben Schrägstrichen von 8 umkehren , erhalten wir Folgendes:

 \/
\/\
/\

Die Darstellung aller Ziffern kann als 8-Bit-Ganzzahl codiert werden, wobei das i- ^te Bit 0 ist, wenn das i- ^te Zeichen durch ein Leerzeichen ersetzt werden soll. Für die Ziffern 0 bis 9 sind die sich ergebenden ganzen Zahlen

247 208 235 250 220 190 191 240 255 254

die den folgenden ISO-8559-1-Zeichen entsprechen:

÷Ðëúܾ¿ðÿþ

Für jede Stelle in dem Eingang nach dem entsprechenden 8-Bit - Integer - Auswahl wiederholen wir die i - ^te Zeichen der Darstellung von 8 genau eine _i - mal, wobei a _i die i - ^te Bit der Ganzzahl. Dadurch wird ein Array von Zeichenfolgen mit einem oder null Zeichen verschoben. Durch Aufteilen dieses Arrays in Abschnitte der Länge 3 erhalten wir ein Array, in dem jedes Element einer Zeile der Darstellung entspricht.

Nun berechnen wir das vektorisierte Maximum der Zeichenfolgen, die das Quadrat darstellen, und der Zeichenfolgen, die die Ziffer darstellen. Die Zeichenfolgen /und \sind größer als die Zeichenfolge  , sodass sie die Leerzeichen im Quadrat ersetzen. Die leere Zeichenfolge ist jedoch kleiner als die Zeichenfolge  , sodass leere Zeichenfolgen in der Stellendarstellung die Leerzeichen im Quadrat beibehalten.

Wir drehen nun die Zeilen und Spalten um zwei Einheiten, um die folgende Zifferndarstellung im richtigen Teil des Quadrats zu platzieren und wiederholen den Vorgang für die verbleibenden Ziffern in der Eingabe.

Schließlich kehren wir jede Zeile um und fügen einen Zeilenumbruch zwischen den einzelnen Zeilen ein.

Code

r_,      e# Read a token from STDIN and push the length of a copy.
5*_      e# Multiply the length by 5 and push a copy.
Sa*      e# Repeat the array [" "] that many times.
a*       e# Repeat the array [[" " ... " "]] that many times.
\{       e# For each character C in the input:
  ~      e#   Push eval(C), i.e., the digit the character represents.

  "÷Ðëúܾ¿ðÿþ"

         e#   Push the encodings of all 10 seven slash representations.

  =      e#   Select the proper one.
  i2b    e#   Push the resulting characters code point in base 2, i.e., its bits.
  S      e#   Push " ".
  "\/"4* e#   Push "\/\/\/\/".
  +W<    e#   Concatenate and eliminate the last character.
  .*     e#   Vectorized repetition.

         e#   For the digit 5, e.g., we have [1 0 1 1 1 1 1 0] and  " \/\/\/\" on
         e#   the stack, so .* yields [" " "" "/" "\" "/" "\" "/" ""].

  3/     e#   Divide the representation into chunks of length 3, i.e., its lines.
  ..e>   e#   Compute the twofold vectorized maximum, as explained above.
  2fm>   e#   Rotate each line to characters to the right.
  2m>    e#   Rotate the lines two units down.
}/
Wf%      e# Reverse each line.
N*       e# Place linefeeds between them.

Die letzten Umdrehungen würden die Ausgabe durcheinander bringen, wenn die Seitenlänge des Quadrats kleiner als 2n + 3 wäre . Da 5n ≥ 2n + 3 für alle positiven ganzen Zahlen n ist , ist das Quadrat groß genug, um dies zu verhindern.

Python 3, 189 183 174 Bytes

s="a%sa"%input()
while s[1:]:b,a,c,d,e,f,g=[c*(ord(n)>>int(s[~(n>"Ͱ")],16)&1)or" "for c,n in zip("\/"*4,"ΟϭŅͭͱͼϻ")];S=len(s)*"  ";print(S+a+b,c+d+"\n"+S+e+f+g);*s,_=s

Die Komprimierung sieht für mich in Ordnung aus, aber ich habe Probleme damit, die sieben Variablen in den Hintergrund zu rücken ...

Glücklicherweise ist die Spezifikation in Bezug auf Whitespace-Regeln ziemlich locker, da es viele führende / nachfolgende Whitespaces gibt.

Erweitert:

s="a%sa"%input()
while s[1:]:
  b,a,c,d,e,f,g=[c*(ord(n)>>int(s[~(n>"Ͱ")],16)&1)or" "
                 for c,n in zip("\/"*4,"ΟϭŅͭͱͼϻ")]
  S=len(s)*"  "
  print(S+a+b,c+d+"\n"+S+e+f+g)
  *s,_=s

Erläuterung

Die durch die Variablen dargestellten Segmentpositionen sind:

    ab               /\
    efg               /\
  ab cd            /\  /
  efg              \ \
ab cd            /\ \/
efg               /
 cd               \/

Jedes Segment wird durch ein einzelnes 2-Byte-Unicode-Zeichen codiert. Codiert beispielsweise ϻdas gSegment wie folgt:

bin(ord("ϻ")) = bin(1019) = "0b1111111011"
                               ^^^^^^^^^^
                               9876543210

Tatsächlich 2ist dies die einzige Ziffer, bei der das untere rechte Segment einer Siebensegmentanzeige nicht verwendet wird.

C 1098 345 323 319 Bytes

Erster zweiter dritter Versuch. Schließlich beschlossen, den Bildschirmpuffer zu löschen, um ein paar Bytes zu sparen. Dieses Programm verwendet einen Ziffernparameter und druckt die Ziffern im 7-Segment-Format.

Erstmaliger Teilnehmer. Nur zum Spaß. Sei sanft.

a[]={100489,2056,98569,67849,2440,67969,100737,2057,100745,67977},i,j,k,n,m;char*c=" /\\";
#define f(q,r) for(q=0;q<(r);q++)
#define P(w) putchar(w)
#define Q(d,i,j) P(c[a[v[1][d]-48]>>(i*3+j)*2&3])
main(w,char**v){f(i,n=strlen(v[1]))f(k,(m=n-i-1)?2:3){f(j,m*2)P(32);f(w,3)Q(m,k,w);if(!k&&i)f(w,2)Q(m+1,2,w+1);P(10);}}

Erweitert, warnfrei:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int a[]={100489,2056,98569,67849,2440,67969,100737,2057,100745,67977};
char *c=" /\\";
#define f(q,r) for(q=0;q<(r);q++)
#define P(w) putchar(w)
#define Q(d,i,j) P(c[a[v[1][d]-48]>>(i*3+j)*2&3])
int main(int w, char **v)
{
    int i,j,k,n,m;
    f(i,n=strlen(v[1])) {
        m=n-i-1;
        f(k,m?2:3) {
            f(j,m*2) P(32);
            f(w,3) Q(m,k,w);
            if (!k&&i) f(w,2) Q(m+1,2,w+1);
            P(10);
        }
    }
}

JavaScript, 192 178 167 162 Bytes

f=x=>{n=b="\n";for(k in x)for(i=0;i<8;)b+=("î\xA0Öô¸|~àþü".charCodeAt(x[k])>>i++&1?i%2?"/":"\\":" ")+(i%3?"":n+"  ".repeat(k));return b.split(n).reverse().join(n)}

Verbrauch: f("1337");kehrt zurück

      /\
        \
    /\   
     /\
  /\  /
   /\
 \  /
  \

Es verwendet die Funktionen von ES6 und weist möglicherweise ein implementierungsabhängiges Verhalten auf, da Semikolons und Klammern weggelassen werden. Dies funktioniert jedoch in Firefox.

Erweitert:

f=x=>
{
    n = b = "\n";

    for (k in x)
        for (i=0; i<8;)
            b += ("î\xA0Öô¸|~àþü".charCodeAt(x[k]) >> i++ & 1? i%2? "/" : "\\" : " ") + (i%3? "" : n+"  ".repeat(k));

    return b.split(n).reverse().join(n)
}

Erläuterung:

list ein Array mit 10 Einzelbytezeichen, die der Form jeder Ziffer entsprechen. Beispielsweise wird die Ziffer 0 durch das Zeichen dargestellt î:

/\        11
\ \  -->  101  --> 11 101 110 = î
 \/       011

Die eingegebenen Zeichen werden als Schlüssel für das Array verwendet, das die Form der Gegenstücke enthält, die Bit für Bit gelesen werden.

Perl - 103 Bytes

#!perl -n
print$i+$%2?U^(u,$i--%2?v9:z)[$i<4+$%2&vec$_,4*$-3-$i,1]:$/.!($i=$--)
while$+=2*y/0-9/wPkz\\>?p~/

Die obigen Angaben enthalten 6 nicht druckbare Zeichen (die Quelle kann bei Ideone heruntergeladen werden ) und entsprechen den folgenden Angaben:

#!perl -n
print$i+$^F%2?U^(u,$i--%2?v9:z)[$i<4+$^F%2&vec$_,4*$^F-3-$i,1]:$/.!($i=$^F--)
while$^F+=2*y/0-9/wPkz\\>?p\177~/

Jedes ^Fkann durch ein Literalzeichen 6 (ACK) und \177durch ein Zeichen 127 (DEL) ersetzt werden.

Der Shebang wird als 1 gezählt, die zweite Newline ist unnötig. Die Eingabe erfolgt aus stdin.

Beispielnutzung

$ echo 0123 | perl seven-slash.pl

      /\
       /\
    /\  /
     /
   \ \/
    \
/\
\ \
 \/

$ echo 456789 | perl seven-slash.pl

          /\
          \/\
        /\  /
        \/\
      /\ \/
        \
    /
    \/\
  /  \/
  \/\
 \  /
\/\

Erläuterung

Die Ausgabe erfolgt byteweise. Jedes Zeichen wird transliteriert und dies wird dann unter Verwendung von als Bit-Array interpretiert vec. Die Bits werden auf folgende Weise gespeichert:

   /\           56 
   \/\          234
 /\ \/   ->   56 01
 \/\          234 
  \/           01

Die Ausgabe wechselt zwischen 3 und 5 Schrägstrichen, sodass Bits 56in 01die nächste Ziffer übergehen. Bit 7wird nicht verwendet.

C #, 360 355 331 Bytes

Hallo, erster Versuch mit Code-Golf. Hoffe, dass dies für einen C # -Eintrag nicht allzu schlecht abschneidet.

string p(string n){var l=new string[n.Length*2+1];var i=l.Length-1;for(;i>0;){var x=@"/\\ \\/ \  \  /\ / \//\ /\ / \\/\  / \/\ // \/\\//\  \  /\\/\\//\\/\ /".Substring((n[0]-48)*7,7);for(var j=i-3;j>=0;){l[j--]+="  ";}l[i--]+=" "+x[5]+x[6];l[i--]+=""+x[2]+x[3]+x[4];l[i]+=""+x[0]+x[1];n=n.Remove(0, 1);}return string.Join("\n",l);}

Verbrauch: p("159114");kehrt zurück

          \
         \/\
        \
         \
      \
       \
   /\
   \/\
 /   /
 \/\
\  /
 \

Erweitert:

string p(string n)
    {
        var l = new string[n.Length * 2 + 1];
        var i = l.Length - 1;
        for (; i > 0; )
        {
            var x = @"/\\ \\/ \  \  /\ / \//\ /\ / \\/\  / \/\ // \/\\//\  \  /\\/\\//\\/\ /".Substring((n[0] - 48) * 7, 7);

            for (var j = i - 3; j >= 0; )
            {
                l[j--] += "  ";
            }
            l[i--] += " " + x[5] + x[6];
            l[i--] += "" + x[2] + x[3] + x[4];
            l[i] += "" + x[0] + x[1];

            n = n.Remove(0, 1);
        }

        return string.Join("\n", l);
    }

Python 2, 317 298 278 273.15

def f(s):
    r=range;n=len(s)*2;l=[[' ']*-~n for x in r(-~n)]
    for x in r(0,n,2):
        for i,[d,y,c]in enumerate(zip('0112012','1021012',r'\\\\///')):l[n-2-x+int(y)][x+int(d)]=[' ',c][('%7s'%(bin(ord('}(7/jO_,\x7fo'[map(int,s)[x/2]])))[2:])[i]=='1']
    for x in l:print''.join(x)

Beim Zählen betrachtete ich 4 Leerzeichen als Tabulatoren.
Unkomprimiert und lesbar:

def f(s):
    r=['1111101','0101000','0110111','0101111','1101010','1001111','1011111','0101100','1111111','1101111']
    ''.join(map(lambda x:chr(eval('0b'+x)),r))
    n=len(s)*2
    l=[[' ']*(n+1) for x in xrange(n+1)]
    shifts=[(0,1,'\\'),(1,0,'\\'),(1,2,'\\'),(2,1,'\\'),(0,0,'/'),(1,1,'/'),(2,2,'/')]
    for x in xrange(0,n,2):
        y=n-2-x
        for i,[dx,dy,c] in enumerate(shifts):
            l[y+dy][x+dx]=c if r[map(int,s)[x/2]][i]=='1' else ' '
    return '\n'.join(''.join(x) for x in l)

KDB (Q), 172 136 Bytes

{d:(9#1 2 0 2)*/:-9#'0b vs'427 136 403 409 184 313 315 392 443 441;
 -1" /\\"{m+(c,/:y),c:(count[m:0 0,x,\:0 0]-3)#0}/[3 3#/:d"J"$'(),x];}

Erläuterung

1) Erstellen Sie eine dKarte mit allen Ziffernformen.

2) Füllen Sie die Matrix mit zusätzlichen Nullen auf und addieren Sie diese. dh "01"

0           0 0 0 2 0   
0           0 0 0 0 2
1 2 0 0 0 + 0 0 0 0 0
2 0 2 0 0   0
0 2 1 0 0   0

3) Verwenden Sie den Index, um mit abzubilden " /\"und zu drucken -1.

Prüfung

q){d:(9#1 2 0 2)*/:-9#'0b vs'427 136 403 409 184 313 315 392 443 441;-1" /\\"{m+(c,/:y),c:(count[m:0 0,x,\:0 0]-3)#0}/[3 3#/:d"J"$'(),x];}"0123456789"
                  /\
                  \/\
                /\  /
                \/\
              /\ \/
                \
            /
            \/\
          /  \/
          \/\
         \  /
        \/\
      /\
       /\
    /\  /
     /
   \ \/
    \
/\
\ \
 \/

Ich bin sicher, das kann kürzer sein !!

Danke @hjk

Pip, 122 + 1 = 123 Bytes

Verwendet die -nFlagge. Übernimmt die Eingabe über das Befehlszeilenargument.

l:$.(J"\/ "@^(A_TB3M"⮐䫶ヷ㄃䓳ⴷⴥㅕ⬿⭑")@_.2<>2Ma)z:2*#ap:sXz+2RLz+2Fi,5Fj,z{c:[4-ii]//2+j(pc@0c@1):(lij)}RVp

Die Zeichen in der UTF-8 - String haben folgende Codepunkte: 11152, 19190, 12535, 12547, 17651, 11575, 11557, 12629, 11071, 11089.

Leicht ungolfed:

t:[120022001 222022202 122012021 122012201 220012202 120212201 120212001 122022202 120012001 120012201]
l:$.({J"\/ "@^[email protected]<>2}Ma)
z:2*#a+2
p:sXzRLz
Fi,5
 Fj,2*#a {
  x:i//2+j
  y:(4-i)//2+j
  p@y@x:l@i@j
 }
P RVp

Die grundlegende Strategie besteht darin, die konstituierenden Zeichen jeder Zahl zu finden und sie dann entsprechend zu verzerren. Zum Beispiel 8wollen wir dies (durch Punkte dargestellte Leerzeichen):

/.
\\
/.
\\
/.

was daraus wird:

 .  
/\. 
\/\.
 \/ 

Das Schöne an dieser Strategie ist, dass mehrere vorversetzte Zahlen einfach nebeneinander verkettet werden können.

Jetzt können wir /.\\/.\\/.in Basis 3 als kodieren 1200120012. Dann können wir dies in eine Dezimalzahl konvertieren und als UTF-8-Codepunkt behandeln.

Der Ausdruck J"\/ "@^(A_TB3M"⮐䫶ヷ㄃䓳ⴷⴥㅕ⬿⭑")@_.2<>2Maerhält die vorversetzten Daten durch den folgenden Prozess:

                            Ma   Map this lambda function to each character in input:
        (A_TB3M"...")            Create list of the code points of each character in UTF-8
                                   string, converted to base 3
                     @_          Index into that list using the input character
                       .2        Concatenate 2 to the end of the base-3 value (all of the
                                   pre-skewed number grids end in 2, i.e. space)
       ^                         Split the number into a list of its digits
 "\/ "@                          Index into this string with those digits, giving a list
                                   of slashes & spaces
J                                Join the list together into a string
                         <>2     Group string two characters at a time

Nachdem wir diese Zeichenfolgen nebeneinander verkettet haben $., erstellen wir ein Gitter mit Leerzeichen (2 * n + 2 Quadrat), durchlaufen das vorversetzte Gitter und ersetzen die entsprechenden Leerzeichen im nachversetzten Gitter durch das entsprechende Zeichen. Um dies zu sehen, können Sie den Code so ändern, dass er jede Stufe druckt und für Benutzereingaben pausiert:

Das Gitter ist tatsächlich verkehrt herum aufgebaut, weil das die Mathematik einfacher zu machen schien.

Ich bin mir sicher, dass es bessere Algorithmen gibt. Aber ich wollte lieber auf meine eigene Idee kommen, als die einer anderen Person zu kopieren.

Mehr zu Pip

Brainfuck - 719 Bytes

Nur für den historischen Kontext, dankt Daniel B Cristofani. Ich bin mir nicht ganz sicher, wann dies erstellt wurde, aber es ist bereits am 9. Mai 2003 im Internetarchiv verfügbar .

Die Ausgabe für 9unterscheidet sich von der Problembeschreibung.

>>>>+>+++>+++>>>>>+++[
  >,+>++++[>++++<-]>[<<[-[->]]>[<]>-]<<[
    >+>+>>+>+[<<<<]<+>>[+<]<[>]>+[[>>>]>>+[<<<<]>-]+<+>>>-[
      <<+[>]>>+<<<+<+<--------[
        <<-<<+[>]>+<<-<<-[
          <<<+<-[>>]<-<-<<<-<----[
            <<<->>>>+<-[
              <<<+[>]>+<<+<-<-[
                <<+<-<+[>>]<+<<<<+<-[
                  <<-[>]>>-<<<-<-<-[
                    <<<+<-[>>]<+<<<+<+<-[
                      <<<<+[>]<-<<-[
                        <<+[>]>>-<<<<-<-[
                          >>>>>+<-<<<+<-[
                            >>+<<-[
                              <<-<-[>]>+<<-<-<-[
                                <<+<+[>]<+<+<-[
                                  >>-<-<-[
                                    <<-[>]<+<++++[<-------->-]++<[
                                      <<+[>]>>-<-<<<<-[
                                        <<-<<->>>>-[
                                          <<<<+[>]>+<<<<-[
                                            <<+<<-[>>]<+<<<<<-[
                                              >>>>-<<<-<-
  ]]]]]]]]]]]]]]]]]]]]]]>[>[[[<<<<]>+>>[>>>>>]<-]<]>>>+>>>>>>>+>]<
]<[-]<<<<<<<++<+++<+++[
  [>]>>>>>>++++++++[<<++++>++++++>-]<-<<[-[<+>>.<-]]<<<<[
    -[-[>+<-]>]>>>>>[.[>]]<<[<+>-]>>>[<<++[<+>--]>>-]
    <<[->+<[<++>-]]<<<[<+>-]<<<<
  ]>>+>>>--[<+>---]<.>>[[-]<<]<
]
[Enter a number using ()-./0123456789abcdef and space, and hit return.
Daniel B Cristofani (cristofdathevanetdotcom)
http://www.hevanet.com/cristofd/brainfuck/]

Perl, 270 Bytes

Ich hätte wirklich nicht meine Zeit damit verschwenden sollen.

$e="\\";$g=" ";$_=reverse<>;$l=length;push@a,(119,18,107,91,30,93,125,19,127,95)[$1]while/(.)/g;for($i=0;$i<=$l;$i++){$j=2*($l-$i);$b=$a[$i];$c=$i&&$a[$i-1];print" "x$j,$b&1?"/":$g,$b&2?$e:$g,$g,$c&32?$e:$g,$c&64?"/":$g,"
"," "x$j,$b&4?$e:$g,$b&8?"/":$g,$b&16?$e:$g,"
"}

JavaScript ( ES6 ), 191 206

Führen Sie zum Testen das Snippet in Firefox aus.

F=m=>(
  a='    \\/  /\\/\\ /  /\\  \\\\ \\'.match(/.../g),
  o=f='',r=' ',
  [for(d of m)(
    n=1e3+'¯B\x91ÿ$ê\x86A\x87ë'.charCodeAt(d)+'', // here there are 3 valid characters tha the evil stackoverflow editor just erase off, so I had to put them as hex escape
    o='\n'+f+' '+a[n[2]]+'\n'+r+a[n[1]]+o,
    r=f+a[n[3]],
    f+='  ')],
  r+o
)


//TEST

go=_=>O.innerHTML =(v=I.value)+'\n'+F(v)

go()

<input id=I value='0123456789'><button onclick='go()'>-></button>
<pre id=O></pre>

Java 8, 341 Bytes

n->{int i=n.length*2,j=i+1,k=0,t;String l[]=new String[j],x;for(;j-->0;l[j]="");for(;i>0;l[i--]+=" "+x.substring(5,7),l[i--]+=x.substring(2,5),l[i]+=x.substring(0,2))for(x="/~~ ~~/ ~  ~  /~ / ~//~ /~ / ~~/~  / ~/~ // ~/~~//~  ~  /~~/~~//~~/~ /".replace('~','\\').substring(t=(n[k++]-48)*7,t+7),j=i-2;j-->0;)l[j]+="  ";return"".join("\n",l);}

Port von @Shions C # .NET-Antwort , also stelle sicher, dass du ihn auch positiv bewertest!

Probieren Sie es online aus.

Erläuterung:

n->{                       // Method with character-array parameter and String return-type
  int i=n.length*2,        //  Two times the length of the input array
      j=i+1,               //  Index integer, starting at `i+1`
      k=0,t;               //  Temp integers
  String l[]=new String[j],//  String-array for the rows, default filled with `null`
         x;                //  Temp-String
  for(;j-->0;l[j]="");     //  Replace all `null` with empty Strings
  for(;i>0                 //  Loop `i` downwards in the range [`n.length*2`, 0)
      ;                    //   After every iteration:
       l[i--]+=            //    Append the row at index `i` with:
                           //    (and decrease `i` by 1 afterwards with `i--`)
         " "               //     A space
         +x.substring(5,7),//     And the 6th and 7th characters of temp-String `x`
       l[i--]+=            //    Append the row at index `i` with:
                           //    (and decrease `i` by 1 afterwards with `i--`)
         x.substring(2,5), //     The 3rd, 4th and 5th characters of temp-String `x`
       l[i]+=              //    Append the row at index `i` with:
         x.substring(0,2)) //     The 1st and 2nd characters of the temp-String `x`
    for(x="/~~ ~~/ ~  ~  /~ / ~//~ /~ / ~~/~  / ~/~ // ~/~~//~  ~  /~~/~~//~~/~ /".replace('~','\\')
                           //   String containing all digit-parts
          .substring(t=(n[k++]-48)*7,t+7),
                           //   and take the substring of 7 characters at index
                           //   `n[k]` as integer multiplied by 7
        j=i-2;j-->0;)      //   Inner loop `j` in the range (`i`-2, 0]
      l[j]+="  ";          //    And append the rows at index `j` with two spaces
  return"".join("\n",l);}  //  Return the rows delimited with new-lines