指导方针

情境

约翰有一个重要的数字，他不希望其他人看到它。

他决定使用以下步骤对数字进行加密：

他的号码始终是一个不递减的序列（即"1123"）

他将每个数字都转换成英语单词。（即"123" -> "ONETWOTHREE"）

然后，随机重新排列字母。（即"ONETWOTHREE" -> "ENOWTOHEETR"）

约翰觉得这样做很安全。实际上，这样的加密很容易解密：(

任务

给定加密的字符串s，您的任务是解密它并返回原始数字。

规则

• 这是代码高尔夫，所以最短答案以字节为单位
• 您可以假设输入字符串始终有效
• 输入字符串仅包含大写字母
• 原始编号始终按升序排列
• 您可以以字符串或整数格式返回数字
• 字母将仅在一个单词之间而不是在整个字符串之间随机播放。
• 这些数字只能是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并用两个字符（例如“ 12”）替换任何Os和用三个字符（例如，X）替换所有长度为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

然后，根据我们的选择（“ 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

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（三个；t插槽中为1，r插槽中为1，插槽中为1，h插槽中为2 e）。通过这种方式，每个数字都有一个唯一的表示形式，可以通过迭代字符串并求和一些数字来轻松地将它们拼凑在一起，并且最终得到的结果与字母的实际顺序无关。当然，这并不是理想的解决方案，但是当前的解决方案仍然牢记这一想法。

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

在线尝试！

使用Javascript（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而言，无论您如何分割，九都很难。

因此，我们最终得到此地图：

[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和5（具有5个向后引用格式），从而节省了字节。多亏了Neil，它使用了我非常不熟悉的JS的几个功能（('例如，将两半剥离的反勾号），并且实际上更接近于我在纸上尝试之前写出来的想法。 （我将9保留为“剩下的内容”，以为它是“如果我看到一个X我可以将其和an Sand 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)))

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上查看。即使可以将一位数字的字符加扰到字符串中的任何位置，它也会解密。

编辑2

根据TheLethalCoder的提示进行了缩短。谢谢！

编辑3

现在，Titus剃了几个字节。谢谢！

的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（这使我们可以立即丢弃其余的O，并在到达5、7、9混乱之前清除一些N）。
• 2、3、4、6和8现在微不足道
• 9是双NN，因此在处理5和7之前先将它们拿掉
• 从右侧替换7s（因此我们不会将VNV降低到75，而不是57）
• 剩下的Vs是5s

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，因此它可以无序匹配它们，并且必须将这些字符中的任何一个相邻匹配五次，并且捕获组被命名为“ 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]}}

字节数包括1个字节的-p选项。

什么？

这个：

/#{"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与调试

‘€µ‚•„í†ìˆÈŒšï¿Ÿ¯¥Š‘# | 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*

在线尝试！

蛮力解决方案没有利用数字的非递减性。

感谢@先生。Xcoder可节省2个字节！

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