Richtlinien

Szenario

John hat eine wichtige Nummer und er möchte nicht, dass andere sie sehen.

Er beschloss, die Nummer mit den folgenden Schritten zu verschlüsseln:

Seine Nummer ist immer eine nicht abnehmende Folge (d. H. "1123")

Er wandelte jede Ziffer in englische Wörter um. (dh. "123" -> "ONETWOTHREE")

Ordnen Sie die Buchstaben dann nach dem Zufallsprinzip neu an. (dh. "ONETWOTHREE" -> "ENOWTOHEETR")

John hatte das Gefühl, dass seine Nummer in Sicherheit war. In der Tat kann eine solche Verschlüsselung leicht entschlüsselt werden :(

Aufgabe

Angesichts der verschlüsselten Zeichenfolge s besteht Ihre Aufgabe darin, sie zu entschlüsseln und die ursprüngliche Nummer zurückzugeben.

Regeln

• Dies ist Codegolf, daher gewinnt die kürzeste Antwort in Bytes
• Sie können davon ausgehen, dass die Eingabezeichenfolge immer gültig ist
• Die Eingabezeichenfolge enthält nur Großbuchstaben
• Die ursprünglichen Nummern sind immer in aufsteigender Reihenfolge angeordnet
• Sie können die Zahl im String- oder Integer-Format zurückgeben
• Die Buchstaben werden nur zwischen einem Wort und nicht zwischen der gesamten Zeichenfolge gemischt.
• Die Zahlen sind nur von 1 bis einschließlich 9 ( ONEbis NINE)

Möglicher nicht verschlüsselter String

Hier ist eine Liste der Zeichenfolgen, nachdem sie aus den Zahlen in Zeichenfolgen konvertiert wurden:

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

Beispiele

"NEO" -> 1

"ENOWOT" -> 12

"EONOTWHTERE" -> 123

"SNVEEGHEITNEIN" -> 789

"ENOOWTEERHTRUOFEVIFXISNEVESTHGIEENIN" -> 123456789

"NOEWOTTOWHEERT" -> 1223

Jelly ,  38  37 Bytes

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

Ein monadischer Link, der eine Liste von Zeichen (die Zeichenfolge) aufnimmt und eine Ganzzahl zurückgibt.

Probieren Sie es online!

Verwendet eine ganz andere Methode als Pietu1998's Jelly-Antwort , hat aber die gleiche Byteanzahl ( ich dachte wirklich, es könnte sein, dass es weniger wird)!

Verlässt sich nicht auf die Monotonie der ursprünglichen Nummer (so HTREEWTONOEwürde zum Beispiel eine Eingabe von funktionieren).

Wie?

Beachten Sie zunächst, dass die Wörter selbst (und daher alle Anagramme davon) alle in Wörter der Länge 4 geändert werden können, indem Sie Rs, Gs und Ss entfernen und Os durch zwei Zeichen (sagen Sie "12") und Xs durch drei Zeichen ersetzen ( sagen Sie "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

Wir können dann das Produkt der Ordnungszahlen dieser Zeichen den Zahlen 1 bis 9 unter Verwendung von Modulo-Arithmetik zuordnen, abhängig von unserer Wahl (die "12345"), und diese dann in einer neu geordneten Liste der Ziffern nachschlagen. Der Code wird zuerst in Zeichen umgewandelt und ersetzt dann die Ordnungszahlen. Es ist jedoch auch möglich, 37 Byte mit Zeichen zu versehen, z. B. "DIAAE" ( probieren Sie es aus ).

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

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 Bytes: Nach all dem Golfen habe ich vergessen, eine Single-Use-Variable einzutragen. Gehirnfurz.
-2 Bytes: Einzug mit zwei Abständen → Einzug mit einem Tabulator (danke an Coty Johnathan Saxman); Beachten Sie, dass dies in der Antwort nicht richtig angezeigt wird.

Ungolfed (kompatibel mit 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

Magic Number Finder:

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

Erläuterung:

Ich hatte das Gefühl, ich könnte die ASCII-Bits zusammenschlagen und sie irgendwie zusammenfassen, um festzustellen, wann ich ein vollständiges Wort hatte. Ursprünglich habe ich versucht, mit 3**ord(letter)den erwarteten Ergebnissen zu experimentieren und sie zu vergleichen, aber es gab einige sehr große Zahlen. Ich denke, es wäre angebracht, einige Parameter ein wenig zu brachialisieren, nämlich den Modul (um sicherzustellen, dass die Zahlen klein sind) und einen Multiplikator, um die Zahlen im Bereich des Moduls unterschiedlich zu verteilen.

Am Ende habe ich die Multiplikatorvariable in eine Variable geändert, die sich auf die Leistung selbst auswirkt, weil es mir (nach Versuch und Irrtum) irgendwie gelungen ist, eine etwas kürzere Antwort zu geben.

Und oben sehen Sie die Ergebnisse dieses brachialen und ein wenig manuellen Golfspiels.

Der Grund für die 3**xursprüngliche Wahl war, dass ich wusste, dass Sie jede Zahl dort vertreten können. Die am häufigsten wiederholten Ziffern einer Zahl sind zwei (thrEE, sEvEn, NiNe usw.), daher habe ich beschlossen, jede Eingabe als Zahl zur Basis 3 zu betrachten. Auf diese Weise könnte ich sie (mental) als so etwas wie 10100000000010020000(drei; eine 1 im tSteckplatz, eine 1 im rSteckplatz, eine 1 im hSteckplatz und eine 2 im eSteckplatz) darstellen. Auf diese Weise erhält jede Zahl eine eindeutige Darstellung, die durch Iteration der Zeichenfolge und Summieren einiger Zahlen leicht zusammengesetzt werden kann, und sie endet unabhängig von der tatsächlichen Reihenfolge der Buchstaben. Natürlich stellte sich dies nicht als die ideale Lösung heraus, aber die aktuelle Lösung ist immer noch unter Berücksichtigung dieser Idee geschrieben.

Python 2 , 131 127 Bytes

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

Probieren Sie es online!

Basiert auf einer korrigierten Version der JavaScript Draco18s- Lösung.

PHP , 164 Bytes

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

Probieren Sie es online!

PHP , 179 Bytes

basierend auf dem vorherigen Ansatz überprüfen Sie zuerst die geraden und dann die ungeraden Zahlen in aufsteigender Reihenfolge

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

Probieren Sie es online!

PHP , 201 Bytes

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

Probieren Sie es online!

Javascript (ES6), 288 150 144 Bytes

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

Länger als die beiden anderen JS-Einträge, aber ich dachte, ich würde einen interessanten Ansatz fallen lassen, der für jemanden in einer anderen Sprache funktionieren könnte.

Grundsätzlich können wir folgendes feststellen:

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

Jedes Vorkommen dieser Buchstaben impliziert, dass diese Ziffer in der ursprünglichen Nummer vorhanden ist. Von hier können wir den Rest der Ziffern ableiten:

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

Einschließlich der zwei komplizierten Fälle:

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

Beides 1und 9Area Hard vergleichsweise. Bei ONE wird Ein einigen Wörtern SEVENmehrmals angezeigt ( hat zwei), ebenso wie bei N( NINE). Wir bleiben also bei der Überprüfung, Owelche an zwei anderen Stellen auftritt. Glücklicherweise sind beide einfach.

Für NEUN ist neun schwer, egal wie Sie es schneiden.

So kommen wir zu dieser Karte:

[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 ist in der Lage, siX, eiGht und Five (mit 5 Rückverweisen für) mit den variablen Zuweisungen rückzuverweisen, wodurch Bytes gespart werden. Dank Neil nutzt es einige Funktionen von JS, mit denen ich nicht vertraut bin (zum Beispiel die Back-Ticks für das Halbieren (') und kommt der Idee, die ich vor dem Versuch, sie zu codieren, auf Papier gezeichnet hatte, tatsächlich viel näher (ich hatte links 9 als „was übrig bleibt“, darüber nachzudenken , wie „wenn ich sehe , ein Xich es entfernen und ein Sund Iaus dem String, dann ...“ , so dass nach den vier einfachen Fällen die nächsten 3 würde sich einfach).

Der Grund, warum dieser Eintrag interessant ist, ist, dass er eine beliebige gemischte Zeichenfolge als Eingabe verarbeiten kann. Das heißt, anstatt die einzelnen Wörter zu mischen, können wir die gesamte Zeichenfolge mischen, was ich dachte, dass John ursprünglich tat:

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 Bytes

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

Eingang

"VENESGTHIEENNI"

Ausgabe

789

C # 218 Bytes

Kurzfassung:

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

Erweiterte Version:

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

Versuchen Sie es ONLINE!

Als mein erster Eintrag bin ich mir nicht sicher über die Regeln ... Ich zähle nur die Größe der Klasse, die zum Entschlüsseln verwendet wird, nicht den Code, der sie testet, oder?

Bearbeiten

Und zum Spaß - hier ist, was ich angefangen habe, nicht die vollständigen Regeln zu lesen: S - Sehen Sie es bei IdeOne . Es wird entschlüsselt, auch wenn Zeichen aus einer Ziffer an eine beliebige Stelle in der Zeichenfolge verschlüsselt werden können.

Bearbeiten 2

Verkürzt nach Tipps von TheLethalCoder. Vielen Dank!

Bearbeiten 3

Und jetzt rasierte sich Titus noch ein paar Bytes. Vielen Dank!

JavaScript (ES6), 142 139 Bytes

3 Bytes gespart dank Neil .

Derzeit nicht ausgenutzt Nummern sind immer in aufsteigender Reihenfolge angeordnet

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

Jelly , 38 Bytes

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

Probieren Sie es online!

Erläuterung

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)

Beispielcode-Snippet:

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

Netzhaut , 160 Bytes

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

Probieren Sie es online! Lose basierend auf @ TessellatingHecklers PowerShell-Antwort.

Netzhaut , 88 Bytes

[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

Probieren Sie es online!

Erläuterung

• Löschen Sie zunächst eine Reihe unnötiger Zeichen, die für die Unterscheidbarkeit nicht benötigt werden
• Wählen Sie die Einsen von der Vorderseite aus (dies lässt uns den Rest der Os unmittelbar danach fallen und räumt einige Ns auf, bevor wir zum 5, 7, 9 Chaos kommen).
• 2, 3, 4, 6 und 8 sind jetzt trivial
• 9s sind eine doppelte NN, also schnappen Sie sich diese am Ende, bevor wir uns mit 5 und 7 befassen
• Ersetzen Sie 7s von rechts (damit wir den VNV nicht auf 75 anstatt auf 57 reduzieren)
• 5s sind die verbleibenden Vs

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

Probieren Sie es online!

Ungolfed aber kein funktionierender Code:

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

Beispiel: (?<3>[THRE]{5})Stimmt mit der Zeichenklasse überein THRE, sodass sie in der angegebenen Reihenfolge übereinstimmen kann. Jedes dieser Zeichen muss fünfmal nebeneinander übereinstimmen. Die Erfassungsgruppe erhält den Namen '3', um Namen mit Zahlen zuzuordnen.

Rudimentäre Komprimierung durch Austauschen des Wiederholungstextes })|(?<gegen a z.

C ++, 296 , 288 Bytes

Kurzfassung:

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

Vollversion:

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

Versuchen Sie es ONLINE!

Edit:
1) 200-> 296 Bytes, um den Namespace und die Definition von N in die Zählung aufzunehmen, wie von orlp vorgeschlagen. 2) 296-> 288, um dank Zacharý ein Makro zu verwenden

Ruby, 138 114 110 Bytes

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

Die Byteanzahl umfasst 1 Byte für die -pOption.

Was?

Dies:

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

ist ein Regex-Literal, das durch String-Interpolation Folgendes ergibt:

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

Wenn wir das zuordnen, regexist der Rest des Codes einigermaßen leicht zu verstehen: Jede Übereinstimmung in der Eingabe wird durch die Nummer der Erfassungsgruppe ersetzt, die aus der magischen Variablen extrahiert wurde, $~die die aktuellen Übereinstimmungsdaten enthält:

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

Probieren Sie es online!

Java 8, 198 256 Bytes

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 Bytes .. aufgrund von Regex der Vorgängerversion, die nicht richtig funktionierte (es passte auch zu "EEE"; "EEN"; etc.)

Erläuterung:

Probieren Sie es hier aus.

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

Probieren Sie es online!

Ich habe mir erlaubt, Kevin Cruyssens TIO-Vorlage wiederzuverwenden . Hoffe es macht dir nichts aus;)

05AB1E , 36 31 Bytes

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

Probieren Sie es online!

View it lief mit Debug: 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 Bytes

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

Probieren Sie es online!

Python 3 , 238 236 Bytes

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*

Probieren Sie es online!

Brute-Force-Lösung, nutzt die Gleichmäßigkeit der Ziffern nicht aus.

Vielen Dank an @Mr. Xcoder zum Speichern von 2 Bytes!

PHP, 141 Bytes

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

ältere Version, 151 Bytes :

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

Durchläuft die Ziffern von 1 bis 9, zählt die einzelnen Zeichen im Wort und subtrahiert die Anzahl der nicht eindeutigen Zeichen.
Obwohl unterwegs gedruckt wird, müssen die Ziffern gespeichert werden, damit der 9Fall funktioniert.

Laufen Sie als Pipe mit -nRoder probieren Sie es online aus .

Es würden 4 weitere Bytes eingespart, um die Ziffernanzahl $a[$i]anstelle von $a[$i+48]ASCII 1und 7(in Anführungszeichen) anstelle der Ziffernzeichen selbst zu speichern .

Nervenzusammenbruch

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

ONEist nicht das einzige Wort mit einem O, daher muss es die Zählungen für W(nur in TWO) und U(nur in FOUR) usw. subtrahieren .
NINEist etwas Besonderes, weil es keine Möglichkeit gibt, nur zu subtrahieren, wenn ich die Buchstaben verwendet habe (das würde I-X-G-F+Uoder erfordern N-O-S+W+U+X), also verwende ich stattdessen die Ziffernanzahl.

PHP, 160 Bytes

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

setzt alle Großbuchstaben voraus; Zeichen können überall verwürfelt sein.
Laufen Sie als Pipe mit -nRoder probieren Sie es online aus .

Erläuterung

Durchläuft die Ziffernwörter und zählt dabei die Vorkommen ihrer eindeutigen Zeichen in der Eingabe und verringert die Anzahl der anderen Zeichen. "Andere Zeichen" können alle anderen Zeichen im Wort bedeuten. aber nur unter Berücksichtigung derer, die später benötigt werden, werden 19 Bytes gespart.

Transformieren der str_repeatSchleife zu einer kombinierten Schleife 5 Bytes gespeichert.

Durch die Verwendung variabler Variablen für die Stellenzahl wurden weitere 8 gespeichert.

Nervenzusammenbruch

$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