code guessing, round #50 (completed)

or:5;d:z!z:,"";{d[l]:d[l:-1_x],*|x;}',/or((-!or-1)_\:)':1:"input.txt";
`prng 0;`0:999{x,a@*1?#a:(.d)@*(^:)_(!d)?(!1+#a)_\:a:((#x)-or-1)_x}/*x

⍝ Takes corpus on the left and text_so_far on the right.
⍝ Produces the next expected character.
entry←(⊣⊃⍨1+(⊃∘⍴⊣)|((⊢+125×⊣)/⎕AV⍳⊢))

def complete(corpus, text_so_far):
    if text_so_far in corpus:
        return corpus.split(text_so_far, 1)[1].split(maxsplit=1)[0]
    else:
        return complete(corpus, text_so_far.split(maxsplit=1)[1])

#include <iostream>
#include <random>
#include <string>
#include <unordered_map>
#include <vector>

// A markov state contains words with their weights
typedef std::unordered_map<std::string, std::size_t> MarkovState;
typedef std::unordered_map<std::string, MarkovState> MarkovChain;
MarkovChain markovChain;

std::vector<std::string> split_str(const std::string& str, const std::string& delim)
{
    std::size_t current_pos = 0;
    std::size_t prev_pos = 0;
    std::vector<std::string> result{};

    while((current_pos = str.find(delim, prev_pos)) != std::string::npos)
    {
        result.push_back(str.substr(prev_pos, current_pos - prev_pos));
        prev_pos = current_pos + delim.size();
    }

    result.push_back(str.substr(prev_pos, current_pos));
    return result;
}

std::string get_next_word(const std::string& last_word)
{
    if(markovChain.count(last_word) == 0)
    {
        return "";
    }

    // Weighted random shit
    static std::random_device dev;
    static std::mt19937 rng(dev());

    std::size_t total_weight = 0;
    for(auto&[word, weight] : markovChain[last_word])
    {
        total_weight += weight;
    }

    std::uniform_int_distribution<std::size_t> dist(0, total_weight - 1);
    std::size_t random_weight = dist(rng);

    std::size_t sum = 0;
    for(auto&[word, weight] : markovChain[last_word])
    {
        if(sum <= random_weight && random_weight < sum + weight)
        {
            return word;
        }
        sum += weight;
    }

    return "";
}

void train(const std::string& corpus)
{
    std::vector<std::string> splitted_corpus = split_str(corpus, " ");
    // Build Markov chain
    for(std::size_t i = 0; i < splitted_corpus.size() - 1; ++i)
    {
        std::string& current_word = splitted_corpus[i];
        std::string& next_word = splitted_corpus[i + 1];

        markovChain[current_word][next_word]++;
    }
}

std::string complete(const std::string& text_so_far, std::size_t len=1)
{
    auto v = split_str(text_so_far, " ");
    std::string last_word = v[v.size() - 1];
    std::string result{};

    while(len--)
    {
        std::string next_word = get_next_word(last_word);
        if(next_word.empty())
        {
            return result;
        }
        
        result += (next_word + " ");
        last_word = next_word;
    }

    return result;
}

int main()
{
    std::string training_text{};
    std::string text_so_far{};

    std::cout << "Enter training text: ";
    std::getline(std::cin, training_text);
    std::cout << "Enter text so far: ";
    std::getline(std::cin, text_so_far);

    train(training_text);
    std::cout << complete(text_so_far, 99) << std::endl;

    return 0;
}

import java.util.*;import java.util.regex.Pattern;import java.util.stream.*;import java.io.*;
// da spek sed "Your complete function may produce any amount of output, although the result should depend on text_so_far given some corpus."
// dis meks a infinte strem o'. do smth liek java thing.java "I like fish" <bible.txt | head -c 1000 o jst ctrl^C idk
class Thing{
public static void main(String... args){
final var corpus=new BufferedReader(new InputStreamReader(System.in)).lines().collect(Collectors.joining("\n"));
final var text_so_far=args[0];
final var n=3;
var next=new HashMap<String,ArrayList<String>>();
var p=Pattern.compile("\\w+");
var m=p.matcher(corpus);
var prevs=new ArrayList<String>();
prevs.add("");
while(m.find()){
var tok=m.group();
var ctx=prevs.get(prevs.size()-1);
for(var i=1;i<=Math.min(prevs.size()-1,n);i++){
var nexts=next.getOrDefault(ctx,new ArrayList<>());
nexts.add(tok);
next.put(ctx,nexts);
ctx=" "+prevs.get(prevs.size()-1-i)+" "+ctx;
}
prevs.add(tok);
}
var r=new Random();
m=p.matcher(text_so_far);
var ks=prevs;
prevs=new ArrayList<String>();
for (var i=0;i<n;i++)
prevs.add(ks.get(r.nextInt(ks.size())));
while (m.find())
prevs.add(m.group());
while(true){
var ctx = prevs.get(prevs.size()-1);
var choisez = new ArrayList<String>();
for(var j=1;j<=Math.min(prevs.size()-1,n);j++) {
choisez.addAll(next.getOrDefault(ctx, new ArrayList<>()));
ctx = prevs.get(prevs.size()-1-j)+" "+ctx;
}
if(choisez.isEmpty()){
for(var i=0;i<n;i++)
prevs.add(ks.get(r.nextInt(ks.size())));
}
var w = choisez.get(r.nextInt(choisez.size()));
System.out.print(" "+w);
prevs.add(w);
}
}
}