olive's stats

-- local debug = function(msg, ...) print(msg, ...) return ... end
local debug = function(msg, ...) return ... end
-- local flip = function() io.write("...") io.read("*l") end
local flip = function() end

local function isnat(n) return ((n >= 0) and (n%1 == 0)) end

local function _reverse(xi, xo)
	debug("reverse", xi, xo)
	if xi == 0 then return xo end
	xo = xo * 10 + xi % 10
	xi = (xi - xi % 10) / 10
	return _reverse(xi, xo)
end

-- input must be reversed
local function _countup(xi, xo)
	debug("countup", xi, xo)
	if xi == 0 then return xo end
	if xi % 10 ~= xo % 10 then xo = xo * 100 + xi % 10 end
	xo = xo + 10 -- safe as seq only contains digits 1,2,3
	xi = (xi - xi % 10) / 10
	return _countup(xi, xo)
end

local function _looksi_iter(n, x)
	debug("iter", n, x)
	if n == 0 then return x end
	local nx = _countup(_reverse(x, 0), 0)
	return _looksi_iter(n-1, nx)
end

--- dom: nat >0
local function looksi(n)
	debug("looksi", n)
	assert(isnat(n))
	return _looksi_iter(n-1, 1)
end

local i = 0
while true do i=i+1 print(i,looksi(i)) flip() end

return looksi

local floor, ceil = math.floor, math.ceil
local min, max = math.min, math.max

local lg = love.graphics
lg.setColour, lg.setColor = lg.setColor, nil

math.randomseed(os.time())
love.window.setMode(600, 600, { resizable = true })
lg.setFont(lg.newFont(12))

local width, height = 4, 4
local grid = {}

local colours = {
	[ 1] = { 11/11, 11/11, 11/11 },
	[ 2] = { 10/11, 10/11, 10/11 },
	[ 3] = {  9/11,  9/11,  9/11 },
	[ 4] = {  8/11,  8/11,  8/11 },
	[ 5] = {  7/11,  7/11,  7/11 },
	[ 6] = {  6/11,  6/11,  6/11 },
	[ 7] = {  5/11,  5/11,  5/11 },
	[ 8] = {  4/11,  4/11,  4/11 },
	[ 9] = {  3/11,  3/11,  3/11 },
	[10] = {  2/11,  2/11,  2/11 },
	[11] = {  1/11,  1/11,  1/11 },
}
assert(2^11 == 2048)

local function addrandomly()
	local value = math.random(1,2)
	local index repeat
		index = math.random(0,width*height-1)
	until not grid[index]
	grid[index] = value
end

local state = "begin"

local function getr()
	local t = love.timer.getTime()
	local w, h = lg.getDimensions()
	local r = min(w,h)
	local pad = min(60, r*0.1)*(0.98 + 0.2 * math.sin(t/8*math.pi*2))
	local xshif = max(0,floor((w-h)/2))
	local yshif = max(0,floor((h-w)/2))
	return r-pad*2, pad, xshif, yshif
end

local function perr(x,y)
	local r, pad, xshif, yshif = getr()
	x = (x - pad - xshif) / r
	y = (y - pad - yshif) / r
	return x, y
end

local drawers = {
	begin = function()
		lg.setColour(0.80, 0.90, 0.80)
		lg.rectangle("fill", 0,0, 1,1)
	end,
	playing = function()
		local tp = love.timer.getTime()*math.pi*2
		lg.setColour(0.85, 0.85, 0.85+0.05*math.sin(tp/5))
		lg.rectangle("fill", 0,0, 1,1)
		for x = 0, width-1 do
			for y = 0, height-1 do
				local v = grid[x+y*width]
				if v then
					lg.setColour(colours[v])
					lg.rectangle("fill", x*0.25+0.01, y*0.25+0.01, 0.23, 0.23)
					lg.setColour(0,0,0)
					for i = 1, v do
						lg.circle("fill", x*0.25+0.01+0.04*i, y*0.25+0.01+0.04, 0.02)
					end
				end
			end
		end
	end,
	over = function()
		lg.setColour(0.90, 0.80, 0.80)
		lg.rectangle("fill", 0,0, 1,1)
	end,
}

local clickers = {
	begin = function(x,y)
		state = "playing"
		addrandomly()
		addrandomly()
	end,
	playing = function(x,y)
	end,
	over = function(x,y)
		state = "begin"
	end,
}

local keybers = {
	begin = function()
	end,
	playing = function(key)
		
		-- I am ashamed
		
		if key == "left" then
			for y = 0, 3 do
				for x = 1, 3 do
					if grid[x+y*width] then
						for xx = x-1, 0, -1 do
							if not grid[xx+y*width] then
								grid[xx+y*width] = grid[(xx+1)+y*width]
								grid[(xx+1)+y*width] = nil
							elseif grid[xx+y*width] == grid[(xx+1)+y*width] then
								grid[xx+y*width] = grid[xx+y*width] + 1
								grid[(xx+1)+y*width] = nil
								break
							else
								break
							end
						end
					end
				end
			end
		elseif key == "right" then
			for y = 0, 3 do
				for x = 2, 0, -1 do
					if grid[x+y*width] then
						for xx = x+1, 3 do
							if not grid[xx+y*width] then
								grid[xx+y*width] = grid[(xx-1)+y*width]
								grid[(xx-1)+y*width] = nil
							elseif grid[xx+y*width] == grid[(xx-1)+y*width] then
								grid[xx+y*width] = grid[xx+y*width] + 1
								grid[(xx-1)+y*width] = nil
								break
							else
								break
							end
						end
					end
				end
			end
		elseif key == "up" then
			for x = 0, 3 do
				for y = 1, 3 do
					if grid[x+y*width] then
						for yy = y-1, 0, -1 do
							if not grid[x+yy*width] then
								grid[x+yy*width] = grid[x+(yy+1)*width]
								grid[x+(yy+1)*width] = nil
							elseif grid[x+yy*width] == grid[x+(yy+1)*width] then
								grid[x+yy*width] = grid[x+yy*width] + 1
								grid[x+(yy+1)*width] = nil
								break
							else
								break
							end
						end
					end
				end
			end
		elseif key == "down" then
			for x = 0, 3 do
				for y = 2, 0, -1 do
					if grid[x+y*width] then
						for yy = y+1, 3 do
							if not grid[x+yy*width] then
								grid[x+yy*width] = grid[x+(yy-1)*width]
								grid[x+(yy-1)*width] = nil
							elseif grid[x+yy*width] == grid[x+(yy-1)*width] then
								grid[x+yy*width] = grid[x+yy*width] + 1
								grid[x+(yy-1)*width] = nil
								break
							else
								break
							end
						end
					end
				end
			end
		end

		addrandomly()

		local filled = 0
		for i = 0, width*height-1 do
			if grid[i] == 11 then
				state = over
			elseif grid[i] then
				filled = filled + 1
			end
		end
		if filled == width*height then
			state = over
		end
	end,
	over = function()
	end,
}

function love.draw()
	lg.clear(1,1,1)
	do
		local r, pad, xshif, yshif = getr()
		lg.translate(pad, pad)
		lg.translate(xshif, yshif)
		lg.scale(r)
	end

	drawers[state]()
end

function love.mousepressed(x,y)
	clickers[state](perr(x,y))
end

function love.keypressed(key, scancode)
	keybers[state](key, scancode)
end

#include <u.h>
#include <libc.h>
#include <bio.h>

/*
	Copyright 2023
	
	The author does not remember how this program works, or if it even does.
	
	Permission to use, copy, modify, and distribute this software for any purpose with or without fee is hereby granted, provided information regarding the author is erased and not disclosed to any third party.
	
	THE SOFTWARE IS PROVIDED "AS IS". THE AUTHOR DISCLAIMS ALL WARRANTIES INCLUDING ALL IMPLIED WARRANTIES. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR DAMAGES.
*/

/* "accessing uninitialized data (for example, popping an empty stack or reading an uninitialized variable) is undefined behaviour." */

/* TODO: check if things error <- TODO: what was that in reference to */
/* TODO: nesting dosen't work for everything */

union var
{
	s32int i;
	union var *reg;
	char *str;
};
#define STACKSIZE 1024
union var stack[STACKSIZE];
usize top = -1;

struct frame
{
	char *ins;
	int incond;
	char *body;
	char *cond;
};
#define CALLSIZE 256
struct frame callstack[CALLSIZE];
usize calltop = -1;

union var regs['z'-'a'+1];

Biobuf prog;
Biobuf in;
Biobuf out;


void
usage(void)
{
	print("oops\n");
	exits("usage");
}

/* leaving this here because I was proud of it, unfortunately pipes & stdin. */
/* untested */
/*
char *
readquote(void)
{
	char *start = Boffset(&prog);
	int len;
	char *s;
	
	for(int nest = 1; nest > 0)
		switch(Bread(&prog))
		{
		case '[':
			nest++;
			break;
		case ']':
			nest--;
			break;
		case Beof:
			exits("eof in quote");
		default:
			break;
		}
	
	len = Boffset(&prog)-start;
	s = malloc(len)
	Bseek(&prog, start, 0);
	Bread(&prog, s, len);
	s[len-1] = 0;
	return s;
}
*/

int
getins(void)
{
	if(calltop == -1)
		return Bgetc(&prog);
	else
		return *(callstack[calltop].ins++);
}

void
ungetins(void)
{
	if(calltop == -1)
		Bungetc(&prog);
	else
		callstack[calltop].ins--;
}

char *
readquote(void)
{
	char *s = nil;
	int len = 0;
	
	for(int nest = 1; nest > 0;)
	{
		s = realloc(s, ++len); /* this is awful - change it later */
		switch(s[len-1] = getins())
		{
		case '[':
			nest++;
			break;
		case ']':
			nest--;
			break;
		case 0:
			exits("null char in quote");
		case Beof:
			exits("eof in quote");
		default:
			break;
		}
	}
	
	s[len-1] = 0;
	return s;
}

void
main(int argc, char *argv[])
{
	Binit(&in, 0, OREAD);
	Binit(&out, 1, OWRITE);
	
	if(argc <= 1 || (argv[1][0] == '-' && argv[1][1] == 0))
		Binit(&prog, 0, OREAD);
	else if(argc == 2)
	{
		int fd = open(argv[1], OREAD);
		Binit(&prog, fd, OREAD);
	}
	else
		usage();
	
	/* Ignore Shebang */
	if(Bgetc(&prog) == '#')
		for(int c = Bgetc(&prog); c != Beof && c != '\n'; c = Bgetc(&prog));
	else
		Bungetc(&prog);
	
	for(int c = getins(); c != Beof; c = getins())
	{
		union var x,y,z;
		
	//	Bprint(&out, "%c", c);
	//	Bflush(&out);
		
		switch(c)
		{
			/* Comments */
			case '{':
				for(c = getins(); c != Beof && c != '}'; c = getins());
				break;
			
			/* Print Message */
			case '"':
				for(c = getins(); c != Beof && c != '"'; c = getins())
					Bputc(&out, c);
				break;
			
			/* Reg Access */
			case ';':
				stack[top] = *(stack[top].reg);
				break;
			case ':':
				*(stack[top].reg) = stack[top-1];
				top -= 2;
				break;
			
			/* Stack */
			case '$':
				stack[top+1] = stack[top];
				top++;
				break;
			case '%':
				top--;
				break;
			case '\\':
				x = stack[top];
				stack[top] = stack[top-1];
				stack[top-1] = x;
				break;
			case '@':
				x = stack[top-2];
				y = stack[top-1];
				z = stack[top  ];
				stack[top-2] = y;
				stack[top-1] = z;
				stack[top  ] = x;
				break;
			case 'ø':
			case 'O':
				stack[top] = stack[top-1-stack[top].i];
				break;
			
			/* Number Ops */
			case '+':
				x = stack[top--];
				stack[top].i += x.i;
				break;
			case '-':
				x = stack[top--];
				stack[top].i -= x.i;
				break;
			case '*':
				x = stack[top--];
				stack[top].i *= x.i;
				break;
			case '/':
				x = stack[top--];
				stack[top].i /= x.i;
				break;
			case '_':
				stack[top].i = -stack[top].i;
				break;
			
			/* Bit Ops */
			case '&':
				x = stack[top--];
				stack[top].i &= x.i;
				break;
			case '|':
				x = stack[top--];
				stack[top].i |= x.i;
				break;
			case '~':
				stack[top].i = ~stack[top].i;
				break;
			
			/* Queries */
			case '=':
				x = stack[top--];
				stack[top].i = -(stack[top].i == x.i);
				break;
			case '>':
				x = stack[top--];
				stack[top].i = -(stack[top].i > x.i);
				break;
			case '<':
				x = stack[top--];
				stack[top].i = -(stack[top].i < x.i);
				break;
			
			/* Calls */
			case '!':
				calltop++;
				callstack[calltop].body = stack[top].str;
				callstack[calltop].cond = nil;
				callstack[calltop].ins = stack[top].str;
				callstack[calltop].incond = 0;
				top--;
				break;
			case '?':
				if(stack[top-1].i != 0)
				{
					calltop++;
					callstack[calltop].body = stack[top].str;
					callstack[calltop].cond = nil;
					callstack[calltop].ins = stack[top].str;
					callstack[calltop].incond = 0;
				}
				top -= 2;
				break;
			case '#':
				calltop++;
				callstack[calltop].body = stack[top].str;
				callstack[calltop].cond = stack[top-1].str;
				callstack[calltop].ins = stack[top].str;
				callstack[calltop].incond = 0;
				top -= 2;
				break;
			
			/* Returns */
			case 0:
				// FIXME: memleak of strings, can't free as may ref'd elsewhere
				if(callstack[calltop].incond)
				{
					if(stack[top--].i != 0)
					{
						callstack[calltop].incond = 0;
						callstack[calltop].ins = callstack[calltop].body;
					}
					else
						calltop--;
				}
				else if(callstack[calltop].cond != nil)
				{
					callstack[calltop].incond = 1;
					callstack[calltop].ins = callstack[calltop].cond;
				}
				else
					calltop--;
				break;
			
			/* Quote */
			case '[':
				stack[++top].str = readquote();
				break;
			case ']':
				// pass
				break;
			
			/* IO */
			case '^':
				c = Bgetc(&in);
				stack[++top].i = (c == Beof ? -1 : c);
				break;
			case ',':
				Bputc(&out, stack[top--].i);
				break;
			case '.':
				Bprint(&out, "%d", stack[top--].i);
				break;
			case 'ß':
			case 'B':
				Bflush(&out);
				break;
			
			/* Character Literal */
			case '\'':
				x.i = getins();
				if(x.i != 0 && x.i != Beof)
					stack[++top].i = x.i;
				else
					ungetins();
				break;
			
			/* Integer Literal */
			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':
				stack[++top].i = c - '0';
				for(c = getins(); '0' <= c && c <= '9'; c = getins())
					stack[top].i = stack[top].i*10 + c - '0';
				ungetins();
				break;
			
			default:
				/* Register Ref */
				if('a' <= c && c <= 'z')
					stack[++top].reg = &(regs[c-'a']);
				break;
		}
		
	//	Bflush(&out);
	}
	
	Bflush(&out);
	exits(0);
}

</$objtype/mkfile

TARG=cg41
BIN=/$objtype/bin

OFILES=\
	cg41.$O\

</sys/src/cmd/mkone

local function push(s, v)
	s[s.n+1], s.n = v, s.n+1
end
local function pop(s)
	local v = s[s.n]
	s[s.n], s.n = nil, s.n-1
	return v
end
local function peek(s)
	return s[s.n]
end

local function nextbyte(s, i)
	i = i + 1
	local b = s:byte(i)
	if b then
		return i, b
	else
		return
	end
end
function string.gbyte(s)
	return nextbyte, s, 0
end
local function B(s) return s:byte() end

local ops = {
	[B'+'] = function(s) push(s,   pop(s)+pop(s)) end,
	[B'-'] = function(s) push(s,  -pop(s)+pop(s)) end,
	[B'*'] = function(s) push(s,   pop(s)*pop(s)) end,
	[B'/'] = function(s) push(s, 1/pop(s)*pop(s)) end,
}

local function evaluate(expr)
	local p = 0
	local yardp = {n=0}
	local yard  = {n=0}
	local stack = {n=0}
	for i, c in expr:gbyte() do
		if     c == B' ' then
			p = p + 1
		elseif c == B'+' or c == B'-' or c == B'*' or c == B'/' then
			local tp = peek(yardp)
			while tp and tp <= p do
				if stack.n > 1 then
					pop(yardp)
					ops[pop(yard)](stack)
				else
					return nan, "unbalanced"
				end
				tp = peek(yardp)
			end
			push(yard, c)
			push(yardp, p)
			p = 0
		elseif B'0' <= c and c <= B'9' then
			push(stack, c-B'0')
			p = 0
		else
			-- ignore unknown char
		end
	end
	while yard.n > 0 and stack.n > 1 do
		ops[pop(yard)](stack)
	end
	if yard.n == 0 and stack.n == 1 then
		return pop(stack)
	else
		return nil, "unbalanced"
	end
end



-- tests --

local tests = {
	"9 / 1+2  -  1    /    2",
	"0-6 * 2",
	"4  /  1 + 1",
	"2-4/2",
	"-4",
	"34",
	"1 / 0",
	"9*9*9*9*9*9*9*9*9*9",
}

for i,test in ipairs(tests) do
	print(i, evaluate(test), "=", test)
end
print("done!")

local type = type
local floor = math.floor


local function fold(f)
	local function _folder(x, y, ...)
		if y == nil then
			return x
		else
			return _folder(f(x,y), ...)
		end
	end
	return _folder
end

local function unfold(f,e)
	local function _unfolder(x, ...)
		local x, y = f(x)
		if x == e then
			return y, ...
		else
			return _unfolder(x, y, ...)
		end
	end
	return function(x) return _unfolder(x) end
end


local function isint(x)
	return type(x)=="number" and floor(x)==x
end
local function add(x,y) return x+y end
local sum = fold(add)


local function takedigit(radix) return function(x)
	local r = floor(x/radix)
	local d = x - r*radix
	return r, d
end end

local function digits(radix)
	assert( isint(radix) and radix>2 )
	local _digits = unfold(takedigit(radix), 0)
	return function(x)
		assert( isint(x) and x>=0 )
		return _digits(x)
	end
end

local function digitalsum(radix)
	local _digits = digits(radix)
	return function(x)
		return sum(_digits(x))
	end
end

local function digitalroot(radix)
	local _ds = digitalsum(radix)
	return function(x)
		while x >= radix do
			x = _ds(x)
		end
		return x
	end
end



-- cli for showcase --

local radix, number = ...
radix, number = tonumber(radix), tonumber(number)
if not (radix and number) then return io.stderr:write[[
args: <radix> <number>
cli input & output is all base-10.
]] end

io.write(tostring(digitalroot(radix)(number)))
io.write("\n")

-- n: u
-- bit: u - 0-based index, starting at LSB
--> bool  - true/false if bit is 1/0
local function getbit(n, bit)
	return 1 == (n/2^bit)%2 - (n/2^bit)%1
end


-- rule: u8 - Wolfram Code
--> { [bool]={ [bool]={ [bool]=bool } } } - rule lookup, starting at left
local function wolframrules(rule)
	return {
		[true]  = {
			[true]  = {
				[true]  = getbit(rule, 7),
				[false] = getbit(rule, 6),
			},
			[false] = {
				[true]  = getbit(rule, 5),
				[false] = getbit(rule, 4),
			},
		},
		[false] = {
			[true]  = {
				[true]  = getbit(rule, 3),
				[false] = getbit(rule, 2),
			},
			[false] = {
				[true]  = getbit(rule, 1),
				[false] = getbit(rule, 0),
			},
		},
	}
end


-- rule: u8             - Wolfram Code
-- state: { bool, ... } - World state
--> { bool, ... }       - Next state, same length as input
return function(rule, state)
	local newstate = {}
	local rules = wolframrules(rule)
	for i = 1,#state do
		newstate[i] = rules
			[state[i-1] or false]
			[state[i]]
			[state[i+1] or false]
	end
	return newstate
end

local entry = dofile("cg29.lua")

local function matches(t1, t2) -- shallow list match
	if #t1 ~= #t2 then return false end
	for i = 1, #t1 do
		if t1[i] ~= t2[i] then return false end
	end
	return true
end

local t,f = true,false
assert(matches(entry(30, {f,t,t,f,f,t,f}),
                         {t,t,f,t,t,t,t}))
assert(matches(entry(72, {f,f,f,t,t,f,f,t,f}),
                         {f,f,f,t,t,f,f,f,f}))

local function sunrise(p)
	if not p then return 0 end
	local dracula = 0
	local pr=p  while pr.r do pr=pr.r
	local pd=pr while pd.d do pd=pd.d
	local pl=pd while pl.l do pl=pl.l
	local pu=pl while pu.u do pu=pu.u
		if pu == p then dracula = dracula + 1 break end
	end end end end
	return dracula
end

return function(t)
	if #t == 0 then return 0 end
	local I,J = #t,#t[1]
	for i=1,I do for j=1,J do
		t[i][j] = t[i][j] and {} or nil
	end end
	for i=1,I do for j=1,J do
		if t[i][j] then
			t[i][j].r = t[i][j+1]
			t[i][j].d = t[i+1] and t[i+1][j] or nil
			t[i][j].l = t[i][j-1]
			t[i][j].u = t[i-1] and t[i-1][j] or nil
		end
	end end
	local duckula = 0
	for i=1,I do for j=1,J do
		duckula = duckula + sunrise(t[i][j])
	end end
	return duckula
end