Freestyle Sparring

function isDivisible(n, x, y) {
  return n % x === 0 && n % y === 0;
}

constexpr int fact(int n) {
    if (n < 2) return 1;
    return n * fact(n-1);
}
const int HOURS_IN_A_DAY      = 24;
const int MINUTES_IN_AN_HOUR  = 60;
const int SECONDS_IN_A_MINUTE = 60;
constexpr int seconds_in_a_day() { return HOURS_IN_A_DAY * MINUTES_IN_AN_HOUR * SECONDS_IN_A_MINUTE; };

auto meaning_of_life_is() {
   return fact(10)/seconds_in_a_day();
}

verify_sum=lambda a,b:sum(map(ord,a))==sum(map(ord,b))if a and b else None

def numberprint(x):
    l1 = [str(i) for i in range(1, x + 1)]
    l2 = [str(i) for i in range(x - 1, 0, -1)]
    l1 += l2
    return int("".join(l1))

def riddle(word): return word.index('?')

function removeEveryThird(str) {
    return str.split('').filter((_, i) => i === 0 || i % 3 !== 0).join('');
}

def prime_checker(n):
    if n in [2, 3, 5]:
        return True
    elif n % 2 == 0 or n % 3 == 0 or n % 5 == 0:
        return False
    
    a = int(n ** 0.5 / 30)
    b = [7, 11, 13, 17, 19, 23, 29, 31]
    
    for i in [30 * j for j in range(a + 1)]:
        if True in [n % (i + q) == 0 for q in b if i + q is not n]:
            return False
    return True 

from __future__ import annotations
from collections import Counter
def sort_values(vals:list[int]) -> list[int]:
    #Given an array of size N containing only 0s, 1s, and 2s; 
    #sort the array in ascending order.
    assert set(vals) <= {0,1,2}
    return counting_sort(vals)
    # O(n+k) instead of n log(n)

def counting_sort(vals:list[T]) -> list[T]:
    res = []
    c = Counter(vals)
    for k,amt in sorted(c.items()):
        res += [k]*amt
    return res

module Knot where
onesAndZeroes=cycle [1,0]

const code = String.raw`
Y = \ f . ( \ x . f (x x) ) ( \ x . f (x x) )
True = \ t f . t
False = \ t f . f
Succ = \ n s z . s (n s z)
Pred = \ n s z . n ( \ f g . g (f s) ) (\_.z) \x.x
Minus = \ m n . n Pred m
Times = \ m n s . m (n s)
isZero = \ n . n (\_.False) True
isNotZero = \ n . n (\_.True) False
And = \ x y . x y x
Or = \ x . x x
GT = \ x y . isNotZero (Minus x y)
Mod = \ n m . ( \ r . isZero (Minus m r) 0 r ) (( \ n m . ( \ d . isZero d n (Mod d m) ) (Minus n m) ) n m)

# function isPrime(n) {
#   const trial = function trial(i) {
#     return i * i > n || n % i != 0 && trial(i+1) ;
#   } ;
#   return n > 1 && trial(2) ;
# }

isPrime = \ n . ( \ trial . And (GT n 1) (trial 2) )
                ( Y \ trial i . Or (GT (Times i i) n) (And (isNotZero (Mod n i)) (trial (Succ i))) )
`