Thử thách của bạn là viết một chương trình dịch (tiếng Anh) leetspeak / lolspeak / txtspk sang tiếng Anh thông thường. Chương trình của bạn nên đọc từ đầu vào tiêu chuẩn và đầu ra sang đầu ra tiêu chuẩn, trừ khi ngôn ngữ của bạn không hỗ trợ những thứ này.

Bạn có thể sử dụng một tệp chứa danh sách các từ trong tiếng Anh, được phân tách bằng các dòng mới. Nó sẽ được gọi Wvà sẽ nằm trong cùng thư mục với chương trình của bạn. (Trên các hệ thống GNU / Linux và có thể các hệ thống khác, bạn có thể tạo Wliên kết đến /usr/share/dict/words) Danh sách không nhất thiết phải là chữ thường, bạn có thể sử dụng nó để xác định xem các từ có nên viết hoa hay không.

Điều này dựa trên một câu hỏi đã bị xóa bởi Nikos M. có thể được tìm thấy ở đây . Đây không phải là một bản sao vì câu hỏi ban đầu này đã bị đóng và không nhận được bất kỳ câu trả lời nào, vì không có tiêu chí chiến thắng và người dùng không sẵn lòng đặt câu hỏi.

Chấm điểm

Việc ghi bàn hơi phức tạp!

Điểm của bạn là

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

Điểm số cao nhất chiến thắng.

Chương trình của bạn không cần phải có và không thể hoàn hảo, nhưng càng chính xác, nó càng nhận được nhiều tiền thưởng!

Vì $có thể có nghĩa là cả hai svà S, bạn nhận được tiền thưởng 5 điểm cho mỗi mục leet để quyết định xem nó có nên viết hoa hay không (tức là chữ in hoa khi bắt đầu câu).

Bạn nhận được thêm 5 điểm cho mỗi mục leet để triển khai các danh từ riêng (các từ luôn có chữ viết hoa) - cách thức hoạt động này là bạn sẽ xem qua danh sách từ, tạo đầu ra viết hoa nếu chỉ có phiên bản viết hoa trong danh sách, và nếu cả hai phiên bản đều ở đó, chỉ cần đoán.

Nếu một ký tự có hai nghĩa (ví dụ 1có thể có nghĩa Lhoặc I), bạn nhận được 20 điểm cho mỗi mục leet chỉ để chọn các bản dịch của mục tạo ra các từ tiếng Anh thực sự - sử dụng danh sách từ cho việc này. Nếu nhiều bản dịch của một mục leet tạo ra một từ tiếng Anh thực sự, bạn có thể tùy ý chọn một trong các bản dịch hợp lệ và vẫn nhận được tiền thưởng.

Danh sách Leet

Đây là những mục leet mà bạn có thể thực hiện. Bạn không cần phải thực hiện tất cả chúng, nhưng bạn càng thêm, bạn càng nhận được nhiều điểm.

Bạn không bao giờ có thể ghi điểm bằng cách dịch một mục hoặc ký tự cho chính nó. Quy tắc này ghi đè bất kỳ sai lầm nào tôi có thể đã mắc phải trong danh sách.

Thật hấp dẫn để làm một cách đơn giản trhoặc s/.../.../g. Thách thức thực sự là xác định nghĩa nào trong số nhiều nghĩa có thể và không thể đúng, sử dụng danh sách từ.

Mục Leet (mỗi mục này thêm 1 leet itemsvào công thức)

$ -> s, S
(-> c, C
5 -> s, S
@ -> a, A
4 -> a, A
3 -> e, E
7 -> t, T
+ -> t, T
# -> h, H
teh ->
'd -> ed
pwnd -> pwned
pwnt -> pwned
k, K -> OK
kk -> OK
0 [không] -> o, O
y, Y -> tại sao
4 -> cho
txt -> văn bản
dafuq -> những gì f ** k
/ \, ^ -> a, A
\ / -> v, V
d00d -> anh chàng
n00b -> người mới
\ / \ / -> w, W
8 -> b, B
| _ | -> u, bạn
| - | -> h, H
Я -> r, R
j00 -> bạn
joo -> bạn
vv, VV -> w, W
tomoz -> ngày mai
| <-> k, K
[), |) -> d, D
<3 -> tình yêu
> <-> x, X
10100111001 -> leet (đại diện nhị phân của 1337)
2 -> cũng vậy
ur, UR -> của bạn, bạn (không cần phân biệt chính xác giữa hai)
bạn, bạn - bạn
8 -> -ate-, 8
x, X -> -ks -, - cks-
z, Z -> s, S
1 -> i, tôi, l, L
! -> tôi, tôi ,!
c, C -> thấy, C, biển
b, B -> được, B, ong
[thư có dấu] -> [mẫu không có dấu] (điểm 1 cho mỗi chữ có dấu được hỗ trợ)
&, 7 -> và, anned, ant (có thể được sử dụng ở giữa một từ)

"Leet" khó hơn: ghi 30 điểm cho leet itemsmỗi

!!! 1 !! 1-> !!!!!!! (dịch 1 giây theo thứ tự! 's thành!')
!!! một! -> !!!!!
! mười một-> !!!

Ví dụ

Đây là những ví dụ về những gì một chương trình thực hiện tất cả các ký tự leet ở trên và một số phần thưởng, có thể có thể làm:

Ví dụ câu: |-|3 15 $|_|(# @ n00b=He is such a newbie

Kiểm duyệt dựa trên Leet: $#!+=s**t

Cực lớn: \/\/ 1 |< 1 P 3 [) 1 A=Wikipedia

hậu tố -xor: H4X0R=hacker

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

Ví dụ chấm điểm

Bash, 10 ký tự, 3 vật phẩm, không có tiền thưởng:

tr 137 let

Điểm này ( 1 * 3 ) * 10 / 10 = 3.

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

Demo trực tuyến:

Tùy chọn "Real dictionary" không hoạt động trên hộp thả nhưng nó sẽ hoạt động nếu chạy trong một máy chủ web thực. Đã thử nghiệm trong máy chủ phát triển phòng thu trực quan và google chrome.

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

Ghi bàn:

49 mặt hàng leet = 49

Phần thưởng viết hoa = 5 * 49 = 245

phần thưởng tra cứu từ điển = 20 * 49 = 980

tiền thưởng cảm thán * 3 = 90 * 49 = 4410

(mục leet + tiền thưởng) * 10 / (độ dài mã)

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

Mã số:

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

Ung dung:

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

Kết quả kiểm tra:

• | - | 3 15 $ | _ | (# @ n00b ====> Anh ấy là một người mới như vậy
• @ 1 // 4Y5 p0 $ + ur n3VV qu35710nz 1n teh $ & 80x ====> Luôn đăng câu hỏi mới của bạn trong hộp cát
• !!! 1 !! 1 ====> !!!!!!!
• !!!một! ====> !!!!!
• ! mười một ====> !!!
• teh !!! 1 !! 1 ====> The !!!!!!!
• teh !!! ====> !!!!!
• teh! mười một ====> The !!!
• teh !!! 1 !! 1 ====> The !!!!!!!
• qu35710nz! 1! ====> Câu hỏi !!!
• +357 +357. 735+ ====> Kiểm tra thử nghiệm. Kiểm tra
• & 31! 73 # 4 (KER $ WR0 + 3 83773R L! K3 + #! 5 7 # @ N 2D @ Y ====> Và các hacker ưu tú đã viết tốt hơn như thế này so với ngày hôm nay

Ghi chú:

Từ điển là một tệp javascript riêng biệt với một đối tượng được gọi là W chứa tất cả các từ. Điều này chỉ chứa những từ tôi cần để chạy các bài kiểm tra có liên quan.

Haskell - Điểm 1.421421421: (37 mục + (21 phần thưởng (viết hoa) * 5)) * 10 / (999 byte)

Đây là câu trả lời cuối cùng của tôi.

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

Xét nghiệm

Khi chương trình được biên dịch thành tệp có tên min-lt, bạn có thể viết tập lệnh shell sau

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

cái nào sẽ in cái này

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 mở rộng : 0,677

{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+))

Vì vậy, điều này thực hiện 15 bản dịch "$ (5 @ 437 + # 0821! &", Không có phần thưởng và nó có 222 byte (không bao gồm các dòng lệnh không cần thiết). 15 * 10/222 = 0,677

Sử dụng:

%> 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 không thực sự được tạo ra để chơi gôn nhưng tính năng rle, macro và tính năng chuỗi in giúp dễ nén hơn BrainFuck. Phần cuối được biên dịch nhị phân BrainFuck trông như thế này:

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

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

Vì vậy, nó thực hiện các biến đổi sau đây

+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

Cách tính điểm rất khó

• (mục leet + tiền thưởng) * 10 / (độ dài mã)
• chiều dài mã = ​​1165 leet
• mục leet = 39 (duy nhất)
• tiền thưởng = 21 (không biết cách tính sao chép MomemtumMori) (Xin tư vấn)

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

Mã không được đánh gôn:

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

Điểm C # 45 * 10/2556 = 0,176

Chương trình có thể xuất ra gần như tất cả các chữ cái viết thường và in thường. Vì tôi không sử dụng danh sách từ tiếng Anh, khóa đầu tiên được tìm thấy trong Từ điển được sử dụng. Ví dụ: \ / \ / trở thành vav. Nếu char là chữ cái đầu tiên của một từ ToUpper được áp dụng.

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

Đây là đầu ra thử nghiệm của tôi:

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