Una parola cifra è una parola in cui, dopo aver eventualmente rimosso alcune lettere, viene lasciata una delle singole cifre: UNA, DUE, TRE, QUATTRO, CINQUE, SEI, Sette, Otto e Nove (non ZERO).

Ad esempio, BOUNCE e ANNOUNCE sono parole con cifre, poiché contengono quelle con una cifra.

ENCODE non è una parola cifra, anche se contiene una O, N ed E, poiché non sono in ordine.

Scrivi un programma / funzione che accetta una singola parola (maiuscola o minuscola - a tua scelta) come input o come parametro e determina se è una parola cifra. Rendi il codice il più breve possibile.

Se la parola non è una cifra, dovresti restituire "NO", 0 o qualsiasi valore "falso" (ciò può variare in base alla tua lingua). Se la parola è una parola cifra, dovresti generare la cifra che contiene, come un numero.

Puoi presumere che nessuna parola contenga più di una cifra, quindi non avrai nulla come ONFIVE.

Casi test

BOUNCE
1

ENCODE
NO

EIGHT
8

BLACKJACK
NO

FABULOUS
NO

EXERCISE
NO

DRIFTWOOD
2

SERVICEMAN
7

INSIGNIFICANCE
9

THROWDOWN
2

ZERO
NO

OZNERO
1

Questa sfida è presa da (ed è una modesta modifica) della domanda 1 di BIO 2009 . La maggior parte dei casi di test sono tratti dallo schema dei marchi .

Javascript (ES6), 101 99 byte

f=
s=>-~'ONE TWO THREE FOUR FIVE SIX SEVEN EIGHT NINE'.split` `.findIndex(x=>s.match([...x].join`.*`))

<!-- snippet demo: -->
<input list=l oninput=console.log(f(this.value))>
<datalist id=l><option value=BOUNCE>
<option value=ENCODE>
<option value=EIGHT>
<option value=BLACKJACK>
<option value=FABULOUS>
<option value=EXERCISE>
<option value=DRIFTWOOD>
<option value=SERVICEMAN>
<option value=INSIGNIFICANCE>
<option value=THROWDOWN>
<option value=ZERO>
<option value=OZNERO>

PHP> = 7.0, 87 byte

<?for(;$i++<9;)levenshtein(IntlChar::charName("$i"),"DIGIT $argn",0,1,1)?:die("$i")?>NO

Se si eseguono solo inserimenti di caratteri da una cifra come parola all'input, uscire dal programma con la cifra. Oppure modifica l'ordine per levenshtein("DIGIT $argn",IntlChar::charName("$i"),1,1,0)non conteggiare le eliminazioni di caratteri

levenshtein

IntlChar :: charName

PHP> = 7.0, 112 byte

for(;$i<9;)$r+=++$i*preg_match("#".chunk_split(substr(IntlChar::charName("$i"),6),1,".*")."#",$argn);echo$r?:NO;

IntlChar :: charName

PHP, 128 byte

foreach([ONE,TWO,THREE,FOUR,FIVE,SIX,SEVEN,EIGHT,NINE]as$v)$r+=++$k*preg_match("#".chunk_split($v,1,".*")."#",$argn);echo$r?:NO;

Provalo online!

143 byte per più di 1 cifra

foreach([ONE,TWO,THREE,FOUR,FIVE,SIX,SEVEN,EIGHT,NINE]as$v)$r.=++$k*preg_match("#".chunk_split($v,1,".*")."#",$argn);echo+$r?strtr($r,[""]):NO;

Provalo online!

Python 3, 150 byte

from itertools import*;lambda x:([i for i in range(10)if(*' OTTFFSSENNWHOIIEIIEORUVXVGN  ERE EHE  E   NT '[i::9],)in[*combinations(x+'  ',5)]]+[0])[0]

combinationsrestituisce tutte le combinazioni di cose in ordine. Sarebbe più semplice avere un numero impostato per il secondo parametro di combinations, quindi gli spazi vengono aggiunti alla fine della stringa originale che è un parametro della mia lambda. Questa è una semplice descrizione di come funziona la mia voce. Chiedi se desideri ulteriori chiarimenti.

Mathematica, 83 byte (codifica Windows ANSI)

±w_:=Rest@Position[Subsets@w~Cases~#&/@Characters@*IntegerName~Array~9,Except@{},1]

Definisce una funzione unaria ±che accetta come input un elenco di caratteri minuscoli e restituisce una cifra, in una forma simile {{7}}, oppure un elenco vuoto {}. Non mi sento di aver fatto un sacco di cose da golf qui, tranne per il fatto che Characters@*IntegerName~Array~9genera le partite nome-numero da cercare senza codificarle.

Esempio di utilizzo:

±{"i", "n", "s", "i", "g", "n", "i", "f", "i", "c", "a", "n", "c", "e"}

rese {{9}}.

Gelatina , 31 28 byte

-2 byte ora che l'input in minuscolo è accettabile

“¡¦ẇṆb~ṇjṚØ%ĖġṘḥḞṾṇJḌ»Ḳe€ŒPT

Un programma completo che prevede input in minuscolo e stampa il risultato, usando 0per il caso false.

Come un collegamento monadico che prende un elenco di caratteri, in realtà restituisce un elenco di numeri interi che contiene un singolo 0nel caso false, un singolo numero intero compreso 1e 9compreso nei casi d'uso previsti e più voci simili nei casi in cui esiste più di un numero nel parola.

Provalo online!

Come?

“¡¦ẇṆb~ṇjṚØ%ĖġṘḥḞṾṇJḌ»Ḳe€ŒPT - Main link: list of characters, s
“¡¦ẇṆb~ṇjṚØ%ĖġṘḥḞṾṇJḌ»       - dictionary lookup of "one two three four five six seven eight nine"
                      Ḳ      - split on spaces
                         ŒP  - partitions of s
                       e€    - exists in? for €ach
                           T - truthy indexes

Ruby + to_words : 49 48 + 12 = 61 60 byte

Usa le bandiere -rto_words -n. Accetta le lettere minuscole. Restituisce nilse non viene trovata alcuna "cifra".

-1 byte ora che è consentito l'input in minuscolo, consentendo la rimozione del iflag sul regex.

p (1..9).find{|i|$_=~/#{i.to_words.chars*".*"}/}

Per una risposta Ruby più pura senza gemme esterne, 91 + 1 = 92 byte:

p (1..9).find{|i|$_=~/#{%w"0 ONE TWO THREE FOUR FIVE SIX SEVEN EIGHT NINE"[i].chars*".*"}/}

05AB1E , 26 byte

Il valore di falsy qui è 0 .

æ‘€µ‚•„í†ìˆÈŒšï¿Ÿ¯¥Š‘#å1k>

Spiegazione:

æ                           # Compute the powerset of the input
 ‘€µ‚•„í†ìˆÈŒšï¿Ÿ¯¥Š‘       # Push "ONE TWO THREE FOUR FIVE SIX SEVEN EIGHT NINE"
                     #      # Break on spaces
                      å     # Check each for membership
                       1k   # Get the index of 1 in the array (-1 if not found)
                         >  # Increment by one

Utilizza la codifica 05AB1E . Provalo online! oppure Verifica tutti i casi di test!

Haskell, 113 111 byte

import Data.List
last.((`elemIndices`([]:words"ONE TWO THREE FOUR FIVE SIX SEVEN EIGHT NINE"))=<<).subsequences

Provalo online!

Restituisce 0se non viene trovata alcuna cifra.

Trova tutte le sottosequenze della parola di input nell'elenco delle cifre. Prepara una stringa vuota []all'indice 0 che fa parte di ogni sottosequenza. elemIndicesrestituisce un elenco di indici e =<<li appiattisce in un unico elenco. Scegli l'ultimo indice.

JavaScript (ES6), 121 byte

f=
s=>[...s].map(c=>a=a.map(s=>s.slice(s[0]==c)),a=`ONE TWO THREE FOUR FIVE SIX SEVEN EIGHT NINE`.split` `)&&1+a.indexOf(``)

<input oninput=o.textContent=f(this.value)><pre id=o>0

Restituisce la cifra rilevata più bassa o 0se non è stata rilevata alcuna cifra (+6 se NOnecessario).

Japt , 52 byte

1+`e two È(e fŒr five £x  v eight ͍`¸a@v fX¬q".*

Provalo online!

Retina , 160 126 120 byte

O.*N.*E
1
T.*W.*O
2
T.*H.*R.*E.*E
3
F.*O.*U.*R
4
F.*I.*V.*E
5
S.*I.*X
6
S.*E.*V.*E.*N
7
E.*I.*G.*H.*T
8
N.*I.*N.*E
9
\D

Provalo online!

Restituisce una stringa vuota se l'input non contiene una cifra.

-6 byte grazie a @CalculatorFeline .

PHP, 134 132 128 byte

<?=preg_match(strtr(chunk_split("#(ONE0TWO0THREE0FOUR0FIVE0SIX0SEVEN0EIGHT0NINE",1,".*"),[")|("]).")#",$argn,$m)?count($m)-1:NO;

esegui come pipe -nFo provalo online .

Crea una regex con le parole tra parentesi; cioè ogni parola Nè nella Nsottoespressione.
Se viene trovata una parola, la stringa corrispondente sarà dentro $m[0]e nell'elemento Nth, con gli elementi tra loro vuoti e nessuna stringa vuota dietro; cioè $mha N+1elementi.

Python , 148 byte

from itertools import*
lambda s:[tuple(w)in combinations(s,len(w))for w in("x ONE TWO THREE FOUR FIVE SIX SEVEN EIGHT NINE "+s).split()].index(1)%10

Una funzione senza nome che prende una sola parola maiuscola e restituisce il numero intero ( 1a 9) o 0per NO.

Provalo online!

Come?

Per una stringa di input sdella funzione attraversa attraverso una lista delle stringhe: "x", "ONE", "TWO", "THREE", "FOUR", "FIVE", "SIX", "SEVEN", "EIGHT", "NINE", e s. Se stessa alla ricerca di eventuali corrispondenze *

Il confronto utilizzato è se questa stringa, wè una che può essere formata da una combinazione di lettere in ordine dall'input. La funzione li combinationsottiene per noi (e solo quelli della lunghezza richiesta usando len(w)), ma sono in forma di tuple, quindi le stringhe vengono espresse in tuple per il confronto.

Degli undici risultati, quello per "x"sempre sarà False, mentre quello per ssé sarà sempre True. L' "x"è lì per garantire l'indice di una partita con ONEattraverso NINEsono i valori richiesti (poiché liste Python sono 0-indicizzato), il sc'è da assicurare la chiamata a index(1)(sinonimo index(True)) WONT sicuro quando nessuna parola cifre stato trovato, dopo di che la risultante 10viene convertito in a 0con un modulo di dieci usando %10.

* Se scontiene spazi per qualche motivo, l'elenco di ws sarà più lungo, ma il processo continuerà a funzionare poiché le corrispondenze delle parole delle cifre funzioneranno allo stesso modo, e se nessuna corrisponde alla prima sottostringa suddivisa nello spazio scorrisponderà, ancora una volta dando 10e ritorno 0.

Se sono presenti parole a più cifre, la funzione restituirà quella minima.

Java, 167 153 byte

s->{for(int i=0;i<9;)if(s.matches(".*"+"".join(".*","ONE TWO THREE FOUR FIVE SIX SEVEN EIGHT NINE".split(" ")[i++].split(""))+".*"))return i;return"NO";}

Un'implementazione piuttosto ingenua, corrispondente su regex.

Test e non golf

import java.util.function.Function;

public class Main {

  public static void main(String[] args) {
    Function<String, Object> f = s -> {
      for (int i = 0; i < 9;) {
        if (s.matches(".*" + "".join(".*", "ONE TWO THREE FOUR FIVE SIX SEVEN EIGHT NINE".split(" ")[i++].split("")) + ".*")) {
          return i;
        }
      }
      return "NO";
    };

    String[] tests = {
      "BOUNCE",
      "ENCODE",
      "EIGHT",
      "BLACKJACK",
      "FABULOUS",
      "EXERCISE",
      "DRIFTWOOD",
      "SERVICEMAN",
      "INSIGNIFICANCE",
      "THROWDOWN",
      "ZERO",
      "OZNERO"
    };

    for (String test : tests) {
      System.out.printf("%s%n%s%n%n", test, f.apply(test));
    }
  }
}

Salva

• 167 -> 153: varie ottimizzazioni grazie a @KevinCruijssen

Bash , 163 byte

a=NO;case $1 in *O*N*E*)a=1;;*T*W*O*)a=2;;*T*H*R*E*E*)a=3;;*F*O*U*R*)a=4;;*F*I*V*E*)a=5;;*S*I*X*)a=6;;*S*E*V*E*N*)a=7;;*E*I*G*H*T*)a=8;;*N*I*N*E*)a=9;;esac;echo $a

Provalo online!

a=NO;
case $1 in
 *O*N*E*)a=1;;
 *T*W*O*)a=2;;
 *T*H*R*E*E*)a=3;;
 *F*O*U*R*)a=4;;
 *F*I*V*E*)a=5;;
 *S*I*X*)a=6;;
 *S*E*V*E*N*)a=7;;
 *E*I*G*H*T*)a=8;;
 *N*I*N*E*)a=9;;
esac;
echo $a

Non conosco RETINA ma sembra una porta diretta di quella risposta.

Javascript, 121 byte

(s,a=0)=>'ONE TWO THREE FOUR FIVE SIX SEVEN EIGHT NINE'.split``.map((p,i)=>RegExp(p.split``.join`.*`).exec(s)?a=i+1:0)&&a

o 116

(s,a=0)=>' ONE TWO THREE FOUR FIVE SIX SEVEN EIGHT NINE'.split` `.map((p,i)=>a|=~s.search(p.split``.join`.*`)&&i)&&a

Ma a questo punto basta riciclare materiale.

Pyth , -44- 41 byte

+1xm}dyQc."EX%~)Û#lº,îQÓCe¯4Aô4"\P1

Accetta una stringa tra virgolette, genera 0 per NO.

Provalo!

spiegazione

+1xm}dyQc."EX%~)Û#lº,îQÓCe¯4Aô4"\P1
         ."EX%~)Û#lº,îQÓCe¯4Aô4"      # Compressed string: "ONEPTWOPTHREEPFOURPFIVEPSIXPSEVENPEIGHTPNINE" (P is close to the other letters, makes the compression better)
        c                       \P    # split on P: ['ONE', 'TWO', 'THREE', 'FOUR', 'FIVE', 'SIX', 'SEVEN', 'EIGHT', 'NINE']
   m                                  # map over this list (variable: d)
    }dyQ                              # is d a (ordered) subset of the input (Q)? (= element of the powerset)
  x                                1  # get the index of the first true
+1                                    # add one, because the list was indexed at 0 and conveniently -1 (not found) becomes 0 

Java, 254 byte

int g(String a,String b){int i=0,p=0;for(char c:a.toCharArray()){p=i;i=b.indexOf(c);if(i<=p)return 0;}return 1;}
String f(String a){String[]T={"ONE","TWO","THREE","FOUR","FIVE","SIX","SEVEN","EIGHT","NINE"};for(String t:T)if(g(t,a)>0)return t;return"NO";}

Prova online

boolean g(String a,String b)
{
    int i = 0, p = 0;
    for(char c:a.toCharArray())
    {
        p = i;
        i = b.indexOf(c);
        if(i <= p) return false;
    }
    return true;
}

String f(String a)
{
    String[]T={"ONE","TWO","THREE","FOUR","FIVE","SIX","SEVEN","EIGHT","NINE"};
    for(String t:T)if(g(t,a))return t;
    return"NO";
}

C, 198 byte

Prova online

char*T[]={"ONE","TWO","THREE","FOUR","FIVE","SIX","SEVEN","EIGHT","NINE"};
g(char*a,char*b){while(*a&*b)a+=(*b++==*a);return!*a;}
i;char*f(char*b){for(i=0;i<9;i++)if(g(T[i],b))return T[i];return"NO";}

Python 2, 155 byte

import re;lambda k:next((i for i,j in enumerate([re.search('.*'.join(list(s)),k)for s in'ONE TWO THREE FOUR FIVE SIX SEVEN EIGHT NINE'.split()])if j),-1)+1

Una funzione anonima che cerca un gruppo regex. Non la migliore soluzione qui in Python ma un modo alternativo.