Cảm ơn @KritixiLithos đã giúp tôi vượt qua thử thách này!

V là một ngôn ngữ lập trình mà tôi đã viết để tôi có thể sử dụng và mở rộng vim cho các thử thách chơi gôn. Cam kết đầu tiên là vào ngày 3 tháng 3 năm 2016, nghĩa là hôm nay V tròn một tuổi! Woo-hoo

Trong năm đầu tiên tồn tại của V, đã có 176 cam kết từ bốn người đóng góp khác nhau, 140 câu trả lời từ 12 người dùng khác nhau và quá nhiều toán tử trùng lặp bị hỏng . Nó có một trình thông dịch trực tuyến , được lưu trữ rộng rãi bởi @Dennis, đã được điều hành gần 8.000 lần kể từ tháng 12 .

Hãy có một thử thách để chúc mừng sinh nhật của V! Vì hầu hết các tính năng trong V được thiết kế với thao tác chuỗi và nghệ thuật ascii , nên có vẻ như bất kỳ thách thức nào để tôn vinh V nên là về nghệ thuật ascii. Vì vậy, thách thức của bạn cho ngày hôm nay là lấy một từ làm đầu vào và định hình lại từ đó theo hình chữ V. Ví dụ: đầu vào "Xin chào" sẽ cho V sau:

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

Dưới đây là một số chi tiết về những gì V của bạn sẽ trông như thế nào. Nếu chuỗi đầu vào dài n ký tự, thì V phải n*2cao dòng. Dòng đầu tiên phải bao gồm:

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

Trên mỗi dòng mới, một khoảng trắng được thêm vào đầu và hai bên của chuỗi di chuyển về phía nhau, loại bỏ bất kỳ ký tự chồng chéo nào. Cho đến dòng cuối cùng, đó chỉ là ký tự đầu tiên của đầu vào. Khoảng trắng lưu trữ trên mỗi dòng là chấp nhận được và một dòng mới cũng được cho phép.

Bạn có thể giả định rằng đầu vào sẽ luôn có thể in ASCII mà không có bất kỳ khoảng trắng nào trong đó và bạn có thể lấy đầu vào và đầu ra theo bất kỳ phương thức hợp lý nào. Dưới đây là một số mẫu đầu vào:

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

~:

~ ~
 ~

Tất nhiên, vì đây là môn đánh gôn , các sơ hở tiêu chuẩn bị cấm và mục tiêu của bạn là viết chương trình ngắn nhất có thể để hoàn thành nhiệm vụ này. Chúc bạn chơi golf vui vẻ!

Đối với những gì nó có giá trị, tôi có một điểm mềm cho câu trả lời vim, vì vậy điểm thưởng tưởng tượng cho việc sử dụng vim hoặc V, mặc dù bất kỳ ngôn ngữ nào cũng được chấp nhận. :)

MATL , 21 14 byte

MATL chúc V sinh nhật vui vẻ!

tnEXyY+c3MZvZ)

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

Giải trình

Xem xét đầu vào

'Hello'

chiều dài n=5. Mã này tính toán tích chập 2D của chuỗi này với ma trận nhận dạng kích thước 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]

Kết quả của phép chập, được chuyển đổi thành char và với char 0 được hiển thị dưới dạng khoảng trắng, là

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

Sau đó, các cột [1, 2, ..., 2*n-1, 2*n, 2*n-1, ..., 2, 1]được chọn từ ma trận char này, tạo ra kết quả mong muốn:

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

Mã nhận xét

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 byte

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

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

Bây giờ ngắn hơn nhiều khi V có toán tử 'đảo ngược' .

Không ấn tượng lắm so với các ngôn ngữ chơi gôn khác đã trả lời, nhưng nó phải được thực hiện. Hexdump:

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

Giải trình:

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

Tại thời điểm này, bộ đệm trông như thế này:

Happy         yppaH

Không, chúng tôi sẽ đệ quy xây dựng tam giác xuống.

ò                   " 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

Đây là nơi tôi có thể thể hiện một trong những tính năng yêu thích của tôi về V. Rất nhiều lệnh yêu cầu một đối số. Ví dụ: >lệnh sẽ thụt vào một số dòng khác nhau tùy thuộc vào đối số:

>>    " 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

nhưng hầu hết các lệnh sẽ buộc phải kết thúc bằng một đối số mặc định (thường là dòng hiện tại) nếu nó ở cuối chương trình và không được chỉ định. Ví dụ, những gì V thực sự chạy cho vòng lặp đệ quy của chúng tôi là:

òâÙHãêxx>>ò

Thứ hai òđược ngầm định điền vào. Điều thú vị là các lệnh kết thúc ngầm áp dụng một số lớp sâu, do đó, mặc dù chúng tôi chỉ viết >, V sẽ ngầm đưa ra _cho đối số của nó và nó sẽ thụt dòng hiện tại.

Brainfuck , 152 byte

Đây là một dịp tuyệt vời như vậy, tôi quyết định bẻ khóa trình thông dịch BF của BF và cho nó một vòng quay.

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

Với nhận xét

++++++++++
[->+>+++<<] 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
]

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

> <> , 221 byte

Tôi đã dành cách quá nhiều thời gian về vấn đề này. Chúc mừng sinh nhật, 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

Bạn có thể dùng thử trực tuyến , nhưng sẽ vui hơn nhiều khi có trình thông dịch này và chạy nó bằng --playcờ

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

kết quả trong hình ảnh động dưới đây.

Thí dụ

(mất ít hơn hai phút)

Giải trình

Bởi vì phần thú vị của câu trả lời này là gói nó trong Vhình dạng, đây là một lời giải thích phù hợp với nó. Chúng tôi sử dụng phiên bản được đánh số dòng sau đây để tham khảo.

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

Đôi khi các mũi tên (→ ↓ ←) được sử dụng để chỉ ra hướng đạt tới một đoạn trích.

1. Khởi tạo

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

   Dòng đầu tiên sẽ đẩy 2n đến [0,1], để lại n trên ngăn xếp và nối thêm một khoảng trắng. Tiếp theo, chúng tôi đi lên và quấn quanh dòng thứ hai bên phải, nơi chúng tôi sẽ bắt đầu đi bên trái. Có một vòng lặp để nối thêm n + 1 khoảng trắng. Điều này hoạt động như sau.

                   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.
   

   Sau khi kết thúc, nó bị trả về dòng 3. Có hai phần tử ngăn xếp trên cùng (0 và một khoảng trắng) được loại bỏ ( ~~) và chúng ta nhảy đến Xvị trí [10,1] ( a1.), tiếp tục đi thẳng. Chúng tôi va vào /, quấn quanh đến dòng 7 và bắt đầu vòng lặp chương trình chính.

2. Vòng lặp chính ( 2n lần làm)

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

   Đây là điều kiện vòng lặp. Lúc đầu, ngăn xếp được đảo ngược để in. Sau đó, chúng tôi nhận được bộ đếm từ [1,0] ( 01g) và lưu trữ một phiên bản giảm dần ( :1-01p). Bằng cách quấn quanh và va chạm lên và sang phải, chúng ta gặp phải điều kiện để chấm dứt chương trình. Nếu chúng tôi không chấm dứt, chúng tôi sẽ nhảy vào vòng in đầu tiên.

   • Vòng lặp in đầu tiên (nửa bên trái)

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

     Chúng tôi bắt đầu với độ dài trên đỉnh của ngăn xếp và thực thi đoạn mã sau miễn là phần tử trên cùng không phải là 0.

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

     Điều này sẽ in ngăn xếp mà không loại bỏ nó. Nếu vòng lặp chấm dứt, chúng tôi nhảy sang phải trên dòng 5, chuẩn bị cho vòng in tiếp theo.

   • Chuẩn bị một nửa đúng

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

     Đây là một trong những phần khó nhất để phù hợp. Dưới đây là một phiên bản tước tất cả các hướng gói để chỉ ra những gì xảy ra.

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

     Sau đó, chúng tôi sẽ đẩy độ dài của những gì sẽ được in và bắt đầu vòng in thứ hai (với một bản sao ban đầu không phải là một phần của vòng lặp).

   • Vòng lặp in thứ hai (nửa bên phải)

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

     Mã được thực thi hoàn toàn giống như trong vòng in đầu tiên, với việc o}được đặt xa hơn một chút vì có sẵn các vị trí. Sau khi kết thúc, chúng ta còn một số việc phải làm trước khi có thể xác minh lại bất biến vòng lặp chính. Sau khi ~dòng 9 được thực thi, chúng ta sẽ quấn theo chiều dọc, kết thúc ở đoạn mã sau.

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

     Đầu tiên aosẽ in một dòng mới. Sau đó, chúng tôi bật lên và đến chính xác cùng một điểm từ sau khi khởi tạo, cụ thể là nhảy đến X.

Brain-Flak , 486 + 1 = 489 byte

Chúc mừng sinh nhật V từ Brain-Flak!

Cũng là một lời cảm ơn đến 0 ' , người đã cung cấp một số mã được sử dụng trong câu trả lời này

+1 do -ccờ được yêu cầu cho ASCII vào và ra

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

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

Đây chắc chắn là điều khó nhất tôi từng làm trong Brain-Flak.

Brain-Flak nổi tiếng là khủng khiếp trong việc nhân đôi và đảo ngược chuỗi và thử thách này không có gì ngoài việc nhân đôi và đảo ngược chuỗi.

Tôi quản lý để có được này đoạn gần như làm việc chỉ trong vòng một tiếng đồng hồ làm việc chăm chỉ, nhưng thêm trong vài khoảng trống cuối cùng hóa ra là một trong những điều khó khăn nhất mà tôi từng thực hiện trong Brain-Flak.

Giải trình

Ý tưởng cơ bản là chúng ta sẽ tạo đỉnh V trước và mỗi lần lặp loại bỏ hai ký tự ở giữa và thêm khoảng trắng vào đầu.

Trong thực tế điều này trở nên khá khó khăn.

Các thuật toán hiện có tồn tại để sao chép và đảo ngược, vì vậy tôi đã sử dụng một trong những thuật toán đó để tạo một bản sao đảo ngược của mã trên offstack. Khi tôi đã hoàn thành, tôi đặt các 2n-1khoảng trống lên trên ngăn xếp ban đầu và di chuyển con quay trở lại trên onstack để tạo ra một chiếc bánh sandwich.

Bây giờ chúng tôi có hàng đầu của chúng tôi. Bây giờ chúng tôi muốn xóa hai ký tự từ đầu và thêm khoảng trắng ở phía trước. Điều này hóa ra là phần khó khăn nhất. Lý do cho điều này là về cơ bản chúng ta cần lưu trữ hai giá trị, một cho độ sâu của đoạn mã hiện tại và một cho độ sâu đến trung tâm của V nơi xảy ra xóa.

Điều này thật khó.

Bởi vì tất cả sự trùng lặp và đảo ngược đang diễn ra trên cả hai ngăn xếp đều được sử dụng đầy đủ mọi lúc. Thực sự không có chỗ nào trên các ngăn xếp này để đặt bất cứ thứ gì. Ngay cả với tất cả Ma thuật ngăn xếp thứ ba trên thế giới, bạn không thể có được loại quyền truy cập bạn cần để giải quyết vấn đề này.

Vậy làm thế nào để chúng tôi sửa chữa nó? Nói tóm lại, chúng tôi không thực sự; Chúng tôi bỏ qua các khoảng trắng bây giờ và vá chúng sau, chúng tôi sẽ thêm các số không vào mã để đánh dấu nơi các không gian dự định đi nhưng ngoài việc chúng tôi sẽ không thực sự làm gì.

Vì vậy, trên mỗi lần lặp, chúng tôi tạo một bản sao của lần lặp cuối cùng và đưa nó vào offstack. Chúng tôi sử dụng độ sâu mà chúng tôi lưu trữ để chia thành một nửa để chúng tôi có nửa bên trái của V trên ngăn xếp bên phải và nửa bên phải của V trên ngăn xếp bên trái. Chúng tôi loại bỏ hai yếu tố và vá hai lại với nhau. Chúng tôi thêm một dòng mới cho biện pháp tốt và bắt đầu lặp lại tiếp theo. Mỗi lần độ sâu đến tâm của V giảm đi một và khi nó chạm 0, chúng ta dừng vòng lặp.

Bây giờ chúng ta có phần lớn của V được xây dựng. Tuy nhiên, chúng tôi đang thiếu không gian thích hợp và V của chúng tôi hiện đang bị đảo lộn một chút (đọc: hoàn toàn).

Vì vậy, chúng tôi lật nó. Để lật nó lên ngăn xếp khác, chúng ta phải di chuyển từng phần tử qua từng phần một. Khi chúng tôi đang di chuyển các yếu tố, chúng tôi kiểm tra các số không. Nếu chúng ta gặp phải một, chúng ta phải đặt các không gian trở lại nơi chúng thuộc về. Chúng tôi tặc lưỡi số 0 và thêm vào một loạt các khoảng trống. Làm thế nào để chúng ta biết có bao nhiêu? Chúng tôi theo dõi; lật một ngăn xếp không giống như sao chép hoặc đảo ngược một ngăn xếp là một nhiệm vụ không chuyên sâu, vì vậy chúng tôi thực sự có bộ nhớ để lưu trữ và truy cập vào một bộ đếm bổ sung để theo dõi có bao nhiêu khoảng trống cần thêm. Mỗi lần chúng ta thêm một số khoảng trắng, chúng ta sẽ giảm số lần truy cập. Bộ đếm sẽ đạt 0 ở dòng mới nhất (đỉnh V) và do đó chúng tôi đã sẵn sàng để in.

Cuối cùng, chúng tôi dọn sạch một vài thứ treo xung quanh và chấm dứt chương trình cho đầu ra ngầm.

Thạch , 15 12 byte

⁶ṁ⁸;;\Uz⁶ŒBY

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

Làm thế nào nó hoạt động

⁶ṁ⁸;;\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 byte

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

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

Python 2 , 65 byte

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

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

JavaScript (ES6), 108 106 98 94 byte

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>

Võng mạc , 51 47 byte

Chúc mừng sinh nhật từ một ngôn ngữ xử lý chuỗi đồng bào!

Số lượng byte giả định mã hóa ISO 8859-1.

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

;{*`.¶

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

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

Giải trình

$
$.`$* 

Điều này nối thêm nkhoảng trắng (trong đó nlà độ dài chuỗi), bằng cách khớp với phần cuối của chuỗi, lấy ra độ dài của chuỗi $.`và lặp lại một khoảng trắng nhiều lần $*.

$
¶$`

Chúng tôi nhân đôi toàn bộ chuỗi (được phân tách bằng một nguồn cấp dữ liệu), bằng cách khớp lại phần cuối của chuỗi và chèn chính chuỗi đó vào $`.

O$^r`.\G

Điều này đảo ngược dòng thứ hai bằng cách khớp từ phải sang trái ( r), sau đó khớp một ký tự tại một thời điểm ( .) nhưng đảm bảo rằng tất cả chúng đều liền kề ( \G). Bằng cách này, các trận đấu không thể vượt qua linefeed. Điều này sau đó được sử dụng trong một giai đoạn sắp xếp. Bằng cách sử dụng chế độ sắp xếp ( $) nhưng thay thế mỗi trận đấu bằng một chuỗi trống, không có sự sắp xếp thực tế nào được thực hiện. Nhưng do ^tùy chọn, các trận đấu được đảo ngược ở cuối, đảo ngược toàn bộ dòng thứ hai.

;{*`.¶

Giai đoạn này là cho đầu ra và cũng ảnh hưởng đến phần còn lại của chương trình. {kết thúc các giai đoạn còn lại trong một vòng lặp được lặp lại cho đến khi các giai đoạn đó không thay đổi chuỗi (điều này sẽ xảy ra vì giai đoạn cuối sẽ không khớp nữa). Các ;đầu ra vô hiệu hóa vào cuối chương trình. Biến *giai đoạn này thành chạy khô, có nghĩa là giai đoạn được xử lý và kết quả được in, nhưng sau đó chuỗi trước đó được khôi phục.

Bản thân giai đoạn chỉ đơn giản là loại bỏ một nguồn cấp dữ liệu và ký tự trước. Cung cấp cho chúng tôi một dòng đầu ra mong muốn (bắt đầu với dòng đầu tiên).

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

Cuối cùng, giai đoạn này biến mỗi dòng thành tiếp theo. Điều này được thực hiện bằng cách chèn một khoảng trắng ở phía trước ký tự không phải khoảng trắng đầu tiên, loại bỏ ký tự cuối cùng trên dòng đầu tiên, cũng như ký tự đầu tiên trên dòng thứ hai. Quá trình này dừng lại khi chỉ còn một ký tự không phải dấu cách trên dòng đầu tiên, tương ứng với dòng cuối cùng của đầu ra.

05AB1E , 12 byte

Dgð×J.p€ûR.c

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

Giải trình

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

Hoặc cho cùng một số byte từ hướng khác.

Âsgú.sí€ûR.c

Giải trình

             # 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

Japt, 22 20 16 14 + 2 byte

Japt chúc V nhiều năm chơi golf thành công hơn nữa!

²¬£²îU²ç iYU)ê

Yêu cầu -Rcờ. Kiểm tra nó trực tuyến!

Giải trình

Điều này sử dụng các chức năng çvà îtôi đã thêm một vài ngày trước:

²¬£²î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)

Kỹ thuật của Dennis dài hơn một byte:

U+Uç)å+ mw y mê

GNU sed , 110 100 + 1 (cờ r) = 101 byte

Chỉnh sửa: 9 byte ngắn hơn nhờ Riley

Là một ngôn ngữ thao tác chuỗi khác, sed chúc V tốt nhất!

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

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

Giải thích: giả sử đầu vào là trường hợp thử nghiệm cuối cùng ('V!'). Tôi sẽ hiển thị không gian mẫu ở mỗi bước cho rõ ràng, thay thế không gian bằng '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 byte

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

Tôi chắc chắn điều này không tối ưu, nhưng ít nhất nó cũng khá 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 byte

Jolf bất đắc dĩ chúc V sinh nhật vui vẻ!

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

Hãy thử nó ở đây! ␅nên là 0x05.

Giải trình

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

Than , 29 byte

Chúc mừng sinh nhật V, từ ngôn ngữ nghệ thuật ASCII đầy thách thức của bạn!

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

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

Giải trình

Chiến lược của chúng tôi: in nửa bên trái của chữ V, bắt đầu từ phía dưới và di chuyển sang phía trên bên trái; sau đó phản ánh nó

Ｓσ                                    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

(Nếu chỉ có Than có cắt chuỗi ... than ôi, có vẻ như chưa được triển khai.)

Pip , 32 25 byte

a.:sX#aL#a{OaDQaPRVaaPUs}

Lấy chuỗi đầu vào làm đối số dòng lệnh. Hãy thử trực tuyến!

Giải trình

                           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 với gói Stringi, 225 Byte

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

Nếu bạn chạy R trong mã tương tác, sau khi dán câu trả lời của tôi, chỉ cần nhập bất cứ điều gì. Bạn sẽ cần cài đặt chuỗi Stringi R (Tôi hy vọng nó không trái với quy tắc).

Giải trình:

Ý tưởng cơ bản là thêm khoảng trắng ở bên trái, sau đó cắt nó theo chiều dài bên phải. Sau đó, dán nó với phiên bản đảo ngược của nó là bên phải. Đây là phiên bản dài hơn, có thể đọc được của hàm:

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 byte

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

Quá trình của tôi là loại bỏ ký tự đầu tiên khỏi nửa bên phải của mỗi dòng sau khi đảo ngược nửa đầu. Như thế này:

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

Tôi không quen chơi golf, vì vậy hãy cho tôi biết nếu tôi có thể làm gì để rút ngắn nó đi.

Hàng loạt, 186 185 byte

@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

Dòng 1 và 6 có một không gian dấu. Chỉnh sửa: Đã lưu 1 byte nhờ @ ConorO'Brien.

Haskell , 76 byte

vlà chức năng chính, lấy một Stringđối số và đưa ra một Stringkết quả.

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

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

Ghi chú:

• i là đối số / đầu vào ban đầu.
• sban đầu ivới length ikhông gian được nối thêm.
• v igọi r s, sau đó tham gia các dòng kết quả.
• rtrả về một danh sách các Stringdòng.
• tlà svới nhân vật cuối cùng bị cắt nhỏ.
• Đệ quy r ttạo ra các dòng trừ đầu tiên, trừ không gian ban đầu trên mỗi dòng.

Thạch , 13 byte

⁶ṁ;@µḣJUz⁶ŒBY

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

Làm sao?

⁶ṁ;@µḣ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 byte

chỉnh sửa: loại bỏ khoảng trắng thừa

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

Tôi thực sự thấy khá khó khăn khi chơi cái này ở Ruby. Sau khi thêm khoảng trắng, nó sẽ mở rộng thành một đoạn mã khá dễ đọc:

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 byte

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

Lần đầu chơi Golf Code. Lời khuyên được chào đón!

Chương trình đầu ra:

Biên tập:

Đã lưu 40 byte nhờ Luis Mendo.

PHP, 95 92 85 80 78 77 byte

Lưu ý: sử dụng mã hóa 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")

Chạy như thế này:

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          

Giải trình

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.

Tinh chỉnh

• Đã lưu 3 byte bằng cách loại bỏ ký tự pad ( str_padmặc định là khoảng trắng, đó là những gì chúng ta cần)
• Đã lưu 7 byte bằng cách sử dụng các hoạt động nhị phân trên chuỗi để cắt bớt nó thay vì substr
• Đã lưu 5 byte bằng cách xoay chuỗi khi in ngược lại. Ngăn chặn sự cần thiết phải in một khoảng lùi, nhưng dẫn đến một khoảng trắng ở mỗi dòng.
• Đã lưu 2 byte bằng cách đệm chuỗi bằng phương pháp phức tạp hơn, nhưng ngắn hơn.
• Đã lưu một byte do thực tế là không cần phải tính đến ~"0"trường hợp (ASCII 207), vì tất cả các đầu vào có thể được coi là có thể in được ascii (Thx @Titus)

JavaScript (ES6), 169 157 byte

(-10 byte nhờ 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

Một giải pháp đệ quy. Tôi chưa quen với JavaScript, vì vậy hãy nhẹ nhàng! Bất kỳ lời khuyên chơi golf được đánh giá rất cao. :)

Và, tất nhiên, một sinh nhật rất hạnh phúc cho bạn V!

Kiểm tra đoạn trích

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 byte

Chúc mừng sinh nhật từ bạn cũ của bạn, CJam!

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

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

Giải trình

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 byte 124 byte

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

Gọi nó với một tham số duy nhất, chẳng hạn như .\V.ps1 Hello.

Chỉnh sửa: 2 byte được lưu với tiền boa từ admBorkBork

Pyke , 14 byte

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

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

JavaScript (ES6), 94 byte

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

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

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 byte

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