这个挑战是基本相同的这一个只有一个区别：它现在允许在字符串中的任何洗牌字母。

情境

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

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

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

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

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

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

任务

给定加密的字符串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

"NWEOOT" -> 12

"TOEERWNEHOT" -> 123

"IHNEVGENNEISTE" -> 789

"WEETVTRFSVUHNEEFRHIXEOINSNIEGTOONIEE" -> 123456789

"EWHEWROETOTTON" -> 1223

"ONEWESTV" -> 27 （感谢ETHproductions！）

Python 2，123字节

c=map(input().count,"OWHUFXSGIQ")
i=4
for j in"71735539994":c[i*2]-=c[int(j)];i=-~i%5
s=""
for n in c:i+=1;s+=`i`*n
print s

一个完整的程序，使用加引号的输入并打印John的号码。

在线尝试！或见一个测试套件

怎么样？

让我们使用示例“ NEONSEXTOWNII”（产生1269，并且有点休闲套件Larry -esque！）。

首先c=map(input().count,"OWHUFXSGIQ")输入并计数每个OWHUFXSGIQ字母的数量-这些字母以升序出现在每个数字中，其中2,4、6和8的“自己”字母（WUXG），外加一个字母，Q以附加零到最后，并使结果列表的长度均匀。例如：

[2,1,0,0,0,1,1,0,2,0] <- c
 O W H U F X S G I Q  <- is the counts of these letters
 1 2 3 4 5 6 7 8 9 0  <- which "relate to" these digits in John's number
   2   4   6   8   0  <- these will be correct as the letters are unique to their words

需要调整1、3、5、7和9的条目以更正其他字母的数量。这由下一个循环执行：

i=4
for j in"71735539994":c[i*2]-=c[int(j)];i=-~i%5

请注意，要调整的条目是交替的条目（1,3,5,7,9,1,3,5，...），因此我们可以在每个步骤中将两个加到索引变量中，并以10为模进行求和如果我们需要遍历不止一次（我们这样做）。为了节省一些字节，我们可以增加1，以5为模，并使用两倍的索引。
由于对9的调整需要最多的工作，因此我们从此处开始–它位于索引8处，因此我们从开始i=4。然后，字符串为每个阶段提供要删除的值"71735539994"的索引，j（在"Q"创建时，我们已确保使用，第九个索引将包含零c）；c[i*2]-=c[int(j)]执行每个单独的调整和i=-~i%5移动i到下一个索引（其中，-~i是-(-1-i)或i+1保存括号(i+1)%5）保持i*2在...的范围内c。
因此，我们首先从索引j=7处的索引i*2=8中减去索引处的数目，从“ I”的数目中减去计数的“ G”的数目，将“ NINE”的数目向下调整（正确的）“ EIGHT”的数目（其中也有一个“ I”）。然后，我们移至i=0（-~4%5 = (4+1)%5 = 0），引用i*2 = 0表示“ ONE”的索引，并减去索引j=1中“ W”和“ TWO”两个条目的值，向下调整“ O”的数量。到循环结束时，我们得到了更正的计数：

[1,1,0,0,0,1,0,0,1,0] <- c   (for 1223333448 it would be: [1,2,4,2,0,0,0,1,0,0])
 1 2 3 4 5 6 7 8 9 0

所以剩下的就是打印出现在c代表（1269）的内容。i现在回到0，因此我们在循环开始时将其递增，并将其用作数字：

s=""
for n in c:i+=1;s+=`i`*n
print s

背面蜱，`i`是Python2简写repr(i)其由许多作者：丛松获得一个对象（问题作为一个字符串的数字字符）的字符串表示和乘以一个字符串，许多重复（新字符串这里我们只显示n=0转向`i`从发言权"5"以""和n=1转向保持发言权"6"的"6"，但它也适用于较大的正整数，因此"3"*4成为"3333"例如）。

05AB1E，31个字节

[{‘Z€µ‚•„í†ìˆÈŒšï¿Ÿ¯¥Š‘#NSèJ{Q#

在线尝试！

说明

[                                   # start loop
 {                                  # sort input
  ‘Z€µ‚•„í†ìˆÈŒšï¿Ÿ¯¥Š‘#            # push the list ['Z','ONE','TWO','THREE','FOUR','FIVE','SIX','SEVEN','EIGHT','NINE']
                        N           # push the current iteration counter
                         S          # split to list of digits
                          è         # index into the list with each
                           J{       # join to string and sort
                             Q#     # if the strings are equal, exit loop
                                    # implicitly print iteration counter

对于大量输入而言非常低效。

视网膜，112 97字节

O`.
}`GH
8
X
6
H
3
+`F(.*)O(.*)U
4$1$2
+`O(.*)W
2$1
+`F(.*)V
5$1
+`N(.*)V
7$1
}`NO
1
NN
9
T`L
O`.

在线尝试！

-12个字节感谢@Neil

通过使用L个字符类在转置中使用-3个字节

怎么运行的

基本上，这取决于仅在某些数字名称中使用字母的事实。例如SIX，唯一的名称包含一个X。由于某些单词在字母中重叠（例如和都使用FIVE和）重叠，因此变得更加棘手。这可以通过识别被校正用。SEVENVFIVEF(.*)V

科特林1.1，359个 352 331 327 325字节

投稿

fun r(r:String):String{var s=""
val f=r.split(s).groupingBy{it}.eachCount()
val c=Array(10,{0})
c[8]=f["G"]?:0
c[6]=f["X"]?:0
c[4]=f["U"]?:0
c[2]=f["W"]?:0
c[1]=(f["O"]?:0)-c[2]-c[4]
c[3]=(f["R"]?:0)-c[4]
c[7]=(f["S"]?:0)-c[6]
c[5]=(f["V"]?:0)-c[7]
c[9]=((f["N"]?:0)-c[1]-c[7])/2
for(i in 1..9)for(x in 1..c[i])s+=i
return s}

由于不支持Kotlin 1.1，因此无法在TryItOnline上运行

测试

fun r(r:String):String{
val f=r.split("").groupingBy{it}.eachCount()
val c=Array(10,{0})
c[8]=f["G"]?:0
c[6]=f["X"]?:0
c[4]=f["U"]?:0
c[2]=f["W"]?:0
c[1]=(f["O"]?:0)-c[2]-c[4]
c[3]=(f["R"]?:0)-c[4]
c[7]=(f["S"]?:0)-c[6]
c[5]=(f["V"]?:0)-c[7]
c[9]=((f["N"]?:0)-c[1]-c[7])/2
var s=""
for(i in 1..9)for(x in 1..c[i])s+=i
return s}

data class TestData(val input: String, val output: String)

fun main(vararg args:String) {
    val items = listOf(
    TestData("NEO" , "1"),
    TestData("NWEOOT" , "12"),
    TestData("TOEERWNEHOT" , "123"),
    TestData("IHNEVGENNEISTE" , "789"),
    TestData("WEETVTRFSVUHNEEFRHIXEOINSNIEGTOONIEE" , "123456789"),
    TestData("EWHEWROETOTTON" , "1223")
    )
    for (item in items) {
        val out = r(item.input)
        if (out != item.output) {
            throw AssertionError("Bad result: $item : $out")
        }
    }
}

逻辑

我用上面的表格算出了解决每个字母的最简单方法

• 绿色=自行解决
• 蓝色=需要绿色解决
• 橙色=需要布鲁斯解决
• 红色=需要橙子解决

编辑

• -7-空格按w0lf进行更改
• -21-将listOf缩小为Array
• -4-删除了不需要的括号
• 0-添加逻辑
• -2-借助kevin-cruijssen，重新使用空字符串

果冻，37个字节

1ðDị“©ȯ¿w¶&ÇhṆỌƘ#Ȯʋ~¢CNẓ_»ŒuḲ¤ẎŒ!ċð1#

在线尝试！

-1感谢乔纳森·艾伦。

Java的8，248个 234字节

s->{int x=0,a[]=new int[10];for(String t:"2WO;4UORF;6XSI;8GI;5FI;7S;3R;1O;9I".split(";"))for(;s.indexOf(t.charAt(1))>=0;a[t.charAt(0)-48]++)for(String z:t.split(""))s=s.replaceFirst(z,"");for(s="";x++<9;)for(;a[x]-->0;)s+=x;return s;}

代码说明：

s->{
    // Array to count how often which number appears
    int a[]=new int[10];
    // The first character behind the number serves the identification
    // the other characters get removed to identify the other numbers later
    for(String t:"2WO;4UORF;6XSI;8GI;5FI;7S;3R;1O;9I".split(";"))
        // Check if the string contains the id 
        for(;s.indexOf(t.charAt(1))>=0;a[t.charAt(0)-48]++)
            // Remove the relevant charcters
            for(String z:t.split(""))
                s=s.replaceFirst(z,"");
    // Clear the string to write the output
    s="";
    // write the numbers sequential into the output 
    for(int x=0;x++<9;)
        for(;a[x]-->0;)
            s+=x;
    return s;
}

-14感谢OlivierGrégoire

爪哇8，346个 345 344 336 327字节

s->{int g=c(s+=" ","G"),u=c(s,"U"),w=c(s,"W"),x=c(s,"X"),f=c(s,"F")-u,h=c(s,"H")-g,v=c(s,"V")-f,o=c(s,"O")-u-w,i=c(s,"I")-f-x-g;return d(s=d(s=d(s=d(s=d(s=d(s=d(s=d(s=d("",o,1),w,2),h,3),u,4),f,5),x,6),v,7),g,8),n,9);}int c(String...s){return~-s[0].split(s[1]).length;}String d(String s,int i,int n){for(;i-->0;s+=n);return s;}

在这里尝试。

一般说明：

我看过字母表中每个字符的出现：

E 13357789
F 45
G 8
H 38
I 5689
N 1799
O 124
R 34
S 67
T 238
U 4
V 57
W 2
X 6

• 我首先计算了所有出现的单匹配字符：G=8; U=4; W=2; X=6。
• 然后出现所有两个匹配的字符，这些字符也匹配上述四个字符之一，我可以从它们的计数中减去F=5; H=3。
• 然后，我再次做了同样的事情V=7（减去F=5）。
• 然后，剩下的所有三个匹配字符都相同：O=1; N=9。
  • 但是由于中N有两次出现，因此我必须为的每次出现NINE都做一个额外-1的操作N，所以我I=9改用了（通过减去之前的三个匹配项而不是两个）。

代码说明：

s->{                    // Method with String as parameter and return-type
  int g=c(s+=" ","G"),  //  Amount of 8s (and append a space to `s` first, for the .split)
      u=c(s,"U"),       //  Amount of 4s
      w=c(s,"W"),       //  Amount of 2s
      x=c(s,"X"),       //  Amount of 6s
      f=c(s,"F")-u,     //  Amount of 5s
      h=c(s,"H")-g,     //  Amount of 3s
      v=c(s,"V")-f,     //  Amount of 7s
      o=c(s,"O")-u-w,   //  Amount of 1s
      i=c(s,"I")-f-x-g; //  Amount of 9s
  return d(             //  Return the result by:
   s=d(
    s=d(
     s=d(
      s=d(
       s=d(
        s=d(
         s=d(
          s=d("",       //   Making the input String `s` empty, since we no longer need it
                 o,1),  //   Append all 1s to `s`
         w,2),          //   Append all 2s to `s`
        h,3),           //   Append all 3s to `s`
       u,4),            //   Append all 4s to `s`
      f,5),             //   Append all 5s to `s`
     x,6),              //   Append all 6s to `s`
    v,7),               //   Append all 7s to `s`
   g,8),                //   Append all 8s to `s`
  i,9);                 //   And then returning `s` + all 9s
}                       // End of method

int c(String...s){  // Separate method with String-varargs parameter and int return-type
                    //  `s[0]` is the input-String
                    //  `s[1]` is the character to check
  return~-s[0].split(s[1]).length;
                    //  Return the amount of times the character occurs in the String
}                   // End of separated method (1)

String d(String s,int i,int n){
               // Separate method with String and two int parameters and String return-type
  for(;i-->0;  //  Loop from the first integer-input down to 0
      s+=n     //   And append the input-String with the second input-integer
  );           //  End of loop
  return s;    //  Return the resulting String
}              // End of separated method (2)

Perl 5，100字节

99字节代码+ 1字节用于-n切换。

${$_}++for/./g;@a=($O-$W-$U,$W,$H-$G,$U,$F-$U,$X,$S-$X,$G,$I-$F+$U-$X-$G);print$_ x$a[$_-1]for 1..9

在线尝试！

Python 3，225字节

def f(s):
	r=[]
	for i,w in zip([2,4,6,8,3,5,7,1,9],["WTO","UFOR","XSI","GEIHT","HTREE","FIVE","VSEEN","ONE","NINE"]):
		while s.count(w[0]):
			r+=[i]
			for l in w:s="".join(s.split(l,1))
	return "".join(sorted(map(str,r)))

在线尝试！

简单明了：首先删除由特定字母标识的数字。

Python 3，125个字节

lambda s:''.join(min(w)*(2*sum(map(s.count,w[:2]))-sum(map(s.count,w)))for w in"O1WU W2 H3G U4 F5U X6 S7X G8 IUFXG9".split())

在线尝试！

阅读了链接的挑战后，我意识到这是mdahmoune的Python解决方案的变体，它本身就是基于Draco18s的ES6解决方案的，但是，至少我们打了两个字节。

像该解决方案一样，我们通过某些字母出现次数的线性组合来计算答案。我们通过将线性组合编写为单词来对它们进行简短编码，在其中添加前两个字母，然后减去所有内容。有时需要一个字符来填充前两个字符；我们用它来隐藏我们要输出的数字（该数字永远不会出现在输入中，因此不会影响我们的算法），并用提取min。

R，154

u=utf8ToInt(s)-71
m=sum
b=m(u==16)
d=m(u==14)
f=m(u==17)
a=m(u==8)-b-d
g=m(u==12)-f
cat(rep(1:9,c(a,b,m(u==11)-d,d,m(u==15)-g,f,g,m(!u),(m(u==7)-a-g)/2)))

在线尝试！

公理，351字节

s:="GXUWRFVIONETHS";e:EqTable(CHAR,INT):=table();v:=[8,6,4,2,3,5,7,9,1];z:=[k for k in 1..46|prime?(k)];F(x,y)==>for i in 1..#x repeat y;F(z,e.(s.i):=z.i);t:=[1787026,2451,16445,5957,16036207,130169,20372239,495349,20677];h(a)==(r:=1;F(a,r:=r*e.(a.i));j:=[];F(v,while r rem z.i=0 repeat(r:=r quo t.i;j:=cons(v.i,j)));j:=sort j;k:=0;F(j,k:=k*10+j.i);k)

取消评论的结果

s:="GXUWRFVIONETHS" -- tutte le lettere di ONE..NINE in ordine di importanza 
e:EqTable(Character,Integer):=table()
v:=[8,6,4,2,3,5,7,9,1]              -- numeri da controllare in quell'ordine di apparizione di v
z:=[k for k in 1..46|prime?(k)]     -- 14 numeri primi da associare a s
F(x,y)==>for i in 1..#x repeat y 
F(z,e.(s.i):=z.i)                   -- riempie la tavola associando numeri primi alle lettere "GXUW..."
t:=[1787026,2451,16445,5957,16036207,130169,20372239,495349,20677]  -- prodotto di numeri primi 1787026 dovrebbe essere HEIGHT
h(a)==
     r:=1 ;F(a,r:=r*e.(a.i))        -- calcola il numero associato alla stringa a
     j:=[];F(v,while r rem z.i=0 repeat(r:=r quo t.i;j:=cons(v.i,j)));j:=sort j  -- leva il nome dei numeri che man mano trova, aggiunge a j
     k:=0 ;F(j,k:=k*10+j.i)         -- costruisce il numero decimale k, da j vettore ordinato
     k                              -- ritorna tale numero k
------------------------------------------------------
(8) -> h("IHNEVGENNEISTE")
   (8)  789
                                                    Type: PositiveInteger