Una palabra de dígito es una palabra en la que, después de eliminar algunas letras, queda uno de los dígitos individuales: UNO, DOS, TRES, CUATRO, CINCO, SEIS, SIETE, OCHO o NUEVE (no CERO).

Por ejemplo, BOUNCE y ANNOUNCE son palabras de dígitos, ya que contienen el dígito uno.

ENCODE no es una palabra de dígitos, aunque contiene una O, N y E, ya que no están en orden.

Escriba un programa / función que tome una sola palabra (mayúscula o minúscula - usted elija) como entrada o parámetro y determine si es una palabra de dígitos. Haz el código lo más corto posible.

Si la palabra no es una palabra de dígitos, debe devolver 'NO', 0 o cualquier valor 'falsey' (esto puede variar según su idioma). Si la palabra es una palabra de dígitos, debe generar el dígito que contiene, como un número.

Puede suponer que ninguna palabra contiene más de un dígito, por lo que no tendrá nada como ONFIVE.

Casos de prueba

BOUNCE
1

ENCODE
NO

EIGHT
8

BLACKJACK
NO

FABULOUS
NO

EXERCISE
NO

DRIFTWOOD
2

SERVICEMAN
7

INSIGNIFICANCE
9

THROWDOWN
2

ZERO
NO

OZNERO
1

Este desafío se toma (y es una modificación muy leve de) la Pregunta 1 de BIO 2009 . La mayoría de los casos de prueba se toman del esquema de marcas .

Javascript (ES6), 101 99 bytes

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 bytes

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

Si solo se realizan inserciones de caracteres de un dígito como palabra en la entrada, salga del programa con el dígito. O cambie el orden para levenshtein("DIGIT $argn",IntlChar::charName("$i"),1,1,0)no contar las eliminaciones de caracteres

levenshtein

IntlChar :: charName

PHP> = 7.0, 112 bytes

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

IntlChar :: charName

PHP, 128 bytes

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

Pruébalo en línea!

143 bytes para más de 1 dígito

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;

Pruébalo en línea!

Python 3, 150 bytes

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]

combinationsdevuelve todas las combinaciones de cosas en orden. Sería más simple tener un número establecido para el segundo parámetro de combinations, por lo que se agregan espacios al final de la cadena original que es un parámetro de mi lambda. Esa es una descripción simple de cómo funciona mi entrada. Pregunte si desea más aclaraciones.

Mathematica, 83 bytes (codificación WindowsANSI)

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

Define una función unaria ±que toma una lista de caracteres en minúscula como entrada y devuelve un dígito, en forma de {{7}}, o una lista vacía {}. No siento que hice un montón de cosas de golf aquí, excepto que Characters@*IntegerName~Array~9genera las coincidencias de nombre-número para buscar sin codificarlas.

Ejemplo de uso:

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

rendimientos {{9}}.

Jalea , 31 28 bytes

-2 bytes ahora que la entrada en minúscula es aceptable

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

Un programa completo que espera una entrada en minúscula e imprime el resultado, 0para el caso falsey.

Como un enlace monádico que toma una lista de caracteres, en realidad devuelve una lista de enteros que contiene un solo 0en el caso de falsey, un solo entero entre 1e 9incluido en los casos de uso esperados y múltiples entradas de este tipo en los casos en que existe más de un número en el palabra.

Pruébalo en línea!

¿Cómo?

“¡¦ẇṆ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 bytes

Utiliza las banderas -rto_words -n. Toma palabras en minúscula. Devuelve nilsi no se encuentra "dígito".

-1 byte ahora que se permite la entrada en minúsculas, lo que permite la eliminación de la ibandera en la expresión regular.

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

Para una respuesta Ruby más pura sin gemas externas, 91 + 1 = 92 bytes:

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

05AB1E , 26 bytes

El valor falso aquí es 0 .

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

Explicación:

æ                           # 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

Utiliza la codificación 05AB1E . Pruébalo en línea! o Verifique todos los casos de prueba!

Haskell, 113 111 bytes

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

Pruébalo en línea!

Devuelve 0si no se encuentra ningún dígito.

Encuentre todas las subsecuencias de la palabra de entrada en la lista de dígitos. Anteponga una cadena vacía []en el índice 0 que es parte de cada subsecuencia. elemIndicesdevuelve una lista de índices y los =<<aplana en una sola lista. Elige el último índice.

JavaScript (ES6), 121 bytes

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

Devuelve el dígito más bajo detectado o 0 si no se detectó ningún dígito (+6 si NOes necesario).

Japt , 52 bytes

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

Pruébalo en línea!

Retina , 160 126 120 bytes

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

Pruébalo en línea!

Devuelve una cadena vacía si la entrada no contiene un dígito.

-6 bytes gracias a @CalculatorFeline .

PHP, 134 132 128 bytes

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

ejecutar como tubería -nFo probarlo en línea .

Crea una expresión regular con las palabras entre paréntesis; es decir, cada palabra Nestá en la Nsubexpresión th.
Si se encuentra una palabra, la cadena coincidente estará dentro $m[0]y en el Nelemento th, con los elementos entre ellos vacíos y sin cadena vacía detrás; es decir, $mtiene N+1elementos.

Python , 148 bytes

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 función sin nombre que toma una sola palabra en mayúscula y devuelve el entero ( 1to 9) o 0for NO.

Pruébalo en línea!

¿Cómo?

Para una cadena de entrada sa la función atraviesa a través de una lista de las cuerdas: "x", "ONE", "TWO", "THREE", "FOUR", "FIVE", "SIX", "SEVEN", "EIGHT", "NINE", ys . Sí en busca de cerillas *

La comparación utilizada es si esta cadena, wes una que se puede formar a partir de una combinación de letras en orden desde la entrada. La función los combinationsobtiene para nosotros (y solo los que tienen la longitud requerida len(w)), pero están en forma de tuplas, por lo que las cadenas se convierten en tuplas para la comparación.

De los once resultados, el de "x" siempre será False, mientras que el de ssiempre lo será True. El "x"está allí para asegurar el índice de un partido con ONEa través NINEson los valores requeridos (ya que las listas de Python son 0-indexada), el ses allí para asegurar la llamada a index(1)(sinónimo index(True)) suele fallar cuando se encontró ninguna palabra dígitos, tras lo cual el resultante 10se convierte en a 0con un módulo de diez usando%10 .

* Si scontiene espacios por algún motivo, la lista de ws será más larga, pero el proceso seguirá funcionando ya que las coincidencias de palabras de dígitos funcionarán de la misma manera, y si ninguna coincide con la primera subcadena dividida en espacios s, coincidirá, dando una vez más 10y volviendo0 .

Si existen palabras de varios dígitos, la función devolverá la mínima.

Java, 167153 bytes

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

Una implementación bastante ingenua, que coincide en regex.

Prueba y sin 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));
    }
  }
}

Ahorra

• 167 -> 153: varias optimizaciones gracias a @KevinCruijssen

Bash , 163 bytes

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

Pruébalo en línea!

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

No sé RETINA, pero parece un puerto directo de esa respuesta.

Javascript, 121 bytes

(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

Pero solo reciclando material en este punto.

Pyth, -44- 41 bytes

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

Toma una cadena entre comillas, emite 0 para NO.

¡Intentalo!

explicación

+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 bytes

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

Probar en línea

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 bytes

Probar en línea

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 bytes

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 función anónima que busca el grupo regex. No es la mejor solución aquí en Python, sino una forma alternativa.