Cifre non collassate

72

Compito

Data una serie di nomi inglesi di cifre "collassate" insieme, in questo modo:

zeronineoneoneeighttwoseventhreesixfourtwofive

Dividi la stringa in cifre:

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

Regole

  • L'input è sempre una stringa. Consiste sempre di uno o più nomi di cifre inglesi minuscoli, raggruppati insieme e nient'altro.

    • I nomi delle cifre inglesi sono zero one two three four five six seven eight nine.

  • L'output può essere un elenco di stringhe o una nuova stringa in cui le cifre sono delimitate da stringhe non alfabetiche e non vuote. (L'output può anche opzionalmente hanno tali stringhe all'inizio o alla fine, e i delimitatori non deve essere coerente. Quindi, anche qualcosa di simile a {{ zero0one$$two );un (se assurda) risposta valida per zeroonetwo.)

  • Vince la risposta più breve in byte.

Casi 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
code-golf  string 
— Lynn
fonte
28
Questa è una sfida eccellente! Il compito è estremamente facile da capire e da verificare, ma l'approccio giusto da usare non è molto ovvio. E scegliere l'approccio giusto potrebbe fare un'enorme differenza nel punteggio. +1 :)
— DJMcMayhem
1
Dopo averlo pensato, mi sono ricordato di una sfida simile, ma più semplicistica, sul golf dell'anarchia: sì ! Ha scatenato alcune sorprendenti risposte in C. Spero di vederne uno presto :)
— Lynn,
Non penso che la mia risposta in C si qualifichi come tale, ma spero sia un punto di partenza per gli altri con un senso dell'umorismo più contorto di me.
— Michael Dorgan,
Sono abbastanza sicuro di aver visto la stessa sfida, ma dove dovresti stampare il numero reale. Sono quasi certo che sia stato pubblicato anche da te, Lynn; ma ho perso il collegamento, mi colleghi con esso?
— Magic Octopus Urn
3
@MichaelDorgan (o qualsiasi altro programmatore C), potresti voler dare un'occhiata all'algoritmo che ho usato nella mia risposta di Befunge. Una conversione diretta di questo in C mi ha procurato una soluzione da 104 byte, che a mio avviso batte tutte le risposte C esistenti. Sono disposto a scommettere che potrebbe essere migliorato da qualcuno con più abilità nel golf C.
— James Holderness,

Risposte:

17

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

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

Provalo online!

(89) Ringraziamo il gastropner per l'hash XOR.
(76) Ringraziamo Toby Speight per l'idea di usare il 1o e il 3o.
(75) Ringraziamo Michael Dorgan per '0'→ 48.
(72) Ringraziamo Michael Dorgan e Lynn per i letterali con personaggi di controllo.
(69) Ringraziamo Lynn per 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. */
— JXH
fonte
11

Python 2 , 50 byte

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

Provalo online!

-3 grazie a Lynn .
-4 grazie a Uriel 's risposta regex' s.

— Erik the Outgolfer
fonte
3
Bello! import re;re.compile('…').findalldovrebbe salvare un paio di byte. Mi aspettavo che questo si trasformasse in regex golf :)
— Lynn,
@Lynn Aspetta, aspetta fino a quando ho finito! :-P EDIT: in realtà sono 3 byte.
— Erik the Outgolfer,
@Lynn Inoltre, avresti dovuto invece trasformarlo in code-golf espressione regolare . ;)
— Erik the Outgolfer,
Sto aspettando una risposta in C, che sarà molto interessante!
— Lynn,
9

Befunge, 87 85 81 76 byte

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

Provalo online!

Befunge non ha alcuna istruzione di manipolazione delle stringhe, quindi quello che facciamo è creare una specie di hash degli ultimi tre caratteri incontrati, mentre li stiamo elaborando.

Questo hash è essenzialmente un numero di tre cifre, base-104. Ogni volta che viene letto un nuovo personaggio, modiamo l'hash con 104 2 per sbarazzarci del personaggio più vecchio, moltiplicandolo per 104 per fare spazio al nuovo personaggio, quindi aggiungere il valore ASCII del nuovo personaggio mod 27 (per essere sicuri non trabocca).

A scopo di confronto, prendiamo questo valore mod 3817, lo scriviamo in memoria (troncandolo così a 8 bit), il che si traduce in numeri più piccoli che sono più facili da gestire per Befunge. Gli hash che dobbiamo quindi confrontare sono 0, 38, 59, 64, 88, 92, 114, 117 e 123. Se corrisponde a uno di questi, sappiamo che abbiamo riscontrato una sequenza di caratteri che segna la fine di un numero, quindi abbiamo generato uno spazio aggiuntivo e azzerato l'hash.

Se ti stai chiedendo perché la base 104, o perché la mod 3817, quei valori sono stati scelti con cura in modo che l'elenco di hash che dovevamo confrontare potesse essere rappresentato nel minor numero di byte possibile.

— James Holderness
fonte
Onestamente, questo mi sembra bakemoji (ば け も じ) per me. Wow. La descrizione dell'algoritmo è buona e la contemplerò.
— Michael Dorgan,
^, Ricordo di aver visto il termine come mojibake (も じ ば け). Come hai trovato quei numeri (base 104, mod 3187), @JamesHolderness?
— Zacharý,
@ Zacharý Ho scritto un piccolo script Python che ha testato diverse combinazioni di base e mod per trovare quelle che avrebbero prodotto i risultati corretti se eseguite su tutti gli input previsti. Una volta saputo quali combinazioni funzionavano, ho eseguito gli output hash risultanti attraverso un generatore di numeri Befunge per scoprire quale producesse il codice più corto.
— James Holderness,
6

Java (OpenJDK 8) , 55 46 43 byte

Risparmio di 9 byte grazie a Forty3 / FrownyFrog

Salvataggio di 3 byte grazie a Titus 

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

Provalo online!

modifica: Grazie per l'accoglienza e la spiegazione di lambdas!

— Luca H.
fonte
3
Ciao, benvenuto in PPCG! Ottima prima risposta, e funziona davvero. Ecco il link TIO per questo. Le lambda possono essere create in più modi. Ecco un altro TIO con alcuni lambda con commenti aggiunti in modo da poter vedere come crearli da soli. (Suggerisco di copiarlo su Eclipse in modo da poter vedere l'evidenziazione del codice.) Inoltre, Suggerimenti per giocare a golf in Java e Suggerimenti per giocare a golf in tutte le lingue potrebbero essere interessanti da leggere. Goditi la permanenza! :)
— Kevin Cruijssen,
@KevinCruijssen grazie! Sono sinceramente sorpreso che Java sia più corto di JavaScript. Di solito quando leggo le sfide, JS è molto più breve.
— Luca H,
JavaScript dovrebbe essere più corto di 2 byte ( gsuffisso regex anziché All).
— Neil,
@Neil è più lungo qui perché sta usando f=(s)=>invece di s->, che è di 4 byte in meno.
— Luca H,
1
@LucaH - su suggerimento di FrownyFrog, puoi ridurre alcune stringhe di due lettere a caratteri singoli: z | f | s invece di ze | fo | fi | si | se /
— Forty3
6

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

Modifica 1: (Aggiunti suggerimenti da Mr. Xcoder - grazie! - La mia versione macro aveva le stesse dimensioni della tua, ma mi piace di più la tua.)

Modifica 2: l' individuo char modificato viene confrontato con le chiamate astrchr()

Modifica 3: K & R sono le dichiarazioni var (Eww!)

Modifica 4: quando 1 macro non è sufficiente ...

Modifica 5: rifatto con il nuovo algoritmo suggerito sopra. Grazie a James Holderness per questa fantastica idea!

Modifica 6: rimosso 0 impostato come sembra andare lì automaticamente - Tecniche di golf con codice di livello master utilizzate (virgole, trucco di stampa , ecc.) - grazie gastropner !

Modifica 7: Usa memchr e risolto un bug segnalato da James Holderness .

Modifica 7: utilizzare &&il controllo finale per sostituire ?- grazie 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);}

Provalo online!

Non golf (che è ancora molto golfy onestamente ...)


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

Vecchia soluzione grep-esqe semplice:

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

Versione vecchia e più pulita.

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

Provalo online!

— Michael Dorgan
fonte
Possiamo macro putchar e simili per pochi byte, ma in generale, se possibile, stiamo ancora pensando a un algoritmo migliore.
— Michael Dorgan,
159 byte di #defineing putchare rimozione di una coppia di staffe inutili.
— Mr. Xcoder,
2
Un po 'brutto, ma 136 byte usando #define p putchar(invece (notare la parentesi aperta).
— Tom Carpenter,
1
109 bytec,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, il trucco di stampa che ho visto di seguito più la rimozione di una parentesi e parentesi graffe. Codice golf livello master abilitato :)
— Michael Dorgan,
5

JavaScript, 66 57 52 44 41 byte

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

Abbastanza ingenuo, ma funziona.

Bella cattura di FrownyFrog per usare 2 caratteri ... tranne "uno" che un controllo di 2 caratteri puro potrebbe rovinare la zeronina. Modifica: il singolo fed serano buone catture da FrownyFrog che ho trascurato i miei primi due campi da golf.

Grazie, Neil, per il suggerimento di un lambda senza nome e per essere in grado di usare un solo carattere per zarrivare a 52.

Titus ha un RegEx più piccolo. Sento che alla fine ci stiamo dirigendo verso la regex di Uriel.

— Forty3
fonte
Si rompe se si usano due personaggi e si spinge "on" fino alla fine?
— FrownyFrog,
Sto pensandoz|tw|th|f|s|ei|ni|on
— FrownyFrog il
1
@FrownyFrog o viene prima di tutto, quindi viene riconosciuto per primo.
— Uriel,
1
on|t[wh]|.i|[fsz](-4 byte)
— Tito
2
@Titus - Sfortunatamente, il rendering on|corrisponderàzeroninezer onine
— Forty3
5

C, 103 99 byte

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

Funziona con qualsiasi codifica di caratteri (compresi quelli imbarazzanti come EBCDIC), perché non utilizza il valore numerico dei caratteri di input. Invece, individua la prima e la terza lettera in una stringa magica. La distanza tra questi indica quante lettere avanzare con ciascuna stampa.

Programma di test

#include <stdio.h>
int main(int argc, char **argv)
{
    for (int i = 1;  i < argc;  ++i) {
        f(argv[i]);
        puts("");
    }
}
— Toby Speight
fonte
1
Alcuni byte possono essere salvati usando la ricorsione: tio.run/##XY/…
— jxh
4

J , 37 35 byte

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

Provalo online!

— FrownyFrog
fonte
2
Fantastica soluzione alternativa! Ho provato f=:[:>'..[eox]|[tse]?....'&rxalle ha funzionato nell'interpeter, ma non funziona in TIO.
— Galen Ivanov,
è davvero intelligente, ben fatto
— Giona,
@GalenIvanov TIO ha l'ultima versione, potrebbe essere una regressione in J.
— FrownyFrog
3

Gelatina ,  23  21 byte

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

Un output separato per la stampa a riga di programma completa. Nota: una volta terminato, stampa ripetutamente linee vuote "per sempre" (fino a quando un enorme limite di ricorsione o un errore di seg)

Provalo online! (L'output TIO viene accumulato, un'implementazione locale verrà stampata riga per riga)

Come?

A partire da un elenco di caratteri, il programma ripetutamente:

  1. trova la lunghezza della prima parola dell'elenco di caratteri usando una matematica ordinale;
  2. stampa la parola più un avanzamento riga; e
  3. rimuove la parola dalla testa dell'elenco di caratteri

La lunghezza della prima parola viene decisa controllando i primi tre caratteri dell'elenco corrente di caratteri (necessariamente parte della prima parola). Il programma li converte in ordinali, li moltiplica insieme, modula il risultato per 953, moduli per sette, moduli per tre e aggiunge tre:

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
fonte
1
Non sono sicuro che sia permesso . (Seriamente, cosa fai quando due meta-risposte fortemente votate dicono il contrario l'una dell'altra?)
— Ørjan Johansen
L'OP afferma esplicitamente "L'output può anche avere tali stringhe all'inizio o alla fine" e questo programma effettivamente stampa come va, quindi l'output viene prodotto prima di qualsiasi terminazione forzata comunque.
— Jonathan Allan,
Certo, ma non credo che OP abbia considerato una stringa di fine infinita. E la meta-domanda riguarda esplicitamente il caso in cui l'output viene stampato per primo.
— Ørjan Johansen,
Penso che soddisfi lo spirito del requisito (se, ad esempio, stampasse infinite stringhe vuote e quindi le parole che potrei sostenere non lo facessero)
— Jonathan Allan,
Quindi, immagino che questo mi metta nel campo di Martin "se è un programma e può giustificare ..." :)
— Jonathan Allan,
3

C 168 ,145,144, 141 byte

EDIT: ho provato init 'i' a 1 in questo modo

a, b; principale (i)

Per sbarazzarsi dello spazio bianco principale,
ma si interrompe sull'input a partire da tre, sette o otto

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

Provalo online

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

Provalo online

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

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

le costanti int diventano inutilmente grandi spostando un << 8
ma nel caso in cui sia possibile confrontare con le stringhe in qualche modo dovrebbe essere il più naturale

146 Uso del confronto delle stringhe

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

Utilizzo del confronto stringhe

offuscato 

#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
fonte
2

Abbastanza lungo. Sei il benvenuto a golf giù.

R , 109 byte

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

Provalo online!

— djhurio
fonte
Qualche modo di usare caratteri unicode invece di cifre?
— Michael Dorgan,
Bella applicazione di intToUtf8! 90 byte sarebbero possibili usando un approccio diverso usando regexp:function(x,p=paste,z=p("(",p(c("zero",broman::numbers),collapse="|"),")"))gsub(z,"\\1 ",x)
— Michael M
2

Haskell , 81 byte

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

Provalo online!

Spiegazione:

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
fonte
2

Python 3 (no regex) , 85 byte

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

Provalo online!

— alex
fonte
2
Benvenuti in PPCG!
— Laikoni,
È bello, ma un programma completo deve includere il codice per accettare l'input.
— Jonathan Allan,
Quindi, come programma completo 104 byte . Tuttavia, è possibile salvare 4 utilizzando while s[i:]e quindi è possibile ottenere fino a 93 byte inviando un ricorsivo lambda(le funzioni devono solo restituire l'output anziché stamparlo da soli).
— Jonathan Allan,
2

Excel, 181 byte

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

Inserisce uno spazio di fronte: z, on, tw, th, f, s, ei,ni

— Wernisch
fonte
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

(È stato divertente adattare la fantastica regex di Uriel a un ambiente ostile alla regex).

— introspec
fonte
1

Gelatina , 40 39 byte

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

Provalo online!

Come funziona

“¢¤Ƙƒ⁺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
— Zaccaria
fonte
1

Python 3 , no regex,  83 68 65  63 byte

-15 grazie a Lynn (refactor in una singola funzione)
-3 grazie a Lynn (evita di indicizzare in un elenco con più aritmetica)
... portando ad un altro salvataggio di 2 byte (evitando parentesi con moduli negativi) :)

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

Una funzione che stampa le parole separate da nuove righe e quindi genera un IndexError.

Provalo online! (elimina le eccezioni per consentire più esecuzioni all'interno della suite di test)

— Jonathan Allan
fonte
Lo sto rivisitando molto più tardi e realizzando che questo potrebbe essere di 68 byte: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)e h(s)come non me ne sono accorto ?! Grazie Lynn!
— Jonathan Allan,
Non sono sicuro di come torno a questa domanda e di notare cose nuove, ma h=(ord(s[0])*ord(s[1])%83%7+1)%3+3è di 65 byte! :)
— Lynn,
Heh, grazie Lynn, che ha permesso di salvare anche altri due byte!
— Jonathan Allan,
0

Gelatina , 36 byte

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

Provalo online!

Algoritmo:

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

Scommetto che possiamo fare ancora meglio.

— Lynn
fonte
0

Mathematica, 125 byte

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


Provalo online!

TIO emette un messaggio di errore su "CountryData" (???)
Non so perché questo accada, ma tutto funziona bene su Mathematica

— J42161217
fonte
0

q / kdb +, 59 51 byte

Soluzione:

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

Esempio:

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"

Spiegazione:

Soluzione rapida, probabilmente migliori e più approcci golfabili.

{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

Appunti:

46 byte con un po 'di golf semplice, sostituendo q chiamate con k, ma comunque una soluzione pesante.

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

— streetster
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.