Data una stringa non vuota s, con lunghezza pari e un numero intero positivo n, che rappresenta la sua altezza, comporre una piramide usando le seguenti regole:

La piramide dovrebbe contenere n righe non vuote; sono consentite nuove righe finali. Per ogni 1 <= i <= n, l'i-esima riga deve contenere la stringa con ogni singolo carattere ripetuto sul posto i volte; abcd ripetuto 3 volte in quanto tale diventa aaabbbcccddd. Ogni linea deve essere centrata con spazi di riempimento in modo che il centro di ogni linea sia allineato verticalmente. Sono consentiti spazi finali alla fine di ogni riga. Puoi anche avere fino a una nuova riga iniziale ma nessun altro spazio bianco prima della prima riga.

La stringa di input non è garantita per essere un palindromo.

Test Case

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 byte

γ².D)ƶJ.C

Provalo online!

γfu, in breve, ispirato dalla risposta di Adnan; ma Sfunzionerebbe anche.

γ          # 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 byte

F²γN>×J}».C

Utilizza la codifica 05AB1E . Provalo online!

Gelatina , 14 13 byte

LH×Ḷ}Ṛ⁶ẋżxЀY

Provalo online!

Come funziona

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 byte

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

Provalo online!

Restituisce un'enumerazione di strings con le linee del disegno. Una volta unito il risultato è così:

                        ಠ_ಠ  ಠ_ಠ
                    ಠಠ__ಠಠ    ಠಠ__ಠಠ
                ಠಠಠ___ಠಠಠ      ಠಠಠ___ಠಠಠ
            ಠಠಠಠ____ಠಠಠಠ        ಠಠಠಠ____ಠಠಠಠ
        ಠಠಠಠಠ_____ಠಠಠಠಠ          ಠಠಠಠಠ_____ಠಠಠಠಠ
    ಠಠಠಠಠಠ______ಠಠಠಠಠಠ            ಠಠಠಠಠಠ______ಠಠಠಠಠಠ
ಠಠಠಠಠಠಠ_______ಠಠಠಠಠಠಠ              ಠಠಠಠಠಠಠ_______ಠಠಠಠಠಠಠ

• 2 byte salvati grazie a Kevin Cruijssen!
• 1 byte risparmiato grazie a Value Ink!
• 6 byte salvati grazie a LiefdeWen!

Cheddar , 71 64 byte

Salvato 7 byte grazie a @ValueInk

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

Provalo online! Aggiungerò una spiegazione tra poco

Spiegazione

(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

Rubino , 58 byte

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

Provalo online!

Java 8, 188 186 185 183 181 173 byte

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 byte (185 → 183) a causa di una correzione di bug (stava n+1invece emettendo righe anziché n). Non succede spesso che una correzione di bug salvi i byte. :)
-2 byte (183 → 181) grazie a @ OlivierGrégoire

Spiegazione:

Provalo qui.

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 byte

Accetta input nella sintassi del curry (string)(height). Include una nuova linea principale.

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

dimostrazione

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>

Carbone , 19 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

Ｆ⁺¹Ｎ«       for (Plus(1, InputNumber())) {

Abbiamo bisogno di linee ripetute 1..nvolte. Il modo più semplice per raggiungere questo obiettivo è passare da 0 a n, poiché il ciclo 0 è fondamentalmente no-op.

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

Posizionare il cursore in modo che la linea risultante sia centrata.

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

Ed è così semplice la stampa di ogni personaggio ripetuto più ivolte.

Python 2 , 75 77 byte

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

Provalo online!

SOGL V0.12 , 14 byte

ā.∫dI*Hd⁄»±IFž

Provalo qui!

Javascript, 105 byte

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

Dopo alcuni anni di pausa, Stretch Maniac è tornato, speriamo un po 'più educato questa volta.

Haskell , 79 73 69 byte

• Salvato 4 byte grazie a nimi

s#n=unlines[(' '<$[1,3..(n-m)*length s])++((<$[1..m])=<<s)|m<-[1..n]]

Provalo online!

APL (Dyalog) , 33 31 byte

2 byte giocati a golf grazie a @ZacharyT rimuovendo le parentesi non necessarie

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

Provalo online!

Spiegazione

L'argomento destro ⍵è la stringa e l'argomento sinistro ⍺è il numero.

{↑((' '/⍨(.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 byte

Non è la soluzione più compatta (forse da qualche parte reinventare la ruota invece di utilizzare le procedure integrate), ma sembra funzionare.

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

Test:

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

Spiegazione:

w e s scrive la giusta quantità di spazi iniziali:

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 gestisce la "duplicazione" dei personaggi ed e è la sua struttura ricorsiva:

//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 e l accodamento al risultato (forse esiste una costruito nel procedimento?):

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 l'output:

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

e infine la p è il metodo principale :

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 byte

Emette un array di righe: aggiungi 2 byte se non è consentito.

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

Provalo

• Salvato 1 byte grazie a ETHproductions

Spiegazione

      :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 byte:

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

Esegui php -nr '<code>' '<string>' <N>o prova online .

abbattersi

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

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

Provalo online!

T-SQL, 223 byte

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

L'input avviene tramite una tabella preesistente t con colonne s e n , secondo i nostri standard IO .

Non c'è molto da spiegare, è un loop nidificato piuttosto semplice, che usa @iper le righe e @jper camminare attraverso i caratteri della stringa che sono REPLICATED @ivolte:

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 byte

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

Provalo online!

Spiegazione:

È abbastanza semplice, suddividere la stringa e ripetere gli elementi iogni volta rep(s,e=i)( eè l'abbreviazione each) mentre eseguiamo il loop. La parte difficile è rep('',(n-i)/2*length(s)+1). Questa è la stringa di riempimento, ma è un mucchio di stringhe vuote. Devo aggiungere 1 perché altrimenti il ​​risultato è character(0)un vettore di lunghezza zero e cat, che per impostazione predefinita separa i suoi elementi con spazi, disallinea la linea finale.

Mathematica, 97 byte

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

ingresso

["oo oo", 10]

Tcl, 143 142 141 138 byte

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}

Test:

% 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

Nota: il "cd" alla fine della procedura impedisce che il risultato del tempo venga stampato sotto la piramide, ma cambia la directory corrente - un effetto collaterale che non è esplicitamente vietato.

Grazie a sergiol per un suggerimento per salvare un byte .... e un altro suggerimento per salvare un altro byte.

Grazie all'aspetto (sulla chat di tcl) per altri 3 byte salvati!

Rapido, 232 byte

Probabilmente potrebbe essere migliore, ma non ho molto tempo per fare il refactoring.

Questa risposta utilizza Swift 4, quindi al momento non può essere eseguita online.

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

LOGO, 97 95 byte

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

Prova il codice sull'interprete FMSLogo.

Definire una funzione fche prende due ingressi, :se :n, quindi stampare il risultato.

Java 8, 164 148 byte

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

Spiegazione:

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

Ruggine, 107 byte

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

collegamento box

Definisce una funzione anonima che accetta una porzione di stringa e un numero, stampando il modello desiderato sull'output standard. Presuppone che la porzione di stringa contenga solo caratteri ASCII, ma la sfida non specifica mai che sia necessario il supporto unicode completo. Per essere corretti anche per Unicode richiederebbe 117 byte:

|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 spiegazione è piuttosto semplice:

|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 byte

∫dč*∑}¹╚

Provalo qui!

Spiegazione:

∫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

Non mi andava di aggiornare qui la mia vecchia risposta in quanto utilizza un metodo diverso e utilizza una nuova funzionalità (più della sfida) - ╚

Python 2 , 79 77 byte

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

Provalo online!

Modifica: -2 byte per gentile concessione di @FlipTack

Excel VBA, 98 byte

Funzione di finestra immediata VBE anonima che accetta l'input come stringa da [A1]e int, [B1]quindi esce alla finestra immediata VBE

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