Lundi Mini-golf: Une série de défis courts en code-golf , postés (espérons-le!) Tous les lundis.

Histoire vraie ¹ : L'autre jour, je jouais sur ma tablette lorsque j'ai eu l'idée de visiter la page que j'utilise normalement sur mon PC pour tester JavaScript. Après la page chargée, je suis entré dans ce programme simple:

alert("Hello!")

J'ai ensuite appuyé sur le bouton Execute (Exécuter) et j'ai été surpris de constater que le code que j'avais entré était invalide. J'ai jeté un deuxième coup d'œil à la zone de texte et j'ai vu ceci:

alllelelerlerlertlert("Heeelelellellelloello!")

Wha ??? Ce n'est pas ce que je suis entré! Alors que s'est-il passé ici? Pour le comprendre, j'ai entré deux lignes simples:

abcdefg
0123456

Cela s'est avéré comme:

abbbcbcbcdbcdbcdebcdebcdefbcdefbcdefgbcdefg
0112123123412345123456

À l'heure actuelle, je n'avais toujours aucune idée de ce qu'il était advenu des lettres, mais les chiffres semblaient plus simples, alors j'ai regardé de plus près. Il s’est avéré que la page Web saisissait simplement le premier caractère, puis répétait tout le reste de la chaîne à chaque pression sur un nouveau:

0112123123412345123456
0
 1
  12
    123
       1234
           12345
                123456

Mais qu'en est-il des sections de lettres? Après avoir réfléchi pendant une minute, je me suis rendu compte que c'était la même chose, mais au lieu de répéter chaque sous-section une fois, il le répète deux fois :

abbbcbcbcdbcdbcdebcdebcdefbcdefbcdefgbcdefg
a
 bb
   bcbc
       bcdbcd
             bcdebcde
                     bcdefbcdef
                               bcdefgbcdefg

Une combinaison des deux œuvres avec une combinaison de ces techniques:

abc123z
abbbcbcbc1bc12bc123bc123zbc123z
a
 bb
   bcbc
       bc1
          bc12
              bc123
                   bc123zbc123z

Quelle que soit Glitch cause cela semble remis à zéro à la ponctuation et les espaces, donc abc defdevient abbbcbc deeefef.

À ce stade, j'étais tellement absorbé par l'idée de le comprendre et de le transformer en un défi intéressant que j'ai oublié pourquoi je m'étais trouvé là-bas. (Cependant, j'ai compris comment taper normalement: appuyer sur espace-espace après chaque caractère. Plutôt ennuyeux, mais il faut faire ce qu'il faut faire.)

Défi

Le but du défi est d’écrire un programme ou une fonction qui intègre le texte à traiter, apporte les modifications répertoriées ci-dessus et génère / renvoie le résultat.

Détails

• L'entrée ne contiendra que de l'ASCII imprimable, sans onglets ni nouvelles lignes.

Cas de test

Entrées: (une par ligne)

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!

Les sorties:

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!

Notation

C'est le code-golf , donc le code valide le plus court en octets gagne. Tiebreaker va à la soumission qui a atteint son nombre d'octets final en premier. Le gagnant sera choisi lundi prochain, le 2 novembre. Bonne chance!

Edit: Et le gagnant est ... @ MartinBüttner utilise Retina pour une solution incroyable de 43 octets !

_{¹ Oui, cette histoire est tout à fait vraie et, si vous avez besoin de précisions, voir la note 1.}

Retina , 43 octets

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

Exécutez le code à partir d'un seul fichier avec l' -sindicateur. Puisqu'il ne s'agit que d'une substitution de regex unique, vous pouvez le tester ici (cliquez sur l'onglet Contexte pour voir les résultats).

Explication

Cela correspond aux chiffres et aux lettres qui ne sont pas les premiers d'une série. Bien qu’ils .puissent correspondre à n’importe quel caractère qui n’a pas d’alignement de ligne, les fonctions de vérification assurent les autres conditions:

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

Cela correspond à l' arrière de la position après .. Tout d'abord, il correspond à un ou plusieurs caractères alphanumériques et les capture dans un groupe 1avec ([^_\W]+). Cela garantit immédiatement que le .correspond à un caractère alphanumérique lui-même. Ensuite, le caractère supplémentaire [^_\W]permet de s’assurer qu’il y a encore un caractère alphanumérique dans l’exécution en cours, ce que nous n’incluons pas . Maintenant, groupe 1est ce avec quoi nous voulons remplacer la correspondance s'il s'agit d'un chiffre - si c'est une lettre, nous voulons le remplacer par deux fois cette chaîne. C'est là qu'intervient le deuxième regard:

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

Celui-ci est facultatif, donc s'il échoue, cela n'affectera pas du tout la correspondance. Cela garantit d’abord que le chiffre .n’est pas un chiffre (?<=\D)- la recherche n’est donc pertinente que lorsque nous comparons des lettres. Dans ce cas, nous correspondons à nouveau au groupe \1(cela correspond toujours, car nous avons capturé le groupe à partir de la même position), mais nous le capturons dans le groupe 2.

Par conséquent, nous remplaçons simplement l'expression rationnelle par le contenu des deux groupes ( $1$2). Si la correspondance était un chiffre, $2sera toujours vide et nous n'écrirons le préfixe qu'une seule fois. Si c’était une lettre, $2c’est la même chose $1et nous l’écrivons deux fois.

JavaScript (ES6) 82

Utilisation de l'optimisation des expressions rationnelles suggérée par 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='')

Testez l'exécution de l'extrait ci-dessous dans n'importe quel navigateur récent

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

Je ne sais pas comment jouer au golf avec ça ...

Merci Mwir247 pour la regex et ETHproductions au golf pour un golf sur un octet en fonction réduite .

Haskell, 215 200 octets

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)

C'est le bordel.

Amusez-vous en lisant toutes ces bizarreries bizarres, je n'aurais jamais pensé en utiliser idautant.

Dommage que la substance qui fait déjà la moitié du travail a besoin d' ici à importer ( isDigit, isAlpha, inits).

Gema, 57 caractères

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

Échantillon échantillon:

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 octets

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

Usage:

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

Je ne sais pas si c'est fondamentalement différent avec la réponse de Leif Willerts. Mais voici l'algorithme.

1. Rechercher une lettre valide (Letter ou Num)
2. Si c'est lettre, commencez à rassembler la lettre. Cependant, comme il est stocké à l'envers, faites en sorte que la chaîne soit inversée. Et le premier élément est omis.
3. Lorsque la lettre est invalide, effectuez la transformation de la question avec une entrée inversée. La transformation de la question est reverse.g.reverse, mais comme elle est déjà inversée, alors nous ne faisons que reverse.g

Je garde en quelque sorte les crochets redudant.

T-SQL, 357 octets

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') retourne1333337 nuuumumumbumbumb3umb3rumb3rumb3r5

Python 2, 131 octets

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

Parcourt les personnages et enregistre / répète si nécessaire.

Pip, 41 octets

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

Prend le texte en argument de ligne de commande. Nous utilisons un remplacement regex pour remplacer tous les runs alphanumériques [^_\W]+par une fonction de rappel. Cette fonction mappe une autre fonction sur chaque caractère du mot, générant des séries de caractères de plus en plus grandes (avec la variable globale ygardant la trace de l'index) et les répétant X2 si le caractère n'est pas un nombre. (La logique pour laquelle est utilisée la +conversion en nombre, puis la Qvérification si c'est une chaîne identique à celle du caractère d'origine.) Ce processus laisse de côté le premier caractère. Nous devons donc l'ajouter après ( a@0.).

Python 3 , 86 octets

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

Essayez-le en ligne!