Entpacken Sie die Ziffern

72

Aufgabe

Ausgehend von einer Folge von englischen Ziffernnamen, die wie folgt „zusammengebrochen“ sind:

zeronineoneoneeighttwoseventhreesixfourtwofive

Teilen Sie die Zeichenfolge wieder in Ziffern auf:

zero nine one one eight two seven three six four two five

Regeln

  • Die Eingabe ist immer eine Zeichenfolge. Es besteht immer aus einem oder mehreren zusammengeklappten englischen Ziffernnamen in Kleinbuchstaben und sonst nichts.

    • Die englischen Ziffernnamen sind zero one two three four five six seven eight nine.
  • Die Ausgabe kann eine Liste von Zeichenfolgen oder eine neue Zeichenfolge sein, bei der die Ziffern durch nicht alphabetische, nicht leere Zeichenfolgen begrenzt sind. (Ihre Ausgabe kann optional auch solche Zeichenfolgen am Anfang oder Ende enthalten, und die Begrenzer müssen nicht konsistent sein. Daher ist auch so etwas {{ zero0one$$two );eine gültige (wenn auch absurde) Antwort für zeroonetwo.)

  • Die kürzeste Antwort in Bytes gewinnt.

Testfälle

three -> three
eightsix -> eight six
fivefourseven -> five four seven
ninethreesixthree -> nine three six three
foursixeighttwofive -> four six eight two five
fivethreefivesixthreenineonesevenoneeight -> five three five six three nine one seven one eight
threesevensevensixninenineninefiveeighttwofiveeightsixthreeeight -> three seven seven six nine nine nine five eight two five eight six three eight
zeroonetwothreefourfivesixseveneightnine -> zero one two three four five six seven eight nine
Lynn
quelle
28
Dies ist eine hervorragende Herausforderung! Die Aufgabe ist sehr einfach zu verstehen und zu überprüfen, aber der richtige Ansatz ist nicht sehr offensichtlich. Und die Wahl des richtigen Ansatzes könnte einen großen Unterschied in der Punktzahl bewirken. +1 :)
DJMcMayhem
1
Nachdem ich mir das überlegt hatte, fiel mir eine ähnliche, aber einfachere Herausforderung beim Anarchie-Golf ein: Ja, nein ! Es löste einige erstaunliche C-Antworten aus. Ich hoffe,
Lynn
Ich glaube nicht, dass meine C-Antwort als solche qualifiziert ist, aber hoffentlich ist es ein Ausgangspunkt für andere mit einem mehr verrückten Sinn für Humor als ich.
Michael Dorgan
Ich bin mir ziemlich sicher, dass ich die gleiche Herausforderung gesehen habe, aber wo soll ich die tatsächliche Nummer ausdrucken? Ich bin mir fast sicher, dass es auch von Lynn gepostet wurde. aber ich habe den link verloren, mach mit?
Magic Octopus Urn
3
@MichaelDorgan (oder andere C-Codierer), vielleicht möchten Sie einen Blick auf den Algorithmus werfen, den ich in meiner Befunge-Antwort verwendet habe. Eine direkte Konvertierung davon in C brachte mir eine 104-Byte-Lösung, die meiner Meinung nach alle vorhandenen C-Antworten übertrifft. Ich bin gewillt, darauf zu wetten, dass jemand mit mehr C-Golf-Fähigkeiten eine Verbesserung bringen könnte.
James Holderness

Antworten:

17

C (GCC) , 89 80 76 75 72 71 70 69 Bytes

f(char*s){*s&&f(s+printf(" %.*s",""[(*s^s[2])%12],s)-1);}

Probieren Sie es online!

(89) Gutschrift an gastropner für den XOR-Hash.
(76) Toby Speight für die Idee, den 1. und 3. zu verwenden.
(75) Dank an Michael Dorgan für '0'48.
(72) Dank an Michael Dorgan und Lynn für Literale mit Steuerzeichen.
(69) Dank an Lynn für x?y:0x&&y

f (char *s) {        /* K&R style implicit return type. s is the input. */
    *s&&f(           /* Recurse while there is input. */
        s+printf(    /* printf returns the number of characters emitted. */
            " %.*s", /* Prefix each digit string with a space. Limit
                      * how many bytes from the string to print out. */
            ""
                     /* Magic hash table, where the value represents
                      * the length of the digit string. The string
                      * is logically equivalent to
                      * "\04\01\05\03\04\05\05\04\04\01\03\03" */
            [(*s^s[2])%12],
                     /* The XOR hash (mod 12) */
            s)       /* The current digit. */
            -1);}    /* Subtract 1 for the space. */
jxh
quelle
11

Python 2 , 50 Bytes

import re
re.compile('..[eox]|[tse]?....').findall

Probieren Sie es online!

-3 danke an Lynn .
-4 dank Uriel 's Antwort ist regex.

Erik der Outgolfer
quelle
3
Nett! import re;re.compile('…').findallsollte ein paar Bytes sparen. Ich habe erwartet, dass dies zu Regex Golf wird :)
Lynn
@Lynn Warte, bis ich fertig bin! :-P EDIT: Eigentlich sind es 3 Bytes.
Erik der Outgolfer 20.11.17
@Lynn Außerdem sollten Sie stattdessen den regulären Code-Golf -Ausdruck verwenden. ;)
Erik der Outgolfer 20.11.17
Ich warte auf eine C-Antwort, die sehr interessant sein wird!
Lynn
9

Befunge, 87 85 81 76 Bytes

<*"h"%*:"h"$_02g-v1$,*<v%*93,:_@#`0:~
"@{&ruX;\"00^ !: _>_48^>+:"yp!"*+%02p0

Probieren Sie es online!

Befunge verfügt über keine Anweisungen zur Manipulation von Zeichenfolgen. Wir erstellen also eine Art Hash der letzten drei Zeichen, während wir sie verarbeiten.

Dieser Hash ist im Wesentlichen eine dreistellige Basis-104-Zahl. Jedes Mal, wenn ein neues Zeichen gelesen wird, modifizieren wir den Hash mit 104 2 , um das älteste Zeichen zu entfernen, multiplizieren ihn mit 104, um Platz für das neue Zeichen zu schaffen, und fügen dann den ASCII - Wert des neuen Zeichens Mod 27 hinzu (um sicherzugehen) es läuft nicht über).

Zu Vergleichszwecken nehmen wir diesen Wert mod 3817, schreiben ihn in den Speicher (kürzen ihn also auf 8 Bit), was zu kleineren Zahlen führt, die für Befunge leichter zu handhaben sind. Die Hashes, mit denen wir dann vergleichen müssen, sind 0, 38, 59, 64, 88, 92, 114, 117 und 123. Wenn einer dieser Hashes übereinstimmt, haben wir eine Zeichenfolge gefunden, die das Ende von markiert Zahl, also geben wir ein zusätzliches Leerzeichen aus und setzen den Hash auf Null zurück.

Wenn Sie sich fragen, warum Base 104 oder warum Mod 3817? Diese Werte wurden sorgfältig ausgewählt, damit die zu vergleichende Hash-Liste in möglichst wenigen Bytes dargestellt werden kann.

James Holderness
quelle
Ganz ehrlich, das sieht für mich aus wie Bakemoji (ば ば も も). Beeindruckend. Die Beschreibung des Algorithmus ist jedoch nett und ich werde darüber nachdenken.
Michael Dorgan
^ Ich erinnere mich, den Begriff als Mojibake (も も ば ば) gesehen zu haben. Wie haben Sie diese Zahlen gefunden (Basis 104, Mod 3187), @JamesHolderness?
Zacharý
@ Zacharý Ich habe ein kleines Python-Skript geschrieben, das verschiedene Basis- und Mod-Kombinationen getestet hat, um diejenigen zu finden, die die richtigen Ergebnisse liefern, wenn sie mit allen erwarteten Eingaben ausgeführt werden. Sobald ich wusste, welche Kombinationen funktionierten, ließ ich die resultierenden Hash-Ausgaben durch einen Befunge-Zahlengenerator laufen, um herauszufinden, welcher den kürzesten Code erzeugte.
James Holderness
6

Java (OpenJDK 8) , 55 46 43 Bytes

9 Bytes sparen dank Forty3 / FrownyFrog

3 Bytes sparen dank Titus

s->s.replaceAll("one|tw|th|f|z|s|.i"," $0")

Probieren Sie es online!

edit: Danke für die Begrüßung und Erklärung von Lambdas!

Luca H
quelle
3
Hallo, willkommen bei PPCG! Tolle erste Antwort, und es funktioniert in der Tat. Hier ist der TIO-Link dafür. Lambdas können auf verschiedene Arten erstellt werden. Hier ist ein weiteres TIO mit einigen Lambdas mit zusätzlichen Kommentaren, damit Sie sehen können, wie Sie sie selbst erstellen. (Ich empfehle, es in Eclipse zu kopieren, damit Sie die Hervorhebung des Codes sehen können.) Außerdem sind möglicherweise Tipps zum Golfen in Java und Tipps zum Golfen in allen Sprachen interessant zu lesen. Genieße deinen Aufenthalt! :)
Kevin Cruijssen
@ KevinCruijssen danke! Ich bin ehrlich überrascht, dass Java kürzer als JavaScript ist. Wenn ich Herausforderungen lese, ist JS normalerweise viel kürzer.
Luca H
JavaScript sollte 2 Byte kürzer sein ( gRegex-Suffix statt All).
Neil
@Neil es ist länger hier, weil es f=(s)=>stattdessen verwendet s->, was 4 Bytes kürzer ist.
Luca H
1
@LucaH - Nach dem Vorschlag von FrownyFrog können Sie einige Ihrer Zeichenfolgen aus zwei Buchstaben auf einzelne Zeichen reduzieren: z | f | s anstelle von ze | fo | fi | si | se /
Forty3
6

C (GCC) , 179 159 146 139 137 116 107 103 102 Bytes

Edit 1: (Vorschläge von Mr. Xcoder hinzugefügt - danke! - Meine Makroversion hatte dieselbe Größe wie Ihre, aber ich mag Ihre besser.)

Edit 2: Geänderte Charaktereigenschaften im Vergleich zu Anrufen mitstrchr()

Edit 3: K & R's die var Deklarationen (Eww!)

Edit 4: Wenn 1 Makro nicht ausreicht ...

Edit 5: Neu gemacht mit dem oben vorgeschlagenen neuen Algorithmus. Vielen Dank an James Holderness für diese großartige Idee!

Edit 6: 0-Set entfernt, da es automatisch dorthin zu gehen scheint - Verwendete Master-Level-Code- Golftechniken (Kommas, Printf-Trick usw.) - Danke Gastropner !

Edit 7: Benutze memchr und behebe einen Fehler, auf den James Holderness hingewiesen hat .

Edit 7: Verwenden Sie &&bei der Endabnahme zu ersetzen ?- danke jxh .

c,h;f(char*s){while(c=*s++)putchar(c),h=h%10816*104+c%27,memchr("&;@X\\ru{",h%3817,9)&&putchar(h=32);}

Probieren Sie es online!

Nicht golfen (was ehrlich gesagt immer noch sehr golfen ist ...)


int c;
int h;
void f(char*s)
{
    while(c=*s++)
        putchar(c),
        h=h%10816*104+c%27,
        memchr("&;@X\\ru{",h%3817,9)?putchar(h=32):1;
}

Alte, einfache grep-esqe-Lösung:

#define p putchar
#define q c=*s++
c,x;f(char*s){while(q){p(c);x=strchr("tse",c);p(q);p(q);if(!strchr("eox",c)){p(q);if(x)p(q);}p(' ');}}

Alte, sauberere Version.

// Above code makes a macro of putchar() call.

void f(char *s)
{
    char c;
    while(c = *s++)
    {
        putchar(c);
        int x = strchr("tse", c);

        putchar(*s++);
        putchar(c=*s++);

        if(!strchr("eox", c))
        {
            putchar(*s++);
            if(x)
            {
                putchar(*s++);
            }
        }       
        putchar(' ');
    }
}

Probieren Sie es online!

Michael Dorgan
quelle
Wir können den Putchar und dergleichen für ein paar Bytes makroisieren, aber im Allgemeinen denken wir immer noch über einen besseren Algorithmus nach, wenn möglich.
Michael Dorgan
159 Bytes durch #defineing putcharund ein Paar unnötiger Klammer zu entfernen.
Mr. Xcoder
2
Ein bisschen hässlich, aber 136 Bytes durch die Verwendung #define p putchar(anstelle (beachten Sie die öffnende Klammer).
Tom Carpenter
1
109 Bytesc,h=0;f(char*s){while(c=*s++)putchar(c),h=h%10816*104+c%27,c=h%3817,printf(" "+!(c&&strchr("&;@X\\ru{",c)));}
Gastropner
Ah, der printf-Trick, den ich unten gesehen habe, plus das Entfernen einiger Klammern und Klammern. Master Level Code Golf aktiviert :)
Michael Dorgan
5

JavaScript, 66 57 52 44 41 Bytes

s=>s.replace(/one|t[wh]|.i|[fsz]/g," $&")

Ziemlich naiv, aber es funktioniert.

Schöner Fang von FrownyFrog, um 2 Zeichen zu verwenden. Mit Ausnahme von "eins", bei dem ein reiner 2-Zeichen-Check die Null durcheinander bringen könnte. Edit: Die Single fund swaren gute Fänge von FrownyFrog, die ich bei meinen ersten beiden Golfspielen übersehen habe.

Vielen Dank, Neil, für den Vorschlag eines unbenannten Lambdas und die Möglichkeit, mit einem einzigen Char z52 zu erreichen.

Titus wartet mit einem kleineren RegEx auf. Ich habe das Gefühl, dass wir uns irgendwann Uriels Regex nähern.

Forty3
quelle
Bricht es, wenn Sie zwei Zeichen verwenden und bis zum Ende auf "Weiter" drücken?
FrownyFrog
Ich denkez|tw|th|f|s|ei|ni|on
FrownyFrog
1
@FrownyFrog o steht an erster Stelle, daher wird es zuerst erkannt.
Uriel
1
on|t[wh]|.i|[fsz](-4 Bytes)
Titus
2
@ Titus - Leider wird das Rendering on|übereinstimmenzeroninezer onine
Forty3
5

Retina , 24 23 Bytes

!`..[eox]|[fnz]...|.{5}

Probieren Sie es online! Bearbeiten: 1 Byte dank @FrownyFrog gespeichert.

Neil
quelle
1
würde .....-> .{5}arbeiten?
FrownyFrog
5

C 103 99 Bytes

char*r="f.tzuonresn.xgv";f(char*s){*s&&f(s+printf("%.*s ",(strrchr(r,s[2])-strchr(r,*s))%10,s)-1);}

Dies funktioniert für jede Zeichenkodierung (einschließlich umständlicher Zeichen wie EBCDIC), da der numerische Wert der eingegebenen Zeichen nicht verwendet wird. Stattdessen werden der erste und der dritte Buchstabe in einer magischen Zeichenfolge lokalisiert. Der Abstand zwischen diesen gibt an, wie viele Buchstaben bei jedem Ausdruck vorgeschoben werden müssen.

Testprogramm

#include <stdio.h>
int main(int argc, char **argv)
{
    for (int i = 1;  i < argc;  ++i) {
        f(argv[i]);
        puts("");
    }
}
Toby Speight
quelle
1
Einige Bytes können mithilfe der Rekursion gespeichert werden: tio.run/##XY/…
jxh
4

J , 37-35 Bytes

rplc'twthsiseeinionzef'(;LF&,)\~_2:

Probieren Sie es online!

FrownyFrog
quelle
2
Coole Alternativlösung! Ich habe es versucht f=:[:>'..[eox]|[tse]?....'&rxallund es hat in Interpeter funktioniert, aber in TIO funktioniert es nicht.
Galen Ivanov
Das ist wirklich klug, gut gemacht
Jonah
@GalenIvanov TIO hat die neueste Version, es könnte eine Regression in J.
FrownyFrog 21.11.17
4

C (gcc) , 106 Bytes, 104 Bytes

-2 Bytes dank @jxh

c;f(char*s){char*t=" $&=B*,29/?";while(*s)for(c=4+(strchr(t,(*s^s[1])+35)-t)/4;c--;)putchar(c?*s++:32);}

Probieren Sie es online!

XOR ist wirklich unser größter Verbündeter.

Gastropner
quelle
Wie der s ++ Trick. Netter Hasch.
Michael Dorgan
1
s[1]wird kürzer sein.
jxh
@ jxh Schöne! Aktualisiert.
Gastropner
3

Pip , 27 Bytes

aR`[zfs]|one|[ent][iwh]`s._

Übernimmt die Eingabe als Befehlszeilenargument. Probieren Sie es online!

Einfacher Regex-Austausch, fügt vor jedem Treffer ein Leerzeichen ein [zfs]|one|[ent][iwh].


Das Springen auf den Zug des Diebstahls von Uriels Regex ergibt 23 Bytes (mit -sFlagge):

a@`..[eox]|[tse]?....`
DLosc
quelle
Sie können einen kürzeren regulären Ausdruck verwenden .
Erik der Outgolfer 20.11.17
3

Jelly ,  23  21 Bytes

ḣ3OP%953%7%3+3ɓḣṄȧṫḊÇ

Ein vollständiges Programm, das zeilenweise getrennte Ausgaben druckt. Hinweis: Sobald dies erledigt ist, werden wiederholt leere Zeilen "für immer" ausgegeben (bis zu einer riesigen Rekursionsgrenze oder einem Seg-Fehler).

Probieren Sie es online! (TIO-Ausgabe wird akkumuliert, eine lokale Implementierung wird zeilenweise gedruckt.)

Wie?

Beginnend mit einer Liste von Zeichen wiederholt das Programm:

  1. Ermittelt die Länge des ersten Wortes in der Liste der Zeichen unter Verwendung von Ordinalmathematik.
  2. druckt das Wort plus Zeilenvorschub; und
  3. Entfernt das Wort aus dem Kopf der Zeichenliste

Die Länge des ersten Wortes wird bestimmt, indem die ersten drei Zeichen der aktuellen Zeichenliste (notwendigerweise Teil des ersten Wortes) überprüft werden. Das Programm konvertiert diese in Ordnungszahlen, multipliziert sie miteinander, moduliert das Ergebnis mit 953, moduliert das Ergebnis mit sieben, moduliert das Ergebnis mit drei und addiert drei:

word   head3  ordinals       product  %953  %7  %3  +3 (=len(word))
zero   zer    [122,101,114]  1404708   939   1   1   4
two    two    [111,110,101]  1233210    28   0   0   3
one    one    [116,119,111]  1532244   773   3   0   3
three  thr    [116,104,114]  1375296   117   5   2   5
four   fou    [102,111,117]  1324674     4   4   1   4
five   fiv    [102,105,118]  1263780   102   4   1   4
six    six    [115,105,120]  1449000   440   6   0   3
seven  sev    [115,101,118]  1370570   156   2   2   5
eight  eig    [101,105,103]  1092315   177   2   2   5
nine   nin    [110,105,110]  1270500   151   4   1   4

ḣ3OP%953%7%3+3ɓḣṄȧṫḊÇ - Main link, list of characters           e.g. "fiveeight..."
ḣ3              - head to index three                                "fiv"
  O             - ordinals                                           [102,105,118]
   P            - product                                            1263780
    %953        - modulo by 953                                      102
        %7      - modulo by seven                                    4
          %3    - modulo by three                                    1
            +3  - add three                                          4

              ɓ - dyadic chain separation swapping arguments...
... ḣṄȧṫḊÇ ...
    ḣ         - head to index                                        "five"
     Ṅ        - print the result plus a line-feed and yield the result
       ṫ      - tail from index                                      "eeight..."
      ȧ       - and (non-vectorising)                                "eeight..."
        Ḋ     - dequeue                                               "eight..."
         Ç    - call the last link (Main*) as a monad with this as input
              -       * since it's the only link and link indexing is modular.
Jonathan Allan
quelle
1
Ich bin mir nicht sicher, ob das erlaubt ist . (Im Ernst, was machen Sie, wenn zwei hochgeladene Meta-Antworten das Gegenteil bedeuten?)
Ørjan Johansen,
Das OP gibt explizit an, dass "Ihre Ausgabe optional auch solche Zeichenfolgen am Anfang oder Ende haben kann", und dieses Programm druckt tatsächlich so, wie es geht, sodass die Ausgabe ohnehin vor einer erzwungenen Beendigung erstellt wird.
Jonathan Allan
Sicher, aber ich denke nicht, dass OP eine unendliche Endzeichenfolge ist. In der Meta-Frage geht es explizit um den Fall, dass die Ausgabe zuerst gedruckt wird.
Ørjan Johansen
Ich denke, es erfüllt den Geist der Anforderung (wenn es zum Beispiel unendlich leere Zeichenfolgen gedruckt und dann die Worte, die ich argumentieren könnte, nicht)
Jonathan Allan
Also, ich denke, das bringt mich in Martins Lager von "Wenn es ein Programm ist und rechtfertigen kann ..." :)
Jonathan Allan
3

C 168 ,145,144141 Bytes

EDIT: Versucht init 'i' zu 1 wie so

a, b; main (i)

Um führende Whitespaces loszuwerden,
die bei Eingaben ab drei, sieben oder acht unterbrochen werden

141

#define s|a%1000==
a,i;main(b){for(;~scanf("%c",&b);printf(" %c"+!!i,b),a|=b%32<<5*i++)if(i>4|a%100==83 s 138 s 116 s 814 s 662 s 478)a=i=0;}

Probieren Sie es online aus

144

a,i;main(b){for(;~(b=getchar());printf(" %c"+!!i,b),a=a*21+b-100,++i)if(i>4|a==204488|a==5062|a==7466|a==23744|a==21106|a==6740|a==95026)a=i=0;}

Probieren Sie es online aus

168

i,a;main(b){for(;~scanf("%c",&b);printf(" %c"+!!i,b),a|=b<<8*i++)if(i>4|a==1869768058|a==6647407|a==7305076|a==1920298854|a==1702259046|a==7891315|a==1701734766)a=i=0;}

Probieren Sie es online!

Ungolfed

i,a;main(b){
for(;~scanf("%c",&b); // for every char of input
printf(" %c"+!!i,b), // print whitespace if i==0 , + char
a|=b<<8*i++ // add char to a for test
)
if(
i>4| // three seven eight
a==1869768058|      // zero
a==6647407|        // one
a==7305076|       // two
a==1920298854|   //four
a==1702259046|  //five
a==7891315|    //six
a==1701734766 //nine
) a=i=0; //reset i and a
}

int-Konstanten werden durch Verschieben von << 8 unnötig groß,
aber wenn Sie sich mit Strings vergleichen können, sollte dies die natürlichste sein

146 Stringvergleich verwenden

#define s|a==*(int*)
a,b;main(i){for(;~(b=getchar());printf(" %c"+!!i,b),a|=b<<8*i++)if(i>4 s"zero"s"one"s"two"s"four"s"five"s"six"s"nine")a=i=0;}

Verwenden des Zeichenfolgenvergleichs

Verschleiert

#define F(x)if(scanf(#x+B,&A)>0){printf(#x,&A);continue;}
B;A;main(i){for(;i;){B=1;F(\40e%4s)F(\40th%3s)F(\40se%3s)F(\40o%2s)B=2;F(\40tw%1s)F(\40si%1s)B=1;F(\40%4s)i=0;}}
PrincePolka
quelle
2

Jelly , 44 Bytes

Ṛ¹Ƥz⁶ZUwЀ“¢¤Ƙƒ⁺6j¹;Ċ-ḶṃżṃgɼṘƑUẏ{»Ḳ¤$€Ẏḟ1Ṭœṗ

Probieren Sie es online!

Erik der Outgolfer
quelle
3
Tut mir leid Mann, du wurdest zweimal überrumpelt.
Zacharý
2

Ganz schön lang. Sie können gerne Golf spielen.

R 109 Bytes

function(x)for(i in utf8ToInt(x)){F=F+i;cat(intToUtf8(i),if(F%in%c(322,340,346,426,444,448,529,536,545))F=0)}

Probieren Sie es online!

Djhurio
quelle
Gibt es eine Möglichkeit, Unicode-Zeichen anstelle von Ziffern zu verwenden?
Michael Dorgan
Schöne Bewerbung von intToUtf8! 90 Bytes wären mit einem anderen Ansatz unter Verwendung von Regexp möglich:function(x,p=paste,z=p("(",p(c("zero",broman::numbers),collapse="|"),")"))gsub(z,"\\1 ",x)
Michael M
2

Haskell , 81 Bytes

f[c]=[c]
f(h:t)=[' '|s<-words"z one tw th f s ei ni",and$zipWith(==)s$h:t]++h:f t

Probieren Sie es online!

Erläuterung:

f(h:t)=                      h:f t -- recurse over input string
   [' '|s<-               ]++      -- and add a space for each string s
      words"z one tw th f s ei ni" -- from the list ["z","one","tw","th","f","s","ei","ni"]
      ,and$zipWith(==)s$h:t        -- which is a prefix of the current string
Laikoni
quelle
2

Python 3 (kein regulärer Ausdruck) , 85 Byte

i=3
while i<len(s):
	if s[i-3:i]in'ineiveroneghtwoureesixven':s=s[:i]+' '+s[i:]
	i+=1

Probieren Sie es online!

Alex
quelle
2
Willkommen bei PPCG!
Laikoni
Es ist schön, aber ein vollständiges Programm muss den Code enthalten, um Eingaben zu erhalten.
Jonathan Allan
Also, als volles Programm 104 Bytes . Sie können jedoch 4 speichern, indem Sie verwenden, while s[i:]und dann können Sie dies durch Übermitteln eines rekursiven Werts auf 93 Byte reduzieren lambda(Funktionen müssen nur die Ausgabe zurückgeben, anstatt sie selbst zu drucken).
Jonathan Allan
2

Excel, 181 Bytes

=SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(A1,"z"," z"),"on"," on"),"tw"," tw"),"th"," th"),"f"," f"),"s"," s"),"ei"," ei"),"ni"," ni")

Platziert einen Raum vor: z, on, tw, th, f, s, ei,ni

Wernisch
quelle
2

Z80-Assembly, 46 - 45 Byte

; HL is the address of a zero-terminated input string
; DE is the address of the output buffer

Match5: ldi                                 ; copy remaining characters
Match4: ldi
Match3: ld a,32 : ld (de),a : inc de        ; and add space after a matched word.

Uncollapse:

        ld a,(hl) : ldi : or a : ret z      ; copy first byte (finish if it was zero)
        ex af,af'                           ; and save its value for later.

        ldi : ld a,(hl) : ldi               ; copy second and third bytes

        cp 'e' : jr z,Match3                ; is the third letter 'e' or 'o' or 'x'?
        cp 'o' : jr z,Match3
        cp 'x' : jr z,Match3

        ex af,af'                           ; now look at the first letter

        cp 'e' : jr z,Match5                ; is it 't' or 's' or 'e'?
        sub 's' : jr z,Match5
        dec a : jr z,Match5
        jr Match4

(Es hat Spaß gemacht, den kühlen Regex des Uriel an eine regex-unfreundliche Umgebung anzupassen).

introspec
quelle
1

Jelly , 40 bis 39 Bytes

“¢¤Ƙƒ⁺6j¹;Ċ-ḶṃżṃgɼṘƑUẏ{»Ḳe€€@ŒṖẠ€TḢịŒṖK

Probieren Sie es online!

Wie es funktioniert

“¢¤Ƙƒ⁺6j¹;Ċ-ḶṃżṃgɼṘƑUẏ{»Ḳe€€@ŒṖẠ€TḢịŒṖK
“¢¤Ƙƒ⁺6j¹;Ċ-ḶṃżṃgɼṘƑUẏ{»                 = the compressed string of the digit names
                        Ḳ                = split at spaces
                         e€€@ŒṖ          = check whether each member of each partition of the argument is a digit.
                               Ạ€        = A function that checks whether all values of an array are true, applied to each element.
                                 T       = Finds the index of each truthy element 
                                  Ḣ      = Grab the first element, since we have a singleton array
                                    ịŒṖ  = The previous command gives us the index, partition that splits the input into digits. This undoes it and gives us the partition.
                                       K = Join the array of digits with spaces                
Zacharý
quelle
1

Python 3 , kein regulärer Ausdruck,  83 68 65  63 Bytes

-15 danke an Lynn (Refaktor in eine einzelne Funktion)
-3 mehr danke an Lynn (vermeide das Indizieren in eine Liste mit mehr Arithmetik)
... was zu einer weiteren Einsparung von 2 Bytes führt (vermeide Klammern mit negativen Modulos) :)

def f(s):h=ord(s[0])*ord(s[1])%83%-7%-3+5;print(s[:h]);f(s[h:])

Eine Funktion, die die durch Zeilenumbrüche getrennten Wörter druckt und dann ein auslöst IndexError.

Probieren Sie es online! (unterdrückt die Ausnahmen, um mehrere Läufe innerhalb der Testsuite zuzulassen)

Jonathan Allan
quelle
Ich besuche dies viel später noch einmal und stelle fest, dass dies 68 Bytes sein könnten:def f(s):h=[4,5,3][ord(s[0])*ord(s[1])%83%7%3];print(s[:h]);f(s[h:])
Lynn
Oh wow, h(s)und h(s)wie habe ich das nicht bemerkt ?! Vielen Dank Lynn!
Jonathan Allan
Ich bin mir nicht sicher, wie ich immer wieder auf diese Frage zurückkomme und neue Dinge bemerke, aber h=(ord(s[0])*ord(s[1])%83%7+1)%3+3es sind 65 Bytes! :)
Lynn
Heh, danke Lynn, damit konnten auch zwei weitere Bytes abgespielt werden!
Jonathan Allan
0

Gelee , 36 Bytes

œṣj⁶;$}
W;“€ɗİẒmṫṃ¦¦ạỊɦ⁼Fḷeṭḷa»s2¤ç/

Probieren Sie es online!

Algorithmus:

for x in ['ze', 'ni', 'on', 'tw', 'th', ...]:
    replace x in input by space+x

Ich wette, wir können es noch besser machen.

Lynn
quelle
0

Mathematica, 125 Bytes

(s=#;While[StringLength@s>2,t=1;a="";While[FreeQ[IntegerName/@0~Range~9,a],a=s~StringTake~t++];Print@a;s=StringDrop[s,t-1]])&


Probieren Sie es online!

TIO gibt eine Fehlermeldung über "CountryData" (???) aus.
Ich weiß nicht, warum dies passiert, aber auf Mathematica funktioniert alles einwandfrei

J42161217
quelle
0

q / kdb + 59 51 Bytes

Lösung:

{asc[raze x ss/:string`z`one`tw`th`f`s`ei`ni]cut x}

Beispiel:

q){asc[raze x ss/:string`z`one`tw`th`f`s`ei`ni]cut x}"threesevensevensixninenineninefiveeighttwofiveeightsixthreeeight"
"three"
"seven"
"seven"
"six"
"nine"
"nine"
"nine"
"five"
"eight"
"two"
"five"
"eight"
"six"
"three"
"eight"

Erläuterung:

Schnelle Lösung, wahrscheinlich bessere und golffähigere Ansätze.

{asc[raze x ss/:string`z`one`tw`th`f`s`ei`ni]cut x} / ungolfed solution
{                                                 } / lambda with implicit x as input
                                             cut x  / cut x at indices given by left
 asc[                                       ]       / sort ascending
                string`z`one`tw`th`f`s`ei`ni        / string list ("z","one",...)
          x ss/:                                    / string-search left with each right
     raze                                           / reduce down list

Anmerkungen:

46 Bytes mit etwas einfachem Golfen, wobei q-Calls durch k-Calls ersetzt werden, aber immer noch eine gewaltige Lösung.

asc[(,/)x ss/:($)`z`one`tw`th`f`s`ei`ni]cut x:

Streetster
quelle