อลิซเป็นผู้ฝึกงานใน บริษัท ที่ใช้ Brainfuck เป็นภาษาหลักสำหรับการพัฒนาลูกค้าและฝั่งเซิร์ฟเวอร์ อลิซเพิ่งเขียนโค้ดแรกของเธอและเธอก็กังวลเล็กน้อยเมื่อเธอเตรียมพร้อมสำหรับการทบทวนรหัสครั้งแรก

อลิซต้องการที่จะทำให้รหัสของเธอในรูปแบบที่ถูกต้องและดูดี แต่เธอก็มีเวลาในการอ่านคู่มือ 328 หน้า บริษัท รหัสลักษณะไม่มีดังนั้นเธอจึงตัดสินใจที่จะจัดรูปแบบเป็นตารางที่สมบูรณ์ อนิจจาความยาวโค้ดอาจไม่เพียงพอในการสร้างสี่เหลี่ยมดังนั้นเธอจึงตัดสินใจทิ้งช่องว่างสี่เหลี่ยมไว้ตรงกลาง ช่องว่างจะต้องอยู่กึ่งกลางอย่างสมบูรณ์และใกล้กับตารางมากที่สุด

ตัวอย่าง

++++++         +++++         +++++         +++++         +++++         +++++
++++++         +++++         +++++         +  ++         ++ ++         +++++
++++++         ++ ++         +   +         +  ++         +   +
++++++         +++++         +++++         +++++         ++ ++         +++++
++++++         +++++         +++++         +++++         +++++         +++++

Perfect         OK         Acceptable   Unacceptable    No way!        Nope.

เขียนโปรแกรมหรือฟังก์ชั่นเพื่อช่วยอลิซ กำหนดรหัสของอลิซเป็นสตริงอินพุตให้จัดรูปแบบรหัสอย่างถูกต้องตามที่อธิบายไว้ด้านล่างหากเป็นไปได้ หากการจัดรูปแบบเป็นไปไม่ได้ให้ส่งอีโมจิ:~(ออกมา

นี่คือcode-golfดังนั้นคำตอบจะได้คะแนนเป็นไบต์โดยมีจำนวนไบต์น้อยกว่าที่เป็นเป้าหมาย

ข้อ จำกัด

1. โปรแกรมหรือฟังก์ชั่นของคุณควรใช้สายอักขระเดียวเป็นอินพุตและเอาต์พุตข้อความหนึ่งบรรทัดหรือมากกว่านั้น (หรือส่งคืนสตริงแบบหลายบรรทัดหรืออาร์เรย์ของสตริงหากคุณใช้ฟังก์ชัน)
2. สตริงอินพุตอาจมีอักขระ ASCII ใด ๆ รวมถึง whitespaces
3. ช่องว่างทั้งหมดในอินพุตต้องถูกละเว้น พวกเขาไม่ควรนับความยาวรหัสและไม่ควรใช้ในผลลัพธ์
4. สตริงอินพุตมีอักขระที่ไม่ใช่ช่องว่างอย่างน้อยหนึ่งตัว
5. รหัสที่จัดรูปแบบต้องมีอักขระที่ไม่ใช่ช่องว่างเดียวกันในลำดับเดียวกันกับในรหัสที่ป้อน
6. รหัสที่จัดรูปแบบแล้วจะต้องเป็นสี่เหลี่ยมจัตุรัสที่สมบูรณ์แบบเช่นทุกบรรทัดควรมีความยาวเท่ากันและจำนวนบรรทัดควรเท่ากับความยาวของเส้น
7. รหัสที่จัดรูปแบบอาจมีช่องว่างตรงกลาง
8. สามารถใช้อักขระช่องว่างเท่านั้น (รหัส ASCII 32) ในช่องว่าง
9. ช่องว่าง (ถ้ามี) จะต้องเป็นสี่เหลี่ยม
10. บรรทัดของโค้ดที่จัดรูปแบบทุกบรรทัดต้องมีอักขระที่ไม่ใช่ช่องว่างอย่างน้อยหนึ่งตัวนั่นคือความกว้างของช่องว่างจะต้องน้อยกว่าความกว้างของตารางอย่างเคร่งครัด (ช่องว่าง 5x1 ไม่สามารถใช้ได้สำหรับ 5x5 ตาราง)
11. ช่องว่างควรเป็นแนวนอนกล่าวคือความกว้างของช่องว่างควรมากกว่าหรือเท่ากับความสูงของช่องว่าง
12. ช่องว่างจะต้องอยู่กึ่งกลางอย่างสมบูรณ์แบบ
13. ดังนั้นความกว้างของช่องว่างและความเท่าเทียมกันของความสูงควรเท่ากับความกว้างของช่องสี่เหลี่ยม (เช่นช่องว่าง 5x5 อาจเป็น 1x1, 3x1 หรือ 3x3)
14. ถ้าเป็นไปได้ให้เอาท์พุทสแควร์โดยไม่มีช่องว่างเลย
15. ในกรณีที่มีการแก้ปัญหาหลายอย่างให้เลือกอันที่มีช่องว่างใกล้กับสแควร์มากที่สุดนั่นคือความแตกต่างระหว่างความกว้างของช่องว่างและความสูงของช่องว่างนั้นน้อยที่สุด (ตัวอย่างเช่นช่องว่าง 10x10 จะดีกว่า 8x6 และ 8x6
16. หากยังคงมีเน็คไทให้เลือกโซลูชันที่มีพื้นที่ช่องว่างน้อยที่สุด (เช่นช่องว่าง 2x2 เป็นที่นิยมมากกว่า 4x4)
17. :~(ถ้ามันเป็นไปไม่ได้ที่จะจัดรูปแบบรหัสที่ทุกคนเอาท์พุท
18. ขึ้นบรรทัดใหม่หลังจากบรรทัดสุดท้ายเป็นตัวเลือก
19. [ใหม่]คุณอาจสันนิษฐานได้อย่างปลอดภัยว่าอักขระใด ๆ ที่มีรหัสต่ำกว่า 33 คือ white-space ฉันหวังว่ามันจะช่วยคุณในการเล่นกอล์ฟ

การทดสอบ

Input           Output      Code length     Comment

+++++++++       +++                   9     Alice is lucky, 
                +++                         her code perfectly fits a square. 
                +++


++++++++        +++                   8     Though code length isn't enough for a square, 
                + +                         a small gap fixes it.
                +++


++++++          :~(                   6     No luck, code cannot be formatted.


Hello,          Hell                 12     Input may contain any ASCII characters, 
World!          o  ,                        but whitespaces in input should be ignored.
                W  o
                rld!


+++++ + +++++   +++++                22     Gap is not required to be a square, 
+++++ + +++++   +++++                       it can be a rectangle.
                +   +
                +++++
                +++++

+++ + +++       ++++++++             28     There exists another solution: 
+++ + +++       +      +                    6x6 square with 4x2 gap, 
+++ + +++       +      +                    but in Alice's opinion square gap 
+++ + +++       +      +                    makes code more readable.
                +      +
                +      +
                +      +
                ++++++++

การทดสอบที่ยุ่งยาก

This must be    Thism                24     7x7 with 5x5 gap looks good,
5x5 with 1x1    ustbe                       but 5x5 with 1x1 gap is better,
gap.            5x 5w                       because gap area is smaller.
                ith1x
                1gap.

+++ +++ +++     :~(                  18     In case you tried 5x5 square
+++ +++ +++                                 with 7x1 gap ;)

ทรัพยากร

เพื่อประหยัดพื้นที่คุณสามารถค้นหารหัสตัวอย่างและกรณีทดสอบเพิ่มเติมได้ที่ tio.run

[ใหม่]คุณอาจจะดูที่ตารางของการแก้ปัญหาที่ได้รับการยอมรับสำหรับปัจจัยการผลิตไม่เกิน 100 ตัวอักษร ฉันสลับความกว้างและความสูงเนื่องจากดูเหมือนว่าจะฉลาดยิ่งขึ้น

แรงบันดาลใจจาก: ข้อความหนึ่งตาราง

การเปลี่ยนแปลง

• เพิ่มการทดสอบ 2 รายการแก้ไขข้อผิดพลาดในโค้ดตัวอย่าง

• เพิ่มตารางของโซลูชันมากถึง 100 เพิ่มการเพิ่มความชัดเจนของ white-space

C (gcc) , 354 ไบต์

h,i,j,k,l,m;g,v,w,d;f(char*s){for(i=l=0;s[i];l+=!isspace(s[i++]));d=g=l;for(i=0;i++<l;)if(h=i*i-l)for(j=0;j<i-++j;h>0&h%k<1&k<=m&m<i&m+~k&&m-k<g|m==k+g&(d-2*v)*(d-2*w)>h?w=(i-m)/2,v=j,g=m-k,d=i:j)k=i-2*j,m=h/k;else g=0,v=w=d=i;if(g-l)for(i=j=1;*s;j+=!i++,k=0,i%=d+1)for(putchar(i?v>=j|j>d-v|w>=i|i>d-w?k=1,*s:32:10);k;k*=isspace(*++s));else puts(":~(");}

ลองออนไลน์!

JavaScript (ES6),  284 ... 274  270 ไบต์

บันทึกแล้ว 4 ไบต์ขอบคุณ @Shaggy

ส่งคืนอาร์เรย์ของสตริง

s=>(s=s.replace(/\s/g,''),n=s.length,o=[':~('],W=d=g=(x,w=0,h=p=0)=>4*~-x>n?o:h>w?++w>x-2?g(-~x):g(x,w):g(x,w,h+1,o=n-x*x+w*h|(w^x|h^x)&!!(w|h)|w-h>d|w-h==d&w>W?o:[...Array(x)].map((_,Y,a)=>a.map((_,X)=>2*X>=x-w&2*X<x+w&2*Y>=x-h&2*Y<x+h?' ':s[p++]).join``,d=w-h,W=w)))``

ลองออนไลน์!

Stax , 80 ไบต์

ö╦Çc▀╕╡ëé╓]µiÖ9♪`W|╣▐↑╖D┘↕♫╗╔äƒ■úφ■U`ÿ⌠%é┴☼vAú)☺@ı◄¬¶¢(îÉ┼6⌠D~♀└lfæA.I@º╤∟òîü╦(

เรียกใช้และแก้ไขข้อบกพร่อง

มันทำงานยังไง?

• พิจารณาสแควร์ทั้งหมดที่มีพิลึกสี่เหลี่ยม
• กรองรูปร่างของโปรแกรมที่มีขนาดไม่ถูกต้อง
• กรองรูปร่างของโปรแกรมที่ไม่มีพาริตีที่ตรงกัน
• กรองรูปร่างของโปรแกรมที่ช่องเจาะมีขนาดใหญ่เกินไปสำหรับจัตุรัส
• หากไม่พบพบว่ามีความล้มเหลวในการส่งออกและออกจาก
• ค้นหารูปร่างที่ลด "rectity" ของ cutout จากนั้นตามขนาด cutout
• แทนที่อักขระแต่ละตัวในรูปแบบโปรแกรมด้วยอักขระที่สอดคล้องกันในอินพุตโปรแกรม

คลายกล่อง ungolfed และแสดงความคิดเห็นว่ามีลักษณะเช่นนี้

                input e.g. "big socks"
L$j$            remove whitespace from input e.g. "bigsocks"
cr{~F           copy push each remaining character to input stack in reverse order
%c              get length L of flattened input and copy e.g. 8
^r3:$           create triples [a,b,c] in range 0..n e.g. [[0,0,0], [0,0,1], ... [8,8,8]]
{E*NsJ+n=f      filter triples: require a*a-b*c=L e.g. [[3,1,1], [4,1,8], ...]
{ET>f           filter triples: a>b and a>c e.g. [[3,1,1]]
{{2%m:u_0#+f    filter triples: a%2=b%2=c%2 or b*c=0 e.g. [[3,1,1]]
":~("s|c        if there are no triples, output ":~(" and terminate
{D:s_D:*\oh     sort by [abs(b-c),b*c]; keep the first e.g. [3,1,1]
X               store the chosen triple in the X register
E               explode onto stack e.g. 3, 1, 1
z)]*            using last two values, make a rectangle of zeroes e.g. 3, [[0]]
~               this will be the cutout, push it to the input stack
c'X*]*          make a square of "X" e.g. ["XXX", "XXX", "XXX"]
xEd-h           given the dimensions in x register, calculate the centered cutout coordinates
xEsd-h          e.g. ["XXX", "XXX", "XXX"], 1, 1
,||             embed the cutout grid at the specified coordinates e.g. ["XXX", "X X", "XXX"]
m'X{,]}R        for each line, regex replace "X" with a character from the input stack

เรียกใช้อันนี้

ถ่าน 120 ไบต์

≔Ｅ⮌⪫⪪Ｓ ωιθ≔⁰ηＦ⊕Ｌθ¿⁼Ｌθ×ιι«≔ιη≔ιζ≔ιε»Ｆ⊘ιＦ⊕κＦ∧⁼Ｌθ⁻×ιι×⁻ι⊗⊕κ⁻ι⊗⊕λ∨¬η›⁻ζε⁻κλ«≔ιη≔⊕κζ≔⊕λε»¿η«ＵＯη#ＪεζＦ›η⊗ζＵＯ⁻η⊗ε⁻η⊗ζψＵＭＫＡ⊟θ»:~(

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด คำอธิบาย:

≔Ｅ⮌⪫⪪Ｓ ωιθ

ตัดช่องว่างจากอินพุตจากนั้นย้อนกลับและแยกเป็นอักขระเพื่อให้เราสามารถวนซ้ำอักขระได้ง่ายขึ้นในภายหลัง

≔⁰η

เริ่มต้นด้วยขนาดศูนย์ระบุว่าไม่พบผลลัพธ์ (ยัง)

Ｆ⊕Ｌθ

ตรวจสอบความยาวด้านทั้งหมดจนถึงความยาวของสตริง (การขว้างหารในหลักสูตรจะทำให้โค้ดเร็วขึ้น)

¿⁼Ｌθ×ιι«≔ιη≔ιζ≔ιε»

หากผลลัพธ์ออกมาเป็นสี่เหลี่ยมจัตุรัสที่สมบูรณ์แบบให้บันทึกขนาดสี่เหลี่ยมและตั้งเป็นขนาดชายแดน

Ｆ⊘ιＦ⊕κ

วนรอบความสูงและความกว้างของเส้นขอบที่เป็นไปได้ (ความกว้างชายแดนไม่เกินความสูงของเส้นขอบทำให้ความสูงของช่องว่างไม่เกินความกว้างของช่องว่าง)

Ｆ∧⁼Ｌθ⁻×ιι×⁻ι⊗⊕κ⁻ι⊗⊕λ∨¬η›⁻ζε⁻κλ«≔ιη≔⊕κζ≔⊕λε»

หากขนาดของเส้นขอบเป็นความยาวที่ต้องการและเรายังไม่มีวิธีแก้ปัญหาหรือไม่เป็นสี่เหลี่ยมจัตุรัสเหมือนโซลูชันนี้จากนั้นอัปเดตโซลูชันด้วยขนาดสี่เหลี่ยมจัตุรัสและเส้นขอบนี้

¿η«

หากเรามีทางออก ...

ＵＯη#

วาดสี่เหลี่ยมของอักขระที่กำหนดขนาดสี่เหลี่ยมที่กำหนด

ＪεζＦ›η⊗ζＵＯ⁻η⊗ε⁻η⊗ζψ

หากเส้นขอบมีขนาดเล็กพอที่จะออกจากช่องว่างได้ให้ลบช่องว่างนั้นออก (คำสั่งการวาดจะวาดขึ้นและไปทางซ้ายสำหรับค่าลบและไม่ชอบค่าศูนย์เลย)

ＵＭＫＡ⊟θ

แทนที่อักขระทั้งหมด (ที่เหลือ) ด้วยอักขระจากอินพุต

»:~(

:~(ส่งออกมิฉะนั้น

เยลลี่ , 91 85 ไบต์

ÆDżU$<Ạa;ḂEɗʋƇṢƑƇ;€€
ḟ⁶ḟ⁷;©⁶L’²<¥Ðḟ²_ç;,`Wɗ¹?⁸ʋ€$Ẏạ/ÞḢµIH+""Rp"/ḟ@/ŒṬ€ĖP€Sị®Yµ“:~(”¹?

ลองออนไลน์!

:~(การเชื่อมโยงเอกที่ใช้สายป้อนเป็นอาร์กิวเมนต์และผลตอบแทนของสตริงทั้งที่มีการส่งออกรูปแบบหรือ

Python 2, 287 281 279 bytes

c=list("".join(input().split()))
l=len(c)
p=[]
for q in range(l*l):x=q%l;y=q/l;s=(l+x*y)**.5;p+=[(abs(x-y)/2,int(s),-x)]*(s%1==0)*(x<s-1>y>=s%2==x%2==y%2or x<1)
if p:d,s,x=min(p);b=(s+x)/2;Y=0;exec"c[b:b]=' '*-x*(b+d<=Y<s-b-d);print''.join(c[:s]);c=c[s:];Y+=1;"*s
else:print':~('

ลองออนไลน์!

ใช้การเปรียบเทียบรายการพจนานุกรมภาษาไพ ธ อนโดยใช้ค่าเดียวกันสำหรับทั้งการเลือกโซลูชันและการพิมพ์ ฉันค่อนข้างแน่ใจว่า10 4 2 หรือมากกว่านั้นไบต์ยังคงสามารถโกนออกได้

คำอธิบาย

c=list("".join(input().split()))
l=len(c)
p=[]

ลบช่องว่างด้วยการแยกช่องว่างและเข้าร่วมด้วย""จากนั้นแปลงอินพุตเป็นรายการภายหลัง เริ่มต้นด้วยlความยาวของรหัสจริงและpรายการความเป็นไปได้ที่ถูกต้อง

for q in range(l*l):x=q%l;y=q/l;s=(l+x*y)**.5;

ห่วงผ่านไปได้ทั้งหมดที่มีขนาดช่องว่างจากการ0*0 l*lคำนวณความยาวขอบของสี่เหลี่ยมด้วยlโค้ดตัวอักษรและx*yช่องว่างsดังนี้

p+=[(abs(x-y)/2,int(s),-x)]*(s%1==0)*(x<s-1>y>=s%2==x%2==y%2or x<1)

ตรวจสอบว่าเงื่อนไขต่อไปนี้ตรงกับ:

• s % 1 == 0นั่นคือสแควร์ที่สมบูรณ์แบบจะเกิดขึ้น
• x < s-1 > yคือxและyอยู่ที่ส่วนใหญ่s-2และพอดีภายในสี่เหลี่ยม
• s % 2 == x % 2 == y % 2นั่นคือทั้งสองxและyตรงกับความเท่าเทียมกันของขอบและสามารถเป็นศูนย์กลาง
• แต่ถ้าx < 1เช่นx == 0เพิกเฉยต่อทั้งหมด แต่ความต้องการกำลังสองสมบูรณ์แบบ

หากเงื่อนไขตรงกันให้เพิ่มรายการต่อไปนี้ใน tuple pเพื่อค้นหาเงื่อนไขที่ดีที่สุด:

• abs(x-y)/2; ขั้นแรกให้ค้นหาความแตกต่างน้อยที่สุดxและyเพื่อให้ได้ช่องว่างที่มากที่สุด นี่คือเสมอดังนั้นเราจึงหารด้วย 2
• int(s); ค้นหาความยาวด้านที่น้อยที่สุด เนื่องจากsเป็นจำนวนเต็มและเพิ่มขึ้นตามพื้นที่ช่องว่างx*yการเรียงลำดับตามพื้นที่ช่องว่าง
• -x; ค้นหาความกว้างสูงสุดเพื่อเลือกช่องว่างแนวนอน สิ่งนี้เกิดขึ้นหลังจากพื้นที่เนื่องจากการพัฒนา แต่พื้นที่นั้นเหมือนกันx*yและy*xใช้งานได้จริง

if p:d,s,x=min(p);b=(s+x)/2;Y=0

หากเราพบเลย์เอาต์ที่ถูกต้องให้ค้นหาอันที่เหมาะสมที่สุดตามที่อธิบายไว้ข้างต้น คำนวณเส้นขอบแนวนอนbและเริ่มต้นหมายเลขบรรทัดYเป็น 0

exec"c[b:b]=' '*-x*(b+d<=Y<s-b-d);print''.join(c[:s]);c=c[s:];Y+=1;"*s

หากหมายเลขบรรทัดที่Yอยู่ภายในช่องว่าง (ชายแดนแนวตั้งb+dด้วยdจาก tuple), cการเพิ่มมูลค่าความกว้างของช่องว่างของพื้นที่หลังจากที่ชายแดนในแนวนอน (ในการปรับเปลี่ยนcคือเหตุผลที่เราต้องการให้เป็นรายการ.) cจากนั้นพิมพ์เส้นของตารางและลบออกจาก ทำซ้ำsครั้งโดยเพิ่มหมายเลขบรรทัด

else:print':~('

หากไม่พบเลย์เอาต์ล้มเหลว

Pyth , 99 98 ไบต์

#JscQ)=QshKh|oaFtNSf!|%hT1&eT|t{%R2TgeStThT+L@+lJ*Fd2^UJ2
":~("Am/-Qd2tKW=W}~hZrG-QGJj*eKdcJ]H<~>J

ลองออนไลน์!

วิธีนี้ใช้อัลกอริธึมแบบเดียวกับคำตอบของ Python แต่รายละเอียดจำนวนมากถูกเปลี่ยนเป็น Pyth

Pyth แสดงอายุของมันที่นี่เนื่องจากมันไม่ได้รับการปรับปรุงในยุคต่างๆและใช้เฉพาะอักขระ ASCII ที่พิมพ์ได้ (สำหรับรหัสไม่ใช่ข้อมูล) ซึ่งเป็นการสิ้นเปลืองพื้นที่มาก

ที่น่าสนใจถ้า Pyth ใช้ base-256 แบบเดียวกับ Stax โปรแกรมนี้อาจมีความยาว log98 log ₂₅₆ 95⌉ = 81 bytes ยาวถัดจาก Stax (80 bytes) และ Jelly (85 bytes) ฉันคิดว่านี่เป็นสิ่งที่แสดงให้เห็นว่าภาษาการเล่นกอล์ฟแบบใกล้ชิดนั้นมีความแตกต่างกันอย่างไร

คำอธิบาย (อ่านน้อยกว่ารหัสเล็กน้อยเท่านั้น)

#ล้อมรอบทุกอย่างในwhile True:ข้อความที่ไม่แสดงข้อความและออกจากข้อผิดพลาด

JscQ) cกระโดดอินพุท ( Q) ที่ช่องว่างsUMS Jชิ้นส่วนร่วมกันและบันทึกผลใน

^UJ2ทำให้รายการของดัชนี ( U) ของJและใช้เวลาของ2อำนาจคาร์ทีเซียนครั้ง ( ^) ส่งผลให้ในทุกคู่[h,w]ด้วยและ0<=h<len(J)0<=w<len(J)

+L@+lJ*Fd: ทั้งหมด ( L) คู่ดังกล่าวdเพิ่ม ( +) ราก ( @... 2) ของ (คนlength ของJบวก ( +) ผลิตภัณฑ์ ( *F) ของคู่d) [side length, gap height, gap width]ไปทางด้านซ้ายของคู่แฝดสร้าง

f!|%hT1&eT|t{%R2TgeStThT: filter สำหรับ triplets Tที่ไหน

• ไม่ใช่ของ ( !|):
  • ความยาวด้าน ( hT) modulo 1 ( %… 1) เป็นค่าที่ไม่ใช่ศูนย์
  • ทั้งสองของ ( &):
    • ความสูงของช่องว่าง ( eT) เป็นค่าที่ไม่ใช่ศูนย์
    • อย่างใดอย่างหนึ่งของ ( |):
      • แต่ละหมายเลขใน triplet ( R) modulo 2 ( %… 2) โดยมีรายการที่ซ้ำกัน ( {) และมีการtลบที่ไม่ซ้ำกันครั้งแรก ( )
      • eSความสูงของช่องว่างที่มีขนาดใหญ่กว่าและความกว้างของช่องว่างtTนั้นgมากกว่าหรือเท่ากับความยาวด้าน ( hT)

Sเรียงลำดับทริปเปิลพจนานุกรม (ตามความยาวด้านจากนั้นตามความสูงของช่องว่าง) oaFtNจากนั้นorders triplets โดยความaแตกต่าง bsolute ระหว่างความสูงของช่องว่างและความกว้างของช่องว่าง ( tN)

ณ จุดนี้ถ้าเราไม่มีการแก้ปัญหาที่ถูกต้อง|ประเมินอาร์กิวเมนต์ที่สองของตนซึ่งพิมพ์และผลตอบแทน\n":~(" ใช้เวลาทางออกที่ดีที่สุด (หรือถ้าไม่มี) และจะมีการบันทึกไว้ใน แล้วก็:~(h":"Khจะใช้เวลายาวด้านข้าง (หรือ":"ถ้าไม่มี) sปลดเปลื้องมันเป็นจำนวนเต็ม (หรือล้มเหลวและลาออกถ้าไม่มี) และจะถูกบันทึกไว้ ( =) Qใน

แต่ละส่วนของ ( m) [gap height, gap width]( tK) จะถูกลบออก ( -) จากความยาวด้าน ( Q) และผลหารด้วย 2 ( /...2 ) ผลที่จะได้Assigned ไปและGH

ในที่สุดเราเข้าสู่Wห่วงไฮล์Zเริ่มต้นที่ 0 และการวนซ้ำแต่ละครั้งเราเพิ่มขึ้น แต่ใช้ค่าเก่า ( ~hZคิดเป็นZ++C)

• หาก ( W) ค่าเก่าอยู่ใน ( {) range Gไปยัง (ความยาวด้าน - G) ( -QG) กำหนด ( =) ให้กับJสิ่งต่อไปนี้: chop Jat position ( ]) Hและjoin ครึ่งที่มีความกว้างของช่องว่างeK ( *) ช่องว่าง ( d) Jถ้าค่าไม่ได้อยู่ในช่วงเพียงกลับ หากผลลัพธ์นี้ว่างให้หยุดการวนซ้ำ
• ลบ ( >) ครั้งแรกที่QตัวละครจากJและกำหนด ( ~) Jผลให้ จากคุณค่าเดิมของJให้ใช้ ( <) Qอักขระตัวแรกและพิมพ์

ในที่สุด#วงเริ่มต้นอีกครั้งข้อผิดพลาดและการลาออกเพราะcQ)มีQมีจำนวนไม่ถูกต้อง

05AB1E , 95 89 ไบต์

… 
    мDg©Ý3ãʒćnsP-®Q}ʒć‹P}ʒÈËyß_~}Dg_i…:~(ëΣ¦DÆÄsP‚}н©¤_iнë¬Uć᤮Ås<иs;R`X*+šXnª£®θð×ýX}ô»

ไม่กี่ไบต์ที่นี่และสามารถเล่นกอล์ฟได้อย่างแน่นอน

สามขั้นตอนแรกของโปรแกรมได้รับแรงบันดาลใจจากคำตอบ Stax ของ@recursive ดังนั้นอย่าลืมโหวตให้เขา!

ลองมันออนไลน์หรือตรวจสอบกรณีทดสอบทั้งหมด

คำอธิบาย:

ขั้นตอนที่ 1: ลบ white-spaces ทั้งหมด:

… 
                   # Push string " \n\t"
    м              # And remove those from the (implicit) input-string

$[a,b,c]$$a$$a×a$$b×c$$[0,a]$

• $a^2-b×c=L$$L$
• $(a\gt b)\text{ and }(a\gt c)$
• $(a\pmod2=b\pmod2=c\pmod2)\text{ or }(min(a,b)\neq0)$

$L=28$[[6,2,4],[6,4,2],[8,6,6]]

Dg                 # Get the length of this string (without popping by duplicating first)
  ©                # Store this length in variable `®` (without popping)
   Ý               # Create a list in the range [0,®]
    3ã             # Create all possible triplets by repeating the cartesian product 3 times
ʒ                  # Filter these triplets by:
 ć                 #  Extract head; pop and push remainder-list and head to the stack
  n                #  Square the head
   sP-             #  Take the product of the remainder, and subtract it from the squared head
      ®Q           #  And check if it's equal to the string length in variable `®`
}ʒ                 # Filter the remaining triplets further by:
  ć‹P              #  Where the first integer is larger than the other two
}ʒ      }          # And filter it a third time by:
  ÈË               #  Where all three are either odd or even
       ~           #  Or
    yß_            #  It does not contain any 0s

":~("$(abs(b-c),b×c)$

ตัวอย่างเช่น: แฝดสาม[[6,2,4],[6,4,2],[8,6,6]]จะถูกจัดเรียง[[8,6,6],[6,2,4],[6,4,2]]หลังจากนั้นจะ[8,6,6]เหลือเพียงเท่านั้น

Dg_i               # If this completely filtered list is now empty:
    …:~(           #  Push string ":~("
ë                  # Else:
 Σ                 #  Sort the triplets by:
  ¦                #   Remove the first character
   DÆÄ             #   Get the absolute difference between the remaining two integers
   sP‚             #   And pair it with the product of the remaining two integers
      }н           #  After we're done sorting: only leave the first triplet

ขั้นตอนที่ 4: สร้างรายการเกี่ยวกับวิธีที่เราควรแยกสตริงเพื่อแทรกช่องว่าง สิ่งนี้ทำเช่นนี้:

$[a,b,c]$

• $\frac{a-b}{2}×a + \frac{a-c}{2}$
• $b-1$${a-c}$
• $a^2$

ตัวอย่างเช่น: แฝดจะส่งผลให้ในรายการ[7,3,5][15,2,2,35]

©                  #  Store this triplet in variable `®` (without popping)
 ¤_i               #  If the last value is 0 (which means the string is a square without gap):
    н              #   Simply keep the first value of the triplet
   ë               #  Else:
    ¬U             #   Store the first value in variable `X` (without popping)
      ć            #   Extract the first value; pop and push remainder-list and head to the stack
       α           #   Get the absolute difference of this head with the other two values
        ¤          #   Push the last value (without popping the pair itself)
         ®Ås<и     #   And repeat it the middle element or `®` minus 1 amount of times
       s           #   Swap to get the difference pair again
        ;          #   Halve both values
         R`        #   Push them reversed to the stack
           X*      #   Multiple the first value by `X`
             +     #   And then add it to the second value
              š    #   Prepend this in front of the repeated list
               Xnª #   And also append the square of `X`

$c$$c$

"Alongtesttoseeifitworksasintended."[15,2,2,35]["Alongtesttoseei","fi","tw","orksasintended."]$c=5$"Alongtesttoseei fi tw orksasintended."$a=7$["Alongte","sttosee","i f","i t","w o","rksasin","tended."]

    £              #   Then split the string into parts based on this list
     ®θð×          #   Push a string consisting of the last value of `®` amount of spaces
         ý         #   Join the list of substrings by this
          X        #   Push variable `X`
   }ô              #  After the if-else: split the string into parts of that size
     »             #  And then join these by newlines
                   # (after which the top of the stack is output implicitly as result)