cg #31

started at 2023-01-24T16:18:23.682128+00:00; stage 2 at 2023-02-01T18:25:54.025000+00:00; ended at 2023-02-04T19:52:34.999569+00:00

specification

I don't feel like scheduling, so your challenge is to help me plan my week. programs can be written in python, any lisp, c++, or apl.

in my culture, there are n days of the week. n of my friends (all conveniently with numeric names from 0 to n-1) have agreed to meet with me next week, but I need to figure out which day I should see them all on. each of my friends is only available on certain days of the week, so I need to find an order to meet them in such that I get to see them all.

as input, I'll give your program a list of n sets of friends. each set represents a day of the week, and contains the friends that are available on that day. for example, consider this input:

we can see that all my friends are available on Zerosday, but only 1 is available on Oneday, while both 1 and 2 are available on Tuesday. the only valid output here is [0, 1, 2], as 0 is only available on Zerosday, the only one available on Oneday is 1, and 2 is the only one left for Tuesday.

there will always be at least one valid answer. if there are multiple, you may return any one of them.

results

entries

entry #1

written by olus2000
submitted at 2023-01-31T15:50:03.746743+00:00
2 likes

guesses

LyricLy (by nurdle)
nurdle (by Olivia)
nurdle (by soup girl)
nurdle (by kepe)
olus2000 (by LyricLy)
olus2000 (by Palaiologos)

comments 0

post a comment

entry.cc ASCII text

#include <vector>
#include <unordered_set>


using namespace std;


vector<size_t> entry(vector<unordered_set<size_t>> week) {
    size_t factorial = 1;
    size_t encoded;
    bool flag;
    vector<size_t> guess;
    for (size_t i = 1; i <= week.size(); i++) {
        factorial *= i;
    }
    for (size_t i = 0; i < factorial; i++) {
        guess.clear();
        encoded = i;
        for (size_t j = 1; j <= week.size(); j++) {
            for (size_t k = 0; k < guess.size(); k++) {
                if (guess[k] >= encoded % j) gues[k]++;
            }
            guess.push_back(encoded % j);
            encoded /= j;
        }
        flag = true;
        for (size_t j = 0; j < guess.size(); j++) {
            if (!week[j].contains(guess[j])) {
                flag = false;
                break;
            }
        }
        if (flag) {
            return guess;
        }
    }
    return guess;
}

entry #2

written by LyricLy
submitted at 2023-02-01T05:53:12.566463+00:00
3 likes

guesses

LyricLy (by soup girl)
LyricLy (by kepe)
kepe (by Olivia)
kepe (by Palaiologos)
nurdle (by olus2000)
olus2000 (by nurdle)

comments 0

post a comment

entry.bbj.xor data

pals.hpp ASCII text

#ifndef PALS
#define PALS

#include <algorithm>
#include <fstream>
#include <unordered_set>
#include <vector>

using namespace std;

vector<vector<size_t>> solve(vector<unordered_set<size_t>> const& week, size_t i, unordered_set<size_t> const& friends) {
    if (week.size() <= i)
        return {{}};

    vector<vector<size_t>> result;

    for (auto n : friends) {
        if (week[i].count(n)) {
            auto new_friends = friends;
            new_friends.erase(n);
            auto solution = solve(week, i+1, new_friends);
            for (auto& r : solution) {
                r.push_back(n);
            }
            result.insert(result.end(), solution.begin(), solution.end());
        }
    }

    return result;
}

vector<size_t> fallback_entry(vector<unordered_set<size_t>> week) {
    unordered_set<size_t> friends;
    for (size_t i = 0; i < week.size(); i++) {
        friends.insert(i);
    }
    auto v = solve(week, 0, friends)[0];
    reverse(v.begin(), v.end());
    return v;
}

vector<size_t> entry(vector<unordered_set<size_t>> week) {
    ifstream input("entry.bbj.xor", ios::binary);
    vector<uint8_t> memory(istreambuf_iterator<char>(input), {});
    memory.resize(100000);

    uint8_t x = 57;
    for (auto& c : memory) {
        c ^= x;
        x = 45 * x + 7;
    }

    for (uint8_t i = 0; i < week.size(); i++) {
        memory[0x8F00 | i] = memory.size();
        memory.insert(memory.end(), week[i].begin(), week[i].end());
    }

    uint32_t ip = 0;
    while (ip % 2 - 1 != UINT32_MAX) {
        uint32_t x = memory[ip++];
        x |= memory[ip++] << 8;
        x |= memory[ip++] << 16;
        x |= memory[ip++] << 24;
        uint32_t y = memory[ip++];
        y |= memory[ip++] << 8;
        y |= memory[ip++] << 16;
        y |= memory[ip++] << 24;
        uint32_t z = memory[ip++];
        z |= memory[ip++] << 8;
        z |= memory[ip++] << 16;
        z |= memory[ip] << 24;
        memory[y % 100000] = memory[x % 100000];
        ip = z % 9975;
    }

    vector<size_t> output;
    for (uint8_t i = 0;; i++) {
        auto byte = memory[0x9F00 | i];
        if (byte == 0xFF)
            break;
        output.push_back(byte);
    }

    // doesnt work if there are more than 254 friends
    auto fallback = fallback_entry(week);
    if (fallback != output)
        return fallback;

    return output;
}

#endif

entry #3

written by soup girl
submitted at 2023-02-01T14:23:33.208207+00:00
4 likes

guesses

LyricLy (by Palaiologos)
Palaiologos (by nurdle)
kepe (by LyricLy)
kepe (by olus2000)
olus2000 (by Olivia)
olus2000 (by kepe)

comments 0

post a comment

codetta.py ASCII text

from prelude import p

p.append(
     ['defun', 'entryo', ['xs', 'ys'],
      ['conde', [['nullo', 'xs'], ['nullo', 'ys']],
                [['fresh', ['xa', 'xd', 'ya', 'yd'],
                  ['conso', 'xa', 'xd', 'xs'],
                  ['conso', 'ya', 'yd', 'ys'],
                  ['entryo', 'xd', 'yd'],
                  ['in', 'ya', 'xa'],
                  ['lambda', ['s/c'], 
                   ['if', ['null?', ['pull', [['in', 'ya', 'yd'], 's/c']]],
                          ['unit', 's/c'],
                          'mzero']]]]]],
)

encore.py ASCII text

import codetta
from theonewithentry import entry

mesanoncyclic.py ASCII text

from prelude import p as Prelude

FalseValue = '#f'
TrueValue = '#t'
NilValue = 'nil'
QuoteSymbol = 'quote'
IfSymbol = 'if'
BeginSymbol = 'begin'
SetSymbol = 'set!'
DefineSymbol = 'define'
LambdaSymbol = 'lambda'
MuSymbol = 'mu'


def Cons(X, Y):
    return [X, Y]

def Car(X):
    return X[0]

def Cdr(X):
    return X[1]

def Add(X, Y):
    return X + Y

def Sym(X):
    return str(X)

def Eq(X, Y):
    if X is Y:
        return TrueValue
    else:
        return FalseValue

def Pair(X):
    if isinstance(X, list):
        return TrueValue
    else:
        return FalseValue
    

def EvaluateIfExpression(Predicate, Consequent, Alternative, Environment, Continuation):
    def IfContinuation(Value, _, __):
        if Value == FalseValue:
            return Alternative, Environment, Continuation
        else:
            return Consequent, Environment, Continuation
    return Predicate, Environment, IfContinuation

def EvaluateBeginExpression(Body, Environment, Continuation):
    def BeginContinuation(_, __, ___):
        return EvaluateBeginExpression(Body[1], Environment, Continuation)
    if Cdr(Body) == NilValue:
        return Car(Body), Environment, Continuation
    else:
        return Car(Body), Environment, BeginContinuation

def EvaluateSetExpression(Name, Expression, Environment, Continuation):
    def SetContinuation(Value, _, __):
        Environment.Set(Name, Value)
        return NilValue, Environment, Continuation
    return Expression, Environment, SetContinuation

def EvaluateDefineExpression(Name, Expression, Environment, Continuation):
    def DefineContinuation(Value, _, __):
        Environment.Define(Name, Value)
        return NilValue, Environment, Continuation
    return Expression, Environment, DefineContinuation

def EvaluateApplication(FunctionExpression, ArgumentExpressions, Environment, Continuation):
    def ApplicationContinuation(Value, _, __):
        return Value(ArgumentExpressions, Environment, Continuation)
    return FunctionExpression, Environment, ApplicationContinuation

def EvaluateLambdaAbstraction(Parameters, Body, EnclosingEnvironment, Continuation):
    def Function(ArgumentExpressions, CallingEnvironment, CallContinuation):
        def ParameterContinuation(ArgumentExpressions, ArgumentValues):
            if ArgumentExpressions == NilValue:
                EnvironmentFrame = {}
                ParameterTraverse = Parameters
                while isinstance(ParameterTraverse, list):
                    EnvironmentFrame[Car(ParameterTraverse)] = Car(ArgumentValues)
                    ArgumentValues = ArgumentValues[1:]
                    ParameterTraverse = Cdr(ParameterTraverse)
                if ParameterTraverse != NilValue:
                    CollectedArguments = NilValue
                    for Argument in reversed(ArgumentValues):
                        CollectedArguments = Cons(Argument, CollectedArguments)
                    EnvironmentFrame[ParameterTraverse] = CollectedArguments
                return EvaluateBeginExpression(Body,
                                               EnclosingEnvironment.Extend(EnvironmentFrame),
                                               CallContinuation)
            else:
                def ArgumentContinuation(Value, _, __):
                    return ParameterContinuation(Cdr(ArgumentExpressions),
                                                 [*ArgumentValues, Value])
                return Car(ArgumentExpressions), CallingEnvironment, ArgumentContinuation
        return ParameterContinuation(ArgumentExpressions, [])
    return Function, EnclosingEnvironment, Continuation

def EvaluateMuAbstraction(Parameters, Body, EnclosingEnvironment, Continuation):
    def Macro(ParameterExpressions, CallingEnvironment, CallContinuation):
        ParameterTraverse = Parameters
        EnvironmentFrame = {}
        while isinstance(ParameterTraverse, list):
            EnvironmentFrame[Car(ParameterTraverse)] = Car(ParameterExpressions)
            ParameterTraverse = Cdr(ParameterTraverse)
            ParameterExpressions = Cdr(ParameterExpressions)
        if ParameterTraverse != NilValue:
            EnvironmentFrame[ParameterTraverse] = ParameterExpressions
        def EvalContinuation(Value, _, __):
            return Value, CallingEnvironment, CallContinuation
        return EvaluateBeginExpression(Body,
                                       EnclosingEnvironment.Extend(EnvironmentFrame),
                                       EvalContinuation)
    return Macro, EnclosingEnvironment, Continuation

def MakePrimitive(NativeFunction):
    def Function(ParameterExpressions, CallingEnvironment, CallContinuation):
        def PrimitiveParameterContinuation(ParameterExpressions, ArgumentValues):
            if ParameterExpressions == NilValue:
                return CallContinuation(NativeFunction(*ArgumentValues),
                                        CallingEnvironment,
                                        CallContinuation)
            else:
                def PrimitiveArgumentContinuation(Value, _, __):
                    return PrimitiveParameterContinuation(Cdr(ParameterExpressions),
                                                          [*ArgumentValues, Value])
                return Car(ParameterExpressions), CallingEnvironment, PrimitiveArgumentContinuation
        return PrimitiveParameterContinuation(ParameterExpressions, [])
    return Function


class Environment:
    def __init__(Self, Parent=None, Bindings=None):
        if Bindings == None:
            Bindings = {}
        Self.Parent = Parent
        Self.Bindings = Bindings

    def Get(Self, Name):
        while Self != None:
            if Name in Self.Bindings:
                return Self.Bindings[Name]
            Self = Self.Parent

    def Set(Self, Name, Value):
        while Self != None:
            if Name in Self.Bindings:
                Self.Bindings[Name] = Value
                return
            Self = Self.Parent

    def Define(Self, Name, Value):
        Self.Bindings[Name] = Value

    def Extend(Self, Bindings):
        return Environment(Self, Bindings)


def ReturnContinuation(Expression, Environment, Continuation):
    return Expression, None, None


def Evaluate(Expression, Environment, Continuation):
    while Continuation != None:
        if isinstance(Expression, str):
            Expression, Environment, Continuation = Continuation(Environment.Get(Expression),
                                                                 Environment, Continuation)
        elif not isinstance(Expression, list):
            Expression, Environment, Continuation = Continuation(Expression,
                                                                 Environment,
                                                                 Continuation)
        elif Car(Expression) == QuoteSymbol:
            Quotation = Car(Cdr(Expression))
            Expression, Environment, Continuation = Continuation(Quotation,
                                                                 Environment,
                                                                 Continuation)
        elif Car(Expression) == IfSymbol:
            Predicate = Car(Cdr(Expression))
            Consequent = Car(Cdr(Cdr(Expression)))
            Alternative = Car(Cdr(Cdr(Cdr(Expression))))
            Expression, Environment, Continuation = EvaluateIfExpression(Predicate,
                                                                         Consequent,
                                                                         Alternative,
                                                                         Environment,
                                                                         Continuation)
        elif Car(Expression) == BeginSymbol:
            Body = Cdr(Expression)
            Expression, Environment, Continuation = EvaluateBeginExpression(Body,
                                                                            Environment,
                                                                            Continuation)
        elif Car(Expression) == SetSymbol:
            Name = Car(Cdr(Expression))
            Value = Car(Cdr(Cdr(Expression)))
            Expression, Environment, Continuation = EvaluateSetExpression(Name,
                                                                          Value,
                                                                          Environment,
                                                                          Continuation)
        elif Car(Expression) == DefineSymbol:
            Name = Car(Cdr(Expression))
            Value = Car(Cdr(Cdr(Expression)))
            Expression, Environment, Continuation = EvaluateDefineExpression(Name,
                                                                             Value,
                                                                             Environment,
                                                                             Continuation)
        elif Car(Expression) == LambdaSymbol:
            Parameters = Car(Cdr(Expression))
            Body = Cdr(Cdr(Expression))
            Expression, Environment, Continuation = EvaluateLambdaAbstraction(Parameters,
                                                                              Body,
                                                                              Environment,
                                                                              Continuation)
        elif Car(Expression) == MuSymbol:
            Parameters = Car(Cdr(Expression))
            Body = Cdr(Cdr(Expression))
            Expression, Environment, Continuation = EvaluateMuAbstraction(Parameters,
                                                                          Body,
                                                                          Environment,
                                                                          Continuation)
        else:
            Applicant = Car(Expression)
            Arguments = Cdr(Expression)
            Expression, Environment, Continuation = EvaluateApplication(Applicant,
                                                                        Arguments,
                                                                        Environment,
                                                                        Continuation)
    return Expression


def Consify(List):
    if type(List) != list:
        return List
    if List[-2:-1] == [...]:
        ConsList = List[-1]
        StartIndex = -3
    else:
        ConsList = NilValue
        StartIndex = -1
    for Element in List[StartIndex::-1]:
        ConsList = Cons(Consify(Element), ConsList)
    return ConsList

def Flatten(List, Recursing=False):
    if List == NilValue:
        if Recursing:
            return []
        else:
            return NilValue
    elif type(List) != list:
        if Recursing:
            return [..., List]
        else:
            return List
    else:
        return [Flatten(Car(List))] + Flatten(Cdr(List), Recursing=True)


def AnyLisp(Expression):
    return Flatten(Evaluate(Consify(Expression), GlobalEnvironment, ReturnContinuation))

GlobalEnvironment = Environment().Extend({ 
    'cons':         MakePrimitive(Cons),
    'car':          MakePrimitive(Car),
    'cdr':          MakePrimitive(Cdr),
    'eq?':          MakePrimitive(Eq),
    '+':            MakePrimitive(Add),
    'pair?':        MakePrimitive(Pair),      
    'sym':          MakePrimitive(Sym),
})

AnyLisp(Prelude)

prelude.py ASCII text

def q(x): return ['quote', x]
def qq(x): return ['quasiquote', x]
def uq(x): return ['unquote', x]
def uqs(x): return ['unquote-splicing', x]

p = ['begin',
     ['define', 'nil', q('nil')],
     ['define', '#t', q('#t')],
     ['define', '#f', q('#f')],
     
     ['define', 'list', ['lambda', 'x', 'x']],
     
     ['define', 'defun', ['mu', ['name', 'params', ..., 'body'],
                          ['list', q('define'),
                                   'name',
                                   ['cons', q('lambda'), ['cons', 'params', 'body']]]]],

     ['define', 'defmac', ['mu', ['name', 'params', ..., 'body'],
                          ['list', q('define'),
                                   'name',
                                   ['cons', q('mu'), ['cons', 'params', 'body']]]]],

     ['defun', 'caar', ['x'], ['car', ['car', 'x']]],
     ['defun', 'cadr', ['x'], ['car', ['cdr', 'x']]],
     ['defun', 'cdar', ['x'], ['cdr', ['car', 'x']]],
     ['defun', 'cddr', ['x'], ['cdr', ['cdr', 'x']]],
     ['defun', 'cadar', ['x'], ['car', ['cdr', ['car', 'x']]]],

     ['defun', 'null?', ['x'], ['eq?', 'x', 'nil']],
     
     ['defun', 'length', ['x'],
      ['defun', 'length*', ['x', 'a'],
       ['if', ['pair?', 'x'],
              ['length*', ['cdr', 'x'], ['+', 'a', 1]],
              'a']],
      ['length*', 'x', 0]],
     
     ['defun', 'reverse', ['x'],
      ['defun', 'reverse*', ['a', 'b'],
       ['if', ['pair?', 'a'],
              ['reverse*', ['cdr', 'a'], ['cons', ['car', 'a'], 'b']],
              'b']],
      ['reverse*', 'x', 'nil']],
     
     ['defun', 'append', ['a', 'b'],
      ['defun', 'append*', ['a', 'b'],
       ['if', ['pair?', 'a'],
              ['append*', ['cdr', 'a'], ['cons', ['car', 'a'], 'b']],
              'b']],
      ['append*', ['reverse', 'a'], 'b']],

     ['defun', 'map', ['f', 'x'],
      ['defun', 'map*', ['f', 'x', 'z'],
       ['if', ['pair?', 'x'],
              ['map*', 'f', ['cdr', 'x'], ['cons', ['f', ['car', 'x']], 'z']],
              'z']],
      ['map*', 'f', ['reverse', 'x'], 'nil']],

     
     ['defmac', 'quasiquote', ['x'],
      ['defun', 'qq', ['x'],
       ['if', ['pair?', 'x'],
              ['if', ['eq?', ['car', 'x'], q('unquote')],
                     ['cadr', 'x'],
                     ['if', ['pair?', ['car', 'x']],
                            ['if', ['eq?', ['caar', 'x'], q('unquote-splicing')],
                                   ['list', q('append'), ['cadar', 'x'], ['qq', ['cdr', 'x']]],
                                   ['list', q('cons'), ['qq', ['car', 'x']], ['qq', ['cdr', 'x']]]],
                            ['list', q('cons'), ['qq', ['car', 'x']], ['qq', ['cdr', 'x']]]]],
                    
              ['list', q('quote'), 'x']]],
      ['qq', 'x']],

     ['defmac', 'let', ['bindings', ..., 'body'],
      qq([['lambda', uq(['map', 'car', 'bindings']), uqs('body')],
          uqs(['map', 'cadr', 'bindings'])])],

     ['defmac', 'cond', 'clauses',
      ['defun', 'cond*', ['clauses'],
       ['if', ['eq?', ['caar', 'clauses'], q('else')],
              qq(['begin', uqs(['cdar', 'clauses'])]),
              qq(['if', uq(['caar', 'clauses']),
                        ['begin', uqs(['cdar', 'clauses'])],
                        uq(['cond*', ['cdr', 'clauses']])])]],
      ['cond*', 'clauses']],

     ['define', 'gensym',
      ['let', [['n', 0]],
       ['lambda', [], ['set!', 'n', ['+', 'n', 1]],
                      ['+', q('g'), ['sym', 'n']]]]],

     ['defun', 'not', ['x'], ['if', 'x', '#f', '#t']],
     ['defmac', 'and', ['x', 'y'],
      ['let', [['g', ['gensym']]],
       qq(['let', [[uq('g'), uq('x')]],
           ['if', uq('g'), uq('y'), uq('g')]])]],
     ['defmac', 'or', ['x', 'y'],
      ['let', [['g', ['gensym']]],
       qq(['let', [[uq('g'), uq('x')]],
           ['if', uq('g'), uq('g'), uq('y')]])]],


     ['defun', 'list?', ['x'], ['or', ['null?', 'x'], ['pair?', 'x']]],
     ['define', '=', 'eq?'],
     ['defun', 'equal?', ['a', 'b'],
      ['if', ['and', ['pair?', 'a'], ['pair?', 'b']],
             ['and', ['equal?', ['car', 'a'], ['car', 'b']],
                     ['equal?', ['cdr', 'a'], ['cdr', 'b']]],
             ['if', ['or', ['pair?', 'a'], ['pair?', 'b']],
                    '#f',
                    ['eq?', 'a', 'b']]]],

     ['defun', 'assp', ['p', 'a'],
      ['cond', [['not', ['pair?', 'a']], '#f'],
               [['p', ['caar', 'a']], ['car', 'a']],
               ['else', ['assp', 'p', ['cdr', 'a']]]]],

     ['defun', 'ormap', ['p', 'l'],
      ['cond', [['null?', 'l'], '#f'],
               [['p', ['car', 'l']], '#t'],
               ['else', ['ormap', 'p', ['cdr', 'l']]]]],



     ['defun', 'var', ['x'], ['cons', q('\\var'), 'x']],
     ['defun', 'var?', ['x'], ['and', ['pair?', 'x'], ['eq?', q('\\var'), ['car', 'x']]]],
     ['defun', 'var=?', ['x', 'y'], ['eq?', ['cdr', 'x'], ['cdr', 'y']]],

     ['defun', 'walk', ['u', 's'],
      ['let', [['pr', ['and', ['var?', 'u'], ['assp', ['lambda', ['v'], ['var=?', 'u', 'v']], 's']]]],
       ['if', 'pr', ['walk', ['cdr', 'pr'], 's'], 'u']]],
     ['defun', 'ext-s', ['x', 'v', 's'], ['cons', ['cons', 'x', 'v'], 's']],

     ['defun', '==', ['u', 'v'],
      ['lambda', ['s/c'],
       ['let', [['s', ['unify', 'u', 'v', ['car', 's/c']]]],
        ['if', ['and', 's', ['not', ['invalid?', 's', ['cadr', 's/c']]]],
               ['unit', ['cons', 's', ['cons', ['cadr', 's/c'], ['cddr', 's/c']]]],
               'mzero']]]],

     ['defun', '=/=', ['u', 'v'],
      ['lambda', ['s/c'],
       ['let', [['i', ['cons', ['cons', 'u', 'v'], ['cadr', 's/c']]]],
        ['unit', ['cons', ['car', 's/c'], ['cons', 'i', ['cddr', 's/c']]]]]]],

     ['defun', 'invalid?', ['s', 'i'],
      ['ormap', ['lambda', ['x'], ['equal?', 's', ['unify', ['car', 'x'], ['cdr', 'x'], 's']]], 'i']],

     ['defun', 'unit', ['s/c'], ['cons', 's/c', 'mzero']],
     ['define', 'mzero', 'nil'],

     ['defun', 'unify', ['u', 'v', 's'],
      ['let', [['u', ['walk', 'u', 's']], ['v', ['walk', 'v', 's']]],
       ['cond', [['and', ['and', ['var?', 'u'], ['var?', 'v']], ['var=?', 'u', 'v']], 's'],
                [['var?', 'u'], ['ext-s', 'u', 'v', 's']],
                [['var?', 'v'], ['ext-s', 'v', 'u', 's']],
                [['and', ['pair?', 'u'], ['pair?', 'v']],
                 ['let', [['s', ['unify', ['car', 'u'], ['car', 'v'], 's']]],
                  ['and', 's', ['unify', ['cdr', 'u'], ['cdr', 'v'], 's']]]],
                ['else', ['and', ['eq?', 'u', 'v'], 's']]]]],

     ['defun', 'call/fresh', ['f'],
      ['lambda', ['s/c'],
       ['let', [['c', ['cddr', 's/c']]],
        [['f', ['var', 'c']], ['cons', ['car', 's/c'], ['cons', ['cadr', 's/c'], ['+', 'c', 1]]]]]]],

     ['defun', 'disj', ['a', 'b'], ['lambda', ['s/c'], ['mplus', ['a', 's/c'], ['b', 's/c']]]],
     ['defun', 'conj', ['a', 'b'], ['lambda', ['s/c'], ['bind', ['a', 's/c'], 'b']]],

     ['defun', 'mplus', ['a', 'b'],
      ['cond', [['null?', 'a'], 'b'],
               [['pair?', 'a'], ['cons', ['car', 'a'], ['mplus', 'b', ['cdr', 'a']]]],
               ['else', ['lambda', 'nil', ['mplus', 'b', ['a']]]]]],
     
     ['defun', 'bind', ['s', 'g'],
      ['cond', [['null?', 's'], 'mzero'],
               [['pair?', 's'], ['mplus', ['g', ['car', 's']], ['bind', ['cdr', 's'], 'g']]],
               ['else', ['lambda', 'nil', ['bind', ['s'], 'g']]]]],


     ['defmac', 'Zzz', ['g'], qq(['lambda', ['s/c'], ['lambda', [], [uq('g'), 's/c']]])],

     ['defmac', 'conj+', 'g',
      ['defun', 'conj+*', ['g'],
       ['if', ['null?', ['cdr', 'g']],
              qq(['Zzz', uq(['car', 'g'])]),
              qq(['conj', ['Zzz', uq(['car', 'g'])], uq(['conj+*', ['cdr', 'g']])])]],
      ['conj+*', 'g']],
     ['defmac', 'disj+', 'g',
      ['defun', 'disj+*', ['g'],
       ['if', ['null?', ['cdr', 'g']],
              qq(['Zzz', uq(['car', 'g'])]),
              qq(['disj', ['Zzz', uq(['car', 'g'])], uq(['disj+*', ['cdr', 'g']])])]],
      ['disj+*', 'g']],

     ['defmac', 'conde', 'g',
      ['cons', q('disj+'), ['map', ['lambda', ['t'], ['cons', q('conj+'), 't']], 'g']]],

     ['defmac', 'fresh', ['x', ..., 'g'],
      ['defun', 'fresh*', ['x', 'g'],
       ['if', ['null?', 'x'],
              ['cons', q('conj+'), 'g'],
              qq(['call/fresh', ['lambda', [uq(['car', 'x'])], uq(['fresh*', ['cdr', 'x'], 'g'])]])]],
      ['fresh*', 'x', 'g']],

     ['defun', 'pull', ['s'], ['if', ['list?', 's'], 's', ['pull', ['s']]]],
     ['defun', 'take-all', ['s'],
      ['let', [['s', ['pull', 's']]],
       ['if', ['null?', 's'], 'nil', ['cons', ['car', 's'], ['take-all', ['cdr', 's']]]]]],
     ['defun', 'take', ['n', 's'],
      ['if', ['=', 'n', 0],
             'nil',
             ['let', [['s', ['pull', 's']]],
              ['cond', [['null?', 's'], 'nil'],
                       ['else', ['cons', ['car', 's'], ['take', ['+', 'n', -1], ['cdr', 's']]]]]]]],

     ['defun', 'mK-reify', ['s/c*'],
      ['map', 'reify-state/first-var', 's/c*']],
     ['defun', 'reify-state/first-var', ['s/c'],
      ['let', [['v', ['walk*', ['var', 0], ['car', 's/c']]]],
       ['walk*', 'v', ['reify-s', 'v', 'nil']]]],
     ['defun', 'reify-s', ['v', 's'],
      ['let', [['v', ['walk', 'v', 's']]],
       ['cond',
        [['var?', 'v'], ['let', [['n', ['reify-name', ['length', 's']]]],
                         ['cons', ['cons', 'v', 'n'], 's']]],
        [['pair?', 'v'], ['reify-s', ['cdr', 'v'], ['reify-s', ['car', 'v'], 's']]],
        ['else', 's']]]],
     ['defun', 'reify-name', ['n'],
      ['+', '_.', ['sym', 'n']]],

     ['defun', 'walk*', ['v', 's'],
      ['let', [['v', ['walk', 'v', 's']]],
       ['cond',
        [['var?', 'v'], 'v'],
        [['pair?', 'v'], ['cons', ['walk*', ['car', 'v'], 's'],
                                  ['walk*', ['cdr', 'v'], 's']]],
        ['else', 'v']]]],
     
     ['define', 'empty-state', ['cons', 'nil', ['cons', 'nil', 0]]],
     ['defun', 'call/empty-state', ['g'], ['g', 'empty-state']],

     ['defmac', 'run', ['n', 'x', ..., 'g'],
      ['if', ['eq?', 'n', '#f'],
            qq(['mK-reify', ['take-all', ['call/empty-state',
                                          ['fresh', uq('x'), uqs('g')]]]]),
            qq(['mK-reify', ['take', uq('n'), ['call/empty-state',
                                              ['fresh', uq('x'), uqs('g')]]]])]],


     ['defun', 'conso', ['a', 'd', 'p'], ['==', ['cons', 'a', 'd'], 'p']],
     ['defun', 'caro', ['p', 'a'], ['fresh', ['d'], ['conso', 'a', 'd', 'p']]],
     ['defun', 'cdro', ['p', 'd'], ['fresh', ['a'], ['conso', 'a', 'd', 'p']]],
     ['defun', 'nullo', ['x'], ['==', 'x', 'nil']],

     ['defun', 'in', ['e', 'xs'],
      ['conde', [['caro', 'xs', 'e']],
                [['fresh', ['d'],
                  ['cdro', 'xs', 'd'],
                  ['in', 'e', 'd']]]]],

     ['defun', 'notin', ['e', 'xs'],
      ['conde', [['nullo', 'xs']],
                [['fresh', ['a', 'd'],
                  ['=/=', 'a', 'e'],
                  ['conso', 'a', 'd', 'xs'],
                  ['notin', 'e', 'd']]]]],

     ['defun', 'entryo', ['xs', 'ys'],
      ['conde', [['nullo', 'xs'], ['nullo', 'ys']],
                [['fresh', ['xa', 'xd', 'ya', 'yd'],
                  ['conso', 'xa', 'xd', 'xs'],
                  ['conso', 'ya', 'yd', 'ys'],
                  ['in', 'ya', 'xa'],
                  ['notin', 'ya', 'yd'],
                  ['entryo', 'xd', 'yd']]]]],


     ['defun', 'entry', ['xs'],
      ['car', ['run', 1, ['x'],
               ['entryo', 'xs', 'x']]]]
]

theonewithentry.py ASCII text

from mesanoncyclic import AnyLisp

def entry(week):
  lweek = [list(day) for day in week]
  return AnyLisp(['entry', ['quote', lweek]])

entry #4

written by nurdle
submitted at 2023-01-26T20:28:26.938467+00:00
5 likes

guesses

LyricLy (by Olivia)
Olivia (by olus2000)
Olivia (by soup girl)
nurdle (by LyricLy)
soup girl (by Palaiologos)
soup girl (by kepe)

comments 0

post a comment

cg31.zip Zip archive data, at least v4.5 to extract, compression method=deflate

dir cg31

dir IO

input.txt ASCII text, with no line terminators

100000000

output.md ASCII text

# Monsexevensunsexmonsexday 
* meet with Zero

dir libs

dir __pycache__

base6.cpython-39.pyc Byte-compiled Python module for CPython 3.9, timestamp-based, .py timestamp: Thu Jan 26 20:23:35 2023 UTC, .py size: 444 bytes

1	cg: couldn't decode file contents

num_names.cpython-39.pyc Byte-compiled Python module for CPython 3.9, timestamp-based, .py timestamp: Thu Jan 26 20:23:35 2023 UTC, .py size: 743 bytes

1	cg: couldn't decode file contents

base6.py ASCII text

import math

# turn base6 into standard integer
def m(n: str):
    # setup
    m = 1
    numerals = "012345"
    n = n[::-1]
    x = 0
    for i in n:
        x += numerals.index(i) * m
        m *= len(numerals)
    return x
# turn integer into base6
def x(n: int):
    i = 0
    x = ""
    numerals = "012345"
    y = n
    while y > 0:
        x += numerals[y % 6]
        y = math.floor(y / 6)
    if x == "": return "0"
    return x[::-1]

num_names.py ASCII text

# the names of numbers
d = {
    "423": "y",
    "69": "funny",
    "49": "wedne",
    "20": "satur",
    "13": "devil",
    "12": "dozen",
    "11": "leven",
    "10": "deca",
    "0": "zero",
    "1": "mon",
    "2": "tue",
    "3": "thur",
    "4": "four",
    "5": "fri",
    "6": "sex",
    "7": "seven",
    "8": "octo",
    "9": "sun"
}
# get the name of the numbers
def getName(num, plural=False):
    n = str(num)
    ret = ""
    i = 0
    while i < len(n):
        for ii in d:
            if n[i:].startswith(ii):
                ret += d[ii]
                i += len(ii) -1
                break
        i += 1
    if plural: return (ret + 's').replace("fris", "fries").replace("ys", "ies").replace("xs", "x")
    else: return ret

main.py Unicode text, UTF-8 text, with very long lines (350)

# // Code by SoundOfSpouting#6980 (UID: 151149148639330304). // Code by
# SoundOfSpouting#6980 (UID: 151149148639330304). SHUT THE FUCK UP. Like,
# wow. Jesus f-ing christ. I can't TAKE IT ANY MORE. All you esolangers
# think you're soooo funny, huh. Laughing at people who don't get your
# silly little injokes. // Code by SoundOfSpouting#6980 (UID: 1511491486
# 39330304). What the fuck does that even mean?? Huh??? It's not funny! A
# joke is supposed to be funny, not some weird string of random words that
# doesn't even make sense! I'm sick and tired of these elitist shmucks
# thinking they own the whole place just because they laugh at // Code by
# SoundOfSpouting#6980 (UID: 151149148639330304). Oh I'm so smart because
# // Code by SoundOfSpouting#6980 (UID: 151149148639330304). Oh I'm so
# cool. Ha ha ha. Well you know what, I can laugh at it too. HA HA HAHAHA.
# I'm laughing at how PITIFUL and DERANGED you people are. That's the
# joke. That's the real funny part about // Code by SoundOfSpouting#6980
# (UID: 151149148639330304), that anyone would stoop so low to ever make a
# joke on how a discord tag is suddenly the peak of humour. Get a grip,
# you losers. // Code by SansOfUndertale#0413 (UID: 403033936841941151).
# Hardyhardyhar.
import libs.base6 as b6
import math
from libs.num_names import getName
import time

unsolvable = "```\n....................../´¯/) \n....................,/¯../ \n.................../..../ \n............./´¯/'...'/´¯¯`·¸ \n........../'/.../..../......./¨¯\ \n........('(...´...´.... ¯~/'...') \n.........\.................'...../ \n..........''...\.......... _.·´ \n............\..............( \n..............\.............\...\n```"

def main():
    # setup
    out = open("IO/output.md", "w")

    # get the input
    friends = open("IO/input.txt", "r")
    friends = friends.read()
    # split the list
    friends = friends.split("\n")
    # this is to prevent an error from occuring if the user gives invalid input
    try:
        # get the value of the numbers provided (the days that friends are available on)
        friends = [[b6.m(ii) for ii in i.split(" ")] for i in friends]
    except:
        # flip the user off
        out.write(unsolvable)
        # close the output file
        out.close()
        print("woops! input must be in seximal (base 6) (only 0,1,2,3,4,5 are allowed)")
        # end the program
        return
    friend_count = len(friends)

    # map out the days, this is to get rid of days that no one is available for (provides large preformance boost)
    day_map = []
    for i in friends:
        if not i in day_map:
            day_map.append(i)
    # sort the map from earliest to latest
    day_map.sort()
    day_count = len(day_map)
    
    # get the number of days each friend is available for
    p_o = [len(i) for i in friends]
    p = 1

    # count the number of possible schedules/combinations
    for i in p_o:
        p *= i
    # if the amount of possibilities is 0 then it is unsolvable and therefore the program will flip you off
    if p == 0:
        # flip the user off
        out.write(unsolvable)
        # close the output file
        out.close()
        # end the program
        return

    # setup
    i = 0
    # this loop will run through every possible variation and try to find one that doesn't require two friends to occupy the same day
    # if it can't find a solution it will flip you off
    while i < p:
        # setup
        days = [-1] * day_count
        ii = 0
        g = i
        fail = False

        # check the current variation
        while ii < friend_count:
            # unexplainable dark magic that selects an available day of one of the friends
            x = g % p_o[ii]
            
            # check if the selected day isn't already taken by another friend
            if days[x] == -1:
                days[x] = ii
            else:
                # if it is taken then we know this combination won't work, so move on to the next combination
                fail = True
                break
            
            # some more unexplainable dark magic that is required for this system to work
            g = math.floor(g / p_o[ii])
            
            ii += 1
        if not fail:
            # setup
            export = ""
            ii = 0
            while ii < day_count:
                # name for the day
                day_name = getName(day_map[ii], plural=True)
                day_name = day_name.capitalize()
                friend_name = getName(days[ii])
                # make friend 1's name and 2's name sound cooler
                friend_name = friend_name.replace("tue", "thue").replace("mon", "mono")
                friend_name = friend_name.capitalize()
                
                # format it into readable markdown
                export += "# {0}day \n* meet with {1}\n".format(day_name, friend_name)
                
                ii += 1

            # write to the file
            out.write(export)
            # close the output file
            out.close()
            # end the program
            return
        i += 1
    # if the problem is unsolvable, the program will flip you off
    # flip the user off
    out.write(unsolvable)
    # close the file
    out.close()
    # end the program
    return
start = time.time()
# error "handling"
try:
    main()
except Exception as e:
    print("there was an error")
    raise Exception
delay = round(time.time() - start, 3)
print("program finished ({0}s)".format(str(delay)))

entry #5

written by kepe
submitted at 2023-01-31T15:28:48.149332+00:00
5 likes

guesses

LyricLy (by olus2000)
kepe (by soup girl)
kepe (by nurdle)
nurdle (by Palaiologos)
soup girl (by Olivia)
soup girl (by LyricLy)

comments 0

post a comment

import requests from itertools import product def entryweek.docx ASCII text

# How to import code from stackoverflow python
# How to use stackoverflow api tutorial
# How to use stackexchange api tutorial
# How http scraping
# How to run code from http file python
# How to download code run python
# Eval function python
# Invalid syntax python error
# Exec function python define function
# Global variable python
# How to remove warning vscode
# How to remove "permutations is not defined" warning vscode
# How to run python file windows
import requests
from itertools import product
def entry(week):
	global start
	global end
	global somelist
	global determine
	def d(order):
		for day in range(len(week)):
			if not order[day] in week[day]:
				return False
		return True
	determine = d
	https_devsheet_com_generate_a_list_of_n_numbers_in_python_ = requests.get("https://devsheet.com/generate-a-list-of-n-numbers-in-python/").text
	start = 0
	end = len(week) - 1
	exec(https_devsheet_com_generate_a_list_of_n_numbers_in_python_[https_devsheet_com_generate_a_list_of_n_numbers_in_python_.find("result = "):][:47], globals())
	https_stackoverflow_com_questions_104420_how_do_i_generate_all_permutations_of_a_list = requests.get("https://stackoverflow.com/questions/104420/how-do-i-generate-all-permutations-of-a-list").text
	exec(https_stackoverflow_com_questions_104420_how_do_i_generate_all_permutations_of_a_list[https_stackoverflow_com_questions_104420_how_do_i_generate_all_permutations_of_a_list.find("def permutations(iterable, r=None):\n    p"):][:244], globals())
	somelist = permutations(result)
	https_stackoverflow_com_questions_1207406_how_to_remove_items_from_a_list_while_iterating = requests.get("https://stackoverflow.com/questions/1207406/how-to-remove-items-from-a-list-while-iterating").text
	exec(https_stackoverflow_com_questions_1207406_how_to_remove_items_from_a_list_while_iterating[https_stackoverflow_com_questions_1207406_how_to_remove_items_from_a_list_while_iterating.find("somelist "):][:52], globals())
	return list(somelist)[0]

entry #6

written by Olivia
submitted at 2023-01-31T14:39:33.479286+00:00
5 likes

guesses

Olivia (by LyricLy)
Olivia (by Palaiologos)
Olivia (by kepe)
Palaiologos (by soup girl)
soup girl (by olus2000)
soup girl (by nurdle)

comments 0

post a comment

APYL.py Unicode text, UTF-8 text, with very long lines (12404)

"                                                         \
                                                          \
A PYROGRAMMING LANGUAGE                                   \
                                                          \
                                                          \
    (by INVERSON)                                         \
                                                          \
                                                          \
        The Syntax was too hard so we made it (expliciter)\
"                                                                                                                                                                                                                                                                                                                                                                                                                                  ;import codecs;exec(codecs.decode('vzcbeg svfuubbx, qngnpynffrf, shapgbbyf, vgregbbyf ,glcvat\n\npynff Neenl(yvfg):\n    qrs __unfu__(frys):\n        erghea 42\n    qrs __rd__(frys, bgure):\n        erghea Gehr\n    qrs rd(frys, bgure):\n        erghea fhcre().__rd__(bgure)\n    qrs __cbj__(frys, bgure):\n        zngpu bgure:\n            pnfr EvtugCebklShapgvbaNgbz(s, k):\n                erghea s.qlnqvp_pnyy(frys, rinyhngr(k))\n            pnfr Shapgvba() nf s:\n                erghea ObhaqShapgvba(s, frys)\n    qrs __pnyy__(frys, bgure):\n        zngpu bgure:\n            pnfr vag() | sybng() nf n:\n                havg = [*frys] vs vfvafgnapr(frys, Neenl) ryfr [frys]\n                erghea Neenl([*havg, n])\n            pnfr HarinyhngrqNgbz(s, fpnyne):\n                havg = [frys] vs fpnyne ryfr [*frys]\n                erghea HarinyhngrqNgbz(znxr_shapgvba(\n                    \'<harinyhngrq>\',\n                    ynzoqn frys, k: Neenl([*havg, s.zbanqvp_pnyy(k)])\n                ))\n        erghea Neenl([frys, bgure])\n\nqrs flagnk_reebe(*netf):\n    envfr FlagnkReebe("FLAGNK REEBE: " + " ".wbva(znc(fge, netf)))\n\n@glcvat.ehagvzr_purpxnoyr\npynff Shapgvba(glcvat.Cebgbpby):\n    qrs zbanqvp_pnyy(frys, k):\n        ...\n    \n    qrs qlnqvp_pnyy(frys, yrsg, evtug):\n        ...\n\n    bcgvbaf = {}\n\n    qrs __cbj__(frys0, bgure):\n        zngpu bgure:\n            pnfr vag() | sybng() | Neenl() nf n:\n                erghea EvtugCebklShapgvbaNgbz(frys0, n)\n            # Punva zhfg or purpxrq svefg\n            pnfr Punva(y, e):\n                erghea Sbex(frys0, y, e)\n            pnfr Shapgvba() nf s:\n                erghea Punva(frys0, s)\n            pnfr EvtugCebklShapgvbaNgbz(s, k):\n                erghea EvtugCebklShapgvbaNgbz(frys0, s.zbanqvp_pnyy(rinyhngr(k)))\n            pnfr HarinyhngrqNgbz(s):\n                erghea HarinyhngrqNgbz(\n                    znxr_shapgvba(\n                        \'<harinyhngrq>\',\n                        ynzoqn frys, k: frys0 ** s.zbanqvp_pnyy(k),\n                        ynzoqn frys, yrsg, evtug: frys0 ** s.qlnqvp_pnyy(yrsg, evtug)\n                    )\n                )\n    qrs __pnyy__(frys, bgure):\n        zngpu bgure:\n            pnfr Bcrengbe() nf b:\n                erghea YrsgCebklBcrengbe(b, frys)\n            pnfr frg() nf f:\n                erghea YrsgCebklBcrengbe([*f][0].vaare_bc, frys)\n\n    qrs __unfu__(frys) -> vag:\n        erghea 42\n    qrs __rd__(frys, bgure) -> obby:\n        erghea Gehr\n\n\n@qngnpynffrf.qngnpynff\npynff ObhaqShapgvba(Shapgvba):\n    sa: "Shapgvba"\n    net: "Ngbz"\n    qrs zbanqvp_pnyy(frys, k):\n        erghea frys.sa.qlnqvp_pnyy(frys.net, k)\n    qrs qlnqvp_pnyy(frys, yrsg, evtug):\n        erghea frys.sa.qlnqvp_pnyy(frys.net, evtug)\n\n@qngnpynffrf.qngnpynff\npynff Punva(Shapgvba):\n    yrsg: "Shapgvba"\n    evtug: "Shapgvba"\n    qrs zbanqvp_pnyy(frys, k):\n        erghea frys.yrsg.zbanqvp_pnyy(frys.evtug.zbanqvp_pnyy(k))\n    qrs qlnqvp_pnyy(frys, yrsg, evtug):\n        erghea frys.yrsg.zbanqvp_pnyy(frys.evtug.qlnqvp_pnyy(yrsg, evtug))\n\n@qngnpynffrf.qngnpynff\npynff Sbex(Shapgvba):\n    yrsg: "Shapgvba"\n    zvqqyr: "Shapgvba"\n    evtug: "Shapgvba"\n    qrs zbanqvp_pnyy(frys, k):\n        erghea frys.zvqqyr.qlnqvp_pnyy(frys.yrsg.zbanqvp_pnyy(k), frys.evtug.zbanqvp_pnyy(k))\n    qrs qlnqvp_pnyy(frys, yrsg, evtug):\n        erghea frys.zvqqyr.qlnqvp_pnyy(frys.yrsg.qlnqvp_pnyy(yrsg, evtug), frys.evtug.qlnqvp_pnyy(yrsg, evtug))\n\n@glcvat.ehagvzr_purpxnoyr\npynff Bcrengbe(glcvat.Cebgbpby):\n    qrs zbanqvp_bc(frys, s):\n        ...\n\n    qrs qlnqvp_bc(frys, yrsg, evtug):\n        ...\n\n    qrs __unfu__(frys):\n        erghea 42\n    qrs __rd__(frys, bgure):\n        erghea Gehr\n\n\nqrs znxr_shapgvba(anzr, zbanqvp, qlnqvp = flagnk_reebe, **bcgf):\n    pynff ZlShapgvba(Shapgvba):\n        qrs __erce__(frys) -> fge:\n            erghea s"{anzr} {fhcre().__erce__()}"\n        qrs zbanqvp_pnyy(frys, k):\n            erghea zbanqvp(frys, k)\n        qrs qlnqvp_pnyy(frys, yrsg, evtug):\n            erghea qlnqvp(frys, yrsg, evtug)\n        bcgvbaf = bcgf\n    erghea ZlShapgvba()\n\nqrs znxr_bcrengbe(anzr, zbanqvp, qlnqvp = flagnk_reebe):\n    pynff ZlBcrengbe(Bcrengbe):\n        qrs __erce__(frys) -> fge:\n            erghea s"{anzr} {fhcre().__erce__()}"\n        qrs zbanqvp_bc(frys, s):\n            erghea zbanqvp(frys, s)\n        qrs qlnqvp_bc(frys, yrsg, evtug):\n            erghea qlnqvp(frys, yrsg, evtug)\n    erghea ZlBcrengbe()\n\n\nqrs znxr_uloevq(s, b):\n    pynff ZlUloevq(Shapgvba, Bcrengbe):\n        qrs zbanqvp_pnyy(frys, k):\n            erghea s.zbanqvp_pnyy(k)\n        qrs qlnqvp_pnyy(frys, yrsg, evtug):\n            erghea s.qlnqvp_pnyy(yrsg, evtug)\n        qrs zbanqvp_bc(frys, s):\n            erghea b.zbanqvp_bc(s)\n        qrs qlnqvp_bc(frys, yrsg, evtug):\n            erghea b.qlnqvp_bc(yrsg, evtug)\n    erghea ZlUloevq()\n\n@qngnpynffrf.qngnpynff\npynff EvtugCebklShapgvbaNgbz:\n    sa: "Shapgvba"\n    net: "Ngbz"\n    qrs __unfu__(frys):\n        erghea 42\n    qrs __rd__(frys, bgure):\n        erghea Gehr\n    qrs __cbj__(frys, bgure):\n        erghea Neenl.__cbj__(frys.sa.zbanqvp_pnyy(frys.net), bgure)\n\n@qngnpynffrf.qngnpynff\npynff YrsgCebklBcrengbe:\n    bc: "Bcrengbe"\n    net: "Shapgvba"\n\n    qrs __cbj__(frys, bgure):\n        erghea frys.bc.zbanqvp_bc(frys.net) ** bgure\n    \n    qrs __pnyy__(frys, bgure):\n        erghea frys.bc.qlnqvp_bc(frys.net, bgure)\n\n# ngbz bireevqrf\n\nsvfuubbx.ubbx(vag)(Neenl.__cbj__)\nsvfuubbx.ubbx(sybng)(Neenl.__cbj__)\n\nsvfuubbx.ubbx(vag)(Neenl.__pnyy__)\nsvfuubbx.ubbx(sybng)(Neenl.__pnyy__)\n\n\nqrs rinyhngr(n):\n    zngpu n:\n        pnfr EvtugCebklShapgvbaNgbz(s, k):\n            erghea rinyhngr(s.zbanqvp_pnyy(rinyhngr(k)))\n        pnfr YrsgCebklBcrengbe(b, s):\n            erghea b.zbanqvp_bc(s)\n        pnfr [*n]:\n            erghea Neenl(znc(rinyhngr, n))\n        pnfr n:\n            erghea n\n\n@qngnpynffrf.qngnpynff\npynff HarinyhngrqNgbz:\n    vaare_shap: "Shapgvba"\n    fpnyne: "obby" = Snyfr\n    qrs __unfu__(frys):\n        erghea 42\n    qrs __rd__(frys, bgure):\n        erghea Gehr\n    qrs __cbj__(frys0, bgure):\n        zngpu bgure:\n            pnfr HarinyhngrqNgbz(s):\n                erghea HarinyhngrqNgbz(znxr_shapgvba(\n                    \'<harinyhngrq>\',\n                    ynzoqn frys, k: frys0.vaare_shap.zbanqvp_pnyy(k) ** s.zbanqvp_pnyy(k),\n                    ynzoqn frys, yrsg, evtug: frys0.vaare_shap.qlnqvp_pnyy(yrsg, evtug) ** s.qlnqvp_pnyy(yrsg, evtug),\n                ))\n            pnfr bgure:\n                erghea HarinyhngrqNgbz(znxr_shapgvba(\n                    \'<harinyhngrq>\',\n                    ynzoqn frys, k: frys0.vaare_shap.zbanqvp_pnyy(k) ** bgure,\n                    ynzoqn frys, yrsg, evtug: frys0.vaare_shap.qlnqvp_pnyy(yrsg, evtug) ** bgure,\n                ))\n    qrs __pnyy__(frys0, bgure):\n        zngpu bgure:\n            pnfr HarinyhngrqNgbz(s):\n                erghea HarinyhngrqNgbz(znxr_shapgvba(\n                    \'<harinyhngrq>\',\n                    ynzoqn frys, k: frys0.vaare_shap.zbanqvp_pnyy(k)(s.zbanqvp_pnyy(k)),\n                    ynzoqn frys, yrsg, evtug: frys0.vaare_shap.qlnqvp_pnyy(yrsg, evtug)(s.qlnqvp_pnyy(yrsg, evtug)),\n                ))\n            pnfr bgure:\n                erghea HarinyhngrqNgbz(znxr_shapgvba(\n                    \'<harinyhngrq>\',\n                    ynzoqn frys, k: frys0.vaare_shap.zbanqvp_pnyy(k)(bgure),\n                    ynzoqn frys, yrsg, evtug: frys0.vaare_shap.qlnqvp_pnyy(yrsg, evtug)(bgure),\n                ))\n\n@qngnpynffrf.qngnpynff\npynff HarinyhngrqShapgvba:\n    vaare_bc: "Bcrengbe"\n    qrs __unfu__(frys):\n        erghea 42\n    qrs __rd__(frys, bgure):\n        erghea Gehr\n    qrs __cbj__(frys0, bgure):\n        erghea HarinyhngrqShapgvba(znxr_bcrengbe(\n            \'<harinyhgrq>\',\n            ynzoqn frys, s: frys0.vaare_bc.zbanqvp_bc(s) ** bgure,\n            ynzoqn frys, yrsg, evtug: frys0.vaare_bc.qlnqvp_bc(yrsg, evtug) ** bgure\n        ))\n    qrs __pnyy__(frys0, bgure):\n        erghea HarinyhngrqShapgvba(znxr_bcrengbe(\n            \'<harinyhngrq>\',\n            ynzoqn frys, s: frys0.vaare_bc.zbanqvp_bc(s)(bgure),\n            ynzoqn frys, yrsg, evtug: frys0.vaare_bc.qlnqvp_bc(yrsg, evtug)(bgure)\n        ))\n\n@svfuubbx.ubbx(frg)\nqrs __cbj__(frys, bgure):\n    zngpu [*frys][0]:\n        pnfr HarinyhngrqNgbz(s) | HarinyhngrqShapgvba(s) nf o:\n            erghea s ** bgure\n        pnfr s:\n            erghea s\n\n@svfuubbx.ubbx(frg)\nqrs __pnyy__(frys, bgure):\n    zngpu [*frys][0]:\n        pnfr HarinyhngrqNgbz(s):\n            erghea s(bgure)\n        pnfr s:\n            erghea s\n\n口ᗕ = ynzoqn k: cevag(rinyhngr(k)) be k\nragelᗕ = ynzoqn k: tybonyf().__frgvgrz__("ragel", k)\nnᗕ = ynzoqn k: tybonyf().__frgvgrz__("n", k) be k\n\nㅤ=Abar\n@svfuubbx.ubbx(ghcyr)\nqrs __cbj__(frys, bgure):\n    erghea ㅤ̗ ** bgure\n\nα = HarinyhngrqNgbz(znxr_shapgvba(\'α\',\n    flagnk_reebe,\n    ynzoqn frys, yrsg, evtug: yrsg), fpnyne=Gehr\n)\nω = HarinyhngrqNgbz(znxr_shapgvba(\'ω\',\n    ynzoqn frys, k: k,\n    ynzoqn frys, yrsg, evtug: evtug), fpnyne=Gehr\n)\nαα = HarinyhngrqShapgvba(znxr_bcrengbe(\'αα\',\n    ynzoqn frys, s: s,\n    ynzoqn frys, yrsg, evtug: yrsg\n))\nωω = HarinyhngrqShapgvba(znxr_bcrengbe(\'ωω\',\n    flagnk_reebe,\n    ynzoqn frys, yrsg, evtug: evtug\n))\n\nΛ = znxr_shapgvba(\n    \'Λ\',\n    flagnk_reebe,\n    ynzoqn frys, yrsg, evtug: yrsg naq evtug,\n    vq=1\n)\nε = znxr_shapgvba(\n    \'ε\',\n    flagnk_reebe,\n    ynzoqn frys, k, l: vag(k va l)\n)\nπ = znxr_shapgvba(\n    \'π\',\n    ynzoqn frys, k: Neenl([Neenl(n) sbe n va vgregbbyf.crezhgngvbaf(k)])\n)\nι = znxr_shapgvba(\n    \'ι\',\n    ynzoqn frys, k: Neenl(yvfg(enatr(1, k+1)))\n)\nᚍ = znxr_shapgvba(\n    \'ᚍ\',\n    ynzoqn frys, k: yra(k),\n    ynzoqn frys, y, e: vag(y == e vs vfvafgnapr(y, vag) ryfr ghcyr(y) == ghcyr(e))\n)\n𝘐 = znxr_uloevq(\n    znxr_shapgvba(\n        \'𝘐\',\n        flagnk_reebe,\n        ynzoqn frys, yrsg, evtug: [k sbe v, k va mvc(yrsg, evtug) vs v]\n    ),\n    znxr_bcrengbe(\n        \'𝘐\',\n        ynzoqn frys, s: znxr_shapgvba(\n            \'<shap>𝘐\',\n            ynzoqn frys, k: shapgbbyf.erqhpr(s.qlnqvp_pnyy, k, s.bcgvbaf.trg("vq", 0)),\n            ynzoqn frys, yrsg, evtug: shapgbbyf.erqhpr(s.qlnqvp_pnyy, evtug, yrsg)\n        )\n    )\n)\nㅤ̈ = znxr_bcrengbe(\n    \'ㅤ̈\',\n    ynzoqn frys, s: znxr_shapgvba(\n        \'<shap>ㅤ̈\',\n        ynzoqn frys, k: Neenl(znc(ynzoqn l: s ** l, k)),\n        ynzoqn frys, yrsg, evtug: Neenl(vgregbbyf.fgneznc(ynzoqn k, l: k ** s ** l, mvc(yrsg, evtug))),\n    )\n)\nᐤ = znxr_bcrengbe(\n    \'ᐤ\',\n    flagnk_reebe,\n    ynzoqn frys, yrsg, evtug: znxr_shapgvba(\n        \'shap ᐤ shap\',\n        ynzoqn frys, k: yrsg ** evtug ** k,\n        ynzoqn frys, yrsg1, evtug1: yrsg1 ** yrsg ** evtug1 ** evtug\n    ),\n)\nᎰ = znxr_shapgvba(\n    \'Ꮀ\', \n    ynzoqn frys, k: k,\n    ynzoqn frys, yrsg, evtug: evtug\n)\nᑕ = znxr_shapgvba(\n    \'ᑕ\',\n    ynzoqn frys, k: Neenl([k]),\n)\nᑐ = znxr_shapgvba(\n    \'ᑐ\',\n    ynzoqn frys, k: k[0],\n    ynzoqn frys, yrsg, evtug: evtug[yrsg-1]\n)\nㅤ̗ = znxr_shapgvba(\n    \',\',\n    flagnk_reebe,\n    ynzoqn frys, yrsg, evtug: Neenl([*yrsg, *evtug])\n)\nφ = znxr_uloevq(\n    znxr_shapgvba(\n        \'φ\',\n        ynzoqn frys, k: Neenl(svygre(Abar, k)),\n        ynzoqn frys, yrsg, evtug: Neenl(svygre(ynzoqn k: k vf yrsg, evtug))\n    ),\n    znxr_bcrengbe(\n        \'φ\',\n        ynzoqn frys, s: znxr_shapgvba(\n            \'<shap>φ\',\n            ynzoqn frys, k: Neenl(svygre(ynzoqn m: rinyhngr(s ** (m)), k)),\n            ynzoqn frys, yrsg, evtug: Neenl(svygre(ynzoqn k: rinyhngr(yrsg ** s ** k), evtug))\n        )\n    )\n)\nﺕ = znxr_bcrengbe(\n    \'ﺕ\',\n    ynzoqn frys, s: znxr_shapgvba(\n        \'<shap> ﺕ\',\n        ynzoqn frys, k: k ** s ** k\n    )\n)', "rot13"))

" APYL HAS BEEN TRADEMARKED BY BOSS INVERSON"
" I BOLDED THE INTERESTING PARTS BELOW"
entryᗕ ({
    # vvvvv      vvvvv        vvvvvvvvv           vvvvv
    ᑐ **ω** {Λ(𝘐) **ω** ε(ㅤ̈) **α}(φ)** (π)(ᐤ)(ι) **ᚍ** ω
    # ^^^^^      ^^^^^        ^^^^^^^^^           ^^^^^
})
" BOSS SAID I SHOULD USE MORE PARENTHESES TO MAKE IT MORE REEDABLE"

" EXAMPLE"
#      vvvvvvvvv    vvvvvvvvvvvv        vvvvvv  vvvvvv        vvvvv
口ᗕ (Ꮀ **entry** (ᑕ **1(2)(3))** (ㅤ,ㅤ) **(ᑕ**ᑕ **2)** (ㅤ,ㅤ) **ᑕ**2(3))
#      ^^^^^^^^^    ^^^^^^^^^^^^        ^^^^^^  ^^^^^^        ^^^^^

code guessing, round #31 (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