Montag Minigolf: Eine Reihe von kurzen Code-Golf- Herausforderungen, die (hoffentlich!) Jeden Montag veröffentlicht werden.

Wahre Begebenheit ¹ : Neulich spielte ich auf meinem Tablet herum, als ich auf die Idee kam, die Seite zu besuchen, die ich normalerweise auf meinem PC zum Testen von JavaScript verwende. Nachdem die Seite geladen war, habe ich dieses einfache Programm aufgerufen:

alert("Hello!")

Ich drückte dann die Execute-Taste und war überrascht, als mir mitgeteilt wurde, dass der von mir eingegebene Code ungültig war. Ich warf einen zweiten Blick auf das Textfeld und sah Folgendes:

alllelelerlerlertlert("Heeelelellellelloello!")

Was ??? Das habe ich nicht eingegeben! Also, was ist hier passiert? Um das herauszufinden, habe ich zwei einfache Zeilen eingegeben:

abcdefg
0123456

Dies stellte sich heraus als:

abbbcbcbcdbcdbcdebcdebcdefbcdefbcdefgbcdefg
0112123123412345123456

Inzwischen hatte ich noch keine Ahnung, was mit den Buchstaben geschah, aber die Zahlen schienen einfacher zu sein, also schaute ich genauer hin. Wie sich herausstellte, gab die Webseite einfach das erste Zeichen ein und wiederholte den Rest der Zeichenkette jedes Mal, wenn ein neues gedrückt wurde:

0112123123412345123456
0
 1
  12
    123
       1234
           12345
                123456

Aber was ist mit den Buchstabenabschnitten? Nachdem ich eine Minute lang nachgedacht hatte, wurde mir klar, dass es genau dasselbe ist, aber anstatt jeden Unterabschnitt einmal zu wiederholen, wird es zweimal wiederholt :

abbbcbcbcdbcdbcdebcdebcdefbcdefbcdefgbcdefg
a
 bb
   bcbc
       bcdbcd
             bcdebcde
                     bcdefbcdef
                               bcdefgbcdefg

Eine Kombination der beiden funktioniert mit einer Kombination dieser Techniken:

abc123z
abbbcbcbc1bc12bc123bc123zbc123z
a
 bb
   bcbc
       bc1
          bc12
              bc123
                   bc123zbc123z

Was auch immer Störimpulse verursachen mag, diese scheinen sich bei Interpunktion und Leerzeichen zurückzusetzen, so abc defwird es abbbcbc deeefef.

Zu diesem Zeitpunkt war ich so fasziniert, es herauszufinden und es zu einer interessanten Herausforderung zu machen, dass ich vergaß, warum ich überhaupt dort gewesen war. (Ich habe jedoch herausgefunden, wie man normal schreibt: Drücken Sie die Leertaste nach jedem Zeichen. Ziemlich langweilig, aber Sie müssen tun, was Sie tun müssen.)

Herausforderung

Ziel der Herausforderung ist es, ein Programm oder eine Funktion zu schreiben, die den zu verarbeitenden Text aufnimmt, die oben aufgeführten Änderungen vornimmt und das Ergebnis ausgibt / zurückgibt.

Einzelheiten

• Die Eingabe enthält nur druckbares ASCII und keine Tabulatoren oder Zeilenumbrüche.

Testfälle

Eingänge: (einer pro Zeile)

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!

Ausgänge:

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!

Wertung

Das ist Code-Golf , also gewinnt der kürzeste gültige Code in Bytes. Tiebreaker geht zur Übermittlung über, die als erste ihre letzte Bytezahl erreicht hat. Der Gewinner wird am kommenden Montag, 2. November, ermittelt. Viel Glück!

Edit: Und der Gewinner ist ... @ MartinBüttner benutzt Retina für eine unglaubliche 43-Byte- Lösung!

_{¹ Ja, diese Geschichte ist völlig richtig, und wenn Sie weitere Erläuterungen benötigen, siehe Fußnote 1.}

Retina , 43 Bytes

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

Führen Sie den Code aus einer einzelnen Datei mit dem -sFlag aus. Da es sich nur um eine einzelne Regex-Ersetzung handelt, können Sie diese hier testen (klicken Sie auf die Registerkarte "Kontext", um die Ergebnisse anzuzeigen).

Erläuterung

Dies entspricht jeder Ziffer und jedem Buchstaben, die nicht die erste in einem Lauf sind. Während .jedes Nicht-Zeilenvorschub-Zeichen passen kann, stellen die Lookbehinds die anderen Bedingungen sicher:

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

Dies entspricht rückwärts von der Position nach dem .. Erstens paßt es ein oder mehr alphanumerische Zeichen und erfasst sie in der Gruppe 1mit ([^_\W]+). Dies stellt sofort sicher, dass das .einem alphanumerischen Zeichen selbst entspricht. Dann stellt der Zusatz [^_\W]sicher, dass es im aktuellen Lauf noch ein alphanumerisches Zeichen gibt, das wir nicht mit einbeziehen. Jetzt 1wollen wir die Übereinstimmung durch eine Gruppe ersetzen, wenn es sich um eine Ziffer handelt. Wenn es sich um einen Buchstaben handelt, möchten wir ihn durch die doppelte Zeichenfolge ersetzen. Hier kommt der zweite Lookbehind ins Spiel:

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

Dieser ist optional. Wenn er fehlschlägt, hat dies keinerlei Auswirkungen auf die Übereinstimmung. Es wird zunächst sichergestellt, dass .es sich nicht um eine Ziffer handelt. (?<=\D)Dieser Lookbehind ist also nur relevant, wenn Buchstaben übereinstimmen. In diesem Fall stimmen wir erneut mit der Gruppe überein \1(dies stimmt immer überein, da wir die Gruppe von derselben Position aus erfasst haben), erfassen sie jedoch in der Gruppe 2.

Daher ersetzen wir einfach den regulären Ausdruck durch den Inhalt beider Gruppen ( $1$2). Wenn die Übereinstimmung eine Ziffer war, ist $2sie immer noch leer und wir schreiben das Präfix nur einmal zurück. Wenn es ein Brief war, $2ist derselbe wie $1und wir schreiben ihn zweimal zurück.

JavaScript (ES6) 82

Verwendung der von Mwr247 vorgeschlagenen Regexp-Optimierung

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

Testen Sie das folgende Snippet in einem aktuellen Browser

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

Ich habe keine Ahnung, wie ich Golf spielen soll ...

Vielen Dank an Mwir247 für den Golf-Down-Regex und an ETHproductions für den 1-Byte-Golf-Down-Funktion .

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 ist ein Chaos.

Viel Spaß beim Lesen all der seltsamen Macken, ich hätte nie gedacht, dass ich so idviel verwenden würde.

Schade , dass die Sachen , die schon funktioniert die Hälfte der Arbeit hier muss importiert werden ( isDigit, isAlpha, inits).

Gema, 57 Zeichen

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

Probelauf:

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

Verwendungszweck:

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

Ich weiß nicht, ob es mit der Antwort von Leif Willerts wesentlich anders ist. Aber hier ist der Algorithmus.

1. Suche nach gültigen Buchstaben (Buchstaben oder Zahlen)
2. Wenn es ein Brief ist, fange an, einen Brief zu sammeln. Es wird jedoch umgekehrt gespeichert, machen Sie die Zeichenfolge umgekehrt. Und der erste Punkt entfällt.
3. Führen Sie bei einem ungültigen Buchstaben die Transformation der Frage mit umgekehrter Eingabe durch. Die Transformation der Frage ist reverse.g.reverse, aber da sie bereits umgekehrt ist, machen wir einfach reverse.g

Ich halte irgendwie überflüssige Klammern.

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

Beispiel: exec x(@s='1337 numb3r5') kehrt zurück1333337 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

Durchläuft Zeichen und speichert / wiederholt sie bei Bedarf.

Pip, 41 Bytes

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

Nimmt den Text als Befehlszeilenargument. Wir verwenden eine Regex-Ersetzung, um alle alphanumerischen Ausführungen ( [^_\W]+) durch eine Rückruffunktion zu ersetzen . Diese Funktion ordnet jedem Zeichen des Wortes eine weitere Funktion zu, wobei immer größere Zeichenfolgen generiert werden (wobei die globale Variable yden Index verfolgt) und diese X2 wiederholt werden, wenn das Zeichen keine Zahl ist. (Die Logik, die verwendet wird +, um in eine Zahl zu konvertieren und dann Qzu prüfen, ob diese Zeichenfolge dem ursprünglichen Zeichen entspricht.) Bei diesem Vorgang wird jedoch das erste Zeichen ausgelassen, sodass wir es anschließend hinzufügen müssen ( 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

Probieren Sie es online!