Leet nach Englisch Übersetzung

23

Ihre Herausforderung besteht darin , ein Programm zu schreiben, mit dem Sie (Englisch) leetspeak / lolspeak / txtspk in normales Englisch übersetzen können. Ihr Programm sollte von der Standardeingabe und -ausgabe zur Standardausgabe lesen, es sei denn, Ihre Sprache unterstützt diese nicht.

Sie können eine Datei verwenden, die eine Liste von Wörtern in englischer Sprache enthält, die durch neue Zeilen getrennt sind. Es sollte aufgerufen werden Wund befindet sich im selben Verzeichnis wie Ihr Programm. (Auf GNU / Linux-Systemen und möglicherweise auch auf anderen können Sie Weinen Link /usr/share/dict/wordserstellen.) Die Liste muss nicht nur aus Kleinbuchstaben bestehen, sondern kann auch verwendet werden, um zu bestimmen, ob Wörter Großbuchstaben enthalten sollen.

Dies basiert auf einer jetzt gelöschten Frage von Nikos M., die hier zu finden ist . Dies ist kein Duplikat, da diese ursprüngliche Frage geschlossen wurde und keine Antworten erhielt, da es kein Gewinnkriterium gab und der Benutzer nicht bereit war, eine Frage einzutragen.

Wertung

Die Wertung ist etwas kompliziert!

Dein Ergebnis ist

(leet items + bonuses) * 10 / (code length)

Höchste Punktzahl gewinnt.

Ihr Programm muss nicht perfekt sein und kann es wahrscheinlich auch nicht, aber je genauer es ist, desto mehr Boni erhält es!

Da $kann beides heißen sund S, Sie erhalten einen Bonus von 5 Punkten pro Leet Item für die Entscheidung, ob es einen Großbuchstaben haben soll (dh Großbuchstaben am Satzanfang).

Für das Implementieren von Eigennamen (Wörter, die immer Großbuchstaben haben) erhalten Sie einen weiteren Bonus von 5 Punkten pro Leet Item - so wie dies funktioniert, würden Sie die Wortliste durchsehen und die Ausgabe aktivieren, wenn nur eine großgeschriebene Version in der vorhanden ist Liste, und wenn beide Versionen vorhanden sind, raten Sie einfach.

Wenn ein Charakter zwei Bedeutungen hat (z. B. oder 1bedeuten kann ), erhalten Sie 20 Punkte pro Leet-Element, wenn Sie nur die Übersetzungen des Elements auswählen, die echte englische Wörter ergeben - verwenden Sie dazu die Wortliste. Wenn mehr als eine Übersetzung eines Leet-Artikels ein echtes englisches Wort ergibt, können Sie beliebig eine der gültigen Übersetzungen auswählen und erhalten trotzdem den Bonus.LI

Liste von Leet

Dies sind die Leet-Elemente, die Sie implementieren können. Sie müssen nicht alle implementieren, aber je mehr Sie hinzufügen, desto mehr Punkte erhalten Sie.

Sie können niemals Punkte erzielen, indem Sie einen Gegenstand oder Charakter in sich selbst übersetzen. Diese Regel überschreibt alle Fehler, die ich in der Liste gemacht habe.

Es ist verlockend, ein einfaches troder zu tun s/.../.../g. Die eigentliche Herausforderung besteht darin, anhand der Wortliste zu bestimmen, welche der mehreren Bedeutungen richtig sein kann und welche nicht.

Leet Items (jedes von diesen addiert 1 zu leet itemsin der Formel)

$ -> s, S
(-> c, c
5 -> s, S
@ -> a, A
4 -> a, A
3 -> e, E
7 -> t, T
+ -> t, T
# -> h, H
die -> die
'd -> ed
pwnd -> pwned
pwnt -> pwned
k, K -> OK
kk -> OK
0 [Null] -> o, O
y, Y -> warum
4 -> für
txt -> text
dafuq -> was zum f ** k
/ \, ^ -> a, A
\ / -> v, V
d00d -> Alter
n00b -> newbie
\ / \ / -> w, W
8 -> b, B
| _ | -> u, u
| - | -> h, h
Я -> r, R
j00 -> du
joo -> du
vv, VV -> w, W
tomoz -> morgen
| <-> k, K
[), |) -> d, D
<3 -> Liebe
> <-> x, X
10100111001 -> leet (binäre Darstellung von 1337)
2 -> auch
ur, UR -> your, you (keine Notwendigkeit, zwischen den beiden richtig zu unterscheiden)
u, u -> du
8 -> -ate-, 8
x, X -> -ks -, - cks-
z, Z -> s, S
1 -> ich, ich, ich, ich
! -> ich, ich!
c, C -> siehe, C, Meer
b, B -> sei, B, Biene
[Akzentbuchstabe] -> [Nicht-Akzentbuchstabe] (Punktzahl 1 pro unterstütztem Akzentbuchstaben)
&, 7 -> und, anned, ant (kann in der Mitte eines Wortes verwendet werden)

Härtere „Leet“: Score 30 Punkte für leet itemsjeden

!!! 1 !! 1-> !!!!!!! (Einsen in eine Folge von Einsen in Einsen übersetzen)
!!! eins! -> !!!!!
! elf-> !!!

Beispiele

Dies sind Beispiele dafür, was ein Programm, das alle oben genannten Leet-Zeichen und einige der Boni implementiert, möglicherweise leisten kann:

Beispielsatz: |-|3 15 $|_|(# @ n00b=He is such a newbie

Leet-basierte Zensur: $#!+=s**t

Extreme Leet: \/\/ 1 |< 1 P 3 [) 1 A=Wikipedia

-xor Suffix: H4X0R=hacker

Extremeres Leet: @1\/\/4Y5 p0$+ ur n3VV qu35710nz 1n teh $&80x=Always post your new questions in the sandbox

Beispiel Scoring

Bash, 10 Zeichen, 3 Elemente, keine Boni:

tr 137 let

Dies punktet ( 1 * 3 ) * 10 / 10 = 3.

code-challenge string natural-language total menschlich
quelle
Tut mir leid, dass ich das nicht im Sandkasten gefunden habe, aber wenn Sie die Boni mit 10 multiplizieren, sind sie immer noch viel mehr wert als die Worte selbst. Ist das deine Absicht?
Martin Ender
@ m.buettner Es ist einfach mit troder zu bekämpfen s/.../.../g. Nur solche Dinge zu übersetzen, würde eine langweilige Herausforderung darstellen, daher müssen wir bessere Übersetzungen belohnen, die die Wortliste verwenden
Wäre eine lange Reihe von regulären Ausdrücken zulässig? Ich würde gerne sehen, ob es möglich (wenn auch schwierig) ist, dies auch in kontextbewusster Weise in den meisten regulären Ausdrücken zu tun. (Oder vielleicht ein sedDrehbuch.)
Isiah Meadows
Wenn ich ein sedSkript sage , meine ich mehr als eine einfache s/.../.../g, sondern eine Datei, die von sedselbst analysiert und ausgeführt wird . So knapp die Sprache auch ist, es könnte sich um eine anständige Golfsprache handeln ...
Isiah Meadows,
@impinball Regexes sind absolut in Ordnung, obwohl ich keine Ahnung habe, wie Sie die Wortliste öffnen und mit einer Regex-Sprache alleine analysieren würden. sedSkripte sind ebenfalls in Ordnung und könnten sehr interessant sein. Aufgrund der kurzen Substitutionssyntax könnten sie hier sehr gut funktionieren. Sie können sie möglicherweise aus der Wortliste lesen, entweder mit GNU-Erweiterungen oder sedals Teil eines größeren Bash-Programms

Antworten:

11

Javascript (49 + 5635) * 10/2174 = 26,14

Online Demo:

Die Option "Reales Wörterbuch" funktioniert bei Dropbox nicht, funktioniert jedoch, wenn sie auf einem echten Webserver ausgeführt wird. Getestet in Visual Studio Development Server und Google Chrome.

https://dl.dropboxusercontent.com/u/141246873/leettranslator/index.html

Ergebnis:

49 Leet Items = 49

Kapitalisierungsbonus = 5 * 49 = 245

Wörterbuchsuchbonus = 20 * 49 = 980

Ausrufezeichenbonus * 3 = 90 * 49 = 4410

(Leet Items + Boni) * 10 / (Codelänge)

(49 + 5635) * 10/2174 = 26,14

Code:

function IsInDict(e) { return W[e] } function translate(e) { words = e.split(" "); res = ""; for (var t in words) { ex = ""; function n(e, r, i) { var s = false; for (var o = 1; o <= e.length; o++) { var u = e.substring(0, o) === "!" || i; var a = et[e.substring(0, o)]; var f = e.substring(o); if (a) { s = true; if (f.length === 0) { if (u) { ex = r + a; words[t] = "" } } else n(f, r + a, u) } } if (i && !s && r) { ex = r; words[t] = e.split("").reverse().join("") } } n(words[t].split("").reverse().join(""), "", false); mes = []; function r(e, t) { for (var n = 1; n <= e.length; n++) { var i = tokens[e.substring(0, n)]; var s = e.substring(n); if (i) { mFound = true; if (s.length === 0) for (var o in i) { mes.push(t + i[o]) } else for (var o in i) r(s, t + i[o]) } } if (e.length > 1) r(e.substring(1), t + e.substring(0, 1)); else { mes.push(t + e) } } m = ""; if (words[t] !== "") { r(words[t].toLowerCase(), ""); if (mes.length === 1) m = mes[0]; else { sl = []; for (var i in mes) { if (IsInDict(mes[i].slice(-1) === "." ? mes[i].substring(0, mes[i].length - 1) : mes[i])) { sl.push(mes[i]) } } if (sl.length > 0) m = sl[0]; else m = mes[0] } if (res === "") { m = cap(m) } if (res.slice(-1) === ".") { m = cap(m) } } res += " " + m; if (ex !== "") res += ex } return res.trim() } function cap(e) { return e.charAt(0).toUpperCase() + e.slice(1) } tokens = { $: ["s"], "(": ["c"], 5: ["s"], "@": ["a"], 4: ["a", "for"], 3: ["e"], "+": ["t"], "#": ["h"], teh: ["the"], "'d": ["ed"], pwnd: ["pwned"], pwnt: ["pwned"], k: ["ok"], kk: ["ok"], 0: ["o"], y: ["why"], txt: ["text"], dafuq: ["what the f**k"], "/\\": ["a"], "^": ["a"], "\\/": ["v"], d00d: ["dude"], n00b: ["newbie"], "\\/\\/": ["w"], 8: ["b", "ate"], "|_|": ["u"], "|-|": ["h"], "Я": ["r"], j00: ["you"], joo: ["you"], vv: ["w"], tomoz: ["tomorrow"], "|<": ["k"], "[)": ["d"], "|)": ["d"], "<3": ["love"], "><": ["x"], 10100111001: ["leet"], 2: ["to", "too"], ur: ["your", "you're"], u: ["you"], x: ["ks", "cks"], z: ["s"], 1: ["i", "l"], "!": ["i"], c: ["see", "sea"], b: ["be", "bee"], "&": ["and", "anned", "ant"], 7: ["and", "anned", "ant", "t"] }; et = { eno: "!", nevele: "!!", 1: "!", "!": "!" }

Ungolfed:

            tokens={
            '$':['s'],'(':['c'],'5':['s'],'@':['a'],'4':['a','for'],'3':['e'],'+':['t'],'#':['h'],'teh':['the'],"'d":['ed'],'pwnd':['pwned'],
            'pwnt':['pwned'],'k':['ok'],'kk':['ok'],'0':['o'],'y':['why'],'txt':['text'],'dafuq':['what the f**k'],
            '/\\':['a'],'^':['a'],'\\/':['v'],'d00d':['dude'],'n00b':['newbie'],
            '\\/\\/':['w'],'8':['b','ate'],'|_|':['u'],'|-|':['h'],'Я':['r'],'j00':['you'],
            'joo':['you'],'vv':['w'],'tomoz':['tomorrow'],'|<':['k'],'[)':['d'],'|)':['d'],'<3':['love'],
            '><':['x'],'10100111001':['leet'],'2':['to','too'],'ur':["your","you're"],
            'u':['you'],'x':['ks','cks'],'z':['s'],'1':['i','l'],'!':['i'],'c':['see','sea'],
            'b':['be','bee'],'&':['and','anned','ant'],'7':['and','anned','ant','t']}
            var excTokens = {'eno':'!','nevele':'!!','1':'!','!':'!'}

            function IsInDict(word)
            {
                return (W[word]);
            }

            function translate(input) {
                var words = input.split(" ");
                var result = "";
                for (var i in words) {
                    var exclamations = "";
                    function parseExclamations(s, prev, exclamationFound) {
                        var matchFound = false;
                        for (var j = 1; j <= s.length; j++) {
                            var hasExclamation = (s.substring(0, j) === "!") || exclamationFound;
                            var currentToken = excTokens[s.substring(0, j)];
                            var remaining = s.substring(j);
                            if (currentToken) {
                                matchFound = true;
                                if (remaining.length === 0) {
                                    if (hasExclamation) {
                                        exclamations = prev + currentToken;
                                        words[i] = "";//word only had exclamations in it so dont parse the rest of it
                                    }
                                }
                                else
                                    parseExclamations(remaining, prev + currentToken, hasExclamation);
                            }
                        }
                        if (exclamationFound && !matchFound && prev) {
                            exclamations = prev;
                            words[i] = s.split("").reverse().join("");//reverse back again
                        }
                    }
                    var reverseWord = words[i].split("").reverse().join("");
                    parseExclamations(reverseWord, "", false);

                    var matches = []
                    function parse(s, prev) {
                        for (var j = 1; j <= s.length; j++) {
                            var currentTokenArray = tokens[s.substring(0, j)];
                            var remaining = s.substring(j);
                            if (currentTokenArray) {
                                matchFound = true;
                                if (remaining.length === 0)
                                    for (var k in currentTokenArray) {
                                        matches.push(prev + currentTokenArray[k]);
                                    }
                                else
                                    for (var k in currentTokenArray)
                                        parse(remaining, prev + currentTokenArray[k]);
                            }
                        }

                        if (s.length > 1)
                            parse(s.substring(1), prev + s.substring(0, 1));
                        else {
                            matches.push(prev + s);
                        }
                    }

                    var match = "";
                    if (words[i] !== "") {
                        parse(words[i].toLowerCase(), "");

                        //check the dictionary
                        if (matches.length === 1)
                            match = matches[0];
                        else {
                            var shortlist = [];
                            for (var j in matches) {
                                //check dictionary. allow for a full stop at the end of the word
                                var isInDict = IsInDict(matches[j].slice(-1) === "." ? matches[j].substring(0, matches[j].length - 1) : matches[j]);
                                if (isInDict) {
                                    shortlist.push(matches[j]);
                                }
                            }

                            if (shortlist.length > 0)
                                match = shortlist[0];
                            else
                                match = matches[0];
                        }
                        if (result === "") {
                            match = cap(match);
                        }
                        if (result.slice(-1) === ".") {
                            match = cap(match);
                        }
                    }
                    result += " " + match;

                    if (exclamations !== "")
                        result += exclamations;
                }

                return result.trim();
            }

            function cap(string) {
                return string.charAt(0).toUpperCase() + string.slice(1);
            }

Testergebnisse:

  • | - | 3 15 $ | _ | (# @ n00b ====> Er ist so ein Neuling
  • @ 1 // 4Y5 p0 $ + ur n3VV qu35710nz 1n teh $ & 80x ====> Veröffentlichen Sie Ihre neuen Fragen immer in der Sandbox
  • !!! 1 !! 1 ====> !!!!!!!
  • !!!eins! ====> !!!!!
  • ! elf ====> !!!
  • teh !!! 1 !! 1 ====> Die !!!!!!!
  • die !!! eine! ====> Die !!!!!
  • teh! elf ====> Die !!!
  • teh !!! 1 !! 1 ====> Die !!!!!!!
  • qu35710nz! 1! ====> Fragen !!!
  • +357 +357. 735+ ====> Test test. Prüfung
  • & 31! 73 # 4 (KER $ WR0 + 3 83773R L! K3 + #! 5 7 # @ N 2D @ Y ====> Und Elite-Hacker schrieben besser als heute

Anmerkungen:

Das Wörterbuch ist eine separate Javascript-Datei mit einem Objekt namens W, das alle Wörter enthält. Dies enthält nur die Wörter, die ich zum Ausführen der relevanten Tests benötige.

rdans
quelle
Wenn Sie das durch den Closure Compiler laufen lassen, sind es nur 1640 Zeichen, die Ihre Punktzahl auf 34 bringen.
AMK
Was macht diese Datei? dl.dropboxusercontent.com/u/141246873/leettranslator/… ist es nur um ein Wörterbuch aus dem Web zu bekommen? (dh kann das Programm ausgeführt werden, W.jswenn es entfernt wurde)
@professorfish das ist eine externe js lib mit einem Wörterbuch darin (Wörter bis zu zehn Buchstaben). Wird nur verwendet, wenn in der Demo die Option "Echtes Wörterbuch" ausgewählt ist. Es ist nur für eine Demo mit einem besseren Wörterbuch und nicht Teil meiner offiziellen Antwort.
rdans
6

Haskell - Score 1.421421421: (37 Elemente + (21 Boni (Großschreibung) * 5)) * 10 / (999 Byte)

Dies ist meine endgültige Antwort.

import System.Environment
import Text.Parsec
import Text.Parsec.String
s=string
r=return
t=try
o=oneOf
(>|)=(<|>)
a p l u=b[p]l u
b (p:q) l u=e(foldl(>|)(s p)$map(s)q)l u
c p l u=e(o p)l u
d p q=t$s p>>r q
e p l u=t$do{p;r l}>|do{s". ";p;r$". "++u}
f p q=t$do{between(t$s" ")(t$s" ")(o p);r q}
g::Parser String
g=do{s<-many$c"$5""s""S">|c"@4^""a""A">|c"3""e""E">|c"7+""t""T">|c"#""h""H">|d"teh""the">|d"'d""ed">|d"pwnd""pwned">|d"pwnt""pwned">|c"kK""ok""OK">|d"kk""OK">|d"n00b""newbie">|f"yY""why">|d"4""for">|d"txt""text">|d"dafuq""what the f**k">|b["\\/\\/","vv","VV"]"w""W">|a"/\\""a""A">|d"d00d""dude">|c"0""o""O">|a"\\/""v""V">|c"8""b""B">|a"|_|""u""U">|a"|-|""h""H">|c"Я""r""R">|b["j00","joo"]"you""you">|d"tomoz""tomorrow">|a"|<""k""K">|b["[)","|)"]"d""D">|d"<3""love">|a"><""x""X">|c"1!""i""I">|d"10100111001""leet">|c"2""too""to">|d"ur""your">|d"UR""you're">|f"uU""you">|c"xX""ks""cks">|d"&""and">|do{c<-anyChar;return [c]};return$concat s}
main=getArgs>>=putStrLn.show.(parse g"").concat

Tests

Wenn das Programm in eine Datei mit dem Namen kompiliert wird min-lt, können Sie das folgende Shell-Skript schreiben

#!/bin/bash
./min-lt "|-|3 15 $|_|(# @ n00b"
./min-lt "\$#!+"
./min-lt "\/\/ 1 |< 1 P 3 [) 1 A"
./min-lt "H4X0R"
./min-lt "@1\/\/4Y5 p0$+ ur n3VV qu35710nz 1n teh $&80x"
./min-lt "+357 +357. 735+"

was wird dies drucken

Right "he is su(h a newbie"
Right "shit"
Right "w i k i P e d i A"
Right "HaksoR"
Right "aiwaYs post your new questionz in the sandboks"
Right "test test. Test"
Gxtaillon
quelle
von -ks-ich meinte ksin der Mitte eines Wortes. Ich werde es mir ansehen, sobald ich einen Hashell-Compiler
Installieren Sie einfach das haskell-platformPaket. Haben Sie ein Beispiel dafür ks?
Gxtaillon
<insertnamehere> rocXoderroX
Ich habe es getestet, es funktioniert
1
Aktualisierte meine Antwort mit einer Punktzahl und einer besseren Handhabung der Wortübersetzung.
Gxtaillon
6

Extended BrainFuck : 0,6757

{a[-])&d}{c(-(-}{d)$t(-}:r:i:t$t,(-$i+$r+)$i($t 6+(-$i 5--)+$i 3+(--&c-(--
(3-(5-&c&c&c-&c--5-((-&d)$r.&d|"A"&a|"B"&a|"T"&a|"S"&a|"A"&a|"E"&a|"TO"&a
|"L"&a|"O"&a|"T"&a|"C"&a|"AND"&a|"S"&a|"H"&a|"I"(-))$i(-)$r(-)$t,(-$i+$r+))

Dies bedeutet also 15 Übersetzungen "$ (5 @ 437 + # 0821! &", Keine Boni und 222 Bytes (nicht erforderliche Zeilenvorschübe nicht enthalten). 15 * 10/222 = 0,6757

Verwendung: 

%> beef ebf.bf < leet.ebf > leet.bf
%> echo '& 31337 #4(KER$ WR0+3 83773R L!K3 +#!5 7#@N 2D@Y' | beef  leet.bf
AND ELEET HACKERS WROTE BETTER LIKE THIS THAN TODAY
%>

EBF ist nicht wirklich zum Golfen geeignet, aber die Rle-Funktion, die Makros und die Print-String-Funktion machen das Komprimieren etwas einfacher als BrainFuck. Das Ende der kompilierten BrainFuck-Binärdatei sieht folgendermaßen aus:

>>,[-<+<+>>]<[>++++++[-<------>]+<+++[--[-[--[--[---[-----[-[-[-[-[-[--[-[--------[[-]
>[-]<<.>]>[->++++++++[-<++++++++>]<+.[-]]<]>[->++++++++[-<++++++++>]<++.[-]]<]>[->++++
+++++[-<+++++++++>]<+++.[-]]<]>[->+++++++++[-<+++++++++>]<++.[-]]<]>[->++++++++[-<++++
++++>]<+.[-]]<]>[->++++++++[-<+++++++++>]<---.[-]]<]>[->+++++++++[-<+++++++++>]<+++.--
---.[-]]<]>[->++++++++[-<+++++++++>]<++++.[-]]<]>[->+++++++++[-<+++++++++>]<--.[-]]<]>
[->+++++++++[-<+++++++++>]<+++.[-]]<]>[->++++++++[-<++++++++>]<+++.[-]]<]>[->++++++++[
-<++++++++>]<+.+++++++++++++.----------.[-]]<]>[->+++++++++[-<+++++++++>]<++.[-]]<]>[-
>++++++++[-<+++++++++>]<.[-]]<]>[->++++++++[-<+++++++++>]<+.[-]]<[-]<[-]>>,[-<+<+>>]<]
Sylwester
quelle
1
Der kompilierte BF-Code scheint gut zu funktionieren, er sieht für ein BF-Programm ziemlich kurz aus
@professorfish Mit ~"OTLHEAND"Ich könnte alle Zeichen einmal für 107 Bytes Objektcode gemacht, anstatt sie von 0 jedes Mal mit 354 zu machen, aber meine Antwort ist für die EBF-Codegröße optimiert :)
Sylwester
2

Java: 1,236

import java.util.*;public class L{static H<String,String>c;static H<String,String>w;static{c=new H();c.p("1","i");c.p("!","i");c.p("$","s");c.p("5","s");c.p("@","a");c.p("4","a");c.p("3","e");c.p("7","t");c.p("+","t");c.p("#","h");c.p("'d","ed");c.p("0","o");c.p("zero","o");c.p("\\/\\/","w");c.p("/\\","a");c.p("\\/","v");c.p("|<","k");c.p("[)","d");c.p("8","b");c.p("|_|","u");c.p("|-|","h");c.p("Я","r");c.p("(","c");c.p("VV","w");c.p("&","and");c.p("2","to");w=new H();w.p("@","a");w.p("teh","the");w.p("pwnd","pwned");w.p("pwnt","pwned");w.p("k","ok");w.p("kk","ok");w.p("y","why");w.p("Y","why");w.p("4","for");w.p("txt","text");w.p("dafuq","what the f**k");w.p("d00d","dude");w.p("n00b","newbie");w.p("j00","you");w.p("joo","you");}public static void main(String[]a){System.out.println(new L().C(a));}String C(String[]o){String x=T(o);for(String d:o){if(w.containsKey(d))x=x.replace(d,w.get(d));else{String r=d;for(String y:c.keySet()){if(d.contains(y))r=r.replace(y,c.get(y));}x=x.replace(d,r);}}return x;}String T(String[]l){String s="";for(String w:l)s+=" "+w;return s;}}class H<T1,T2>extends LinkedHashMap<T1,T2>{T2 p(T1 k,T2 v){return super.put(k,v);}}

So macht es die folgenden Transformationen

+357 +357. 735+
test test. test
|-|3 15 $|_|(# @ n00b
he is such a newbie
$#!+
shit
\/\/ 1 |< 1 P 3 [) 1 A
w i k i P e d i A
@1\/\/4Y5 p0$+ ur n3VV qu35710nz 1n teh $&80x
aiwaYs post ur new questionz in the sandbox
& 31337 #4(KER$ WR0+3 83773R L!K3 +#!5 7#@N 2D@Y
and eieet hacKERs WRote betteR LiKe this thaN toDaY

Die Punkteberechnung ist schwierig

  • (Leet Items + Boni) * 10 / (Codelänge)
  • Codelänge = 1165 Leet
  • Leet Items = 39 (einzigartig)
  • Bonus = 21 (weiß nicht, wie man so kopierte MomemtumMori berechnet) (Bitte beraten)

((39 + (21 · 5)) · 10) / 1165 = 1,236

Code ohne Golf:

import java.util.*;

public class L {
    static H<String, String> c;
    static H<String, String> w;

    static {
        c = new H();
        c.p("1", "i");
        c.p("!", "i");
        c.p("$", "s");
        c.p("5", "s");
        c.p("@", "a");
        c.p("4", "a");
        c.p("3", "e");
        c.p("7", "t");
        c.p("+", "t");
        c.p("#", "h");
        c.p("'d", "ed");
        c.p("0", "o");
        c.p("zero", "o");
        c.p("\\/\\/", "w");
        c.p("/\\", "a");
        c.p("\\/", "v");
        c.p("|<", "k");
        c.p("[)", "d");
        c.p("8", "b");
        c.p("|_|", "u");
        c.p("|-|", "h");
        c.p("Я", "r");
        c.p("(", "c");
        c.p("VV", "w");
        c.p("&", "and");
        c.p("2", "to");
        w = new H();
        w.p("@", "a");
        w.p("teh", "the");
        w.p("pwnd", "pwned");
        w.p("pwnt", "pwned");
        w.p("k", "ok");
        w.p("kk", "ok");
        w.p("y", "why");
        w.p("Y", "why");
        w.p("4", "for");
        w.p("txt", "text");
        w.p("dafuq", "what the f**k");
        w.p("d00d", "dude");
        w.p("n00b", "newbie");
        w.p("j00", "you");
        w.p("joo", "you");
    }

    public static void main(String[] a) {
        System.out.println(new L().C(a));
    }

    String C(String[] o) {
        String x = T(o);
        for (String d : o) {
            if (w.containsKey(d)) x = x.replace(d, w.get(d));
            else {
                String r = d;
                for (String y : c.keySet()) {
                    if (d.contains(y)) r = r.replace(y, c.get(y));
                }
                x = x.replace(d, r);
            }
        }
        return x;
    }

    String T(String[] l) {
        String s = "";
        for (String w : l) s += " " + w;
        return s;
    }
}

class H<T1, T2> extends LinkedHashMap<T1, T2> {
    T2 p(T1 k, T2 v) {
        return super.put(k, v);
    }
}
Uday Shankar
quelle
2
Würde es Ihnen etwas ausmachen, das Golfspiel zu beenden? : D
Knerd
0

C # Score 45 * 10/2556 = 0,176

Das Programm kann fast alle Groß- und Kleinbuchstaben ausgeben. Da ich keine englische Wortliste verwende, wird der erste im Wörterbuch gefundene Schlüssel verwendet. ZB \ / \ / wird vav. Wenn char der erste Buchstabe eines Wortes ist, wird ToUpper angewendet.

using System;
using System.Collections.Generic;
class L
{
Dictionary<string, string> D;        
public L() 
{ 
D = new Dictionary<string, string>();
M();
}
public void M()
{
D.Add("$", "s,S");
D.Add("(", "c,C");
D.Add("5", "s,S");
D.Add("@", "a,A");
D.Add("4", "a,A,for");
D.Add("3", "e,E");
D.Add("7", "t,T,and,anned,ant");
D.Add("+", "t,T");
D.Add("#", "h,H");
D.Add("teh", "the");
D.Add("'d", "ed");
D.Add("pwnd", "pwned");
D.Add("pwnt", "pwned");
D.Add("k", "OK");
D.Add("K", "OK");
D.Add("kk", "OK");
D.Add("0", "o,O");
D.Add("y", "why");
D.Add("Y", "why");
D.Add("txt", "text");
D.Add("dafuq", "what the f**k");
D.Add("\\/\\/", "w,W");
D.Add("/\\", "a,A");
D.Add("^", "a,A");
D.Add("\\/", "v,V");
D.Add("d00d", "dude");
D.Add("n00b", "newbie");       
D.Add("8", "b,B,ate,8");
D.Add("|_|", "u,U");
D.Add("|-|", "h,H");
D.Add("j00", "you");
//Я      -> r,R
D.Add("joo", "you");
D.Add("vv", "w,W");
D.Add("VV", "w,W");
D.Add("tomoz", "tomorrow");
D.Add("|<", "k,K");
D.Add("[)", "d,D");
D.Add("|)", "d,D");
D.Add("<3", "love");
D.Add("><", "x,X");
D.Add("2", "to,too");
//10100111001       -> leet (binary representation of 1337)
D.Add("ur", "your,you're");
D.Add("UR", "your,you're");
D.Add("u", "you");
D.Add("U", "you");
D.Add("x", "ks,cks");
D.Add("X", "ks,cks");
D.Add("z", "s,S");
D.Add("Z", "s,S");
D.Add("1", "i,I,l,L");
D.Add("!", "i,I,!");
D.Add("c", "see,C,sea");
D.Add("C", "see,C,sea");
D.Add("b", "be,B,bee");
D.Add("B", "be,B,bee");
//[accented letter] -> [non-accented form] (score 1 per accented letter supported)
D.Add("&", "and,anned,ant");
}

int P(string K, out List<string> V)
{
V = new List<string>();
string v,comma=",";
if(D.TryGetValue(K,out v))
{
string[] vv = v.Split(comma.ToCharArray());
foreach(string s in vv)
{
V.Add(s);
}
}
return V.Count;
}

public string E(string X)
{
string e ="";
string S = " ",t,k="";
string[] W = X.Split(S.ToCharArray());
int n = 0,x=0,m=0;
List<string> V=new List<string>();
bool F = false;
foreach(string s in W)
{
n = s.Length;
F = false;
for (int i = 0; i < n; i++)
{
m = 0;
for (int j = 1; j < n - i+1; j++)
{
k = s.Substring(i, j);
x = P(k, out V);
if (x > 0)
{
t = V[0];
if (t.Length == 1 && i == 0)
t = t.ToUpper();
e += t;
m = t.Length;
F = true;
break;
}
}
if (m > 0) i += (m - 1);
}
e += S;
}
return e;
}
static void Main(string[] a)
{
string t = Console.ReadLine();
L x = new L();
t = x.E(t);
Console.WriteLine(t);
Console.ReadLine();
}
}

Hier ist meine Testausgabe:

$ -> S 
( -> C 
5 -> S 
@ -> A 
4 -> A 
3 -> E 
7 -> T 
+ -> T 
# -> H 
teh -> the 
'd -> ed 
pwnd -> pwned 
pwnt -> pwned 
k -> OK 
K -> OK 
0 -> O 
y -> why 
Y -> why 
4 -> A 
txt -> text 
dafuq -> what the f**k 
/\ -> A 
^ -> A 
\/ -> V 
d00d -> dude 
n00b -> newbie 
\/\/ -> Vav 
8 -> B 
|_| -> U 
|-| -> H 
j00 -> you 
joo -> you 
vv -> W 
VV -> W 
tomoz -> tomorrow 
|< -> K 
[) -> D 
|) -> D 
<3 -> love 
>< -> X 
2 -> to 
ur -> you 
UR -> you 
u -> you 
U -> you 
8 -> B 
x -> ks 
X -> ks 
z -> S 
Z -> S 
1 -> I 
! -> I 
c -> see 
C -> see 
b -> be 
B -> be
Bacchusbeale
quelle