Dzięki @KritixiLithos za pomoc w tym wyzwaniu!

V jest językiem programowania, który napisałem, aby móc używać i rozszerzać vima do wyzwań związanych z golfem. Pierwsze zatwierdzenie nastąpiło 3 marca 2016 roku, co oznacza, że ​​dziś V kończy roczek! Woo-hoo

W ciągu pierwszego roku istnienia V wykonano 176 zatwierdzeń od czterech różnych autorów, 140 odpowiedzi od 12 różnych użytkowników i zbyt wielu popsutych zduplikowanych operatorów, aby liczyć . Ma tłumacza online , hojnie obsługiwanego przez @Dennis, który był uruchamiany prawie 8 000 razy od grudnia .

Podejmijmy wyzwanie, aby świętować urodziny V. Ponieważ większość funkcji w V została zaprojektowana z myślą o manipulacji strunami i sztuce ascii , po prostu wydaje się naturalne, że każde wyzwanie świętujące V powinno dotyczyć sztuki ascii. Twoim dzisiejszym wyzwaniem jest przyjęcie słowa jako danych wejściowych i przekształcenie go w kształt litery V. Na przykład wpis „Hello” powinien dać następujące V:

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

Oto kilka szczegółów na temat tego, jak powinno wyglądać Twoje V. Jeśli ciąg wejściowy ma długość n znaków, litera V powinna mieć n*2wysokość wiersza. Pierwsza linia powinna składać się z:

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

W każdym nowym wierszu jedna spacja jest dodawana na początku, a dwie strony łańcucha przesuwają się ku sobie, usuwając nakładające się znaki. Aż do ostatniego wiersza, który jest tylko pierwszym znakiem wprowadzania. Końcowe białe znaki w każdej linii są dopuszczalne, a dozwolony jest także końcowy znak nowej linii.

Możesz założyć, że dane wejściowe zawsze będą możliwe do wydrukowania w formacie ASCII bez żadnych spacji, a także możesz pobierać dane wejściowe i wyjściowe dowolną rozsądną metodą. Oto kilka przykładowych danych wejściowych:

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

~:

~ ~
 ~

Oczywiście, ponieważ jest to gra w golfa , standardowe luki są zakazane, a Twoim celem jest napisanie możliwie najkrótszego programu do wykonania tego zadania. Miłej gry w golfa!

Jeśli chodzi o to, co warto, mam słabość do odpowiedzi na vima, więc wymyślone punkty bonusowe za używanie vima lub V, chociaż każdy język jest akceptowalny. :)

MATL , 21 14 bajtów

MATL życzy V wszystkiego najlepszego!

tnEXyY+c3MZvZ)

Wypróbuj online!

Wyjaśnienie

Rozważ dane wejściowe

'Hello'

długości n=5. Kod oblicza splot 2D tego ciągu z macierzą tożsamości wielkości 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]

Wynikiem splotu, przekonwertowanego na char i z char 0 pokazanym jako spacja, jest

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

Następnie kolumny [1, 2, ..., 2*n-1, 2*n, 2*n-1, ..., 2, 1]są wybierane z tej macierzy znaków, co daje pożądany wynik:

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

Skomentowany 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 bajtów

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

Wypróbuj online!

Znacznie krótszy teraz, gdy V ma operator „wstecz” .

Nie tak imponujące w porównaniu z innymi językami golfa, które odpowiedziały, ale trzeba było to zrobić. Hexdump:

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

Wyjaśnienie:

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

W tym momencie bufor wygląda następująco:

Happy         yppaH

Nie, rekurencyjnie zbudujemy trójkąt.

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

Tutaj mogę pokazać jedną z moich ulubionych funkcji V. Wiele poleceń wymaga kłótni. Na przykład >polecenie spowoduje wcięcie zmiennej liczby linii w zależności od argumentu:

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

ale większość poleceń będzie musiała zakończyć się domyślnym argumentem (zwykle bieżącym wierszem), jeśli jest na końcu programu i nie jest określony. Na przykład V faktycznie działa dla naszej pętli rekurencyjnej:

òâÙHãêxx>>ò

Drugi òjest niejawnie wypełniony. Fajne jest to, że niejawnie zakończone polecenia nakładają głębokość na kilka warstw, więc nawet jeśli pisaliśmy tylko >, V domyślnie poda _swój argument i wciśnie bieżącą linię.

Brainfuck , 152 bajty

To taka doniosła okazja, postanowiłem wypróbować starego tłumacza BF i dać mu szansę.

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

Z komentarzami

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

Wypróbuj online!

> <> , 221 bajtów

Spędziłem sposób zbyt dużo czasu na to. Wszystkiego najlepszego, 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

Możesz wypróbować go online , ale znacznie fajniej jest zdobyć ten interpreter i uruchomić go przy użyciu --playflagi

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

co powoduje animację poniżej.

Przykład

(zajmuje to nieco mniej niż dwie minuty)

Wyjaśnienie

Ponieważ interesującą częścią tej odpowiedzi jest zawijanie jej w Vkształt, oto wyjaśnienie, które jest z nią zgodne. W celach informacyjnych wykorzystujemy następującą wersję o numerze liniowym.

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

Czasami strzałki (→ ↓ ←) służą do wskazania kierunku, w którym osiągnięty został fragment kodu.

1. Inicjalizacja

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

   Pierwszy wiersz popchnie 2n do [0,1], pozostawi n na stosie i doda jedno spację. Następnie idziemy w górę i owijamy się do drugiej linii po prawej, gdzie zaczniemy iść w lewo. Istnieje pętla do dodawania spacji n + 1 . Działa to w następujący sposób.

                   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.
   

   Po zakończeniu odbija się do linii 3. Tam dwa górne elementy stosu (0 i spacja) są usuwane ( ~~) i przeskakujemy do Xlokalizacji [10,1] ( a1.), kontynuując w prawo. Podbijamy się /, zawijamy do linii 7 i uruchamiamy główną pętlę programu.

2. Pętla główna ( 2 razy)

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

   To jest warunek pętli. Początkowo stos jest odwracany do drukowania. Następnie pobieramy licznik z [1,0] ( 01g) i przechowujemy wersję zmniejszoną ( :1-01p). Otaczając się i podbijając w prawo, napotykamy warunek zakończenia programu. Jeśli się nie zakończymy, przejdziemy do pierwszej pętli drukowania.

   • Pierwsza pętla drukująca (lewa połowa)

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

     Zaczynamy od długości na górze stosu i wykonujemy następujący kod, dopóki górny element nie jest równy 0.

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

     Spowoduje to wydrukowanie stosu bez jego odrzucania. Jeśli pętla się kończy, przeskakujemy w prawo na linii 5, przygotowując się do następnej pętli drukowania.

   • Przygotowanie prawej połowy

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

     To była jedna z najtrudniejszych części do dopasowania. Poniżej znajduje się wersja pozbawiona zawijania wszystkich kierunków, aby wskazać, co się stanie.

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

     Następnie przesuwamy długość tego, co ma zostać wydrukowane, i rozpoczynamy drugą pętlę drukującą (z początkowym duplikatem nie będącym częścią pętli).

   • Druga pętla drukująca (prawa połowa)

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

     Wykonywany kod jest całkowicie taki sam, jak w pierwszej pętli drukującej, a o}umieszczany jest nieco dalej, ponieważ były dostępne lokalizacje. Po zakończeniu mamy jeszcze kilka rzeczy do zrobienia, zanim będziemy mogli ponownie zweryfikować niezmiennik głównej pętli. Po wykonaniu ~on-line 9 owijamy się pionowo, kończąc na kolejnym fragmencie kodu.

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

     Najpierw aowydrukuje nowy wiersz. Następnie odbijamy się i docieramy do dokładnie tego samego miejsca po inicjalizacji, czyli przeskakiwania do X.

Brain-Flak , 486 + 1 = 489 bajtów

Wszystkiego najlepszego V od Brain-Flak!

Również dziękuję 0, którzy dostarczyli część kodu użytego w tej odpowiedzi

+1 ze względu na -cflagę, która jest wymagana dla wejść i wyjść ASCII

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

Wypróbuj online!

Jest to bez wątpienia najtrudniejsza rzecz, jaką kiedykolwiek zrobiłem w Brain-Flak.

Brain-Flak jest znany ze strasznego powielania i odwracania łańcuchów, a wyzwanie to składa się wyłącznie z powielania i odwracania łańcuchów.

Udało mi się zdobyć ten prawie działający fragment w niecałą godzinę ciężkiej pracy, ale dodanie kilku ostatnich miejsc okazało się jedną z najtrudniejszych rzeczy, jakie kiedykolwiek zrobiłem w Brain-Flak.

Wyjaśnienie

Podstawową ideą jest to, że najpierw utworzymy górę V, a każda iteracja usunie dwie postacie ze środka i doda spację na początku.

W praktyce staje się to dość trudne.

Istnieją istniejące algorytmy kopiowania i odwracania, więc użyłem jednego z tych, aby utworzyć odwróconą kopię kodu na offstacku. Kiedy to zrobię, kładę 2n-1spacje na oryginalnym stosie i przesuwam tor z powrotem na stos, aby utworzyć kanapkę.

Teraz mamy nasz górny rząd. Teraz chcemy usunąć dwie postacie od początku i dodać spację z przodu. To okazuje się najtrudniejsze. Powodem tego jest to, że musimy zasadniczo przechowywać dwie wartości, jedną dla głębokości bieżącego fragmentu i jedną dla głębokości do środka litery V, w której ma nastąpić usunięcie.

To jest trudne.

Z powodu całego powielania i odwracania, które mają miejsce na obu stosach, cały czas są w pełni wykorzystywane. Naprawdę nigdzie na tych stosach nie można niczego umieścić. Nawet przy całej Magii Trzeciego Stosu na świecie nie możesz uzyskać takiego dostępu, jakiego potrzebujesz, aby rozwiązać ten problem.

Jak to naprawić? Krótko mówiąc, tak naprawdę nie; na razie ignorujemy spacje i łatamy je później, dodamy zera do kodu, aby zaznaczyć, dokąd mają iść spacje, ale poza tym tak naprawdę nic nie zrobimy.

Tak więc na każdej iteracji tworzymy kopię ostatniej iteracji i umieszczamy ją na stosie. Używamy zapisanej głębokości, aby podzielić to na pół, więc mamy lewą połowę V na prawym stosie i prawą połowę V na lewym stosie. Usuwamy dwa elementy i łączymy je z powrotem. Dodajemy nowy wiersz dla lepszej miary i rozpoczynamy następną iterację. Za każdym razem, gdy głębokość do środka V zmniejsza się o jeden, a gdy osiągnie zero, zatrzymujemy pętlę.

Teraz mamy zbudowaną większość V. Brakuje nam jednak odpowiednich spacji, a nasze V jest obecnie nieco (czytaj: całkowicie) do góry nogami.

Więc odwracamy to. Aby przerzucić go na drugi stos, musimy przesuwać każdy element jeden po drugim. Podczas przenoszenia elementów sprawdzamy zer. Jeśli go napotkamy, musimy umieścić spacje w miejscu, do którego należą. Obcinamy zero i dodajemy kilka spacji. Skąd wiemy ile? Śledzimy; przerzucanie stosu w przeciwieństwie do powielania lub odwracania jest bardzo nie wymagającym zadaniem, więc faktycznie mamy pamięć do przechowywania i dostęp do dodatkowego licznika, aby śledzić, ile spacji dodać. Za każdym razem, gdy dodajemy spacje, zmniejszamy licznik o jeden. Licznik powinien trafić zero na ostatnim nowym wierszu (na górze litery V) i dlatego jesteśmy gotowi do drukowania.

Na koniec usuwamy kilka nierozstrzygniętych spraw i kończymy program w celu uzyskania niejawnego wyniku.

Galaretka , 15 12 bajtów

⁶ṁ⁸;;\Uz⁶ŒBY

Wypróbuj online!

Jak to działa

⁶ṁ⁸;;\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 bajtów

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

Wypróbuj online!

Python 2 , 65 bajtów

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

Wypróbuj online!

JavaScript (ES6), 108 106 98 94 bajtów

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 bajtów

Wszystkiego najlepszego z innego języka przetwarzania łańcuchów!

Liczba bajtów zakłada kodowanie ISO 8859-1.

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

;{*`.¶

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

Wypróbuj online!

Wyjaśnienie

$
$.`$* 

To dodaje nspacje (gdzie njest długością łańcucha), dopasowując koniec łańcucha, wyszukując długość łańcucha $.`i powtarzając spację, z którą wiele razy $*.

$
¶$`

Duplikujemy cały ciąg (oddzielony linią), ponownie dopasowując koniec łańcucha i wstawiając sam łańcuch $`.

O$^r`.\G

To odwraca drugą linię, dopasowując od prawej do lewej ( r), a następnie dopasowując jeden znak na raz ( .), ale upewniając się, że wszystkie są sąsiadujące ( \G). W ten sposób mecze nie mogą przekroczyć linii. Jest to następnie wykorzystywane na etapie sortowania. Używając trybu sortowania według ( $), ale zastępując każde dopasowanie pustym ciągiem, rzeczywiste sortowanie nie jest wykonywane. Ale z powodu tej ^opcji dopasowania są odwracane na końcu, odwracając całą drugą linię.

;{*`.¶

Ten etap dotyczy danych wyjściowych i wpływa również na resztę programu. {opakowuje pozostałe etapy w pętlę, która jest powtarzana, dopóki etapy nie zmienią łańcucha (co się stanie, ponieważ ostatni etap nie będzie już pasował). ;Wyjście wyłącza na końcu programu. Te *zakręty tym etapie na sucho, co oznacza, że scena jest przetwarzany, a wynik jest drukowany, ale potem poprzedni ciąg zostanie przywrócony.

Sam etap usuwa po prostu kanał i poprzedni znak. Co daje nam jeden wiersz pożądanego wyniku (zaczynając od pierwszego wiersza).

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

Wreszcie ten etap zamienia każdą linię w następną. Odbywa się to przez wstawienie spacji przed pierwszym znakiem spacji, usunięcie ostatniego znaku w pierwszym wierszu, a także pierwszego znaku w drugim wierszu. Proces ten kończy się, gdy w pierwszym wierszu pozostanie tylko jeden znak spacji, który odpowiada ostatniemu wierszowi wyniku.

05AB1E , 12 bajtów

Dgð×J.p€ûR.c

Wypróbuj online!

Wyjaśnienie

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

Lub dla tej samej liczby bajtów z drugiego kierunku.

Âsgú.sí€ûR.c

Wyjaśnienie

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

Japt życzy V wielu kolejnych udanych lat gry w golfa!

²¬£²îU²ç iYU)ê

Wymaga -Rflagi. Przetestuj online!

Wyjaśnienie

Korzysta z funkcji çi, îktóre dodałem kilka dni temu:

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

Technika Dennisa jest dłuższa o bajt:

U+Uç)å+ mw y mê

GNU sed , 110 100 + 1 (flaga r) = 101 bajtów

Edycja: 9 bajtów krótszych dzięki Riley

Jako kolejny język manipulacji ciągami, sed życzy V wszystkiego najlepszego!

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

Wypróbuj online!

Objaśnienie: zakładając, że dane wejściowe są ostatnim przypadkiem testowym („V!”). Dla jasności pokażę przestrzeń wzoru na każdym kroku, zastępując spacje literami „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 bajtów

Wypróbuj online!

Jestem pewien, że nie jest to optymalne, ale przynajmniej jest dość Pythoniczne:

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 bajtów

Jolf niechętnie życzy V wszystkiego najlepszego!

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

Wypróbuj tutaj! ␅powinno być 0x05.

Wyjaśnienie

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

Węgiel drzewny , 29 bajtów

Wszystkiego najlepszego V, z twojego rozczarowującego języka ASCII-art!

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

Wypróbuj online!

Wyjaśnienie

Nasza strategia: wydrukuj lewą połowę litery V, zaczynając od dołu i przechodząc do lewej górnej; następnie odzwierciedl to.

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

(Gdyby tylko węgiel drzewny miał przecinanie sznurka ... niestety, wygląda na to, że nie został jeszcze zaimplementowany).

Pip , 32 25 bajtów

a.:sX#aL#a{OaDQaPRVaaPUs}

Bierze ciąg wejściowy jako argument wiersza polecenia. Wypróbuj online!

Wyjaśnienie

                           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 z pakietem stringi, 225 bajtów

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

Jeśli uruchamiasz R w interaktywnym kodzie, po wklejeniu mojej odpowiedzi po prostu wpisz cokolwiek. Będziesz musiał zainstalować pakiet stringi R (mam nadzieję, że nie jest to niezgodne z regułami).

Wyjaśnienie:

Podstawowym pomysłem jest dodanie spacji do lewej strony, a następnie przycięcie jej na odpowiednią długość. Następnie wklej go z odwróconą wersją jako prawą stronę. Oto dłuższa, czytelna dla człowieka wersja funkcji:

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 bajtów

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

Mój proces polegał na usunięciu pierwszego znaku z prawej połowy każdej linii po odwróceniu pierwszej połowy. Lubię to:

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

Nie jestem przyzwyczajony do gry w golfa, więc daj mi znać, jeśli mogę coś zrobić, aby skrócić.

Partia, 186 185 bajtów

@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

Linie 1 i 6 mają spację końcową. Edycja: Zapisano 1 bajt dzięki @ ConorO'Brien.

Haskell , 76 bajtów

vjest główną funkcją, biorąc Stringargument i dając Stringwynik.

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

Wypróbuj online!

Uwagi:

• i jest początkowym argumentem / danymi wejściowymi.
• sjest początkowo iz length idołączonymi spacjami.
• v iwywołuje r s, a następnie dołącza do linii wynikowych.
• rzwraca listę Stringlinii.
• tjest sz odciętą ostatnią postacią.
• Rekurencja r ttworzy linie oprócz pierwszej, minus początkowa spacja na każdej linii.

Galaretka , 13 bajtów

⁶ṁ;@µḣJUz⁶ŒBY

Wypróbuj online!

W jaki sposób?

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

Rubinowy, 85 83 bajtów

edycja: usunięto nadmiar białych znaków

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

Naprawdę trudno mi było grać w golfa w Ruby. Po dodaniu spacji rozwija się do całkiem czytelnego fragmentu kodu:

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 bajtów

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

Gra w golfa po raz pierwszy. Wskazówki są mile widziane!

Wyjście programu:

Edytować:

Zaoszczędzono 40 bajtów dzięki Luisowi Mendo.

PHP, 95 92 85 80 78 77 bajtów

Uwaga: używa kodowania 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")

Uruchom tak:

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          

Wyjaśnienie

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.

Poprawki

• Zaoszczędzono 3 bajty, pozbywając się znaku padu ( str_paddomyślnie spacja, czego potrzebujemy)
• Zapisano 7 bajtów, używając operacji binarnych na łańcuchu, aby go obciąć zamiast substr
• Zaoszczędzono 5 bajtów, obracając ciąg znaków podczas drukowania do tyłu. Zapobiega konieczności drukowania backspace, ale powoduje końcowe spacje w każdej linii.
• Zaoszczędzono 2 bajty, wypełniając ciąg znaków bardziej skomplikowaną, ale krótszą metodą.
• Zapisano bajt ze względu na fakt, że nie ma potrzeby rozliczania ~"0"sprawy (ASCII 207), ponieważ można przyjąć, że wszystkie dane wejściowe można wydrukować jako ascii (Thx @Titus)

JavaScript (ES6), 169 157 bajtów

(-10 bajtów dzięki Conorowi O'Brienowi)

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

Rozwiązanie rekurencyjne. Jestem nowy w JavaScript, więc proszę, bądź delikatny! Wszelkie wskazówki dotyczące gry w golfa są bardzo mile widziane. :)

I, oczywiście, wszystkiego najlepszego z okazji urodzin V!

Test Snippet

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 bajtów

Wszystkiego najlepszego od twojego starego kumpla CJama!

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

Wypróbuj online!

Wyjaśnienie

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 bajtów 124 bajty

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

Nazwij to jednym parametrem, takim jak .\V.ps1 Hello.

Edycja: 2 bajty zapisane z końcówką z AdmBorkBork

Pyke , 14 bajtów

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

Wypróbuj online!

JavaScript (ES6), 94 bajty

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

Przypadki testowe

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 bajtów

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