@KritixiLithos'a bu zorlukta yardımcı olduğun için teşekkürler !

V , kod golf sorunları için vim'i kullanabilmem ve genişletebilmem için yazdığım bir programlama dilidir. İlk taahhüt 3 Mart 2016'da gerçekleşti, yani bugün V bir yaşında! İşte oldu

V'nin ilk varoluş yılı boyunca, dört farklı katılımcıdan 176 komisyon , 12 farklı kullanıcıdan 140 cevabı ve sayılabilecek çok sayıda bozuk kopya operatörü oldu . Bir sahiptir çevrimiçi tercüman cömertçe işletilmektedir @Dennis, evsahipliğinde Aralık ayından bu yana neredeyse 8.000 kez .

V'nin doğum gününü kutlamak için bir meydan okuma yapalım! V'deki özelliklerin çoğu akılda dizi manipülasyonu ve asıl-sanatla tasarlandığından, V'yi kutlayan herhangi bir mücadelenin asil sanatla ilgili olması doğal görünmektedir. Dolayısıyla bugün için zorlu göreviniz bir kelimeyi girdi olarak almak ve bu kelimeyi V şeklinde yeniden şekillendirmektir. Örneğin, "Merhaba" girişi aşağıdaki V değerini vermelidir:

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

İşte V'nizin neye benzemesi gerektiği hakkında bazı detaylar. Giriş dizesi n karakter uzunluğundaysa, V n*2satırların yüksekliğinde olmalıdır . İlk satır aşağıdakilerden oluşmalıdır:

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

Her yeni satırda, başlangıcına bir boşluk eklenir ve dizenin iki tarafı üst üste binen karakterleri kaldırarak birbirlerine doğru hareket eder. En son satıra kadar olan, girişin sadece ilk karakteri. Her satırdaki sondaki boşluk boşluğu kabul edilebilir ve sondaki yeni satıra da izin verilir.

Girişin, içinde herhangi bir boşluk olmadan her zaman yazdırılabilir ASCII olacağını varsayabilir ve herhangi bir makul yöntemle giriş ve çıkış alabilirsiniz. İşte birkaç örnek girdi daha:

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

~:

~ ~
 ~

Elbette, bu kod golf olduğu için standart boşluklar yasaklandı ve amacınız bu görevi tamamlamak için mümkün olan en kısa programı yazmak. Mutlu golf!

Ne olursa olsun, herhangi bir dil kabul edilebilir olsa da, vim cevapları için yumuşak bir noktaya sahibim; :)

MATL , 21 14 bayt

MATL, V'ye mutlu yıllar diler!

tnEXyY+c3MZvZ)

Çevrimiçi deneyin!

açıklama

Girişi düşünün

'Hello'

uzunlukta n=5. Kod, bu dizenin 2B evrişimini boyut kimlik matrisiyle hesaplar 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]

Karaktere dönüştürülen ve alan 0 olarak gösterilen karakter 0 ile dönüştürülen evrişimin sonucu

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

Ardından sütunlar [1, 2, ..., 2*n-1, 2*n, 2*n-1, ..., 2, 1]bu karakter matrisinden seçilir ve istenen sonucu verir:

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

Yorumlanan kod

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 bayt

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

Çevrimiçi deneyin!

Şimdi çok daha kısa, V 'ters' bir işleci var .

Yanıtlayan diğer golf dillerine göre bu etkileyici değil, ama yapılması gerekiyordu. HexDump:

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

Açıklama:

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

Bu noktada, arabellek şuna benzer:

Happy         yppaH

Hayır, üçgeni tekrar tekrar oluşturacağız.

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

Burası V.'nin en sevdiğim özelliklerinden birini göstermeme neden oluyor. Çok fazla komut argüman gerektiriyor. Örneğin, >komut argümana bağlı olarak değişken sayıda satır girintisi gösterecektir:

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

ancak komutların çoğu, programın sonundaysa ve belirtilmemişse varsayılan bir argümanla (genellikle mevcut satır) bitmek zorunda kalır. Örneğin, özyinelemeli döngü için gerçekten V'nin çalıştığı şey şudur:

òâÙHãêxx>>ò

İkincisi òdolaylı olarak doldurulur. Harika olan, dolaylı olarak sona eren komutların birkaç katman derinliği uygulamasıdır, bu yüzden sadece yazsak bile >, V dolaylı olarak _argümanını verecek ve mevcut çizgiyi girecek.

Brainfuck , 152 bayt

Bu çok önemli bir durum, ol 'BF yorumlayıcısını kırmaya karar verdim ve bir tur atmaya karar verdim.

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

Yorumlar ile

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

Çevrimiçi deneyin!

> <> , 221 bayt

Ben harcanan yolu bu konuda çok fazla zaman. Doğum günün kutlu olsun, 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

Şunları yapabilirsiniz çevrimiçi denemek , ama almak için çok daha eğlenceli bu tercüman kullanarak çalıştırmak --playbayrağı

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

Aşağıdaki animasyon sonuçlanır.

Örnek

(iki dakikadan biraz daha az zaman alır)

açıklama

Bu cevabın ilginç kısmı onu Vşekle soktuğundan, işte ona uyan bir açıklama. Referans için aşağıdaki satır numaralı sürümü kullanıyoruz.

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

Bazen bir snippet'in ulaştığı yönü belirtmek için oklar (→ ↓ ←) kullanılır.

1. Başlangıç ​​durumuna

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

   İlk satır 2n ' yi [0,1]' e itecek , n'i yığında bırakacak ve bir boşluk ekleyecektir. Sonra yukarı çıkıp sağdaki ikinci çizgiye doğru sarılırız, sola başlayacağız. N + 1 boşluk eklemek için bir döngü var . Bu, aşağıdaki gibi çalışır.

                   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.
   

   Bu işlem bittikten sonra, 3. çizgiye ~~sıçramaktadır . Orada üstteki iki yığın elemanı (0 ve bir boşluk) çıkarılır ( ) ve X[10,1] ( a1.) konumuna atlayarak sağa doğru devam ederiz. Çarptık /, satır 7'ye sarılır ve ana program döngüsünü başlatırız.

2. Ana döngü ( 2n kez yapar)

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

   Bu döngü koşulu. İlk başta, yığın yazdırma için tersine çevrilir. Sonra sayacı [1,0] ( 01g) ' den alırız ve azaltılmış bir sürümünü ( :1-01p) depolarız . Etrafına sarılıp sağa sola dönerek programı sonlandırmak için şartlı koşullarla karşılaşırız. Sonlandırmazsak, ilk baskı döngüsüne atlarız.

   • İlk baskı döngüsü (sol yarısı)

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

     Yığının üstündeki uzunlukla başlıyoruz ve üst eleman 0 olmadıkça aşağıdaki kodu çalıştırıyoruz.

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

     Bu, yığını atmadan yazdırır. Döngü sona ererse, bir sonraki yazdırma döngüsüne hazırlanarak 5. satırda sağa atlarız.

   • Sağ yarı hazırlık

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

     Bu, sığması en zor kısımlardan biriydi. Aşağıda, ne olduğunu belirtmek için tüm yönlerden sarılmış bir versiyon var.

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

     Daha sonra, yazdırılacak olanın uzunluğunu zorlarız ve ikinci baskı döngüsünü başlatırız (ilk kopya, döngünün bir parçası değil).

   • İkinci baskı döngüsü (sağ yarı)

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

     Yürütülen kod, ilk baskı döngüsündeki ile tamamen aynıdır, o}çünkü mevcut konumlar olduğundan biraz daha ileriye yerleştirilir. Bitirdikten sonra, ana döngüyü değişmez doğrulayabilmemiz için yapmamız gereken birkaç şey var. Sonra ~hat 9 yürütülür biz aşağıdaki kod parçası biten dikey etrafında sarın.

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

     İlk önce aoyeni bir satır yazdıracak. Sonra zıplıyoruz ve başlangıçtan sonraki aynı noktaya geliyoruz, yani atlamak X.

Brain-Flak , 486 + 1 = 489 bayt

Beyin Flak'tan Mutlu Doğum Günü V!

Ayrıca bu cevapta kullanılan bazı kodları sağlayan 0 ' a teşekkür ederiz.

-cASCII'ye giriş ve çıkış için gerekli bayrak nedeniyle +1

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

Çevrimiçi deneyin!

Bu şüphesiz Brain-Flak'ta yaptığım en zor şeydi.

Brain-Flak, dizeleri çoğaltmak ve tersine çevirmek konusunda korkunç derecede kötüdür ve bu zorluk, dizeleri çoğaltmak ve tersine çevirmekten başka bir şey değildir.

Bu neredeyse çalışan parçacığını bir saatlik zorlu çalışmanın altına almayı başardım , ancak son birkaç alana ekleyerek Brain-Flak'ta yaptığım en zor şeylerden biri çıktı.

açıklama

Temel fikir, önce V'nin tepesini oluşturacağımız ve her yinelemenin ortasından iki karakter kaldıracak ve başlangıcına bir boşluk ekleyeceğiz.

Uygulamada bu oldukça zorlaşıyor.

Mevcut algoritmalar kopyalama ve geri alma için var, bu nedenle offstack'taki kodun ters bir kopyasını oluşturmak için bunlardan birini kullandım. Bir kere yaptım 2n-1, orjinal yığının üstüne boşluk koydum ve bir sandviç oluşturmak için üst tabakayı tekrar sahaya geri getirdim.

Şimdi üst sıramız var. Şimdi iki karakteri baştan kaldırmak ve cepheye bir boşluk eklemek istiyoruz. Bu en zor kısım olarak ortaya çıkıyor. Bunun nedeni, esas olarak iki parçayı saklamak zorundayız, biri geçerli snippet'in derinliği için diğeri de silme işleminin gerçekleşmesi gereken V'nin merkezine derinlik için.

Bu zor.

Her iki yığınta da süren tüm çoğaltma ve geri alma işlemleri nedeniyle her zaman tam olarak kullanımda. Bir şey koymak için bu yığınlarda gerçekten hiçbir yer yok. Dünyadaki tüm Üçüncü Stack Magic'lerde bile bu sorunu çözmek için ihtiyaç duyduğunuz erişim türünü alamazsınız.

Peki nasıl düzelteceğiz? Kısacası biz gerçekten değil; boşlukları şimdilik görmezden geliyoruz ve daha sonra bunları ekliyoruz, boşlukların nereye gitmesi gerektiğini işaret etmek için koda sıfır ekleyeceğiz, ancak bunun dışında gerçekten hiçbir şey yapmayacağız.

Bu yüzden her bir yinelemede, son yinelemenin bir kopyasını çıkardık ve onu offstack'a koyduk. Bunu ikiye bölmek için sakladığımız derinliği kullanırız, böylece V'nin sol yarısını sağ yığında ve V'nin sağ yarısını sol yığında tutarız. İki elementi kaldırır ve ikisini birbirine bağlarız. İyi ölçüm için yeni bir satır ekler ve bir sonraki yinelemeye başlarız. V'in merkezine olan derinlik birer birer azalır ve sıfıra çarptığında döngüyü durdururuz.

Şimdi inşa edilen V'nin büyük bir kısmına sahibiz. Bununla birlikte uygun alanlardan yoksağız ve V'miz şu anda biraz (tamamen: tamamen) baş aşağı.

Bu yüzden çeviririz. Onu diğer yığına çevirmek için her elemanı birer birer üst üste kaydırmamız gerekir. Elemanları taşırken sıfırları kontrol ediyoruz. Eğer biriyle karşılaşırsak, boşlukları ait oldukları yerlere geri koymak zorundayız. Sıfırı kıkırdattık ve bir sürü boşluk ekledik. Kaç tane olduğunu nasıl bilebiliriz? Takip ederiz; Birini çoğaltmak veya tersine çevirmek yerine bir yığını çevirmek çok yoğun olmayan bir iştir, bu yüzden aslında kaç tane alan ekleyeceğimizi takip etmek için ek bir sayacı saklamak ve erişmek için belleğe sahibiz. Her yeni boşluk eklediğimizde sayacı birer birer azaltırız. Sayaç son satırda (V'nin üstü) sıfıra gitmeli ve bu nedenle yazdırmaya hazırız.

Son olarak, etrafta dolaşan birkaç şeyi temizler ve örtük çıktılar için programı sonlandırırız.

Jöle , 15 12 bayt

⁶ṁ⁸;;\Uz⁶ŒBY

Çevrimiçi deneyin!

Nasıl çalışır

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

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

Çevrimiçi deneyin!

Python 2 , 65 bayt

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

Çevrimiçi deneyin!

JavaScript (ES6), 108 106 98 94 bayt

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 bayt

Bir dize işleme dilden mutlu yıllar!

Bayt sayısı, ISO 8859-1 kodlamasını varsayar.

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

;{*`.¶

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

Çevrimiçi deneyin!

açıklama

$
$.`$* 

Bu , dizenin sonunu eşleştirerek, dizenin uzunluğunu alarak ve birçok kez tekrarlanan bir alanı tekrar ederek nboşluklar ( ndizge uzunluğu olan) ekler .$.`$*

$
¶$`

Dizenin sonunu tekrar eşleştirerek ve dizenin kendisini ekleyerek dizenin tamamını (satır beslemeyle ayrılmış) çoğaltırız $`.

O$^r`.\G

Bu, ikinci satırı sağdan sola ( r) göre eşleştirerek, ardından bir defada bir karakteri eşleştirerek ( .ancak hepsinin bitişik olduğundan) emin olarak tersine çevirir \G. Bu şekilde, maçlar çizgiyi geçemez. Bu daha sonra bir sıralama aşamasında kullanılır. Sıralama modunu ( $) kullanarak ancak her eşleşmeyi boş bir dizeyle değiştirmek yerine, gerçek sıralama yapılmaz. Ancak bu ^seçenek nedeniyle , maçlar sonunda ikinci satırın tamamını tersine çevirir.

;{*`.¶

Bu aşama çıktı içindir ve programın geri kalanını da etkiler. {Kalan aşamaları, bu aşamalar dizgiyi değiştirmeyi başaramayana kadar tekrarlanan bir döngüde sarar (bu, son aşama artık eşleşmeyeceği için gerçekleşir). Programın ;sonunda çıkışı devre dışı bırakır. *Dönüşler sahne işlenir ve sonuç yazdırılır, ancak daha sonra bir önceki dize restore demektir kuru bir vadede içine bu sahne.

Sahnenin kendisi bir satır beslemesi ve bir önceki karakteri siler. Bu bize istenen çıktının bir satırını verir (ilk satırdan başlayarak).

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

Son olarak, bu aşama her çizgiyi diğerine çevirir. Bu, ilk boşluk olmayan karakterin önüne bir boşluk ekleyerek, ilk satırdaki son karakteri ve ikinci satırdaki ilk karakteri kaldırarak yapılır. Bu işlem, ilk satırda kalan ve satırın son satırına karşılık gelen yalnızca bir boşluk olmayan karakter kaldıktan sonra durur.

05AB1E , 12 bayt

Dgð×J.p€ûR.c

Çevrimiçi deneyin!

açıklama

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

Veya aynı byte için diğer yönden sayma.

Âsgú.sí€ûR.c

açıklama

             # 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 bayt

Japt, daha başarılı yıllar süren golf oynamak dileğiyle!

²¬£²îU²ç iYU)ê

-RBayrağı gerektirir .Çevrimiçi test edin!

açıklama

Bu, birkaç gün önce eklediğim çve îişlevlerinden yararlanı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)

Dennis'in tekniği artık bir bayt.

U+Uç)å+ mw y mê

GNU sed , 110 100 + 1 (bayrak) = 101 bayt

Düzenleme: Riley sayesinde 9 byte daha kısa

Başka bir dize manipülasyon dili olarak, sed V'ye en iyisini diliyor !

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

Çevrimiçi deneyin!

Açıklama: girişin son test durumu olduğu varsayılarak ('V!'). Her adımda desen uzayını, boşlukları 'S ile değiştirerek göstereceğim.

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 bayt

Çevrimiçi deneyin!

Eminim bu en uygun değildir, ama en azından oldukça 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 bayt

Jolf yalvararak V mutlu yıllar diler!

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

Burada dene! ␅0x05 olmalıdır.

açıklama

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

Kömür , 29 bayt

İyi ki doğdun V, dostunuzdan hayal kırıklığı yaratan, bu zorlu ASCII sanat dilinden!

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

Çevrimiçi deneyin!

açıklama

Stratejimiz: V'nin sol yarısını yazdırın, alttan başlayıp sol üste doğru hareket edin; o zaman yansıt.

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

(Sadece Kömür tel dilimleme ... ne yazık ki, henüz uygulanmadı gibi görünüyor.)

Pip , 32 25 bayt

a.:sX#aL#a{OaDQaPRVaaPUs}

Giriş dizesini komut satırı argümanı olarak alır. Çevrimiçi deneyin!

açıklama

                           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

Stringi paketli R, 225 Bayt

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'yi etkileşimli kodda çalıştırırsanız, cevabımı yapıştırdıktan sonra herhangi bir şey girin. Yüklenecek stringi R paketine ihtiyacınız olacak (umarım kurallara aykırı değildir).

Açıklama:

Temel fikir sol tarafa boşluk eklemek, ardından doğru uzunluğa kesmektir. Bundan sonra, ters sürümü ile sağ tarafa yapıştırın. İşte fonksiyonun daha uzun, insan tarafından okunabilen bir versiyonu:

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 bayt

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

İşlemim, ilk yarıyı ters çevirdikten sonra her bir satırın sağ yarısından ilk karakteri çıkarmaktı. Bunun gibi, böyle:

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

Bir şeyleri golf oynamaya alışkın değilim, bu yüzden kısaltmak için yapabileceğim bir şey olursa bana bildirin.

Toplu iş, 186 185 bayt

@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 ve 6 numaralı satırların sonda alanı vardır. Düzenleme: @ ConorO'Brien sayesinde 1 bayt kaydedildi.

Haskell , 76 bayt

vasıl işlev, Stringargüman alma ve Stringsonuç vermedir.

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

Çevrimiçi deneyin!

Notlar:

• i başlangıç ​​argümanı / girişidir.
• sbaşlangıçta eklenen boşluklarla ibirlikte length i.
• v içağırır r s, ardından sonuç satırlarına katılır.
• rStringsatır listesini döndürür .
• t dır-dir s kapalı kıyılmış son karakteri ile.
• Özyineleme r t, her satırdaki ilk boşluğu eksi olan eksi satırları üretir.

Jöle , 13 bayt

⁶ṁ;@µḣJUz⁶ŒBY

Çevrimiçi deneyin!

Nasıl?

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

düzenleme: fazla boşluk kaldırıldı

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

Bunu Ruby'de golf oynamak oldukça zor buldum. Boşluk ekledikten sonra oldukça okunabilir bir kod snippet'ine genişler:

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 bayt

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

İlk kez Code Golfing. İpuçları açıktır!

Program Çıktısı:

Düzenle:

Luis Mendo sayesinde 40 bayt kaydedildi.

PHP, 95 92 85 80 78 77 bayt

Not: IBM-850 kodlamasını kullanır

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

Bu şekilde koş:

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          

açıklama

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.

Düzenlemeler

• Pad karakterinden kurtularak 3 bayt kurtarıldı (str_pad varsayılan olarak boşluğa, ki ihtiyacımız olan şey bu)
• İpte kesmek için dizede ikili işlemler kullanarak 7 bayt kaydedildi substr
• Ters basarken dizeyi döndürerek 5 bayt kurtardı. Bir backspace yazdırma gereksinimini önler, ancak her satırda arkada bir boşluk olmasıyla sonuçlanır.
• Daha kıvrımlı, ancak daha kısa bir metot kullanarak kayan teli kullanarak 2 bayt kaydedildi.
• ~"0"Tüm girdilerin yazdırılabilir ascii olduğu varsayılabileceğinden (ASCII 207), olayı hesaba katmaya gerek olmadığı gerçeği nedeniyle bir bayt kaydedildi (Thx @ Titus)

JavaScript (ES6), 169 157 bayt

(Conor O'Brien sayesinde -10 bayt)

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

Özyinelemeli bir çözüm. JavaScript’te yeniyim, lütfen nazik olun! Herhangi bir golf ipucu büyük beğeni topluyor. :)

Ve elbette, size çok mutlu bir doğum günü V !

Test Parçacığı

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 bayt

Eski dostun CJam'dan doğum günün kutlu olsun!

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

Çevrimiçi deneyin!

açıklama

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

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

Gibi tek bir parametre ile çağırın .\V.ps1 Hello.

Düzenleme: AdmBorkBork'tan ipucu ile kaydedilen 2 bayt

Pyke , 14 bayt

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

Çevrimiçi deneyin!

JavaScript (ES6), 94 bayt

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

Test durumları

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 Bayt

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