Mini golf de lunes: una serie de desafíos de código corto de golf , publicados (¡con suerte!) Todos los lunes.

Historia real ¹ : El otro día, estaba jugando en mi tableta cuando tuve la idea de visitar la página que normalmente uso en mi PC para probar JavaScript. Después de cargar la página, ingresé a este sencillo programa:

alert("Hello!")

Luego procedí a presionar el botón Ejecutar, y me sorprendió cuando me dijo que el código que había ingresado no era válido. Eché un segundo vistazo al cuadro de texto y vi esto:

alllelelerlerlertlert("Heeelelellellelloello!")

Que ??? Eso no es lo que entré! Entonces, ¿qué pasó aquí? Para resolverlo, ingresé dos líneas simples:

abcdefg
0123456

Esto resultó como:

abbbcbcbcdbcdbcdebcdebcdefbcdefbcdefgbcdefg
0112123123412345123456

Por ahora, todavía no tenía idea de lo que sucedió con las letras, pero los números parecían más simples, así que lo miré más de cerca. Al final resultó que, la página web simplemente estaba ingresando el primer carácter, luego repitiendo todo el resto en la cadena cada vez que se presionaba uno nuevo:

0112123123412345123456
0
 1
  12
    123
       1234
           12345
                123456

¿Pero qué pasa con las secciones de letras? Después de reflexionar por un minuto, me di cuenta de que es lo mismo, pero en lugar de repetir cada subsección una vez, la repite dos veces :

abbbcbcbcdbcdbcdebcdebcdefbcdefbcdefgbcdefg
a
 bb
   bcbc
       bcdbcd
             bcdebcde
                     bcdefbcdef
                               bcdefgbcdefg

Una combinación de los dos funciona con una combinación de estas técnicas:

abc123z
abbbcbcbc1bc12bc123bc123zbc123z
a
 bb
   bcbc
       bc1
          bc12
              bc123
                   bc123zbc123z

Cualquiera que sea la falla, esto parece restablecerse en la puntuación y los espacios, por lo que se abc defconvierte abbbcbc deeefef.

En este punto, estaba tan absorto en resolverlo y convertirlo en un desafío interesante que olvidé por qué había estado allí en primer lugar. (Sin embargo, descubrí cómo escribir normalmente: presionando la barra espaciadora después de cada personaje. Bastante tedioso, pero tienes que hacer lo que tienes que hacer).

Desafío

El objetivo del desafío es escribir un programa o función que tome el texto a procesar, realice los cambios enumerados anteriormente y genere / devuelva el resultado.

Detalles

• La entrada solo contendrá ASCII imprimible, y no habrá pestañas ni líneas nuevas.

Casos de prueba

Entradas: (una por línea)

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!

Salidas:

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!

Puntuación

Esto es código de golf , por lo más corto código válido en bytes victorias. Tiebreaker va a la presentación que alcanzó su conteo final de bytes primero. El ganador será elegido el próximo lunes 2 de noviembre. ¡Buena suerte!

Editar: ¡ Y el ganador es ... @ MartinBüttner usando Retina para una increíble solución de 43 bytes !

_{¹ Sí, esta historia es completamente cierta, y si necesita más aclaraciones, vea la nota al pie 1.}

Retina , 43 bytes

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

Ejecute el código desde un solo archivo con la -sbandera. Dado que esta es solo una sustitución de expresiones regulares, puede probarla aquí (haga clic en la pestaña Contexto para ver los resultados).

Explicación

Esto coincide con cualquier dígito y letra que no sea el primero en una ejecución. Si bien .puede coincidir con cualquier carácter sin salto de línea, los aspectos retrospectivos aseguran las otras condiciones:

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

Esto coincide hacia atrás desde la posición después de .. Primero hace coincidir uno o más caracteres alfanuméricos y los captura en grupo 1con ([^_\W]+). Esto asegura inmediatamente que .corresponde a un carácter alfanumérico en sí. Luego, el adicional [^_\W]se asegura de que haya un carácter alfanumérico más en la ejecución actual, que no incluimos la coincidencia. Ahora grupo 1es con lo que queremos reemplazar la coincidencia si es un dígito; si es una letra, queremos reemplazarlo con el doble de esta cadena. Ahí es donde entra en juego la segunda mirada atrás:

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

Este es opcional, por lo que si falla no afectará en absoluto la coincidencia. Primero se asegura que el .era no un dígito a través de (?<=\D)- por lo que esta búsqueda hacia atrás sólo es relevante cuando estamos letras coincidentes. En ese caso, hacemos coincidir el grupo \1una vez más (esto siempre coincide, porque hemos capturado al grupo desde la misma posición), pero lo capturamos en el grupo 2.

Por lo tanto, simplemente reemplazamos la expresión regular con el contenido de ambos grupos ( $1$2). Si la coincidencia era un dígito, $2todavía estará vacía y reescribiremos el prefijo solo una vez. Si fue una carta, $2es lo mismo $1y la escribimos dos veces.

JavaScript (ES6) 82

Usando la optimización 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='')

Pruebe a ejecutar el fragmento a continuación en cualquier navegador reciente

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=''))

No tengo idea de cómo jugar golf ...

Gracias Mwir247 por la expresión regular de golf y las producciones ETH por un byte de golf en función reducida .

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)

Es un desastre.

Diviértete leyendo todas las peculiaridades extrañas, nunca pensé que usaría idtanto.

Lástima que el material que ya lo hace la mitad del trabajo que aquí tiene que ser importado ( isDigit, isAlpha, inits).

Gema, 57 caracteres

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

Ejecución de muestra:

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

Haskell, 183181 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!"

No sé si es esencialmente diferente con la respuesta de Leif Willerts. Pero aquí está el algoritmo.

1. Busque una carta válida (letra o número)
2. Si tiene letras, comience a recolectar cartas. Sin embargo, se almacena al revés, invierta la cadena. Y el primer elemento se omite.
3. Cuando toque una letra no válida, haga la transformación de la pregunta con la entrada invertida. La transformación de la pregunta es reverse.g.reverse, pero como ya está invertida, entonces solo hacemos reverse.g

De alguna manera mantengo soportes reductores.

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

Ej: exec x(@s='1337 numb3r5') devoluciones1333337 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

Recorre los caracteres y guarda / repite si es necesario.

Pip, 41 bytes

aR`[^_\W]+`{[email protected]@{1,++y}X2-(_Q+_)MJa}

Toma el texto como un argumento de línea de comandos. Utilizamos un reemplazo de expresiones regulares para reemplazar todas las ejecuciones alfanuméricas ( [^_\W]+) con una función de devolución de llamada. Esta función asigna otra función a cada carácter de la palabra, generando series de caracteres progresivamente más grandes (con la variable global haciendo un yseguimiento del índice) y repitiéndolas X2 si el carácter no es un número. (La lógica que utiliza +para convertir a un número y luego Qpara verificar si es igual a la cadena del carácter original). Sin embargo, este proceso omite el primer carácter, por lo que tenemos que agregarlo después ( 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

Pruébalo en línea!