Escriba un programa que tome una cadena no vacía de los dígitos del 0 al 9 e imprima cómo se mostrarían en una pantalla de siete segmentos utilizando barras ( /, \).

Estas son las formas precisas de dígitos:

/\  
\ \
 \/

 \
  \


/\
 /
 \/

/\
 /\
  /

 \
\/\

/
\/\
  /

/
\/\
 \/

/\
  \

/\
\/\
 \/

/\
\/\
  /

Cuando un dígito ocurre después de otro, se encadenan diagonalmente hacia arriba y hacia la derecha, con un espacio diagonal en el medio. Entonces, por ejemplo, 203se convertiría en esto:

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

Tenga en cuenta que el 1personaje ocupa la misma cantidad de espacio que los demás. Las dos líneas 1están en el lado derecho de la pantalla, no a la izquierda.

Entonces 159114se convertiría en esto:

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

Puede haber cualquier cantidad y combinación de nuevas líneas o espacios iniciales / finales en la salida, siempre que los dígitos estén en la posición correcta entre sí.

Entonces 159114, esto también sería válido:

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

Tome la entrada de stdin o la línea de comando, o escriba una función que tome una cadena. Imprima el resultado en stdout o puede devolverlo como una cadena si escribe una función.

Cualquier cadena no vacía de los dígitos del 0 al 9 debería funcionar, incluidas las cadenas de un solo dígito (p 8. Ej. ) Y las cadenas con ceros a la izquierda (p. Ej. 007, Los ceros sí necesita ser impresa).

El código más corto en bytes gana.

CJam, 77 71 70 69 63 62 bytes

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

Todos los caracteres son imprimibles, por lo que copiar y pegar debería funcionar bien.

Pruébelo en línea en el intérprete de CJam .

Idea

Comenzamos examinando el número de dígitos n en la entrada y presionando un cuadrado de espacios lo suficientemente grande como para cubrir la salida. En la implementación, este cuadrado se codificará como una matriz bidimensional de cadenas de un carácter.

Un cuadrado de longitud 2n + 1 sería correcto (es decir, sin espacios en blanco circundantes) para una implementación sencilla, pero usaremos uno de longitud 5n para guardar un par de bytes. Afortunadamente, se permite el espacio en blanco circundante.

Si invertimos las líneas de la representación de siete barras diagonales de 8 , obtenemos lo siguiente:

 \/
\/\
/\

La representación de todos los dígitos se puede codificar como un entero de 8 bits, donde el i- ^ésimo bit es 0 si el i- ^ésimo carácter debe reemplazarse con un espacio. Para los dígitos del 0 al 9 , los enteros resultantes son

247 208 235 250 220 190 191 240 255 254

que corresponden a los siguientes caracteres ISO-8559-1:

÷Ðëúܾ¿ðÿþ

Para cada dígito en la entrada, después de seleccionar el entero de 8 bits correspondiente, repetimos el i- ^ésimo carácter de la representación de 8 exactamente a _i veces, donde a _i es el i ^th bit del entero. Esto empuja una serie de cadenas de uno o cero caracteres. Al dividir esta matriz en trozos de longitud 3, obtenemos una matriz donde cada elemento corresponde a una línea de la representación.

Ahora, calculamos el máximo vectorizado de las cadenas que representan el cuadrado y las cadenas que representan el dígito. Las cadenas /y \son más grandes que la cadena  , por lo que reemplazarán los espacios en el cuadrado. Sin embargo, la cadena  vacía es más pequeña que la cadena , por lo que las cadenas vacías en la representación de dígitos preservarán los espacios en el cuadrado.

Ahora rotamos las filas y columnas por dos unidades para colocar la siguiente representación de dígitos en la parte adecuada del cuadrado y repetir el proceso para los dígitos restantes en la entrada.

Finalmente, invertimos cada fila e insertamos un salto de línea entre las filas individuales.

Código

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.

Las últimas rotaciones estropearían la salida si la longitud del lado del cuadrado fuera menor que 2n + 3 . Como 5n ≥ 2n + 3 para todos los enteros positivos n , el cuadrado es lo suficientemente grande como para evitar esto.

Pitón 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

La compresión me parece bien, pero tengo problemas para encontrar una buena forma de deshacerme de las siete variables ...

Afortunadamente, la especificación es bastante relajada en las reglas de espacios en blanco, porque hay muchos espacios en blanco iniciales / finales.

Expandido:

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

Explicación

Las posiciones de segmento representadas por las variables son:

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

Cada segmento está codificado por un único carácter Unicode de 2 bytes. Por ejemplo, ϻcodifica gel segmento de esta manera:

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

De hecho, 2es el único dígito que no utiliza el segmento inferior derecho de una pantalla de siete segmentos.

C, 1.098 mil 345 323 319 bytes

primero Segundo Tercer intento. Finalmente decidió deshacerse del búfer de pantalla para guardar algunos bytes. Este programa toma un parámetro de dígitos e imprime los dígitos en formato de 7 segmentos.

Participante por primera vez. Solo por diversión. Sé 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);}}

Ampliado, sin advertencia:

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

Uso: f("1337");volverá

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

Utiliza características de ES6 y puede tener un comportamiento dependiente de la implementación debido a la omisión de punto y coma y paréntesis, pero funciona en Firefox.

Expandido:

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

Explicación:

les una matriz que contiene 10 caracteres de un solo byte que corresponden a la forma de cada dígito. Por ejemplo, el dígito 0 está representado por el carácter î:

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

Los caracteres de entrada se utilizan como claves para la matriz que mantiene su forma que representa las contrapartes, que se leen poco a poco.

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

Lo anterior contiene 6 caracteres no imprimibles (la fuente se puede descargar en Ideone ), y es equivalente a lo siguiente:

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

Cada uno ^Fpuede ser reemplazado por un carácter literal 6 (ACK), y \177reemplazado por el carácter 127 (DEL).

El shebang se cuenta como 1, la segunda línea nueva no es necesaria. La entrada se toma de stdin.

Uso de muestra

$ echo 0123 | perl seven-slash.pl

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

$ echo 456789 | perl seven-slash.pl

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

Explicación

La salida se genera un byte a la vez. Cada carácter se transcribe, y esto se interpreta como una matriz de bits usando vec. Los bits se almacenan de la siguiente manera:

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

La salida alterna entre 3 y 5 barras inclinadas, de modo que los bits se 56extienden al 01siguiente dígito. El bit 7no se usa.

C #, 360 355 331 bytes

Hola, primer intento de code-golf. Espero que esto no sea tan malo para una entrada 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);}

Uso: p("159114");volverá

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

Expandido:

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

pitón 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)

Consideré 4 espacios como pestañas mientras contaba.
Sin comprimir y legible:

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), 172136 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];}

Explicación

1) Crear d mapa con todas las formas de los dígitos.

2) Rellene la matriz con ceros adicionales y agréguelos juntos. es decir, "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) Use el índice para mapear " /\"e imprimir con-1 .

Prueba

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

Estoy seguro de que esto puede ser más corto !!

Gracias @hjk

Pip, 122 + 1 = 123 bytes

Usa la -nbandera. Toma entrada a través de la línea de comando argumento.

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

Los caracteres de la cadena UTF-8 tienen los siguientes puntos de código: 11152, 19190, 12535, 12547, 17651, 11575, 11557, 12629, 11071, 11089.

Ligeramente incólume:

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 estrategia básica es encontrar los caracteres constituyentes de cada número y luego sesgarlos adecuadamente. Por ejemplo, para 8, queremos esto (espacios representados por puntos):

/.
\\
/.
\\
/.

que se convertirá en esto:

 .  
/\. 
\/\.
 \/ 

La buena característica de esta estrategia es que múltiples números pre-sesgados pueden simplemente concatenarse uno al lado del otro.

Ahora, podemos codificar /.\\/.\\/.en la base 3 como 1200120012. Luego podemos convertir esto a decimal y tratarlo como un punto de código UTF-8.

La expresión J"\/ "@^(A_TB3M"⮐䫶ヷ㄃䓳ⴷⴥㅕ⬿⭑")@_.2<>2Maobtiene los datos previamente sesgados mediante el siguiente proceso:

                            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

Una vez que hemos concatenado estas cadenas una al lado de la otra $., creamos una cuadrícula de espacios (2 * n +2 cuadrados), recorremos la cuadrícula sesgada y reemplazamos los espacios correspondientes en la cuadrícula sesgada con personajes apropiados Para ver cómo sucede, se puede modificar el código para imprimir cada etapa y pausar la entrada del usuario:

La cuadrícula en realidad está construida al revés, porque eso parecía facilitar las matemáticas.

Estoy seguro de que hay mejores algoritmos para usar. Pero quería tener mi propia idea en lugar de copiar la de otra persona.

Más sobre Pip

Brainfuck - 719 bytes

Solo para contexto histórico, créditos a Daniel B Cristofani. No estoy exactamente seguro de cuándo se creó, pero está disponible en Internet Archive a partir del 9 de mayo de 2003.

La salida para 9es diferente que en la descripción del problema.

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

Perl, 270 bytes

Realmente no debería haber perdido mi tiempo en esto.

$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

Ejecute el fragmento en Firefox para probar.

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

Puerto de la respuesta C # .NET de @Shion , ¡así que asegúrese de votarlo también!

Pruébalo en línea.

Explicación:

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