Merci à @KritixiLithos de m'aider à relever ce défi!

V est un langage de programmation que j'ai écrit pour pouvoir utiliser et étendre vim aux défis du code-golf. Le tout premier engagement a eu lieu le 3 mars 2016, ce qui signifie qu'aujourd'hui V a un an! Woo-hoo

Au cours de la première année d'existence de V, 176 commits ont été envoyés par quatre contributeurs différents, 140 réponses de 12 utilisateurs différents et trop d'opérateurs en double dupliqués pour être pris en compte . Il dispose d'un interprète en ligne , hébergé généreusement par @Dennis, qui a été exécuté près de 8 000 fois depuis décembre .

Ayons un défi pour célébrer l'anniversaire de V! Étant donné que la plupart des fonctionnalités de V sont conçues dans l’esprit de la manipulation des cordes et de l’art ascii , il semble naturel que tout défi qui célèbre V soit lié à l’art ascii. Votre défi pour aujourd'hui est donc de prendre un mot en entrée et de le remodeler sous la forme d'un V. Par exemple, l'entrée "Hello" devrait donner le V suivant:

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

Voici quelques détails sur ce à quoi votre V devrait ressembler. Si la chaîne en entrée est longue de n caractères, le V doit avoir une n*2hauteur de ligne. La toute première ligne devrait comprendre:

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

À chaque nouvelle ligne, un espace est ajouté au début et les deux côtés de la chaîne se rapprochent, éliminant ainsi les caractères qui se chevauchent. Jusqu'à la toute dernière ligne, qui n'est que le premier caractère de l'entrée. Les espaces de fin sur chaque ligne sont acceptables, et les sauts de fin sont également autorisés.

Vous pouvez supposer que l'entrée sera toujours un fichier ASCII imprimable sans espace, et vous pouvez utiliser des entrées et des sorties de n'importe quelle méthode raisonnable. Voici d'autres exemples d'entrées:

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

~:

~ ~
 ~

Bien entendu, puisqu'il s'agit de code-golf , les échappatoires standard sont interdites et votre objectif est d'écrire le programme le plus court possible pour mener à bien cette tâche. Bon golf!

Pour ce que cela vaut, j’ai un faible pour les réponses vim, donc des points bonus imaginaires pour utiliser vim ou V, bien que toutes les langues soient acceptables. :)

MATL , 21 14 octets

MATL souhaite à V un joyeux anniversaire!

tnEXyY+c3MZvZ)

Essayez-le en ligne!

Explication

Considérez l'entrée

'Hello'

de longueur n=5. Le code calcule la convolution 2D de cette chaîne avec la matrice d’identité de taille 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]

Le résultat de la convolution, converti en caractère et avec caractère 0 affiché comme espace, est

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

Ensuite, les colonnes [1, 2, ..., 2*n-1, 2*n, 2*n-1, ..., 2, 1]sont sélectionnées dans cette matrice de caractères, produisant le résultat souhaité:

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

Code commenté

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 octets

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

Essayez-le en ligne!

Beaucoup plus court maintenant que V a un opérateur «inversé» .

Pas si impressionnant par rapport aux autres langues de golf qui ont répondu, mais cela devait être fait. Hexdump:

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

Explication:

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

À ce stade, le tampon ressemble à ceci:

Happy         yppaH

Non, nous construirons le triangle de manière récursive.

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

Voici où je peux montrer l'une de mes fonctionnalités préférées de V. De nombreuses commandes nécessitent un argument. Par exemple, la >commande indentera un nombre variable de lignes en fonction de l'argument:

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

mais la plupart des commandes seront forcées de se terminer par un argument par défaut (généralement la ligne courante) s'il est à la fin du programme et non spécifié. Par exemple, ce que V exécute réellement pour notre boucle récursive est:

òâÙHãêxx>>ò

La seconde òest implicitement complétée. La chose intéressante est que les commandes terminées implicitement appliquent plusieurs couches de profondeur. Ainsi, même si nous n’avons écrit qu’auparavant >, V donnera implicitement _son argument et indente la ligne courante.

Brainfuck , 152 octets

C’est une occasion si mémorable que j’ai décidé de démêler l’ancien interprète de BF et de lui donner un nouveau souffle.

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

Avec des commentaires

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

Essayez-le en ligne!

> <> , 221 octets

J'ai passé beaucoup trop de temps là-dessus. Joyeux anniversaire, 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

Vous pouvez l’ essayer en ligne , mais c’est beaucoup plus amusant d’avoir cet interprète et de le lancer avec le --playdrapeau

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

ce qui résulte dans l'animation ci-dessous.

Exemple

(cela prend un peu moins de deux minutes)

Explication

Parce que la partie intéressante de cette réponse l’emballe dans la Vforme, voici une explication qui s’y conforme. Nous utilisons la version suivante numérotée par ligne pour référence.

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

Parfois, les flèches (→ ←) sont utilisées pour indiquer la direction dans laquelle un extrait de code est atteint.

1. Initialisation

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

   La première ligne va pousser 2n à [0,1], laisser n sur la pile et ajouter un espace. Ensuite, nous montons et nous retournons à la deuxième ligne à droite, où nous allons commencer à gauche. Il y a une boucle pour ajouter n + 1 espaces. Cela fonctionne comme suit.

                   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.
   

   Une fois cette opération terminée, elle rebondit sur la ligne 3. Les deux éléments de pile les plus élevés (0 et un espace) sont supprimés ( ~~) et nous passons à la Xposition at [10,1] ( a1.), en continuant vers la droite. Nous arrivons à la /ligne 7 et commençons la boucle du programme principal.

2. Boucle principale ( 2n fois)

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

   C'est la condition de boucle. Au début, la pile est inversée pour l'impression. Ensuite, nous obtenons le compteur de [1,0] ( 01g) et stockons une version décrémentée ( :1-01p). En se retournant et en se soulevant à droite, nous rencontrons la condition pour terminer le programme. Si nous ne terminons pas, nous passons à la première boucle d'impression.

   • Première boucle d'impression (moitié gauche)

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

     Nous commençons avec la longueur en haut de la pile et exécutons le code suivant tant que l'élément top n'est pas 0.

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

     Ceci imprimera la pile sans la jeter. Si la boucle se termine, nous sautons à droite sur la ligne 5 pour nous préparer à la prochaine boucle d'impression.

   • Préparation de la moitié droite

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

     C'était l'une des parties les plus difficiles à installer. Vous trouverez ci-dessous une version dépourvue de toutes directions pour indiquer ce qui se passe.

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

     Nous repoussons ensuite la longueur de ce qui doit être imprimé et lançons la deuxième boucle d'impression (avec un duplicata initial ne faisant pas partie de la boucle).

   • Deuxième boucle d'impression (moitié droite)

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

     Le code en cours d’exécution est complètement identique à celui de la première boucle d’impression, mais il o}est placé un peu plus loin car il y avait des emplacements disponibles. Une fois l’opération terminée, nous avons quelques tâches à accomplir avant de pouvoir vérifier à nouveau l’invariant de la boucle principale. Une fois que la ~ligne 9 est exécutée, nous nous enroulons verticalement pour aboutir au code suivant.

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

     D'abord aoimprimera une nouvelle ligne. Ensuite, nous rebondissons et arrivons exactement au même endroit après l’initialisation, à savoir sauter vers le X.

Brain-Flak , 486 + 1 = 489 octets

Joyeux anniversaire V de Brain-Flak!

Merci également à 0 ' qui a fourni une partie du code utilisé dans cette réponse

+1 en raison du -cdrapeau requis pour les entrées et sorties ASCII

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

Essayez-le en ligne!

C'est sans aucun doute la chose la plus difficile que j'ai jamais faite dans Brain-Flak.

Brain-Flak est notoirement redoutable en matière de duplication et d'inversion de chaînes, et ce défi consiste uniquement en une duplication et une inversion de chaînes.

J'ai réussi à obtenir cet extrait presque opérationnel en un peu moins d'une heure de travail acharné, mais l'ajout des derniers espaces s'est avéré être l'une des choses les plus difficiles que j'ai jamais réalisées dans Brain-Flak.

Explication

L'idée de base est que nous allons créer le haut du V en premier et chaque itération supprime deux caractères du milieu et ajoute un espace au début.

En pratique, cela devient assez difficile.

Des algorithmes existants existent pour la copie et l’inverse, j’ai donc utilisé l’un de ceux-ci pour créer une copie inversée du code hors pile. Une fois que cela est fait, je mets des 2n-1espaces au-dessus de la pile d'origine et je replace le désempilé sur l'empilage pour créer un sandwich.

Nous avons maintenant notre première ligne. Maintenant, nous voulons supprimer deux caractères du début et ajouter un espace au début. Cela s'avère être la partie la plus difficile. La raison en est que nous devons essentiellement stocker deux valeurs, une pour la profondeur de l’extrait de code actuel et une pour la profondeur au centre du V où la suppression doit avoir lieu.

C'est dur.

En raison de la duplication et du renversement qui se produisent sur les deux piles, elles sont pleinement utilisées tout le temps. Il n'y a vraiment nulle part sur ces piles pour mettre quoi que ce soit. Même avec toute la troisième pile magique du monde, vous ne pouvez pas obtenir le type d'accès dont vous avez besoin pour résoudre ce problème.

Alors, comment pouvons-nous résoudre ce problème? En bref, nous ne faisons pas vraiment; nous ignorons les espaces pour le moment et les corrigeons plus tard, nous ajouterons des zéros au code pour marquer l'endroit où les espaces sont censés aller, mais à part cela, nous ne ferons rien.

Donc, à chaque itération, nous faisons une copie de la dernière itération et la plaçons sur la pile distante. Nous utilisons la profondeur que nous avons stockée pour diviser cela en deux, nous avons donc la moitié gauche du V sur la pile de droite et la moitié droite du V sur la pile de gauche. Nous retirons deux éléments et les corrigeons ensemble. Nous ajoutons une nouvelle ligne pour faire bonne mesure et commençons la prochaine itération. Chaque fois que la profondeur au centre du V diminue de un et quand elle atteint zéro, nous arrêtons la boucle.

Nous avons maintenant construit le gros du V Cependant, nous manquons d’espaces appropriés et notre V est actuellement un peu (lire: complètement) à l’envers.

Alors on le retourne. Pour le retourner sur l'autre pile, nous devons déplacer chaque élément un par un. Comme nous déplaçons des éléments, nous vérifions les zéros. Si nous en rencontrons un, nous devons replacer les espaces là où ils appartiennent. Nous jetons le zéro et ajoutons un tas d'espaces. Comment savons-nous combien? Nous suivons renverser une pile contrairement à la duplication ou l'inversion est une tâche très peu intensive, nous avons donc la mémoire pour stocker et accéder à un compteur supplémentaire pour garder une trace du nombre d'espaces à ajouter. Chaque fois que nous ajoutons des espaces, nous décrémentons le compteur de un. Le compteur devrait atteindre zéro à la dernière nouvelle ligne (le haut du V) et nous sommes donc prêts à imprimer.

Enfin, nous nettoyons quelques éléments et terminons le programme pour obtenir une sortie implicite.

Gelée , 15 à 12 octets

⁶ṁ⁸;;\Uz⁶ŒBY

Essayez-le en ligne!

Comment ça fonctionne

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

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

Essayez-le en ligne!

Python 2 , 65 octets

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

Essayez-le en ligne!

JavaScript (ES6), 108 106 98 94 octets

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 octets

Joyeux anniversaire d'un autre langage de traitement des cordes!

Le nombre d'octets suppose un codage ISO 8859-1.

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

;{*`.¶

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

Essayez-le en ligne!

Explication

$
$.`$* 

Cela ajoute des nespaces (où nest la longueur de la chaîne), en faisant correspondre la fin de la chaîne, en récupérant la longueur de la chaîne $.`et en répétant un espace plusieurs fois avec $*.

$
¶$`

Nous dupliquons la chaîne entière (séparée par un saut de ligne), en faisant correspondre à nouveau la fin de la chaîne et en insérant la chaîne elle-même avec $`.

O$^r`.\G

Cela inverse la deuxième ligne en faisant correspondre la droite à la gauche ( r), puis en faisant correspondre un caractère à la fois ( .), mais en s'assurant qu'ils sont tous adjacents ( \G). De cette façon, les matchs ne peuvent pas dépasser le saut de ligne. Ceci est ensuite utilisé dans une étape de tri. En utilisant le mode de tri ( $) mais en remplaçant chaque correspondance par une chaîne vide, aucun tri n'est effectué. Mais en raison de cette ^option, les matchs sont inversés à la fin, ce qui annule toute la deuxième ligne.

;{*`.¶

Cette étape est pour la sortie et affecte également le reste du programme. {encapsule les étapes restantes dans une boucle qui est répétée jusqu'à ce que ces étapes ne puissent pas changer la chaîne (ce qui se produira car la dernière étape ne correspondra plus). Le ;désactive la sortie à la fin du programme. Les *tours de cette étape dans un fonctionnement à sec ce qui signifie que l'étape est traitée et le résultat est imprimé, mais après la chaîne précédente est rétablie.

La scène elle-même supprime simplement un saut de ligne et le caractère précédent. Ce qui nous donne une ligne de la sortie souhaitée (en commençant par la première ligne).

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

Enfin, cette étape transforme chaque ligne dans la suivante. Cela se fait en insérant un espace devant le premier caractère non espace, en supprimant le dernier caractère de la première ligne, ainsi que le premier caractère de la deuxième ligne. Ce processus s'arrête une fois qu'il ne reste plus qu'un seul caractère non-espace sur la première ligne, ce qui correspond à la dernière ligne de la sortie.

05AB1E , 12 octets

Dgð×J.p€ûR.c

Essayez-le en ligne!

Explication

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

Ou pour le même nombre d'octets de l'autre sens.

Âsgú.sí€ûR.c

Explication

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

Japt souhaite à V encore beaucoup d'années de golf réussies!

²¬£²îU²ç iYU)ê

Nécessite le -Rdrapeau. Testez-le en ligne!

Explication

Cela utilise les fonctions çet que îj’ai ajoutées il ya quelques jours:

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

La technique de Dennis est un octet plus long:

U+Uç)å+ mw y mê

GNU sed , 110 100 + 1 (drapeau r) = 101 octets

Edit: 9 octets plus court grâce à Riley

Comme autre langage de manipulation de chaîne, sed souhaits V le meilleur!

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

Essayez-le en ligne!

Explication: en supposant que l'entrée est le dernier cas de test ('V!'). Je vais montrer l'espace du motif à chaque étape pour plus de clarté, en remplaçant les espaces par des '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 octets

Essayez-le en ligne!

Je suis sûr que ce n'est pas optimal, mais au moins c'est joli 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 octets

Jolf souhaite à contrecœur à V un joyeux anniversaire!

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

Essayez-le ici! ␅devrait être 0x05.

Explication

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

Charbon de bois , 29 octets

Joyeux anniversaire V, de la part de votre collègue, le langage d'art ASCII, qui est décevant depuis si longtemps pour ce défi!

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

Essayez-le en ligne!

Explication

Notre stratégie: imprimer la moitié gauche du V, en partant du bas vers le haut à gauche; alors réfléchissez-le.

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

(Si seulement Charcoal avait découpé les cordes ... hélas, il semblerait que cela n'ait pas encore été mis en œuvre.)

Pip , 32 25 octets

a.:sX#aL#a{OaDQaPRVaaPUs}

Prend la chaîne d'entrée en tant qu'argument de ligne de commande. Essayez-le en ligne!

Explication

                           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 avec package stringi, 225 octets

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

Si vous exécutez R en code interactif, après avoir collé ma réponse, saisissez n'importe quoi. Vous aurez besoin du paquet stringi R pour être installé (j'espère que ce n'est pas contre les règles).

Explication:

L'idée de base est d'ajouter des espaces sur le côté gauche, puis de le couper à la bonne longueur. Après cela, collez-le avec sa version inversée comme partie droite. Voici une version plus longue, lisible par l'homme, de la fonction:

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 octets

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

Mon processus consistait à supprimer le premier caractère de la moitié droite de chaque ligne après avoir inversé la première moitié. Comme ça:

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

Je ne suis pas habitué à essayer de jouer au golf, alors laissez-moi savoir si je peux faire quelque chose pour le raccourcir.

Lot, 186 185 octets

@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

Les lignes 1 et 6 ont un espace de fuite. Edit: 1 octet enregistré grâce à @ ConorO'Brien.

Haskell , 76 octets

vest la fonction principale, prenant un Stringargument et donnant un Stringrésultat.

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

Essayez-le en ligne!

Remarques:

• i est l'argument / entrée initial.
• sest initialement iavec des length iespaces ajoutés.
• v iappelle r s, puis rejoint les lignes de résultat.
• rrenvoie une liste de Stringlignes.
• test savec le dernier caractère coupé.
• La récursion r tproduit les lignes sauf la première, moins l'espace initial sur chaque ligne.

Gelée , 13 octets

⁶ṁ;@µḣJUz⁶ŒBY

Essayez-le en ligne!

Comment?

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

edit: suppression des espaces blancs en excès

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

En fait, j'ai trouvé assez difficile de jouer au golf celui-ci en Ruby. Après avoir ajouté des espaces, il se développe en un extrait de code lisible:

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 octets

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

Première fois le golf de code. Les pourboires sont les bienvenus!

Sortie du programme:

Modifier:

Sauvegardé 40 octets grâce à Luis Mendo.

PHP, 95 92 85 80 78 77 octets

Remarque: utilise l'encodage 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")

Courez comme ça:

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          

Explication

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

• Sauvegardé 3 octets en supprimant le caractère pad (par str_paddéfaut, espace, ce dont nous avons besoin)
• 7 octets enregistrés en utilisant des opérations binaires sur la chaîne pour la tronquer au lieu de substr
• Sauvegardé 5 octets en faisant pivoter la chaîne lors de l’inverse. Empêche d'imprimer un retour arrière, mais crée un espace de fin sur chaque ligne.
• Enregistré 2 octets en chaîne de remplissage en utilisant une méthode plus compliquée, mais plus courte.
• Enregistrement d'un octet car il n'est pas nécessaire de comptabiliser le ~"0"cas (ASCII 207), toutes les entrées pouvant être supposées être imprimables en ascii (Thx @Titus)

JavaScript (ES6), 169 157 octets

(-10 octets grâce à 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

Une solution récursive. Je suis nouveau sur JavaScript, alors soyez gentil! Tous les conseils de golf sont grandement appréciés. :)

Et bien sûr, un très bon anniversaire à vous 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 octets

Joyeux anniversaire de ton vieux copain CJam!

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

Essayez-le en ligne!

Explication

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

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

Appelez-le avec un seul paramètre, tel que .\V.ps1 Hello.

Edit: 2 octets enregistrés avec astuce de AdmBorkBork

Pyke , 14 octets

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

Essayez-le en ligne!

JavaScript (ES6), 94 octets

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

Cas de test

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 octets

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