Wytyczne

Scenariusz

John ma ważną liczbę i nie chce, aby inni ją widzieli.

Postanowił zaszyfrować numer, wykonując następujące czynności:

Jego liczba jest zawsze ciągiem malejącym (tj. "1123")

Przekształcił każdą cyfrę w angielskie słowa. (tj. "123" -> "ONETWOTHREE")

A następnie, losowo ułóż litery. (tj. "ONETWOTHREE" -> "ENOWTOHEETR")

John czuł, że jego liczba jest w tym bezpieczna. W rzeczywistości takie szyfrowanie można łatwo odszyfrować :(

Zadanie

Biorąc pod uwagę zaszyfrowane ciągi, Twoim zadaniem jest odszyfrowanie go i zwrócenie oryginalnego numeru.

Zasady

• To jest kod golfowy, więc wygrywa najkrótsza odpowiedź w bajtach
• Możesz założyć, że ciąg wejściowy jest zawsze poprawny
• Łańcuch wejściowy zawiera tylko wielkie litery
• Oryginalne numery są zawsze ułożone w porządku rosnącym
• Możesz zwrócić liczbę w formacie ciągu lub liczby całkowitej
• Litery będą tasowane tylko między jednym słowem, a nie między całym ciągiem.
• Liczby będą tylko od 1 do 9 włącznie ( ONEdo NINE)

Możliwy nieszyfrowany ciąg

Oto lista ciągów zaraz po ich przekonwertowaniu na ciągi z liczb:

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

Przykłady

"NEO" -> 1

"ENOWOT" -> 12

"EONOTWHTERE" -> 123

"SNVEEGHEITNEIN" -> 789

"ENOOWTEERHTRUOFEVIFXISNEVESTHGIEENIN" -> 123456789

"NOEWOTTOWHEERT" -> 1223

Galaretka ,  38  37 bajtów

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

Monadyczny link pobierający listę znaków (ciąg znaków) i zwracający liczbę całkowitą.

Wypróbuj online!

Używa bardzo różne metody do Pietu1998 za Jelly odpowiedź , ale ma taką samą liczbę bajtów ( I rzeczywiście, że może to nie skończyć jako mniej)!

Nie opiera się na monotoniczności pierwotnego numeru (więc wejście HTREEWTONOEmogłoby działać na przykład).

W jaki sposób?

Najpierw zauważ, że same słowa (a zatem i wszelkie ich anagramy) można zmienić na te o długości 4, usuwając dowolne R, G i S i zastępując dowolne OS dwoma znakami (powiedz „12”) i dowolnymi X trzema znakami ( powiedz „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

Następnie możemy odwzorować iloczyn porządkowy tych znaków na liczby od 1 do 9, stosując arytmetykę modulo, w zależności od naszego wyboru („12345”), a następnie wyszukać je na uporządkowanej liście cyfr. Kod faktycznie najpierw rzutuje na znaki, a następnie zastępuje liczby porządkowe, ale jest również możliwe w 37 bajtach ze znakami, np. „DIAAE” ( spróbuj ).

ḟ“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 bajtów

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 bajty: po całym tym golfie zapomniałem wprowadzić zmienną jednorazowego użytku. Pierdnięcie mózgu.
-2 bajty: Wcięcie w podwójnych odstępach → wcięcie w pojedynczej tabulacji (dzięki Coty Johnathan Saxman); zwróć uwagę, że nie wyświetla się to poprawnie w odpowiedzi.

Ungolfed (kompatybilny z 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

Wyszukiwarka liczb magicznych:

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

Wyjaśnienie:

Miałem wrażenie, że mogę zmiażdżyć bity ASCII i podsumować je w jakiś sposób, aby ustalić, kiedy mam pełne słowo. Początkowo próbowałem zadzierać z 3**ord(letter)oczekiwanymi wynikami i porównywać je, ale przyniosło to bardzo duże liczby. Wydawało mi się, że byłoby właściwe, aby nieco brutalnie wymusić niektóre parametry, a mianowicie moduł (aby upewnić się, że liczby są małe) i mnożnik, aby rozproszyć liczby w różny sposób w całym zakresie modułu.

Ostatecznie zmieniłem zmienną mnożnika na zmienną wpływającą na samą moc, ponieważ (z prób i błędów), która w jakiś sposób dała mi nieco krótszą odpowiedź golfową.

A powyżej widać wyniki tego brutalnego forsowania i trochę ręcznego grania w golfa.

Pierwotnym powodem wyboru 3**xjest to, że wiedziałem, że możesz reprezentować każdą liczbę. Najbardziej powtarzającymi się cyframi, które miała dowolna liczba, są dwie (thrEE, sEvEn, NiNe itp.), Więc postanowiłem pomyśleć o każdym wejściu jako o liczbie 3. W ten sposób mogłem (mentalnie) przedstawić je jako coś w rodzaju 10100000000010020000(trzy; 1 w tgnieździe, 1 w rgnieździe, 1 w hgnieździe i 2 w egnieździe). Każda liczba w ten sposób otrzymuje unikalną reprezentację, którą można łatwo poskładać, iterując ciąg znaków i sumując niektóre liczby, i kończy się to niezależnie od rzeczywistej kolejności liter. Oczywiście nie okazało się to idealnym rozwiązaniem, ale obecne rozwiązanie wciąż jest napisane z myślą o tym pomyśle.

Python 2 , 131 127 bajtów

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

Wypróbuj online!

Na podstawie poprawionej wersji rozwiązania JavaScript Draco18s .

PHP , 164 bajty

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

Wypróbuj online!

PHP , 179 bajtów

w oparciu o poprzednie podejście najpierw sprawdź liczby parzyste, a następnie nieparzyste w porządku rosnącym

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

Wypróbuj online!

PHP , 201 bajtów

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

Wypróbuj online!

JavaScript (ES6), 288 150 144 bajtów

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

Dłuższy niż pozostałe dwa inne wpisy JS, ale pomyślałem, że rzuciłbym ciekawe podejście, które może zadziałać dla kogoś w innym języku.

Zasadniczo możemy ustalić, co następuje:

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

Wystąpienie tych liter oznacza, że ​​cyfra istnieje w pierwotnym numerze. Stąd możemy wywnioskować resztę cyfr:

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

W tym dwa skomplikowane przypadki:

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

Zarówno 1i 9obszar Hard stosunkowo. W JEDNYM, Epojawia się więcej niż raz w niektórych słowach ( SEVENma dwa) tak jak robi N( NINE), więc utknęliśmy w sprawdzaniu, Októre zdarzenie występuje w dwóch innych miejscach, na szczęście oba są proste.

Dla NINE dziewięć jest trudne, bez względu na to, jak je pokroisz.

W ten sposób otrzymujemy tę mapę:

[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 jest w stanie odwoływać się do siX, eiGht i Five (z 5 foUr odwołań wstecznych) za pomocą zmiennych przypisań, oszczędzając bajty. Dzięki Neilowi ​​do tego wykorzystuje kilka cech JS, z którymi jestem bardzo obcy (na przykład tyknięcia wstecz przy rozbieraniu ('na pół) i faktycznie zbliża się znacznie do pomysłu, który naszkicowałem na papierze, zanim spróbowałem go zakodować (Zostawiłem 9 jako „to, co zostało”, myśląc o tym jako „jeśli widzę, że Xmogę to usunąć i an Si Iz łańcucha, a następnie ...”, tak że po czterech prostych przypadkach kolejne 3 stałyby się prosty).

Powodem tego, że ten wpis jest interesujący jest to, że może on obsługiwać dowolny tasowany ciąg jako dane wejściowe. tzn. zamiast tasowania pojedynczych słów, możemy przetasować cały ciąg znaków, co moim zdaniem pierwotnie robił 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 bajty

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

wkład

„VENESGTHIEENNI”

wydajność

789

C #, 218 bajtów

Krótka wersja:

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

Wersja rozszerzona:

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

Wypróbuj ONLINE!

Będąc moim pierwszym wpisem nie jestem pewien co do zasad ... Liczę tylko rozmiar klasy użytej do deszyfrowania, a nie kod, który to testuje, prawda?

Edytować

A dla zabawy - oto, co zacząłem robić, nie czytając pełnych zasad: S - Zobacz to w IdeOne . Odszyfrowuje, nawet jeśli znaki z jednej cyfry można zaszyfrować w dowolnym miejscu ciągu.

Edytuj 2

Skrócono zgodnie ze wskazówkami TheLethalCoder. Dzięki!

Edytuj 3

A teraz Tytus ogolił się z jeszcze kilku bajtów. Dzięki!

JavaScript (ES6), 142 139 bajtów

Zaoszczędzono 3 bajty dzięki Neilowi .

Obecnie nie korzysta z liczb, zawsze są ułożone w porządku rosnącym

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

Galaretka , 38 bajtów

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

Wypróbuj online!

Wyjaśnienie

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 bajtów

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)

Przykładowy fragment kodu:

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

Siatkówka , 160 bajtów

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

Wypróbuj online! Luźno oparty na odpowiedzi PowerShell @ TessellatingHeckler.

Siatkówka , 88 bajtów

[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

Wypróbuj online!

Wyjaśnienie

• Najpierw upuść kilka niepotrzebnych znaków, które nie są potrzebne do odróżnienia
• Wybierz 1 z przodu (to pozwala nam upuścić resztę Os bezpośrednio po i oczyścić niektóre N, zanim dojdziemy do bałaganu 5, 7, 9)
• 2, 3, 4, 6 i 8 są teraz banalne
• 9 to podwójne NN, więc złap je z końca, zanim zajmiemy się 5 i 7
• Zamień 7 z prawej (więc nie zmniejszamy VNV do 75 zamiast 57)
• 5s to pozostałe Vs

PowerShell , 182 bajty

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

Wypróbuj online!

Nieskluczony, ale niedziałający kod:

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

np. (?<3>[THRE]{5})dopasowuje klasę znaków THRE, aby mogła dopasować je w kolejności i musi dopasować dowolną z tych postaci pięć razy obok siebie, a grupa przechwytywania nosi nazwę „3”, aby odwzorować nazwy za pomocą liczb.

Prymitywna kompresja poprzez zamianę powtarzającego się tekstu })|(?<na a z.

C ++, 296 , 288 bajtów

Krótka wersja:

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

Pełna wersja:

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

Wypróbuj ONLINE!

Edycja:
1) 200-> 296 bajtów, w celu włączenia przestrzeni nazw i definicji N do liczby, jak sugeruje orlp 2) 296-> 288, za użycie makra, dzięki Zacharý

Rubin, 138 114 110 bajtów

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

Liczba bajtów obejmuje 1 bajt dla -popcji.

Co?

To:

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

jest literałem wyrażenia regularnego, które poprzez interpolację łańcuchów zwraca:

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

Jeśli przypiszemy to do regex, resztę kodu można nieco uchwycić: Każde dopasowanie na wejściu jest zastępowane numerem grupy przechwytywania, wyodrębnionej z magicznej zmiennej $~zawierającej bieżące dane dopasowania:

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

Wypróbuj online!

Java 8, 198 256 bajtów

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 bajtów .. z powodu regexu poprzedniej wersji, która nie działała poprawnie (pasowało również do „EEE”; „EEN”; itp.)

Wyjaśnienie:

Wypróbuj tutaj.

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 bajtów

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

Wypróbuj online!

Pozwoliłem sobie ponownie wykorzystać szablon TIO Kevina Cruyssena . Mam nadzieję, że nie masz nic przeciwko;)

05AB1E , 36 31 bajtów

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

Wypróbuj online!

Zobacz, jak działa z debugowaniem: TIO z debugowaniem

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

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

Wypróbuj online!

Python 3 , 238 236 bajtów

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*

Wypróbuj online!

Rozwiązanie brute-force, nie wykorzystuje niemniejszalności cyfr.

Dzięki @Mr. Xcoder do zapisywania 2 bajtów!

PHP, 141 bajtów

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

starsza wersja, 151 bajtów :

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

zapętla cyfry od 1 do 9, licząc niepowtarzalne znaki w słowie i odejmując liczbę znaków nie unikatowych, drukując cyfrę w drodze.
Mimo że drukowanie odbywa się w drodze, liczba cyfr musi być zapisana, aby 9obudowa mogła działać.

Uruchom jako potok z -nRlub spróbuj online .

Zaoszczędziłoby to 4 dodatkowe bajty do przechowywania liczby cyfr $a[$i]zamiast $a[$i+48]i używania ASCII 1i 7(w cudzysłowach) zamiast samych znaków cyfr.

awaria

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

ONEnie jest jedynym słowem z O, więc musi odjąć liczbę dla W(tylko pojawia się w TWO) i U(tylko pojawia się w FOUR) i tak dalej.
NINEjest wyjątkowy, ponieważ nie ma sposobu, aby po prostu odjąć, jeśli użyłem liter (wymagałoby to I-X-G-F+Ulub N-O-S+W+U+X), więc zamiast tego używam liczb.

PHP, 160 bajtów

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

zakłada wszystkie duże litery; postacie mogą być wszędzie zakodowane.
Uruchom jako potok z -nRlub spróbuj online .

wyjaśnienie

zapętla słowa cyfrowe, licząc wystąpienia ich unikalnych znaków na wejściu oraz w procesie zmniejszając liczbę innych znaków. „Inne znaki” mogą oznaczać wszystkie inne znaki w słowie; ale tylko biorąc pod uwagę te, które będą potrzebne później zaoszczędzono 19 bajtów.

Przekształcenie str_repeatpętli w pętlę łączoną pozwoliło zaoszczędzić 5 bajtów.

A użycie zmiennych zmiennych do liczby cyfr pozwoliło zaoszczędzić kolejne 8.

awaria

$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