Texto triangular

39

Escriba un programa o función que tome una cadena garantizada que solo contenga caracteres ASCII imprimibles , excepto el espacio, y que sea un número triangular positivo (1, 3, 6, 10, 15, ...) de longitud.

Imprima o devuelva la misma cadena, pero en forma de triángulo usando espacios. Algunos ejemplos mostrarán mejor lo que quiero decir:

Si la entrada es Rentonces la salida será

R

Si la entrada es catentonces la salida será

 c
a t

Si la entrada es monk3yentonces la salida será

  m
 o n
k 3 y

Si la entrada es meanIngfu1entonces la salida será

   m
  e a
 n I n
g f u 1

Si la entrada es ^/\/|\/[]\entonces la salida será

   ^
  / \
 / | \
/ [ ] \

Si la entrada es

Thisrunofcharactersismeanttohavealengththatcanbeexpressedasatriangularnumber.Diditwork?Youtellme,Ican'tcountverywell,ok?

entonces la salida será

              T
             h i
            s r u
           n o f c
          h a r a c
         t e r s i s
        m e a n t t o
       h a v e a l e n
      g t h t h a t c a
     n b e e x p r e s s
    e d a s a t r i a n g
   u l a r n u m b e r . D
  i d i t w o r k ? Y o u t
 e l l m e , I c a n ' t c o
u n t v e r y w e l l , o k ?

Básicamente, se insertan nuevas líneas entre las subcadenas de longitud triangular, se agregan espacios entre todos los caracteres y cada línea se sangra con espacios para ajustarse a la forma del triángulo.

Opcionalmente, se permite una nueva línea final y líneas con espacios finales, pero de lo contrario su salida debería coincidir exactamente con estos ejemplos. La última línea del triángulo no debe tener espacios iniciales.

El código más corto en bytes gana.

Pasatiempos de Calvin
fuente
¿Hay un máximo absoluto que puede ser la longitud de la cadena?
geokavel
@geokavel Debería funcionar para cualquier longitud de cadena que su idioma pueda manejar normalmente.
Aficiones de Calvin
11
Aquí hay un árbol de Navidad para cualquiera que aún no haya puesto el suyo. * / \ / | \ / | o \ / | o | \ / o | o | \ / || o | o \ / o ||| o | \ / o || o ||| \ / || o | || o | \ / | o ||| o || o \
Timmy

Respuestas:

9

Pyth, 22 bytes

jua+L\ GjdHfTczsM._UzY

Pruébelo en línea: Demostración o conjunto de pruebas

Explicación:

jua+L\ GjdHfTczsM._UzY   implicit: z = input string
                   Uz    create the list [0, 1, ..., len(z)-1]
                 ._      all prefixes of this list: [[0], [0,1], [0,1,2], ...]
               sM        sum up each sublist: [0, 1, 3, 6, 10, ...]
             cz          split z at these indices
           fT            remove all the unnecessary empty strings
                         this gives us the list of strings of the triangle
 u                   Y   reduce this list, with the initial value G = []
   +L\ G                    prepend a space to each string in G
        jdH                 join the current string with spaces
  a                         and append it to G
j                        print each string on a separate line
Jakube
fuente
12

Python, 81 bytes

def f(s,p=''):
 i=-int(len(2*s)**.5)
 if s:f(s[:i],p+' ');print p+' '.join(s[i:])

Una función recursiva. Va desde el final de s, cortando e imprimiendo personajes. El número de caracteres a tomar se calcula a partir de la longitud de s. La función está configurada para imprimir en orden inverso a las llamadas recursivas, que finalizan cuando sestá vacía y luego resuelven una copia de seguridad de la línea. Cada capa, el prefijo ptiene un espacio extra agregado.

En Python 3, ifse puede hacer a través de cortocircuito, aunque esto no parece guardar caracteres:

def f(s,p=''):i=-int(len(2*s)**.5);s and[f(s[:i],p+' '),print(p+' '.join(s[i:]))]

Una alternativa igualmente larga con cadena de desigualdad:

def f(s,p=''):i=-int(len(2*s)**.5);''<s!=f(s[:i],p+' ')!=print(p+' '.join(s[i:]))

Ambos printy fvolver None, que es difícil de usar.

xnor
fuente
1
Esto es bastante inteligente. Al cortar la cadena una fila a la vez, aún terminas con una cadena de longitud triangular para calcular el número de espacios iniciales con.
xsot
6

Retina , 108 102 94 87 82 64 63 bytes

Gracias a Sp3000 por hacerme seguir mi enfoque original, que redujo el conteo de bytes de 108 a 82.

Un enorme agradecimiento a Kobi que encontró una solución mucho más elegante, lo que me permitió guardar otros 19 bytes además de eso.

S_`(?<=^(?<-1>.)*(?:(?<=\G(.)*).)+)
.
$0 
m+`^(?=( *)\S.*\n\1)
<space>

Donde <space>representa un solo carácter de espacio (que de otro modo sería eliminado por SE). Para fines de conteo, cada línea va en un archivo separado y \ndebe reemplazarse con un carácter de salto de línea real. Para mayor comodidad, puede ejecutar el código tal como está desde un único archivo con la -sbandera.

Pruébalo en línea.

Explicación

Bueno ... como siempre, no puedo dar una introducción completa a los grupos de equilibrio aquí. Para una introducción, vea mi respuesta de desbordamiento de pila .

S_`(?<=^(?<-1>.)*(?:(?<=\G(.)*).)+)

La primera etapa es una Setapa de división, que divide la entrada en líneas de longitud creciente. El _indica que los fragmentos vacíos deben omitirse de la división (lo que solo afecta al final, porque habrá una coincidencia en la última posición). La expresión regular en sí está completamente contenida en un vistazo, por lo que no coincidirá con ningún personaje, sino solo con las posiciones.

Esta parte se basa en la solución de Kobi con algo de golfitud adicional que encontré yo mismo. Tenga en cuenta que las retrospectivas coinciden de derecha a izquierda en .NET, por lo que la siguiente explicación debería leerse de abajo hacia arriba. También he insertado otro \Gen la explicación para mayor claridad, aunque eso no es necesario para que el patrón funcione.

(?<=
  ^         # And we ensure that we can reach the beginning of the stack by doing so.
            # The first time this is possible will be exactly when tri(m-1) == tri(n-1),
            # i.e. when m == n. Exactly what we want!
  (?<-1>.)* # Now we keep matching individual characters while popping from group <1>.
  \G        # We've now matched m characters, while pushing i-1 captures for each i
            # between 1 and m, inclusive. That is, group <1> contains tri(m-1) captures.
  (?:       
    (?<=
      \G    # The \G anchor matches at the position of the last match.
      (.)*  # ...push one capture onto group <1> for each character between here
            # here and the last match.
    )       # Then we use a lookahead to...
    .       # In each iteration we match a single character.
  )+        # This group matches all the characters up to the last match (or the beginning
            # of the string). Call that number m.
)           # If the previous match was at position tri(n-1) then we want this match
            # to happen exactly n characters later.

Todavía estoy admirando el trabajo de Kobi aquí. Esto es incluso más elegante que la expresión regular de prueba principal. :)

Pasemos a la siguiente etapa:

.
$0 

Simple: inserte un espacio después de cada carácter sin salto de línea.

m+`^(?=( *)\S.*\n\1)
<space>

Esta última etapa sangra todas las líneas correctamente para formar el triángulo. El mes sólo el modo multilínea habitual para hacer ^que coincida con el comienzo de una línea. El +le dice a Retina que repita esta etapa hasta que la cadena deje de cambiar (lo que, en este caso, significa que la expresión regular ya no coincide).

^      # Match the beginning of a line.
(?=    # A lookahead which checks if the matched line needs another space.
  ( *) # Capture the indent on the current line.
  \S   # Match a non-space character to ensure we've got the entire indent.
  .*\n # Match the remainder of the line, as well as the linefeed.
  \1   # Check that the next line has at least the same indent as this one.
)

Entonces esto coincide con el comienzo de cualquier línea que no tenga una sangría más grande que la siguiente. En cualquiera de esas posiciones, insertamos un espacio. Este proceso termina, una vez que las líneas se arreglan en un triángulo ordenado, porque ese es el diseño mínimo donde cada línea tiene una sangría más grande que la siguiente.

Martin Ender
fuente
@ _ @ ¿Qué diablos hace?
n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳
@ n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ Ahora con un 100% más de asombro, cortesía de Kobi.
Martin Ender
6

Candy , 67 59 57 bytes

&iZ1-=yZ1+Z*2/>{0g}0=z@1i&{|.}bYR(" ";=)ZR(=a&{;}" ";)"\n";Y1-=ya1j

&1-8*1+r1-2/=y@1i&{|.}bYR(" ";=)ZR(=a&{;}" ";)"\n";Y1-=ya1j

&8*7-r1-2/=y@1i&{|.}bYR(" ";=)ZR(=a&{;}" ";)"\n";Y1-=ya1j

o:

          &
         8 *
        7 - r
       1 - 2 /
      = y @ 1 i
     & { | . } b
    Y R ( "   " ;
   = ) Z R ( = a &
  { ; } "   " ; ) "
 \ n " ; Y 1 - = y a
1 j

forma larga:

stackSz
digit8    # Y = (sqrt((numCh - 1) * 8 + 1) - 1) / 2   using pythagorean
mult      # Y = (sqrt(numCh * 8 - 7) - 1) / 2  equivalent but shorter
digit7
sub
root
digit1
sub
digit2
div
popA
YGetsA
label digit1
incrZ
stackSz   # bail if we're out of letters
if
  else
  retSub
endif
stack2
pushY     # print the leading spaces (" " x Y)
range1
while
  " " printChr
  popA
endwhile
pushZ
range1      # output this row of characters (Z of them)
while
  popA
  stack1
  stackSz
  if
    printChr    # bail on unbalanced tree
  endif
  " " printChr
endwhile
"\n" printChr
pushY
digit1
sub
popA
YGetsA
stack1
digit1 jumpSub   # loop using recursion
Dale Johnson
fuente
Sí, me sentí como en Navidad.
Dale Johnson
5

CJam, 27 26 bytes

Gracias a Sp3000 por guardar 1 byte.

Lq{' @f+_,)@/(S*N+a@\+\s}h

Sorprendentemente cerca de Pyth, veamos si se puede jugar al golf ...

Pruébalo aquí.

Explicación

L        e# Push an empty array to build up the lines in.
q        e# Read input.
{        e# While the top of the stack is truthy (non-empty)...
  ' @f+  e#   Prepend a space to each line we already have.
  _,)    e#   Get the number of lines we already have and increment.
  @/     e#   Split the input into chunks of that size.
  (S*    e#   Pull off the first chunk (the next line) and join with spaces.
  N+     e#   Append a linefeed.
  a@\+   e#   Append it to our list of lines.
  \s     e#   Pull up the other chunks of the input and join them back into one string.
}h
Martin Ender
fuente
¿Por qué no funciona si me cambio ' a S???
geokavel
@geokavel Porque Ses una cadena, no un carácter, por lo que se fasignará sobre esa cadena en lugar de la lista de líneas.
Martin Ender
Esa fue mi suposición. ¿Tienes alguna idea de la razón para hacer de S una cuerda?
geokavel
@geokavel No, no lo hago.
Martin Ender
5

Ruby, 84 77 73 bytes

->v{1.upto(n=v.size**0.5*1.4){|i|puts" "*(n-i)+v[i*(i-1)/2,i].chars*" "}}

77 bytes

->v{0.upto(n=(v.size*2)**0.5-1){|i|puts" "*(n-i)+v[i*(i+1)/2,i+1].chars*" "}}

Se rredujeron algunos bytes más al eliminar la variable como sugiere steveverrill.

84 bytes

->v{n=(v.size*2)**0.5-1;0.upto(n){|i|puts" "*(n-i)+v[(r=i*(i+1)/2)..r+i].chars*" "}}

Sin golf:

->v {
  1.upto(n=v.size**0.5*1.4) { |i|
    puts" "*(n-i)+v[i*(i-1)/2,i].chars*" "
  }
}

Primero calcular el número triangular de la cadena de entrada

n=v.size**0.5*1.4

es decir, por ejemplo, el tamaño de la cadena de entrada es 120 y nuestro número triangular n será 15.

puts" "*(n-i)+v[i*(i-1)/2,i].chars*" "

En la línea anterior, imprime espacios seguidos de series de cadenas que se obtienen de la cadena de entrada utilizando el siguiente patrón

[[0,0],[1,2],[3,5],[6,9]]

Uso:

f=->v{1.upto(n=v.size**0.5*1.4){|i|puts" "*(n-i)+v[i*(i-1)/2,i].chars*" "}}
f["Thisrunofcharactersismeanttohavealengththatcanbeexpressesasatriangularnumber.Diditwork?Youtellme,Ican'tcountverywell,ok?"]
              T
             h i
            s r u
           n o f c
          h a r a c
         t e r s i s
        m e a n t t o
       h a v e a l e n
      g t h t h a t c a
     n b e e x p r e s s
    e s a s a t r i a n g
   u l a r n u m b e r . D
  i d i t w o r k ? Y o u t
 e l l m e , I c a n ' t c o
u n t v e r y w e l l , o k ?
Vasu Adari
fuente
Wow, nuestros enfoques son muy similares, pero parece que tenemos un conocimiento complementario de golf. No sabía uptoque no requiere un argumento entero ( timesciertamente lo hace). He incorporado parte de su sintaxis en una revisión de mi respuesta. El mayor consejo que tengo para ti es que no necesitas esa variable r. Simplemente use un en ,lugar de ..y el número después de la coma es el número total de elementos a devolver, en lugar del final del rango.
Level River St
Cierto. Gracias por el consejo, estoy actualizando mi respuesta de inmediato :)
Vasu Adari
4

Pyth, 27 bytes

Js.IsSGlzWz+*-J=hZdjd<~>zZZ

                               z = input()
                               Z = 0
                               d = ' '
    sSG                        G -> tri(G)
  .I   lz                      Find the (float) input whose output is len(z).
 s                             Convert to int.
J                              Save as J.
         Wz                    while z:
               =hZ             Z += 1
            *-J  Zd            Generate J-Z spaces.
                      ~>zZ     Remove the first Z characters from z.
                     <    Z    Generate those first Z characters.
                   jd          Join on spaces.
           +                   Add the two together and print.

Banco de pruebas

Un enfoque interesante - imperativo, y usos .I. Probablemente golfable.

isaacg
fuente
4

C, 138 136 134 bytes

Toma una cadena como entrada:

j,r,k,a;f(char*s){j=strlen(s);r=k=sqrt(1+8*j)/2;for(;r--;printf("\n")){for(j=r;j--;)printf(" ");for(j=k-r;j--;)printf("%c ",s[a++]);}}
Sahil Arora
fuente
Parece que has vencido a JavaScript con C por 1 byte hasta ahora: D
Mark K Cowan
@ MarkKCowan sí, aparentemente. ¡Espero hacerlo aún más pequeño! :)
Sahil Arora
@SahilArora: puede reemplazar printf(" ")y printf("\n")con puts(" ")y puts("\n"). Cada sustitución le ahorrará 2 bytes. :)
enhzflep
@enhzflep Ya lo probé, ¡dio un resultado ambiguo!
Sahil Arora
Oh. :( Funciona bien aquí en win7 con gcc 4.7.1 - Supongo que tiene que ver con la forma en que la salida de printf se vacía a stdout. +1 para vencer Javascript.
enhzflep
4

Enfoque de Ruby 2 rev 1, 76 bytes

->s{s=s.chars*' '
0.upto(w=s.size**0.5-1){|i|puts' '*(w-i)+s[i*i+i,i*2+2]}}

Optimizado usando ideas de sintaxis de la respuesta de Vasu Adari, más algunos giros míos.

Enfoque de Ruby 2 rev 0, 93 bytes

->s{s=s.chars.to_a.join(' ')
w=(s.size**0.5).to_i
w.times{|i|puts' '*(w-i-1)+s[i*i+i,i*2+2]}}

Enfoque completamente diferente. Primero agregamos espacios entre los caracteres de la entrada. Luego imprimimos las filas línea por línea.

Enfoque de rubí 1, 94 bytes

->s{n=-1;w=((s.size*2)**0.5).to_i
(w*w).times{|i|print i/w+i%w<w-1?'':s[n+=1],-i%w==1?$/:' '}}

Esto terminó mucho más tiempo de lo previsto.

w contiene el número de caracteres imprimibles en la fila inferior, o de manera equivalente, el número de líneas.

Cada línea contiene wcaracteres de espacio en blanco (el último de los cuales es la nueva línea), por lo que la idea es imprimir estos caracteres de espacio en blanco e insertar los caracteres imprimibles cuando sea necesario.

Level River St
fuente
3

Minkolang 0.14 , 42 bytes

(xid2;$I2*`,)1-[i1+[" "o]lrx" "$ii-1-D$O].

Pruébalo aquí

Explicación

(                Open while loop
 x               Dump top of stack
  i              Loop counter (i)
   d2;           Duplicate and square
      $I2*       Length of input times two
          `,     Push (i^2) <= (length of input)
            )    Close for loop; pop top of stack and exit when it's 0

1-[                              Open for loop that repeats sqrt(len(input))-1 times
   i1+[                          Open for loop that repeats (loop counter + 1) times
       " "o                      Push a space then read in character from input
           ]                     Close for loop
            l                    Push 10 (newline)
             r                   Reverse stack
              x                  Dump top of stack
               " "               Push a space
                  $i             Push the max iterations of for loop
                    i-           Subtract loop counter
                      1-         Subtract 1
                        D        Pop n and duplicate top of stack n times
                         $O      Output whole stack as characters
                           ].    Close for loop and stop.
El'endia Starman
fuente
2
¡Un conteo de bytes tan perfecto! ¡buen trabajo!
TanMath
1
¡@TanMath pero 42 no es un número triangular!
Paŭlo Ebermann
3

Python 2, 88 85 bytes

s=t=raw_input()
i=1
while s:print' '*int(len(t*2)**.5-i)+' '.join(s[:i]);s=s[i:];i+=1

Gracias xnor por guardar 3 bytes.

xsot
fuente
¿El acortamiento no arruina sel cálculo del número de espacios?
xnor
Correcto. Eliminé una variable temporal antes de enviarla, pero no me di cuenta de que invalidaba el código.
xsot
¿Qué pasa si te gusta antes pero guardas una copia de seguridad S=s=raw_input()?
xnor
Buena sugerencia. Sin embargo, creo que probablemente haya una estrategia general más corta.
xsot
Tachado 88 se ve divertido
pinkfloydx33
3

CJam, 50 bytes

q:QQ,1>{,{),:+}%:RQ,#:IR2ew<{~Q<>:LS*L,I+(Se[N}%}&

Pruébalo aquí

Explicación

q:QQ,1>{  e# Only proceed if string length > 1, otherwise just print.
,{),:}%:R e# Generates a list of sums from 0 to k, where k goes from 0 to the length of the string [0,1,3,6,10,15,21,...]
Q,#:I     e# Find the index of the length of the string in the list
R2ew<     e# Make a list that looks like [[0,1],[1,3],[3,6],...,[?,n] ]where n is the length of the string 
{~Q<>:L   e# Use that list to get substrings of the string using the pairs as start and end indices
S*        e# Put spaces between the substrings
L,I+(Se[N e# (Length of the substring + Index of string length in sum array -1) is the length the line should be padded with spaces to. Add a new line at the end.
%}& 
geokavel
fuente
2

JavaScript (ES6), 135 bytes

w=>{r='';for(s=j=0;j<w.length;j+=s++);for(i=j=0;w[j+i];j+=++i)r+=Array(s-i-1).join` `+w.slice(j,i+j+1).split``.join` `+'<br>';return r}

De-golf + demo:

function t(w) {
    r = '';
    for (s = j = 0; j < w.length; j += s++);
    for (i = j = 0; w[j + i]; j += ++i) r += Array(s - i - 1).join` ` + w.slice(j, i + j + 1).split``.join` ` + '<br>';
    return r;
}

document.write('<pre>' + t(prompt()));

nicael
fuente
¿Cuál es el objetivo de for (s = j = 0; j < w.length; j += s++);? Además, dentro de a <pre>, puede usar en \nlugar de <br>. Además, olvidó mencionar que es ES6.
Ismael Miguel
El objetivo del primer bucle es contar la longitud de la última línea, para sangrar cada línea correctamente.
nicael
2

Java, 258 194

Golfizado:

String f(String a){String r="";int t=(((int)Math.sqrt(8*a.length()+1))-1)/2-1;int i=0,n=0;while(n++<=t){for(int s=-1;s<t-n;++s)r+=" ";for(int j=0;j<n;++j)r+=a.charAt(i++)+" ";r+="\n";}return r;}

Sin golf:

public class TriangulatingText {

  public static void main(String[] a) {
    // @formatter:off
    String[] testData = new String[] {
      "R",
      "cat",
      "monk3y",
      "meanIngfu1",
      "^/\\/|\\/[]\\",
      "Thisrunofcharactersismeanttohavealengththatcanbeexpressedasatriangularnumber.Diditwork?Youtellme,Ican'tcountverywell,ok?",
    };
    // @formatter:on

    for (String data : testData) {
      System.out.println("f(\"" + data + "\")");
      System.out.println(new TriangulatingText().f(data));
    }
  }

  // Begin golf
  String f(String a) {
    String r = "";
    int t = (((int) Math.sqrt(8 * a.length() + 1)) - 1) / 2 - 1;
    int i = 0, n = 0;
    while (n++ <= t) {
      for (int s = -1; s < t - n; ++s)
        r += " ";
      for (int j = 0; j < n; ++j)
        r += a.charAt(i++) + " ";
      r += "\n";
    }
    return r;
  }
  // End golf
}

Salida del programa:

f("R")
R 

f("cat")
 c 
a t 

f("monk3y")
  m 
 o n 
k 3 y 

f("meanIngfu1")
   m 
  e a 
 n I n 
g f u 1 

f("^/\/|\/[]\")
   ^ 
  / \ 
 / | \ 
/ [ ] \ 

f("Thisrunofcharactersismeanttohavealengththatcanbeexpressedasatriangularnumber.Diditwork?Youtellme,Ican'tcountverywell,ok?")
              T 
             h i 
            s r u 
           n o f c 
          h a r a c 
         t e r s i s 
        m e a n t t o 
       h a v e a l e n 
      g t h t h a t c a 
     n b e e x p r e s s 
    e d a s a t r i a n g 
   u l a r n u m b e r . D 
  i d i t w o r k ? Y o u t 
 e l l m e , I c a n ' t c o 
u n t v e r y w e l l , o k ? 

fuente
Probablemente podría importar estáticamente System.out para guardar algunos bytes.
RAnders00
import static System.out;tiene 25 bytes y System.tiene 7 bytes. Se usa tres veces y 21 <25, por lo que en realidad aumentaría el tamaño en 4 bytes. Sin embargo, una buena ventaja, las importaciones estáticas pueden ahorrar espacio y no todos saben sobre ellas.
1
Estaba buscando respuestas antiguas cuando encontré esta: "escribir un programa o función " que no me di cuenta al principio. Eliminar las cosas de la clase ahorró espacio. Lo convertí en una función adecuada y encontré algunos bytes más para depilar.
1

JavaScript (ES6), 106 bytes

a=>(y=z=0,(f=p=>p?" ".repeat(--p)+a.split``.slice(y,y+=++z).join` `+`
`+f(p):"")(Math.sqrt(2*a.length)|0))

Utiliza recursividad en lugar de un bucle for para construir la cadena.

Para encontrar la longitud de la fila más larga, utilizar la fórmula para el enésimo número triangular T_nes T_n = (n^2 + n)/2. Dado ny resolviendo el T_nuso de la fórmula cuadrática, tenemos:

1/2 * n^2 + 1/2 * n - T_n = 0

a = 1/2, b = 1/2, c = -T_n

-1/2 + sqrt(1/2^2 - 4*1/2*-T_n)   
------------------------------- = sqrt(1/4 + 2*T_n) - 1/2
             2*1/2

Resulta que después del piso, agregar 1/4 dentro de la raíz cuadrada no cambia el resultado, por lo tanto, la fórmula para la fila más larga es Math.sqrt(2*a.length)|0.

codificador intrépido
fuente
1

TeaScript , 44 bytes

r(m=$s(2*xn)|0)ßp.R(m-i)+x·.S(v,v+=Æw)jø+§)µ

Utiliza el mismo método que mi respuesta de JavaScript , pero es mucho más corto.

Sin golf

r(m=$s(2*xn)|0)m(#p.R(m-i)+xs``.S(v,v+=++w)j` `+`
`)j``
codificador intrépido
fuente
1

Powershell, 69 bytes

($args|% t*y|?{$r+="$_ ";++$p-gt$l}|%{$r;rv r,p;$l++})|%{' '*--$l+$_}

Menos guión de prueba de golf:

$f = {

(
    $args|% t*y|?{  # test predicate for each char in a argument string 
        $r+="$_ "   # add current char to the result string
        ++$p-gt$l   # return predicate value: current char posision is greater then line num
    }|%{            # if predicate is True
        $r          # push the result string to a pipe
        rv r,p      # Remove-Variable r,p. This variables will be undefined after it.
        $l++        # increment line number
    }

)|%{                # new loop after processing all characters and calculating $l
    ' '*--$l+$_     # add spaces to the start of lines
}                   # and push a result to a pipe

}

@(
    ,("R",
    "R ")

    ,("cat",
    " c ",
    "a t ")

    ,("monk3y",
    "  m ",
    " o n ",
    "k 3 y ")

    ,("meanIngfu1",
    "   m ",
    "  e a ",
    " n I n ",
    "g f u 1 ")

    ,("^/\/|\/[]\",
    "   ^ ",
    "  / \ ",
    " / | \ ",
    "/ [ ] \ ")

    ,("Thisrunofcharactersismeanttohavealengththatcanbeexpressedasatriangularnumber.Diditwork?Youtellme,Ican'tcountverywell,ok?",
    "              T ",
    "             h i ",
    "            s r u ",
    "           n o f c ",
    "          h a r a c ",
    "         t e r s i s ",
    "        m e a n t t o ",
    "       h a v e a l e n ",
    "      g t h t h a t c a ",
    "     n b e e x p r e s s ",
    "    e d a s a t r i a n g ",
    "   u l a r n u m b e r . D ",
    "  i d i t w o r k ? Y o u t ",
    " e l l m e , I c a n ' t c o ",
    "u n t v e r y w e l l , o k ? ")

    ,("*/\/|\/|o\/|o|\/o|o|\/||o|o\/o|||o|\/o||o|||\/||o|||o|\/|o|||o||o\",
    "          * ",
    "         / \ ",
    "        / | \ ",
    "       / | o \ ",
    "      / | o | \ ",
    "     / o | o | \ ",
    "    / | | o | o \ ",
    "   / o | | | o | \ ",
    "  / o | | o | | | \ ",
    " / | | o | | | o | \ ",
    "/ | o | | | o | | o \ ")

) | % {
    $s,$expected = $_
    $result = &$f $s
    "$result"-eq"$expected"
    $result
}

Salida:

True
R
True
 c
a t
True
  m
 o n
k 3 y
True
   m
  e a
 n I n
g f u 1
True
   ^
  / \
 / | \
/ [ ] \
True
              T
             h i
            s r u
           n o f c
          h a r a c
         t e r s i s
        m e a n t t o
       h a v e a l e n
      g t h t h a t c a
     n b e e x p r e s s
    e d a s a t r i a n g
   u l a r n u m b e r . D
  i d i t w o r k ? Y o u t
 e l l m e , I c a n ' t c o
u n t v e r y w e l l , o k ?
True
          *
         / \
        / | \
       / | o \
      / | o | \
     / o | o | \
    / | | o | o \
   / o | | | o | \
  / o | | o | | | \
 / | | o | | | o | \
/ | o | | | o | | o \
mazzy
fuente
0

C #, 202

string r(string s,List<string> o,int i=1){o=o.Select(p=>" "+p).ToList();o.Add(String.Join(" ",s.Substring(0,i).ToCharArray()));return s.Length==i?String.Join("\n",o):r(s.Substring(i,s.Length-i),o,i+1);}

No sé si esto es legal en el código de golf, pero, ¿pasar una lista en la función cuenta? No puedo encontrar una manera de repetir esto sin una Lista <cadena> declarada fuera de la función, así que lo puse como parámetro.

Uso:

 r("1",new List<string>());
 r("123", new List<string>());
 r("123456", new List<string>());
 r("Thisrunofcharactersismeanttohavealengththatcanbeexpressedasatriangularnumber.Diditwork?Youtellme,Icanstcountverywell,ok?",new List<string>());
noisyass2
fuente
0

C, 102 bytes

i,j;main(n,s){for(n=sqrt(strlen(gets(s))*2);j<n;printf("%*.1s",i>1?2:i*(n-j),i++>j?i=!++j,"\n":s++));}
xsot
fuente
0

Bash + sed, 87

for((;i<${#1};i+=j));{
a+=(${1:i:++j})
}
printf %${j}s\\n ${a[@]}|sed 's/\S/ &/g;s/.//'
Trauma digital
fuente
0

R, 142 bytes

Estoy bastante seguro de que puedo entender esto más. Aunque todavía estoy trabajando en eso. Siento que me falta una recursión fácil, pero no he podido acortarla correctamente.

f=function(a){n=nchar(a);l=which(cumsum(1:n)==n);w=strsplit(a,c())[[1]];for(i in 1:l){cat(rep(" ",l-i),sep="");cat(w[1:i],"\n");w=w[-(1:i)]}}

sin golf

f=function(a){
    n = nchar(a)                 #number of characters
    l= which(cumsum(1:n)==n)     #which triangle number
    w= strsplit(a,c())[[1]]      #Splits string into vector of characters
    for (i in 1:l) {
        cat(rep(" ",l-i),sep="") #preceeding spaces
        cat(w[1:i],"\n")         #Letters
        w=w[-(1:i)]              #Shifts removes letters (simplifies indexing)
    }
}
usuario5957401
fuente