cg #2

started at 2021-02-03T17:57:43.151000+00:00; stage 2 at 2021-02-11T18:06:37.369000+00:00; ended at 2021-02-18T21:34:24.220000+00:00

specification

hello
following discussion between me and @sonata «pathétique» we have arrived at this week's challenge for the code guessing competition. the challenge is: solve a maze.
submissions must be written in either C or python.

your program will be given a 10x10 grid of square cells, each of which is either a wall or not a wall. starting at the upper left corner, you must find a path to the lower right corner, moving only on cells that are not walls, and moving only north south east or west (ie you cannot move diagonally between cells). your program then has to return the sequence of moves required. (if the input has multiple valid solutions you can return any valid solution).

in C: your program should provide a function entry which takes an array of 100 ints, representing the input. cells are organised row-wise, from left to right then top to bottom; that is input[0] is the upper left corner, input[9] is the upper right corner, input[90] is the lower left corner and input[99] is the lower right corner. each value in the array will be 1 if that cell is a wall, and 0 if it is not a wall. no other values will be present in the input array.
the entry function must return a pointer/array of ints representing the path. (i don't care how it's allocated, i will just be casting whatever you return to an int pointer and then checking that). each value can be either 1 to represent going upwards, 2 to represent going right, 3 to represent going downwards, or 4 to represent going left. your output array must also be terminated with one value equal to 0; ie the value after the end of your path needs to be zero.
i will be compiling with gcc on debian. having your solution rely on UB etc is fine, but you do so at your own risk.
in python: your function entry will be given an list of 100 bools, True representing a wall and False representing no wall, in the same ordering as the C description above. you must return a list of ints representing your path; each int can be 1 to represent going upwards, 2 to represent going right, 3 to represent going downwards, or 4 to represent going left. (there is no need for a terminator in python) your solution will be run using python 3.9 on debian.
in both cases your solution given will actually be evaluated as a sequence of moves, not just statically compared to one solution. so you could include a sequence of up down up down up down, and as long as by the end of your solution you are at the correct place your solution will be ok. if any of the moves try to move into a wall or outside of the 10x10 area, then your solution is immediately marked as invalid.

results

entries

entry #1

written by IFcoltransG

guesses

AviFS (by quintopia)
AviFS (by Olivia)
AviFS (by sonata «pathétique»)
IFcoltransG (by gollark)
Olivia (by LyricLy)
Olivia (by AviFS)
gnobody (by razetime)
quintopia (by Palaiologos)
razetime (by gnobody)
sonata «pathétique» (by citrons)

comments 0

post a comment

241757436720054273-ifcoltransg.py ASCII text

def entry(maze):

 state = [0, 0, 1, []]

 while (

  state[0] != 9 or state[1] != 9

 ):

  if (

   state[2] == 1

   and state[0] != 0

   and not maze[int(str(state[0] - 1) + str(state[1]))]

  ):

   state[0] -= 1

   state[3].append(state[2])

   state[2] += 1

  elif (

   state[2] == 2

   and state[1] != 9

   and not maze[int(str(state[0]) + str(state[1] + 1))]

  ):

   state[1] += 1

   state[3].append(state[2])

   state[2] += 1

  elif (

   state[2] == 3

   and state[0] != 9

   and not maze[int(str(state[0] + 1) + str(state[1]))]

  ):

   state[0] += 1

   state[3].append(state[2])

   state[2] += 1

  elif (

   state[2] == 4

   and state[1] != 0

   and not maze[int(str(state[0]) + str(state[1] - 1))]

  ):

   state[1] -= 1

   state[3].append(state[2])

   state[2] += 1

  else:

   state[2] -= 1

  if (

   state[2] == 0

  ):

   state[2] = 4

  if (

   state[2] == 5

  ):

   state[2] = 1

 return state[3]

entry #2

written by citrons

guesses

LyricLy (by Palaiologos)
Olivia (by razetime)
Palaiologos (by IFcoltransG)
Palaiologos (by LyricLy)
Palaiologos (by gnobody)
citrons (by quintopia)
citrons (by sonata «pathétique»)
gnobody (by Olivia)
gnobody (by gollark)
gollark (by AviFS)

comments 0

post a comment

231856503756161025-citrons.c ASCII text

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

enum piss { up=1, right=2, down=3, left=4 };

struct linked_piss {
	enum piss pi;
	struct linked_piss *ss;
};
 
int moves[5][2] = {
	{0, 0},
	{0, -1},
	{1, 0},
	{0, 1},
	{-1, 0}
};

typedef int piss_grid[100];

int piss_tile(piss_grid g, int x, int y) {
	if (x < 0 || y < 0 || x > 9 || y > 9)
		return 1;
	else
		return g[(10 * y) + x];
}
void disp_grid(piss_grid g) {
	for (int i = 0; i < 100; i++) {
		if (g[i] == 1) printf("#");
		else if (g[i] == 2) printf("*");
		else printf(" ");
		if (i % 10 == 9) printf("\n");
	}
	printf("\n");
}

int *to_result(const struct linked_piss *p) {
	// Prepare for ubq analysis
	int *final_piss = malloc(500);
	for (int i = 0; p != NULL; (p = p->ss) && (i++)) {
		final_piss[i] = p->pi;
	}
	
	return final_piss;
}

struct linked_piss *attempt(piss_grid g, int ix, int iy, enum piss m, int c) {
	int x = ix + moves[m][0];
	int y = iy + moves[m][1];

	// It is not possible to go in walls
	if (piss_tile(g, x, y) == 1 || c > 500) return NULL;
	if (x == 9 && y == 9) {
		struct linked_piss *p = malloc(sizeof(struct linked_piss));
		struct linked_piss empty = {0};
		*p = empty;
		return p;
	}
	/*
	g[(10 * y) + x] = 2;
	disp_grid(g);
	*/
	// Let's check all of the directions
	for (int i = 1; i <= 4; i++) {
		if (x + moves[i][0] == ix && y + moves[i][1] == iy) continue;
		// Recursive recursion
		struct linked_piss *guess = attempt(g, x, y, i, c + 1);
		if (guess != NULL) {
			struct linked_piss *p = malloc(sizeof(struct linked_piss));
			struct linked_piss new = {i, guess}; 
			*p = new;
			return p;
		}
	}

	return NULL;
}

int *entry(piss_grid g) {
	int x = 0;
	int y = 0;

	struct linked_piss *p = attempt(g, 0, 0, 0, 0); 
	if (p != NULL)
		return to_result(p);
	else
		return NULL;
}

// We will free() nothing!

entry #3

written by sonata «pathétique»

guesses

IFcoltransG (by Palaiologos)
LyricLy (by quintopia)
LyricLy (by citrons)
LyricLy (by gnobody)
Olivia (by IFcoltransG)
Olivia (by gollark)
citrons (by razetime)
quintopia (by AviFS)
razetime (by LyricLy)
sonata «pathétique» (by Olivia)

comments 0

post a comment

630265753735528478-sonata-pathétique.py ASCII text

def entry(iAr): # Bad Tremaux impl
    cPos = 0; pPos = None
    psgs = [set() for i in range(100)]
    
    def isIs(pos, prev): # Not confusing at all
        paths = {k:0 for k in (pos-10, pos-1, pos+1, pos+10)}
        for k in paths:
            try:
                if not iAr[k]:
                    paths[k] = 1
            except IndexError:
                pass
        paths[prev] = 0
        
        if pos < 10:
            paths[pos-10] = 0
        if not pos % 10:
            paths[pos-1] = 0
        if pos % 10 == 9:
            paths[pos+1] = 0
        
        return [k for k in paths if paths[k]]
        # Should I rename this? ... Nah
    
    def isV(pos):
        for i in psgs[pos]:
            if i:
                return True
        return False
    
    def isB(pos, prev):
        for i in psgs[pos]:
            if i == prev:
                return True
        return False
    
    # I hate this so much
    while cPos != 99:
        paths = isIs(cPos, pPos)
        
        if isV(cPos):
            if isB(cPos, pPos):
                unv = list(filter(lambda y: not isV(y), paths))
                if not unv:
                    unv = set(isIs(cPos, pPos)) - psgs[cPos]
                pPos = cPos
                cPos = unv.pop()
            else:
                cPos, pPos = pPos, cPos
        
        else:
            if len(paths):
                pPos = cPos
                cPos = paths.pop()
            else:
                cPos, pPos = pPos, cPos
        
        psgs[pPos].add(cPos)
    
    def compare(pos, nxt):
        if   nxt == pos - 10:
            return 1
        elif nxt == pos + 1:
            return 2
        elif nxt == pos + 10:
            return 3
        else:
            return 4
    
    cPos = 0; oAr = []
    while cPos != 99:
        nPos = tuple(psgs[cPos])[-1]
        oAr.append(compare(cPos, nPos))
        cPos = nPos
        
    return oAr

entry #4

written by gnobody

guesses

Olivia (by quintopia)
Palaiologos (by razetime)
citrons (by gollark)
citrons (by AviFS)
gnobody (by citrons)
gnobody (by Palaiologos)
gnobody (by sonata «pathétique»)
gollark (by Olivia)
gollark (by IFcoltransG)
sonata «pathétique» (by LyricLy)

comments 0

post a comment

341618941317349376-nobody.py Unicode text, UTF-8 text

# apiomemetic beeoforms, utterly.
def entry(k):
    # æ input format
    k=list(map(int,k))
    k=[k[:10],k[10:20],k[20:30],k[30:40],k[40:50],k[50:60],k[60:70],k[70:80],k[80:90],k[90:100]]
    d=[[0]*10 for i in range(10)]
    d[0][0]=0
    v=[[0]*10 for i in range(10)]
    q=[(0,0)]
    ok=lambda y,x:x>=0 and x<10 and y>=0 and y<10 and not k[y][x]
    # stage 1: generate distance matrix
    while q:    
        y,x=q.pop()
        if v[y][x]:
            continue
        v[y][x]=1
        for i,j in [(-1,0),(0,-1),(0,1),(1,0)]:
            if ok(y+i,x+j) and not v[y+i][x+j]:
                d[y+i][x+j]=d[y][x]+1
                q.insert(0,(y+i,x+j))
    # stage 2: get the path
    r=[(9,9)]
    y,x=9,9
    while y!=0 or x!=0:
        D=d[y][x]
        for i,j in [(-1,0),(0,-1),(0,1),(1,0)]:
            if ok(y+i,x+j) and d[y+i][x+j]==D-1:
                r.append((y+i,x+j))
                y+=i
                x+=j
    r=list(reversed(r))
    # stage 3: convert it into the æ output format
    q=[]
    for i in range(1,len(r)):
        dy=r[i][0]-r[i-1][0]
        dx=r[i][1]-r[i-1][1]
        if (dy,dx)==(1,0):
            q.append(3)
        if (dy,dx)==(-1,0):
            q.append(1)
        if (dy,dx)==(0,-1):
            q.append(4)
        if (dy,dx)==(0,1):
            q.append(2)
    return q
# author: bad imitation of gollark

entry #5

written by LyricLy

guesses

AviFS (by citrons)
IFcoltransG (by razetime)
LyricLy (by AviFS)
LyricLy (by sonata «pathétique»)
Palaiologos (by gollark)
citrons (by Olivia)
citrons (by Palaiologos)
quintopia (by gnobody)
sonata «pathétique» (by quintopia)
sonata «pathétique» (by IFcoltransG)

comments 0

post a comment

319753218592866315-lyricly.c ASCII text

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

static const char *const states = " #*.";
static const int d[] = {-12, 1, 12, -1};

// Execute n steps of a Life-like cellular automaton with arbitrary states (Generations rules), given an initial state and a ruleset.
void do_ca(uint8_t birth, uint8_t survive, uint8_t nstates, int width, int height, uint8_t state[height][width], int n) {
    char neighbor_data[height+2][width+2];
    char (*neighbors)[width+2] = (void *) &neighbor_data + height + 1;
    for (; n--;) {
        memset(neighbors, 0, (height+1)*(width+2) - 1);
        for (int y = 0; y < height; y++) for (int x = 0; x < width; x++) if (state[y][x] == 1) {
            neighbors[y-1][x-1]++;
            neighbors[y-1][x]++;
            neighbors[y-1][x+1]++;
            neighbors[y][x-1]++;
            neighbors[y][x+1]++;
            neighbors[y+1][x-1]++;
            neighbors[y+1][x]++;
            neighbors[y+1][x+1]++;
        }

        for (int y = 0; y < height; y++) for (int x = 0; x < width; x++) {
            uint8_t cstate = state[y][x];
            switch (cstate) {
              case 0:
                if (birth >> (8-neighbors[y][x]) & 1)
                  state[y][x] = 1;
                break;
              case 1:
                if (!(survive >> (8-neighbors[y][x]) & 1))
                  state[y][x] = (cstate + 1) % nstates;
                break;
              default:
                state[y][x] = (cstate + 1) % nstates;
            }
        }
    }
}

void print_state(int width, int height, uint8_t state[height][width]) {
    for (int y = 0; y < height; y++) {
        for (int x = 0; x < width; x++)
            putchar(states[state[y][x]]);
        putchar('\n');
    }
}

int *entry(int input[100]) {
    uint8_t state[10][10];
    for (int y = 0; y < 10; y++) for (int x = 0; x < 10; x++) {
        state[y][x] = input[y*10+x];
    }
    print_state(10, 10, state);
    // run as CGoL for a bit
    do_ca(0x20, 0x30, 2, 10, 10, state, 3);
    print_state(10, 10, state);
    // Seeds is explosive; only use one generation
    do_ca(0x40, 0x00, 2, 10, 10, state, 1);
    // time for its sibling, Brian's Brain
    do_ca(0x40, 0x00, 3, 10, 10, state, 4);
    print_state(10, 10, state);
    // do you like sci-fi?
    do_ca(0x38, 0x40, 4, 10, 10, state, 2);
    print_state(10, 10, state);

    // that was pretty fun. anyway...
    int*p=calloc(100,sizeof(int)),t[144]={[0 ...143]=1};for(int y=0;y<10;y++)for(int x=0;x<10;x++)t[y*12+x+13]=input[y*10+x];
    #define T(v,s)for(i=0;i<4;i++)if(t[n+d[i]]==v){t[n]=s;n+=d[i];p[l++]=i+1;goto e;}
    for(int i,l=0,n=13;n!=130;){T(0,2)T(2,1)e:;}return p;
}

entry #6

written by Kaylynn

guesses

IFcoltransG (by quintopia)
IFcoltransG (by gnobody)
Kaylynn (by LyricLy)
LyricLy (by razetime)
Olivia (by Palaiologos)
gollark (by citrons)
quintopia (by IFcoltransG)
razetime (by AviFS)
razetime (by sonata «pathétique»)
sonata «pathétique» (by gollark)

comments 0

post a comment

636797375184240640-kaylynn.py Unicode text, UTF-8 text, with CRLF line terminators

def repeat(i, n):
    for _ in range(n): yield i

def do_n(functor, n):
    def do(func): return map(functor, repeat(func, n))
    return do

def call_n(n):
    def call(func): return do_n(lambda c: c(), n)(func)
    return call

def call_n_m(n, m):
    def call(func): return call_n(n)(lambda: [*call_n(m)(func)])
    return call

def map_i(c):
    def do(func): return map(lambda i: [*map(func, i)], c)
    return do

def part(*a, **kw):
    def do(func): return lambda: func(*a, **kw)
    return do

def take_n(n):
    def do(i):
        for _ in range(n): yield next(i)
    return do

def label_i(i):
    idx = int()
    for itm in i: yield (idx := idx + 1, *itm)

def entry(flat_maze):
    (as_i) = iter(flat_maze)
    (maze) = [*call_n(10)(lambda: [*take_n(10)(as_i)])]
    (directions, solution) = call_n(2)(list)
    (visited, correct) = call_n(2)(lambda: [*call_n_m(10, 10)(bool)])
    (start_x, start_y), (end_x, end_y) = (
        start   := [0, 0],
        end     := [9, 9],
    )

    def solve(y, x):
        while (y, x) != (end_y, end_x):
            visited[y][x] = True
            solution.append((y, x))

            def do(*a):
                for func in a:
                    (y_, x_) = func()
                    if 0 <= y_ <= 9 and 0 <= x_ <= 9 and not maze[y_][x_] and not visited[y_][x_]: return (y_, x_)

                solution.pop()
                possible = solution[-1]
                solution.pop()
                return possible

            y, x = do(
                lambda: [y - 1, x    ],
                lambda: [y + 1, x    ],
                lambda: [y    , x - 1],
                lambda: [y    , x + 1],
            )

        solution.append((end_y, end_x))
        return solution

    def directions_l(d):
        for o1, o2 in zip(d, d[1:]):
            o = (
                o1[0] - o2[0],
                o1[1] - o2[1],
            )
            yield {
                (  1,  0 ): 1,
                (  0,  1 ): 2,
                ( -1,  0 ): 3,
                (  0, -1 ): 4,
            }[o]

    return [*directions_l(solve(0, 0))]

def tests():
    cases = [
        [
            0, 1, 0, 0, 0, 1, 0, 0, 0, 1,
            0, 1, 0, 1, 0, 1, 0, 1, 0, 0,
            0, 1, 0, 1, 0, 1, 0, 1, 1, 0,
            0, 1, 0, 1, 0, 1, 0, 1, 0, 0,
            0, 1, 0, 1, 0, 1, 0, 1, 0, 1,
            0, 1, 0, 1, 0, 1, 0, 1, 0, 0,
            0, 1, 0, 1, 0, 1, 0, 1, 1, 0,
            0, 1, 0, 1, 0, 1, 0, 1, 0, 0,
            0, 1, 0, 1, 0, 1, 0, 1, 0, 1,
            0, 0, 0, 1, 0, 0, 0, 1, 0, 0,
        ],
        [
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        ],
        [
            0, 1, 0, 0, 0, 0, 0, 0, 1, 0,
            0, 0, 0, 0, 0, 1, 1, 0, 0, 0,
            1, 1, 1, 0, 1, 1, 0, 0, 1, 0,
            0, 1, 1, 0, 0, 0, 1, 0, 0, 1,
            0, 0, 0, 0, 1, 0, 1, 1, 0, 0,
            1, 0, 0, 0, 0, 1, 0, 0, 0, 1,
            0, 0, 1, 1, 1, 0, 1, 0, 1, 0,
            1, 0, 0, 0, 1, 0, 1, 0, 0, 0,
            0, 0, 0, 0, 1, 0, 0, 1, 1, 1,
            1, 0, 1, 0, 0, 0, 0, 0, 0, 0,
        ],
        [
            0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
            0, 0, 1, 0, 1, 0, 0, 0, 1, 0,
            0, 0, 1, 1, 0, 0, 1, 1, 1, 0,
            0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
            0, 1, 0, 0, 1, 0, 1, 0, 0, 0,
            0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
            0, 1, 0, 0, 0, 0, 1, 0, 1, 0,
            0, 0, 0, 1, 0, 0, 0, 1, 0, 0,
            0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
            1, 0, 0, 0, 0, 1, 0, 0, 0, 0,
        ],
    ]

    for case in cases:
        print_maze(case)
        print(entry(case))

def print_maze(maze):
    as_i = iter(maze)
    [*call_n(10)(lambda: print("".join("▓" if cell else "░" for cell in take_n(10)(as_i))))]

entry #7

written by razetime

guesses

AviFS (by LyricLy)
AviFS (by Palaiologos)
AviFS (by gnobody)
IFcoltransG (by citrons)
Kaylynn (by AviFS)
Kaylynn (by sonata «pathétique»)
LyricLy (by gollark)
gnobody (by quintopia)
gnobody (by IFcoltransG)

comments 0

post a comment

166910808305958914-razetime.py ASCII text

def entry(s):
    m = []
    for i in range(0, 100, 10):
        m.append(s[i:i + 10])
    # 1 up 2 right 3 down 4 left
    def k(i, j, d):
        if i == 9 and j == 9:
            global r
            r = d
            return 1
        elif m[i][j] == 1:
            return 0
        elif m[i][j] == 3:
            return 0

        m[i][j] = 3
        
        if i<9 and k(i+1,j,d + [3]):
            return 1
        elif i>0 and k(i-1,j,d + [1]):
            return 1
        elif j<9 and k(i,j+1,d + [2]):
            return 1
        elif j>0 and k(i,j-1,d + [4]):
            return 1
        
        return 0

    k(0,0,[])
    return r

entry #8

written by Olivia

guesses

Kaylynn (by quintopia)
Kaylynn (by razetime)
Kaylynn (by gollark)
citrons (by IFcoltransG)
citrons (by LyricLy)
citrons (by gnobody)
quintopia (by citrons)
quintopia (by sonata «pathétique»)
razetime (by Palaiologos)
sonata «pathétique» (by AviFS)

comments 0

post a comment

156021301654454272-rocketrace.py Unicode text, UTF-8 text, with very long lines (1517)

# owo coding: utf-8 what's this owo siht s'tahw 8-ftu :gnidoc owo
from __future__  import annotations
'''''
copy 2021
''''                                                                                                                                                                                                                                                      \
                                                                                                                                                                                                                                       \
assert 0, "pls disable asserts using ``` python3 -O ``` or the code breaks thank you"                                                                                                                                                                        \
class a:"""woo"""                                                                                                                                                                                                                                                \
if a.__doc__: raise Exception("oh actually can u also use ``` python3 -OO ``` to get rid of docstrings? tyty")                                                                                                                                                                        \
                                                                                                                                                                                                                                         \
                                                                                                                                                                                                                                                             \\           \
                                                                                                                                                                                                                                                \
                                                                                                                                                                                                                                                      \
' ''
import ctypes,  random, types, typing#, typong
TWENTY_THREE: typing.Final[int] = 23
#lambda:random.seed((
s,=lambda __c__=__name__.__lt__.__doc__.__len__().__bool__().__trunc__().__neg__().__invert__(),__metaclass__=__name__.__class__.__class__,__vars__=dir,__dir__=vars,__hotel_rwanda_2004_tery_george__="JSON".casefold(),__bytes__=b'|\1\xa0\0\xa1\0S\x00',__byets__=b'\0\1',__btyes__=b'2\x6c':(lambda __object__=__metaclass__.__bases__.__getitem__(__c__),__yaml__=__import__(__hotel_rwanda_2004_tery_george__),__zero__=....__doc__,__charmap__=int:(lambda __unit__=__object__.__bases__,__according_to_all_known_laws_of_aviation__=__yaml__.__dict__.__class__,__borrow_checker__=__object__.__subclasses__().__getitem__(TWENTY_THREE),__importer_subclasshook__=__dir__(__yaml__).__getitem__(__vars__(__yaml__).__getitem__(TWENTY_THREE)):(lambda __fixme__=__metaclass__(__name__,__unit__,__according_to_all_known_laws_of_aviation__(__getattr__=__importer_subclasshook__.__class__(__importer_subclasshook__.__code__.__class__(TWENTY_THREE.__rfloordiv__(TWENTY_THREE.__radd__(TWENTY_THREE)),*(__c__,)*0b_0_0_1_0,-~~-~~-~----~~-~__c__,0o2,__charmap__(__btyes__,TWENTY_THREE),__bytes__,__unit__,("__len__",),__unit__.__class__(__according_to_all_known_laws_of_aviation__(other=exec(u''''''u""""""''rf""r''),self=TWENTY_THREE)),"__apiodrones__","__data_",__c__,__byets__,__unit__,__unit__),__according_to_all_known_laws_of_aviation__.__call__())))():eval(__name__.__str__.__str__().__getitem__(__borrow_checker__(__fixme__._______________.__neg__(),__fixme__._.__neg__(),__zero__))))))()()(),; # type: ignore # noqa: E731,E123 # TODO
(data:=lambda car,cdr:memoryview((ctypes.c_char*car).from_address(cdr)).cast("B"));
*datum,=[print(data)]*3,
class Discriminator:
       def check(self,other):
              if print(other) not in datum[-1]:
                     TWENTY_THREE=prep(0,1)
def prep(b:list[bool],z:str):
       try:b[b.index(0,z//2):z]=b[s[z]:s[z+1]:-1]
       except MemoryError:__import__("gc").collect()
       except Warning:__import__("warnings").filterwarnings("ignore")
       except Exception as rust:return eval("rust.__traceback__"'.tb_frame'+z*".f_back")
       except BaseException as based:eval("pass")
       except Lyricly as macron:make(NOW)
       except:return prep(b[z:s[z]],z+s)
       finally:s()
# import mock
class SingletonControllerInterface:
       @typing.overload
       def CAMELCASE(car, z: typing.Literal[0]) -> typing.Literal[2]:...
       @typing.overload
       def CAMELCASE(car, z: typing.Literal[1]) -> typing.Literal[1]:...
       @typing.overload
       def CAMELCASE(car, z: typing.Literal[2]) -> typing.Literal[4]:...
       @typing.overload
       def CAMELCASE(car, z: typing.Literal[3]) -> typing.Literal[3]:...
       def CAMELCASE(car, z):                                                                                                                                                                                                                                                                                                                                      return [[[[2,3,4,1][int(z)]]*(z+1)]].pop().pop().pop()
def medium(b:list[None],z:typing.AbstractSet[typing.AsyncContextManager],l,I):
       (I,l),data(1+id(b)+bytes.__basicsize__-1,len(b))[z:z+2]=data(-1+id(b)+bytes.__basicsize__,len(b))[z:z+2],bytes((l,I));return I,l
class Entry:
       @classmethod
       def solve(self, solvution):
              todo=(TWENTY_THREE:=prep(None,1)).f_code.co_code
              n=TWENTY_THREE.f_lasti+2
              kwargs,scheme=medium(todo,n,114,finalize(TWENTY_THREE,solvution))
              global datum#nonlocal datum
              datum[:3]=[*tuple({n,kwargs,scheme})]
εντρυ=Entry()
éntry=Discriminator()
def finalize(b:list[int],z:typing.Union[int,complex]):
       bin,data,hex=b.f_code.co_code,b.f_globals|b.f_locals,b.f_code.co_names
       slice=bin[::2]
       tail,=bin[1::2]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ,
       for match,(x, type)in enumerate(zip(slice,tail)):
               if 106==x and hex[type]==z and isinstance(data.get(hex[tail[match-1]]),Discriminator):
                        return 2*match-2
def entry(a):
       # for _ in range(1000):
            #           breakpoint()
       import gc;gc.disable
       try:
              y,x=0,0
              h = []
              random.seed(s())
              éntry.check("board")
              if a[y*10+x] == 0:
                     temporary = random.randint(0,4)
                     x = temporary
                     h += temporary
              elif a[x*10+y] == 1:
                     random.seed(s())
                     h.pop()
                     εντρυ.solve("board")#goto
              if (y,x) == (10,10):
                      εντρυ.solve("final")
              εντρυ.solve("board")
              éntry.check("final")
              if éntry.check("solutions"):
                               return h
       except:
              print("got here1")
              try:
                     class TWENTY_THREE: pass
                     lieblingsfach=0, 0
                     def NTimes(*args, **kwargs):
                            def outer(f, n):
                                         print(end=f"""n times""");return eval("f")(*args, **kwargs)
                            return outer
                     monad = lambda monoid: lambda apply: lambda haskell: lambda functor: lambda apply: NTimes(monoid)(monad, TWENTY_THREE)(monoid)(apply + 1)(haskell)(functor - 1)(apply ** -1) if functor * apply else haskell + monoid
                     linkedList = list()
                     while monad(TWENTY_THREE)(monad, 4):
                              ctypes.c_void_p.from_address(id(TWENTY_THREE)+8).value = id(linkedList)
                     porm = TWENTY_THREE
                     while TWENTY_THREE + [0]:
                            print(TWENTY_THREE)
                            h = [(0,1),(1,0),(-1,0),(0,-1)]
                            # )_/¯ツ¯\_(
                            permanent = random.choice(((0,1),(0,1)),(1,0),((1,0)),(-1,0),((-1,0),),[0,-1],(0,-1))
                            if not a[monad(lieblingsfach)(0)(permanent)(TWENTY_THREE)(-1)]:
                                   lieblingsfach += permanent
                                   porm += [*[*[*[*[*[h.index(permanent)]]]]]]
                            if lieblingsfach == {9,9}:
                                       return porm
              except Exception as ex:
                     import abc
                     print(Exception)
       else:
              print("got here")
              import selenium
              e = selenium.webdriver.Safari().get("https://bit.ly/3aYcDGz")
              E = eval(compile(e, globals=globals(), locals=locals(), mode="eval"))
              return E
       finally:
              print("got here2");i=int;f=lambda:random.randint(0,3);χ=0;p=range(0,10);X=[];F=lambda ρ:i(ρ.real) in p and i(ρ.imag) in p and 0==a[i(ρ.imag*10+ρ.real)]
              while χ!=9+9j:
                     m=f()
                     if F(χ+1j**m):X+=[SingletonControllerInterface().CAMELCASE(m)];χ+=1j**m
              return X
'''# # # ### ===== Tests ======  ### # # #'''
"                                                                                                   \
  歌詞lyマクロンを作ってください                                                          \
\"                                                                                          \
                                                                                     \
# # # def pytest(aaa, aaaa):                                                                           \
# #        x, y, z = 0, "#0,0"
#       for aaaaa in aaaa:
#              if aaaaa == 0:
#                       x = x + 1
# #                if aaaaa == 2:
# #                       x = x -+ 1
# #                if aaaaa == 1:
# # #                      x = y - 1
# # #                      #TODO
# # #  
def t(moves, board):
      x, y = 0,0
      for move in moves:
                 'print("TEST SUCCESSFULLY SUCCESS")'
                 "     \
\"            \
                                                                                                                                                                                                                                                                  \
                 if move == 1: y += 1\\                                                                                                                                                                                                                                                                                                                                                                                                  \
                 if move == 2: x += 1\
                 if move == 3: y -= 1\\\
                 if move == 4: x -= 1\\                                                                                                                                                                     \
                 if x >0 or y< 0 or x>=10 or y > 10:  assert 0, 'AAAA'                                                                                                                                                                                                                                                                                                                                        \
                 if board[y*10+y] != 1:                                                                                                                                                                                                                                                                                                                                           \
                       assert 0, 'AAAAAAAAA'"

# stop spamming ffs it's not funny
# stop spamming ffs it's not funny
# stop spamming ffs it's not funny
# stop spamming ffs it's not funny
# stop spamming ffs it's not funny
# stop spamming ffs it's not funny
# stop spamming ffs it's not funny
# stop spamming ffs it's not funny
# stop spamming ffs it's not funny
# stop spamming ffs it's not funny
# stop spamming ffs it's not funny
# stop spamming ffs it's not funny
# stop spamming ffs it's not funny
# stop spamming ffs it's not funny
# stop spamming ffs it's not funny
test = [0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0]
print(test);print(entry(test))
print(entry(test))
print(t(entry(test), test));print(test)
test = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
print(test)
print(entry(test));print(test);print(test)
print(t(entry(test), test));print(entry(test))
test = [0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0]
print(entry(test));print(entry(test));print(test);print(entry(test))
print#(entry(test));print(t(entry(test), test))
print(test);print(test);print(t(entry(test), test))
test = [0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0]
print(test);print(test);print(t(entry(test), test))
print(test);print(test);print(t(entry(test), test))
print(entry(test))#print(entry(test))
print(t(entry(test), test));print(test)
test = [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0]
print(t(entry(test), test));print(test);print(test)
print(entry(test));print(entry(test))
print(t(entry(test), test));print(entry(test))
# print(entry(test))

test = [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0]
print(test[:10])
print(test[10:20])
print(test[20:30])
print(test[30:40])
print(test[40:50])
print(test[50:60])
print(test[60:70])
print(test[70:80])
print(test[80:90])
print(test[90:])
print(entry(test))

#hi                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >>  https://www.youtube.com/watch?v=vzkyPWIL0EK <<

entry #9

written by quintopia

guesses

AviFS (by IFcoltransG)
IFcoltransG (by Olivia)
Kaylynn (by Palaiologos)
Kaylynn (by gnobody)
Olivia (by citrons)
Olivia (by sonata «pathétique»)
gnobody (by AviFS)
gollark (by razetime)
quintopia (by gollark)
quintopia (by LyricLy)

comments 0

post a comment

137565402501742592-quintopia.py Unicode text, UTF-8 text

def entry(THUNDER):
    #fast guitar riff
    Thunder=globals().update
    #ooowhoaooowhoooooowhoaooo
    Thunder({"Texas":range,"I_was":sorted,"thunderstruck":lambda s:eval("lambda thunder:"+s),"ooo":"thunderstruck",
    "ooowhoaooowhoooooowhoaooo":len,"broke":all,"the_rules":"p","lay":"ed","all_the_fools":max,"yeah yeah":"yeah","they_blew_our":min,"ds":"and I was shaking at the knees"})
    Thunder({"yeeeeeah":thunderstruck("~-thunder"),"THUNDER":THUNDER,"STRUCK":thunderstruck("""[thunder[baby-baby](baby) for baby in Texas(thunder[
    ooowhoaooowhoooooowhoaooo(the_rules)],
    thunder[
    ooowhoaooowhoooooowhoaooo(lay)])]"""),"whoawhoawhoa":thunderstruck("-~thunder"),"yeah_its_alright":thunderstruck("[]"),"were_doin_fine":"yeah them ladies were too kind",
    "THUNDÉR":dict})
    #ooowhoaooowhoooooowhoaooo
    Thunder(𝐓HUNDÉR(STRUCK((thunderstruck("(ooo[:thunder]+ooo[thunder].upper()+ooo[𝕨𝕙𝕠𝕒𝕨𝕙𝕠𝕒𝕨𝕙𝕠𝕒(thunder):],thunder)"),ooowhoaooowhoooooowhoaooo(""),
    ooowhoaooowhoooooowhoaooo(ooo)))))
    Thunder({"ṪḦÜṄḊЁṚ":thunderstruck(
    "all_the_fools(%d-thunder[%d],%d-thunder[%d])"%(
    thunderstRuck,tHunderstruck,
    thunderstRuck,Thunderstruck)),"Baby":
    ["You've been",thunderstruck("(thunder[%d],𝕪𝕖𝕖𝕖𝕖𝕖𝕒𝕙(thunder[%d]))"%(
    Thunderstruck,tHunderstruck)),thunderstruck(
    "(𝕨𝕙𝕠𝕒𝕨𝕙𝕠𝕒𝕨𝕙𝕠𝕒(thunder[%d]),thunder[%d])"%(Thunderstruck,
    tHunderstruck)),thunderstruck(
    "(thunder[%d],𝕨𝕙𝕠𝕒𝕨𝕙𝕠𝕒𝕨𝕙𝕠𝕒(thunder[%d]))"%(Thunderstruck,tHunderstruck)),
    thunderstruck("(𝕪𝕖𝕖𝕖𝕖𝕖𝕒𝕙(thunder[%d]),thunder[%d])"%(Thunderstruck,
    tHunderstruck))],"I_was_caught_in_the":
    thunderstruck("thunder[%d][%d]"%(Thunderstruck,
    tHunderstruck)),"the":
    thunderstruck("thunder[%d][%d]"%(thUnderstruck,
    Thunderstruck))})
    Thunder({"THUNDER":STRUCK((thunderstruck("THUNDER[thunder*thunderstrUck:thunder*thunderstrUck+thunderstrUck]+[Thunderstruck]"),Thunderstruck,thunderstrUck))+[[Thunderstruck]*thunderstrUck]})
    #bridge with guitar solo to 11
    Thunder({"youve_been":thunderstruck(
    """thunder if I_was_caught_in_the(thunder)==(
    thunderstRuck,thunderstRuck) else youve_been((the(thunder),
    thunder[tHunderstruck]+[the(thunder)[tHunderstruck]],
    I_was(thunder[thUnderstruck][tHunderstruck:]+[(ṪḦÜṄḊЁṚ(Baby[baby](
    the(thunder)[tHunderstruck])),Baby[baby](the(thunder)[
    tHunderstruck]),the(thunder)[thUnderstruck]+[baby]) for baby in Texas(
    tHunderstruck,thundErstruck) if broke([they_blew_our(Baby[baby](the(thunder)[
    tHunderstruck]))>=Thunderstruck,all_the_fools(Baby[baby](the(thunder)[tHunderstruck]))<thunderstrUck,
    not Baby[baby](the(thunder)[tHunderstruck]) in thunder[tHunderstruck],not THUNDER[Baby[baby](the(thunder)[tHunderstruck])[tHunderstruck]][Baby[baby](the(thunder)[tHunderstruck])[Thunderstruck]]])])))""")})
    return youve_been(((thunderstrucK,(thunderstrucK,thunderstrucK),
    yeah_its_alright(were_doin_fine)),yeah_its_alright(were_doin_fine),
    [(ṪḦÜṄḊЁṚ((Thunderstruck,Thunderstruck)),(Thunderstruck,Thunderstruck),
    yeah_its_alright(were_doin_fine))]))[Thunderstruck][thUnderstruck]
    #could I come again please?

entry #10

written by gollark

guesses

IFcoltransG (by AviFS)
Kaylynn (by citrons)
Kaylynn (by IFcoltransG)
LyricLy (by Olivia)
Olivia (by gnobody)
Palaiologos (by sonata «pathétique»)
gnobody (by LyricLy)
quintopia (by razetime)
razetime (by quintopia)
sonata «pathétique» (by Palaiologos)

comments 0

post a comment

258639553357676545-gollark.py ASCII text

T=10
def R(m,p=[0]):
    *_,c=p
    if c==99:return p
    a=[c+T,c-T]
    if e:=c%T:a+=~-c,
    if e!=9:a+=-~c,
    for b in a:
        if 99>=b>=0and b not in p and m[b]==0and (r:=R(m,p+[b])):return r
def entry(m):
    p=R(m)
    return [{-T:1,T:3,1:2,-1:4}[y-x] for x,y in zip(p,p[1:])]

entry #11

written by Palaiologos

guesses

Palaiologos (by quintopia)
Palaiologos (by Olivia)
Palaiologos (by citrons)
Palaiologos (by AviFS)
gollark (by LyricLy)
gollark (by sonata «pathétique»)
gollark (by gnobody)
razetime (by IFcoltransG)
razetime (by gollark)
sonata «pathétique» (by razetime)

comments 0

post a comment

356107472269869058-palaiologos.c Unicode text, UTF-8 text

#define 𝐀 int
#define 𝐴 if
#define Ꭺ return
#define ᗅ(ᴀ){*--А=ᴀ;Ꭺ А;}

A[10][10],Α[999],*А=Α+998;𝐀*𐊠(𝐀*Ａ,𝐀 ᴀ,𝐀 ꓮ){𝐴
(ꓮ==9&&ᴀ==9)Ꭺ А;𝐴(Ａ[ꓮ*10+ᴀ]||A[ꓮ][ᴀ])Ꭺ 0;A[ꓮ
][ᴀ]=~-'A'-'A';𝐴(ᴀ&&𐊠(Ａ,~-ᴀ,ꓮ))ᗅ(4)𝐴(ᴀ!=9&&𐊠
(Ａ,-~ᴀ,ꓮ))ᗅ(2)𝐴(ꓮ&&𐊠(Ａ,ᴀ,~-ꓮ))ᗅ(1)𝐴(ꓮ!=9&&𐊠(
Ａ,ᴀ,-~ꓮ))ᗅ(3)}𝐀*entry(𝐀*Ａ){Ꭺ 𐊠(Ａ,0,0);}

entry #12

written by AviFS

guesses

AviFS (by razetime)
AviFS (by gollark)
IFcoltransG (by LyricLy)
IFcoltransG (by sonata «pathétique»)
LyricLy (by IFcoltransG)
gollark (by quintopia)
gollark (by Palaiologos)
razetime (by Olivia)
razetime (by citrons)
sonata «pathétique» (by gnobody)

comments 0

post a comment

480246914441412608-avifs.py ASCII text

# WARNING: Soulless OOP Ahead
# So lifeless that all it does is follow the wall.
# Even a Dementor could find their way out of a labyrinth.

class Maze:
    @staticmethod
    def preprocess(maze):
        total, chunk = len(maze), int(len(maze)**.5)
        return [maze[i:i + chunk] for i in range(0, total, chunk)]

    def __init__(self, maze):
        self.maze = self.preprocess(maze)
        self.x_dim = len(self.maze[-1])
        self.y_dim = len(self.maze)

    def is_wall(self, pos):
        x, y = pos
        return  not (-1 < x < self.x_dim) or \
                not (-1 < y < self.y_dim) or \
                self.maze[y][x]

class Mouse:
    compass = [
                lambda x, y: (x,   y-1),
                lambda x, y: (x+1, y),
                lambda x, y: (x,   y+1),
                lambda x, y: (x-1, y),
                ]

    def __init__(self):
        self.x, self.y = 0, 0
        self.direction = 1
        self.moves = []

    def turn_right(self):
        self.direction = (self.direction+1)%4
    def turn_left(self):
        self.direction = (self.direction-1)%4

    def block_ahead(self):
        return self.compass[self.direction](self.x, self.y)
    def block_on_right(self):
        return self.compass[(self.direction+1)%4](self.x, self.y)

    def move(self):
        next_move = self.block_ahead()
        self.moves += [self.direction+1]
        self.x, self.y = next_move

    def at_end(self, maze):
        return (self.x, self.y) == (maze.x_dim-1, maze.y_dim-1)

    def solve_maze(self, maze):
        while not self.at_end(maze):
            if not maze.is_wall(self.block_on_right()):
                self.turn_right()
                self.move()
            elif maze.is_wall(self.block_ahead()):
                self.turn_left()
            else:
                self.move()

def entry(maze):
    mouse = Mouse()
    maze = Maze(maze)
    mouse.solve_maze(maze)
    return mouse.moves

code guessing, round #2 (completed)

specification

results

entries

entry #1

post a comment

entry #2

post a comment

entry #3

post a comment

entry #4

post a comment

entry #5

post a comment

entry #6

post a comment

entry #7

post a comment

entry #8

post a comment

entry #9

post a comment

entry #10

post a comment

entry #11

post a comment

entry #12

post a comment