मोबि डिक लिखें, लगभग


297

यहाँ एक 1.2Mb ASCII टेक्स्ट फाइल है जिसमें हर्मन मेलविले के मोबी-डिक का पाठ है ; या, व्हेल । आपका कार्य किसी प्रोग्राम या फंक्शन (या क्लास, आदि - नीचे देखें) को लिखना है, जिसे इस फ़ाइल को एक बार में एक वर्ण दिया जाएगा, और प्रत्येक चरण में अगले वर्ण का अनुमान लगाना होगा।

यह । आपका स्कोर होगा

2*L + E

Lबाइट्स में आपके सबमिशन का आकार कहां है, और Eयह गलत है इसका अनुमान लगाने वाले पात्रों की संख्या है। सबसे कम स्कोर जीतता है।

आगे का विवरण

आपका सबमिशन एक प्रोग्राम या फंक्शन (आदि) होगा जिसे कई बार कॉल या इनवाइट या सेंड किया जाएगा। (1215235 बार सटीक होने के लिए।) जब इसे n वें समय के लिए कहा जाता है, तो इसे n वें वर्ण दिया जाएगा whale.txtया whale2.txtइसे ( n + 1 ) वें वर्ण के लिए इसका अनुमान लगाना होगा । Eइसके स्कोर का घटक वर्णों की कुल संख्या होगी जो यह गलत अनुमान लगाता है।

अधिकांश सबमिशन को इनवोकेशन के बीच कुछ राज्य को स्टोर करने की आवश्यकता होगी, ताकि वे ट्रैक कर सकें कि उन्हें कितनी बार बुलाया गया है और पिछले इनपुट क्या थे। आप इसे किसी बाहरी फ़ाइल पर लिखकर, staticया वैश्विक चर का उपयोग करके, किसी फ़ंक्शन के बजाय एक कक्षा जमा करके, एक राज्य मोनाद का उपयोग करके, या जो कुछ भी आपकी भाषा के लिए काम करता है, उसे लिखकर कर सकते हैं। आपके सबमिशन में पहले आह्वान से पहले अपने राज्य को शुरू करने के लिए आवश्यक कोई भी कोड शामिल होना चाहिए।

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

आपके उत्तर में न केवल आपका सबमिशन शामिल होना चाहिए, बल्कि आपके Eस्कोर के भाग की गणना करने के लिए आपके द्वारा उपयोग किया जाने वाला कोड भी होना चाहिए । यह आपके सबमिशन के रूप में उसी भाषा में नहीं लिखा जाना चाहिए, और इसकी बाइट गिनती की ओर नहीं गिना जाएगा। आपको इसे पठनीय बनाने के लिए प्रोत्साहित किया जाता है।

आपके सबमिशन और इस स्कोर-कैलकुलेटिंग प्रोग्राम के बीच इंटरफेस के बारे में, कुछ भी ठीक है, जब तक कि आपका प्रोग्राम हमेशा इनपुट के अगले बाइट को प्राप्त करने से पहले आउटपुट का एक बाइट देता है। (इसलिए, उदाहरण के लिए, आप इसे केवल एक स्ट्रिंग नहीं दे सकते हैं जिसमें सभी इनपुट हों और एक स्ट्रिंग वापस प्राप्त करें जिसमें सभी आउटपुट हों।)

आपको वास्तव में अपना परीक्षण कार्यक्रम चलाना चाहिए और अपनी प्रविष्टि सबमिट करने से पहले अपने स्कोर की गणना / सत्यापन करना होगा। यदि आपका सबमिशन आपके स्कोर को सत्यापित करने के लिए बहुत धीरे-धीरे चलता है तो यह प्रतिस्पर्धा करने के लिए योग्य नहीं है, भले ही आपको पता हो कि सिद्धांत में इसका स्कोर क्या होगा।

Lअपने स्कोर के घटक कोड गोल्फ चुनौतियों के लिए हमेशा की तरह नियमों के अनुसार गणना की जाएगी। यदि आपके सबमिशन में कई फाइलें होंगी, तो कृपया उस स्थिति में स्कोरिंग और डायरेक्टरी स्ट्रक्चर पर नियमों का ध्यान रखें । आपके कोड का उपयोग करने वाला कोई भी डेटा आपके Lस्कोर में शामिल होना चाहिए ।

आप मौजूदा पुस्तकालयों का आयात कर सकते हैं लेकिन किसी अन्य बाहरी फ़ाइल को लोड नहीं कर सकते हैं, और आपका कोड whale.txtया तक नहीं पहुंच सकता हैwhale2.txtऊपर वर्णित के अलावा किसी भी तरह से फ़ाइल। आप किसी भी पूर्व-प्रशिक्षित तंत्रिका नेटवर्क या सांख्यिकीय डेटा के अन्य स्रोतों को लोड नहीं कर सकते हैं। (यह तंत्रिका नेटवर्क का उपयोग करने के लिए ठीक है, लेकिन आपको अपने जमाव में वेट डेटा को शामिल करना होगा और इसे अपनी बाइट की गिनती में बदलना होगा।) यदि किसी कारण से आपकी भाषा या पुस्तकालयों में एक ऐसी सुविधा शामिल है जो Moby डिक के कुछ या सभी पाठ प्रदान करती है। , आप उस सुविधा का उपयोग नहीं कर सकते हैं। इसके अलावा आप किसी भी अन्य अंतर्निहित या लाइब्रेरी सुविधाओं का उपयोग कर सकते हैं, जिन्हें आप पसंद करते हैं, जिनमें टेक्स्ट प्रोसेसिंग, भविष्यवाणी या संपीड़न से संबंधित, जब तक वे आपकी भाषा या इसके मानक पुस्तकालयों का हिस्सा हैं। अधिक विदेशी, विशेष दिनचर्या के लिए जिसमें सांख्यिकीय डेटा के स्रोत शामिल हैं, आपको उन्हें स्वयं लागू करना होगा और उन्हें अपनी बाइट की गिनती में शामिल करना होगा।

यह संभावना है कि कुछ प्रस्तुतियाँ में घटक शामिल होंगे जो कोड द्वारा स्वयं उत्पन्न होते हैं। यदि यह मामला है, तो कृपया अपने उत्तर में उस कोड को शामिल करें जिसका उपयोग उन्हें उत्पादन करने के लिए किया गया था, और यह बताएं कि यह कैसे काम करता है । (जब तक आपके सबमिशन को चलाने के लिए इस कोड की आवश्यकता नहीं होती है तब तक यह आपके बाइट काउंट में शामिल नहीं होगा।)

ऐतिहासिक कारणों से, फ़ाइल के दो संस्करण हैं, और आप उनमें से किसी एक उत्तर में उपयोग कर सकते हैं। में whale2.txt(ऊपर लिंक किया गया) पाठ लपेटा नहीं गया है, इसलिए नए खंड केवल पैराग्राफ के अंत में दिखाई देते हैं। मूल whale.txtमें पाठ को 74 अक्षरों की चौड़ाई से लपेटा गया है, इसलिए आपको प्रत्येक पंक्ति के अंत के साथ-साथ पाठ की भविष्यवाणी भी करनी होगी। यह चुनौती को और अधिक महत्वपूर्ण बनाता है, इसलिए whale2.txtनए उत्तरों के लिए सिफारिश की जाती है। दोनों फाइलें समान आकार, 1215236 बाइट्स हैं।


संक्षेप में, सभी उत्तरों में निम्नलिखित बातें शामिल होनी चाहिए:

  • अपना सबमिशन। (कोड, प्लस किसी भी डेटा फ़ाइलों का उपयोग करता है - ये बड़े होने पर लिंक हो सकते हैं।)
  • आपका कोड कैसे काम करता है, इसका स्पष्टीकरण। कृपया I / O विधि की व्याख्या करें और साथ ही यह अगले वर्ण की भविष्यवाणी कैसे करें। आपके एल्गोरिथ्म की व्याख्या महत्वपूर्ण है, और अच्छी व्याख्याएं मुझसे आय अर्जित करेंगी।
  • वह कोड जिसका उपयोग आपने अपने स्कोर का मूल्यांकन करने के लिए किया था। (यदि यह पिछले उत्तर के समान है तो आप इसे लिंक कर सकते हैं।)
  • उस कोड की व्याख्या के साथ , आपके द्वारा सबमिट किया गया कोई भी कोड। इसमें वह कोड शामिल है जिसका उपयोग आपने मापदंडों का अनुकूलन करने, डेटा फ़ाइलों को उत्पन्न करने आदि के लिए किया है (यह आपके बाइट की गिनती की ओर नहीं है, लेकिन आपके उत्तर में शामिल होना चाहिए)

लीडरबोर्ड

bounties

समय-समय पर विभिन्न दृष्टिकोणों को प्रोत्साहित करने के लिए मैं इनामों की पेशकश करूंगा।

पहले एक, 50 अंक, उस समय सर्वश्रेष्ठ स्कोरिंग उत्तर के लिए ए रेक्स से सम्मानित किया गया था।

दूसरा, 100 अंक, ए रेक्स को भी इसी उत्तर के लिए प्रदान किया गया था, क्योंकि उन्होंने अपने मौजूदा उत्तर में बहुत अच्छी व्याख्या जोड़ी है।

अगले अंक , 200 अंक , दोनों को प्रदान किया जाएगा

  • एक प्रतिस्पर्धी उत्तर जो एक नई तकनीक का उपयोग करता है। (यह मेरे व्यक्तिपरक निर्णय पर आधारित होगा क्योंकि यह मेरा प्रतिनिधि है जो इनाम में जाता है, लेकिन आप मुझ पर विश्वास करने के लिए निष्पक्ष हो सकते हैं। ध्यान दें कि आपके उत्तर में यह समझने के लिए मेरे लिए पर्याप्त स्पष्टीकरण होना चाहिए कि यह कैसे काम करता है!) इस तरह के उत्तर की आवश्यकता है 'शीर्ष स्कोर को न लें, इसे मौजूदा उत्तरों की तुलना में बहुत अच्छा करने की जरूरत है। मैं विशेष रूप से आवर्तक तंत्रिका नेटवर्क के आधार पर समाधान देखने के लिए उत्सुक हूं, लेकिन मैं मार्कोव मॉडल से काफी भिन्न प्रतीत होने वाली किसी भी चीज़ को इनाम दूंगा जो वर्तमान शीर्ष स्कोर पर हावी है।

या:

  • कोई और जो किसी भी विधि का उपयोग करके ए रेक्स के शीर्ष स्कोर (वर्तमान में 444444) को हराता है।

एक बार 200 अंक की बाउंटी का दावा किया जाता है, तो मैं सबसे अधिक संभावना के अनुसार आवश्यकताओं को अद्यतन करते हुए, 400 बिंदुओं की पेशकश करूंगा।


टिप्पणियाँ विस्तारित चर्चा के लिए नहीं हैं; इस वार्तालाप को बातचीत में स्थानांतरित कर दिया गया है ।
डेनिस

9
xkcd.com/1960 इस चुनौती का संदर्भ प्रतीत होता है!
ए रेक्स

मैं इस संपीड़ित करने के बारे में सोचा ... लेकिन यह थोड़ा बहुत लंबा है कि मेरे कंप्यूटर दुर्घटनाग्रस्त हो गया है कंधे उचकाने की क्रिया
Naruyoko

जवाबों:


135

/// , 2 * 1 + 1020874 = 1020876

 

एक स्पेस प्रिंट करता है।


टिप्पणियाँ विस्तारित चर्चा के लिए नहीं हैं; इस वार्तालाप को बातचीत में स्थानांतरित कर दिया गया है ।
डेनिस

यह कुछ बहुत ही स्मार्ट इनाम हैकिंग है! आपको एक एजीआई होना चाहिए;)
एलेक्स

97

नोड.जेएस, 2 * 224 + 524279 = 524727

कृपया स्कोर अपडेट के लिए इस पोस्ट के अंत में परिवर्तन लॉग देखें।

बाइट लेने और वापस करने का एक कार्य।

a=[...l='14210100'],m={},s={},b={}
f=c=>a.some((t,n)=>x=s[y=l.slice(n)]>t|/^[A-Z '"(]/.test(y)&&b[y],l+=String.fromCharCode(c),a.map((_,n)=>(m[x=l.slice(n)]=-~m[x])<s[y=l.slice(n,8)]||(s[y]=m[x],b[y]=c)),l=l.slice(1))&&x||32

इसमें एक साधारण पीपीएम मॉडल होता है जो अगले 8 की भविष्यवाणी करने वाले अगले अक्षर को देखता है।

हम लंबाई एल के एक पैटर्न पर भरोसा करते हैं जब हमने इसे कम से कम टी [एल] बार सामना किया है , जहां टी मनमानी थ्रेसहोल्ड की एक सरणी है: [1,1,2,1,2,3,5,2] । इसके अलावा, हम हमेशा एक पैटर्न पर भरोसा करते हैं जिसका पहला चरित्र मेल खाता है [A-Z '"(]

हम सबसे लंबे भरोसेमंद पैटर्न का चयन करते हैं और कॉल के समय इस पैटर्न से जुड़े उच्चतम स्कोर के साथ भविष्यवाणी लौटाते हैं।

टिप्पणियाँ

  • यह स्पष्ट रूप से गति के लिए अनुकूलित नहीं है, लेकिन यह मेरे लैपटॉप पर लगभग 15 सेकंड में चलता है।

  • यदि हमें मॉडल को रीसेट किए बिना एक पंक्ति में कई बार प्रक्रिया को दोहराने की अनुमति दी गई थी, तो 5 पुनरावृत्तियों के बाद त्रुटियों की संख्या ~ 268000 में बदल जाएगी।

  • भविष्यवाणी समारोह की वर्तमान सफलता दर ~ 56.8% है। जैसा कि टिप्पणियों में @immibis द्वारा देखा गया है, अगर खराब और सही अनुमानों को एक साथ मिलाया जाता है, तो परिणाम भी मुश्किल से पढ़ने योग्य नहीं है।

    उदाहरण के लिए, पुस्तक के अंत के पास यह स्निपेट:

    Here be it said, that this pertinacious pursuit of one particular whale,[LF]
    continued through day into night, and through night into day, is a thing[LF]
    by no means unprecedented in the South sea fishery.
    

    हो जाता है:

    "e e be it said, that thes woacangtyous sarsuet of tie oort cular thale[LF][LF]
     orsinued toeough tir on e togh   and sheough toght an o ters af t shin[LF][LF]
    be to means insrocedented tn hhe sputh Sevsaonh ry,
    

    अंडरस्कोर के साथ खराब अनुमानों को हटाकर, हमारे पास एक बेहतर विचार है कि फ़ंक्शन क्या सही है:

    _e_e be it said, that th_s _____n___ous __rsu_t of __e __rt_cular _hale_[LF]
    _o__inued t__ough ___ _n__ __gh__ and _h_ough __ght _n_o ____ __ _ _hin_[LF]
    b_ _o means _n_r_cedented _n _he __uth _e_____h_ry_
    

    एनबी : उपरोक्त उदाहरण को इनपुट फ़ाइल के पहले संस्करण पर काम करते हुए, कोड के पिछले संस्करण के साथ बनाया गया था।

टेस्ट कोड

/**
  The prediction function f() and its variables.
*/
a=[...l='14210100'],m={},s={},b={}
f=c=>a.some((t,n)=>x=s[y=l.slice(n)]>t|/^[A-Z '"(]/.test(y)&&b[y],l+=String.fromCharCode(c),a.map((_,n)=>(m[x=l.slice(n)]=-~m[x])<s[y=l.slice(n,8)]||(s[y]=m[x],b[y]=c)),l=l.slice(1))&&x||32

/**
  A closure containing the test code and computing E.
  It takes f as input.
  (f can't see any of the variables defined in this scope.)
*/
;
(f => {
  const fs = require('fs');

  let data = fs.readFileSync('whale2.txt'),
      len = data.length,
      err = 0;

  console.time('ElapsedTime');

  data.forEach((c, i) => {
    i % 100000 || console.log((i * 100 / len).toFixed(1) + '%');

    if(i < len - 1 && f(c) != data[i + 1]) {
      err++;
    }
  })

  console.log('E = ' + err);
  console.timeEnd('ElapsedTime');
})(f)

लॉग बदलें

  • 524727 - whale2.txt (चुनौती अद्यतन) पर स्विच करके 19644 अंक बचाए गए
  • 544371 - एक कैपिटल लेटर, एक उद्धरण, एक डबल- कोट्स या एक ओपनिंग कोष्ठक के साथ शुरू होने वाले पैटर्न को मजबूर करके 327 अंक बचाया गया।
  • 544698 - हमेशा भरोसेमंद होने के लिए एक स्थान से शुरू होने वाले पैटर्न को मजबूर करके 2119 अंक बचाए
  • 546817 - थ्रेसहोल्ड को समायोजित करके और भविष्यवाणी फ़ंक्शन को गोल करके 47 अंक बचाया
  • 546864 - अधिकतम पैटर्न लंबाई को 8 वर्णों तक बढ़ाकर 1496 अंक बचाए गए
  • 548360 - विश्वसनीय पैटर्न की धारणा को पेश करके 6239 अंकों की बचत की गई, जिसमें उनकी लंबाई के आधार पर थ्रेसहोल्ड थे
  • 554599 - लाइन फीड भविष्यवाणी में सुधार करके 1030 अंक बचाया
  • ५५५६२ ९ - भविष्यवाणी समारोह को गोल्फ द्वारा २२ अंक बचाया
  • 555651 - भविष्यवाणी कार्य को पूरा करके 40 अंक बचाए गए
  • 555691 - प्रारंभिक स्कोर

44
जिज्ञासु के लिए, नहीं, यह मोबी डिक की तरह कुछ भी पैदा नहीं करता है। यह पूरी तरह से है sidg tlanses,oeth to, shuld hottut tild aoersors Ch, th! Sa, yr! Sheu arinning whales aut ihe e sl he traaty of rrsf tg homn Bho dla tiasot a shab sor ty, af etoors tnd hocket sh bts ait mtubb tiddin tis aeewnrs, dnhost maundy cnd sner aiwt d boelh cheugh -aaieiyns aasiyns taaeiins! th, tla। यह कभी-कभी कुछ पूर्ण शब्द प्राप्त करने का प्रबंधन करता है। की तरह whales
इनिबिस

23
@immibis चुनौती का शीर्षक बुद्धिमानी से चुना गया था। यह मोबि डिक है, लगभग । :-)
अरनुलद

3
@ नथानियल कई अपडेट हो चुके हैं, इसलिए यह मुश्किल से पढ़ने योग्य होगा और वास्तव में जानकारीपूर्ण नहीं होगा। मैंने सुधार के बारे में संक्षिप्त स्पष्टीकरण के बजाय एक परिवर्तन लॉग जोड़ा है।
अरनौलड

45
मुझे लगता है कि आपका कार्यक्रम वास्तव में गेलिक में एक सटीक अनुवाद कर रहा है।
बस्का

1
@ Draco18s यह बताना मुश्किल है कि यह अल्पविराम अच्छा था या बुरा। यदि यह एक बुरा अनुमान था, तो एक बार प्राप्त होने के बाद, जो भी अन्य-अक्षर-कि-वास्तव में वहाँ-की-जगह-अल्पविराम था , के बाद भविष्यवाणी समारोह ने वैध रूप से एक पत्र लगाने की कोशिश की हो सकती है ।
अरनौलद

91

पर्ल, 2 · 70525 + 326508 = 467558

भविष्यवक्ता

$m=($u=1<<32)-1;open B,B;@e=unpack"C*",join"",<B>;$e=2903392593;sub u{int($_[0]+($_[1]-$_[0])*pop)}sub o{$m&(pop()<<8)+pop}sub g{($h,%m,@b,$s,$E)=@_;if($d eq$h){($l,$u)=(u($l,$u,$L),u($l,$u,$U));$u=o(256,$u-1),$l=o($l),$e=o(shift@e,$e)until($l^($u-1))>>24}$M{"@c"}{$h}++-++$C{"@c"}-pop@c for@p=($h,@c=@p);@p=@p[0..19]if@p>20;@c=@p;for(@p,$L=0){$c="@c";last if" "ne pop@c and@c<2 and$E>99;$m{$_}+=$M{$c}{$_}/$C{$c}for sort keys%{$M{$c}};$E+=$C{$c}}$s>5.393*$m{$_}or($s+=$m{$_},push@b,$_)for sort{$m{$b}<=>$m{$a}}sort keys%m;$e>=u($l,$u,$U=$L+$m{$_}/$s)?$L=$U:return$d=$_ for sort@b}

इस प्रोग्राम को चलाने के लिए, आपको यहां इस फाइल की आवश्यकता है , जिसे नाम दिया जाना चाहिए B। (आप ऊपर दिए गए वर्ण के दूसरे उदाहरण में इस फ़ाइल नाम को बदल सकते हैं B।) इस फ़ाइल को बनाने के लिए नीचे देखें।

यह प्रोग्राम अनिवार्य रूप से मार्कोव मॉडल के संयोजन का उपयोग करता है, जैसा कि इस उत्तर में user2699 द्वारा किया गया है , लेकिन कुछ छोटे संशोधनों के साथ। यह अगले चरित्र के लिए एक वितरण पैदा करता है । हम सूचना सिद्धांत का उपयोग यह तय करने के लिए करते हैं कि त्रुटि को स्वीकार करना है या Bएन्कोडिंग संकेत में भंडारण के बिट्स खर्च करना है (और यदि हां, तो कैसे)। हम मॉडल से भिन्नात्मक बिट्स को स्टोर करने के लिए अंकगणित कोडिंग का उपयोग करते हैं ।

कार्यक्रम 582 बाइट्स (एक अनावश्यक अंतिम न्यूलाइन सहित) और बाइनरी फ़ाइल B69942 बाइट्स लंबा है, इसलिए कई फ़ाइलों को स्कोर करने के नियमों के तहत , हम L582 + 69942 + 1 = 70525 स्कोर करते हैं।

कार्यक्रम को लगभग निश्चित रूप से 64-बिट (थोड़ा-एंडियन?) वास्तुकला की आवश्यकता होती है। m5.largeAmazon EC2 पर एक इंस्टेंस पर चलने में लगभग 2.5 मिनट लगते हैं।

टेस्ट कोड

# Golfed submission
require "submission.pl";

use strict; use warnings; use autodie;

# Scoring length of multiple files adds 1 penalty
my $length = (-s "submission.pl") + (-s "B") + 1;

# Read input
open my $IN, "<", "whale2.txt";
my $input = do { local $/; <$IN> };

# Run test harness
my $errors = 0;
for my $i ( 0 .. length($input)-2 ) {
    my $current = substr $input, $i, 1;
    my $decoded = g( $current );

    my $correct = substr $input, $i+1, 1;
    my $error_here = 0 + ($correct ne $decoded);
    $errors += $error_here;
}

# Output score
my $score = 2 * $length + $errors;
print <<EOF;
length $length
errors $errors
score  $score
EOF

परीक्षण हार्नेस मानता है कि सबमिशन फाइल में है submission.pl, लेकिन इसे दूसरी पंक्ति में आसानी से बदला जा सकता है।

पाठ तुलना

"And did none of ye see it before?" cried Ahab, hailing the perched men all around him.\\"I saw him almost that same instant, sir, that Captain 
"And wid note of te fee bt seaore   cried Ahab, aasling the turshed aen inl atound him. \"' daw him wsoost thot some instant, wer, that Saptain 
"And _id no_e of _e _ee _t _e_ore__ cried Ahab, _a_ling the __r_hed _en __l a_ound him._\"_ _aw him ___ost th_t s_me instant, __r, that _aptain 

Ahab did, and I cried out," said Tashtego.\\"Not the same instant; not the same--no, the doubloon is mine, Fate reserved the doubloon for me. I 
Ahab aid  ind I woued tut,  said tashtego, \"No, the same instant, tot the same -tow nhe woubloon ws mane. alte ieserved the seubloon ior te, I 
Ahab _id_ _nd I ___ed _ut,_ said _ashtego__\"No_ the same instant_ _ot the same_-_o_ _he _oubloon _s m_ne_ __te _eserved the __ubloon _or _e_ I 

only; none of ye could have raised the White Whale first. There she blows!--there she blows!--there she blows! There again!--there again!" he cr
gnly  towe of ye sould have tersed the shite Whale aisst  Ihere ihe blows! -there she blows! -there she blows! Ahere arains -mhere again!  ce cr
_nly_ _o_e of ye _ould have ___sed the _hite Whale _i_st_ _here _he blows!_-there she blows!_-there she blows! _here a_ain__-_here again!_ _e cr

यह नमूना ( किसी अन्य उत्तर में चुना गया ) पाठ में देर से होता है, इसलिए मॉडल इस बिंदु से काफी विकसित होता है। याद रखें कि मॉडल "संकेत" के 70 किलोबाइट्स द्वारा संवर्धित है जो सीधे पात्रों को अनुमान लगाने में मदद करता है; यह केवल ऊपर दिए गए कोड के छोटे स्निपेट द्वारा संचालित नहीं है।

संकेत उत्पन्न करना

निम्न प्रोग्राम ऊपर दिए गए सटीक सबमिशन कोड (मानक इनपुट पर) को स्वीकार करता है और सटीक Bफ़ाइल को ऊपर (मानक आउटपुट पर ) उत्पन्न करता है :

@S=split"",join"",<>;eval join"",@S[0..15,64..122],'open W,"whale2.txt";($n,@W)=split"",join"",<W>;for$X(0..@W){($h,$n,%m,@b,$s,$E)=($n,$W[$X]);',@S[256..338],'U=0)',@S[343..522],'for(sort@b){$U=($L=$U)+$m{$_}/$s;if($_ eq$n)',@S[160..195],'X<128||print(pack C,$l>>24),',@S[195..217,235..255],'}}'

सबमिशन के रूप में इसे चलाने के लिए लगभग उतना ही समय लगता है, क्योंकि यह समान संगणना करता है।

व्याख्या

इस खंड में, हम यह वर्णन करने का प्रयास करेंगे कि यह समाधान पर्याप्त विस्तार से क्या करता है कि आप "इसे घर पर आज़माएं"। मुख्य तकनीक जो अन्य लोगों से इस उत्तर को अलग करती है, "रिवाइंड" तंत्र के रूप में कुछ खंड नीचे है, लेकिन इससे पहले कि हम वहां पहुंचें, हमें मूल बातें स्थापित करने की आवश्यकता है।

आदर्श

समाधान का मूल घटक एक भाषा मॉडल है। हमारे उद्देश्यों के लिए, एक मॉडल एक ऐसी चीज है जो अंग्रेजी पाठ की कुछ राशि लेता है और अगले चरित्र पर एक संभावना वितरण देता है । जब हम मॉडल का उपयोग करते हैं, तो अंग्रेजी पाठ मोबी डिक का कुछ (सही) उपसर्ग होगा। कृपया ध्यान दें कि वांछित आउटपुट एक वितरण है , और सबसे संभावित चरित्र के लिए केवल एक अनुमान नहीं है।

हमारे मामले में, हम अनिवार्य रूप से इस उत्तर में मॉडल का उपयोग user2699 द्वारा करते हैं । हमने एंडर्स कसेग द्वारा उच्चतम स्कोरिंग उत्तर (अपने स्वयं के अलावा) से मॉडल का सटीक रूप से उपयोग नहीं किया क्योंकि हम एक सर्वोत्तम अनुमान के बजाय वितरण को निकालने में असमर्थ थे। सिद्धांत रूप में, यह उत्तर एक भारित ज्यामितीय माध्य की गणना करता है, लेकिन हमें कुछ खराब परिणाम मिले जब हमने इसकी व्याख्या की। हमने एक मॉडल को दूसरे उत्तर से चुरा लिया है क्योंकि हमारा "गुप्त सॉस" मॉडल नहीं है, बल्कि समग्र दृष्टिकोण है। यदि किसी के पास "बेहतर" मॉडल है, तो उन्हें हमारी बाकी तकनीकों का उपयोग करके बेहतर परिणाम प्राप्त करने में सक्षम होना चाहिए।

एक टिप्पणी के रूप में, लेम्पेल-ज़िव जैसी अधिकांश संपीड़न विधियों को इस तरह से "भाषा मॉडल" के रूप में देखा जा सकता है, हालांकि किसी को थोड़ा सा भटकना पड़ सकता है। (यह विशेष रूप से एक ऐसी चीज़ के लिए बहुत मुश्किल है जो एक बर्स-व्हीलर को रूपांतरित करता है!) इसके अलावा, ध्यान दें कि user2699 द्वारा मॉडल मार्कोव मॉडल का एक संशोधन है; अनिवार्य रूप से और कुछ भी इस चुनौती के लिए प्रतिस्पर्धी नहीं है या शायद सामान्य रूप से पाठ भी मॉडलिंग कर रहा है।

कुल मिलाकर वास्तुकला

समझ के प्रयोजनों के लिए, कई टुकड़ों में समग्र वास्तुकला को तोड़ना अच्छा है। उच्चतम-स्तर के दृष्टिकोण से, राज्य प्रबंधन कोड का थोड़ा सा होना आवश्यक है। यह विशेष रूप से दिलचस्प नहीं है, लेकिन पूर्णता के लिए हम तनाव चाहते हैं कि हर बिंदु पर कार्यक्रम अगले अनुमान के लिए कहा जाए, यह इसके लिए Moby Dick का एक सही उपसर्ग उपलब्ध है। हम किसी भी तरह से अपने अतीत के गलत अनुमानों का उपयोग नहीं करते हैं। दक्षता के लिए, भाषा मॉडल संभवत: अपने राज्य को पहले N अक्षर से अपने राज्य की गणना करने के लिए पहले (N + 1) वर्णों के लिए पुन: उपयोग कर सकता है, लेकिन सिद्धांत रूप में, यह हर बार आह्वान किए जाने पर चीजों को खरोंच से फिर से जोड़ सकता है।

आइए कार्यक्रम के इस मूल "चालक" को एक तरफ सेट करें और उस हिस्से के अंदर झांकें जो अगले चरित्र का अनुमान लगाता है। यह तीन भागों को अलग करने के लिए वैचारिक रूप से मदद करता है: भाषा मॉडल (ऊपर चर्चा की गई), एक "संकेत" फ़ाइल, और एक "दुभाषिया"। प्रत्येक चरण में, दुभाषिया अगले चरित्र के लिए वितरण के लिए भाषा मॉडल पूछेगा और संभवतः संकेत फ़ाइल से कुछ जानकारी पढ़ेगा। फिर यह इन भागों को एक अनुमान में संयोजित करेगा। वास्तव में संकेत फ़ाइल में क्या जानकारी है और साथ ही इसका उपयोग कैसे किया जाता है, इसके बारे में बाद में बताया जाएगा, लेकिन अब यह इन भागों को मानसिक रूप से अलग रखने में मदद करता है। ध्यान दें कि कार्यान्वयन-वार, संकेत फ़ाइल का शाब्दिक रूप से एक अलग (बाइनरी) फ़ाइल है, लेकिन यह प्रोग्राम के अंदर संग्रहीत एक स्ट्रिंग या कुछ हो सकता है। एक सन्निकटन के रूप में,

यदि कोई इस जवाब में bzip2 जैसी मानक संपीड़न विधि का उपयोग कर रहा है , तो "संकेत" फ़ाइल संपीड़ित फ़ाइल से मेल खाती है। "दुभाषिया" डिकम्प्रेसर से मेल खाता है, जबकि "भाषा मॉडल" थोड़ा सा निहित है (जैसा कि ऊपर उल्लेख किया गया है)।

क्यों एक संकेत फ़ाइल का उपयोग करें?

चलो आगे का विश्लेषण करने के लिए एक सरल उदाहरण चुनें। मान लीजिए कि पाठ Nएक मॉडल द्वारा वर्ण लंबा और सुव्यवस्थित है, जिसमें प्रत्येक वर्ण स्वतंत्र रूप से अक्षर है ( Eसंभावना ) एक आधे से थोड़ा कम, Tइसी तरह संभावना के साथ थोड़ा कम आधे से अधिक, और Aसंभावना 1/1000 = 0.1% के साथ। मान लें कि कोई अन्य वर्ण संभव नहीं है; किसी भी मामले में, Aनीले रंग के पहले अनदेखे चरित्र के मामले के समान सुंदर है।

यदि हम L 0 शासन में संचालित होते हैं (जैसा कि अधिकांश, लेकिन सभी नहीं, तो इस प्रश्न के अन्य उत्तरों के लिए), दुभाषिए के लिए इससे बेहतर कोई रणनीति नहीं है कि वह Eऔर में से किसी एक को चुनें T। औसतन, यह लगभग आधे पात्रों को सही करेगा। तो ई / एन / 2 और स्कोर 2 एन / 2 भी। हालांकि, अगर हम एक संपीड़न रणनीति का उपयोग करते हैं, तो हम प्रति चरित्र एक से थोड़ा अधिक संपीड़ित कर सकते हैं। क्योंकि L को बाइट्स में गिना जाता है, इसलिए हमें L 8 N / 8 मिलता है और इस तरह count N / 4 स्कोर होता है, जो पिछली रणनीति से दोगुना है।

इस मॉडल के लिए प्रति वर्ण एक से थोड़ा अधिक की दर को प्राप्त करना थोड़ा असम्भव है, लेकिन एक विधि अंकगणित कोडिंग है।

अंकगणित कोडिंग

जैसा कि आमतौर पर जाना जाता है, एन्कोडिंग बिट्स / बाइट्स का उपयोग करके कुछ डेटा का प्रतिनिधित्व करने का एक तरीका है। उदाहरण के लिए, ASCII अंग्रेजी पाठ और संबंधित वर्णों का 7 बिट / कैरेक्टर एन्कोडिंग है, और यह विचाराधीन मूल मोबी डिक फ़ाइल का एन्कोडिंग है। यदि कुछ अक्षर दूसरों की तुलना में अधिक सामान्य हैं, तो ASCII जैसी निश्चित-चौड़ाई वाली एन्कोडिंग इष्टतम नहीं है। ऐसी स्थिति में, कई लोग हफ़मैन कोडिंग के लिए पहुंचते हैं । यह इष्टतम है यदि आप प्रति वर्ण बिट्स के पूर्णांक संख्या के साथ एक निश्चित (उपसर्ग-मुक्त) कोड चाहते हैं।

हालांकि, अंकगणित कोडिंग और भी बेहतर है। मोटे तौर पर, यह जानकारी को एन्कोड करने के लिए "आंशिक" बिट्स का उपयोग करने में सक्षम है। ऑनलाइन अंकगणित कोडिंग के लिए कई गाइड उपलब्ध हैं। हम यहां उपलब्ध विवरण (विशेष रूप से व्यावहारिक कार्यान्वयन की, जो कि प्रोग्रामिंग के नजरिए से थोड़ी मुश्किल हो सकती है) को ऑनलाइन उपलब्ध अन्य संसाधनों के कारण छोड़ सकते हैं, लेकिन अगर कोई शिकायत करता है, तो शायद यह खंड अधिक समाप्त हो जाए।

यदि किसी के पास वास्तव में एक ज्ञात भाषा मॉडल द्वारा उत्पन्न पाठ है, तो अंकगणित कोडिंग उस मॉडल से पाठ का अनिवार्य रूप से इष्टतम एन्कोडिंग प्रदान करता है। कुछ अर्थों में, यह उस मॉडल के लिए संपीड़न समस्या को हल करता है। (इस प्रकार, व्यवहार में, मुख्य मुद्दा यह है कि मॉडल ज्ञात नहीं है, और कुछ मॉडल मानव पाठ की मॉडलिंग में दूसरों की तुलना में बेहतर हैं।) यदि इस प्रतियोगिता में त्रुटियां करने की अनुमति नहीं थी, तो पिछले अनुभाग की भाषा में , इस चुनौती के समाधान का उत्पादन करने का एक तरीका भाषा मॉडल से "संकेत" फ़ाइल उत्पन्न करने के लिए एक अंकगणित एनकोडर का उपयोग करना होगा और फिर "इंटरप्रेटर" के रूप में एक अंकगणितीय डिकोडर का उपयोग करना होगा।

इस अनिवार्य-इष्टतम एन्कोडिंग में, हम प्रायोजन p के साथ एक चरित्र के लिए खर्च -log_2 (p) बिट्स को समाप्त करते हैं, और एन्कोडिंग की समग्र बिट-दर शैनन एन्ट्रॉपी है । इसका मतलब है कि 1/2 के पास प्रायिकता वाले चरित्र को एन्कोड करने में लगभग एक बिट लगता है, जबकि प्रायिकता 1/1000 के साथ लगभग 10 बिट्स लेता है (क्योंकि 2 ^ 10 लगभग 1000 है)।

लेकिन इस चुनौती के लिए स्कोरिंग मीट्रिक को इष्टतम रणनीति के रूप में संपीड़न से बचने के लिए अच्छी तरह से चुना गया था। हम एक छोटे संकेत फ़ाइल प्राप्त करने के लिए एक व्यापार के रूप में कुछ त्रुटियों को बनाने के लिए किसी तरह का पता लगाना होगा। उदाहरण के लिए, एक रणनीति जो एक कोशिश हो सकती है वह एक सरल शाखा रणनीति है: हम आम तौर पर अंकगणितीय एन्कोडिंग का उपयोग करने की कोशिश करते हैं जब हम कर सकते हैं, लेकिन अगर मॉडल से संभावना वितरण "खराब" है तो किसी तरह से हम केवल सबसे अधिक संभावना चरित्र और डॉन का अनुमान लगाते हैं ' t इसे एन्कोड करने का प्रयास करें।

गलतियाँ क्यों?

आइए पहले से उदाहरण का विश्लेषण करें कि हम क्यों "जानबूझकर" त्रुटियां करना चाहते हैं प्रेरित करने के लिए। यदि हम सही वर्ण को कूटबद्ध करने के लिए अंकगणित कोडिंग का उपयोग करते हैं, तो हम लगभग एक बिट Eया एक के मामले में खर्च करेंगे T, लेकिन एक के मामले में लगभग दस बिट्स A

कुल मिलाकर, यह एक बहुत अच्छा एन्कोडिंग है, प्रति संभावना पर थोड़ा सा खर्च करना, भले ही तीन संभावनाएं हों; मूल रूप से, Aकाफी संभावना नहीं है और हम इसके अक्सर दस बिट्स भी खर्च नहीं करते हैं। हालाँकि, क्या यह अच्छा नहीं होगा यदि हम इसके बजाय एक त्रुटि कर सकते हैं A? आखिरकार, समस्या के लिए मीट्रिक 1 बाइट = 8 बिट्स की लंबाई को 2 त्रुटियों के बराबर मानता है; इस प्रकार ऐसा लगता है कि एक चरित्र पर 8/2 = 4 बिट्स से अधिक खर्च करने के बजाय किसी को एक त्रुटि पसंद करनी चाहिए। एक त्रुटि को बचाने के लिए एक बाइट से अधिक खर्च निश्चित रूप से सबॉप्टिमल लगता है!

"रिवाइंड" तंत्र

यह खंड इस समाधान के मुख्य चतुर पहलू का वर्णन करता है, जो कि बिना किसी लागत के गलत अनुमानों को संभालने का एक तरीका है।

सरल उदाहरण के लिए हम विश्लेषण कर रहे हैं, रिवाइंड तंत्र विशेष रूप से सीधा है। दुभाषिया संकेत फ़ाइल से एक बिट पढ़ता है। यदि यह 0 है, तो यह अनुमान लगाता है E। यदि यह 1 है, तो यह अनुमान लगाता है T। अगली बार जब यह कहा जाता है, तो यह देखता है कि सही चरित्र क्या है। यदि संकेत फ़ाइल को अच्छी तरह से सेट किया गया है, तो हम यह सुनिश्चित कर सकते हैं कि Eया के मामले में T, दुभाषिया सही अनुमान लगाता है। लेकिन इससे क्या A? रिवाइंड मैकेनिज्म का विचार केवल कोड Aको बिल्कुल नहीं देना है । अधिक सटीक रूप से, अगर दुभाषिया बाद में सीखता है कि सही चरित्र एक था A, तो यह रूपक " टेप को रीवाइंड करता है": यह पहले पढ़ा गया बिट लौटाता है। इसे पढ़ा बिट कोड Eया करने का इरादा हैT, पर अभी नहीं; बाद में इसका उपयोग किया जाएगा। इस सरल उदाहरण में, यह मूल रूप से मतलब है कि यह रहता है एक ही चरित्र (अनुमान लगा Eया T) जब तक यह यह सही हो जाता है; तब यह एक और बिट पढ़ता है और चलता रहता है।

इस संकेत फ़ाइल के लिए एन्कोडिंग बहुत सरल है: सभी Eको 0 बिट्स में बदल दें और T1 बिट्स में एस, सभी को Aपूरी तरह से अनदेखा करते हुए । पिछले अनुभाग के अंत में विश्लेषण द्वारा, यह योजना कुछ त्रुटियां करती है, लेकिन किसी भी एस को एन्कोडिंग नहीं करके कुल स्कोर को कम करती है A। एक छोटे से प्रभाव के रूप में, यह वास्तव में संकेत फ़ाइल की लंबाई पर भी बचाता है, क्योंकि हम प्रत्येक के लिए बिल्कुल एक बिट का उपयोग करते हैं Eऔर T, बिट के बजाय थोड़ा अधिक।

थोड़ा प्रमेय

हम कैसे तय करते हैं कि कब त्रुटि होगी? मान लीजिए कि हमारा मॉडल हमें अगले चरित्र के लिए एक संभाव्यता वितरण पी देता है। हम संभावित पात्रों को दो वर्गों में अलग करेंगे: कोडित और कोडित नहीं । यदि सही चरित्र को कोडित नहीं किया गया है, तो हम बिना किसी लागत के त्रुटि को स्वीकार करने के लिए "रिवाइंड" तंत्र का उपयोग करके समाप्त हो जाएंगे। यदि सही चरित्र को कोडित किया गया है, तो हम अंकगणित कोडिंग का उपयोग करके इसे एन्कोड करने के लिए कुछ अन्य वितरण क्यू का उपयोग करेंगे।

लेकिन हमें क्या वितरण Q चुनना चाहिए? यह देखना बहुत कठिन नहीं है कि कोडित वर्णों में सभी की संभावना अधिक होनी चाहिए (P में) कोडित वर्णों की तुलना में। इसके अलावा, वितरण Q में केवल कोडित वर्ण शामिल होने चाहिए; आखिरकार, हम दूसरे को कोड नहीं कर रहे हैं, इसलिए हमें उन पर "खर्च" नहीं करना चाहिए। यह देखने के लिए थोड़ा पेचीदा है कि संभावना वितरण क्यू को कोडित वर्णों पर पी के समानुपाती होना चाहिए। इन टिप्पणियों को एक साथ रखने का मतलब है कि हमें सबसे अधिक संभावना वाले पात्रों को कोड करना चाहिए, लेकिन संभवतः कम-संभावित पात्रों को नहीं, और यह कि क्यू केवल कोडित वर्णों पर पुनर्विकसित है।

इसके अलावा यह पता चलता है कि एक शांत प्रमेय है जिसके बारे में "कटऑफ" को कोडिंग पात्रों के लिए चुनना चाहिए: आपको एक चरित्र को तब तक कोड करना चाहिए जब तक कि यह कम से कम 1 / 5.393 हो, जैसा कि अन्य कोडित वर्णों की संभावना है। यह "समझाता है" प्रतीत होता है यादृच्छिक निरंतर 5.393कार्यक्रम के अंत के करीब लगातार । नंबर 1 / 5.393 ≈ 0.18542 समीकरण -p लॉग (16) - पी लॉग पी + (1 + पी) लॉग (1 + पी) = 0 का समाधान है ।

शायद इस प्रक्रिया को कोड में लिखना एक उचित विचार है। यह स्निपेट C ++ में है:

// Assume the model is computed elsewhere.
unordered_map<char, double> model;

// Transform p to q
unordered_map<char, double> code;
priority_queue<pair<double,char>> pq;
for( char c : CHARS )
    pq.push( make_pair(model[c], c) );
double s = 0, p;
while( 1 ) {
    char c = pq.top().second;
    pq.pop();
    p = model[c];
    if( s > 5.393*p )
        break;
    code[c] = p;
    s += p;
}
for( auto& kv : code ) {
    char c = kv.first;
    code[c] /= s;
}

यह सब एक साथ डालें

पिछला खंड दुर्भाग्य से थोड़ा तकनीकी है, लेकिन अगर हम अन्य सभी टुकड़ों को एक साथ रखते हैं, तो संरचना इस प्रकार है। जब भी प्रोग्राम को किसी सही चरित्र के बाद अगले चरित्र की भविष्यवाणी करने के लिए कहा जाता है:

  1. Moby Dick के ज्ञात सही उपसर्ग में सही वर्ण जोड़ें।
  2. पाठ का मार्कोव (मार्कोव) मॉडल अपडेट करें।
  3. गुप्त सॉस : अगर पिछले अनुमान गलत था, रिवाइंड पिछले अनुमान से पहले अपने राज्य के लिए गणित डिकोडर का राज्य!
  4. मार्कोव मॉडल से अगले चरित्र के लिए संभाव्यता वितरण पी की भविष्यवाणी करने के लिए कहें।
  5. पिछले अनुभाग से सबरूटीन का उपयोग करके क्यू से ट्रांसफ़ॉर्म करें।
  6. वितरण क्यू के अनुसार, अंक फ़ाइल के शेष भाग से एक वर्ण को डिकोड करने के लिए अंकगणितीय डिकोडर से पूछें।
  7. परिणामी चरित्र का अनुमान लगाएं।

संकेत फ़ाइल की एन्कोडिंग समान रूप से संचालित होती है। उस स्थिति में, प्रोग्राम जानता है कि सही अगला वर्ण क्या है। यदि यह एक चरित्र है जिसे कोडित किया जाना चाहिए, तो निश्चित रूप से उस पर अंकगणित एनकोडर का उपयोग करना चाहिए; लेकिन अगर यह एक कोडित चरित्र नहीं है, यह सिर्फ अंकगणित एनकोडर की स्थिति को अद्यतन नहीं करता है।

यदि आप संभावना-वितरण, एन्ट्रापी, संपीड़न और अंकगणितीय कोडिंग जैसी सूचना-सिद्धांत संबंधी पृष्ठभूमि को समझते हैं लेकिन इस पोस्ट को समझने की कोशिश और असफल रहे (सिवाय इसके कि सत्य क्यों है), तो आइए जानते हैं और हम चीजों को स्पष्ट करने का प्रयास कर सकते हैं। पढ़ने के लिए धन्यवाद!


8
वाह, प्रभावशाली जवाब। मुझे लगता है कि Bफ़ाइल बनाने के लिए आवश्यक अतिरिक्त कोड है ? यदि हां, तो क्या आप इसे अपने उत्तर में शामिल कर सकते हैं?
नथानियल

8
अति उत्कृष्ट! 500k स्कोर बाधा को तोड़ने के लिए पहला (और अब तक एकमात्र) उत्तर है।
श्रीवत्सआर

5
"द शाइट व्हेल" ने कहा कि मैं रो रहा हूं
फिल

5
चूंकि बाउंटी अवधि के दौरान कोई नया उत्तर पोस्ट नहीं किया गया था, इसलिए मैं आपके उत्तर के लिए इसे प्रदान कर रहा हूं, क्योंकि सर्वश्रेष्ठ स्कोरिंग और सबसे परिष्कृत दृष्टिकोण दोनों। यदि आपके पास कभी समय होता है, तो मैं वास्तव में गहराई से स्पष्टीकरण की सराहना करता हूं कि यह उत्तर कैसे काम करता है, अर्थात एल्गोरिथ्म वास्तव में क्या है?
नथानिएल

2
@ नथानियल: मैंने इस पोस्ट में एक स्पष्टीकरण जोड़ा। मुझे पता है अगर आपको लगता है कि यह अपने आप समाधान को पुन: पेश करने के लिए पर्याप्त विस्तृत है।
ए। रेक्स

77

पायथन 3, 2 · 267 + 510193 = 510727

भविष्यवक्ता

def p():
 d={};s=b''
 while 1:
  p={0:1};r=range(len(s)+1)
  for i in r:
   for c,n in d.setdefault(s[:i],{}).items():p[c]=p.get(c,1)*n**b'\1\6\f\36AcWuvY_v`\270~\333~'[i]
  c=yield max(sorted(p),key=p.get)
  for i in r:e=d[s[:i]];e[c]=e.get(c,1)+1
  s=b'%c'%c+s[:15]

यह 0,…, 16 मार्कोव मॉडलों के भारित संयोजन का उपयोग करता है, जिनका वजन [1, 6, 12, 30, 65, 99, 87, 117, 118, 89, 95, 118, 96, 184, 126, है। २१ ९, १२६]।

परिणाम इन वज़न के चयन के लिए बहुत संवेदनशील नहीं है, लेकिन मैंने उन्हें अनुकूलित किया क्योंकि मैं उसी देर से स्वीकृति पहाड़ी पर चढ़ने वाले एल्गोरिथ्म का उपयोग कर सकता था, जिसका उपयोग मैंने अपने उत्तर में "सीनेट बहुमत के लिए एक साथ रखा" , जहां प्रत्येक उम्मीदवार उत्परिवर्तन है। एक वजन के लिए सिर्फ inc 1 वेतन वृद्धि।

टेस्ट कोड

with open('whale2.txt', 'rb') as f:
    g = p()
    wrong = 0
    a = next(g)
    for b in f.read():
        wrong += a != b
        a = g.send(b)
    print(wrong)

2
नौकरी के लिए सही उपकरण। शानदार स्कोर। अच्छा है।
22

1
संभावित स्पष्टीकरण: b"\0\3\6\r\34'&-20'\22!P\n[\26"भार का एससीआई प्रतिनिधित्व है, जहां अष्टक में छोटे गैर-मुद्रण योग्य मूल्य बच जाते हैं।
कॉर

मैंने उस फ़ाइल के एक संस्करण के साथ प्रश्न को अपडेट किया है जहां पाठ लपेटा नहीं गया है - आप उस पर अपना कोड फिर से चलाने की कोशिश कर सकते हैं (यह थोड़ा बेहतर हो सकता है)
नथानिएल

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

1
@ क्रिसस्टोफ़ मेरा मॉडल संयोजन वास्तव में एक भारित ज्यामितीय माध्य है। लेकिन लॉजिस्टिक डोमेन में PAQ का औसत थोड़ा अलग है - मुझे यह देखना होगा कि क्या यह बेहतर है।
एंडर्स कासोर्ग

55

पायथन 3 , 2 * 279 + 592920 = 593478 2 * 250 + 592467 = 592967 2 * 271 + 592084 = 592626 2 * 278 + 592059 = 592615 2 * 285 + 586260 = 587230 2 * 320 + 585161 = 585801 2 * 339 + 5850 + = 585728

d=m={}
s=1
w,v='',0
def f(c):
 global w,m,v,s,d
 if w not in m:m[w]={}
 u=m[w];u[c]=c in u and 1+u[c]or 1;v+=1;q=n=' ';w=w*s+c;s=c!=n
 if w in m:_,n=max((m[w][k],k)for k in m[w])
 elif s-1:n=d in'nedtfo'and't'or'a'
 elif'-'==c:n=c
 elif"'"==c:n='s'
 elif'/'<c<':':n='.'
 if v>4*(n!=q)+66:n='\n'
 if s:d=c
 if c<q:w=w[:-1]+q;v=s=0
 return n

इसे ऑनलाइन आज़माएं!

वैश्विक चर का उपयोग कर एक समारोह। यह सीखता है कि यह शब्द स्तर पर एक मॉडल का निर्माण करता है: इस शब्द में अब तक जो देखा गया है, उसे देखते हुए सबसे आम अगला चरित्र क्या है? जैसे ही अधिक इनपुट आता है, पाठ से सामान्य शब्दों को अच्छी तरह से सीखता है, और यह अगले शब्द को शुरू करने के लिए सबसे आम चरित्र भी सीखता है ।

उदाहरण के लिए:

  • यदि इसे अभी तक देखा जाए तो 'कैपेई' एक "एन" की भविष्यवाणी करता है
  • यदि यह "कप्तान" है तो यह एक स्थान की भविष्यवाणी करता है
  • यदि यह एक शब्द की शुरुआत है, और अंतिम शब्द "कप्तान" था, तो यह एक 'ए' की भविष्यवाणी करता है
  • यदि अब तक का शब्द 'ए' है तो यह 'एच' (और फिर 'ए' और 'बी' की भविष्यवाणी करता है। इसी तरह 'सी' के लिए)।

यह शुरुआत में बहुत अच्छा नहीं करता है, लेकिन अंत तक वास्तविक शब्दों के बड़े हिस्से सामने आ रहे हैं। फ़ॉलबैक विकल्प एक स्थान है, और एक एकल स्थान के बाद यह एक "ए" है, जब तक कि पूर्ववर्ती पत्र "एनडीटीएफओ", एक अंक, या एक हाइफ़न या एपोस्ट्रोफ़ में से एक नहीं था। यह 71 वर्णों के बाद आक्रामक रूप से लाइन ब्रेक करता है, या यदि 66 के बाद किसी स्थान की उम्मीद की जाती है। उन दोनों को केवल डेटा के लिए ट्यून किया गया था ("t" एक स्थान के बाद कहीं अधिक सामान्य है, लेकिन पहले से ही अधिक बार भविष्यवाणी की गई है, इसलिए " a "उन छह विशेष मामलों के बाहर एक बेहतर अनुमान है)।

सीखना क्या शब्द जोड़े एक साथ चला गया और मानचित्रण preseeding निकला सार्थक नहीं है।


यह इस तरह से पाठ के साथ समाप्त होता है:

nl tneund his    I woi tis tnlost ahet toie tn tant  wod, ihet taptain Ahab ses
 snd t
oeed Sft   aoid thshtego    Io, fhe soie tn tant  tot the soie      ahe sewbtoon
swn tagd  aoths eatmved fhe sewbtoon wor ta  I sfey  aote of totsonld nive betse
d ahe
hate Whale iorst  Ihe e ioi beaos! -there soi beaos! -there soi beaos!

जो इनपुट के इस भाग से मेल खाती है:

उसके चारों ओर।

तश्तेगो ने कहा, "मैंने उसे लगभग उसी पल देखा, सर, जो कप्तान अहाब ने किया, और मैं रोया।"

"वही नहीं - वही नहीं; नहीं, नहीं, डबलडून मेरा है, फेट ने मेरे लिए डबलून आरक्षित कर दिया है। मैं ही हूँ, आप में से कोई भी व्हाइट व्हेल को पहले नहीं उठा सकता था। -तो वह शरमा गई!

आप देख सकते हैं कि जहां विशेष रूप से उचित संज्ञाएं बहुत अच्छी तरह से निकलती हैं, लेकिन शब्दों के अंत भी ज्यादातर सही होते हैं। जब इसे "डौ" देखा जाता है, तो यह "संदेह" की उम्मीद करता है, लेकिन एक बार "एल" प्रकट होने के बाद इसे "डबलन" मिलता है।

यदि आप इसे उसी मॉडल के साथ दूसरी बार चलाते हैं तो इसे तुरंत बनाया गया यह तुरंत एक और 92k सही (51.7% -> 59.3%) हो जाता है, लेकिन यह हमेशा दूसरे पुनरावृत्ति से सिर्फ 60% से कम है।


मापने का कोड TIO लिंक में है, या यहाँ थोड़ा बेहतर संस्करण है:

total = 0
right = 0
with open('whale.txt') as fp:
    with open('guess.txt', 'w') as dest:
        for l in fp.readlines():
            for c in l:
                last = c
                if p == c: right += 1
                n = f(c)
                p = n
                total += 1
                dest.write(n)
                if total % 10000 == 0:
                    print('{} / {} E={}\r'.format(right, total, total-right), end='')
print('{} / {}: E={}'.format(right, total, total - right))

guess.txt अंत में अनुमानित आउटपुट है।


3
यह एक उत्कृष्ट दृष्टिकोण है!
Skyler

2
बहुत अधिक <s> s;
FantaC

1
+1 क्योंकि इस दृष्टिकोण ने मुझे LZW संपीड़न एल्गोरिदम की याद दिला दी।
मार्कोस

25

सी ++, स्कोर: 2 * 132 + 865821 = 866085

217 बाइट बचाने के लिए @ क्वेंटिन को धन्यवाद!

int f(int c){return c-10?"t \n 2  sS \n  -  08........       huaoRooe oioaoheu thpih eEA \n   neo    enueee neue hteht e"[c-32]:10;}

एक बहुत ही सरल समाधान, जो एक चरित्र दिया गया है, बस उस चरित्र को आउटपुट करता है जो इनपुट चरित्र के बाद सबसे अधिक बार दिखाई देता है।

इसके साथ स्कोर सत्यापित करें:

#include <iostream>
#include <fstream>

int f(int c);

int main()
{
    std::ifstream file;
    file.open("whale2.txt");

    if (!file.is_open())
        return 1;

    char p_ch, ch;
    file >> std::noskipws >> p_ch;
    int incorrect = 0;
    while (file >> std::noskipws >> ch)
    {
        if (f(p_ch) != ch)
            ++incorrect;
        p_ch = ch;
    }

    file.close();

    std::cout << incorrect;
}

संपादित करें: का उपयोग करना whale2.txtबेहतर स्कोर देता है।


5
आप इस सरणी को एक स्ट्रिंग शाब्दिक में अनुवाद कर सकते हैं और इसे Lपात्रों के एक समूह को बचाने के लिए सीधे इनलाइन कर सकते हैं :)
क्वेंटिन

@ क्वेंटिन धन्यवाद! अब मैं सोच रहा हूँ कि मैंने पहली बार में ऐसा क्यों नहीं सोचा ...
स्टैडबॉक्स

20

पायथन, 2 * 516 + 521122 = 522154

कलन विधि:

फिर भी एक और अजगर प्रस्तुत, यह एल्गोरिथ्म सबसे अधिक संभावना अगले पत्र की गणना करता है जो लंबाई 1, ..., एल के दृश्यों को देख रहा है। संभावनाओं के योग का उपयोग किया जाता है, और बेहतर परिणाम प्राप्त करने के लिए कुछ तरकीबें हैं।

from collections import Counter as C, defaultdict as D
R,l=range,10
s,n='',[D(C) for _ in R(l+1)]
def A(c):
 global s;s+=c;
 if len(s)<=l:return ' '
 P=D(lambda:0)
 for L in R(1,l+1):
  w=''.join(s[-L-1:-1]);n[L][w].update([c]);w=''.join(s[-L:])
  try:
   q,z=n[L][w].most_common(1)[0];x=sum(list(n[L][w].values()))
  except IndexError:continue
  p=z/x
  if x<3:p*=1/(3-x)
  P[q]+=p
 if not P:return ' '
 return max(P.items(),key=lambda i:i[1])[0]
import this, codecs as d
[A(c) for c in d.decode(this.s, 'rot-13')]

परिणाम:

ज्यादातर जिबरिश, हालांकि आप इसे कभी-कभार वाक्यांश पर उठा सकते हैं, जैसे कि "फादर मैपल"।

errors: 521122
TRAINING:
result:  tetlsnowleof the won -opes  aIther Mapple,woneltnsinkeap hsd   lnd the  thth a shoey,aeidorsbine ao
actual: ntal knobs of the man-ropes, Father Mapple cast a look upwards, and then with a truly sailor-like bu
FINAL:
result: mnd wnd round  ahe   ind tveryaonsracting th ards the sol ens-ike aeock tolblescn the sgis of thet t
actual: und and round, then, and ever contracting towards the button-like black bubble at the axis of that s

टेस्ट कोड:

बहुत सरल, अलग-अलग बिंदुओं पर पाठ के कुछ उदाहरणों को आउटपुट करता है। Whale2.txt का उपयोग करता है, क्योंकि यह नए वर्णों की गणना करने के लिए कुछ अतिरिक्त तर्क से बचता है।

from minified import A

def score(predict, text):
    errors = 0
    newtext = []
    for i, (actual, current) in  enumerate(zip(text[1:], text[:-1])):
        next = predict(current)
        errors += (actual != next)
        newtext.append(next)
        if (i % (len(text) // 100) == 0):
            print ('.', end='', flush=True)
    return errors, ''.join(newtext)

t = open('whale2.txt')
text = t.read()
err2, text2 = score(A, text)
print('errors:', err2)
print("TRAINING:")
print(text2[100000:100100].replace('\n', '\\n'))
print(text1[100001:100101].replace('\n', '\\n'))
print("FINAL:")
print(text2[121400:1215500].replace('\n', '\\n'))
print(text[121401:1215501].replace('\n', '\\n'))

3
साइट पर आपका स्वागत है! यह एक शानदार पहला सबमिशन है। :)
DJMcMayhem

@DJMcMayhem, स्वागत के लिए धन्यवाद। मुझे अब थोड़ी देर देखने का आनंद मिला है, यह एक प्रविष्टि के लिए मेरा ध्यान आकर्षित करने वाली पहली प्रतियोगिता है।
user2699

19

C (gcc) , 679787 652892

84 76 बाइट्स, 679619 652740 गलत अनुमान

p[128][128][128][128];a,b,c,d;g(h){p[a][b][c][d]=h;h=p[a=b][b=c][c=d][d=h];}

इसे ऑनलाइन आज़माएं!

अद्यतन: ~ 27000 अद्यतन फ़ाइल के साथ बंद, 16 अंक (8 बाइट्स) एक बेहतर गोल्फ समारोह के साथ।

व्याख्या

जिस तरह से यह काम करता है कि जैसे ही कोड पाठ के माध्यम से चलता है, यह अंतिम वर्ण को याद करता है जो किसी भी 4-वर्ण अनुक्रम को समाप्त करता है, और उस मूल्य को वापस करता है। ऊपर से अरनुल्ड के दृष्टिकोण के समान, लेकिन दो दिए गए 4-वर्ण अनुक्रमों की अंतर्निहित संभावना पर निर्भर करता है उसी तरह समाप्त।

डी-golfed:

p[128][128][128][128];
a,b,c,d;
g(h){
    p[a][b][c][d]=h; // Memorize the last character.
    h=p[a=b][b=c][c=d][d=h]; // Read the guess. We save several
                             // bytes with the assignments inside indices.
}

... TIO लिंक बेकार है। तो फ़ंक्शन अंतिम असाइनमेंट का मान लौटाता है?
user202729

मुझे एक स्पष्टीकरण के साथ उत्तर को संपादित करने दें, फिर :)

1
@Rogem मैंने एक डी-गोल्फ संस्करण जोड़ा है (जो मैंने किया क्योंकि मैं या तो इसका पालन नहीं कर सकता था) - उम्मीद है कि यह आपको परेशान नहीं करता है लेकिन कृपया वांछित होने पर वापस रोल करें।
एडम डेविस

C के अधिकांश कार्यान्वयन पर @AdamDavis, सभी वैश्विक चर शून्य पर शुरू होते हैं। यह अपरिभाषित व्यवहार है, इसलिए यह केवल कोड-गोल्फ में उपयोग किया जाता है।
16

1
@NieDzejkob आह, आप सही कह रहे हैं, धन्यवाद! "एएनएसआई-सी के लिए आवश्यक है कि सभी अनैतिक रूप से स्थिर / वैश्विक चर को 0. के साथ आरम्भ किया जाए।"
एडम डेविस

16

sh + bzip2, 2 * 364106 = 728212

2 * 381249 + 0 = 762498

dd if=$0 bs=1 skip=49|bunzip2&exec cat>/dev/null

इसके बाद bzip2- संपीडित whale2.txt के साथ पहली बाइट गायब है

इसके इनपुट को अनदेखा करता है; सही उत्तर का उत्पादन करता है। यह एक छोर पर एक आधार रेखा प्रदान करता है; डेनिएरो दूसरे छोर पर एक आधार रेखा प्रदान करता है।

बिल्डर स्क्रिप्ट:

#!/bin/sh
if [ $# -ne 3 ]
then
    echo "Usage $0 gen.sh datafile output.sh"
    exit 1
fi

cat $1 > $3
dd ibs=1 if=$2 skip=1 | bzip2 -9 >> $3
chmod +x $3

I / O परीक्षण हार्नेस (tcc; gcc के लिए पहली पंक्ति को काटें)। इस टेस्ट हार्नेस का उपयोग किसी भी उपयुक्त मंच पर किया जा सकता है जो एक पूर्ण कार्यक्रम प्रस्तुत करता है जो I / O पढ़ने / लिखने की अपेक्षा करता है। यह धोखा देने से बचने के लिए बाइट-एट-ए-टाइम I / O का उपयोग करता है। बाल कार्यक्रम अवरुद्ध होने से बचने के लिए हर बाइट के बाद आउटपुट फ्लश करना चाहिए।

#!/usr/bin/tcc -run
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>

int main(int argc, char **argv)
{
    volatile int result;
    int readfd[2];
    int writefd[2];
    int cppid;
    int bytecount;
    char c1, c2, c3;
    if (argc != 2) {
        printf("write X approximately -- service host\n");
        printf("Usage: %s serviceprocessbinary < source.txt\n", argv[0]);
        return 1;
    }
    /* Start service process */
    if (pipe(readfd)) {
        perror("pipe()");
        return 3;
    }
    if (pipe(writefd)) {
        perror("pipe()");
        return 3;
    }
    result = 0;
    if (!(cppid = vfork())) {
        char *argtable[3];
        argtable[0] = argv[1];
        argtable[1] = NULL;
        dup2(readfd[0], 0);
        dup2(writefd[1], 1);
        close(readfd[1]);
        close(writefd[0]);
        close(readfd[0]);
        close(writefd[1]);
        execvp(argv[1], argtable);
        if (errno == ENOEXEC) {
            argtable[0] = "/bin/sh";
            argtable[1] = argv[1];
            argtable[2] = NULL;
            /* old standard -- what isn't an executable
             * can be exec'd as a /bin/sh script */
            execvp("/bin/sh", argtable);
            result = ENOEXEC;
        } else {
            result = errno;
        }
        _exit(3);
    } else if (cppid < 0) {
        perror("vfork()");
        return 3;
    }
    if (result) {
        errno = result;
        perror("execvp()");
        return 3;
    }
    close(readfd[0]);
    close(writefd[1]);
    /* check results */
    read(0, &c2, 1);
    bytecount = 1;
    errno = 0;
    while (read(0, &c1, 1) > 0) {
        write(readfd[1], &c2, 1);
        if (read(writefd[0], &c3, 1) <= 0) {
            printf("%d errors (%d bytes)\n", result, bytecount);
            if (errno == 0)
                fprintf(stderr, "pipe: unexpected EOF\n");
            else
                perror("pipe");
            return 3;
        }
        if (c3 != c1)
            ++result;
        c2 = c1;
        ++bytecount;
    }
    printf("%d errors (%d bytes)\n", result, bytecount);
    return 0;
}

6
मुझे लगता है कि वह क्या पूछ रहा है: यह but may not load any other external files, and your code may not access the whale.txt file in any way other than described above.खंड का उल्लंघन कैसे नहीं करता है ?

8
@Rogem संपीड़ित डेटा को यहां दिखाए जाने के बाद डाला जाता है, और कोड स्वयं पहुंच जाता है।
user202729

4
प्रश्न कहता है: "आपका सबमिशन एक प्रोग्राम या फंक्शन (आदि) होगा, जिसे कई बार कॉल या इनवॉइस किया जाएगा। जब इसे उस nthसमय के लिए कॉल किया जाएगा, तो इसे nth कैरेक्टर का नाम दिया जाएगा whale.txtया whale2.txtइसे इसके अनुमान के लिए आउटपुट करना होगा।" (n+1)thचरित्र। " - इस आवश्यकता को कैसे पूरा किया जाता है? कोड whale.txtहर बार निष्पादित होने के पूरे पाठ को प्रदर्शित करता है।
अक्षीय

1
@axiac "कुछ भी ठीक है, जब तक कि आपका प्रोग्राम हमेशा इनपुट के अगले बाइट प्राप्त करने से पहले आउटपुट का एक बाइट देता है।"
user202729

5
@axiac ने टेस्ट हार्नेस दिया, मुझे STDIN के एक बाइट को "कॉलिंग या इनवॉइस" के रूप में भेजने के संबंध में खुशी हुई। आयात की बात यह है कि कार्यक्रम इनपुट के प्रत्येक बाइट के बाद आउटपुट का एक बाइट लौटाता है, जो कि यह वास्तव में करता है, जब परीक्षण दोहन के माध्यम से चलाया जाता है। जैसा कि सवाल कहता है, "कुछ भी ठीक है, जब तक कि आपका कार्यक्रम हमेशा इनपुट के अगले बाइट प्राप्त करने से पहले आउटपुट का एक बाइट देता है।"
नथानिएल

13

पायथन 3 , 879766

F=[[0]*123for _ in range(123)]
P=32
def f(C):global P;C=ord(C);F[P][C]+=1;P=C;return chr(max(enumerate(F[C]),key=lambda x:x[1])[0])

इसे ऑनलाइन आज़माएं!


... ///उत्तर जो एक स्थान को प्रिंट करता है उसे 10 अपवोट मिलते हैं, जबकि मेरा कोड केवल 3 प्राप्त कर सकता है ...

स्पष्टीकरण:

प्रत्येक चरित्र के लिए, कार्यक्रम:

  • बढ़ना frequency[prev][char]
  • उस चरित्र को ढूंढें जो सबसे अधिक बार दिखाई देता है frequency[char]
  • और इसे आउटपुट करें।

  • TIO लिंक में अनप्लग्ड कोड, टिप्पणी की।
  • कोड 131 बाइट्स है।
  • मेरी मशीन रिपोर्ट पर चलने वाला कोड:
879504 / 1215235
Time: 62.01348257784468

जो कुल स्कोर है

2*131 + 879504 = 879766

क्योंकि TIO पर एक बड़ी फ़ाइल अपलोड करने का कोई तरीका नहीं है (डेनिस को छोड़कर), TIO लिंक में चलाया गया उदाहरण केवल पाठ के एक छोटे हिस्से के लिए प्रोग्राम चलाता है।

पुराने उत्तर की तुलना में, इस में 362 अधिक गलत वर्ण हैं, लेकिन कोड 255 बाइट्स से छोटा है। गुणक मेरे प्रस्तुत करने का स्कोर कम होता है।


13

सी #, 378 * 2 + 569279 = 570035

using System.Collections.Generic;using System.Linq;class P{Dictionary<string,Dictionary<char,int>>m=new
Dictionary<string,Dictionary<char,int>>();string b="";public char N(char
c){if(!m.ContainsKey(b))m[b]=new Dictionary<char,int>();if(!m[b].ContainsKey(c))m[b][c]=0;m[b][c]++;b+=c;if(b.Length>4)b=b.Remove(0,1);return
m.ContainsKey(b)?m[b].OrderBy(k=>k.Value).Last().Key:' ';}}

यह दृष्टिकोण किसी दिए गए स्ट्रिंग का अनुसरण करने वाले सबसे सामान्य चरित्र को जानने के लिए एक लुक-अप तालिका का उपयोग करता है। लुक-अप तालिका की कुंजियों में अधिकतम 4 वर्ण होते हैं, इसलिए फ़ंक्शन पहले लुक-अप तालिका को वर्तमान वर्ण के साथ अपडेट करता है और फिर यह जाँचता है कि वर्तमान 4 सहित 4 पिछले वाले के बाद कौन सा वर्ण होने की सबसे अधिक संभावना है । यदि वे 4 वर्ण लुक-अप तालिका में नहीं पाए जाते हैं, तो यह एक स्थान प्रिंट करता है।

यह संस्करण whale2.txtफ़ाइल का उपयोग करता है , क्योंकि यह सफल अनुमानों की संख्या में बहुत सुधार करता है।

कक्षा का परीक्षण करने के लिए उपयोग किया जाने वाला कोड निम्नलिखित है:

using System;
using System.IO;
using System.Text;

public class Program
{
    public static void Main(string[] args)
    {
        var contents = File.OpenText("whale2.txt").ReadToEnd();
        var predictor = new P();

        var errors = 0;
        var generated = new StringBuilder();
        var guessed = new StringBuilder();
        for (var i = 0; i < contents.Length - 1; i++)
        {
            var predicted = predictor.N(contents[i]);
            generated.Append(predicted);
            if (contents[i + 1] == predicted)
                guessed.Append(predicted);
            else
            {
                guessed.Append('_');
                errors++;
            }
        }

        Console.WriteLine("Errors/total: {0}/{1}", errors, contents.Length);
        File.WriteAllText("predicted-whale.txt", generated.ToString());
        File.WriteAllText("guessed-whale.txt", guessed.ToString());

        Console.ReadKey();
    }
}

कोड बमुश्किल 2 सेकंड में चलता है। केवल रिकॉर्ड के लिए, यह वही है जो मुझे तब मिलता है जब मैं लुक-अप तालिका की कुंजियों के आकार को संशोधित करता हूं (इसमें मॉडल को रीसेट किए बिना एक दूसरे रन के परिणाम भी शामिल हैं):

Size   Errors   Errors(2)
-------------------------
1      866162   865850
2      734762   731533
3      621019   604613
4      569279   515744
5      579446   454052
6      629829   396855
7      696912   335034
8      765346   271275
9      826821   210552
10     876471   158263

यह जानना दिलचस्प होगा कि 4 वर्णों का एक महत्वपूर्ण आकार इस एल्गोरिथ्म में सबसे अच्छा विकल्प क्यों है।

पाठ तुलना

मूल:

"And did none of ye see it before?" cried Ahab, hailing the perched men all around him.

"I saw him almost that same instant, sir, that Captain Ahab did, and I cried out," said Tashtego.

"Not the same instant; not the same--no, the doubloon is mine, Fate reserved the doubloon for me. I only; none of ye could have raised the White Whale first. There she blows!--there she blows!--there she blows! There again!--there again!"

निर्मित:

"Tnd tes note of to seamtn we ore  
sried thab  wedleng the srriead te  a l tneund tes  
"T day tim t lost shet toie tn tand  aor, ahet taptain thab sid  tnd t waued tnt   said teshtego  
"To, ahe shme tn tand  aot the shme whot nhe sewbteodsan tagd  althsteatnved the sewbteodsaor te, I hncy  aote of to sanld bave beised the shate Whale iorst  Bhe e ati boaos  -the   ati boaos  -the   ati boaos  the e anains -ahe   anains 

अनुमान:

"_nd ___ no_e of __ se____ _e_ore____ried _hab_ ___l_ng the __r___d _e_ a_l ___und _____
"_ _a_ _im ___ost _h_t ___e _n_tan__ __r, _h_t _aptain _hab _id_ _nd _ ___ed __t__ said __shtego__
"_o_ _he s_me _n_tan__ _ot the s_me___o_ _he ___b__o____ _____ __t___e___ved the ___b__o___or _e_ I _n_y_ _o_e of __ ___ld _ave __ised the _h_te Whale __rst_ _he_e ___ b___s__-the__ ___ b___s__-the__ ___ b___s_ _he_e a_ain__-_he__ a_ain__

लॉग बदलें

  • 569279 - बदल गया whale2.txtऔर इस प्रकार अनुकूलन को हटा दिया गया।
  • 577366 - कोड के साथ अनुकूलित जो लाइन फीड को वापस करने के लिए अनुमान लगाने की कोशिश करता है।
  • 590354 - मूल संस्करण।

4
जैसे ही आप कुंजी आकार और स्तंभ सीमा बदलते हैं, विचरण दिखाने के लिए धन्यवाद!
जेरेमी वेइरिच

मैंने प्रश्न को उस फ़ाइल के एक संस्करण के साथ अद्यतन किया है जहाँ पाठ लपेटा नहीं गया है - आप शायद कुछ बिंदुओं का उपयोग करके बचा सकते हैं
Nathaniel

@ नथानियल यह वास्तव में करता है। मैंने जवाब अपडेट कर दिया है।
चार्ली

आप प्रकारों को घोषित करने के बजाय var का उपयोग करके कुछ बाइट्स बचा सकते हैं।
एड टी

1
जैसे-जैसे कुंजी का आकार बड़ा होता जाता है, हिट छंद की संख्या कम होती चली जाएगी और इस तरह अधिक स्थान आउटपुट होंगे जब एक छोटी कुंजी ने सही वर्ण का अनुमान लगाया होगा। जैसे-जैसे कुंजी आकार छोटा होता जाता है, वैसे-वैसे सेगमेंट के लिए अलग-अलग अनुमान कम सटीक होते हैं। मुझे संदेह है कि चार की लंबाई इष्टतम क्यों है। यदि आप कई लंबाई की कुंजी बनाए रखते हैं और छोटे मैचों का उपयोग करते हैं जब लंबे समय तक उपलब्ध नहीं होते हैं, तो मुझे उम्मीद है कि हिट दर (और इस प्रकार स्कोर) को लंबी लंबाई में बहुत सुधार किया जाएगा।
जेफरी एल व्हाइटलेज

11

जावा 7, 1995 वर्ण, (1995 * 2 + 525158) 529148

जावा छोटे प्रोग्राम साइज के लिए बेकार है। वैसे भी, मैंने कई बेहद जटिल और पेचीदा तरीकों की कोशिश की, जो आश्चर्यजनक रूप से बकवास परिणाम उत्पन्न करते हैं। मैं बाद में वापस चला गया और बस एक सरल दृष्टिकोण किया, जिसके परिणामस्वरूप एक छोटा कार्यक्रम आकार और बेहतर परिणाम मिला।

यह दृष्टिकोण वास्तव में बेहद सरल है। यह आँख बंद करके पिछले x वर्णों (उन वर्णों के सभी सब्सट्रेटिंग के अलावा) को हैशटेबल में, वर्तमान वर्ण में मैप कर देता है। यह तब नज़र रखता है कि कौन से पैटर्न वर्तमान चरित्र की सबसे सटीक भविष्यवाणी करते हैं। यदि कुछ वर्णों से पहले के पैटर्न कई बार सामने आते हैं, तो वे चरित्र की भविष्यवाणी करने में सफल होते हैं। यह लंबे समय तक तार को पूर्वता देता है और यह चरित्र को अधिकता देता है, जो अक्सर एक दिए गए स्ट्रिंग का अनुसरण करता है। यह एल्गोरिथ्म दस्तावेज़ या अंग्रेजी भाषा के प्रकार के बारे में कुछ नहीं जानता है।

मैं 9 वर्णों का उपयोग करने और संभव होने पर उन पिछले 9 वर्णों के भीतर पूरे शब्दों का मिलान करने का प्रयास करने पर बस गया। जब आप स्ट्रिंग्स के भीतर शब्द मिलान करने की कोशिश नहीं करते हैं, तो अधिकतम लंबाई 6 वर्ण होती है, जो कई हजार और गलतफहमी पैदा करती है।

एक दिलचस्प अवलोकन यह था कि 20 पात्रों का उपयोग करने से पहली बार खराब भविष्यवाणियां हुईं, लेकिन बाद में 99.9 प्रतिशत सटीकता हुई। एल्गोरिथ्म मूल रूप से 20 बाइट चैंक्स को ओवरलैप करने में पुस्तक को याद करने में सक्षम था, और यह पर्याप्त था कि यह एक बार में पूरी किताब को एक चरित्र को याद करने की अनुमति दे।

  • (1950 * 2 + 532919) 536819
  • (2406 * 2 + 526233) 531045 बेहतर अनुमान लगाने के लिए विराम चिह्न की जाँच
  • (१ ९९ ५ * २ + ५२५१५ golf) ५२१४ tweak अधिक ट्विकिंग, कुछ क्रियाओं को छोड़ दिया

package mobydick; import java.util.HashMap; public class BlindRankedPatternMatcher { String previousChars = ""; int FRAGLENGTH = 9; HashMap > patternPredictor = new HashMap<>(); void addWordInfo(String key, String prediction) { HashMap predictions = patternPredictor.get(key); if (predictions == null) { predictions = new HashMap(); patternPredictor.put(key, predictions); } WordInfo info = predictions.get(prediction); if (info == null) { info = new WordInfo(prediction); predictions.put(prediction, info); } info.freq++; } String getTopGuess (String pattern) { if (patternPredictor.get(pattern) != null) { java.util.List predictions = new java.util.ArrayList<>(); predictions.addAll(patternPredictor.get(pattern).values()); java.util.Collections.sort(predictions); return predictions.get(0).word; } return null; 
} String mainGuess() { 
if (trimGuess(",") != null) return trimGuess(","); if (trimGuess(";") != null) return trimGuess(";"); 
if (trimGuess(":") != null) return trimGuess(":"); 
if (trimGuess(".") != null) return trimGuess("."); if (trimGuess("!") != null) return trimGuess("!"); if (trimGuess("?") != null) return trimGuess("?"); if (trimGuess(" ") != null) return trimGuess(" "); for (int x = 0;x< previousChars.length();x++) { String tg = getTopGuess(previousChars.substring(x)); if (tg != null) { return tg; } } return "\n"; } String trimGuess(String c) { if (previousChars.contains(c)) { 
String test = previousChars.substring(previousChars.indexOf(c)); return getTopGuess(test); } return null; } public String predictNext(String newChar) { if (previousChars.length() < FRAGLENGTH) { previousChars+= newChar; } else { for (int x = 0; x addWordInfo(previousChars.substring(x), newChar); } previousChars = previousChars.substring(1) + newChar; } return mainGuess(); 
} class WordInfo implements Comparable { public WordInfo (String text) { this.word = text; } 
String word; int freq = 0; @Override public int compareTo(WordInfo arg0) { return Integer.compare(arg0.freq, this.freq); }

ऐसी वाचाल भाषा के लिए यह बहुत अच्छा स्कोर है।
DJMcMayhem

1
मुझे लगा कि यह एक शॉट के लायक था क्योंकि फ़ाइल का आकार कार्यक्रम के आकार की तुलना में सुधार के लिए बहुत जगह देता है।
जिम डब्ल्यू

3
यह जावा 7 (या किसी भी जावा संस्करण के तहत, इसके लायक नहीं है)। क्या आप कृपया अपना कोड ठीक करेंगे? एक बार ऐसा करने के बाद, मैं ख़ुशी से इसे गोल्फ करूँगा ताकि आपका स्कोर बेहतर हो।
ओलिवियर ग्राएगेयर

अनटाइटेड, लेकिन यह आपका सटीक समान कोड होना चाहिए जो कि थोड़ा गोल्फ हो: 950 बाइट्स । आपके वर्तमान कोड में हालांकि कुछ त्रुटियां थीं, इसलिए मुझे यकीन नहीं है कि अगर मैं सही तरीके से सब कुछ भर दूं। फिर, अप्रयुक्त, इसलिए केवल उन संस्करणों की तुलना करें जिन्हें मैंने बदल दिया है / नाम बदल दिया है, और देखें कि क्या सब कुछ अभी भी आपके मूल कोड के समान ही काम करता है। निश्चित रूप से कुछ और गोल्फ हो सकता है, हालांकि।
केविन क्रूज़सेन

बकवास, मैंने अपनी पुरानी नौकरी पर ऊबते हुए ऐसा किया और मेरे साथ कोड नहीं लिया। मुझे यह देखना होगा कि टाइपो कहां है।
डब्ल्यू पर जिम डब्ल्यू

10

पायथन 3, 2 × 497 + 619608 = 620602 2 × 496 + 619608 = 620600

import operator as o
l=''
w=''
d={}
p={}
s=0
def z(x,y):
 return sorted([(k,v) for k,v in x.items() if k.startswith(y)],key=o.itemgetter(1))
def f(c):
 global l,w,d,p,s
 r=' '
 if c in' \n':
  s+=1
  if w in d:d[w]+=1
  else:d[w]=1
  if w:
   if l:
    t=l+' '+w
    if t in p:p[t]+=1
    else:p[t]=1
   n=z(p,w+' ')
   if n:g=n[-1];l=w;w='';r=g[0][len(l)+1]
   else:l=w;w='';r='t'
 else:
  w=w+c;m=z(p,w)
  if m:
   g=m[-1]
   if g[0]==w:
    if s>12:s=0;r='\n'
   else:r=g[0][len(w)]
 return r

मैंने इसे स्वतंत्र रूप से करने का प्रयास किया, लेकिन माइकल होमर के उत्तर के प्रभावी रूप से प्रभावी संस्करण के साथ समाप्त हुआ। मुझे उम्मीद है कि मेरे जवाब को पूरी तरह से अप्रचलित नहीं करता है।

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

यह शब्द जोड़े का घृणित अक्षम्य शब्द भी बनाता है। एक शब्द सीमा को मारने पर, यह अनुमान लगाता है कि अगला चरित्र सबसे आम मिलान शब्द जोड़ी में दूसरे शब्द का पहला अक्षर है, या tयदि कोई मेल नहीं है। यह बहुत चालाक नहीं है, हालांकि। निम्नलिखित Moby, कार्यक्रम सही ढंग से अनुमान लगाता है कि अगला चरित्र है D, लेकिन फिर यह संदर्भ के बारे में सब भूल जाता है और आमतौर पर व्हेल को "मोबी डक" कहकर समाप्त होता है (क्योंकि "डच" शब्द पाठ के पहले छमाही में अधिक बार लगता है )। व्यक्तिगत शब्दों पर शब्द जोड़े को प्राथमिकता देकर इसे ठीक करना आसान होगा, लेकिन मुझे उम्मीद है कि लाभ मामूली होगा (क्योंकि यह आमतौर पर तीसरे चरित्र से सही होता है, और शब्द जोड़े पहले स्थान पर सहायक नहीं हैं)।

मैं प्रदान किए गए पाठ से बेहतर मिलान करने के लिए इसे ट्यून कर सकता हूं, लेकिन मुझे नहीं लगता कि इनपुट के पूर्व ज्ञान के आधार पर एल्गोरिथ्म को मैन्युअल रूप से ट्यूनिंग करना वास्तव में खेल की भावना में है, इसलिए एक स्थान के बाद फ़ॉलबैक चरित्र के रूप में टी चुनने के अलावा अन्य ( और मुझे शायद ऐसा नहीं करना चाहिए था), मैंने इससे परहेज किया। मैंने इनपुट फ़ाइल की ज्ञात लाइन की लंबाई को नजरअंदाज कर दिया, और \nहर 13 स्थानों के बाद डाला - यह लगभग निश्चित रूप से एक बहुत ही खराब मैच है, मुख्य उद्देश्य इनपुट को मैच करने के बजाय लाइन की लंबाई को उचित रखना था।

कोड बिल्कुल तेज नहीं है (मेरी मशीन पर ~ 2 घंटे), लेकिन कुल मिलाकर लगभग आधे अक्षर सही हैं (49%)। मुझे उम्मीद है कि अगर रन पर स्कोर थोड़ा बेहतर होगा whale2.txt, लेकिन मैंने ऐसा नहीं किया है।

आउटपुट की शुरुआत इस तरह दिखती है:

T t t t t t t t t L t t t tsher t t t ty t to t t te t t t t t tem t t t d b ta tnL te t tv tath a to tr t tl t l toe g to tf ahe gi te we th austitam ofd laammars, tn te to t tis nf tim oic t t th tn cindkth ae tf t d bh ao toe tr ai tat tnLiat tn to ay to tn hf to tex tfr toe tn toe kex te tia t l t l ti toe ke tf hhe kirl tou tu the tiach an taw th t t Wh tc t d t te the tnd tn tate tl te tf teu tl tn oan. HeAL. tn nn tf r t-H ta t WhALE.... S tn nort ts tlom rhe ka tnd Dr t t tALL th teuli th tis t-H taCTIONARY " t r t o t a t A t . t eALT t I t HLW t I t e t w t AO t t t AOLE, I T t t t ALE t w t t R t EK t T t R tSupplied by wnLw t t iit ty cce thet whe to tal ty tnd

लेकिन अंत तक, यह थोड़ा अधिक लगता है ... कुछ। पुस्तक के अंत के पास से मेरा पसंदीदा मार्ग,

और जब से न तो मेरा हो सकता है, तब मैं तुझे टुकड़े-टुकड़े कर दूं, जबकि अभी भी तेरा पीछा कर रहा हूं, यद्यपि तू ने मुझे मार डाला है, तू ने मुझे मार डाला है! धन्यवाद, मैं भाला छोड़ देता हूं! "

के रूप में बाहर आता है

I dhrnery oyay ooom the woc Ihal iiw chshtego -tit my ti ddohe bidmer Hh, ho sheee opdeprendera toetis of tygd ahesgapdo tnep tnd tf y arosl tinl ahesgaorsltoak, and tidlhty ai p, cnd telas taep toip syst ho she tachlhe tnd tith ut ay Rnet hor bf toom the wist tord oaeve of ty nsst toip recked,hontain th, tingly toadh af tingly tike 'h, tot a hoet ty oh ost sreat ess iik in ty oh ost sremf Hew hiw"aoom tnl tou oolthert tyand . taoneoo sot an ao syad tytlows of ty oii e oor hoi tike and th ohes if oaped uoueid tf ty ooadh Ih ards the t houle lhesganl p tyt tpdomsuera tiile ah the wist t hrenelidtith the Ioom ti p s di dd o hoinbtn the Ior tid toie o hoetefy oist tyoakh on the Opr tnl toufin and tnl ti dd .mh tf ooueon gaor tnd todce tovther lon by tygd ait my the th aih tapce ciice toill moaneng she thesgh thmd th the thesgaoy d jiile YhE t hrve tpothe woerk "

इसने द रथ ऑफ़ खान को और अधिक भ्रमित कर दिया होगा। और "अकेला" → "tingly" एक विशेष रूप से संतोषजनक प्रतिस्थापन है।

संपादित करें: एक बाहरी स्थान को हटाकर एक बाइट को बचाया

स्कोरिंग

#! /usr/bin/env python3
import sys
import os
import mobydick as moby


def eprint(*args, **kwargs):
    print(*args, file=sys.stderr, **kwargs)

total = 0
right = 0
real_char = ''
guess_char = 'T'
print('T',end='')
with open("whale.txt") as whale:
    while True:
        if real_char == guess_char:
            right += 1
        real_char = whale.read(1)
        if not real_char:
            eprint(str(right) + " / " + str(total) + " (" +
                str(right/total*100) + "%)")
            size = os.path.getsize("mobydick.py")
            eprint("Source size: " + str(size) + "B")
            eprint("Score: " + str(2*size + total - right))
            sys.exit(0)
        guess_char = moby.f(real_char)
        print(guess_char,end='')
        total += 1

यह मोबी डिक के पाठ के लिए कार्यक्रम चलाता है और "पूर्वानुमानित" टेक्स्टो स्टडआउट को आउटपुट करता है, और स्कोर लिखने के लिए स्टैडर का दुरुपयोग करता है। मैं आउटपुट को एक फ़ाइल पर पुनर्निर्देशित करने की सलाह दूंगा।


2
PPCG में आपका स्वागत है!
मार्टिन एंडर

1
lambda i:i[1]से निपटने की तुलना में सस्ता नहीं होगा operator?
ड्रेकोनिस

@Draconis लगभग निश्चित रूप से।
georgewatson

9

C ++, 2 · 62829 + 318786 = 444444

इस प्रोग्राम को चलाने के लिए, आपको यहां इस फाइल की आवश्यकता है , जिसे नाम दिया जाना चाहिए C

कार्यक्रम मार्कोव मॉडल के समान संयोजन का उपयोग करता है जैसा कि हमारे पहले के उत्तर में था । पहले की तरह, यह संयोजन अनिवार्य रूप से उपयोगकर्ता के इस उत्तर से मॉडल है, जो कि उपयोगकर्ता के लिए है , लेकिन कुछ छोटे संशोधनों के साथ।

यह देखते हुए कि यह उत्तर पहले की तरह सटीक मॉडल का उपयोग कैसे करता है, सुधार पहले से "रिवाइंड" तंत्र की तुलना में एक बेहतर सूचना-सिद्धांत तंत्र है। यह एक छोटी संयुक्त लंबाई होने के साथ-साथ इसे कम त्रुटियां बनाने की अनुमति देता है। यह कार्यक्रम बहुत महत्वपूर्ण नहीं है क्योंकि यह स्कोर का प्रमुख योगदानकर्ता नहीं है।

कार्यक्रम 2167 बाइट्स लंबा है (इंडेंटेशन के लिए सभी टैब और अन्य अनावश्यक वर्णों के बहुत सारे सहित, लेकिन परीक्षण कोड से पहले), और बाइनरी फ़ाइल C60661 बाइट्स लंबी है, इसलिए कई फ़ाइलों को स्कोर करने के नियमों के तहत , हम L2167 + स्कोर करते हैं 60661 + 1 = 62829।

यह कार्यक्रम m5.4xlargeअमेज़ॅन ईसी 2 पर एक उदाहरण पर चलने के लिए लगभग 8 मिनट का समय लेता है और 16 जीबी से अधिक मेमोरी का उपयोग करता है। (यह अत्यधिक मेमोरी उपयोग आवश्यक नहीं है - हमने अभी भी इसका अनुकूलन नहीं किया है।)

#include <map>
#include <queue>
#include <vector>
using namespace std;

FILE *in;
unsigned int a, b = -1, c, d;
string s, t;
double l, h = 1, x[128][129], y[129], m[128];
map<string, int> N;
map<string, double[128]> M;
int G, S;

int f(int C)
{
    int i, j;
    for (i = 0; i <= 20 && i <= S; i++) {
        t = s.substr(S - i);
        N[t]++;
        M[t][C]++;
    }
    s += C;
    S++;

    for (i = 0; i < 128; i++)
        m[i] = 0;

    int E = 0;
    for (i = 20; i >= 0; i--) {
        if (i > S)
            continue;
        t = s.substr(S - i);
        if (i <= 2 && E >= 100 && (i == 0 || t[0] != ' '))
            break;
        if (M.find(t) == M.end())
            continue;
        for (j = 0; j < 128; j++) {
            m[j] += M[t][j] / N[t];
        }
        E += N[t];
    }

    double r = 0;
    for (i = 0; i < 128; i++)
        r += m[i];
    for (i = 0; i < 128; i++)
        m[i] = m[i] / r;

    if (!in) {
        in = fopen("C", "r");
        for (i = 0; i < 4; i++)
            c = c << 8 | getc(in);
    } else {
        l = x[C][G]
            + (l - y[G]) * (x[C][G + 1] - x[C][G]) / (y[G + 1] - y[G]);
        h = x[C][G]
            + (h - y[G]) * (x[C][G + 1] - x[C][G]) / (y[G + 1] - y[G]);
    }

    priority_queue<pair<double, int>> q;
    for (i = 0; i < 128; i++) {
        q.push(make_pair(m[i], i));
    }

    int n = 0;
    double s = 0;
    while (q.size()) {
        i = q.top().second;
        q.pop();
        if (m[i] < s / (n + 15))
            break;
        s += m[i];
        n++;
    }

    r = 0;
    for (i = 0; i < 128; i++) {
        y[i + 1] = m[i] - s / (n + 15);
        if (y[i + 1] < 0)
            y[i + 1] = 0;
        r += y[i + 1];
    }
    for (i = 0; i < 128; i++)
        y[i + 1] /= r;

    for (i = 0; i < 128; i++) {
        r = 0;
        for (j = 0; j < 128; j++) {
            x[i][j + 1] = y[j + 1];
            if (i == j)
                x[i][j + 1] *= 16;
            r += x[i][j + 1];
        }
        for (j = 0; j < 128; j++)
            x[i][j + 1] /= r;
        x[i][0] = 0;
        for (j = 0; j < 128; j++)
            x[i][j + 1] += x[i][j];
    }

    y[0] = 0;
    for (i = 0; i < 128; i++)
        y[i + 1] += y[i];

    for (G = 0; G < 128; G++) {
        if (y[G + 1] <= l)
            continue;
        if (y[G + 1] < h) {
            d = a + (b - a) * ((h - y[G + 1]) / (h - l));
            if (c <= d) {
                b = d;
                l = y[G + 1];
            } else {
                a = d + 1;
                h = y[G + 1];
            }
            while ((a ^ b) < (1 << 24)) {
                a = a << 8;
                b = b << 8 | 255;
                c = c << 8 | getc(in);
            }
        }
        if (h <= y[G + 1])
            return G;
    }
}
// End submission here.  Test code follows.
int main()
{
    FILE *moby = fopen("whale2.txt", "r");

    int E = 0;
    int c = getc(moby);
    while (c != EOF) {
        int guess = f(c);
        c = getc(moby);
        if (c != guess)
            E++;
    }

    printf("E=\t%d\n", E);

    return 0;
}

7

अजगर 3, 526640

274 बाइट्स, 526092 त्रुटियां (उपयोग करते हुए whale2.txt)। यह निश्चित रूप से आगे सुधार करने में सक्षम है, लेकिन यह "पोस्ट करने के लिए पर्याप्त अच्छा" तक पहुंच गया है।

from collections import*
D=defaultdict
M=[D(lambda:D(int))for i in range(10)]
X=""
def f(c):
 global X;G=D(int)
 for L in range(10):
  M[L][X[:L]][c]+=1;N=M[L][(c+X)[:L]]
  if N:g=max(N,key=lambda k:(N[k],k));G[g]+=N[g]*L**8
 X=(c+X)[:10]
 return max(G,key=lambda k:(G[k],k))

विचार 2, 3, 4, ..., 10 वर्णों के सभी रनों की आवृत्तियों को संग्रहीत करना है। इनमें से प्रत्येक लंबाई एल के लिए, हम जांचते हैं कि क्या सबसे हालिया एल -1 अक्षर एक संग्रहीत पैटर्न से मेल खाते हैं; यदि हां, तो हमारा अनुमान g L उस पैटर्न का अनुसरण करने वाला सबसे लगातार अगला वर्ण है। हम इस तरह से नौ अनुमानों को इकट्ठा करते हैं। यह तय करने के लिए कि कौन सा उपयोग करने का अनुमान है, हम प्रत्येक पैटर्न की आवृत्ति को अपनी लंबाई से 8 वीं शक्ति तक वजन करते हैं। भारित आवृत्तियों के सबसे बड़े योग के साथ अनुमान चुना जाता है। यदि उस मैच से कोई पैटर्न नहीं है, तो हम अंतरिक्ष का अनुमान लगाते हैं।

(अधिकतम पैटर्न लंबाई और वज़निंग घातांक को सबसे कम गलत अनुमान देने के लिए परीक्षण-और-त्रुटि द्वारा चुना गया था।)

यहाँ मेरा अनगढ़ काम-प्रगति संस्करण है:

from collections import defaultdict

PATTERN_MAX_LEN = 10
prev_chars = ""
patterns = [defaultdict(lambda:defaultdict(int))
            for i in range(PATTERN_MAX_LEN)]
# A pattern dictionary has entries like {" wh": {"i": 5, "a": 9}}

def next_char(c):
    global prev_chars
    guesses = defaultdict(int)
    for pattern_len in range(PATTERN_MAX_LEN):
        # Update patterns dictionary based on pattern and c
        pattern = prev_chars[:pattern_len]
        patterns[pattern_len][pattern][c] += 1
        # Make a guess at the next letter based on pattern (including c)
        pattern = (c + prev_chars)[:pattern_len]
        if pattern in patterns[pattern_len]:
            potential_next_chars = patterns[pattern_len][pattern]
            guess = max(potential_next_chars,
                        key=lambda k:(potential_next_chars[k], k))
            frequency = potential_next_chars[guess]
            # Exact formula TBD--long patterns need to be heavily
            # advantaged, but not too heavily
            weight = frequency * pattern_len ** 8
            guesses[guess] += weight
    # Update prev_chars with the current character
    prev_chars = (c + prev_chars)[:PATTERN_MAX_LEN]
    # Return the highest-weighted guess
    return max(guesses, key=lambda k:(guesses[k], k))

और परीक्षण दोहन:

from textPredictorGolfed import f as next_char
# OR:
# from textPredictor import next_char

total = 0
correct = 0
incorrect = 0

with open("whale2.txt") as file:
    character = file.read(1)
    while character != "":
        guess = next_char(character)
        character = file.read(1)
        if guess == character:
            correct += 1
        else:
            incorrect += 1
        total += 1

print("Errors:", incorrect, "({:.2f}%)".format(100 * incorrect / total))

पाठ की शुरुआत के पास से कुछ नमूना आउटपुट यहां दिए गए हैं। पहले से ही हम अपने पहले पत्र देखने के बाद आम शब्दों को समाप्त करने की क्षमता को देखना शुरू कर ( in, to, and, by, यह भी, जाहिरा तौर पर, school)।

 you take in hand to school others, and to teach them by what name a whale-fish
xU wshhlnrwn cindkgo dooool)tfhe -; wnd bo so rhoaoe ioy aienisotmhwnqiatl t n 

अंत के पास, अभी भी बहुत सारी गलतियाँ हैं, लेकिन बहुत अच्छे दृश्यों में भी ( shmage seashawksउदाहरण के लिए)।

savage sea-hawks sailed with sheathed beaks. On the second day, a sail drew near
shmage seashawks wtidod oith tua dh   tyfr.  Tn the shaond tay, wnltiloloaa niar

यह कुछ गलतियों को देखने और अनुमान लगाने में दिलचस्प है कि एल्गोरिथ्म "उम्मीद" क्या शब्द है। उदाहरण के लिए, के बाद sail, कार्यक्रम दोनों समय की भविष्यवाणी करता है o- इसलिए sailor, मैं अनुमान लगाता हूं। या फिर, , aयह होने के बाद की उम्मीद है - nसंभवतः की आम घटना की वजह से , and


बदलाव का:

  • २४ * २ + ५२६० ९ २ = ५२६६४० कुछ अलग-अलग त्रुटियों की कीमत पर, एल्गोरिदम को गढ़ा
  • 306 * 2 + 526089 = 526701 मूल संस्करण

6

पायथन 2, स्कोर: 2 * (407 + 56574) + 562262 = 676224

पाठ में उपयोग किए जाने वाले  सभी  शब्दों की सूची में पिछले पात्रों से मेल खाने वाले शब्दों की खोज , उनकी घटनाओं की संख्या के आधार पर क्रमबद्ध।

कोड:

import zlib
f=open("d","rb")
l=zlib.decompress(f.read()).split()
w=""
def f(c):
 global w
 if c.isalpha():
  w+=c
  try:n=next(x for x in l if x.startswith(w))
  except StopIteration:return" "
  if len(n)>len(w):
   return list(n)[len(w)]
  return" "
 w="";
 n=ord(c)
 if n>31:
  return list("t \n 2  sS \n  -  08........       huaoRooe oioaoheu thpih eEA \n   neo    enueee neue hteht e")[n-32]
 return"\n"

डेटा: https://www.dropbox.com/s/etmzi6i26lso8xj/d?dl=0

परीक्षण सूट:

incorrect = 0

with open("whale2.txt") as file:
    p_ch = ch = file.read(1)
    while True:
        ch = file.read(1)
        if not ch:
            break
        f_ch = f(p_ch)
        if f_ch != ch:
            incorrect += 1
        p_ch = ch

print incorrect

संपादित करें: का उपयोग करना whale2.txtबेहतर स्कोर देता है।


5

सी ++ (जीसीसी), 725 × 2 + 527076 = 528526

फिर भी एक और उपसर्ग-आवृत्ति प्रस्तुत करना। दौड़ें whale2.txt, और दूसरों की तुलना में समान (थोड़ा खराब) स्कोर प्राप्त करें।

#import<bits/stdc++.h>
char*T="\n !\"$&'()*,-.0123456789:;?ABCDEFGHIJKLMNOPQRSTUVWXYZ[]_abcdefghijklmnopqrstuvwxyz";
int I[124];std::string P(7,0);struct D{int V=0;std::array<int,81>X{{0}};};std::vector<D>L(1);D
init(){for(int i=81;i--;)I[T[i]]=i;}int
f(int c){P=P.substr(1)+(char)I[c];for(int i=7;i--;){int D=0;for(char
c:P.substr(i)){if(!L[D].X[c]){L[D].X[c]=L.size();L.push_back({});}D=L[D].X[c];}++L[D].V;}std::vector<int>C(81);for(int
i=81;i--;)C[i]=i;for(int
i=0;i<7;++i){int D=0;for(char c:P.substr(i)){D=L[D].X[c];if(!D)break;}if(!D)continue;int M=0;for(int
x:C)M=std::max(M,L[L[D].X[x]].V);C.erase(std::remove_if(C.begin(),C.end(),[&](int
x){return L[L[D].X[x]].V!=M;}),C.end());if(C.size()<2)break;}return T[C[0]];}

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

उदाहरण के लिए: अगर पिछले 7 चरित्र abcdefgh, और स्ट्रिंग abcdefghiऔर abcdefghjफार्म के सभी स्ट्रिंग्स में सबसे बड़ा आवृत्ति के साथ प्रकट होता है abcdefgh*, उत्पादन या तो हो जाएगा iया j, (कम प्रत्यय के साथ टाईब्रेक bcdefgh, cdefgh, ...)।

अज्ञात कारणों से, 7 से अधिक और मेरे कंप्यूटर में इसे चलाने के लिए पर्याप्त रैम नहीं है। 7 के साथ भी, मुझे इसे चलाने के लिए सभी वेब ब्राउज़र को बंद करने की आवश्यकता है।


परीक्षण कोड:

int main() {
    init(); 

    std::cout << "Start ---\n";
    std::time_t start = std::clock();

    std::ifstream file {"whale2.txt"};
    // std::ofstream file_guess {"whale_guess.txt"};
    std::ofstream file_diff {"whale_diff.txt"};
    if (!file.is_open()) {
        std::cout << "File doesn't exist\n";
        return 0;
    }

    char p_ch, ch;
    file >> std::noskipws >> p_ch;
    int incorrect = 0, total = 0;
    // file_diff << p_ch;

    int constexpr line_len = 80;
    std::string correct, guess_diff;
    correct += p_ch;
    guess_diff += '~';

    while (file >> ch) {
        char guess = f(p_ch);

        // file_guess << guess;
/*        if (guess != ch) {
            if (ch == '\n') {
                file_diff << "$";
            } else if (ch == ' ') {
                file_diff << '_';
            } else {
                file_diff << '~';
            }
        } else {
            file_diff << ch;
        }*/
        incorrect += (guess != ch);
        total += 1;
        p_ch = ch;

        if (guess == '\n') guess = '/';
        if (ch == '\n') ch = '/';
        correct += ch; guess_diff += (ch == guess ? ch == ' ' ? ' ' : '~' : guess);
        if (correct.length() == line_len) {
            file_diff << guess_diff << '\n' << correct << "\n\n";
            guess_diff.clear();
            correct.clear();
        }
    }

    file_diff << guess_diff << '\n' << correct << "\n\n";

    file.close();
    file_diff.close();

    std::cout << (std::clock() - start) 
    / double(CLOCKS_PER_SEC) << " seconds, "
    "score = " << incorrect << " / " << total << '\n';
}

Ungolfed:

size_t constexpr N = 7;

int constexpr NCHAR = 81;

std::array<int, NCHAR> const charset = {{
'\n', ' ', '!', '"', '$', '&', '\'', '(', ')', '*', ',', '-', '.', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '?', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '[', ']', '_', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'
}}; // this actually contains a lot of information, may want to golf it
// (may take the idea of using AndersKaseorg's algorithm, late acceptance hill climbing)

std::array<int, 'z' + 1> const char_index = [](){
    std::array<int, 'z' + 1> char_index;
    for (size_t i = NCHAR; i --> 0;) 
        char_index[charset[i]] = i;
    return char_index;
}(); // IIFE ?

std::string past (N, 0); 
// modifying this may improve the score by a few units

struct node {
    int value = 0;
    std::array<size_t, NCHAR> child_index {{0}};
};
std::vector<node> node_pool (1); // root

int f(int c) {
    past = past.substr(1) + (char) char_index[c];

    for (size_t i = 0; i < N; ++i) {
        // add past.substr(i) to the string
        size_t node = 0;
        for (char c : past.substr(i)) {
            if (node_pool[node].child_index[c] == 0) {
                node_pool[node].child_index[c] = node_pool.size();
                node_pool.emplace_back();
            }
            node = node_pool[node].child_index[c];
        }
        assert(node != 0); // the substring is non-empty
        ++node_pool[node].value;
    }

    std::vector<size_t> candidates (NCHAR);
    std::iota(candidates.begin(), candidates.end(), 0);
    for (size_t i = 0; i < N; ++i) {
        size_t node = 0;
        for (char c : past.substr(i)) {
            node = node_pool[node].child_index[c];
            if (node == 0) break;
        }
        if (node == 0) continue;

        assert(node_pool[0].value == 0);
        int max_value = 0;
        for (size_t x : candidates)
            max_value = std::max(max_value, node_pool[node_pool[node].child_index[x]].value);

        candidates.erase(
            std::remove_if(candidates.begin(), candidates.end(), [&](size_t x){
                return node_pool[node_pool[node].child_index[x]].value != max_value;
            }), candidates.end()
        );

        if (candidates.size() == 1) 
            break;
    }

    return charset[candidates[0]];
}

उदाहरण आउटपुट:

~ ~s  ta~ hard ts tt~~~~~~~ ~doam ~~ ar~ ~ i~~~ ~~~ ~he~~~~,a~ t~~~~ t~ ho~si~  
n--as his wont at intervals--stepped forth from the scuttle in which he leaned, 

~~~ thr~ ~~ t~~ crp~~~~~~~~ a~ wap~~~~~ a~eo~~ h~~ o~~ s~~~ or~~y~ ~  boog~e~~ t
and went to his pivot-hole, he suddenly thrust out his face fiercely, snuffing u

~ a~~ ~h~ ~n~ onitn~oi~~~~~~ ~~a~ ~ cewsoat~  a~ tae~~~~ ~e~~t~~ te~~ ouc~s~i~~ 
p the sea air as a sagacious ship's dog will, in drawing nigh to some barbarous 

ct as I~ iisk~~~~ ~~e~ tls~~~~ i~~~ ~~ soe~e Ae ~ ~~e~ tar~~~~~ trd~  ot ~ h~~~ 
isle. He declared that a whale must be near. Soon that peculiar odor, sometimes 

यह एक पाठ के अंत के पास है। सबसे लंबे समय तक शब्द काफी सही भविष्यवाणी कर रहे हैं ( intervals, pivot-hole, distance)

 au t  tf weu~i~ aor~ mre~g~~~ m~t~~ ~~~  ~"NC~X~t~ti~  ~~n~ SNsh A FNECnSERTR O
 on as it rolled five thousand years ago./////Epilogue//"AND I ONLY AM ESCAPED A

NL~~,S~ ~HR~ yO~ -/s~n "~A~~ laeu~ta Vew~, S~e s~~  s~ ~ ain~ t~d ~t~ oirept~~ ~
LONE TO TELL THEE" Job.//The drama's done. Why then here does any one step forth

ऊपरी-मामला अच्छा नहीं लगता।


मुझे लगता है की तुलना में Trie अधिक मेमोरी-खपत वाला लगता है ...
user202729

... और लागू करना भी कठिन।
user202729

4

अजगर 2, 756837

मार्कोव श्रृंखला हो सकती है कि कुछ का उपयोग करता है?

import zlib
a=eval(zlib.decompress('x\x9cM\x9cis\xda\xcc\xd2\x86\xff\x8a2\xf5\xd4\x81\xb8,\x977l\'\xf9\x90\x12 \x02f\x11G\x02c||*%@,a\x11a1\xe0S\xef\x7f\x7fC\x13\xf75\xdf\xda\xaaa4\xd3\xcb\xddw\xf7\x8c\xfc\xbf\xcc\x8f\xd7E\xe6\xab\x93if\xce\x9d\xcc\x8f\xefG\xd1\x11\xf1\x1b\xa2At\x8e\xa2\'\xe2\xc5Q\xfc,\xa2{\x14+"\x9e3\xf63b\x87\x9f\xb5\x8fb$b\xeb(\x96E\x8c\x18\x1b2\xb6{\x14/D\xfcq\x14\x03\x11}\xc6zG\xb1.b\xc0\xd3\x06\xcb\xa9\xf1\xb3\xcaQl\x88X>\x8a-\x11\xb7G1\x11q\x85\x98\x1c\xc5\x95\x88\xf1Q\xec\x89\x98\x1e\xc5\x81\x88\xa2\xb3X\xc4\x19\xe2\xe4(\xbe\x898\xd6\xc9F\xa8\xe4E\x16\x19\x8a\xc8r^|U\xc9\x8b\xc7\xd8\xfcQ\xf4\x8f\xe2\xbf\x1c\x06\xbc\xa8v6\xef\xba\xb2\x17V\xf6\x92\xe8r6\x07\x9d\xcc\x95EN\xe4\xe9FW\xb6\xd9\xea6M\xa2K\xdf\xact\x86\xf9\xc976Gy\xf2\xce\xef\x96G1\x15q\xf1\xf1\xd4\xcc3\xe6\x8f\xb8\x96\xdf}\xd27\xcf\x1d\x9da\x8e\x1f\xcd\xc5c\\\x11Q\xcf\xfc\x02Q\x9c\xe7\\\xd6\xbe;\x8acY\xe5\x8c\x17\xcfu9F\xc4\x83\xfc\x0c\x076\x0b\x1d;\xc7\x97\xe7_U\x9c\xacT\xfc\xc2\x1a\xbe\xb0\x06\x83\r7b\xd9\x85<\x9d\xe8\x86\xbe|Q\xff\xfc\xf2\xa0\xe2d\xa7?\xfbr\xc5\xbc\x97\x8c\xbd\xd1\xbd}\xb9f@\x8e\x01\xb7\x88\xf7\x88w*\xce\x13v1\xc1ZCv\x1c\xebz\xe7=]\xce\x1c\x9d\xcdg\xe8,U/\x98/\x18`\xed\xf8\x8d\xa7\xe21\'\x1bo\xd4,sk\x80\xb8\xc6L\xc45Oq\xa9M\xac\x9e8\xc7?k\xb8\x9fY\xe9\x80\x9a\x8c\x9d\x8a\x98\xea\xde\x8c\xcc\xbb\x94\xa7\x13\x06\xc8\xca\xfa"\x1e\x98\xa1\xa4\xe1R\xfb\xa1\xb1W+\xf2b\xc0\xa4\x96W\xac\xa8\x15\x10=\x8d\xd3ZC#\xb2F \xd7j\xccP\xd78\xadU\x8fbWD"\xbd\xd6Q\xb7\xaf\xb5\x98\x0cH\xac\x85\xfc\x0cH\xac5\x15(k\xdd\x8f\xa7\xa6&\xf1v\xfa\x19\x00Q\xc3\x7fkxuM\xe2\xad(\xa2D\xd6\xabX\xb6&\xfeyy\x14\x1d\xdc\xa4v\x8azY\xdbU\xa4P\xf9\xc4\xcc?\x0fj\x8d\x9f\x135\xf8O\xde\xf7\xd3Q?Ym\xf4\xe9\n\xefY\xe12\xab\x9d:\xc7\n`Y\xfd>\x8a[\x11\xf1\x88\xd5\x9a\xc9\xf6\xcc\x80#\xad\xde\xd5+W\x03\x9e\x12/\xab!\xf3\x8e\x98\x81xY\xf5\x18\xd0g2\xe2e5g\xb2\x05+\x13\x07\x9d\x8b8fCD\xd1j\xca\xcf,X]\x81X+\xb0i\xa5\x88\xf5\'\x1c\x14VW`\xe9\n\x84]\x19u\xaa\x15\x16X\x81\xb0+\x0c\xb7"\'\xbf.N\xab0\xa7?n\xd5\x13^\x179\xb5\xf9\xebB<\xe4\xe1$_[c\x04\xc3\x06\'\x99W\xbd.\xb2\x1ap\xaf\x8b\xb3\x8fy\xcc\x9fW\x19\xe6t\xacE\x18\x1d\xffoR\xf1\xeb\xa2k\xc9/\x96\xfc\x1fk\xfa\x96Z\xe7u\xd1VLx]<\xa9Q^\x17\x1dkL\xd3\x9a\xe7\xdfj\xe4\xd7Eh\x8d\x8fT\xc3\xaf\x8b\x9a5\xben\xc9\ru\xd2\xd7E\xa0\xf6}]\x94\xad1\x15k\x8b\x8f\xd6\xf8\xaa\xf5\xae\xa25\xde\xb7\xe6)Y\xe3\x7fX\xb2g\x8d\xc9[\xeb/(:\xfc[\xd4P9=>X?}\xb7\xe4\x8d\xa5\x92\xad5\xe5\x9b\xb5\x9c\x9d5Fbru\x92\x7f[\xaf]Y\xe3\xd7\x96\xdaf\xd6\x16\xe7\x1a\t\xaf\x8b\x85\xb5\x06\t\x96\xe1I\x1e[\xf3L\xac\xf5\xfc\xb2~;\xb5\x9e\x0f\xac\xf1\x12\xd7\xfb\x93<\xb4\xe6\x1fYk\x8e\xad\xdf\xf6\xac\xdf\xf6u\xfc\x80\x00\x19\x10A\x03\xdcz\xa0ac\x06\x84\xe3\x00>3 2\x07D\xe6\x80\xd8\x1e\x10\xdb\x03\xd8\xc8\xc0\x02\x82\x01\xb9w \xea\xd9\x89\x08\xee\x0c\xe6\xaa\xd8\x01\xba\x19L\xf9\x19\x9a\x1c\xa0\xc8\x01\x807\x00\xf0\x06hq\x00\xd9\x1d\xf4\xd0\x89\xa5\x9e\x985\x80\xb4\x837\xd6\x00\x82\x0f\xf0\xae\x01\x19y\x80\xaf\x0c@\xf0\xc1\xf2cCf\x87Vw\xe8o\x87Vw\x98h\x87]vXk\x07a\xdc\xa1\xf6\x1d\xba\xdea\x81K\x012aR\x977\x88\x97\no\x97W<\x85u]\n\x17;e\xceK(\xda%\xc4\xed\x12\x16x\t7\xdcYV\xbe\x94-I\xba\xbcd\xa3\x97\xec\xee\xf2\\W\xb1\xc3r;l\xb4\xc3r\xbb\xbe\xea}\xd7C\x14s\x9dt\t\xb5\xdb-\xd0\x04>\xb5#)\xed\xe0\xb5;\x12\xd8\x0e\x84\xd8Q8\xec0\xe2\x8e\xe4\xbc[2\x00?\xb9\xc4#\nl\xb3\x80\xe5\n\xa2\x12![\x05\x81G!\x1e\x05AP)\xed\n\x02\xac\x02\xfa\x85\x80\xa75\xc5\xba\x02t\xad  )\xc5l\x01jW\xe8"\x86\xbcB\xd0RrR\xa1\xc5+\x08\x9d\xc2X\xd5W \xbd\x17f\xba\xcd\x82\xa8Z\xd2N!Q\xf5\x15\xdeU}\x85\x83\xc6@a\xa5\x01U\x10\xa5\x9e\xd8\xee@\x9fN 4\x06,3#\xd5\xaf\x01\xc9\x0c$\xc5\x10\xa8\x13\xe0y\xb2\xd4\x1dO0\x96I\xd5\x16\x93\xadnh\x82\x85\xcc/f \x1f\x18\x06L\xc6\xba\x9c\t\xc8c\xc8\x17\x13j\x8c\xc9L}}\x92\xea\xd2\'\xe2\x88#\x11\xd9\xd0\x04\xaa5\xe9\xf1\xb3D]\xd9\x90\xce&#\xc6\x0e\xd9[\x11\x9d\xf9\xe8\x97dj\xc8\xa5\xc6\xd3\x080dRSP\xbb\x99\x1ac\xeb<%\xf3\x9b\x00\x9d\x91\xf7\ri\xdf<2/I\xdf\xc0Y\x0c\x94\xc5<1\x03\x84\xc5\xc0W\x0ct\xc5\x84,\x07\xb2b\xe0KO\xb2\xb7\x9ah\x07\xf43\xaf\x19uv\x039\x7f\x12MI\x1d\xf3$k/\xc8\x80\x0b\xc5.s\x06\xe6=\xc9\x9e\xa58\x99\xb8\xea\xd7\x13"yr\x81\xed\x01\xb7\x89\xbcN\xb2\xd9\xc4\xe8l\x7f\xcah\x85|\xc3:\x9fp\x89\'0\xefi\xa2\xa29\x81\xe9\xdf\x15\xa5j\xc7\xc9\xe9\xb9\xbc&Gc)\x87\xeb\xe6@\xe4\x1c8\x9d\xcb)\xde\xe6\xc0\xf4\x1cew\x8e\x04\x90#-\xe4.u\xc99RHN\x12\x8b$\xa1\x1cj\xc9\x01{9\xf8w\x19L*\xd3\xf2*S\xf5\x95\x9fxJ\xff\xac\xdcb\x00uc\xb9\x82\xd8`\x00Uj\xb9\xce\x0c@d\x19\x88,\x1f\xd4ve\xca\xb4\xf2\x04\x11RR\x8e\xd5\x1ce*\xab\xb2m\x992&-\x7fV\xfd\x94/\xac\x11(\xa8\xec\xaac\x95\xb5\x92\xfd\x13VZ\xdf\xfeG\xb4\xd2\x16Q;d&\xf3\xcd\xe8l\xaf\x19\xcb\xb52\xce\x87k\x99\x8c{\x14]\x11\xcf\xcd\xc7\x0b\x17$8\x8br.\x00\xbf\x05yqA\xb6\xb4\xe8\xec\x02\xb6v"\xb3\x12\x86\'\xaey\x12\xa1R\'\xa6y\x1aKM\xba@s\'\xea*\x00qb\xae\xa7\xa7{\x9e\x92N\x17$\x97/\x04\x96E\xd2-\x8enQ\xf4\x05I`AA\xbe \tX\xf4\x7f\xa1t\xcedv\xe6o\xf8\x98\xcc\x9b\xf9;\xc0d\xb6\xe6\xef6Mf\xf3\xa1T\x93Y#\xae\x18\xfb\xdb\xfc]\x8e\xc9,\x8d\xce{`\xc0\x88\xa7C\xf3Wg&\x93\x98\xbf+3\x7fx\xb6\xce\xdb?\x8a3\x11{\xcc\x1b36\xe5\xe9\xe2\x8fh2\xe6(\xce\x99a\xc6\x0c\x13\xf3\xd7\xf2&3f9\x1dv\xfc\xc4\xd3\x16O#\xdc\x08&\xba\xb8\xc0-\x9bFm\x01\x81]\x00\x88\x0b\xc3\xd8\xae\xbe\xe2T!\x9f\x94\xea\x1f\xc5\xbd\x88E\xb4S@\xcc\xb3M\xcf\xa8{~g\xde\x80\xf56\xf8Y\xfdc\xac\xc9\xd4\xcc_\xe72\x99\n\xda)\x7f\x8c\xcd|eo_\x1du\xb9\xaf\xf4\x1a\xbeZ\xe1\xfe\'Gj\xac\xd6\x8f\x1b\x15\xbdg\xea\x8e\xe6\x9c:\xd3\xd5\t\xfc:\xc8X\x07%\xea\xf0\xf7\xfa\xe9%\x1d\x91\xe9l\xd7\xc9\x12u\x89>\xe9\x82\xd7\x01\xab:\xb5G}\xc3\xc4+D"\xaa\x0e\x08\xd6i\xf6\xd5\x0b\x9a\x0e\xeb4\x06\xeb\x02\xa3\xc2\x1e\xeb5\x05\xad:8[o(\xce\xd6+\xec\xbe\xcd\xcf\x9a\ne\xf5\x88\xe5\x90\x0c\xce_9[X[\x95\xc3\x1aD]S\xca\xac\xd1\xd59f:G\xdb\xe7g\x0c \xf9\x9c\xd3\xeeYgu\x99k\xcc\xb1f\x865\xf6ZS\xf1\xae\xf1\xe7\xb5z\xb9Yg48\xce\x1f\xf4\x15\xdfu2\xf3\x9d\x01\xdfA\xec\xccwG\xcd\xbc\xc62k@kM\x07y\r\xc0\xad\xa98\xd6t\xdd\xd7\x18\x7f\r\xd6\xad\xa1\xab\xeb_\x8a\xcdk\xe0\x7f\r\xb5]\xc3\xf6\xd7\x00\xfd\x1a\xf8_\x93\x14\xd6}\x85\xdeu\x8f\xa7\xb4\xb9\xd7#\xd6\x0b\xd0\xaf\x81\xff55@H\xb9\x15&\xba\x86P&\x93f[\xc8\xca\xc2\xb1\xbe-\x94]\x08\xa7\x0e\xe1\x07!\xdd\xa0\xf0\tQ\xb8\x84\x90\xa3\xb0\xa9\x8e\x1dBAB(H\x88[\x86\xf4\xccC\x02&\xfc\xa1\x8e\x1dz\x1a0a^}<\xa49\x15R\xb0\x85\xb0\x91P\x02F\x90#\xa4\xb8\x0b\xe9\x99\x87\xd4\x84!\xce\x1e\x12\x02!\xbd\xd2\x10\x18\n\xc5\xa3\xaeD\xc4\x81C\xf1\xc4\xbc\x888{\x08\xf6\x84\xa7\x88\x93pH(e\x12J\x99$Us&\xd4\xd4\t\x0c5\xa1\r\x93L\x15\x91\x12|.I\xd4\xc8\t| !\xf3\'\x94\x7f\tT+\xe9+\x16$\x90\x8b\x84pI\xf6\x0c\xe0\xb0.\x81\xcd%DC\xb2C$\xf3\'\x84VB\x01\x99\x10\x86\tgf\xc9\xcf\xa3(\\7\x01,\x12t\x9d\xa0\xe0\x84\xfeY\x02\xedO\x80\x90\x84\x92$!\xc5$\xd8;\x01\xfd\x12L\x7fA\xa1\x92\x9c\x0c\'S\xec\xa1w\xfb\x89jjO3dO\t\xbf\'\xa8\xf7\xf0\xb4}\xac\x10\xb2O4\xf8\xf6\xa2\xebO"\x82<{\x94\xb6\xa7E\xb2\xdf\xaa\xc7\\\xd1\x1d\xdd\xa3\x93=\x9a\xda\x8b\xfe$\x87\xedE\x11R\xaf\xecU=f\x8f\xd2\xf6\xec~om\xf9\xeaR\xadqE=rE\xa3\xeb\x8a:\xe7\x8a:\xe7J\xea\x9c{\x11\xa9s\xae\xa8\x94\xae\x04\xc5\xafE$\xbf\\\xd1l\xbb\xa2_u\xc5\xe6\x8a\x12\xca\x82\xe7\xc5\x9a\xc6z\xb1\xae\xb8P$\xc0\x8b`H\xb1\xa8\x10Q\xf4\x15N\x8ad\xe5"\x80T\xa4<*\xb6\x15\xc7\x8a\x1c\xa0\x15#\x85\x93"\xed\x87\xe2D-[\x84P\x14c\x05\xd0"\xa7\x87\xc5\xad\x1a\xaeH\xfe)\x9e\xd4.(S\xb4\xb6\xac\xf64\xc5\x8cr\xb2"\x14\xa8\x88\xbb\x17\xf1\xe6\x8e\xaf\x88\xd4\xa1r\xefp\x9b\xa1C=\xd7\x81rt\xd0_\x87\xf6X\x87\xc2\xb7#\xbb\xff&"-\xafN\x131Q\x07\xed\xd01\xec\x80n\x1d\x1a\x82\x1d\x02\xaa\xa3\x8a0\x1d\xd0\xb6\xe3\xb02\xee\x85t\xb8\x17\xd2\xb1N\x1d;\xec~\xcb\x81\xdf/p\xeaZ\xbc2\'O\'\x1a\x1a\xbf\x12\xb5\xdc/Y\xb0T>\xbfR5\xd7\x1d\xfc\xe6\x8e\xe0\xba\xc3Dw\x04\xc9\x1d\xa5\xfc\x1dArG\xe8\xdc\x11$w9\x8d\x81;\t\x129\x0e\xbb\x93EJ\x82\xb9\xa3\x9dp\xf7E\xc3\xa1\xc5\xed\x8a;\xab\x81F\xeb\xbeb\xc5o\x05\x9dT@\xbd\n\xc0ZaG\x15vT\xc1\xa7*\n\xa1\xa6\x92\xf9(r2\x95g\xf4^\xe1\xeeH\xa5\xc9\xefH\xf7\x95\x10\xb1\xad\xc1S\xc1\xa9*O\xea>\x95\x8a\xee\xb9R\xd7\xf0\xabp\xdf\xa6\x12\xa8\x87V\xc4\x85\x7f\x88\xc8\x8d\x9dJ\x81\xc9\xf2\xea(\x15\xc8E\xa5\xc8\x80\x1f\xac\xa1\xc4S*\xe4\n9\xaaB\xa3\xb5B\xc2\xab\x08\xceK\xbb\xadB2\xaf\x88\xf7\x08\xa2WH\xe6\x15\x12Ae\xa4\xc8Q\xa1\xd7\x98\xa5\xb0\xce\xaeu\rY\x8a\xf0,\r\xd1,\xb6\xf7\xb0a\x16\x92\x90\x85\x82f9O\xce\x92\xad\xb2\x9c\xa8e\xa1$Y\xc8f\x96s\x80,\xa1\x9c\x85E\\\x8b\x01\xe4\xf8?\x0b\xad\xcc\x82\x0b\xd9H\x8d\x95m\xf26i;\n^g\xe9@e\xf1\x87lU\xed\x96-3\x96.h\x96r(+\xfe \x80\x9e\xad\xf1b\n\xaa,\x9d\xd8l\x81\x9fy\n\xb6\xd9\x92:W\x96\xcb\x1c\xd9"/\xf6\xd9\x85\xc4\xf71\xb1\x99\xe3!\xb3\xc6@jUT\x0b\xfbv\x13\xa7*\x9eL\xf8$\xa3\x89\xb4\x94PL1c\n\xb1I\xc9\xd1)Q\x99\xd2\x01H\x89\xeb\x94hO\xc9\xe7\xdf\xa8\xae\xbei\xae5\xdf\xa8\x98\xbeQ\xcb}\xb3\x96#\x9e"\x97`R|8\xc5SR\xf1\x1fa0)EP\xfa\x0b\x11\x0fL\xc7\x1a\x10)\xa7\x85)\xae\x9f\xd2\x92O!\xafi\x9f5\xd0\xbeOi\x87y\xa1z`\n7M\x0f\xea\xb8\xe9\x9e\xc9\xe0\xa6\xdf\xacb8%\x1b\xa7\xc4u\xca-\xa3\x14r\x9a\xc2\xc9R\x98Z\x83}6\xe8f6h&4\x92\x8f\xa7\xa6Erk\xf0\xe2\x06i\xb7\x81\xef7\xa08\r*\x9b\x06\xd7\x85\x1a\xa4\xf3\x06d\xa6Am\xd4\xa0\xbaj\xf8\xfc\xec\x07O\x9f\x11\xe1@\r\x9a\t\r\x88O\x03Do\xb4\x18@\x0f\xa2\x01\x8c7:\xec\xc2J\xd1\r\\\xbcA\xc9\xd4\xb0\xda\xb7\x0b\x92m\x03\x8e\xd3\x80\xb36,\x05\xe2\xee\x0bk\xe2\x93me\xff16\x88\x01\xdf\x18W\x8aa+1n\x17\xe3\xa2\xf1P\x8d\x14c\xe6x\xccX\\?\xc6\xf5c\xc2$&-\xc4\x80o\xbc\xd0\xe0\x89q\xaax\xc9\xdb\xc8<\xf1\x8a\xb1\xb0\x99\x18g\x8d9(\x8f\xa9\xbabJ\xb8\x983\xc0\x980\xb9\x82\xac,\x80\x8b\x05Zm\x9dTy#\xbf\x03|b(A\x0c:\xc5\x90\xf7\x98c\x9c\x18\xc3\xc4\xa0^\xcc;b\xe0+\xb6\x88\x8b\xebk`\xbb\x9c\xc0\xb9\x9c\xb5\xb9\x82\xda\x92O\\\xf1}I\x85.G\xb6n\x9e\xb1u\xc4\x1a?\xe3\xac\xcd%\xa6\\\xb2\x8c[\xe6gD\xa5\xfb\xc8+\xda\xea\x11.\'p.gm.w\x86\\\xce\xda\xdc&\xf3r\xd6\xe6\x86\xfa\xd4!\xc5\xba\x9c\xc09\xdc>q)\xf5]2\x8ck\r\xa0#\xe4\x12\x03.g\xba.\xa5\xbeK\xa9\xba\xd9\xf1\x94\xbb4.Wl\\b`\x83\x83\xba\xdc\xa3q9\xecp\xc5W\x85\x1a\xb9\x90\x95\r5\xb2\x8b\xaf\xba\xc4\x80\x0bww\xd7h\x12\xf6\xb5\xe1\xfe\xc2\x86\x1do\xe8vm8\xe1s9~\xdap\x14\xecr\xd8\xe1\xda\xa7K\x1b+s;\xd6\xd5f\x1a\xe0\xaev\xd33\x1bBf\x83;\xbbV\xf7\xd1u1.a\xe0f\x99\x98\x88\xd80`\xe3\xa2,x\xc0\x86H\xdb\x90\xd07\xf0\x80\r\x01\xea\xa0\xee\x11\x17\\G4\x17#\x16\x1c\xb1\x8d\x88P\x8ch]E\x16:G\xb24\xc92\x11\x0b\x8e\xe4\xcdB\x1a"\xbd\xc8o"\x80::\xe9\xb5$\xf2A\x8d\x13a\xf4\x88l\x1a\x01f\x11\x1d\xd7h\xc3\xd8\xa9*0\xa2=\x16QKF)K#\xcfG@r\x84\x0fF\x84D$\x81"\x146J\x18\x10)4DT\xb9Q\x07Q@@\xca\xeb\x88\xcb\xb7\x11\x17u#\x92{TV\x18\x89\xe8JF\xa0OTg\x00\xd9?\x82\xb7Fy\xe6\xf5\x18Ku3\xc4\x9eC\xac<\x14\xd3\xca\x9d\xcc!.3\xc4e\x86\xda\x1e3C<mH6\x1eb\xef!$q\x88\x07\x8f\xf0\x9e\xa1\x15GC\x02w\x08b\x0c\xe9h\r\xe9h\ri\xb6\x0fi\x97\x0ci\x9a\r\xb1\xcb\x10\xee8\x04\x94\x86\xdc\xe4\x1f\x02kC\xcd\xbbf\xc4\xe6\x1c\xa9\xb4\xa5\xfe>\xb0\xcf\x03\x9b;\xb0\xe5\x03\xfb<\xa0\xb4\x03\xaa<\xa0\xbf\x03\xaf8`\x81\x03v9\xa0\xa9\x11o\xbb\xa63p\xcd\xd5\xafk\xdag\x07K\xab\xd7\\\xfb\xbf&\x8b_\xd3r\xb8\xa6\xe5pM\x1b\xe1\x9a\x0e\xdc\xb5\xac]: \xd7\xec\xf3\xda\xda\'Z=PU\x1e\xe6\xfa\xb3\x03\x08y\xa0\xbds\xe0`\xe3@\xf7\xeb\x00\xf8\x1e\xc8<\x07\x0e+\x0e\xc0\xf7\x81\xabI\x07\xa0\xfe\xb0d\x06\xfc\xe8@\xff\xec\x00\xe8\x1d(\x93}\x0bz|\xd0\xcbg\xcb\xbe\x85o\xbe\xc2\x9e\xf1\x81/\x1f\x8b\xfb\xdc\x88\xf7Aa\x1f\x83\xfaX\xdc\xa7\x7f\xe1\x13\xcb~\xa0p\xe1K\xdcK\xe9\xea\x83\x11~Y\xd1\xc0\x87u\xf8\x12\xe1/"B\xea}>_\xf2\xa9b}j\x01\xbf\xc0\x0cy\x96\x0e\xd5\xf7\xa5\x00\x10\x92\xed\xbf\xf0bN{\xfc\x0e?\x83\xdf\xfb\x94\xf0>=\x1f\x9f\n\xc1\xa7\xe7\xe3\xd3"\xf1q\x19\x9f\xfbZ>\xc7L>W\xe3|\xf1\x08a\xbd\xbex\x84d.\x9fF\x84Oq\xe8\xe3S\xfe\x9e\xb7Au}\x9af>\xd0\xe3C@|r\x91\xbfd\x91\xe2i\xbfE\xa47\xf3|\xf2)1\xe73\x01\xf3\x8co<\x8b9\x9fE\xa4_\xf5La\xf6\x0c\xbd}~V\x13\xfd#\x88$\x14\xfa\x1f.\xc5?\x8b1\xa4)\xf1\x0c\xb3\x99Zh0\xe5lc\x8a\xafN9?\x9d\x02ISh\xfa\x94\xb5O\xc1\xa1)\xa11\xc5\x99\xa7\xc0\xd7\x14o\xbfg\x86{\x1a\xf6\xf7\xf4Y\xef\xef\xf4m\xf79]\xef=Pw\x0fN\xdd\x83^\xf7|\xe0t\x0f\xd2\xdd\x0bzIk\xf4\x1eL\x9bb\xfb)\x1f\xd5Ma\x86\xd3\xa1b\xc4\x14\xc0\x99\x02oS\xe0mJG\x7f\n\xeb\x9d\x92J\xa6P\x87)04\xe5\xb6\xea\x14\xef\x99\xc2d\xa6$\xb9)e\xd9c\xa0\x0e\xf1\xe8+L=J\xf8J[\xf3\x99\xf3\xd5GV\xf6(K\x17\xa2\xf2\x88C<ri\xf4\x11k>b\xa1,*1\x0c\xf8\xafM\x80?c\xf0\xcf\x18\xfc3\xa3?\xe3\x1c\x9f/x\xca\x8d\xa1\xcf\xa0\xe2\x92\x88Y\xa2\xaa%Lo\x89~\x96\x1bDBu\x89\xaa\x96\\D^\xd2\x96\xfcl/~I\xd5\xb4D-K\xd8\xe2\x12;/\xb1\xfe\x92\x84\xb5D\xc7K>\xbf\\b\xfd\x1b\xf2\xe7\xd2\x8a\xbf%j[\x12\x1cK\xd8\xc1\x92\xfe\xc5\x92P\\\xc2:\x96\x98i\x89\x8a\x97(\xfe\x86\xa7\x01c\x03W!\'\xb0\x06h\x88\x9b\x80,\x16\x80\x0c\x01\x9d\x95\xe0\xb4\r\xf1\xb6\x806_@\x9a\x0fh\xf3\x05c\x8d\xe6\x00\xfa\x15\xd0Y\t\xf8\x10"\xe0\x849\x80\xd6\x05 n@\xfb+ u\x07DR@\xc6\x0f$P\xaa"rn\x15\xd4\x11\xb9\x04\x10Ty\xca\xf5\xc5\xa0\xac0\x1cH\xd2\x14\n\x1d\x94\x18\xcb\xd7\xb2\x01\x07\x04A\x01M\xf1\xe1l\xe0\xf1TR\xa9\xa4\x82\xa0\xc3+\xc8\x94\x01\xb7\xc1\x03:\xdc\x01UE\x10\xaaO\x05Z`\x98\x1en\xd2\xe3\x10\xbb\x87\r{\xd8\xbb\x87\x9b\xf4\xf0\x8d\x1e\xde\xd5\x83\xfd\xf7\xbe2\x16\xaf\xed\xbd\x02v\xbd\x81Z\xa0\x07\\\xf6F\x0c\x80\x8f\xf7z\x0c\x00\x18{TZ=\x82\xab\x97j\x18\xf5\xc6LF \xf6h\x9f\xf56\n\x97=\xdc\xa4\xf7\xc6\xcap\xa9\x1e\x05F\x8f\xa6m\x0f\xe8\xb8\xb0Ab{\xfaC\xc0\xd3\xa13ra5)\xb7\x84\xf0\x05J\xbe@\xc9[\x14wA$]X7E/2\x1c\rl\xad\x1f2\xdd\x96\x8b}[\x8e\xd5\xb6\xd8w\x0b\xa6n\x7f\xf2\xbe\xba:\xcbE\x11\xd1G,!\xfe\x97=]p\'\xec\xa2\xa3\xe2\x16%m\x856\t\xff\xd9\nmz\x17\x91\x8b\x9c[\xda\x8d[\x94\xbf\xc5$\x17\t\xf3\x02\xf7[\x92\xc0\x16\x1e\xb8\x05S\xb6|c\xbe\xa5\'\xba\xe5\x90xK\x83uK\xf9\xb7\xa5\xed\xb5\xe5\xde\xfeVPI\x9aV\xdbX]hK\xf1\xb1\xed)\xae\xb5\x0e\xba\x9c\x16m/\xcf\xeaA\xb6V\xaa\x93{\x0b\xed[\xb4\x17Zd\x94\x16I\xb9ES\xb9\x05]\xf5\x08\xe3\x960\xedc\xef\xdbx\x1c\xc3\xb4\xba\x8a\t-\xb1\x91\x90\xf9\x96\x80\x86\xd4\x0b-\x81\x12\xa9\x17<q*\xb9l\xdd\x82t{\xe2T\xc2*[\xfc\xb3\x82\x16\xa7\x04-N\xc8Z\x94\x19\xad\no\xa3\xa0hq\x87\xbf\x05qm\t\xf4\xc9)\x96WPP\xf6\xf2\xac\xc1\xfa\x19q\xe2q\x19\xc3\x13\x0f\x15\xa6\xe3Uto\x1e\xb7\r<\xaa\x1e\x0f\x84\xf7X\xba\xc7\xb1c\xcb*\xde\xbc\xa6\xc6\xa2\x17\xb1`\xce\x19<\xa0\xd8\xa3\xc0\xf1:<}\xd2\xdd{\x94H\xde3O_P\x8f\xa3\x9e\xdf"j\xbd\xbeb\xa3\x07/\xf5\x06\n}\xde\x08\x91\xa3\x05\x0f\x14\xf4\xe8cyP\x97\x16\xf7\xe8<\xd0\xd5\xe3h\xc1#v<J\x19\x8f\xa3c\x8f\x98\xf4V,\x92\xf3\x04\x8f\x00\xf7 f\x1e\x9f\xe3y\xf4R=>\xfc\x1c1\xd6\xa1\x976\x82\xef\x8e\xacf$k\x18\x81\x0b\x0e\xa1\xec\xf0\xbd\xbeC#\xd9\xa1\xbd\xecp\x99\xd2Ag\x0e\xd9\xcb\xa1m=\x02\xdd\x1c(\xdc\x88\xb3\x9d\xd1P\xb53"\xd3\x8d\xe8D8\xb0\x15\x87\x96\xc2\x88;\x98\x0e-n\xc7R\t\xc7\xed#\x8c\xe5\xf0\xa5\xd1\x88\xa5\x8f\xc6\xea\x04\x0e\x07\xd5\x0e\x9f\x0c9\x1cn8|t\xe4p\x10\xe2p<\xe2\xf0\xb9\xaf\xc3\xd7\xc1\x0e\xdf\t9|S\xe4p\xce\xe1\xf0\xfd\x91\xc3\x99\x88\xc3\xb7J\x0e\xe7\'\x0e\xdf\t9\x9c]8|S\xe4p\xce\xe1p\xfa\xe1p&\xe2pR\xe2\xf0\xad\x92\xf3\xc2+\x9e\x99\x8c\xd3\x8f\x11\xe1\xe4H>\x94v\x80c\x14+\x1c>\xffv\xfe\xf5!\x1a\'ct\xb2\x7f\x8eO\xa5\xdf\xe7\xc8\x89\xb7\x90=\'\x8b\xc8\xb5\xbf\x11\xd5\x8fC\xfev\xa4B\x95km\x0eu\xab\xc3\xb7\xec\x8e\x94\xbbR\x04\x8f(\x84\x1c)w\x856;R\x04Ki<\x82\xaa9R\xcd~\x11\x91\nc\x04\x81\x1bY\xe9\xe7\x1d\xa2\xf5N\xbd\xf2N&z\xc7\xbb\xde\xb9d\xf8\x0e\x1f\x7f\x87\xa5\xbf\x13#\xef\xef\x1a\xb2\xef\x94`74\x9b\x1cB\xf6f\xa0;z\x87\xd3\xbc\xbb\xbc\xcd\xda\xdcZ\r\xf7\x0ef\xbe\x83\x99m\x0e|\x1c\xf0\xea\x86\n\xff\x06]\xdf\xd0#\xb8\xa1\xefyC\x8f\xe0\x86/\xacnh\x9d\xde\xd0P\xbd\xa1\xf7pC+\xe4\x86\xf5>nu\x17\x0eHZ\x12\xbf\x17\xe4/\xd1\xe5/\xd1\xfb/q\x03\xa9D7\xbeTR\xff,q\xd7\xa8D]R\xa23X\xe2\xba\x7f\tU\x97\xb0E\x89{\x0f%\x0c[\xe2\xf3\x84\x12Ek\x89\xa3\xe6\x92u ^\x82\xaf\x96\xc4\x02R\x14\x948\xed)\xb9\xcc\xc6\x8d\xbb.\xed\xc9.]\xcd\xae,X\x9a\x80]z\x16]v\xdf\xa5\x90\xea\xc2R\xba\xa2\xbfS\xce\xee\xd28\xee\xe2\xa0].\x83t\xed\xcfA\xce!K)\xd0|N\xa4u\t\x99\xae\xab\xf6\xe8\xe2\xa2]\x8b/t\xf5\x03a\xd3\xa5L\xeeBZ\xba\x14\x02c\x9e\xce\xa8|g\xe4\x92\x19\xb7\x07f\xe4\x92\x19]\x8bY_w:\xa3\xee\x98Q\x1f\xcd\xb8:2\x9b1\xc3\\\x83c\xcd\xe6f\x84\xf8\x0cE\xccH\xc53\x92\xf9\x0c\x7f\x9e\xe1V3R\xf1\x8c+\xd93:\xa63\x90\xe1\x9c/\xd8g\x00\x91\x99Q\xa2\xce0\xc1\x8c\xae\xc7\x8c\x18\x9f\x11_3\xac1\x03Zg\xd6\xe6P\xfb\x0c\x18\x9ea\x81\x07&{`\xb2\x07y\xb1$\x93\x87\x07\x9erq\xf2\xe1Zq\xfa\xe1F\x01\xf7\x81\xcd=\\\xf1\x14\xecx\x00Q\x1e\x04;$\x83<\x08\xa2H/\xb2\xea|\xc4\xb8\xa9\xe2GUb\xaaj9]\x95\x05W\xd9Q\xf5\xa4V\x89\xaaj\xacJ\xa9R\xefT\xb1x\x15\x86X%\xca\xab\x90\x8e*uK\xd5\xd7x\xaf\x12\xc3\xd5\x9a\x06n\x95\xb8\xac\x86\x8aUU\xae\xe5U\xb9\xb1Y\x85\x13\x9f\x91\xc4\xcf:\xfa\xe2\xb3\xa6\xae\xec\x0c\x1ap\x161\x00\xd2q\xc6\xbf$;\xcb\xeb\x80\xefv\xad~\x86{\x9cQ\r\x9f\xd9C.\xf1\x95\xdfh\xb6\x85\xf8\x9b\xff\xfe\xd2\xa4Q\xd0\xdc \xc2T\x9b\x07u\xdd&`\xd4\x14#\xc8\x19@\x13\xf6\xd9\x9c\xa8\xb75Sf\x00\x80\x9b\xdc\x82lF\xaa\xcd\xa6hH0\xbe\xd9A$\xa34\xf9\xf8\xb6\xd9U\xfcmr\xa2\xd3\xa4\xbejr7\xb2)\x8a\x95z\xb0I\x1ai\xd2\x15kr\x81\xac\xe9\xf06"\xa9\x89\xce\x9a\x94LM\xeb\xf8\xac\xcf\xc7\xab\xfd\x89j\xb5\xcfU\xa8>t\xa4\x0fI\xe9S\x15\xf4\xa9\xc9\xfb\x16HR\xe6\xf4\xb9\x98\xd1\x07\x7f\xfa`U\x1f\x04\xeb\x93\x9c\xfb\xd8\xb0\xbfa26\xd7\'\xab\xf5\xd9g\x1f|\xeaS\x9c\xf7\t\xcb>\xf0\xd3\xc7\xd1\xfaV\x8b\xe0\x8d\x1d\xbd\xd1s~#X\xdf\xf8\x94\xfc\x8d\xb5\xbf\xb1\xe07\xdd\xa7y\xcb\x18\xfd\x19k\xcfc\xf0<\xdfB\xe5\xa9\xb8\xf3T\xc6\xf9@a$O\xb8\xe7\xdb\xcc\x00\x8d\xc9\x13\xf9y\x02;O\xea\xcd\xd3\xe7\xcb\xe3\xd7y6\x94\xe7\x7ft\xe5\xe9\xd2\xe5\xe9\xe0\xe6\xb1\xe1F\x9b&&\x0fH\xe692\xcbc\x97\xbc\x85\x97yL\xd0fD\x1b\xf5\xb4\x15}3#,\xd7\xde\xe8z\\\x98q\x9b\xfbDm\xc9\xab\xc2\xfd\xda3\x1d\xdb\x06D7\xd6\xcf\xba\n\xa2m)S\xe4\x18\xb6M7\xb7\xcd1M\x9bo\xdf\xda(\xb8\r\x18\xb4\xeb\x1a\xa9m1\x9c\xb0\xc7\xb6\x18NZ\x1am\xba\x1bmxb\x9b\xeb\x9b\xed\xa2\x86r\xfb\x87"@\xdbS#\xb7i\xcc\xb4\xf3\x1a\xcac4\xf9\x89\x1c\xfd\xc9\xba\xaf4\xe6\x9e\xd3\'\x98\xd6\'2\xf3\'\xeb\xbf6|\x02\x9c\xc7\xf0\xe81\x86\x19c\xae\xb15\x96W\x8f9\x14\x19C%>\xd9\xf0>\xb6\x0fY\x80\xe41~5\x06\xd4\xc7\xc0\xc4\x98\x92b\x0cL\x8c\xe1Gc\xf8\xd1\x98o#\xc7\xf4\xa5\xc7\xb0\xea1\x1cm\x0c]\x1ds\x9bjLwaL\x95:\x86\xad\x8f\xb9\xc60\x16\xca(g\xdd\xe3\x01\x1b\x02\r7P\xc6[J\xa0[\xa11\xc2<n\xa1&\xb7P\x93[\xbe\xbc\xbd\xcd\xa99n\xf9\xc7\x11\xb7\x14Q\xb7\xfc\x93\x89[\x8a\xa8[Lw\xcbY\xee\x85e\xf2[<~\x04t\x8e\xfeZ\xf4\xff\xfe\x1f\xfa\xddI\x97'))
global t
t=' '
def f(k):
 global t
 r=a[t+k]if t+k in a else'e';t=k
 return r

1
त्वरित स्पष्टीकरण: यह zlib.decompress('...')मूल्यांकन करता है {'G?':' ', 'G;':' ','G"':' ',.......}, और aएक शब्दकोश है जो 2 वर्णों से 1 वर्ण तक का मानचित्र बनाता है। Steadybox के मूल रूप से 2-चरित्र संस्करण जवाब
user202729

1
जैसा कि मैं देख सकता हूं, शाब्दिक 17780 बाइट्स हैं। आप विघटित सामग्री में व्हाट्सएप को हटाकर इसे 11619 चार्ट तक कम कर सकते हैं, जो 12322 बाइट्स बचाता है। (अगर मैंने सही तरीके से गिना है) इसके अलावा ... हेक्स एस्केप कोड्स को वास्तविक कच्चे वर्णों में परिवर्तित करना और भी अधिक बाइट्स बचा सकता है।
user202729

कच्चे बाइट्स होने पर मैं यहां कुछ कैसे पोस्ट करूं?
स्काइलर

1
xxd, hexdump, uuencode, या इसी तरह
पीटर टेलर

@ user202729 कृपया ध्यान दें कि पायथन कोड में वास्तविक कच्ची NUL बाइट्स नहीं हो सकती हैं।
mbomb007

4

हास्केल, (1904 + 1621 + 208548 + 25646) * 2 + 371705 = 847143

{-# LANGUAGE FlexibleInstances, DeriveGeneric #-}

import Control.Arrow
import Control.Monad
import Control.Monad.Trans.State
import Data.List

import System.IO
import Data.ByteString (ByteString)
import qualified Data.ByteString as BS
import qualified Data.ByteString.Lazy as BSL
import qualified Data.ByteString.Char8 as BC8
import Data.Ord
import Data.Char
import Data.Monoid
import Data.Maybe (fromJust, catMaybes)
import Data.Function
import qualified Data.Map as Map

import Codec.Compression.Lzma

import Data.Flat

import GHC.Word

maxWordLen :: Integral n => n
maxWordLen = 20

wordSeqDictSize :: Integral n => n
wordSeqDictSize = 255

predict :: [Trie] -> Char -> State ([Either Char Int], String) Char
predict statDict c = do
   (nextChar:future, begunWord) <- get
   case nextChar of
     Left p -> do
       put (future, [])
       return p
     Right lw -> do
       let wpre = begunWord++[c]
       put (future, wpre)
       return $ trieLook (tail wpre) (case drop lw statDict of{(t:_)->t;_->Trie[]})

newtype Trie = Trie [(Char,Trie)] deriving (Show, Generic)
instance Flat Trie

trieLook :: String -> Trie -> Char
trieLook [] (Trie ((p,_):_)) = p
trieLook (c:cs) (Trie m)
 | Just t' <- lookup c m  = trieLook cs t'
trieLook _ _ = ' '

moby :: IO (String -> String)
moby = do
    approxWSeq <- BSL.unpack . decompress <$> BSL.readFile "wordsseq"
    Right fallbackTries <- unflat <$> BS.readFile "dicttries"
    seqWords <- read <$> readFile "seqwords"
    let rdict = Map.fromList $ zip [maxWordLen..wordSeqDictSize] seqWords
    return $ \orig ->
      let reconstructed = approxWSeq >>= \i
             -> if i<maxWordLen then let l = fromIntegral i+1
                                     in replicate l $ Right l
                                else Left <$> rdict Map.! i
      in (`evalState`(reconstructed, ""))
              $ mapM (predict fallbackTries) (' ':orig)

उदाहरण:

Call me Ishmael. Some years ago--never mind how long precisely--having
 ap  me ,nhmael.  Hme ?ears |ce--never  usd how long .aacesely--|ubing
little or no money in my purse, and nothing particular to interest me on
little or no ?ivey in my ?efse, and ,uwhing .hrticular to Bdaenest me on
shore, I thought I would sail about a little and see the watery part of
?neae, I thought I would  cfl about a little and see the |rkers part of
the world. It is a way I have of driving off the spleen and regulating
the world. It is a way I have of ,uiving off the |kli   and .ia       
the circulation. Whenever I find myself growing grim about the mouth;
the Ca         . B        I  rtd |yself ,haoing  eom about the ?ivlh;
whenever it is a damp, drizzly November in my soul; whenever I find
Baieever it is a  'mp, ,uiv    Bar      in my  cfl; Baieever I  rtd

तीन पूर्व-संगणित सहायक फ़ाइलों का उपयोग करता है:

  • seqwords जिसमें 236 सबसे आम शब्द हैं।
  • wordsseq इन शब्दों का एक LZMA-संपीडित सिस्ट होता है, और सभी शब्दों के लिए 236 सबसे आम, लंबाई नहीं है।
  • dicttriesप्रत्येक शब्द-लंबाई के लिए, एक निर्णय वृक्ष जिसमें सभी शेष शब्द शामिल हैं। इन कोशिशों से, प्रविष्टियों को उठाया जाता है जैसे हम जाते हैं।

इस तरह, हम अन्य सभी हानिपूर्ण योजनाओं की तुलना में काफी कम त्रुटि दर प्राप्त करते हैं; दुर्भाग्य से, wordsseqफ़ाइल अभी भी प्रतिस्पर्धी होने के लिए बहुत बड़ी है।

यहां एक पूर्ण संस्करण है जो फाइलें बनाता है और विश्लेषण करता है:

depunct :: String -> [String]
depunct (p:l) = (p:take lm1 wordr) : depunct (drop lm1 wordr ++ srcr)
 where lm1 = maxWordLen-1
       (wordr, srcr) = (`span`l) $ if isAlpha p
                 then \c -> isLetter c || c=='\''
                 else not . isAlpha
depunct []=[]

mhead :: Monoid a => [a] -> a
mhead (h:_) = h
mhead [] = mempty

limit :: [Int] -> [Int]
limit = go 0
 where go z (n:l) | z<100 = n : go (z+n) l
       go _ l = take 1 l

packStr :: String -> Integer
packStr = go 0
 where go n [] = n
       go n (c:cs)
        | c>='a' && c<='z'  = go (28*n + fromIntegral
                                   (1 + fromEnum c - fromEnum 'a')) cs
        | otherwise         = go (28*n) cs


mkTrie :: [String] -> Trie
mkTrie [] = Trie []
mkTrie strs = Trie [ (c, mkTrie . filter (not . null) $ tail<$>l)
                   | l@((c:_):_) <- sortBy (comparing length)
                                  . groupBy ((==)`on`head)
                                  $ sortBy (comparing head) strs ]

mkTries :: [String] -> [Trie]
mkTries rsrc = [ mkTrie $ filter ((==l) . length) rsrc
               | l <- [0..maximum (length<$>rsrc)] ]

main :: IO ()
main = do
    orig <- readFile "whale.txt"
    let wordchopped = depunct orig
        dictRes
          = take 5000
          . map mhead
          . sortBy (comparing $ negate . length)
          . group . sort
          $ wordchopped
        dict = Map.fromList $ zip dictRes [maxWordLen..wordSeqDictSize]
        rdict = Map.fromList $ zip [maxWordLen..wordSeqDictSize] dictRes
        approxWSeq = [ case Map.lookup w dict of
                        Just i -> i
                        Nothing -> fromIntegral (length w - 1) :: Word8
                     | w <- wordchopped ]
        fallbackTries = mkTries . drop (wordSeqDictSize-maxWordLen) $ dictRes
        reconstructed = approxWSeq >>= \i
             -> if i<maxWordLen then let l = fromIntegral i+1
                                     in replicate l $ Right l
                                else Left <$> rdict Map.! i
        predicted = (`evalState`(reconstructed, ""))
              $ mapM (predict fallbackTries) (' ':orig)
        incorrects = length . filter id $ zipWith (/=) orig predicted
    putStrLn $ "longest word: "++show(maximum $ length<$>wordchopped)
    putStrLn $ show incorrects++" errors / "++show (length orig)++" chars"
    BSL.writeFile "wordsseq" . compress $ BSL.pack approxWSeq
    BS.writeFile "dicttries" $ flat fallbackTries
    writeFile "seqwords" . show $ take (256-maxWordLen) dictRes
    writeFile "whale-approx.txt" . unlines $ coLines orig predicted

coLines :: String -> String -> [String]
coLines [] _ = [[],[]]
coLines ('\n':l) (_:m) = []:[]:coLines l m
coLines l ('\n':m) = coLines l ('|':m)
coLines (c:l) (d:m) = case coLines l m of
   (lt:mt:r) -> (c:lt):(d:mt):r

3

C ++ (WIP), 1923 * 2 + 1017344 = 1021190

#include <map>
#include <random>
#include <string>
#include <type_traits>
#include <vector>

using namespace std;

constexpr minstd_rand::result_type seed = 10087702;

template<typename T>
class discrete_mapped_distribution {
private:
    discrete_distribution<size_t> distr;
    vector<T> values;

public:
    discrete_mapped_distribution() :
            distr(), values() {
    }
    template<typename I, typename = typename enable_if<is_arithmetic<I>::value,
            I>::type>
    discrete_mapped_distribution(map<T, I> distribution) :
            values() {
        vector<I> counts;

        values.reserve(distribution.size());
        counts.reserve(distribution.size());

        for (typename map<T, I>::const_reference count : distribution) {
            values.push_back(count.first);
            counts.push_back(count.second);
        }

        distr = discrete_distribution<size_t>(counts.cbegin(), counts.cend());
    }

    discrete_mapped_distribution(const discrete_mapped_distribution&) = default;
    discrete_mapped_distribution& operator=(const discrete_mapped_distribution&) = default;

    template<typename URNG>
    T operator()(URNG& urng) {
        return values.at(distr(urng));
    }
};

class generator2 {
private:
    static map<char, discrete_mapped_distribution<char>> letters;

    minstd_rand rng;

public:
    static void initDistribution(const string& text) {
        map<char, map<char, uint64_t>> letterDistribution;

        string::const_iterator it = text.cbegin();
        char oldLetter = *it++;

        for (; it != text.cend();) {
            ++(letterDistribution[oldLetter][*it]);
            oldLetter = *it++;
        }

        generator2::letters = map<char, discrete_mapped_distribution<char>>();

        for (map<char, map<char, uint64_t>>::const_reference letter : letterDistribution) {
            generator2::letters[letter.first] = discrete_mapped_distribution<char>(letter.second);
        }
    }

    generator2() :
            rng(seed) {
    }

    char getNextChar(char in) {
        return letters.at(in)(rng);
    }
};

map<char, discrete_mapped_distribution<char>> generator2::letters;

के रूप में यह समाधान WIP है और इसलिए ungolfed खड़ा है। यह भी विचार करते हुए कि वास्तविक कोड आकार मुश्किल से स्कोर पर कोई प्रभाव डालता है, मैंने सोचा कि मैं अपना उत्तर माइक्रो ऑप्टिमाइज़ करने से पहले शुरू कर दूं।
(यहां उपलब्ध पूर्ण कोड: https://github.com/BrainStone/MobyDickRNG - इसमें पूरा कार्यक्रम और बीज खोज शामिल है)

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

फिर पाठ को मुद्रित करने की कोशिश करते समय मैं एक लुकअप करता हूं और संभावित लोगों के यादृच्छिक चरित्र को खींचता हूं। हालांकि यह आमतौर पर केवल सबसे आम निम्नलिखित पत्र के उत्पादन की तुलना में खराब परिणाम पैदा करता है, लेकिन संभावना है कि देवता बीज बेहतर परिणाम उत्पन्न करेंगे। इसलिए बीज कठिन कूट है। मैं वर्तमान में सबसे अच्छा बीज खोज रहा हूं। और बेहतर बीज मिलने के बाद मैं इस उत्तर को अपडेट करूंगा। इसलिए तैनात रहें!

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

स्कोर की गणना करने के लिए उपयोग की जाने वाली विधि: https://github.com/BrainStone/MobyDickRNG/blob/master/src/search.cpp#L15

ध्यान दें कि भले ही कुल स्कोर इस समय सबसे खराब है, यह सिर्फ आउटपुट स्पेस की त्रुटि गिनती को हराता है। और संभावना अच्छी है कि स्कोर अधिक बीज की जाँच करके, ड्रॉप हो जाएगा।

बदलाव का

  • 2018/01/24 : पोस्ट में जवाब दिया गया
    चेक किए गए बीज: 0-50000। स्कोर: 2305 * 2 + 1017754 = 1022364
  • 2018/01/24 : कुछ न्यूनतम गोल्फिंग किया। स्कोर गणना पद्धति में लिंक जोड़ा गया।
    चेक किए गए बीज: 0-80000। स्कोर: 1920 * 2 + 1017754 = 1021594 (-770)
  • 2018/02/02 : नया बीज (10087702) (सबमिशन ठीक करने का समय नहीं मिला)
    चेक किए गए बीज: 0-32000000। स्कोर: 1923 * 2 + 1017344 = 1021190 (-404)

क्या आप अपने उत्तर में एक टेस्ट हार्नेस शामिल कर सकते हैं जो स्कोर का मूल्यांकन करता है?
नथानिएल

@ नथानियल I ने स्कोर कोड को सीधे लिंक किया। रिपॉजिटरी के अलावा क्या आप इस पर पर्याप्त विचार करेंगे?
ब्रेनस्टोन

नियमों की समीक्षा करने पर मैंने देखा है कि मैं उनमें से कुछ का उल्लंघन करता हूं। एक बार जब मैं समस्याओं को ठीक कर
BrainStone

फिर आप टेक्स्ट को रैंडम सीड में एन्कोडिंग करेंगे। गूढ़ प्रोग्रामिंग भाषा बीज देखें , और आप MT19937 प्रोग्राम को रिवर्स इंजीनियर कर सकते हैं और इस उत्तर को हरा सकते हैं (यदि आप कर सकते हैं)।
user202729

अच्छा विचार है, लेकिन एक अच्छा स्कोर प्राप्त करने में मदद नहीं करेगा। वैसे भी +1।
user202729

3

रूबी, ११६४४१18 (ouch)

मैं सिर्फ यह देखना चाहता था कि किसी अन्य उत्तर की जांच के बिना मैं कितना अच्छा कर सकता हूं।
मुझे यकीन नहीं है कि अगर इसकी अनुमति है क्योंकि इसमें फ़ाइल का विश्लेषण करने के माध्यम से उत्पन्न एक शाब्दिक शामिल है, लेकिन यहां तक ​​कि अगर यह ऐसा नहीं था तो यह किसी की पिटाई के खतरे में नहीं था।

x="\"ect,htabsdd,in,\\nodniwlrfydbulkm;f?ckgwvi0,.*pr;\\\"uz17klI\\n-c'WSpA\\nTwqu8.77!-BeWO5.4.CoP\\n\\\"UHEFu2.?-9.jo6.NI3.MaLYDOGoOAR'QUECziJoxp(\\nYa:\\nVI);K\\nUS*IZEX\\n&\\n$\\n_y[S\""
f=->n{(x.include? n)? x[x.index(n)+1] : ' '}

मैंने कैसे उत्पन्न किया x

सबसे पहले, मैं a.txtनिम्नलिखित के साथ उत्पन्न :

grep -o ".." whale2.txt | sort | uniq -c|sort -bn>a.txt

फिर मैंने उत्पन्न किया a.csv:

cat a.txt | awk '{ print $1","$2 }'|sort -n|tac>a.csv

तब मैंने इसे xनिम्नलिखित रूबी लिपि में शामिल किया:

f={}
File.open('./a.csv').each{|l|x=l.partition(',')
f[x.last[0..1]]=x.first}
n={}
r={}
f.each{|k,v|if((r.include? k[0]and v>n[k[0]])or not r.include? k[0])and not k[1].nil?
r[k[0]]=k[1]
n[k[0]]=v
end}
s=''
r.each{|k,v|s+=k+v}
puts s.inspect

मैंने कैसे स्कोर किया

w=File.read('whale2.txt')
x="ect,htabsdd,in,\nodniwlrfydbulkm;f?ckgwvi0,.*pr;\"uz17klI\n-c'WSpA\nTwqu8.77!-BeWO5.4.CoP\n\"UHEFu2.?-9.jo6.NI3.MaLYDOGoOAR'QUECziJoxp(\nYa:\nVI);K\nUS*IZEX\n&\n$\n_y[S"
f=->n{(x.include? n)? x[x.index(n)+1] : ' '}

score = 235
w.each_line{|l|v=l[0];l[0..-3].each_char{|n|v+=f[n]};v.split(//).each_with_index{|c,i|if l[i]==c
print c
else
print '_'
score+=1

end}}

puts "FINAL SCORE: #{score}"

मुझे यकीन है कि इसकी अनुमति है; यदि आप फ़ाइल का विश्लेषण, अच्छा काम! केवल अगर प्रोग्राम ऐसा करता है तो यह अमान्य है।
निकोलफर

@EriktheOutgolfer> _> (चुपचाप एक "(गैर-प्रतिस्पर्धी)" शीर्षक में स्लाइड करता है)
NO_BOOT_DEVICE

क्यों? यदि यह वैध है, तो यह प्रतिस्पर्धा कर रहा है, भले ही यह ज्यादा हरा न हो। यदि यह अमान्य है (अर्थात, आपका समाधान फ़ाइल से पढ़ता है, और इसमें केवल शाब्दिक नहीं है), इसे हटा दिया जाना चाहिए।
आउटगोल्फ

हममम। मुझे लगा कि आपका मतलब है अगर किसी प्रोग्राम ने फाइल का विश्लेषण किया, न कि सिर्फ समाधान का।
NO_BOOT_DEVICE

1
मैं रूबी को नहीं पढ़ सकता, लेकिन मुझे लगता है कि यह मान्य है। कार्यक्रम के अंदर शाब्दिक पूरी तरह से ठीक है, यह कोई समस्या नहीं है।
नथानिएल

2

पायथन 3 , (146 * 2 + 879757) 880049 बाइट्स

def f(c):return"\n                     t \n 2  sS \n  -  08........       huaoRooe oioaohue thpih eEA \n   neo    enueee neue hteht e"[ord(c)-10]

इसे ऑनलाइन आज़माएं!

सुंदर सीधी आवृत्ति तालिका। स्ट्रिंग में प्रत्येक स्थिति वर्तमान चरित्र के एससी कोड (माइनस 10 = 0x0a = '\ n', फ़ाइल में सबसे कम वर्ण) से मेल खाती है, और प्रत्येक इंडेक्स पर वर्ण सबसे अधिक बार अगला वर्ण होता है। मान लें कि मैंने आवृत्तियों की सही गणना की है ...

User202729 के परीक्षण से कोड के साथ परीक्षण किया गया


क्या आप उपयोग करके कुछ बाइट्स बचा सकते हैं def f(c):return(" ">c)*c or"t ... e"[ord(c)-32]?
नील

0

[अजगर ३] (६४४४४ ९ * २ + ०) १२88 ९। अंक

केवल 644449 बाइट्स में सही सटीकता

import zlib,base64 as s
t=enumerate(zlib.decompress(s.b64decode(b'###')).decode());a=lambda c:next(t)[1]

पूर्ण कोड एक उत्तर में फिट नहीं हो सकता है, इसलिए मैंने इसे यहां रख दिया है और उत्तर पाठ में b '###' के साथ बड़े बाइनरी स्ट्रिंग शाब्दिक को बदल दिया है।

यह निम्न कोड के साथ उत्पन्न होता है, जहां "संशोधित" जेनरेट की गई फ़ाइल है, और "cheatsheet.txt" दूसरे वर्ण से शुरू होने वाली व्हेल 2.txt फ़ाइल है।

import zlib, base64
with open("modified.py","w") as writer:
    writer.write("import zlib,base64 as s\nt=enumerate(zlib.decompress(s.b64decode(")
    with open("cheatsheet.txt","rb") as source:
        text = source.read()
        writer.write(str(base64.b64encode(zlib.compress(text,9))))
    writer.write(')).decode());a=lambda c:next(t)[1]')

कोड को "संशोधित थिंकपैड" के अंत में जोड़कर निष्पादित किया जा सकता है। "whale2.txt" को एक ही डायरेक्टरी में "संशोधित" के रूप में होना चाहिए, और आउटपुट "out.txt" को लिखा जाएगा।

with open("out.txt","w") as writer:
    with open("whale2.txt","r") as reader:
        text = reader.read()
        for b in text:
            c = a(b)
            writer.write(c)

यह उत्तर सीधे तौर पर whale.txt या whale2.txt तक नहीं पहुंचता है। यह मौजूदा मानक संपीड़न पुस्तकालयों का उपयोग नियमों में स्पष्ट रूप से अनुमत है।


वहाँ एक "\ r \ n" हो सकता है कि जब मैं उनकी गिनती कर रहा था तो मैं विंडोज में छुटकारा नहीं पा सकता था
लेगोरहिन

2
हाँ, यह एक टाइपो था जिसने प्रचार किया था
लेगोरहिन
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.