Dada cualquier cadena, imprímala en forma de triángulo donde el texto corre hacia arriba y hacia abajo a lo largo de cada diagonal. Por ejemplo, una entrada de "Hello World"debería salir:

                    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

El espacio entre cada carácter en una fila debe ser al menos 1, para mantener el formato adecuado.

Carbón , 10 7 bytes

↗ＥＬθ✂θιＵＥ¹

Pruébalo en línea! Pruébalo en línea! Los enlaces son a la versión detallada del código. Explicación:

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

La primera vez pude usar el ＵＥcomando.

05AB1E , 10 8 7 bytes

¡Gracias a Emigna por guardar 2 bytes!

ðâƶ.cðζ

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

Python 2 , 75 bytes

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

Pruébalo en línea!

Ruud ahorró 3 bytes.

C, 86 78 73 70 caracteres

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

Pruébalo en línea!

Explicación

Implementación ingenua: dos ciclos, relleno de arriba a abajo, de izquierda a derecha (99 bytes):

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

Aquí, pone () solo imprime \ n en la salida. Combinemos declaraciones de variables y combinemos j ++ con algo (94 bytes):

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

Bueno. La variable j tiene un rango de 0 ... 2n; déjelo estar dentro de -n ... n, esto simplifica las matemáticas. Observe que la expresión booleana a la derecha de && siempre tiene el valor 0 o 1. Esto significa que podemos reemplazar && con &. 91 bytes:

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

Y ahora nos dimos cuenta de que imprimimos un espacio extra. Y sí, no necesitamos printf () para imprimir un solo símbolo. 86 bytes:

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

Aun mejor. Observe que la condición i * i> = j * j es la misma que i> = abs (j), pero más corta. Vamos a mover pone () en la expresión de incremento de bucle. ¿Y adivina qué? En realidad, no necesitamos las llaves alrededor de i + j. 78 bytes:

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

¿Sabía que putchar () devuelve el carácter que ha impreso? Usemos XOR para probar números para equivalencia. Reemplacemos el espacio con su código ASCII, 32. Recuerde que el código de caracteres al final de la línea es 13. Y finalmente: ¿Sabía que GCC / Clang admite https://en.wikipedia.org/wiki/Elvis_operator ? 73 bytes:

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

Finalmente, ¿adivina qué? No necesitamos dos para bucles. Podemos reemplazar feo ~ i + j con solo ij. 70 bytes:

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

Trabajo futuro: ¿cambiar la dirección del circuito? Esto podría ahorrar algunos bytes, si se hace correctamente.

SOGL V0.12 , 13 10 9 bytes

ēI*@∑}¹╚H

Utiliza una función que acabo de agregar , pero que se documentó hace un tiempo.

Pruébalo aquí!
En ese enlace ,se agrega porque esto espera la entrada en la pila y se {agrega porque de lo contrario ,se ejecutaría cada vez en el 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 bytes

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

Pruébalo en línea!

Gaia , 16 bytes

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

Pruébalo en línea!

Explicación

$                 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 bytes

-3 gracias a officialaimm

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

Pruébalo en línea!

Jalea , 15 bytes

;€⁶ṁ"JUz⁶ZUŒBZG

Pruébalo en línea!

Octava, 59 63 58 57 bytes

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

Pruébalo en línea!

Java, 292 bytes (lo siento)

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 bytes

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

Pruébalo en línea!

Java (OpenJDK 8) , 116 bytes

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

Pruébalo en línea!

Explicación

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 bytes

Bien, aquí está mi oportunidad 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);

¡Pruébelo en línea (ideone)!

Haskell , 140 137 bytes

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

Pruébalo en línea!

Guardado 3 bytes gracias a Challenger5

No creo que sea óptimo ...

fproduce una de las líneas ( m= 0 o 1 es el módulo del número de línea, nes el número de la línea)

g intercala líneas "impares" y "pares", y agrega al resultado un espejo de sí mismo.

Pyth , 25 bytes

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

Pruébalo aquí

Jalea , 18 bytes

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

Pruébalo en línea!

Mathematica 105 Bytes

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

Tal vez podría eliminar otro byte o dos, pero el recuento de caracteres sobrecargado de lidiar con cadenas en Mathematica hace que desafíos simples como este no sean competitivos.

J, 54 bytes

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

Pruébalo en línea!(tenga en cuenta que la salida en TIO tiene una nueva línea y tres espacios, pero eso no proviene de la llamada a la función; probablemente sea lo que el intérprete J hace automáticamente).

Creo que la idea general para resolver esto es correcta, pero hay cosas pequeñas que probablemente estoy haciendo de manera subóptima que se están agregando al conteo de bytes.

Variantes anteriores

55 bytes

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

56 bytes

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

Explicación

Esto se dividirá en algunas funciones. Además, no fui tan minucioso con las últimas partes de la explicación, así que avíseme si desea una mejor explicación para cierta parte y puedo editarla.

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

• dup duplica cada carácter tantas veces como su índice (más uno) en la cadena
• space inserta espacios entre cada personaje
• pad rellena los caracteres con la cantidad correcta de espacios
• trans transpone la matriz resultante

Llamada de muestra:

   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

Los resultados están encuadrados para evitar que J rellene los extremos con espacios (ya que son de longitud desigual).

Llamada de muestra:

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

Espacio

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

Llamada de muestra:

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

Almohadilla

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

Básicamente, rellene el primer elemento con longitud - 1 espacios, el segundo con longitud - 2, etc. También elimina el boxeo.

Llamada de muestra:

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

Transponer

Esta es solo la función incorporada |:que toma la transposición de una matriz.

JavaScript (ECMAScript 6), 161 bytes

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

Pruébalo en línea!

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

Usé las sugerencias de @ Dom y algunos de mis propios ajustes para reducir el recuento de bytes.

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

Pruébalo en línea!

q / kdb +, 55 bytes

Solución:

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

Ejemplo:

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

Explicación:

QUE HACER. la versión sin golf es de 66 bytes:

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

Prima:

Para obtener el mismo resultado que el ejemplo (74 bytes):

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