Hướng dẫn

Kịch bản

John có một con số quan trọng và anh ấy không muốn người khác nhìn thấy nó.

Anh quyết định mã hóa số, sử dụng các bước sau:

Số của anh ta luôn luôn là một chuỗi không giảm (ví dụ. "1123")

Anh chuyển đổi từng chữ số thành từ tiếng Anh. (tức là. "123" -> "ONETWOTHREE")

Và sau đó, sắp xếp lại các chữ cái một cách ngẫu nhiên. (I E."ONETWOTHREE" -> "ENOWTOHEETR" )

John cảm thấy rằng số của mình là an toàn khi làm như vậy. Trên thực tế, mã hóa như vậy có thể dễ dàng được giải mã :(

Bài tập

Với các chuỗi được mã hóa, nhiệm vụ của bạn là giải mã nó và trả về số ban đầu.

Quy tắc

• Đây là mã golf, vì vậy câu trả lời ngắn nhất bằng byte sẽ thắng
• Bạn có thể giả sử rằng chuỗi đầu vào luôn hợp lệ
• Chuỗi đầu vào chỉ chứa các chữ cái viết hoa
• Các số ban đầu luôn được sắp xếp theo thứ tự tăng dần
• Bạn có thể trả về số ở định dạng chuỗi hoặc số nguyên
• Các chữ cái sẽ chỉ được xáo trộn giữa một từ, không phải giữa toàn bộ chuỗi.
• Những con số sẽ chỉ có 1-9 bao gồm ( ONEđể NINE)

Chuỗi có thể xắp xếp lại

Dưới đây là danh sách các chuỗi ngay sau khi chúng được chuyển đổi thành chuỗi từ các số:

 1 -> ONE 
 2 -> TWO
 3 -> THREE
 4 -> FOUR
 5 -> FIVE
 6 -> SIX
 7 -> SEVEN
 8 -> EIGHT
 9 -> NINE

Ví dụ

"NEO" -> 1

"ENOWOT" -> 12

"EONOTWHTERE" -> 123

"SNVEEGHEITNEIN" -> 789

"ENOOWTEERHTRUOFEVIFXISNEVESTHGIEENIN" -> 123456789

"NOEWOTTOWHEERT" -> 1223

Thạch ,  38  37 byte

ḟ“RGS”O“OX‘,“¢©“¢¢¤‘yF×4/%74ị⁽Gל?9¤Ḍ

Một liên kết đơn âm lấy một danh sách các ký tự (chuỗi) và trả về một số nguyên.

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

Sử dụng một phương pháp rất khác với câu trả lời Jelly của Pietu1998 , nhưng có cùng số byte ( tôi thực sự nghĩ rằng nó có thể đã kết thúc ít hơn)!

Không phụ thuộc vào tính đơn điệu của số ban đầu (vì vậy, một đầu vào của HTREEWTONOEsẽ hoạt động chẳng hạn).

Làm sao?

Đầu tiên lưu ý rằng bản thân các từ (và do đó, bất kỳ đảo chữ cái nào) đều có thể được thay đổi thành các từ có độ dài 4 bằng cách xóa bất kỳ chữ R, G và S nào và thay thế bất kỳ chữ Os nào bằng hai ký tự (giả sử "12") và bất kỳ chữ X nào bằng ba ký tự ( nói "345").

letters  -> -RGS  -> O:12, X:345
ONE         ONE      12NE
TWO         TWO      TW12
THREE       THEE     THEE
FOUR        FOU      F12U
FIVE        FIVE     FIVE
SIX         IX       I345
SEVEN       EVEN     EVEN
EIGHT       EIHT     EIHT
NINE        NINE     NINE

Sau đó, chúng tôi có thể ánh xạ sản phẩm của các ký tự của các ký tự đó sang các số từ 1 đến 9 bằng số học modulo, tùy thuộc vào lựa chọn của chúng tôi ("12345"), sau đó tra cứu chúng trong danh sách các chữ số được sắp xếp lại. Mã thực sự chuyển thành các ký tự trước và sau đó thay thế các lệnh, nhưng cũng có thể có 37 byte bằng các ký tự, ví dụ "DIAAE" ( thử nó ).

ḟ“RGS”O“OX‘,“¢©“¢¢¤‘yF×4/%74ị⁽Gל?9¤Ḍ - link: list of characters
 “RGS”                                - literal ['R','G','S']
ḟ                                     - filter discard
      O                               - convert to ordinals
       “OX‘                           - code-page indices list = [79,88]
            “¢©“¢¢¤‘                  - code-page indices lists = [[1,6],[1,1,3]]
           ,                          - pair -> [[79,88],[[1,6],[1,1,3]]]
                    y                 - translate (replace 79s (Os) with [1,6]
                                                       and 88s (Xs) with [1,1,3])
                     F                - flatten into a single list
                       4/             - 4-wise reduce by:
                      ×               -   multiplication (product of each window of four)
                         %74          - modulo 74
                                   ¤  - nilad followed by link(s) as a nilad:
                             ⁽G×      -   base 250 literal = 18768
                                œ?9   -   permutation of [1,2,3,4,5,6,7,8,9] at that
                                      -   index in a lexicographically sorted list of
                                      -   all such permutations -> [1,5,8,2,4,9,7,6,3]
                            ị         - index into
                                    Ḍ - convert from decimal digits to an integer

Python 2, 121 117 115 byte

def g(s,a=0,f=''):
 for c in s:
    a+=34**ord(c)%43;r='P!\x83u\x8eI\x92|Z'.find(chr(a))+1
    if r:f,a=f+`r`,0
 return f

-4 byte: Sau tất cả những lần chơi golf đó, tôi đã quên nội tuyến một biến sử dụng một lần. Rối não.
-2 byte: thụt lề cách đôi → thụt lề tab đơn (nhờ Coty Johnathan Saxman); lưu ý rằng điều này không hiển thị chính xác trong câu trả lời.

Ungolfed (tương thích với python 3):

nums = [80, 33, 131, 117, 142, 73, 146, 124, 90]

def decode(str):
    acc = 0
    final = ''
    for c in str:
        acc += (34**ord(c))%43
        if acc in nums:
            final += str(1+nums.index(acc))
            acc=0
    return final

Công cụ tìm số ma thuật:

#!/usr/bin/env python3
from itertools import count, permutations

def cumul(x):
    s = 0
    for v in x:
        s += v
        yield s

all_words = 'ONE TWO THREE FOUR FIVE SIX SEVEN EIGHT NINE'.split()

for modulo in range(1, 1000):
    for power in range(1, 300):
        combinations = []
        for word in all_words:
            my_combination = []
            for perm in permutations(word):
                my_combination += cumul(power**(ord(x)) % modulo for x in perm)
            combinations.append(my_combination)

        past_combinations = set(())
        past_intermediates = set(())
        collision = False
        for combination in combinations:
            final = combination[-1]
            if final in past_intermediates or any(intermediate in past_combinations for intermediate in combination):
                collision = True
                break
            past_combinations.add(final)
            past_intermediates.update(combination)

        if not collision:
            print("Good params:", power, modulo)
            print("Results:", ", ".join(str(x[-1]) for x in combinations))

Giải trình:

Tôi có cảm giác rằng tôi có thể đập các bit ASCII lại với nhau và tổng hợp chúng bằng cách nào đó để xác định khi nào tôi có một từ đầy đủ. Ban đầu tôi đã thử nhắn tin với3**ord(letter) và so sánh với kết quả mong đợi, nhưng kết quả là một số lượng rất lớn. Mặc dù tôi sẽ thích hợp để tạo ra một số tham số một chút, cụ thể là mô đun (để đảm bảo các số nhỏ) và một số nhân để phân tán các số khác nhau xung quanh phạm vi của mô đun.

Cuối cùng tôi đã thay đổi biến số nhân thành một biến ảnh hưởng đến chính sức mạnh bởi vì (từ thử nghiệm và lỗi) bằng cách nào đó đã xoay sở để cho tôi một câu trả lời ngắn hơn một chút.

Và ở trên, bạn thấy kết quả của sự vũ phu đó và một chút chơi gôn thủ công.

Lý do chọn 3**xban đầu là vì tôi biết bạn có thể đại diện cho mọi số ở đó. Các chữ số được lặp lại nhiều nhất mà bất kỳ số nào có là hai (thrEE, sEvEn, NiNe, v.v.), vì vậy tôi quyết định nghĩ mỗi đầu vào là một số cơ sở 3. Bằng cách đó, tôi có thể (về mặt tinh thần) đại diện cho họ như một cái gì đó giống như 10100000000010020000(ba; 1 trong tkhe, 1 trong rkhe, 1 trong hkhe và 2 trong ekhe). Mỗi số theo cách này có một biểu diễn duy nhất có thể dễ dàng ghép lại với nhau bằng cách lặp chuỗi và tổng hợp một số số, và nó kết thúc độc lập với thứ tự thực tế của các chữ cái. Tất nhiên, đây không phải là giải pháp lý tưởng, nhưng giải pháp hiện tại vẫn được viết với ý tưởng này.

Python 2 , 131 127 byte

s=input()
for y in'WXGURFSOIZ':vars()[y]=s.count(y)
while Z<9:s+=[O-U-W,W,R-U,U,F-U,X,S-X,G,I-X-G-F+U][Z]*str(Z+1);Z+=1
print s

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

Dựa trên phiên bản sửa lỗi của giải pháp JavaScript Draco18s .

PHP , 164 byte

for($c=count_chars($argn);$i<9;)echo str_pad("",[$c[79]-$c[87]-$u=$c[85],$c[87],$c[72]-$g=$c[71],$u,$f=$c[70]-$u,$x=$c[88],$c[86]-$f,$g,$c[73]-$x-$f-$g][+$i],++$i);

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

PHP , 179 byte

dựa trên cách tiếp cận trước, kiểm tra trước các số chẵn và sau đó là các số lẻ theo thứ tự tăng dần

for($z=[$o=($c=count_chars($argn))[87],$f=$c[85],$x=$c[88],$g=$c[71],$c[79]-$o-$f,$c[72]-$g,$v=$c[70]-$f,$c[86]-$v,$c[73]-$x-$v-$g];$i<9;)echo str_repeat(++$i,$z[_405162738[$i]]);

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

PHP , 201 byte

for(;$o=ord(WUXGOHFVN[$i]);$i++)for(;$r[$o]<count_chars($argn)[$o];$t[]=$i>3?2*$i-7:2+2*$i,sort($t))for(++$r[$o],$n=0;$q=ord(([TO,ORF,IS,HEIT,EN,TREE,IVE,SEEN,NIE][+$i])[$n++]);)$r[$q]++;echo join($t);

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

Javascript (ES6), 288 150 144 byte

q=s=>[u=(l=t=>s.split(t).length-1)`U`,l`O`-l`W`-u,l`W`,l`R`-w,u,f=l`F`-u,x=l`X`,l`S`-x,g=l`G`,l`I`-x-g-f].map((n,i)=>`${i}`.repeat(i&&n)).join``

const testCases = ['NEO', 'ENOWOT', 'EONOTWHTERE', 'SNVEEGHEITNEIN', 'ENOOWTEERHTRUOFEVIFXISNEVESTHGIEENIN']

testCases.forEach(testCase => console.log(testCase, q(testCase)))

Dài hơn hai mục còn lại của một trong những mục nhập khác, nhưng tôi nghĩ rằng tôi đã bỏ một cách tiếp cận thú vị có thể hiệu quả với ai đó bằng ngôn ngữ khác.

Về cơ bản chúng ta có thể xác định như sau:

W -> 2
X -> 6
G -> 8
U -> 4

Bất kỳ sự xuất hiện của các chữ cái này ngụ ý rằng chữ số đó tồn tại trong số ban đầu. Từ đây chúng ta có thể suy ra phần còn lại của các chữ số:

R-U -> 3
F-U -> 5
S-X -> 7

Bao gồm hai trường hợp phức tạp:

O-(U+W) -> 1
I-(X+G+(F-U)) -> 9

Cả hai 1 và 9khu vực cứng tương đối. Đối với ONE, Exuất hiện nhiều hơn một lần trong một số từ ( SEVENcó hai) cũng như N( NINE), vì vậy chúng tôi bị mắc kẹt với việc kiểm tra xem Ođiều gì xảy ra ở hai nơi khác, may mắn là cả hai đều đơn giản.

Đối với NINE, chín là khó cho dù bạn cắt nó như thế nào.

Vì vậy, chúng tôi kết thúc với bản đồ này:

[u=(l=t=>s.split(t).length-1)`U`,  //unused 0; precompute 'U's
 l`O`-l`W`-u,    //1
 l`W`,           //2
 l`R`-w,         //3
 u,              //4
 f=l`F`-u,       //5
 x=l`X`,         //6
 l`S`-x,         //7
 g=l`G`,         //8
 l`I`-x-g-f]     //9

9 có thể tham chiếu lại siX, eiGht và Five (với 5 foUr tham chiếu ngược) với các phép gán biến, lưu byte. Cảm ơn Neil vì điều này, nó sử dụng một số tính năng của JS mà tôi rất lạ lẫm (dấu tích ngược cho việc tước bỏ(' ví dụ, việc đánh một nửa) và thực sự đến gần hơn với ý tưởng tôi đã vẽ nguệch ngoạc trên giấy trước khi thử viết mã (tôi đã rời 9 như "những gì còn lại", suy nghĩ về nó như là "nếu tôi thấy một Xtôi có thể loại bỏ nó và một Svà Itừ chuỗi, sau đó ..." để sau khi bốn trường hợp đơn giản tiếp theo 3 sẽ trở thành đơn giản).

Lý do mục này là thú vị là vì nó có thể xử lý bất kỳ chuỗi xáo trộn nào làm đầu vào. tức là thay vì các từ riêng lẻ bị xáo trộn, chúng ta có thể xáo trộn toàn bộ chuỗi, đó là những gì tôi nghĩ John đang làm ban đầu:

q=s=>[u=(l=t=>s.split(t).length-1)`U`,l`O`-l`W`-u,l`W`,l`R`-w,u,f=l`F`-u,x=l`X`,l`S`-x,g=l`G`,l`I`-x-g-f].map((n,i)=>`${i}`.repeat(i&&n)).join``

const testCases = ['XENSENINEVSI']

testCases.forEach(testCase => console.log(testCase, q(testCase)))

Toán học, 133 byte

(s={};c=Characters;j=c@#;Table[If[FreeQ[j~Count~#&/@c[#[[i]]]&@ToUpperCase@IntegerName@Range@9,0],s~AppendTo~i],{i,9}];FromDigits@s)&

đầu vào

"VENESGTHIEENNI"

đầu ra

789

C #, 218 byte

Phiên bản ngắn:

string q(string s){var n="ONE,TWO,THREE,FOUR,FIVE,SIX,SEVEN,EIGHT,NINE".Split(',');for(inti=0,j;;i++)for(j=0;n[i].IndexOf(s[j])>=0;){if(++j==n[i].Length){var r=++i+"";for(;j<s.Length;r+=++i)j+=n[i].Length;return r;}}}

Phiên bản mở rộng:

string q(string s)
{
    var n = "ONE,TWO,THREE,FOUR,FIVE,SIX,SEVEN,EIGHT,NINE".Split(',');
    for (int i = 0, j; ; i++)
        for (j = 0; n[i].IndexOf(s[j]) >= 0;)
        {
            if (++j == n[i].Length)
            {
                var r = ++i + "";
                for (; j < s.Length; r += ++i)
                    j += n[i].Length;
                return r;
            }
        }
}

Hãy thử TRỰC TUYẾN!

Là mục nhập đầu tiên của tôi, tôi không chắc chắn về các quy tắc ... Tôi chỉ đếm kích thước của lớp được sử dụng để giải mã, chứ không phải mã kiểm tra nó, phải không?

Chỉnh sửa

Và để giải trí - đây là những gì tôi bắt đầu làm, không đọc các quy tắc hoàn chỉnh: S - Xem nó tại IdeOne . Nó khử nhiễu ngay cả khi các ký tự từ một chữ số có thể được xáo trộn đến bất kỳ vị trí nào trong chuỗi.

Chỉnh sửa 2

Rút ngắn theo lời khuyên của TheLethalCoder. Cảm ơn!

Chỉnh sửa 3

Và bây giờ Titus đã cạo thêm một vài byte. Cảm ơn!

JavaScript (ES6), 142 139 byte

Tiết kiệm được 3 byte nhờ Neil .

Hiện tại không tận dụng các số luôn được sắp xếp theo thứ tự tăng dần

f=s=>s?'ENO|OTW|EEHRT|FORU|EFIV|ISX|EENSV|EGHIT|EINN'.split`|`.findIndex(w=>[...s.slice(0,y=w.length)].sort().join``==w)+1+f(s.slice(y)):''

f=s=>s?'ENO|OTW|EEHRT|FORU|EFIV|ISX|EENSV|EGHIT|EINN'.split`|`.findIndex(w=>[...s.slice(0,y=w.length)].sort().join``==w)+1+f(s.slice(y)):''

const testCases = ['NEO', 'ENOWOT', 'EONOTWHTERE', 'SNVEEGHEITNEIN', 'ENOOWTEERHTRUOFEVIFXISNEVESTHGIEENIN']

testCases.forEach(testCase => console.log(testCase, f(testCase)))

Thạch , 38 byte

Dị“©ȯ¿w¶&ÇhṆỌƘ#Ȯʋ~¢CNẓ_»Ḳ¤FṢŒu
L3*Ç€iṢ

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

Giải trình

L3*Ç€iṢ    Main link. Argument: s (string)
L            Get length of s.
 3*          Raise 3 to that power. This will always be greater than n.
   ǀ        Get the name of each of the numbers using the helper link.
     iṢ      Find the position of the sorted input.

Dị“©ȯ¿w¶&ÇhṆỌƘ#Ȯʋ~¢CNẓ_»Ḳ¤FṢŒu    Helper link. Argument: n (number)
D                                   Get digits of n.
  “©ȯ¿w¶&ÇhṆỌƘ#Ȯʋ~¢CNẓ_»            The string "one two (...) eight nine AA".
                        Ḳ           Split that string at spaces.
 ị                                  Get name of each digit in the list.
                          F         Flatten to a single string.
                           Ṣ        Sort the characters.
                            Œu      Make uppercase.

Javascript (ES6), 221 byte

s=>(m=btoa`8Ñ>Mc¾LtDáNQ!Q>HþHA7átþ4Ò`.split`+`.map(s=>RegExp(s.replace(/(.)\1*/g,c=>`(?=(.*${c[0]}){${c.length}})`))),t=0,r=0,[...s].map(c=>(t+=c,d=1,n=0,m.map((r,i)=>t.match(r)&&(d--,n=i)),d||(r=r*10+n+1,t=0))),r)

Đoạn mã ví dụ:

f=

s=>(m=btoa`8Ñ>Mc¾LtDáNQ…!Q>H…þHA7átþ4Ò`.split`+`.map(s=>RegExp(s.replace(/(.)\1*/g,c=>`(?=(.*${c[0]}){${c.length}})`))),t=0,r=0,[...s].map(c=>(t+=c,d=1,n=0,m.map((r,i)=>t.match(r)&&(d--,n=i)),d||(r=r*10+n+1,t=0))),r)

console.log(f("NEO"))
console.log(f("ENOWOT"))
console.log(f("EONOTWHTERE"))
console.log(f("SNVEEGHEITNEIN"))
console.log(f("ENOOWTEERHTRUOFEVIFXISNEVESTHGIEENIN"))

Võng mạc , 160 byte

([ONE]{3})*([TWO]{3})*([THRE]{5})*([FOUR]{4})*([FIVE]{4})*([SIX]{3})*([SEVN]{5})*([EIGHT]{5})*([NIE]{4})*
$#1$*1$#2$*2$#3$*3$#4$*4$#5$*5$#6$*6$#7$*7$#8$*8$#9$*9

Hãy thử trực tuyến! Dựa vào câu trả lời PowerShell của @ TessellatingHeckler.

Võng mạc , 88 byte

[EFIST]

^(ON|NO)*
$#1$*1
O

W
2
HR|RH
3
UR|RU
4
X
6
GH|HG
8
(NN)*$
$#1$*9
r`NV|VN
7
V
5

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

Giải trình

• Đầu tiên, bỏ một loạt các ký tự không cần thiết cho sự khác biệt
• Chọn các số 1 ở phía trước (điều này cho phép chúng ta bỏ phần còn lại của Os ngay sau đó và xóa một số N trước khi chúng ta đi đến mớ hỗn độn 5, 7, 9)
• 2, 3, 4, 6 và 8 giờ là tầm thường
• 9s là một NN kép, vì vậy hãy lấy những thứ đó ra trước khi chúng ta giải quyết 5 và 7
• Thay 7 số từ bên phải (vì vậy chúng tôi không giảm VNV xuống 75 thay vì 57)
• 5s là Vs còn lại

PowerShell , 182 byte

[regex]::Replace("$args",'(?<1>[ONE]{3z2>[TWO]{3z3>[THRE]{5z4>[FOUR]{4z5>[FIVE]{4z6>[SIX]{3z7>[SVEN]{5z8>[EIGHT]{5z9>[NIE]{4})'.replace('z','})|(?<'),{$args.groups.captures[1].name})

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

Ungolfed nhưng không hoạt động mã:

[System.Text.RegularExpressions.Regex]::Replace("$args",

    '(?<1>[ONE]{3})       
    |(?<2>[TWO]{3})
    |(?<3>[THRE]{5})
    |(?<4>[FOUR]{4})
    |(?<5>[FIVE]{4})
    |(?<6>[SIX]{3})
    |(?<7>[SVEN]{5})
    |(?<8>[EIGHT]{5})
    |(?<9>[NIE]{4})'

    ,{$args.groups.captures[1].name}
)

ví dụ (?<3>[THRE]{5})phù hợp với lớp nhân vậtTHRE , do đó, nó có thể khớp chúng theo thứ tự và phải khớp bất kỳ nhân vật nào trong số năm nhân vật này cạnh nhau và nhóm bắt giữ được đặt tên là '3' để ánh xạ tên với các số.

Nén thô sơ bằng cách hoán đổi văn bản lặp lại })|(?<cho a z.

C ++, 296 , 288 byte

Phiên bản ngắn:

#define T string
using namespace std;T N[]={"ONE","TWO","THREE","FOUR","FIVE","SIX","SEVEN","EIGHT","NINE"};T Q(T S){T R="";for(int i=0;i<9;i++){do{if(S.find(N[i])!=T::npos){S.erase(S.find(N[i]),N[i].size());R+=to_string(i+1);}}while(next_permutation(N[i].begin(),N[i].end()));}return R;}

Phiên bản đầy đủ:

#define T string
using namespace std;

T N[]={"ONE","TWO","THREE","FOUR","FIVE","SIX","SEVEN","EIGHT","NINE"};

T Q(T S)
{
    T R="";
    for(int i=0;i<9;i++)                             //for all possible                             
                                                     //codewords (ONE,TWO...NINE)   
    {
        do
        {   
            if(S.find(N[i])!=T::npos)                //if found in encrypted word
            {
                S.erase(S.find(N[i]),N[i].size());  //erase it from the word
                R+=to_string(i+1);                  //save integer to the result string
            }
                                                    //check next permuation of codeword  

        } while(next_permutation(N[i].begin(),N[i].end())); 
    }                                                   

    return R;
}

Hãy thử TRỰC TUYẾN!

Chỉnh sửa:
1) 200-> 296 byte, để bao gồm không gian tên và định nghĩa của N trong số đếm, như được đề xuất bởi orlp 2) 296-> 288, để sử dụng macro, nhờ Zacharý

Ruby, 138 114 110 byte

gsub(/#{"3ONE3TWO5THRE4FOUR4FIVE3SIX5SEVN5EIGHT4NIE".gsub(/(.)(\D+)/,'([\2]{\1})|')}/){(1..9).find{|i|$~[i]}}

Số byte bao gồm 1 byte cho -p tùy chọn.

Gì?

Điều này:

/#{"3ONE3TWO5THRE4FOUR4FIVE3SIX5SEVN5EIGHT4NIE".gsub(/(.)(\D+)/,'([\2]{\1})|')}/

là một regex nghĩa đen, thông qua nội suy chuỗi, ước tính:

/([ONE]{3})|([TWO]{3})|([THRE]{5})|([FOUR]{4})|([FIVE]{4})|([SIX]{3})|([SEVN]{5})|([EIGHT]{5})|([NIE]{4})|/

Nếu chúng ta gán nó cho regex, phần còn lại của mã có phần dễ nắm bắt: Mỗi trận đấu trong đầu vào được thay thế bằng số nhóm bắt giữ, được trích xuất từ ​​biến ma thuật $~chứa dữ liệu khớp hiện tại:

gsub(regex){(1..9).find{|i|$~[i]}}

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

Java 8, 198 256 byte

s->{String r="",x=r;for(String n:"ONE TWO THREE FOUR FIVE SIX SEVEN EIGHT NINE".split(" ")){for(char c:n.toCharArray())x+="(?=.*"+c+")";x+="["+n+"]{"+n.length()+"}x";}for(int i=0,q;i<9;)for(q=(s+" ").split(x.split("x")[i++]).length-1;q-->0;)r+=i;return r;}

+58 byte .. do regex của phiên bản trước không hoạt động đúng (nó cũng khớp với "EEE"; "EEN"; v.v.)

Giải trình:

Hãy thử nó ở đây.

s->{                     // Method with String as parameter and return-type
  String r="",           //  Result-String
         x=r;            //  Regex-String
  for(String n:"ONE TWO THREE FOUR FIVE SIX SEVEN EIGHT NINE".split(" ")){
                         //  Loop (1) from "ONE" through "NINE":
    for(char c:n.toCharArray())
                         //   Inner loop (2) over the characters of this String
      x+="(?=.*"+c+")";  //    Append regex-group `(?=\w*c)` where `c` is the capital character
                         //   End of inner loop (2) (implicit / single-line body)
    x+="["+n+"]{"+n.length()+"}x";
                         //   Append regex part `[s]{n}` where `s` is the String, and `n` is the length
  }                      //  End of loop (1)
  // The regex now looks like this, which we can split on "x":
  // (?=.*O)(?=.*N)(?=.*E)[ONE]{3}x(?=.*T)(?=.*W)(?=.*O)[TWO]{3}x(?=.*T)(?=.*H)(?=.*R)(?=.*E)(?=.*E)[THREE]{5}x(?=.*F)(?=.*O)(?=.*U)(?=.*R)[FOUR]{4}x(?=.*F)(?=.*I)(?=.*V)(?=.*E)[FIVE]{4}x(?=.*S)(?=.*I)(?=.*X)[SIX]{3}x(?=.*S)(?=.*E)(?=.*V)(?=.*E)(?=.*N)[SEVEN]{5}x(?=.*E)(?=.*I)(?=.*G)(?=.*H)(?=.*T)[EIGHT]{5}x(?=.*N)(?=.*I)(?=.*N)(?=.*E)[NINE]{4}x
  for(int i=0,q;i<9;)    //  Loop (3) from 0 through 9 (exclusive)
    for(q=(s+" ").split(x.split("x")[i++]).length-1;
                         //   Split the input on the current regex-part,
                         //   and save the length - 1 in `q`
        q-->0;           //   Inner loop (4) over `q`
      r+=i               //    And append the result-String with the current index (+1)
    );                   //   End of inner loop (4)
                         //  End of loop (3) (implicit / single-line body)
  return r;              //  Return the result-String
}                        // End of method

Java (OpenJDK 8) , 181 byte

s->{String x="",r;for(int i=0,l;i<9;)for(r="ONE,TWO,THREE,FOUR,FIVE,SIX,SEVEN,EIGHT,NINE".split(",")[i++],l=r.length();s.matches("["+r+"]{"+l+"}.*");s=s.substring(l))x+=i;return x;}

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

Tôi đã tự do sử dụng lại mẫu TIO của Kevin Cruyssen . Hy vọng bạn không phiền;)

05AB1E , 36 31 byte

‘€µ‚•„í†ìˆÈŒšï¿Ÿ¯¥Š‘#vyœN>UvyX:

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

Xem nó chạy với gỡ lỗi: TIO With Debug

‘€µ‚•„í†ìˆÈŒšï¿Ÿ¯¥Š‘# | Push ['ONE', 'TWO', 'THREE', 'FOUR', 'FIVE', 'SIX', 'SEVEN', 'EIGHT', 'NINE']
vyœ                   | For each list of permutations of that word...
   N>U                | Push index + 1 into register X.          
      vyX:            | Replace each permutation with X.

Perl 5 , 102 + 1 (-n) = 103 byte

for$i(map{"[$_]{".length.'}'}ONE,TWO,THREE,FOUR,FIVE,SIX,SEVEN,EIGHT,NINE){$,++;print$,while(s/^$i//)}

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

Python 3 , 238 236 byte

def f(s):
 e=''
 while len(s):
  for i in range(9):
   for r in[''.join(p)for p in permutations('ONE TWO THREE FOUR FIVE SIX SEVEN EIGHT NINE'.split()[i])]: 
    if s[:len(r)]==r:e+=str(i+1);s=s[len(r):]
 return e
from itertools import*

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

Giải pháp Brute-force, không tận dụng lợi thế không giảm của các chữ số.

Cảm ơn @Mr. Xcoder để lưu 2 byte!

PHP, 141 byte

for($a=count_chars($argn);$c=ord($s[++$p]?:$s=[OWU,W,HG,U,FU,X,SX,G,N17.$p=0][$i-print str_repeat($i++,$x)]);)$x=$a[$i+48]+=($p?-1:1)*$a[$c];

phiên bản cũ hơn, 151 byte :

for($a=count_chars($argn,1);$s=[OWU,W,HG,U,FU,X,SX,G,N17][+$i++];print str_repeat($i,$a[$i+48]))for($p=0;$c=ord($s[$p]);)$a[$i+48]+=($p++?-1:1)*$a[$c];

các vòng lặp thông qua các chữ số từ 1 đến 9, đếm các ký tự duy nhất trong từ và trừ các ký tự không phải là duy nhất Số đếm, in chữ số khi đang di chuyển.
Mặc dù nó đang in khi đang di chuyển, số lượng chữ số phải được lưu trữ cho9 trường hợp hoạt động.

Chạy như đường ống với -nRhoặc thử trực tuyến .

Nó sẽ tiết kiệm thêm 4 byte để lưu trữ số lượng chữ số $a[$i]thay vì $a[$i+48]và sử dụng ASCII 1và7 (trong dấu ngoặc kép) thay vì chính các ký tự chữ số.

phá vỡ

for(
    $a=count_chars($argn,1);                # count character occurences in input
    $s=[OWU,W,HG,U,FU,X,SX,G,N17][+$i++];   # loop through digit names
    print str_repeat($i,$a[$i+48])              # print digit repeatedly
)
    for($p=0;$c=ord($s[$p]);)                   # loop through name
        $a[$i+48]+=                                 # add to digit count
        ($p++?-1:1)*                                # (add first, subtract other)
        $a[$c];                                     # character occurences

ONEkhông phải là từ duy nhất có an O, vì vậy nó cần phải trừ đi số đếm choW (chỉ xuất hiện trong TWO) và U(chỉ xuất hiện trong FOUR), v.v.
NINElà đặc biệt, bởi vì không có cách nào để trừ nếu tôi sử dụng các chữ cái (điều đó sẽ yêu cầu I-X-G-F+UhoặcN-O-S+W+U+X ), vì vậy tôi sử dụng số đếm thay thế.

PHP, 160 byte

$a=count_chars($argn);foreach([W2O,U4FOR,X6SI,G8I,F5I,O1,R3,S7,I9]as$s)for(${$s[$p=1]}+=$n=$a[ord($s)];$c=ord($s[++$p]);)$a[$c]-=$n;while($$i--?print$i:$i++<9);

giả định tất cả các trường hợp đầu vào; nhân vật có thể được tranh giành tất cả.
Chạy như ống với -nRhoặc thử trực tuyến .

giải trình

các vòng lặp thông qua các từ chữ số, đếm các ký tự duy nhất của chúng xảy ra trong đầu vào và trong quá trình giảm số lượng các ký tự khác. "Nhân vật khác" có thể nghĩa là tất cả các ký tự khác trong từ; nhưng chỉ xem xét những thứ sẽ cần sau này đã lưu 19 byte.

Chuyển đổi str_repeat vòng lặp thành vòng lặp kết hợp đã lưu 5 byte.

Và sử dụng các biến số cho số lượng chữ số đã lưu thêm 8.

phá vỡ

$a=count_chars($argn);                              # count character occurences in input
foreach([W2O,U4FOR,X6SI,G8I,F5I,O1,R3,S7,I9]as$s)   # loop through digit names
    for(${$s[$p=1]}+=                                   # 2. add to digits count
        $n=$a[ord($s)];                                 # 1. get count of unique character
        $c=ord($s[++$p]);)                              # 3. loop through other characters
        $a[$c]-=$n;                                         # reduce character count
while(
    $$i--?print$i                                       # print digit repeatedly
    :$i++<9);                                       # loop through digits