Napisz program, który pobiera niepusty ciąg cyfr od 0 do 9 i drukuje, jak będą wyświetlane na siedmiosegmentowym wyświetlaczu za pomocą ukośników ( /, \).

Są to dokładne kształty cyfr:

/\  
\ \
 \/

 \
  \


/\
 /
 \/

/\
 /\
  /

 \
\/\

/
\/\
  /

/
\/\
 \/

/\
  \

/\
\/\
 \/

/\
\/\
  /

Kiedy jedna cyfra występuje po drugiej, są one powiązane łańcuchem po przekątnej w górę i w prawo, z odstępem po przekątnej między nimi. Na przykład 203stałoby się tak:

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

Zauważ, że 1postać zajmuje tyle samo miejsca co pozostałe. Dwie linie 1znajdują się po prawej stronie wyświetlacza, a nie po lewej stronie.

Stałoby 159114się tak:

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

Na wyjściu może znajdować się dowolna ilość i kombinacja wiodących / końcowych znaków nowej linii lub spacji, o ile cyfry znajdują się we właściwej pozycji względem siebie.

Tak więc 159114, byłoby to również ważne:

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

Pobierz dane wejściowe ze standardowego wiersza poleceń lub wiersza poleceń albo napisz funkcję, która pobiera ciąg znaków. Wydrukuj wynik na standardowe wyjście lub możesz zwrócić jako ciąg, jeśli napiszesz funkcję.

Dowolny niepusty ciąg cyfr od 0 do 9 powinna działać, w tym pojedynczych cyfr (np strun 8) i smyczki z wiodącymi zerami (np 007, zera nie muszą być drukowane).

Najkrótszy kod w bajtach wygrywa.

CJam, 77 71 70 69 63 62 bajtów

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

Wszystkie znaki można drukować, więc kopiowanie i wklejanie powinno działać dobrze.

Wypróbuj online w interpretatorze CJam .

Pomysł

Zaczynamy od zbadania liczby cyfr n na wejściu i przesunięcia kwadratu spacji wystarczająco dużego, aby pokryć wynik. W realizacji ten kwadrat zostanie zakodowany jako dwuwymiarowa tablica ciągów jednoznakowych.

Kwadrat o długości 2n + 1 byłby w sam raz (tj. Bez otaczających białych znaków) dla prostej implementacji, ale użyjemy jednego o długości 5n, aby zaoszczędzić kilka bajtów. Na szczęście otaczające spacje są dozwolone.

Jeśli odwrócimy linie reprezentacji siedmiu ukośników 8 , otrzymamy:

 \/
\/\
/\

Reprezentacja wszystkich cyfr może być zakodowana jako 8-bitowa liczba całkowita, przy czym i- ^ty bit ma wartość 0, a i- ^ty znak należy zastąpić spacją. Dla cyfr od 0 do 9 wynikowe liczby całkowite to

247 208 235 250 220 190 191 240 255 254

które odpowiadają następującym znakom ISO-8559-1:

÷Ðëúܾ¿ðÿþ

Dla każdej cyfry w wejściu, po wybraniu odpowiedniej 8-bitową liczbę całkowitą, powtarzamy I ^th charakteru reprezentacji 8 dokładnie ciągu _í czasach, gdzie _ja Czy I ^th bitu liczby całkowitej. To popycha tablicę ciągów jednego lub zera znaków. Dzieląc tę ​​tablicę na części o długości 3, otrzymujemy tablicę, w której każdy element odpowiada linii reprezentacji.

Teraz obliczamy wektoryzowane maksimum łańcuchów reprezentujących kwadrat i łańcuchów reprezentujących cyfrę. Ciągi /i \są większe niż ciąg  , więc zastąpią spacje w kwadracie. Pusty ciąg jest jednak mniejszy niż ciąg  , więc puste ciągi w reprezentacji cyfrowej zachowają spacje w kwadracie.

Obracamy teraz wiersze i kolumny o dwie jednostki, aby umieścić następującą cyfrę w odpowiedniej części kwadratu i powtórzyć proces dla pozostałych cyfr na wejściu.

Na koniec odwracamy każdy wiersz i wstawiamy linię między poszczególnymi wierszami.

Kod

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.

Ostatnie obroty zakłóciłyby wynik, gdyby długość boku kwadratu była mniejsza niż 2n + 3 . Ponieważ 5n ≥ 2n + 3 dla wszystkich dodatnich liczb całkowitych n , kwadrat jest wystarczająco duży, aby temu zapobiec.

Python 3, 189 183 174 bajtów

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

Kompresja wygląda dla mnie dobrze, ale mam problem z wymyśleniem dobrego sposobu wyrzucenia siedmiu zmiennych ...

Na szczęście specyfikacja jest dość luźna w regułach białych znaków, ponieważ istnieje wiele wiodących / końcowych białych znaków.

Rozszerzony:

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

Wyjaśnienie

Pozycje segmentu reprezentowane przez zmienne to:

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

Każdy segment jest kodowany przez pojedynczy 2-bajtowy znak Unicode. Na przykład ϻkoduje gsegment w taki sposób:

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

Rzeczywiście, 2jest to jedyna cyfra, która nie używa prawego dolnego segmentu siedmiosegmentowego wyświetlacza.

C, 1098 345 323 319 bajtów

Pierwsza druga trzecia próba. W końcu postanowiłem porzucić bufor ekranu, aby zaoszczędzić kilka bajtów. Ten program pobiera parametr cyfr i drukuje cyfry w formacie 7-segmentowym.

Uczestnik po raz pierwszy. Dla żartu. Bądź delikatny.

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

Rozszerzony, bez ostrzeżeń:

#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 bajtów

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

Zastosowanie: f("1337");powróci

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

Wykorzystuje funkcje ES6 i może zachowywać się zależnie od implementacji z powodu pominięcia średników i nawiasów, ale działa w przeglądarce Firefox.

Rozszerzony:

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

Wyjaśnienie:

lto tablica zawierająca 10 jednobajtowych znaków, które odpowiadają kształtowi każdej cyfry. Na przykład cyfra 0 jest reprezentowana przez znak î:

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

Znaki wejściowe są używane jako klucze do tablicy o kształcie odpowiadającym odpowiednikom, które są odczytywane krok po kroku.

Perl - 103 bajtów

#!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~/

Powyższe zawiera 6 niedrukowalnych znaków (źródło można pobrać z Ideone ) i jest równoważne z następującymi:

#!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~/

Każdy ^Fmoże być zastąpiony literalnym znakiem 6 (ACK) i \177zastąpiony znakiem 127 (DEL).

Shebang jest liczony jako 1, druga nowa linia jest niepotrzebna. Dane wejściowe są pobierane ze standardowego wejścia.

Przykładowe użycie

$ echo 0123 | perl seven-slash.pl

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

$ echo 456789 | perl seven-slash.pl

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

Wyjaśnienie

Dane wyjściowe są generowane jeden bajt na raz. Każdy znak jest transliterowany, a następnie interpretowany jako tablica bitów przy użyciu vec. Bity są przechowywane w następujący sposób:

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

Wyjście zmienia się między 3 a 5 ukośnikami, tak że bity 56przenoszą się 01na następną cyfrę. Bit 7nie jest używany.

C #, 360 355 331 bajtów

Cześć, pierwsza próba golfa kodowego. Mam nadzieję, że nie osiąga to zbyt słabego wyniku dla wpisu C #.

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

Zastosowanie: p("159114");powróci

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

Rozszerzony:

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)

Podczas liczenia rozważałem 4 spacje jako tabulatory.
Nieskompresowane i czytelne:

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 bajtów

{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];}

Wyjaśnienie

1) Utwórz dmapę ze wszystkimi kształtami cyfr.

2) Wypełnij matrycę dodatkowymi zerami i dodaj je razem. tzn. „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) Użyj indeksu do mapowania " /\"i drukowania -1.

Test

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

Jestem pewien, że może to być krótsze !!

Dzięki @hjk

Pip, 122 + 1 = 123 bajty

Używa -nflagi. Pobiera dane wejściowe za pomocą argumentu wiersza polecenia.

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

Znaki w ciągu UTF-8 mają następujące punkty kodowe: 11152, 19190, 12535, 12547, 17651, 11575, 11557, 12629, 11071, 11089.

Nieznacznie nie golfista:

t:[120022001 222022202 122012021 122012201 220012202 120212201 120212001 122022202 120012001 120012201]
l:$.({J"\/ "@^t@a.2<>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

Podstawową strategią jest znalezienie znaków składających się na poszczególne liczby, a następnie odpowiednie ich przekrzywienie. Na przykład, 8chcemy, aby to (spacje reprezentowane przez kropki):

/.
\\
/.
\\
/.

co zamieni się w to:

 .  
/\. 
\/\.
 \/ 

Zaletą tej strategii jest to, że wiele wstępnie wypaczonych liczb można po prostu połączyć obok siebie.

Teraz możemy zakodować /.\\/.\\/.w bazie 3 jako 1200120012. Następnie możemy przekonwertować to na dziesiętne i potraktować jako punkt kodowy UTF-8.

Wyrażenie J"\/ "@^(A_TB3M"⮐䫶ヷ㄃䓳ⴷⴥㅕ⬿⭑")@_.2<>2Mapobiera wstępnie wypaczone dane w następujący sposób:

                            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

Po połączeniu tych ciągów obok siebie $., tworzymy siatkę spacji (2 * n +2 kwadrat), zapętlamy wstępnie skośną siatkę i zastępujemy odpowiednie spacje w skośnej siatce odpowiednie postacie. Aby zobaczyć, jak to się dzieje, można zmodyfikować kod w celu wydrukowania każdego etapu i wstrzymać wprowadzanie przez użytkownika:

Siatka jest faktycznie zbudowana do góry nogami, ponieważ wydawało się to ułatwiać matematykę.

Jestem pewien, że są lepsze algorytmy do użycia. Ale chciałem wymyślić własny pomysł, niż kopiować czyjś pomysł.

Więcej na Pip

Brainfuck - 719 bajtów

Tylko w kontekście historycznym, przypisy Danielowi Cristofani. Nie jestem do końca pewien, kiedy to zostało utworzone, ale jest ono dostępne z Archiwum Internetowego już 9 maja 2003.

Wynik działania 9jest inny niż w opisie problemu.

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

Perl, 270 bajtów

Naprawdę nie powinienem tracić na to czasu.

$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

Uruchom snippet w przeglądarce Firefox, aby przetestować.

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 bajtów

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 @Shion „s C # .NET odpowiedzi , więc upewnij się upvote go tak dobrze!

Wypróbuj online.

Wyjaśnienie:

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