공백을 제외하고 인쇄 가능한 ASCII 문자 만 포함 하고 양의 삼각 숫자 (1, 3, 6, 10, 15, ...) 가되도록 보장하는 문자열을 취하는 프로그램 또는 함수를 작성하십시오 .

같은 문자열을 인쇄하거나 반환하지만 공백을 사용하여 삼각형 모양. 일부 예는 내가 의미하는 바를 가장 잘 보여줍니다.

입력이 입력 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 ?

기본적으로 줄 바꿈은 삼각형 길이의 하위 문자열 사이에 삽입되고 공백은 모든 문자 사이에 추가되며 각 줄은 삼각형 모양에 맞는 공백으로 들여 쓰기됩니다.

단일 후행 줄 바꿈 및 후행 공백이있는 행은 선택적으로 허용되지만 그렇지 않으면 출력이이 예제와 정확히 일치해야합니다. 삼각형의 마지막 줄에는 선행 공백이 없어야합니다.

바이트 단위의 가장 짧은 코드가 이깁니다.

Pyth, 22 바이트

jua+L\ GjdHfTczsM._UzY

온라인으로 사용해보십시오 : 데모 또는 테스트 스위트

설명:

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

파이썬, 81 바이트

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

재귀 함수 끝에서 시작하여 s문자를 자르고 인쇄합니다. 사용할 문자 수는의 길이에서 계산됩니다 s. 이 함수는 재귀 호출의 역순으로 인쇄하도록 설정되어 있으며, s비어 있으면 종료 되고 회선을 다시 확인합니다. 각 레이어의 접두사 p에는 추가 공간이 추가됩니다.

파이썬 3에서는 if단락을 통해 수행 할 수 있지만 문자를 저장하지는 않습니다.

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

불평등 체이닝의 균등 한 대안 :

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

모두 print와 f복귀 None사용하기 어렵다.

망막 , 108 (102) 94 87 82 64 63 바이트

바이트 수를 108에서 82로 줄인 원래의 접근 방식을 찾게 해준 Sp3000에 감사합니다.

훨씬 더 우아한 솔루션을 찾은 Kobi 덕분에 그 위에 19 바이트를 더 절약 할 수있었습니다.

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

여기서 <space>단일 공백 ​​문자 (SE에 의해 제거됨)를 나타냅니다. 계산을 위해 각 줄은 별도의 파일로 들어가 \n므로 실제 줄 바꿈 문자로 바꿔야합니다. 편의상 -s플래그가 있는 단일 파일에서 코드를 그대로 실행할 수 있습니다 .

온라인으로 사용해보십시오.

설명

글쎄 ... 평소와 같이 나는 여기에 그룹 균형에 대한 완전한 소개를 줄 수는 없습니다. 입문서 는 Stack Overflow answer를 참조하십시오 .

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

첫 번째 단계는 S플리트 단계로, 입력을 길이가 증가하는 라인으로 분할합니다. 는 _빈 덩어리가 (마지막 위치에 일치되기 때문에 만, 마지막에 영향을) 분할 생략해야 함을 나타냅니다. 정규 표현식 자체는 전체적으로 둘러보기에 포함되어 있으므로 문자와 일치하지 않고 위치 만 일치합니다.

이 부분은 내가 찾은 추가 golfitude가있는 Kobi의 솔루션을 기반으로합니다. lookbehinds는 .NET에서 오른쪽에서 왼쪽으로 일치하므로 아래 설명을 가장 잘 읽으십시오. \G명확성을 위해 설명에 다른 것을 삽입 했지만 패턴이 작동하는 데 필요하지는 않습니다.

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

나는 여전히 Kobi의 작품에 감탄하고 있습니다. 이것은 주요 테스트 정규 표현식보다 훨씬 우아합니다. :)

다음 단계로 넘어 갑시다.

.
$0 

단순 : 모든 비줄 바꿈 문자 뒤에 공백을 삽입하십시오.

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

이 마지막 단계는 모든 선을 올바르게 들여 쓰기하여 삼각형을 형성합니다. 는 m만들 그냥 보통 여러 모드입니다 ^라인의 시작을 일치합니다. 는 +문자열이 변경 멈출 때까지이 단계를 반복 망막을 알려줍니다 (이,이 경우 수단에 그 정규식 더 이상 일치).

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

따라서 이것은 다음 줄보다 들여 쓰기가없는 줄의 시작과 일치합니다. 그러한 위치에서 우리는 공백을 삽입합니다. 선이 깔끔한 삼각형으로 정렬되면이 프로세스는 종료됩니다. 왜냐하면 각 선이 다음 선보다 더 큰 들여 쓰기를 갖는 최소 레이아웃이기 때문입니다.

캔디 , 67 59 57 바이트

&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

또는:

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

긴 형식 :

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 바이트

1 바이트를 절약 한 Sp3000에 감사합니다.

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

놀랍게도 Pyth에 가깝게 골프를 칠 수 있는지 보자 ...

여기에서 테스트하십시오.

설명

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

루비, 84 77 73 바이트

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

77 바이트

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

rsteveverrill이 제안한대로 변수 를 제거하여 몇 바이트를 더 줄였습니다.

84 바이트

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

언 골프 드 :

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

입력 문자열에서 먼저 삼각수 계산

n=v.size**0.5*1.4

예를 들어 입력 문자열 크기는 120이고 삼각 숫자 n은 15입니다.

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

위의 줄에서 다음 패턴을 사용하여 입력 문자열에서 가져온 일련의 문자열과 공백을 인쇄합니다.

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

용법:

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 바이트

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.

테스트 스위트

흥미로운 접근법-명령 및 사용 .I. 아마 골프 타기.

C, 138 (136) 134 바이트

문자열을 입력으로받습니다.

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

루비 어프로치 2 rev 1, 76 바이트

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

Vasu Adari의 답변에서 나온 구문 아이디어와 내 자신의 비틀기를 사용하여 최적화되었습니다.

루비 어프로치 2 rev 0, 93 바이트

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

완전히 다른 접근법. 먼저 입력 문자 사이에 공백을 추가합니다. 그런 다음 행을 한 줄씩 인쇄합니다.

루비 접근 방식 1, 94 바이트

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

이것은 예상보다 훨씬 길었다.

w 맨 아래 행에 인쇄 가능한 문자 수 또는 행 수를 포함합니다.

모든 줄에는 w공백 문자 (마지막 줄 바꿈)가 포함되어 있으므로 공백 문자를 인쇄하고 필요한 경우 인쇄 가능한 문자를 삽입하는 것이 좋습니다.

Minkolang 0.14 , 42 바이트

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

여기에서 시도하십시오.

설명

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

파이썬 2, 88 85 바이트

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

3 바이트를 저장해 주셔서 감사합니다.

CJam, 50 바이트

q:QQ,1>{,{),:+}%:RQ,#:IR2ew<{~Q<>:LS*L,I+(Se[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.
%}& 

자바 스크립트 (ES6), 135 바이트

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}

디 골프 + 데모 ​​:

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

자바, 258 (194)

골프 :

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

언 골프 드 :

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
}

프로그램 출력 :

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 ? 

자바 스크립트 (ES6), 106 바이트

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

for 루프 대신 재귀를 사용하여 문자열을 작성합니다.

가장 긴 행의 길이를 찾으려면 n 번째 삼각수 T_n는 의 공식을 사용하십시오 T_n = (n^2 + n)/2. 주어 n와 대한 해결 T_n차 공식을 사용하여, 우리는이 :

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

바닥 후 1/4 제곱근 안에 1/4을 추가해도 결과가 변경되지 않으므로 가장 긴 행의 공식은 Math.sqrt(2*a.length)|0입니다.

티 스크립트 , 44 바이트

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

이것은 내 JavaScript 답변 과 동일한 방법을 사용 하지만 훨씬 짧습니다.

언 골프

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

파워 쉘, 69 바이트

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

덜 골프 테스트 스크립트 :

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

산출:

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

이것이 코드 골프에서 합법적인지 모르겠지만 함수의 목록을 전달합니까? 함수 외부에서 선언 된 List <string>없이 이것을 재귀하는 방법을 찾을 수 없으므로 매개 변수로 넣습니다.

용법:

 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 바이트

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

배쉬 + sed, 87

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

R, 142 바이트

이걸 더 많이 얻을 수 있다고 확신합니다. 그래도 여전히 노력하고 있습니다. 나는 쉬운 재귀를 잃어버린 것처럼 느낍니다. 그러나 그것을 바로 줄일 수 없었습니다.

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

언 골프

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 바이트

ā£õKεSðý}.c

온라인으로 사용해보십시오!