Joyeux anniversaire V!

72

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 , 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 , 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. :)

DJMcMayhem
la source
Puis-je imprimer un seul caractère nul (0x00) après chaque nouvelle ligne?
Wheat Wizard
@ Wheatwizard Hmm. C'est un peu étrange, mais j'imagine que c'est bien tant que la sortie est visuellement la même.
DJMcMayhem
21
Le 5ème anniversaire sera autre chose! (En chiffres romains)
Albert Renshaw
5
Meilleurs voeux à la langue V par le Vee :-)
The Vee

Réponses:

44

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
Luis Mendo
la source
Approche très intéressante! +1
Seshoumara
3
@seshoumara Merci! Comme le dit flawr, la convolution est la clé du succès :-)
Luis Mendo
38

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.

DJMcMayhem
la source
J'y travaillais, mais je pense qu'il est plus approprié que vous répondiez!
nmjcman101
29

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!

ATaco
la source
23

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

Exemple de parcours de pêche

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

PidgeyUsedGust
la source
vous devriez probablement faire de la version golfée la version principale
Destructible Lemon
1
@DestructibleWatermelon, le post concerne davantage la version V, car il était beaucoup plus difficile de tout mouler dans une forme spécifique avec seulement un nombre limité d'octets disponibles. Une explication suivra donc pour la version V plutôt que pour la version standard. Je pourrais en faire un plus golfé plus tard.
PidgeyUsedGust
Ceci est de l'or juste de l'or
Christopher
J'apprécie que cette réponse soit dans une langue dont le nom est composé exclusivement de 'V' en rotation.
Sellyme
19

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.

Test 1

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.

Test 2

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.

Test 3

Assistant de blé
la source
Très impressionnant que vous avez réussi à le faire fonctionner du tout! Pensez-vous que vous pourriez économiser des octets en le laissant inversé et en ajoutant le -rdrapeau?
DJMcMayhem
@DJMcMayhem Je ne le pense pas. Le processus d’inversion et l’insertion d’espaces se déroulent en même temps. Par conséquent, si j’ajoutais le -rdrapeau, j’aurais besoin de l’inverser une autre fois. Il commence à être tard où je suis mais je pense que je vais essayer d’essayer de jouer au golf substantiellement demain. Si je peux résoudre le problème des espaces, je vais certainement utiliser le -rdrapeau.
Wheat Wizard
16

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.
Dennis
la source
Il est composé de 12 caractères, mais existe-t-il un encodage qui ne contiendrait que 12 octets?
kasperd
1
Oui, Jelly utilise sa propre page de code personnalisée .
Dennis
16

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>

Neil
la source
Seriez-vous capable de faire un post expliquant cela? Je suis un peu confus par le remplacement et les expressions régulières.
Jacob Persi
@ JacobPersi Ils sont un hareng rouge. Tout ce dont j'ai besoin est une zone de sortie de taille n*2par n*4(y compris les nouvelles lignes à la fin de chaque ligne). Je calcule ensuite le caractère qui doit apparaître dans chaque cellule.
Neil
Agréable! Vous pouvez supprimer un octet en supprimant la nouvelle ligne entre f=et s=>.
Yummypasta
@yummypasta The f=n'est qu'une partie de l'extrait de code, pas la réponse. En tant que tel, il n'est pas inclus dans le nombre d'octets.
Neil
11

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.

Martin Ender
la source
J'aimerais une explication de la façon dont cela fonctionne. Je sais que la syntaxe de sed est moins compacte, mais mon brouillon est deux fois plus long. Inverser la chaîne et assembler la première ligne de sortie en constitue l'essentiel.
Seshoumara
@seshoumara Bien sûr, voilà.
Martin Ender
Merci. Maintenant, je sais qu'un script sed double longueur n'est pas mauvais :)) en raison des s///caractères supplémentaires qui s'ajoutent, de l'inversion de chaîne plus longue et d'autres opérations dépourvues des subtilités de Retina. Bonne lecture. +1
seshoumara
9

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
Emigna
la source
2
Si vous indenter les commentaires progressivement, alors même la source ressemble à un V :)
aross
9

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ê
ETHproductions
la source
5

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)
seshoumara
la source
@Riley Réponse mise à jour, merci!
Seshoumara
4

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]
Hactar
la source
4

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
Conor O'Brien
la source
4

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!

SσF…·¹Lσ«Fι§σκMι←↖»Fσ«Pσ↖»‖O→

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.

Sσ                                    Input σ as string
                                       The bottom len(σ) half-rows:
   F…·¹Lσ«           »               For ι in inclusive range from 1 to length(σ):
            Fι                          For κ in range(ι):
               §σκ                         Print character of σ at index κ
                  Mι←                   Move cursor ι spaces leftward
                      ↖                  Move cursor one space up and left
                                       The top len(σ) half-rows:
                        Fσ«    »      For each character ι in σ:
                            Pσ          Print σ without moving the cursor
                               ↖         Move cursor one space up and left
                                 ‖O→  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.)

DLosc
la source
Bien que Charcoal n’ait pas de découpage de chaîne, il en CycleChopexistait un , qui peut être utilisé pour extraire la tête de la chaîne, économisant ainsi 4 octets. Cependant, il existe une meilleure approche qui économise 9 octets. Certaines économies supplémentaires qui, à mon avis, fonctionnaient également à l'époque: la valeur par Reflectdéfaut, le droit, sont reflétées, un octet supplémentaire est sauvegardé, et l'une des variables est prédéfinie à la première entrée, ce qui permet d'économiser deux octets.
Neil
4

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
DLosc
la source
4

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()
Atajti
la source
Bienvenue sur le site! :)
DJMcMayhem
4

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.

utilisateur3334690
la source
Bienvenue sur le site, c'est une bonne réponse! Malheureusement, je ne connais pas grand chose au rubis, je ne peux donc offrir aucun conseil. Vous pourrez peut-être trouver quelque chose sur cette page .
DJMcMayhem
Merci! Il y a beaucoup de choses intéressantes sur cette page mais il me semble que j'en fais déjà beaucoup. J'ai réalisé que je pouvais économiser quelques octets via les effets secondaires et l'ordre des opérations.
user3334690
1
Je suppose que [Ruby] est juste Ruby, le langage de programmation plus ou moins connu?
Rɪᴋᴇʀ
Vous pouvez économiser 8 octets en faisant un lambda .
Jordanie
4

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.

Neil
la source
1
Voici un moyen compliqué de sauvegarder un octet . (créez un alias pour @set et supprimez-le @echo off, insérez-le @si nécessaire.
Conor O'Brien
@ ConorO'Brien Merci, je n'aurais jamais deviné que 8 sets m'auraient épargné suffisamment d'octets pour que cela en vaille la peine.
Neil
3

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.
Ørjan Johansen
la source
2
+1 pour nommer la fonction principale v. : D
DJMcMayhem
1
@DJMcMayhem: ne pas nommer la fonction principale est un octet plus: unlines.r.((++)<*>(' '<$)).
nimi
1
@nimi Je suppose qu'il a aimé quel nom j'ai choisi. Techniquement, un lien lambda ... Lorsque j'ai écrit la réponse, je ne savais pas que vous pouviez utiliser des déclarations de niveau supérieur pour certaines fonctions, mais pas nommer la fonction principale. Bien que j'ai vu quelqu'un d'autre le faire, je le trouve un peu dérangeant. Ces jours-ci, cela fonctionne au moins dans GHCi.
Ørjan Johansen
3

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
Jonathan Allan
la source
Les mêmes esprits pensent bien. : P
Dennis
Oh mon dieu, je n'ai pas pensé à une concaténation cumulative! Le fusain a une direction en V, peut-être une enquête autour de ...
Jonathan Allan
3

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
Sculper
la source
1
Vous pourriez probablement économiser un peu en définissant à la longueur une variable comme je l'ai fait? Aussi, je pense que vous devriez envisager de faire la taille au lieu de la longueur?
user3334690
Faire ce que @ user3334690 a suggéré et déplacer la déclaration .times, 79 octets:s=ARGV[0];(s+=' '*s.size).size.times{|i|puts s+s[i..-2].reverse;s=' '+s[0..-2]}
Conor O'Brien
Vous pouvez économiser cinq octets en faisant un lambda .
Jordanie
3

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:

MATLAB Code Golf

Modifier:

Sauvegardé 40 octets grâce à Luis Mendo.

Grant Miller
la source
2
Bienvenue sur PPCG, et bonne première réponse! Malheureusement, je ne connais rien à MATLAB, je ne peux donc pas vous aider à
jouer au
1
La saisie d'une chaîne incluant ses guillemets est autorisée par défaut. Donc, vous pouvez retirer 's'de input. De plus, je ne vois pas pourquoi vous utilisez evalc(disp(...)), mais je pense que vous pouvez simplement utiliser cell2mat cette méthode
Luis Mendo
1
Aussi, flipest plus court que end:-1:1, voir ici
Luis Mendo
3

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)
aross
la source
echo$s,strrev($s=" $s"^$s^$s),~§;enregistre 5 octets.
Titus
@Titus, merci Habituellement, j'évite les espaces, mais OP a dit que c'était acceptable
aross
~$s[$i++]est suffisant (l'entrée est imprimable en ASCII, et ainsi de suite $s)
Titus
@Titus, merci, bonne prise. J'ai tendance à coder en toute sécurité
aross
2

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

R. Kap
la source
1
C'est très bien! Habituellement, s.split("")peut être changé en [...s], et a.join("")peut devenir a.joinsuivi d'une paire de backticks. Vous pouvez économiser 3 octets supplémentaires en remplaçant [r='repeat']et [r]par plain ol 'repeat, comme avec slice.
Conor O'Brien
@ ConorO'Brien Merci pour les conseils! Ils sont très appréciés. :)
R. Kap
2

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)
Chat d'affaires
la source
2

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

Tor
la source
1
A Essayez-le en ligne! lien, au cas où vous êtes intéressé.
Dennis
Oh, je ne connaissais pas ce petit outil, merci!
Tor
Salut! Un couple de petits golf sur le devant. Prenez l’entrée sous forme de chaîne et utilisez encapsulation pour transmettre la variable. Enregistre deux octets. $l=($s="$args")|% Le*;
AdmBorkBork
Wow, je ne connaissais pas ces 2 golfs, merci!
Tor
2

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

Arnauld
la source
2

J, 44 octets

(([(,}.@|.)@{."1-@i.@[|."0 1(,#&' ')~)~+:@#)
Mark Allen
la source
1
Hmm, je n'arrive pas à comprendre comment gérer cela en ligne. Essayez-le en ligne! Est-ce que je dis simplement que c'est faux? (Je suis un newb)
DJMcMayhem
@DJMcMayhem C'est une fonction, pas un programme. tio.run/nexus/…
Dennis
Golf: |."0 1à |."{(sauvegardé 2 octets)
Conor O'Brien
En outre, vous n'avez pas besoin d'avoir les parenthèses externes.
Conor O'Brien