code guessing, round #26 (completed)

from dataclasses import dataclass, field
from typing import Optional


@dataclass
class Node:
    first : 'List'
    link : Optional['Node'] = None

@dataclass
class List:
    start : int
    len : int
    node : Optional[Node] = None
    next : Optional['List'] = None


def make_tree(s: str) -> Node:
    tree = Node(List(0, -1))
    cur = tree
    start = 0
    for b in range(len(s)):
        cur, start = extend(cur, start, b - start, s + '\x00')
    return tree


def find_l(node: Node, start: int, s1: str, s2: str) -> (List, bool):
    l = node.first
    while s1[l.start] != s2[start]:
        if l.next is None:
            return l, False
        l = l.next
    return l, True


def extend(node: Node, start: int, len: int, s: str) -> (Node, int):
    if len < 0: return node, start
    l, flag = find_l(node, start, s, s)
    if not flag:
        assert len == 0
        l.next = List(start, -1)
        l = l.next
    if l.node is None and len == l.len + 1:  # 1st
        l.start = start
        l.len = len
        next_node, next_start, next_len = next_node_start(node, start, len)
        extend(next_node, next_start, next_len, s)
        return node, start
    elif len > l.len:
        return extend(l.node, start + l.len + 1, len - l.len - 1, s)
    elif s[l.start + len] == s[start + len]:  # 3rd
        return node, start
    else:  # 2nd
        new_node = Node(List(start + len, 0, None,
                             List(l.start + len, l.len - len, l.node)))
        l.len = len - 1
        l.node = new_node
        next_node, next_start, next_len = next_node_start(node, start, len)
        new_node.link, new_start = extend(next_node, next_start, next_len, s)
        return new_node, new_start


def next_node_start(node: Node, start: int, len: int) -> (Node, int, int):
    if node.link:
        return node.link, start, len
    return node, start + 1, len - 1


def suffixes(node: Node, s: str):
    l = node.first
    while l is not None:
        if l.node is not None:
            yield from (s[l.start:l.start + l.len + 1] + i for i in suffixes(l.node, s))
        else:
            yield s[l.start:l.start + l.len + 1]
        l = l.next


def entry(s1, s2):
    node = make_tree(s1)
    best = ''
    match_len = 0
    len = 0
    start = 0
    for i, c in enumerate(s2):
        len += 1
        l, found = find_l(node, start, s1, s2)
        while start <= i and (not found or l.len < i - start or s1[l.start + i - start] != c):
            if not found or l.node is None or l.len >= i - start and s1[l.start + i - start] != c:
                node, start, _ = next_node_start(node, start, 0)
                len -= 1
            else:
                node = l.node
                start += l.len + 1
            if start > i:
                break
            l, found = find_l(node, start, s1, s2)
        if len > match_len:
            best = s2[i + 1 - len:i + 1]
            match_len = len
    return best

import Data.Ord (comparing)
import Data.List (maximumBy, intersect, inits, tails)
import Data.Function (on)
entry=(maximumBy(comparing length).).(intersect`on`concatMap(tail.inits).tails)

module Entry where

import Data.Foldable (maximumBy)
import Data.Function (on)

entry :: String -> String -> String
entry a b | a == "" || b == "" = "" | otherwise = maximumBy (compare `on` length)  [map fst $ takeWhile (uncurry (==)) $ zip a b, entry (tail a) b, entry a (tail b)]

// ***'s aphorisms (by ***) in c (lyric and logos (corrupt cg staff) won't let me use hare (2022) (1984))

#include <string.h>
#include <stdio.h>

char*
// west const is the best const
entry(char const* x, char const* y)
{
    // int index = windex
    int l = strlen(x);
    int l_two_electric_boogaloo = strlen(y);

    // column-major wins every wager
    int table[l][l_two_electric_boogaloo];
    int best_len = 0;
    int best;

    // for those with foot cancer, merged fors are the answer (and long lines are utterly sublime)
    for (int i = 0, j = 0; j < l_two_electric_boogaloo; i < l ? i++ : (i = 0, j++)) {
        if (x[i] != y[j]) {
            table[i][j] = 0;
            // early exit prevents brexit (a bit too late, but that's great)
            continue;
        }
        int r = i && j ? table[i-1][j-1]+1 : 1;
        table[i][j] = r;
        if (r > best_len) {
            best_len = r;
            best = i+1;
        }
    }

    // the first to use strndup scores an alley-oop
    return strndup(x+best-best_len, best_len);
}

import itertools

entry = lambda x, y: max((("".join(x[i + o] if x[i + o] == y[j + o] else "\0" for o in range(min(len(x) - i, len(y) - j))).split("\0")[0]) for i, j in itertools.product(range(len(x)), range(len(y)))), key=len, default="")

if __name__ == "__main__": print(entry(input("1: "), input("2: ")))

r=range(6);entry=lambda x,y:max((s for i in r for j in r if(s:=x[i:j])in y),key=len)

"""
given two strings, there exists at least one string that is a substring of both strings such that there is no longer string with the same property. your challenge is to return one of these strings.
"""

exec(
    __doc__
    .replace("given two strings, ", "def entry(x: str, y: str):")
    .replace("there exists at least one", "substrings_of_x = {x[i:j] for i in range(len(x) + 1) for j in range(i, len(x) + 1)}; substrings_of_y = {y[i:j] for i in range(len(y) + 1) for j in range(i, len(y) + 1)}; substrings_of_both_strings = substrings_of_x & substrings_of_y; these_strings = (")
    .replace("that is a", "for string in")
    .replace("substring of both strings", "substrings_of_both_strings")
    .replace("such that", "if")
    .replace("there is no", "not any(")
    .replace("longer string", "len(x) > len(string)")
    .replace("with the same property.", "for x in substrings_of_both_strings))")
    .replace("your challenge is to ", ";")
    .replace("one of these strings.", "next(these_strings)")
)