数字单词是一个单词，在其中可能删除了一些字母之后，剩下的数字只有一个：一个，两个，三个，四个，五个，六个，七个，八个或九个（不是零）。

例如，BOUNCE和ANNOUNCE是数字字，因为它们包含数字1。

即使ENCODE包含O，N和E，但它们也不是数字字，因为它们的顺序不正确。

编写一个程序/函数，该程序/函数将单个（大写或小写–您选择）的单词作为输入或参数，并确定它是否为数字单词。使代码尽可能短。

如果该单词不是数字单词，则应返回“ NO”，0或任何“假”值（这可能会因您的语言而异）。如果单词是数字单词，则应将其包含的数字输出为数字。

您可以假设单词的位数不超过一个，因此您不会有ONFIVE之类的东西。

测试用例

BOUNCE
1

ENCODE
NO

EIGHT
8

BLACKJACK
NO

FABULOUS
NO

EXERCISE
NO

DRIFTWOOD
2

SERVICEMAN
7

INSIGNIFICANCE
9

THROWDOWN
2

ZERO
NO

OZNERO
1

这个挑战来自BIO 2009的问题1（只是对它的微小修改）。大多数测试用例均来自评分方案。

Javascript（ES6），101 99字节

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字节

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

如果仅将一位字符作为输入字符插入字符，则退出带有该位的程序。或更改顺序以levenshtein("DIGIT $argn",IntlChar::charName("$i"),1,1,0)不计算字符的删除

莱文施泰因

IntlChar :: charName

PHP> = 7.0，112字节

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

IntlChar :: charName

PHP，128字节

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

在线尝试！

143个字节（大于1位）

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;

在线尝试！

Python 3，150个字节

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]

combinations按顺序返回所有事物组合。为的第二个参数设置一个编号会更简单，因此会将combinations空格添加到作为我的lambda参数的原始字符串的末尾。这是我输入内容的简单描述。询问您是否还要澄清。

Mathematica，83个字节（WindowsANSI编码）

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

定义一元函数±，该函数将小写字符列表作为输入，并以形式返回数字{{7}}或一个空列表{}。我不觉得我在这里做了很多类似的事情，除了会Characters@*IntegerName~Array~9生成数字名称匹配项，而无需对其进行硬编码。

用法示例：

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

产量{{9}}。

果冻，31 28 字节

现在可以接受小写输入的-2个字节

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

一个完整的程序，要求输入小写字母并打印结果，0用于伪造的情况。

作为采用字符列表的单子链接，它实际上返回一个整数列表，该整数列表0在false情况下包含一个单数，在预期使用情况下包含一个单数1（9包括）之间的整数，并且在其中存在多个数字的情况下包含多个此类条目。字。

在线尝试！

怎么样？

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

使用标志-rto_words -n。接受小写单词。nil如果找不到“数字”，则返回。

现在允许使用-1个字节的小写输入，从而可以删除i正则表达式上的标志。

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

对于没有外部gem的更纯净的Ruby答案，91 + 1 = 92字节：

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

05AB1E，26个字节

假值是0。

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

说明：

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

使用05AB1E编码。在线尝试！或验证所有测试用例！

Haskell，113111字节

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

在线尝试！

0如果找不到数字，则返回。

在数字列表中找到输入单词的所有子序列。[]在每个子序列的索引0处添加一个空字符串。 elemIndices返回索引列表并将其展=<<平为单个列表。选择最后一个索引。

JavaScript（ES6），121个字节

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

返回检测到的最低位数或未0检测到位数（如果NO需要则为+6 ）。

Japt，52个字节

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

在线尝试！

视网膜，160 126 120个字节

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

在线尝试！

如果输入不包含数字，则返回一个空字符串。

-6个字节，感谢@CalculatorFeline。

PHP，134132128字节

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

作为管道运行-nF或在线尝试。

用括号中的单词创建一个正则表达式；也就是说，每个单词N都在第Nth个子表达式中。
如果找到一个单词，匹配字符串将是在$m[0]与在所述N第i个元素，用空背后没有空字符串在它们之间的元件和; 即$m具有N+1元素。

Python，148字节

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

一个未命名的函数，仅使用大写单词，然后返回整数（1to 9），或者返回0for NO。

在线尝试！

怎么样？

对于输入字符串s函数通过字符串列表遍历："x"，"ONE"，"TWO"，"THREE"，"FOUR"，"FIVE"，"SIX"，"SEVEN"，"EIGHT"，"NINE"，和s。自己找任何匹配*

所使用的比较是该字符串是否w是从输入开始按字母顺序组合而成的字符串。该函数combinations为我们获取这些（并且仅使用所需长度的那些len(w)），但是它们采用元组的形式，因此将字符串强制转换为元组以进行比较。

在这11个结果中，一个"x"永远会存在False，而一个s本身将会永远存在True。的"x"是有保证的匹配的与所述索引ONE通过NINE是所需要的值（因为Python列表是0的索引），则s是有保证的调用index(1)（代名词index(True)）不会失败时，没有数字字被发现，随后使所得10使用转换为010的模%10。

*如果s由于某些原因包含空格，则ws 的列表将更长，但是该过程仍将起作用，因为数字字匹配将以相同的方式工作，并且如果没有匹配，则第一个以空格分隔的子字符串s将匹配，再次给出10然后返回0。

如果存在多个数字字，则该函数将返回最小的一个。

Java，167153字节

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

一个相当幼稚的实现，在正则表达式上匹配。

测试和取消高尔夫

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

节省

• 167-> 153：@KevinCruijssen进行了各种优化

Bash 163字节

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

在线尝试！

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

不知道RETINA，但似乎直接回答了这个问题。

Javascript，121个字节

(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

或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

但是，此时只回收材料。

Pyth，-44- 41字节

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

接受带引号的字符串，为NO输出0。

试试吧！

说明

+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个字节

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

在线尝试

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字节

在线尝试

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个字节

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

搜索正则表达式组的匿名函数。这不是Python中最好的解决方案，而是另一种方法。