소개:

에서 영감 의이 댓글 @MagicOctopusUrn 에 @Emigna 의 05AB1E 응답 내에 " 그냥 버그이었다 도전" :

8F9ÝÀNð×ý}».∊나는 우주선을 깎았 다! 그리고 12 바이트 편집을 제안하는 것에 모두 흥분했습니다. – 매직 문어 Urn Jul 17 '17 at 20:10

이는입니다 05AB1E 이 결과 (레거시) 프로그램 :

1234567890
1 2 3 4 5 6 7 8 9 0
1  2  3  4  5  6  7  8  9  0
1   2   3   4   5   6   7   8   9   0
1    2    3    4    5    6    7    8    9    0
1     2     3     4     5     6     7     8     9     0
1      2      3      4      5      6      7      8      9      0
1       2       3       4       5       6       7       8       9       0
1      2      3      4      5      6      7      8      9      0
1     2     3     4     5     6     7     8     9     0
1    2    3    4    5    6    7    8    9    0
1   2   3   4   5   6   7   8   9   0
1  2  3  4  5  6  7  8  9  0
1 2 3 4 5 6 7 8 9 0
1234567890

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

도전:

입력 : 비어 있지 않은 문자열

출력 : 바깥 쪽에서 안쪽으로, 위의 출력에서와 같이 각 문자 사이에 공백을 하나 더 추가하십시오 length - 1. 따라서 입력의 1234567890경우 실제로 출력은 다음과 같습니다.

1234567890
1 2 3 4 5 6 7 8 9 0
1  2  3  4  5  6  7  8  9  0
1   2   3   4   5   6   7   8   9   0
1    2    3    4    5    6    7    8    9    0
1     2     3     4     5     6     7     8     9     0
1      2      3      4      5      6      7      8      9      0
1       2       3       4       5       6       7       8       9       0
1        2        3        4        5        6        7        8        9        0
1         2         3         4         5         6         7         8         9         0
1        2        3        4        5        6        7        8        9        0 
1       2       3       4       5       6       7       8       9       0
1      2      3      4      5      6      7      8      9      0
1     2     3     4     5     6     7     8     9     0
1    2    3    4    5    6    7    8    9    0
1   2   3   4   5   6   7   8   9   0
1  2  3  4  5  6  7  8  9  0
1 2 3 4 5 6 7 8 9 0
1234567890

왜? 의 길이는 1234567890입니다 10. 그래서 우리는 10 줄을 출력하는 것으로 시작합니다 : 공백이없는 첫 번째 줄; 하나의 공백 구분자가있는 두 번째; 둘 셋째; 그런 다음 ( length - 1공백이 중복 된 중간 줄이 없으면 ) 아래로 내려 가면서 초기 입력으로 돌아갑니다.

도전 규칙 :

• 입력은 비어 있지 않아야합니다 (length >= 1). (단일 문자 입력의 경우 단순히 해당 문자를 출력합니다.)
• 출력 자체 (화면의 어느 곳이든)가 올바른 한, 모든 후행 / 앞 공백 / 줄 바꾸기가 허용됩니다. (출력 라인 사이의 빈 라인도 허용되지 않습니다.)
• 입력은 공백을 제외한 인쇄 가능한 ASCII 문자 만 포함합니다 (코드 포인트 범위 [33, 126]).
• I / O는 유연합니다. 입력은 STDIN, 인수 또는 함수 매개 변수로 취할 수 있습니다. 문자열 대신 문자 목록 / 배열 / 문자 스트림 일 수 있습니다. 출력은 문자열 대신 문자 목록 / 배열 / 문자 스트림 일 수도 있습니다. STDOUT에 인쇄 될 수 있습니다. 개행으로 구분 된 문자열로 반환됩니다. 기타

일반적인 규칙:

• 이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.
  코드 골프 언어가 코드 골프 언어 이외의 언어로 답변을 게시하지 못하게하지 마십시오. '모든'프로그래밍 언어에 대한 가능한 한 짧은 대답을 생각해보십시오.
• 표준 규칙이 답변에 적용 되므로 STDIN / STDOUT, 적절한 매개 변수 및 리턴 유형의 전체 프로그램과 함께 함수 / 방법을 사용할 수 있습니다. 당신의 전화.
• 기본 허점 은 금지되어 있습니다.
• 가능하면 코드 테스트 링크를 추가하십시오.
• 또한 답변에 대한 설명을 추가하는 것이 좋습니다.

테스트 사례 :

Input: @
Output:
@

Input: test
Output:
test
t e s t
t  e  s  t
t   e   s   t
t  e  s  t
t e s t
test

Input: ?!
Output:
?!
? !
?!

Input: Spaceship
Output:
Spaceship
S p a c e s h i p
S  p  a  c  e  s  h  i  p
S   p   a   c   e   s   h   i   p
S    p    a    c    e    s    h    i    p
S     p     a     c     e     s     h     i     p
S      p      a      c      e      s      h      i      p
S       p       a       c       e       s       h       i       p
S        p        a        c        e        s        h        i        p
S       p       a       c       e       s       h       i       p
S      p      a      c      e      s      h      i      p
S     p     a     c     e     s     h     i     p
S    p    a    c    e    s    h    i    p
S   p   a   c   e   s   h   i   p
S  p  a  c  e  s  h  i  p
S p a c e s h i p
Spaceship

Input: 05AB1E
Output:
05AB1E
0 5 A B 1 E
0  5  A  B  1  E
0   5   A   B   1   E
0    5    A    B    1    E
0     5     A     B     1     E
0    5    A    B    1    E
0   5   A   B   1   E
0  5  A  B  1  E
0 5 A B 1 E
05AB1E

Input: )}/\
Output:
)}/\
) } / \
)  }  /  \
)   }   /   \
)  }  /  \
) } / \
)}/\

Japt , 8 6 바이트

입력을 문자 배열로 취하고 문자열 배열을 출력합니다.

£qYçÃê

시도 해봐

설명

£          :Map each element at (0-based) index Y
 q         :  Join input with
  Yç       :   Space repeated Y times
    Ã      :End Map
     ê     :Palindromise

원본, 8 바이트

I / O는 문자열입니다. -R플래그를 사용합니다 . 각 줄에 후행 공백을 포함합니다.

¬£múYÄÃê

시도 해봐

설명

             :Implicit input of string U
¬            :Split
 £           :Map each character at 0-based index Y
  m          :  Map original U
   ú         :    Right pad with spaces to length ...
    YÄ       :     Y+1
      Ã      :End map
       ê     :Palindromise
             :Implicitly join with newlines

R , 105 99 85 84 79 바이트

@Kevin Cruissen과 @Giuseppe 덕분에 -6

-14 정규식 기반 방법으로 변경

@Giuseppe 덕분에 -1

@digEmALl 덕분에 -5

function(w,n=nchar(w)-1)write(trimws(Map(gsub,"",strrep(" ",n-abs(n:-n)),w)),1)

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

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

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

f=(s,p=i='',o=s.join(p)+`
`)=>s[++i]?o+f(s,p+' ')+o:o

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

숯 , 10 바이트

Ｅθ⪫θ× κ‖Ｏ↓

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명:

Ｅθ          Map over characters of input string
  ⪫θ        Join characters of input string using
    ×       a literal space repeated 
      κ     current index number of times
            Implicitly print each result on its own line
       ‖Ｏ↓  Reflect vertically with overlap

캔버스 , 8 바이트

┐² ×＊］──

여기 사용해보십시오!

이 도전 에는 7 바이트 버전이 너무 좋았습니다.

파이썬 2 , 72 70 68 66 65 바이트

^{Kevin Cruijssen 덕분에 -2 바이트
덕분에 -3 바이트}

w=input();c=s=-1
while c:print(' '*~c).join(w);s*=w[:c]>'';c+=s|1

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

05AB1E , 10 9 바이트

덕분에 1 바이트 절약 Adnan

εINð×ý}û»

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

설명

ε            # apply to each in input
 I           # push the input
  Nð×        # push <index> spaces
     ý       # merge the input on the spaces
      }      # end loop
       û     # palendromize
        »    # join on newlines

루비 , 54 49 바이트

->a{(-(z=a.size-1)..z).map{|i|a*(?\s*(z-i.abs))}}

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

입력을 문자 배열로 취하고 문자열 배열을 출력합니다.

apt , 9 8 바이트

@Shaggy에서 -1 바이트

ÊƬqXîÃê

ÊƬqXîÃê        Full program, implicity input U
ÊÆ              Rage from 0 to U length and map
  ¬             split U at ""
   qXîà     join U using " " times range current value
        ê       horizontal mirror

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

PowerShell , 66 54 바이트

mazzy 덕분에 -12 바이트

0..($x=($a=$args).count-1)+$x..0|gu|%{$a-join(' '*$_)}

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

TIO에서 각 문자에 대해 별도의 명령 줄 인수로 나타나는 스플래 팅을 통해 입력을받습니다.

먼저 $a=$args입력 인수로 설정 했습니다. 그런 다음 해당 배열 $x과 동일하게 설정 합니다. 그런 다음 우주선을 구성하기 위해 문자를 반복해야합니다. 그것은에서 까지 범위를 구성한 다음 다시로 범위를 정한 다음 적절한 범위 만 꺼내기 위해 사용 됩니다..count-10$x$x0Get-Unique

반복 할 때마다 입력 인수와 -join해당하는 공백 수와 함께 인수를 가져 옵니다. 이러한 각 문자열은 파이프 라인에 남아 Write-Output있으며 프로그램이 완료되면 암시 적으로 줄 바꿈을 제공합니다.

05AB1E (레거시) , 9 바이트

εINúíJ}û»

문자 목록으로 입력하십시오.

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

설명:

ε     }    # Map each character in the input to:
 I         #  Take the input
  Nú       #  Prepend each with the 0-indexed amount of spaces
           #   i.e. ["t","e","s","t"] & 3 → ["   t","   e","   s","   t"]
    í      #  Reverse each item
           #   i.e. ["   t","   e","   s","   t"] → ["t   ","e   ","s   ","t   "]
     J     #  Join them together to a single string
           #   i.e. ["t   ","e   ","s   ","t   "] → "t   e   s   t   "
       û»  # Palindromize the list, and join by newlines
           #  i.e. ["test","t e s t ","t  e  s  t  ","t   e   s   t   "]
           #   → "test\nt e s t \nt  e  s  t  \nt   e   s   t   \nt  e  s  t  \nt e s t \ntest"

하스켈 , 60 59 바이트

(init<>reverse).(scanl(?)<*>tail)
a?_=do u<-a;u:[' '|' '<u]

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

설명

문자열 (예 :)의 "abc"경우 먼저 적용

scanl (?) <*> tail

이것은 같은

\str -> scanl (?) str (tail str)

이것은 반복 적용 (?)(범위의 각 문자에 공간을 추가 [.. 33] 받는) str로서 많은 문자열이 없을 때까지 str문자가 :["abc","a b c ", "a b c "]

이제 우리는 결과를 (마지막 요소를 뺀) 반대 부분으로 연결하면됩니다.

init<>reverse

MATL , 25 22 13 바이트

zZv"Gtz@he!1e

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

덕분에 Luis Mendo5 바이트 골프를 제안 해 에게 말씀을 전하며 4 바이트를 더 줄였습니다.

입력 예와 함께 설명 'abc':

         # Implicit input, 'abc'
z        # find number of nonzero elements (length of string)
         # stack: [3]
Zv       # symmetric range
         # stack: [[1 2 3 2 1]]
"        # begin for loop, iterating over [1 2 3 2 1] as the loop indices
G        # push input
         # stack: ['abc']
tz       # dup and push length
         # stack: ['abc', 3]
@        # push loop index, i (for example, 2)
         # stack: ['abc', 3, 2]
h        # horizontally concatenate
         # stack: ['abc', [3, 2]]
e!       # reshape to matrix of 3 rows and i columns, padding with spaces, and transpose
         # stack: [['abc';'   ';'   ']]
1e       # reshape to matrix of 1 row, leaving last value on stack
         # stack: ['a  b  c  ']
         # implicit end of for loop
         # implicit end of program, display stack contents

젤리 , 9 바이트

jⱮLḶ⁶ẋƲŒḄ

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

행 목록을 리턴합니다. 출력은 TIO를 통해 미리 결정됩니다.

Pyth , 12 바이트

필자의 필수 Pyth 제출. 나는 이것을 자랑스럽게 생각하므로 설명이 곧 올 것입니다.

+P_=jRQ*L;_U

여기 사용해보십시오!

+P_=jRQ_.e*d

여기 사용해보십시오!

Stax , 10 바이트

Ç·9ƒù▌╘Ä┘e

실행 및 디버깅

각 줄에 후행 공백이있는 출력.

설명:

%R|pmx{]n(m Full program, unpacked, implicit input
%           Length of input
 R          1-based range
  |p        Palindromize
    m       Map:
     x{   m   Map over characters of input:
       ]        Character -> string
        n(      Right-pad to length given by outer map value
              Implicit flatten and output

Java (JDK 10) , 115 바이트

s->{for(int l=s.length(),i=-l;++i<l;)System.out.printf(s.replaceAll(".","%-"+(i<0?l+i:l-i)+"s")+"%n",s.split(""));}

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

• Kevin Cruijssen 덕분에 -2 바이트

K (oK) , 25 24 바이트

해결책:

,/'(1+a,1_|a:!#x)$\:+,x:

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

설명:

내 K4 솔루션의 포트 :

,/'(1+a,1_|a:!#x)$\:+,x: / the solution
                      x: / save input as x
                     ,   / enlist
                    +    / flip
                 $\:     / pad ($) right by each-left (\:)
   (            )        / do this together
              #x         / count length of input,           e.g. 3
             !           / range 0..length,                 e.g. 0 1 2
           a:            / save as a
          |              / reverse it,                      e.g. 2 1 0
        1_               / drop first,                      e.g. 1 0
      a,                 / join to a,                       e.g. 0 1 2 1 0
    1+                   / add 1,                           e.g. 1 2 3 2 1
,/'                      / flatten (,/) each (')

노트:

• ngn 덕분에 -1 바이트

파스칼 (FPC) , 143135 바이트

var s:string;i,j,l:word;begin read(s);l:=length(s);repeat i:=i+1;for j:=1to l do write(s[j],'':l-abs(l-i)-1);writeln until i=l*2-1 end.

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

아마 Lenguage에 대해서만 이길 것입니다 ...

PHP, 88 89 바이트

for(;++$i<2*$e=count($a=str_split($argn));)echo join(str_pad("",~-$e-abs($i-$e)),$a),"\n";

에 PHP 5 이상이 필요합니다 str_split. 파이프로 실행 -nR하거나 온라인으로 사용해보십시오 .

K4 , 23 바이트

해결책:

,/'(1+a,1_|a:!#x)$\:$x:

예:

q)k),/'(1+a,1_|a:!#x)$\:$x:"Spaceship"
"Spaceship"
"S p a c e s h i p "
"S  p  a  c  e  s  h  i  p  "
"S   p   a   c   e   s   h   i   p   "
"S    p    a    c    e    s    h    i    p    "
"S     p     a     c     e     s     h     i     p     "
"S      p      a      c      e      s      h      i      p      "
"S       p       a       c       e       s       h       i       p       "
"S        p        a        c        e        s        h        i        p        "
"S       p       a       c       e       s       h       i       p       "
"S      p      a      c      e      s      h      i      p      "
"S     p     a     c     e     s     h     i     p     "
"S    p    a    c    e    s    h    i    p    "
"S   p   a   c   e   s   h   i   p   "
"S  p  a  c  e  s  h  i  p  "
"S p a c e s h i p "
"Spaceship"

설명:

각 줄에 공백이 있습니다.

,/'(1+a,1_|a:!#x)$\:$x: / the solution
                     x: / save input as x,                 e.g. "abc"
                    $   / string,                          e.g. (,"a";,"b";,"c")
                 $\:    / pad ($) right by each-left (\:)
   (            )       / do this together
              #x        / count length of input,           e.g. 3
             !          / range 0..length,                 e.g. 0 1 2
           a:           / save as a
          |             / reverse it,                      e.g. 2 1 0
        1_              / drop first,                      e.g. 1 0
      a,                / join to a,                       e.g. 0 1 2 1 0
    1+                  / add 1,                           e.g. 1 2 3 2 1
,/'                     / flatten each

C 번호, 113 (105) 98 바이트

s=>{for(int l=s.Length,i=-l;++i<l;)WriteLine(Join("",s.Select(c=>$"{c}".PadRight(i<0?l+i:l-i))));}

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

스칼라 , 82 바이트

for(i<-(0 to a.size)union(-a.size to 0))println(a.map(_+" "*Math.abs(i)).mkString)

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

스칼라는 여기에 나를 돕는 많은 지름길을 가지고 있으며 그것은 꽤 읽을 수 있습니다! 스칼라 시도

Oracle SQL, 115 바이트

골프 언어는 아니지만 ...

SELECT TRIM(REGEXP_REPLACE(v,'(.)',LPAD('\1',1+LENGTH(v)-ABS(LEVEL-LENGTH(v)))))FROM t CONNECT BY LEVEL<2*LENGTH(v)

값이 v테이블의 열에 있다고 가정 합니다 t.

SQL 바이올린

Oracle 11g R2 스키마 설정 :

CREATE TABLE t ( v ) AS
  SELECT 'test' FROM DUAL;

쿼리 1 :

SELECT TRIM(REGEXP_REPLACE(v,'(.)',LPAD('\1',1+LENGTH(v)-ABS(LEVEL-LENGTH(v)))))
FROM   t
CONNECT BY LEVEL<2*LENGTH(v)

결과 :

(SQLFiddle은 어떤 이유로 열에 오른쪽 정렬 된 값을 인쇄합니다. 선행 공백은 없습니다)

| TRIM(REGEXP_REPLACE(V,'(.)',LPAD('\1',1+LENGTH(V)-ABS(LEVEL-LENGTH(V))))) |
|---------------------------------------------------------------------------|
|                                                                      test |
|                                                                   t e s t |
|                                                                t  e  s  t |
|                                                             t   e   s   t |
|                                                                t  e  s  t |
|                                                                   t e s t |
|                                                                      test |

8086 기계 코드, 56 53 바이트

00000000  bf 35 01 57 ba 01 00 52  be 82 00 b3 ff ac 59 51  |.5.W...R......YQ|
00000010  aa 3c 0d 74 07 b0 20 e2  f7 43 eb f1 b0 0a aa 59  |.<.t.. ..C.....Y|
00000020  00 d1 e3 08 38 cb d6 08  c2 51 eb dc c6 05 24 5a  |....8....Q....$Z|
00000030  b4 09 cd 21 c3                                    |...!.|
00000035

다음에서 조립 :

org 0x100
use16
        mov di, buffer
        push di
        mov dx, 1
        push dx
nextl:  mov si, 0x82
        mov bl, -1
nextc:  lodsb
        pop cx
        push cx
stor:   stosb
        cmp al, 0x0d
        je cr
        mov al, ' '
        loop stor
        inc bx
        jmp nextc
cr:     mov al, 0x0a
        stosb
        pop cx
        add cl, dl
        jcxz done
        cmp bl, cl
        salc
        or dl, al
        push cx
        jmp nextl
done:   mov [di], byte '$'
        pop dx
        mov ah, 0x09
        int 0x21
        ret
buffer:

테스트 사례 :

하스켈, 64 60 59 바이트

(""#)
a#s|l<-(:a)=<<s,w<-' ':a=l:[x|w<(' '<$s),x<-w#s++[l]]

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

a#s                         -- take a string of spaces 'a' and the input string 's'
 |l<-(:a)=<<s               -- let 'l' be the current line, i.e. the spaces in 'a'
                            -- appended to each char in 's'
  w<-' ':a                  -- let 'w' be 'a' with an additional space   
 =l                         -- return that 'l'
   :[   |w<(' '<$s)   ]     -- and, if 'w' is shorter than 's',
     x  ,x<-w#s++[l]        -- followed by a recursive call with 'w' 
                            -- and by another copy of 'l'

(""#)                       -- start with an empty 'a'

배쉬 , 115 , 109 , 105 , 100 , 97 , 96 , 92 , 91 , 90 바이트

Kevin Cruissen 덕분에 -5 & -3

read s;for((c=f=1;f;c-=2*(f>=${#s}),f+=c))
{ printf '%-'${f}'.c' `grep -o .<<<"$s"`
echo
}

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

(가)부터주의 \쉘 이스케이프 문자이며, 테스트 케이스를 )}/\추가로 입력해야 \다음과 같습니다 : )}/\\.

펄 6 , 43 바이트

{(0....comb-1...0)>>.&{join ' 'x$^a,.comb}}

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

줄 목록을 반환합니다.

설명:

 {                                         }  # Anonymous code block
  (0....comb-1...0) # A list from
   0                  # 0
    ...               # to
       .comb-1        # the length of the input string -1
              ...     # back to
                 0    # 0
                   >>.&{                  }  # Map each number to
                        join        ,.comb   # Join the list of characters
                             ' 'x$^a         # With the number of spaces

C (GCC) , 131 (129) 111 바이트

i;x;f(k,j)char*k,*j;{x=strlen(k)-1;for(i=0;i<x-~x;i+=puts(""))for(j=k;*j;)printf("%c%*s",*j++,i<x?i:2*x-i,"");}

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

ceilingcat 덕분에 -20 바이트 !

#import<string.h>
i;x;f(k,j)char*k,*j;{x=strlen(k)-1;for(i=0;i<x-~x;i+=puts(""))for(j=k;*j;)printf("%c%*s",*j++,i<x?i:2*x-i,"");}

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

또는 길이를 매개 변수로 승인 할 수있는 경우 :

C (gcc), 105 바이트

ceilingcat 덕분에 -1 바이트!

i;x;f(k,x,j)char*k,*j;{for(i=!x--;i<x-~x;i+=puts(""))for(j=k;*j;)printf("%c%*s",*j++,i<x?i:2*x-i,"");}

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

PHP, 148 146 143 141 바이트

function s($s){for(;$i<strlen($s);++$i)f($i,$s);for(--$i;--$i>=0;)f($i,$s);}function f($i,$s){echo chunk_split($s,1,str_repeat(' ',$i))."
";}

다음과 같이 테스트 할 수 있습니다.

<?php
error_reporting(0);

$s = 1234567890;
function s($s){for(;$i<strlen($s);++$i)f($i,$s);for(--$i;--$i>=0;)f($i,$s);}function f($i,$s){echo chunk_split($s,1,str_repeat(' ',$i))."
";}

산출

1234567890
1 2 3 4 5 6 7 8 9 0 
1  2  3  4  5  6  7  8  9  0  
1   2   3   4   5   6   7   8   9   0   
1    2    3    4    5    6    7    8    9    0    
1     2     3     4     5     6     7     8     9     0     
1      2      3      4      5      6      7      8      9      0      
1       2       3       4       5       6       7       8       9       0       
1        2        3        4        5        6        7        8        9        0        
1         2         3         4         5         6         7         8         9         0         
1        2        3        4        5        6        7        8        9        0        
1       2       3       4       5       6       7       8       9       0       
1      2      3      4      5      6      7      8      9      0      
1     2     3     4     5     6     7     8     9     0     
1    2    3    4    5    6    7    8    9    0    
1   2   3   4   5   6   7   8   9   0   
1  2  3  4  5  6  7  8  9  0  
1 2 3 4 5 6 7 8 9 0 
1234567890

모래 상자

확장 버전

 function s($s){
    //loop upwards 0-10
    for(;$i<strlen($s);++$i) f($i,$s);
     //decrement so it's odd, from 9 loop downwards to 0
    for(--$i;--$i>=0;)f($i,$s);
 }
 //2nd function to save space
 function f($i,$s){
     //chunk it, split 1 char, insert $i number of spaces
     echo chunk_split($s,1,str_repeat(' ',$i))."
";}

시도 2, 92 바이트

@Titus의 답변을 본 후 나는 이것을 내 것으로 줄였습니다.

for(;++$i<2*$e=strlen($s=$argn);)echo chunk_split($s,1,str_repeat(' ',~-$e-abs($i-$e)))."
";

나는 2 대신에 1 루프를 사용하는 방법을 생각하고 있었다. 믿거 나 말거나, 나는 for"실제"코드에서 루프를 거의 사용하지 않는다 . 그것은이었다 ~내가 없어진 것을, 아니 비트 ...

조금 아파서 92너무 나쁘지 않습니다. 그러나 나는 어쨌든 그것을 두 번째 시도로 넣을 것이다.

$argn 명령 행의 입력

-nR을 사용하여 파이프로 실행하거나 온라인으로 시도하십시오.

모래 상자