Étirer le mot

50

L'entrée est un mot de lettres minuscules non séparées par des espaces. Une nouvelle ligne à la fin est facultative.

Le même mot doit être sorti dans une version modifiée: pour chaque caractère, doublez-le la deuxième fois qu'il apparaît dans le mot d'origine, triplez-le une troisième fois, etc.

Exemple d'entrée:

bonobo

Exemple de sortie:

bonoobbooo

Les règles d'E / S standard s'appliquent. Le code le plus court en octets gagne.

Tests fournis par @Neil:

tutu -> tuttuu
queue -> queuuee
bookkeeper -> boookkkeeepeeer
repetitive -> repeetittiiveee
uncopyrightables -> uncopyrightables
abracadabra -> abraacaaadaaaabbrraaaaa
mississippi -> misssiisssssssiiipppiiii
MIllIbyte
la source

Réponses:

36

Gelée , 4 octets

;\f"

Essayez-le en ligne!

Comment ça fonctionne

;\f"  Main link. Argument: S (string)

;\    Cumulatively reduce by concatenation.
      This yields the array of all prefixes of S.
  f"  Vectorized filter.
      Keep only occurrences of the nth letter in the nth prefix.
Dennis
la source
21
Eh bien alors ... déchire Pyth.
Adnan
2
Ce site est en train de devenir une compétition pour la meilleure langue de golf à usage général ... ce n’est pas une mauvaise chose.
Shelvacu
8
@shelvacu Ce dernier est discutable, deux amis à qui j'ai montré que PPCG avait dit quelque chose dans le sens de "toutes les meilleures réponses utilisent seulement les langues de golf" comme une première impression.
Insane
@Insane il y a / sont. Le code de golf est une chose assez commune. Les langues sont donc réunies exclusivement à cet effet.
Evan Carslake
Comment cela marche-t-il?
Erik l'Outgolfer
21

Pyth, 6 octets

Merci à @Doorknob d'avoir enlevé 1 octet.

Merci à @Maltysen d’avoir supprimé 5 octets.

s@VQ._

Essayez-le en ligne!

Comment ça fonctionne


Par exemple, prenez la chaîne "bonobo".

._ fait une liste: ['b', 'bo', 'bon', 'bono', 'bonob', 'bonobo']

VQ._signifie "la fonction précédente vectorisée (appliquée en parallèle) sur Qet ._", ce qui signifie Q(l'entrée évaluée) sera traitée comme une liste:, ['b', 'o', 'n', 'o', 'b', 'o']puis ils seront appariés par ce qui @suit:

     Q      ._         @ (intersect)
0:  'b'     'b'       'b'
1:  'o'     'bo'      'o'
2:  'n'     'bon'     'n'
3:  'o'     'bono'    'oo'
4:  'b'     'bonob'   'bb'
5:  'o'     'bonobo'  'ooo'

Par conséquent, @VQ._produira ['b', 'o', 'n', 'oo', 'bb', 'ooo'].

Le stout les réunit alors ensemble, créant une chaîne 'bonoobbooo', qui est ensuite implicitement imprimée pour devenir bonoobbooo.

Fuite, nonne
la source
2
Kenny, ton explication est fausse. VQsignifie seulement for N in Qquand ce n'est pas dans une fonction. Dans ce cas, ce qui se passe réellement est que cela @Vsignifie que la @fonction vectorisée (appliquée en parallèle) sur ses deux arguments suivants, Qet ._. Cela manque dans la documentation, alors je vais le réparer.
isaacg
14

Retina , 34 19 octets

Économisez 15 octets en vous inspirant de la solution isaacg.

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


$`¶
(\D)(?!.*\1¶)

Les lignes vides de début et de fin sont significatives.

Essayez-le en ligne!

Explication


$`¶

C'est une étape de remplacement qui correspond à l'expression rationnelle vide (c'est-à-dire chaque position de largeur nulle dans la chaîne) et la remplace $`¶, où $`est le préfixe de la correspondance et insère un saut de ligne. Cela calcule tous les préfixes et les place sur une ligne séparée avec le dernier caractère de ce préfixe:

bb
obo
oboo
kbook
kbookk
ebookke
ebookkee
pbookkeep
ebookkeepe
rbookkeeper

Il y aura des sauts de ligne en tête et en queue, mais nous pouvons les ignorer.

Pour chacun de ces préfixes, nous voulons conserver les caractères égaux au dernier caractère. Pour cela nous utilisons une autre étape de remplacement:

(\D)(?!.*\1¶)

Cela correspond à tout ce que nous ne voulons pas conserver et le remplace par un rien. Nous faisons correspondre tout caractère (en utilisant, \Dcar nous savons qu'il n'y aura pas de chiffres dans l'entrée), puis nous nous assurerons qu'il n'y a pas d' autre copie de ce caractère à la fin de la ligne.

Martin Ender
la source
11

Python, 56 octets

Il me semble que je suis coincé avec deux réponses de la même longueur:

f=lambda x,*y:x and-~y.count(x[0])*x[0]+f(x[1:],x[0],*y)
f=lambda x,y=0:x[y:]and-~x[:y].count(x[y])*x[y]+f(x,y+1)

Edit: Voir la réponse de @ pacholik pour une approche alternative plus courte en Python.

Sp3000
la source
Je ne suis pas habitué à te frapper avec mes réponses <>, j'attends une réponse de Gol> <> pour résoudre ce problème;)
Aaron
@ Aaron Dommage, je vais effectivement vous battre en arrière avec> <>: P
SP3000
Bruit de ligne en Python? Quelle hérésie !
chat le
Qu'est-ce que - ~ fait? Je sais que c'est bitwise PAS suivi par négation, mais qu'est-ce que vous essayez de faire pour que cela économise quelques octets?
Nic Hartley
2
@QPaysTaxes C'est une incrémentation +1assez prioritaire pour que les parens ne soient pas nécessaires
Sp3000 le
10

Haskell, 39 octets

f""=""
f x=f(init x)++filter(==last x)x

Exemple d'utilisation: f "bonobo"-> "bonoobbooo".

Assez différent de la réponse de @ Damien . Construit la chaîne à partir de la droite en extrayant toutes les occurrences du dernier caractère de la chaîne et en ajoutant un appel récursif à tous les caractères sauf le dernier.

nimi
la source
9

> <> , 27 octets

>i:0g1+:\
:{-1v!?:<}o
/p${/

Requiert l’interprète officiel qui se termine en essayant d’imprimer le point de code -1. Essayez-le en ligne!

Le code lit l'entrée d'un caractère à la fois et utilise la première ligne de la boîte de code comme un grand tableau qui stocke le nombre de fois que chaque caractère a été vu jusqu'à présent (> <> initialise les cellules non programmées à 0). La deuxième ligne est une boucle permettant de générer plusieurs fois un caractère.

Alternativement, voici une version qui sort proprement (37 octets, pas correctement joué au golf):

>i:0(?;:0g1+:\
}o:{-1v!?:   <
v  p${<
Sp3000
la source
Bon sang c'est bon! Je devrais arrêter de m'appuyer si lourdement sur l'interprète en ligne, je n'aurais jamais pensé à utiliser simplement une boîte de code d'une telle taille, et je ne savais même pas que l'interprète officiel était sorti sur -1 empreinte
Aaron
2
@ Aaron Ouais, c'est un corollaire de l'erreur de Python lorsque vous essayez de le faire chr(-1). L'interprète animé est excellent pour les visualisations, mais malheureusement, certaines divergences par rapport à l'interprète officiel sont un peu gênantes: /
Sp3000 le
9

JavaScript (ES6), 48 45 octets

s=>s.replace(n=/./g,c=>c.repeat(n[c]=-~n[c]))

Edit: 3 octets sauvegardés grâce à @ user81655.

Neil
la source
8

Haskell, 50 42 41 octets

Sauvegardé 8 octets grâce à Lynn

f t=[c|(i,c)<-zip[1..]t,x<-take i t,c==x]
Damien
la source
1
Que diriez-vous de:f t=[c|(i,c)<-zip[0..]t,j<-[0..i],c==t!!j]
Lynn
8

MATL , 8 octets

tt!=RsY"

Essayez-le en ligne! Ou vérifiez tous les cas de test à la fois .

Explication

t    % take input string implictly. Duplicate
t!   % duplicate and transpose into a column
=    % test for equality with broadcast. Gives an NxN array, where N is
     % input string length
R    % upper triangular part: set entries below the diagonal to 0
s    % sum of each column. For each postion in the input, gives how many
     % times that letter has appeared up to that position
Y"   % replicate elements (run-length decoding). Display implicitly
Luis Mendo
la source
8

Labyrinthe , 54 à 25 octets

<#; "#: ={},>
 }=}(.);("@

Un autre collab avec @ MartinBüttner, qui a effectivement fait plus la quasi - totalité du golf pour celui - ci. En réaménageant l'algorithme, nous avons réussi à réduire de beaucoup la taille du programme!

Essayez-le en ligne!

Explication

Un rapide apprêt de Labrinth:

  • Labyrinth est un langage 2D basé sur des piles. Il y a deux piles, une pile principale et une pile auxiliaire, et le décompression d'une pile vide donne zéro.

  • À chaque jonction, où il existe plusieurs chemins pour le pointeur d'instruction à déplacer vers le bas, le haut de la pile principale est vérifié pour voir où aller ensuite. Le négatif est à gauche, le zéro est droit et le positif à droite.

Les deux piles d'entiers de précision arbitraire ne sont pas très flexibles en termes d'options de mémoire. Pour effectuer le comptage, ce programme utilise en fait les deux piles en tant que bande, le déplacement d’une valeur d’une pile à l’autre revenant à déplacer un pointeur de mémoire vers la gauche ou la droite d’une cellule. Ce n’est pas tout à fait la même chose, car nous devons faire glisser un compteur de boucles avec nous vers le haut.

entrez la description de l'image ici

Tout d’abord, les boutons <et >à chaque extrémité créent un décalage et font pivoter la ligne de code qui est décalée d’un côté à l’autre. Ce mécanisme est utilisé pour que le code soit exécuté en boucle: le <zéro s'affiche et la ligne actuelle est pivotée à gauche, en plaçant l'adresse IP à droite du code, puis >un autre zéro et la ligne est corrigée.

Voici ce qui se passe à chaque itération, par rapport au diagramme ci-dessus:

[Section 1]
,}    Read char of input and shift to aux - the char will be used as a counter
      to determine how many elements to shift

[Section 2 - shift loop]
{     Shift counter from aux
"     No-op at a junction: turn left to [Section 3] if char was EOF (-1), otherwise
      turn right
(     Decrement counter; go forward to [Section 4] if zero, otherwise turn right
=     Swap tops of main and aux - we've pulled a value from aux and moved the
      decremented counter to aux, ready for the next loop iteration

[Section 3]
@     Terminate

[Section 4]
;     Pop the zeroed counter
)     Increment the top of the main stack, updating the count of the number of times
      we've seen the read char
:     Copy the count, to determine how many chars to output

[Section 5 - output loop]
#.    Output (number of elements on stack) as a char
(     Decrement the count of how many chars to output; go forward to [Section 6]
      if zero, otherwise turn right
"     No-op

[Section 6]
}     Shift the zeroed counter to aux

[Section 7a]
This section is meant to shift one element at a time from main to aux until the main
stack is empty, but the first iteration actually traverses the loop the wrong way!

Suppose the stack state is [... a b c | 0 d e ...].

=     Swap tops of main and aux               [... a b 0 | c d e ...]
}     Move top of main to aux                 [... a b | 0 c d e ...]
#;    Push stack depth and pop it (no-op)
=     Swap tops of main and aux               [... a 0 | b c d e ...]
      Top is 0 at a junction - can't move
      forwards so we bounce back
;     Pop the top 0                           [... a | b c d e ... ]

The net result is that we've shifted two chars from main to aux and popped the
extraneous zero. From here the loop is traversed anticlockwise as intended.

[Section 7b - unshift loop]

#     Push stack depth; if zero, move forward to the <, else turn left
}=    Move to aux and swap main and aux, thus moving the char below (stack depth)
      to aux
;     Pop the stack depth
Sp3000
la source
7

Perl, 17 ans

(Code de 16 octets, +1 pour -p)

s/./${$&}.=$&/ge

Usage:

perl -pe 's/./${$&}.=$&/ge' <<< 'bonobo'
bonoobbooo
Dom Hastings
la source
7

Pyth, 7 octets

s@Led._

Suite de tests

Suite de test grâce à DenkerAffe

Explication:

s@Led._
     ._    All prefixes, implicitly applied to the input.
 @L        Filter each prefix for characters equal to
   ed      the last character of the prefix
s          Concatenate and implicitly print.
isaacg
la source
6

Python 3, 52

def f(s):*s,x=s;return s and f(s)+x+x*s.count(x)or x
pacholik
la source
4
Ah, partir de la fin a tellement plus de sens! Vous pouvez le faire plus f=lambda s:s and f(s[:-1])+s[-1]*s.count(s[-1])
rapidement
Je pensais que cela pourrait être fait de cette façon. Mais je n'aime pas les souscriptions en Python: P
pacholik
5

PowerShell v2 +, 52 47 octets

$b=@{};-join([char[]]$args[0]|%{"$_"*++$b[$_]})

Construit une hashtable vide et la stocke $b. Ceci est notre "compteur" des lettres que nous avons vues. Nous prenons ensuite l’entrée $args[0], la convertissons en tableau de caractères et l’envoyons à travers une boucle. Chaque itération, nous prenons le caractère actuel "$_"et le multiplions par le compteur pré-incrémenté à la valeur donnée, ce qui fera que la première occurrence sera multipliée par 1, la seconde par 2et ainsi de suite. Nous encapsulons cela avec un -joinmot donc tout est en sortie.

5 octets sauvés grâce à TessellatingHeckler en utilisant une table de hachage au lieu d’un tableau, nous n’avions donc pas besoin de décrémenter le caractère ASCII 97pour atteindre l’index approprié. Cela fonctionne car la pré-incrémentation de l'index de hachage appelle implicitement .Add()en arrière-plan si cet index n'existe pas, car les hashtables sont mutables.

PS C:\Tools\Scripts\golfing> .\stretch-the-word.ps1 tessellatingheckler
tessseelllattingheeeckllleeeer
AdmBorkBork
la source
@TessellatingHeckler Effectivement - merci!
AdmBorkBork
5

Dyalog APL , 6 octets

∊,\∩¨⊢

TryAPL!

4 fonctions est un au sommet (2 trains) d'une fourche (3 trains):

┌──┴──┐  
∊ ┌───┼─┐
  \   ¨ ⊢
┌─┘ ┌─┘  
,   ∩    

Premier (à droite - non-op) sur la chaîne donnée, donnant'bonobo'

Puis ,\(scan de concaténation) sur la chaîne en donnant'b' 'bo' 'bon' 'bono' 'bonob' 'bonobo'

Les deux sont entrelacés avec (donnés comme arguments de droite et de gauche) ∩¨(intersection chaque), c’est ('b'∩'b') ('bo'∩'o') ('bon'∩'n') ('bono'∩'o') ('bonob'∩'b') ('bonobo'∩'o')-à- dire'b' 'o' 'n' 'oo' 'bb' 'ooo'

Enfin, (enlist) est appliqué au résultat pour l’aplatir, en donnant'bonoobbooo'

Hé, au moins ça correspond à Pyth ! De toute évidence, Jelly est plus courte car il s’agit d’une version golf de J, qui est à son tour un dialecte avancé de 2 caractères par fonction d’APL.

Adam
la source
4

Pyth, 11 octets

s.e*b/<Qhkb

Essayez-le ici!

Explication

se * b / <Qhkb # Q = entrée

 .e # mappe sur l'entrée avec b comme valeur et k comme index (Q est ajouté à la fin de manière non explicite)
      <Qhk # prend les k + 1 premiers caractères de Q
     / b # compte les occurrences de b dedans
   * b # répète b que plusieurs fois
s # joindre la liste résultante en une chaîne
Denker
la source
4

J, 11 octets

#~+/@(={:)\

C'est un verbe monadique. Essayez ici. Usage:

   f =: #~+/@(={:)\
   f 'tutu'
'tuttuu'

Explication

#~+/@(={:)\
     (   )\  For each non-empty prefix:
       {:      Take last element,
      =        compare for equality to the others and itself
  +/@          and take sum (number of matches).
#~           Replicate original elements wrt the resulting array.
Zgarb
la source
4

05AB1E , 10 octets

Code:

$vy«Dy¢y×?

Explication:

$           # Push the number 1 and input
 v          # Map over the input string
  y«        # Concat the letter to the previous string (initial 1)
    D       # Duplicate this string
     y¢     # Count the occurences of the current character in the string
       y×   # Multiply this number with the current character
         ?  # Pop and print without a newline

Utilise le codage CP-1252 . Essayez-le en ligne!

Adnan
la source
3

CJam, 14

q:A,{)A<_)--}/

Essayez-le en ligne

Explication:

q:A      read the input and store in A
,        get the string length
{…}/     for each number from 0 to length-1
  )      increment the number
  A<     get the prefix of A with that length
  _      duplicate it
  )      separate the last character
  -      remove it from the rest of the prefix
  -      remove all the remaining characters (different from the last one)
          from the prefix
Aditsu
la source
2

Perl 6, 37 octets

{.split('').map({$_ x++%.{$_}}).join}
Ven
la source
2

> <> , 52 octets

i:0(?;&l:?!v1-$:&:&=?\}70.>
6f+0.00o:&~/         \:o

Il empile chaque lettre lue, les imprime une fois de plus pour chaque lettre similaire de la pile.
Il utilise le &registre, car devoir gérer 3 variables sur la pile (lettre lue actuelle, position dans la pile, lettre à cette position) est une douleur.

Vous pouvez l'essayer ici !

Aaron
la source
2

Rouille, 176 octets

fn s(w:&str)->String{let mut m=std::collections::HashMap::new();w.chars().map(|c|{let mut s=m.remove(&c).unwrap_or(String::new());s.push(c);m.insert(c,s.clone());s}).collect()}

Cela utilise une carte pour stocker une chaîne pour chaque caractère de l'entrée. Pour chaque caractère, la chaîne sera supprimée de la carte, concaténée avec le caractère, insérée dans la carte et ajoutée à la sortie.

J'aurais aimé utiliser get(...)au lieu de remove(...), mais le vérificateur d'emprunt m'a fait changer d'avis.

ECS
la source
2

Mathcad, 66 octets

Malheureusement, Mathcad ne gère pas très bien les chaînes. J'ai donc converti la chaîne d'entrée en un vecteur, puis utilisé un vecteur (code de caractère indexé) pour suivre le nombre de fois qu'un caractère est rencontré, en ajoutant le caractère nombre de fois à un vecteur de résultat. Enfin, le vecteur de résultat est reconverti en chaîne. Assez long malheureusement.

entrez la description de l'image ici

Notez que Mathcad utilise une interface "tableau blanc" 2D, combinant du texte normal et des opérateurs; les opérateurs sont normalement entrés via une barre d’outils ou un raccourci clavier; par exemple, ctl- # entre l'opérateur de boucle for, qui comprend le mot clé for, l'élément-of symbol et 3 "espaces réservés" vides pour les expressions de variable d'itération, de plage et de corps, respectivement. Saisie [après que le nom de la variable passe en mode d’index de tableau, Saisie 'entre une paire de parenthèses correspondante (la plupart du temps ... il existe des exceptions qui dépendent de ce qui se trouve dans l’expression environnante )

Stuart Bruff
la source
2

Javascript ES6 44 octets

q=>q.replace(/./g,a=>x[a]=(x[a]||'')+a,x=[])

ancienne réponse

Javascript ES6 46 octets

q=>(x=[...q]).map(a=>x[a]=(x[a]||'')+a).join``

//thanks user81655 for -1 byte
Charlie Wynn
la source
1
Vous pouvez enregistrer un octet en vous déplaçant xdans le tableau d'entrée ->q=>(x=[...q]).map(a=>x[a]=(x[a]||'')+a).join``
user81655
2

Julia, 38 35 octets

!s=[]==s?s:[!s[1:end-1];ss[end]]

I / O est dans le début des tableaux de caractères. Essayez-le en ligne!

Comment ça fonctionne

On (re) définit l'opérateur monadique ! pour nos fins.

Lorsque ! est appelé, il vérifie si son argument s est vide. Si c'est le cas, il retourne son argument.

Si s n'est pas vide, nous intersectons s avec son dernier caractère ( s[end]), ce qui donne toutes les occurrences de ce caractère dans s . Ce résultat est concaténé avec la valeur de retour d'un appel récursif à ! avec s moins son dernier caractère ( s[1:end-1]) comme argument.

Dennis
la source
2

PHP, 54 51 50 47 octets

for(;$C=$argn[$X++];)echo str_repeat($C,++$$C);

Courez comme ça:

echo abracadabra | php -nR 'for(;$C=$argn[$X++];)echo str_repeat($C,++$$C); echo"\n";'

Tweaks

  • Sauvegardé 3 octets en utilisant des variables variables. Changement des variables utilisées en majuscules pour éviter les collisions
  • Enregistré un octet en supprimant le transtypage nulldansint de chaîne de décalage, en tant que chaîne de décalage est coulé à toute façon int
  • Sauvegardé 3 octets en utilisant à la $argnplace de $argv(merci Titus)
aross
la source
Utilisez $argnavec -Rpour enregistrer trois octets supplémentaires.
Titus
Oh, et -ndevrait faire la même chose que votre -d error_reporting: nsignifie no config file, et les avis sont désactivés dans la configuration par défaut; so -nr(respectivement -nR) devrait suffire.
Titus
@Titus 2 ans de réponse, mais merci quand même :)
aross
1

Mathematica, 57 octets

StringReplace[Clear@c;c@_=0;#,x_:>x~StringRepeat~++c[x]]&

Nous utilisons c[x]comme table de correspondance la fréquence à laquelle un personnage xs'est déjà produit. Ceci est incrémenté chaque fois qu'il est récupéré dans x~StringRepeat~++c[x]. Malheureusement, pour rendre la fonction réutilisable, nous devons réinitialiser la table de consultation à chaque fois Clear@c;c@_=0;, ce qui est assez coûteux.

Martin Ender
la source
1

awk, 72 octets

BEGIN{FS=""}{for(i=1;i<=NF;i++){a[$i]++;for(j=0;j<a[$i];j++)printf $i}}

L'idée est de stocker le nombre de caractères apparaissant dans un tableau associatif et d'imprimer le caractère multiplié par le nombre de caractères.

rexkogitans
la source
1

Poutre, 32 33 42 octets

Cela aurait dû être plus petit, mais j'ai perdu quelques octets lors de l'initialisation des emplacements de mémoire sur 0. L'échange de certaines directions de flux a permis d'éliminer beaucoup d'espace vide.

 >+\
vus/
>rnH
  >g'\
(@v's/
^`<

Essayez-le dans cet extrait

Explication générale

  • Définissez tous les emplacements de mémoire de 0 à 255 à 0
  • Lire la valeur d'entrée ascii dans le faisceau
  • Si le faisceau est à 0 arrêt (beam = store)
  • Récupère la valeur de mémoire [faisceau] dans le magasin, incrémente-la et sauvegarde-la
  • Décrémentez le magasin à 0 en imprimant le caractère de faisceau
  • Répéter
MickyT
la source
1

Python, 66 62 octets

Essayez-le ici

Golfé

def s(w,o=[],n=""):
 for x in w:o+=x;n+=x*o.count(x)
 return n

Ungolfed

def stretch(word):
    occurrences = []
    newWord = ""
    for w in word:
        occurrences.append(w)
        newWord += w * occurrences.count(w)
    return newWord
Argenis García
la source