Từ chữ số là một từ mà sau khi có thể xóa một số chữ cái, bạn chỉ còn lại một trong các chữ số duy nhất: ONE, TWO, BA, BỐN, FIVE, SIX, SEVEN, EIGHT hoặc NINE (không phải ZERO).

Ví dụ, BOUNCE và ANNOUNCE là các từ chữ số, vì chúng chứa chữ số một.

ENCODE không phải là một từ chữ số, mặc dù nó có chứa O, N và E, vì chúng không theo thứ tự.

Viết chương trình / hàm lấy một từ (chữ hoa hoặc chữ thường - bạn chọn) làm đầu vào hoặc tham số và xác định xem đó có phải là từ có chữ số không. Làm cho mã càng ngắn càng tốt.

Nếu từ đó không phải là một từ chữ số, bạn nên trả về 'KHÔNG', 0 hoặc bất kỳ giá trị 'falsey' nào (điều này có thể thay đổi tùy theo ngôn ngữ của bạn). Nếu từ là một từ chữ số, bạn nên xuất chữ số chứa, dưới dạng một số.

Bạn có thể cho rằng không có từ nào chứa nhiều hơn một chữ số, vì vậy bạn sẽ không có bất cứ thứ gì như ONFIVE.

Các trường hợp thử nghiệm

BOUNCE
1

ENCODE
NO

EIGHT
8

BLACKJACK
NO

FABULOUS
NO

EXERCISE
NO

DRIFTWOOD
2

SERVICEMAN
7

INSIGNIFICANCE
9

THROWDOWN
2

ZERO
NO

OZNERO
1

Thử thách này được lấy từ (và là một sửa đổi rất nhỏ) Câu hỏi 1 từ BIO 2009 . Hầu hết các trường hợp thử nghiệm được lấy từ sơ đồ đánh dấu .

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

Nếu chỉ chèn các ký tự từ một chữ số dưới dạng từ vào đầu vào thì thoát khỏi chương trình với chữ số đó. Hoặc thay đổi thứ tự levenshtein("DIGIT $argn",IntlChar::charName("$i"),1,1,0)để đếm không phải là xóa ký tự

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;

Hãy thử trực tuyến!

143 byte cho hơn 1 chữ số

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;

Hãy thử trực tuyến!

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]

combinationstrả về tất cả các kết hợp của mọi thứ theo thứ tự. Sẽ đơn giản hơn khi có một số được đặt cho tham số thứ hai combinations, vì vậy khoảng trắng được thêm vào cuối chuỗi gốc là tham số của lambda của tôi. Đó là một mô tả đơn giản về cách hoạt động của tôi. Hỏi nếu bạn muốn làm rõ thêm.

Mathicala, 83 byte (mã hóa WindowsANSI)

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

Xác định một hàm unary ±lấy danh sách các ký tự chữ thường làm đầu vào và trả về một chữ số, dưới dạng như {{7}}, hoặc một danh sách trống khác {}. Tôi không cảm thấy như mình đã làm rất nhiều thứ golf ở đây, ngoại trừ việc Characters@*IntegerName~Array~9tạo ra các trận đấu tên số để tìm kiếm mà không cần mã hóa chúng.

Ví dụ sử dụng:

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

năng suất {{9}}.

Thạch , 31 28 byte

Bây giờ -2 byte mà đầu vào chữ thường được chấp nhận

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

Một chương trình đầy đủ mong đợi đầu vào chữ thường và in kết quả, sử dụng 0cho trường hợp falsey.

Là một liên kết đơn lấy một danh sách các ký tự, nó thực sự trả về một danh sách các số nguyên có chứa một số 0trong trường hợp falsey, một số nguyên duy nhất giữa 1và 9bao gồm trong các trường hợp sử dụng dự kiến ​​và nhiều mục như vậy trong trường hợp có nhiều hơn một số trong từ.

Hãy thử trực tuyến!

Làm sao?

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

Sử dụng các cờ -rto_words -n. Mất chữ thường. Trả về nilnếu không tìm thấy "chữ số".

Bây giờ -1 byte cho phép nhập chữ thường, cho phép xóa icờ trên biểu thức chính quy.

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

Để có câu trả lời Ruby thuần túy hơn mà không cần đá quý bên ngoài, 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

Giá trị giả ở đây là 0 .

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

Giải trình:

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

Sử dụng mã hóa 05AB1E . Hãy thử trực tuyến! hoặc Xác minh tất cả các trường hợp thử nghiệm!

Haskell, 113 111 byte

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

Hãy thử trực tuyến!

Trả về 0nếu không tìm thấy chữ số.

Tìm tất cả các phần sau của từ đầu vào trong danh sách các chữ số. Chuẩn bị một chuỗi rỗng []ở chỉ số 0 là một phần của mọi chuỗi. elemIndicestrả về một danh sách các chỉ số và =<<làm phẳng chúng thành một danh sách. Chọn chỉ số cuối cùng.

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

Trả về chữ số được phát hiện thấp nhất hoặc 0nếu không có chữ số nào được phát hiện (+6 nếu NOđược yêu cầu).

Japt , 52 byte

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

Hãy thử trực tuyến!

Võng mạc , 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

Hãy thử trực tuyến!

Trả về một chuỗi trống nếu đầu vào không chứa một chữ số.

-6 byte nhờ @CalculatorFeline .

PHP, 134 132 128 byte

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

chạy như ống với -nFhoặc thử trực tuyến .

Tạo một biểu thức chính với các từ trong ngoặc đơn; tức là mỗi từ Nnằm trong Nbiểu thức con thứ.
Nếu một từ được tìm thấy, chuỗi phù hợp sẽ nằm trong $m[0]và trong Nphần tử thứ, với các phần tử giữa chúng trống và không có chuỗi trống phía sau; tức là $mcó N+1các yếu tố.

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

Một hàm không tên chỉ lấy một chữ hoa và trả về số nguyên ( 1to 9) hoặc 0for NO.

Hãy thử trực tuyến!

Làm sao?

Đối với một chuỗi đầu vào schức năng đi qua thông qua một danh sách các chuỗi: "x", "ONE", "TWO", "THREE", "FOUR", "FIVE", "SIX", "SEVEN", "EIGHT", "NINE", và s. Bản thân tìm kiếm bất kỳ trận đấu *

Sự so sánh được sử dụng là liệu chuỗi này w, là một chuỗi có thể được hình thành từ sự kết hợp các chữ cái theo thứ tự từ đầu vào. Hàm combinationslấy những thứ này cho chúng ta (và chỉ những cái có độ dài cần thiết sử dụng len(w)), nhưng chúng ở dạng bộ, vì vậy các chuỗi được chuyển thành bộ để so sánh.

Trong số mười một kết quả, một kết quả "x"sẽ luôn luôn như vậy False, trong khi kết quả ssẽ luôn luôn như vậy True. Có "x"ở đó để đảm bảo chỉ mục khớp với ONEthông qua NINEcác giá trị được yêu cầu (vì danh sách Python được lập chỉ mục 0), nên scó để đảm bảo lệnh gọi index(1)(đồng nghĩa với index(True)) sẽ không thất bại khi không tìm thấy từ chữ số nào, từ đó kết quả 10được chuyển đổi thành a 0với một modulo mười bằng cách sử dụng %10.

* Nếu scó chứa khoảng trắng vì một số lý do, danh sách ws sẽ dài hơn, nhưng quá trình sẽ vẫn hoạt động do các từ khớp chữ số sẽ hoạt động theo cùng một cách và nếu không có chuỗi nào skhớp với chuỗi con phân tách không gian đầu tiên sẽ khớp, một lần nữa sẽ cho 10và trở về 0.

Nếu nhiều từ có chữ số tồn tại, hàm sẽ trả về từ tối thiểu.

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

Một triển khai khá ngây thơ, phù hợp trên regex.

Kiểm tra và không có ý thức

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

Tiết kiệm

• 167 -> 153: tối ưu hóa khác nhau nhờ @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

Hãy thử trực tuyến!

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

Không biết RETINA nhưng dường như một cổng thẳng của câu trả lời đó.

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

hoặc 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

Nhưng chỉ tái chế vật liệu vào thời điểm này.

Pyth, -44- 41 byte

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

Lấy một chuỗi trích dẫn, xuất ra 0 cho NO.

Thử nó!

giải trình

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

Thử trực tuyến

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

Thử trực tuyến

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

Một chức năng ẩn danh tìm kiếm nhóm regex. Không phải là giải pháp tốt nhất ở đây trong Python mà là một cách khác.