Oryginalny numer

36

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

Amorris
źródło
5
We wszystkich przypadkach testowych tasowane są tylko litery w słowie, a nie litery między słowami. Czy tak będzie zawsze?
xnor
1
@xnor Tak będzie zawsze. Zredagowałem pytanie.
Amorris,
1
następnie musisz zmienić to „.... (tj.„ ONETWOTHREE ”->„ TTONWOHREEE ”)”
J42161217,
2
@ TessellatingHeckler: Nie ściśle rosnąca sekwencja ma miejsce, gdy następny numer może być taki sam jak poprzedni. 1-1-1-2-2-3 (nie ściśle rosnące) w przeciwieństwie do 1-2-3-4-5 (ściśle rosnące)
koita_pisw_sou
1
Technicznie rzecz biorąc, jest to kodowanie, a nie szyfrowanie, ponieważ nie ma klucza.
Patrick Roberts,

Odpowiedzi:

5

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
Jonathan Allan
źródło
Twoja odpowiedź jest dosłownie jedyna odpowiedź na tej stronie, która zwraca prawidłową wartość: NINEONENIENOENNNIENOENNEINEONEINEONNENIENOINNEINENINNEINENIENNIENNNNIENNEININENIENNENINEINENINENNIEINNEINNENNIENIN.
Magic Octopus Urn
+ Punkty nieskończoności.
Magic Octopus Urn
Dzięki! ( rzuciło mnie, ponieważ w komentarzu nie ma spacji o szerokości zerowej, ale (whew) to działa )
Jonathan Allan
To i tak nie jest poprawne wejście;).
Magic Octopus Urn
Och wow, nie wiedziałem, że nadchodzi nagroda - dzięki! Tak, nie było to częścią wymaganej specyfikacji, właśnie stworzyłem metodę, która będzie działać z nieuporządkowanym wejściem.
Jonathan Allan
10

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.

Score_Under
źródło
Co to jest Py3K? ...
CalculatorFeline
Przeprosiny, zredagowane (to dawna nazwa python 3)
Score_Under
1
Jest tani, ale możesz zaoszczędzić 2 bajty (ponieważ jest to python 2), umieszczając drugi poziom wcięcia (dwie spacje) dla jednej tabulacji. [ tio.run/##NU7NCoJAGDy7T/… Wypróbuj online!]
Coty Johnathan Saxman
Ponadto, może być w stanie zaoszczędzić 6 bajtów za pomocą dosłownym \x83, \x8eoraz \x92w ciągu.
CalculatorFeline
@CalculatorFeline Niestety mój tłumacz nie robi tak: SyntaxError: Non-ASCII character '\xc2' in file <stdin> on line 3, but no encoding declared; see http://python.org/dev/peps/pep-0263/ for details. Działa, jeśli umieszczę tam codingkomentarz, ale zyskuje 15 dodatkowych bajtów.
Score_Under
6

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 .

mdahmoune
źródło
Cóż za ciekawe wykorzystanie vars!
xnor
@xnor to było, jak się nauczyłem, że dla innych golfów :)))
mdahmoune
Bardzo mądry. Mają +1 za dostosowanie mojej odpowiedzi (tak jak pierwotnie była wadliwa).
Draco18s,
5

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!

Jörg Hülsermann
źródło
kończy się niepowodzeniemENOOWTWTOWOT
Tytus
@Tytus jest teraz naprawiony. Nie zrozumiałem pytania
Jörg Hülsermann
Tak, przykłady są nieco mylące. Wow, to kosztowało! Rozbiłbyś to ?!
Tytus
@Titus Wydaje mi się, że osiągnąłem limit, aby znaleźć inny sposób na podejście
Jörg Hülsermann
1
$i++<9i $izamiast $i<10i ++$i(-1 bajt); _405162738[$i]zamiast $i%2?$i/2+4:$i/2-1(-4 bajtów) (też $i/2+~($i%2*-5)by działało, ale to jest o jeden bajt dłużej.)
Tytus
5

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

Draco18s
źródło
1
Świetnie, ale jest problem z liczeniem 9 ... Myślę, że może to być ixg-f + u
mdahmoune
@mdahmoune Strzelaj, masz rację. Zepsułem to. : <
Draco18s,
Zaoszczędź 4 bajty za pomocą s.split(t).length-1, 2 bajty za pomocą s.repeat(n>0&&n)(dlaczego w każdym razie n jest mniejsze od zera? Zapisuje 7 bajtów). Zaoszczędź kilka bajtów, deklarując gw zakresie s, abyś nie musiał ciągle go przekazywać, a jeszcze lepiej, aby był to szablon otagowany, który oszczędza w sumie 55 bajtów (przed 9 poprawkami). Zapisz się więcej bajtów, zapisując powtarzających się wartości w tymczasowych i Ogoliłem kilku bardziej wyłączyć za pomocą map: s=>[,(l=t=>s.split(t).length-1)`O`-l`W`-l`U`,w=l`W`,l`R`-w,u=l`U`,l`F`-u,x=l`X`,l`S`-x,g=l`G`,l`I`-x-g].map((n,i)=>`${i}`.repeat(n)).join`` .
Neil
@Neil Nie jestem pewien, dlaczego N kiedykolwiek skończył mniej niż zero, ale tak się stało podczas testowania na TRZY. Wciąż pojawiał się błąd i sprawdziłem, czy jest potrzebny, ale nadal nie jestem pewien. Skryptowana mapa biblioteki, którą tam masz, to javascript, którego nawet nie umiem czytać. : D
Draco18s,
@ Neil Ah, racja, powód sprawdzenia n> 0: Jeśli jest DWA, ale nie TRZY. R = 0, W = 1. 0-1 = -1. Miałem problem z odgadnięciem tego godzinę temu, wiedziałem, że ma to związek z 3-czekiem, ale miałem diabelski czas na jego wypracowanie (brak kawy).
Draco18s,
4

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

J42161217
źródło
Czy możesz zapisać dodatkowy bajt c@#[[i]]zamiast c[#[[i]]]? Możesz być w stanie zapisać kolejny bajt przy użyciu składni infix ~na Table.
numbermaniac
4

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!

SamWhan
źródło
2
Witaj w PPCG! Musisz tylko podać metodę, z której możesz ją usunąć public static. Możesz przekonwertować na anonimową metodę, taką jak s=>{<do stuff>return"";}. Możesz użyć varkilka razy, deklarowanie razem zmiennych oszczędza bajty tj int i=1,j;. Tworzenie tablicy z łańcucha i dzielenie na nią jest zwykle krótsze (chociaż w tym przypadku nie sprawdziłem), tj "ONE|TWO".Split('|'). Możesz użyć <0zamiast==-1
TheLethalCoder
Aby uzyskać więcej wskazówek, zobacz Wskazówki dotyczące gry w golfa w C # .
TheLethalCoder
@TheLethalCoder Świetne wskazówki, dzięki!
SamWhan,
W ogóle nie testowany, ale uważam, że następujący kod jest odpowiednikiem 221 bajtów:s=>{var n="ONE|TWO|THREE|FOUR|FIVE|SIX|SEVEN|EIGHT|NINE".Split('|');for(int i=0,j;++i<= 9;)for(j=0;n[i-1].IndexOf(s[j])<0;){if(++j==n[i-1].Length){var r=i+"";while(j<s.Length){j+=n[i].Length;r+=++i;}return r;}}return "";}
TheLethalCoder
Na marginesie, zwykle łatwiej jest używać TIO dla swoich TIO!
TheLethalCoder
3

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

Craig Ayre
źródło
czekaj, co?? "axbxc".split`x`.join``. Jak to się nazywa? Nie mogę znaleźć niczego w Google.
Qwerty
@Qwerty - Są to otagowane literały szablonów , funkcja ES6, której używam, aby zaoszczędzić kilka bajtów, ponieważ nie potrzebuję parens w przypadku splitijoin
Craig Ayre
Odpowiedziałeś Znam otagowane literały szablonów, ale nie zdawałem sobie sprawy, że można ich również używać w tych funkcjach. Dziękuję Ci.
Qwerty
Są trochę inne, masz literały szablonów (np. x=`foo${5+5}bar`), Są otagowane, gdy wywołujesz funkcję, używając ich bez parens: foo`foo${5+5}bar`co jest tym samym, cofoo(['foo','bar'], 10)
Craig Ayre
1
f(s.slice(y))jest zawsze ciągiem, więc nie potrzebujesz ''+go wcześniej.
Neil,
2

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.
PurkkaKoodari
źródło
Wystąpił problem z Twoim kodem. Spróbuj przekazać do niego łańcuch "EIGHTNINE":)
Amorris,
@Amorris naprawiono na 0 bajtów.
PurkkaKoodari,
Myślę, że to nie działa dla „VENESGTHIEENNI”
J42161217,
I drugi @Jenny_mathy
Amorris
@Jenny_mathy Program jest bardzo nieefektywny i brakuje mu czasu i pamięci na długie wejścia (wiem, to naprawdę źle). Można wymienić 3z 2.2korzystania mniejsza górna granica, która pozwala łatwo obliczyć 789 bez zmiany zasady pracy. 2byłoby fajnie, ale dla niektórych danych wejściowych z dużą liczbą szóstek ledwo by to nie zawiodło.
PurkkaKoodari,
2

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

Herman L.
źródło
2

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.

Neil
źródło
2

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
Kytheron
źródło
Jeśli dodasz% (G` do nagłówka, możesz użyć oryginalnego kodu, a każdy wiersz danych wejściowych zostanie oceniony osobno: TIO
PunPun1000,
Dzięki @ PunPun1000. Uznałem, że musi to być sposób, ale poddałem się, ponieważ nie znalazłem go szybko.
Kytheron
1

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.

TessellatingHeckler
źródło
1

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ý

koita_pisw_sou
źródło
Musisz dołączyć definicję Ni using namespace std;do swojej liczby bajtów.
orlp
Powinienem być bardziej szczegółowy, nie tylko uwzględniać go w liczbie bajtów, ale także w odpowiedzi. Twoja odpowiedź musi być w stanie uruchomić się, dzwoniąc Qzaraz po niej, bez żadnych innych dodatków.
orlp
Zredagowałem, aby uwzględnić to wszystko. Jeśli chodzi o definicję N, sam nie byłem pewien, ale w przypadku przestrzeni nazw zwykle jej nie uwzględniam (traktuj to jak bibliotekę). Chociaż w obecnym kodzie kluczowe jest, aby ciąg działał
koita_pisw_sou
1
Czy możesz zdefiniować makro, aby zaoszczędzić kilka bajtów? repl.it/JY7k
Zacharý
1

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!

daniero
źródło
1

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
Kevin Cruijssen
źródło
1
Erf ... zły wynik dla "ENOOWTEERHTRUOFEVIFXISNEVESTHGIEENIN":(
Olivier Grégoire,
Tak, to jedyna rzecz, która nie pozwoliła mi dać +1! Moje rozwiązanie miało 240 bajtów ... zanim mnie pobiłeś.
Olivier Grégoire,
@ OlivierGrégoire Nie krępuj się opublikować 240-bajtowego rozwiązania, ponieważ nie jestem w stanie znaleźć rozwiązania. Wadą [ONE]{3}jest to, że pasuje on również EENna końcu tego przypadku testowego do części ósmej i dziewiątej. I wątpię, czy istnieje regex pasujący do tych wszystkich: ENO|EON|NEO|NOE|OEN|ONEbez dopasowania EEE;EEN;EEO;...dla wszystkich liczb krótszych niż 40 bajtów .. Może mogę coś zrobić, używając substringi odwracając sprawdzanie liczb, ale tak naprawdę nie mam teraz czasu, aby to rozgryźć.
Kevin Cruijssen
@ OlivierGrégoire Jeśli nadal masz 240-bajtową odpowiedź, możesz ją opublikować. Właśnie spotkałem się z tym wyzwaniem i naprawiłem moją odpowiedź, tworząc nowe wyrażenie regularne dla +58 bajtów ..
Kevin Cruijssen
1
Wygląda na to, że znalazłem jeszcze krótszą drogę , powtarzając to wyzwanie: p
Olivier Grégoire,
1

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

Olivier Grégoire
źródło
Ach, nieważne mój poprzedni komentarz. Budujesz regex, zamiast zapętlić go. Mimo to byłem blisko mojej pierwszej odpowiedzi, gdybym tylko z niej skorzystał s.substring. Najgorsze jest to, że używam s.substringw mojej obecnej odpowiedzi, lol .. Ach cóż, +1 ode mnie. Cieszę się, że już prawie weekend ..
Kevin Cruijssen
1

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.
Urna Magicznej Ośmiornicy
źródło
Właśnie sugerowałem, że masz zielony znak zamiast mnie i zauważyłem błąd: FURONESEVzwraca FUR1SEV:(
Jonathan Allan
1

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!

Xcali
źródło
Miły! Kilka sztuczek, które pomogą: map{...}często może być zastąpiony map...,, lengthi y///csą zazwyczaj wymienne zbyt (nie zawsze mniejsza, gdy nie działa on $_jednak!), Zamiast while, ++$,x s/^$i//jest krótszy, a jeśli zmieni -nsię -pmożna dołączyć do `$ \` zamiast dzwonić print! Wypróbuj online!
Dom Hastings,
Mam również nadzieję, że nie masz nic przeciwko, żebym opublikował jakąś radę, jeśli wolisz, powstrzymam się. :)
Dom Hastings,
0

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!

Chase Vogeli
źródło
Musisz uwzględnić def f(s):w swojej liczbie bajtów, to nie jest funkcja anonimowa
Mr. Xcoder
Ponadto można wymienić while len(s)>0zwhile len(s)
Mr. Xcoder
@ Mr.Xcoder dziękuje za to wyjaśnienie
Chase Vogeli
Możesz przenieść deklarację edo nagłówka funkcji dla -1 bajtu. Ponadto execwyrazy listy mogą zaoszczędzić bajty przy wcięciach.
CalculatorFeline
0

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
Tytus
źródło