ガイドライン

シナリオ

ジョンには重要な数があり、他の人に見られたくない。

彼は、次の手順を使用して番号を暗号化することにしました。

彼の番号は常に非減少列である（すなわち。"1123"）

彼は各桁を英語の単語に変換しました。（つまり"123" -> "ONETWOTHREE"）

そして、文字をランダムに並べ替えます。（つまり"ONETWOTHREE" -> "ENOWTOHEETR"）

ジョンはそうすることで彼の番号が安全であると感じました。実際、このような暗号化は簡単に解読できます:(

仕事

暗号化された文字列sが与えられたら、あなたの仕事はそれを解読して元の番号を返すことです。

ルール

• これはコードゴルフであるため、バイト単位の最短回答が優先されます
• 入力文字列は常に有効であると仮定できます
• 入力文字列には大文字のみが含まれています
• 元の番号は常に昇順で配置されます
• 文字列または整数形式で数値を返すことができます
• 文字は、文字列全体ではなく、1つの単語間でのみシャッフルされます。
• 数字は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のゼリーの答えは、まだ同じバイト数を持っている（私は実際にそれがかもしれないと思った ことはなかった以下のように終わります）！

元の数値の単調性に依存しません（HTREEWTONOEたとえば、の入力は機能します）。

どうやって？

最初に、Rs、Gs、Ssを削除し、Osを2文字（「12」など）に置き換え、Xを3文字に置き換えて、単語自体（およびそのアナグラム）をすべて長さ4に変更できることに注意してください（ 「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

次に、選択に応じてモジュロ演算を使用して、これらの文字の序数の積を1〜9の数値にマッピングし（「12345」）、次に、これらを数字の並べ替えられたリストで検索します。コードは実際に最初に文字にキャストしてから序数を置き換えますが、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

Python 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（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

マジックナンバーファインダー：

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

他の2つのJSエントリよりも長くなっていますが、他の言語の人に役立つかもしれない興味深いアプローチをやめると思いました。

基本的に、次のことを判断できます。

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

これらの文字の出現は、その数字が元の数字に存在することを意味します。ここから、残りの数字を推測できます。

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

2つの複雑なケースを含む：

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

両方1と9比較的ハード。ONEの場合E、いくつかの単語（SEVEN2つあります）で複数回表示されますN（NINE）のでO、他の2つの場所でどちらが発生するかをチェックする必要があります。幸いなことに両方とも簡単です。

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つの逆参照foUrを含む）を後方参照でき、バイトを節約できます。Neilのおかげで、JSのいくつかの機能を使用しています（('たとえば、半分にストリッピングするためのバックティック）、実際にコーディングする前に紙に落書きしたアイデアにずっと近づいています（私は「私が見るかのようにそれについて考え、「オーバー残っているもの」として9を残したのだX、私はそれを削除することができ、SかつI、その後...文字列から」そう4つの簡単な例の後に次の3があろうとなりますシンプル）。

このエントリが興味深いのは、シャッフルされた文字列を入力として処理できるためです。つまり、個々の単語をシャッフルするのではなく、文字列全体をシャッフルすることができます。

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

Mathematica、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でそれを見てください。1桁の文字を文字列内の任意の場所にスクランブルできる場合でも、暗号化を解除します。

編集2

TheLethalCoderによるヒントに従って短縮されました。ありがとう！

編集3

そして今、タイタス​​はさらに数バイト削りました。ありがとう！

JavaScript（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.

Javascript（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を選択します（これにより、5、7、9の混乱に到達する前に、残りのOをすぐにドロップし、Nをクリアします）。
• 2、3、4、6、および8は今では簡単です
• 9はダブルNNなので、5と7を処理する前に最後からそれらを取得します
• 右から7を置き換えます（したがって、VNVを57ではなく75に減らしません）
• 5sは残りの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})

オンラインでお試しください！

ゴルフではないが動作しないコード：

[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、198 256バイト

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

Java（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.

Perl 5、102 + 1（-n）= 103バイト

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

オンラインでお試しください！

Pythonの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か、オンラインで試してください。

ASCII を使用する$a[$i]代わりに桁数を保存するためにさらに4バイトを節約し、$a[$i+48]17、数字自体の代わりに（引用符で）します。

壊す

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