Traducción de Leet a Inglés

23

Su desafío es escribir un programa para traducir (inglés) leetspeak / lolspeak / txtspk al inglés normal. Su programa debe leer desde la entrada y salida estándar hasta la salida estándar, a menos que su idioma no lo admita.

Puede usar un archivo que contenga una lista de palabras en inglés, separadas por nuevas líneas. Debe llamarse Wy se ubicará en el mismo directorio que su programa. (En los sistemas GNU / Linux y posiblemente en otros, puede hacer Wun enlace /usr/share/dict/words) La lista no tiene que estar en minúsculas, puede usarla para determinar si las palabras deben tener mayúsculas.

Esto se basa en una pregunta ahora eliminada publicada por Nikos M. que se puede encontrar aquí . Esto no es un duplicado ya que esta pregunta original se cerró y no recibió ninguna respuesta, porque no había un criterio ganador y el usuario no estaba dispuesto a poner una.

Tanteo

¡La puntuación es un poco complicada!

tu puntaje es

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

La puntuación más alta gana.

Su programa no tiene que ser y probablemente no pueda ser perfecto, pero cuanto más preciso sea, ¡más bonificaciones obtendrá!

Como $puede significar ambos sy S, obtienes una bonificación de 5 puntos por elemento leet para decidir si debe tener una letra mayúscula (es decir, letras mayúsculas al comienzo de las oraciones).

Obtiene una bonificación adicional de 5 puntos por elemento leet para implementar nombres propios (palabras que siempre tienen mayúsculas): la forma en que esto funciona es que miraría a través de la lista de palabras, haría que la salida en mayúscula si solo una versión en mayúscula está presente en el lista, y si ambas versiones están ahí, solo adivina.

Si un personaje tiene dos significados (por ejemplo, 1puede significar Lo I), obtienes 20 puntos por elemento leet por solo elegir aquellas traducciones del elemento que hacen palabras reales en inglés; usa la lista de palabras para esto. Si más de una traducción de un elemento leet hace una palabra real en inglés, puede elegir arbitrariamente una de las traducciones válidas y aún así obtener la bonificación.

Lista de Leet

Estos son los elementos de leet que puede implementar. No tiene que implementarlos todos, pero cuanto más agregue, más puntos obtendrá.

Nunca puedes ganar puntos traduciendo un elemento o personaje a sí mismo. Esta regla anula cualquier error que pueda haber cometido en la lista.

Es tentador hacer un simple tro s/.../.../g. El verdadero desafío es determinar cuál de los múltiples significados podría o no ser correcto, utilizando la lista de palabras.

Elementos de Leet (cada uno de estos agrega 1 a leet itemsen la fórmula)

$ -> s, S
(-> c, C
5 -> s, S
@ -> a, A
4 -> a, A
3 -> e, E
7 -> t, T
+ -> t, T
# -> h, H
teh -> el
'd -> ed
pwnd -> pwned
pwnt -> pwned
k, K -> OK
kk -> OK
0 [cero] -> o, O
y, Y -> por qué
4 -> para
txt -> texto
dafuq -> que carajo
/ \, ^ -> a, A
\ / -> v, V
d00d -> amigo
n00b -> novato
\ / \ / -> w, W
8 -> b, B
| _ | -> u, U
| - | -> h, H
Я -> r, R
j00 -> usted
joo -> tu
vv, VV -> w, W
tomoz -> mañana
| <-> k, K
[), |) -> d, D
<3 -> amor
> <-> x, X
10100111001 -> leet (representación binaria de 1337)
2 -> a, también
ur, UR -> tu, eres (no es necesario distinguir correctamente entre los dos)
u, U -> usted
8 -> -ate-, 8
x, X -> -ks -, - cks-
z, Z -> s, S
1 -> i, I, l, L
! -> i, yo ,!
c, C -> ver, C, mar
b, B -> ser, B, abeja
[letra acentuada] -> [forma no acentuada] (puntaje 1 por letra acentuada admitida)
&, 7 -> y, anned, hormiga (puede usarse en el medio de una palabra)

"Leet" más difícil: consigue 30 puntos por leet itemscada

!!! 1 !! 1-> !!!!!!! (traduzca 1 en una secuencia de! 's en!' s)
!!! uno! -> !!!!!
! once-> !!!

Ejemplos

Estos son ejemplos de lo que podría hacer un programa que implementa todos los caracteres anteriores y algunos de los bonos:

Oración de ejemplo: |-|3 15 $|_|(# @ n00b=He is such a newbie

Censura basada en Leet: $#!+=s**t

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

-xor sufijo: H4X0R=hacker

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

Ejemplo de puntuación

Bash, 10 personajes, 3 artículos, sin bonificaciones:

tr 137 let

Esto puntúa ( 1 * 3 ) * 10 / 10 = 3.

code-challenge string natural-language totalmente humano
fuente
Lo siento, no entendí esto en el sandbox, pero si estás multiplicando los bonos por 10, todavía valen mucho más que las palabras en sí. ¿Esa es tu intención?
Martin Ender
@ m.buettner Es para combatir simplemente usando tro s/.../.../g. Simplemente traducir cosas así supondría un desafío aburrido, por lo que debemos recompensar mejores traducciones que utilicen la lista de palabras
¿Sería permisible una larga serie de expresiones regulares? Me encantaría ver si fuera posible (aunque difícil) hacer esto incluso de una manera contextual en la mayoría de las expresiones regulares. (O tal vez un sedguión.)
Isiah Meadows
Cuando digo un sedscript, me refiero a algo más que simple s/.../.../g, sino un archivo que se analiza y ejecuta por sedsí mismo. Tan breve como es el idioma, podría ser un lenguaje jugable decente ...
Isiah Meadows
@impinball Las expresiones regulares están absolutamente bien, aunque no tengo idea de cómo abrirías la lista de palabras y la analizarías solo con un lenguaje de expresiones regulares. sedlos scripts también están bien y podrían ser muy interesantes, podrían funcionar muy bien en esto debido a la breve sintaxis de sustitución, es posible que pueda leer de la lista de palabras, ya sea con extensiones GNU o sedcomo parte de un programa Bash más grande

Respuestas:

11

Javascript (49 + 5635) * 10/2174 = 26.14

Demostración en línea:

La opción "Diccionario real" no funciona en el cuadro desplegable, pero funcionará si se ejecuta en un servidor web real. Probado en el servidor de desarrollo visual studio y google chrome.

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

Puntuación:

49 artículos leet = 49

Bonificación de capitalización = 5 * 49 = 245

bono de búsqueda de diccionario = 20 * 49 = 980

bono de exclamación * 3 = 90 * 49 = 4410

(artículos leet + bonos) * 10 / (longitud del código)

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

Código:

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: "!", "!": "!" }

Sin golf:

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

Resultados de la prueba:

  • | - | 3 15 $ | _ | (# @ n00b ====> Él es un novato
  • @ 1 // 4Y5 p0 $ + ur n3VV qu35710nz 1n teh $ & 80x ====> Siempre publique sus nuevas preguntas en el sandbox
  • !!! 1 !! 1 ====> !!!!!!!
  • !!!¡uno! ====> !!!!!
  • ! once ====> !!!
  • ¡¡¡¡¡¡¡¡¡1 !!! 1 ====> ¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡
  • te !!! uno! ====> El !!!!!
  • teh! once ====> El !!!
  • ¡¡¡¡¡¡¡¡¡1 !!! 1 ====> ¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡
  • qu35710nz! 1! ====> Preguntas !!!
  • +357 +357. 735+ ====> Prueba de prueba. Prueba
  • & 31! 73 # 4 (KER $ WR0 + 3 83773R L! K3 + #! 5 7 # @ N 2D @ Y ====> Y los hackers de élite escribieron mejor que hoy

Notas:

El diccionario es un archivo javascript separado con un objeto llamado W que contiene todas las palabras. Esto solo contiene las palabras que necesitaba para ejecutar las pruebas relevantes.

rdans
fuente
Si ejecuta eso a través del compilador de cierre, solo 1640 caracteres llevarán su puntaje a 34.
AMK
¿Qué hace este archivo? dl.dropboxusercontent.com/u/141246873/leettranslator/… ¿ es solo para obtener un diccionario de la web? (es decir, el programa puede ejecutarse W.jssi se elimina)
@professorfish que es una js lib externa con un diccionario (palabras de hasta diez letras). Solo se usa si la opción 'diccionario real' está seleccionada en la demostración. Es solo para una demostración con un mejor diccionario y no forma parte de mi respuesta oficial.
rdans
6

Haskell - Puntaje 1.421421421: (37 artículos + (21 bonos (capitalización) * 5)) * 10 / (999 bytes)

Esta es mi respuesta final.

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

Pruebas

Cuando el programa se compila en un archivo llamado min-lt, puede escribir el siguiente script de shell

#!/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+"

que imprimirá esto

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
fuente
por -ks-que me refería ksen el medio de una palabra.
Simplemente instale el haskell-platformpaquete. ¿Tienes un ejemplo para ks?
gxtaillon
<insertnamehere> rocXoroX
Lo he probado, está funcionando
1
Actualicé mi respuesta con una puntuación y un mejor manejo de la traducción de palabras.
gxtaillon
6

BrainFuck extendido : 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+))

Entonces esto hace 15 traducciones "$ (5 @ 437 + # 0821! &", Sin bonificaciones y tiene 222 bytes (no se incluyen avances de línea innecesarios). 15 * 10/222 = 0.6757

Uso: 

%> 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 en realidad no está hecho para jugar al golf, pero su función rle, macros y función de cadena de impresión hace que sea algo más fácil de comprimir que BrainFuck. El binario final compilado BrainFuck se ve así:

>>,[-<+<+>>]<[>++++++[-<------>]+<+++[--[-[--[--[---[-----[-[-[-[-[-[--[-[--------[[-]
>[-]<<.>]>[->++++++++[-<++++++++>]<+.[-]]<]>[->++++++++[-<++++++++>]<++.[-]]<]>[->++++
+++++[-<+++++++++>]<+++.[-]]<]>[->+++++++++[-<+++++++++>]<++.[-]]<]>[->++++++++[-<++++
++++>]<+.[-]]<]>[->++++++++[-<+++++++++>]<---.[-]]<]>[->+++++++++[-<+++++++++>]<+++.--
---.[-]]<]>[->++++++++[-<+++++++++>]<++++.[-]]<]>[->+++++++++[-<+++++++++>]<--.[-]]<]>
[->+++++++++[-<+++++++++>]<+++.[-]]<]>[->++++++++[-<++++++++>]<+++.[-]]<]>[->++++++++[
-<++++++++>]<+.+++++++++++++.----------.[-]]<]>[->+++++++++[-<+++++++++>]<++.[-]]<]>[-
>++++++++[-<+++++++++>]<.[-]]<]>[->++++++++[-<+++++++++>]<+.[-]]<[-]<[-]>>,[-<+<+>>]<]
Sylwester
fuente
1
El código BF compilado parece funcionar bien, parece bastante corto para un programa BF
@professorfish Usando ~"OTLHEAND"Podría hacer todos los caracteres una vez para el código de objeto de 107 bytes en lugar de hacerlos desde 0 cada vez usando 354, pero mi respuesta está optimizada para el tamaño del código EBF :)
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);}}

Entonces hace las siguientes transformaciones

+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

El cálculo del puntaje es complicado

  • (artículos leet + bonos) * 10 / (longitud del código)
  • longitud del código = 1165 leet
  • artículos leet = 39 (único)
  • bono = 21 (no sé cómo calcular MomemtumMori tan copiado) (Por favor avise)

((39 + (21 * 5)) * 10) / 1165 = 1.236

Código sin 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
fuente
2
¿Te importaría desentrañarlo? : D
Knerd
0

C # puntaje 45 * 10/2556 = 0.176

El programa puede generar casi todas las letras mayúsculas y minúsculas. Como no estoy usando una lista de palabras en inglés, se usa la primera clave encontrada en el Diccionario. Por ejemplo, \ / \ / se convierte en vav. Si char es la primera letra de una palabra, se aplica ToUpper.

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

Aquí está mi salida de prueba:

$ -> 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
fuente