0'dan 9'a kadar olan rakamların boş olmayan bir dizgisine giren ve eğik çizgiler ( , ) kullanarak yedi bölümlü bir ekranda nasıl görüneceklerini yazdıran bir program yazın ./\

Bunlar kesin rakamlardır:

/\  
\ \
 \/

 \
  \


/\
 /
 \/

/\
 /\
  /

 \
\/\

/
\/\
  /

/
\/\
 \/

/\
  \

/\
\/\
 \/

/\
\/\
  /

Bir basamak birbiri ardına ortaya çıktığında, aralarında çapraz boşluk olacak şekilde çapraz olarak yukarı ve sağa doğru zincirlenirler. Yani, örneğin, 203bu olur:

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

1Karakterin, diğerleriyle aynı miktarda yer tuttuğunu unutmayın . İki satırı 1solda değil ekranın sağ tarafındadır.

Böylece 159114bu olur:

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

Rakamlar birbirine göre doğru konumda olduğu sürece, çıkıştaki / izleyen yeni satırların veya boşlukların herhangi bir miktarı ve kombinasyonu olabilir.

Yani 159114, bu da geçerli olacaktır:

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

Stdin'den veya komut satırından girdi alın veya bir dizgede geçen bir işlevi yazın. Sonucu stdout'a yazdırın ya da bir işlev yazarsanız dizge olarak geri döndürebilirsiniz.

9 arasındaki basamağı 0 herhangi bir boş olmayan bir dize tek basamaklı dizeleri (örneğin dahil çalışması gerekir 8) ve sıfır dolgulu dizeleri (örn 007, sıfırlar yok basılacak gerekir).

Bayt cinsinden en kısa kod kazanır.

CJam, 77 71 70 69 63 62 bayt

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

Tüm karakterler basılabilirdir, bu nedenle kopyala ve yapıştır işleminin iyi çalışması gerekir.

CJam tercümanında çevrimiçi olarak deneyin .

Fikir

Girişteki n rakamlarını inceleyerek ve çıktıyı kaplayacak kadar büyük bir boşluk karesini iterek başlıyoruz . Uygulamada, bu kare iki boyutlu bir karakter karakter dizisi olarak kodlanacaktır.

Basit bir uygulama için 2n + 1 uzunluğunda bir kare doğru olacaktır (yani çevreleyen beyaz alan yoktur), ancak birkaç bayttan tasarruf etmek için 5n uzunluğundan birini kullanacağız . Neyse ki, çevreleyen boşluklara izin verilir.

8'in yedi eğik çizgi temsilinin satırlarını tersine çevirirsek , aşağıdakileri elde ederiz:

 \/
\/\
/\

Tüm rakam temsili I, 8-bitlik bir tamsayı olarak kodlanabilir ^inci bit 0 ı IFF ^inci karakter bir boşluk ile yerini almak gerekir. 0 - 9 arasındaki rakamlar için

247 208 235 250 220 190 191 240 255 254

aşağıdaki ISO-8559-1 karakterlerine karşılık gelir:

÷Ðëúܾ¿ðÿþ

Giriş, her basamak için, karşılık gelen 8-bit tam sayı seçtikten sonra, biz i tekrar ^inci temsilinin karakter 8 tam bir _ı kez, bir _i i ^inci tam sayı bit. Bu, bir veya sıfır karakterden oluşan bir dizi dizisini iter. Bu diziyi 3 uzunluktaki parçalara bölerek, her bir öğenin temsil çizgisine karşılık geldiği bir dizi elde ederiz.

Şimdi, kareyi temsil eden dizgelerin vectorized maksimumunu ve rakamı temsil eden dizgileri hesaplıyoruz. Dizeler /ve \dizgiden daha büyük  , bu nedenle karedeki boşlukları değiştirecekler. Bununla birlikte, boş dize, dizeden daha küçüktür  , bu nedenle basamak temsilindeki boş dizeler karedeki boşlukları korur.

Şimdi aşağıdaki rakam gösterimini karenin uygun kısmına yerleştirmek için satırları ve sütunları iki birim döndürür ve girişte kalan basamaklar için işlemi tekrar ederiz.

Son olarak, her satırı tersine çeviririz ve ayrı sıralar arasına bir satır beslemesi ekleriz.

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.

Son dönmeler, karenin kenar uzunluğu 2n + 3'ten küçükse çıktısını bozacaktır . Yana 5n ≥ 2n + 3 tüm pozitif tamsayılar için n , kare Bunu önlemek için yeterince büyüktür.

Python 3, 189 183 174 bayt

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

Sıkıştırma bana iyi geliyor, ama yedi değişkeni atmanın iyi bir yolunu bulmakta zorlanıyorum ...

Neyse ki, teknik, boşluk kuralları konusunda oldukça rahat, çünkü birçok lider / takip eden boşluk var.

Expanded:

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

açıklama

Değişkenlerin temsil ettiği bölüm konumları:

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

Her bölüm tek bir 2 baytlık Unicode karakteri ile kodlanır. Örneğin, segmentini şöyle ϻkodlar g:

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

Nitekim, 2yedi bölümlü ekranın sağ alt bölümünü kullanmayan tek hanedir.

C, 1098 345 323 319 bayt

Birinci İkinci Üçüncü deneme. Sonunda birkaç byte tasarruf için ekran tamponu hendek karar verdi. Bu program bir rakam parametresi alır ve rakamları 7 segment formatında basar.

İlk kez katılımcı. Sadece eğlence için. Nazik olmak.

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

Genişletilmiş, ücretsiz uyarı:

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

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

Kullanım: f("1337");dönecektir

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

ES6'nın özelliklerini kullanır ve noktalı virgüllerin ve parantezlerin kullanılmamasına bağlı olarak bazı uygulamaya bağlı davranışlarda bulunabilir, ancak Firefox'ta çalışır.

Expanded:

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

Açıklama:

lher basamağın şekline karşılık gelen 10 tek baytlık karakter içeren bir dizidir. Örneğin, 0 basamağı karakterle temsil edilir î:

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

Girdi karakterleri, bire bir okunan karakterlerini temsil eden biçimlerini tutan dizinin anahtarları olarak kullanılır.

Perl - 103 Bayt

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

Yukarıdakiler 6 yazdırılamayan karakter içeriyor (kaynak Ideone'da indirilebilir ) ve aşağıdakine eşittir:

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

Her biri ^Fdeğişmez bir karakter 6 (ACK) ile \177değiştirilebilir ve karakter 127 (DEL) ile değiştirilebilir.

Shebang 1 olarak sayılır, ikinci satırsonu gereksizdir. Giriş stdin'den alınmıştır.

Örnek Kullanım

$ echo 0123 | perl seven-slash.pl

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

$ echo 456789 | perl seven-slash.pl

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

açıklama

Çıktı her seferinde bir bayt üretilir. Her karakter çevrilir ve bu daha sonra kullanarak bir bit dizisi olarak yorumlanır vec. Bitler aşağıdaki şekilde depolanır:

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

Çıktı 3 ile 5 arasında eğik çizgi yapar, böylece bitler bir sonraki basamağın 56içine dökülür 01. Bit 7kullanılmamış.

C #, 360 355 331 bayt

Merhaba, ilk önce kod-golf denemesinde. Umarım bu bir C #-terası için çok kötü puan değil.

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

Kullanım: p("159114");dönecektir

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

Expanded:

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)

Sayma sırasında 4 boşluk sekme olarak kabul ettim.
Sıkıştırılmamış ve okunabilir:

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 bayt

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

açıklama

1) dTüm rakamların şekilleriyle harita oluşturun .

2) Matrisi fazladan sıfırlarla doldurun ve birleştirin. yani "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) Eşlemek " /\"ve ile yazdırmak için dizini kullanın -1.

Ölçek

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

Bunun daha kısa olabileceğine eminim !!

Teşekkürler @hjk

Pip, 122 + 1 = 123 bayt

-nBayrağı kullanır . Komut satırı argümanı ile girdi alır.

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

UTF-8 dizesinde karakter Aşağıdaki kod noktaları vardır: 11152, 19190, 12535, 12547, 17651, 11575, 11557, 12629, 11071, 11089.

Biraz ungolfed:

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

Temel strateji, her sayının kurucu karakterlerini bulmak ve sonra onları uygun şekilde eğriltmektir. Örneğin, bunun için 8bunu istiyoruz (noktalarla temsil edilen boşluklar):

/.
\\
/.
\\
/.

Bu buna dönüşecek:

 .  
/\. 
\/\.
 \/ 

Bu stratejinin güzel özelliği, önceden çarpık birden fazla sayının yan yana birleştirilmesidir.

Şimdi, /.\\/.\\/.üs 3'te olarak kodlayabiliriz 1200120012. Sonra bunu ondalık basamağa dönüştürebilir ve UTF-8 kod noktası olarak kabul edebiliriz.

İfade J"\/ "@^(A_TB3M"⮐䫶ヷ㄃䓳ⴷⴥㅕ⬿⭑")@_.2<>2Maönceden eğrilmiş verileri aşağıdaki işlemle alır:

                            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

Bu dizeleri yan yana birleştirdikten $.sonra, boşluklardan oluşan bir ızgara (2 * n + 2 kare) oluşturur, önceden eğrilmiş ızgaradan geçiririz ve eğriltilmiş ızgaradaki karşılık gelen boşlukları değiştiririz. uygun karakterler Bunu görmek için, her aşamayı yazdırmak ve kullanıcı girişini duraklatmak için kod değiştirilebilir:

Şebeke aslında baş aşağı inşa edildi, çünkü bu matematiği kolaylaştırıyor gibi görünüyordu.

Kullanılacak daha iyi algoritmalar olduğundan eminim. Ama başkasını kopyalamak yerine kendi fikrimi bulmak istedim.

Pip hakkında daha fazlası

Brainfuck - 719 bayt

Sadece tarihsel bağlam için, Daniel B Cristofani'ye teşekkür eder. Bunun ne zaman yaratıldığından tam olarak emin değilim, ancak 9 Mayıs 2003 gibi erken bir tarihte Internet Arşivinden edinilebilir .

İçin çıktı 9, sorun açıklamasından farklı.

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

Perl, 270 bayt

Bunun için zamanımı boşa harcamamalıydım.

$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

Test etmek için Firefox'ta snippet'i çalıştırın.

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 bayt

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 of @Shion'un C # .NET cevabı , bu yüzden onu da oyladığınızdan emin olun!

Çevrimiçi deneyin.

Açıklama:

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