Un mot à chiffres est un mot où, après avoir éventuellement supprimé certaines lettres, vous vous retrouvez avec un seul chiffre: UN, DEUX, TROIS, QUATRE, CINQ, SIX, SEPT, HUIT ou NEUF (pas ZÉRO).

Par exemple, BOUNCE et ANNOUNCE sont des mots numériques, car ils contiennent le chiffre un.

ENCODE n'est pas un mot numérique, même s'il contient un O, N et E, car ils ne sont pas en ordre.

Écrivez un programme / fonction qui prend un seul mot (majuscule ou minuscule - vous choisissez) comme entrée ou paramètre et détermine s'il s'agit d'un mot numérique. Rendez le code aussi court que possible.

Si le mot n'est pas un mot à chiffres, vous devez retourner «NON», 0 ou toute valeur «falsey» (cela peut varier en fonction de votre langue). Si le mot est un mot numérique, vous devez sortir le chiffre qu'il contient, sous forme de nombre.

Vous pouvez supposer qu'aucun mot ne contient plus d'un chiffre, vous n'aurez donc rien comme ONFIVE.

Cas de 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

Ce défi est tiré de (et est une très légère modification de) la question 1 de BIO 2009 . La plupart des cas de test sont tirés du schéma de marque .

Javascript (ES6), 101 99 octets

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 octets

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

Si seules les insertions de caractères d'un chiffre comme mot à l'entrée sont effectuées, quittez le programme avec le chiffre. Ou changez l'ordre pour levenshtein("DIGIT $argn",IntlChar::charName("$i"),1,1,0)ne pas compter les suppressions de caractères

levenshtein

IntlChar :: charName

PHP> = 7,0, 112 octets

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

IntlChar :: charName

PHP, 128 octets

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

Essayez-le en ligne!

143 octets pour plus de 1 chiffre

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;

Essayez-le en ligne!

Python 3, 150 octets

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]

combinationsrenvoie toutes les combinaisons de choses dans l'ordre. Il serait plus simple d'avoir un nombre défini pour le deuxième paramètre de combinations, donc les espaces sont ajoutés à la fin de la chaîne d'origine qui est un paramètre de mon lambda. C'est une simple description du fonctionnement de mon entrée. Demandez si vous souhaitez plus de précisions.

Mathematica, 83 octets (encodage WindowsANSI)

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

Définit une fonction unaire ±qui prend une liste de caractères minuscules en entrée et renvoie soit un chiffre, sous une forme similaire {{7}}, soit une liste vide {}. Je n'ai pas l'impression d'avoir fait une tonne de choses golfiques ici, sauf que cela Characters@*IntegerName~Array~9génère les correspondances nombre-nom à rechercher sans les coder en dur.

Exemple d'utilisation:

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

rendements {{9}}.

Gelée , 31 28 octets

-2 octets maintenant que l'entrée en minuscules est acceptable

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

Un programme complet qui attend une entrée en minuscules et imprime le résultat, en utilisant 0 pour le cas falsey.

En tant que lien monadique prenant une liste de caractères, il retourne en fait une liste d'entiers qui contient un seul 0dans le cas falsey, un seul entier entre 1et 9inclusif dans les cas d'utilisation attendus et plusieurs entrées de ce type dans les cas où plusieurs nombres existent dans le mot.

Essayez-le en ligne!

Comment?

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

Utilise les drapeaux -rto_words -n . Prend des mots en minuscules. Renvoie nilsi aucun "chiffre" n'a été trouvé.

-1 octet maintenant que l'entrée en minuscules est autorisée, ce qui permet la suppression du idrapeau sur l'expression régulière.

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

Pour une réponse Ruby plus pure sans gemmes externes, 91 + 1 = 92 octets:

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

05AB1E , 26 octets

La valeur de falsification ici est 0 .

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

Explication:

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

Utilise l' encodage 05AB1E . Essayez-le en ligne! ou Vérifiez tous les cas de test!

Haskell, 113 111 octets

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

Essayez-le en ligne!

Retour 0 si aucun chiffre n'est trouvé.

Recherchez toutes les sous-séquences du mot saisi dans la liste des chiffres. Ajoutez une chaîne vide []à l'index 0 qui fait partie de chaque sous-séquence. elemIndicesrenvoie une liste d'indices et les =<<aplatit en une seule liste. Choisissez le dernier index.

JavaScript (ES6), 121 octets

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

Renvoie le chiffre le plus bas détecté ou 0si aucun chiffre n'a été détecté (+6 si NOnécessaire).

Japt , 52 octets

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

Essayez-le en ligne!

Retina , 160 126 120 octets

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

Essayez-le en ligne!

Renvoie une chaîne vide si l'entrée ne contient pas de chiffre.

-6 octets grâce à @CalculatorFeline .

PHP, 134 132 128 octets

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

fonctionner comme tuyau avec -nF ou essayer en ligne .

Crée une expression régulière avec les mots entre parenthèses; c'est-à-dire que chaque mot Nest dans la Ne sous-expression.
Si un mot est trouvé, la chaîne correspondante sera dans $m[0]et dans le Ne élément, avec les éléments entre eux vides et aucune chaîne vide derrière; c'est à dire $ma des N+1éléments.

Python , 148 octets

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

Une fonction sans nom prenant un mot en majuscule uniquement et renvoyant l'entier ( 1à 9) ou 0pour NO.

Essayez-le en ligne!

Comment?

Pour une chaîne d'entrée de sla fonction traverse par une liste des chaînes: "x", "ONE", "TWO", "THREE", "FOUR", "FIVE", "SIX", "SEVEN", "EIGHT", "NINE"ets . Lui - même chercher les correspondances *

La comparaison utilisée est de savoir si cette chaîne,, west celle qui peut être formée à partir d'une combinaison de lettres dans l'ordre à partir de l'entrée. La fonction les combinationsobtient pour nous (et uniquement celles de la longueur requise en utilisantlen(w) ), mais elles sont sous la forme de tuples, donc les chaînes sont converties en tuples pour la comparaison.

Des onze résultats, celui pour "x"sera toujours False, tandis que celui pour slui sera toujours True. Le "x"est là pour s'assurer que l'index d'une correspondance avec ONEthrough NINEest les valeurs requises (puisque les listes Python sont indexées sur 0), le sest là pour s'assurer que l'appel à index(1)(synonyme de index(True)) n'échouera pas quand aucun mot numérique n'a été trouvé, après quoi le résultat 10est converti en un 0avec un modulo de dix en utilisant%10 .

* Si scontient des espaces pour une raison quelconque, la liste des ws sera plus longue, mais le processus fonctionnera toujours puisque les correspondances de mots de chiffres fonctionneront de la même manière, et si aucune ne correspond à la première sous-chaîne à espace séparé de scorrespondra, donnant encore une fois 10et de retour 0.

S'il existe des mots à plusieurs chiffres, la fonction renverra le mot minimal.

Java, 167 153 octets

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

Une implémentation plutôt naïve, correspondant sur regex.

Test et 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));
    }
  }
}

Sauvegarde

• 167 -> 153: optimisations diverses grâce à @KevinCruijssen

Bash , 163 octets

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

Essayez-le en ligne!

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

Je ne connais pas RETINA mais semble être un port direct de cette réponse.

Javascript, 121 octets

(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

Mais il suffit de recycler le matériel à ce stade.

Pyth, -44- 41 octets

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

Prend une chaîne entre guillemets, renvoie 0 pour NON.

Essayez!

explication

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

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

Essayez en ligne

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 octets

Essayez en ligne

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 octets

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

Une fonction anonyme recherchant le groupe regex. Pas la meilleure solution ici en Python mais une manière alternative.