ขอบคุณ @KritixiLithos ที่ช่วยเหลือฉันด้วยความท้าทายนี้!

Vเป็นภาษาการเขียนโปรแกรมที่ฉันเขียนเพื่อให้ฉันสามารถใช้และขยายเสียงเรียกเข้าสำหรับความท้าทายของ code-golf ความมุ่งมั่นแรกคือวันที่ 3 มีนาคม 2016 ซึ่งหมายความว่าวันนี้ V มีอายุหนึ่งปี! Woo-ฮู

กว่าปีแรกของ V ของการดำรงอยู่มีการกระทำ 176 จากสี่ร่วมสมทบที่แตกต่างกัน140 คำตอบจากผู้ใช้ 12 คนที่แตกต่างกันและมากเกินไปเสียผู้ประกอบการที่ซ้ำกันในการนับ มันมีล่ามออนไลน์เจ้าภาพเห็นแก่ตัวโดย @Dennis ซึ่งได้รับการทำงานเกือบ 8,000 ครั้งตั้งแต่เดือนธันวาคม

มาท้าทายการฉลองวันเกิดของ V กันเถอะ! เนื่องจากคุณสมบัติส่วนใหญ่ใน V ได้รับการออกแบบโดยใช้การจัดการสตริงและASCII-artอยู่ในใจจึงดูเหมือนเป็นธรรมชาติที่การท้าทายใด ๆ ที่เฉลิมฉลอง V ควรเกี่ยวกับศิลปะ ASCII ดังนั้นความท้าทายของคุณในวันนี้คือการใส่คำเป็นอินพุตและจัดรูปใหม่คำนั้นในรูปของ V ตัวอย่างเช่นอินพุต "Hello" ควรให้ V ต่อไปนี้:

Hello         olleH
 Hello       olleH
  Hello     olleH
   Hello   olleH
    Hello olleH
     HellolleH
      HellleH
       HeleH
        HeH
         H

นี่คือรายละเอียดบางอย่างเกี่ยวกับสิ่งที่ V ของคุณควรมีลักษณะอย่างไร หากสายป้อนเป็นnยาวตัวอักษร V ที่ควรจะเป็นn*2เส้นสูง บรรทัดแรกควรประกอบด้วย:

<input string><(n*2) - 1 spaces><input string reversed>

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

คุณสามารถสันนิษฐานได้ว่าอินพุตนั้นจะสามารถพิมพ์ได้แบบ ASCIIโดยไม่มีช่องว่างใด ๆ อยู่ในนั้นและคุณอาจใช้อินพุตและเอาต์พุตในวิธีการที่สมเหตุสมผล นี่คือตัวอย่างอินพุตเพิ่มเติม:

Happy:

Happy         yppaH
 Happy       yppaH
  Happy     yppaH
   Happy   yppaH
    Happy yppaH
     HappyppaH
      HapppaH
       HapaH
        HaH
         H

Birthday:

Birthday               yadhtriB
 Birthday             yadhtriB
  Birthday           yadhtriB
   Birthday         yadhtriB
    Birthday       yadhtriB
     Birthday     yadhtriB
      Birthday   yadhtriB
       Birthday yadhtriB
        BirthdayadhtriB
         BirthdadhtriB
          BirthdhtriB
           BirthtriB
            BirtriB
             BiriB
              BiB
               B

V!:

V!   !V
 V! !V
  V!V
   V

~:

~ ~
 ~

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

สำหรับสิ่งที่คุ้มค่าฉันมีจุดอ่อนสำหรับคำตอบที่เป็นกลุ่มดังนั้นคะแนนโบนัสจินตนาการสำหรับการใช้ vim หรือ V แม้ว่าภาษาใดก็ได้ :)

MATL , 21 14 ไบต์

MATL ขออวยพรวันเกิด V!

tnEXyY+c3MZvZ)

ลองออนไลน์!

คำอธิบาย

พิจารณาอินพุต

'Hello'

n=5ความยาว รหัสคำนวณบิด 2D ของสายนี้กับเมทริกซ์เอกลักษณ์ของขนาด2*n,

[1 0 0 0 0 0 0 0 0 0;
 0 1 0 0 0 0 0 0 0 0;
 0 0 1 0 0 0 0 0 0 0;
 0 0 0 1 0 0 0 0 0 0;
 0 0 0 0 1 0 0 0 0 0;
 0 0 0 0 0 1 0 0 0 0;
 0 0 0 0 0 0 1 0 0 0;
 0 0 0 0 0 0 0 1 0 0;
 0 0 0 0 0 0 0 0 1 0;
 0 0 0 0 0 0 0 0 0 1]

ผลลัพธ์ของการบิดที่แปลงเป็นถ่านและถ่าน 0 แสดงเป็นช่องว่างคือ

['Hello         ';
 ' Hello        ';
 '  Hello       ';
 '   Hello      ';
 '    Hello     ';
 '     Hello    ';
 '      Hello   ';
 '       Hello  ';
 '        Hello ';
 '         Hello']

จากนั้นคอลัมน์[1, 2, ..., 2*n-1, 2*n, 2*n-1, ..., 2, 1]จะถูกเลือกจากเมทริกซ์ถ่านนี้เพื่อสร้างผลลัพธ์ที่ต้องการ:

['Hello         olleH';
 ' Hello       olleH ';
 '  Hello     olleH  ';
 '   Hello   olleH   ';
 '    Hello olleH    ';
 '     HellolleH     ';
 '      HellleH      ';
 '       HeleH       ';
 '        HeH        ';
 '         H         ']

รหัสแสดงความคิดเห็น

t      % Implicitly input string. Duplicate
nE     % Length, say n. Multiply by 2
Xy     % Identity matrix of that size
Y+     % 2D convolution. This converts chars to ASCII codes
c      % Convert to char
3M     % Push 2*n, again
Zv     % Push symmetric range [1, 2, ..., 2*n, 2*n-1, ..., 1]
Z)     % Apply as column indices. This reflects the first 2*n columns
       % symmetrically, and removes the rest. Implicitly display

V , 24, 23 , 20 ไบต์

3Ù2Ò Íî
Xæ$òâÙHãêxx>

ลองออนไลน์!

สั้นมากในขณะนี้ว่า V มีผู้ประกอบการ

ไม่น่าประทับใจเมื่อเทียบกับภาษากอล์ฟอื่น ๆ ที่ได้ตอบไป แต่ก็ต้องทำ hexdump:

00000000: 33d9 32d2 20cd ee0a 58e6 24f2 e2d9 48e3  3.2. ...X.$...H.
00000010: ea78 783e                                .xx>

คำอธิบาย:

3Ù                  " Make three extra copies of this current line
  2Ò                " Replace each character on this line and the next line with spaces
     Íî             " Join all lines together
X                   " Delete one space
 æ$                 " Reverse the word under the cursor

ณ จุดนี้บัฟเฟอร์มีลักษณะดังนี้:

Happy         yppaH

ไม่เราจะสร้างสามเหลี่ยมซ้ำ ๆ ซ้ำ ๆ

ò                   " Recursively:
 â                  "   Break if there is only one non-whitespace character on this line
  Ù                 "   Make a copy of this line
   H                "   Move to the first line
    ã               "   Move to the center of this line
     ê              "   Move to this column on the last line
      xx            "   Delete two characters
        >           "   Indent this line

นี่คือที่ที่ฉันจะแสดงให้เห็นถึงหนึ่งในคุณสมบัติที่ชื่นชอบของ V. คำสั่งจำนวนมากต้องการอาร์กิวเมนต์ ตัวอย่างเช่น>คำสั่งจะเยื้องจำนวนบรรทัดของตัวแปรขึ้นอยู่กับการโต้แย้ง:

>>    " Indent this line (this command is actually a synonym for '>_')
>j    " Indent this line and the line below
>k    " Indent this line and the line above
6>>   " Indent 6 lines
>}    " Indent to the end of this paragraph
>G    " Indent to the last line
...   " Many many many more

แต่คำสั่งส่วนใหญ่จะถูกบังคับให้จบด้วยอาร์กิวเมนต์เริ่มต้น (โดยปกติคือบรรทัดปัจจุบัน) หากอยู่ที่ท้ายของโปรแกรมและไม่ได้ระบุไว้ ตัวอย่างเช่นสิ่งที่ V ทำงานจริงสำหรับลูปวนซ้ำของเราคือ:

òâÙHãêxx>>ò

ที่สองòเต็มไปโดยปริยายใน. สิ่งที่เย็นคือคำสั่งที่สิ้นสุดโดยปริยายใช้หลายชั้นลึกดังนั้นแม้ว่าเราจะเขียน>, V จะโดยปริยายให้_มันเป็นข้อโต้แย้งและมันจะเยื้องบรรทัดปัจจุบัน

Brainfuck , 152 ไบต์

นี่เป็นโอกาสที่สำคัญมากฉันตัดสินใจที่จะถอดรหัสล่ามเฒ่า BF และให้หมุน

++++++++++[->+>+++<<]>>++>>+>>>,[[<]<<+>>>[>],]<[<]<<-[->+>>[>]>++++[-<++++++++>]<[<]<<]>[->++<]>[-<+>]<[<[-<+<.>>]<[->+<]>+>->>[.>]<[-]<[.<]<<<<<.>>>>]

ด้วยความเห็น

++++++++++
[->+>+++<<] Insert 0 into the first buffer (Which we don't care about) 10 into the second and 30 into the thrd
>>++    Raise the third buffer to 32 making us our space
>   This buffer is reserved for the Insertable spaces counter
>
+>>>    Raise our incrementer This will be used to fill the other half of the string with spaces
,[  Read a byte
    [<]<<   Move to the back of the string buffer which is our incrementer
    +       increment it
    >>>[>]      And move to the next space of the string
    ,       And then read a new byte
]
<[<]<<-     Decrement the incrementer and begin to add spaces
[
    -       Decrement the incrementer
    >+      Raise the incrementer in the padding
    >>[>]   Move to a new part of the string buffer
    >++++[-<++++++++>]< Write a space
    [<]<<   Move all the way back to the string counter
]
BEGIN WRITING!!
>
[->++<]>[-<+>]<Double the incrementer
[
    <[  Move to the space counter
        -<+<.>> Decrement the space counter increment the temporary one to the left of it then print the space we stored to the left of that then return
    ]<[->+<]>+> Move the temporary space counter back
    -   Decrement the incrementer
    >>[.>]  Print every character from left to right
    <[-]    Snip the end off this
    <[.<]   Print every character from right to left
    <   Move back ot the incrementer
    <<<<.>>>> Print a newline aswell
]

ลองออนไลน์!

> <> , 221 ไบต์

ผมใช้วิธีเวลามากเกินไปเกี่ยวกับเรื่องนี้ สุขสันต์วันเกิด, V!

l:2*01           p84*/v
 !@:$-1         /!?:$<
  1.v/ ^       v\~~>a
   vv\}o<     >ao  /
    1\/84/   :}o:$-
     \\!?<: l;!?\v
      p10-1:g10r\
       >  :>?\vv
        v:$-1/~
         </r+*
          </~
           l

คุณสามารถลองออนไลน์ได้ แต่มันสนุกมากขึ้นที่จะได้ล่ามนี้และใช้มันโดยใช้--playธง

python3 fish.py v.fish -s "ppcg" --tick 0.05 --play

ซึ่งส่งผลให้ภาพเคลื่อนไหวด้านล่าง

ตัวอย่าง

(ใช้เวลาน้อยกว่าสองนาที)

คำอธิบาย

เนื่องจากส่วนที่น่าสนใจของคำตอบนี้คือห่อในVรูปร่างนี่คือคำอธิบายที่สอดคล้องกับมัน เราใช้เวอร์ชันหมายเลขบรรทัดต่อไปนี้สำหรับการอ้างอิง

1. l:2*01           p84*/v
2.  !@:$-1         /!?:$<
3.   1.v/ ^       v\~~>a
4.    vv\}o<     >ao  /
5.     1\/84/   :}o:$-
6.      \\!?<: l;!?\v
7.       p10-1:g10r\
8.        >  :>?\vv
9.         v:$-1/~
10.         </r+*
11.          </~
12.           l

บางครั้งลูกศร (→↓←) ใช้เพื่อระบุทิศทางที่เข้าถึงข้อมูลตัวอย่าง

1. initialisation

      1.→l:2*01           p84*/v
      2.  !@:$-1   X     /!?:$<
      3.   1.            \~~>a
   

   บรรทัดแรกจะผลักดัน2nไปที่ [0,1] ปล่อยให้nบนสแต็กและผนวกหนึ่งช่องว่าง ต่อไปเราขึ้นไปแล้วพันรอบเส้นที่สองทางด้านขวาซึ่งเราจะเริ่มจากซ้าย มีการวนซ้ำสำหรับการต่อท้ายช่องว่างn + 1 วิธีนี้ใช้ได้ผลดังนี้

                   Initial:                 "ppcg4 "
   !@:$-1 /!?:$<
              $     Swap.                   "ppcg 4"
             :      Duplicate.              "ppcg 44"
            ?       If more spaces to add:
       -1            Subtract 1.            "ppcg 3"
      $              Swap.                  "ppcg3 "
     :               Duplicate.             "ppcg3  "
    @                Rotate top 3.          "ppcg 3 "
   !                 Jump over stored value
                            and wrap around.
                   Else:
           /         Go to next part.
   

   หลังจากสิ่งนี้เสร็จสิ้นก็จะเด้งลงไปที่บรรทัดที่ 3 มีองค์ประกอบสแต็คสองอันดับแรก (0 และช่องว่าง) ถูกลบออก ( ~~) และเราข้ามไปXที่ตำแหน่ง [10,1] ( a1.) ต่อไปทางขวา เราชนที่/, ล้อมรอบไปที่บรรทัด 7 และเริ่มวนรอบโปรแกรมหลัก

2. ห่วงหลัก ( 2nครั้งทำ)

    6.              ;!?\
    7.       p10-1:g10r\   ←
   

   นี่คือเงื่อนไขวง ในตอนแรกสแต็กจะกลับรายการสำหรับการพิมพ์ จากนั้นเราจะได้รับตัวนับจาก [1,0] ( 01g) และเก็บรุ่นที่ลดลง ( :1-01p) โดยการพันไปมาและกระแทกเข้าหากันเราพบเงื่อนไขในการยกเลิกโปรแกรม หากเราไม่ยุติเราก็กระโดดเข้าไปในลูปการพิมพ์แรก

   • ลูปการพิมพ์ครั้งแรก (ครึ่งซ้าย)

     5.    1\   /   :}o:$-
     6.     \\!?<: l         ←
     

     เราเริ่มต้นด้วยความยาวด้านบนสุดของสแต็กและรันโค้ดต่อไปนี้ตราบใดที่องค์ประกอบบนสุดไม่ใช่ 0

     1-$:o}
     
     1-        Subtract 1.    "ppcg3"
       $       Swap.          "ppc3g"
        :      Duplicate.     "ppc3gg"
         o     Output.        "ppc3g"
          }    Rotate right.  "gppc3"
     

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

   • เตรียมครึ่งขวา

     5.  →    /84/   
     6.       \     
     7.            :    
     8.            >
     9.         v:$-1/~
     10.         </r+*
     11.          </~
     12.           l
     

     นี่เป็นหนึ่งในส่วนที่ยากที่สุดเพื่อให้พอดี ด้านล่างนี้เป็นเวอร์ชั่นที่ถูกตัดการห่อหุ้มทุกทิศทางเพื่อระบุว่าเกิดอะไรขึ้น

                  Initial stack:   "    gcpp0"
     84*+r~
     84*          Push 32 == " ".  "    gcpp0 "
        +         Add 32 and 0.    "    gcpp "
         r        Reverse.         " gcpp    "
          ~       Remove top.      " gcpp   "
     

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

   • ลูปการพิมพ์ที่สอง (ครึ่งขวา)

     3.     / ^ 
     4.     \}o<
     5.    
     6.           ↓   
     7.           
     8.       >  :>?\vv
     9.        v:$-1/~ 
     

     รหัสที่ถูกดำเนินการนั้นเหมือนกับในลูปการพิมพ์ครั้งแรกโดยที่o}จะถูกวางให้ไกลออกไปเล็กน้อยเนื่องจากมีตำแหน่งที่พร้อมใช้งาน เมื่อเสร็จแล้วเรามีบางสิ่งที่ต้องทำก่อนที่เราจะสามารถตรวจสอบลูปหลักไม่แปรเปลี่ยนได้อีกครั้ง หลังจากประมวลผล~บนบรรทัดที่ 9 แล้วเราจะพันกันตามแนวตั้งและสิ้นสุดที่โค้ดต่อไปนี้

                     ↓
     2.          X     / 
     3.  1.v/             >a
     4.              >ao  /
     

     ก่อนอื่นaoจะพิมพ์บรรทัดใหม่ จากนั้นเราก็เด้งขึ้นและมาถึงที่ตรงจุดเดียวกันจากหลังจาก initialisation Xคือกระโดดไป

Brain-Flak , 486 + 1 = 489 ไบต์

สุขสันต์วันเกิด V จาก Brain-Flak!

นอกจากนี้ขอขอบคุณคุณ0ที่ให้รหัสบางส่วนที่ใช้ในคำตอบนี้

+1 เนื่องจากการ-cตั้งค่าสถานะซึ่งจำเป็นสำหรับ ASCII เข้าและออก

((([]<{({}<>)<>}<>([]){({}[()]<(([][()])<{({}[()]<({}<>)<>>)}{}><>)<>({}<<>{({}[()]<({}<>)<>>)}{}><>)(({})<>)<>>)}{}([][][()]){({}[()]<((((()()()()){}){}){})>)}{}<>{({}<>)<>}<>>){}[()])<{((({})<((({}){}())){({}[()]<(({}<(({})<>)<>>)<(({}<({}<>)<>>[()])<<>({}<<>{({}[()]<({}<>)<>>)}{}>)<>>){({}[()]<({}<>)<>>)}{}<>>)>)}{}{}((()()()()()){})(<()>)<>>)<{({}[()]<({}<>)<>>)}{}{}{}{({}<>)<>}<>>[()])}{}>()())([][()]){{}(({}[()])<{({}[()]<((((()()()()){}){}){})>)}{}{({}<>)<>}{}>)([][()])}{}<>

ลองออนไลน์!

ไม่ต้องสงสัยเลยว่านี่เป็นสิ่งที่ยากที่สุดที่ฉันเคยทำใน Brain-Flak

Brain-Flak นั้นน่ากลัวอย่างมากในการทำซ้ำและการย้อนกลับของสตริงและความท้าทายนี้ไม่ได้มี แต่การทำซ้ำและการย้อนกลับของสตริง

ฉันจัดการที่จะได้รับนี้ข้อมูลโค้ดเกือบทำงานในเวลาเพียงหนึ่งชั่วโมงของการทำงานหนัก แต่เพิ่มในพื้นที่ไม่กี่สุดท้ายจะกลายเป็นหนึ่งในสิ่งที่ยากที่สุดเท่าที่ผมเคยทำมาในสมอง Flak

คำอธิบาย

แนวคิดพื้นฐานคือเราจะสร้างจุดสูงสุดของ V ก่อนและการวนซ้ำแต่ละครั้งจะลบอักขระสองตัวออกจากตรงกลางและเพิ่มช่องว่างไปที่จุดเริ่มต้น

ในทางปฏิบัติมันค่อนข้างยาก

มีอัลกอริทึมที่มีอยู่สำหรับการคัดลอกและย้อนกลับดังนั้นฉันใช้หนึ่งในนั้นเพื่อสร้างสำเนาของรหัสที่ตรงกันข้ามใน offstack เมื่อฉันทำเสร็จแล้วฉันก็วาง2n-1ช่องว่างไว้ที่ด้านบนสุดของสแต็กดั้งเดิมและย้าย offstack กลับไปยัง onstack เพื่อสร้างแซนวิช

ตอนนี้เรามีแถวบนของเรา ตอนนี้เราต้องการลบอักขระสองตัวจากจุดเริ่มต้นและเพิ่มช่องว่างด้านหน้า สิ่งนี้กลายเป็นส่วนที่ยากที่สุด เหตุผลสำหรับสิ่งนี้คือเราต้องเก็บค่าสองค่าเป็นค่าแรกสำหรับความลึกของตัวอย่างปัจจุบันและอีกค่าหนึ่งสำหรับความลึกจนถึงจุดศูนย์กลางของ V ที่การลบเกิดขึ้น

นี่มันยาก.

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

ดังนั้นเราจะแก้ไขได้อย่างไร ในระยะสั้นเราไม่ได้จริงๆ เราไม่สนใจช่องว่างสำหรับตอนนี้และทำการแก้ไขในภายหลังเราจะเพิ่มเลขศูนย์ลงในรหัสเพื่อทำเครื่องหมายว่าช่องว่างนั้นตั้งใจจะไปที่ใด แต่นอกเหนือจากนั้นเราจะไม่ทำอะไรเลย

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

ตอนนี้เรามีกลุ่มของ V ที่สร้างขึ้น อย่างไรก็ตามเราขาดช่องว่างที่เหมาะสมและ V ของเราอยู่ในขณะนี้เล็กน้อย (อ่าน: สมบูรณ์) กลับหัวกลับหาง

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

สุดท้ายเราก็ทำความสะอาดสิ่งเล็ก ๆ น้อย ๆ ที่แขวนอยู่รอบ ๆ และยุติโปรแกรมสำหรับการส่งออกโดยนัย

เยลลี่ , 15 12 ไบต์

⁶ṁ⁸;;\Uz⁶ŒBY

ลองออนไลน์!

มันทำงานอย่างไร

⁶ṁ⁸;;\Uz⁶ŒBY  Main link. Argument: s (string)

⁶ṁ            Mold ' ' like s, creating a string of len(s) spaces.
  ⁸;          Prepend s to the spaces.
    ;\        Cumulative concatenation, generating all prefixes.
      U       Upend; reverse each prefix.
       z⁶     Zip/transpose, filling empty spots with spaces.
         ŒB   Bounce; map each string t to t[:-1]+t[::-1].
           Y  Join, separating by linefeeds.

Python 3 , 65 ไบต์

s=input();s+=' '*len(s)
for _ in s:s=' '+s[print(s+s[-2::-1]):-1]

ลองออนไลน์!

Python 2 , 65 ไบต์

s=input();s+=' '*len(s)
for _ in s:print s+s[-2::-1];s=' '+s[:-1]

ลองออนไลน์!

JavaScript (ES6), 108 106 98 94 ไบต์

f=
s=>s.repeat((j=l=s.length*4)*2).replace(/./g,_=>--j?s[j+j<l?j-i:l-i-j]||` `:(j=l,++i,`
`),i=1)

<input oninput=o.textContent=f(this.value)><pre id=o>

เรติน่า , 51 47 ไบต์

สุขสันต์วันเกิดจากภาษาที่ใช้ในการประมวลผลสตริง!

จำนวนไบต์ถือว่าการเข้ารหัส ISO 8859-1

$
$.`$* 
$
¶$`
O$^r`.\G

;{*`.¶

(\S.*).¶.
 $1¶

ลองออนไลน์!

คำอธิบาย

$
$.`$* 

นี้ผนวกnช่องว่าง (ซึ่งnคือความยาวสตริง) โดยการจับคู่จุดสิ้นสุดของสตริงที่เรียกความยาวของสตริงที่มีและการทำซ้ำพื้นที่ที่หลายครั้งด้วย$.`$*

$
¶$`

เราซ้ำสตริงทั้งหมด (คั่นด้วยเลื่อนบรรทัด a) $`โดยการจับคู่ท้ายของสตริงอีกครั้งและใส่สตริงตัวเองด้วย

O$^r`.\G

สิ่งนี้จะย้อนกลับบรรทัดที่สองโดยจับคู่จากขวาไปซ้าย ( r) จากนั้นจับคู่อักขระทีละตัว ( .) แต่ให้แน่ใจว่าพวกมันอยู่ติดกัน ( \G) ด้วยวิธีนี้การแข่งขันจะไม่สามารถผ่าน linefeed ได้ สิ่งนี้จะถูกใช้ในการเรียงลำดับ โดยการใช้โหมด sort-by ( $) แต่การแทนที่แต่ละคู่แข่งขันด้วยสตริงว่างจะไม่มีการเรียงลำดับจริง แต่เนื่องจาก^ตัวเลือกการแข่งขันจะกลับรายการในตอนท้ายทำให้ย้อนกลับทั้งสองบรรทัด

;{*`.¶

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

ขั้นตอนตัวเองเพียงแค่ลบ linefeed และตัวละครก่อนหน้า ซึ่งให้เราหนึ่งบรรทัดของเอาต์พุตที่ต้องการ (เริ่มต้นด้วยบรรทัดแรก)

(\S.*).¶.
 $1¶

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

05AB1E , 12 ไบต์

Dgð×J.p€ûR.c

ลองออนไลน์!

คำอธิบาย

D             # duplicate input
 g            # length of copy
  ð×J         # append that many spaces to input
     .p       # get a list of all prefixes
       €û     # turn each into a palindrome
         R    # reverse the list
          .c  # pad each line until centered

หรือนับไบต์เดียวกันจากทิศทางอื่น

Âsgú.sí€ûR.c

คำอธิบาย

             # push a reversed copy of input
 s            # swap the input to the top of the stack
  g           # get its length
   ú          # prepend that many spaces
    .s        # get a list of all suffixes
      í       # reverse each
       €û     # turn each into a palindrome
         R    # reverse the list
          .c  # pad each line until centered

Japtap, 22 20 16 14 + 2 ไบต์

Japt ขอให้ V ประสบความสำเร็จในการเล่นกอล์ฟอีกหลายปี!

²¬£²îU²ç iYU)ê

ต้องใช้-Rธง ทดสอบออนไลน์!

คำอธิบาย

นี่ใช้ประโยชน์จากçและîฟังก์ชั่นที่ฉันเพิ่มเมื่อไม่กี่วันที่ผ่านมา:

²¬£²îU²ç iYU)ê    Implicit: U = input string
²                 Double the input string.
 ¬                Split into chars.
  £               Map each char X and index Y by this function:
     U²             Take the input doubled.
       ç            Fill this with spaces.
         iYU        Insert the input at index Y.
    î       )       Mask: repeat that string until it reaches the length of
   ²                the input doubled.
                    This grabs the first U.length * 2 chars of the string.
             ê      Bounce the result ("abc" -> "abcba").
                  Implicit: output result of last expression, joined by newlines (-R flag)

เทคนิคของเดนนิสนั้นยาวกว่า:

U+Uç)å+ mw y mê

GNU sed , 110 100 + 1 (ธง r) = 101 ไบต์

แก้ไข:สั้นลง 9 ไบต์ขอบคุณRiley

ในฐานะที่เป็นภาษาจัดการสตริงอื่นsedปรารถนาVที่ดีที่สุด!

h;G
:;s:\n.: \n:;t
h;:r;s:(.)(\n.*):\2\1:;tr
H;x
s:\n\n ::
:V
h;s:\n::p;g
s:^: :;s:.\n.:\n:
/\n$/!tV

ลองออนไลน์!

คำอธิบาย:สมมติว่าอินพุตเป็นกรณีทดสอบสุดท้าย ('V!') ฉันจะแสดงพื้นที่ลวดลายในแต่ละขั้นตอนเพื่อความชัดเจนแทนที่ช่องว่างด้วย 'S

h;G                       # duplicate input to 2nd line: V!\nV!
:;s:\n.: \n:;t            # shift each char from 2nd line to 1st, as space: V!SS\n
h;:r;s:(.)(\n.*):\2\1:;tr # save pattern space, then loop to reverse it: \nSS!V
H;x                       # append reversed pattern to the one saved V!SS\n\n\nSS!V
s:\n\n ::                 # convert to format, use \n as side delimiter: V!SS\nS!V
:V                        # start loop 'V', that generates the remaining output
h;s:\n::p;g               # temporarily remove the side delimiter and print pattern
s:^: :;s:.\n.:\n:         # prepend space, delete char around both sides: SV!S\n!V
/\n$/!tV                  # repeat, till no char is left on the right side
                          # implicit printing of pattern left (last output line)

Python ขนาด 110 ไบต์

ลองออนไลน์!

ฉันแน่ใจว่านี่ไม่เหมาะสม แต่เป็น Pythonic อย่างน้อย:

def f(s):n=len(s)*2-1;return''.join(i*' '+s[:n+1-i]+(n-2*i)*' '+s[n-i-1::-1]+'\n'for i in range(n))+n*' '+s[0]

Jolf, 31 ไบต์

Jolf ขออวยพรให้ V สุขสันต์วันเกิด!

RΜwzΒώlid+γ_pq_ l+*␅Hi0ΒΒ␅ L_γ1S

ลองที่นี่! ␅ควรเป็น 0x05

คำอธิบาย

RΜzΒώlid+γ_pq_ l+*␅Hi0ΒΒ␅ L_γ1S  i = input
     li                                  i.length
    ώ                                2 * 
   Β                             Β =
  z                              range(1, Β + 1)
 Μ     d                         map with: (S = index, from 0)
                +                 add:
                 *␅H               S spaces
                    i              and the input
               l                  slice (^) from
                     0Β            0 to Β
           pq_         Β␅         pad (^) with spaces to the right
         γ_                       γ = reverse (^)
        +                 L_γ1    γ + behead(γ)
R                             S  join with newlines

ถ่าน 29 ไบต์

สุขสันต์วันเกิด V จากเพื่อน ๆ ของคุณภาษา ASCII- ศิลปะที่ท้าทายมาอย่างยาวนานสำหรับคุณ!

ＳσＦ…·¹Ｌσ«Ｆι§σκＭι←↖»Ｆσ«Ｐσ↖»‖Ｏ→

ลองออนไลน์!

คำอธิบาย

กลยุทธ์ของเรา: พิมพ์ครึ่งซ้ายของ V โดยเริ่มจากด้านล่างแล้วเลื่อนไปทางซ้ายบน จากนั้นสะท้อนมัน

Ｓσ                                    Input σ as string
                                       The bottom len(σ) half-rows:
   Ｆ…·¹Ｌσ«           »               For ι in inclusive range from 1 to length(σ):
            Ｆι                          For κ in range(ι):
               §σκ                         Print character of σ at index κ
                  Ｍι←                   Move cursor ι spaces leftward
                      ↖                  Move cursor one space up and left
                                       The top len(σ) half-rows:
                        Ｆσ«    »      For each character ι in σ:
                            Ｐσ          Print σ without moving the cursor
                               ↖         Move cursor one space up and left
                                 ‖Ｏ→  Reflect the whole thing rightward, with overlap

(ถ้าถ่านมีการแบ่งสตริง ... อนิจจาดูเหมือนว่ายังไม่ได้ใช้งาน)

Pip , 32 25 ไบต์

a.:sX#aL#a{OaDQaPRVaaPUs}

รับค่าสตริงป้อนเข้าเป็นอาร์กิวเมนต์บรรทัดคำสั่ง ลองออนไลน์!

คำอธิบาย

                           a is 1st cmdline arg, s is space (implicit)
     #a                    Len(a)
   sX                      Space, string-multiplied by the above
a.:                        Concatenate that to the end of a
       L#a{             }  Loop len(a) times (but NB, a is now twice as long as it was):
           Oa                Output a (no trailing newline)
             DQa             Dequeue one character from the end of a
                PRVa         Print reverse(a) (with trailing newline)
                    aPUs     Push one space to the front of a

R พร้อมแพ็กเกจ stringi 225 ไบต์

library(stringi)
f=function(){
s=scan(,'',1,sep="\n")
m=2*nchar(s)
l=stri_pad(sapply(1:m-1,function(x)substr(paste(paste(rep(" ",x),collapse=""),s),1,m)),m,"right")
r=substr(stri_reverse(l),2,m)
message(paste0(l,r,"\n"))}
f()

หากคุณเรียกใช้ R ในรหัสโต้ตอบหลังจากวางคำตอบของฉันเพียงแค่ป้อนอะไร คุณจะต้องติดตั้งแพ็คเกจ stringi R (ฉันหวังว่ามันจะไม่ขัดกับกฎ)

คำอธิบาย:

แนวคิดพื้นฐานคือการเพิ่มช่องว่างทางด้านซ้ายแล้วตัดให้มีความยาวที่เหมาะสม หลังจากนั้นให้วางด้วยเวอร์ชันที่ตรงกันข้ามเป็นด้านขวา นี่คือฟังก์ชันเวอร์ชันที่ยาวและอ่านง่ายโดยมนุษย์:

library(stringi)
make_V <- function(){                  # declaring the function
  string <- scan(, '', n=1, sep="\n")  # reading input
  max_length <- 2*nchar(string)        # number of chars in each half row

  # creating the left side of the V

  left <- stri_pad(                    
            sapply(1:max_length-1,     # for each row
                   function(x){     
                    substr(            
                      paste0(
                        paste0(rep(" ", x),
                               collapse=""), string), # add spaces to left side
                           1,
                           max_length) # cut the unneeded end
                    }),
            width=max_length,
            side="right")              # add spaces to the right side

  # creating the right side of the V

  right <- substr(stri_reverse(left), 2, max_length)

  # print it without any symbols before the strings 
  message(paste0(left, right, "\n"))
}

# run the function
make_V()

Ruby, 92 89 85 ไบต์

s=gets.chomp
s<<" "*n=s.size*2
n.times{s=s[0..(n-1)]
puts s+s.reverse[1..-1]
s=" "+s}

กระบวนการของฉันคือการลบตัวอักษรตัวแรกออกจากครึ่งขวาของแต่ละบรรทัดหลังจากย้อนกลับครึ่งแรก แบบนี้:

Hello     |    olleH
 Hello    |   olleH 
  Hello   |  olleH  
   Hello  | olleH   
    Hello |olleH    
     Hello|lleH     
      Hell|leH      
       Hel|eH       
        He|H        
         H|         

ฉันไม่คุ้นเคยกับการเล่นกอล์ฟดังนั้นขอให้ฉันรู้ว่ามีสิ่งใดที่ฉันสามารถทำได้เพื่อทำให้มันสั้นลง

แบตช์186 185 ไบต์

@set e=@set 
%e%/ps=
%e%t=%s%
%e%r=
:l
%e%s=%s% 
%e%r= %r%%t:~-1%
%e%t=%t:~,-1%
@if not "%t%"=="" goto l
:g
%e%r=%r:~1%
@echo %s%%r%
%e%s= %s:~,-1%
@if not "%r%"=="" goto g

บรรทัดที่ 1 และ 6 มีช่องว่างต่อท้าย แก้ไข: บันทึกแล้ว 1 ไบต์ขอบคุณ @ ConorO'Brien

Haskell , 76 ไบต์

vเป็นฟังก์ชั่นหลักการStringโต้แย้งและให้Stringผลลัพธ์

v i=unlines.r$i++(' '<$i)
r""=[]
r s|t<-init s=(s++reverse t):map(' ':)(r t)

ลองออนไลน์!

หมายเหตุ:

• i เป็นอาร์กิวเมนต์ / อินพุตเริ่มต้น
• sเริ่มแรกiด้วยการlength iเพิ่มช่องว่าง
• v iการโทรr sจากนั้นเข้าร่วมบรรทัดผลลัพธ์
• rส่งคืนรายการStringบรรทัด
• tอยู่sกับอักขระตัวสุดท้ายที่ถูกตัดออก
• การเรียกซ้ำr tสร้างบรรทัดยกเว้นครั้งแรกลบพื้นที่เริ่มต้นในแต่ละบรรทัด

เยลลี่ขนาด 13 ไบต์

⁶ṁ;@µḣJUz⁶ŒBY

ลองออนไลน์!

อย่างไร?

⁶ṁ;@µḣJUz⁶ŒBY - Main link: string s
⁶             - space character
 ṁ            - mould like s: len(s) spaces
  ;@          - concatenate s with that
    µ         - monadic chain separation (call that t)
      J       - range(length(t))
     ḣ        - head (vectorises): list of prefixes from length to all
       U      - upend: reverse each of them
        z     - transpose with filler:
         ⁶    -     space: now a list of the left parts plus centre
          ŒB  - bounce each: reflect each one with only one copy of the rightmost character
            Y - join with line feeds
              - implicit print

Ruby, 85 83 ไบต์

แก้ไข: ลบพื้นที่ว่างส่วนเกินออก

s=ARGV[0];s+=' '*s.length;s.length.times{|i|puts s+s[i..-2].reverse;s=' '+s[0..-2]}

จริงๆแล้วฉันพบว่ามันยากที่จะตีกอล์ฟลงในรูบี หลังจากเพิ่มช่องว่างมันจะขยายตัวอย่างโค้ดที่อ่านง่าย:

s = ARGV[0]
s+=' ' * s.length

s.length.times do |i|
  puts s + s[i..-2].reverse
  s = ' ' + s[0..-2]
end

MATLAB (R2016b), 223 183 ไบต์

r=input('');l=nnz(r)*2;for i=1:l;m=l+1-2*i;c={' '};s=cell(1,i-1);s(:)=c;x=cell(1,m);x(:)=c;e=r;y=flip(r);if(m<1);e=r(1:2*end-i+1);y=r(l/2+end-i:-1:1);end;disp(cell2mat([s e x y]));end

การตีกอล์ฟเป็นครั้งแรก ยินดีต้อนรับเคล็ดลับ!

เอาท์พุทโปรแกรม:

แก้ไข:

บันทึก 40 ไบต์ขอบคุณ Luis Mendo

PHP, 95 92 85 80 78 77 ไบต์

หมายเหตุ: ใช้การเข้ารหัส IBM-850

for($s.=strtr($s^$s=$argn,~ ,~▀);~$s[$i++];)echo$s,strrev($s=" $s"^$s^$s),~§;
          # Note that this ^ char is decimal 255 (negating it yields "\0")

ทำงานแบบนี้:

echo "Hello" | php -nR 'for($s.=strtr($s^$s=$argn,"\0",~▀);~$s[$i++];)echo$s,strrev($s=" $s"^$s^$s),~§;'
> Hello         olleH 
>  Hello       olleH  
>   Hello     olleH   
>    Hello   olleH    
>     Hello olleH     
>      HellolleH      
>       HellleH       
>        HeleH        
>         HeH         
>          H          

คำอธิบาย

for(
  $s.=strtr(             # Set string to the input, padded with spaces.
    $s^$s=$argn,         # Input negated with itself, leads to string with
                         # only null bytes with the same length.
    ~ ,                  # Replace null bytes...
    ~▀                   # ... with spaces.
  );
  ~$s[$i++];             # Iterate over the string by chars, works because 
                         # there are just as many lines as the padded
                         # string has chars.
)
  echo                   # Output!
    $s,                  # The string.
    strrev(              # The reverse of the string.
      $s=" $s"^$s^$s     # After each iteration, prefix string with a
    ),                   # space, and trim the last character.
    ~§;                  # Newline.

การปรับแต่ง

• บันทึก 3 ไบต์ด้วยการกำจัดอักขระแผ่น ( str_padค่าเริ่มต้นไปยังพื้นที่ซึ่งเป็นสิ่งที่เราต้องการ)
• บันทึก 7 ไบต์โดยใช้การดำเนินการแบบไบนารีบนสตริงเพื่อตัดทอนแทน substr
• บันทึก 5 ไบต์โดยหมุนสตริงเมื่อพิมพ์ย้อนกลับ ป้องกันความต้องการในการพิมพ์ backspace แต่ส่งผลให้มีพื้นที่ต่อท้ายในแต่ละบรรทัด
• บันทึก 2 ไบต์โดยการเติมสตริงโดยใช้วิธีที่ซับซ้อนกว่า แต่สั้นกว่า
• บันทึกเป็นไบต์เนื่องจากไม่จำเป็นต้องคำนึงถึง~"0"กรณี (ASCII 207) เนื่องจากข้อมูลทั้งหมดอาจถูกสมมติว่าเป็น ASCII ที่พิมพ์ได้ (Thx @Titus)

JavaScript (ES6), 169 157 ไบต์

(-10 ไบต์ขอบคุณ Conor O'Brien)

V=(j,i=0,p="")=>i<(f=j.length)*2?V(j,-~i,p+" ".repeat(i)+j.slice(0,f-i*(i>f))+" ".repeat(i<f?(f-i)*2-1:0)+[...j.slice(0,f+~i*(i>=f))].reverse().join``+`
`):p

โซลูชันแบบเรียกซ้ำ ฉันยังใหม่กับ JavaScript ดังนั้นโปรดเป็นคนอ่อนโยน! เคล็ดลับการเล่นกอล์ฟใด ๆ ที่ชื่นชมอย่างมาก :)

และแน่นอนว่าเป็นวันเกิดที่มีความสุขมากสำหรับคุณV!

ตัวอย่างการทดสอบ

V=(j,i=0,p="")=>i<(f=j.length)*2?V(j,-~i,p+" ".repeat(i)+j.slice(0,f-i*(i>f))+" ".repeat(i<f?(f-i)*2-1:0)+[...j.slice(0,f+~i*(i>=f))].reverse().join``+`
`):p

<input oninput=o.textContent=V(this.value)><pre id=o>

CJam , 26 ไบต์

สุขสันต์วันเกิดจาก CJam เพื่อนเก่าของคุณ!

q_,2*:L,\f{LS*+m>L<_W%(;N}

ลองออนไลน์!

คำอธิบาย

q                           Push the input
 _,2*:L                     Push 2 times the length of the input, store it in L
       ,                    Take the range from 0 to L-1
        \                   Swap top stack elements
         f{                 Map over the range, using the input as an extra parameter
           LS*+               Append L spaces to the input
               m>             Rotate the resulting string right i positions (where i is the
                               current number being mapped)
                 L<           Take the first L characters of the string
                   _W%        Duplicate it and reverse it
                      (;      Remove the first character from the copy
                        N     Add a newline
                         }  (end of block)
                            (implicit output)

PowerShell, 126 ไบต์ 124 ไบต์

$l=($s="$args")|% Le*;$r=-join$s[-1..-$l];0..($l*2-1)|%{' '*$_+($s+' '*$l).substring(0,$l*2-$_)+(' '*$l+$r).substring($_+1)}

.\V.ps1 Helloเรียกว่ามีพารามิเตอร์เดียวเช่น

แก้ไข: บันทึก 2 ไบต์ด้วยคำแนะนำจาก AdmBorkBork

Pykeขนาด 14 ไบต์

l}j Fd*R+j^j<s

ลองออนไลน์!

JavaScript (ES6), 94 ไบต์

f=(s,y=0,x=0,l=s.length*2-1)=>(s[(x>l?l*2-x:x)-y]||' ')+(x<l*2?f(s,y,x+1):y<l?`
`+f(s,y+1):'')

กรณีทดสอบ

f=(s,y=0,x=0,l=s.length*2-1)=>(s[(x>l?l*2-x:x)-y]||' ')+(x<l*2?f(s,y,x+1):y<l?`
`+f(s,y+1):'')

console.log(f('Happy'))
console.log(f('Birthday'))
console.log(f('V!'))
console.log(f('~'))

J, 44 ไบต์

(([(,}.@|.)@{."1-@i.@[|."0 1(,#&' ')~)~+:@#)