Die ursprüngliche Nummer

36

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

Amorris
quelle
5
In allen Testfällen werden nur die Buchstaben innerhalb eines Wortes gemischt, nicht die Buchstaben zwischen den Wörtern. Wird das immer so sein?
Xnor
1
@xnor Das wird immer so sein. Ich habe die Frage bearbeitet.
Amorris
1
dann müssen Sie dies ändern ".... (dh" ONETWOTHREE "->" TTONWOHREEE ")"
J42161217
2
@ TessellatingHeckler: Eine nicht streng aufsteigende Reihenfolge ist, wenn die nächste Nummer dieselbe sein kann wie die vorherige ex. 1-1-1-2-2-3 (nicht streng steigend) im Gegensatz zu 1-2-3-4-5 (streng steigend)
koita_pisw_sou
1
Technisch gesehen ist dies eine Kodierung, keine Verschlüsselung, da es keinen Schlüssel gibt.
Patrick Roberts

Antworten:

5

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
Jonathan Allan
quelle
Ihre Antwort ist buchstäblich die einzige Antwort auf dieser Seite , die einen korrekten Wert zurückgibt für: NINEONENIENOENNNIENOENNEINEONEINEONNENIENOINNEINENINNEINENIENNIENNNNIENNEININENIENNENINEINENINENNIEINNEINNENNIENIN.
Magic Octopus Urn
+ Unendlichkeitspunkte.
Magic Octopus Urn
Vielen Dank! (Das hat mich geworfen , weil der Codeblock im Kommentar keine Leerzeichen enthält , aber (puh) es funktioniert )
Jonathan Allan
Es ist sowieso keine gültige Eingabe;).
Magic Octopus Urn
Oh wow, ich wusste nicht, dass ein Kopfgeld kommen würde - danke! Ja, es war nicht Teil der angeforderten Spezifikation. Ich habe nur eine Methode entwickelt, die mit ungeordneten Eingaben funktioniert.
Jonathan Allan
10

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.

Score_Under
quelle
Was ist Py3K? ...
CalculatorFeline
Entschuldigung, bearbeitet (es ist der frühere Name von Python 3)
Score_Under
1
Es ist billig, aber Sie können 2 Bytes sparen (da dies Python 2 ist), indem Sie Ihre zweite Einrückungsstufe (zwei Leerzeichen) für einen einzelnen Tabulator angeben. [ tio.run/##NU7NCoJAGDy7T/… Online ausprobieren !]
Coty Johnathan Saxman
Außerdem können Sie möglicherweise 6 Bytes mit wörtlichen speichern \x83, \x8eund \x92in der Zeichenkette.
CalculatorFeline
@CalculatorFeline Leider hat mein Dolmetscher nicht so: 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. Es funktioniert, wenn ich den codingKommentar dort oben platziere, aber das bringt 15 zusätzliche Bytes.
Score_Under
6

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.

mdahmoune
quelle
Was für eine interessante Verwendung von vars!
xnor
@xnor es war ovs wie ich das für andere golfs gelernt :)))
mdahmoune
Sehr schlau. Habe eine +1 für die Anpassung meiner Antwort (so fehlerhaft wie es ursprünglich war).
Draco18s
5

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!

Jörg Hülsermann
quelle
schlägt fehl fürENOOWTWTOWOT
Titus
@Titus ist jetzt behoben. Ich habe die Frage falsch verstanden
Jörg Hülsermann
Ja, die Beispiele sind etwas irreführend. Wow das hat gekostet! Würdest du das aufschlüsseln ?!
Titus
@Titus Ich glaube, ich habe die Grenze erreicht, um einen anderen Weg als Ihren Ansatz zu finden
Jörg Hülsermann
1
$i++<9und $ianstelle von $i<10und ++$i(-1 Byte); _405162738[$i]anstelle von $i%2?$i/2+4:$i/2-1(-4 Bytes) ( $i/2+~($i%2*-5)würde auch funktionieren, aber das ist ein Byte länger.)
Titus
5

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

Draco18s
quelle
1
Großartig, aber es gibt ein Problem beim Zählen von 9 ... Ich denke, es könnte ixg-f + u sein
mdahmoune
@ mdahmoune Shoot, du hast recht. Ich habe das durcheinander gebracht. : <
Draco18s
Sparen Sie 4 Bytes mit s.split(t).length-1, 2 Bytes mit s.repeat(n>0&&n)(warum ist n ohnehin kleiner als Null? Spart 7 Bytes). Sparen Sie eine Menge Bytes, indem Sie gim Bereich von deklarieren, sdamit Sie es nicht ständig weitergeben müssen, und noch besser, Sie können es zu einer mit Tags versehenen Vorlage machen, die insgesamt 55 Bytes spart (vor 9 Korrekturen). Speichern Sie mehr Bytes durch wiederholte Werte in Provisorien zu speichern, und ich rasierte ein paar mehr dran mit 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 Ich bin mir nicht sicher, warum N jemals unter Null gelandet ist, aber beim Testen auf DREI. Ich bekam immer wieder einen Fehler und stellte fest, dass er gebraucht wurde, aber ich bin mir immer noch nicht sicher. Die Vorlagenbibliothekskarte, die Sie dort haben, ist Javascript, das ich nicht einmal lesen kann. : D
Draco18s
@Neil Ah, richtig, der Grund für die Überprüfung n> 0: Wenn es ist ein zwei , aber nicht drei. R = 0, W = 1. 0-1 = -1. Ich hatte vor einer Stunde Probleme damit, das herauszufinden, ich wusste, dass es mit dem 3-Check zusammenhängt, aber ich hatte den Teufel der Zeit, es herauszufinden (Mangel an Kaffee).
Draco18s
4

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

J42161217
quelle
Könnten Sie ein zusätzliches Byte mit c@#[[i]]anstelle von speichern c[#[[i]]]? Möglicherweise können Sie ein anderes Byte speichern, indem Sie die Infix-Syntax ~auf dem verwenden Table.
Numbermaniac
4

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!

SamWhan
quelle
2
Hallo und willkommen bei PPCG! Sie müssen nur die Methode einfügen, die Sie daraus entfernen public statickönnen. Sie können zu einer anonymen Methode wie konvertieren s=>{<do stuff>return"";}. Sie können varein paar Mal verwenden, wenn Sie Variablen zusammen deklarieren, werden Bytes gespart, d int i=1,j;. H. Das Erstellen eines Arrays aus einer Zeichenfolge und das Aufteilen darauf ist normalerweise kürzer (obwohl ich dies in diesem Fall nicht überprüft habe) "ONE|TWO".Split('|'). Sie können <0anstelle von==-1
TheLethalCoder
Weitere Tipps finden Sie unter Tipps zum Code-Golfen in C # .
TheLethalCoder
@TheLethalCoder Tolle Tipps, danke!
SamWhan
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 "";}
Überhaupt
In der Regel ist es einfacher, TIO für Ihre TIOs zu verwenden!
TheLethalCoder
3

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

Craig Ayre
quelle
warte was?? "axbxc".split`x`.join``. Wie heißt das? Ich kann auf Google nichts finden.
Qwerty
@Qwerty - Es handelt sich um mit Tags versehene Vorlagenliterale , eine ES6-Funktion, mit der ich ein paar Bytes einsparen kann, indem ich im Fall von splitund keine Parens benötige.join
Craig Ayre
Du hast geantwortet. Ich kenne mit Tags versehene Vorlagenliterale, aber ich habe nicht bemerkt, dass Sie sie auch für diese Funktionen verwenden können. Vielen Dank.
Qwerty
Sie sind ein bisschen anders, Sie haben Template-Literale (zB x=`foo${5+5}bar`), sie sind markiert, wenn Sie eine Funktion aufrufen, die sie ohne Parens verwendet: foo`foo${5+5}bar`das ist das Gleiche wiefoo(['foo','bar'], 10)
Craig Ayre
1
f(s.slice(y))ist immer eine Zeichenfolge, daher brauchen Sie die ''+vorher nicht.
Neil
2

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.
PurkkaKoodari
quelle
Es liegt ein Problem mit Ihrem Code vor. Versuchen Sie, die Zeichenfolge hinein "EIGHTNINE"zu geben :)
Amorris
@Amorris für 0 Bytes festgelegt.
PurkkaKoodari
Ich denke, es funktioniert nicht für "VENESGTHIEENNI"
J42161217
Ich bin zweiter @Jenny_mathy
Amorris
@Jenny_mathy Das Programm ist sehr ineffizient und hat zu wenig Zeit und Speicher für lange Eingaben (ich weiß, es ist wirklich schlecht). Sie können das 3mit ersetzen 2.2, um eine kleinere Obergrenze zu verwenden, mit der Sie problemlos 789 berechnen können, ohne das Arbeitsprinzip zu ändern. 2Wäre nett, würde aber bei bestimmten Eingaben mit vielen Sechsern kaum scheitern.
PurkkaKoodari
2

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

Herman L
quelle
2

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.

Neil
quelle
2

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
Kytheron
quelle
Wenn Sie dem Header% (G` hinzufügen, können Sie den Originalcode verwenden, und jede Zeile der Eingabe wird separat ausgewertet: TIO
PunPun1000
Vielen Dank @ PunPun1000. Ich dachte, es muss einen Weg geben, aber ich gab auf, nachdem ich ihn nicht schnell gefunden hatte.
Kytheron
1

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.

TessellatingHeckler
quelle
1

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

koita_pisw_sou
quelle
Sie müssen die Definition von Nund using namespace std;in Ihre Byteanzahl aufnehmen.
Orlp
Ich sollte präziser sein und es nicht nur in Ihre Byteanzahl, sondern auch in Ihre Antwort einbeziehen. Ihre Antwort muss ausgeführt werden können, indem Sie Qdirekt danach ohne weitere Zusätze anrufen .
Orlp
Ich habe es überarbeitet, um alles aufzunehmen. Für die Definition von N war ich mir nicht sicher, aber für den Namespace schließe ich ihn normalerweise nicht ein (behandle ihn als Bibliotheksmaterial). Im aktuellen Code ist es jedoch entscheidend, dass die Zeichenfolge funktioniert
koita_pisw_sou
1
Können Sie ein Makro definieren, um ein paar Bytes zu sparen? repl.it/JY7k
Zacharý
1

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!

daniero
quelle
1

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
Kevin Cruijssen
quelle
1
Erf ... falsches Ergebnis für "ENOOWTEERHTRUOFEVIFXISNEVESTHGIEENIN":(
Olivier Grégoire
Ja, das ist das einzige, was mich daran gehindert hat, dies zu +1 zu machen! Meine Lösung war 240 Bytes ... bevor du mich geschlagen hast.
Olivier Grégoire
@ OlivierGrégoire Zögern Sie nicht, Ihre 240-Byte-Lösung zu veröffentlichen, da ich keine Lösung finden kann. Der Nachteil [ONE]{3}ist, dass sie auch EENam Ende dieses Testfalls mit Teilen von ACHT und NEUN übereinstimmt. Und ich bezweifle, dass es eine gibt ein regulärer Ausdruck all diese übereinstimmen: ENO|EON|NEO|NOE|OEN|ONEohne auch passend EEE;EEN;EEO;...für alle Zahlen , die kürzer als 40 Byte ist .. Vielleicht kann ich mit so etwas tun substringjetzt und kehren sie die Zahlen überprüft, aber ich weiß nicht wirklich die Zeit haben , um es herauszufinden ..
Kevin Cruijssen
@ OlivierGrégoire Wenn Sie noch eine 240-Byte-Antwort haben, können Sie diese gerne posten.
Bin
1
Nun, es sieht so aus, als hätte ich bei der Wiederholung dieser Herausforderung einen noch kürzeren Weg gefunden: p
Olivier Grégoire
1

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

Olivier Grégoire
quelle
Ah, vergiss meinen vorherigen Kommentar. Du erstellst die Regex, anstatt eine Schleife über die Regex zu führen. Trotzdem war ich mit meiner ersten Antwort fast fertig, wenn ich nur die verwendet hätte s.substring. Das Schlimmste ist, dass ich s.substringin meiner aktuellen Antwort verwende, lol .. Ah gut, +1 von mir.
Ich bin
1

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.
Magische Kraken-Urne
quelle
Ich habe nur vorgeschlagen, dass Sie die grüne Markierung eher als ich hatten, und ich bemerkte einen Fehler: FURONESEVgibt FUR1SEV:(
Jonathan Allan
1

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!

Xcali
quelle
Nett! Ein paar Tricks , die helfen: map{...}oft ersetzt werden map...,, lengthund y///csind in der Regel austauschbar zu (nicht immer kleiner , wenn sie nicht arbeiten , $_obwohl!), Statt das while, ++$,x s/^$i//kürzer ist , und wenn Sie ändern , -num -pSie zu `$ \` stattdessen kann anhängen zu nennen print! Probieren Sie es online!
Dom Hastings
Außerdem hoffe ich, dass es Ihnen nichts ausmacht, wenn ich Ratschläge veröffentliche, wenn Sie es vorziehen, werde ich davon Abstand nehmen. :)
Dom Hastings
0

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!

Chase Vogeli
quelle
Sie müssen def f(s):in Ihre
Byteanzahl aufnehmen
Sie können auch while len(s)>0mitwhile len(s)
Mr. Xcoder
@ Mr.Xcoder danke für diese Klarstellung
Chase Vogeli
Sie können die Deklaration von ein den Funktionsheader für -1 Byte verschieben. Auch execund Listenverständnisse können Bytes beim Einrücken sparen.
CalculatorFeline
0

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
Titus
quelle