आपकी चुनौती सामान्य अंग्रेजी में अनुवाद (अंग्रेजी) लेट्सपेक / लोलस्पीक / txtspk अनुवाद करने का कार्यक्रम लिखना है। आपके कार्यक्रम को मानक इनपुट और आउटपुट से मानक आउटपुट तक पढ़ना चाहिए, जब तक कि आपकी भाषा इन का समर्थन नहीं करती है।

आप अंग्रेजी भाषा में शब्दों की एक सूची वाली एक फाइल का उपयोग कर सकते हैं, जिसे नई पंक्तियों द्वारा अलग किया गया है। इसे बुलाया जाना चाहिए Wऔर आपके कार्यक्रम के समान निर्देशिका में स्थित होगा। (जीएनयू / लिनक्स सिस्टम और संभवतः अन्य पर, आप Wएक लिंक बना सकते हैं /usr/share/dict/words) सूची में सभी-लोअरकेस होने की आवश्यकता नहीं है, आप यह निर्धारित करने के लिए उपयोग कर सकते हैं कि क्या शब्दों में राजधानियां होनी चाहिए।

यह निकोस एम द्वारा पोस्ट किए गए अब-हटाए गए प्रश्न पर आधारित है जो यहां पाया जा सकता है । यह कोई डुप्लिकेट नहीं है क्योंकि यह मूल प्रश्न बंद था और इसे कोई जवाब नहीं मिला, क्योंकि इसमें कोई जीत की कसौटी नहीं थी और उपयोगकर्ता एक को डालने के लिए तैयार नहीं था।

स्कोरिंग

स्कोरिंग थोड़ा जटिल है!

आपका स्कोर है

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

उच्चतम स्कोर जीतता है।

आपका कार्यक्रम होना आवश्यक नहीं है और शायद यह सही नहीं हो सकता है, लेकिन जितना अधिक सटीक होगा, उतना अधिक बोनस मिलेगा!

चूँकि $दोनों का अर्थ हो सकता है sऔर S, आपको यह तय करने के लिए 5 अंक प्रति लेट आइटम का बोनस मिलता है कि क्या इसमें एक कैपिटल लेटर (वाक्यों की शुरुआत में कैपिटल लेटर्स) होना चाहिए।

आपको उचित संज्ञा को लागू करने के लिए प्रति लेट आइटम पर 5 अंक का एक और बोनस मिलता है (जिन शब्दों में हमेशा राजधानियां होती हैं) - यह जिस तरह से काम करता है वह यह है कि आप शब्द सूची के माध्यम से देखेंगे, आउटपुट को पूंजीकृत बना देंगे यदि केवल एक पूंजीकृत संस्करण में मौजूद है। सूची, और यदि दोनों संस्करण हैं, तो केवल अनुमान लगाएं।

एक चरित्र के दो अर्थ हैं तो (उदाहरण के लिए 1हो सकता है Lया I), आप केवल जो वास्तविक अंग्रेजी शब्दों बनाने के मद में से जो अनुवाद चुनने के लिए leet प्रति आइटम 20 अंक मिलता है - इस के लिए शब्द सूची का उपयोग करें। यदि एक लेट आइटम का एक से अधिक अनुवाद एक वास्तविक अंग्रेजी शब्द बनाता है, तो आप मनमाने ढंग से मान्य अनुवादों में से एक चुन सकते हैं और अभी भी बोनस प्राप्त कर सकते हैं।

Leet की सूची

ये लेट आइटम हैं जिन्हें आप लागू कर सकते हैं। आपको उन सभी को लागू करने की आवश्यकता नहीं है, लेकिन जितना अधिक आप जोड़ते हैं, उतने अधिक अंक मिलते हैं।

आप कभी भी किसी वस्तु या चरित्र का स्वयं अनुवाद करके अंक नहीं बना सकते। यह नियम सूची में की गई किसी भी गलती से आगे निकल जाता है।

यह एक साधारण trया करने के लिए आकर्षक है s/.../.../g। वास्तविक चुनौती यह निर्धारित करना है कि वर्डलिस्ट का उपयोग करके कौन से कई अर्थ हो सकते हैं और सही नहीं हो सकते हैं।

लेट आइटम (इनमें से प्रत्येक `leet items`सूत्र में 1 जोड़ता है)

$ -> एस, एस
(-> सी, सी
5 -> एस, एस
@ -> ए, ए
4 -> ए, ए
3 -> ई, ई
7 -> टी, टी
+ -> टी, टी
# -> एच, एच
ते -> द
'd -> एड
pwnd -> चबाया हुआ
pwnt -> pwned
के, के -> ठीक है
kk -> ठीक है
0 [शून्य] -> ओ, ओ
y, Y -> क्यों
4 -> के लिए
txt -> पाठ
dafuq -> क्या च ** k
/ \, ^ -> ए, ए
\ / -> वी, वी
d00d -> यार
n00b -> नौसिखिया
\ / \ / -> डब्ल्यू, डब्ल्यू
8 -> बी, बी
| _ | -> यू, यू
| - | -> एच, एच
, -> आर, आर
j00 -> आप
जू -> आप
वीवी, वीवी -> डब्ल्यू, डब्ल्यू
टोमोज़ -> कल
| <-> के, के
[); |) -> डी, डी
<3 -> प्यार
> <-> एक्स, एक्स
10100111001 -> लेट (1337 का द्विआधारी प्रतिनिधित्व)
2 -> से भी
उर, यूआर -> आपका, आप (दोनों के बीच सही अंतर करने की कोई आवश्यकता नहीं है)
यू, यू -> आप
-> -ते-,-
x, X -> -ks -, - cks-
z, Z -> s, S
1 -> मैं, मैं, एल, एल
! -> मैं, मैं,!
सी, सी -> देखें, सी, समुद्र
बी, बी -> हो, बी, मधुमक्खी
[उच्चारण पत्र] -> [गैर-उच्चारण रूप] (स्कोर प्रति अक्षर समर्थित 1)
&, 7 -> और, एनीड, चींटी (एक शब्द के बीच में इस्तेमाल किया जा सकता है)

हार्डर "लेट": `leet items`प्रत्येक के लिए 30 अंक

!!! १ !! १-> !!!!!!! (1 के अनुक्रम में अनुवाद! 's में!' s)
!!! एक! -> !!!!
ग्यारह-> !!!

उदाहरण

ये ऐसे उदाहरण हैं जो एक कार्यक्रम है जो उपरोक्त सभी लेफ़्ट वर्णों को लागू करता है, और कुछ बोनस, ऐसा करने में सक्षम हो सकता है:

उदाहरण वाक्य: |-|3 15 $|_|(# @ n00b=He is such a newbie

लेट-आधारित सेंसरशिप: $#!+=s**t

अत्यधिक लेट: \/\/ 1 |< 1 P 3 [) 1 A=Wikipedia

-सुख प्रत्यय: 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।

code-challenge string natural-language

— totallyhuman
स्रोत

क्षमा करें, मैंने इसे सैंडबॉक्स में नहीं पकड़ा है, लेकिन यदि आप बोनस को 10 से गुणा कर रहे हैं, तो वे अभी भी शब्दों से बहुत अधिक मूल्य के हैं। क्या आपका इरादा ऐसा है?

— मार्टिन एंडर

@ m.buettner यह बस का उपयोग कर trया से निपटने के लिए है s/.../.../g। बस इस तरह की चीजों का अनुवाद करना एक उबाऊ चुनौती होगी, इसलिए हमें बेहतर अनुवादों को पुरस्कृत करने की आवश्यकता है जो शब्दसूची का उपयोग करते हैं

Regexps की एक लंबी श्रृंखला अनुमेय होगी? मैं यह देखना पसंद करूंगा कि क्या यह संभव था (यद्यपि इसके बावजूद) संदर्भ-जागरूक तरीके से ऐसा करना संभव था। (या शायद एक sedस्क्रिप्ट।)

— इसियाह मीडोज

जब मैं एक sedस्क्रिप्ट कहता हूं , तो मेरा मतलब एक साधारण से अधिक होता है s/.../.../g, लेकिन एक ऐसी फ़ाइल जो sedस्वयं द्वारा पार्स और निष्पादित की जाती है। जैसा कि भाषा के रूप में, यह एक सभ्य गोल्फ की भाषा हो सकती है ...

— मीडोज

@impinball Regexes बिल्कुल ठीक हैं, हालांकि मुझे नहीं पता कि आप शब्दसूची कैसे खोलेंगे और इसे केवल एक rexx भाषा के साथ पार्स करेंगे। sedस्क्रिप्ट भी ठीक हैं और बहुत दिलचस्प हो सकती हैं, वे इस पर बहुत अच्छा काम कर सकते थे। छोटे प्रतिस्थापन वाक्यविन्यास के कारण, आप शब्दसूची से पढ़ने में सक्षम हो सकते हैं, या तो जीएनयू एक्सटेंशन के साथ या sedएक बड़े बैश प्रोग्राम के भाग के रूप में उपयोग करके

11

जावास्क्रिप्ट (49 + 5635) * 10/2174 = 26.14

ऑनलाइन डेमो:

"रियल डिक्शनरी" विकल्प ड्रॉप बॉक्स पर काम नहीं करता है, लेकिन यह काम करेगा यदि यह एक वास्तविक वेब सर्वर में चलता है। दृश्य स्टूडियो विकास सर्वर और Google क्रोम में परीक्षण किया गया।

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

स्कोर:

49 लेट आइटम = 49

पूंजीकरण बोनस = 5 * 49 = 245

शब्दकोश लुकअप बोनस = 20 * 49 = 980

विस्मयादिबोधक बोनस * 3 = 90 * 49 = 4410

(लेट आइटम + बोनस) * 10 / (कोड लंबाई)

(४ ९ + ५६३५) * १० / २१ =४ = २६.१४

कोड:

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

परीक्षण के परिणाम:

| - | ३ १५ $ | _ | (# @ n00b ====> वह ऐसी ही नौसिखिया है
@ 1 // 4Y5 p0 $ + ur n3VV qu35710nz 1n teh $ & 80x ====> हमेशा सैंडबॉक्स में अपने नए प्रश्न पोस्ट करें
!!! १ !! १ ====> !!!!!!!
!!!एक! ====> !!!!!
ग्यारह ====> !!!
तेह !!! १ !! १ ====> द !!!!!!!
तेह !!! एक! ====> द !!!!
तेह! ग्यारह ====> द !!!
तेह !!! १ !! १ ====> द !!!!!!!
qu35710nz! 1! ====> प्रश्न !!!
+357 +357। 735+ ====> परीक्षण परीक्षण। परीक्षा
& 31; 73 # 4 (KER $ WR0 + 3 83773R L! K3 + #! 5 7 # @ N 2D @ Y ====> और कुलीन हैकर्स ने आज की तुलना में इस तरह बेहतर लिखा है

टिप्पणियाँ:

शब्दकोश एक अलग जावास्क्रिप्ट फ़ाइल है जिसमें एक वस्तु होती है जिसे डब्ल्यू शब्द कहा जाता है। इसमें केवल प्रासंगिक परीक्षण चलाने के लिए आवश्यक शब्द हैं।

— rdans
स्रोत

यदि आप इसे क्लोजर कंपाइलर के माध्यम से चलाते हैं तो यह केवल 1640 अक्षर आपके स्कोर को 34 तक लाता है।

— AMK

यह फाइल क्या करती है? dl.dropboxusercontent.com/u/141246873/leettranslator/… क्या यह केवल वेब से एक शब्दकोश प्राप्त करना है? (यानी W.jsअगर इसे हटा दिया जाता है तो प्रोग्राम चल सकता है)

@professorfish इसमें एक शब्दकोश के साथ एक बाहरी js lib है (दस अक्षरों तक शब्द)। इसका केवल तभी उपयोग किया जाता है जब डेमो पर 'वास्तविक शब्दकोश' विकल्प चुना जाता है। यह सिर्फ एक बेहतर शब्दकोश के साथ एक डेमो के लिए और मेरे आधिकारिक जवाब का हिस्सा नहीं है।

— रदंस

6

हास्केल - स्कोर 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"

— gxtaillon
स्रोत

द्वारा -ks-मैं ksएक शब्द के बीच में था । जैसे ही मुझे एक

बस haskell-platformपैकेज स्थापित करें । क्या आपके पास इसके लिए एक उदाहरण है ks?

— gxtaillon

<insertnamehere> rocXयाroX

मैंने इसका परीक्षण किया है, यह काम कर रहा है

1

एक शब्द और अनुवाद के बेहतर संचालन के साथ मेरे जवाब को अपडेट किया।

— gxtaillon

6

विस्तारित ब्रेनफैक : 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 वास्तव में गोल्फिंग के लिए नहीं बनाया गया है, लेकिन यह rle फीचर है, मैक्रोज़ और प्रिंट स्ट्रिंग फीचर, BrainFuck की तुलना में इसे कम करना आसान बनाता है। अंतिम संकलित ब्रेनफैक बाइनरी इस तरह दिखता है:

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

— Sylwester
स्रोत

1

संकलित बीएफ कोड ठीक काम करने के लिए लगता है, यह एक बीएफ कार्यक्रम के लिए बहुत छोटा लगता है

@professorfish का उपयोग करते हुए ~"OTLHEAND"मैं एक बार 107 बाइट्स ऑब्जेक्ट कोड के लिए एक बार सभी चार्ट बना सकता था बजाय उन्हें हर बार 0 से बनाने के लिए 354 का उपयोग करके, लेकिन मेरा उत्तर EBF कोड आकार के लिए अनुकूलित है :)

— सिल्वेस्टर

2

जावा: 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 लेट
लेट आइटम = 39 (अद्वितीय)
बोनस = 21 (पता नहीं है कि नकल किए गए मोमेंटमोरी की गणना कैसे करें) (कृपया सलाह दें)

((३ ९ + (२१ * ५)) * १०) / ११६५ = १.२३६

गैर-गोल्फ कोड:

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

— उदय शंकर
स्रोत

2

आप इसे ungolfing मन होगा? : D

— Knerd

0

सी # स्कोर 45 * 10/2556 = 0.176

कार्यक्रम लगभग सभी निचले और ऊपरी मामलों के पत्रों को आउटपुट कर सकता है। चूंकि मैं अंग्रेजी शब्द सूची का उपयोग नहीं कर रहा हूं, इसलिए शब्दकोश में पाई जाने वाली पहली कुंजी का उपयोग किया जाता है। जैसे \ / \ / vav हो जाता है। यदि एक शब्द ToUpper पर पहली बार char लगाया जाता है।

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

— bacchusbeale
स्रोत

अंग्रेजी अनुवाद के लिए लेट