Ecrivez un programme qui prend une chaîne non vide des chiffres de 0 à 9 et affiche leur affichage sur un affichage à sept segments à l' aide de barres obliques ( /, \).

Ce sont les formes de chiffres précis:

/\  
\ \
 \/

 \
  \


/\
 /
 \/

/\
 /\
  /

 \
\/\

/
\/\
  /

/
\/\
 \/

/\
  \

/\
\/\
 \/

/\
\/\
  /

Lorsqu'un chiffre apparaît l'un après l'autre, ils sont chaînés en diagonale vers le haut et à droite, avec un espace diagonal entre eux. Ainsi, par exemple, 203deviendrait ceci:

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

Notez que le 1personnage occupe la même quantité d’espace que les autres. Les deux lignes du 1sont à droite de l'écran et non à gauche.

Ainsi 159114deviendrait ceci:

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

Il peut y avoir toute quantité et combinaison de nouvelles lignes ou d’espaces dans la sortie tant que les chiffres sont dans la position correcte les uns par rapport aux autres.

Donc 159114, cela serait aussi valable pour:

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

Prenez une entrée de stdin ou de la ligne de commande, ou écrivez une fonction qui prend une chaîne. Imprimez le résultat sur stdout ou vous pouvez le renvoyer sous forme de chaîne si vous écrivez une fonction.

Toute chaîne non vide des chiffres 0 à 9 devrait fonctionner, y compris les chaînes (par exemple , un seul chiffre 8) et les chaînes par des zéros (par exemple 007, les zéros ne doivent être imprimés).

Le code le plus court en octets gagne.

CJam, 77 71 70 69 63 62 octets

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

Tous les caractères sont imprimables, le copier-coller devrait donc fonctionner correctement.

Essayez-le en ligne dans l' interprète CJam .

Idée

Nous commençons par examiner le nombre de chiffres n dans l'entrée et en poussant un carré d'espaces assez grand pour couvrir la sortie. Dans l'implémentation, ce carré sera codé sous la forme d'un tableau à deux dimensions de chaînes à un caractère.

Un carré de longueur 2n + 1 conviendrait parfaitement (c’est-à-dire qu’il n’ya pas d’espace blanc) pour une implémentation simple, mais nous en utiliserons un de longueur 5n pour économiser quelques octets. Heureusement, les espaces blancs environnants sont autorisés.

Si nous inversons les lignes de la représentation sept barres obliques de 8 , nous obtenons ce qui suit:

 \/
\/\
/\

La représentation de tous les chiffres peut être codé comme un entier 8 bits, où le i ^ème bit est 0 ssi le i ^ème personnage doit me remplacer par un espace. Pour les chiffres de 0 à 9 , les entiers résultants sont

247 208 235 250 220 190 191 240 255 254

qui correspondent aux caractères ISO-8559-1 suivants:

÷Ðëúܾ¿ðÿþ

Pour chaque chiffre dans l'entrée, après avoir sélectionné le nombre entier de 8 bits, on répète le i correspondant ^ième caractère de la représentation de 8 exactement un _i fois, où un _i est le i ^ème bit du nombre entier. Cela pousse un tableau de chaînes de un ou zéro caractères. En divisant ce tableau en morceaux de longueur 3, nous obtenons un tableau où chaque élément correspond à une ligne de la représentation.

Maintenant, nous calculons le maximum vectorisé des chaînes qui représentent le carré et les chaînes qui représentent le chiffre. Les chaînes /et \sont plus grandes que la chaîne  , elles vont donc remplacer les espaces dans le carré. Toutefois, la chaîne  vide est plus petite que la chaîne . Par conséquent, les chaînes vides dans la représentation numérique préservent les espaces du carré.

Nous tournons maintenant les lignes et les colonnes de deux unités pour placer la représentation numérique suivante dans la partie appropriée du carré et répétons le processus pour les chiffres restants de l'entrée.

Enfin, nous inversons chaque ligne et insérons un saut de ligne entre les lignes individuelles.

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.

Les dernières rotations gâcheraient la sortie si la longueur du côté du carré était inférieure à 2n + 3 . Puisque 5n ≥ 2n + 3 pour tous les entiers positifs n , le carré est suffisamment grand pour empêcher cela.

Python 3, 189 183 174 octets

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

La compression me convient, mais j'ai du mal à trouver un bon moyen d'abandonner les sept variables ...

Heureusement, la spécification est assez détendue sur les règles d'espaces, car il y a beaucoup d'espaces en tête / en fin.

Étendu:

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

Explication

Les positions de segment représentées par les variables sont:

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

Chaque segment est codé par un seul caractère Unicode de 2 octets. Par exemple, ϻencode gle segment comme suit:

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

En effet, 2c’est le seul chiffre à ne pas utiliser le segment inférieur droit d’un affichage à sept segments.

C, 1098 345 323 319 octets

Première Deuxième Troisième tentative. Finalement décidé d'abandonner le tampon d'écran pour économiser quelques octets. Ce programme prend un paramètre de chiffres et imprime les chiffres au format 7 segments.

Premier participant. Juste pour le fun. Sois gentil.

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

Élargi, sans avertissement:

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

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

Utilisation: f("1337");reviendra

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

Il utilise des fonctionnalités de ES6 et peut avoir un comportement dépendant de l'implémentation en raison de l'omission des points-virgules et des parenthèses, etc., mais cela fonctionne dans Firefox.

Étendu:

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

Explication:

lest un tableau contenant 10 caractères sur un octet correspondant à la forme de chaque chiffre. Par exemple, le chiffre 0 est représenté par le caractère î:

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

Les caractères en entrée sont utilisés comme clés pour que le tableau conserve leur forme, représentant des contreparties, qui sont lues bit par bit.

Perl - 103 octets

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

Ce qui précède contient 6 caractères non imprimables (la source peut être téléchargée sur Ideone ) et correspond à ce qui suit:

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

Chacun ^Fpeut être remplacé par un caractère littéral 6 (ACK) et \177par le caractère 127 (DEL).

Le shebang est compté comme 1, la deuxième nouvelle ligne est inutile. L'entrée est prise de stdin.

Exemple d'utilisation

$ echo 0123 | perl seven-slash.pl

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

$ echo 456789 | perl seven-slash.pl

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

Explication

La sortie est générée un octet à la fois. Chaque caractère est translittéré, et ceci est ensuite interprété comme un tableau de bits utilisant vec. Les bits sont stockés de la manière suivante:

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

La sortie alterne entre 3 et 5 barres obliques, de sorte que les bits 56débordent 01du chiffre suivant. Le bit 7n'est pas utilisé.

C #, 360 355 331 octets

Bonjour, première tentative de code-golf. J'espère que cela ne marque pas trop mal pour une entrée en 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);}

Utilisation: p("159114");reviendra

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

Étendu:

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)

J'ai considéré 4 espaces comme des onglets en comptant.
Non compressé et lisible:

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 octets

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

Explication

1) Créer une dcarte avec toutes les formes des chiffres.

2) Remplissez la matrice avec des zéros supplémentaires et ajoutez-les ensemble. c'est-à-dire "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) Utilisez l’index pour cartographier " /\"et imprimer avec -1.

Tester

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

Je suis sûr que ça peut être plus court !!

Merci @hjk

Pip, 122 + 1 = 123 octets

Utilise le -ndrapeau. Prend une entrée via un argument de ligne de commande.

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

Les caractères de la chaîne UTF-8 ont les points de code suivant: 11152, 19190, 12535, 12547, 17651, 11575, 11557, 12629, 11071, 11089.

Légèrement non-golfé:

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

La stratégie de base consiste à rechercher les caractères constitutifs de chaque numéro, puis à les biaiser de manière appropriée. Par exemple, pour 8, nous voulons ceci (espaces représentés par des points):

/.
\\
/.
\\
/.

qui se transformera en ceci:

 .  
/\. 
\/\.
 \/ 

La fonctionnalité intéressante de cette stratégie est que plusieurs nombres pré-asymétriques peuvent simplement être concaténés côte à côte.

Maintenant, nous pouvons encoder /.\\/.\\/.en base 3 comme 1200120012. Ensuite, nous pouvons convertir cela en décimal et le traiter comme un point de code UTF-8.

L'expression J"\/ "@^(A_TB3M"⮐䫶ヷ㄃䓳ⴷⴥㅕ⬿⭑")@_.2<>2Maobtient les données pré-asymétriques par le processus suivant:

                            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

Une fois que nous avons concaténé ces chaînes côte à côte $., nous créons une grille d’espaces (2 * n +2 carrés), parcourons la grille pré-asymétrique et remplaçons les espaces correspondants dans la grille post-asymétrique par les caractères appropriés. Pour le voir se produire, on peut modifier le code pour imprimer chaque étape et mettre en pause pour la saisie de l'utilisateur:

La grille est en réalité construite à l'envers, car cela semblait faciliter les calculs.

Je suis sûr qu'il existe de meilleurs algorithmes à utiliser. Mais je voulais proposer ma propre idée plutôt que de copier celle de quelqu'un d'autre.

Plus sur Pip

Brainfuck - 719 octets

Pour contexte historique seulement, crédits à Daniel B Cristofani. Je ne sais pas exactement quand cela a été créé, mais il est disponible sur Internet Archive dès le 9 mai 2003.

La sortie 9est différente de celle décrite dans la description du problème.

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

Perl, 270 octets

Je n'aurais vraiment pas dû perdre mon temps avec ça.

$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

Exécutez le fragment de code dans Firefox pour tester.

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 octets

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

La réponse du port de @Shion en C # .NET , assurez-vous donc également de lui donner son vote!

Essayez-le en ligne.

Explication:

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