Data qualsiasi stringa, stampala sotto forma di un triangolo in cui il testo scorre su e giù lungo ciascuna diagonale. Ad esempio, un input di "Hello World"dovrebbe produrre:

                    d
                  l  
                r   d
              o   l  
            W   r   d
              o   l  
        o   W   r   d
      l       o   l  
    l   o   W   r   d
  e   l       o   l  
H   l   o   W   r   d
  e   l       o   l  
    l   o   W   r   d
      l       o   l  
        o   W   r   d
              o   l  
            W   r   d
              o   l  
                r   d
                  l  
                    d

Lo spazio tra ogni carattere di una riga deve essere almeno 1, al fine di mantenere il formato corretto.

Carbone , 10 7 byte

↗ＥＬθ✂θιＵＥ¹

Provalo online! Provalo online! I collegamenti sono alla versione dettagliata del codice. Spiegazione:

    ↗       Print up and to the right
     ＥＬθ✂θι All suffixes of the input, as a list down and to the right
    ＵＥ¹     Insert blank columns

La prima volta che devo usare il ＵＥcomando.

05AB1E , 10 8 7 byte

Grazie a Emigna per aver salvato 2 byte!

ðâƶ.cðζ

Utilizza la codifica 05AB1E . Provalo online!

Python 2 , 75 byte

s=input()
k=l=len(s)
while k>1-l:k-=1;m=abs(k);print' '*m+' '.join(s[m::2])

Provalo online!

Ruud ha salvato 3 byte.

C, 86 78 73 70 caratteri

for(int i=1,j=1-n;i=putchar(j*j<i*i&i-j?s[i-1]?:13:32)^13?i+1:++j<n;);

Provalo online!

Spiegazione

Implementazione ingenua: due cicli, riempimento dall'alto verso il basso, da sinistra a destra (99 byte):

for(int j=1;j<n*2;j++){for(int i=0;i<n;i++)printf("%c ",(i+j)%2&&i+1>=abs(j-n)?s[i]:' ');puts("");}

Qui, put () stampa solo \ n sull'output. Uniamo le dichiarazioni delle variabili e combiniamo j ++ con qualcosa (94 byte):

for(int i,j=0;++j<n*2;){for(i=0;i<n;i++)printf("%c ",(i+j)%2&&i>=abs(j-n)?s[i]:' ');puts("");}

Buono. La variabile j ha un intervallo 0 ... 2n; lascia che sia all'interno di -n ... n, questo semplifica la matematica. Nota che l'espressione booleana a destra di && ha sempre il valore 0 o 1. Ciò significa che possiamo sostituire && con &. 91 byte:

for(int i,j=-n;++j<n;){for(i=0;i<n;i++)printf("%c ",~(i+j)%2&i>=abs(j)?s[i]:' ');puts("");}

E ora ci siamo resi conto che stavamo stampando uno spazio extra. E sì, non abbiamo bisogno di printf () per stampare solo un singolo simbolo. 86 byte:

for(int i,j=-n;++j<n;){for(i=0;i<n;i++)putchar(~(i+j)%2&i>=abs(j)?s[i]:' ');puts("");}

Anche meglio. Notare che la condizione i * i> = j * j è uguale a i> = abs (j), ma più breve. Spostiamo put () in per l'espressione dell'incremento del ciclo. E indovina cosa? In realtà, non abbiamo bisogno delle parentesi graffe intorno a i + j. 78 byte:

for(int i,j=-n;++j<n;puts(""))for(i=0;i<n;i++)putchar(i*i>=j*j&~i+j?s[i]:' '); 

Sapevi che putchar () restituisce il personaggio che ha stampato? Usiamo XOR per testare i numeri per l'equivalenza. Sostituiamo lo spazio con il suo codice ASCII, 32. Ricorda che il codice carattere di fine riga è 13. E infine: sapevi che GCC / Clang supporta https://en.wikipedia.org/wiki/Elvis_operator ? 73 byte:

for(int i,j=-n;++j<n;)for(i=0;putchar(i*i>=j*j&~i+j?s[i]?:13:32)^13;i++);

Infine, indovina un po '? Non abbiamo bisogno di due per i loop. Possiamo sostituire brutti ~ i + j con solo ij. 70 byte:

for(int i=1,j=1-n;i=putchar(j*j<i*i&i-j?s[i-1]?:13:32)^13?i+1:++j<n;);

Lavori futuri: cambiare la direzione del loop? Questo potrebbe salvare alcuni byte, se fatto correttamente.

SOGL V0.12 , 13 10 9 byte

ēI*@∑}¹╚H

Questo utilizza una funzione che ho appena aggiunto , ma è stata documentata qualche tempo fa.

Provalo qui!
In quel collegamento ,viene aggiunto perché ciò prevede l'input nello stack e {aggiunto perché altrimenti ,verrebbe eseguito ogni volta nel ciclo

implicitly start loop over POP
ē            increase the variable E, on first push which will be 0
 I           increase by 1
  *          multiply the current character that many times
   @∑        join with spaces
     }     end loop
      ¹    wrap everything on stack in an array
       ╚   center vertically
        H  rotate counter-clockwise

Haskell , 73 byte

f s|l<-length s-1=[zipWith min s$(' '<$[1..abs x])++cycle"~ "|x<-[-l..l]]

Provalo online!

Gaia , 16 byte

$:ċ⟪×$§×⟫†€|$¦tụ

Provalo online!

Spiegazione

$                 Split into list of chars
 :ċ               Push [1 .. len(input)]
   ⟪×$§×⟫†        Apply this block to corresponding elements of the two lists:
    ×              Repetition
     $             Split into chars
      §×           Join with spaces
          €|      Centre align the rows
            $¦    Split each line into chars
              t   Transpose
               ụ  Join each row with spaces, then join the rows together with newlines

Python 2 , 86 83 byte

-3 grazie a officialaimm

lambda s,j=' '.join:map(j,zip(*(j(c*-~i).center(len(s)*2)for i,c in enumerate(s))))

Provalo online!

Gelatina , 15 byte

;€⁶ṁ"JUz⁶ZUŒBZG

Provalo online!

Ottava, 59 63 58 57 byte

@(s,a=@strjust)a([kron(+a(hankel(s)),[1 0;0 0]) '']',99)'

Provalo online!

Java, 292 byte (scusa)

public class D{
public static void main(String[]r){
String s=r[0];int L=s.length(),n=L*2-1,x=L-1,d=-1,i,j;boolean a=false,o=L%2==1;
for(i=0;i<n;i++){
for(j=0;j<L;j++)System.out.print(j<x||a&&j%2==(o?0:1)||!a&&j%2==(o?1:0)?' ':s.charAt(j));
System.out.println();
x+=d;if(x<0){x=0;d=1;}a=!a;}}}

Haskell , 81 byte

f s|l<-length s=[[last$' ':[s!!i|i>=n,mod(n+i)2<1]|i<-[0..l-1]]|n<-abs<$>[-l..l]]

Provalo online!

Java (OpenJDK 8) , 116 byte

s->{for(int l=s.length(),i=-l;++i<l;)System.out.printf("%"+l+"s%n",s.substring(i<0?-i:i).replaceAll("(.).","$1 "));}

Provalo online!

Spiegazione

s->{                                // Consumer<String> lambda
 for(int l=s.length(),i=-l;++i<l;)  // For each length between l and 1 and back to l, 
  System.out.printf("%"+l+"s%n",    // Print with align to right
    s.substring(i<0?-i:i)           // skip the first |i| characters
     .replaceAll("(.).","$1 ")      // replace every even-positioned character with a space.
   );
}

C ++, 135 byte

Ok, ecco il mio scatto con C ++:

auto f=[&](auto f,int y)->void{
  for(int i{};i<n;i++) putchar(y<0?f(f,y+1?i+1:n-1-i),'\n':i<y||i+y&1?' ':s[i]);
}; f(f,-1); f(f,-2);

Provalo online (ideone)!

Haskell , 140 137 byte

(m#n)s=(\(i,x)->' ':(last$"  ":[x:" "|rem i 2==m&&i>n]))=<<zip[0..]s
g s=((++)=<<reverse.tail)$id=<<[[(0#n)s,(1#n)s]|n<-[-1,1..length s]]

Provalo online!

Salvato 3 byte grazie a Challenger5

Non penso sia ottimale ...

fproduce una delle righe ( m= 0 o 1 è il modulo del numero di riga, nè il numero della riga)

g intercala le linee "dispari" e "pari" e aggiunge al risultato uno specchio di se stesso.

Pyth , 25 byte

j+_Km++*d;@Qdtj;%2>QdUQtK

Provalo qui.

Gelatina , 18 byte

JrLm€2Ṭ;€0a⁸o⁶ṚŒḄG

Provalo online!

Mathematica 105 byte

(c=Characters@#;l=Length@c;StringRiffle@Table[If[Abs[j-l]<i&&EvenQ[j+i],c[[i]]," "],{j,1,2l+1},{i,1,l}])&

Forse potrei radere via un altro byte o due, ma il conteggio dei caratteri sovraccarico di gestire le stringhe in Mathematica rende semplici sfide come questa non competitiva.

J, 54 byte

[:|:|.@i.@#(>@],~' '#~[)"_1[:(,' '&,)/&.>>:@i.@#<@#"0]

Provalo online! (nota che l'output su TIO ha una nuova riga e tre spazi, ma ciò non deriva dalla chiamata di funzione - probabilmente è proprio quello che fa automaticamente l'interprete J).

Penso che l'idea generale di risolverlo sia giusta, ma ci sono piccole cose che probabilmente sto facendo in modo subottimale che si stanno aggiungendo al bytecount.

Varianti precedenti

55 byte

<:@+:@#{.[:|:|.@i.@#(],~' '#~[)"_1>:@i.@#(,' '&,)/@#"0]

56 byte

<:@+:@#{.[:|:|.@i.@#(],~' '#~[)"_1#{.[:(,' '&,)//.[:]\.]

Spiegazione

Questo sarà suddiviso in alcune funzioni. Inoltre, non ero così approfondito con le ultime parti della spiegazione, quindi fatemi sapere se volete una spiegazione migliore per una determinata parte e posso modificarla in.

dup   =. >:@i.@# <@#"0 ]
space =. (,' '&,)/&.>
pad   =. |.@i.@# (>@],~' '#~[)"_1 ]
trans =. |:

• dup duplica ogni carattere quante volte il suo indice (più uno) nella stringa
• space inserisce spazi tra ogni personaggio
• pad riempie i personaggi con la giusta quantità di spazi
• trans traspone la matrice risultante

Chiamata di esempio:

   trans pad space dup 'abc'
  c
 b 
a c
 b 
  c

Dup

>:@i.@# <@#"0 ]
>:@i.@#         Indices of each character plus one
      #          Length of the string
   i.            Range [0,length)
>:               Add one
        <@#"0 ] Duplicate each character as many times as it index (plus one)
           "0   For each
          #   ]  Copy the character
>:@i.@#           as many times as it index
        <        Box the result

I risultati vengono inscatolati per impedire a J di riempire le estremità con spazi (poiché sono di lunghezza irregolare).

Chiamata di esempio:

   dup 'abc'
┌─┬──┬───┐
│a│bb│ccc│
└─┴──┴───┘

Spazio

(,' '&,)/&.>
         &.>  For each boxed element
(,' '&,)/      Insert spaces between each

Chiamata di esempio:

   space dup 'abc'
┌─┬───┬─────┐
│a│b b│c c c│
└─┴───┴─────┘

tampone

|.@i.@# (>@],~' '#~[)"_1 ]
        (>@],~' '#~[)      Pad the right arg with spaces given by the left arg
|.@i.@#                    Indices in reverse order
   i. #                     Range [0,length)
|.                          Reverse

Fondamentalmente, riempi il primo elemento con lunghezza - 1 spazi, il secondo con lunghezza - 2, ecc. Rimuove anche il pugilato.

Chiamata di esempio:

   pad space dup 'abc'
  a  
 b b 
c c c

Trasporre

Questa è solo la funzione integrata |:che prende la trasposizione di una matrice.

JavaScript (ECMAScript 6), 161 byte

(s,n=console.log)=>s.split("").map((q,i,a,p)=>n(p=" ".repeat(q=a.length-++i)+a.map((v,j)=>j>=q&&j%2==q%2?a[j]+' ':'').join(''))||p).reverse().map((v,i)=>i&&n(v))

Provalo online!

Perl 5 , 86 + 2 (-F) = 88 byte

Ho usato i suggerimenti di @ Dom e alcune mie modifiche personali per ridurre il conteggio dei byte.

for$k(0..$#F){$i=1;$a[$#F+$k]=$a[$#F-$k]=[map$i++<$k|($i+$k)%2?$":$_,@F]}say"@$_"for@a

Provalo online!

q / kdb +, 55 byte

Soluzione:

-1(+){{1_a,((2*y)#" ",z),a:x#" "}'[(|)c;1+c:(!)(#)x]x};

Esempio:

q)-1(+){{1_a,((2*y)#" ",z),a:x#" "}'[(|)c;1+c:(!)(#)x]x}"Hello World";
          d
         l
        r d
       o l
      W r d
       o l
    o W r d
   l   o l
  l o W r d
 e l   o l
H l o W r d
 e l   o l
  l o W r d
   l   o l
    o W r d
       o l
      W r d
       o l
        r d
         l
          d

Spiegazione:

FARE. la versione ungolf è di 66 byte:

-1 flip{{1_a,((2*y)#" ",z),a:x#" "}'[reverse c;1+c:til count x]x};

Bonus:

Per ottenere lo stesso output dell'esempio (74 byte):

q)-1(+){1_'raze{(a,((2*y)#" ",z),a:x#" ";(2*y+x)#" ")}'[(|)c;1+c:(!)(#)x]x}"Hello World";
                    d
                  l
                r   d
              o   l
            W   r   d
              o   l
        o   W   r   d
      l       o   l
    l   o   W   r   d
  e   l       o   l
H   l   o   W   r   d
  e   l       o   l
    l   o   W   r   d
      l       o   l
        o   W   r   d
              o   l
            W   r   d
              o   l
                r   d
                  l
                    d