Ecrivez un programme ou une fonction qui contient une chaîne dont le caractère garanti est de ne contenir que des caractères ASCII imprimables, à l' exception de l'espace, et d'être un nombre triangulaire positif (1, 3, 6, 10, 15, ...).

Imprimer ou retourner la même chaîne, mais en forme de triangle à l'aide d'espaces. Certains exemples montreront mieux ce que je veux dire:

Si l'entrée est Ralors la sortie sera

R

Si l'entrée est catalors la sortie sera

 c
a t

Si l'entrée est monk3yalors la sortie sera

  m
 o n
k 3 y

Si l'entrée est meanIngfu1alors la sortie sera

   m
  e a
 n I n
g f u 1

Si l'entrée est ^/\/|\/[]\alors la sortie sera

   ^
  / \
 / | \
/ [ ] \

Si l'entrée est

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

alors la sortie sera

              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 ?

Fondamentalement, les nouvelles lignes sont insérées entre les sous-chaînes de longueur triangulaire, les espaces sont ajoutés entre tous les caractères et chaque ligne est mise en retrait avec des espaces pour s’ajuster à la forme du triangle.

Une seule nouvelle ligne de fin et des lignes avec des espaces de fin sont éventuellement autorisées, mais sinon, votre sortie doit correspondre exactement à ces exemples. La dernière ligne du triangle ne doit pas comporter d'espaces de début.

Le code le plus court en octets gagne.

Pyth, 22 octets

jua+L\ GjdHfTczsM._UzY

Essayez-le en ligne: démonstration ou suite de tests

Explication:

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

Python, 81 octets

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

Une fonction récursive. Aller de la fin de s, couper et imprimer des caractères. Le nombre de caractères à prendre est calculé à partir de la longueur de s. La fonction est configurée pour imprimer dans l'ordre inverse des appels récursifs, qui se terminent quand sest vide puis résolus de sauvegarder la ligne. Chaque couche, le préfixe pa un espace supplémentaire ajouté.

En Python 3, cela ifpeut être fait via un court-circuit, bien que cela ne semble pas économiser les caractères:

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

Une alternative également longue avec des inégalités chaînant:

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

Les deux printet frevenir None, ce qui est difficile à utiliser.

Retina , 108 102 94 87 82 64 63 octets

Merci à Sp3000 de m'avoir fait suivre mon approche originale, qui faisait passer le nombre d'octets de 108 à 82.

Un gros merci à Kobi qui a trouvé une solution beaucoup plus élégante, ce qui m'a permis d'économiser 19 octets supplémentaires.

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

Où <space>représente un caractère d'espacement unique (qui serait sinon supprimé par SE). À des fins de comptage, chaque ligne est placée dans un fichier séparé et \ndoit être remplacée par un caractère de saut de ligne réel. Pour plus de commodité, vous pouvez exécuter le code tel quel à partir d'un seul fichier avec l' -sindicateur.

Essayez-le en ligne.

Explication

Eh bien ... comme d'habitude, je ne peux pas vous donner une introduction complète aux groupes d'équilibrage ici. Pour un aperçu, voir ma réponse Stack Overflow .

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

La première étape est une Sétape de pli, qui divise l’entrée en lignes de plus en plus longues. Le _signe que les morceaux vides doivent être omis de la scission (ce qui n’affecte que la fin, car il y aura une correspondance dans la dernière position). La regex elle-même est entièrement contenue dans une apparence, elle ne correspond donc à aucun caractère, mais uniquement à des positions.

Cette partie est basée sur la solution de Kobi avec une golfitude supplémentaire que je me suis trouvée. Notez que les recherches en arrière-plan sont associées de droite à gauche dans .NET. Il est donc préférable de lire l'explication suivante de bas en haut. J'ai également inséré une autre \Gexplication pour plus de clarté, bien que cela ne soit pas nécessaire pour que le motif fonctionne.

(?<=
  ^         # 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.

J'admire toujours le travail de Kobi ici. C'est encore plus élégant que la regex de test principal. :)

Passons à l'étape suivante:

.
$0 

Simple: insérez un espace après chaque caractère sans saut de ligne.

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

Cette dernière étape indente correctement toutes les lignes pour former le triangle. Le mn'est que le mode multiligne habituel pour faire ^correspondre le début d'une ligne. Le +dit à Retina de répéter cette étape jusqu'à ce que la chaîne cesse de changer (ce qui, dans ce cas, signifie que l'expression régulière ne correspond plus).

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

Cela correspond donc au début de toute ligne qui n'a pas d'indentation plus grande que la suivante. Dans une telle position, nous insérons un espace. Ce processus se termine, une fois que les lignes sont disposées dans un triangle ordonné, car il s’agit de la disposition minimale dans laquelle chaque ligne a un retrait plus important que le suivant.

Candy , 67 59 57 octets

&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

ou:

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

forme longue:

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

CJam, 27 26 octets

Merci à Sp3000 d’avoir économisé 1 octet.

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

Étonnamment proche de Pyth, voyons si cela peut être joué au golf ...

Testez-le ici.

Explication

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

Ruby, 84 77 73 octets

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

77 octets

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

Réduction de quelques octets supplémentaires en supprimant la variable rcomme suggéré par steveverrill.

84 octets

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

Ungolfed:

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

Premier calcul du nombre triangulaire à partir de la chaîne de saisie

n=v.size**0.5*1.4

Par exemple, la taille de la chaîne d'entrée est de 120 et notre nombre triangulaire n sera de 15.

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

Dans la ligne ci-dessus, il affiche les espaces suivis d'une série de chaînes extraites de la chaîne d'entrée à l'aide du modèle suivant

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

Usage:

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 ?

Pyth, 27 octets

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.

Suite de tests

Une approche intéressante - impératif, et utilise .I. Probablement golfable.

C, 138 136 134 octets

Prend une chaîne en tant qu'entrée:

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++]);}}

Approche Ruby 2 rev 1, 76 octets

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

Optimisé à l'aide des idées de syntaxe de la réponse de Vasu Adari, ainsi que de quelques modifications personnelles.

Approche Ruby 2 rev 0, 93 octets

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

Approche complètement différente. Tout d'abord, nous ajoutons des espaces entre les caractères de l'entrée. Ensuite, nous imprimons les lignes ligne par ligne.

Approche Ruby 1, 94 octets

->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?$/:' '}}

cela s'est avéré bien plus long que prévu.

w contient le nombre de caractères imprimables dans la rangée du bas ou, de manière équivalente, le nombre de lignes.

Chaque ligne contient des wcaractères d'espacement (la dernière étant la nouvelle ligne). L'idée est donc d'imprimer ces caractères et d'insérer les caractères imprimables si nécessaire.

Minkolang 0,14 , 42 octets

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

Essayez ici.

Explication

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

Python 2, 88 à 85 octets

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

Merci xnor d'avoir économisé 3 octets.

CJam, 50 octets

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

Essayez ici.

Explication

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.
%}& 

JavaScript (ES6), 135 octets

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 + démo:

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

Java, 258 194

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

Ungolfed:

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
}

Sortie du programme:

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 ? 

JavaScript (ES6), 106 octets

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

Utilise la récursivité au lieu d’une boucle for pour construire la chaîne.

Pour trouver la longueur de la plus longue ligne, utilisez la formule du nième nombre triangulaire T_nest T_n = (n^2 + n)/2. Étant donné net résolus d’ T_nutiliser la formule quadratique, nous avons:

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

Il s'avère que, après le revêtement de sol, l'ajout de 1/4 à la racine carrée ne modifie pas le résultat. La formule de la rangée la plus longue l'est donc Math.sqrt(2*a.length)|0.

TeaScript , 44 octets

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

Ceci utilise la même méthode que ma réponse JavaScript , mais est beaucoup plus court.

Ungolfed

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

Powershell, 69 octets

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

Script de test moins joué:

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

Sortie:

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 \

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

Je ne sais pas si c'est légal en code-golf mais, est-ce que passer une liste dans la fonction compte? Je ne peux pas trouver un moyen de récidiver ceci sans une liste <string> déclarée en dehors de la fonction, donc je la mets en paramètre.

Usage:

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

C, 102 octets

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

Bash + sed, 87

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

R, 142 octets

Je suis assez sûr de pouvoir en parler davantage. Je travaille toujours là-dessus. J'ai l'impression de rater une récursion facile - mais je n'ai pas réussi à la raccourcir correctement.

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

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

05AB1E , 11 octets

ā£õKεSðý}.c

Essayez-le en ligne!