Schreiben Sie ein Programm oder eine Funktion, die eine Zeichenfolge enthält, die mit Ausnahme des Leerzeichens garantiert nur druckbare ASCII- Zeichen enthält und eine positive dreieckige Zahl (1, 3, 6, 10, 15, ...) ist.

Die gleiche Zeichenfolge drucken oder zurückgeben, jedoch mit Leerzeichen zu einem Dreieck geformt. Einige Beispiele zeigen am besten, was ich meine:

Wenn der Eingang ist, Rist der Ausgang

R

Wenn der Eingang ist, catist der Ausgang

 c
a t

Wenn der Eingang ist, monk3yist der Ausgang

  m
 o n
k 3 y

Wenn der Eingang ist, meanIngfu1ist der Ausgang

   m
  e a
 n I n
g f u 1

Wenn der Eingang ist, ^/\/|\/[]\ist der Ausgang

   ^
  / \
 / | \
/ [ ] \

Wenn der Eingang ist

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

dann wird die Ausgabe sein

              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 ?

Grundsätzlich werden zwischen den dreieckigen Teilzeichenfolgen Zeilenumbrüche eingefügt, zwischen allen Zeichen Leerzeichen eingefügt und jede Zeile mit Leerzeichen eingerückt, um der Dreieckform zu entsprechen.

Eine einzelne nachgestellte Zeile und Zeilen mit nachgestellten Leerzeichen sind optional zulässig, ansonsten sollte Ihre Ausgabe genau mit diesen Beispielen übereinstimmen. Die letzte Zeile des Dreiecks sollte keine führenden Leerzeichen enthalten.

Der kürzeste Code in Bytes gewinnt.

Pyth, 22 Bytes

jua+L\ GjdHfTczsM._UzY

Probieren Sie es online aus: Demo oder Test Suite

Erläuterung:

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 Bytes

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

Eine rekursive Funktion. Geht vom Ende ab s, hackt ab und druckt Zeichen. Die Anzahl der zu verwendenden Zeichen wird aus der Länge von berechnet s. Die Funktion ist so eingerichtet, dass in umgekehrter Reihenfolge der rekursiven Aufrufe gedruckt wird, die enden, wenn sie sleer sind, und dann die Sicherungskopie der Zeile auflösen. Für jede Ebene wird dem Präfix pein zusätzlicher Speicherplatz hinzugefügt.

In Python 3 ifkann dies durch Kurzschließen geschehen, obwohl dies keine Zeichen zu sparen scheint:

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

Eine ebenso lange Alternative mit Verkettung von Ungleichungen:

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

Beide printund fzurück None, was schwer zu bedienen ist.

Retina , 108 102 94 87 82 64 63 Bytes

Vielen Dank an Sp3000, der mich dazu gebracht hat, meinen ursprünglichen Ansatz zu verfolgen, bei dem die Byteanzahl von 108 auf 82 gesenkt wurde.

Ein großes Dankeschön an Kobi, der eine viel elegantere Lösung gefunden hat, mit der ich zusätzlich noch 19 Bytes einsparen konnte.

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

Wobei <space>ein einzelnes Leerzeichen darstellt (das sonst von SE entfernt würde). Zu Zählzwecken wird jede Zeile in eine separate Datei geschrieben und \nsollte durch ein tatsächliches Zeilenvorschubzeichen ersetzt werden. Der Einfachheit halber können Sie den Code so ausführen, wie er aus einer einzelnen Datei mit dem -sFlag stammt.

Probieren Sie es online aus.

Erläuterung

Naja ... wie immer kann ich hier keine vollständige Einführung in die Bilanzkreise geben. Für einen Primer siehe meine Stack Overflow Antwort .

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

Die erste Stufe ist eine SPlitstufe, die die Eingabe in Zeilen mit zunehmender Länge aufteilt. Das _bedeutet, dass leere Chunks von der Aufteilung ausgeschlossen werden sollten (dies wirkt sich nur auf das Ende aus, da an der letzten Position eine Übereinstimmung vorliegt). Die Regex selbst ist vollständig in einem Look-Around enthalten, sodass keine Zeichen, sondern nur Positionen gefunden werden.

Dieser Teil basiert auf der Lösung von Kobi mit einer zusätzlichen Golfstärke, die ich selbst gefunden habe. Beachten Sie, dass Lookbehinds in .NET von rechts nach links übereinstimmen. Daher sollte die folgende Erklärung am besten von unten nach oben gelesen werden. Ich habe \Gder Klarheit halber auch eine andere in die Erklärung eingefügt , obwohl dies nicht erforderlich ist, damit das Muster funktioniert.

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

Ich bewundere immer noch Kobis Arbeit hier. Dies ist noch eleganter als der Prime Testing Regex. :)

Fahren wir mit der nächsten Stufe fort:

.
$0 

Ganz einfach: Fügen Sie nach jedem Zeichen ohne Zeilenvorschub ein Leerzeichen ein.

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

In dieser letzten Phase werden alle Linien korrekt eingerückt, um das Dreieck zu bilden. Dies mist nur der übliche mehrzeilige Modus, um eine ^Übereinstimmung mit dem Zeilenanfang herzustellen . Das +weist Retina an, diesen Schritt zu wiederholen, bis sich die Zeichenfolge nicht mehr ändert (was in diesem Fall bedeutet, dass die Regex nicht mehr übereinstimmt).

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

Dies entspricht also dem Anfang einer Zeile, die keinen größeren Einzug als die nächste hat. In einer solchen Position fügen wir ein Leerzeichen ein. Dieser Vorgang wird beendet, sobald die Zeilen in einem ordentlichen Dreieck angeordnet sind, da dies das minimale Layout ist, bei dem jede Zeile einen größeren Einzug als die nächste hat.

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

oder:

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

lange Form:

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 Bytes

Vielen Dank an Sp3000 für das Speichern von 1 Byte.

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

Überraschenderweise in der Nähe von Pyth, lassen Sie uns sehen, ob dies Golf spielen kann ...

Teste es hier.

Erläuterung

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 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*" "}}

Reduziert einige Bytes mehr durch Entfernen der Variablen, rwie von steveverrill vorgeschlagen.

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*" "}}

Ungolfed:

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

Erste Berechnung der Dreieckszahl aus der Eingabezeichenfolge

n=v.size**0.5*1.4

dh zum Beispiel ist die Größe der Eingabezeichenfolge 120 und unsere Dreieckszahl n ist 15.

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

In der obigen Zeile werden Leerzeichen gefolgt von einer Reihe von Zeichenfolgen gedruckt, die anhand des folgenden Musters aus der Eingabezeichenfolge abgerufen werden

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

Verwendungszweck:

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

Test Suite

Ein interessanter Ansatz - unerlässlich und nützlich .I. Wahrscheinlich golfen.

C 138, 136, 134 Bytes

Nimmt einen String als Eingabe:

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

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

Optimiert mit Syntax-Ideen aus Vasu Adaris Antwort und einigen eigenen Wendungen.

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

Ganz andere Herangehensweise. Zuerst fügen wir Leerzeichen zwischen den Zeichen der Eingabe ein. Dann drucken wir die Zeilen zeilenweise aus.

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

das endete viel länger als erwartet.

w Enthält die Anzahl der druckbaren Zeichen in der unteren Zeile oder entsprechend die Anzahl der Zeilen.

Jede Zeile enthält wWhitespace-Zeichen (die letzte Zeile ist die neue Zeile). Sie sollten diese Whitespace-Zeichen also drucken und die druckbaren Zeichen bei Bedarf einfügen.

Minkolang 0,14 , 42 Bytes

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

Probieren Sie es hier aus.

Erläuterung

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

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

Danke xnor für das Speichern von 3 Bytes.

CJam, 50 Bytes

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

Probieren Sie es hier aus.

Erläuterung

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 Byte

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

Java, 258 194

Golf gespielt:

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
}

Programmausgabe:

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 Byte

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

Verwendet eine Rekursion anstelle einer for-Schleife, um die Zeichenfolge zu erstellen.

Um die Länge der längsten Zeile zu finden, verwendet die Formel für die n - te Dreieckszahl T_nist T_n = (n^2 + n)/2. nFür die T_nVerwendung der quadratischen Formel haben wir gegeben und gelöst :

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

Es stellt sich heraus, dass das Hinzufügen von 1/4 innerhalb der Quadratwurzel nach dem Bodenbelag das Ergebnis nicht ändert, daher lautet die Formel für die längste Reihe Math.sqrt(2*a.length)|0.

TeaScript , 44 Bytes

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

Dies verwendet die gleiche Methode wie meine JavaScript-Antwort , ist jedoch viel kürzer.

Ungolfed

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

Powershell, 69 Bytes

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

Weniger Golf-Testskript:

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

Ausgabe:

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

Ich weiß nicht, ob dies im Code-Golf erlaubt ist, aber zählt das Übergeben einer Liste in der Funktion? Ich kann keine Möglichkeit finden, dies zu wiederholen, ohne eine List <string>, die außerhalb der Funktion deklariert ist. Deshalb habe ich sie als Parameter angegeben.

Verwendungszweck:

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

Bash + Sed, 87

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

R, 142 Bytes

Ich bin mir ziemlich sicher, dass ich das noch besser hinbekomme. Ich arbeite aber immer noch daran. Ich habe das Gefühl, dass mir eine einfache Rekursion fehlt - aber ich konnte sie nicht richtig verkürzen.

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

ungolfed

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 Bytes

ā£õKεSðý}.c

Probieren Sie es online!