Passa alla traduzione inglese

23

La tua sfida è quella di scrivere un programma per tradurre (inglese) leetspeak / lolspeak / txtspk in inglese normale. Il tuo programma dovrebbe leggere dallo standard input e output allo standard output, a meno che la tua lingua non li supporti.

È possibile utilizzare un file contenente un elenco di parole in lingua inglese, separate da nuove righe. Dovrebbe essere chiamato We si troverà nella stessa directory del programma. (Sui sistemi GNU / Linux e possibilmente su altri, è possibile creare Wun collegamento a /usr/share/dict/words) L'elenco non deve essere in minuscolo, è possibile utilizzarlo per determinare se le parole devono avere maiuscole.

Questo si basa su una domanda ora cancellata pubblicata da Nikos M. che può essere trovata qui . Questo non è un duplicato poiché questa domanda originale è stata chiusa e non ha ricevuto alcuna risposta, perché non c'erano criteri vincenti e l'utente non era disposto a inserirne uno.

punteggio

Il punteggio è un po 'complicato!

il tuo punteggio è

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

Il punteggio più alto vince.

Il tuo programma non deve essere e probabilmente non può essere perfetto, ma più è preciso, più bonus ottiene!

Dal momento che $può significare entrambi se S, ricevi un bonus di 5 punti per oggetto leet per decidere se deve avere una lettera maiuscola (cioè lettere maiuscole all'inizio delle frasi).

Ottieni un ulteriore bonus di 5 punti per elemento leet per l'implementazione di nomi propri (parole che hanno sempre le maiuscole) - il modo in cui funziona è che guardi l'elenco delle parole, rendi l'output in maiuscolo se solo una versione in maiuscolo è presente nel elenco, e se entrambe le versioni sono presenti, indovina.

Se un personaggio ha due significati (ad es. 1Può significare Lo I), ottieni 20 punti per oggetto leet solo per scegliere quelle traduzioni dell'oggetto che rendono vere parole inglesi - usa la lista di parole per questo. Se più di una traduzione di un oggetto leet fa una vera parola inglese, puoi scegliere arbitrariamente una delle traduzioni valide e ottenere comunque il bonus.

Elenco di Leet

Questi sono gli elementi leet che puoi implementare. Non è necessario implementarli tutti, ma più aggiungi, più punti ottieni.

Non puoi mai segnare punti traducendo un oggetto o un personaggio in se stesso. Questa regola ha la precedenza su tutti gli errori che avrei potuto fare nella lista.

È allettante fare un semplice tro s/.../.../g. La vera sfida è determinare quale dei molteplici significati potrebbe e non potrebbe essere corretto, usando la lista di parole.

Leet Items (ognuno di questi aggiunge 1 a leet itemsnella formula)

$ -> s, S
(-> c, C
5 -> s, S
@ -> a, A
4 -> a, A
3 -> e, E
7 -> t, T
+ -> t, T
# -> h, H
il -> il
'd -> ed
pwnd -> pwned
pwnt -> pwned
k, K -> OK
kk -> OK
0 [zero] -> o, O
y, Y -> perché
4 -> per
txt -> testo
dafuq -> cosa f ** k
/ \, ^ -> a, A
\ / -> v, V
d00d -> amico
n00b -> newbie
\ / \ / -> w, W
8 -> b, B
| _ | -> u, U
| - | -> h, H
Я -> r, R
j00 -> tu
joo -> tu
vv, VV -> w, W
tomoz -> domani
| <-> k, K
[), |) -> d, D
<3 -> amore
> <-> x, X
10100111001 -> leet (rappresentazione binaria del 1337)
2 -> anche a
ur, UR -> tuo, sei (non c'è bisogno di distinguere correttamente tra i due)
u, U -> tu
8 -> -ate-, 8
x, X -> -ks -, - cks-
z, Z -> s, S
1 -> i, I, l, L
! -> I, I ,!
c, C -> vedi, C, mare
b, B -> essere, B, ape
[lettera accentata] -> [modulo non accentato] (punteggio 1 per lettera accentata supportata)
&, 7 -> e, anned, ant (può essere usato nel mezzo di una parola)

"Leet" più duro: segna 30 punti per leet itemsciascuno

!!! 1 !! 1-> !!!!!!! (traduci 1 in una sequenza di! in!)
!!! uno! -> !!!!!
! undici> !!!

Esempi

Questi sono esempi di ciò che un programma che implementa tutti i personaggi leet sopra, e alcuni dei bonus, potrebbe essere in grado di fare:

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

Censura basata su leet: $#!+=s**t

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

-xor suffix: H4X0R=hacker

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

Punteggio di esempio

Bash, 10 personaggi, 3 oggetti, nessun bonus:

tr 137 let

Questo segna ( 1 * 3 ) * 10 / 10 = 3.

code-challenge  string  natural-language 
— totallyhuman
fonte
Mi dispiace non averlo preso nella sandbox, ma se moltiplichi i bonus per 10 valgono comunque molto di più delle parole stesse. È questa la tua intenzione?
— Martin Ender,
@ m.buettner È per combattere semplicemente usando tro s/.../.../g. La sola traduzione di cose del genere costituirebbe una sfida noiosa, quindi dobbiamo premiare le traduzioni migliori che utilizzano l'
Sarebbe ammissibile una lunga serie di regexps? Mi piacerebbe vedere se fosse possibile (anche se difficile) farlo anche in modo consapevole del contesto in gran parte delle repliche. (O forse una sedsceneggiatura.)
— Isiah Meadows
Quando dico uno sedscript, intendo più di un semplice s/.../.../g, ma un file che viene analizzato ed eseguito da sedsolo. Per quanto la lingua sia concisa, potrebbe essere una lingua giocabile decente ...
— Isiah Meadows,
@impinball Regexes è assolutamente perfetto, anche se non ho idea di come aprire la lista di parole e analizzarla con un solo linguaggio regex. sedanche gli script vanno bene e potrebbero essere molto interessanti, potrebbero fare molto bene su questo a causa della breve sintassi di sostituzione, potresti essere in grado di leggere dalla lista di parole, con estensioni GNU o usando sedcome parte di un programma Bash più grande

Risposte:

11

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

Demo online:

L'opzione "Dizionario reale" non funziona nella casella di riepilogo ma funzionerà se eseguita in un server Web reale. Testato su Visual Studio Development Server e Google Chrome.

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

Punto:

49 elementi lasciati = 49

Bonus di capitalizzazione = 5 * 49 = 245

bonus di ricerca nel dizionario = 20 * 49 = 980

bonus esclamativo * 3 = 90 * 49 = 4410

(elementi leet + bonus) * 10 / (lunghezza del codice)

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

Codice:

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

Risultati del test:

  • | - | 3 15 $ | _ | (# @ n00b ====> È un principiante
  • @ 1 // 4Y5 p0 $ + ur n3VV qu35710nz 1n teh $ & 80x ====> Pubblica sempre le tue nuove domande nella sandbox
  • !!! 1 !! 1 ====> !!!!!!!
  • !!!uno! ====> !!!!!
  • ! undici ====> !!!
  • teh !!! 1 !! 1 ====> Il !!!!!!!
  • teh !!! uno! ====> Il !!!!!
  • teh! undici ====> Il !!!
  • teh !!! 1 !! 1 ====> Il !!!!!!!
  • qu35710nz! 1! ====> Domande !!!
  • +357 +357. 735+ ====> Test test. Test
  • & 31! 73 # 4 (KER $ WR0 + 3 83773R L! K3 + #! 5 7 # @ N 2D @ Y ====> E gli hacker d'élite hanno scritto meglio così di oggi

Gli appunti:

Il dizionario è un file javascript separato con un oggetto chiamato W che contiene tutte le parole. Questo contiene solo le parole di cui avevo bisogno per eseguire i test pertinenti.

— rdans
fonte
Se lo attraversi nel compilatore di chiusura, sono solo 1640 i personaggi a portare il tuo punteggio a 34.
— AMK
cosa fa questo file? dl.dropboxusercontent.com/u/141246873/leettranslator/… è solo per ottenere un dizionario dal web? (vale a dire che il programma può essere eseguito W.jsse viene rimosso)
@professorfish è una libreria js esterna con un dizionario (parole fino a dieci lettere). Viene utilizzato solo se l'opzione "dizionario reale" è selezionata nella demo. È solo per una demo con un dizionario migliore e non fa parte della mia risposta ufficiale.
— rdans,
6

Haskell - Punteggio 1.421421421: (37 articoli + (21 bonus (capitalizzazione) * 5)) * 10 / (999 byte)

Questa è la mia risposta finale.

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

test

Quando il programma viene compilato in un file denominato min-lt, è possibile scrivere il seguente script 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+"

che stamperà questo

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
da -ks-volevo dire ksnel mezzo di una parola. Lo guarderò non appena troverò un compilatore di
Installa il haskell-platformpacchetto. Hai un esempio per ks?
— gxtaillon,
<insertnamehere> rocXoppureroX
L'ho provato, funziona
1
Aggiornato la mia risposta con un punteggio e una migliore gestione della traduzione delle parole.
— gxtaillon,
6

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

Quindi, questo fa 15 traduzioni "$ (5 @ 437 + # 0821! &", Nessun bonus e ha 222 byte (avanzamenti di riga non obbligatori non inclusi). 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
%>

L'EBF non è fatto apposta per il golf, ma la sua funzione rle, le macro e le stringhe di stampa rendono un po 'più facile la compressione rispetto a BrainFuck. Il binario BrainFuck compilato alla fine si presenta così:

>>,[-<+<+>>]<[>++++++[-<------>]+<+++[--[-[--[--[---[-----[-[-[-[-[-[--[-[--------[[-]
>[-]<<.>]>[->++++++++[-<++++++++>]<+.[-]]<]>[->++++++++[-<++++++++>]<++.[-]]<]>[->++++
+++++[-<+++++++++>]<+++.[-]]<]>[->+++++++++[-<+++++++++>]<++.[-]]<]>[->++++++++[-<++++
++++>]<+.[-]]<]>[->++++++++[-<+++++++++>]<---.[-]]<]>[->+++++++++[-<+++++++++>]<+++.--
---.[-]]<]>[->++++++++[-<+++++++++>]<++++.[-]]<]>[->+++++++++[-<+++++++++>]<--.[-]]<]>
[->+++++++++[-<+++++++++>]<+++.[-]]<]>[->++++++++[-<++++++++>]<+++.[-]]<]>[->++++++++[
-<++++++++>]<+.+++++++++++++.----------.[-]]<]>[->+++++++++[-<+++++++++>]<++.[-]]<]>[-
>++++++++[-<+++++++++>]<.[-]]<]>[->++++++++[-<+++++++++>]<+.[-]]<[-]<[-]>>,[-<+<+>>]<]
— Sylwester
fonte
1
Il codice BF compilato sembra funzionare bene, sembra piuttosto breve per un programma BF
@professorfish Usando ~"OTLHEAND"ho potuto creare tutti i caratteri una volta per 107 byte di codice oggetto invece di farli da 0 ogni volta usando 354, ma la mia risposta è ottimizzata per la dimensione del codice 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);}}

Quindi esegue le seguenti trasformazioni

+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

Il calcolo del punteggio è complicato

  • (elementi leet + bonus) * 10 / (lunghezza del codice)
  • codice lunghezza = 1165 leet
  • leet items = 39 (unico)
  • bonus = 21 (non so come calcolare MomemtumMori così copiato) (Si prega di avvisare)

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

Codice non golfato:

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
Ti dispiacerebbe disinteressarlo? : D
— Knerd,
0

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

Il programma può generare quasi tutte le lettere maiuscole e minuscole. Poiché non sto usando un elenco di parole inglesi, viene utilizzata la prima chiave trovata nel dizionario. Ad esempio \ / \ / diventa vav. Se char è la prima lettera di una parola ToUpper viene applicato.

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

Ecco il mio risultato del test:

$ -> 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
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.