ดำเนินการต่อของฉันมันเป็นเพียงข้อบกพร่องความท้าทาย :

การป้อนข้อมูล:

สตริงที่ประกอบด้วยอักขระ 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 บรรทัด ดังนั้นด้วยอินพุต1234567890เอาต์พุตที่แสดงด้านบนคือ 17 บรรทัด (ความยาว 10 * 2 - 3)
• อินพุตจะมีเฉพาะ ASCII ที่พิมพ์ได้ (ยกเว้นช่องว่างแท็บและบรรทัดใหม่)
• ช่องว่างต่อท้ายเป็นตัวเลือก
• บรรทัดใหม่ต่อท้ายเป็นตัวเลือก
• ไม่อนุญาตให้เว้นวรรคนำหน้าหรือขึ้นบรรทัดใหม่
• คุณสามารถสันนิษฐานได้ว่าอินพุตจะมีความยาวอย่างน้อยสี่ตัวอักษร
• แตกต่างจากฉันมันเป็นเพียงความท้าทายข้อบกพร่องทั้งรูปแบบอินพุตและเอาต์พุตมีความยืดหยุ่น ดังนั้นคุณจะได้รับอนุญาตให้ส่งออกผลลัพธ์เป็น String-array, String-list ฯลฯ

กฎทั่วไป:

• นี่คือ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

Japt , 22 21 ไบต์

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

ทดสอบออนไลน์!

คำอธิบาย

8 ไบต์แรกสร้าง Quadrant ด้านล่างขวาของลวดลาย:

 ¬ Å  £    ¬ 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"]e กรัม น่าเสียดายที่ใช้เวลา 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

ลองออนไลน์!

-1 ขอบคุณที่kalsowerus

JavaScript (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 ฉันต้องขออภัยล่วงหน้าสำหรับข้อผิดพลาดที่ชัดเจนใด ๆ

ขอบคุณ Justin Mariner ที่ประหยัด 23 ไบต์! ขอบคุณ Craig Ayre สำหรับการบันทึก 11 ไบต์และสำหรับรายงานข้อผิดพลาด

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

Python 3 , 149 141 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 สำหรับการบันทึกไบต์

ขอขอบคุณ @notjagan ที่ช่วยประหยัด 46 ไบต์!

PHP, 145 131 ไบต์

มันต้องใช้ความคิดที่จะตีกอล์ฟเพิ่มอีกหนึ่งไบต์ แต่มันก็คุ้มค่า.

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

  ⍳ ที่หลายɩ ndices (0 ... d - 1)

  1↓ ปล่อยหนึ่ง (ศูนย์)

 ∊¨ ϵ รายการ (แบน) แต่ละรายการ

 ↑ เพิ่มอันดับ (แปลงรายการของรายการเป็นเมทริกซ์)

 (m←… ) ใช้ฟังก์ชั่น tacit ต่อไปนี้mซึ่งนิยามเป็น:

  ⊖ อาร์กิวเมนต์คว่ำ

  ⍪ ด้านบนของ

  1 หนึ่ง [แถว]

  ↓ ลดลงจาก

  ⊢ อาร์กิวเมนต์

 ⍉ transpose

 (... )↓ ลดลง:

  2-d = - ( d - 2) คือd - 2 แถวจากด้านล่าง

 m ใช้เมตร

 ⍉ transpose

ลองออนไลน์!

Java (OpenJDK 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

Python 3 , 134 124 ไบต์

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 สำหรับการปรับปรุง!

Haskell, 177 163 ไบต์

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นี้เป็นฟังก์ชั่นท้าทายและส่งกลับรายการของสตริง ( [String]) โดยใช้unlinesมันควรจะให้เอาต์พุตภาพเหมือนกรณีทดสอบ (main = putStr $ unlines $ f "test string"เพื่อคอมไพล์มัน)

ลองออนไลน์!

-14 ไบต์ขอบคุณ @nimi

Mathematica, 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]&