Sinthorion's stats

// C is a functional programming language featuring concepts such as
// purity, immutability, first class functions, and flexible dynamic typing

// C is a rather old language, which means we need a lot of boilerplate
// I recommend skipping this section to get to the fun parts

#include <stdint.h>
#define Num intptr_t

#define let const Num
#define defun Env
#define params(...) (Env env, ##__VA_ARGS__)
#define return(V) ({env.x = V; return env;})

#define cons(L, R) ({ env = fmallocsetcons(env, L, R); env.x; })
#define null 0
#define left(cons) (cons?((Num*)cons)[0]:null)
#define right(cons) (cons?((Num*)cons)[1]:null)

#define call(F, ...) ({env = F(env, ##__VA_ARGS__); env.x;})

#define ref(V) ({let ret = (let)V; ret;})

// create our own memory management, since C's is inferior

#define MEMINIT(N) \
static Num memarr[N]; \
Mem mem = { (Num)memarr, 0}; \
Env env = { 0, mem }

let numsize = sizeof(Num);

struct Mem { Num mem; Num next; };
typedef struct Mem Mem;

struct Env { Num x; struct Mem mem; };
typedef struct Env Env;

let set(let ptr, let val)
{
    Num *mut = (void*)ptr;
    *mut = val;
    let con = (const Num) mut;
    return con;
}

// I don't understand this part either; just ignore it

defun fmallocsetcons params(let left, let right)
{
    let ptr = set(env.mem.mem+env.mem.next, left);
    set(env.mem.mem+env.mem.next+numsize, right);
    Mem newmem = { env.mem.mem, env.mem.next + 2*numsize };
    Env ret = { ptr, newmem };
    return ret;
}

defun fmallocsetmatrix params (let matrix)
{
    int * ptr = (int*)(env.mem.mem + env.mem.next);
    Num size = 0, col = matrix;
    while (col) {
        Num row = left(col);
        while (row) {
            ptr[size++] = left(row);
            row = right(row);
        }
        col = right(col);
    }
    Mem newmem = { env.mem.mem, env.mem.next + size * sizeof(int) };
    Env ret = { (Num) ptr, newmem };
    return ret;
}

typedef defun (*monad) params(let);
typedef defun (*dyad) params(let, let);

defun apply1 params(let func, let a)
{
    monad f = (monad) func;
    return(call(f, a));
}

defun apply2 params(let func, let a, let b)
{
    dyad f = (dyad) func;
    return(call(f, a, b));
}

// with that done, let's start

// In C we define functions with the defun keyword
// params and local variables are defined with the let keyword
defun sum params(let list)
{
    return(list
        ? left(list) + call(sum, right(list))
        : null);
}

defun map params(let func, let list)
{
    if (!list) return(null);

    //  we call functions with the call keyword
    let retl = call(apply1, func, left(list));
    let retr = call(map, func, right(list));

    return(cons(retl,retr));
}

// inject one additional (plus) param into map function
// needed since C lacks partial application
defun mapplus1 params(let func, let plus, let list)
{
    if (!list) return(null);

    let retl = call(apply2, func, plus, left(list));
    let retr = call(mapplus1, func, plus, right(list));

    return(cons(retl,retr));
}

// merge two lists by combining one element from each list as pair in the new list
// assume both lists have the same size; ignore any remainders
defun zip params(let list1, let list2)
{
    return(list1 == null || list2 == null
        ? 0
        : cons(cons(left(list1), left(list2)),
                call(zip, right(list1), right(list2))));
}

defun length params(let list)
{
    return(list
        ? 1 + call(length, right(list))
        : 0);
}

defun nth params(let n, let list)
{
    return(n
        ? call(nth, n-1, right(list))
        : left(list));
}

defun getrow params(let matrix, let rownum)
{
    return(rownum
        ? call(getrow, right(matrix), rownum - 1)
        : left(matrix));
}

defun getcol params(let matrix, let colnum)
{
    return(call(mapplus1, ref(nth), colnum, matrix));
}

defun mult_pair params(let pair)
{
    return(left(pair) * right(pair));
}

defun matrixmult_single params(let m1, let m2, let rownum, let colnum)
{
    let row = call(getrow, m1, rownum);
    let col = call(getcol, m2, colnum);
    let zipped = call(zip, row, col);

    let products = call(map, ref(mult_pair), zipped);
    return(call(sum, products));
}

defun _matrixmult_row params(let m1, let m2, let n, let rownum, let colnum)
{
    return(colnum >= n
           ? 0
           : cons(call(matrixmult_single, m1, m2, rownum, colnum), call(_matrixmult_row, m1, m2, n, rownum, colnum+1)));
}
defun matrixmult_row params(let m1, let m2, let n, let rownum)
{
    return(call(_matrixmult_row, m1, m2, n, rownum, null));
}

defun _matrixmult params(let m1, let m2, let n, let rownum)
{
    return(rownum >= n
        ? 0
        : cons(call(matrixmult_row, m1, m2, n, rownum), call(_matrixmult, m1, m2, n, rownum+1)));
}
defun matrixmult params(let m1, let m2, let n)
{
    return(call(_matrixmult, m1, m2, n, null));
}

// the real world sometimes forces us to break from our elegancy and purity
defun ints2list params(int * ints, int len)
{
    return(len
           ? cons(ints[0], call(ints2list, ints+1, len-1))
           : null);
}

// convert impure external matrix-array to superior cons matrix
defun _matrix_deserialise params(int * m, int n, int col)
{
    if (col == n) return(null);
    let row = call(ints2list, m, n);
    return(cons(
            row,
            call(_matrix_deserialise, m + n, n, col + 1)
    ));
}
defun matrix_deserialize params(int * m, int n)
{
    return(call(_matrix_deserialise, m, n, null));
}

// convert back to matrix-array for lesser beings to understand
defun matrix_serialize params(let matrix)
{
    return(call(fmallocsetmatrix, matrix));
}

int * entry(int * m1, int * m2, int n)
{
    MEMINIT(1024 * 1024);

    let a = call(matrix_deserialize, m1, n);
    let b = call(matrix_deserialize, m2, n);

    let c = call(matrixmult, a, b, n);

    int * result = (int*)call(matrix_serialize, c);
    return result;
}

import sqlite3

def entry(input):
  values = ','.join([f"({x})" for x in input])
  cur = sqlite3.connect("sort.db").cursor()
  cur.execute(f"select val from\
    (select 0 as val union all values {values}) input\
    order by val limit -1 offset 1")
  return [row[0] for row in cur.fetchall()]