මොබී ඩික් ලියන්න, දළ වශයෙන්


303

මෙන්න හර්මන් මෙල්විල්ගේ මොබී-ඩික්ගේ පෙළ අඩංගු 1.2Mb ASCII පෙළ ගොනුවක් ; හෝ, තල්මසා . ඔබේ කර්තව්‍යය වන්නේ වැඩසටහනක් හෝ ශ්‍රිතයක් ලිවීමයි (හෝ පංතිය යනාදිය - පහත බලන්න) මෙම ගොනුවට වරකට එක් අක්ෂරයක් ලබා දෙන අතර සෑම පියවරකදීම ඊළඟ අක්‍ෂරය අනුමාන කළ යුතුය.

මෙය . ඔබේ ලකුණු වනු ඇත

2*L + E

එහිදී Lබයිට් ඔබේ ඉදිරිපත් ප්රමාණය වන අතර, Eඑය සාවද්ය අනුමානය චරිත සංඛ්යාව වේ. අඩුම ලකුණු දිනා ගනී.

වැඩිදුර විස්තර

ඔබගේ ඉදිරිපත් කිරීම වැඩසටහනක් හෝ ශ්‍රිතයක් (යනාදිය) වන අතර එය දත්ත කැඳවනු ලැබේ. (1215235 වරක් නිශ්චිත විය.) එය නම්, ඒ සඳහා කර ඇති විට n වන එය ලබා දෙනු ඇත කාලය n වන ස්වභාවය whale.txtහෝ whale2.txtඑය කල යුතු (එහි අනුමාන ප්රතිදානය n + 1 ) වැනි චරිත. Eඑහි ලකුණු වල සං component ටකය එය වැරදි ලෙස අනුමාන කරන මුළු අක්ෂර ගණන වේ.

බොහෝ ඉදිරිපත් කිරීම් සඳහා ආයාචනා අතර යම් තත්වයක් ගබඩා කිරීමට අවශ්‍ය වනු ඇත, එවිට ඒවා කොපමණ වාරයක් කැඳවා ඇත්ද සහ පෙර යෙදවුම් මොනවාදැයි සොයා ගැනීමට හැකි වේ. බාහිර ගොනුවකට ලිවීමෙන්, staticගෝලීය විචල්‍යයන් භාවිතා කිරීමෙන් හෝ ශ්‍රිතයකට වඩා පන්තියක් ඉදිරිපත් කිරීමෙන්, රාජ්‍ය මොනාඩ් භාවිතා කිරීමෙන් හෝ ඔබේ භාෂාවට වැඩ කරන වෙනත් ඕනෑම දෙයකින් ඔබට මෙය කළ හැකිය. ඔබගේ ඉල්ලීමට පළමු ආයාචනයට පෙර එහි තත්වය ආරම්භ කිරීමට අවශ්‍ය ඕනෑම කේතයක් ඇතුළත් විය යුතුය.

ඔබේ වැඩසටහන නිශ්චිතවම ක්‍රියාත්මක විය යුතු අතර එමඟින් සෑම විටම එකම ආදානය එකම අනුමාන කරයි (එම නිසා සෑම විටම එකම ලකුණු ලබා ගනී).

ඔබගේ පිළිතුරට ඔබගේ ඉදිරිපත් කිරීම පමණක් නොව E, එහි ලකුණු වල කොටස ගණනය කිරීමට ඔබ භාවිතා කළ කේතයද ඇතුළත් විය යුතුය . මෙය ඔබ ඉදිරිපත් කළ භාෂාවෙන්ම ලිවිය යුතු නැති අතර එහි බයිට් ගණනට ගණන් නොගනු ඇත. එය කියවිය හැකි ලෙස සකස් කිරීමට ඔබව දිරිමත් කරනු ලැබේ.

ඔබගේ ඉදිරිපත් කිරීම සහ මෙම ලකුණු ගණනය කිරීමේ වැඩසටහන අතර ඇති අතුරු මුහුණත සම්බන්ධයෙන්, ඕනෑම දෙයක් හොඳයි, ඔබේ වැඩසටහන සෑම විටම එහි ඊළඟ ආදාන බයිට් ලැබීමට පෙර සෑම නිමැවුම් බයිට් එකක්ම ලබා දෙන තාක් කල්. (උදාහරණයක් ලෙස, ඔබට එය සියලු ආදාන අඩංගු නූලක් පසු කර සියලු ප්‍රතිදානයන් අඩංගු නූලක් ආපසු ලබා ගත නොහැක.)

ඔබ ඇත්ත වශයෙන්ම ඔබේ පරීක්ෂණ වැඩසටහන ක්‍රියාත්මක කළ යුතු අතර ඔබේ ප්‍රවේශය ඉදිරිපත් කිරීමට පෙර ඔබේ ලකුණු ගණනය කිරීම / සත්‍යාපනය කළ යුතුය. ඔබගේ ඉදිරිපත් කිරීම ඔබට එහි ලකුණු සත්‍යාපනය කිරීමට නොහැකි තරම් සෙමින් ධාවනය වන්නේ නම්, එහි ලකුණු ප්‍රතිපත්තිමය වශයෙන් කුමක් දැයි ඔබ දැන සිටියද, එය තරඟ කිරීමට සුදුසුකම් නොලබයි.

Lකේත ගොල්ෆ් අභියෝග සඳහා සුපුරුදු නීතිරීති අනුව ඔබේ ලකුණු වල අංගය ගණනය කෙරේ. ඔබගේ ඉදිරිපත් කිරීම තුළ බහු ලිපිගොනු අඩංගු වේ නම්, කරුණාකර එම අවස්ථාවේ දී ලකුණු කිරීම සහ නාමාවලි ව්‍යුහය පිළිබඳ නීති සැලකිල්ලට ගන්න . ඔබගේ කේතය භාවිතා කරන ඕනෑම දත්තයක් ඔබගේ Lලකුණු වලට ඇතුළත් කළ යුතුය .

ඔබ දැනට පවතින පුස්තකාල ආනයනය විය හැකි නමුත්, වෙනත් ඕනෑම බාහිර ගොනු පූරණය නොවේ, සහ ඔබේ කේතය ප්රවේශ විය හැක whale.txtහෝwhale2.txtඉහත විස්තර කර ඇති ආකාරයට හැර වෙනත් ආකාරයකින් ගොනු කරන්න. ඔබ පෙර පුහුණුව ලත් ස්නායුක ජාල හෝ සංඛ්‍යාන දත්තවල වෙනත් ප්‍රභවයන් පටවන්නේ නැත. (ස්නායුක ජාල භාවිතා කිරීම හොඳයි, නමුත් ඔබ ඉදිරිපත් කළ බර දත්ත ඇතුළත් කර එය ඔබේ බයිට් ගණනට ගණන් කළ යුතුය.) කිසියම් හේතුවක් නිසා ඔබේ භාෂාව හෝ පුස්තකාලවල මොබී ඩික්ගේ පෙළ හෝ සමහරක් සපයන අංගයක් ඇතුළත් වේ. , ඔබ එම අංගය භාවිතා නොකරනු ඇත. ඒ හැරුණු විට, ඔබේ භාෂාවේ හෝ එහි සම්මත පුස්තකාලවල කොටසක් වන තාක් කල්, පෙළ සැකසීම, පුරෝකථනය කිරීම හෝ සම්පීඩනය සම්බන්ධ ඒවා ඇතුළුව ඔබ කැමති වෙනත් බිල්ට් හෝ පුස්තකාල අංග භාවිතා කළ හැකිය. සංඛ්‍යාන දත්තවල ප්‍රභවයන් ඇතුළත් වන වඩාත් විදේශීය, විශේෂිත ක්‍රියාකාරකම් සඳහා, ඔබ ඒවා ඔබම ක්‍රියාත්මක කර ඔබේ බයිට් ගණන් වලට ඇතුළත් කළ යුතුය.

සමහර ඉදිරිපත් කිරීම් වලට කේත මඟින් ජනනය කරන ලද සංරචක ඇතුළත් වනු ඇත. මෙය එසේ නම්, කරුණාකර ඒවා නිෂ්පාදනය කිරීමට භාවිතා කළ කේතය ඔබේ පිළිතුරට ඇතුළත් කර එය ක්‍රියාත්මක වන ආකාරය පැහැදිලි කරන්න . (ඔබගේ ඉදිරිපත් කිරීම ක්‍රියාත්මක කිරීමට මෙම කේතය අවශ්‍ය නොවන තාක් කල් එය ඔබගේ බයිට් ගණනට ඇතුළත් නොවේ.)

Historical තිහාසික හේතූන් මත, ගොනුවේ අනුවාද දෙකක් ඇති අතර, ඔබට ඒවායින් එකක් හෝ පිළිතුරක් ලෙස භාවිතා කළ හැකිය. දී whale2.txt(ඉහත සම්බන්ධ) එසේ හිස් පේලි ගැන ඡේද අවසානයේ පමණක් සඳහන් වන අතර, පෙළ ඔතා නැත. මුල් whale.txtපිටපතේ අක්ෂර 74 ක පළලකට ඔතා ඇති බැවින් එක් එක් පේළියේ අවසානය මෙන්ම පෙළ පුරෝකථනය කළ යුතුය. මෙය අභියෝගය වඩාත් විචක්ෂණශීලී කරයි, එබැවින් whale2.txtනව පිළිතුරු සඳහා නිර්දේශ කෙරේ. ගොනු දෙකම එකම ප්‍රමාණයෙන්, බයිට් 1215236 කි.


සාරාංශගත කිරීම සඳහා, සියලු පිළිතුරු සඳහා පහත සඳහන් දෑ ඇතුළත් විය යුතුය:

  • ඔබේ ඉදිරිපත් කිරීමම. (කේතය, එය භාවිතා කරන ඕනෑම දත්ත ගොනු - ඒවා විශාල නම් ඒවා සබැඳි විය හැකිය.)
  • ඔබේ කේතය ක්‍රියාත්මක වන ආකාරය පිළිබඳ පැහැදිලි කිරීමක්. කරුණාකර I / O ක්‍රමය මෙන්ම එය ඊළඟ චරිතය පුරෝකථනය කරන්නේ කෙසේද යන්න පැහැදිලි කරන්න. ඔබේ ඇල්ගොරිතම පිළිබඳ පැහැදිලි කිරීම වැදගත් වන අතර හොඳ පැහැදිලි කිරීම් මගෙන් ත්‍යාග ලබා ගනී.
  • ඔබේ ලකුණු තක්සේරු කිරීමට ඔබ භාවිතා කළ කේතය. (මෙය පෙර පිළිතුරකට සමාන නම් ඔබට එයට සම්බන්ධ විය හැකිය.)
  • ඔබගේ ඉදිරිපත් කිරීම ජනනය කිරීමට ඔබ භාවිතා කළ ඕනෑම කේතයක් සහ එම කේතය පිළිබඳ පැහැදිලි කිරීමක් සමඟ. පරාමිතීන් ප්‍රශස්තිකරණය කිරීමට, දත්ත ගොනු ජනනය කිරීමට ඔබ භාවිතා කළ කේතය මෙයට ඇතුළත් වේ (මෙය ඔබගේ බයිට් ගණනට ගණන් නොගන්නා නමුත් ඔබේ පිළිතුරට ඇතුළත් කළ යුතුය.)

ප්‍රමුඛ පුවරුව

වරප්‍රසාද

වරින් වර විවිධ ප්‍රවේශයන් දිරිගැන්වීම සඳහා මම ත්‍යාග පිරිනමමි.

පළමු එක, ලකුණු 50, ඒ. රෙක්ස් වෙත ප්‍රදානය කරන ලද්දේ එකල හොඳම ලකුණු ලබා ගත් පිළිතුර සඳහා ය.

දෙවන, ලකුණු 100 ද ඒ. රෙක්ස් වෙත පිරිනමන ලද්දේ එම පිළිතුර සඳහාම ය. මන්ද ඔවුන් දැනට පවත්නා පිළිතුරට ඉතා හොඳ පැහැදිලි කිරීමක් එක් කළ බැවිනි.

ඊළඟ ත්‍යාගය වන ලකුණු 200 , එක්කෝ ප්‍රදානය කෙරේ

  • නව තාක්ෂණයක් භාවිතා කරන තරඟකාරී පිළිතුරක්. (මෙය මගේ ආත්මීය විනිශ්චය මත පදනම් වනු ඇත. ඉහළම ලකුණු ලබා නොගන්න, පවතින පිළිතුරු හා සසඳන විට එය සාධාරණව කළ යුතුය. පුනරාවර්තන ස්නායුක ජාල මත පදනම් වූ විසඳුම් දැකීමට මම විශේෂයෙන් උනන්දු වෙමි, නමුත් වර්තමාන ඉහළම ලකුණු වල ආධිපත්‍යය දරන මාකෝව් මාදිලිවලට වඩා වෙනස් ලෙස පෙනෙන ඕනෑම දෙයකට මම ත්‍යාගය ප්‍රදානය කරමි.

හෝ:

  • ඕනෑම ක්‍රමයක් භාවිතා කරමින් ඒ. රෙක්ස්ගේ ඉහළම ලකුණු (දැනට 444444) පරාජය කරන වෙනත් අයෙක්.

ලකුණු 200 ක ත්‍යාගය ලබා ගත් පසු, මම බොහෝ විට ලකුණු 400 ක් ලබා දෙන්නෙමි, ඒ අනුව අවශ්‍යතා යාවත්කාලීන කරමි.


අදහස් දීර් discussion සාකච්ඡාවක් සඳහා නොවේ; මෙම සංවාදය චැට් කිරීමට ගෙන ගොස් ඇත .
ඩෙනිස්

9
xkcd.com/1960 මෙම අභියෝගයට යොමු කිරීමක් ලෙස පෙනේ!
ඒ. රෙක්ස්

මම මේ සම්පීඩනය කල්පනා ... නමුත් එය ටිකක් වැඩි කාලයක් මගේ පරිගණකය ගැටී බව ය ජායාරුප
Naruyoko

Answers:


141

/// , 2 * 1 + 1020874 = 1020876

 

අවකාශයක් මුද්‍රණය කරයි.


අදහස් දීර් discussion සාකච්ඡාවක් සඳහා නොවේ; මෙම සංවාදය චැට් කිරීමට ගෙන ගොස් ඇත .
ඩෙනිස්

එය අතිශයින්ම හොඳ විපාක අනවසරයෙන් ඇතුළුවීමකි! ඔබ AGI විය යුතුය;)
ඇලෙක්ස්

97

Node.js, 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 ගැන අනාවැකි කීමට අවසාන අක්ෂර 8 දෙස බලයි.

අවම වශයෙන් ටී [එල්] වාර ගණනක් අපට හමු වූ විට අපි දිග L රටාවක් විශ්වාස කරමු , එහිදී T යනු අත්තනෝමතික එළිපත්තකි: [1,1,2,1,2,3,5,2] . තවද, සෑම විටම පළමු චරිතයට ගැලපෙන රටාවක් අපි විශ්වාස කරමු .[A-Z '"(]

අපි දීර් est තම විශ්වාසදායක රටාව තෝරාගෙන ඇමතුම ලබා දෙන අවස්ථාවේදී මෙම රටාවට සම්බන්ධ ඉහළම ලකුණු සමඟ අනාවැකිය නැවත ලබා දෙන්නෙමු.

සටහන්

  • මෙය පැහැදිලිවම වේගය සඳහා ප්‍රශස්තිකරණය කර නැත, නමුත් එය මගේ ලැප්ටොප් පරිගණකයේ තත්පර 15 කින් පමණ ධාවනය වේ.

  • ආකෘතිය නැවත සැකසීමෙන් තොරව කිහිප වතාවක්ම ක්‍රියාවලිය නැවත කිරීමට අපට ඉඩ දුන්නේ නම්, දෝෂ ගණන නැවත නැවත 5 කට පසු ~ 268000 බවට පරිවර්තනය වේ.

  • පුරෝකථන ශ්‍රිතයේ වර්තමාන සාර්ථකත්ව අනුපාතය ~ 56.8% කි. අදහස් දැක්වීමේදී ඉමිබිස් විසින් දැක ඇති පරිදි, නරක සහ නිවැරදි අනුමාන එකට මිශ්‍ර වුවහොත්, ප්‍රති result ලය යන්තම් කියවිය නොහැක.

    උදාහරණයක් ලෙස, පොතේ අවසානයට ආසන්නයේ ඇති මෙම කුඩා කොටස:

    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 - මාරු වූ විට 19644 ක් බේරා whale2.txt (අභියෝගය යාවත්කාලීන)
  • 544371 - කැපිටල් අකුරක්, උපුටා දැක්වීමක්, ද්විත්ව උපුටා දැක්වීමක් හෝ ආරම්භක වරහන් සමඟ ආරම්භ වන රටාවන් ද සැමවිටම විශ්වාස කළ යුතුය.
  • 544698 - සෑම විටම විශ්වාස කළ හැකි අවකාශයකින් ආරම්භ වන රටාවන්ට බල කිරීමෙන් ලකුණු 2119 ක් ඉතිරි කර ඇත
  • 546817 - එළිපත්ත සකස් කිරීමෙන් සහ පුරෝකථන ශ්‍රිතය ගොල්ෆ් කිරීමෙන් ලකුණු 47 ක් ඉතිරි කර ඇත
  • 546864 - උපරිම රටා දිග අක්ෂර 8 දක්වා දිගු කිරීමෙන් ලකුණු 1496 ක් ඉතිරි කර ඇත
  • 548360 - විශ්වාසනීය රටා පිළිබඳ සංකල්පය හඳුන්වා දීමෙන් ලකුණු 6239 ක් ඉතිරි කර ගත් අතර ඒවායේ දිග අනුව සීමාවන් ඇත
  • 554599 - රේඛීය ආහාර පුරෝකථනය වැඩි දියුණු කිරීමෙන් ලකුණු 1030 ක් ඉතිරි කර ඇත
  • 555629 - පුරෝකථන ශ්‍රිතය ගොල්ෆ් කිරීමෙන් ලකුණු 22 ක් ඉතිරි කර ඇත
  • 555651 - පුරෝකථන ශ්‍රිතය ගොල්ෆ් කිරීමෙන් ලකුණු 40 ක් ඉතිරි කර ඇත
  • 555691 - ආරම්භක ලකුණු

47
කුතුහලය දනවන අය සඳහා, මෙය මොබී ඩික් වැනි කිසිවක් නිපදවන්නේ නැත. ඒක ගොඩක් 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.
user253751

25
@immibis අභියෝගයේ මාතෘකාව ely ානවන්තව තෝරා ගන්නා ලදී. මෙය ආසන්න වශයෙන් මොබී ඩික් ය . :-)
ආර්නෝල්ඩ්

3
Athan නතානියෙල් බොහෝ යාවත්කාලීනයන් ඇති බැවින් එය යන්තම් කියවිය හැකි වන අතර ඇත්ත වශයෙන්ම තොරතුරු නොවේ. වැඩිදියුණු කිරීම් පිළිබඳ කෙටි පැහැදිලි කිරීම් සමඟ මම වෙනස් කිරීමේ ලොගයක් එක් කළෙමි.
ආර්නෝල්ඩ්

47
මම හිතන්නේ ඔබේ වැඩසටහන ඇත්ත වශයෙන්ම ගැලැක්සි භාෂාවට පරිපූර්ණ පරිවර්තනයක් කරයි.
බෙස්කා

1
@ Draco18s මෙම කොමාව හොඳ හෝ නරක අනුමානයක් දැයි කීමට අපහසුය. එය නරක අනුමානය නම්, පුරෝකථන ශ්‍රිතය එය ලැබුනු පසු කොමාව වෙනුවට වෙනත් ඕනෑම අකුරකට පසු ඇත්ත වශයෙන්ම ලිපියක් තැබීමට නීත්‍යානුකූලව උත්සාහ කර ඇත.
ආර්නෝල්ඩ්

93

පර්ල්, 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.) මෙම ගොනුව ජනනය කරන්නේ කෙසේදැයි පහත බලන්න.

මෙම වැඩසටහන පරිශීලක 2699 විසින් මෙම පිළිතුරෙහි මෙන් මාකෝව් ආකෘතිවල සංයෝජනයක් භාවිතා කරයි , නමුත් කුඩා වෙනස් කිරීම් කිහිපයක් සමඟ. මෙය ඊළඟ චරිතය සඳහා බෙදාහැරීමක් සිදු කරයි . Bඉඟියක් කේතනය කිරීමේදී දෝෂයක් පිළිගැනීමට හෝ ගබඩා කිරීම සඳහා වැය කිරීමට තීරණය කිරීමට අපි තොරතුරු න්‍යාය භාවිතා කරමු (එසේ නම්, කෙසේද). ආකෘතියෙන් භාගික බිටු ප්‍රශස්ත ලෙස ගබඩා කිරීම සඳහා අපි අංක ගණිත කේතීකරණ භාවිතා කරමු .

වැඩසටහන බයිට් 582 ක් දිගයි (අනවශ්‍ය අවසාන නව Bරේඛාවක් ඇතුළුව) සහ ද්විමය ගොනුව බයිට් 69942 ක් දිගයි, එබැවින් බහු ගොනු ලබා ගැනීමේ නීතිරීති යටතේ අපි ලකුණු L582 + 69942 + 1 = 70525 ලෙස ලකුණු කරමු.

වැඩසටහනට නිසැකවම පාහේ 64-බිට් (කුඩා-එන්ඩියන්?) ගෘහ නිර්මාණ ශිල්පයක් අවශ්‍ය වේ. m5.largeඇමේසන් ඊසී 2 හි උදාහරණයක් ක්‍රියාත්මක කිරීමට ආසන්න වශයෙන් මිනිත්තු 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],'}}'

සමාන ගණනය කිරීම් සිදු කරන බැවින්, ඉදිරිපත් කිරීම සඳහා ධාවනය කිරීමට ආසන්න වශයෙන් වැඩි කාලයක් ගත වේ.

පැහැදිලි කිරීම

මෙම කොටසේදී, මෙම විසඳුම මඟින් ඔබට "නිවසේදී එය අත්හදා බැලිය හැකිය" යන්න ප්‍රමාණවත් ලෙස විස්තර කිරීමට අපි උත්සාහ කරමු. මෙම පිළිතුර අනෙක් පිළිතුරු වලින් වෙන්කර හඳුනාගත හැකි ප්‍රධාන තාක්‍ෂණය වන්නේ “රිවයින්ඩ්” යාන්ත්‍රණය ලෙස කොටස් කිහිපයක් පහළට බැස ඇති නමුත් අප එහි යාමට පෙර මූලික කරුණු සකස් කළ යුතුය.

ආකෘතිය

විසඳුමේ මූලික සං ient ටකය භාෂා ආකෘතියකි. අපගේ අරමුණු සඳහා, ආකෘතියක් යනු ඉංග්‍රීසි පෙළෙන් යම් ප්‍රමාණයක් ගෙන ඊළඟ අක්ෂරයට සම්භාවිතා බෙදාහැරීමක් ලබා දෙන දෙයකි . අපි ආකෘතිය භාවිතා කරන විට, ඉංග්‍රීසි පෙළ මොබී ඩික්ගේ (නිවැරදි) උපසර්ගයක් වනු ඇත. අපේක්ෂිත ප්‍රතිදානය බෙදාහැරීමක් වන අතර බොහෝ දුරට ඉඩ ඇති චරිතය සඳහා එක් අනුමානයක් පමණක් නොවන බව කරුණාවෙන් සලකන්න .

අපගේ නඩුවේදී, පරිශීලක 2699 විසින් මෙම පිළිතුරේ ආකෘතිය අපි භාවිතා කරමු . ඇන්ඩර්ස් කසෝර්ග් විසින් වැඩිම ලකුණු ලබා ගත් පිළිතුරෙන් (අපේම හැර) අපි ආකෘතිය භාවිතා නොකළේ හරියටම අපට හොඳම අනුමානයකට වඩා බෙදාහැරීමක් උපුටා ගැනීමට නොහැකි වූ බැවිනි. න්‍යායට අනුව, එම පිළිතුර බරින් යුත් ජ්‍යාමිතික මධ්‍යන්‍යයක් ගණනය කරයි, නමුත් එය වචනානුසාරයෙන් අර්ථ නිරූපණය කරන විට අපට තරමක් දුර්වල ප්‍රති results ල ලැබුණි. අපි වෙනත් පිළිතුරකින් ආකෘතියක් "සොරකම්" කළේ අපගේ "රහස් සෝස්" ආකෘතිය නොව සමස්ත ප්‍රවේශය නිසාය. යමෙකුට "වඩා හොඳ" ආකෘතියක් තිබේ නම්, අපගේ ඉතිරි ශිල්පීය ක්‍රම උපයෝගී කර ගනිමින් ඔවුන්ට වඩා හොඳ ප්‍රති results ල ලබා ගත හැකිය.

ප්‍රකාශයක් ලෙස, ලෙම්පල්-සිව් වැනි බොහෝ සම්පීඩන ක්‍රම මේ ආකාරයෙන් “භාෂා ආකෘතියක්” ලෙස දැකිය හැකිය. (බරෝස්-වීලර් පරිණාමනය කරන දෙයක් සඳහා එය විශේෂයෙන් උපක්‍රමශීලී ය!) එසේම, පරිශීලක 2699 හි ආකෘතිය මාකෝව් ආකෘතියේ වෙනස් කිරීමක් බව සලකන්න; මෙම අභියෝගය සඳහා තරඟකාරී වන්නේ වෙනත් කිසිවක් නොවේ.

සමස්ත ගෘහ නිර්මාණ ශිල්පය

අවබෝධ කර ගැනීමේ අරමුණු සඳහා, සමස්ත ගෘහ නිර්මාණ ශිල්පය කැබලි කිහිපයකට කැඩීම සතුටක්. ඉහළම මට්ටමේ දෘෂ්ටි කෝණයෙන් බලන කල, රාජ්‍ය කළමනාකරණ කේතය ටිකක් තිබිය යුතුය. මෙය විශේෂයෙන් සිත්ගන්නා සුළු නොවේ, නමුත් සම්පූර්ණත්වය සඳහා අපට අවධාරණය කිරීමට අවශ්‍ය වන්නේ සෑම අවස්ථාවකදීම ඊළඟ අනුමානය සඳහා වැඩසටහන ඉල්ලා සිටින විට එය මොබී ඩික්ගේ නිවැරදි උපසර්ගයක් ලබා ගත හැකි බවයි. අපගේ අතීත වැරදි අනුමාන අපි කිසිම ආකාරයකින් භාවිතා නොකරමු. කාර්යක්‍ෂමතාවය උදෙසා, භාෂා ආකෘතියට පළමු (N + 1) අක්ෂර සඳහා එහි තත්වය ගණනය කිරීම සඳහා පළමු N අක්‍ෂර වලින් එහි තත්වය නැවත භාවිතා කළ හැකි නමුත් ප්‍රතිපත්තිමය වශයෙන් එය ආයාචනා කරන සෑම අවස්ථාවකම මුල සිටම නැවත ගණනය කළ හැකිය.

වැඩසටහනේ මෙම මූලික “ධාවක” පසෙකට දමා ඊළඟ චරිතය අනුමාන කරන කොටස දෙස බලමු. එය කොටස් තුනක් වෙන් කිරීමට සංකල්පමය වශයෙන් උපකාරී වේ: භාෂා ආකෘතිය (ඉහත සාකච්ඡා කර ඇත), “ඉඟි” ගොනුවක් සහ “පරිවර්තකය”. සෑම පියවරකදීම, පරිවර්තකයා භාෂා ආකෘතිය ඊළඟ චරිතය සඳහා බෙදා හැරීමක් ඉල්ලා සිටින අතර ඉඟි ගොනුවෙන් යම් තොරතුරු කියවනු ඇත. එවිට එය මෙම කොටස් අනුමාන කිරීමකට ඒකාබද්ධ කරයි. ඉඟි ගොනුවේ ඇති තොරතුරු මෙන්ම එය භාවිතා කරන ආකාරයද පසුව පැහැදිලි කරනු ඇත, නමුත් දැනට එය මෙම කොටස් මානසිකව වෙන්ව තබා ගැනීමට උපකාරී වේ. ක්‍රියාත්මක කිරීම අනුව, ඉඟි ගොනුව වචනාර්ථයෙන් වෙනම (ද්විමය) ගොනුවක් වන නමුත් එය නූලක් හෝ වැඩසටහන තුළ ගබඩා කර ඇති යමක් විය හැකි බව සලකන්න. ආසන්න වශයෙන්,

මෙම පිළිතුරෙහි මෙන් යමෙකු bzip2 වැනි සම්මත සම්පීඩන ක්‍රමයක් භාවිතා කරන්නේ නම් , “ඉඟි” ගොනුව සම්පීඩිත ගොනුවට අනුරූප වේ. "පරිවර්තකය" විසංයෝජනයට අනුරූප වන අතර "භාෂා ආකෘතිය" ටිකක් ව්‍යංගයෙන් (ඉහත සඳහන් කළ පරිදි).

ඉඟි ගොනුවක් භාවිතා කරන්නේ ඇයි?

වැඩිදුර විශ්ලේෂණය කිරීම සඳහා සරල උදාහරණයක් තෝරා ගනිමු. Nසෑම අක්ෂරයක්ම (ස්වාධීනව) Eසම්භාවිතාව සහිත ලිපිය අඩකටත් වඩා මඳක් අඩු, Tඒ හා සමානව සම්භාවිතාව අඩකටත් වඩා අඩුවෙන් හා Aසම්භාවිතාව 1/1000 = 0.1% සහිත ආකෘතියක් මඟින් පෙළ දිගු හා හොඳින් තක්සේරු කර ඇති අයුරු සිතමු . වෙනත් චරිත කළ නොහැකි යැයි උපකල්පනය කරමු; කෙසේ වෙතත්, Aමෙය නිල් පැහැයෙන් පිටත නොපෙනෙන චරිතයකට සමාන ය.

අපි (මෙම ප්රශ්නයට වෙනත් පිළිතුරු සියලු බොහෝ, නමුත්, එසේ ලෙස) එල් 0 තන්ත්රය ක්රියාත්මක නම්, තාලිත්, එක් කෙනෙකුට වඩා භාෂණ සඳහා වඩා හොඳ උපාය තියෙනවා Eසහ T. සාමාන්‍යයෙන්, එය අක්ෂරවලින් අඩක් පමණ නිවැරදි වනු ඇත. එබැවින් E ≈ N / 2 සහ ලකුණු ≈ N / 2 ද වේ. කෙසේ වෙතත්, අපි සම්පීඩන උපාය මාර්ගයක් භාවිතා කරන්නේ නම්, එවිට අපට අක්ෂරයකට බිට් එකකට වඩා ටිකක් වැඩි කළ හැකිය. L බයිට් වලින් ගණනය කර ඇති නිසා, අපට L ≈ N / 8 ලැබෙන අතර එමඟින් score N / 4 ලකුණු ලබා ගනී, එය පෙර උපාය මාර්ගයට වඩා දෙගුණයකි.

මෙම ආකෘතිය සඳහා එක් අක්ෂරයකට බිට් එකකට වඩා ටිකක් වැඩි අනුපාතයක් ළඟා කර ගැනීම තරමක් අශිෂ්ට ය, නමුත් එක් ක්‍රමයක් වන්නේ ගණිත කේතීකරණයයි.

අංක ගණිත කේතනය

පොදුවේ දන්නා පරිදි, කේතන ක්‍රමයක් යනු බිටු / බයිට් භාවිතා කරමින් සමහර දත්ත නිරූපණය කිරීමේ ක්‍රමයකි. උදාහරණයක් ලෙස, ASCII යනු ඉංග්‍රීසි පෙළ සහ ඒ හා සම්බන්ධ අක්ෂර 7 බිට් / අක්ෂර කේතන ක්‍රමයක් වන අතර එය සලකා බලනු ලබන මුල් මොබී ඩික් ගොනුවේ කේතන ක්‍රමය වේ. සමහර අක්ෂර අනෙක් ඒවාට වඩා පොදු නම්, ASCII වැනි ස්ථාවර පළල කේතන ක්‍රමයක් ප්‍රශස්ත නොවේ. එවැනි තත්වයක් තුළ, බොහෝ අය හෆ්මන් කේතීකරණය සඳහා ළඟා වේ . ඔබට අක්ෂරයකට බිටු සංඛ්‍යාවක් සහිත ස්ථාවර (උපසර්ග රහිත) කේතයක් අවශ්‍ය නම් මෙය ප්‍රශස්ත වේ.

කෙසේ වෙතත්, අංක ගණිත කේතනය ඊටත් වඩා හොඳය. දළ වශයෙන් කිවහොත්, තොරතුරු කේතනය කිරීම සඳහා "භාගික" බිටු භාවිතා කිරීමට එයට හැකියාව ඇත. අංක ගණිත කේතීකරණය සඳහා මාර්ගෝපදේශ බොහෝමයක් මාර්ගගතව ඇත. අන්තර්ජාලය හරහා ලබා ගත හැකි වෙනත් සම්පත් නිසා අපි මෙහි විස්තර (විශේෂයෙන් ප්‍රායෝගිකව ක්‍රියාත්මක කිරීම, ක්‍රමලේඛන දෘෂ්ටිකෝණයකින් ටිකක් උපක්‍රමශීලී විය හැකිය) මඟ හරිමු, නමුත් යමෙකු පැමිණිලි කළහොත්, සමහර විට මෙම කොටස තවත් ඉවත් කළ හැකිය.

යමෙකුට දන්නා භාෂා ආකෘතියක් මගින් සත්‍ය වශයෙන්ම ජනනය කරන ලද පෙළක් තිබේ නම්, ගණිත කේතීකරණය මඟින් එම ආකෘතියෙන් අත්‍යවශ්‍යයෙන්ම ප්‍රශස්ත කේතයක් ලබා දේ. යම් ආකාරයකින්, මෙය එම ආකෘතිය සඳහා සම්පීඩන ගැටළුව "විසඳයි". (මේ අනුව, ප්‍රායෝගිකව, ප්‍රධාන ගැටළුව වන්නේ ආකෘතිය නොදන්නා අතර සමහර ආකෘතීන් අනෙක් ඒවාට වඩා මානව පෙළ ආකෘතිකරණයට වඩා හොඳය.) මෙම තරඟයේ වැරදි කිරීමට ඉඩ නොදුන්නේ නම්, පෙර කොටසේ භාෂාවෙන් , මෙම අභියෝගයට විසඳුමක් ලබා ගත හැකි එක් ක්‍රමයක් වනුයේ භාෂා ආකෘතියෙන් “ඉඟි” ගොනුවක් ජනනය කිරීම සඳහා අංක ගණිත කේතන ක්‍රමයක් භාවිතා කර ගණිත විකේතකය “පරිවර්තකයා” ලෙස භාවිතා කිරීමයි.

මෙම අත්‍යවශ්‍යයෙන්ම ප්‍රශස්ත කේතීකරණයේදී, අපි සම්භාවිතාව p සහිත අක්‍ෂරයක් සඳහා -log_2 (p) බිටු වියදම් කිරීම අවසන් කරන අතර, කේතන ක්‍රමයේ සමස්ත බිට් අනුපාතය ෂැනන් එන්ට්‍රොපිය වේ. මෙයින් අදහස් කරන්නේ 1/2 ට ආසන්න සම්භාවිතාවක් ඇති අක්ෂරයක් කේතනය කිරීමට බිට් එකක් පමණ ගත වන අතර 1/1000 සම්භාවිතාව සහිත එකක් බිටු 10 ක් පමණ ගනී (මන්ද 2 ^ 10 දළ වශයෙන් 1000 ක් වන නිසා).

නමුත් මෙම අභියෝගය සඳහා ලකුණු ලබා ගැනීමේ මෙට්‍රික් ප්‍රශස්ත ක්‍රමෝපාය ලෙස සම්පීඩනය වළක්වා ගැනීමට හොඳින් තෝරා ගන්නා ලදී. කෙටි ඉඟි ගොනුවක් ලබා ගැනීම සඳහා වෙළඳාමක් ලෙස යම් දෝෂයක් කිරීමට අපට යම් ක්‍රමයක් සොයා ගැනීමට සිදුවේ. උදාහරණයක් ලෙස, යමෙකු උත්සාහ කළ හැකි එක් උපක්‍රමයක් සරල ශාඛා ක්‍රමෝපායක් වේ: අපි සාමාන්‍යයෙන් අපට හැකි විට ගණිත කේතීකරණ භාවිතා කිරීමට උත්සාහ කරමු, නමුත් ආකෘතියෙන් සම්භාවිතා ව්‍යාප්තිය “නරක” නම් යම් ආකාරයකින් අපි අනුමාන කරන්නේ බොහෝ දුරට ඉඩ ඇති චරිතය සහ ඩොන් ' එය කේතනය කිරීමට උත්සාහ නොකරන්න.

වැරදි කරන්නේ ඇයි?

"හිතාමතාම" වැරදි කිරීමට අපට අවශ්‍ය විය හැක්කේ මන්දැයි පෙළඹවීම සඳහා පෙර සිටම උදාහරණය විශ්ලේෂණය කරමු. නිවැරදි අක්‍ෂරය කේතනය කිරීම සඳහා අපි අංක ගණිත කේතීකරණයක් භාවිතා කරන්නේ නම්, අපි දළ වශයෙන් එක් බිට් එකක් වැය කරන්නේ Eහෝ T, නමුත් බිටු දහයක් පමණ Aවේ.

සමස්තයක් වශයෙන්, මෙය හොඳ කේතීකරණයක් වන අතර, හැකියාවන් තුනක් තිබුණද, එක් චරිතයකට ටිකක් වැඩි මුදලක් වැය කරයි; මූලික වශයෙන්, Aඑය තරමක් අසීරු වන අතර, අපි ඊට අනුරූප බිටු දහයක් නිතර වියදම් කිරීම අවසන් නොකරමු. කෙසේ වෙතත්, අපට ඒ වෙනුවට වැරැද්දක් කළ හැකි නම් එය හොඳ Aනොවේද? සියල්ලට පසු, ගැටළුව සඳහා මෙට්‍රික් 1 බයිට් 1 = බිටු 8 දිග දෝෂ 2 ට සමාන යැයි සලකයි; අක්ෂරයක් සඳහා බිටු 8/2 = 4 කට වඩා වියදම් කරනවා වෙනුවට යමෙකු දෝෂයකට වැඩි කැමැත්තක් දැක්විය යුතු බව පෙනේ. එක් දෝෂයක් සුරැකීමට බයිට් එකකට වඩා වියදම් කිරීම නියත වශයෙන්ම උප ප්‍රශස්ත බවක් පෙනේ!

"රිවයින්ඩ්" යාන්ත්‍රණය

මෙම කොටස මෙම විසඳුමේ ප්‍රධාන දක්ෂ අංගය විස්තර කරයි, එය දිගින් දිගටම කිසිදු වියදමක් නොමැතිව වැරදි අනුමාන හැසිරවිය හැකි ක්‍රමයකි.

අප විශ්ලේෂණය කර ඇති සරල උදාහරණය සඳහා, රිවයින්ඩ් යාන්ත්‍රණය විශේෂයෙන් සරල ය. පරිවර්තකයා ඉඟි ගොනුවෙන් එක් කොටසක් කියවයි. එය 0 නම්, එය අනුමාන කරයි E. එය 1 නම්, එය අනුමාන කරයි T. ඊළඟ වතාවේ එය හැඳින්වූ විට, එය නිවැරදි චරිතය කුමක්දැයි දකී. ඉඟි ගොනුව හොඳින් සකසා ඇත්නම්, Eහෝ T, හෝ , පරිවර්තකයා නිවැරදිව අනුමාන කරන බව අපට සහතික කළ හැකිය . නමුත් කුමක් ද A? මෙම නැරැඹීමට Rewind යාන්ත්රණයක් අදහස සරලව ය කේතය නොවන Aසියලු දී . වඩාත් නිවැරදිව, පරිවර්තකයා පසුව නිවැරදි චරිතය බව දැන ගන්නේ නම් A, එය රූපකීයව “ටේප් එක පෙරළා දමයි”: එය කලින් කියවූ කොටස නැවත ලබා දෙයි. එය කියවන බිට් කේත කිරීමට අදහස් කරයි EහෝT, නමුත් දැන් නොවේ; එය පසුව භාවිතා වේ. මෙම සරල උදාහරණයක්, මේ මූලික වශයෙන් එහි අරුත වන්නේ කරයි එම චරිතය (අනුමාන Eහෝ Tඑය නිවැරදි එය ලැබෙන තෙක්); ඉන්පසු එය තවත් ටිකක් කියවා ඉදිරියට යයි.

මෙම ඉඟි ගොනුව සඳහා කේතන කිරීම ඉතා සරල ය: සියල්ල මුළුමනින්ම නොසලකා හරිමින්, සියලු s Eබිටු 0 ක් සහ Tබිටු 1 ක් බවට පත් කරන්න A. පෙර කොටසේ අවසානයේ විශ්ලේෂණය කිරීමෙන්, මෙම යෝජනා ක්‍රමය යම් යම් දෝෂ සිදු කරන නමුත් කිසිදු එකක් කේතනය නොකිරීමෙන් සමස්ත ලකුණු ප්‍රමාණය අඩු කරයි A. කුඩා බලපෑමක් ලෙස, එය ඇත්ත වශයෙන්ම ඉඟි ගොනුවේ දිගද ඉතිරි කරයි, මන්ද අප අවසන් වන්නේ එක් එක් සඳහා හරියටම එක් බිට් එකක් භාවිතා කරන Eඅතර T, ටිකක් වඩා ටිකක් වැඩි වෙනුවට.

පොඩි ප්‍රමේයයක්

දෝෂයක් කළ යුත්තේ කවදාදැයි අපි තීරණය කරන්නේ කෙසේද? අපගේ ආකෘතිය අපට ඊළඟ අක්ෂර සඳහා සම්භාවිතා බෙදාහැරීමක් ලබා දෙයි යැයි සිතමු. හැකි අක්ෂර අපි පන්ති දෙකකට වෙන් කරමු: කේතනය කර ඇති අතර කේතනය නොකෙරේ . නිවැරදි අක්ෂර කේතනය කර නොමැති නම්, අපි දිගින් දිගටම කිසිදු වියදමක් නොමැතිව දෝෂයක් පිළිගැනීමට “රිවයින්ඩ්” යාන්ත්‍රණය භාවිතා කරමු. නිවැරදි අක්‍ෂරය කේතනය කර ඇත්නම්, ගණිත කේතීකරණය භාවිතයෙන් එය කේතනය කිරීම සඳහා අපි වෙනත් බෙදාහැරීම් Q භාවිතා කරමු.

Q අප තෝරා ගත යුත්තේ කුමන බෙදාහැරීමද? කේත කරන ලද අක්ෂර සියල්ල කේතගත නොකළ අක්ෂරවලට වඩා ඉහළ සම්භාවිතාවක් (P වලින්) තිබිය යුතු බව දැකීම එතරම් අපහසු නොවේ. Q බෙදාහැරීමේ කේතයට ඇතුළත් කළ යුත්තේ කේතගත අක්ෂර පමණි; සියල්ලට පසු, අපි අනෙක් ඒවා කේත කරන්නේ නැත, එබැවින් අපි ඒවා සඳහා එන්ට්‍රොපිය "වියදම්" නොකළ යුතුය. කේතනය කරන ලද අක්ෂර මත සම්භාවිතා ව්‍යාප්තිය Q P ට සමානුපාතික විය යුතු බව දැකීම ටිකක් උපක්‍රමශීලී ය. මෙම නිරීක්ෂණ එකට තැබීමෙන් අදහස් කරන්නේ අප බොහෝ දුරට ඉඩ ඇති අක්‍ෂර කේත කළ යුතු නමුත් අඩු ඉඩක් ඇති අක්ෂර නොවිය යුතු අතර Q යනු කේතනය කරන ලද අක්ෂර මත නැවත යථා තත්ත්වයට පත් කිරීමයි.

කේතීකරණ අක්ෂර සඳහා යමෙකු තෝරා ගත යුතු "කප්පාදුව" සම්බන්ධයෙන් සිසිල් ප්‍රමේයයක් ඇති බව තවදුරටත් එය හැරී යයි: ඔබ අවම වශයෙන් 1 / 5.393 ක් වන තාක් දුරට අනෙක් කේතගත කළ අක්ෂර ඒකාබද්ධ වන තාක් දුරට ඔබ කේතයක් කේත කළ යුතුය. 5.393ඉහත වැඩසටහනේ අවසානයට ආසන්නව පෙනෙන අහඹු නියතයේ පෙනුම මෙය "පැහැදිලි කරයි" . අංක 1 / 5.393 ≈ 0.18542 යනු -p ලොග් (16) - p ලොග් p + (1 + p) ලොග් (1 + p) = 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. මොබී ඩික්ගේ දන්නා නිවැරදි උපසර්ගයට නිවැරදි අක්‍ෂරය එක් කරන්න.
  2. පා Mark යේ (මාකෝව්) ආකෘතිය යාවත්කාලීන කරන්න.
  3. මෙම රහස් සෝස් : කලින් අනුමාන වැරදි නම්, Rewind අංක ගණිතමය විකේතන රාජ්ය සිය රාජ්ය සඳහා පෙර අනුමාන පෙර!
  4. ඊළඟ අක්ෂර සඳහා සම්භාවිතා ව්‍යාප්තියක් P පුරෝකථනය කිරීමට මාකෝව් ආකෘතියෙන් විමසන්න.
  5. පෙර කොටසේ සිට සබ්ට්‍රවුටින් භාවිතයෙන් P ට Q බවට පරිවර්තනය කරන්න.
  6. බෙදාහැරීමේ Q ට අනුව, ඉඟි ගොනුවේ ඉතිරි කොටසෙන් අක්‍ෂරයක් විකේතනය කිරීමට අංක ගණිත විකේතකය අසන්න.
  7. එහි ප්‍රති character ලයක් ලෙස අනුමාන කරන්න.

ඉඟි ගොනුවේ කේතනය ඒ හා සමානව ක්‍රියාත්මක වේ. එවැනි අවස්ථාවක, නිවැරදි ඊළඟ චරිතය කුමක්දැයි වැඩසටහන දනී. එය කේතගත කළ යුතු අක්ෂරයක් නම්, ඇත්ත වශයෙන්ම යමෙකු එය මත අංක ගණිත කේතන ක්‍රමය භාවිතා කළ යුතුය; නමුත් එය කේතගත නොකළ අක්‍ෂරයක් නම්, එය ගණිත කේතන ක්‍රමයේ තත්වය යාවත්කාලීන නොකරයි.

සම්භාවිතා බෙදාහැරීම්, එන්ට්‍රොපි, සම්පීඩනය සහ අංක ගණිතය වැනි තොරතුරු-න්‍යායාත්මක පසුබිම ඔබ තේරුම් ගෙන ඇති නමුත් මෙම ලිපිය තේරුම් ගැනීමට උත්සාහ කර අසමත් වුවහොත් (ප්‍රමේයය සත්‍ය වන්නේ මන්ද යන්න හැර), අපට දන්වන්න සහ අපට කරුණු නිරවුල් කිරීමට උත්සාහ කළ හැකිය. කියවීමට ස්තූතියි!


8
වාව්, ආකර්ෂණීය පිළිතුර. Bගොනුව ජනනය කිරීම සඳහා අමතර කේතයක් අවශ්‍ය යැයි මම සිතමි ? එසේ නම්, කරුණාකර එය ඔබේ පිළිතුරට ඇතුළත් කළ හැකිද?
නතානියෙල්

8
විශිෂ්ටයි! 500k ලකුණු බාධකය බිඳ දැමීමේ පළමු (හා මෙතෙක් එකම) පිළිතුර.
ශ්‍රීවාට්සාර්

6
"ෂයිට් තල්මසුන් ඉරා දැමුවා" omg මම අ crying නවා
ෆිල්

5
ත්‍යාග කාලය තුළ නව පිළිතුරු කිසිවක් පළ කර නොමැති බැවින්, හොඳම ලකුණු ලබා ගැනීම සහ නවීනතම ප්‍රවේශය ලෙස මම එය ඔබගේ පිළිතුරට ප්‍රදානය කරමි. ඔබ කවදා හෝ කාලය ඇති නම්, මං ඇත්තටම මේ පිළිතුරට ක්රියා කරන්නේ කෙසේද යන්න පිළිබඳ වැඩි ගැඹුර පැහැදිලි කිරීමක්, එනම්, අගය හරියටම ඇල්ගොරිතමය කුමක්ද?
නතානියෙල්

2
Athan නතානියෙල්: මම මෙම තනතුරට පැහැදිලි කිරීමක් එක් කළෙමි. විසඳුම ඔබම ප්‍රතිනිෂ්පාදනය කිරීමට තරම් සවිස්තරාත්මක යැයි ඔබ සිතන්නේ නම් මට දන්වන්න.
ඒ. රෙක්ස්

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]

මෙය බරින් යුත් [1, 6, 12, 30, 65, 99, 87, 117, 118, 89, 95, 118, 96, 184, 126, මාකෝව් මාදිලි 16, පිළිවෙලින් බරින් යුත් බේසියානු සංයෝජනයක් භාවිතා කරයි. 219, 126].

මෙම පඩි තෝරාගැනීමේදී ප්‍රති result ලය ඉතා සංවේදී නොවේ, නමුත් මම ඒවා ප්‍රශස්තිකරණය කළේ , එක් එක් අපේක්ෂක විකෘතියක් ඇති “සෙනෙට් බහුතරයක් එක් කරන්න” යන මගේ පිළිතුරේ දී මා භාවිතා කළ ප්‍රමාද පිළිගැනීමේ කඳු නැගීමේ ඇල්ගොරිතම භාවිතා කළ හැකි බැවිනි. තනි බරකට ± 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
කාර්යය සඳහා නිවැරදි මෙවලම. නියම ලකුණු. කදිම එකක්.
agtoever

1
විය හැකි පැහැදිලි කිරීම: b"\0\3\6\r\34'&-20'\22!P\n[\26"පඩි වල ascii නිරූපණය වන අතර එහිදී මුද්‍රණය කළ නොහැකි කුඩා අගයන් අෂ්ටකයෙන් ගැලවී යයි.
Cœur

පෙළ ඔතා නැති ගොනුවේ අනුවාදයක් සමඟ මම ප්‍රශ්නය යාවත්කාලීන කර ඇත්තෙමි - ඔබට ඔබේ කේතය නැවත ක්‍රියාත්මක කිරීමට උත්සාහ කළ හැකිය (එය තරමක් හොඳ වනු ඇත)
නතානියෙල්

3
එම පැහැදිලි කිරීම සඳහා ස්තූතියි - ඔබට ප්‍රශ්නයට සාරාංශයක් සංස්කරණය කළ හැකි නම් එය විශිෂ්ට වනු ඇත. (මගේ පෙර අභියෝගය වන පේන්ට් ස්ටාර්රි නයිට් හි අත්දැකීම නම්, මෙම ප්‍රශස්තිකරණ ක්‍රියාපටිපාටීන් පිළිතුරු වල වඩාත්ම සිත්ගන්නා සුළු කොටසයි, එබැවින් පිළිතුරු සඳහා ඒ සඳහා භාවිතා කරන කේතය සහ එය පැහැදිලි කිරීමක් ඇතුළත් කිරීම වඩා හොඳය. මම දෙකටම රීතියක් ඇතුළත් කළෙමි අභියෝග කළ යුතුයි.)
නතානියෙල්

1
H ක්‍රිස්ටෝෆ් මගේ ආකෘති සංයෝජනය ඇත්ත වශයෙන්ම බරින් යුත් ජ්‍යාමිතික මධ්‍යන්‍යයකි. නමුත් ලොජිස්ටික් වසමේ PAQ හි සාමාන්‍යය තරමක් වෙනස් ය that එය වඩා හොඳ දැයි බැලීමට මට සිදුවේ.
ඇන්ඩර්ස් කසෝර්ග්

55

පයිතන් 3 , 2 * 279 + 592920 = 593478 2 * 250 + 592467 = 592967 2 * 271 + 592084 = 592626 2 * 278 + 592059 = 592615 2 * 285 + 586660 = 587230 2 * 320 + 585161 = 585801 2 * 339 + 585050 = 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

එය මාර්ගගතව උත්සාහ කරන්න!

ගෝලීය විචල්‍යයන් භාවිතා කරන ශ්‍රිතයක්. එය යන විට ඉගෙන ගනී, වචන මට්ටමින් ආකෘතියක් ගොඩනඟයි: මෙම වචනයේ මෙතෙක් දැක ඇති දේ අනුව, වඩාත් පොදු ඊළඟ චරිතය කුමක්ද? වැඩි ආදානයක් එන විට එය පෙළෙන් පොදු වචන ඉතා හොඳින් ඉගෙන ගන්නා අතර ඊළඟ වචනය ආරම්භ කිරීම සඳහා වඩාත් පොදු චරිතය ද එය ඉගෙන ගනී .

උදාහරණයක් වශයෙන්:

  • මෙතෙක් දැක ඇති දෙය 'කැප්ටායි' නම් එය පුරෝකථනය කරන්නේ "n"
  • එය "කැප්ටන්" නම් එය අවකාශයක් පුරෝකථනය කරයි
  • එය වචනයේ ආරම්භය නම් සහ අවසාන වචනය "කැප්ටන්" නම් එය 'ඒ' පුරෝකථනය කරයි
  • මේ දක්වා ඇති වචනය 'ඒ' නම් එය පුරෝකථනය කරන්නේ 'හ' (ඉන්පසු 'අ' සහ 'ආ'; ඒ හා සමානව 'සී' සඳහා).

ආරම්භයේ දී එය එතරම් සාර්ථක නොවේ, නමුත් අවසානය වන විට සත්‍ය වචන විශාල ප්‍රමාණයක් එළියට එයි. ආපසු හැරවීමේ විකල්පය අවකාශයක් වන අතර, එක් අකුරකට පසු එය "අ" වේ, පෙර අකුර "නෙඩ්ට්ෆෝ", ඉලක්කම් හෝ යටි ඉරක් හෝ අපෝස්තලයක් නොවේ නම්. අක්ෂර 71 කට පසුව හෝ 66 න් පසු අවකාශයක් අපේක්ෂා කළේ නම් එය ආක්‍රමණශීලී ලෙස පුරෝකථනය කරයි. මේ දෙකම දත්ත වලට සුසර කර ඇත ("t" අවකාශයකින් පසුව වඩාත් සුලභ ය, නමුත් බොහෝ විට දැනටමත් පුරෝකථනය කර ඇත, එබැවින් " a "යනු එම විශේෂ අවස්ථා හයෙන් පිටත වඩා හොඳ අනුමානයකි).

වචන යුගල එකට ගිය දේ ඉගෙන ගැනීම සහ සිතියම්ගත කිරීම පූර්ව නිගමනය කිරීම වටින්නේ නැත.


එය අවසන් වන්නේ මේ වගේ පෙළකින්:

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
මෙය විශිෂ්ට ප්‍රවේශයකි!
ස්කයිලර්

2
ඕනෑවට වඩා <s> </s>;)
FantaC

1
+1 මෙම ප්‍රවේශය නිසා මට LZW සම්පීඩන ඇල්ගොරිතම මතක් විය.
මාකෝස්

25

සී ++, ලකුණු: 2 * 132 + 865821 = 866085

බයිට් 217 ක් ඉතිරි කිරීම ගැන u ක්වෙන්ටින්ට ස්තූතියි!

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අතර අක්ෂර පොකුරක් සුරැකීමට එය කෙලින්ම යොමු කරන්න :)
ක්වෙන්ටින්

@ ක්වෙන්ටින් ස්තූතියි! දැන් මම කල්පනා කරන්නේ ඇයි මම මුලින් ඒ ගැන
නොසිතුවේ

c=වෙනුවට -10 ලකුණු return.
එස්එස් ne න්

21

පයිතන්, 2 * 516 + 521122 = 522154

ඇල්ගොරිතම:

තවත් පයිතන් ඉදිරිපත් කිරීමක්, මෙම ඇල්ගොරිතම ගණනය කරනුයේ දිග 1, ..., l අනුක්‍රම දෙස බලන ඊළඟ අකුරයි. සම්භාවිතාවන්ගේ එකතුව භාවිතා වන අතර වඩා හොඳ ප්‍රති .ල ලබා ගැනීම සඳහා උපක්‍රම කිහිපයක් තිබේ.

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, පිළිගැනීමට ස්තූතියි. මම දැන් ටික වේලාවක් නැරඹීමෙන් සතුටක් ලැබුවෙමි, ප්‍රවේශයක් සඳහා මගේ අවධානය දිනා ගන්නා පළමු තරඟය මෙයයි.
user2699

19

සී ( ජීසීසී ) , 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 කින් යුත් අනුක්‍රම දෙකක එකම ආකාරයකින් අවසන් වන සහජ සම්භාවිතාව මත රඳා පවතී.

ඩී ගොල්ෆ්:

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
Og රොජම් මම ගොල්ෆ් කරන ලද අනුවාදයක් එක් කර ඇත්තෙමි (එය මට අනුගමනය කිරීමට නොහැකි වූ නිසා) - මෙය ඔබට කරදරයක් නොවන නමුත් අවශ්‍ය නම් කරුණාකර ආපසු පෙරළන්න.
ඇඩම් ඩේවිස්

D ඇඩම් ඩේවිස් C හි බොහෝ ක්‍රියාත්මක කිරීම් වලදී, සියලුම ගෝලීය විචල්‍යයන් ආරම්භ වන්නේ ශුන්‍යයෙන් ය. එය නිර්වචනය නොකළ හැසිරීමකි, එබැවින් එය භාවිතා කරන්නේ කේත-ගොල්ෆ් වල පමණි.
NieDzejkob

1
@NieDzejkob අහ්, ඔබ හරි, ස්තූතියි! "ANSI-C මගින් සියලු ආරම්භක නොවන ස්ථිතික / ගෝලීය විචල්‍යයන් 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

එහි ආදානය නොසලකා හැරේ; නිවැරදි පිළිතුර ලබා දෙයි. මෙය එක් කෙළවරක මූලික පදනමක් සපයයි; daniero අනෙක් කෙළවරේ මූලික පදනමක් සපයයි.

සාදන්නාගේ පිටපත:

#!/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.වගන්තිය උල්ලං does නය නොකරන්නේ කෙසේද?

8
OgRogem සම්පීඩිත දත්ත මෙහි පෙන්වා ඇති දේට පසුව තබා ඇති අතර කේත ප්‍රවේශයම වේ.
user202729

4
ප්රශ්නය පවසයි: "ඔබගේ ඉදිරිපත් වැඩසටහනක් හෝ කාර්යය (ආදිය) වනු ඇත කැඳවා ලබන්නේ හෝ කීප වරක් පළ කළහ එය නම්, ඒ සඳහා කර ඇති විට. 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 සබැඳියේ Ungolfed කේතය, අදහස් දැක්වීය.
  • කේතය බයිට් 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 සොයාගත නොහැකි නම්, එය අවකාශයක් මුද්‍රණය කරයි.

මෙම අනුවාදය 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 කින් ක්‍රියාත්මක වේ. වාර්තාව සඳහා, බැලීමේ වගුවේ යතුරු වල ප්‍රමාණය වෙනස් කරන විට මට ලැබෙන්නේ මෙයයි (ආකෘතිය නැවත සකස් නොකර දෙවන ධාවනයේ ප්‍රති results ල ඇතුළත් වේ):

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
ඔබ යතුරු ප්‍රමාණය සහ තීරු සීමාව වෙනස් කරන විට විචලනය පෙන්වීමට ස්තූතියි!
ජෙරමි වේරිච්

පෙළ ඔතා නැති ගොනුවේ අනුවාදයක් සමඟ මම ප්‍රශ්නය යාවත්කාලීන කර ඇත්තෙමි - ඔබට එය භාවිතා කිරීමෙන් ලකුණු කිහිපයක් ඉතිරි කර ගත හැකිය
නතානියෙල්

Athan නතානියෙල් එය ඇත්තෙන්ම කරයි. මම පිළිතුර යාවත්කාලීන කර ඇත.
චාලි

වර්ග ප්‍රකාශ කිරීම වෙනුවට var භාවිතා කරමින් ඔබට බයිට් කිහිපයක් ඉතිරි කළ හැකිය.
එඩ් ටී

1
යතුරු ප්‍රමාණය විශාල වන විට, මඟ හැරුණු පද ගණන අඩු වන අතර කෙටි යතුරක් නිවැරදි අක්‍ෂරය අනුමාන කළ විට වැඩි ඉඩ ප්‍රමාණයක් ප්‍රතිදානය වනු ඇත. යතුරු ප්‍රමාණය කුඩා වන විට, ගැලපෙන කොටස් සඳහා තනි අනුමාන අඩු නිරවද්‍ය වේ. හතරක දිග ප්‍රශස්ත වන්නේ මේ නිසා යැයි මම සැක කරමි. ඔබ බහු දිග යතුරු පවත්වා ගෙන ගිය අතර දිගු ඒවා නොමැති විට කෙටි තරග භාවිතා කළේ නම්, මම බලාපොරොත්තු වන්නේ පහර යතුරු අනුපාතය (සහ ඒ අනුව ලකුණු) දිගු යතුරු දිගින් වැඩි දියුණු වනු ඇති බවයි.
ජෙෆ්රි එල් වයිට්ලෙජ්

11

ජාවා 7, 1995 අක්ෂර, (1995 * 2 + 525158) 529148

ජාවා කුඩා වැඩසටහන් ප්‍රමාණ සඳහා උරා ගනී. කෙසේ වෙතත්, මම පුදුම සහගත ලෙස කපටි ප්‍රති .ල ලබා දුන් අතිශය සංකීර්ණ හා උපායශීලී ප්‍රවේශයන් කිහිපයක් උත්සාහ කළෙමි. මම පසුව ආපසු ගොස් සරල ප්‍රවේශයක් කළෙමි, එහි ප්‍රති program ලය වූයේ කුඩා වැඩසටහන් ප්‍රමාණයක් සහ වඩා හොඳ ප්‍රති .ල ලබා ගැනීමයි.

මෙම ප්රවේශය ඇත්ත වශයෙන්ම අතිශයින්ම සරල ය. එය පෙර අක්ෂරයේ අන්ධ ලෙස පෝෂණය කරයි (එම අක්ෂරවල සියලුම උපස්ථර වලට අමතරව) වර්තමාන අක්ෂරයට අනුරූපව හැෂ් ටේබල් එකකට. එමඟින් වර්තමාන චරිතය වඩාත් නිවැරදිව පුරෝකථනය කරන්නේ කුමන රටාවන් දැයි සොයා ගනී. සමහර අක්ෂර වලට පෙර රටා කිහිප වතාවක් හමු වුවහොත්, චරිතය පුරෝකථනය කිරීමට ඒවා සමත් වේ. එය දිගු නූල් වලට ප්‍රමුඛතාවය ලබා දෙන අතර, ලබා දී ඇති නූලක් බොහෝ විට අනුගමනය කරන ඕනෑම චරිතයකට එය ප්‍රමුඛතාවයක් ලබා දෙයි. මෙම ඇල්ගොරිතම ලේඛනයේ වර්ගය හෝ ඉංග්‍රීසි භාෂාව ගැන කිසිවක් දන්නේ නැත.

මම අක්ෂර 9 ක් භාවිතා කරමින් සහ හැකි විට එම පෙර අක්ෂර 9 තුළ සම්පූර්ණ වචන ගැලපීමට උත්සාහ කළෙමි. ඔබ නූල් තුළ වචන ගැලපීම කිරීමට උත්සාහ නොකරන විට, ප්‍රශස්ථ දිග අක්ෂර 6 ක් වන අතර තවත් දහස් ගණනක් වැරදි අනාවැකි පළ කරයි.

එක් සිත්ගන්නාසුලු නිරීක්ෂණයක් වූයේ පළමු වරට අක්ෂර 20 ක් භාවිතා කිරීමෙන් නරක අනාවැකි පළ වූ නමුත් පසුව සමත් වීමේ ප්‍රතිශතය සියයට 99.9 කි. ඇල්ගොරිතමයට මූලික වශයෙන් බයිට් කුට්ටි 20 ක් අතිච්ඡාදනය කර පොත කටපාඩම් කර ගැනීමට හැකි වූ අතර, මෙය එකවර මුළු පොතක්ම චරිතයක් සිහිපත් කිරීමට ඉඩ සලසයි.

  • (1950 * 2 + 532919) 536819
  • (2406 * 2 + 526233) 531045 වඩා හොඳ අනුමාන කිරීම සඳහා විරාම ලකුණු පරීක්ෂා කිරීම
  • (1995 * 2 + 525158) 529148 තවත් කරකැවීම, ගොල්ෆ් කිහිපයක් වාචිකව ඉවත් කර ඇත

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

එවැනි වාචික භාෂාවක් සඳහා එය හොඳ ලකුණු වේ.
ජේම්ස්

1
වැඩසටහන් ප්‍රමාණයට සාපේක්ෂව ගොනුවේ විශාලත්වය වැඩි දියුණු කිරීම සඳහා විශාල ඉඩක් ලබා දෙන බැවින් එය වෙඩි තැබීම වටී යැයි මම සිතුවෙමි.
ජිම් ඩබ්ලිව්

3
මෙය ජාවා 7 යටතේ සම්පාදනය කළ නොහැක (හෝ ඕනෑම ජාවා අනුවාදයක්, එය වටින දේ සඳහා). කරුණාකර ඔබේ කේතය නිවැරදි කරනවාද? එය අවසන් වූ පසු, ඔබගේ ලකුණු වැඩි දියුණු කිරීම සඳහා මම එය සතුටින් ගොල්ෆ් කරමි.
ඔලිවියර් ග්‍රෙගෝයර්

පරීක්ෂා නොකළ නමුත් මෙය තරමක් ගොල්ෆ් කළ ඔබේ එකම කේතය විය යුතුය: බයිට් 950 . ඔබගේ වර්තමාන කේතයේ දෝෂ කිහිපයක් තිබුනද, එබැවින් මම සෑම දෙයක්ම නිවැරදිව පුරවා ඇත්දැයි මට විශ්වාස නැත. නැවතත්, පරීක්ෂා නොකළ, එබැවින් මා වෙනස් කළ / නැවත නම් කළ දේ බැලීමට අනුවාදයන් සංසන්දනය කරන්න, සහ සියල්ල තවමත් ඔබේ මුල් කේතයට සමානව ක්‍රියාත්මක වේදැයි බලන්න. අනිවාර්යෙන්ම තවත් ගොල්ෆ් ක්‍රීඩා කළ හැකිය.
කෙවින් ක ru යිසන්

කපටි, මම මෙය කළේ මගේ පැරණි රැකියාව ගැන කම්මැලි වන අතර කේතය මා සමඟ ගත්තේ නැත. යතුරු ලියනය තිබෙන්නේ කොහේදැයි බැලීමට මට එය බැලීමට සිදුවේ.
ජිම් ඩබ්ලිව්

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සිද්ධි සංවේදී හා විරාම ලකුණු ඇතුළුව). එය පසුව මෙම ශබ්ද කෝෂය වත්මන් වචනය පිළිබඳව මෙතෙක් දන්නා දේ සමඟ ආරම්භ වන අතර, එහි ප්‍රති list ල ලැයිස්තුව සංඛ්‍යාතයෙන් (සෙමින්) වර්ග කරයි, සහ ඊළඟ චරිතය වඩාත් පොදු ගැලපෙන වචනයේ ඊළඟ චරිතය යැයි අනුමාන කරයි. අප සතුව වඩාත් සුලභ ගැලපෙන වචනය දැනටමත් තිබේ නම් හෝ තවදුරටත් ගැලපෙන වචනයක් නොමැති නම්, එය නැවත පැමිණේ .

එය වචන යුගලවල පිළිකුල් සහගත අකාර්යක්ෂම ශබ්ද කෝෂයක් ද ගොඩනංවයි. වචන සීමාවකට පහර දුන් පසු, එය අනුමාන කරන්නේ ඊළඟ අක්‍ෂරය වඩාත් පොදු ගැලපෙන වචන යුගලයේ දෙවන වචනයේ පළමු අකුර හෝ නොගැලපීමක් tනම්. එය එතරම් දක්ෂ නැත. පහත දැක්වෙන පරිදි Moby, වැඩසටහන නිවැරදිව අනුමාන කරන්නේ ඊළඟ චරිතයයි D, නමුත් පසුව එය සන්දර්භය සියල්ල අමතක කර සාමාන්‍යයෙන් තල්මසාව "මොබී තාරා" ලෙස හැඳින්වීම අවසන් කරයි (මන්ද ලන්දේසි යන වචනය පා text යේ පළමු භාගයේදී නිතර නිතර සිදුවන බව පෙනේ ). තනි වචන වලට වඩා වචන යුගලවලට ප්‍රමුඛතාවය දීම මගින් මෙය නිවැරදි කිරීම පහසුය, නමුත් මම බලාපොරොත්තු වන්නේ එහි ලාභය ආන්තික වනු ඇත (එය සාමාන්‍යයෙන් තුන්වන අක්ෂරයෙන් නිවැරදි බැවින් සහ වචන යුගල මුලින් ම එතරම් ප්‍රයෝජනවත් නොවන බැවිනි).

සපයා ඇති පෙළට වඩා හොඳින් ගැලපෙන පරිදි මට මෙය සුසර කළ හැකිය, නමුත් ආදානය පිළිබඳ පූර්ව දැනුම මත පදනම්ව ඇල්ගොරිතම අතින් සකස් කිරීම සැබවින්ම ක්‍රීඩාවේ ආත්මය තුළ ඇතැයි මම නොසිතමි, අවකාශයකින් පසු පසුබෑමේ චරිතය ලෙස තෝරා ගැනීම හැර ( මම බොහෝ විට එය නොකළ යුතුව තිබුණි), මම එය වළක්වා ගත්තෙමි. ආදාන ගොනුවේ දන්නා රේඛීය දිග මම නොසලකා හැර, ඒ වෙනුවට \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 "

එය ඛාන්ගේ කෝපය තවත් අවුල් සහගත වනු ඇත. “තනිකම” t “රසවත්” යනු විශේෂයෙන් තෘප්තිමත් ආදේශකයකි.

සංස්කරණය කරන්න: බාහිර ඉඩක් මකා දැමීමෙන් එක් බයිට් එකක් සුරකින ලදි

ලකුණු කිරීම

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

මෙය මොබී ඩික්ගේ පෙළ සඳහා වැඩසටහන ක්‍රියාත්මක කරන අතර "පුරෝකථනය කරන ලද" පා st මාලා නිමැවුම් ප්‍රතිදානය කරයි, සහ ලකුණු ලිවීමට stderr අපයෝජනය කරයි. ප්‍රතිදානය ගොනුවකට හරවා යැවීමට මම නිර්දේශ කරමි.


2
PPCG වෙත සාදරයෙන් පිළිගනිමු!
මාටින් එන්ඩර්

1
නැහැ lambda i:i[1]සමඟ කටයුතු වඩා අඩු විය operator?
ඩ්‍රැකොනිස්

Ra ඩ්‍රැකොනිස් නිසැකවම.
ජෝර්ජ්වොට්සන්

10

සී ++, 2 · 62829 + 318786 = 444444

මෙම වැඩසටහන ක්‍රියාත්මක කිරීම සඳහා, ඔබට මෙම ගොනුව මෙහි අවශ්‍ය වේ , එය නම් කළ යුතුය C.

වැඩසටහන අපගේ පෙර පිළිතුරේ දී මෙන් මාර්කෝව් ආකෘතිවල සංයෝජනය භාවිතා කරයි . පෙර මෙන්, මෙම සංයෝජනය අත්‍යවශ්‍යයෙන්ම පරිශීලක 2699 විසින් මෙම පිළිතුරෙන් ලබා ගත් ආකෘතියකි , නමුත් කුඩා වෙනස් කිරීම් කිහිපයක් සමඟ.

මෙම පිළිතුර පෙර මෙන් එකම ආකෘතිය භාවිතා කරන ආකාරය දෙස බලන විට, වැඩිදියුණු කිරීම යනු කලින් විස්තර කර ඇති “රිවයින්ඩ්” යාන්ත්‍රණයට වඩා හොඳ තොරතුරු-න්‍යායාත්මක යාන්ත්‍රණයකි . කුඩා ඒකාබද්ධ දිගක් ඇති අතර අඩු දෝෂ ඇති කිරීමට මෙය ඉඩ දෙයි. වැඩසටහනම ගොල්ෆ් කර නැත, මන්ද එය ලකුණු සඳහා ප්‍රධාන දායකයා නොවන බැවිනි.

වැඩසටහන බයිට් 2167 ක් දිගයි (ඉන්ඩෙන්ටේෂන් සඳහා වන සියලුම ටැබ් සහ වෙනත් අනවශ්‍ය අක්ෂර රාශියක් ඇතුළුව, නමුත් පරීක්ෂණ කේතයට පෙර), සහ ද්විමය ගොනුව Cබයිට් 60661 ක් දිගයි, එබැවින් බහු ලිපිගොනු ලකුණු කිරීමේ නීති යටතේ , අපි ලකුණු L2167 + 60661 + 1 = 62829.

මෙම වැඩසටහන m5.4xlargeඇමසන් ඊසී 2 හි නිදසුනක් මත ක්‍රියාත්මක වීමට ආසන්න වශයෙන් මිනිත්තු 8 ක් ගත වන අතර මතක ධාරිතාව 16 GB ට වඩා ටිකක් භාවිතා කරයි. (මෙම අධික මතක භාවිතය අවශ්‍ය නොවේ - අපි එය ප්‍රශස්තිකරණය කළේද නැත.)

#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 කින් යුත් සියලුම ධාවන සංඛ්‍යාත ගබඩා කිරීම මෙහි අදහසයි. මෙම එක් එක් දිග L සඳහා, නවතම L-1 අක්ෂර ගබඩා කළ රටාවකට ගැලපේදැයි අපි පරීක්ෂා කරමු; එසේ නම්, අපගේ අනුමානය g L යනු එම රටාව අනුගමනය කරන ඊළඟ චරිතයයි. අපි මේ ආකාරයෙන් අනුමාන නවයක් දක්වා එකතු කරමු. කුමන අනුමානය භාවිතා කළ යුතුද යන්න තීරණය කිරීම සඳහා, අපි එක් එක් රටාවේ සංඛ්‍යාතය එහි දිග අනුව 8 වන බලයට බර කරමු. විශාලතම බර කිරන සංඛ්‍යාත සමඟ අනුමානය තෝරා ගනු ලැබේ. ගැළපෙන රටා නොමැති නම්, අපි අවකාශය අනුමාන කරමු.

(අවම වැරදි අනුමාන ලබා දීම සඳහා උපරිම රටා දිග සහ බර කිරිමේ on ාතකය අත්හදා බැලීම් සහ දෝෂ මඟින් තෝරාගෙන ඇත.)

මෙන්න මගේ නොගැලපෙන වැඩ කිරීමේ ප්‍රගතිය:

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--for sailorමම අනුමාන. නැතහොත් නැවතත්, , aඑය අපේක්ෂා කිරීමෙන් පසුව - nපොදු සිදුවීම නිසා විය , andහැකිය.


Changelog:

  • 274 * 2 + 526092 = 526640 අමතර දෝෂ කිහිපයක් සඳහා ඇල්ගොරිතම ගොල්ෆ් කළේය
  • 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]];}

ඉතිහාසයේ උපසර්ගයකින් ආරම්භ වන දීර් est තම නූල මෙය කෑදර ලෙස සොයා ගන්නා අතර, බහු අපේක්ෂකයින් සිටී නම්, කෙටි නූල් සමඟ ටයිබ්‍රේක් කරන්න.

උදාහරණයක් ලෙස: පසුගිය චරිත 7 නම් abcdefgh, හා සංගීත abcdefghiහා abcdefghjස්වරූපයෙන් සියලු නූල් විශාලතම සංඛ්යාත සමග දර්ශණය abcdefgh*, ප්රතිදානය හෝ වනු ඇත iහෝ jකෙටි suffixes (සමග tiebreak, bcdefgh, cdefgh, ...).

නොදන්නා හේතු නිසා, 7 ට වඩා වැඩි කිසිවක් සහ මගේ පරිගණකයට එය ක්‍රියාත්මක කිරීමට ප්‍රමාණවත් RAM ප්‍රමාණයක් නොමැත. 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 

මෙය පා of යේ අවසානයට ආසන්නය. බොහෝ දිගු වචන ඉතා නිවැරදිව අනාවැකි පල වේ ( 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

ඉහළ නඩුව හොඳ නැත.


ට්‍රයි මම බලාපොරොත්තු වූවාට වඩා මතක ශක්තිය පරිභෝජනය කරන බවක් පෙනේ ...
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"':' ',.......}, සහ a2 චරිත සිට 1 චරිතයට සිතියම් වන ශබ්ද කෝෂය වේ. ස්ටෙඩිබොක්ස්ගේ පිළිතුරේ මූලික වශයෙන් අක්ෂර 2 ක ප්‍රභේදයකි .
user202729

1
මට පෙනෙන පරිදි, වචනානුසාරයෙන් බයිට් 17780 කි. බයිට් 12322 ක් ඉතිරි කරන, දිරාපත් වූ අන්තර්ගතයේ ඇති හිස් අවකාශයන් ඉවත් කිරීමෙන් ඔබට එය අක්ෂර 11619 දක්වා අඩු කළ හැකිය. (මම නිවැරදිව ගණන් කළහොත්) එසේම ... හෙක්ස් ගැලවීමේ කේත සැබෑ අමු අක්ෂර බවට පරිවර්තනය කිරීමෙන් ඊටත් වඩා බයිට් ඉතිරි වේ.
user202729

අමු බයිට් නම් මා මෙහි යමක් පළ කරන්නේ කෙසේද?
ස්කයිලර්

1
xxd, hexdump, uuencode, හෝ ඒ හා සමාන
පීටර් ටේලර්

20 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

සී ++ (ඩබ්ලිව්අයිපී), 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;

මෙම විසඳුම ඩබ්ලිව්.අයි.පී. මයික්‍රෝ ප්‍රශස්තිකරණය කිරීමට පෙර මගේ පිළිතුර පළ කිරීමට පළමුවෙන්ම මම සිතුවෙමි.
(සම්පූර්ණ කේතය මෙතැනින් ලබා ගත හැකිය: https://github.com/BrainStone/MobyDickRNG - සම්පූර්ණ වැඩසටහන සහ බීජ සෙවීම ඇතුළත් වේ)

මෙම විසඳුම RNG මත පදනම් වේ. පළමුව මම පෙළ විශ්ලේෂණය කරමි. අඛණ්ඩ අක්ෂර දෙකක සිදුවීම් ගණනය කරන සිතියමක් මම නිර්මාණය කරමි. ඉන්පසු මම බෙදාහැරීමේ සිතියමක් සාදමි. මේ සියල්ල සංඛ්‍යාත්මකව සිදු කෙරෙන බැවින් නීතිරීතිවලට අනුකූල විය යුතුය.

පෙළ මුද්‍රණය කිරීමට උත්සාහ කරන අතරතුර මම සොයා බලා හැකි අයගේ අහඹු චරිතයක් අදින්නෙමි. මෙය සාමාන්‍යයෙන් වඩාත් සුලභ පහත දැක්වෙන ලිපිය ප්‍රතිදානය කිරීමට වඩා නරක ප්‍රති results ල ලබා දෙන අතර, වඩා හොඳ ප්‍රති .ල ලබා දෙන දෙවියන්ගේ බීජ තිබිය හැකිය. බීජය තදින් කේත කර ඇත්තේ එබැවිනි. මම දැනට හොඳම බීජය සොයමි. වඩා හොඳ බීජ සොයාගත් පසු මම මෙම පිළිතුර යාවත්කාලීන කරමි. ඒ නිසා දිගටම රැඳී සිටින්න!

යමෙකුට බීජ සෙවීමට හෝ විවිධ ආර්එන්ජී භාවිතා කිරීමට අවශ්‍ය නම්, රෙපෝව ලබා ගැනීමට නිදහස් වන්න.

ලකුණු ගණනය කිරීමට භාවිතා කරන ක්‍රමය: 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)

ඔබේ පිළිතුරෙහි ලකුණු තක්සේරු කරන පරීක්ෂණ පටි ඇතුළත් කළ හැකිද?
නතානියෙල්

Athan නතානියෙල් මම ලකුණු කේතය කෙලින්ම සම්බන්ධ කළෙමි. ගබඩාවට අමතරව ඔබ මෙය ප්‍රමාණවත්ද?
බ්‍රයින්ස්ටෝන්

නීති සමාලෝචනය කිරීමෙන් පසු මම ඒවායින් සමහරක් උල්ලං that නය කරන බව දුටුවෙමි. ගැටළු නිරාකරණය කළ පසු මම ස්වභාවයෙන්ම මගේ පිළිතුර යාවත්කාලීන කරමි
BrainStone

එවිට ඔබ අහඹු බීජයට පෙළ කේතනය කිරීම අවසන් කරනු ඇත. එසෝටරික් ක්‍රමලේඛන භාෂා බීජය බලන්න , ඔබට MT19937 වැඩසටහන ආපසු හැරවීමට අවශ්‍ය විය හැකි අතර මෙම පිළිතුර පරාජය කරන්න (ඔබට හැකි නම්).
user202729

හොඳ අදහසක්, නමුත් හොඳ ලකුණු ලබා ගැනීමට උපකාරී නොවේ. +1 කෙසේ හෝ.
user202729

3

රූබි, 1164418 (ඕච්)

මට අවශ්‍ය වූයේ වෙනත් පිළිතුරු පරික්ෂා නොකර මට කොතරම් හොඳින් කළ හැකිද යන්නයි.
ගොනුව විශ්ලේෂණය කිරීමෙන් මා විසින් ජනනය කරන ලද වචනානුසාරයෙන් එයට ඇතුළත් වන්නේ දැයි මට විශ්වාස නැත, නමුත් එය එසේ නොවුනත් එය කිසිවෙකුට පහර දීමේ අවදානමක් ඇත.

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> _> (නිහ ly ව "(තරඟ නොකරන)" මාතෘකාවට තල්ලු කරයි)
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]

එය මාර්ගගතව උත්සාහ කරන්න!

ඉතා සරල සංඛ්‍යාත වගුව. නූලෙහි සෑම ස්ථානයක්ම වත්මන් අක්‍ෂරයේ ascii කේතයට අනුරූප වේ (us ණ 10 = 0x0a = '\ n', ගොනුවේ පහළම අක්‍ෂරය), සහ එක් එක් දර්ශකයේ ඇති අක්‍ෂරය බොහෝ විට ඊළඟ අක්ෂර වේ. මම සංඛ්‍යාත නිවැරදිව ගණනය කළා යැයි සිතමු…

පරිශීලක 202729 පරීක්ෂණයෙන් කේතය සමඟ පරීක්ෂා කර ඇත


භාවිතයෙන් ඔබට බයිට් කිහිපයක් ඉතිරි කළ හැකිද def f(c):return(" ">c)*c or"t ... e"[ord(c)-32]?
නීල්

1

[පයිතන් 3] (644449 * 2 + 0) ලකුණු 1288898

පරිපූර්ණ නිරවද්‍යතාවය බයිට් 644449 කින් පමණි

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

සම්පූර්ණ කේතයට පිළිතුරකට නොගැලපේ, එබැවින් මම එය මෙහි දමා විශාල ද්විමය වචන වචනාර්ථයෙන් පිළිතුරු පා .යේ b '###' සමඟ ආදේශ කර ඇත.

මෙය ජනනය කරනු ලබන්නේ පහත දැක්වෙන කේතයෙනි, එහිදී "modified.py" ජනනය කරන ලද ගොනුව වන අතර "cheatsheet.txt" යනු දෙවන අක්ෂරයෙන් ආරම්භ වන whale2.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]')

"Modified.py" හි අවසානයට පහත සඳහන් දෑ එකතු කිරීමෙන් කේතය ක්‍රියාත්මක කළ හැකිය. "whale2.txt" "modified.py" හා සමාන නාමාවලියක තිබිය යුතු අතර ප්‍රතිදානය "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
ඔව්, එය ප්‍රචාරය කළ
යතුරු ලියනයකි
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.