def nrep(n,c):
    #return [(a+1)*b for a,b in zip(n,c)]
    return [a*b for a,b in zip(n,c)]

nrep([3,0,1],"abc")

def stable(c):
    r = abs(c)
    #if r < 1.5:
    if r < 1:
        return r
    else:
        raise ValueError
        
for s in (0, 0.5+0.5j, 1+0.5j):
    try:
        print(stable(s))
    except ValueError:
        pass

def onetry():
    import random
    if random.random() > 0.5:
        print("raising ValueError")
        raise ValueError
    else:
        raise NotImplementedError    

def rerun(f,n):
    while n>0:
        try:
            f()
        except ValueError:
            n -= 1
            #n -= 2
        except:
            pass
    return

rerun(onetry,5)

# lab validation code; do not modify
def labcheck(testing=0,ntest=10):
    '''
    Python exercise checking.
    Ed.Casas 2023-5-22
    Calls functions q<n>* and checks HMAC of return value[0].
    On mismatch prints return value[1] (e.g. function, arguments and return values).
    Setting testing=1 prints HMACs of correct results; paste into 'hashvalues'.
    Notes:
    If q<n>* result not JSON-able, convert to string.
    Result order matters for comparison. Sort result if specific order not required.
    '''
    
    import base64, copy, hashlib, json, random, re, string, types 
    from random import randint
    
    # compare regex to strings that should/shouldn't match
    def checkre(pat,ok,nok):
        for s in ok:
            assert re.fullmatch(pat,s), \
                f"pattern '{pat}'\n did not match string '{s}'"
        for s in nok:
            assert not re.fullmatch(pat,s), \
                f"pattern '{pat}'\n matched string '{s}'"  
    
    # list of n words with nl letters from chars without repeats
    def randwords(n,chars=string.ascii_lowercase,nl=(2,5)):
        l = []
        while len(l)<n:
            w = ''.join([chars[randint(0,len(chars)-1)] for i in range(randint(*nl))])
            if w not in l:
                l.append(w)
        return l
    
    # convert sets to dicts and dict keys to strings so they can be sorted
    def orderkeys(o):
        if isinstance(o,set):
            return {str(k):None for k in o}
        if isinstance(o,dict):
            return {str(k):orderkeys(v) for k,v in o.items()}
        return o

    class newlist(list):
        pop, copy = None, None
        def __getitem__(self,i):
            raise NotImplementedError("it's not a list!")

    # Q1a, Q1b, ...
    names=[]
    for f in builtins:
        try:
            names.append(f.__name__)
        except:
            names.append("???")
    def Q1a(): return names[0],f"builtins[0] ({names[0]}) is wrong"
    def Q1b(): return names[1],f"builtins[1] ({names[1]}) is wrong"
    def Q1c(): return names[2],f"builtins[2] ({names[2]}) is wrong"
    def Q1d(): return names[3],f"builtins[3] ({names[3]}) is wrong"

    def Q2():
        l = []
        ni,ns,nw = [randint(0,3) for i in range(3)]
        nt = [ni,ns,nw]
        l.extend([1]*ni + [0]*randint(0,3))
        l.extend([{1}]*ns + [{}]*randint(0,3))
        l.extend(randwords(nw) + ['']*randint(0,3))
        random.shuffle(l)
        l = newlist(l)
        ol = copy.deepcopy(l)
        r = counttrue(l)
        return r, f"counttrue({ol}) returned {r}"
    
    def Q3():
        nl = randint(3,5)
        c = newlist((chr(randint(ord('a'),ord('z'))) for i in range(nl)))
        n = newlist([randint(0,4) for i in range(nl)])
        l=copy.deepcopy([n,c])
        r = nrep(*l)
        return r,f"nrep({n},{c}) returns {r}"
    
    def Q4():
        r = []
        for i in range(40):
            c = complex(random.random(),random.random())
            try:
                stable(c)
            except ValueError:
                abs(c) <= 1 and r.append(f"stable({c:.3f}) did not raise ValueError")
                continue
            except Exception as e:
                r.append(f"stable({c:.3f}) raised exception {e}")
                continue
            abs(c) > 1 and r.append(f"stable({c:.3f}) did not raise exception")
        return r,'\n'.join(r)
    
    def Q5():
        n=randint(3,8)
        m=0
        def f():
            nonlocal m
            i = randint(1,3)
            if i == 1:
                m += 1
                raise ValueError
            elif i == 2:
                raise RuntimeWarning           
        rerun(f,n)
        return f"{n}{m}",f"rerun(f,{n}) asserted ValueError {m} times."
    
             
    hashvalues = '''
zY5pzY5pzY5pzY5pzY5pzY5pzY5pzY5pzY5pzY5p
YRUxYRUxYRUxYRUxYRUxYRUxYRUxYRUxYRUxYRUx
sjVusjVusjVusjVusjVusjVusjVusjVusjVusjVu
yT6RyT6RyT6RyT6RyT6RyT6RyT6RyT6RyT6RyT6R
+Hd6LgOnHreh6x5+LgOndp1qLgOnZEo+HrehVj+X
bVYN3Dd7w+Wq9iVBo1+Y/pjXUBBgm+F+oZytc2QJ
q1ESq1ESq1ESq1ESq1ESq1ESq1ESq1ESq1ESq1ES
2rEtmXGz2445mXGz2rEtmXGz2rEtmXGzmXGzxbQr
'''.split()

    newhash = ''
    dsize = 3 # HMAC base64 digest size (bytes, use 3 or 6 for 4 or 8 char digests)
    dlen = ((dsize*8+5)//6+3)//4*4
    
    for n,f in [(n,f) for n,f in locals().items() if callable(f) and re.search(r'^[Qq]\d+.*',n)]:
        random.seed(n)      
        hashes = '0'*dlen*ntest if testing else hashvalues.pop(0)
        err = ''
        while hashes and not err:
            h, hashes = hashes[:dlen], hashes[dlen:] 
            try:
                v,s = f()
                b = json.dumps(orderkeys(v),sort_keys=True).encode()
                c = base64.b64encode(hashlib.blake2b(b,digest_size=dsize).digest()).decode()
                if testing:
                    print(s)
                    newhash += c
                else:
                    if c != h:
                        err = f"Wrong result for test {n}: {s} (HMAC={c} instead of {h})"
            except Exception as e:
                err = f"Error during test {n}: {e}"
                if testing:
                    print(err)
        if testing:
            newhash += '\n'
        else:
            print(err or f"Passed test {n}.")
            
    if testing:
        print(newhash)

labcheck()