def a2r(x):
    return x

def oppervlakte_van_driehoek(basis, hoogte):
    oppervlakte = 0.5 * basis * hoogte
    return f'Een driehoek met basis {basis} en hoogte {hoogte} heeft oppervlakte {oppervlakte}'

def clean(s):
    s = s.lower()
    r = ""
    for el in s:
        if el in string.ascii_lowercase:
            r = r + el
    return r

def chaos(d, r):
    return r * d * (1 - d)

import string

def w8w2score(w):
    # w = input()
    score = 0
    up = False
    low = False
    dig = False
    special = False
    for el in w:
        if el in string.ascii_uppercase:
            up = True
        elif el in string.ascii_lowercase:
            low = True
        elif el in string.digits:
            dig = True
        else:
            special = True
    if len(w) >= 8:
        score += 1
    x = (up, low, dig, special)
    score += x.count(True)

    if score == 5:
        return "sterk"
    elif score < 3:
        return "zwak"
    else:
        return "matig"

import math

def omtrek(a, b, c):
    return a + b + c


def oppervlakte(a, b, c):
    s = (a+b+c)*0.5
    A = math.sqrt(s*(s-a)*(s-b)*(s-c))
    return round(A, 2)

def iseven(n):
    if n % 2 == 0:
        return True
    return False

def go(s, c):
    if c == "low":
        return s.lower()
    return s.upper()

def discriminant(a, b, c):
    return float(b ** 2 - 4 * a * c)

def oplossingen(a, b, c):
    D = discriminant(a, b, c)
    if abs(D) < 1e-6:
        aantal = 1
        x1 = (-b - D ** 0.5) / (2 * a)
        x2 = x1
    elif D > 0:
        aantal = 2
        x1 = (-b - D ** 0.5) / (2 * a)
        x2 = (-b + D ** 0.5) / (2 * a)
    else:
        aantal = 0
        x1 = 0
        x2 = 0

    return aantal, x1, x2

def gregory_leibnitz(termen):

    som = 0
    for index in range(termen):
        som += 1 / (2 * index + 1) * (-1) ** index

    return 4 * som

def snelheid2tempo(v):
    t = (v**-1) * 60
    return t


def tempo2snelheid(t):
    v = t**-1 * 60
    return v


def converter(x):
    x = x.replace(" ", "")
    if "km/h" in x:  # snelheid
        x = float(x[:-4])
        return f"{snelheid2tempo(x)} min/km"
    else:  # "min/km"  # tempo
        x = float(x[:-6])
        return f"{tempo2snelheid(x)} km/h"

def deelbaar_door(a, b):
    if b > a:
        return False
    return a % b == 0

def iseven(n:int):
    return n%2 == 0

def is_even_en_deelbaar_door(n: int, d = None):
    if d is None:
        return iseven(n)
    return iseven(n) and deelbaar_door(n, d)

def faculteit(n):
    resultaat = 1
    for factor in range(1, n + 1):
        resultaat *= factor

    return resultaat

def binomiaal(n, k):
    if not 0 <= k <= n:
        return 0

    return faculteit(n) // (faculteit(k) * faculteit(n - k))

def karakterwaarde(karakter):
    return ord(karakter.upper()) - ord('A') + 1 if karakter.isalpha() else 0

def stringwaarde(zin):
    return sum(karakterwaarde(karakter) for karakter in zin)

def isevenwaardig(zin1, zin2):
    return stringwaarde(zin1) == stringwaarde(zin2)

def isgelijkheid(uitdrukking):
    if not uitdrukking.count('=') == 1:
        return False

    return isevenwaardig(*uitdrukking.split('='))

def waardering(prijs, wisselkoers):
    # procentuele verhouding berekenen
    v = prijs / 4.07
    v = ((v - wisselkoers) / wisselkoers) * 100.0
    
    # waardering bepalen
    if v <= -25:
        return 'sterk ondergewaardeerd'
    elif v <= -5:
        return 'ondergewaardeerd'
    elif v <= 5:
        return 'ongeveer gelijk'
    elif v <= 25:
        return 'overgewaardeerd'
    else:
        return 'sterk overgewaardeerd'
    
def wisselkoersanalyse(prijs, wisselkoers):
    bedrag, munt = prijs.split(' ', 1)
    return 'De {} is {} ten opzichte van de dollar.'.format(munt, waardering(float(bedrag), wisselkoers))