Kumite

def middle_prime(*args):
  nArg = 3
  minArgValue = 1
  maxArgValue = 10
  argsLen = len(args)
  try:
    if argsLen > nArg:
      raise Exception('Only accepts up to {} params.'.format(nArg))
    elif argsLen < 1:
      raise Exception('At least 1 param is required.')
    else:
      for i in args:
        if not minArgValue <= i <= maxArgValue:
          raise Exception('Only accepts numbers from {} to {}.'.format(minArgValue, maxArgValue))
    num = int(''.join([str(i) for i in args]))
    primes = generate_primes(num)
    if primes:
      mididx = len(primes) // 2 if len(primes) % 2 else len(primes) // 2 - 1
      return primes[mididx]
    return -1
  except Exception as e:
    print(e)
    return -1

def is_prime(number:int, primes = [2,3]):
  if not primes:
    primes = [2, 3]
  for i in primes:
    if not number % i:
      return False
  if not i % 2:
    i += 1
  while i <= (number // i):
    if not number % i:
      return False
    i += 2
  return True
  
def generate_primes(number):
  primes = [2]
  i = 3
  while i <= number:
    if is_prime(i, primes):
      primes.append(i)
    i += 2
  return primes

total = 0

grade_dictionary = {
    "A+":4.0,
    "A":4.0,
    "A-":3.7,
    "B+":3.3,
    "B":3.0,
    "B-":2.7,
    "C+":2.3,
    "C":2.0,
    "C-": 1.7,
    "D": 1.0,
    }

for _ in range(6):
    grade = input("Enter Your Grade For Each Class Listed in Order (Letter Form): ").upper()
    total += grade_dictionary.get(grade, 0)
    
print(total / 6)

module Example where

isPoly :: Integer -> Bool
isPoly = fold ( \ n z -> n `mod` len n == 0 && z ) True

fold :: (Integer -> z -> z) -> z -> Integer -> z
fold _ z 0 = z
fold fn z n = n `fn` fold fn z (n `div` 10)
-- Foldable doesn't allow an (Eq Integer,Integral Integer) constraint -- otherwise, this is functionally identical to foldr

len :: Integer -> Integer
len = fold ( \ _ c -> c+1 ) 0
-- Foldable uses foldl' -- this is, m.m., otherwise verbatim