Ваша задача - написать программу для перевода (английский) leetspeak / lolspeak / txtspk на обычный английский. Ваша программа должна читать из стандартного ввода и вывода в стандартный вывод, если ваш язык не поддерживает их.

Вы можете использовать файл, содержащий список слов на английском языке, разделенных новыми строками. Он должен быть вызван Wи находиться в том же каталоге, что и ваша программа. (В системах GNU / Linux и, возможно, в других вы можете сделать Wссылку на /usr/share/dict/wordsэтот список). Список не обязательно должен быть в нижнем регистре, вы можете использовать его, чтобы определить, должны ли слова иметь заглавные буквы.

Это основано на удаленном вопросе, опубликованном Никосом М., который можно найти здесь . Это не дубликат, так как этот оригинальный вопрос был закрыт и не получил никаких ответов, потому что не было критерия выигрыша, и пользователь не хотел его вводить.

счет

Подсчет очков немного сложнее!

ваш счет

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

Самый высокий балл выигрывает.

Ваша программа не должна быть и, вероятно, не может быть идеальной, но чем она точнее, тем больше бонусов!

Так как $может означать и то, sи другое S, вы получаете бонус в 5 баллов за каждый элемент leet за решение, должно ли оно иметь заглавную букву (то есть заглавные буквы в начале предложений).

Вы получаете дополнительный бонус в 5 баллов за элемент leet для реализации собственных имен (слов, которые всегда имеют заглавные буквы) - способ, которым это работает, заключается в том, что вы просматриваете список слов, делаете вывод заглавными, если в нем присутствует только заглавная версия. список, и если обе версии есть, просто угадайте.

Если персонаж имеет два значения (например, 1может означать Lили I), вы получаете 20 баллов за элемент leet за выбор только тех переводов элемента, которые составляют настоящие английские слова - используйте для этого список слов. Если более одного перевода элемента leet представляет собой реальное английское слово, вы можете произвольно выбрать один из действительных переводов и при этом получить бонус.

Список Leet

Это те элементы, которые вы можете реализовать. Вам не нужно реализовывать их все, но чем больше вы добавляете, тем больше очков вы получаете.

Вы никогда не сможете набрать очки, переводя предмет или персонажа на себя. Это правило отменяет любые ошибки, которые я мог допустить в списке.

Это заманчиво сделать простой trили s/.../.../g. Реальная задача состоит в том, чтобы определить, какое из нескольких значений может и не может быть правильным, используя список слов.

Leet Items (каждый из них добавляет 1 к leet itemsформуле)

$ -> s, S
(-> C, C
5 -> с, с
@ -> а, а
4 -> а, а
3 -> е, е
7 -> т, т
+ -> т, т
# -> ч, ч
это
'd -> ed
pwnd -> pwned
pwnt -> pwned
К, К -> ОК
кк -> ОК
0 [ноль] -> о, о
у, у -> почему
4 -> для
TXT -> текст
Дафук -> что за **
/ \, ^ -> а, а
\ / -> V, V
d00d -> чувак
n00b -> новичок
\ / \ / -> ш, ш
8 -> б, б
| _ | -> ты, ты
| - | -> ч, ч
Я -> R, R
J00 -> Вы
Джу -> ты
VV, VV -> W, W
Томоз -> завтра
| <-> к, к
[), |) -> д, д
<3 -> любовь
> <-> х, х
10100111001 -> leet (двоичное представление 1337)
2 -> чтобы тоже
ур, UR -> твой, ты (нет необходимости правильно различать два)
ты, ты -> ты
8 -> -ate-, 8
x, X -> -ks -, - cks-
z, Z -> s, S
1 -> я, я, л, л
! -> Я, я!
C, C -> см., C, море
б, б -> бе, б, пчела
[акцентированное письмо] -> [не акцентированная форма] (оценка 1 за акцентированное письмо поддерживается)
&, 7 -> и anned, ant (можно использовать в середине слова)

Сложнее "Лет": набери 30 очков за leet itemsкаждого

!!! 1 !! 1-> !!!!!!! (переведите 1 в последовательности! в!)
!!! один! -> !!!!!
! одиннадцать-> !!!

Примеры

Это примеры того, что может сделать программа, которая реализует все приведенные выше символы leet, и некоторые бонусы:

Пример предложения: |-|3 15 $|_|(# @ n00b=He is such a newbie

Leet-на-основе цензура: $#!+=s**t

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

суффикс -xor: H4X0R=hacker

Более экстремальный взгляд: @1\/\/4Y5 p0$+ ur n3VV qu35710nz 1n teh $&80x=Always post your new questions in the sandbox

Пример подсчета очков

Баш, 10 персонажей, 3 предмета, без бонусов:

tr 137 let

Это баллы ( 1 * 3 ) * 10 / 10 = 3.

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

Демо онлайн:

Опция «Настоящий словарь» не работает в выпадающем списке, но она будет работать при запуске на реальном веб-сервере. Протестировано в Visual Studio разработки сервера и Google Chrome.

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

Гол:

49 летов = 49

Бонус капитализации = 5 * 49 = 245

словарь поиска бонус = 20 * 49 = 980

восклицательный бонус * 3 = 90 * 49 = 4410

(детали + бонусы) * 10 / (длина кода)

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

Код:

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

Результаты теста:

• | - | 3 15 $ | _ | (# @ n00b ====> Он такой новичок
• @ 1 // 4Y5 p0 $ + ur n3VV qu35710nz 1n $ & 80x ====> Всегда оставляйте свои новые вопросы в песочнице
• !!! 1 !! 1 ====> !!!!!!!
• !!!один! ====> !!!!!
• ! одиннадцать ====> !!!
• тх !!! 1 !! 1 ====> !!!!!!!
• Teh !!! один! ====> The !!!!!
• одиннадцать ====> The !!!
• тх !!! 1 !! 1 ====> !!!!!!!
• qu35710nz! 1! ====> Вопросы !!!
• +357 +357. 735+ ====> Тестовый тест. Тест
• & 31! 73 # 4 (KER $ WR0 + 3 83773R L! K3 + #! 5 7 # @ N 2D @ Y ====> И элитные хакеры писали лучше, чем сегодня

Заметки:

Словарь представляет собой отдельный файл javascript с объектом W, который содержит все слова. Это просто содержит слова, которые мне нужны для запуска соответствующих тестов.

Haskell - Счет 1.421421421: (37 предметов + (21 бонус (заглавная буква) * 5)) * 10 / (999 байт)

Это мой окончательный ответ.

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

тесты

Когда программа скомпилирована в файл с именем min-lt, вы можете написать следующий скрипт оболочки

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

который напечатает это

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"

Расширенный 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+))

Таким образом, это делает 15 переводов "$ (5 @ 437 + # 0821! &", Без бонусов и имеет 222 байта (дополнительные строки не включены). 15 * 10/222 = 0,6757

Использование:

%> 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 на самом деле не предназначен для игры в гольф, но его особенность, макросы и функции печати строк облегчают сжатие, чем BrainFuck. Конечный скомпилированный двоичный файл BrainFuck выглядит так:

>>,[-<+<+>>]<[>++++++[-<------>]+<+++[--[-[--[--[---[-----[-[-[-[-[-[--[-[--------[[-]
>[-]<<.>]>[->++++++++[-<++++++++>]<+.[-]]<]>[->++++++++[-<++++++++>]<++.[-]]<]>[->++++
+++++[-<+++++++++>]<+++.[-]]<]>[->+++++++++[-<+++++++++>]<++.[-]]<]>[->++++++++[-<++++
++++>]<+.[-]]<]>[->++++++++[-<+++++++++>]<---.[-]]<]>[->+++++++++[-<+++++++++>]<+++.--
---.[-]]<]>[->++++++++[-<+++++++++>]<++++.[-]]<]>[->+++++++++[-<+++++++++>]<--.[-]]<]>
[->+++++++++[-<+++++++++>]<+++.[-]]<]>[->++++++++[-<++++++++>]<+++.[-]]<]>[->++++++++[
-<++++++++>]<+.+++++++++++++.----------.[-]]<]>[->+++++++++[-<+++++++++>]<++.[-]]<]>[-
>++++++++[-<+++++++++>]<.[-]]<]>[->++++++++[-<+++++++++>]<+.[-]]<[-]<[-]>>,[-<+<+>>]<]

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

Так что он делает следующие преобразования

+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

Расчет баллов сложен

• (детали + бонусы) * 10 / (длина кода)
• длина кода = 1165 лет
• leet items = 39 (уникально)
• бонус = 21 (не знаю, как рассчитать так скопированный MomemtumMori) (пожалуйста, сообщите)

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

Un-Golfed код:

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

C # оценка 45 * 10/2556 = 0,176

Программа может выводить практически все строчные и прописные буквы. Поскольку я не использую список английских слов, используется первый ключ, найденный в словаре. Например, \ / \ / становится vav. Если char - первая буква слова, применяется 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();
}
}

Вот мой тестовый вывод:

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