Ось 1.2Mb текстовий файл ASCII, що містить текст Мобі-Діка Германа Мелвілла ; або, Кит . Ваше завдання - написати програму або функцію (або клас тощо - див. Нижче), якому цей файл буде наданий по одному символу, і на кожному кроці повинен вгадувати наступний символ.

Це виклик коду . Ваш рахунок буде

2*L + E

де Lрозмір вашої подачі в байтах, і Eкількість символів, яку вона неправильно здогадується. Виграє найнижчий бал.

Подальші дані

Ваша заявка буде програмою або функцією (тощо), яка буде викликана або викликана або надіслана даними кілька разів. (1215235 разів, щоб бути точним.) Коли він буде викликаний в n- ^й раз, йому буде надано n- ^й символ whale.txtабо, whale2.txtі він повинен вивести свою здогадку для ( n + 1 ) ^-го символу. EКомпонент його рахунок буде загальна кількість символів , які він НЕ вгадає.

Більшість подань потребує збереження певного стану між викликами, щоб вони могли відслідковувати, скільки разів вони були викликані та якими були попередні дані. Це можна зробити, записавши у зовнішній файл, використовуючи staticглобальні змінні, подавши клас, а не функцію, використовуючи монаду стану або все, що працює для вашої мови. Ваше подання повинно включати будь-який код, необхідний для ініціалізації його стану до першого виклику.

Ваша програма повинна запускатися детерміновано, так що вона завжди робить однакові здогадки з одним і тим же входом (і, отже, завжди отримує однаковий бал).

Ваша відповідь повинна містити не тільки ваше подання, але і код, який ви використовували для підрахунку Eчастини його балу. Це не потрібно писати тією самою мовою, що і ваше подання, і не зараховуватиметься до його кількості байтів. Вам рекомендується зробити його читабельним.

Що стосується інтерфейсу між вашою подачею та цією програмою для обчислення балів, то все добре, доки ваша програма завжди дає один байт виводу, перш ніж отримувати наступний байт введення. (Так, наприклад, ви не можете просто передати йому рядок, що містить увесь вхід, і отримати рядок назад, що містить весь вихід.)

Ви дійсно повинні запустити свою тестову програму та розрахувати / підтвердити свій результат, перш ніж подавати заявку. Якщо ваше подання працює занадто повільно, щоб ви підтвердили його бал, то воно не кваліфіковане для змагання, навіть якщо ви в принципі знаєте, який би його бал.

LКомпонент вашого рахунку буде розраховуватися в відповідно до звичайних правил для викликів коду для гольфу. Якщо ваше повідомлення буде містити кілька файлів, будь ласка, врахуйте правила щодо балів та структури каталогів у цьому випадку. Будь-які дані, які використовує ваш код, повинні бути включені до вашої Lоцінки.

Ви можете імпортувати існуючі бібліотеки, але не можете завантажувати будь-які інші зовнішні файли, а ваш код може не мати доступу до whale.txtабоwhale2.txtфайл будь-яким іншим способом, ніж описано вище. Ви не можете завантажувати будь-які заздалегідь підготовлені нейронні мережі чи інші джерела статистичних даних. (Добре використовувати нейронні мережі, але ви повинні включити у ваші дані дані про вагу та порахувати їх до кількості байтів.) Якщо з якоїсь причини ваша мова чи бібліотеки містять функцію, яка надає частину чи весь текст Moby Dick , ви можете не використовувати цю функцію. Крім цього, ви можете використовувати будь-які інші вбудовані або бібліотечні функції, які вам подобаються, включаючи ті, що стосуються обробки тексту, передбачення або стиснення, якщо вони є частиною вашої мови або її стандартних бібліотек. Для більш екзотичних, спеціалізованих процедур, які включають джерела статистичних даних, вам доведеться їх реалізувати самостійно і включити їх у свій облік байтів.

Цілком імовірно, що деякі подання включатимуть компоненти, які самі генеруються кодом. Якщо це так, будь ласка, включіть у свою відповідь код, який використовувався для їх виготовлення, та поясніть, як це працює . (Поки цей код не потрібен для запуску подання, він не буде включений до вашого числа байтів.)

З історичних причин файл існує дві версії, і ви можете використовувати будь-яку з них у відповіді. У whale2.txtтексті (зв'язане вище) текст не загортається, тому нові рядки з’являються лише в кінці абзаців. В оригіналі whale.txtтекст загортається шириною до 74 символів, тому вам потрібно передбачити кінець кожного рядка, а також передбачити текст. Це робить складніше виклик, тому whale2.txtрекомендується для нових відповідей. Обидва файли однакового розміру, 1215236 байт.

Підсумовуючи, всі відповіді повинні містити такі речі:

• Само ваше подання. (Код, а також усі файли даних, які він використовує - це можуть бути посилання, якщо вони великі.)
• Пояснення, як працює ваш код. Поясніть, будь ласка, метод вводу / виводу, а також те, як він передбачає наступний символ. Пояснення вашого алгоритму важливе, і хороші пояснення зароблять від мене щедрості.
• Код, який ви використовували для оцінки своєї оцінки. (Якщо це ідентично попередній відповіді, ви можете просто посилання на нього.)
• Будь-який код, який ви використовували для створення подання, а також пояснення цього коду. Сюди входить код, який ви використовували для оптимізації параметрів, генерації файлів даних і т.д.

Таблиця лідерів

var QUESTION_ID=152856,OVERRIDE_USER=21034;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:380px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Score</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

Bounties

Час від часу я пропоную щедроти для заохочення різних підходів.

Перший, 50 балів, був нагороджений А. Рексом за найкращу оцінку на той момент.

Другий, 100 балів, був також присуджений А. Рексу, за ту саму відповідь, бо вони додали дуже хороше пояснення до існуючої відповіді.

Наступний рахунок, 200 балів , буде присуджений будь-якому

• Конкурентна відповідь, яка використовує нову техніку. (Це буде грунтуватися на моєму суб'єктивному судження, оскільки саме моя репутація переходить у винагороду, але ви можете довіряти мені, щоб бути справедливим. Зауважте, що ваша відповідь повинна містити достатнє пояснення для мене, щоб зрозуміти, як це працює!) Така відповідь потрібна Не беру найкращий бал, він просто повинен зробити досить добре порівняно з існуючими відповідями. Мені особливо хочеться бачити рішення, що базуються на періодичних нейронних мережах, але я присуджую нагороду за все, що здається досить відмінним від моделей Маркова, які домінують у поточних найкращих показниках.

Або:

• Усі, хто б'є найкращий показник А. Рекса (зараз 444444), використовуючи будь-який метод.

Після того, як заявлений виграш на 200 очок, я, швидше за все, запропоную 400 балів, відповідно оновивши вимоги.

/// , 2 * 1 + 1020874 = 1020876

Друкує пробіл.

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

Він складається з простої моделі PPM, яка розглядає останні 8 символів, щоб передбачити наступний.

Ми довіряємо шаблону довжини L, коли ми стикалися з ним принаймні T [L] разів, де T - масив довільних порогів: [1,1,2,1,2,3,5,2] . Крім того, ми завжди довіряємо шаблону, чий перший персонаж відповідає [A-Z '"(].

Ми вибираємо найдовший довірений шаблон і повертаємо прогноз із найвищим балом, пов’язаним із цим шаблоном на момент виклику.

Примітки

• Це, очевидно, не оптимізовано для швидкості, але він працює приблизно за 15 секунд на моєму ноутбуці.

• Якщо б нам дозволили повторити процес кілька разів поспіль, не скидаючи модель, кількість помилок збільшиться до ~ 268000 після 5 ітерацій.

• Поточний рівень успішності функції передбачення становить ~ 56,8%. Як зауважив @immibis у коментарях, якщо погані та правильні здогадки змішані разом, результат навіть не ледве читається.

  Наприклад, цей фрагмент наприкінці книги:

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

  стає:

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

  Замінивши погані здогадки на підкреслення, ми маємо краще уявлення про те, яка функція вийшла правильно:

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

  _{Примітка . Наведений вище приклад був створений з попередньою версією коду, що працює над першою версією вхідного файлу.}

Код тесту

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

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

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

  console.time('ElapsedTime');

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

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

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

Журнал змін

• 524727 - збережено 19644 бали, перейшовши на whale2.txt (оновлення виклику)
• 544371 - заощаджено 327 балів, змусивши шаблони, починаючи з великої літери, цитати, подвійної лапки або вступних дужок, яким також завжди довіряти
• 544698 - збережено 2119 очок, змушуючи шаблони, починаючи з простору, якому завжди слід довіряти
• 546817 - заощаджено 47 балів, скоригувавши пороги та виконуючи функцію прогнозування
• 546864 - збережено 1496 очок, збільшивши максимальну довжину візерунка до 8 символів
• 548360 - збережено 6239 балів, ввівши поняття довірених шаблонів, з порогами залежно від їх довжини
• 554599 - заощаджено 1030 балів за рахунок покращення прогнозування стрічкових рядків
• 555629 - заощаджено 22 очки за допомогою функції прогнозування
• 555651 - заощаджено 40 очок, використовуючи функцію прогнозування
• 555691 - початковий бал

Perl, 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 байт, тому згідно з правилами скорингу декількох файлів ми Lоцінюємо як 582 + 69942 + 1 = 70525.

Програма майже напевно вимагає 64-бітової (мало-ендіанської?) Архітектури. Для запуску m5.largeекземпляра на Amazon EC2 потрібно приблизно 2,5 хвилини .

Код тесту

# Golfed submission
require "submission.pl";

use strict; use warnings; use autodie;

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

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

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

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

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

Тестовий джгут передбачає, що подання знаходиться у файлі submission.pl, але це легко змінити у другому рядку.

Порівняння тексту

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

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

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

Цей зразок (обраний в іншій відповіді ) зустрічається досить пізно в тексті, тому модель досить розвинена до цього моменту. Пам’ятайте, що модель доповнена на 70 кілобайт «підказки», які безпосередньо допомагають їй відгадати персонажів; він не керується просто коротким фрагментом коду вище.

Створення натяків

Наступна програма приймає точний код подання вище (на стандартному введенні) та генерує точний Bфайл вище (на стандартному виході):

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

Виконання займає приблизно стільки ж часу, як і подання, оскільки воно виконує аналогічні обчислення.

Пояснення

У цьому розділі ми спробуємо описати, що це рішення робить досить детально, щоб ви могли «спробувати його вдома» самостійно. Основна техніка, яка відрізняє цю відповідь від інших, - це кілька розділів вниз як механізм "перемотування назад", але перш ніж ми туди потрапимо, нам потрібно встановити основи.

Модель

Основний компонент розчину - це мовна модель. Для наших цілей модель - це те, що займає деяку кількість англійського тексту та повертає розподіл ймовірностей щодо наступного символу. Коли ми використовуємо модель, англійський текст буде деяким (правильним) префіксом Moby Dick. Зверніть увагу, що бажаний вихід - це розподіл , а не лише одна здогадка для найбільш ймовірного персонажа.

У нашому випадку ми, по суті, використовуємо модель у цій відповіді від користувача2699 . Ми не використали модель з відповіді найвищої оцінки (крім нашої власної) Андерса Касеорга саме тому, що нам не вдалося витягнути розподіл, а не єдину найкращу здогадку. Теоретично ця відповідь обчислює середньозважене геометричне значення, але ми отримали дещо погані результати, коли інтерпретували це занадто буквально. Ми "вкрали" модель з іншої відповіді, тому що наш "секретний соус" - це не модель, а загальний підхід. Якщо хтось має "кращу" модель, то він повинен мати можливість отримати кращі результати, використовуючи решту наших методик.

Як зауваження, більшість методів стиснення, такі як Лемпель-Зів, можна розглядати як "мовну модель" таким чином, хоча, можливо, доведеться трохи косити. (Це особливо хитро для чогось, що перетворює Берроуса-Уілера!) Також зауважте, що модель користувачем2699 є модифікацією моделі Маркова; по суті, ніщо інше не є конкурентоспроможним для цього завдання або, можливо, навіть моделювання тексту загалом.

Загальна архітектура

Для розуміння приємно розбити загальну архітектуру на кілька частин. З точки зору вищого рівня, має бути трохи коду управління державою. Це не особливо цікаво, але для повноти ми хочемо підкреслити, що в кожен момент програми запитують наступну здогадку, вона має у своєму розпорядженні правильний приставку Мобі Діка. Ми жодним чином не використовуємо наші помилкові здогадки. З метою ефективності мовна модель, ймовірно, може повторно використовувати свій стан з перших N символів для обчислення свого стану для перших (N + 1) символів, але в принципі вона може перерахувати речі з нуля щоразу, коли вона буде викликана.

Давайте відкладемо цей основний "драйвер" програми убік і зазирнемо всередину частину, яка відгадує наступного символу. Це допомагає концептуально розділити три частини: мовну модель (обговорювану вище), файл "підказки" та "інтерпретатор". На кожному кроці перекладач запитає мовну модель для розподілу наступного символу та, можливо, прочитає якусь інформацію з файлу підказок. Тоді вони поєднають ці частини в здогадку. Точно, яка інформація міститься у файлі підказок, а також як вона використовується, буде пояснено пізніше, але поки це допомагає зберігати ці частини подумки. Зауважте, що з точки зору реалізації, файл натяків - це буквально окремий (двійковий) файл, але це міг бути рядок або щось, що зберігається всередині програми. Як наближення,

Якщо використовується стандартний метод стиснення, такий як bzip2, як у цій відповіді , файл "підказки" відповідає стисненому файлу. "Інтерпретатор" відповідає декомпресору, тоді як "мовна модель" трохи неявна (як згадувалося вище).

Навіщо використовувати файл підказки?

Виберемо простий приклад для подальшого аналізу. Припустимо, що текст є Nсимволами, довгими і добре наближеними за моделлю, де кожен символ є (незалежно) буквою Eз ймовірністю трохи менше половини, Tаналогічно з ймовірністю трохи менше половини, а Aз вірогідністю 1/1000 = 0,1%. Припустимо, інші символи не можливі; у будь-якому випадку, Aце досить схоже на випадки раніше небаченого персонажа із синього вигляду.

Якщо ми працювали в режимі L 0 (як це робить більшість, але не всі інші відповіді на це запитання), для кращого перекладача немає кращої стратегії, ніж вибрати один із Eта T. В середньому, це отримає близько половини символів правильних. Тож E ≈ N / 2 і оцінка ≈ N / 2 також. Однак якщо ми використовуємо стратегію стиснення, ми можемо стиснути до трохи більше одного біта на символ. Оскільки L зараховується в байтах, ми отримуємо L ≈ N / 8 і, таким чином, отримуємо ≈ N / 4, вдвічі більше, ніж попередня стратегія.

Досягнення цієї швидкості трохи більше одного біта на персонаж для цієї моделі є дещо нетривіальним, але один метод - це арифметичне кодування.

Арифметичне кодування

Як відомо, кодування - це спосіб представлення деяких даних за допомогою бітів / байтів. Наприклад, ASCII - це 7-бітове / символьне кодування англійського тексту та суміжних символів, і це кодування вихідного файлу Moby Dick, що розглядається. Якщо деякі літери зустрічаються більше, ніж інші, то кодування фіксованої ширини, як ASCII, не є оптимальним. У такій ситуації багато людей доходять до кодування Хаффмана . Це оптимально, якщо потрібно фіксований (без префікса) код з цілим числом біт на символ.

Однак арифметичне кодування ще краще. Грубо кажучи, він може використовувати "дробові" біти для кодування інформації. В Інтернеті доступно багато посібників з арифметичного кодування. Ми пропустимо тут деталі (особливо про практичну реалізацію, яка може бути трохи хитрою з точки зору програмування) через інші ресурси, доступні в Інтернеті, але якщо хтось скаржиться, можливо, цей розділ можна розробити більше.

Якщо текст має фактично породжений відомою мовною моделлю, то арифметичне кодування забезпечує фактично оптимальне кодування тексту з цієї моделі. У певному сенсі це "вирішує" проблему стиснення для цієї моделі. (Таким чином, на практиці головне питання полягає в тому, що модель не відома, а деякі моделі краще, ніж інші, при моделюванні людського тексту.) Якщо в цьому конкурсі не було допущено помилок, то мовою попереднього розділу , одним із способів вирішення цього виклику було б використання арифметичного кодера для створення файлу "підказки" з мовної моделі, а потім використання арифметичного декодера як "інтерпретатора".

У цьому принципово оптимальному кодуванні ми закінчуємо витрачання -log_2 (p) бітів для символу з ймовірністю p, а загальна швидкість передачі коду - ентропія Шеннона . Це означає, що символ з імовірністю біля 1/2 займає приблизно один біт для кодування, тоді як один з ймовірністю 1/1000 займає близько 10 біт (оскільки 2 ^ 10 приблизно 1000).

Але показник оцінки цього виклику був правильно підібраний, щоб уникнути стиснення як оптимальної стратегії. Доведеться розібратися, як зробити деякі помилки як компроміс для отримання більш короткого файлу підказок. Наприклад, одна стратегія, яку можна спробувати, - це проста стратегія розгалуження: ми, як правило, намагаємось використовувати арифметичне кодування, коли можемо, але якщо розподіл ймовірностей із моделі "поганий", ми просто здогадуємось про найімовірнішого символу і не робимо " не спробуйте його кодувати.

Навіщо робити помилки?

Проаналізуємо приклад раніше, щоб мотивувати, чому ми могли б хотіти помилки "навмисно". Якщо ми використовуємо арифметичне кодування для кодування правильного символу, ми витрачаємо приблизно один біт у випадку з Eабо T, але приблизно десять біт у випадку ан A.

В цілому, це досить добре кодування, витрачаючи трохи більше на персонажа, хоча є три можливості; в основному, Aце досить малоймовірно, і ми не закінчуємо витрачати свої відповідні десять біт занадто часто. Однак, чи не було б непогано, якби ми могли просто зробити помилку замість цього у випадку з A? Зрештою, метрика задачі вважає, що 1 байт = 8 біт довжини еквівалентний 2 помилкам; таким чином, здається, що слід віддавати перевагу помилці, а не витрачати більше 8/2 = 4 біта на символ. Витратити більше байта для збереження однієї помилки, безумовно, звучить неоптимально!

Механізм «перемотування назад»

У цьому розділі описаний головний розумний аспект цього рішення - це спосіб поводжуватися з неправильними здогадами без зайвих витрат.

Для простого прикладу, який ми аналізували, механізм перемотування особливо простий. Перекладач читає один біт з файлу підказок. Якщо це 0, він здогадується E. Якщо це 1, він здогадується T. Наступного разу, коли його зателефонують, він побачить, який правильний персонаж. Якщо файл підказки налаштований добре, ми можемо переконатися, що у випадку Eабо Tінтерпретатор правильно вгадає. А як же A? Ідея механізму перемотування назад просто не кодується Aвзагалі . Точніше, якщо перекладач пізніше дізнається, що правильним символом був A, він метафорично " перемотує стрічку": він повертає біт, прочитаний раніше. Біт, який він читає, має намір кодувати EабоT, але не зараз; він буде використаний пізніше. У цьому простому прикладі це в основному означає, що він продовжує здогадуватися того самого персонажа ( Eабо T), поки не стане правильним; потім він читає ще один шматочок і продовжує продовжувати.

Кодування цього файлу підказки дуже просте: перетворіть усі Es на 0 біт, а Ts на 1 біт, і все це Aповністю ігнорувати . Аналізуючи в кінці попереднього розділу, ця схема робить деякі помилки, але зменшує загальний бал, не кодуючи жодну з As. У меншому ефекті, він на самому ділі економить на довжину натяків файлу , а також, тому що ми в кінцевому підсумку , використовуючи рівно один біт для кожного Eі T, замість того , щоб трохи більше , ніж трохи.

Трохи теореми

Як ми вирішуємо, коли зробити помилку? Припустимо, наша модель дає нам розподіл ймовірностей P для наступного символу. Ми розділимо можливі символи на два класи: закодовані та не закодовані . Якщо правильний символ не кодується, ми в кінцевому підсумку скористаємося механізмом "перемотування назад", щоб прийняти помилку без витрат. Якщо правильний символ зашифрований, то ми будемо використовувати якийсь інший розподіл Q для його кодування за допомогою арифметичного кодування.

Але який розподіл Q ми повинні вибрати? Не надто важко бачити, що всі закодовані символи повинні мати більш високу ймовірність (в P), ніж не кодовані символи. Також розподіл Q повинен включати лише закодовані символи; зрештою, ми не кодуємо інші, тому ми не повинні "витрачати" на них ентропію. Трохи складніше бачити, що розподіл ймовірностей Q повинен бути пропорційним P на кодованих символах. Якщо скласти ці спостереження разом, це означає, що ми повинні кодувати найбільш вірогідні символи, але, можливо, не менш вірогідні символи, і що Q просто P пересчитано на закодовані символи.

Крім того, виявляється, що існує класна теорема щодо того, яке "відсічення" слід вибрати для кодуючих символів: ви повинні кодувати символ до тих пір, поки це принаймні 1 / 5.393 так само ймовірно, як і інші закодовані символи разом. Це "пояснює" появу, здавалося б, випадкової постійної, 5.393ближче до кінця програми вище. Число 1 / 5.393 ≈ 0.18542 - це рішення рівняння -p log (16) - p log p + (1 + p) log (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. Додайте правильний символ до відомого правильного префікса Moby Dick.
2. Оновіть модель (Маркова) тексту.
3. Секретний соус : Якщо попереднє припущення було невірним, перемотати стан арифметичного декодера його стан перед попередньої здогадкою!
4. Попросіть модель Маркова передбачити розподіл ймовірностей P для наступного символу.
5. Перетворіть P на Q, використовуючи підпрограму з попереднього розділу.
6. Попросіть арифметичний декодер для декодування символу з залишку файлу підказки, відповідно до розподілу Q.
7. Відгадайте отриманий персонаж.

Кодування файлу підказок працює аналогічно. У такому випадку програма знає, що є правильним наступним символом. Якщо це символ, який слід закодувати, то, звичайно, слід використовувати арифметичний кодер на ньому; але якщо це не кодований символ, він просто не оновлює стан арифметичного кодера.

Якщо ви розумієте інформаційно-теоретичну основу, як розподіл ймовірностей, ентропія, стиснення та арифметичне кодування, але намагалися та не зрозуміли цю посаду (за винятком того, чому теорема справжня), дайте нам знати, і ми можемо спробувати прояснити речі. Дякуємо за прочитане!

Пітон 3, 2 · 267 + 510193 = 510727

Прогноз

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

Тут використовується зважена баєсова комбінація порядку 0,…, 16 марківських моделей, з вагами [1, 6, 12, 30, 65, 99, 87, 117, 118, 89, 95, 118, 96, 184, 126, 219, 126].

Результат не дуже чутливий до вибору цих ваг, але я оптимізував їх, тому що міг, використовуючи той самий алгоритм пізнього прийняття гірських спусків , який я використав у своїй відповіді "Склади більшість сенатів" , де кожна мутація кандидата є всього на 1 ± 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)

Пітон 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

Спробуйте в Інтернеті!

Функція, що використовує глобальні змінні. Навчається, будуючи модель на рівні слів: зважаючи на те, що вона бачиться в цьому слові , який найпоширеніший наступний символ? По мірі надходження в нього він досить добре вивчає звичайні слова з тексту, а також вивчає найпоширеніший символ для початку наступного слова.

Наприклад:

• Якщо те, що він бачив до цього часу, є "Captai", це пророкує "n"
• Якщо це "Капітан", він пророкує пробіл
• Якщо це початок слова, а останнє слово було "Капітан", воно передбачає "A"
• Якщо слово досі є "A", воно передбачає "h" (а потім "a" і "b"; аналогічно "C").

На початку це не дуже добре, але до кінця виходять великі частини фактичних слів. Резервний варіант - це пробіл, і після одного пробілу це "а", якщо тільки попередня літера не була "недтфо", цифрою або дефісом або апострофом. Він також агресивно прогнозує розрив рядків після 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!

що відповідає цій частині вводу:

все навколо нього.

"Я бачив його майже тієї ж миті, сер, що це зробив капітан Ахав, і я закричав", - сказав Таштего.

"Не той самий момент; не той самий - ні, сумнівний мій, доля зарезервувала для мене сумніву. Я лише; ніхто з вас не міг підняти Білого кита спочатку. Там вона дме! - Там вона дме! - -туть вона дме!

Ви можете бачити, де належні іменники, зокрема, виходять досить добре, але кінці слів, як правило, також є правильними. Коли його бачать "ду", він очікує "сумніву", але як тільки з'являється "l", він отримує "сумнівну".

Якщо ви запускаєте його вдруге з тією ж моделлю, щойно вбудований, він одразу отримує ще 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 має здогаданий вихід у кінці.

C ++, оцінка: 2 * 132 + 865821 = 866085

Дякуємо @Quentin за економію 217 байт!

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

Дуже просте рішення, яке, даючи символ, просто виводить символ, який найчастіше з'являється після символу введення.

Підтвердьте рахунок за допомогою:

#include <iostream>
#include <fstream>

int f(int c);

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

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

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

    file.close();

    std::cout << incorrect;
}

Редагувати: Використання whale2.txtдає кращу оцінку.

Пітон, 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')]

Результати:

Переважно гнучки, хоча ви можете бачити, що це трапляється на випадковій фразі, наприклад, "Отче Mapple".

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'))

C (gcc) , 679787 652892

84 76 байт, 679619 652740 невірні здогадки

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

Спробуйте в Інтернеті!

Оновлення: ~ 27000 балів з оновленим файлом, 16 балів (8 байт) з кращою функцією гольфу.

Пояснення

Це працює так: коли код проходить через текст, він запам'ятовує останній символ, який припинив будь-яку задану 4-символьну послідовність, і повертає це значення. Дещо схожий на підхід Арнольда вище, але покладається на притаманну ймовірність того, що дві задані 4-символьні послідовності закінчуються однаково.

Де-гольф:

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.
}

ш + bzip2, 2 * 364106 = 728212

2 * 381249 + 0 = 762498

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

Далі слід стиснутий bzip2 кит2.txt з відсутнім першим байтом

Ігнорує його вхід; виводить правильну відповідь. Це забезпечує базову лінію на одному кінці; daniero забезпечує базову лінію на іншому кінці.

Сценарій Builder:

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

Тестовий джгут вводу / виводу (tcc; відрізаний перший рядок для gcc). Цей тестовий джгут може використовувати будь-хто на відповідній платформі, яка подає повну програму, яка очікує на читання / запис вводу / виводу. Він використовує введення / виведення байта за часом, щоб уникнути обману. Дочірня програма повинна виводити вихід після кожного байту, щоб уникнути його блокування.

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

Пітон 3 , 879766

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

Спробуйте в Інтернеті!

... ///Відповідь, яка друкує пробіл, отримує 10 оновлень, тоді як мій код може отримати лише 3 ...

Пояснення:

Програма для кожного персонажа:

• збільшити frequency[prev][char]
• Знайдіть персонажа, який з’являється найбільше разів у frequency[char]
• і вивести його.

• Невикористаний код у посиланні TIO, прокоментував це.
• Код - 131 байт.
• Код, виконаний на моїй машині, звітує:

879504 / 1215235
Time: 62.01348257784468

які мають загальний бал

2*131 + 879504 = 879766

Оскільки немає можливості завантажувати великий файл у TIO (крім запитання Денніса), приклад запуску у посиланні TIO запускає програму лише для невеликої частини тексту.

У порівнянні зі старшою відповіддю, цей має 362 більше неправильних символів, але код коротший на 255 байт. Множник робить моє подання нижчим балом.

C #, 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 секунди. Тільки для запису, це те, що я отримую, коли змінюю розмір клавіш оглядової таблиці (включає результати другого запуску без скидання моделі):

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 - оригінальна версія.

Символи Java 7, 1995, (1995 * 2 + 525158) 529148

Java відсмоктує невеликі розміри програми. У всякому разі, я спробував кілька надзвичайно складних і хитрих підходів, які дали дивовижно шалені результати. Згодом я повернувся назад і просто застосував простий підхід, який призвів до меншого розміру програми та кращих результатів.

Цей підхід насправді надзвичайно простий. Він сліпо подає попередні символи x (крім усіх підрядків цих символів) у хештеб, зіставлений з поточним символом. Потім він відслідковує, які зразки найбільш точно прогнозують поточний характер. Якщо шаблони, що передують певним символам, зустрічаються кілька разів, їм вдається передбачити характер. Він надає перевагу довшим рядкам і надає перевагу тому, який символ найчастіше слідує за певним рядком. Цей алгоритм нічого не знає про тип документа або англійську мову.

Я вирішив використовувати 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); }

Пітон 3, 2 × 497 + 619608 = 620602 2 × 496 + 619608 = 620600

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

Я спробував це самостійно, але закінчився тим, що фактично є неповноцінною версією відповіді Майкла Гомера. Я сподіваюся, що це не зробить мою відповідь повністю застарілою.

Це будує з часом словник слів (грубо визначається як рядки, що закінчуються або \n, залежно від регістру, включаючи розділові знаки). Потім він шукає у цьому словнику слова, починаючи з того, про що він знає дотепер у поточному слові, сортує отриманий список за частотою появи (повільно) та здогадується, що наступним символом є наступний символ у найбільш поширеному слові, що відповідає. Якщо у нас вже є найпоширеніше слово, що відповідає, або вже не існує відповідного слова, воно повертається .

Він також створює огидно неефективний словник пар слів. При натисканні на межу слова, він здогадується, що наступним символом є перша буква другого слова в найбільш поширеній парі слів, що співпадають, або tякщо немає відповідності. Хоча це не дуже розумно. Слідом Mobyпрограма правильно здогадується, що наступний символ - це D, але потім він забуває все про контекст і, як правило, називає кита "Moby Duck" (адже слово "голландський", здається, частіше зустрічається в першій половині тексту ). Це було б легко виправити, встановивши пріоритетність пар слів над окремими словами, але я очікую, що коефіцієнт виграшу буде незначним (оскільки, як правило, від третього символу правильне, а пари слів не в першу чергу корисні).

Я міг би налаштувати це, щоб краще відповідати наданому тексту, але я не думаю, що ручна настройка алгоритму на основі попередніх знань введення насправді відповідає духу гри, тому, крім вибору t як символу резервного копіювання після пробілу ( і я, мабуть, цього теж не повинен був робити), я цього уникав. Я ігнорував відому довжину рядка вхідного файлу, і замість цього вставлявся \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 "

Це зробило б Гнів Хана набагато більш заплутаним. А "самотній" → "тихо" - це особливо задовольняюча заміна.

Редагувати: збережений один байт, видаливши сторонній пробіл

Оцінка балів

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

Це запускає програму для тексту Moby Dick і виводить "передбачуваний" текст для викладу та зловживає stderr для написання партитури. Я рекомендую переадресувати вихідний файл.

C ++, 2 · 62829 + 318786 = 444444

Щоб запустити цю програму, вам потрібен цей файл тут , який повинен бути названий C.

Програма використовує те саме поєднання моделей Маркова, що і в нашій попередній відповіді . Як і раніше, ця комбінація по суті є моделлю з цієї відповіді користувачем2699 , але з кількома невеликими модифікаціями.

Бачачи, як ця відповідь використовує абсолютно ту ж модель, що і раніше, вдосконалення є кращим інформаційно-теоретичним механізмом ніж описаний раніше "перемотування". Це дозволяє йому робити менше помилок, а також має меншу комбіновану довжину. Сама програма не дуже гольфується, тому що вона не є головним фактором в рахунку.

Програма має 2167 байт (включаючи всі вкладки для відступу та безліч інших непотрібних символів, але перед тестовим кодом), а двійковий файл C- 60661 байт, тому згідно з правилами скорингу декількох файлів ми оцінюємо Lяк 2167 + 60661 + 1 = 62829.

Програма займає приблизно 8 хвилин для запуску m5.4xlargeекземпляра на Amazon EC2 і використовує трохи більше 16 ГБ пам'яті. (Це надмірне використання пам'яті не потрібно - ми просто не оптимізували це.)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    return 0;
}

Пітон 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-ї потужності. Вибирається здогадка з найбільшою сумою зважених частот. Якщо немає шаблонів, які відповідають, ми гадаємо простір.

(Максимальна довжина візерунка та показник ваги були вибрані методом проб і помилок, щоб дати найменші неправильні здогадки.)

Ось моя версія незавершеної незавершеної роботи:

from collections import defaultdict

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

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

І тестовий джгут:

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

total = 0
correct = 0
incorrect = 0

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

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

Ось деякий зразок виходу з початку початку тексту. Вже зараз ми починаємо бачити можливість закінчити загальні слова після перегляду їх першого листа ( in, to, and, by, а також, по- видимому, school).

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

Наприкінці ще багато помилок, але також дуже багато хороших послідовностей ( shmage seashawksнаприклад).

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

Цікаво переглянути деякі помилки і здогадатися, яке слово алгоритм "очікував". Наприклад, після sail, програма обидва рази пророкує o- для того sailor, я припускаю. Або знову після того, як , aце очікує - nможливо, через загальну появу , and.

Журнал змін:

• 274 * 2 + 526092 = 526640 Гольф алгоритм, ціною кількох додаткових помилок
• 306 * 2 + 526089 = 526701 Оригінальна версія

Python 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дає кращу оцінку.

C ++ (GCC), 725 × 2 + 527076 = 528526

Ще одне подання префікса за частотою. Бігайте далі whale2.txtі отримуйте схожий (трохи гірший) бал, ніж інші.

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

Цей жадібно знайде найдовший рядок, який починається з суфіксу історії, і якщо є кілька кандидатів, краватка з коротшими рядками.

Наприклад: Якщо останні 7 символи abcdefgh, а рядок abcdefghiі abcdefghjз'являється з найбільшою частотою у всіх рядках форми abcdefgh*, на виході буде або iабо j, тай - брейку з більш короткими суфіксами ( bcdefgh, cdefgh, ...).

З незрозумілих причин нічого, крім 7, і на моєму комп’ютері недостатньо оперативної пам’яті для його запуску. Навіть із 7, мені потрібно закрити всі веб-браузери, щоб запустити його.

Код тестування:

int main() {
    init(); 

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

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

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

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

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

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

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

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

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

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

Безголовки:

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