Tiếp tục của tôi Đó chỉ là một thử thách lỗi:

Đầu vào:

Một chuỗi bao gồm các ký tự ASCII có thể in mà không có khoảng trắng cũng như dòng mới.

Đầu ra:

Đầu tiên, biến đầu vào thành một bảng màu bằng cách hoàn nguyên đầu vào và thêm nó vào trước, ngoại trừ ký tự ở giữa (nghĩa là với một đầu vào 1234567890, nó sẽ trở thành 0987654321234567890).

Và sau đó xuất văn bản này:

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

(Từ giữa ra ngoài theo cả hai hướng, mỗi ký tự được phân tách bằng một khoảng trắng so với dòng trước.)

Quy tắc thử thách:

• Bạn cần in gấp đôi chiều dài của đầu vào, trừ 3 dòng. Vì vậy, với đầu vào 1234567890, đầu ra hiển thị ở trên là 17 dòng (dài 10 * 2 - 3).
• Đầu vào sẽ chỉ chứa ASCII có thể in (không bao gồm không gian, tab và dòng mới).
• Không gian lưu trữ là tùy chọn.
• Một dòng mới duy nhất là tùy chọn.
• (Bổ sung) không gian hàng đầu hoặc dòng mới hàng đầu không được phép.
• Bạn có thể giả sử đầu vào sẽ luôn dài ít nhất bốn ký tự.
• Không giống như tôi Đó chỉ là một thử thách lỗi, cả định dạng đầu vào và đầu ra đều linh hoạt. Vì vậy, bạn được phép xuất kết quả dưới dạng Chuỗi-mảng, Danh sách chuỗi, v.v.

Quy tắc chung:

• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.
  Đừng để ngôn ngữ mã-golf ngăn cản bạn đăng câu trả lời với các ngôn ngữ không mã hóa. Cố gắng đưa ra một câu trả lời càng ngắn càng tốt cho ngôn ngữ lập trình 'bất kỳ'.
• Các quy tắc chuẩn áp dụng cho câu trả lời của bạn, vì vậy bạn được phép sử dụng STDIN / STDOUT, các hàm / phương thức với các tham số thích hợp và kiểu trả về, các chương trình đầy đủ. Cuộc gọi của bạn.
• Lỗ hổng mặc định bị cấm.
• Nếu có thể, vui lòng thêm một liên kết với một bài kiểm tra cho mã của bạn.
• Ngoài ra, xin vui lòng thêm một lời giải thích nếu cần thiết.

Các trường hợp thử nghiệm:

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

Than , 14 byte

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

Hãy thử trực tuyến!

AST:

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

Japt , 22 21 byte

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

Kiểm tra nó trực tuyến!

Giải trình

8 byte đầu tiên tạo góc phần tư phía dưới bên phải của mẫu:

 ¬ Å  £    ¬ 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.

Tại thời điểm này, chúng tôi có một mảng ví dụ ["ABCD", "A B C D", "A B C D"]. Thật không may, phải mất 13 byte để bình phương này:

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 byte

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

Hãy thử trực tuyến!

-1 nhờ kalsowerus .

JavaScript (ES6) , 159 136 129 127 byte

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):''

Hãy thử trực tuyến! Giải thích bên dưới

// 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)
  : ''

Đầu tiên vào codegolf, tôi xin lỗi trước cho bất kỳ sai lầm rõ ràng.

Cảm ơn Justin Mariner vì đã tiết kiệm 23 byte! Cảm ơn Craig Ayre vì đã lưu 11 byte và cho báo cáo lỗi.

SOGL V0.12 , 22 18 byte

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

Hãy thử nó ở đây!

Giải trình:

ā                   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

Python 3 , 149 141 95 byte

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

Hãy thử trực tuyến!

Cảm ơn @KevinCruijssen và @ETHproductions đã lưu một số byte

Đặc biệt cảm ơn @notjagan vì đã tiết kiệm 46 byte!

PHP, 145 131 byte

Phải mất một số suy nghĩ để chơi golf thêm byte; Nhưng nó đáng mà.

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

in một dòng mới hàng đầu. Chạy như ống với -nRhoặc thử trực tuyến .

phá vỡ

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

giải pháp thay thế , cùng chiều dài:

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 byte

Yêu cầu ⎕IO←0mặc định trên nhiều hệ thống.

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

{... } chức năng ẩn danh mà lập luận được đại diện bởi ⍵

 (... )↑¨¨⊂⍵ cho mỗi ( ¨) của những con số sau đây mất ( ↑) mà nhiều nhân vật từ mỗi ( ¨) của toàn bộ ( ⊂tranh cãi), đệm với không gian khi cần thiết:

  ≢w số lượng ký tự trong đối số

  d← lưu trữ trong d

  ⍳ rất nhiều ɩ ndices (0 làng d - 1)

  1↓ thả một (số không)

 ∊¨ ε nlist (flatten) mỗi

 ↑ nâng thứ hạng (chuyển đổi danh sách danh sách thành ma trận)

 (m←... ) áp dụng sau ngầm chức năng m , được xác định như sau:

  ⊖ đối số lộn ngược

  ⍪ trên đỉnh

  1 một hàng]

  ↓ rơi từ

  ⊢ tranh luận

 ⍉ hoán vị

 (Giáo dục)↓  thả:

  2-d = - ( d - 2), tức là d - 2 hàng từ dưới lên

 m ứng dụng m

 ⍉ hoán vị

Hãy thử trực tuyến!

Java (OpenJDK 8) , 201 196 byte

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

Hãy thử trực tuyến!

Đó là ý tưởng giống như ý tưởng mà tôi đã sử dụng cho thử thách trước đó , ngoại trừ chuỗi trình tạo giờ dài hơn một chút và khó xử lý hơ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

Python 3 , 134 124 byte

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

Hãy thử trực tuyến!

Bài đăng đầu tiên lên PPCG sau khi ẩn nấp một lúc. Tìm kiếm bất kỳ đề nghị / lời khuyên!

Cảm ơn @LyricLy và @ ukasz Rogalski vì những cải tiến!

Haskell, 177 163 byte

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]

Hàm fnày là hàm thử thách và trả về một danh sách các chuỗi ( [String]), sử dụng unlinestrên nó sẽ cung cấp đầu ra trực quan giống như các trường hợp thử nghiệm (main = putStr $ unlines $ f "test string" để biên dịch nó).

Hãy thử trực tuyến!

-14 byte nhờ @nimi

Toán học, 141 byte

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