Soit une chaîne s vide, de longueur paire, et un entier positif n, représentant sa hauteur, composez une pyramide en appliquant les règles suivantes:

La pyramide doit contenir n lignes non vides; les retours à la ligne sont autorisés. Pour chaque 1 <= i <= n, la i-ème ligne doit contenir la chaîne avec chaque caractère individuel répété à la place i fois; abcd répété 3 fois car tel devient aaabbbcccddd. Chaque ligne doit être centrée avec des espaces de remplissage de manière à ce que le milieu de chaque ligne soit aligné verticalement. Les espaces de fin à la fin de chaque ligne sont autorisés. Vous pouvez également avoir jusqu'à une nouvelle ligne principale, mais aucun autre espace avant la première ligne.

Il n'est pas garanti que la chaîne d'entrée soit un palindrome.

Cas de test

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 octets

γ².D)ƶJ.C

Essayez-le en ligne!

γétait en grande partie inspiré par la réponse d'Adnan; mais Sfonctionnerait aussi.

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

F²γN>×J}».C

Utilise le codage 05AB1E . Essayez-le en ligne!

Gelée , 14 à 13 octets

LH×Ḷ}Ṛ⁶ẋżxЀY

Essayez-le en ligne!

Comment ça marche

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 octets

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

Essayez-le en ligne!

Retourne une énumération de strings avec les lignes du dessin. Une fois rejoint le résultat est comme ça:

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

• 2 octets économisés grâce à Kevin Cruijssen!
• 1 octet économisé grâce à Value Ink!
• 6 octets sauvés grâce à LiefdeWen!

Cheddar , 71 64 octets

Sauvegardé 7 octets grâce à @ValueInk

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

Essayez-le en ligne! Je vais ajouter une explication dans un peu

Explication

(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 octets

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

Essayez-le en ligne!

Java 8, 188 186 185 183 183 181 173 octets

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 octets (185 → 183) en raison d'une correction de bugs (il s'agissait de n+1lignes en sortie au lieu de n). Il n'arrive pas souvent qu'un correctif de bogue sauve des octets. :)
-2 octets (183 → 181) grâce à @ OlivierGrégoire

Explication:

Essayez ici.

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 octets

Prend des entrées dans la syntaxe de currying (string)(height). Inclut une nouvelle ligne principale.

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

Démo

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>

Charbon de bois , 19 octets

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

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Explication:

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

Nous avons besoin de lignes répétées plusieurs 1..nfois. Le moyen le plus simple d'y parvenir est de passer de 0 à n en boucle, car la boucle 0 est fondamentalement non-op.

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

Positionnez le curseur de sorte que la ligne résultante soit centrée.

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

Et voici à quel point il est simple d’imprimer chaque caractère à plusieurs ireprises.

Python 2 , 75 77 octets

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

Essayez-le en ligne!

SOGL V0.12 , 14 octets

ā.∫dI*Hd⁄»±IFž

Essayez-le ici!

Javascript, 105 octets

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

Après quelques années de repos, le Stretch Maniac est de retour, avec un peu plus d’instruction cette fois-ci.

Haskell , 79 73 69 octets

• 4 octets sauvés grâce à nimi

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

Essayez-le en ligne!

APL (Dyalog) , 33 31 octets

2 octets joués au golf grâce à @ZacharyT en supprimant les parenthèses inutiles

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

Essayez-le en ligne!

Explication

L'argument de droite ⍵est la chaîne et l'argument de gauche ⍺est le nombre.

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

Ce n'est pas la solution la plus compacte (peut-être réinventer la roue au lieu d'utiliser des procédures intégrées), mais cela semble fonctionner.

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

Tester:

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

Explication:

w et s écrit la quantité appropriée d'espaces de début:

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

ré gère la "duplication" des caractères et e est sa facilité récursive:

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

une et l sont ajoutés au résultat (peut-être existe-t-il une procédure intégrée?):

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 crée la sortie:

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

et finalement le p est la méthode 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 octets

Sort un tableau de lignes - ajoutez 2 octets si cela n'est pas autorisé.

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

Essaye-le

• Sauvegardé 1 octet grâce à ETHproductions

Explication

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

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

Courez avec php -nr '<code>' '<string>' <N>ou testez-le en ligne .

panne

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

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

Essayez-le en ligne!

T-SQL, 223 octets

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 saisie s'effectue via la table préexistante t avec les colonnes s et n , conformément à nos normes IO .

Pas grand chose à expliquer, c'est une boucle imbriquée assez simple, utilisant @ipour les lignes et @jpour parcourir les caractères de la chaîne qui sont des REPLICATED @ifois:

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 octets

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

Essayez-le en ligne!

Explication:

C'est assez simple, diviser la chaîne et répéter les éléments ifois rep(s,e=i)( ec'est l'abréviation de each) en boucle. La partie délicate est rep('',(n-i)/2*length(s)+1). C'est la chaîne de remplissage, mais c'est un tas de chaînes vides. Je dois ajouter 1 car sinon, le résultat est character(0)un vecteur de longueur nulle et cat, qui sépare par défaut ses éléments avec des espaces, désaligne la dernière ligne.

Mathematica, 97 octets

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

contribution

["oo oo", 10]

Tcl, 143 142 141 138 octets

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}

Tester:

% 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

Remarque: le "cd" à la fin de la procédure empêche l'impression du résultat de l'heure en dessous de la pyramide, mais modifie le répertoire en cours - un effet secondaire qui n'est pas explicitement interdit.

Merci à sergiol de lui avoir laissé un indice pour sauvegarder un octet ... et un autre indice en vue de sauver un octet supplémentaire.

Merci à aspect (sur le chat tcl) d’avoir encore 3 octets sauvés!

Swift, 232 octets

Ça pourrait probablement être mieux, mais je n'ai pas beaucoup de temps pour refactoriser.

Cette réponse utilise Swift 4, elle ne peut donc pas être exécutée actuellement en ligne.

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 octets

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

Essayez le code sur l'interpréteur FMSLogo.

Définir une fonction fqui prend deux entrées, :set :npuis imprimer le résultat.

Java 8, 164 148 octets

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

Explication:

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

Rouille, 107 octets

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

lien parc

Définit une fonction anonyme qui prend une tranche de chaîne et un nombre, imprimant le motif souhaité sur la sortie standard. Il suppose que la tranche de chaîne ne contient que des caractères ASCII, mais le défi ne spécifie jamais qu'une prise en charge complète de l'unicode est nécessaire. Pour être correct pour unicode également, il faudrait 117 octets:

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

L'explication est assez 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 octets

∫dč*∑}¹╚

Essayez-le ici!

Explication:

∫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

Je n'avais pas envie de mettre à jour mon ancienne réponse ici car elle utilise une méthode différente et utilise une nouvelle fonctionnalité (autre que le défi) - ╚

Python 2 , 79 77 octets

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

Essayez-le en ligne!

Edit: -2 bytes avec la permission de @FlipTack

Excel VBA, 98 octets

Fonction de fenêtre immédiate VBE anonyme qui prend l’entrée sous forme de chaîne de [A1]et int de [B1]sortie ensuite dans la fenêtre immédiate 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