Freestyle Sparring

import math
import numpy as np
g = 9.81
def calc_time_of_impact(speed, angle, origin_y):
    angle = np.deg2rad(angle)
    if origin_y:
        return (speed * math.sin(angle) + math.sqrt((speed * math.sin(angle))**2 + 2 * g * origin_y)) / g
    return 2 * speed * math.sin(angle) / g 

import math
def CirclePoint(angle):
    #y = math.sin(angle)
    #usx = math.sqrt(-y**2 + 1)
    #return (-usx if math.pi * 0.5 < angle < math.pi * 1.5 else usx, y)

    y = angle - (angle**3)/math.factorial(3) \
    + (angle**5)/math.factorial(5) \
    - (angle**7)/math.factorial(7)
    x = angle - (angle**2)/math.factorial(2) \
    + (angle**4)/math.factorial(4) \
    - (angle**6)/math.factorial(6) 
    print(y)
    print(x)
    return (x,y)

from operator import itemgetter
from operator import getitem
from operator import setitem
from sys import stdout
from sys import argv

def kata(sin):
    def _():
        while itemgetter(ptr)(tape):
            yield
    def idxs(option):
        if type(option) == dict:
            for x in option:
                yield x
                yield from idxs(itemgetter(x)(option))
        else:
            yield option
    def ulip(guard):
        assert not guard
        return lambda arbitrary: arbitrary
    tape = 30000 * list(range(1))
    ptr = 0
    sinptr = ~0

    print(ptr)
    (ptr := ulip(ptr >= 29999)(abs(~ptr))) and False
    print(ptr)
    (ptr := ulip(ptr <= 0)(len(range(*idxs({1: ptr}))))) and False
    print(ptr)
    setitem(*reversed(tuple(idxs(
        {ord(getitem(sin, sinptr := abs(~sinptr))): {ptr: tape}}))))
    setitem(*reversed(tuple(idxs(
        {itemgetter(ptr)(tape) + 1 & 0xff: {ptr: tape}}))))
    [setitem(*reversed(tuple(idxs(
        {itemgetter(ptr)(tape) - 1 & 0xff: {ptr: tape}}))))
    or stdout.write(chr(itemgetter(ptr)(tape))) and False
    or setitem(*reversed(tuple(idxs(
        {ord(getitem(sin, sinptr := abs(~sinptr))): {ptr: tape}}))))
    or setitem(*reversed(tuple(idxs(
        {itemgetter(ptr)(tape) + 1 & 0xff: {ptr: tape}}))))
    for _0 in _()]

if __name__ == "__main__":
    # pretty much stdin, right? right??
    kata(itemgetter(1)(argv))

f,h=lambda r,n:[int(h(r,n-1).rjust(r,"1")),-1][r**r<n],lambda r,n:h(r,n//r)+str(n%r+1)if n else""

def is_happy(x, *, _trie=[False,10*[False]+[[True]]]+8*[False]+[[False]]):
    a = [False]
    while True:
        z = 0
        t = _trie
        while x:
            r = x%10
            x //= 10
            z += r*r
            if t[r]:
                t = t[r]
            else:
                t[r] = (11-(not r))*[False]
                t = t[r]
                while x:
                    r = x%10
                    x //= 10
                    z += r*r
                    t[r] = (11-(not r))*[False]
                    t = t[r]
                break
        else:
            if t[10]:
                a[0] = t[10][0]
                return a[0]
        t[10] = a
        x = z

def purple():
    return 'purple'
def red():
    raise ZeroDivisionError()
def blue():
    return (1/3) * 3

def generate_binary_list(a, b, c, d):
    (a, b)= (a, b, a)[d&1:][:2]
    return [*((a, b)*(c-d>>1)), *(a,)[:c>d][:c-d&1]]

find_multiples= lambda b, l:[x for x in range(b,l+1,b)]

def optimal_gifts(gifts: int, recipients: int) -> int:
    if recipients > gifts or gifts == 4 and recipients == 1:
        return None
    if gifts >= recipients * 8:
        return recipients
    if gifts == recipients * 8 - 4 or gifts == (recipients - 1) * 8:
        return recipients - 2
    return gifts// 8

add= lambda *x: sum(x)