Uma palavra de dígito é uma palavra em que, após a remoção de algumas letras, você fica com um dos dígitos: UM, DOIS, TRÊS, QUATRO, CINCO, SEIS, SETE, OITO ou NOVE (não ZERO).

Por exemplo, BOUNCE e ANUNUNCE são palavras de dígito, pois contêm o dígito um.

ENCODE não é uma palavra de dígito, mesmo que contenha O, N e E, pois não estão em ordem.

Escreva um programa / função que use uma única palavra (maiúscula ou minúscula - você escolhe) como entrada ou parâmetro e determine se é uma palavra de dígito. Torne o código o mais curto possível.

Se a palavra não for um dígito, você deve retornar 'NÃO', 0 ou qualquer valor 'falsey' (isso pode variar de acordo com o seu idioma). Se a palavra é um dígito, você deve fornecer o dígito que ele contém, como um número.

Você pode assumir que nenhuma palavra contém mais de um dígito; portanto, você não terá nada como ONFIVE.

Casos de teste

BOUNCE
1

ENCODE
NO

EIGHT
8

BLACKJACK
NO

FABULOUS
NO

EXERCISE
NO

DRIFTWOOD
2

SERVICEMAN
7

INSIGNIFICANCE
9

THROWDOWN
2

ZERO
NO

OZNERO
1

Esse desafio foi retirado (e é uma modificação muito leve da) Questão 1 da BIO 2009 . A maioria dos casos de teste é retirada do 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

Se apenas inserções de caracteres de um dígito como palavra na entrada forem feitas, saia do programa com o dígito. Ou altere a ordem para levenshtein("DIGIT $argn",IntlChar::charName("$i"),1,1,0)não contar as exclusões 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;

Experimente online!

143 bytes por mais de um 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;

Experimente online!

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]

combinationsretorna todas as combinações de coisas em ordem. Seria mais simples ter um número definido para o segundo parâmetro de combinations, para que espaços sejam adicionados ao final da string original que é um parâmetro da minha lambda. Essa é uma descrição simples de como minha entrada funciona. Pergunte se você deseja mais esclarecimentos.

Mathematica, 83 bytes (codificação WindowsANSI)

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

Define uma função unária ±que recebe uma lista de caracteres em minúsculas como entrada e retorna um dígito, em um formato semelhante {{7}}ou uma lista vazia{} . Eu não acho que fiz muitas coisas de golfe aqui, exceto que Characters@*IntegerName~Array~9gera as correspondências nome-número a serem procuradas sem codificá-las.

Exemplo de uso:

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

rendimentos {{9}}.

Jelly , 31 28 bytes

-2 bytes agora que a entrada em minúscula é aceitável

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

Um programa completo que espera entrada em minúscula e imprime o resultado, usando 0 o caso falsey.

Como um link monádico que obtém uma lista de caracteres, ele realmente retorna uma lista de números inteiros que contém um único 0no caso falsey, um único inteiro entre 1e9 inclusive nos casos de uso esperados e várias entradas desse tipo nos casos em que mais de um número existe no palavra.

Experimente online!

Quão?

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

Usa as bandeiras -rto_words -n . Leva minúsculas. Retorna nilse nenhum "dígito" for encontrado.

-1 byte agora que a entrada em minúsculas é permitida, permitindo a remoção do isinalizador no regex.

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

Para uma resposta Ruby mais pura, sem 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

O valor falso aqui é 0 .

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

Explicação:

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

Usa a codificação 05AB1E . Experimente online! ou Verifique todos os casos de teste!

Haskell, 113 111 bytes

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

Experimente online!

Devoluções 0 se nenhum dígito for encontrado.

Encontre todas as subsequências da palavra de entrada na lista de dígitos. Anexe uma sequência vazia []no índice 0, que faz parte de cada subsequência. elemIndicesretorna uma lista de índices e os =<<nivela em uma única lista. Escolha o ú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

Retorna o dígito detectado mais baixo ou 0se nenhum dígito foi detectado (+6 se NOnecessário).

Japonês , 52 bytes

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

Experimente online!

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

Experimente online!

Retorna uma string vazia se a entrada não contiver um dígito.

-6 bytes graças a @CalculatorFeline .

PHP, 134 132 128 bytes

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

executar como tubo -nFou experimentá-lo online .

Cria uma regex com as palavras entre parênteses; ou seja, cada palavra Nestá na Nsub-expressão.
Se uma palavra for encontrada, a string correspondente estará dentro $m[0]e no Nquinto elemento, com os elementos entre eles vazios e nenhuma string vazia atrás; ou seja, $mtem 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

Uma função sem nome, que pega apenas uma palavra em maiúscula e retorna o número inteiro ( 1para 9) ou 0para NO.

Experimente online!

Quão?

Para uma cadeia de entrada sa função atravessa uma lista de strings: "x", "ONE","TWO" , "THREE", "FOUR", "FIVE", "SIX", "SEVEN", "EIGHT", "NINE", es . Em si à procura de quaisquer jogos *

A comparação usada é se essa sequência,, wé aquela que pode ser formada a partir de uma combinação de letras em ordem a partir da entrada. A função combinationsobtém essas informações para nós (e somente as que usam o comprimento necessário len(w)), mas elas estão na forma de tuplas, portanto, as cadeias são convertidas em tuplas para comparação.

Dos onze resultados, aquele para "x"sempre será False, enquanto o para ssi sempre será True. O "x"que há para garantir o índice de um jogo com o ONEmeioNINE são os valores necessários (uma vez que as listas Python são 0-indexada), os que há para garantir a chamada para index(1)(sinônimo index(True)) costuma falhar quando nenhuma palavra dígito foi encontrado, após o que o resultante 10é convertido para a 0com um módulo de dez usando%10 .

* E se s contiver espaços por algum motivo, a lista de ws será mais longa, mas o processo ainda funcionará, pois a correspondência de palavras com dígitos funcionará da mesma maneira e, se nenhuma corresponder à primeira substring de divisão de espaço s, corresponderá, fornecendo novamente 10e voltando 0.

Se existirem palavras com vários dígitos, a função retornará a mínima.

Java, 167 153 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";}

Uma implementação bastante ingênua, correspondente ao regex.

Teste e ungolfed

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: várias otimizações graças 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

Experimente 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

Não conheço RETINA, mas parece uma porta direta dessa resposta.

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

ou 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

Mas apenas reciclando material neste momento.

Pyth, -44- 41 bytes

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

Pega uma string entre aspas e gera 0 para NO.

Tente!

explicação

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

Experimente on-line

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

Experimente on-line

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

Uma função anônima que procura pelo grupo regex. Não é a melhor solução aqui em Python, mas uma maneira alternativa.