Mini-golfe de segunda-feira: Uma série de desafios curtos de golfe com código , publicados (espero!) Toda segunda-feira.

História verdadeira ¹ : Outro dia, eu estava brincando no meu tablet quando tive a ideia de visitar a página que normalmente uso no meu PC para testar o JavaScript. Depois que a página foi carregada, entrei neste programa simples:

alert("Hello!")

Passei a pressionar o botão Executar e fiquei surpreso ao me dizer que o código que eu havia inserido era inválido. Dei uma segunda olhada na caixa de texto e vi o seguinte:

alllelelerlerlertlert("Heeelelellellelloello!")

Wha??? Não foi isso que eu entrei! Então o que aconteceu aqui? Para descobrir, digitei duas linhas simples:

abcdefg
0123456

Isso acabou como:

abbbcbcbcdbcdbcdebcdebcdefbcdefbcdefgbcdefg
0112123123412345123456

Até agora, eu ainda não tinha idéia do que aconteceu com as letras, mas os números pareciam mais simples, então olhei mais de perto. Como se viu, a página da Web estava simplesmente inserindo o primeiro caractere e repetindo todo o resto da string toda vez que um novo era pressionado:

0112123123412345123456
0
 1
  12
    123
       1234
           12345
                123456

Mas e as seções de letras? Depois de refletir por um minuto, percebi que é a mesma coisa, mas em vez de repetir cada subseção uma vez, ela repete duas vezes :

abbbcbcbcdbcdbcdebcdebcdefbcdefbcdefgbcdefg
a
 bb
   bcbc
       bcdbcd
             bcdebcde
                     bcdefbcdef
                               bcdefgbcdefg

Uma combinação dos dois funciona com uma combinação dessas técnicas:

abc123z
abbbcbcbc1bc12bc123bc123zbc123z
a
 bb
   bcbc
       bc1
          bc12
              bc123
                   bc123zbc123z

Qualquer falha que causa isso parece redefinir a pontuação e os espaços, assim abc defse torna abbbcbc deeefef.

A essa altura, eu estava tão absorto em descobrir e transformá-lo em um desafio interessante que esqueci por que eu estava lá em primeiro lugar. (Contudo, eu descobri como digitar normalmente: pressionar espaço-atrás após cada caractere. Bastante entediante, mas você precisa fazer o que precisa.)

Desafio

O objetivo do desafio é escrever um programa ou função que inclua o texto a ser processado, faça as alterações listadas acima e produza / retorne o resultado.

Detalhes

• A entrada conterá apenas ASCII imprimível e nenhuma guia ou nova linha.

Casos de teste

Entradas: (uma por linha)

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!

Saídas:

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!

Pontuação

Este é o code-golf , pelo que o código válido mais curto em bytes vence. O desempatador vai para o envio que atingiu sua contagem final de bytes primeiro. O vencedor será escolhido na próxima segunda-feira, 2 de novembro. Boa sorte!

Edit: E o vencedor é ... @ MartinBüttner usando Retina para uma incrível solução de 43 bytes !

_{¹ Sim, essa história é completamente verdadeira e, se você precisar de mais esclarecimentos, consulte a nota de rodapé 1.}

Retina , 43 bytes

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

Execute o código de um único arquivo com o -ssinalizador. Como essa é apenas uma substituição de regex única, você pode testá-la aqui (clique na guia Contexto para ver os resultados).

Explicação

Isso corresponde a qualquer dígito e letra que não seja o primeiro de uma execução. Embora .possa corresponder a qualquer caractere que não seja de avanço de linha, os visores garantem as outras condições:

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

Isso corresponde ao contrário da posição após o .. Primeiro ele corresponde a um ou mais caracteres alfanuméricos e os captura em grupo 1com ([^_\W]+). Isso garante imediatamente que o valor .corresponde a um caracter alfanumérico. O adicional [^_\W]garante que haja mais um caracter alfanumérico na execução atual, que não inclui a correspondência. Agora grupo 1é o que queremos substituir a correspondência se for um dígito - se for uma letra, queremos substituí-lo com o dobro dessa string. É aí que o segundo olhar entra em cena:

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

Este é opcional, portanto, se falhar, não afetará a partida. Primeiro, ele garante que não. havia um dígito via - portanto, isso só é relevante quando estamos correspondendo letras. Nesse caso, correspondemos ao grupo mais uma vez (isso sempre corresponde, porque capturamos o grupo da mesma posição), mas capturamos no grupo .(?<=\D)\12

Portanto, simplesmente substituímos a regex pelo conteúdo de ambos os grupos ( $1$2). Se a correspondência foi um dígito, $2ainda estará vazia e nós escrevemos o prefixo apenas uma vez. Se era uma carta, $2é a mesma que $1e escrevemos de volta duas vezes.

JavaScript (ES6) 82

Usando a otimização regexp sugerida por 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='')

Teste a execução do snippet abaixo em qualquer navegador 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=''))

Eu não tenho idéia de como jogar isso para baixo ...

Obrigado Mwir247 pelo regex reduzido e ETHproductions pelo golfe de um byte na função de redução .

Haskell, 215 200 bytes

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)

É uma bagunça.

Divirta-se lendo todas as peculiaridades estranhas, eu nunca pensei que usaria idtanto.

Pena que o material que já faz metade do trabalho aqui precisa ser importado ( isDigit, isAlpha, inits).

Gema, 57 caracteres

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

Exemplo de execução:

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 bytes

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!"

Não sei se é essencialmente diferente com a resposta de Leif Willerts. Mas aqui está o algoritmo.

1. Procure por letras válidas (Letter ou Num)
2. Se carta, comece a coletar carta. No entanto, ele é armazenado inversamente, faça com que a string seja revertida. E o primeiro item é omitido.
3. Quando encontrar uma letra inválida, faça a transformação da pergunta com entrada invertida. A transformação da pergunta é reverse.g.reverse, mas, como já está revertida, fazemos apenas reverse.g.

De alguma forma, mantenho colchetes redundantes.

T-SQL, 357 bytes

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

ex: exec x(@s='1337 numb3r5') retorna1333337 nuuumumumbumbumb3umb3rumb3rumb3r5

Python 2, 131 bytes

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

Faz um loop entre os caracteres e salva / repete, se necessário.

Pip, 41 bytes

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

Leva o texto como um argumento da linha de comando. Usamos uma substituição de regex para substituir todas as execuções alfanuméricas ( [^_\W]+) por uma função de retorno de chamada. Essa função mapeia outra função para cada caractere da palavra, gerando execuções cada vez maiores de caracteres (com a variável global yacompanhando o índice) e repetindo-as X2 se o caractere não for um número. (A lógica pela qual +se converte em um número e depois Qverifica se é igual a um caractere original.) Esse processo deixa de fora o primeiro caractere; portanto, precisamos adicioná-lo posteriormente ( a@0.).

Python 3 , 86 bytes

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

Experimente online!