Terima kasih kepada @KritixiLithos karena membantu saya mengatasi tantangan ini!

V adalah bahasa pemrograman yang saya tulis sehingga saya bisa menggunakan dan memperluas vim untuk tantangan kode-golf. Komitmen pertama adalah pada 3 Maret 2016, artinya hari ini V berumur satu tahun! Woo hoo

Selama tahun pertama keberadaan V, ada 176 komitmen dari empat kontributor berbeda, 140 jawaban dari 12 pengguna yang berbeda , dan terlalu banyak operator duplikat yang rusak untuk dihitung . Ini memiliki juru bahasa online , yang disediakan oleh @ Dennis, yang telah dijalankan hampir 8.000 kali sejak Desember .

Mari kita tantangan untuk merayakan ulang tahun V! Karena sebagian besar fitur dalam V dirancang dengan manipulasi string dan ascii-art dalam pikiran, sepertinya wajar bahwa setiap tantangan merayakan V harus tentang seni ascii. Jadi tantangan Anda untuk hari ini adalah mengambil kata sebagai input, dan membentuk kembali kata itu dalam bentuk huruf V. Misalnya, input "Halo" harus memberikan V berikut:

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

Berikut adalah beberapa detail tentang seperti apa penampilan V Anda. Jika string input panjangnya n karakter, maka V harus berupa n*2garis yang tinggi. Baris pertama harus terdiri dari:

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

Pada setiap baris baru, satu spasi ditambahkan ke awal, dan kedua sisi string bergerak ke satu sama lain, menghilangkan karakter yang tumpang tindih. Sampai baris terakhir, yang hanya merupakan karakter input pertama. Trailing whitespace pada setiap baris dapat diterima, dan trailing newline juga diperbolehkan.

Anda dapat mengasumsikan bahwa input akan selalu dapat dicetak ASCII tanpa spasi di dalamnya, dan Anda dapat mengambil input dan output dengan metode yang masuk akal. Berikut ini beberapa contoh input:

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

~:

~ ~
 ~

Tentu saja, karena ini adalah kode-golf , celah standar dilarang dan tujuan Anda adalah menulis program sesingkat mungkin untuk menyelesaikan tugas ini. Selamat bermain golf!

Untuk apa nilainya, saya memiliki titik lemah untuk jawaban vim, jadi poin bonus imajiner untuk menggunakan vim atau V, meskipun bahasa apa pun dapat diterima. :)

MATL , 21 14 byte

MATL mengucapkan selamat ulang tahun V!

tnEXyY+c3MZvZ)

Cobalah online!

Penjelasan

Pertimbangkan inputnya

'Hello'

panjangnya n=5. Kode menghitung konvolusi 2D dari string ini dengan matriks ukuran identitas 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]

Hasil konvolusi, dikonversi menjadi char dan dengan char 0 ditampilkan sebagai spasi, adalah

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

Kemudian kolom [1, 2, ..., 2*n-1, 2*n, 2*n-1, ..., 2, 1]dipilih dari matriks char ini, menghasilkan hasil yang diinginkan:

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

Kode yang dikomentari

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>

Cobalah online!

Jauh lebih pendek sekarang bahwa V memiliki operator 'mundur' .

Tidak terlalu mengesankan dibandingkan dengan bahasa golf lainnya yang telah menjawab, tetapi itu harus dilakukan. Hexdump:

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

Penjelasan:

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

Pada titik ini, buffer terlihat seperti ini:

Happy         yppaH

Tidak, kami akan membangun segitiga secara rekursif.

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

Di sinilah saya bisa memamerkan salah satu fitur favorit saya dari V. Banyak perintah memerlukan argumen. Sebagai contoh, >perintah akan membuat indentasi sejumlah variabel baris tergantung pada argumen:

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

tetapi sebagian besar perintah akan dipaksa untuk diakhiri dengan argumen default (biasanya baris saat ini) jika berada di akhir program dan tidak ditentukan. Sebagai contoh, apa yang sebenarnya dijalankan oleh V untuk loop rekursif kami adalah:

òâÙHãêxx>>ò

Yang kedua òsecara implisit diisi. Yang keren adalah bahwa perintah yang berakhir secara implisit menerapkan beberapa lapisan dalam, jadi meskipun kita hanya menulis >, V secara implisit akan memberikan _argumennya, dan itu akan membuat indentasi baris saat ini.

Brainfuck , 152 byte

Ini adalah kesempatan yang sangat penting, saya memutuskan untuk memecahkan penerjemah BF ol dan memberikan ini putaran.

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

Dengan Komentar

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

Cobalah online!

> <> , 221 byte

Aku menghabiskan cara terlalu banyak waktu untuk hal ini. Selamat ulang tahun, 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

Anda dapat mencobanya secara online , tetapi jauh lebih menyenangkan untuk mendapatkan juru bahasa ini dan menjalankannya menggunakan --playbendera

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

yang menghasilkan animasi di bawah ini.

Contoh

(Dibutuhkan sedikit di bawah dua menit)

Penjelasan

Karena bagian yang menarik dari jawaban ini adalah membungkusnya dalam Vbentuk, di sini ada penjelasan yang sesuai dengannya. Kami menggunakan versi nomor baris berikut untuk referensi.

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

Terkadang panah (→ ↓ ←) digunakan untuk menunjukkan arah pencapaian potongan.

1. Inisialisasi

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

   Baris pertama akan mendorong 2n ke [0,1], meninggalkan n pada tumpukan dan menambahkan satu spasi. Selanjutnya, kita naik dan membungkus ke baris kedua di sebelah kanan, di mana kita akan mulai ke kiri. Ada loop untuk menambahkan n + 1 spasi. Ini berfungsi sebagai berikut.

                   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.
   

   Setelah ini selesai, ia memantul ke baris 3. Di sana dua elemen tumpukan teratas (0 dan spasi) dihapus ( ~~) dan kami melompat ke Xlokasi [10,1] ( a1.), terus ke kanan. Kami bertemu di /, membungkus ke baris 7 dan memulai loop program utama.

2. Loop utama ( 2n kali dilakukan)

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

   Ini adalah kondisi loop. Pada awalnya, tumpukan dibalik untuk dicetak. Kemudian kita mendapatkan penghitung dari [1,0] ( 01g) dan menyimpan versi yang dikurangi ( :1-01p). Dengan membungkus dan menabrak ke kanan, kita menemukan persyaratan untuk mengakhiri program. Jika kita tidak berhenti, kita langsung ke lingkaran pencetakan pertama.

   • Lingkaran pencetakan pertama (setengah kiri)

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

     Kita mulai dengan panjang di atas tumpukan dan menjalankan kode berikut selama elemen atas bukan 0.

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

     Ini akan mencetak tumpukan tanpa membuangnya. Jika loop berakhir, kita melompat ke kanan pada baris 5, mempersiapkan loop pencetakan berikutnya.

   • Persiapan setengah tepat

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

     Ini adalah salah satu bagian tersulit yang pas. Di bawah ini adalah versi yang dilucuti dari semua pembungkus arah untuk menunjukkan apa yang terjadi.

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

     Kami kemudian mendorong panjang dari apa yang akan dicetak dan memulai loop pencetakan kedua (dengan duplikat awal bukan bagian dari loop).

   • Lingkaran pencetakan kedua (setengah kanan)

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

     Kode yang dieksekusi sepenuhnya sama dengan di loop pencetakan pertama, dengan o}ditempatkan sedikit lebih jauh karena ada lokasi yang tersedia. Setelah selesai, kami memiliki beberapa hal yang harus dilakukan sebelum kami dapat memverifikasi invarian loop utama lagi. Setelah ~jalur 9 dijalankan, kita membungkus secara vertikal, berakhir di bagian kode berikut.

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

     Pertama aoakan mencetak baris baru. Kemudian kami bangkit dan tiba di tempat yang sama persis setelah inisialisasi, yaitu melompat ke X.

Brain-Flak , 486 + 1 = 489 byte

Selamat Ulang Tahun V dari Brain-Flak!

Juga Terima kasih kepada 0 ' yang menyediakan beberapa kode yang digunakan dalam jawaban ini

+1 karena -cbendera yang diperlukan untuk masuk dan keluar ASCII

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

Cobalah online!

Ini tanpa diragukan lagi adalah hal tersulit yang pernah saya lakukan di Brain-Flak.

Brain-Flak terkenal mengerikan dalam menduplikasi dan membalikkan string dan tantangan ini tidak lain adalah menduplikasi dan membalikkan string.

Saya berhasil mendapatkan potongan ini hampir bekerja hanya dalam waktu kurang dari satu jam kerja keras, tetapi menambahkan dalam beberapa ruang terakhir ternyata menjadi salah satu hal paling sulit yang pernah saya lakukan di Brain-Flak.

Penjelasan

Ide dasarnya adalah bahwa kita akan membuat bagian atas V terlebih dahulu dan setiap iterasi menghapus dua karakter dari tengah dan menambahkan spasi ke awal.

Dalam praktiknya ini menjadi sangat sulit.

Algoritma yang ada ada untuk menyalin dan membalikkan jadi saya menggunakan salah satu dari mereka untuk membuat salinan kode terbalik pada offstack. Setelah saya selesai melakukan itu, saya meletakkan 2n-1spasi di atas tumpukan asli dan memindahkan backstack kembali ke onstack untuk membuat sandwich.

Sekarang kita memiliki baris teratas. Sekarang kami ingin menghapus dua karakter dari awal dan menambahkan spasi ke depan. Ini ternyata menjadi bagian yang paling sulit. Alasan untuk ini adalah bahwa kita perlu menyimpan dua nilai dasarnya, satu untuk kedalaman potongan saat ini dan satu untuk kedalaman ke pusat V di mana penghapusan harus terjadi.

Ini sulit.

Karena semua duplikasi dan pembalikan yang terjadi pada kedua tumpukan digunakan penuh sepanjang waktu. Benar-benar tidak ada tempat di tumpukan ini untuk menaruh apa pun. Bahkan dengan semua Magic Stack Ketiga di dunia Anda tidak bisa mendapatkan jenis akses yang Anda butuhkan untuk menyelesaikan masalah ini.

Jadi bagaimana cara memperbaikinya? Singkatnya, kita tidak benar-benar; kita mengabaikan spasi untuk saat ini dan menambalnya nanti kita akan menambahkan nol pada kode untuk menandai ke mana ruang-ruang yang dimaksudkan untuk pergi tetapi selain itu kita tidak akan benar-benar melakukan apa pun.

Jadi pada setiap iterasi, kami membuat salinan iterasi terakhir dan meletakkannya di offstack. Kami menggunakan kedalaman yang kami simpan untuk membaginya menjadi dua sehingga kami memiliki bagian kiri dari V di tumpukan kanan dan setengah kanan dari V di tumpukan kiri. Kami menghapus dua elemen dan menambal keduanya kembali bersama. Kami menambahkan baris baru untuk ukuran yang baik dan memulai iterasi berikutnya. Setiap kali kedalaman ke pusat V berkurang satu dan ketika mencapai nol kita menghentikan loop.

Sekarang kita memiliki sebagian besar V yang dibangun. Namun kami kekurangan ruang yang tepat dan V kami saat ini sedikit (baca: sepenuhnya) terbalik.

Jadi kami balikkan. Untuk membalikkannya ke tumpukan lain kita harus memindahkan setiap elemen satu per satu. Saat kita bergerak elemen kita memeriksa nol. Jika kita menemukan satu, kita harus meletakkan ruang kembali di tempatnya. Kami membuang nol dan menambahkan banyak spasi. Bagaimana kita tahu berapa banyak? Kami melacak; membalik tumpukan tidak seperti menggandakan atau membalikkan adalah tugas yang sangat tidak intensif sehingga kita benar-benar memiliki memori untuk menyimpan dan mengakses penghitung tambahan untuk melacak berapa banyak ruang yang akan ditambahkan. Setiap kali kita menambahkan beberapa spasi, kita mengurangi penghitung dengan satu. Penghitung harus mencapai nol pada baris baru terakhir (bagian atas V) dan dengan demikian kami siap mencetak.

Terakhir kami membersihkan beberapa hal yang berkeliaran dan mengakhiri program untuk output implisit.

Jelly , 15 12 byte

⁶ṁ⁸;;\Uz⁶ŒBY

Cobalah online!

Bagaimana itu bekerja

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

Cobalah online!

Python 2 , 65 byte

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

Cobalah online!

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>

Retina , 51 47 byte

Selamat ulang tahun dari bahasa pemrosesan string sesama!

Hitungan byte mengasumsikan penyandian ISO 8859-1.

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

;{*`.¶

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

Cobalah online!

Penjelasan

$
$.`$* 

Ini menambahkan nspasi (di mana npanjang string), dengan mencocokkan ujung string, mengambil panjang string dengan $.`, dan mengulangi spasi yang berulang kali $*.

$
¶$`

Kami menduplikasi seluruh string (dipisahkan oleh umpan baris), dengan mencocokkan ujung string lagi dan memasukkan string itu sendiri $`.

O$^r`.\G

Ini membalikkan baris kedua dengan mencocokkan dari kanan ke kiri ( r), lalu mencocokkan satu karakter pada satu waktu ( .) tetapi memastikan bahwa mereka semua berdekatan ( \G). Dengan cara ini, pertandingan tidak dapat melewati linefeed. Ini kemudian digunakan dalam sort-stage. Dengan menggunakan mode urut ( $) tetapi mengganti setiap kecocokan dengan string kosong, tidak ada penyortiran yang sebenarnya dilakukan. Tetapi karena ^opsi, pertandingan dibalik di akhir, membalikkan seluruh baris kedua.

;{*`.¶

Tahap ini untuk output dan juga mempengaruhi sisa program. {membungkus tahap-tahap yang tersisa dalam satu lingkaran yang diulang sampai tahap-tahap itu gagal untuk mengubah string (yang akan terjadi karena tahap terakhir tidak akan cocok lagi). The ;menonaktifkan output pada akhir program. The *bergantian tahap ini menjadi kering-run yang berarti bahwa panggung diproses dan hasilnya dicetak, tapi setelah string sebelumnya dipulihkan.

Panggung itu sendiri hanya menghapus linefeed dan karakter sebelumnya. Yang memberi kita satu baris dari output yang diinginkan (dimulai dengan baris pertama).

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

Akhirnya, tahap ini mengubah setiap baris menjadi yang berikutnya. Ini dilakukan dengan memasukkan spasi di depan karakter non-spasi pertama, menghapus karakter terakhir di baris pertama, serta karakter pertama di baris kedua. Proses ini berhenti setelah hanya ada satu karakter non-spasi yang tersisa di baris pertama, yang sesuai dengan baris terakhir dari output.

05AB1E , 12 byte

Dgð×J.p€ûR.c

Cobalah online!

Penjelasan

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

Atau untuk jumlah byte yang sama dari arah lain.

Âsgú.sí€ûR.c

Penjelasan

             # 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 berharap V bertahun-tahun lebih sukses bermain golf!

²¬£²îU²ç iYU)ê

Membutuhkan -Rbendera. Uji secara online!

Penjelasan

Ini memanfaatkan çdan îfungsi yang saya tambahkan beberapa hari yang lalu:

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

Teknik Dennis adalah satu byte lebih panjang:

U+Uç)å+ mw y mê

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

Sunting: 9 byte lebih pendek berkat Riley

Sebagai bahasa manipulasi string lain, sed mengucapkan V yang terbaik!

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

Cobalah online!

Penjelasan: mengasumsikan input adalah test case terakhir ('V!'). Saya akan menunjukkan ruang pola pada setiap langkah untuk kejelasan, mengganti spasi dengan '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

Cobalah online!

Saya yakin ini tidak optimal, tetapi setidaknya cukup 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 dengan bangga mengucapkan selamat ulang tahun kepada V!

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

Coba di sini! ␅harus 0x05.

Penjelasan

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

Arang , 29 byte

Selamat ulang tahun V, dari bahasa ASCII-art sesama seni Anda yang mengecewakan-lama-untuk-ini!

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

Cobalah online!

Penjelasan

Strategi kami: cetak setengah kiri dari V, mulai dari bawah dan pindah ke kiri atas; lalu mencerminkannya.

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

(Kalau saja Charcoal memiliki slicing string ... sayangnya, tampaknya belum diimplementasikan.)

Pip , 32 25 byte

a.:sX#aL#a{OaDQaPRVaaPUs}

Mengambil string input sebagai argumen baris perintah. Cobalah online!

Penjelasan

                           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 dengan paket stringi, 225 Bytes

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

Jika Anda menjalankan R dalam kode interaktif, setelah menempelkan jawaban saya, masukkan saja apa saja. Anda akan memerlukan paket R stringi untuk diinstal (saya harap ini tidak melanggar aturan).

Penjelasan:

Ide dasarnya adalah menambahkan spasi ke sisi kiri, lalu memotongnya menjadi panjang yang tepat. Setelah itu, rekatkan dengan versi terbalik sebagai sisi kanan. Ini adalah versi fungsi yang lebih panjang dan dapat dibaca manusia:

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}

Proses saya adalah menghapus karakter pertama dari bagian kanan setiap baris setelah membalikkan bagian pertama. Seperti ini:

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

Saya tidak terbiasa mencoba golf, jadi beri tahu saya jika ada yang bisa saya lakukan untuk membuatnya lebih pendek.

Batch, 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

Baris 1 dan 6 memiliki ruang tambahan. Sunting: Disimpan 1 byte berkat @ ConorO'Brien.

Haskell , 76 byte

vadalah fungsi utama, mengambil Stringargumen dan memberikan Stringhasil.

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

Cobalah online!

Catatan:

• i adalah argumen / input awal.
• sawalnya idengan length ispasi ditambahkan.
• v ipanggilan r s, kemudian bergabung dengan garis hasil.
• rmengembalikan daftar Stringgaris.
• tadalah sdengan karakter terakhir dipotong.
• Rekursi r tmenghasilkan garis-garis kecuali yang pertama, dikurangi ruang awal pada setiap baris.

Jelly , 13 byte

⁶ṁ;@µḣJUz⁶ŒBY

Cobalah online!

Bagaimana?

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

sunting: menghapus kelebihan spasi putih

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

Sebenarnya saya merasa sangat sulit untuk bermain golf di Ruby. Setelah menambahkan spasi, itu diperluas ke potongan kode yang cukup mudah dibaca:

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

Golf Code pertama kali. Kiatnya diterima!

Output Program:

Sunting:

Disimpan 40 byte berkat Luis Mendo.

PHP, 95 92 85 80 78 77 byte

Catatan: menggunakan pengkodean 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")

Jalankan seperti ini:

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          

Penjelasan

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.

Tweaks

• Disimpan 3 byte dengan menghilangkan karakter pad ( str_paddefault ke spasi, yang kita butuhkan)
• Menyimpan 7 byte dengan menggunakan operasi biner pada string untuk memotongnya alih-alih substr
• Disimpan 5 byte dengan memutar string saat mencetak kebalikannya. Mencegah kebutuhan untuk mencetak backspace, tetapi menghasilkan ruang tambahan di setiap baris.
• Disimpan 2 byte oleh string padding menggunakan metode yang lebih berbelit-belit, tetapi lebih pendek.
• Menyimpan byte karena fakta bahwa tidak perlu memperhitungkan ~"0"kasus ini (ASCII 207), karena semua input dapat diasumsikan dapat dicetak ascii (Thx @Titus)

JavaScript (ES6), 169 157 byte

(-10 byte terima kasih kepada 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

Solusi rekursif. Saya baru mengenal JavaScript, jadi harap bersikap lembut! Setiap tips bermain golf sangat dihargai. :)

Dan, tentu saja, ulang tahun yang sangat bahagia untuk Anda V!

Cuplikan Tes

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

Selamat ulang tahun dari teman lama Anda CJam!

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

Cobalah online!

Penjelasan

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

Sebut saja dengan parameter tunggal, seperti .\V.ps1 Hello.

Sunting: 2 byte disimpan dengan tip dari AdmBorkBork

Pyke , 14 byte

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

Cobalah online!

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

Uji kasus

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 Bytes

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