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

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.

05AB1E , 11 bytes

F²γN>×J}».C

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

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.

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!

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

Ruby , 58 bytes

->s,n{(1..n).map{|i|s.gsub(/./){$&*i}.center s.size*n}*$/}

Pruébalo en línea!

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

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

let f =

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

o.innerHTML = f('o-o  o-o')(10)

<pre id=o></pre>

Carbón de leña , 19 bytes

Ｆ⁺¹Ｎ«Ｊ±×ι÷Ｌη²ιＦηＦικ

Pruébalo en línea! El enlace es a la versión detallada del código. Explicació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.

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

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

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

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

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!

SOGL V0.12 , 14 bytes

ā.∫dI*Hd⁄»±IFž

Pruébalo aquí!

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.

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!

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

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

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

• Guardado 1 byte gracias a ETHproductions

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.

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

CJam , 36 bytes

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

Pruébalo en línea!

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

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.

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]

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!

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

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.

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

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

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): ╚

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

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