Reto

Dado un número entero positivo , repetir cada uno de sus dígitos un número de veces correspondiente a su posición en . En otras palabras, cada dígito debe repetirse veces (para cada , 1-indexado), creando así el nuevo número:$N$$d_1, d_2, d_3, \cdots, d_n$$N$$d_k$$k$$1\le k\le n$

Luego, escríbalo horizontal y verticalmente y complete los espacios en blanco con copias del dígito que corresponde al índice mayor entre el índice de columna y el índice de fila del espacio en blanco. El resultado final debería verse así:

Especificaciones

Puede tomar $N$ como un entero, una cadena, una lista de dígitos o una lista de caracteres que representan los dígitos. El resultado puede ser una cadena separada por una nueva línea, una lista de cadenas / enteros o una lista de listas de caracteres / dígitos, pero si es posible, incluya una versión impresa bonita. Si la salida es una cadena separada por una nueva línea, también es aceptable:

• tener espacios en blanco iniciales / finales, siempre que la apariencia visual de la salida no cambie
• separe las columnas usando una cantidad consistente de espacios o las filas con una cantidad consistente (no cero) de líneas nuevas

Puede tomar entradas y proporcionar salidas a través de cualquier método estándar , mientras toma nota de que estas lagunas están prohibidas de manera predeterminada. Este es el código de golf , así que intente completar la tarea en la menor cantidad de bytes que pueda administrar en el idioma que elija.

Casos de prueba

65:

655
555
555

---------------

203:

200333
000333
000333
333333
333333
333333

--------------

233:

233333
333333
333333
333333
333333
333333

---------------

5202:

5220002222
2220002222
2220002222
0000002222
0000002222
0000002222
2222222222
2222222222
2222222222
2222222222

---------------

12345:

122333444455555
222333444455555
222333444455555
333333444455555
333333444455555
333333444455555
444444444455555
444444444455555
444444444455555
444444444455555
555555555555555
555555555555555
555555555555555
555555555555555
555555555555555

JavaScript (ES7), 70 bytes

Toma la entrada como una cadena. Devuelve una cadena con un salto de línea final.

s=>(g=x=>(c=s[(x>y?x:y)**.5-1>>1])?c+g(x+8):x>y?`
`+g(1,y+=8):'')(y=1)

Pruébalo en línea!

¿Cómo?

Método

Construimos la salida carácter por carácter caminando a través de una matriz cuadrada y convirtiendo cada celda en un índice en la cadena de entrada.$i_{x,y}$

Coordenadas para indexar cadenas

El límite superior del área de dígitos n t h (indexado a 0) a lo largo de cada eje está dado por A000096 :$u_{n}$$n^{th}$

u0=0,u1=2,u2=5,u3=9,u4=14,u5=20,

Dado un entero , podemos encontrar en qué área n = ⌊ x ⌋ + 1 se encuentra resolviendo:$k$$n=\lfloor{x}\rfloor+1$

Llevando a:

n=⌊

Para cada celda , definimos:$(x, y)$

Estos valores se convierten en índices i x , y en la cadena de entrada haciendo:$v_{x,y}$$i_{x,y}$

 v(x,y) |  0  1  2  3  4  5  6  7  8  9        i(x,y) |  0  1  2  3  4  5  6  7  8  9
--------+-------------------------------      --------+-------------------------------
    0   |  1  9 17 25 33 41 49 57 65 73           0   |  0  1  1  2  2  2  3  3  3  3
    1   |  9  9 17 25 33 41 49 57 65 73           1   |  1  1  1  2  2  2  3  3  3  3
    2   | 17 17 17 25 33 41 49 57 65 73           2   |  1  1  1  2  2  2  3  3  3  3
    3   | 25 25 25 25 33 41 49 57 65 73           3   |  2  2  2  2  2  2  3  3  3  3
    4   | 33 33 33 33 33 41 49 57 65 73   -->     4   |  2  2  2  2  2  2  3  3  3  3
    5   | 41 41 41 41 41 41 49 57 65 73           5   |  2  2  2  2  2  2  3  3  3  3
    6   | 49 49 49 49 49 49 49 57 65 73           6   |  3  3  3  3  3  3  3  3  3  3
    7   | 57 57 57 57 57 57 57 57 65 73           7   |  3  3  3  3  3  3  3  3  3  3
    8   | 65 65 65 65 65 65 65 65 65 73           8   |  3  3  3  3  3  3  3  3  3  3
    9   | 73 73 73 73 73 73 73 73 73 73           9   |  3  3  3  3  3  3  3  3  3  3

Condiciones de detención

Sabemos que hemos alcanzado:

• el límite derecho de la matriz cuando el carácter en no existe y tenemos x > $i_{x,y}$$x > y$

• el límite inferior de la matriz cuando el carácter no existe y tenemos $x \le y$

J , 16 15 bytes

-1 byte gracias a FrownyFrog!

{~#\<:@>./~@##\

Pruébalo en línea!

Toma Ncomo una cuerda.

Explicación de la solución inicial:

              #\   finds the length of the successive prefixes of the input (1 2 3...)
            #~     copies each digit as many times (1 2 2 3 3 3...)  
       >./~@       and creates a table of the max of the row/col numbers
  [:<:@            then subtract 1 from each element (for indexing)
{~                 select the corresponding digit from the input

Sesión de prueba con entrada 203:

   #\ '203'
1 2 3

   #~#\ '203'
1 2 2 3 3 3

   >./~@#~#\ '203'
1 2 2 3 3 3
2 2 2 3 3 3
2 2 2 3 3 3
3 3 3 3 3 3
3 3 3 3 3 3
3 3 3 3 3 3

   <:@>./~@#~#\ '203'
0 1 1 2 2 2
1 1 1 2 2 2
1 1 1 2 2 2
2 2 2 2 2 2
2 2 2 2 2 2
2 2 2 2 2 2

   ({~[:<:@>./~@#~#\) '203'
200333
000333
000333
333333
333333
333333

Haskell , 60 59 58 bytes

f x|s<-do(n,_)<-zip[0..]x;n<$[0..n]=[(x!!).max a<$>s|a<-s]

Pruébalo en línea!

Versión sin puntos (68 bytes)

(map=<<(.((snd.).max)).flip map).((\t@(n,c)->t<$[1..n])=<<).zip[1..]

Pruébalo en línea!

Python 2 , 71 bytes

i=j=0;r=''
for x in input():i+=1;r+=x*i
for c in r:print j*c+r[j:];j+=1

Pruébalo en línea!

Primero genera la primera fila r, luego itera rpara imprimir cada línea.

R , 59 bytes

function(a){m=outer(x<-rep(g<-seq(a),g),x,pmax);m[]=a[m];m}

Pruébalo en línea!

• Noté que tomar un vector de dígitos es aceptable, y esto me permitió guardar 21 bytes :)
• -2 bytes gracias a la sugerencia de @Giuseppe de aceptar solo el vector de caracteres
• -2 bytes asignados en la definición de argumentos

Jalea , 7 bytes

Jx`»þ`ị

Pruébalo en línea!

Salida clarificada.

05AB1E , 14 11 10 bytes

Guardado 1 byte gracias a Magic Octopus Urn / Adnan

ƶJDv¬N×?=¦

Pruébalo en línea!

Explicación

ƶ            # repeat each element its index (1-based) times 
 J           # join to string
  Dv         # for N in [0 ... len(string)-1] do
    ¬N×      # push the head repeated N times
       ?     # print without newline
        =    # print the rest of the string without popping
         ¦   # remove the head

APL (Dyalog Classic) , 16 bytes

{⍵[∘.⌈⍨(/⍨⍳⍴⍵)]}

Estoy separando esta solución de la publicación con mi respuesta J, como lo sugirió Jo King

Pruébalo en línea!

Python 2 , 74 bytes

i=1;a=[]
for c in input():exec"a=zip(*a+[c*-~len(a)]);"*i;i+=2+i%2
print a

Pruébalo en línea!

Excel VBA, 95 bytes

Una función de ventana inmediata anónima de VBE que toma entradas [A1]y salidas de la consola

n=[len(A1)]:For y=1To n:For l=1To y:?:For x=1To n:?String(x,Mid([A1],IIf(x>y,x,y)));:Next x,l,y

Ungolfed y comentó

n=[len(A1)]                         ''  Get Length
For y=1To n                         ''  Iterate down input
For l=1To y                         ''  Iterate down repeat lines
?                                   ''  Print Newline
For x=1To n                         ''  Iterate accross input
?String(x,Mid([A1],IIf(x>y,x,y)));  ''  Print x of the `max(x,y)`th digit in input
Next x,r,y                          ''  Loop, Loop, Loop

MATL , 15 12 bytes

tftY"t!2$X>)

Pruébalo en línea!

Sospecho que esto se puede acortar, pero no es tan malo ...

          % implicit input, '230'
t         % duplicate input. Stack: ['230','230']
f         % indices of nonzero values. Stack: ['230',[1,2,3]]
t         % duplicate. Stack: ['230',[1,2,3],[1,2,3]]
Y"        % run-length decoding. Stack: ['230',[1,2,2,3,3,3]]
t         % duplicate. Stack: ['230',[1,2,2,3,3,3],[1,2,2,3,3,3]]
!         % transpose. Stack: ['230',[1,2,2,3,3,3],[1;2;2;3;3;3]]
2$X>      % elementwise maximum of 2 inputs, with broadcast.
          % Stack:
          % ['230',
          % [1, 2, 2, 3, 3, 3;
          %  2, 2, 2, 3, 3, 3;
          %  2, 2, 2, 3, 3, 3;
          %  3, 3, 3, 3, 3, 3;
          %  3, 3, 3, 3, 3, 3;
          %  3, 3, 3, 3, 3, 3]]
 )        % index into G
          % implicit end, display stack contents

Agregar ++ , 35 bytes

L,bLRdBcB]£X¦Ω+d‽b>1€Ω_A€Ω:AbLR¦+$T

Pruébalo en línea!

Cómo funciona

Tomamos la entrada como una lista de dígitos, mientras que nos impide a) tener que convertir a dígitos con BD , y también tener que guardar los dígitos, lo que tomaría dos bytes.

Primero, generamos un rango desde [1 ... len (input)] con bLR, luego repetimos cada elemento$n$ en el rango $n$veces. Como la vectorización automática no existe en Add ++, la comprimimos consigo misma dBcB]para crear una lista de pares$[[1, 1], [2, 2] ... [n, n]]$. Luego aplicamos el mapa estelar , junto con la repetición sobre los pares: £Xantes de concatenarlos en una matriz plana ( ¦Ω+).

A continuación, duplicar esta matriz y mesa por el máximo, d‽b>. Es decir, cada elemento de la matriz se empareja entre sí desde la segunda matriz y el comando máximo diádico se ejecuta sobre el par. Para una entrada de ejemplo de [6 5] , esto crea la matriz [1 2 2 2 2 2 2 2 2] , que es una versión aplanada del mosaico, como los índices para la matriz. Por desgracia, Añadir ++ utiliza matrices 0-indexados, por lo que necesitamos para disminuir cada elemento: 1€Ω_.

Luego, indexamos en la lista de entrada, presionando la entrada nuevamente ( A), lo que nuevamente ahorra bytes al tomar la entrada como una lista. Indice en la lista con €Ω:antes de cortar la matriz en las piezas alargadas adecuadamente. Si el número de dígitos en la entrada se denota por$x$, entonces el tamaño de la pieza es

o el $x^{th}$ número triangular . Generamos eso empujando la longitud de la entrada, calculando el rango de 1 a ese valor, luego tomando la suma con AbLR¦+. Ahora, la pila, para una entrada de [6 5] , se ve como [[6 5 5 5 5 5 5 5 5] 3] . Tcorta la matriz en trozos de tamaño$n$, pero los argumentos están actualmente en el orden incorrecto, por lo que los intercambiamos $antes de cortarlos y volver con ellos T.

Carbón de leña , 17 bytes

Ｆ⮌…ＬθＵＯ⊕⊘×ι⁺³ι§θι

Pruébalo en línea! Explicación:

Ｆ⮌…Ｌθ

Recorre los índices de los personajes en orden inverso.

⊕⊘×ι⁺³ι

Calcule el tamaño del cuadrado.

ＵＯ...§θι

Dibuja el cuadrado usando el personaje actual.

Lienzo , 12 bytes.

ø╶｛；ｌ└²＋：＊；ｎ

Pruébalo aquí!

Python 2 , 76 73 bytes

-3 bytes gracias a Lynn .

l=0;m=[]
for k in input():l+=1;m=[r+l*k for r in m]+l*[l*-~l/2*k]
print m

Pruébalo en línea!

Carbón , 14 bytes

Ｅ⭆θ×⊕κι×⊕κι‖Ｏ↗

Pruébalo en línea!

¿Cómo?

Ｅ⭆θ×⊕κι×⊕κι‖Ｏ↗ - implicitly print the result of...
Ｅ                - map:
  ⭆              -   over: string map:       
    θ             -     over: first input
     ×            -     using: repeat
        ι         -       what: ι (loop value)
      ⊕κ          -       by: incremented κ (loop counter)
         ×        -   using: repeat
            ι     -     what: ι (loop value)
          ⊕κ      -     by: incremented κ (loop counter)
             ‖Ｏ  - Reflect with overlap:
                ↗ -   direction: up-right

... ¿Se puede jugar a este método?

Stax , 12 bytes

ü°√¿«│⌠º₧@\τ

Ejecutar y depurarlo

Usando este algoritmo .

Explicación:

c%R:BXm]i*xit+ Full program, implicit input
c%             Length of input
  R            1-based range
   :B          Repeat each element according to the range ("123" -> "122333")
     X         Save to X register
      m        Map:
       ]         Character -> string
        i*       Repeat by iteration index
          xit    Trim first <iteration index> elements from X
             +   Concatenate
                 Implicit output with newline

Stax , 20 19 18 16 bytes

ù↔‼i,ÑΓæ☺=╘‼æ↕4╝

Ejecutar y depurarlo

Explicación:

c%R:BX%mYx%{y|Mvx@m Full program, implicit input
c%                  Length of input
  R                 1-based range
   :B               Repeat each element according to the range ("123" -> "122333")
     X              Save to X register
      %             Length
       m            Map over 1-based range:
        Y             Save index to Y register
         x%           Push length of X register
           {      m   Map over 1-based range:
            y|M         Maximum of both indices
               v        1-based -> 0-based (decrement)
                x@      Index into X register
                      Implicit output with newline

Adjunto , 34 bytes

{_[Table[Max,Flat!{_&_}=>1:#_]-1]}

Pruébalo en línea!

Explicación

Funciona de manera similar a la respuesta J de Galen Ivanov .

{_[Table[Max,Flat!{_&_}=>1:#_]-1]}
{                                }   anonymous function: _ is input, array of digits
                                     example: _ := [2, 0, 3]
                         1:#_        the range 1 to Size[_]
                                     > e.g.: [1, 2, 3]
                  {   }=>            over each number N:
                   _&_                   map to N repeated N times
                                     > e.g.: [[1], [2, 2], [3, 3, 3]]
             Flat!                   flatten it
                                     > e.g.: [1, 2, 2, 3, 3, 3]
   Table[Max,                ]       create a "max" table with it
                                     > e.g.:
                                       1 2 2 3 3 3
                                       2 2 2 3 3 3
                                       2 2 2 3 3 3
                                       3 3 3 3 3 3
                                       3 3 3 3 3 3
                                       3 3 3 3 3 3
                              -1     subtract 1 from each
                                     > e.g.:
                                       0 1 1 2 2 2
                                       1 1 1 2 2 2
                                       1 1 1 2 2 2
                                       2 2 2 2 2 2
                                       2 2 2 2 2 2
                                       2 2 2 2 2 2
 _[                             ]    index the original array with this matrix
                                     > e.g.:
                                       2 0 0 3 3 3
                                       0 0 0 3 3 3
                                       0 0 0 3 3 3
                                       3 3 3 3 3 3
                                       3 3 3 3 3 3
                                       3 3 3 3 3 3

K (ngn / k) , 16 bytes

{x@i|\:i:&1+!#x}

Pruébalo en línea!

C (gcc) , 130 bytes

¿Quién necesita matemáticas sofisticadas cuando puedes usar la fuerza bruta?

n,l;R(n,c){for(;n--;)putchar(c);}f(s){for(char*p=s,*q;*p++;)for(n=l=p-s;l--;R(1,10))for(R(n*n+n>>1,p[-1]),q=p;*q;q++)R(q-s+1,*q);}

Pruébalo en línea!

QBasic 1.1 , 127 bytes

INPUT S$
FOR X=1TO LEN(S$)
K=K+X
R$=R$+STRING$(X,MID$(S$,X,1))
NEXT
FOR C=1TO K
?STRING$(C-1,MID$(R$,C,1))RIGHT$(R$,K-C+1)
NEXT

-4 gracias a DLosc .

Utiliza una versión modificada del algoritmo Python 2 de xnor .

La entrada es una cadena sin comillas. La salida está \nseparada sin espacios adicionales o \ns.

QBasic , 111 bytes

Una función anónima que solicita entradas y salidas a la consola.

INPUT s$
n=LEN(s$)
FOR y=1TO n
FOR l=1TO y
?
FOR x=1TO n
z=x
IF y>x THEN z=y
?STRING$(x,MID$(s$,z));
NEXT x,l,y

Php 7.1 , 163 bytes

Vía CLI proporcionando el número como argumento:

<?foreach(str_split($argv[1])as$k=>$d)$a[]=array_fill(0,$s+=$k+1,array_fill(0,$s,$d));foreach(array_replace_recursive(...array_reverse($a))as$v)echo join($v)."\n";

No tan golfizado:

$n = 123;

foreach(str_split($n) as $k => $d) {
    $s += $k + 1;
    $a[] = array_fill(0, $s, array_fill(0, $s, $d));
}

foreach(array_replace_recursive(...array_reverse($a)) as $v)
    echo implode('', $v) . "\n";

Salida:

122333
222333
222333
333333
333333
333333

Método:

Básicamente construya cuadrados de matriz multidimensionales que consisten en el dígito, y luego superponga todos ellos (array_replace_recursive).

(Sí, sé que esto es vergonzosamente largo).

Rubí , 80 bytes.

->n{s=(1..n.size).map{|i|n[i-1]*i}*"";(0...s.size).map{|i|s[i]*i+s[i..-1]}*"\n"}

Pruébalo en línea!

Similar a la respuesta de ovs

Japt, 12 bytes

Toma la entrada como una cadena, emite una matriz de cadenas.

Ë+pE
¬£h°YçX

Intentalo

Explicación

            :Implicit input of string U
Ë           :Map each character D at 0-based index E
  pE        :  Repeat D E times
 +          :  Append to D
\n          :Reassign to U
¬           :Split to character array
 £          :Map each element X at 0-based index Y
   °Y       :  Increment Y
     çX     :  Repeat X Y times
  h         :  Replace the first Y characters in U with that

uBASIC , 120 bytes

Una función anónima que toma la entrada desde STDIN y sale a STDOUT

0Input"",S$:N=Len(S$):ForY=1ToN:ForL=1ToY:ForX=1ToN:ForC=1ToX:Z=X:IfY>XThenZ=Y
1?Mid$(s$,z,1);:NextC:NextX:?:NextL:NextY

Pruébalo en línea!

Visual Basic .NET (VBC) , 198 bytes

Una Subrutina que toma entradas de STDIN y salidas a STDOUT.

Parece que no puede hacer que StrDup funcione: /

Module M
Sub Main
Dim c,s,n,l,x,y
s=Console.readLine()
n=Len(s)
For y=1To n
For l=1To y
For x=1To n
For c=1To x
Console.Write(Mid(s,IIf(x>y,x,y),1)&IIf(c=n,vbLf,""))
Next c,x,l,y 
End Sub
End Module

Pruébalo en línea!

Lua, 149 140 bytes

Función que acepta una lista de cadenas de dígitos e imprime el resultado en stdout. Este es mi primer intento de golf de código (y la elección del idioma tampoco ayuda), así que tengan paciencia conmigo :)

Pruébalo en línea!

function(a)F,s=0,""for b=1,#a do s=s..a[b]:rep(b)end;for b=1,#a do io.write((s.."\n"):rep(b))F,z=F+b,a[b+1]or""s=z:rep(F)..s:sub(F+1)end end

Sin golf:

G = function(p)
    F,s = 0,""
    for i=1,#p do
        s=s..p[i]:rep(i)
    end
    for i=1, #p do
        io.write((s.."\n"):rep(i))
        F,z = F+i, p[i+1]or""
        s = z:rep(F)..s:sub(F+1)
    end
end
-- allows to pass the argument list from stdin
-- example: {"1", "2", "3", "4", "5"}
G(load("return " .. io.read())())

Perl 5 + -nalF -M5.010, 67 bytes

s/./$&x++$-/ge;eval'eval"say;"x++$i;$x+=$i;s/.{$x}/$F[$i]x$x/e;'x@F

Pruébalo en línea!

Yabasic , 108 bytes

Una función anónima que toma entradas de STDIN y salidas a STDOUT

Input""s$
n=len(s$)
For y=1To n
For r=1To y
For x=1To n
For c=1To x?Mid$(s$,max(x,y),1);Next
Next
?Next
Next

Pruébalo en línea!