Tulis program yang menggunakan string non-kosong dari digit 0 hingga 9 dan cetak bagaimana mereka akan ditampilkan pada layar tujuh segmen menggunakan garis miring ( /, \).

Ini adalah bentuk digit yang tepat:

/\  
\ \
 \/

 \
  \


/\
 /
 \/

/\
 /\
  /

 \
\/\

/
\/\
  /

/
\/\
 \/

/\
  \

/\
\/\
 \/

/\
\/\
  /

Ketika satu digit terjadi berurutan, mereka dirantai secara diagonal ke atas dan ke kanan, dengan ruang diagonal di antaranya. Jadi, misalnya, 203akan menjadi ini:

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

Perhatikan bahwa 1karakter membutuhkan jumlah ruang yang sama dengan yang lain. Dua garis 1berada di sisi kanan layar, bukan di kiri.

Jadi 159114akan menjadi ini:

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

Mungkin ada jumlah dan kombinasi baris baru atau spasi di dalam output selama digit berada di posisi yang benar sehubungan satu sama lain.

Jadi untuk 159114, ini juga berlaku:

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

Ambil input dari stdin atau baris perintah, atau tulis fungsi yang mengambil string. Cetak hasilnya ke stdout atau Anda dapat mengembalikannya sebagai string jika Anda menulis suatu fungsi.

Setiap string yang tidak kosong dari angka 0 sampai 9 harus bekerja, termasuk string digit tunggal (misalnya 8) dan string dengan nol terkemuka (misalnya dalam 007, nol jangan perlu dicetak).

Kode terpendek dalam byte menang.

CJam, 77 71 70 69 63 62 byte

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

Semua karakter dapat dicetak, jadi salin dan tempel harus berfungsi dengan baik.

Cobalah online di juru bahasa CJam .

Ide

Kami mulai dengan memeriksa jumlah digit n dalam input dan mendorong kuadrat ruang yang cukup besar untuk menutupi output. Dalam implementasinya, kuadrat ini akan dikodekan sebagai array dua dimensi string satu karakter.

Kuadrat panjang 2n +1 akan tepat (yaitu, tidak ada spasi putih di sekitarnya) untuk implementasi langsung, tetapi kami akan menggunakan salah satu dari panjang 5n untuk menyimpan beberapa byte. Untungnya, ruang putih di sekitarnya diizinkan.

Jika kita membalikkan garis tujuh representasi garis miring 8 , kita memperoleh yang berikut:

 \/
\/\
/\

Representasi semua digit dapat dikodekan sebagai bilangan bulat 8-bit, di mana bit ^ke - 0 adalah jika karakter ^ke- i harus diganti dengan spasi. Untuk digit 0 hingga 9 , bilangan bulat yang dihasilkan adalah

247 208 235 250 220 190 191 240 255 254

yang sesuai dengan karakter ISO-8559-1 berikut:

÷Ðëúܾ¿ðÿþ

Untuk setiap digit pada input, setelah memilih 8-bit integer yang sesuai, kita ulangi i ^th karakter representasi 8 tepatnya sebuah _i kali, di mana sebuah _i adalah i ^th bit dari integer. Ini mendorong array string baik karakter satu atau nol. Dengan membagi array ini menjadi potongan-potongan dengan panjang 3, kita mendapatkan sebuah array di mana setiap elemen sesuai dengan garis representasi.

Sekarang, kita menghitung maksimum dari string yang mewakili kuadrat dan string yang mewakili digit. String /dan \lebih besar dari string  , sehingga mereka akan mengganti spasi di dalam kotak. String kosong, bagaimanapun, lebih kecil dari string  , jadi string kosong dalam representasi digit akan mempertahankan spasi di kotak.

Kami sekarang memutar baris dan kolom dengan dua unit untuk menempatkan representasi digit berikut di bagian yang tepat dari kuadrat dan mengulangi proses untuk digit yang tersisa di input.

Akhirnya, kami membalikkan setiap baris dan menyisipkan umpan baris di antara masing-masing baris.

Kode

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.

Rotasi terakhir akan mengacaukan output jika panjang sisi persegi lebih kecil dari 2n + 3 . Karena 5n ≥ 2n + 3 untuk semua bilangan bulat positif n , kuadratnya cukup besar untuk mencegah hal ini.

Python 3, 189 183 174 byte

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

Kompresinya terlihat oke bagi saya, tapi saya mengalami masalah dengan cara yang baik untuk membuang tujuh variabel ...

Syukurlah spek ini cukup santai pada aturan spasi putih, karena ada banyak spasi putih terkemuka / tertinggal.

Diperluas:

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

Penjelasan

Posisi segmen yang diwakili oleh variabel adalah:

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

Setiap segmen dikodekan oleh karakter Unicode 2-byte tunggal. Misalnya, ϻmengkodekan g's segmen seperti:

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

Memang, 2adalah satu-satunya digit untuk tidak menggunakan segmen kanan bawah dari tampilan tujuh segmen.

C, 1098 345 323 319 byte

Pertama Kedua Ketiga upaya. Akhirnya memutuskan untuk membuang buffer layar untuk menyimpan beberapa byte. Program ini mengambil parameter digit dan mencetak digit dalam format 7-segmen.

Peserta pertama kali. Hanya untuk bersenang-senang. Bersikaplah lembut.

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

Diperluas, bebas peringatan:

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

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

Penggunaan: f("1337");akan kembali

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

Ini menggunakan fitur ES6 dan mungkin memiliki beberapa perilaku tergantung implementasi karena kelalaian titik koma dan tanda kurung dan semacamnya, tetapi ia bekerja di Firefox.

Diperluas:

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

Penjelasan:

ladalah array yang berisi 10 karakter byte tunggal yang sesuai dengan bentuk setiap digit. Misalnya, angka 0 diwakili oleh karakter î:

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

Karakter input digunakan sebagai kunci pada array yang menahan bentuknya mewakili rekan, yang dibaca sedikit demi sedikit.

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

Di atas berisi 6 karakter yang tidak patut dicetak (sumbernya dapat diunduh di Ideone ), dan setara dengan yang berikut:

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

Masing ^F- masing dapat digantikan oleh karakter literal 6 (ACK), dan \177digantikan oleh karakter 127 (DEL).

Shebang dihitung sebagai 1, baris baru kedua tidak perlu. Input diambil dari stdin.

Contoh Penggunaan

$ echo 0123 | perl seven-slash.pl

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

$ echo 456789 | perl seven-slash.pl

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

Penjelasan

Output dihasilkan satu byte pada suatu waktu. Setiap karakter ditransliterasikan, dan ini kemudian ditafsirkan sebagai menggunakan bit array vec. Bit disimpan dengan cara berikut:

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

Output bergantian antara 3 dan 5 garis miring, sehingga bit 56melimpah ke 01digit berikutnya. Bit 7tidak digunakan.

C #, 360 355 331 byte

Halo, upaya pertama di kode-golf. Semoga ini tidak skor terlalu buruk untuk masuk 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);}

Penggunaan: p("159114");akan kembali

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

Diperluas:

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)

Saya menganggap 4 spasi sebagai tab saat menghitung.
Tidak terkompresi dan mudah dibaca:

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 byte

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

Penjelasan

1) Buat dpeta dengan semua bentuk digit.

2) Pad matriks dengan nol tambahan dan tambahkan bersama-sama. yaitu "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) Gunakan indeks untuk memetakan " /\"dan mencetak -1.

Uji

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

Saya yakin ini bisa lebih pendek !!

Terima kasih @ hjk

Pip, 122 + 1 = 123 byte

Menggunakan -nbendera. Mengambil input melalui argumen baris perintah.

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

Karakter dalam UTF-8 string memiliki poin kode berikut: 11152, 19190, 12535, 12547, 17651, 11575, 11557, 12629, 11071, 11089.

Sedikit tidak berbulu:

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

Strategi dasarnya adalah menemukan karakter penyusun angka masing-masing dan kemudian condongkannya dengan tepat. Misalnya, untuk 8, kami menginginkan ini (spasi diwakili oleh titik-titik):

/.
\\
/.
\\
/.

yang akan berubah menjadi ini:

 .  
/\. 
\/\.
 \/ 

Fitur bagus dari strategi ini adalah bahwa beberapa angka pra-kemiringan dapat disatukan.

Sekarang, kita dapat mengkodekan /.\\/.\\/.dalam basis 3 sebagai 1200120012. Kemudian kita dapat mengonversi ini menjadi desimal dan memperlakukannya sebagai titik kode UTF-8.

Ekspresi J"\/ "@^(A_TB3M"⮐䫶ヷ㄃䓳ⴷⴥㅕ⬿⭑")@_.2<>2Mamendapatkan data pra-miring dengan proses berikut:

                            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

Setelah kami menggabungkan string-string ini berdampingan menggunakan $., kami kemudian membuat grid spasi (2 * n +2 persegi), loop melalui grid pre-skewed, dan mengganti spasi yang sesuai di grid post-skewed dengan karakter yang sesuai. Untuk melihatnya terjadi, seseorang dapat memodifikasi kode untuk mencetak setiap tahap dan berhenti untuk input pengguna:

Grid sebenarnya dibangun terbalik, karena itu membuat matematika lebih mudah.

Saya yakin ada algoritma yang lebih baik untuk digunakan. Tapi saya ingin memunculkan ide saya sendiri daripada menyalin ide orang lain.

Lebih lanjut tentang Pip

Brainfuck - 719 byte

Hanya untuk konteks historis, kredit untuk Daniel B Cristofani. Saya tidak yakin kapan ini dibuat, tetapi tersedia dari Internet Archive pada 9 Mei 2003.

Output untuk 9berbeda dari deskripsi masalah.

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

Perl, 270 byte

Aku seharusnya tidak membuang-buang waktu untuk hal ini.

$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

Jalankan cuplikan di Firefox untuk menguji.

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 byte

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 dari @Shion 's C # .NET jawaban , jadi pastikan untuk mengunggahnya juga!

Cobalah online.

Penjelasan:

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