계속 내 버그에 불과 했습니다.

입력:

공백이나 줄 바꿈없이 인쇄 가능한 ASCII 문자로 구성된 문자열입니다.

산출:

먼저 입력을 되돌리고 입력하기 전에 중간 문자를 제외하고 입력을 회문으로 바꿉니다 (즉, 입력의 1234567890경우 0987654321234567890).

그런 다음이 텍스트를 출력하십시오.

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

(중간에서 바깥 방향으로, 각 문자는 이전 행보다 하나 이상의 공백으로 구분됩니다.)

도전 규칙 :

• 입력 길이에서 3 줄을 뺀 길이의 두 배를 인쇄해야합니다. 따라서 input으로 1234567890위에 표시된 출력은 17 줄 (길이 10 * 2-3)입니다.
• 입력에는 인쇄 가능한 ASCII 만 포함됩니다 (공백, 탭 및 줄 바꾸기 제외).
• 후행 공백은 선택 사항입니다.
• 단일 후행 줄 바꾸기는 선택 사항입니다.
• (추가) 선행 공백 또는 선행 개행은 허용되지 않습니다.
• 입력 길이는 항상 4 자 이상이라고 가정 할 수 있습니다.
• 내 버그 와 달리 입력 및 출력 형식 모두 유연합니다. 따라서 결과를 문자열 배열, 문자열 목록 등으로 출력 할 수 있습니다.

일반 규칙:

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

테스트 사례 :

Input: 1234567890
Output:
0        9        8        7        6        5        4        3        2        1        2        3        4        5        6        7        8        9        0
         0       9       8       7       6       5       4       3       2       1       2       3       4       5       6       7       8       9       0
                  0      9      8      7      6      5      4      3      2      1      2      3      4      5      6      7      8      9      0
                           0     9     8     7     6     5     4     3     2     1     2     3     4     5     6     7     8     9     0
                                    0    9    8    7    6    5    4    3    2    1    2    3    4    5    6    7    8    9    0
                                             0   9   8   7   6   5   4   3   2   1   2   3   4   5   6   7   8   9   0
                                                      0  9  8  7  6  5  4  3  2  1  2  3  4  5  6  7  8  9  0
                                                               0 9 8 7 6 5 4 3 2 1 2 3 4 5 6 7 8 9 0
                                                                        0987654321234567890
                                                               0 9 8 7 6 5 4 3 2 1 2 3 4 5 6 7 8 9 0
                                                      0  9  8  7  6  5  4  3  2  1  2  3  4  5  6  7  8  9  0
                                             0   9   8   7   6   5   4   3   2   1   2   3   4   5   6   7   8   9   0
                                    0    9    8    7    6    5    4    3    2    1    2    3    4    5    6    7    8    9    0
                           0     9     8     7     6     5     4     3     2     1     2     3     4     5     6     7     8     9     0
                  0      9      8      7      6      5      4      3      2      1      2      3      4      5      6      7      8      9      0
         0       9       8       7       6       5       4       3       2       1       2       3       4       5       6       7       8       9       0
0        9        8        7        6        5        4        3        2        1        2        3        4        5        6        7        8        9        0

Input: ABCD
Output:
D  C  B  A  B  C  D 
   D C B A B C D
      DCBABCD
   D C B A B C D
D  C  B  A  B  C  D

Input: =>)}]
Output:
]   }   )   >   =   >   )   }   ]
    ]  }  )  >  =  >  )  }  ]
        ] } ) > = > ) } ]
            ]})>=>)}]
        ] } ) > = > ) } ]
    ]  }  )  >  =  >  )  }  ]
]   }   )   >   =   >   )   }   ]

Input: XXxxXX
Output:
X    X    x    x    X    X    X    x    x    X    X
     X   X   x   x   X   X   X   x   x   X   X
          X  X  x  x  X  X  X  x  x  X  X
               X X x x X X X x x X X
                    XXxxXXXxxXX
               X X x x X X X x x X X
          X  X  x  x  X  X  X  x  x  X  X
     X   X   x   x   X   X   X   x   x   X   X
X    X    x    x    X    X    X    x    x    X   X

숯 , 14 바이트

Ｅ⁻Ｌθ¹⪫θ× ι‖Ｏ←↑

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

AST :

Program
├Print
│└Ｅ: Map
│ ├⁻: Difference
│ │├Ｌ: Length
│ ││└θ: Identifier θ
│ │└1: Number 1
│ └⪫: Join
│  ├θ: Identifier θ
│  └×: Product
│   ├' ': String ' '
│   └ι: Identifier ι
└‖Ｏ: Reflect overlap
 └Multidirectional
  ├←: Left
  └↑: Up

apt , 22 21 바이트

¬Å£¬qYîÃy w ê y w ê ·

온라인으로 테스트하십시오!

설명

처음 8 바이트는 패턴의 오른쪽 아래 사분면을 생성합니다.

 ¬ Å  £    ¬ qYîÃ
Uq s1 mXY{Uq qYî} 

Uq                 : Split the input into characters.
   s1              : Slice off the first.
      mXY{      }  : Map each item X and index Y to
          Uq       :   the input split into chars,
             q     :   joined with
              Yî   :     Y spaces.

이 시점에서 예를 들어 배열이 ["ABCD", "A B C D", "A B C D"]있습니다. 불행히도 이것을 제곱하는 데 13 바이트가 필요합니다.

y w ê y w ê ·
y w ê y w ê qR
y                : Pad each line to the same length with spaces and transpose.
  w              : Reverse the array, and
    ê            : palindromize. Now we have the bottom half of the output transposed.
      y          : Transpose back.
        w ê      : Reverse and palindromize again, giving the full output.
            qR   : Join with newlines.
                 : Implicit: output result of last expression

05AB1E , 17 바이트

g<F¹RSðN×ýû})Rû.c

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

kalsowerus 에게 -1 감사합니다 .

자바 스크립트 (ES6) , 159 (136) 129 (127) 바이트

f=(i,x=1-(l=i.length-1),y=x<0?-x:x,[,...b]=i)=>l>x?''.padEnd(l*(l+~y))+[...b.reverse(),...i].join(''.padEnd(y))+`
`+f(i,x+1):''

온라인으로 사용해보십시오! 아래 설명

// This is a recursive function
// First, inputs and various variable initializations
// by using defaults
let func = (
  // Text input, will not be modified through recursion
  input,

  // Current line, for the first function call we start from -lines to +lines
  // It's roughly equivalent to lines*2 but this helps us computing the spacing
  // Also computing the total amount of lines
  currentLine = 1 - (totalLines = input.length - 1),

  // Getting the absolute value of the current line (like Math.floor)
  absCurrentLine = currentLine < 0 ? -currentLine : currentLine,

  // Getting the input without it's first letter, useful for the palidrome of the input
  [,...slicedInput] = input

// Base case, stopping the recursion if the current line
// is still below the total amount of lines
) => totalLines > currentLine

  // Leading spacing
  ? ''.padEnd(totalLines * (totalLines + ~absCurrentLine)) + 

  // Putting together the palindrome version and adding spaces between the chars
    [...slicedInput.reverse(), ...input].join(''.padEnd(absCurrentLine)) + `

  // Line return + recursion call
` + f(input, currentLine + 1)
  : ''

codegolf에 처음 입장하면 명백한 실수에 대해 미리 사과드립니다.

23 바이트를 절약 해 준 Justin Mariner에게 감사합니다! 11 바이트를 절약하고 버그 보고서를 작성한 Craig Ayre에게 감사합니다.

SOGL V0.12 , 22 18 바이트

ā,⁄H{,čFH@*∑Κ}▓±╬-

여기 사용해보십시오!

설명:

ā                   push an empty array - canvas
 ,⁄H{        }      input length-1 times do
     ,                push the input
      č               chop it into chars
       FH@*           get the current iteration-1 amount of spaces
           ∑          join the chopped input with the spaces
            Κ         prepend it to the array
              ▓     space to a square
               ±    reverse each string in that list
                ╬-  quad-palindromize with 1 X and 1 Y overlap and without swapping characters

파이썬 3 , 149141 95 바이트

def f(s):l=len(s)-1;[print((' '*abs(i)).join(s[:0:-1]+s).center(2*l*l+1))for i in range(1-l,l)]

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

바이트를 절약 해 준 @KevinCruijssen 및 @ETHproductions에게 감사합니다

46 바이트를 절약 한 @notjagan에게 특별한 감사를드립니다!

PHP, 145131 바이트

추가 바이트를 골프화하는 데 약간의 생각이 필요했습니다. 그렇지만 그만한 가치가 있었어.

while($y<=2*$e=strlen($a=$argn)-1)echo($p=str_pad)("
",$e*($e-$d=abs($y++-$e))+1),chunk_split($a.substr(strrev($a),1),1,$p("",$d));

선행 줄 바꿈을 인쇄합니다. 파이프로 실행 -nR하거나 온라인으로 사용해보십시오 .

고장

while($y<=2*$e=strlen($a=$argn)-1)  # $e=length-1, loop through rows
                                        # 1. print linebreak and left padding
    echo($p=str_pad)("\n",$e*($e-$d=abs($y++-$e))+1),
        chunk_split(
            $a.substr(strrev($a),1)     # 2. palindromize input
            ,1,$p("",$d));              # 3. insert $e..0..$e spaces between characters

대체 솔루션 , 같은 길이 :

for($d=-$e=strlen($a=$argn)-1;$d<$e;)echo($p=str_pad)("
",$e*($e-$b=abs($d++))+1),chunk_split($a.substr(strrev($a),1),1,$p("",$b));

APL (Dyalog) , 37 바이트

⎕IO←0많은 시스템에서 기본값이 필요합니다 .

{⍉m(2-d)↓⍉(m←⊖⍪1↓⊢)↑∊¨(1↓⍳d←≢⍵)↑¨¨⊂⍵}

{… } 인수가 ⍵ 로 표시되는 익명 함수

 (... )↑¨¨⊂⍵ 각 (위해 ¨다음 번호)를 받아 ( ↑) 많은 문자의 각 ( ¨전체 (의) ⊂) 인수, 필요에 따라 공백 패딩 :

  ≢w 인수의 문자 수

  d←d에  저장

  ⍳ 많은 ndi dioces (0… d -1)

  1↓ 하나를 떨어 뜨리십시오 (0)

 ∊¨ ϵ nlist (평평하게) 각

 ↑ 순위를 올립니다 (목록 목록을 행렬로 변환)

 (m←… ) 다음과 같이 정의 된 다음 암묵 함수 m을 적용하십시오 .

  ⊖ 거꾸로 논쟁

  ⍪ 위에

  1 하나 [행]

  ↓ 에서 떨어졌다

  ⊢ 논쟁 거리

 ⍉ 바꾸어 놓다

 (... )↓ 드롭 :

  2-d =-( d − 2), 즉 바닥에서 d -2 행

 mm을  적용

 ⍉ 바꾸어 놓다

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

자바 (오픈 JDK 8) , 201 (196) 바이트

s->{for(int l=s.length()-1,i=-l,x=0;++i<l;x+=i<0?l:-l)System.out.printf("%1$"+(x<1?"":x)+"s"+s.join("%1$"+(i<0?-i:i>0?i:"")+"s",(new StringBuffer(s.substring(1)).reverse()+s).split(""))+"%n","");}

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

생성기 문자열이 길어지고 처리하기가 더 어렵다는 점을 제외하고 는 이전 챌린지 에서 사용한 것과 같은 아이디어 입니다.

%1$Ns0%1$Ns9%1$Ns8%1$Ns7%1$Ns6%1$Ns5%1$Ns4%1$Ns3%1$Ns2%1$Ns1%1$Ns2%1$Ns3%1$Ns4%1$Ns5%1$Ns6%1$Ns7%1$Ns8%1$Ns9%1$Ns0%n

파이썬 3 , 134124 바이트

f=lambda s:'\n'.join([' '*(len(s)-1)*abs(len(s)-abs(i)-2)+(' '*abs(i)).join(s[::-1]+s[1:]) for i in range(2-len(s),len(s)-1)])

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

잠시 동안 숨어서 PPCG에 첫 번째 게시물. 어떤 제안이나 조언을 찾고 있습니다!

개선을위한 @LyricLy와 @ Łukasz Rogalski에게 감사합니다!

하스켈, 177163 바이트

import Data.List
k n=[1..n]>>" "
f s=let n=length s in map(\x->(k(((n-1)*(n-(abs x)))))++(intercalate (k(abs x))$map(\z->[z])$((++)=<<reverse.tail) s))[n,n-1.. -n]

이 함수 f는 challenge 함수이며 문자열을 [String]사용 unlines하여 테스트 목록과 동일한 시각적 출력을 제공해야합니다 ().main = putStr $ unlines $ f "test string" 컴파일).

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

@nimi 덕분에 -14 바이트

수학, 141 바이트

Column[Join[Reverse@(s=Row/@Table[Riffle[Reverse@Rest@b~Join~b,""<>Table[" ",i]],{i,0,Length[b=Characters@#]-1}]),Rest@s],Alignment->Center]&