Neurotische Frösche entziffern

Jetzt, da Puzzling.SE endlich meine von Amphibien besessene Chiffre geknackt hat , schreiben wir ein Programm oder eine Funktion, um sie zu entschlüsseln!

(Wenn Sie sich das Puzzle ansehen möchten, bevor es für Sie verwöhnt wird, klicken Sie jetzt auf den obigen Link.)

Wie die Chiffre funktioniert

In Neurotic Frösche O ught Um Rel ein x in M ud Bäder ( „Neurotic Frösche“ abgekürzt), wird jeder Brief als ein oder zwei Wörter verschlüsselt:

• Die Länge eines nicht kursiv geschriebenen Wortes entspricht einem Buchstaben.
  • neurotic => 8 Buchstaben => H
  • frogs => 5 Buchstaben => E
  • perpendicular => 13 Buchstaben = M
• Ein Wort, das Kursivschrift enthält, ändert das folgende Wort und fügt 10 hinzu, wenn das kursiv geschriebene Wort ungerade lang war, oder 20, wenn das kursiv geschriebene Wort gerade lang war. Das Wort kann ganz oder teilweise kursiv geschrieben werden. Auf ein kursives Wort folgt immer ein nicht kursives Wort.
  • *o*ught to => ungerade, 2 => 12 => L
  • lo*u*nging calms => gerade, 5 => 25 => Y

Jedes Wort im Klartext entspricht einem Satz im Chiffretext, und jeder Satz im Klartext entspricht einem Absatz im Chiffretext.

Eingabeformat

Ihr Programm oder Ihre Funktion soll eine Nachricht in Neurotic Frogs eingeben, die in Markdown formatiert ist. Die Eingabe besteht nur aus druckbarem ASCII und Zeilenumbrüchen.

• Wörter sind Zeichenfolgen, die dem regulären Ausdruck entsprechen [A-Za-z0-9'].
  • Zahlen und Buchstaben zählen jeweils zur Länge eines Wortes. QB64darstellt D.
  • HINWEIS: Apostrophe zählen nicht zur Länge eines Wortes. Isn'tdarstellt D, nicht E.
• Kursiv geschriebene Buchstaben sind in zwei Sternchen ( *letters*) eingeschlossen.
  • Ein oder mehrere aufeinanderfolgende Buchstaben können bis zu einem ganzen Wort ( masseus*es*, *all*) kursiv geschrieben werden . Es können auch mehrere nicht aufeinanderfolgende Buchstaben in einem Wort kursiv geschrieben werden ( g*e*n*e*rates).
  • Kursivschrift umfasst niemals mehrere Wörter, enthält niemals Satzzeichen und niemals Apostrophe.
  • Nicht gepaarte Sternchen und mehrere benachbarte Sternchen werden niemals auftreten.
• Interpunktion ist eine der folgenden Zeichen: .,?!:;-()".
  • Wörter innerhalb eines Satzes werden durch ein oder mehrere Interpunktionszeichen und / oder ein einzelnes Leerzeichen getrennt. Beispiele: *all* welcomed, toad*s*, newts, Ever*y*one--frogs, cap... bliss,they're (I
  • Sätze enden mit einem oder mehreren Interpunktionszeichen und werden durch ein doppeltes Leerzeichen getrennt: Th*e* Montgomery A*m*phibian Salon! Come luxuriate today!
  • Absätze werden durch eine neue Zeile getrennt. (Der letzte Satz eines Absatzes enthält am Ende noch ein oder mehrere Satzzeichen.)

Andere Zeichen werden in der Eingabe nicht angezeigt und müssen nicht behandelt werden.

Ihr Code kann nach eigenem Ermessen davon ausgehen, dass die Eingabe eine einzige nachgestellte Zeile enthält.

Ausgabeformat

Das Ergebnis der Entschlüsselung der Eingabe sind ein oder mehrere Sätze. Klartextbuchstaben können eine beliebige Kombination aus Groß- und Kleinschreibung sein. Wörter innerhalb eines Satzes müssen durch einzelne Leerzeichen getrennt werden. Sätze müssen mit einem Punkt ( .) enden und durch ein Leerzeichen getrennt sein. Sie können nach dem letzten Satz ein Leerzeichen ausgeben. Ihre Ausgabe erfolgt alle in einer Zeile, Sie können jedoch eine nachfolgende neue Zeile ausgeben.

Verschiedene Details

Ihr Code kann eine der Standardeingabe- und -ausgabemethoden verwenden. Es muss Eingaben als mehrzeilige Zeichenfolge empfangen, keine Liste oder andere Datenstruktur, und es muss eine Zeichenfolge ausgeben.

Der kürzeste Code in Bytes gewinnt!

Testfälle

-->
Neurotic Frogs *O*ught To Rel*a*x In *M*ud Baths!
<--
HELLO.

-->
Business standards all*o*w only *adult* amphibians.
<--
HINT.

-->
Rejoice, *a*ll frogs an*d* toads also!  Montgomery Sal*o*n opens up!  Ha*pp*y throng fill*s* street ecstatically!
<--
GOOD JOB PPL.

-->
I like 3.1415926535897.
IM*O*, it's a *b*la*st*, yeah!
<--
ADAM. MAN.

-->
*I*, happily, *th*anks 2 u *e*ditin*g* specific wor*ding*--clarifying a *bit*--betterment :D!
<--
QUARTATA.

-->
Perpendicular l*ou*nging calms.  *A* frog, a m*u*d cap... bliss!  Wallowing g*e*n*e*rates happiness.  Amphibian sp*a* isn't expensive--seventy d*o*llars--cheap!  That'*s* not *a* large e*x*pens*e* from an*y* discerning fr*o*g's money, unlik*e* Super 8.
Ever*y*one--frogs, toad*s*, newts, *a*nd salamanders!  G*e*t a wonderful shiat*s*u, or recei*v*e an other kind.  Masseus*es* are her*e* today!  Invite a fianc*e*e, supervisor, roommate, niece: *all* welcomed!
Y*o*u simply ne*v*er believed these p*o*ssibilitie*s*; they're (I *swear*) absolute truth!  Th*e* Montgomery A*m*phibian Salon!  Come luxuriate today!
<--
MY NAME IS INIGO MONTOYA. YOU KILLED MY FATHER. PREPARE TO DIE.

Perl, 72 Bytes

#!perl -n
$x=/\*/?2-y/'//c%2:!print/ /?$':chr$x.0+y/'//c+64for/[\w*']+|  /g,' . '

Zählt man den Shebang als einen, wird die Eingabe von stdin übernommen.

Beispielnutzung

$ more in.dat
Neurotic Frogs *O*ught To Rel*a*x In *M*ud Baths!
Perpendicular l*ou*nging calms.  *A* frog, a m*u*d cap... bliss!  Wallowing g*e*n*e*rates happiness.  Amphibian sp*a* isn't expensive--seventy d*o*llars--cheap!  That'*s* not *a* large e*x*pens*e* from an*y* discerning fr*o*g's money, unlik*e* Super 8.
Ever*y*one--frogs, toad*s*, newts, *a*nd salamanders!  G*e*t a wonderful shiat*s*u, or recei*v*e an other kind.  Masseus*es* are her*e* today!  Invite a fianc*e*e, supervisor, roommate, niece: *all* welcomed!
Y*o*u simply ne*v*er believed these p*o*ssibilitie*s*; they're (I *swear*) absolute truth!  Th*e* Montgomery A*m*phibian Salon!  Come luxuriate today!

$ perl neurotic-frogs.pl < in.dat
HELLO. MY NAME IS INIGO MONTOYA. YOU KILLED MY FATHER. PREPARE TO DIE.

JavaScript (ES6), 172 169 157 150 Byte

10 Bytes dank @Neil eingespart

x=>x.match(/[\w'*]+|\s+/g).map(y=>y[0]==" "?y[1]:y==`
`?". ":/\*/.test(y,l+=y.match(/\w/g).length)?(l=l%2*10+19,""):l.toString(36,l=9),l=9).join``+"."

Kann wohl noch weiter verbessert werden. Ausgaben in Kleinbuchstaben.

Python 2, 238 221 218 214 207 205 Bytes

from re import*
def f(x):
 d='';m=0
 for w in split(r"[^\w\d*'~\n]+",sub('  ','~',x))[:-1]:l=len(sub("[*'~\n]",'',w));q='*'in w;d+='. '[w[0]>'}':]*(w[0]in'~\n')+chr(64+l+m)[q:];m=(2-l%2)*10*q
 print d+'.'

Verwendet viel Regex, um die Verarbeitung durchzuführen. Wir wandeln den Doppelraum in einen um ~und verwenden ihn, um ihn zu verarbeiten. ~und \nwerden speziell behandelt.

Der größte Zeichengewinn ergibt sich aus der Vorverarbeitung der Eingabe in der forZeile. Dies kann definitiv weiter golfen werden.

Ideone es! (alle Testfälle)

7 Bytes gespart dank DLosc!

Pip , 65 64 Bytes

Die Punktzahl beträgt 62 Byte Code + 2 für die -rsFlags.

Flg{O{{(zy*t+#a-1)X!Y'*Na&2-#a%2}MJa@`[\w*]+`}MlRM''^sX2O". "}

Probieren Sie es online!

Erläuterung

Das -rFlag liest alle Zeilen von stdin und speichert eine Liste von ihnen in g. Das -sFlag setzt das Ausgabeformat von Listen auf Leerzeichen.

Der einfachste Weg, diesen Code zu lesen, ist von außen in:

Flg{...}                   For each line l in g, do:

O{...}MlRM''^sX2O". "      Translate a paragraph into a sentence of plaintext:
       lRM''               Remove apostrophe characters
            ^sX2           Split on "  " into sentences
 {...}M                    Map the below function to each sentence
O                          Output the result list, space-separated, without newline
                O". "      Output that string, without newline

{...}MJa@`[\w*]+`          Translate a sentence into a word of plaintext:
       a@`[\w*]+`          Find all matches of regex (runs of alphanumeric and *)
{...}MJ                    Map the below function to each word and join into string

(zy*t+#a-1)X!Y'*Na&2-#a%2  Translate a word into a letter of plaintext:
      #a-1                 Length of word minus 1
  y*t+                     Add 10 or 20 if y is set (see below)
(z        )                Use that number to index into lowercase alphabet
              '*Na&        Count * characters in word, logical AND with...
                   2-#a%2  2 if word is even length, 1 if odd
             Y             Yank that value into y, to modify the following word
           X!              String multiply the character by not(y)
                           If y is truthy, the word had italics, and we get ""
                           If y is falsy, the word had no italics, and we get a letter

Python 2.7, 390 342 341 339 335 Bytes:

from re import*
def F(i):
 W=X="";S,s=split,sub;D='[^\w\s*]';Q=lambda c,t:len(s(D,X,c.group()).split()[t])
 for m in S('\W\n',s(D+"*\w*\*\w+\*.*?(?=\s) \w+",lambda v:"a"*([20,10][Q(v,0)%2]+Q(v,1)),s("'",X,s("--"," ",i)))):
  for g in S('\W  ',m):
   for q in S('\W',g):
    W+=chr(64+len(q))
   W+=" "
  W=W[:-1]+". "
 print s("@",X,W)

Nimmt Eingaben im Format:

F('''Multi or Single-lined String''')

Kann viel mehr golfen werden, was ich tun werde, wenn ich die Chance dazu bekomme.

Repl.it mit allen Testfällen!

Erläuterung:

Verwendet die immense Kraft der in Python integrierten regulären Ausdrücke, um die Eingabe zu entschlüsseln. Dies ist der grundlegende Prozess, den die Funktion für jede Eingabe durchläuft:

1. Erstens werden alle --durch ein einzelnes Leerzeichen ersetzt, und jeder Apostroph wird entfernt. Dann werden alle Wörter mit kursiven Komponenten und das Wort ausgehend es sind beide in einer Saite abgestimmt und mit ersetzt 10 + len(second word)Anzahl aufeinanderfolgender as , wenn die Länge des ersten Wortes ist odd, und in 20 + len(second word)Folge as anders. Dabei wird der folgende reguläre Ausdruck verwendet:

   [^\w\s*]*\w*\*\w+\*.*?(?=\s) \w+

   Wenn wir zum Beispiel den Satz haben Perpendicular l*ou*nging calms., l*ou*nging calmswird er durch aaaaaaaaaaaaaaaaaaaaaaaaaoder 25 as ersetzt, da er l*ou*ngingeine gerade Anzahl von Zeichen hat und calms5 hat 20+5=25.

2. Jetzt wird die neu geänderte Eingabe an jedem Satzzeichen geteilt, gefolgt von einer neuen Zeile ( \n), um die Absätze zu erhalten, dann wird jeder Absatz an jeder Interpunktion geteilt, gefolgt von zwei Leerzeichen, um die Sätze zu erhalten, und schließlich wird jeder Satz in Wörter aufgeteilt Interpunktion einschließlich Leerzeichen. Dann wird für jedes Wort (einschließlich der Läufe von aufeinanderfolgenden as), fügen wir in einen String auf Wden Brief an den Unicode - Codepunkt entspricht 64(der Unicode - Codepunkt des Zeichens vor A, das ist @) zzgl len(word). Wir fügen dann einen einzigen Raum zu Weinmal alle Wörter eines Satzes erschöpft sind, und wenn alle die Sätze in einem Absatz erschöpft sind, wir fügen Sie .durch ein Leerzeichen gefolgt.

3. Schließlich wird, nachdem die gesamte Eingabe durchlaufen wurde W, stdoutals entschlüsselte Nachricht ausgegeben .

PHP, 196 Bytes

<?preg_match_all("#[\w*']+|  |$#m",$_GET[s],$m);foreach($m[0]as$s){if(!$s||$s=="  ")echo!$s?". ":" ";else{$l=$p+64+strlen(str_replace("'","",$s));if(!$p=strstr($s,"*")?20-$l%2*10:0)echo chr($l);}}

Wenn ich davon ausgehen könnte, dass in der Mitte eines Wortes nur ein Apostroph 194 Bytes steht

<?preg_match_all("#[\w*]+(<?=')[\w*]+|[\w*]+|  |$#m",$_GET[s],$m);foreach($m[0]as$s){if(!$s||$s=="  ")echo!$s?". ":" ";else{$l=$p+64+strlen($s);if(!$p=strstr($s,"*")?20-$l%2*10:0)echo chr($l);}}

PHP, 231 226 228 Bytes

für den Anfang

<?preg_match_all("#([\w\*']+)([^\w\*']*)#",$argv[1],$m,2);foreach($m as list(,$a,$b)){$e=strlen(strtr($a,["'"=>""]))+$d;if(!$d=strstr($a,'*')?$e%2*10:0)echo chr($e+64),strpos(".$b","
")?". ":(strpos(".$b","  ")?" ":"");}echo".";

In Datei speichern, rund php <scriptpath> <text>. Escape-Zeilen im Text, damit es in der Shell funktioniert.