Dada una cadena cuya longitud es divisible por 4, haga un triángulo como se muestra a continuación.

Si la cadena es abcdefghijkl, entonces el triángulo sería:

   a
  b l
 c   k
defghij

Si la cadena es iamastringwithalengthdivisiblebyfour, entonces el triángulo sería:

         i
        a r
       m   u
      a     o
     s       f
    t         y
   r           b
  i             e
 n               l
gwithalengthdivisib

Si la cadena es thisrepresentationisnotatriangle, entonces el triángulo sería:

        t
       h e
      i   l
     s     g
    r       n
   e         a
  p           i
 r             r
esentationisnotat

Notas

• La cadena solo constará de caracteres de aa z.
• Se permiten espacios en blanco iniciales y finales y nuevas líneas siempre que la forma no se rompa.
• Se permite una lista de cadenas como salida.

Este es el código de golf . La respuesta más corta en bytes gana. Se aplican lagunas estándar .

Carbón , 25 22 21 bytes

≔÷Ｌθ⁴λ↙…θλ→✂θλ±λ↖✂θ±λ

Pruébalo en línea! El enlace es a la versión detallada del código. Simplemente corta la cuerda en tres partes e imprímelas en las direcciones apropiadas. Editar: guardado 3 bytes mediante el uso de división entera y segmentación. Se guardó un byte adicional utilizando en CycleChoplugar de Slicepara el encabezado de la cadena. Editar: el carbón ahora admite dibujar texto arbitrario a lo largo del borde de un polígono, simplificando el código a 12 bytes:

ＧＨ↙→→↖⊕÷Ｌθ⁴θ

Pruébalo en línea! El enlace es a la versión detallada del código.

05AB1E , 23 bytes

ćsIg4÷GćsÁćsŠN·<ú«s}».C

Pruébalo en línea!

Explicación

ć                        # extract head of input
 s                       # swap the remaining string to top of stack
  Ig4÷G                  # for N in [1...len(input)/4-1] do:
       ć                 # extract head
        sÁ               # swap remaining string to top of stack and rotate right
          ć              # extract head
           sŠ            # reorder stack as tail, head, remaining
             N·<ú        # prepend N-1 spaces to tail
                 «s      # concatenate with head and swap remaining string to top
                   }     # end loop
                    ».C  # join by newlines and center

JavaScript (ES6), 119 117 108 105 bytes

s=>(l=s.length/4,S=' ',g=([c,...s],p)=>S.repeat(l)+c+(l--?p+s.pop()+`
`+g(s,p?p+S+S:S):s.join``))(s+S,'')

Formateado y comentado

s => (                            // given the input string s:
  l = s.length / 4,               // l = length of side edge - 1
  S = ' ',                        // S = space (defining S costs 6 bytes but saves 7)
  g = (                           // g = recursive function which takes:
       [c,                        //   - c = next character
           ...s],                 //   - s = array of remaining characters
                  p) =>           //   - p = middle padding string
    S.repeat(l) + c + (           // append left padding + left character
      l-- ?                       // if side edges are not complete:
        p + s.pop() + '\n' +      //   append middle padding + right character + Line Feed
        g(s, p ? p + S + S : S)   //   and do a recursive call with updated middle padding
      :                           // else:
        s.join``                  //   append all remaining characters and stop recursion
    )                             //   (this is the bottom edge)
  )(s + S, '')                    // initial call to g()

Casos de prueba

let f =

s=>(l=s.length/4,S=' ',g=([c,...s],p)=>S.repeat(l)+c+(l--?p+s.pop()+`
`+g(s,p?p+S+S:S):s.join``))(s+S,'')

console.log(f('abcdefghijkl'))
console.log(f('iamastringwithalengthdivisiblebyfour'))
console.log(f('thisrepresentationisnotatriangle'))

C #, 260 bytes

namespace System{using static Console;class P{static void Main(){var d=ReadLine();int e=d.Length/4,x=e,y=0,g=0,i=0;Action<int,int>a=(p,q)=>{SetCursorPosition(p,q);Write(d[g++]);};for(;i<e;i++)a(x--,y++);for(i=0;i<e*2;i++)a(x++,y);for(i=0;i<e;i++)a(x--,y--);}}}

Realmente quería usar SetCursorPosition.

Sin golf:

namespace System {
    using static Console;

    class P {
        static void Main() {
            var d = ReadLine();
            int e = d.Length / 4, x = e, y = 0, g = 0, i = 0;
            Action<int, int> a = (p, q) => { SetCursorPosition(p, q); Write(d[g++]); };
            for (; i < e; i++)
                a(x--, y++);
            for (i = 0; i < e * 2; i++)
                a(x++, y);
            for (i = 0; i < e; i++)
                a(x--, y--);
        }
    }
}

Mathematica, 164 bytes

(b=Length[c=Characters@#];k=Column[#,Alignment->Center]&;T=Table;k@{#&@@c,k@T[""<>{c[[i+2]],T[" ",2i+1],c[[-i-1]]},{i,0,(a=b/4)-2}],""<>T[c[[i]],{i,a+1,b/2+1+a}]})&

entrada

["iamastringwithalengthdivisiblebyfour"]

Python 3 , 120 bytes

Primero golf, pensé que bien podría aprender algo de Python en el camino.

a=input()
l=len(a)//4
print(l*" "+a[0])
for i in range(1,l):print((l-i)*" "+a[i]+(2*i-1)*" "+a[4*l-i])
print(a[l:3*l+1])

Pruébalo en línea!

Explicación:

El primer carácter se imprime solo después de los len(a)//4espacios, luego se imprimen los caracteres primero y último a ipartir del segundo, separados por 2*i - 1espacios.

Finalmente, se imprime la subcadena restante.

GNU sed , 178 158 132 + 1 = 133 bytes

+1 byte para -rbandera.

s/(.)(.*)(.)/ \1\n\2;\3/
:
s/( *)(.\n.)(.*)(...);(.*)(.)/\1\2\1  \6\n\3;\4\5/m
t
:A
s/(.*\n)( *)(.*);/ \2;\1\2\3/m
tA
s/. (.)$/\1/gm

Pruébalo en línea!

Explicación

En revisiones anteriores , utilicé muchos bytes relacionados con matemáticas, casos especiales y limpieza, aunque intuitivamente estaba seguro de que podrían evitarse. Desde entonces he logrado hacerlo, principalmente.

Supongamos que tenemos la entrada abcdEFGHIJKLMnop. Las letras EFGHIJKLMserán la parte inferior del triángulo, así que las he capitalizado como una ayuda visual.

Primero preparamos la entrada colocando el primer carácter en su propia línea (precedido por un espacio) e insertando un cursor ( ;) antes del último carácter:

s/(.)(.*)(.)/ \1\n\2;\3/

Ahora tenemos:

 a
bcdEFGHIJKLMno;p

Ahora, en un bucle, vamos a hacer algunas cosas en la última línea: 1. Copie los espacios de la línea anterior e insértelos después del primer carácter, más dos; 2. Mueva el último carácter a la derecha después de los espacios, seguido de una nueva línea; y 3. Mueva el cursor tres caracteres hacia la izquierda.

:
  s/( *)(.\n.)(.*)(...);(.*)(.)/\1\2\1  \6\n\3;\4\5/m
  t

Aquí está el resultado de cada iteración:

 a
b   p
cdEFGHIJKL;Mno

 a
b   p
c     o
dEFGHI;JKLMn

 a
b   p
c     o
d       n
EF;GHIJKLM

Puedes ver que la pirámide comienza a tomar forma. También puede ver para qué era el cursor: en cada iteración se movía a la izquierda tres caracteres, y cuando ya no hay tres caracteres a su izquierda, se rompe el bucle, que sucede justo cuando hemos llegado al "fondo" de la pirámide

Ahora vamos a hacer una operación similar pero a la inversa. En un bucle, copiaremos los espacios desde el comienzo de la línea con el cursor hasta el comienzo de la línea anterior, más uno, en el proceso moviendo el cursor hacia esa línea.

:A
  s/(.*\n)( *)(.*);/ \2;\1\2\3/m
  tA

Aquí hay un par de iteraciones y el resultado final:

 a
b   p
c     o
 ;d       n
EFGHIJKLM

 a
b   p
  ;c     o
 d       n
EFGHIJKLM

...

    ; a
   b   p
  c     o
 d       n
EFGHIJKLM

Ya hemos terminado, excepto algunos caracteres adicionales: A ;y espacio adicional en la primera línea, y dos espacios en el "centro" de la pirámide en las siguientes tres líneas. Una simple sustitución se deshace de ellos:

s/. (.)$/\1/gm

¡Todo listo!

    a
   b p
  c   o
 d     n
EFGHIJKLM

Ruby , 106 bytes

i=-1
s= ~/$/
sub /./,"#{' '*l=s/4}\\0
"
(l-1).times{sub /^(\w)(.*)(.)/,"#{' '*l-=1}\\1#{' '*i+=2}\\3
\\2"}

Pruébalo en línea!

Python 2 , 100 97 96 bytes

• Jacoblaw guardó 1 byte: la división entera es innecesaria

a=input()+" "
k=j=len(a)/4
while j:print j*" "+a[0]+(2*(k-j)-1)*" "+a[-1];a=a[1:-1];j-=1
print a

Pruébalo en línea!

Explicación:

Una cosa inteligente que he hecho aquí es rellenar la entrada con un espacio al final, de modo que el primer carácter se empareje con él y esto se pueda insertar en el bucle (y dado que se permiten espacios en blanco finales)

abcdefghijkl[space]   
To print [0] [-1]            Output=>[spaces]a[another_calculated_spaces(=0 here)][space]
Strip at both ends(a[1:-1])  
bcdefghijkl                
To print [0] [-1]            Output=>[spaces]b[another_calculated_spaces]l
Strip at both ends(a[1:-1])
and so on.

El número de bucles a seguir está asociado len(word)//4. En el paso final, se imprime toda la cadena restante (esto forma la base del triángulo). Los espacios siguen un patrón simple; el primer conjunto de espacios continúa disminuyendo en 1, mientras que el segundo conjunto de espacios continúa aumentando en 2.

C 225 bytes

p(c){putchar(c);}S(n){while(n--)p(' ');}main(int c,char**v){int i= strlen(v[1]),n=i/4,r;char*s=v[1],*e=&s[i-1];S(n);p(*s++);p('\n');for (r=1;r<n;r++){S(n-r);p(*s++);S(2*r-1);p(*e--);p('\n');}e++;while (s!=e)p(*s++);p('\n');}

explicado

p(c){putchar(c);}        // p is alias for putchar
S(n){while(n--)p(' ');}  // S prints n spaces
main(int c,char**v){
    int i= strlen(v[1]), // counter
        n=i/4,           // num rows in figure - 1
        r;               // current row 
    char*s=v[1],         // start char
        *e=&s[i-1];      // end char
    S(n);p(*s++);p('\n');// print first row
    for (r=1;r<n;r++){ 
        S(n-r);p(*s++);S(2*r-1);p(*e--);p('\n'); // print middle rows
    }
    e++;while (s!=e)p(*s++);p('\n'); // print last row
}

C #, 172 bytes

int i=0,n=s.Length;var p="";p=new string(' ',n/4)+s[i]+"\r\n";for(i=1;i<n/4;i++){p+=new string(' ',n/4-i)+s[i]+new string(' ',i*2-1)+s[n-i]+"\r\n";}p+=s.Substring(i,n/2+1);

Pruébalo en línea!

Octava, 87 bytes

@(s,x=(n=nnz(s))/4)[[' ';flip(diag(s(1:x))')]' [' ';diag(s(n:-1:n-x+2))];s(x+1:n-x+1)];

* En una máquina Windows, el código anterior produce el resultado correcto, sin embargo, en este momento agregué un código para corregirlo.

Explicación:

[' ';flip(diag(s(1:x))')]'        %left side
[' ';diag(s(n:-1:n-x+2))]         %right side
s(x+1:n-x+1)                      %bottom side

Pruébalo en línea!

Haskell , 136 bytes

i#x=x<$[1..i]
f s|let h=div l 4;l=length s=unlines$[(h-i)#' '++(s!!i):(2*i-1)#' '++[(s++" ")!!(l-i)]|i<-[0..h-1]]++[drop h$take(l-h+1)s]

Pruébalo en línea!

PHP> = 7.1, 122 bytes

for(;$i*2<$w=strlen($a=$argn)/2;$e=$a[-++$i])echo str_pad(str_pad($a[$i],$i*2).$e,$w+1," ",2),"
";echo substr($a,$i,$w+1);

PHP Sandbox en línea

PHP> = 7.1, 124 bytes

for(;$i*2<$w=strlen($a=$argn)/2;$e=$a[-++$i],$s.=$s?"  ":" ")echo str_pad("",$w/2-$i)."$a[$i]$s$e
";echo substr($a,$i,$w+1);

PHP Sandbox en línea

AWK , 129 bytes

{n=split($0,a,"")
printf"%"(w=n/4+1)"s\n",a[++i]
for(;++i<w;)printf"%"(w-i+1)"s%"2*i-2"s\n",a[i],a[n-i+2]
$0=substr($0,i,i+w-1)}1

Pruébalo en línea!

Debería pensar que esto se podría jugar un poco más, solo que no lo veo.

Retina , 99 bytes

^(.)(?=(....)+)
$#2$*  $1¶$#2$* 
( ( *).)(.*)(.)$
$1 $4¶$2$3
+`(( +).¶ ( *).)(.*)(.)$
$1$2  $5¶$3$4

Pruébalo en línea! Explicación: Las dos primeras etapas generan las dos primeras líneas, pero después de eso no es necesaria una carcasa especial y cada línea subsiguiente se puede generar automáticamente:

thisrepresentationisnotatriangle

        t
       hisrepresentationisnotatriangle

        t
       h e
      isrepresentationisnotatriangl

        t
       h e
      i   l
     srepresentationisnotatriang

...

        t
       h e
      i   l
     s     g
    r       n
   e         a
  p           i
 r             r
esentationisnotat

Java 8, 213 bytes

s->{int n=s.length()/4,i;String r=s(n)+s.charAt(0)+"\n";for(i=1;i<n;r+=s(n-i)+s.charAt(i)+s(i*2-1)+s.charAt(n*4-i++)+"\n");return r+s.substring(i,n*2+i+1);}String s(int n){String r="";for(;n-->0;r+=" ");return r;}

Explicación:

Pruébalo aquí

s->{                           // Method (1) with String parameter and String return-type
  int n=s.length()/4,          //  The length of the input divided by 4
      i;                       //  And an index-integer
  String r=                    //  Result-String which starts as:
           s(n)                //   Trailing spaces
           +s.charAt(0)+"\n";  //   + the first character and a new-line
  for(i=1;i<n;                 //  Loop from `1` to `n`
      r+=                      //   And append the result-String with:
         s(n-i)                //    Trailing spaces
         +s.charAt(i)          //    + the character of the left diagonal line
         +s(i*2-1)             //    + center spaces
         +s.charAt(n*4-i++)    //    + the character of the right diagonal line
         +"\n"                 //    + a new-line
  );                           //  End of loop
  return r                     //  Return the result-String
         +s.substring(i,n*2+i+1);
                               //   + the bottom part of the triangle
}                              // End of method (1)

String s(int n){               // Method (2) with integer parameter and String return-type
  String r="";                 //  Result-String
  for(;n-->0;r+=" ");          //  Append the result-String with `n` spaces
  return r;                    //  Return the result-String
}                              // End of method (2)

Perl 5 , 76 bytes

74 bytes de código +2 para -F

say$"x($l=@F/4),shift@F;say$"x$l,shift@F,$"x($#i+=2),pop@F while--$l;say@F

Pruébalo en línea!