Allunga la parola


50

L'input è una parola di lettere minuscole non separate da spazi bianchi. Una nuova riga alla fine è facoltativa.

La stessa parola deve essere emessa in una versione modificata: per ogni carattere, raddoppia la seconda volta che appare nella parola originale, triplica la terza volta ecc.

Esempio di input:

bonobo

Esempio di output:

bonoobbooo

Si applicano le regole I / O standard. Vince il codice più breve in byte.

Test forniti da @Neil:

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

Risposte:


36

Gelatina , 4 byte

;\f"

Provalo online!

Come funziona

;\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.

21
Bene, allora ... rip Pyth.
Adnan,

2
Questo sito sta diventando una competizione per il miglior linguaggio del golf per tutti gli usi ... non che sia una cosa negativa.
Shelvacu,

8
@shelvacu Quest'ultimo è discutibile, 2 amici ho mostrato a PPCG di aver detto qualcosa sulla falsariga di "tutte le risposte migliori usano solo i linguaggi del golf" come prima impressione.
Insane

@Insane c'è / ci sono. Il golf di codice è una cosa abbastanza comune. Quindi le lingue sono messe insieme per quello scopo, esclusivamente.
Evan Carslake,

Come funziona?
Erik the Outgolfer,

21

Pyth, 6 byte

Grazie a @Doorknob per il decollo di 1 byte.

Grazie a @Maltysen per il decollo di 5 byte.

s@VQ._

Provalo online!

Come funziona


Ad esempio, prendi la stringa "bonobo".

._ fa un elenco: ['b', 'bo', 'bon', 'bono', 'bonob', 'bonobo']

VQ._significa "la funzione precedente vettorializzata (applicata in parallelo) sopra Qe ._", il che significa che Q(l'input valutato) sarà trattato come un elenco:, ['b', 'o', 'n', 'o', 'b', 'o']e quindi saranno accoppiati in @questo modo:

     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'

Pertanto, @VQ._produrrà ['b', 'o', 'n', 'oo', 'bb', 'ooo'].

L' spoi li unisce tutti insieme, creando una stringa 'bonoobbooo', che viene poi implicitamente stampato per diventare bonoobbooo.


2
Kenny, la tua spiegazione è sbagliata. VQsignifica solo for N in Qquando non è all'interno di una funzione. In questo caso, ciò che sta realmente accadendo è che @Vsignifica la @funzione vettorializzata (applicata in parallelo) sui suoi due successivi argomenti Qe ._. Questo non è presente nei documenti, quindi lo risolverò.
isaacg,

14

Retina , 34 19 byte

Hai salvato 15 byte prendendo ispirazione dalla soluzione di isaacg.

Il conteggio dei byte presuppone la codifica ISO 8859-1.


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

Le righe vuote iniziali e finali sono significative.

Provalo online!

Spiegazione


$`¶

Questa è una fase di sostituzione che corrisponde alla regex vuota (cioè ogni posizione di larghezza zero nella stringa) e la sostituisce $`¶, dove $`è il prefisso della corrispondenza e inserisce un avanzamento di riga. Questo in pratica calcola tutti i prefissi e li mette su una riga separata insieme all'ultimo carattere di quel prefisso:

bb
obo
oboo
kbook
kbookk
ebookke
ebookkee
pbookkeep
ebookkeepe
rbookkeeper

Ci saranno alcuni avanzamenti di riga iniziali e finali, ma possiamo ignorarli.

Da ciascuno di questi prefissi vogliamo mantenere i caratteri uguali all'ultimo carattere. Per questo usiamo un altro stadio di sostituzione:

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

Questo corrisponde a tutto ciò che non vogliamo conservare e lo sostituisce con un nulla. Abbiniamo qualsiasi carattere (usando \Dpoiché sappiamo che non ci saranno cifre nell'input) e quindi assicuriamo che non ci sia un'altra copia di quel personaggio alla fine della riga.


11

Python, 56 byte

Mi sembra di essere bloccato con due risposte della stessa lunghezza:

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)

Modifica: vedi la risposta di @ pacholik per un approccio Python alternativo più breve.


Non sono abituato a picchiarti con le mie risposte <>, sto aspettando una risposta Gol> <> per risolverlo;)
Aaron

@Aaron Peccato, mi è stato effettivamente andando a battere di nuovo con> <>: P
SP3000

Disturbi di linea in Python? Che eresia !
gatto

Cosa fa - ~ fare? So che NON è seguito in modo bit a bit dalla negazione, ma cosa stai cercando di fare per risparmiare qualche byte?
Nic Hartley,

2
@QPaysTaxes È un incremento +1con precedenza abbastanza alta da non
rendere

10

Haskell, 39 byte

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

Esempio di utilizzo: f "bonobo"-> "bonoobbooo".

Abbastanza diverso dalla risposta di @Damien . Crea la stringa da destra estraendo tutte le occorrenze dell'ultimo carattere dalla stringa e anteponendo una chiamata ricorsiva con tutto tranne l'ultimo carattere.


9

> <> , 27 byte

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

Richiede l'interprete ufficiale che esce con un errore quando si tenta di stampare il punto di codice -1. Provalo online!

Il codice legge l'input di un carattere alla volta e utilizza la prima riga del codebox come un array di grandi dimensioni che memorizza il numero di volte in cui ogni carattere è stato visto finora (> <> inizializza le celle non di programma su 0). La seconda riga è un ciclo per l'output di un carattere più volte.

In alternativa, ecco una versione che esce in modo pulito (37 byte, non correttamente giocata a golf):

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

Accidenti, va bene! Dovrei smettere di fare così tanto affidamento sull'interprete online, non avrei mai pensato di usare semplicemente una casella di codice così grande, e non sapevo nemmeno che l'interprete ufficiale fosse uscito su -1 print
Aaron

2
@Aaron Sì, è un corollario di errori Python quando si tenta di farlo chr(-1). L'interprete animato è fantastico per le visualizzazioni, ma sfortunatamente alcune discrepanze con l'interprete ufficiale sono un po 'fastidiose: /
Sp3000

9

JavaScript (ES6), 48 45 byte

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

Modifica: salvato 3 byte grazie a @ user81655.


8

Haskell, 50 42 41 byte

Risparmiato 8 byte grazie a Lynn

f t=[c|(i,c)<-zip[1..]t,x<-take i t,c==x]

1
Che ne dici di:f t=[c|(i,c)<-zip[0..]t,j<-[0..i],c==t!!j]
Lynn

8

MATL , 8 byte

tt!=RsY"

Provalo online! Oppure verifica tutti i casi di test contemporaneamente .

Spiegazione

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

8

Labyrinth , 54 25 byte

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

Un altro collab con @ MartinBüttner, che effettivamente ha fatto la maggior parte quasi tutti i campi da golf per questo. Rinnovando l'algoritmo, siamo riusciti a ridurre un po 'le dimensioni del programma!

Provalo online!

Spiegazione

Un rapido primer Labrinth:

  • Labyrinth è un linguaggio 2D basato su stack. Ci sono due stack, uno principale e uno ausiliario, e spuntando da uno stack vuoto si ottiene zero.

  • Ad ogni incrocio, in cui vi sono più percorsi per spostare il puntatore dell'istruzione verso il basso, la parte superiore dello stack principale viene controllata per vedere dove andare dopo. Il negativo è girare a sinistra, zero è dritto e il positivo è girare a destra.

Le due pile di numeri interi di precisione arbitraria non offrono molta flessibilità in termini di opzioni di memoria. Per eseguire il conteggio, questo programma utilizza effettivamente le due pile come nastro, spostando un valore da una pila all'altra è simile allo spostamento di un puntatore di memoria a sinistra / destra di una cella. Non è esattamente lo stesso però, dato che dobbiamo trascinare un contatore di loop con noi sulla strada.

inserisci qui la descrizione dell'immagine

Prima di tutto, l'una <e >l'altra estremità pop un offset e ruotano la riga di codice che si allontana di uno a sinistra oa destra. Questo meccanismo viene utilizzato per far funzionare il codice in un ciclo: il< fa apparire uno zero e ruota la riga corrente a sinistra, mettendo l'IP alla destra del codice, e >fa apparire un altro zero e ripara la riga.

Ecco cosa succede ogni iterazione, in relazione al diagramma sopra:

[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

7

Perl, 17 anni

(Codice 16 byte, +1 per -p)

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

Uso:

perl -pe 's/./${$&}.=$&/ge' <<< 'bonobo'
bonoobbooo

7

Pyth, 7 byte

s@Led._

Suite di test

Test suite grazie a DenkerAffe

Spiegazione:

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.

6

Python 3, 52

def f(s):*s,x=s;return s and f(s)+x+x*s.count(x)or x

4
Ah, andare dalla fine ha molto più senso! Puoi farlo più corto in una lambda, senza la necessità specifica di Python 3:f=lambda s:s and f(s[:-1])+s[-1]*s.count(s[-1])
Sp3000

Pensavo che potesse essere fatto in quel modo. Ma non mi piace la sottoscrizione in Python: P
pacholik,

5

PowerShell v2 +, 52 47 byte

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

Costruisce una hashtable vuota, la memorizza in $b. Questo è il nostro "contatore" di quali lettere abbiamo visto. Quindi prendiamo l'input $args[0], lo lanciamo come char-array e lo inviamo attraverso un loop. Ad ogni iterazione, prendiamo il carattere corrente "$_"e lo moltiplichiamo per il contatore pre-incrementato per il valore dato, il che renderà la prima occorrenza moltiplicata per 1, la seconda per 2e così via. Lo incapsuliamo con un -joinquindi è tutta una parola in uscita.

5 byte salvati grazie a TessellatingHeckler utilizzando una tabella hash anziché una matrice, quindi non è stato necessario ridurre il carattere ASCII 97per raggiungere l'indice appropriato. Questo funziona perché il pre-incremento dell'indice hash chiama implicitamente .Add()in background se tale indice non esiste, poiché gli hashtable sono mutabili.

PS C:\Tools\Scripts\golfing> .\stretch-the-word.ps1 tessellatingheckler
tessseelllattingheeeckllleeeer

@TessellatingHeckler In effetti - grazie!
AdmBorkBork

5

Dyalog APL , 6 byte

∊,\∩¨⊢

TryAPL!

4 funzioni è una cima (2 treni) di una forcella (3 treni):

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

Primo (a destra - un no-op) sulla stringa data, dando'bonobo'

Quindi ,\(scansione di concatenazione) sulla stringa, dando'b' 'bo' 'bon' 'bono' 'bonob' 'bonobo'

I due sono biforcuta insieme (dato come destra e sinistra argomenti a) ∩¨(intersezione ciascuna), cioè ('b'∩'b') ('bo'∩'o') ('bon'∩'n') ('bono'∩'o') ('bonob'∩'b') ('bonobo'∩'o'), che è'b' 'o' 'n' 'oo' 'bb' 'ooo'

Infine, (enlist) viene applicato al risultato per appiattirlo, dando'bonoobbooo'

Ehi, almeno corrisponde a Pyth ! Ovviamente Jelly è più corta in quanto è una versione da golf di J, che a sua volta è un dialetto avanzato di APL a 2 caratteri per funzione.


4

Pyth, 11 byte

s.e*b/<Qhkb

Provalo qui!

Spiegazione

se * b / <Qhkb # Q = input

 .e # mappa sull'input con b come valore e k come indice (Q viene aggiunto alla fine in modo implicito)
      <Qhk # prende i primi k + 1 caratteri di Q
     / b # conta le occorrenze di b lì dentro
   * b # ripeti b tante volte
s # unisce l'elenco risultante in una stringa

4

J, 11 byte

#~+/@(={:)\

Questo è un verbo monadico. Provalo qui. Uso:

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

Spiegazione

#~+/@(={:)\
     (   )\  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.

4

05AB1E , 10 byte

Codice:

$vy«Dy¢y×?

Spiegazione:

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

Utilizza la codifica CP-1252 . Provalo online!


3

CJam, 14

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

Provalo online

Spiegazione:

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

2

Perl 6, 37 byte

{.split('').map({$_ x++%.{$_}}).join}

2

> <> , 52 byte

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

Impila tutte le lettere lette, le stampa ancora e ancora per ogni lettera simile nella pila.
Usa il &registro, perché dover gestire 3 variabili nello stack (lettera di lettura corrente, posizione nello stack, lettera in questa posizione) è una seccatura.

Puoi provarlo qui !


2

Ruggine, 176 byte

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

Questo utilizza una mappa per memorizzare una stringa per ogni carattere nell'input. Per ogni carattere, la stringa verrà rimossa dalla mappa, concatenata con il carattere, reinserita nella mappa e aggiunta all'output.

Mi sarebbe piaciuto usare get(...)invece di remove(...), ma il controllore del prestito mi ha fatto cambiare idea.


2

Mathcad, 66 byte

Sfortunatamente, Mathcad non ha una gestione delle stringhe particolarmente buona, quindi ho convertito la stringa di input in un vettore e quindi ho usato un vettore (indicizzato con codice carattere) per tenere traccia del numero di volte che si incontra un carattere, aggiungendo il carattere che numero di volte per un vettore risultato. Infine, il vettore del risultato viene riconvertito in una stringa. Abbastanza lunga purtroppo.

inserisci qui la descrizione dell'immagine

Nota che Mathcad utilizza un'interfaccia "lavagna" 2D, con un mix di testo e operatori normali; gli operatori vengono normalmente inseriti tramite una barra degli strumenti o una scorciatoia da tastiera; per esempio, ctl- # inserisce l'operatore for loop, che comprende la parola chiave per, l'elemento-simbolo e 3 "segnaposto" vuoti per la variabile di iterazione, l'intervallo e le espressioni del corpo rispettivamente. Digitazione [dopo che il nome di una variabile entra in modalità indice array, la digitazione "inserisce una coppia di parentesi abbinata ( principalmente ... ci sono eccezioni a seconda di cos'altro si trova nell'espressione circostante )


2

Javascript ES6 44 byte

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

vecchia risposta

Javascript ES6 46 byte

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

//thanks user81655 for -1 byte

1
È possibile salvare un byte spostandosi xsull'array di input ->q=>(x=[...q]).map(a=>x[a]=(x[a]||'')+a).join``
user81655

2

Julia, 38 35 byte

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

L'I / O si trova nelle matrici di caratteri. Provalo online!

Come funziona

Definiamo (ri) l'operatore monadico !per i nostri scopi.

Quando ! viene chiamato, controlla se il suo argomento s è vuoto. Se lo è, restituisce il suo argomento.

Se s non è vuoto, interseciamo s con il suo ultimo carattere ( s[end]), che produce tutte le occorrenze di quel carattere in s . Questo risultato è concatenato con il valore di ritorno di una chiamata ricorsiva a ! con s meno il suo ultimo carattere ( s[1:end-1]) come argomento.


2

PHP, 54 51 50 47 byte

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

Esegui in questo modo:

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

Ritocchi

  • Salvato 3 byte utilizzando variabili variabili. Modificate le variabili utilizzate in maiuscolo per evitare la collisione
  • Ho salvato un byte rimuovendo il tipo cast nullin intper lo scostamento della stringa, poiché lo scostamento della stringa viene comunque impostato su int
  • Salvato 3 byte utilizzando $argninvece di $argv(thx Titus)

Utilizzare $argncon -Rper salvare altri tre byte.
Tito,

Oh, e -ndovrebbe fare lo stesso del tuo -d error_reporting: nsta per no config file, e gli avvisi sono disattivati ​​nella configurazione predefinita; quindi -nr(rispettivamente -nR) dovrebbe essere sufficiente.
Tito,

@Titus 2 anni di risposta, ma comunque grazie :)
circa

1

Mathematica, 57 byte

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

Usiamo c[x]come una tabella di ricerca di quanto spesso il personaggio si xè già verificato. Questo viene incrementato ogni volta che viene recuperato x~StringRepeat~++c[x]. Sfortunatamente, per rendere riutilizzabile la funzione, è necessario reimpostare la tabella di ricerca ogni volta Clear@c;c@_=0;, il che è piuttosto costoso.


1

awk, 72 byte

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

L'idea è di memorizzare il conteggio del personaggio che appare in un array associativo e stampare il personaggio questo conteggio volte.


1

Beam, 32 33 42 byte

Questo avrebbe dovuto essere più piccolo, ma ho perso alcuni byte inizializzando gli slot di memoria su 0. Lo scambio di alcune direzioni del flusso è riuscito a eliminare molto spazio vuoto.

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

Provalo in questo frammento

Spiegazione generale.

  • Impostare tutti gli slot di memoria da 0-255 a 0
  • Leggere il valore ASCII di input nel raggio
  • Se il raggio è di 0 stop (raggio = negozio)
  • Ottieni il valore di memoria [beam] nell'archivio, incrementalo e salvalo indietro
  • Decrementa il negozio a 0 stampando il carattere trave
  • Ripetere

1

Python, 66 62 byte

Provalo qui

golfed

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
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.