지침

대본

요한은 중요한 숫자를 가지고 있으며 다른 사람들이 그것을보고 싶어하지 않습니다.

그는 다음 단계를 사용하여 번호를 암호화하기로 결정했습니다.

그의 수는 항상 비 감소 순서입니다 (예. "1123")

그는 각 숫자를 영어 단어로 변환했습니다. (예. "123" -> "ONETWOTHREE")

그런 다음 글자를 무작위로 재 배열하십시오. (예. "ONETWOTHREE" -> "ENOWTOHEETR")

요한은 자신의 수가 안전하다고 느꼈습니다. 실제로 이러한 암호화는 쉽게 해독 할 수 있습니다.

태스크

암호화 된 문자열이 주어지면 작업은 암호를 해독하고 원래 숫자를 반환하는 것입니다.

규칙

• 이것은 코드 골프이므로 바이트 단위의 최단 답변이 이깁니다.
• 입력 문자열이 항상 유효하다고 가정 할 수 있습니다
• 입력 문자열은 대문자 만 포함합니다
• 원래 숫자는 항상 오름차순으로 정렬됩니다
• 숫자를 문자열 또는 정수 형식으로 반환 할 수 있습니다
• 글자는 전체 문자열이 아닌 한 단어 사이에서만 섞입니다.
• 숫자는 1에서 9까지입니다 ( ONE~ NINE)

가능한 스크램블되지 않은 문자열

다음은 문자열을 숫자에서 문자열로 변환 한 직후의 목록입니다.

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

예

"NEO" -> 1

"ENOWOT" -> 12

"EONOTWHTERE" -> 123

"SNVEEGHEITNEIN" -> 789

"ENOOWTEERHTRUOFEVIFXISNEVESTHGIEENIN" -> 123456789

"NOEWOTTOWHEERT" -> 1223

젤리 ,  38  37 바이트

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

문자 목록 (문자열)을 가져와 정수를 반환하는 모나드 링크.

온라인으로 사용해보십시오!

Pietu1998의 Jelly 답변 과 는 매우 다른 방법을 사용 하지만 바이트 수는 동일합니다 ( 실제로 그것이 끝날 것이라고 생각했습니다 )!

원래 숫자의 단 조성에 의존하지 않습니다 (따라서 입력 HTREEWTONOE은 작동합니다).

어떻게?

먼저, 단어 자체 (및 그에 따른 임의의 아나그램)는 Rs, Gs 및 Ss를 제거하고 Os를 2 개의 문자 (예 : "12")로 대체하고 X를 3 개의 문자 ( "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

그런 다음 선택한 문자 ( "12345")에 따라 모듈로 산술을 사용하여 해당 문자 서수의 곱을 1에서 9까지의 숫자로 매핑 한 다음 순서대로 정렬 된 숫자 목록에서 찾을 수 있습니다. 코드는 실제로 문자로 먼저 캐스트 한 다음 서수를 대체하지만 37 바이트 단위의 문자 (예 : "DIAAE"( 시도해보십시오 )) 로도 가능합니다 .

ḟ“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

파이썬 2 121 117 115 바이트

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 바이트 : 모든 골프 후에는 일회용 변수를 인라인하는 것을 잊었습니다. 뇌 방귀.
-2 바이트 : 이중 간격 들여 쓰기 → 단일 탭 들여 쓰기 (Coty Johnathan Saxman 덕분에); 이것은 답변에 올바르게 표시되지 않습니다.

Ungolfed (파이썬 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

매직 넘버 파인더 :

#!/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))

설명:

나는 ASCII 비트를 함께 부수고 어떻게 든 전체 단어가 언제 있는지 결정하기 위해 그것들을 요약 할 수 있다고 생각했습니다. 원래 나는 엉망 3**ord(letter)이고 예상 결과와 비교 하려고 시도 했지만 결과가 매우 많았습니다. 나는 일부 매개 변수, 즉 모듈러스 (수를 작게하기 위해)와 모듈러스 범위 주위에서 숫자를 다르게 분산시키는 승수를 조금 무차별하게하는 것이 적절할 것입니다.

나는 곱셈 변수를 전력 자체에 영향을 미치는 변수로 바꾸었다. (시험 시행 착오에서) 어떻게 든 조금 짧은 골프 답변을 주었기 때문이다.

그리고 당신은 그 무차별 강제력과 약간의 수동 골프의 결과를 볼 수 있습니다.

3**x원래 선택하는 이유 는 모든 숫자를 나타낼 수 있다는 것을 알고 있기 때문입니다. 숫자가 가장 많이 반복되는 숫자는 2 개 (thrEE, sEvEn, NiNe 등)이므로 모든 입력을 기본 3 숫자로 생각하기로 결정했습니다. 그렇게하면 (정신적으로) 10100000000010020000(3 : t슬롯의 1, r슬롯의 1, h슬롯 의 1 및 슬롯의 2)과 같은 것으로 나타낼 수 있습니다 e. 이 방법으로 각 숫자는 문자열을 반복하고 숫자를 합하여 쉽게 조각 할 수있는 고유 한 표현을 얻습니다. 실제 문자의 순서와 무관합니다. 물론 이것은 이상적인 솔루션으로 보이지는 않았지만 현재 솔루션은 여전히이 아이디어를 염두에두고 작성되었습니다.

파이썬 (2) , 131 (127) 바이트

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

온라인으로 사용해보십시오!

JavaScript Draco18s 솔루션 의 수정 된 버전을 기반으로합니다 .

PHP , 164 바이트

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

온라인으로 사용해보십시오!

PHP , 179 바이트

이전 접근 방식을 기반으로 먼저 짝수를 확인한 다음 홀수를 순서대로 증가시킵니다.

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

온라인으로 사용해보십시오!

PHP , 201 바이트

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

온라인으로 사용해보십시오!

자바 (ES6) 288 150 144 바이트

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

다른 JS 항목 중 다른 두 항목 보다 더 길지만 다른 언어로 누군가에게 도움이 될 수있는 흥미로운 접근법을 포기할 것이라고 생각했습니다.

본질적으로 우리는 다음을 결정할 수 있습니다.

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

이 문자가 나타나면 해당 숫자가 원래 숫자로 존재한다는 의미입니다. 여기에서 나머지 숫자를 추론 할 수 있습니다.

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

두 가지 복잡한 경우를 포함합니다.

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

하드 1와 9면적 모두 비교적. ONE의 경우, E최대 이상 일부 단어에 한 번 이상 쇼 ( SEVEN이있다)처럼 N( NINE), 확인 나왔습니다 붙어 우리가 정도 O되는 다행히 모두가 간단, 두 개의 다른 장소에서 발생합니다.

NINE의 경우 슬라이스 방식에 관계없이 9 개는 어렵습니다.

따라서 우리는이지도로 끝납니다 :

[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는 변수 할당으로 siX, eiGht 및 ​​Five (5의 역 참조 fore와 함께)를 역 참조하여 바이트를 절약 할 수 있습니다. Neil 덕분에 JS의 몇 가지 기능을 사용합니다 ( ('예를 들어 반으로 벗기는 백틱 ). 실제로 코딩하려고 시도하기 전에 종이에 낙서 한 아이디어에 훨씬 가깝습니다. (I는 "내가 볼 것처럼 그것에 대해 생각,"남은 무슨 "로 9 왼쪽했던 X나는 그것을 제거 할 수 있고 S하고 I, 다음 ... 문자열에서"이렇게 네 개의 간단한 경우 한 후 다음 3는 것이 될 단순한).

이 항목이 흥미로운 이유는 섞인 문자열 을 입력으로 처리 할 수 ​​있기 때문 입니다. 즉, 개별 단어를 섞는 대신 전체 줄을 섞을 수 있습니다. 이는 John이 원래하고 있다고 생각한 것입니다.

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

수학, 133 바이트

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

입력

"VENESGTHIEENNI"

산출

789

C #, 218 바이트

짧은 버전 :

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

확장 버전 :

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

온라인을보십시오!

첫 번째 항목이기 때문에 규칙에 대해 잘 모르겠습니다 ... 해독하는 데 사용되는 클래스의 크기 만 계산합니다. 테스트하는 코드는 아닙니다.

편집하다

그리고 그것의 재미를 위해-여기에 완전한 규칙을 읽지 않고 내가 시작한 것이 있습니다 : S- IdeOne에서 그것을보십시오 . 한 자릿수의 문자를 문자열의 임의의 위치로 스크램블 할 수있는 경우에도 암호를 해독합니다.

편집 2

TheLethalCoder의 팁에 따라 단축되었습니다. 감사!

편집 3

그리고 이제 Titus는 몇 바이트 더 면도했습니다. 감사!

자바 스크립트 (ES6) 142 139 바이트

Neil 덕분에 3 바이트를 절약했습니다 .

현재 숫자를 활용하지는 않지만 항상 오름차순으로 정렬됩니다

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

젤리 , 38 바이트

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

온라인으로 사용해보십시오!

설명

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.

자바 스크립트 (ES6), 221 바이트

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)

코드 스 니펫 예제 :

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"))

레티 나 , 160 바이트

([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

온라인으로 사용해보십시오! @TessellatingHeckler의 PowerShell 답변을 기반으로합니다.

레티 나 , 88 바이트

[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

온라인으로 사용해보십시오!

설명

• 첫째, 구별에 필요하지 않은 불필요한 문자를 삭제하십시오.
• 전면에서 1을 선택하십시오 (이로 인해 나머지 Os를 즉시 드롭하고 5, 7, 9 혼란에 도달하기 전에 일부 N을 정리할 수 있습니다)
• 2, 3, 4, 6 및 8은 이제 사소합니다.
• 9s는 더블 NN이므로 5와 7을 다루기 전에 끝까지 잡으십시오.
• 오른쪽에서 7을 바꿉니다 (57 대신 VNV를 75로 줄이지 않음)
• 5는 나머지 V입니다

PowerShell , 182 바이트

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

온라인으로 사용해보십시오!

Ungolfed이지만 작동하지 않는 코드 :

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

예를 들어 (?<3>[THRE]{5}), 문자 클래스와 일치 THRE하므로 순서가 맞지 않을 수 있으며 이러한 문자를 서로 5 번 일치시켜야하며 캡처 그룹의 이름은 '3'으로 지정되어 이름과 숫자를 매핑합니다.

에 반복되는 텍스트 })|(?<를 교체하여 기본 압축 z.

C ++, 296 , 288 바이트

짧은 버전 :

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

풀 버전:

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

온라인을보십시오!

편집 :
1) 200-> 296 바이트, 카운트에 N의 네임 스페이스 및 정의 포함, orlp에서 제안한 2) 296-> 288, Zacharý 덕분에 매크로 사용

루비, 138 (114) 110 바이트

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

바이트 수에는 -p옵션에 대한 1 바이트가 포함됩니다 .

뭐?

이:

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

문자열 보간을 통해 다음과 같이 평가되는 정규식 리터럴입니다.

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

에 regex코드 를 할당 하면 나머지 코드를 파악하기가 다소 쉽습니다. 입력의 각 일치 항목 $~은 현재 일치 데이터가 포함 된 마법 변수에서 추출 된 캡처 그룹의 수로 대체됩니다 .

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

온라인으로 사용해보십시오!

Java 8, 198256 바이트

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 바이트. 이전 버전의 정규식으로 인해 제대로 작동하지 않습니다 ( "EEE"; "EEN";

설명:

여기에서 시도하십시오.

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

자바 (OpenJDK 8) , 181 바이트

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

온라인으로 사용해보십시오!

Kevin Cruyssen의 TIO 템플릿 을 재사용하기 위해 자유를 얻었습니다 . 당신이 신경 쓰지 않기를 바랍니다.)

05AB1E , 36 31 바이트

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

온라인으로 사용해보십시오!

디버그로 실행 한보기 : 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.

펄 5 , 102 + 1 (-n) = 103 바이트

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

온라인으로 사용해보십시오!

파이썬 3 , 238 236 바이트

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*

온라인으로 사용해보십시오!

무차별 대입 솔루션은 숫자의 비 감소를 이용하지 않습니다.

@Mr에게 감사합니다. 2 바이트 절약을위한 Xcoder!

PHP, 141 바이트

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];

이전 버전, 151 바이트 :

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];

는 1에서 9까지의 숫자를 반복하여 단어의 고유 문자를 계산하고 고유하지 않은 문자의 수를 빼서 이동 중에 숫자를 인쇄합니다.
이동 중에 인쇄 중이지만 9케이스가 작동 하려면 숫자 카운트를 저장해야합니다 .

파이프로 실행 -nR하거나 온라인으로 사용해보십시오 .

그것은에 자리 수를 저장하기 위해 4 바이트 이상을 절약 할 수 $a[$i]대신 $a[$i+48]사용의 ASCII 1하고 7대신 숫자 문자 자체의 (따옴표).

고장

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

ONE있는 유일한 단어가 아니다 O그것을위한 카운트 뺄 필요가 있으므로, W(에서만 나타나는 TWO)와 U(에서만 나타나는 FOUR) 등을.
NINE문자를 사용하면 ( I-X-G-F+U또는 필요한 문자) 빼기 할 수있는 방법이 없으므로 N-O-S+W+U+X대신 숫자를 사용합니다.

PHP, 160 바이트

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

모든 대문자 입력을 가정합니다. 모든 문자가 스크램블 될 수 있습니다.
파이프로 실행 -nR하거나 온라인으로 사용해보십시오 .

설명

입력과 다른 문자의 수를 줄이는 과정에서 고유 문자의 발생을 계산하여 숫자 단어를 반복합니다. "기타 문자" 는 단어의 다른 모든 문자를 의미 할 수 있습니다 . 그러나 나중에 필요할 것만 고려하면 19 바이트가 절약됩니다.

str_repeat루프를 결합 루프로 변환하면 5 바이트가 절약되었습니다.

그리고 숫자 카운트에 변수 변수를 사용하면 또 다른 8이 절약되었습니다.

고장

$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