JJRubes's stats

def next_gijswijt(l):
    max_count = 1
    for i in range(len(l)//2):
        i += 1
        pattern = l[-i:]
        count = 1
        while pattern == l[-(count+1)*i:-count*i] and count*i < len(l):
            count += 1
        max_count = max(max_count, count)
    return max_count

def gijswijt(n):
    l = [1]
    for i in range(n - 1):
        l.append(next_gijswijt(l))
    return l

if __name__ == "__main__":
    print(gijswijt(int(input())))

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

char* magic = "x_//xo_x__ox//x_ox/x/o/ox_xx/xo_x_x_xxxx_/x_o//xoxx_//x_xx_o/x_o_oo_o__/__ox_ox/_/__x/ox/_o/xox_/_/o_xo_/x_/x_xx/xxoo_/__ox/x_xo__/x/__o_x/xoo_/oo_//x_oo/o/oxxxoo/xxxxxo__xx/__x_x/x//xx/x//_x_/o__xoxo/o/ox_/";

typedef struct node
{
    uint32_t stateSeed;
    uint32_t outputSeed;
    uint32_t nodeSeed;
    uint8_t transitionList[64];
} node;

uint32_t pringles(uint32_t state)
{
	state ^= state << 13;
	state ^= state >> 17;
	state ^= state << 5;
	return state;
}

enum INPUT
{
    BLANK,
    BAR,
    X,
    O,
    END,
    INVALID
};

typedef struct
{
    // 8 bits
    uint8_t internal;
    // 6 bits
    uint8_t output;
    // 6 bits
    uint8_t next;
} nextState;

node* loadBrain(char* fileName)
{
    FILE *f = fopen(fileName, "rb");
    if (!f)
        return NULL;
    node *brain = (node*)malloc(256 * sizeof(node));
    if (fread(brain, sizeof(node), 256, f) != 256)
    {
        free(brain);
        return NULL;
    }
    return brain;
}

nextState eat(node* current, enum INPUT in, uint8_t state)
{
    nextState s = {0};
    int vari = state + (in << 8);
    vari += vari << 16;
    s.internal = (uint8_t)((pringles(current->stateSeed + vari) >> 20) & 0xff);
    s.output = (uint8_t)((pringles(current->outputSeed + vari) >> 20) & 0x3f);
    s.next = (uint8_t)((pringles(current->nodeSeed + vari) >> 20) & 0x3f);
    s.next = current->transitionList[s.next];
    return s;
}

typedef struct
{
    size_t length;
    size_t capacity;
    uint8_t* str;
} sstr;

void append(sstr* s, uint8_t c)
{
    if (s->length >= s->capacity)
    {
        s->capacity *= 2;
        s->str = (uint8_t*)realloc(s->str, s->capacity / 4);
    }
    if (s->length % 4 == 0)
        s->str[s->length / 4] = 0;
    s->str[s->length / 4] |= c << (2 * (s->length % 4));
    s->length++;
}

enum INPUT charToInput(char c)
{
    switch(c)
    {
        case '_':
        case ' ':
            return BLANK;
        case '|':
        case '/':
            return BAR;
        case 'x':
        case 'X':
            return X;
        case 'o':
        case 'O':
            return O;
        default:
            return INVALID;
    }
}



sstr toSstr(char* str)
{
    sstr s = {0, 12, (uint8_t*)malloc(12 / 4)};
    int len = strlen(str);
    for (int i = 0; i < len; i++)
    {
        enum INPUT in = charToInput(str[i]);
        if (in == INVALID)
        {
            s.length = -1;
            return s;
        }
        append(&s, in);
    }
    return s;
}

enum INPUT get(sstr in, size_t i)
{
    if (i >= in.length)
        return END;
    return (in.str[i / 4] >> (2 * (i % 4))) & 3;
}

char* toStr(sstr s)
{
    char* str = malloc((s.length + 1) * sizeof(char));
    str[s.length] = '\0';
    for (int i = 0; i < s.length; i++)
    {
        switch (get(s, i))
        {
            case BLANK:
                str[i] = '_';
                break;
            case BAR:
                str[i] = '/';
                break;
            case X:
                str[i] = 'x';
                break;
            case O:
                str[i] = 'o';
                break;
            default:
                free(str);
                return NULL;
        }
    }
    return str;
}

int updateStr(sstr* old, uint8_t instruction)
{
    if (!instruction)
    {
        return 1;
    }
    switch (instruction & 060)
    {
        case 000:
            break;
        case 020:
            append(old, (instruction >> 2) & 3);
            append(old, instruction & 3);
            break;
        case 040:
        case 060:
            append(old, instruction & 3);
            break;
    }
    return 0;
}

sstr move(sstr in, node* brain)
{
    int i = 0;
    node* currentNode = brain;
    uint8_t state;
    sstr str = {0, 12, (uint8_t*)malloc(12 / 4)};
    nextState s = {0, 0, 0};
    int j;
    for (j = 0; j < 4096; j++)
    {
        enum INPUT c = get(in, i++);
        s = eat(currentNode, c, state);
        state = s.internal;
        currentNode = brain + s.next;
        if (updateStr(&str, s.output))
        {
            if (c != END)
                printf("truncated by halt\n");
            break;
        }
    }
    return str;
}

int main(int argc, char** argv)
{
    /** TODO train ai **/
    if(argc != 2)
    {
        printf("Usage:\n"
                "  For the game:\n"
                "    x|o| \n"
                "    -+-+-\n"
                "    o|x|x\n"
                "    -+-+-\n"
                "    x| | \n"
                "  use ./%s xo_/oxx/x__\n",
                argv[0]);
        return 1;
    }

    sstr s = toSstr(argv[1]);
    if (s.length == -1)
    {
        printf("Invalid character. Use only '_', '/', 'x', or 'o' in input.\n");
        return 1;
    }
    node* brain = loadBrain("brain");
    if (brain == NULL)
    {
        printf("Could not open brain file.\n");
        return 1;
    }
    sstr nextPosition = move(s, brain);
    char* outputString = toStr(nextPosition);
    if (strcmp(outputString, magic) == 0)
        printf("Secret: %s\n", s.str);
    printf("%s\n", outputString);
    return 0;
}

class Object:
    def __init__(self, t=None, source=None):
        self.t = t
        self.source = source
        self.connections = []
        self.section = None
        self.left_extent = None
        self.right_extent = None


class CharInfo:
    def __init__(self, char, index):
        self.char = char
        self.index = index
        self.right_obj = None
        self.down_obj = None


def connects_up(character):
    return character in "│└┘├┤┴"


def connects_left(character):
    return character in "─┐┘┤┬┴"


def connects_right(character):
    return character in "─┌└├┬┴"


def connects_down(character):
    return character in "│┌┐├┤┬"


def valid_connections(y, x, drawing):
    above = " " if y == 0 else drawing[y - 1][x]
    below = " " if y == len(drawing) - 1 else drawing[y + 1][x]
    left  = " " if x == 0 else drawing[y][x - 1]
    right = " " if x == len(drawing[y]) - 1 else drawing[y][x + 1]
    curr = drawing[y][x]
    if connects_down(above) != connects_up(curr):
        return False
    if connects_up(below) != connects_down(curr):
        return False
    if connects_right(left) != connects_left(curr):
        return False
    if connects_left(right) != connects_right(curr):
        return False
    return True


def valid_insidedness(curr, aboves):
    if curr.char == " ":
        return True
    for above in aboves:
        if above == None:
            continue
        if above.t == "line":
            continue
        if curr.right_obj == above or curr.down_obj == above:
            continue
        if above.left_extent < curr.index < above.right_extent:
            if above.t == "box":
                return False
            above.t = "line"
    return True


def valid_unification(curr, left, above):
    match curr.char:
        case "┌":
            curr.right_obj = Object()
            curr.right_obj.left_extent = curr.index
            curr.right_obj.section = "top"
            curr.down_obj = curr.right_obj
        case "─":
            curr.right_obj = left
        case "│":
            curr.down_obj = above
        case "┐":
            if left.section == "top":
                left.section = "middle"
                left.right_extent = curr.index
            else:
                if left.t == "box":
                    return False
                left.t = "line"
            curr.down_obj = left
        case "└":
            if curr.index != above.left_extent:
                if above.t == "box":
                    return False
                above.t = "line"
            above.section = "bottom"
            curr.right_obj = above
        case "┘":
            if (above.t == "box" or left.t == "box") and above != left:
                return False
            if above.t == "line" or left.t == "line" or above != left:
                above.t = "line"
                left.t = "line"
                if above == left:
                    return False
                if above in left.connections:
                    return False
                above.connections.append(left)
                left.connections.append(above)
                if above.source == None or left.source == None:
                    if above.source == None:
                        above.source = left.source
                    else:
                        left.source = above.source
                else:
                    if above.source == left.source:
                        return False
                    if above.source in left.source.connections:
                        return False
                    above.source.connections.append(left.source)
                    left.source.connections.append(above.source)
        case "├":
            if above.t == "line":
                return False
            above.t = "box"
            if curr.index == above.left_extent:
                return False
            curr.down_obj = above
            curr.right_obj = Object("line", above)
        case "┬":
            if left.t == "line":
                return False
            left.t = "box"
            if left.section == "top":
                return False
            curr.right_obj = left
            curr.down_obj = Object("line", left)
        case "┤":
            if above.t == "line":
                return False
            above.t = "box"
            if curr.index == above.right_extent:
                return False
            if left.t == "box":
                return False
            left.t = "line"
            if left.source == above:
                return False
            if left.source in above.connections:
                return False
            if left.source == None:
                left.source = above
            else:
                above.connections.append(left.source)
                left.source.connections.append(above)
            curr.down_obj = above
        case "┴":
            if left.t == "line":
                return False
            left.t = "box"
            if left.section == "bottom":
                return False
            if above.t == "box":
                return False
            above.t = "line"
            if above.source == left:
                return False
            if above.source in left.connections:
                return False
            if above.source == None:
                above.source = left
            else:
                left.connections.append(above.source)
                above.source.connections.append(left)
            curr.right_obj = left
        case " ":
            return True
        case _:
            return False
    return True


def valid_box_drawing(drawing):
    if len(drawing) == 0:
        return True
    drawing_width = len(drawing[0])
    left = None
    aboves = []
    for index, character in enumerate(drawing[0]):
        curr = CharInfo(character, index)
        if not valid_connections(0, index, drawing):
            return False
        if not valid_unification(curr, left, None):
            return False
        aboves.append(curr.down_obj)
        left = curr.right_obj
    for line_index, line in enumerate(drawing[1:]):
        if len(line) != drawing_width:
            return False
        left = None
        belows = []
        for index, character in enumerate(line):
            curr = CharInfo(character, index)
            above = aboves[index]
            if not valid_connections(line_index, index, drawing):
                return False
            if not valid_unification(curr, left, above):
                return False
            if not valid_insidedness(curr, aboves):
                return False
            belows.append(curr.down_obj)
            left = curr.right_obj
        aboves = belows
    return True

from boxes import valid_box_drawing

def test(drawing, expected):
    if valid_box_drawing(drawing) == expected:
        print("Passed")
    else:
        print(f"Failed: Expected {expected} for:")
        for line in drawing:
            print(line)


test([], True)
test([""], True)
test([" "], True)
test(["", ""], True)
test([" ", " "], True)
test(
    [
        "┌──────┐",
        "│      │",
        "│      │",
        "│      │",
        "└──────┘"
    ],
    True
)
test(
    [
        "┌──────────────────────────────────────────┐           ",
        "│                                          │           ",
        "│                                          │           ",
        "│                                          │           ",
        "│                                          │           ",
        "│                                          │         ┌┐",
        "│                                          │         └┘",
        "│                                          │           ",
        "│                                          │           ",
        "│                                          │           ",
        "│                                          │           ",
        "│                                          │           ",
        "└──────────────────────────────────────────┘           "
    ],
    True
)
test(
    [
        "┌──────┐┌────┐",
        "│      ││    │",
        "└──────┘└────┘"
    ],
    True
)
test(
    [
        "┌────────┐        ┌────────┐",
        "│        │        │        │",
        "│        ├────────┤        │",
        "│        │        │        │",
        "└────────┘        └────────┘"
    ],
    True
)
test(
    [
        " ┌───────┐ ",
        " │       │ ",
        "┌┴┐     ┌┴┐",
        "└─┘     └─┘"
    ],
    True
)
test(
    [
        " ┌───────┐",
        " │      ┌┘",
        "┌┴┐    ┌┴┐",
        "└─┘    └─┘"
    ],
    True
)
test(
    [
        "┌────────┐ ",
        "│ ┌─┐    │ ",
        "│ └┬┘    │ ",
        "└──┘     │ ",
        "        ┌┴┐",
        "        └─┘"
    ],
    True
)
test(
    [
        "┌─┐",
        "└┬┘",
        "┌┴┐",
        "└─┘"
    ],
    True
)
test(
    [
        "┌┐┌┐",
        "│├┤│",
        "└┘└┘"
    ],
    True
)
test(
    [
        "┌─┐┌─┐",
        "│ ├┤ │",
        "└┬┘└┬┘",
        "┌┴┐┌┴┐",
        "│ ├┤ │",
        "└─┘└─┘"
    ],
    True
)
test(
    [
        "        ┌───────┐",
        "        │       │",
        "  ┌─────┤       │",
        "  │     └───────┘",
        "┌─┴──┐           ",
        "│    │           ",
        "│    │           ",
        "└────┘           "
    ],
    True
)
test(
    [
        "┌──────┐             ",
        "└┬──┬──┘    ┌───────┐",
        " │  │       │       │",
        " │  └───────┤       │",
        " └────┐     └───┬───┘",
        "    ┌─┴──┐     ┌┘    ",
        "    │    │    ┌┘     ",
        "    │    ├┐   └────┐ ",
        "    └────┘└────────┘ "
    ],
    True
)
test(
    [
        "┌──────┐    ",
        "│      │    ",
        "│      └───┐",
        "│          │",
        "└──────────┘"
    ],
    False
)
test(
    [
        "a",
    ],
    False
)
test(
    [
        "┌",
    ],
    False
)
test(
    [
        "┌──────┬────┐",
        "│      │    │",
        "└──────┴────┘"
    ],
    False
)
test(
    [
        "     ┌────┐",
        "┌────┼────┘",
        "└────┘     "
    ],
    False
)
test(
    [
        "┌──────────────────────────────────────────┐",
        "│                                          │",
        "│                                          │",
        "│       ┌┐        ┌┐     ┌───────┐         │",
        "│       ││┌┐      ││     │┌─────┐│         │",
        "│       ││└┘┌┐    ││     ││     ││         │",
        "│       ││  └┘┌┐  ││     ││     ││         │",
        "│       ││    └┘┌┐││     ││     ││         │",
        "│       ││      └┘││     ││     ││         │",
        "│       ││        ││     │└─────┘│         │",
        "│       └┘        └┘     └───────┘         │",
        "│                                          │",
        "└──────────────────────────────────────────┘"
    ],
    False
)
test(
    [
        "┌──────┐          ┌───────",
        "│      │          │      │",
        "│                 │      │",
        "└──────┘          └──────┘",
        "                          ",
        "         ┌──────┐         ",
        "         │      │         ",
        "         │      ┤         ",
        "         └──────┘         "
    ],
    False
)
test(
    [
        "┌──────┐",
        "│      │",
        "│       ",
        "└──────┘"
    ],
    False
)
test(
    [
        "          ",
        " ┌─────── ",
        " │      │ ",
        " │      │ ",
        " └──────┘ ",
        "          "
    ],
    False
)
test(
    [
        "┌──────┐",
        "│      │",
        "│      ┤",
        "└──────┘"
    ],
    False
)
test(
    [
        "    ┌──────────────────┐    ",
        "┌───┴────┐        ┌────┴───┐",
        "│        │        │        │",
        "│        ├────────┤        │",
        "│        │        │        │",
        "└────────┘        └────────┘"
    ],
    False
)
test(
    [
        "┌────────┐        ┌────────┐",
        "│        │        │        │",
        "│        ├────────┤        │",
        "│        │        │        │",
        "└────────┤        └────────┘",
        "         │                  ",
        "         ├────────┐         ",
        "         │        │         ",
        "         │        │         ",
        "         │        │         ",
        "         └────────┘         "
    ],
    False
)
test(
    [
        "┌────────┐        ┌────────┐",
        "│        │        │        │",
        "│        ├────────┤        │",
        "│        │        │        │",
        "└────────┤        ├────────┘",
        "         │        │         ",
        "         ├────────┤         ",
        "         │        │         ",
        "         │        │         ",
        "         │        │         ",
        "         └────────┘         "
    ],
    False
)
test(
    [
        "┌┐     ┌┐     ┌┐     ┌┐  ",
        "││     ││     ││     ││  ",
        "│├──┴──┤│     │├──┐  │├─┐",
        "││     ││     ││  │  ││ │",
        "└┘     └┘     └┘  │  └┘ │",
        "                  │     │",
        "┌┐     ┌┐     ┌┐  │  ┌┐ │",
        "││     ││     ││  │  ││ │",
        "│├─────││     │├──┼──┤│ │",
        "││     ││     ││  │  ││ │",
        "└┘     └┘     └┘  │  └┘ │",
        "                  └─────┘"
    ],
    False
)
test(
    [
        "┌┐     ┌┐",
        "││     ││",
        "│├──┴──┤│",
        "││     ││",
        "└┘     └┘"
    ],
    False
)
test(
    [
        "┌┐     ┌┐",
        "││     ││",
        "│├─────││",
        "││     ││",
        "└┘     └┘"
    ],
    False
)
test(
    [
        "┌┐     ┌┐  ",
        "││     ││  ",
        "│├──┐  │├─┐",
        "││  │  ││ │",
        "└┘  │  └┘ │",
        "    │     │",
        "┌┐  │  ┌┐ │",
        "││  │  ││ │",
        "│├──┼──┤│ │",
        "││  │  ││ │",
        "└┘  │  └┘ │",
        "    └─────┘"
    ],
    False
)
test(
    [
        "┌────────┐",
        "│        │",
        "│        │",
        "│       ┌┘",
        "└───────┘ "
    ],
    False
)