Tâche

Soit une chaîne de noms anglais de chiffres «collapsed» ensemble, comme ceci:

zeronineoneoneeighttwoseventhreesixfourtwofive

Fractionner la chaîne en chiffres:

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

Règles

• L'entrée est toujours une chaîne. Il se compose toujours d’un ou de plusieurs noms de chiffres anglais minuscules, regroupés et rien d’autre.

  • Les noms de chiffres anglais sont zero one two three four five six seven eight nine.

• La sortie peut être une liste de chaînes ou une nouvelle chaîne dont les chiffres sont délimités par des chaînes non alphabétiques et non vides. (Votre sortie peut aussi éventuellement avoir de telles chaînes au début ou à la fin, et les délimiteurs ne doivent pas nécessairement être cohérents. Ainsi, même quelque chose comme {{ zero0one$$two );est une réponse valide (si absurde) pour zeroonetwo.)

• La réponse la plus courte en octets l'emporte.

Cas de test

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

Rétine , 20 octets

!`..[eox]|[tse]?....

Essayez-le en ligne!

C (gcc) , 89 80 76 75 72 71 70 69 octets

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

Essayez-le en ligne!

(89) Crédit à gastropner pour le hachage XOR.
(76) Nous remercions Toby Speight d’ avoir eu l’idée d’utiliser 1st et 3rd.
(75) Nous remercions Michael Dorgan pour '0'→ 48.
(72) Nous remercions Michael Dorgan et Lynn pour des littéraux avec des caractères de contrôle.
(69) Nous remercions Lynn pour x?y:0→x&&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. */

Python 2 , 50 octets

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

Essayez-le en ligne!

-3 merci à Lynn .
-4 grâce à la réponse rationnelle d ' Uriel .

Befunge, 87 85 81 76 octets

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

Essayez-le en ligne!

Befunge ne contient aucune instruction de manipulation de chaîne, nous créons donc une sorte de hachage des trois derniers caractères rencontrés, lors de leur traitement.

Ce hachage est essentiellement un nombre à trois chiffres, base 104. Chaque fois qu'un nouveau caractère est lu, nous modifions le hachage avec 104 ² pour supprimer le caractère le plus ancien, nous le multiplions par 104 pour faire de la place pour le nouveau caractère, puis nous ajoutons la valeur ASCII du nouveau caractère mod 27 (pour être sûr il ne déborde pas).

À des fins de comparaison, prenons cette valeur mod 3817, écrivons-la en mémoire (en la tronquant à 8 bits), ce qui donne des nombres plus petits, plus faciles à gérer par Befunge. Les hachages avec lesquels nous devons alors comparer sont 0, 38, 59, 64, 88, 92, 114, 117 et 123. Si cela correspond, nous savons que nous avons rencontré une séquence de caractères marquant la fin d'un nombre, donc nous sortons un espace supplémentaire et réinitialisons le hachage à zéro.

Si vous vous demandez pourquoi la base 104 ou le mod 3817, ces valeurs ont été soigneusement choisies afin que la liste de hachage avec laquelle nous devions faire la comparaison puisse être représentée avec le moins d’octets possible.

Java (OpenJDK 8) , 55 46 43 octets

Économisez 9 octets grâce à Forty3 / FrownyFrog

Économiser 3 octets grâce à Titus

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

Essayez-le en ligne!

edit: Merci pour l'accueil et l'explication de lambdas!

C (gcc) , 179 159 146 139 137 137 116 107 103 102 octets

Edit 1: (Ajout des suggestions de M. Xcoder - merci! - Ma version macro a la même taille que la vôtre, mais j’aime mieux la vôtre.)

Éditer 2: Le caractère modifié se compare aux appels àstrchr()

Edit 3: Les déclarations de K & R's (Eww!)

Edit 4: Quand 1 macro ne suffit pas ...

Edit 5: Redone avec le nouvel algorithme suggéré ci-dessus. Merci à James Holderness pour cette idée géniale!

Edit 6: Suppression de 0 set car il semble y aller automatiquement - Techniques de golf de niveau maître utilisées (virgules, astuce printf, etc.) - Merci gastropner !

Edit 7: utilisez memchr et corrigez un bug signalé par James Holderness .

Edit 7: Utilisez &&le contrôle final pour remplacer ?- merci 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);}

Essayez-le en ligne!

Non-golfé (qui est toujours très golfy honnêtement ...)

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;
}

Solution de grep-esqe simple et ancienne:

#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(' ');}}

Ancienne version plus propre.

// 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(' ');
    }
}

Essayez-le en ligne!

JavaScript, 66 57 52 44 41 octets

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

Assez naïf, mais ça marche.

FrownyFrog attrape bien 2 caractères .. à l'exception de "un" pour lequel un contrôle pur de 2 caractères pourrait gâcher la zéronine. Edit: le simple fet sont été de bonnes prises par FrownyFrog que j'ai négligé mes deux premiers golfs.

Merci, Neil, pour la suggestion d’un lambda non nommé et le fait d’utiliser un seul caractère pour zdescendre à 52.

Titus propose un RegEx plus petit. Je sens que nous nous dirigeons éventuellement vers la regex d'Uriel.

Retina , 24 23 octets

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

Essayez-le en ligne! Edit: 1 octet enregistré grâce à @FrownyFrog.

C, 103 99 octets

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

Cela fonctionne pour tout encodage de caractères (y compris les encombrants comme EBCDIC), car il n'utilise pas la valeur numérique des caractères saisis. Au lieu de cela, il localise les première et troisième lettres dans une chaîne magique. La distance entre ceux-ci indique le nombre de lettres à avancer avec chaque impression.

Programme de test

#include <stdio.h>
int main(int argc, char **argv)
{
    for (int i = 1;  i < argc;  ++i) {
        f(argv[i]);
        puts("");
    }
}

J , 37 35 octets

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

Essayez-le en ligne!

C (gcc) , 106 octets 104 102 octets

-2 octets grâce à @jxh -2 octets grâce à ceilingcat

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

Essayez-le en ligne!

XOR est vraiment notre plus grand allié.

Retina , 28 octets

t[ewh]|[zfs]|(ni|o)ne|ei
 $&

Essayez-le en ligne!

Pyth , 35 27 23 octets

Économiser beaucoup d'octets en reportant l'approche d'Uriel .

:Q"..[eox]|[tse]?...."1

Essayez-le ici! Approche initiale

Pip , 27 octets

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

Prend l'entrée en tant qu'argument de ligne de commande. Essayez-le en ligne!

Remplacement de regex simple, insère un espace avant chaque match de [zfs]|one|[ent][iwh] .

Sautant dans le train de voler en empruntant la regex d'Uriel donne 23 octets (avec -sdrapeau):

a@`..[eox]|[tse]?....`

Gelée ,  23  21 octets

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

Un programme complet imprimant une sortie séparée par une ligne. Remarque: une fois que cela est fait, il imprime de manière répétée des lignes vides "pour toujours" (jusqu'à une limite de récursion énorme ou un seg-fault)

Essayez-le en ligne!(La sortie du TIO est accumulée, une implémentation locale imprimera ligne par ligne)

Comment?

En commençant par une liste de caractères, le programme répète:

1. trouve la longueur du premier mot de la liste de caractères en utilisant des mathématiques ordinales;
2. affiche le mot plus un saut de ligne; et
3. supprime le mot de l'en-tête de la liste de caractères

La longueur du premier mot est déterminée en inspectant les trois premiers caractères de la liste de caractères actuelle (nécessairement partie du premier mot). Le programme les convertit en ordinaux, les multiplie ensemble, modulos le résultat par 953, modulos par sept, modulos par trois et en ajoute trois:

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.

C 168 ,145,144, 141 octets

EDIT: essayé init 'i' à 1 comme si

a, b; principal (i)

Pour se débarrasser des grands espaces,
mais cela commence par trois, sept ou huit

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;}

Essayez-le en ligne

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;}

Essayez-le en ligne

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;}

Essayez-le en ligne!

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
}

Les constantes int deviennent inutiles en déplaçant un << 8,
mais si vous pouvez les comparer aux chaînes, cela devrait être le plus naturel

146 Utilisation de la comparaison de chaînes

#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;}

Utilisation de la comparaison de chaîne

Obscurci

#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;}}

Gelée , 44 octets

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

Essayez-le en ligne!

Un assez long. Vous êtes invités à jouer au golf.

R , 109 octets

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)}

Essayez-le en ligne!

Haskell , 81 octets

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

Essayez-le en ligne!

Explication:

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

Python 3 (sans regex) , 85 octets

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

Essayez-le en ligne!

Excel, 181 octets

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

Place un espace devant: z , on, tw, th, f, s, ei,ni

Z80 Assembly, 46 45 bytes

; 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

(C'était amusant d'adapter la regex cool d'Uriel à un environnement peu favorable aux regex).

Gelée , 40 à 39 octets

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

Essayez-le en ligne!

Comment ça fonctionne

“¢¤Ƙƒ⁺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                

QuadS , 21 à 20 octets

..[eox]|[tse]?....
&

Essayez-le en ligne!

Ceci est un port de ma réponse rétine .

APL (Dyalog Unicode) , 25 octets

'..[eox]|[tse]?....'⎕S'&'

Essayez-le en ligne!

Python 3 , sans regex,  83 68 65  63 octets

-15 grâce à Lynn (refactorisation dans une seule fonction)
-3 plus grâce à Lynn (éviter l'indexation dans une liste avec plus d'arithmétique)
... menant à une autre sauvegarde de 2 octets (évitant les parenthèses avec des modulos négatifs) :)

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

Une fonction qui imprime les mots séparés par des nouvelles lignes puis soulève un IndexError.

Essayez-le en ligne! (supprime les exceptions pour autoriser plusieurs exécutions dans la suite de tests)

Gelée , 36 octets

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

Essayez-le en ligne!

Algorithme:

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

Je parie que nous pouvons faire encore mieux.

Mathematica, 125 octets

(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]])&

Essayez-le en ligne!

TIO génère un message d'erreur à propos de "CountryData" (???).
Je ne sais pas pourquoi cela se produit, mais tout fonctionne bien pour Mathematica.

Perl 6 ,  42  30 octets

*.comb(/<{(0..9).Str.uninames.lc.words}>/)

Essaye-le

{m:g/..<[eox]>||<[tse]>?..../}

Testez-le
(Traduit d'autres réponses)

q / kdb +, 59 51 octets

Solution:

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

Exemple:

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"

Explication:

Solution rapide, probablement des approches meilleures et plus golfables.

{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

Remarques:

46 octets avec un peu de golf, remplaçant q appels par k, tout en restant une solution lourde.

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