Ausgehend von einer nicht leeren Zeichenfolge s mit gerader Länge und einer positiven Ganzzahl n, die ihre Höhe darstellt, erstellen Sie eine Pyramide nach den folgenden Regeln:

Die Pyramide sollte n nicht leere Zeilen enthalten. nachgestellte Zeilenumbrüche sind erlaubt. Für jede 1 <= i <= n sollte die i-te Zeile die Zeichenfolge enthalten, wobei jedes einzelne Zeichen i-mal an der richtigen Stelle wiederholt wird. abcd wird dreimal wiederholt und zu aaabbbcccddd. Jede Zeile sollte mit Abständen zentriert sein, sodass die Mitte jeder Zeile vertikal ausgerichtet ist. Leerzeichen am Ende jeder Zeile sind zulässig. Sie können auch bis zu eine führende neue Zeile, jedoch kein anderes Leerzeichen vor der ersten Zeile einfügen.

Es ist nicht garantiert, dass die Eingabezeichenfolge ein Palindrom ist.

Testfall

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

Probieren Sie es online!

γwurde in kurzer Zeit von Adnans Antwort inspiriert; Swürde aber auch funktionieren.

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

Verwendet die 05AB1E- Codierung. Probieren Sie es online!

Jelly , 14 13 Bytes

LH×Ḷ}Ṛ⁶ẋżxЀY

Probieren Sie es online!

Wie es funktioniert

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

Probieren Sie es online!

Gibt eine Aufzählung von strings mit den Linien der Zeichnung zurück. Nach dem Beitritt sieht das Ergebnis so aus:

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

• 2 Bytes gespart dank Kevin Cruijssen!
• Dank Value Ink 1 Byte gespart!
• 6 Bytes gespart dank LiefdeWen!

Cheddar , 71 64 Bytes

7 Bytes dank @ValueInk eingespart

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

Probieren Sie es online! Ich werde gleich eine Erklärung hinzufügen

Erläuterung

(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}*$/}

Probieren Sie es online!

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) aufgrund eines Bugfixes (es wurden n+1stattdessen Zeilen ausgegeben n). Es kommt nicht oft vor, dass ein Bugfix Bytes spart. :)
-2 Bytes (183 → 181) dank @ OlivierGrégoire

Erläuterung:

Probieren Sie es hier aus.

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

Übernimmt Eingaben in der Currying-Syntax (string)(height). Beinhaltet eine führende Newline.

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

Demo

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>

Holzkohle , 19 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

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

Wir brauchen Zeilen, die sich 1..nmehrmals wiederholen . Der einfachste Weg, dies zu erreichen, ist eine Schleife von 0 nach n, da die Schleife 0 im Grunde genommen ein No-Op ist.

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

Positionieren Sie den Cursor so, dass die resultierende Linie zentriert ist.

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

Und so einfach ist es, jedes Zeichen mehrmals zu drucken 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)

Probieren Sie es online!

SOGL V0.12 , 14 Bytes

ā.∫dI*Hd⁄»±IFž

Probieren Sie es hier aus!

Javascript, 105 Bytes

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

Nach ein paar Jahren ist der Stretch Maniac zurück, hoffentlich diesmal etwas besser ausgebildet.

Haskell , 79 73 69 Bytes

• 4 Bytes dank nimi gespart

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

Probieren Sie es online!

APL (Dyalog) , 33 31 Bytes

2 Bytes dank @ZacharyT durch Entfernen unnötiger Klammern golfen

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

Probieren Sie es online!

Erläuterung

Das rechte Argument ⍵ist die Zeichenfolge und das linke Argument ⍺ist die Zahl.

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

Es ist nicht die kompakteste Lösung (vielleicht das Rad neu erfinden, anstatt eingebaute Verfahren anzuwenden), aber es scheint zu funktionieren.

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

Prüfung:

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

Erläuterung:

w und s schreiben die richtige Anzahl von führenden Leerzeichen:

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 verwaltet die "Vervielfältigung" von Zeichen und e ist die rekursive Funktion:

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

a und l hängen an das Ergebnis an (möglicherweise gibt es eine eingebaute Prozedur?):

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 erstellt die Ausgabe:

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

und schließlich ist das p die Hauptmethode :

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

Gibt ein Array von Zeilen aus - fügen Sie 2 Bytes hinzu, wenn dies nicht zulässig ist.

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

Probier es aus

• Dank ETHproductions 1 Byte gespart

Erläuterung

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

Laufen Sie mit php -nr '<code>' '<string>' <N>oder testen Sie es online .

Nervenzusammenbruch

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

Probieren Sie es online!

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

Die Eingabe erfolgt über bereits vorhandene Tabelle t mit Spalten s und n , je unseren IO - Standards .

Es ist nicht viel zu erklären, es ist eine ziemlich einfache verschachtelte Schleife, die @ifür die Zeilen verwendet wird und @jum durch die Zeichen der Zeichenfolge zu gehen, die REPLICATED @iZeiten sind:

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="",'
')

Probieren Sie es online!

Erläuterung:

Es ist ziemlich unkompliziert, die Zeichenfolge zu teilen und die Elemente in der Schleife ijedes Mal zu wiederholen rep(s,e=i)(dies eist die Abkürzung für each). Der schwierige Teil ist rep('',(n-i)/2*length(s)+1). Dies ist die Füllzeichenfolge, aber es sind ein paar leere Zeichenfolgen. Ich muss 1 hinzufügen, da das Ergebnis sonst character(0)ein Vektor mit der Länge Null ist und catdie letzte Linie standardmäßig durch Leerzeichen voneinander trennt.

Mathematica, 97 Bytes

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

Eingang

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

Prüfung:

% 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

Anmerkung: Die "cd" am Ende des Vorgangs verhindert, dass das Ergebnis der Zeit unterhalb der Pyramide ausgedruckt wird, ändert jedoch das aktuelle Verzeichnis - ein Nebeneffekt, der nicht ausdrücklich verboten ist.

Vielen Dank an Sergiol für einen Hinweis zum Speichern eines Bytes ... und einen weiteren Hinweis zum Speichern eines weiteren Bytes.

Dank Aspekt (im tcl-Chat) für weitere 3 Bytes gespart!

Schnell, 232 Bytes

Wahrscheinlich könnte es besser sein, aber ich habe nicht viel Zeit zum Umgestalten.

Diese Antwort verwendet Swift 4, sodass sie derzeit nicht online ausgeführt werden kann.

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 Bytes

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

Probieren Sie den Code im FMSLogo-Interpreter aus.

Definieren Sie eine Funktion, fdie zwei Eingaben annimmt, :sund :ndrucken Sie dann das Ergebnis aus.

Java 8, 164 148 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;}

Erläuterung:

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

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

Laufgitter-Link

Definiert eine anonyme Funktion, die ein Zeichenfolgen-Slice und eine Zahl verwendet und das gewünschte Muster in der Standardausgabe ausgibt. Es wird davon ausgegangen, dass das Zeichenfolgen-Slice nur ASCII-Zeichen enthält, die Abfrage gibt jedoch niemals an, dass eine vollständige Unicode-Unterstützung erforderlich ist. Um auch für Unicode korrekt zu sein, wären 117 Bytes erforderlich:

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

Die Erklärung ist ziemlich einfach:

|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č*∑}¹╚

Probieren Sie es hier aus!

Erläuterung:

∫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

Ich hatte keine Lust, meine alte Antwort hier zu aktualisieren, da sie eine andere Methode verwendet und eine neue (äh als die Herausforderung) Funktion verwendet. ╚

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)

Probieren Sie es online!

Edit: -2 Bytes mit freundlicher Genehmigung von @FlipTack

Excel VBA, 98 Bytes

Anonyme VBE-Direktfensterfunktion, die Eingaben als Zeichenfolge von [A1]und int übernimmt und [B1]dann an das VBE-Direktfenster ausgibt

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