Hold up ..... ce n'est pas la traîne.

Contexte

Ces jours-ci sur YouTube, les sections de commentaires sont jonchées de tels modèles:

S
St
Str
Stri
Strin
String
Strin
Stri
Str
St
S

où Stringest un simple espace réservé et fait référence à toute combinaison de caractères. Ces schémas sont généralement accompagnés d’un It took me a lot of time to make this, pls likeou de quelque chose, et souvent le PO réussit à accumuler un certain nombre de goûts.

La tâche

Bien que vous ayez le talent pour accumuler des votes positifs sur PPCG grâce à vos talents de golfeurs charmants, vous n’êtes certainement pas le premier choix pour faire des remarques spirituelles ou faire référence aux memes dans les sections de commentaires de YouTube. Ainsi, vos commentaires constructifs faits en pensant délibérément ne rapportent que peu ou pas de «j'aime» sur YouTube. Vous voulez que cela change. Vous avez donc recours aux schémas clichés susmentionnés pour atteindre votre ultime ambition, mais sans perdre de temps à essayer de les écrire manuellement.

En termes simples, votre tâche consiste à prendre une chaîne, disons s, et des 2*s.length - 1sous-chaînes de sortie de s, délimitées par une nouvelle ligne, de manière à respecter le modèle suivant:

(pour s= "Bonjour")

H
He
Hel
Hell
Hello
Hell
Hel
He
H

Contribution

Une seule corde s. Les valeurs par défaut de la communauté s’appliquent. Vous pouvez supposer que la chaîne d'entrée ne contiendra que des caractères ASCII imprimables.

Sortie

Plusieurs lignes séparées par une nouvelle ligne, constituant un motif approprié, comme expliqué ci-dessus. Les valeurs par défaut en sortie de la communauté s’appliquent. Les lignes vides de début et de fin (ne contenant ni caractères ni caractères ne pouvant être vus, comme un espace) dans la sortie sont autorisées.

Cas de test

Un cas de test multi-mots:

Input => "Oh yeah yeah"

Output =>

O
Oh
Oh 
Oh y
Oh ye
Oh yea
Oh yeah
Oh yeah 
Oh yeah y
Oh yeah ye
Oh yeah yea
Oh yeah yeah
Oh yeah yea
Oh yeah ye
Oh yeah y
Oh yeah 
Oh yeah
Oh yea
Oh ye
Oh y
Oh 
Oh
O

Notez qu'il existe des distorsions apparentes dans la forme de la sortie du cas de test ci-dessus (par exemple, la ligne deux et la ligne trois de la sortie semblent identiques). Ce sont parce que nous ne pouvons pas voir les espaces blancs de fuite. Votre programme n'a PAS besoin d'essayer de réparer ces distorsions.

Critère gagnant

C'est du code-golf , donc le code le plus court en octets dans chaque langue gagne!

brainfuck , 32 octets

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

Essayez-le en ligne!

La même boucle est utilisée pour les deux moitiés du motif.

Explication:

,             Take first input character as initial line
[             Until line to output is empty:
  [<]>        Move to beginning of line
  [.>]        Output all characters in line
  ++++++++++. Output newline
  ,           Input next character
  [>>]        Move two cells right if input character nonzero
  <[-]        Otherwise remove last character in line
  <           Move to new last character in line
]

JavaScript (ES6), 36 octets

f=([c,...r],s=`
`)=>c?s+f(r,s+c)+s:s

Essayez-le en ligne!

Commenté

f = (             // f is a recursive function taking:
                  //   the input string split into:
  [c,             //     c   = next character (may be undefined if we've reached the end)
      ...r],      //     r[] = array of remaining characters
  s = `\n`        //   the output string s, initialized to a linefeed
) =>              // 
  c ?             // if c is defined:
    s +           //   append s (top of the ASCII art)
    f(r, s + c) + //   append the result of a recursive call to f, using r[] and s + c
    s             //   append s again (bottom of the ASCII art)
  :               // else:
    s             //   append s just once (this is the final middle row) and stop recursion

05AB1E (ancien) ,  4  3 octets

^{Barré  4 n'est plus 4 :)}

η.∊

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

η     # Get the prefixes of the (implicit) input-string
 .∊   # Vertically mirror everything with the last line overlapping
      # (which implicitly joins by newlines in the legacy version of 05AB1E)
      # (and output the result implicitly)

Dans la nouvelle version de 05AB1E, et explicit »est requis après le η, c’est pourquoi j’utilise la version héritée de 05AB1E ici pour enregistrer un octet.

IBM PC DOS, assemblage 8088,  44  43

d1ee ad8b d6b4 0948 8af8 8ac8 d0e1 49b3 243a cf7d 024e
4e46 861c cd21 861c 52ba 2901 cd21 5ae2 eac3 0d0a 24

Non assemblé:

    SHR  SI, 1              ; point SI to DOS PSP at 80H (SI intialized at 100H)
    LODSW                   ; load arg length into AL, advance SI to 82H
    MOV  DX, SI             ; save start of string pointer
    MOV  AH, 9              ; DOS API display string function
    DEC  AX                 ; remove leading space from string length
    MOV  BH, AL             ; save string len in BH (AL gets mangled by INT 21H,9)
    MOV  CL, AL             ; set up loop counter in CL
    SHL  CL, 1              ; number of lines = 2 * string length - 1
    DEC  CX
    MOV  BL, '$'            ; end of string marker
LINE_LOOP:
    CMP  CL, BH             ; if CL >= string length, ascend
    JGE  ASCEND
    DEC  SI                 ; descend by backing up two places (always increments)
    DEC  SI                 ; (this is fewer bytes than 'SUB SI, 2' or two branches)
ASCEND:
    INC  SI                 ; increment current string position
    XCHG BL, [SI]           ; swap current string byte with end of string delimiter
    INT  21H                ; write substring to console
    XCHG BL, [SI]           ; restore string byte
    PUSH DX                 ; save output string pointer
    MOV  DX, OFFSET CRLF    ; load CRLF string
    INT  21H                ; write to console
    POP  DX                 ; restore output string pointer
    LOOP LINE_LOOP          ; move to next line
    RET
CRLF DB 0DH,0AH,'$'

Explication

Boucle 2 * input length - 1pour chaque ligne. La fonction d'affichage de chaîne de l'API DOS ( INT 21H,9) écrit une $chaîne -terminée à l'écran. Ainsi, à chaque boucle, le caractère situé après la dernière affichée est échangé avec le terminateur de fin de chaîne.

Le compteur de boucle est comparé à la longueur de la chaîne. Si elle est supérieure (ce qui correspond à la partie ascendante de la sortie), la position chaîne / échange est incrémentée, sinon elle est décrémentée (en fait, il -1-1+1s'agit d'octets moins qu'une structure de branchement if / else).

Programme exécutable autonome, prend la chaîne d'entrée à partir de la ligne de commande.

Sortie

Télécharger YT2.COM (43 bytes)

• -1 octet grâce à gastropner !

Python 2 , 60 52 octets

f=lambda s,n=1:s[n:]and[s[:n]]+f(s,n+1)+[s[:n]]or[s]

Essayez-le en ligne!

Python 3.8 (pré-version) , 50 octets

f=lambda s,n=1:s>(x:=s[:n])and[x,*f(s,n+1),x]or[s]

Essayez-le en ligne!

MATL , 8 octets

nZv"G@:)

Essayez-le en ligne!

S'il vous plaît, comme cet article pour le smiley :)dans le code, cela m'a pris beaucoup de temps pour faire.

n  % Length of the input string
Zv % Symmetric range ([1 2 ... n ... 1])
"  % For each k in above range
G  % Push input
@: % Push [1 2 ... k]
)  % Index

J , 11 octets

Fonction de préfixe tacite anonyme. Retourne une matrice de caractères complétée par des espaces.

[:(}:,|.)]\

Essayez-le en ligne!

]\ la liste des préfixes

[:(… ) Appliquer la fonction suivante à cette liste

 |. la liste inverse

 , préfixé avec

 }: la liste restreinte (sans dernier élément)

Perl 6 , 31 octets

{[\~](@_)[0...@_-1...0]}o*.comb

Essayez-le en ligne!

Bloc de code anonyme qui prend une chaîne et retourne une liste de lignes.

Explication:

{                      }o*.comb   # Pass the list of characters into the codeblock
 [\~](@_)                 # Triangular reduce by concatenation
                          # e.g. The list [1,2,3,4] turns into [1,12,123,1234]
         [0...@_-1        # Return the elements from 0 to length of string minus 1
                  ...0]   # And back down to 0

Japt -R , 4 octets

å+ ê

Cumulative réduire sur une chaîne.

-1 octet grâce à @Shaggy

Essayez-le en ligne!

Japt -R , 9 7 octets

-2 octets grâce à Shaggy

Êõ@¯XÃê

Essayez-le en ligne!

Perl 5 ( -p), 26 octets

s,.,$\=$`.$/.$\;"$`$&
",ge

TIO

Haskell, 52 50 44 octets

f x=unlines$init<>reverse$scanr(\_->init)x x

• -2 octets par une variante du tour de Ørjan Johansen
• -6 octets en profitant deinstance Semigroup b => Semigroup (a -> b)

Essayez-le en ligne!

R , 79 65 62 58 octets

write(substring(s<-scan(,""),1,c(1:(r=nchar(s)),r-1:r)),1)

Essayez-le en ligne!

-14 par la connaissance des fonctions supérieures de Giuseppe

-3 avec indexation plus propre

-4 grâce à Nick Kennedy et au déménagement de Giuseppe vers scanetwrite

Éviter les boucles (et substr) est bien.

Gelée , 5 à 4 octets

-1 octet grâce à @JonathanAllan !

¹ƤŒḄ

Essayez-le en ligne! Je pense que ceci est ma deuxième réponse de gelée? Je ne sais pas si c'est optimal. Je suis plus convaincu que c'est optimal. Retourne un tableau de lignes.

Explication

¹ƤŒḄ     input: "Hi!"
¹Ƥ       prefixes of the input: [["H"], ["H", "i"], ["H", "i", "!"]]
  ŒḄ     bounce, using each array: [["H"], ["H", "i"], ["H", "i", "!"], ["H", "i"], ["H"]]

Une autre approche, proposée par @JonathanAllan, consiste à ;\ŒḄréduire cumulativement ( \) la concaténation ( ;), ce qui constitue un autre moyen de générer des préfixes.

Python 3.8 (pré-version) , 48 octets

lambda s,r='':(l:=[r:=r+c for c in s])+l[-2::-1]

Essayez-le en ligne!

Utilise des expressions d’affectation avec :=pour accumuler une liste de préfixes , puis de nouveau pour sauvegarder le résultat afin de concaténer son inverse (sans le premier caractère).

Python 2 , 51 octets

f=lambda s,l=[]:s and f(s[:-1],[s]+l)or l+l[-2::-1]

Essayez-le en ligne!

Nous avons presque la bonne solution suivante de 45 octets, mais elle contient la chaîne d'origine deux fois et je ne vois pas de moyen court pour résoudre ce problème.

f=lambda s,l=[]:s and f(s[:-1],[s]+l+[s])or l

Essayez-le en ligne!

Charbon de bois , 5 octets

Ｇ^Ｌθθ

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Explication: Ｇdessine un polygone rempli, ^spécifie que les côtés sont en bas à droite et en bas à gauche (le polygone se ferme alors automatiquement), Ｌθspécifie la longueur de ces côtés comme étant la longueur de l'entrée d'origine et la fin θspécifie la chaîne de remplissage.

C # (compilateur interactif Visual C #) , 123 109 94 84 74 octets

Suppose que nous pouvons renvoyer un tableau de caractères (je crois que nous pouvons le faire, car un tableau de caractères est une représentation valide pour une chaîne et un tableau de chaînes est une représentation valide pour plusieurs lignes)

a=>new int[a.Length*2-1].Select((b,i)=>a.SkipLast(Math.Abs(a.Length-i-1)))

Essayez-le en ligne!

Attaché , 15 octets

Bounce@Prefixes

Essayez-le en ligne!

Assez simple. Bounces (ajoute l'inverse sans le centre) le Prefixesde l'entrée.

Alternativement, 21 octets: Bounce@{_[0..0:~-#_]} réimplémentation du préfixe.

Brachylog (v2), 6 octets

a₀ᶠ⊆.↔

Essayez-le en ligne!

Fonction de soumission, renvoyant un tableau de lignes. Librement basé sur @ réponse de Fatalize .

Explication

a₀ᶠ⊆.↔
    .↔  Find a palindrome
   ⊆      that contains, in order,
  ᶠ       all
a₀        prefixes of {the input}

L'ordre de départage est défini ici par le ⊆, qui, lorsqu'il est utilisé avec ce modèle d'écoulement, préfère la sortie la plus courte possible, lié au départ en plaçant les éléments donnés le plus tôt possible . Le résultat le plus court possible correspond à ce que nous voulons ici (car il n’est pas possible d’avoir des préfixes en double), et placer les éléments donnés (c’est-à-dire les préfixes) le plus tôt possible les placera dans la première moitié (arrondi) du sortie. Etant donné que nous exigeons également qu'ils soient placés dans le même ordre, nous obtenons exactement le modèle dont nous avons besoin même si la description que nous avons donnée à Brachylog est très générale. les égalités se passent exactement comme prévu, ce qui amène Brachylog à choisir le résultat souhaité plutôt qu’un autre résultat conforme à la description.

PowerShell, 89 ans 87 66 octets

-2 octets grâce à @AdmBorkBork

param($a)0..($d=$a.Length-1)|%{$b+=,-join$a[0..$_]};$b+$b[--$d..0]

Essayez-le en ligne!

En fait, cela n'a pas fonctionné comme spécifié auparavant, désolé pour ça! Je l'ai édité et j'ai également réussi à supprimer quelques octets.

PowerShell , 46 octets

($l=$args|% t*y|%{($s+=$_);++$i})+$l[$i..0]|gu

Essayez-le en ligne!

PowerShell , 42 octets (spécial YouTube, sale)

On sait que la longueur maximale d'un commentaire sur youtube est de 10 000 caractères. Ok, utilisez ceci comme limite supérieure.

($l=$args|% t*y|%{($s+=$_)})+$l[1e4..0]|gu

Essayez-le en ligne!

APL (Dyalog Unicode) , 9 octets ^{SBCS de}

Fonction de préfixe tacite anonyme. Renvoie la liste des chaînes.

(⊢,1↓⌽),\

Essayez-le en ligne!

,\ la liste des préfixes (lit, la concaténation cumulée)

(… ) Appliquez la fonction suivante à cette liste:

 ⌽ la liste inversée

 1↓ déposer le premier article

 , ajouter

 ⊢ la liste non modifiée

Ruby , 51 42 40 octets

f=->s,i=1{s[i]?[t=s[0,i],*f[s,i+1],t]:s}

Essayez-le en ligne!

Merci à Doorknob pour -2 octets.

JavaScript (Node.js) , 90 octets

Cela peut probablement être joué beaucoup plus, Arnauld a déjà une façon plus courte mais je me suis amusé au moins!

s=>{a=[];for(c=s.length-1;c--;)a[c]=s.slice(0,c+1);return[...a,s,...a.reverse()].join`\n`}

Essayez-le en ligne!

SNOBOL4 (CSNOBOL4) , 118 octets

	N =INPUT
	L =1
1	X =LT(X,SIZE(N)) X + 1	:F(D)
O	N ARB . OUTPUT POS(X)	:($L)
D	X =GT(X) X - 1	:F(END)
	L ='D'	:(O)
END

Essayez-le en ligne!

Il semble y avoir un bogue dans cette implémentation de SNOBOL; tenter de remplacer l'étiquette Dpar l'étiquette 2provoque une erreur, bien que le manuel de Vanilla SNOBOL indique que (non souligné dans l'original)

Si une étiquette est présente, elle doit commencer par le premier caractère de la ligne. Les étiquettes fournissent un nom à l'instruction et servent de cible pour le transfert du contrôle à partir du champ GOTO de toute instruction. Les étiquettes doivent commencer par une lettre ou un chiffre, éventuellement suivies d'une chaîne de caractères arbitraire.Le champ d'étiquette se termine par le caractère blanc, une tabulation ou un point-virgule. Si le premier caractère d'une ligne est vide ou tabulé, le champ d'étiquette est absent.

Ma supposition est que l'interpréteur CSNOBOL ne prend en charge qu'une seule étiquette commençant par un entier.

APL + WIN, 31 octets

Invites pour l'entrée de chaîne:

 ⊃((⍳n),1↓⌽⍳n)↑¨(¯1+2×n←⍴s)⍴⊂s←⎕

Explication:

(¯1+2×n←⍴s)⍴⊂s create a nested vector of the string of length =1+2x length of string

((⍳n),1↓⌽⍳n)↑¨ progressively select elements from each element of the nested vector 
              following the pattern 1  2 ...to n to n-1 ... 1

⊃ convert nested vector into a 2d array.

F # (.NET Core) , 67 à 61 octets

let l=s.Length
[1..l*2-1]|>Seq.map(fun i->s.[..l-abs(i-l)-1])

Essayez-le en ligne!

L'entrée est un stringet la sortie est unseq<string>

Une autre solution pourrait consister let f(s:string)=for i=1 to s.Length*2-1 do printfn"%s"s.[..s.Length-abs(i-s.Length)-1]en 80 octets ... Je ne suis pas sûr que cela vaille la peine d'être examiné.

sed , 31 35 octets

:x
h
s/.\n.*\|.$//
/^$/{x;q}
H
G
bx

Essayez-le en ligne!

Explication

Au début de chaque itération de la boucle, l'espace de modèle est une "partie centrale" de la sortie souhaitée, et chaque boucle ajoute une copie abrégée en haut et en bas.

:x                 
h                  Copy the current chunk to hold space
s/.\n.*\|.$//      Remove the last letter of the first line, and all other lines (if there are any)
/^$/{x;q}          If pattern space is empty we're done; output hold space
H                  Add the shortened line to the end of hold space
G                  and add the new hold space to pattern space.
bx                 

Python 2 , 131 100 84 octets

Ma première réponse sur Code Golf!

-47 octets au total grâce à @ SriotchilismO'Zaic

a,b=[],len(x)
for i in range(2*b-1):
 if i<b:a+=x[i]
 else:a=a[:-1]
 print''.join(a)

Essayez-le en ligne!

J , 12 octets

]\,[:}.@|.]\

Essayez-le en ligne!

Encore 1 octet de plus que celui d'Adam

K (oK) , 12 à 11 octets

-1 octet grâce à ngn

{x,1_|x}@,\

Essayez-le en ligne!