Tradução Leet para Inglês

23

Seu desafio é escrever um programa para traduzir (inglês) leetspeak / lolspeak / txtspk para o inglês normal. Seu programa deve ler de entrada e saída padrão para saída padrão, a menos que seu idioma não os suporte.

Você pode usar um arquivo que contém uma lista de palavras no idioma inglês, separadas por novas linhas. Ele deve ser chamado We estará localizado no mesmo diretório do seu programa. (Nos sistemas GNU / Linux e possivelmente em outros, você pode criar Wum link para /usr/share/dict/words) A lista não precisa estar em letras minúsculas, você pode usá-lo para determinar se as palavras devem ter letras maiúsculas.

Isso se baseia em uma pergunta agora excluída postada por Nikos M., que pode ser encontrada aqui . Esta não é uma duplicata, pois esta pergunta original foi encerrada e não recebeu nenhuma resposta, porque não havia critério de vencimento e o usuário não estava disposto a colocá-lo.

Pontuação

A pontuação é um pouco complicada!

Sua pontuação é

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

Maior pontuação ganha.

Seu programa não precisa ser e provavelmente não pode ser perfeito, mas quanto mais preciso, mais bônus ele recebe!

Desde $pode significar tanto se S, você recebe um bônus de 5 pontos por item leet para decidir se ele deve ter uma letra maiúscula (letras maiúsculas ou seja, no início de frases).

Você recebe um bônus adicional de 5 pontos por item leet para implementar substantivos próprios (palavras que sempre possuem maiúsculas) - a maneira como isso funciona é que você examinaria a lista de palavras, tornaria a saída maiúscula se apenas uma versão maiúscula estiver presente no lista, e se as duas versões estiverem lá, apenas adivinhe.

Se um personagem tiver dois significados (por exemplo, 1pode significar Lou I), você ganha 20 pontos por item leet por escolher apenas as traduções do item que produzem palavras reais em inglês - use a lista de palavras para isso. Se mais de uma tradução de um item leet formar uma palavra em inglês real, você poderá escolher arbitrariamente uma das traduções válidas e ainda assim obter o bônus.

Lista de Leet

Estes são os itens leet que você pode implementar. Você não precisa implementar todos eles, mas quanto mais você adicionar, mais pontos receberá.

Você nunca pode marcar pontos traduzindo um item ou personagem para si mesmo. Esta regra substitui quaisquer erros que eu possa ter cometido na lista.

É tentador fazer um simples trou s/.../.../g. O verdadeiro desafio é determinar qual dos múltiplos significados poderia ou não estar correto, usando a lista de palavras.

Itens Leet (cada um deles adiciona 1 a leet itemsna 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 -> o
'd -> ed
pwnd -> pwned
pwnt -> pwned
k, K -> OK
kk -> OK
0 [zero] -> o, O
y, Y -> por que
4 -> para
txt -> texto
dafuq -> que porra é essa
/ \, ^ -> a, A
\ / -> v, V
d00d -> cara
n00b -> novato
\ / \ / -> w, W
8 -> b, B
| _ | -> u, U
| - | -> h, H
Я -> r, R
j00 -> você
joo -> você
vv, VV -> w, W
tomoz -> amanhã
| <-> k, K
[), |) -> d, D
<3 -> amor
> <-> x, X
10100111001 -> leet (representação binária de 1337)
2 -> também
ur, UR -> seu, você é (não é necessário distinguir corretamente entre os dois)
você, você
8 -> -ate-, 8
x, X -> -ks -, - cks-
z, Z -> s, S
1 -> i, eu, eu, L
! -> eu, eu!
c, C -> ver, C, mar
b, B -> ser, B, abelha
[letra acentuada] -> [formulário sem acentuação] (pontuação 1 por letra acentuada suportada)
&, 7 -> e, anned, ant (pode ser usado no meio de uma palavra)

"Leet" mais difícil: faça 30 pontos por leet itemscada

!!! 1 !! 1-> !!!!!!! (traduza 1's em uma sequência de! 's para!' s)
!!! um! -> !!!!!
! eleven-> !!!

Exemplos

Estes são exemplos do que um programa que implementa todos os personagens leet acima e alguns dos bônus pode ser capaz de fazer:

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

Censura baseada em Leet: $#!+=s**t

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

-xor sufixo: H4X0R=hacker

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

Exemplo de Pontuação

Bash, 10 caracteres, 3 itens, sem bônus:

tr 137 let

Isso marca ( 1 * 3 ) * 10 / 10 = 3.

code-challenge string natural-language totalmente humano
fonte
Desculpe por não ter pego isso na caixa de areia, mas se você multiplicar os bônus por 10, eles ainda valem muito mais do que as próprias palavras. Essa é a sua intenção?
Martin Ender
@ m.buettner É combater simplesmente usando trou s/.../.../g. Apenas traduzir coisas como que faria um desafio chato, por isso precisamos para recompensar melhores traduções que usam a lista de palavras
Uma longa série de regexps seria permitida? Eu adoraria ver se era possível (ainda que difícil) fazer isso, mesmo de maneira consciente do contexto, principalmente em expressões regulares. (Ou talvez um sedscript.)
Isiah Meadows
Quando digo um sedscript, quero dizer mais do que um simples s/.../.../g, mas um arquivo que é analisado e executado por sedsi só. Como concisa como a língua é, pode ser uma linguagem golfable decente ...
Isiah Meadows
Regimpes @impinball são absolutamente bons, embora eu não tenha idéia de como você abriria a lista de palavras e a analisaria apenas com um idioma regex. sedscripts também são bons e podem ser muito interessantes, pois eles podem se sair muito bem devido à breve sintaxe de substituição. Você pode ler a lista de palavras, com extensões GNU ou usando sedcomo parte de um programa Bash maior

Respostas:

11

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

Demo Online:

A opção "Dicionário real" não funciona na caixa suspensa, mas funcionará se for executada em um servidor Web real. Testado no servidor de desenvolvimento do visual studio e no google chrome.

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

Ponto:

49 itens leet = 49

Bônus de capitalização = 5 * 49 = 245

bônus de pesquisa de dicionário = 20 * 49 = 980

bônus de exclamação * 3 = 90 * 49 = 4410

(itens leet + bônus) * 10 / (comprimento do 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: "!", "!": "!" }

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

Resultado dos testes:

  • | - | 3 15 $ | _ | (# @ n00b ====> Ele é um novato
  • @ 1 // 4Y5 p0 $ + ur n3VV qu35710nz 1 & $ 80x ====> Sempre poste suas novas perguntas na sandbox
  • !!! 1 !! 1 ====> !!!!!!!
  • !!!1! ====> !!!!!
  • ! onze ====> !!!
  • 1 !!! 1 ====> O !!!!!!!
  • um !!! ====> O !!!!!
  • onze ====> O !!!
  • 1 !!! 1 ====> O !!!!!!!
  • qu35710nz! 1! ====> Perguntas !!!
  • +357 +357. 735+ ====> Teste de teste. Teste
  • & 31! 73 # 4 (KER $ WR0 + 3 83773R L! K3 + #! 5 7 # @ N 2D @ Y ====> E hackers de elite escreveram melhor assim do que hoje

Notas:

O dicionário é um arquivo javascript separado com um objeto chamado W contendo todas as palavras. Isso contém apenas as palavras necessárias para executar os testes relevantes.

rdans
fonte
Se você executar isso através do Closure Compiler, são apenas 1640 caracteres, elevando sua pontuação para 34. #
AMK
o que esse arquivo faz? dl.dropboxusercontent.com/u/141246873/leettranslator/… é apenas para obter um dicionário da web? (ou seja, o programa pode ser executado utilizando W.js, se for removido)
@professorfish é uma js lib externa com um dicionário (palavras com até dez letras). É usado apenas se a opção 'dicionário real' estiver selecionada na demonstração. É apenas para uma demonstração com um dicionário melhor e não faz parte da minha resposta oficial.
Rdans
6

Haskell - Pontuação 1.421421421: (37 itens + (21 bônus (capitalização) * 5)) * 10 / (999 bytes)

Esta é a minha resposta 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

Testes

Quando o programa é compilado em um arquivo chamado min-lt, você pode escrever o seguinte 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á isto

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
fonte
por -ks-eu quis dizer ksno meio de uma palavra. Vou dar uma olhada nisso assim que encontrar um compilador haskell
Basta instalar o haskell-platformpacote. Você tem um exemplo para ks?
Gxtaillon 31/05
<insertnamehere> rocXouroX
Eu testei-lo, ele está trabalhando
1
Atualizei minha resposta com uma pontuação e melhor manuseio da tradução de palavras.
precisa saber é o seguinte
6

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

Portanto, isso faz 15 traduções "$ (5 @ 437 + # 0821! &", Sem bônus e possui 222 bytes (feeds de linha desnecessários não incluídos). 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
%>

O EBF não é realmente feito para o golfe, mas seu recurso básico, macros e recurso de cadeia de impressão tornam um pouco mais fácil compactar do que o BrainFuck. O final do binário BrainFuck compilado é assim:

>>,[-<+<+>>]<[>++++++[-<------>]+<+++[--[-[--[--[---[-----[-[-[-[-[-[--[-[--------[[-]
>[-]<<.>]>[->++++++++[-<++++++++>]<+.[-]]<]>[->++++++++[-<++++++++>]<++.[-]]<]>[->++++
+++++[-<+++++++++>]<+++.[-]]<]>[->+++++++++[-<+++++++++>]<++.[-]]<]>[->++++++++[-<++++
++++>]<+.[-]]<]>[->++++++++[-<+++++++++>]<---.[-]]<]>[->+++++++++[-<+++++++++>]<+++.--
---.[-]]<]>[->++++++++[-<+++++++++>]<++++.[-]]<]>[->+++++++++[-<+++++++++>]<--.[-]]<]>
[->+++++++++[-<+++++++++>]<+++.[-]]<]>[->++++++++[-<++++++++>]<+++.[-]]<]>[->++++++++[
-<++++++++>]<+.+++++++++++++.----------.[-]]<]>[->+++++++++[-<+++++++++>]<++.[-]]<]>[-
>++++++++[-<+++++++++>]<.[-]]<]>[->++++++++[-<+++++++++>]<+.[-]]<[-]<[-]>>,[-<+<+>>]<]
Sylwester
fonte
1
O código BF compilado parece funcionar bem, parece muito curto para um programa BF
@professorfish Usando ~"OTLHEAND"eu poderia fez todos os caracteres de uma vez por 107 bytes código objeto em vez de fazê-los a partir de 0 a cada vez usando 354, mas a minha resposta é otimizada para o tamanho do 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);}}

Por isso, realiza as seguintes transformações

+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

O cálculo da pontuação é complicado

  • (itens leet + bônus) * 10 / (comprimento do código)
  • comprimento do código = 1165 leet
  • itens leet = 39 (único)
  • bônus = 21 (não sabe calcular MomemtumMori tão copiado) (Por favor, informe)

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

Código não golfe:

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
fonte
2
Você se importaria de não gostar dele? : D
Knerd 5/06
0

Pontuação C # 45 * 10/2556 = 0,176

O programa pode gerar quase todas as letras maiúsculas e minúsculas. Como não estou usando uma lista de palavras em inglês, a primeira chave encontrada no Dicionário é usada. Por exemplo, \ / \ / torna-se vav. Se char for a primeira letra de uma palavra, o ToUpper será aplicado.

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

Aqui está a minha saída de teste:

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