Mini-golf del lunedì: una serie di sfide da golf a codice corto , pubblicate (si spera!) Ogni lunedì.

Storia vera ¹ : l'altro giorno, stavo giocando sul mio tablet quando ho avuto l'idea di visitare la pagina che normalmente uso sul mio PC per testare JavaScript. Dopo aver caricato la pagina, ho inserito questo semplice programma:

alert("Hello!")

Ho quindi continuato a premere il pulsante Esegui e sono rimasto sorpreso quando mi ha detto che il codice che avevo inserito non era valido. Ho dato una seconda occhiata alla casella di testo e ho visto questo:

alllelelerlerlertlert("Heeelelellellelloello!")

Wha ??? Non è quello che ho inserito! Quindi cosa è successo qui? Per capirlo, ho inserito due semplici righe:

abcdefg
0123456

Questo si è rivelato come:

abbbcbcbcdbcdbcdebcdebcdefbcdefbcdefgbcdefg
0112123123412345123456

Ormai non avevo ancora idea di cosa fosse successo alle lettere, ma i numeri sembravano più semplici, quindi ho dato un'occhiata più da vicino. Come si è scoperto, la pagina web stava semplicemente inserendo il primo carattere, quindi ripetendo tutto il resto nella stringa ogni volta che ne veniva premuto uno nuovo:

0112123123412345123456
0
 1
  12
    123
       1234
           12345
                123456

Ma per quanto riguarda le sezioni di lettere? Dopo aver riflettuto per un minuto, mi sono reso conto che è lo stesso, ma invece di ripetere ogni sottosezione una volta, la ripete due volte :

abbbcbcbcdbcdbcdebcdebcdefbcdefbcdefgbcdefg
a
 bb
   bcbc
       bcdbcd
             bcdebcde
                     bcdefbcdef
                               bcdefgbcdefg

Una combinazione dei due funziona con una combinazione di queste tecniche:

abc123z
abbbcbcbc1bc12bc123bc123zbc123z
a
 bb
   bcbc
       bc1
          bc12
              bc123
                   bc123zbc123z

Qualunque glitch causi questo sembra reimpostare alla punteggiatura e agli spazi, così abc defdiventa abbbcbc deeefef.

A questo punto, ero così assorbito nel capirlo e trasformarlo in una sfida interessante che ho dimenticato perché ero stato lì in primo luogo. (Ho capito come digitare normalmente, tuttavia: premendo spazio-spazio dopo ogni personaggio. Piuttosto noioso, ma devi fare quello che devi fare.)

Sfida

L'obiettivo della sfida è scrivere un programma o una funzione che accetta il testo da elaborare, apporta le modifiche sopra elencate e restituisce / restituisce il risultato.

Dettagli

• L'input conterrà solo ASCII stampabile e nessuna scheda o nuova riga.

Casi test

Ingressi: (uno per riga)

Mess up text
This is some longer text.
CAPS LOCK && "Punc-tua"+'tion'
under_score_style
CaPs wItHIn loWERs
1337 numb3r5
abcdefghij 0123456789
Code-golf is the best!

Uscite:

Meeesesessess upp teeexexextext
Thhhihihishis iss sooomomomeome looononongongongeongeongeronger teeexexextext.
CAAAPAPAPSAPS LOOOCOCOCKOCK && "Puuunununcunc-tuuuaua"+'tiiioioionion'
unnndndndendendernder_scccococorcorcorecore_stttytytyltyltyletyle
CaaaPaPaPsaPs wIIItItItHItHItHIItHIItHInItHIn loooWoWoWEoWEoWERoWERoWERsoWERs
1333337 nuuumumumbumbumb3umb3rumb3rumb3r5
abbbcbcbcdbcdbcdebcdebcdefbcdefbcdefgbcdefgbcdefghbcdefghbcdefghibcdefghibcdefghijbcdefghij 0112123123412345123456123456712345678123456789
Cooodododeode-gooolololfolf iss thhhehe beeesesestest!

punteggio

Questo è code-golf , quindi vince il codice valido più breve in byte. Tiebreaker va all'invio che ha raggiunto per primo il numero di byte finale. Il vincitore verrà scelto lunedì prossimo, 2 novembre. Buona fortuna!

Modifica: E il vincitore è ... @ MartinBüttner usando Retina per un'incredibile soluzione a 43 byte !

_{¹ Sì, questa storia è completamente vera e se hai bisogno di ulteriori chiarimenti, vedi la nota 1.}

Retina , 43 byte

.(?<=[^_\W]([^_\W]+))(?<=(\1)(?<=\D))?
$1$2

Esegui il codice da un singolo file con il -sflag. Poiché questa è solo una singola sostituzione regex, puoi testarla qui (fai clic sulla scheda Contesto per vedere i risultati).

Spiegazione

Questo corrisponde a qualsiasi cifra e lettera che non è la prima di una corsa. Mentre .può abbinare qualsiasi personaggio senza linefeed, i lookbehinds garantiscono le altre condizioni:

(?<=[^_\W]([^_\W]+))

Questo corrisponde all'indietro dalla posizione dopo il .. In primo luogo che corrisponda a uno o più caratteri alfanumerici e li cattura in gruppo 1con ([^_\W]+). Ciò garantisce immediatamente che .corrisponda a un carattere alfanumerico stesso. Quindi l'aggiunta si [^_\W]assicura che ci sia un altro carattere alfanumerico nella corsa corrente, che non includiamo la corrispondenza. Ora group 1è ciò con cui vogliamo sostituire la corrispondenza se è una cifra - se è una lettera vogliamo sostituirla con il doppio di questa stringa. È qui che entra in gioco il secondo lookbehind:

(?<=(\1)(?<=\D))?

Questo è facoltativo, quindi se fallisce non influenzerà affatto la partita. In primo luogo garantisce che non. fosse una cifra tramite - quindi questo aspetto è rilevante solo quando stiamo abbinando le lettere. In tal caso, abbiniamo di nuovo il gruppo (questo corrisponde sempre, perché abbiamo catturato il gruppo dalla stessa posizione), ma lo catturiamo nel gruppo .(?<=\D)\12

Quindi, sostituiamo semplicemente la regex con il contenuto di entrambi i gruppi ( $1$2). Se la corrispondenza era una cifra, $2sarà comunque vuota e riscriveremo il prefisso una sola volta. Se era una lettera, $2è la stessa di $1e la riscriviamo due volte.

JavaScript (ES6) 82

Utilizzando l'ottimizzazione regexp suggerita da Mwr247

s=>s.replace(/([\W_])|./g,(x,y)=>y?(f=0,x):f?(p+=x,p+(-x-1?z:p)):(p=z,f=x),f=z='')

Prova a eseguire lo snippet di seguito in qualsiasi browser recente

F=s=>s.replace(/([\W_])|./g,(x,y)=>y?(f=0,x):f?(p+=x,p+(-x-1?z:p)):(p=z,f=x),f=z='')

// document.write(F(prompt('Insert string')))

// TEST
console.log=x=>O.innerHTML+=x+'\n'

function test()
{
  O.innerHTML=F(I.value)
}

;[
 ['Mess up text','Meeesesessess upp teeexexextext']
,['This is some longer text.',
  'Thhhihihishis iss sooomomomeome looononongongongeongeongeronger teeexexextext.']
,['CAPS LOCK && "Punc-tua"+\'tion\'',
  'CAAAPAPAPSAPS LOOOCOCOCKOCK && "Puuunununcunc-tuuuaua"+\'tiiioioionion\'']
,['CaPs wItHIn loWERs'
  ,'CaaaPaPaPsaPs wIIItItItHItHItHIItHIItHInItHIn loooWoWoWEoWEoWERoWERoWERsoWERs']
,['1337 numb3r5','1333337 nuuumumumbumbumb3umb3rumb3rumb3r5']
,['abcdefghij 0123456789'
 ,'abbbcbcbcdbcdbcdebcdebcdefbcdefbcdefgbcdefgbcdefghbcdefghbcdefghibcdefghibcdefghijbcdefghij 0112123123412345123456123456712345678123456789']
,['Code-golf is the best!'
  ,'Cooodododeode-gooolololfolf iss thhhehe beeesesestest!']
].forEach(t => (
  i=t[0],x=t[1],r=F(i),
  console.log('Test ' + (r==x?'OK':'Fail')+'\nInput:  '+i+'\nResult: '+r+'\nCheck:  '+x+'\n')
))

#I { width: 50% }

Your test<input id=I><button onclick="test()">-></button>
<pre id=O></pre>

JavaScript (ES6), 92 88 87

f=>f.replace(/[^_\W]+/g,m=>m[0]+[...m].slice(1).reduce((a,e)=>a+=(y+=e,++e?y:y+y),y=''))

Non ho idea di come giocare a golf ...

Grazie a Mwir247 per il regex down golf e le produzioni ETH per il golf a un byte in funzione ridotta .

Haskell, 215 200 byte

import Data.List
import Data.Char
c=concatMap
p c=[isDigit c,isAlpha c]
r(Just n)=c id.replicate(n+1)
r _=id
f(h:t)=h:(c(\s->r(findIndex id.p$last s)s).tail.inits)t
m=c f.groupBy(\a b->or$p a==or$p b)

È un casino.

Divertiti a leggere tutte le strane stranezze, non avrei mai pensato di usarlo idcosì tanto.

Peccato che la roba che fa già metà del lavoro qui ha bisogno di essere importato ( isDigit, isAlpha, inits).

Gema, 57 personaggi

\X?=?@set{s;}
<D1>=@append{s;$0}$s
<L1>=@append{s;$0}$s$s

Esecuzione di esempio:

bash-4.3$ gema '\X?=?@set{s;};<D1>=@append{s;$0}$s;<L1>=@append{s;$0}$s$s' <<< '1337 numb3r5'
1333337 nuuumumumbumbumb3umb3rumb3rumb3r5

Haskell, 183 181 byte

import Data.Char
b(x:y)|h x=x:c[]y|2>1=x:b y
b[]=[]
h y=isDigit y||isAlpha y
c x l@(y:z)|h y=c(y:x)z|2>1=c x[]++b l
c x[]=reverse$g$x
g[]=[]
g a@(x:y)|isDigit x=a++g y|2>1=a++a++g y

Uso:

b"Hello, world!"
>"Heeelelellellelloello, wooorororlorlorldorld!"

Non so se è sostanzialmente diverso con la risposta di Leif Willerts. Ma ecco l'algoritmo.

1. Cerca lettera valida (Letter o Num)
2. Se segna lettera, inizia a raccogliere lettere. Tuttavia, viene memorizzato in modo inverso, invertire la stringa. E il primo articolo è stato omesso.
3. Quando ha colpito una lettera non valida, fai la trasformazione della domanda con input invertito. La trasformazione della domanda è reverse.g.reverse, ma poiché è già invertita, facciamo semplicemente reverse.g

Mantengo in qualche modo parentesi ridondanti.

T-SQL, 357 byte

create proc x(@s varchar(99),@z int=0,@i int=0,@y varchar(99)='',@x varchar(99)='',@w varchar(99)='') as

while LEN(@s)>0
begin
    select @z=patindex('%[^0-z]%',@s+' '),@i=1,@w+=LEFT(@s,1)
    while @i<@z-1
    begin
        select @y=SUBSTRING(@s,2,@i)
        ,@x+=@y            
        ,@i+=1
        if @y like'%[a-z]'set @x+=@y
    end
select @w+=@x+SUBSTRING(@s,@z,1)
        ,@x=''
        ,@s=REPLACE(@s,left(@s,@z),'')
end

select @w

es: exec x(@s='1337 numb3r5') ritorna1333337 nuuumumumbumbumb3umb3rumb3rumb3r5

Python 2, 131 byte

i=raw_input();s=r='';g=1
for c in i:
 s+=c
 if g:r+=c;g=0;s=''
 elif c.isalpha():r+=s*2
 elif '/'<c<':':r+=s
 else:g=1;r+=c
print r

Scorre i personaggi e salva / si ripete se necessario.

Pip, 41 byte

aR`[^_\W]+`{Y0a@0.Ya@{1,++y}X2-(_Q+_)MJa}

Prende il testo come argomento della riga di comando. Usiamo una sostituzione regex per sostituire tutte le esecuzioni alfanumeriche ( [^_\W]+) con una funzione di callback. Questa funzione associa un'altra funzione a ciascun carattere della parola, generando sequenze di caratteri progressivamente più grandi (con la variabile globale che ytiene traccia dell'indice) e ripetendole X2 se il carattere non è un numero. (La logica per la quale si usa +per convertire in un numero e poi Qper verificare se questo è stringa uguale al carattere originale.) Questo processo, tuttavia, elimina il primo carattere, quindi dobbiamo aggiungerlo in seguito ( a@0.).

Python 3 , 86 byte

f=0
m=''
for i in input():g=i.isalnum();m=m*g*f+i*f;print(end=m*-~i.isalpha()or i);f=g

Provalo online!