Salida de una pirámide (o carretera)

39

Dada una cadena no vacía s, con una longitud par, y un entero positivo n, que representa su altura, componga una pirámide usando las siguientes reglas:

La pirámide debe contener n líneas no vacías; Se permiten nuevas líneas al final. Para cada 1 <= i <= n, la línea i-ésima debe contener la cadena con cada carácter individual repetido en el lugar i veces; abcd repetido 3 veces como tal se convierte en aaabbbcccddd. Cada línea debe estar centrada con espacios de relleno para que el centro de cada línea esté alineado verticalmente. Se permiten espacios finales al final de cada línea. También puede tener hasta una nueva línea inicial pero ningún otro espacio en blanco antes de la primera línea.

No se garantiza que la cadena de entrada sea un palíndromo.

Caso de prueba

s = 'o-o  o-o', n = 10:

                                    o-o  o-o                                    
                                oo--oo    oo--oo                                
                            ooo---ooo      ooo---ooo                            
                        oooo----oooo        oooo----oooo                        
                    ooooo-----ooooo          ooooo-----ooooo                    
                oooooo------oooooo            oooooo------oooooo                
            ooooooo-------ooooooo              ooooooo-------ooooooo            
        oooooooo--------oooooooo                oooooooo--------oooooooo        
    ooooooooo---------ooooooooo                  ooooooooo---------ooooooooo    
oooooooooo----------oooooooooo                    oooooooooo----------oooooooooo
Hiperneutrino
fuente
1
Sandbox Post creado por user42649, que era mi cuenta hasta que se eliminó.
HyperNeutrino
¿Puede la salida de una función en esta pregunta ser una lista de cadenas, cada una representando una línea, o debería estar unida por nuevas líneas?
notjagan
77
Salida de una pirámide ¡Seguramente quieres decir una carretera !
Luis Mendo
¡Parece una pirámide azteca!
QBrute
3
@QBrute Na. Fue hecho por un Goa'uld :)
theblitz

Respuestas:

12

05AB1E , 9 bytes

γ².D)ƶJ.C

Pruébalo en línea!


γfue, en poco tiempo, inspirado por la respuesta de Adnan; pero Stambién funcionaría


γ          # Split into runs.    | ['0','-','0']
 ².D)      # Push n times.       | [['0','-','0'],['0','-','0'],['0','-','0']]
     ƶ     # Lift by index.      | [['0','-','0'],['00','---','00'],['000','---','000']]
      J    # Inner join.         | ['0-0','00--00','000---000']
       .C  # Center.             | Expected output.
Urna de pulpo mágico
fuente
No puedo creer que alguien haya rechazado tu publicación equivocada: /
Jonathan Allan
1
@JonathanAllan la frecuencia de mis errores evitables merece negatividad hasta cierto punto.
Magic Octopus Urn
12

05AB1E , 11 bytes

F²γN>×J}».C

Utiliza la codificación 05AB1E . Pruébalo en línea!

Adnan
fuente
Comienza a funcionar con entradas por encima de 168. De lo contrario, ¡genial!
tuskiomi
@carusocomputing »une las matrices internas por espacios. Reemplazarlo Jdebería funcionar (y creo que debería publicarlo como una respuesta diferente).
Adnan
Ah! ¿Siempre ha sido así? Si es así, genial, si no debo haberme perdido eso. Gracias, lo hare.
Magic Octopus Urn
8

Jalea , 14 13 bytes

LH×Ḷ}Ṛ⁶ẋżxЀY

Pruébalo en línea!

Cómo funciona

LH×Ḷ}Ṛ⁶ẋżxЀY  Main link. Arguments: s (string), n (integer)

L              Get the length l of s.
 H             Halve it, yielding l/2.
   Ḷ}          Unlength right; yield [0, ... n-1].
  ×            Compute [0, l/2, ..., l(n-1)/2].
     Ṛ         Reverse; yield [l(n-1)/2, ..., l/2, 0].
      ⁶ẋ       Space repeat; create string of that many spaces.
         xЀ   Repeat in-place each; repeat the individual characters of s
               1, ..., n times, yielding an array of n strings.
        ż      Zipwith; pair the k-th string of spaces with the k-th string of 
               repeated characters of s.
            Y  Sepatate the resulting pairs by linefeeds.
Dennis
fuente
8

C # (.NET Core) , 139 137 136 130 bytes

using System.Linq;s=>n=>Enumerable.Range(0,n).Select(i=>"".PadLeft((n+~i)*s.Length/2)+string.Concat(s.Select(c=>new string(c,i))))

Pruébalo en línea!

Devuelve una enumeración de strings con las líneas del dibujo. Una vez unido, el resultado es así:

                        _  _
                    ಠಠ__ಠಠ    ಠಠ__ಠಠ
                ಠಠಠ___ಠಠಠ      ಠಠಠ___ಠಠಠ
            ಠಠಠಠ____ಠಠಠಠ        ಠಠಠಠ____ಠಠಠಠ
        ಠಠಠಠಠ_____ಠಠಠಠಠ          ಠಠಠಠಠ_____ಠಠಠಠಠ
    ಠಠಠಠಠಠ______ಠಠಠಠಠಠ            ಠಠಠಠಠಠ______ಠಠಠಠಠಠ
ಠಠಠಠಠಠಠ_______ಠಠಠಠಠಠಠ              ಠಠಠಠಠಠಠ_______ಠಠಠಠಠಠಠ
  • ¡2 bytes guardados gracias a Kevin Cruijssen!
  • ¡1 byte guardado gracias a Value Ink!
  • ¡6 bytes guardados gracias a LiefdeWen!
Charlie
fuente
1
Puede guardar dos bytes eliminando el paréntesis en (n-i-1)*s.Length/2. Y me gustan tus casos de prueba. +1 :)
Kevin Cruijssen
10
ಠ_ಠse intensifica
Magic Octopus Urn
1
Obligatorio " ~ies equivalente a -i-1", por lo que puede guardar un byte cambiando (n-i-1)a (n+~i).
Value Ink
1
y puedes usar curry s=>n=>...para otro byte
LiefdeWen
1
@CarlosAlejo Perdón por publicar ediciones separadas, pero también puede reemplazar new string(' '...con"".PadLeft(...
LiefdeWen
7

Cheddar , 71 64 bytes

Guardado 7 bytes gracias a @ValueInk

(s,n)->(1|>n=>i->(s.len*(n-i)/2)*" "+s.sub(/./g,"$&"*i)).asLines

Pruébalo en línea! Agregaré una explicación en un momento

Explicación

(string, count)->(
   1 |> count          // 1..count, the amount of rep/char per line
     => i -> (         // Map over the range       
        s.len*(n-i)/2  // Calculate amount of spaces and repeat by it.
     )*" "
     + s.sub(/./g,"$&"*i) // replace each character, duplicate the amount of times `*i`
).asLines              // return the above joined with newlines
Downgoat
fuente
¡No hay problema! Me pregunto si Cheddar tiene una centerfunción que pueda usar como la que tengo en mi respuesta Ruby, porque eso también podría ahorrar bytes.
Value Ink
5

Java 8, 188 186 185 183 181 173 bytes

s->n->{String r="";int l=s.length()/2,x=l*n,i,j;for(i=0;i++<n;r+="\n"){r+=s.format("%"+x+"s",r).substring(0,x-i*l);for(char c:s.toCharArray())for(j=0;j++<i;r+=c);}return r;}

-2 bytes (185 → 183) debido a una corrección de errores (estaba generando n+1líneas en lugar de n). No sucede a menudo que una corrección de errores ahorre bytes. :)
-2 bytes (183 → 181) gracias a @ OlivierGrégoire

Explicación:

Pruébalo aquí

s->n->{                          // Method with String and integer parameter and String return-type
  String r="";                   //  Return-String
  int l=s.length()/2,            //  Halve the length of the input-String
      x=l*n,                     //  Halve the length * the input integer
      i,j;                       //  Some temp integers
  for(i=0;i++<n;                 //  Loop (1) `n` times
      r+="\n"){                  //    And after every iteration, add a new-line
    r+=s.format("%"+x+"s",r).substring(0,x-i*l);
                                 //   Add the appropriate trailing spaces
    for(char c:s.toCharArray())  //   Loop (2) over the characters of the String
      for(j=0;j++<i;r+=c);       //    And repeat each one more than in the previous row
                                 //   End of loop (2) (implicit / single-line body)
  }                              //  End of loop (1)
  return r;                      //  Return the result-String
}                                // End of method
Kevin Cruijssen
fuente
1
Si mueve sus entradas primero, puede declarar r="",q=s.format("%"+x+"s",r)guardar 2 bytes. Mucho movimiento por solo dos bytes :(
Olivier Grégoire
1
@ OlivierGrégoire Gracias! Al usar s.format("%"+x+"s",r)directamente, he podido guardar 8 bytes más después de tu golf. :)
Kevin Cruijssen
4

JavaScript (ES6), 85 bytes

Toma entrada en la sintaxis de curry (string)(height). Incluye una nueva línea líder.

s=>g=(n,p=`
`)=>n?g(n-1,p+' '.repeat(s.length/2))+p+s.replace(/./g,c=>c.repeat(n)):''

Manifestación

Arnauld
fuente
Hay espacios en blanco antes de la última línea, ¿está permitido?
Charlie
@CarlosAlejo Oh, ese fue un efecto secundario no deseado de una actualización de último minuto. Ahora arreglado. ¡Gracias por informar esto!
Arnauld
4

Carbón de leña , 19 bytes

F⁺¹N«J±×ι÷Lη²ιFηFικ

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

F⁺¹N«       for (Plus(1, InputNumber())) {

Necesitamos líneas repetidas 1..nveces. La forma más fácil de lograr esto es hacer un bucle de 0 a n, ya que el bucle 0 es básicamente un no-op.

J±×ι÷Lη²ι       JumpTo(Negate(Times(i, IntDivide(Length(h), 2))), i);

Coloque el cursor de modo que la línea resultante esté centrada.

FηFικ           for (h) for (i) Print(k);

Y así de simple es imprimir cada personaje repetidamente i.

Neil
fuente
4

Python 2 , 75 77 bytes

s,n=input()
for i in range(n):print''.join(c*-~i for c in s).center(len(s)*n)

Pruébalo en línea!

Barra
fuente
Dang, tenía casi la misma respuesta, pero no estaba seguro de si una función podía devolver una lista de líneas. Si es así, publicaré la mía como respuesta separada, pero si no, sería demasiado similar a la publicación.
notjagan
3
Wow, hay un centerincorporado? Realmente necesito leer los documentos a veces: P
HyperNeutrino
Devuelve la salida incorrecta; esto tiene una línea en blanco al inicio seguida de n-1filas.
Value Ink
También tiene algunos espacios en blanco iniciales antes de la última línea, ¿está permitido?
Charlie
@FryAmTheEggman que podría ser cierto, pero sigue devolviendo 9líneas de pirámide cuando la entrada es 10...
Value Ink
4

Javascript, 105 bytes

(s,n)=>Array(N=n).fill().reduce(a=>a+'\n'+' '.repeat(--n*s.length/2)+s.replace(/./g,_=>_.repeat(N-n)),'')

Después de unos años de descanso, el Stretch Maniac está de vuelta, con suerte un poco más educado esta vez.

Estiramiento maniaco
fuente
Tiene demasiados espacios iniciales en cada línea.
Shaggy
Aquí hay una versión ES8 de 99 bytes de este método que se me ocurrió antes de ver el tuyo: s=>n=>[...Array(x=n)].reduce(a=>a+'\n'.padEnd(--x*s.length/2+1)+s.replace(/./g,c=>c.repeat(n-x)),'')tendrás que reemplazar el 's con backticks y el \ncon una nueva línea literal.
Shaggy
3

Haskell , 79 73 69 bytes

  • Guardado 4 bytes gracias a nimi
s#n=unlines[(' '<$[1,3..(n-m)*length s])++((<$[1..m])=<<s)|m<-[1..n]]

Pruébalo en línea!

sudee
fuente
1
Si se utiliza una en el paso .., se puede eliminar el div: (' '<$[1,3..(n-m)*length s]).
nimi
Otros 5 bytes de descuento .
ბიმო
3

APL (Dyalog) , 33 31 bytes

2 bytes de golf gracias a @ZacharyT eliminando paréntesis innecesarios

{↑((' '/⍨(.5×≢⍵)×⍺-⊢),⍵/⍨⊢)¨⍳⍺}

Pruébalo en línea!

Explicación

El argumento derecho es la cadena y el argumento izquierdo es el número.

{↑((' '/⍨(.5×≢⍵)×⍺-⊢),⍵/⍨⊢)¨⍳⍺}
                             ⍳⍺      Range 1 .. 
  (                                For each element (let's call it i) do:
                      ⍵/⍨⊢          Replicate ⍵ i times
  (                 ),               Concatenated with
         (.5×≢⍵)×⍺-⊢                (⍺-i)×(len(⍵)×0.5)
   ' '/⍨                                spaces
 ↑                                    Convert the resulting array to a 2D matrix
Kritixi Lithos
fuente
¿Necesitas los padres alrededor ⍺-⊢?
Zacharý
@ZacharyT Tienes razón, no los necesito. Gracias :)
Kritixi Lithos
3

SWI Prolog, 398 bytes

No es la solución más compacta (tal vez en algún lugar reinventando la rueda en lugar de usar procedimientos integrados), pero parece funcionar.

w(0).
w(X):-write(' '),Y is X-1,w(Y).
s(S,N):-string_length(S,X),Y is div(X,2)*N,w(Y).
d(S,N,R):-atom_chars(S,A),e([],A,N,R).
e(B,[H|T],N,R):-l(B,H,N,I),e(I,T,N,R).
e(B,[],_,B).
a([], L, L).
a([H|T],L,[H|R]):-a(T,L,R).
l(L,_,0,L).
l(L,I,N,R):-M is N-1,l(L,I,M,T),a(T,[I],R).
o([]):-nl.
o([H|T]):-write(H),o(T).
p(S,N):-p(S,N,N).
p(_,0,_).
p(S,N,L):-Q is N-1,p(S,Q,L),d(S,N,R),W is L-N,s(S,W),o(R).

Prueba:

?- p("o-o  o-o",10).
                                    o-o  o-o
                                oo--oo    oo--oo
                            ooo---ooo      ooo---ooo
                        oooo----oooo        oooo----oooo
                    ooooo-----ooooo          ooooo-----ooooo
                oooooo------oooooo            oooooo------oooooo
            ooooooo-------ooooooo              ooooooo-------ooooooo
        oooooooo--------oooooooo                oooooooo--------oooooooo
    ooooooooo---------ooooooooo                  ooooooooo---------ooooooooo
oooooooooo----------oooooooooo                    oooooooooo----------oooooooooo
true .

Explicación:

w y s escribe la cantidad adecuada de los espacios iniciales:

w(0).
w(X):-write(' '),Y is X-1,w(Y).
s(S,N):-string_length(S,X),Y is div(X,2)*N,w(Y).

d gestiona la "duplicación" de caracteres y e es su recurso recursivo:

//d(String, Number of repetitions, Result)
d(S,N,R):-atom_chars(S,A),e([],A,N,R).
e(B,[H|T],N,R):-l(B,H,N,I),e(I,T,N,R).
e(B,[],_,B).

una y l anexados para el resultado (tal vez no existe construido en un procedimiento?):

a([], L, L).
a([H|T],L,[H|R]):-a(T,L,R).
l(L,_,0,L).
l(L,I,N,R):-M is N-1,l(L,I,M,T),a(T,[I],R).

o crea la salida:

o([]):-nl.
o([H|T]):-write(H),o(T).

y finalmente la p es el método principal :

p(S,N):-p(S,N,N).
p(_,0,_).
//p(String, Current level, Number of levels) :- go to the bottom, create pyramide level, write whitespaces, write the level
p(S,N,L):-Q is N-1,p(S,Q,L),d(S,N,R),W is L-N,s(S,W),o(R).
Jan Drozen
fuente
3

Japt , 20 + 1 = 21 19 + 1 = 20 14 bytes

Emite una matriz de líneas: agregue 2 bytes si eso no está permitido.

Võ@®pXÃù°V*UÊz

Pruébalo


Explicación

      :Implicit input of string U & integer V
Võ    :Generate an array of integers from 1 to V, inclusive
@     :Map over the elements of the array
®     :Map over the characters of U
p     :Repeat the current character ...
X     :  X (the current element) times.
à    :End string mapping.
ù     :Left pad each line with spaces to length...
°V    :  V incremented by one...
*     :  multiplied by...
UÊ    :  the length of U...
z     :  divided by 2.
      :Implicit output of resulting array.
Lanudo
fuente
Creo que puedes cambiar SpUla ... espera, no importa :( Sin embargo, puedes guardar un byte reemplazándolo (V-Xcon XnV, si no me equivoco.
ETHproductions
Oh, sí, se olvidó n; gracias @ETHproductions.
Shaggy
2

PHP, 113 bytes:

for([,$s,$n]=$argv;$i++<$n;)for(print($f=str_pad)("
",($n-$i)*strlen($s)/2+!$p=0);~$c=$s[$p++];)echo$f($c,$i,$c);

Ejecutar php -nr '<code>' '<string>' <N>o probarlo en línea .

Descompostura

# import input, loop $i from 1 to $n
for([,$s,$n]=$argv;$i++<$n;)
    # 1. print newline and padding, reset $p
    for(print($f=str_pad)("\n",($n-$i)*strlen($s)/2+!$p=0);
    # 2. loop $c through string
        ~$c=$s[$p++];)
        # print repeated character
        echo$f($c,$i,$c);
Titus
fuente
2

CJam , 36 bytes

l_,2/:T;]li:F{[_U)*zSTFU)-**\N]\}fU;

Pruébalo en línea!

Siguza
fuente
Bienvenido a PPCG! Buena primera presentación :)
HyperNeutrino
@HyperNeutrino Bueno, tengo la sensación de que mi código está bastante lejos de ser optimizado, pero ... gracias. :)
Siguza
44
Pero contiene STFU :-D
Luis Mendo
2

T-SQL, 223 bytes

DECLARE @ char(99),@n INT,@i INT=1,@j INT,@p varchar(max)SELECT @=s,@n=n FROM t
R:SET @j=0SET @p=SPACE((@n-@i)*len(@)/2)C:SET @j+=1SET @P+=REPLICATE(SUBSTRING(@,@j,1),@i)IF @j<LEN(@)GOTO C
PRINT @p SET @i+=1IF @i<=@n GOTO R

La entrada es a través preexistente mesa de t con columnas s y n , de acuerdo con nuestras normas IO .

No hay mucho que explicar, es un bucle anidado bastante sencillo, que se usa @ipara las filas y @jpara recorrer los caracteres de la cadena que son REPLICATED @itiempos:

DECLARE @ char(99),@n INT,@i INT=1,@j INT,@p varchar(max)
SELECT @=s,@n=n FROM t
R:
    SET @j=0
    SET @p=SPACE((@n-@i)*len(@)/2) 
    C:
        SET @j+=1
        SET @P+=REPLICATE(SUBSTRING(@,@j,1),@i)
    IF @j<LEN(@)GOTO C
    PRINT @p
    SET @i+=1
IF @i<=@n GOTO R
BradC
fuente
2

R , 125 95 bytes

function(S,n)for(i in 1:n)cat(rep(' ',(n-i)/2*nchar(S)),rep(el(strsplit(S,'')),e=i),sep="",'
')

Pruébalo en línea!

Explicación:

Es bastante sencillo, dividiendo la cadena y repitiendo los elementos iveces cada uno rep(s,e=i)( ees la abreviatura de each) a medida que avanzamos. La parte difícil es rep('',(n-i)/2*length(s)+1). Esta es la cadena de relleno, pero es un montón de cadenas vacías. Necesito agregar 1 porque, de lo contrario, el resultado es character(0)un vector de longitud cero y cat, que por defecto separa sus elementos con espacios, desalinea la línea final.

Giuseppe
fuente
1

Mathematica, 97 bytes

(c=Characters@#;T=Table;Column[T[""<>T[""<>T[c[[i]],j],{i,Length@c}],{j,#2}],Alignment->Center])&


entrada

["oo oo", 10]

J42161217
fuente
1

Tcl, 143 142 141 138 bytes

proc p s\ n {set p [expr [set w [expr [string le $s]/2]]*$n];time {incr p $w;puts [format %$p\s [regsub -all . $s [append r \\0]]]} $n;cd}

Prueba:

% p "o-o  o-o" 5
                o-o  o-o
            oo--oo    oo--oo
        ooo---ooo      ooo---ooo
    oooo----oooo        oooo----oooo
ooooo-----ooooo          ooooo-----ooooo

Observación: el "cd" al final del procedimiento evita que el resultado del tiempo se imprima debajo de la pirámide, pero cambia el directorio actual, un efecto secundario que no está explícitamente prohibido.

Gracias a sergiol por una pista para guardar un byte ... y otra pista para guardar un byte más.

¡Gracias al aspecto (en el chat tcl) por otros 3 bytes guardados!

avl42
fuente
1

Rápido, 232 bytes

Probablemente podría ser mejor, pero no tengo mucho tiempo para refactorizar.

Esta respuesta usa Swift 4, por lo que actualmente no se puede ejecutar en línea.

var p:(String,Int)->String={s,i in let r=(1...i).map{n in return s.map{return String(repeating:$0,count:n)}.joined()};return(r.map{return String(repeating:" ",count:(r.last!.count-$0.count)/2)+$0}as[String]).joined(separator:"\n")}
Caleb Kleveter
fuente
1

LOGOTIPO, 97 95 bytes

to f :s :n
for[i 1 :n][repeat(:n-:i)/2*count :s[type "\ ]foreach :s[repeat :i[type ?]]pr "]
end

Pruebe el código en el intérprete FMSLogo.

Defina una función fque tome dos entradas :sy :nluego imprima el resultado.

usuario202729
fuente
1

Java 8, 164148 bytes

s->n->{String o="";for(int i=0,m,j;i++<n;){o+="\n";for(m=0;m++<(n-i)*s.length()/2;)o+=" ";for(char c:s.toCharArray())for(j=0;j++<i;)o+=c;}return o;}

Explicación:

s->n->{
    String o = "";                                  //empty output string
    for (int i = 0, m, j; i++ < n; ) {              //for each row
        o += "\n";                                  //append a new line
        for (m = 0; m++ < (n - i)*s.length()/2; )   //for amount of spaces = inversed row_number * half length
            o += " ";                               //append a space
        for (char c : s.toCharArray())              //for each char of the string
            for (j = 0; j++ < i; )                  //row_number times
                o+=c;                               //append char
    }
    return o;
}
Sebastian Matschke
fuente
1

Óxido, 107 bytes

|a:&str,b|for i in 0..b{println!("{:^1$}",a.split("").map(|s|s.repeat(i+1)).collect::<String>(),a.len()*b)}

enlace de corralito

Define una función anónima que toma un segmento y un número de cadena, imprimiendo el patrón deseado en la salida estándar. Se supone que el segmento de cadena solo contiene caracteres ASCII, pero el desafío nunca especifica que sea necesario el soporte completo de Unicode. Para ser correcto para Unicode también requeriría 117 bytes:

|a:&str,b|for i in 0..b{println!("{:^1$}",a.split("").map(|s|s.repeat(i+1)).collect::<String>(),a.chars().count()*b)}

La explicación es bastante simple:

|a:&str,b|                             // arguments, compiler can't infer the type of a unfortunately
    for i in 0..b {                    // iterate from row 0 to row b - 1
        println!(
            "{:^1$}",                  // print a line containing arg 0, centered with the width specified as arg 1
            a.split("")                // split the string into slices of one character
                .map(|s|s.repeat(i+1)) // for each slice, yield a string containing row+1 times that slice
                .collect::<String>(),  // concatenate each of the strings into one string
            a.len()*b                  // total length should be the length of the string times the amount of rows
        )
    }
Nombre de usuario censurado
fuente
1

SOGL V0.12 , 8 bytes

∫dč*∑}¹╚

Pruébalo aquí!

Explicación:

∫dč*∑}¹╚
∫    }    iterate over 1..input, pushing counter
 d        push the variable D, which sets itself to the next input as string
  č       chop into characters - a vertical array
   *      multiply horizontally by the counter
    ∑     join the array together
      ¹   wrap all that in an array
       ╚  center horizontally

No tenía ganas de actualizar mi respuesta anterior aquí, ya que usa un método diferente y usa una nueva función (er que el desafío):

dzaima
fuente
1

Python 2 , 79 77 bytes

s,n=input();m=n
while m:m-=1;print' '*(m*len(s)/2)+''.join(i*(n-m)for i in s)

Pruébalo en línea!

Editar: -2 bytes cortesía @FlipTack

Koishore Roy
fuente
Puede eliminar los corchetes [i*(n-m)for i in s], ya que .joines capaz de tomar un generador, que debería tener dos bytes.
FlipTack
0

Excel VBA, 98 bytes

Función de ventana inmediata anónima de VBE que toma la entrada como una cadena desde [A1]e int desde [B1]entonces salidas a la ventana inmediata de VBE

For i=1To[B1]:?Spc([Len(A1)/2]*([B1]-i));:For j=1To[Len(A1)]:?String(i,Mid([A1],j,1));:Next:?:Next
Taylor Scott
fuente