Hilf mir, mein Monster zu erkennen

35

Hintergrund

Das Computerspiel NetHack stammt aus dem Jahr 1987, bevor die Verwendung von Grafiken in Computerspielen weit verbreitet war. Es gibt viele Monster im Spiel und möglicherweise muss eine Menge auf den Bildschirm passen, daher werden Monster auf sehr minimale Weise gezeichnet: Ein Monster wird einfach als ASCII-Zeichen auf dem Bildschirm gezeichnet.

Es gibt nicht nur viele Monster, sondern auch viele Arten von Monstern. Es kann wichtig sein zu wissen, welches welches ist; du müsstest anders reagieren, wenn du ein Kätzchen und einen Drachen siehst. Daher wird der Großteil von ASCII zur Darstellung von Monstern verwendet. Zum Beispiel ist ein Kätzchen fund ein roter Drache D. Dies bedeutet, dass es sehr hilfreich sein kann zu wissen, wie ein bestimmtes Monster aussehen wird, da es Ihnen hilft, es zu erkennen, wenn Sie es später im Spiel antreffen. (Beachten Sie, dass es mehr Arten von Monstern gibt als ASCII-Zeichen. Einige von ihnen teilen sich also; ein roter Drache und ein blauer Drache sind beides D.)

Aufgabe

Ihr Programm muss den Namen eines NetHack-Monsters als Eingabe verwenden und das ASCII-Zeichen erzeugen, das es im Spiel als Ausgabe darstellt. Das Programm darf davon ausgehen, dass es sich bei der Eingabe tatsächlich um den Namen eines NetHack-Monsters handelt. Wenn die Eingabe ungültig ist, kann dies zu Abstürzen, bedeutungslosen Ergebnissen usw. führen.

Das folgende Stack-Snippet ist ein JSON-Objekt, das die vollständige Zuordnung möglicher Eingaben zu den entsprechenden Ausgaben ermöglicht:

Code-Snippet anzeigen

Im Grunde genommen lautet die Aufgabe hier "Geben Sie einen Schlüssel im Wörterbuch ein, das vom obigen JSON-Objekt dargestellt wird, und geben Sie den entsprechenden Wert zurück".

Beachten Sie, dass diese Herausforderung in gewisser Weise eine umgekehrte Kolmogorov-Komplexität ist . Anstatt von einer kleinen / leeren Eingabe zu einer großen Ausgabe zu wechseln, wechseln Sie von einer großen Eingabe zu einer kleinen Ausgabe. (Die Eingabe enthält daher viele redundante Informationen, die Sie ignorieren oder nach Belieben verwenden können.) Es ist auch ziemlich ähnlich zu Regex-Golf, außer dass a) jede Sprache erlaubt ist (nicht nur Regex) und b) es mehr als zwei mögliche Ausgaben gibt. (Wir hatten schon einige Aufgaben wie diese, wie diese beiden , aber diese Aufgabe ist etwas anders, weil das angegebene Eingabe- / Ausgabeverhalten stärkere Muster aufweist.)

Klarstellungen

Sie können jedes sinnvolle Eingabe- und Ausgabeformat verwenden (z. B. können Sie die Ausgabe als Zeichen oder als ASCII-Code oder als Zeichenfolge mit einer Länge von einem Zeichen erstellen). Sie können eine Funktion anstelle eines vollständigen Programms einreichen, wenn Sie dies vorziehen.

Dies wird bereits in den Standardlücken erwähnt, aber nur um es noch einmal zu wiederholen: Sie können die Korrespondenz zwischen Eingabe und Ausgabe nur im Quellcode Ihres Programms speichern. Bei dieser Herausforderung geht es im Wesentlichen darum, das Eingabe- / Ausgabeverhalten auf kleinstem Raum darzustellen. Sie dürfen also keine Liste aus dem Internet herunterladen, die Korrespondenz in einer externen Datei speichern, NetHack im Debug-Modus starten und das betreffende Monster erzeugen um zu sehen, wie es aussieht, etc .. (Außerdem möchte ich keine Monster bekämpfen müssen, um deine Beiträge zu testen.)

Siegbedingung

Dies ist Code-Golf , daher ist der gewinnende Eintrag der kürzeste, in Bytes gezählte Eintrag. Viel Glück!

code-golf compression classification hashing Peter Taylor
quelle
6
mail daemon> _ <
Briantist
1
Vorschlag: Vielleicht kannst du die Liste der Monster auch nach dem ASCII-Symbol ordnen, das sie darstellen
Kritixi Lithos
2
Seufz - das war so ein gutes Spiel, das waren die Tage ...
GreenAsJade
2
@GreenAsJade ist immer noch so ein gutes Spiel! In der Tat wurde eine neue Version vor ein paar Monaten nach ein paar Jahren Inaktivität veröffentlicht
nmjcman101
1
Ein wildes BROWN PUDDING ist erschienen !!
Magic Octopus Urn

Antworten:

11

Jelly , 309 Bytes in Jellys Codierung

“Æ÷“¥s“ɲ“¡µ’;“ịƊ⁴çNṂ‘_\
OḌ;¢*5$%¥/µ“+⁷ż!¤ña¡jIȧƁfvḶg/Ọ=^ƝĠ0Ẇƭ³½N~=.Ɗ°ɗẇ⁵\ɦ*ɠPf⁾?ṾHḣ 2=⁹ƒ!©ƊĠṣƥ®Ƙ0Yƙ>!ȧtƊN0w,$ɠẎ46fẋ⁷(ṣẆm⁾ŻƓṫµsçwṣḂḲd0Ruṛ’ḃ21+\iµØW“&;:' ”;“¡3ȧ%⁾xƑ?{Ñṃ;Ċ70|#%ṭdṃḃ÷ƑĠẏþḢ÷ݳȦṖcẇọqƁe ʠ°oḲVḲ²ụċmvP[ỴẊẋ€kṢ ȯḂ;jɓỴẏeṾ⁴ḳḢ7Ẓ9ġƤṙb€xÇ4ɗ⁻>Ẉm!Ƈ)%Ḃẇ$ġ£7ȧ`ỵẈƘɗ¡Ṃ&|ƙƥ³ẏrṛbḋƙċ⁻ṁƲRṀẹṾ<ñ⁻Ṅ7j^ɓĊ’b58¤ị;0ị@
ḲÇ€t0”@;Ṫ

Probieren Sie es online!

Ich entschied, dass es an der Zeit war, meine eigene Herausforderung anzunehmen. Die Verwendung von Jelly (und seiner 8-Bit-Codepage) bietet mir einen Vorteil von 12,5% gegenüber den Nur-ASCII-Sprachen, und Jelly ist für diese Herausforderung geeignet, da es integrierte Operatoren für die Basiskonvertierung mit kurzen Namen hat, aber die meisten Einsparungen erzielt sind auf einen besseren Komprimierungsalgorithmus zurückzuführen (dieses Programm berechnet im Durchschnitt weniger als ein Byte pro Monstertyp).

Algorithmus und Erklärung

Wortbasierte Klassifikation

Ich entschied, dass es für eine gute Punktzahl notwendig war, die Struktur der Eingabe besser auszunutzen als bei anderen Einträgen. Eine Sache , die sehr auffällig ist , dass viele Monster haben Namen der Form „ Adjektiv Spezies “; a red dragonund a blue dragonsind beide Drachentypen und erscheinen daher als D. Einige andere Monster haben Namen der Form " Spezies Job ", wie die orc shaman; Als eine Art Ork erscheint dies als o. Komplizierende Dinge sind die Untoten; a kobold zombieist sowohl ein Kobold als auch ein Zombie, und der letztere Status hat Vorrang bei der Benennung von NetHack-Monstern. Daher möchten wir dies als klassifizieren Z.

Als solches habe ich die Wörter, die in Monsternamen vorkommen, wie folgt klassifiziert: Ein Indikator ist ein Wort, das stark auf die entsprechende Monsterklasse spherehinweist (z. B. deutet stark darauf hin, dass das Monster in der Klasse ist e); ein mehrdeutiges wort ist ein wort, das viel weniger suggeriert ( lordnicht viel sagt), und alle anderen wörter sind nicht wörter , die uns egal sind. Die Grundidee ist, dass wir die Wörter im Monsternamen vom Ende bis zum Anfang von hinten betrachten und den ersten Indikator auswählen, den wir sehen. Daher musste sichergestellt werden, dass jeder Monstername mindestens einen Indikator enthielt, auf den ausschließlich mehrdeutige Wörter folgten. Ausnahmsweise Wörter, die in den Namen von Monstern vorkommen, die aussehen wie@(die größte Gruppe) werden alle als mehrdeutig eingestuft. Vor einem Indikator kann alles stehen. Beispielsweise erscheinen Farbnamen (wie red) in einem Namen immer früher als ein Indikator und werden daher als Nichtwörter betrachtet (da sie bei der Bestimmung der Identität eines Monsters niemals untersucht werden).

Am Ende läuft dieses Programm wie die anderen Programme auf eine Hash-Tabelle hinaus. Die Tabelle enthält jedoch nicht Einträge für alle Monsternamen oder für alle Wörter, die in Monsternamen vorkommen. vielmehr enthält es nur die Indikatoren. Die Hashes mehrdeutiger Wörter erscheinen nicht in der Tabelle, sondern müssen leeren Slots zugewiesen werden (der Versuch, ein mehrdeutiges Wort nachzuschlagen, bleibt immer leer). Bei Nichtwörtern spielt es keine Rolle, ob das Wort in der Tabelle erscheint oder nicht, oder ob der Hash kollidiert oder nicht, da wir niemals den Wert verwenden, ein Nichtwort nachzuschlagen. (Die Tabelle ist ziemlich spärlich, daher werden die meisten Nichtwörter nicht in der Tabelle angezeigt, aber einige, wie z. B. flesh, werden als Folge von Hash-Kollisionen in der Tabelle gefunden.)

Hier einige Beispiele, wie dieser Teil des Programms funktioniert:

  • woodchuckist ein einzelnes Wort lang (also ein Indikator) und die Tabellensuche woodchuckgibt uns die beabsichtigte Antwort r.
  • abbotist auch ein einziges Wort lang, sieht aber aus wie ein @. Als solches abbotwird ein mehrdeutiges Wort betrachtet; Die Tabellensuche ist leer und wir geben @standardmäßig eine Antwort von zurück.
  • vampire lordbesteht aus einem Indikator ( vampireentspricht V) und einem mehrdeutigen Wort ( lorddas nicht in der Tabelle enthalten ist). Das heißt, wir überprüfen beide Wörter (in umgekehrter Reihenfolge) und geben dann die richtige Antwort von V.
  • gelatinous cubebesteht aus einem Nichtwort ( gelatinousentspricht Heiner Hash-Kollision) und einem Indikator ( cubeentspricht b). Da wir nur das letzte Wort nehmen, das in der Tabelle gefunden wurde, wird dies bwie erwartet zurückgegeben.
  • gnome mummybesteht aus zwei Indikatoren, gnomeentsprechend Gund mummyentsprechend M. Wir nehmen den letzten Indikator und erhalten M, was wir wollen.

Der Code zum Behandeln der wortbasierten Klassifizierung ist die letzte Zeile des Jelly-Programms. So funktioniert das:

ḲÇ€t0”@;Ṫ
Ḳ          Split on spaces
 ǀ        Call function 2 (table lookup) on each entry
   t0      Remove trailing zeroes (function 2 returns 0 to mean "not found")
     ”@;   Prepend an @ character
        Ṫ  Take the last result

Es gibt zwei reale Fälle; Wenn die Eingabe vollständig aus mehrdeutigen Wörtern besteht, wird t0die gesamte Ausgabe der Tabellensuche gelöscht, und es @wird standardmäßig ein Ergebnis erhalten. Wenn Indikatoren in der Eingabe vorhanden sind, t0werden alle Elemente rechts vom Indikator ganz rechts gelöscht und Ṫdas entsprechende Ergebnis für diesen Indikator ausgegeben.

Tabellenkomprimierung

Natürlich löst das Aufteilen der Eingabe in Wörter das Problem nicht von selbst; Wir müssen immer noch die Korrespondenz zwischen Indikatoren und den entsprechenden Monsterklassen codieren (und die fehlende Korrespondenz von mehrdeutigen Wörtern). Dazu habe ich eine spärliche Tabelle mit 181 Einträgen (entsprechend den 181 Indikatoren; dies ist eine große Verbesserung gegenüber den 378 Monstern!) Und 966 Gesamteinträgen (entsprechend den 966 Ausgabewerten der Hash-Funktion) erstellt. Die Tabelle wird im Programm mit zwei Zeichenketten codiert: Die erste Zeichenkette gibt die Größe der "Lücken" in der Tabelle an (die keine Einträge enthalten); und die zweite Zeichenfolge gibt die Monsterklasse an, die jedem Eintrag entspricht. Beides wird übersichtlich über die Basisumsetzung dargestellt.

Im Jelly-Programm wird der Code für die Tabellensuche zusammen mit dem Programm selbst von Anfang µan in der zweiten Zeile dargestellt . So funktioniert dieser Teil des Programms:

“…’ḃ21+\iµØW“&;:' ”;“…’b58¤ị;0ị@
“…’                              Base 250 representation of the gap sizes
   ḃ21                           Convert to bijective base 21 
      +\                         Cumulative sum (converts gaps to indexes)
        i                        Find the input in this list
         µ                       Set as the new default for missing arguments

          ØW                     Uppercase + lowercase alphabets (+ junk we ignore)
            “&;:' ”;             Prepend "&;:' "
                    “…’          Base 250 representation of the table entries
                       b58       Convert to base 58
                          ¤      Parse the preceding two lines as a unit
                           i     Use the table to index into the alphabets
                            ;0   Append a zero
                              i@ Use {the value as of µ} to index into the table

Die bijektive Basis 21 ist wie die Basis 21, mit der Ausnahme, dass 21 eine gültige Ziffer ist und 0 nicht. Dies ist für uns eine bequemere Codierung, da wir zwei benachbarte Einträge mit einer Lücke von 1 zählen, sodass wir die gültigen Indizes über die kumulative Summe finden können. Wenn es um den Teil der Tabelle geht, der die Werte enthält, haben wir 58 eindeutige Werte, also dekodieren wir zuerst in 58 aufeinanderfolgende ganze Zahlen und dekodieren dann erneut mit einer Nachschlagetabelle, die diese den tatsächlich verwendeten Zeichen zuordnet. (Die meisten davon sind Buchstaben, also beginnen wir diese sekundäre Nachschlagetabelle mit den Nicht-Buchstaben-Einträgen &;:' und hängen dann einfach eine Jelly-Konstante an, die mit den Groß- und Kleinbuchstaben beginnt. Sie enthält auch einen anderen Müll, der uns aber egal ist über das.)

Wenn Sie den Sentinel-Wert "index not found" von Jelly zum Indizieren in eine Liste verwenden, wird das letzte Element der Liste zurückgegeben. Daher habe ich der Nachschlagetabelle eine Null angehängt (eine ganzzahlige Null, auch wenn die Tabelle hauptsächlich aus Zeichen besteht), um ein passenderes Sentinel anzugeben, das auf einen fehlenden Eintrag hinweist.

Hash-Funktion

Der verbleibende Teil des Programms ist die Hash-Funktion. Das fängt einfach genug an, mitOḌ; Dies konvertiert die Eingabezeichenfolge in ihre ASCII - Codes und berechnet dann den letzten Code plus den 10 - fachen vorletzten Code plus den 100 - fachen Code zuvor und so weiter String → Integer-Konvertierungsfunktion). Wenn wir diesen Hash jedoch einfach direkt über eine Modul-Operation reduzieren würden, bräuchten wir eine ziemlich große Tabelle. Stattdessen beginne ich mit einer Operationskette, um die Tabelle zu verkleinern. Sie arbeiten jeweils folgendermaßen: Wir nehmen die fünfte Potenz des aktuellen Hashwerts; dann reduzieren wir den Wert modulo um eine Konstante (welche Konstante von der von uns verwendeten Operation abhängt). Diese Kette bietet auf zwei Arten mehr Einsparungen (in Bezug auf die Reduzierung der resultierenden Tabellengröße) als Kosten (in Bezug auf die Notwendigkeit, die Operationskette selbst zu codieren): Sie kann die Tabelle erstellenviel kleiner (966 statt 3529 Einträge), und die Verwendung mehrerer Stufen bietet mehr Gelegenheit, nützliche Kollisionen einzuführen (dies ist nicht viel passiert, aber es gibt eine solche Kollision: sowohl Deathals auch YeenoghuHash auf 806, wodurch wir eine entfernen können Eintrag vom Tisch, als sie beide gehen&). Die hier verwendeten Module sind [3529, 2163, 1999, 1739, 1523, 1378, 1246, 1223, 1145, 966]. Im Übrigen liegt der Grund für die Erhöhung auf die fünfte Potenz darin, dass die Lücken in der Regel gleich groß bleiben, wenn Sie den Wert direkt eingeben, während die Exponentiation die Lücken verschiebt und eine gleichmäßigere Verteilung des Tisches nach dem bewirkt Kette statt in einem lokalen Minimum stecken zu bleiben (gleichmäßig verteilte Lücken ermöglichen eine engere Kodierung der Lückengrößen). Dies muss eine ungerade Potenz sein, um zu verhindern, dass x² = (- x )² Kollisionen einführt und 5 besser als 3 funktioniert.

Die erste Zeile des Programms codiert die Folge von Modulen mit Delta-Codierung:

“…’;“…‘_\
“…’       Compressed integer list encoding, arbitrary sized integers
   ;      Append
    “…‘   Compressed integer list encoding, small integers (≤ 249)
       _\ Take cumulative differences

Der Rest des Programms, der Beginn der zweiten Zeile, implementiert die Hash-Funktion:

OḌ;¢*5$%¥/
O           Take ASCII codepoints
 Ḍ          "Convert from decimal", generalized to values outside the range 0-9
  ;¢        Append the table of moduli from the previous line
         /  Then reduce by:
    *5$       raising to the power 5 (parsing this as a group)
       %¥     and modulusing by the right argument (parsing this as a group, too).

Nachprüfung

Dies ist das Perl-Skript, mit dem ich überprüft habe, ob das Programm ordnungsgemäß funktioniert:

use warnings;
use strict;
use utf8;
use IPC::Run qw/run/;

my %monsters = ("Aleax", "A", "Angel", "A", "Arch Priest", "@", "Archon", "A",
"Ashikaga Takauji", "@", "Asmodeus", "&", "Baalzebub", "&", "Chromatic Dragon",
"D", "Croesus", "@", "Cyclops", "H", "Dark One", "@", "Death", "&", "Demogorgon",
"&", "Dispater", "&", "Elvenking", "@", "Famine", "&", "Geryon", "&",
"Grand Master", "@", "Green-elf", "@", "Grey-elf", "@", "Hippocrates", "@",
"Ixoth", "D", "Juiblex", "&", "Keystone Kop", "K", "King Arthur", "@",
"Kop Kaptain", "K", "Kop Lieutenant", "K", "Kop Sergeant", "K", "Lord Carnarvon",
"@", "Lord Sato", "@", "Lord Surtur", "H", "Master Assassin", "@", "Master Kaen",
"@", "Master of Thieves", "@", "Medusa", "@", "Minion of Huhetotl", "&",
"Mordor orc", "o", "Nalzok", "&", "Nazgul", "W", "Neferet the Green", "@", "Norn",
"@", "Olog-hai", "T", "Oracle", "@", "Orcus", "&", "Orion", "@", "Pelias", "@",
"Pestilence", "&", "Scorpius", "s", "Shaman Karnov", "@", "Thoth Amon", "@",
"Twoflower", "@", "Uruk-hai", "o", "Vlad the Impaler", "V", "Wizard of Yendor",
"@", "Woodland-elf", "@", "Yeenoghu", "&", "abbot", "@", "acid blob", "b",
"acolyte", "@", "air elemental", "E", "aligned priest", "@", "ape", "Y",
"apprentice", "@", "arch-lich", "L", "archeologist", "@", "attendant", "@",
"baby black dragon", "D", "baby blue dragon", "D", "baby crocodile", ":",
"baby gray dragon", "D", "baby green dragon", "D", "baby long worm", "w",
"baby orange dragon", "D", "baby purple worm", "w", "baby red dragon", "D",
"baby silver dragon", "D", "baby white dragon", "D", "baby yellow dragon", "D",
"balrog", "&", "baluchitherium", "q", "barbarian", "@", "barbed devil", "&",
"barrow wight", "W", "bat", "B", "black dragon", "D", "black light", "y",
"black naga hatchling", "N", "black naga", "N", "black pudding", "P",
"black unicorn", "u", "blue dragon", "D", "blue jelly", "j", "bone devil", "&",
"brown mold", "F", "brown pudding", "P", "bugbear", "h", "captain", "@",
"carnivorous ape", "Y", "cave spider", "s", "caveman", "@", "cavewoman", "@",
"centipede", "s", "chameleon", ":", "chickatrice", "c", "chieftain", "@",
"clay golem", "'", "cobra", "S", "cockatrice", "c", "couatl", "A", "coyote", "d",
"crocodile", ":", "demilich", "L", "dingo", "d", "disenchanter", "R", "djinni",
"&", "dog", "d", "doppelganger", "@", "dust vortex", "v", "dwarf king", "h",
"dwarf lord", "h", "dwarf mummy", "M", "dwarf zombie", "Z", "dwarf", "h",
"earth elemental", "E", "electric eel", ";", "elf mummy", "M", "elf zombie", "Z",
"elf", "@", "elf-lord", "@", "energy vortex", "v", "erinys", "&", "ettin mummy",
"M", "ettin zombie", "Z", "ettin", "H", "fire ant", "a", "fire elemental", "E",
"fire giant", "H", "fire vortex", "v", "flaming sphere", "e", "flesh golem", "'",
"floating eye", "e", "fog cloud", "v", "forest centaur", "C", "fox", "d",
"freezing sphere", "e", "frost giant", "H", "gargoyle", "g", "garter snake", "S",
"gas spore", "e", "gecko", ":", "gelatinous cube", "b", "ghost", " ", "ghoul",
"Z", "giant ant", "a", "giant bat", "B", "giant beetle", "a", "giant eel", ";",
"giant mimic", "m", "giant mummy", "M", "giant rat", "r", "giant spider", "s",
"giant zombie", "Z", "giant", "H", "glass golem", "'", "glass piercer", "p",
"gnome king", "G", "gnome lord", "G", "gnome mummy", "M", "gnome zombie", "Z",
"gnome", "G", "gnomish wizard", "G", "goblin", "o", "gold golem", "'",
"golden naga hatchling", "N", "golden naga", "N", "gray dragon", "D", "gray ooze",
"P", "gray unicorn", "u", "green dragon", "D", "green mold", "F", "green slime",
"P", "gremlin", "g", "grid bug", "x", "guard", "@", "guardian naga hatchling",
"N", "guardian naga", "N", "guide", "@", "healer", "@", "hell hound pup", "d",
"hell hound", "d", "hezrou", "&", "high priest", "@", "hill giant", "H",
"hill orc", "o", "hobbit", "h", "hobgoblin", "o", "homunculus", "i",
"horned devil", "&", "horse", "u", "housecat", "f", "human mummy", "M",
"human zombie", "Z", "human", "@", "hunter", "@", "ice devil", "&", "ice troll",
"T", "ice vortex", "v", "iguana", ":", "imp", "i", "incubus", "&", "iron golem",
"'", "iron piercer", "p", "jabberwock", "J", "jackal", "d", "jaguar", "f",
"jellyfish", ";", "ki-rin", "A", "killer bee", "a", "kitten", "f", "knight", "@",
"kobold lord", "k", "kobold mummy", "M", "kobold shaman", "k", "kobold zombie",
"Z", "kobold", "k", "kraken", ";", "large cat", "f", "large dog", "d",
"large kobold", "k", "large mimic", "m", "leather golem", "'", "lemure", "i",
"leocrotta", "q", "leprechaun", "l", "lich", "L", "lichen", "F", "lieutenant",
"@", "little dog", "d", "lizard", ":", "long worm", "w", "lurker above", "t",
"lynx", "f", "mail daemon", "&", "manes", "i", "marilith", "&", "master lich",
"L", "master mind flayer", "h", "mastodon", "q", "mind flayer", "h", "minotaur",
"H", "monk", "@", "monkey", "Y", "mountain centaur", "C", "mountain nymph", "n",
"mumak", "q", "nalfeshnee", "&", "neanderthal", "@", "newt", ":", "ninja", "@",
"nurse", "@", "ochre jelly", "j", "ogre king", "O", "ogre lord", "O", "ogre", "O",
"orange dragon", "D", "orc mummy", "M", "orc shaman", "o", "orc zombie", "Z",
"orc", "o", "orc-captain", "o", "owlbear", "Y", "page", "@", "panther", "f",
"paper golem", "'", "piranha", ";", "pit fiend", "&", "pit viper", "S",
"plains centaur", "C", "pony", "u", "priest", "@", "priestess", "@", "prisoner",
"@", "purple worm", "w", "pyrolisk", "c", "python", "S", "quantum mechanic", "Q",
"quasit", "i", "queen bee", "a", "quivering blob", "b", "rabid rat", "r",
"ranger", "@", "raven", "B", "red dragon", "D", "red mold", "F",
"red naga hatchling", "N", "red naga", "N", "rock mole", "r", "rock piercer", "p",
"rock troll", "T", "rogue", "@", "rope golem", "'", "roshi", "@", "rothe", "q",
"rust monster", "R", "salamander", ":", "samurai", "@", "sandestin", "&",
"sasquatch", "Y", "scorpion", "s", "sergeant", "@", "sewer rat", "r", "shade", " ",
"shark", ";", "shocking sphere", "e", "shopkeeper", "@", "shrieker", "F",
"silver dragon", "D", "skeleton", "Z", "small mimic", "m", "snake", "S",
"soldier ant", "a", "soldier", "@", "spotted jelly", "j", "stalker", "E",
"steam vortex", "v", "stone giant", "H", "stone golem", "'", "storm giant", "H",
"straw golem", "'", "student", "@", "succubus", "&", "tengu", "i", "thug", "@",
"tiger", "f", "titan", "H", "titanothere", "q", "tourist", "@", "trapper", "t",
"troll", "T", "umber hulk", "U", "valkyrie", "@", "vampire bat", "B",
"vampire lord", "V", "vampire", "V", "violet fungus", "F", "vrock", "&", "warg",
"d", "warhorse", "u", "warrior", "@", "watch captain", "@", "watchman", "@",
"water demon", "&", "water elemental", "E", "water moccasin", "S", "water nymph",
"n", "water troll", "T", "werejackal", "d", "wererat", "r", "werewolf", "d",
"white dragon", "D", "white unicorn", "u", "winged gargoyle", "g",
"winter wolf cub", "d", "winter wolf", "d", "wizard", "@", "wolf", "d",
"wood golem", "'", "wood nymph", "n", "woodchuck", "r", "wraith", "W", "wumpus",
"q", "xan", "x", "xorn", "X", "yellow dragon", "D", "yellow light", "y",
"yellow mold", "F", "yeti", "Y", "zruty", "z");

for my $monster (sort keys %monsters) {
    run ["./jelly", "fu", "monsters.j", $monster], \ "", \my $out;
    print "$monster -> \"$out\" (",
        ($out ne $monsters{$monster} ? "in" : ""), "correct)\n";
}

quelle
10

JavaScript (ES6), 915 ... 902 890 Bytes

w=>[..."aZM?o@;LWu&P?D@zF@W: @aT&@nCEfvQ&R&Tb'b@&p@:Srn @ahlrdpdT'TRv:HUYG@&fSfYdG&SGHL@Mh@G@gs';@CS@km@OsirA@q@njOZS@O@';HYqHE&DJavq&&aYaBmZMf;bv@EqHg@Z@;dm@M@?@rs@d@@oDAosDT@d@ZeBVrq@jFooD@VV&&BvMEDKiuiPC@&@DYrD&eD@D@@:AwccKZiF:DKLXAwdL@w&@@u'Hc@@q&;D:::WjdN@N@xD&eFh@gh@&Md?&Ye@@&h@hNN'Z&qtKEd@@HtH&@'@&@xd&dZsv@oo@FDyd@@&&@&@HS'Hw?DF@@@MPfDfi'AH&@@pkZkuMyZhFNN'P?d@u@NN&B@uo'fdi@?ke&"].find((_,i)=>!(s-=`GD4~#_@'R<1*~7C7RbZ6F'"Sa&!*1),#''3'.+B6(K$.l%9&!#0@51""~/+!gaW!/.(5'-@0'';!%C.&""!-.$16.2>(#&g!!O,#8A50O!)*(9b|Z4@7V).;*A*HWO(g1$/*-4&SL1I#K$#"3"#=e/'V~4'B(*,.3),$@D3)*76-"\\&kL7(-4#=7!!#+(B/B!-%!"_+!")+)0$1:E84!L191&)(255)!3O<,90NN6&;Q2'"bO=*h7.%1![<o!%M'G5/R.0$-J*%\\~6T?>)16""L&!X94T4"3$!2'^070Y2a"##)#"&n&(+1*&!-M""73R5%'y0~$-6<".MV?+1*ED>!B6b!)%&)8.+$&X0~Q'E%8&#%S/H.1<#>~!sU`.charCodeAt(i)-32),w=w.replace(/\W/g,1),s=parseInt((w+=w+w)[0]+w[2]+w[3]+w[6]+[...w].pop(),36)%8713)

Formatiert

Unten finden Sie eine formatierte Version des Codes mit abgeschnittenen Nutzdaten.

w => [..."aZM(…)"].find(
  (_, i) =>
    !(s -= `GD4(…)`.charCodeAt(i) - 32),
    w = w.replace(/\W/g, 1),
    s = parseInt((w += w + w)[0] + w[2] + w[3] + w[6] + [...w].pop(), 36) % 8713
)

Wie es funktioniert

Schritt 1

Wir reduzieren zuerst den Monsternamen um:

  1. Ersetzen von nicht alphanumerischen Zeichen (Leerzeichen und Bindestrichen) durch 1's.
  2. Wiederholen Sie diese Zeichenfolge dreimal, um sicherzustellen, dass genügend Zeichen vorhanden sind, mit denen Sie im nächsten Schritt arbeiten können.
  3. Behalten Sie nur das 1., 3., 4., 7. und letzte Zeichen bei.

Beispiele:

1.34..7..L
Demogorgon -> Dmorn
^ ^^  ^  ^

             1.34..7.L
orc mummy -> orc1mummy -> oc1my
             ^ ^^  ^ ^

        1.34..7....L
xorn -> xornxornxorn -> xrnrn
        ^ ^^  ^    ^

Dies führt zu einigen Kollisionen. Zum Beispiel "Master Assassin"und "Master Kaen"sind beide auf reduziert "Mst1n". Glücklicherweise haben alle Namen kollidierender Monster dasselbe Symbol ( @in diesem Fall).

Schritt 2

Dann interpretieren wir diese 5-stellige Zeichenfolge als Basisgröße, um sie in eine Dezimalzahl umzuwandeln (bei dieser Operation wird die Groß- und Kleinschreibung nicht berücksichtigt), und wenden ein Modulo an 8713, das empirisch ausgewählt wurde, um eine kollisionsfreie Liste von Schlüsseln zu erstellen.

Beispiele:

Dmorn --[from base 36]--> 22893539 --[MOD 8713]--> 4488
oc1my --[from base 36]--> 40872778 --[MOD 8713]--> 95
xrnrn --[from base 36]--> 56717843 --[MOD 8713]--> 4926

Schritt 3

Alle Schlüssel sind in aufsteigender Reihenfolge sortiert:

[ 39, 75, 95, 192, 255, 287, 294, 344, 372, 389, 399, 516, 551, 574, 624, ..., 8635, 8688 ]

Umgerechnet in Delta-Werte:

[ 39, 36, 20, 97, 63, 32, 7, 50, 28, 17, 10, 117, 35, 23, 50, ..., 83, 53 ]

Und als ASCII-Zeichen im Bereich codiert [ 32, 126 ]. Einige Dummy-Zwischenwerte werden eingefügt, wenn die Differenz zwischen zwei aufeinanderfolgenden Tasten die maximal codierbare Größe überschreitet.

Schließlich wird die Liste der Tasten einer Liste von Symbolen zugeordnet, die in derselben Reihenfolge angeordnet sind.

Prüfung

Code-Snippet anzeigen

Arnauld
quelle
Entsprechend Ihrer eigenen Testsuite werden 5 Einträge falsch klassifiziert. Ich habe nicht untersucht, was sie verursacht, aber das muss wahrscheinlich behoben werden.
@ ais523 Das bekomme ich, weil ich es nur in Firefox getestet habe. Ich werde versuchen, das für (zumindest) Chrome zu beheben.
Arnauld
2
@ ais523 Das sollte jetzt auf FF, Chrome & Edge gut funktionieren. Das tut mir leid.
Arnauld
Ich hatte die Idee, Bits aus den in Zahlen umgewandelten Namen zu extrahieren, aber ich dachte offensichtlich zu klein. Glückwunsch!
Jonas Schäfer
8

Java, 1130 Bytes

import java.util.*;class G{public static void main(String[]u){BitSet s=BitSet.valueOf(Base64.getDecoder().decode("D94FuoCWYEIhCTEgLWwRNU/CMB1cE7XBhxBsBCusihaASRg14IJpQMOIDJdFx3BOdDcmThdhILVkCgGsEmhII8UE+SB4kDYEEJzw7Tw54oUEQZe0AUHCACH6nAdqgiZgJhASCIPAEAzJBmuMIrBCHE8IiFjgKQwrN4/90B4QFaLBQBEwTArRBMLCLHQOUQs7ZXZ8B8uGC1EbeAMJBdihUDgCIwGUEKgEAu4W2SJkIAhzB1IQSHgNiEAwABQECV5BvAB7eizABXxFLEg5iMA3whhAFXOKHXEURB7UA7PQjgUK7sji8CmIC0FJsTB4tAMFgiARB3hOJATDsBkgGKnGmWIiIWBRwkMgToQJ49G8gTR4IqcB4vJwDBHSVBLQhpwHsUFipqBcWWaEsCBoGBF0AlNAE305HAfdU1AEbELBO0EERAfkmMkgZcEXDIa4MAp4HcENmYAMBB7UBbTwBqQPSMS9kVkEBMhCudAqBAKaR1CzZggDRw8WMAh0FQPEyKAsRAxzBwn0grwDMQMyQMdADRtFUBAsBQetRRBwcUgrlsQ1IkosBc9B6iBcjAkSDDKgEAQ1wgLIMEEwMkYB42ERBCdiEJMAt1wYSIAQkdIEI0UPNhALsDnRQ1AT/HQi1AyCEwiICOICpiAPlB8MwxnBPIk6JYaIgDy8NJHDsiAqzK0JAXpQPXgPLwJuEEbMTAGBYlQbDESvAXJAAQ=="));int i,j,k,c,d,h=u[0].hashCode(),a=(h&4092)>>2|(h>>5)&1024|(h>>7)&2048|(h>>9)&4096;char r='@';for(i=k=0;i<4297;i+=14){for(c=0,j=7;j>=0;j--)c+=c+(s.get(i+j)?1:0);if((k+=c)==a){for(d=0,j=13;j>=8;j--)d+=d+(s.get(i+j)?1:0);r=d<5?" &':;".charAt(d):(char)((d<31?60:66)+d);}}System.out.println(r);}}

Ungolfed:

import java.util.*;

class G {
    public static void main(String[] u) {
        BitSet s = BitSet.valueOf(Base64.getDecoder().decode(
                "D94FuoCWYEIhCTEgLWwRNU/CMB1cE7XBhxBsBCusihaASRg14IJpQMOIDJdFx3BOdDcmThdhILVkCgGsEmhII8UE+SB4kDYEEJzw7Tw54oUEQZe0AUHCACH6nAdqgiZgJhASCIPAEAzJBmuMIrBCHE8IiFjgKQwrN4/90B4QFaLBQBEwTArRBMLCLHQOUQs7ZXZ8B8uGC1EbeAMJBdihUDgCIwGUEKgEAu4W2SJkIAhzB1IQSHgNiEAwABQECV5BvAB7eizABXxFLEg5iMA3whhAFXOKHXEURB7UA7PQjgUK7sji8CmIC0FJsTB4tAMFgiARB3hOJATDsBkgGKnGmWIiIWBRwkMgToQJ49G8gTR4IqcB4vJwDBHSVBLQhpwHsUFipqBcWWaEsCBoGBF0AlNAE305HAfdU1AEbELBO0EERAfkmMkgZcEXDIa4MAp4HcENmYAMBB7UBbTwBqQPSMS9kVkEBMhCudAqBAKaR1CzZggDRw8WMAh0FQPEyKAsRAxzBwn0grwDMQMyQMdADRtFUBAsBQetRRBwcUgrlsQ1IkosBc9B6iBcjAkSDDKgEAQ1wgLIMEEwMkYB42ERBCdiEJMAt1wYSIAQkdIEI0UPNhALsDnRQ1AT/HQi1AyCEwiICOICpiAPlB8MwxnBPIk6JYaIgDy8NJHDsiAqzK0JAXpQPXgPLwJuEEbMTAGBYlQbDESvAXJAAQ=="));

        int i, j, k, c, d, h = u[0].hashCode(), 
            a = (h & 4092) >> 2 | (h >> 5) & 1024 | (h >> 7) & 2048 | (h >> 9) & 4096;
        char r = '@';
        for (i = 0, k = 0; i < 4297; i += 14) {
            for (c = 0, j = 7; j >= 0; j--)
                c += c + (s.get(i + j) ? 1 : 0);
            if ((k += c) == a) {
                for (d = 0, j = 13; j >= 8; j--)
                    d += d + (s.get(i + j) ? 1 : 0);
                r = d < 5 ? " &':;".charAt(d) : (char) ((d < 31 ? 60 : 66) + d);
            }
        }
        System.out.println(r);
    }
}

Monsternamen sind:

  • Hashing mit Java- hashcodeMethode => 32 Bit
  • UND-verknüpft mit der Maske 1001001000111111111100 => 13 Bit
  • vom kleinsten zum größten sortiert
  • Wir verwenden dann die Delta-Werte der sortierten Liste => 8 Bits

Das Anzeigezeichen ist mit 6 Bits codiert.

Jedes Tupel (Monstername, Charakter) verwendet also 14 Bits. Alle Tupel werden in einem BitSet gespeichert und mit der Basis 64 codiert.

Ich verliere eine Menge Bytes mit Base64-Codierung und BitSet-Operationen :-)

Arnaud
quelle
Sie können die Größe reduzieren , indem es Lambda - Ausdruck zu machen: ()->{...}. Die Frage sagt dies in ihrem Abschnitt "Erläuterungen".
Olivier Grégoire
5

Mathematica, 1067 Byte (römische Mac OS-Zeichencodierung)

FromCharacterCode[Mod[Tr/@{c=ToCharacterCode@#,c^2},216,32],"MacintoshRoman"]/.Inner[Rule,";¤7«´3πœ(ú-UU=6z±'¥ÿ†tƒ|\¢KÛd§≤jSóKWÊ8‰Ñwiøì¡ÛhÓ\‡¨:–*~‚¬æº¢»‘¤Á^∫„·nLÒ¤b|$|ÇòCóÌÈS_Ñä.Ëí 5y«KΔË\Ãò™_E`J’ëΔñTV–N„'„Ÿà¥xpîH#-PP)ÈÊVQ©LrBt}∑WÉ∏dÿå„•Tz∑Âao¿rÃ^bbP¨}ëÖ◇1èÇ&d¢¤ái√,B}±BˆÍdA´íBtæÅ/m√yQ6,uãÊ≤/Î!ïøuΩÒÉ)ë“∕C$RY•ÍÍu£oÉÓå‚Ïl.·1‚40ÃÚ¨ÇÆÅccflÓ8Ï Gáç3EÑ¥fXñ¨Àìz~j÷–ñÓz0~ôWtñ}μÎ◇f||Dd\ ÙH﷿É∑Ì´|¿Ö_»RT8Ûª|Äqü‘&6Ãác›Yˆ¿ô5≈ënÚqΩåVä>∫æ∂p ¨jtöåoÌfløÏÏò§¤flÈ;À∑Ѥ·›9né∕<·ì∕ÿmŸ«Ì»j√üà‰÷“5ïä^Ûe◇kd‡“(Ïö71›iΟÁm„ÈïÒß„kÕπ°ÊÓÒçÓfˆ¨flÁ9k|¶ä∕l~Òød‹jZÏ2[kÎ√3ÛâìÓΔE]ıIÚ>{#ÁÖ‚Üâ;·?l^vàß‹‘jîÙÇÅÉú¥äärÆæ™∏Üi≈mØÂ’-%USÌâ’ı Ê›·Ëÿb‡ıÖ31nh™Δ$~%À0n-À´sflk∑p.o5vz}mè]ÎÅç©lt;Îu„ŸW„›ˆˆÍ﷿Ä*7m8‰πór,„Õш/”Ë∕ªß9±‡¶çÁ•âg˜fló)ÖÔ¡'wúæ0ñ„Kûr"~(a=StringPartition)~2,"AAA&&DH&&&&&D&KKKKH&o&WT&&soV&bEYLDD:DDwDwDDDD&q&WBDyNNPuDj&FPhYss:c'ScAd:LdR&dvhhMZhE;MZv&MZHaEHve'evCdeHgSe:b ZaBa;mMrsZH'pGGMZGGo'NNDPuDFPgxNNdd&Hohoi&ufMZ&Tv:i&'pJdf;AafkMkZk;fdkm'iqlLFd:wtf&i&LhqhHYCnq&:jOODMoZooYf';&SCuwcSQiabrBDFNNrpT'qR:&Ysr eFDZmSajEvH'H'&ifHqtTUBVVF&du&ESnTdrdDugddd'nrWqXDyFYz"~a~1,List]/.x_/;StringLength@x>1->"@"&

Unbenannte Funktion, die eine Zeichenfolge als Eingabe verwendet und ein Zeichen zurückgibt. Die Funktion hat folgende Form:

1  FromCharacterCode[
2    Mod[Tr/@{c=ToCharacterCode@#,c^2},216,32]
3    ,"MacintoshRoman"] /.
4  Inner[Rule,
5    GIANT_STRING_1 ~(a=StringPartition)~2,
6    GIANT_STRING_2 ~a~1,
7    List]
8  /. x_/;StringLength@x>1 -> "@" &

Hier ist GIANT_STRING_1 eine Zeichenfolge mit 608 Ein-Byte-Zeichen in der lateinischen Mac OS-Zeichencodierung (von denen keines im Bereich von 00-1F liegt), während GIANT_STRING_2 eine Zeichenfolge mit 304 ASCII-Zeichen ist.

Zeile 2 startet die Hash-Funktion: Sie konvertiert die Eingabezeichenfolge in eine Liste von Zeichencodes (Codierung irrelevant, da sie alle druckbares ASCII sind) und berechnet dann die Summe dieser Zeichencodes und die Summe ihrer Quadrate, sowohl modulo 216 als auch forcing Die Antwort liegt zwischen 32 und 255. Dann konvertieren die Zeilen 1 und 3 diese geordneten Paare von Ganzzahlen in Zeichenfolgen mit zwei Zeichen. Dies ist der Hash-Wert, den wir letztendlich verwenden.

Zeile 5 verwandelt GIANT_STRING_1 in eine Liste von 304 Zeichenfolgen mit zwei Zeichen. Zeile 6 verwandelt GIANT_STRING_2 in eine Liste von 304 Ein-Zeichen-Strings. Dann wandeln die Zeilen 4 und 5 diese beiden Listen in einen Satz von 304 Ersetzungsregeln um: Wenn Sie eine solche und eine solche Zeichenfolge sehen, wandeln Sie sie in eine solche und eine solche Zeichenfolge um. Schließlich verwandelt Zeile 8 jede verbleibende zweistellige Zeichenfolge in "@".

Es gibt 71 Monster in der Liste, deren Symbol ist "@", und diese werden ohne Hash behandelt (ich habe diese Idee aus einem Kommentar von ais523 zu einer anderen Antwort gestohlen). Es ist nur so, dass die anderen 304 Hash-Werte alle eindeutig sind! Daher sind keine weiteren Änderungen am Algorithmus erforderlich. (Es ist ein Glücksfall, "human"auf den abgebildet werden muss "@", da die Summen der Zeichencodes der Buchstaben in "human"und der Buchstaben in "shark"identisch sind, ebenso wie die Summen der Quadrate dieser Codes - als ganze Zahlen, nicht einmal modulo 216!)

Greg Martin
quelle
3

Python, 2055 Bytes

def f(s):import re;m=re.search(s[-3:-1]+s[:2]+str(len(s))+"(.)","omgn5Gteen13vligr7glero10'akga12Sanso11aragi9rgoDe10&tiet5HleVl16Vanst11Hmpmo14nubge15brsho5uingo21Nbuin7&gobl11Dgobl12Duaja6faule10lkest7Eolic9Ttawa15EanKo14KanKo12Kviba12&gore10Dimim3iutzr5zingn10Ganhi10Herfr15emmel9Mlele13'guNa6Wkaja6dotco6docvr5&petr7tmaor10oarli6:nhpi7;moma11&icli4Linbl20Nolwa11Titwr6Wtlgi12ateru12Rbign12Zozgr9Plepa11'oufo9vingu23Norhi8onena10&tati5Hiosc8sinre18Nligo6obeki10aeaow7Yeyfl12elewo10'adsh5 anfr11Hapap3Ygrog4Obequ9ahopy6Steki6fgogr11Dgogr12Dpepi9Sngdi5dindw10hlegl11'imgr11Pbava11Bcero12phaOl8Tdoli10dcuwi15dargn14GotIx5Dinbl13Parwa4dpuhe14dtisa9&ilba14:liho9onyer6&euAs8&aupl14Cttle9qmmdw11Molbr10Fmism11mncPe10&mpwa11noror3oispy8caumo16Clest11'haUr8okekr6;bigi12ZbuBa9&gowh12Dbiko13Zbiet12Zmmgn11Molwe8dmowa11&icde8Lbiho6hdola9dleJu7&otMi18&ulum10Uenpi9&luho10ighye12ymamu5qorwh13ughbl11yylga8gKoKe12Knndj6&mmet11Magbl10Narsh5;osgh5 orxo4Xoltr5Tdoma8qopCy7Hceir12pgoba18Dorlo9wgoba16Dbidw12ZinFa6&goor13DeaAl5Aiuba14qloac9bkemo6Yniqu16QteDi8&aufo14Ckesh8Fetye4Yolro9ryema18hersh15eaggo11Nrase9ranig6:ghba12Winbr13Polwi11dgeti5fzoNa6&orga9emmko12Manfi8aorgn10Gatco6Alecl10'goye13Deabu7hinog9Oheli6Feoch9:ynly4fngte5ieeel12;rawe7ricch11caior11ocala9fguvi13Fangi9aangi5Hhepa7fdesa10:cuOr5&rswa8ubrco5Sorva12Vxaxa3xovlu12tbaba3Bilcr9:geAn5Aolwo4dviic9&tafi14Ecegl13pbugr8xorpu11wgoCh16Dicar9Laggu13Ndegi12shoAr6Aolla12kedce9sitma8&erti11qicma11Lbior10Zviho12&test12vbusu8&fofo3ddeca11srara9rolko6kmpwo10ntaea15Ellbl10jgosi13Daksn5Svibo10&tosk8Zicco10cvera5Bgoba15DatDe5&goba17Dpuwu6qkawe10dmmhu11Mdodo3dunhe10dtcsa9Yckge5:tefi11vsiqu6iloqu14bewne4:yoGe6&caho8fucwo9rorMo10oisje9;taai13Eardw5holye11Fordw10hlloc11jough5Zerfl14emila11mtedu11vthro5qteic10vtuLo11Hmmor9Mirva7Vbagi9Bolro10Tmako13kleir10'biel10Zmmgi11Mnema5ilego10'olre8Forbl13usiwa14Sroba6&agre8Nrohe6&orgr12ulefl11'ocja10JghYe8&aumi8HiuSc8sbihu12Zriki6Ayemi11horko11kolgr10Furle6ianfi10Hmigi11monpo4ullsp13jaiKo11Ktedi12Rapca15Yorog9Oylwi15geegi9;orba14worba16w");return m.group(1)if m else'@'

Hier ist mein Testgeschirr, falls es jemand anderem hilft.

MAPPING = {
    # as given in the original question
}
def validate_solution(f):
    for k, v in MAPPING.iteritems():
        vv = f(k)
        if vv != v:
            print 'FAIL: f(%s) = %s instead of %s' % (k, vv, v)
    print 'SUCCESS!'

Ich habe ein kleines Programm geschrieben, um die verschiedenen Möglichkeiten zum Extrahieren von 4 Zeichen plus der Länge der Zeichenfolge aufzulisten. Mein ursprünglicher Plan war es, ord()diese Zeichen zu analysieren und zu einer perfekten Hash-Funktion zusammenzufassen, die Indizes in einer Tabelle mit Ausgaben erzeugt. Also habe ich ein weiteres kleines Programm geschrieben, um all die verschiedenen Arten des Summierens / Multiplizierens / Modulierens dieser 4 Zeichen zusammen aufzuzählen. aber die daraus resultierenden Hash - Funktionen gehalten, die Art und Weise zu viele Kollisionen. Also habe ich irgendwann aufgegeben und einfach das getan, was Sie hier sehen. Das ist nur eine Karte von der kleinen Darstellung des Monsternamens bis zum entsprechenden Symbol.

Das heißt: Was ich bekommen wollte war

def f(monster_name):
    small_string = f1(monster_name)
    integer_index = f2(small_string)
    symbol = "relatively_short_table"[integer_index]
    return symbol

aber ich schaffte es nur so weit zu kommen

def f(monster_name):
    small_string = f1(monster_name)
    symbol = {relatively_large_dict}[small_string]
    return symbol

wo mein Diktat Lookup {relatively_large_dict}[small_string]als re.match(small_string+"(.)", "relatively_large_string")für Golfiness ausgedrückt wird.

Quuxplusone
quelle
2

JavaScript (ES6), 1178

n=>'@0uy1c8@@@@@@2cb7sj0sb5rhcm626435y6js6u651b1nj5jg85g2xj02l4wh31u2py2xl96h5fz6ys46tc7821p2e9c1o1td1cy834@2sq2c055iabn91f82vahc6ytagh5d363i@@@@@@@@@@@@@@@@@@@7hh2wf2nd1bu2d93cm0gu862@144819a6v2h44o41d4@@@@@@0c404806f3fa0z8@04c82o1vfac3@c10a3g08g@82e0lr7bf26p2dibcb11t9y19q6bbh4db7tr3592u2bof4913edawy84p1cr@bap1qzb1o033bt6@8d93v230t4240w9ahh8cy@09u0a60sd1qd@1n23ak1bt614bax0ro7sd57xagg22s1gj@@be0@74l01c28qcdi@1so83t0c068s@2jh7as7ddalq0vxag68pn6b9@0gabu71zp54m6997imb2047h@10s0zo0mv@aww6ixbqgag7@944@bza76b@1a053c2yn6101eh8en@4je6fq97t1py9f0@6co@b3k5my44p@4edb737t9@0tl@00rau75y369z5hk0ot@23d2wicb90uwb54a9l3gw9lv3z51nv@@@@@@@amy81e3kh9yc90e59d@6528z42ic@7uv6bm58t@3av0w004t05aavs3oq3040irawj0ov1n90213h89yn0vs@0mcc284fv6uyaxp@3242ok39h0jd06905v1ia@7zc9659bk@ax30ua0um0652sa65daqd@00z03d2ra1f95751xu@9x10676yz@72w33r24b63d@2d7@ats6f678u@bcg9uf6h6@1b60us2d17ygbxn72106t02g@adublf05q@8xu5wobqb1tc1c73cs7pj@87k3cj2xq6258l379y@0q42qy3vs3y70r9@06v2a9@ast4su12w0ko4y77dn@7oubr07ju1ct5qe81v@0d52kb66t4zj@93508c@af30kj@299'.replace(/@\w*/g,v=>~-v.search((100+h.toString(36)).slice(-3))%3?++i:r=String.fromCharCode(i),i=32,r='@',n.replace(/\w/g,c=>h=parseInt(c,36)^(h*3)&16383,h=0))&&r

Weniger golfen

n=>(
'@0uy1c8@@@@@@2cb7sj0sb5rhcm626435y6js6u651b1nj5jg85g2xj02l4wh31u2py2xl96h5fz6ys46tc7821p2e9c1o1td1cy834@2sq2c055iabn91f82vahc6ytagh5d363i@@@@@@@@@@@@@@@@@@@7hh2wf2nd1bu2d93cm0gu862@144819a6v2h44o41d4@@@@@@0c404806f3fa0z8@04c82o1vfac3@c10a3g08g@82e0lr7bf26p2dibcb11t9y19q6bbh4db7tr3592u2bof4913edawy84p1cr@bap1qzb1o033bt6@8d93v230t4240w9ahh8cy@09u0a60sd1qd@1n23ak1bt614bax0ro7sd57xagg22s1gj@@be0@74l01c28qcdi@1so83t0c068s@2jh7as7ddalq0vxag68pn6b9@0gabu71zp54m6997imb2047h@10s0zo0mv@aww6ixbqgag7@944@bza76b@1a053c2yn6101eh8en@4je6fq97t1py9f0@6co@b3k5my44p@4edb737t9@0tl@00rau75y369z5hk0ot@23d2wicb90uwb54a9l3gw9lv3z51nv@@@@@@@amy81e3kh9yc90e59d@6528z42ic@7uv6bm58t@3av0w004t05aavs3oq3040irawj0ov1n90213h89yn0vs@0mcc284fv6uyaxp@3242ok39h0jd06905v1ia@7zc9659bk@ax30ua0um0652sa65daqd@00z03d2ra1f95751xu@9x10676yz@72w33r24b63d@2d7@ats6f678u@bcg9uf6h6@1b60us2d17ygbxn72106t02g@adublf05q@8xu5wobqb1tc1c73cs7pj@87k3cj2xq6258l379y@0q42qy3vs3y70r9@06v2a9@ast4su12w0ko4y77dn@7oubr07ju1ct5qe81v@0d52kb66t4zj@93508c@af30kj@299'
.replace(/@\w*/g, v= > 
   (v.search((100 + h.toString(36)).slice(-3))-1) % 3  
     ? ++i : r = String.fromCharCode(i),
   i=32,
   r='@',
   n.replace(/\w/g,c => h=parseInt(c,36) ^ (h*3) & 16383,h=0)
)
&& r

Prüfung 

F=
n=>'@0uy1c8@@@@@@2cb7sj0sb5rhcm626435y6js6u651b1nj5jg85g2xj02l4wh31u2py2xl96h5fz6ys46tc7821p2e9c1o1td1cy834@2sq2c055iabn91f82vahc6ytagh5d363i@@@@@@@@@@@@@@@@@@@7hh2wf2nd1bu2d93cm0gu862@144819a6v2h44o41d4@@@@@@0c404806f3fa0z8@04c82o1vfac3@c10a3g08g@82e0lr7bf26p2dibcb11t9y19q6bbh4db7tr3592u2bof4913edawy84p1cr@bap1qzb1o033bt6@8d93v230t4240w9ahh8cy@09u0a60sd1qd@1n23ak1bt614bax0ro7sd57xagg22s1gj@@be0@74l01c28qcdi@1so83t0c068s@2jh7as7ddalq0vxag68pn6b9@0gabu71zp54m6997imb2047h@10s0zo0mv@aww6ixbqgag7@944@bza76b@1a053c2yn6101eh8en@4je6fq97t1py9f0@6co@b3k5my44p@4edb737t9@0tl@00rau75y369z5hk0ot@23d2wicb90uwb54a9l3gw9lv3z51nv@@@@@@@amy81e3kh9yc90e59d@6528z42ic@7uv6bm58t@3av0w004t05aavs3oq3040irawj0ov1n90213h89yn0vs@0mcc284fv6uyaxp@3242ok39h0jd06905v1ia@7zc9659bk@ax30ua0um0652sa65daqd@00z03d2ra1f95751xu@9x10676yz@72w33r24b63d@2d7@ats6f678u@bcg9uf6h6@1b60us2d17ygbxn72106t02g@adublf05q@8xu5wobqb1tc1c73cs7pj@87k3cj2xq6258l379y@0q42qy3vs3y70r9@06v2a9@ast4su12w0ko4y77dn@7oubr07ju1ct5qe81v@0d52kb66t4zj@93508c@af30kj@299'.replace(/@\w*/g,v=>~-v.search((100+h.toString(36)).slice(-3))%3?++i:r=String.fromCharCode(i),i=32,r='@',n.replace(/\w/g,c=>h=parseInt(c,36)^(h*3)&16383,h=0))&&r


monsters = {
  "Aleax": "A",
  "Angel": "A",
  "Arch Priest": "@",
  "Archon": "A",
  "Ashikaga Takauji": "@",
  "Asmodeus": "&",
  "Baalzebub": "&",
  "Chromatic Dragon": "D",
  "Croesus": "@",
  "Cyclops": "H",
  "Dark One": "@",
  "Death": "&",
  "Demogorgon": "&",
  "Dispater": "&",
  "Elvenking": "@",
  "Famine": "&",
  "Geryon": "&",
  "Grand Master": "@",
  "Green-elf": "@",
  "Grey-elf": "@",
  "Hippocrates": "@",
  "Ixoth": "D",
  "Juiblex": "&",
  "Keystone Kop": "K",
  "King Arthur": "@",
  "Kop Kaptain": "K",
  "Kop Lieutenant": "K",
  "Kop Sergeant": "K",
  "Lord Carnarvon": "@",
  "Lord Sato": "@",
  "Lord Surtur": "H",
  "Master Assassin": "@",
  "Master Kaen": "@",
  "Master of Thieves": "@",
  "Medusa": "@",
  "Minion of Huhetotl": "&",
  "Mordor orc": "o",
  "Nalzok": "&",
  "Nazgul": "W",
  "Neferet the Green": "@",
  "Norn": "@",
  "Olog-hai": "T",
  "Oracle": "@",
  "Orcus": "&",
  "Orion": "@",
  "Pelias": "@",
  "Pestilence": "&",
  "Scorpius": "s",
  "Shaman Karnov": "@",
  "Thoth Amon": "@",
  "Twoflower": "@",
  "Uruk-hai": "o",
  "Vlad the Impaler": "V",
  "Wizard of Yendor": "@",
  "Woodland-elf": "@",
  "Yeenoghu": "&",
  "abbot": "@",
  "acid blob": "b",
  "acolyte": "@",
  "air elemental": "E",
  "aligned priest": "@",
  "ape": "Y",
  "apprentice": "@",
  "arch-lich": "L",
  "archeologist": "@",
  "attendant": "@",
  "baby black dragon": "D",
  "baby blue dragon": "D",
  "baby crocodile": ":",
  "baby gray dragon": "D",
  "baby green dragon": "D",
  "baby long worm": "w",
  "baby orange dragon": "D",
  "baby purple worm": "w",
  "baby red dragon": "D",
  "baby silver dragon": "D",
  "baby white dragon": "D",
  "baby yellow dragon": "D",
  "balrog": "&",
  "baluchitherium": "q",
  "barbarian": "@",
  "barbed devil": "&",
  "barrow wight": "W",
  "bat": "B",
  "black dragon": "D",
  "black light": "y",
  "black naga hatchling": "N",
  "black naga": "N",
  "black pudding": "P",
  "black unicorn": "u",
  "blue dragon": "D",
  "blue jelly": "j",
  "bone devil": "&",
  "brown mold": "F",
  "brown pudding": "P",
  "bugbear": "h",
  "captain": "@",
  "carnivorous ape": "Y",
  "cave spider": "s",
  "caveman": "@",
  "cavewoman": "@",
  "centipede": "s",
  "chameleon": ":",
  "chickatrice": "c",
  "chieftain": "@",
  "clay golem": "'",
  "cobra": "S",
  "cockatrice": "c",
  "couatl": "A",
  "coyote": "d",
  "crocodile": ":",
  "demilich": "L",
  "dingo": "d",
  "disenchanter": "R",
  "djinni": "&",
  "dog": "d",
  "doppelganger": "@",
  "dust vortex": "v",
  "dwarf king": "h",
  "dwarf lord": "h",
  "dwarf mummy": "M",
  "dwarf zombie": "Z",
  "dwarf": "h",
  "earth elemental": "E",
  "electric eel": ";",
  "elf mummy": "M",
  "elf zombie": "Z",
  "elf": "@",
  "elf-lord": "@",
  "energy vortex": "v",
  "erinys": "&",
  "ettin mummy": "M",
  "ettin zombie": "Z",
  "ettin": "H",
  "fire ant": "a",
  "fire elemental": "E",
  "fire giant": "H",
  "fire vortex": "v",
  "flaming sphere": "e",
  "flesh golem": "'",
  "floating eye": "e",
  "fog cloud": "v",
  "forest centaur": "C",
  "fox": "d",
  "freezing sphere": "e",
  "frost giant": "H",
  "gargoyle": "g",
  "garter snake": "S",
  "gas spore": "e",
  "gecko": ":",
  "gelatinous cube": "b",
  "ghost": " ",
  "ghoul": "Z",
  "giant ant": "a",
  "giant bat": "B",
  "giant beetle": "a",
  "giant eel": ";",
  "giant mimic": "m",
  "giant mummy": "M",
  "giant rat": "r",
  "giant spider": "s",
  "giant zombie": "Z",
  "giant": "H",
  "glass golem": "'",
  "glass piercer": "p",
  "gnome king": "G",
  "gnome lord": "G",
  "gnome mummy": "M",
  "gnome zombie": "Z",
  "gnome": "G",
  "gnomish wizard": "G",
  "goblin": "o",
  "gold golem": "'",
  "golden naga hatchling": "N",
  "golden naga": "N",
  "gray dragon": "D",
  "gray ooze": "P",
  "gray unicorn": "u",
  "green dragon": "D",
  "green mold": "F",
  "green slime": "P",
  "gremlin": "g",
  "grid bug": "x",
  "guard": "@",
  "guardian naga hatchling": "N",
  "guardian naga": "N",
  "guide": "@",
  "healer": "@",
  "hell hound pup": "d",
  "hell hound": "d",
  "hezrou": "&",
  "high priest": "@",
  "hill giant": "H",
  "hill orc": "o",
  "hobbit": "h",
  "hobgoblin": "o",
  "homunculus": "i",
  "horned devil": "&",
  "horse": "u",
  "housecat": "f",
  "human mummy": "M",
  "human zombie": "Z",
  "human": "@",
  "hunter": "@",
  "ice devil": "&",
  "ice troll": "T",
  "ice vortex": "v",
  "iguana": ":",
  "imp": "i",
  "incubus": "&",
  "iron golem": "'",
  "iron piercer": "p",
  "jabberwock": "J",
  "jackal": "d",
  "jaguar": "f",
  "jellyfish": ";",
  "ki-rin": "A",
  "killer bee": "a",
  "kitten": "f",
  "knight": "@",
  "kobold lord": "k",
  "kobold mummy": "M",
  "kobold shaman": "k",
  "kobold zombie": "Z",
  "kobold": "k",
  "kraken": ";",
  "large cat": "f",
  "large dog": "d",
  "large kobold": "k",
  "large mimic": "m",
  "leather golem": "'",
  "lemure": "i",
  "leocrotta": "q",
  "leprechaun": "l",
  "lich": "L",
  "lichen": "F",
  "lieutenant": "@",
  "little dog": "d",
  "lizard": ":",
  "long worm": "w",
  "lurker above": "t",
  "lynx": "f",
  "mail daemon": "&",
  "manes": "i",
  "marilith": "&",
  "master lich": "L",
  "master mind flayer": "h",
  "mastodon": "q",
  "mind flayer": "h",
  "minotaur": "H",
  "monk": "@",
  "monkey": "Y",
  "mountain centaur": "C",
  "mountain nymph": "n",
  "mumak": "q",
  "nalfeshnee": "&",
  "neanderthal": "@",
  "newt": ":",
  "ninja": "@",
  "nurse": "@",
  "ochre jelly": "j",
  "ogre king": "O",
  "ogre lord": "O",
  "ogre": "O",
  "orange dragon": "D",
  "orc mummy": "M",
  "orc shaman": "o",
  "orc zombie": "Z",
  "orc": "o",
  "orc-captain": "o",
  "owlbear": "Y",
  "page": "@",
  "panther": "f",
  "paper golem": "'",
  "piranha": ";",
  "pit fiend": "&",
  "pit viper": "S",
  "plains centaur": "C",
  "pony": "u",
  "priest": "@",
  "priestess": "@",
  "prisoner": "@",
  "purple worm": "w",
  "pyrolisk": "c",
  "python": "S",
  "quantum mechanic": "Q",
  "quasit": "i",
  "queen bee": "a",
  "quivering blob": "b",
  "rabid rat": "r",
  "ranger": "@",
  "raven": "B",
  "red dragon": "D",
  "red mold": "F",
  "red naga hatchling": "N",
  "red naga": "N",
  "rock mole": "r",
  "rock piercer": "p",
  "rock troll": "T",
  "rogue": "@",
  "rope golem": "'",
  "roshi": "@",
  "rothe": "q",
  "rust monster": "R",
  "salamander": ":",
  "samurai": "@",
  "sandestin": "&",
  "sasquatch": "Y",
  "scorpion": "s",
  "sergeant": "@",
  "sewer rat": "r",
  "shade": " ",
  "shark": ";",
  "shocking sphere": "e",
  "shopkeeper": "@",
  "shrieker": "F",
  "silver dragon": "D",
  "skeleton": "Z",
  "small mimic": "m",
  "snake": "S",
  "soldier ant": "a",
  "soldier": "@",
  "spotted jelly": "j",
  "stalker": "E",
  "steam vortex": "v",
  "stone giant": "H",
  "stone golem": "'",
  "storm giant": "H",
  "straw golem": "'",
  "student": "@",
  "succubus": "&",
  "tengu": "i",
  "thug": "@",
  "tiger": "f",
  "titan": "H",
  "titanothere": "q",
  "tourist": "@",
  "trapper": "t",
  "troll": "T",
  "umber hulk": "U",
  "valkyrie": "@",
  "vampire bat": "B",
  "vampire lord": "V",
  "vampire": "V",
  "violet fungus": "F",
  "vrock": "&",
  "warg": "d",
  "warhorse": "u",
  "warrior": "@",
  "watch captain": "@",
  "watchman": "@",
  "water demon": "&",
  "water elemental": "E",
  "water moccasin": "S",
  "water nymph": "n",
  "water troll": "T",
  "werejackal": "d",
  "wererat": "r",
  "werewolf": "d",
  "white dragon": "D",
  "white unicorn": "u",
  "winged gargoyle": "g",
  "winter wolf cub": "d",
  "winter wolf": "d",
  "wizard": "@",
  "wolf": "d",
  "wood golem": "'",
  "wood nymph": "n",
  "woodchuck": "r",
  "wraith": "W",
  "wumpus": "q",
  "xan": "x",
  "xorn": "X",
  "yellow dragon": "D",
  "yellow light": "y",
  "yellow mold": "F",
  "yeti": "Y",
  "zruty": "z"
}
err = ok = 0

for(name in monsters) {
  code = monsters[name]
  result = F(name)
  if (result != code)
    console.log('ERROR',++err, name, result, code)
  else
    ++ok
}
console.log('Errors',err,'OK', ok)
Erweitern Sie das Snippet

edc65
quelle
2

Javascript, 1185 Bytes

s=>{h=0;for(i of s)h=(h<<5)-h+i.charCodeAt()|0;for(v of "Aqgh201etxitsxy0_&ctpzfekt09j36uafamqw46mz1qcxvnnoego4212nxfivutt09qyac4td1ayiotfh3dvub5fggzjqa58h37bnva3dzy_D9wlywkgkifldlp6t46v97basg905f8wadwt0w49q0gk9c8edz9e33uj6esjl_Hkkt54kr0qdlxs6hxdxxyegrdzcmz8ymvg_Ki0enu0ct1shv_o193ve2y3tpa71xu3pud405o7_We09jfsayx_Tw2gk0spoqab5c9k_s7timco3yh674rp1_Vppq2k9t1q_b3mo3tac13_E0r50a7vi5a0kgim_Y2omnjbkq59mw5njf5t_Lu9z2bj6w2128_:n0gngsocqeuh5czhyiedwd3a_w9lf1hv1rra7r_qmckg7rbhlldbvros4f44h_B32t12yzdci83_yjkb3va_Nt2cbaqd46toc29anic1qq3es_P3mkmtv2l4j8r_ukjb44lwm5vkaz5hwkh_j3oo7uj9ip_Fzuk8mh1rpfw7obl6s9fsq_hzmwz3f7kdhiaj4enlxha1_c0q0yu8tnf_'nf7c1sks8rzgxhw83vjq0s76xhrvppbgn_Slr90h5su3zokncwi2m_doi5t2p4vw6dryycyhtl6eujb1ta26752ta7hr19d9vceq_Rqk8tsy_vuxwglitt4u25zfhj5q_M4j7tjk9cryvqn8101u5h646p_Ztzwr09t8ckxx3hbsl6r7dqv7qxmnwt_;u7r3e9trqqkmdj5tlx_apoj0ngpcqy6r7t8gw9_e2wtyw9oyve8uxlf_C8tpo3hlb3_gxji2n2nl4_ kwft9p_maxcdzat5e_rcy28c360mmndp8ksxh_pegqkkuur3_Gh6f8pheo0nn2_xu6yjdx_iz538jwkbwuh4ge7ymj_f3eytt6khltgxj13itedbz_Jlgk_knskybpe8n69a_llnv_tuxgkxc_nod5ob3cft_Oij0a222q3_Q6af_Uc5x_Xzjn_z6iq".split`_`)if(~v.slice(1).match(/.../g).indexOf(h.toString(36).slice(-3)))return v[0];return"@"}

Verwendet eine Golf-Version des hier gefundenen Javascript-String-Hashs . Der in der Tabelle gespeicherte tatsächliche Hash (diese lange Zeichenfolge) nimmt den Absolutwert des von dieser Methode erzeugten Hashs, konvertiert ihn in base-36 und löscht alle Ziffern mit Ausnahme der drei niedrigstwertigen Ziffern.

SuperJedi224
quelle
1
Soweit ich das beurteilen kann, werden Sie nach {erstem Zeichen, letztem Zeichen, Länge} gehasht und verwenden dann eine große Nachschlagetabelle? Das macht Sinn, aber ich denke, Sie könnten einige Verbesserungen vornehmen: Es gibt einige doppelte Einträge in der Tabelle, und Sie könnten eine Menge Platz sparen, indem Sie die Einträge für @aus der Tabelle entfernen und nur die Standardeinstellung für @die Eingabe verwenden wird nicht gefunden.
2
cavewomanund chameleonhaben die gleichen ersten Zeichen, letzten Zeichen und Länge, das kann ein Problem sein?
Arnaud
1
split("_")kann split backtick werden _ backtick
user2428118
@ SuperChafouin Behoben.
SuperJedi224
1
@ SuperJedi224 Es gibt andere: Cyclopsund Croesus, baluchitheriumund baby long worm, crocodileund centipede, und 24 mehr
Arnaud
1

Python 3, 1915 - 1900 Bytes

Änderungsprotokoll:

  • Arbeit mit und Ausgabe von ASCII-Code anstelle des Zeichens selbst (15 Byte gespeichert)

Übergebe den Monsternamen als erstes Kommandozeilenargument und erhalte das Zeichen auf stdout.

import sys
D=b'`"\x08\x04\x02&@Yx\xf6\x90a\x00Z\x00\x00c\x00X\x00\x00f\x00z\x00\x00hS\x12\x06\t@PSTft?z\x0fnK\nH\x87\xa2ig\t\t\x12 &;@FZkoq\x05\xfc~?\x1b\x80\xc2,z\r\xf3Y\x141\x9cS\x10\x80jU\x06\x08\t&;@BKpqr\x9f\xbe\xbb\xf9O\xcde\x03!kK\x11\x07\x07&:@WYsu\x1boDv\xc9i\x90lS$\x06\r@Sdirw\x1f\x1d\x198\xb3\xb2\x91\x0fm\xa5\x03A@mB#\x07\x07@GPWdiv\x7f;n\xb3Bk\xa5ng\x07\x0c\x16&@EHSVcdfqru\x01\xfen\x83q\xd8\xf3\x1c.\xe5\xac^\x87\t\xaaT\xd4D\x9c\xe1*Io;\x03\x05\x06@desu\x01\xf7\x95R0\x88pc \x08\n:@KMNknq\xfd\xfe\ru\xb2z\xea\\\x9b\x05qC\x08\x07\x06&@AGOfhy\xe2\xbbA\xf2ArS\x1e\x08\x08&@JVYdfi_\x1c\xd8/k\x89\xa8\xe0sw\x08\x0b\x1c&;@Kdfhijou\t\xe0[# \\\x9a\xd3F(L\xfapM\tp\xa8t\xccp\x8d\x11e+\x05\x0c\x8a\x08t+)\x04\x02@PQT\xf2\x94uG\x1c\x06\t&@Uilq\x0f\ryl\xc4`\xa5\x10\x90v\x85\r\x0e$&:@FKLNORSWYry\x9f\x97\xf8\xae\xb8\xdf\xdd\xc1\xcdl\xb2\xc9L|\xbb;\x92\xb8j\xb0\xa99\xdd\x9c\xb8\xd0\x8bh\x95\x88T\xb3;1\xb6\x0bwb\x06\x0c\x11&:;@DGHOVhkm\x02\xfe\x8fO{\xd9u\xac&\xd7\x90\x9fe\xc0\xf44GxW\x07\x07\x0bADHScdv?>\xdd<:\xb7s.\x8cI\x07yR\x07\x07\t&:@bcht;Zx\x16sO\x8d\xab\xc3ze\x0b\x08\x14&@ABCaqs\x01}\xbe=\x15\xc6\xcdL\xa1\xc8\x9e.\xf7\x02\xc1Xq4\x99\t{G\x16\x06\t@Faefg\x1f\x9bU$2P`\xa8\x80|G\x15\x06\x07&\';@Go\x1c1\\\xa7*\x0bS}s\x06\n" &@AHLYZdh\xf6\x1e\t\xb93N2\xc27\xd6\xd8\xd8*\xe5L\xa3\xa4f\x860A\xfa:7.\xdd\x9b)\xb80\x85\xc4\xb4\x83~W\x0e\x07\r&:@ERbd>\x1b\xda\x15\xd4\x92\x0eM\xacJH\x04c\x7fG\x00\x06\x08:@dghx\x1f\xbc\xf4Z\xa1%\xd3C'
R=range
N=sys.argv[1].lower()
B=0
for c in N:B|=ord(c)&0x7f;B<<=7
B%=2**62-1
P=N.split()
F=ord(P[-1][0])^(ord(P[-1][1])>>2)
while D:
 f=D[0];ik,j,h,n=D[1:5];i=ik>>4;k=ik&15;D=D[5:];c=D[:h];m=D[h:h+n];m=int.from_bytes(m,"big");s=1;C=j;b=(h-1).bit_length()
 for x in R(i-1):s<<=k;s|=1
 s<<=j;z=(B&s)>>j;x=0;u=1
 for y in R(i):x<<=1;x|=bool(z&u);u<<=k
 if f!=F:D=D[h+n:];continue
 while m:
  if m&(2**i-1)==x:m>>=i;C=c[m&(2**b-1)];break
  m>>=b+i
 break
print(C)

Als ich die Frage las, dachte ich "Ich muss das komprimieren". Der erste Schritt bestand darin, alle Namen in Kleinbuchstaben zu schreiben.

Als ich mir die Daten ansah, hatte ich das Gefühl, dass die Verwendung des ersten Buchstabens des letzten Wortes den Trick als grobe erste Vermutung, welche Buchstaben das Monster haben könnte, tun sollte. Wie sich herausstellte, war das eine starke anfängliche Vermutung. Die folgende Tabelle enthält "erstes Zeichen des letzten Wortes", "Anzahl der Treffer" und "Monsterzeichen":

 'd' (37) => & @ D L R d h
 'g' (31) =>   & ' : @ G H Z g o
 's' (30) =>   & : ; @ E F H K P S Y Z e k o s
 'm' (28) => & @ F H M Q R S Y i m q r
 'c' (24) => : @ A C H S b c d f s v
 'p' (20) => & ; @ P S c d f p u
 'w' (20) => @ G W d q r u w
 'a' (19) => & @ A L Y a t
 'h' (17) => & @ N U d f h i o u
 'l' (17) => : @ F G K L O V f h i k l q y
 'n' (15) => & : @ N W n
 't' (14) => @ H T f i q t
 'b' (14) => & @ B a b h q x
 'k' (13) => ; @ A G K O f h k
 'e' (12) => & ; @ E H e
 'o' (12) => & @ O P T Y o
 'z' ( 9) => Z z
 'v' ( 9) => & @ S V v
 'r' ( 8) => @ B q r
 'j' ( 8) => & ; J d f j
 'f' ( 6) => & F d h
 'i' ( 5) => & : D V i
 'u' ( 4) => o u
 'y' ( 3) => & @ Y
 'x' ( 2) => X x
 'q' ( 1) => i

Um die Streuung weiter zu verbessern, habe ich den Schlüssel leicht modifiziert, indem ich das zweite Zeichen des letzten Wortes, das zu Bits nach rechts verschoben ist, in das erste Zeichen XOR-verknüpft habe (nennen wir dieses Konstrukt first_key):

 '}' (29) =>   & @ A H L Y Z d h
 'v' (25) => & : @ F K L N O R S W Y r y
 'x' (25) => A D H S c d v
 's' (21) => & ; @ K d f h i j o u
 'p' (21) => : @ K M N k n q
 'z' (19) => & @ A B C a q s
 'n' (19) => & @ E H S V c d f q r u
 '|' (18) => & ' ; @ G o
 'l' (17) => @ S d i r w
 '~' (16) => & : @ E R b d
 '{' (15) => @ F a e f g
 'w' (14) => & : ; @ D G H O V h k m
 'i' (14) =>   & ; @ F Z k o q
 'j' (13) => & ; @ B K p q r
 'u' (12) => & @ U i l q
 'm' (12) => @ G P W d i v
 '\x7f' (11) => : @ d g h x
 'o' (11) => @ d e s u
 'h' (11) => @ P S T f t
 'y' (10) => & : @ b c h t
 'r' ( 9) => & @ J V Y d f i
 'k' ( 9) => & : @ W Y s u
 'a' ( 8) => Z
 'q' ( 7) => & @ A G O f h
 't' ( 6) => @ P Q T
 '`' ( 4) => & @ Y x
 'c' ( 1) => X
 'f' ( 1) => z

Wie Sie sehen, erhalten wir neun Namen, die nur mit diesen Informationen eindeutig zugeordnet werden können. Nett!

Jetzt musste ich die verbleibende Zuordnung finden. Zu diesem Zweck habe ich zunächst den vollständigen Namen (in Kleinbuchstaben) in eine Ganzzahl umgewandelt:

def name_to_int(name):
    bits = 0
    for c in name:
        bits |= ord(c) & 0x7f
        bits <<= 7
    return bits

Dies verkettet einfach die 7-Bit-ASCII-Werte der Namen zu einer riesigen Ganzzahl. Wir nehmen dieses Modulo 4611686018427387903(2⁶²-1) für die nächsten Schritte.

Jetzt versuche ich, eine Bitmaske zu finden, die eine Ganzzahl ergibt, die wiederum die verschiedenen Monstercharaktere gut unterscheidet. Die Bitmasken bestehen aus gleichmäßig verteilten (wie z. B. 101010101oder 1000100010001) und werden durch die Anzahl der Bits ( i>=1) und die Spreizung ( k>=1) parametrisiert . Außerdem werden die Masken um bis zu 32*iBits nach links verschoben . Diese werden mit dem ganzzahligen Namen UND-verknüpft und die resultierende Ganzzahl wird als Schlüssel in einem Mapping verwendet. Die beste (durch i*number_of_mapping_entries) konfliktfreie Zuordnung wird verwendet.

Die ganzen Zahlen , die aus AND-ing der Maske und des integerised Namen verschoben zurück von jBits und gestrippt ihrer Nullen (wir speichern i, kund jzusammen mit der Zuordnung der Lage sein , das zu rekonstruieren), viel Platz zu sparen.

Jetzt haben wir also eine zweistufige Zuordnung: Von first_keyzur Hashmap, und die Hashmap ordnet den vollständigen Namen dem Monstercharakter eindeutig zu. Wir müssen das irgendwie speichern. Jeder Eintrag des Top-Level-Mappings sieht folgendermaßen aus:

Row = struct.Struct(
    ">"
    "B"  # first word char
    "B"  # number of bits (i) and bit spacing (k)
    "B"  # shift (j) or character to map to if i = 0
    "B"  # number of monster characters
    "B"  # map entry bytes
)

gefolgt von den Monster-Charakteren und dem Mapping der zweiten Ebene.

Die Zuordnung der zweiten Ebene wird serialisiert, indem sie in eine große Ganzzahl gepackt und in Bytes konvertiert wird. Jeder Wert und jeder Schlüssel wird nacheinander in die Ganzzahl verschoben, wodurch die Zuordnung rekonstruierbar wird (die Anzahl der Bits pro Schlüssel / Wert ist aus der Anzahl der Zeichen ableitbar und ibeide im Zeileneintrag gespeichert).

Wenn ein Eintrag nur ein einziges mögliches Monsterzeichen enthält, auf das eine Zuordnung erfolgen kann, iist der Wert Null, und die Anzahl der Zeichen und die Zuordnung sind ebenfalls null Byte. Das Zeichen wird dort gespeichert, wo jes normalerweise gespeichert werden würde.

Die vollständigen Daten haben eine Größe von 651 Byte und sind als Python-Byte-Zeichenfolge mit 1426 Byte serialisiert.

Das Dekodierungsprogramm macht es im Wesentlichen umgekehrt: Zuerst extrahiert es first_keydie Daten und sucht in den Daten nach dem entsprechenden Eintrag. Dann berechnet es den Hash des Namens und durchsucht die Hashmap nach dem entsprechenden Eintrag.

Unverdeckter Decoder

#!/usr/bin/python3
import sys
import math

data = b'`"\x08\x04\x02&@Yx\xf6\x90a\x00Z\x00\x00c\x00X\x00\x00f\x00z\x00\x00hS\x12\x06\t@PSTft?z\x0fnK\nH\x87\xa2ig\t\t\x12 &;@FZkoq\x05\xfc~?\x1b\x80\xc2,z\r\xf3Y\x141\x9cS\x10\x80jU\x06\x08\t&;@BKpqr\x9f\xbe\xbb\xf9O\xcde\x03!kK\x11\x07\x07&:@WYsu\x1boDv\xc9i\x90lS$\x06\r@Sdirw\x1f\x1d\x198\xb3\xb2\x91\x0fm\xa5\x03A@mB#\x07\x07@GPWdiv\x7f;n\xb3Bk\xa5ng\x07\x0c\x16&@EHSVcdfqru\x01\xfen\x83q\xd8\xf3\x1c.\xe5\xac^\x87\t\xaaT\xd4D\x9c\xe1*Io;\x03\x05\x06@desu\x01\xf7\x95R0\x88pc \x08\n:@KMNknq\xfd\xfe\ru\xb2z\xea\\\x9b\x05qC\x08\x07\x06&@AGOfhy\xe2\xbbA\xf2ArS\x1e\x08\x08&@JVYdfi_\x1c\xd8/k\x89\xa8\xe0sw\x08\x0b\x1c&;@Kdfhijou\t\xe0[# \\\x9a\xd3F(L\xfapM\tp\xa8t\xccp\x8d\x11e+\x05\x0c\x8a\x08t+)\x04\x02@PQT\xf2\x94uG\x1c\x06\t&@Uilq\x0f\ryl\xc4`\xa5\x10\x90v\x85\r\x0e$&:@FKLNORSWYry\x9f\x97\xf8\xae\xb8\xdf\xdd\xc1\xcdl\xb2\xc9L|\xbb;\x92\xb8j\xb0\xa99\xdd\x9c\xb8\xd0\x8bh\x95\x88T\xb3;1\xb6\x0bwb\x06\x0c\x11&:;@DGHOVhkm\x02\xfe\x8fO{\xd9u\xac&\xd7\x90\x9fe\xc0\xf44GxW\x07\x07\x0bADHScdv?>\xdd<:\xb7s.\x8cI\x07yR\x07\x07\t&:@bcht;Zx\x16sO\x8d\xab\xc3ze\x0b\x08\x14&@ABCaqs\x01}\xbe=\x15\xc6\xcdL\xa1\xc8\x9e.\xf7\x02\xc1Xq4\x99\t{G\x16\x06\t@Faefg\x1f\x9bU$2P`\xa8\x80|G\x15\x06\x07&\';@Go\x1c1\\\xa7*\x0bS}s\x06\n" &@AHLYZdh\xf6\x1e\t\xb93N2\xc27\xd6\xd8\xd8*\xe5L\xa3\xa4f\x860A\xfa:7.\xdd\x9b)\xb80\x85\xc4\xb4\x83~W\x0e\x07\r&:@ERbd>\x1b\xda\x15\xd4\x92\x0eM\xacJH\x04c\x7fG\x00\x06\x08:@dghx\x1f\xbc\xf4Z\xa1%\xd3C'


def name_to_int(name):
    bits = 0
    for c in name:
        bits |= ord(c) & 0x7f
        bits <<= 7
    return bits


def make_mask(nbits, k):
    mask = 1
    for i in range(nbits-1):
        mask <<= k
        mask |= 1
    return mask


def collapse_mask(value, nbits, k):
    bits = 0
    shift = 0
    for i in range(nbits):
        bits <<= 1
        bits |= bool(value & (1<<shift))
        shift += k
    return bits


name = sys.argv[1].casefold()
last_word = name.split()[-1]
last_word_char = chr(ord(last_word[0]) ^ (ord(last_word[1]) >> 2))
while data:
    first_char = chr(data[0])
    ik, j, nchars, nbytes = data[1:5]

    i = ik >> 4
    k = ik & 15

    data = data[5:]
    if first_char != last_word_char:
        # skip this entry
        data = data[nchars+nbytes:]
        continue

    chars, mapping = data[:nchars], data[nchars:nchars+nbytes]
    result = j
    if i == 0:
        break

    mapping = int.from_bytes(mapping, "big")

    name_bits = name_to_int(name) % (2**62-1)
    mask = make_mask(i, k) << j
    key = collapse_mask((name_bits & mask) >> j, i, k)
    bits_per_key = i
    key_mask = 2**(bits_per_key)-1
    bits_per_value = math.ceil(math.log(len(chars), 2))
    value_mask = 2**(bits_per_value)-1
    while mapping:
        if mapping & key_mask == key:
            mapping >>= bits_per_key
            result = chars[mapping & value_mask]
            break
        mapping >>= bits_per_value+bits_per_key

    break
print(chr(result))

Analyse-Tool

Dies ist das Tool, das ich erstellt und verwendet habe, um die Daten zu generieren - lesen Sie auf eigenes Risiko:

#!/usr/bin/python3
import base64
import collections
import math
import json
import struct
import zlib

data = json.load(open("data.json"))

reverse_pseudomap = {}
forward_pseudomap = {}
forward_info = {}
reverse_fullmap = {}
hits = collections.Counter()
monster_char_hitmap = collections.Counter()

for name, char in data.items():
    name = name.casefold()
    parts = name.split()
    monster_char_hitmap[char] += 1

    # if len(parts) > 1:
    #     key = first_char + parts[0][0]
    # else:
    #     key = first_char + last_part[1]

    key = chr(ord(parts[-1][0]) ^ (ord(parts[-1][1]) >> 2))
    # key = parts[-1][0]

    hits[key] += 1
    reverse_pseudomap.setdefault(char, set()).add(key)
    forward_pseudomap.setdefault(key, set()).add(char)
    forward_info.setdefault(key, {})[name] = char
    reverse_fullmap.setdefault(char, set()).add(name)


for char, hit_count in sorted(hits.items(), key=lambda x: x[1], reverse=True):
    monsters = forward_pseudomap[char]
    print(" {!r} ({:2d}) => {}".format(
        char,
        hit_count,
        " ".join(sorted(monsters))
    ))


def make_mask(nbits, k):
    mask = 1
    for i in range(nbits-1):
        mask <<= k
        mask |= 1
    return mask


def collapse_mask(value, nbits, k):
    bits = 0
    shift = 0
    for i in range(nbits):
        bits <<= 1
        bits |= bool(value & (1<<shift))
        shift += k
    return bits


def expand_mask(value, nbits, k):
    bits = 0
    for i in range(nbits):
        bits <<= k
        bits |= value & 1
        value >>= 1
    return bits


assert collapse_mask(expand_mask(0b110110, 6, 3), 6, 3)
assert expand_mask(collapse_mask(0b1010101, 7, 3), 7, 3)


def name_to_int(name):
    # mapped_name = "".join({"-": "3", " ": "4"}.get(c, c) for c in name)
    # if len(mapped_name) % 8 != 0:
    #     if len(mapped_name) % 2 == 0:
    #         mapped_name += "7"
    #     mapped_name = mapped_name + "="*(8 - (len(mapped_name) % 8))
    # print(mapped_name)
    # return base64.b32decode(
    #     mapped_name,
    #     casefold=True,
    # )

    bits = 0
    for c in name:
        bits |= ord(c) & 0x7f
        bits <<= 7
    return bits


compressed_maps = {}
max_bit_size = 0
nmapentries = 0


for first_char, monsters in sorted(forward_info.items()):
    monster_chars = forward_pseudomap[first_char]
    print("trying to find classifier for {!r}".format(first_char))
    print("  {} monsters with {} symbols".format(
        len(monsters),
        len(monster_chars))
    )
    bits = math.log(len(monster_chars), 2)
    print("  {:.2f} bits of clever entropy needed".format(
        bits
    ))

    bits = math.ceil(bits)

    int_monsters = {
        name_to_int(name): char
        for name, char in monsters.items()
    }

    reverse_map = {}
    for name, char in int_monsters.items():
        reverse_map.setdefault(char, set()).add(name)

    solution = None
    solution_score = float("inf")

    if bits == 0:
        char = ord(list(int_monsters.values())[0][0])
        solution = 0, 0, char, {}

    for i in range(bits, 3*bits+1):
        print("  trying to find solution with {} bits".format(i))
        for k in [2, 3, 5, 7, 11]:
            mask = make_mask(i, k)
            for j in range(0, 32*bits):
                bucketed = {}
                for int_name, char in int_monsters.items():
                    bucket = (int_name % (2**62-1)) & mask
                    try:
                        if bucketed[bucket] != char:
                            break
                    except KeyError:
                        bucketed[bucket] = char
                else:
                    new_solution_score = i*len(bucketed)
                    if new_solution_score < solution_score:
                        print("   found mapping: i={}, k={}, j={}, mapping={}".format(
                            i, k, j, bucketed
                        ))
                        solution = i, k, j, bucketed
                        solution_score = new_solution_score
                mask <<= 1

    if solution is not None:
        print("  solution found!")

    chars = "".join(sorted(set(int_monsters.values())))
    i, k, j, mapping = solution

    # sanity check 1
    if i > 0:
        mask = make_mask(i, k) << j
        for int_name, char in int_monsters.items():
            key = (int_name % (2**62-1)) & mask
            assert mapping[key] == char

    compressed_mapping = {}
    for hash_key, char in mapping.items():
        hash_key = collapse_mask(hash_key >> j, i, k)
        max_bit_size = max(hash_key.bit_length(), max_bit_size)
        compressed_mapping[hash_key] = chars.index(char)

    nmapentries += len(compressed_mapping)
    compressed_maps[first_char] = i, k, j, chars, compressed_mapping

    print(" ", compressed_maps[first_char])

    print()

print("max_bit_size =", max_bit_size)
print("nmapentries =", nmapentries)

print("approx size =", (1+math.ceil(max_bit_size/8))*nmapentries)


# first we need to map first word chars to compressed mappings
Row = struct.Struct(
    ">"
    "B"  # first word char
    "B"  # number of bits (i) and bit spacing (k)
    "B"  # shift (j) or character to map to if i = 0
    "B"  # number of characters
    "B"  # map entry bytes
)


def map_to_bytes(i, nchars, mapping):
    bits_per_value = math.ceil(math.log(nchars, 2))
    bits_per_key = i

    bits = 0
    # ensure that the smallest value is encoded last
    for key, value in sorted(mapping.items(), reverse=True):
        assert key.bit_length() <= bits_per_key
        assert value.bit_length() <= bits_per_value

        bits <<= bits_per_value
        bits |= value
        bits <<= bits_per_key
        bits |= key

    return bits.to_bytes(math.ceil(bits.bit_length() / 8), "big")


def bytes_to_map(i, nchars, data):
    data = int.from_bytes(data, "big")

    bits_per_value = math.ceil(math.log(nchars, 2))
    bits_per_key = i
    key_mask = 2**(bits_per_key)-1
    value_mask = 2**(bits_per_value)-1

    mapping = {}
    while data:
        key = data & key_mask
        data >>= bits_per_key
        value = data & value_mask
        data >>= bits_per_value
        assert key not in mapping
        mapping[key] = value

    return mapping


parts = bytearray()
for first_char, (i, k, j, chars, mapping) in sorted(compressed_maps.items()):
    raw_data = map_to_bytes(i, len(chars), mapping)
    recovered_mapping = bytes_to_map(i, len(chars), raw_data)
    assert recovered_mapping == mapping, "{}\n{}\n{}\n{} {}".format(
        mapping,
        recovered_mapping,
        raw_data,
        i, len(chars),
    )
    assert len(raw_data) <= 255

    print(" {!r} => {} {} {} {} {}".format(
        first_char,
        i, k, j,
        len(chars),
        raw_data
    ))

    assert k <= 15
    assert i <= 15

    if i == 0:
        chars = ""

    row = Row.pack(
        ord(first_char),
        (i << 4) | k, j,
        len(chars),
        len(raw_data),
    )
    row += chars.encode("ascii")
    row += raw_data
    parts.extend(row)

parts = bytes(parts)
print(parts)
print(len(parts))
print(len(str(parts)))
print(len(str(zlib.compress(parts, 9))))

Testfahrer

#!/usr/bin/python3
import json
import subprocess
import sys

with open("data.json") as f:
    data = json.load(f)

for name, char in data.items():
    stdout = subprocess.check_output(["python3", sys.argv[1], name])
    stdout = stdout.decode().rstrip("\n")
    if char != stdout:
        print("mismatch for {!r}: {!r} != {!r}".format(
            name, char, stdout
        ))
Jonas Schäfer
quelle
0

awk 73 + 2060 bytes

s{while(!(i=index(s,$0)))sub(/.$/,"");print substr(s,i+length(),1)}{s=$0}

Die Daten wurden dazu aufbereitet:

  "Aleax": "A",            Al A     # first of alphabet truncate to len=1
  "Angel": "A",            An A
  "Arch Priest": "@",      Arch @   # this needs to come
  "Archon": "A",           Archo A  # before this
  "Ashikaga Takauji": "@", Ash @
  "Asmodeus": "&",         Asm &

(2060 Zeichen) dh. zu kürzester eindeutiger Zeichenfolge mit dem an den Namen angehängten Monsterzeichen und schließlich zu dieser Form:

AlAAnAArch@ArchoAAsh@Asm&

(Am Anfang der Zeichenfolge muss ein Fallback-Zeichen stehen, um eine Nichtübereinstimmung zu kennzeichnen.) Bei der Suche nach einer Übereinstimmung wird der Name vom Ende an durch das Zeichen gekürzt, bis eine Übereinstimmung vorliegt, und das nächste Zeichen nach der Übereinstimmung wird zurückgegeben :

$ cat monster
Aleax
$ awk -f program.awk monsters_string monster
A

Ich kann immer noch ein paar Bytes von der Monsterschnur entfernen, wenn ich etwas organisiere:

AAnArch@ArchoAsh@Asm&

Wenn man bedenkt, wie groß die Daten mit Monsternamen sind, die mit A38 Bytes beginnen, bedeutet dies, dass die Datengröße im Durchschnitt von 2060 auf 1193 gesunken ist.

Dies ist noch in Arbeit und der Monster-String wird etwas später veröffentlicht.

James Brown
quelle