Exercícios de Exame

n1 = int(input("n1? "))
n2 = int(input("n2? "))
n3 = int(input("n3? "))

if n1 % 2 != 0:
    print(n2 * n3)
else:
    print(n2 - n3)

O resto da divisão por 2 distingue par de ímpar: n1 % 2 != 0 é verdadeiro só quando n1 é ímpar. Cada ramo escreve a expressão pedida.

num = int(input("num? "))

count = 0
while num > 9:
    aux = 1
    while num != 0:
        aux = (num % 10) * aux
        num = num // 10
    num = aux
    count += 1

print(count)

O ciclo exterior conta um passo por multiplicação. O ciclo interior calcula o produto dos dígitos: num % 10 dá o último dígito e num // 10 o remove. O ciclo termina quando resta um só dígito (num <= 9).

num = int(input("num? "))

tmp = num
rev = 0
while tmp > 0:
    d = tmp % 10
    rev = rev * 10 + d
    tmp = tmp // 10

print(rev)

A cada passo, tmp % 10 extrai o último dígito e rev = rev * 10 + d acrescenta esse dígito à direita do número que está a construir. Para num = 0 o ciclo não corre e a saída é 0.

quat = int(input("Quaternary number = "))

dec = 0
power = 0

while quat:
    last = quat % 10
    dec += last * 4 ** power
    quat //= 10
    power += 1

print(dec)

Cada dígito last vale last * 4^power, com a posição power a começar em 0. quat % 10 dá o dígito menos significativo e quat //= 10 avança para o seguinte.

def is_armstrong(n):
    soma = 0
    aux = n
    while aux > 0:
        digit = aux % 10
        soma += digit ** 3
        aux //= 10
    return soma == n

Percorrem-se os dígitos de n com aux % 10 e aux //= 10, acumulando o cubo de cada um em soma. No fim, compara-se a soma com o número original. Para 153: 1 + 125 + 27 = 153.

def moving_average(alist, n):
    if len(alist) < 3 or n < 3:
        return []
    avgs = []
    for i in range(n // 2, len(alist) - n // 2):
        left = alist[i - n // 2:i]
        right = alist[i + 1:i + n // 2 + 1]
        neighbors = left + right
        avgs.append(round(sum(neighbors) / len(neighbors), 2))
    return avgs

Só os índices com n // 2 elementos de cada lado têm uma vizinhança completa, por isso o ciclo começa em n // 2 e termina antes de len(alist) - n // 2. A média usa os n - 1 vizinhos (o elemento central não entra), como no exemplo: (1+3)/2 = 2.0.

def order_digits(n):
    if n == 0:
        return (0,)
    result = ()
    for i in range(9, -1, -1):
        aux = n
        while aux > 0:
            if aux % 10 == i:
                result += (i,)
            aux //= 10
    return result

Para cada dígito possível de 9 até 0, percorre-se o número e acrescenta-se esse dígito ao tuplo uma vez por cada ocorrência. O caso n == 0 é tratado à parte porque o ciclo while nunca correria.

def swap_case(astr):
    result = ""
    for letter in astr:
        if letter.isupper():
            result += letter.lower()
        else:
            result += letter.upper()
    return result

Percorre-se a string letra a letra e constrói-se o resultado por concatenação, trocando a capitalização de cada letra. Caracteres que não são letras (como !) não são maiúscula nem minúscula e passam para o outro ramo, que os mantém inalterados.

def is_pattern(astring):
    net = 0
    for i in range(len(astring) - 1):
        if astring[i + 1] > astring[i]:
            net += 1
        if astring[i + 1] < astring[i]:
            net -= 1
    return net == 0

def subpatterns(astring):
    counter = 0
    for step in range(2, len(astring) + 1):
        for char_index in range(0, len(astring) - step + 1):
            sub_str = astring[char_index:char_index + step]
            if is_pattern(sub_str):
                counter += 1
    return "The string '{0}' contains {1} substring patterns.".format(
        astring, counter)

Uma subcadeia é padrão quando o saldo entre crescimentos (+1) e encolhecimentos (-1) é zero. Experimentam-se todas as subcadeias de comprimento pelo menos 2 e conta-se quantas têm saldo zero.

def unique_values(alist):
    uniqs = set()
    for d in alist:
        for v in d.values():
            uniqs.add(v)
    return uniqs

Percorrem-se os valores de cada dicionário com d.values() e juntam-se todos a um conjunto, que elimina duplicados automaticamente.

def sum_dicts(lst):
    result = {}
    for d in lst:
        for k, v in d.items():
            result[k] = result.get(k, 0) + v
    return result

Para cada par chave-valor, result.get(k, 0) devolve o valor acumulado ou 0 se a chave ainda não existe, e o valor novo é somado. Assim todas as chaves ficam no dicionário final.

def process(commands):
    s = commands[0]
    for op, t in zip(commands[1::2], commands[2::2]):
        if op == '|':
            s = s | t
        if op == '&':
            s = s & t
        if op == '-':
            s = s - t
        if op == 'x':
            r = set()
            for i in s:
                for j in t:
                    r.add((i, j))
            s = r
    return s

A lista alterna conjunto, operador, conjunto. commands[1::2] são os operadores e commands[2::2] os operandos seguintes; o zip emparelha-os e cada operador é aplicado ao acumulador s. O produto cartesiano constrói explicitamente o conjunto de pares.

def rec_count(alist):
    result = {}
    for el in alist:
        if type(el) != list:
            d = {el: 1}
        else:
            d = rec_count(el)
        for k, v in d.items():
            result[k] = result.get(k, 0) + v
    return result

Se o elemento não é uma lista, conta-se como uma ocorrência ({el: 1}); se for, conta-se recursivamente a sublista. Depois de cada chamada recursiva, os pares do dicionário devolvido são somados ao acumulador result.

def count_digits(n):
    if n == 0:
        return {}
    d = count_digits(n // 10)
    d[n % 10] = d.get(n % 10, 0) + 1
    return d

O caso base é n == 0, que devolve o dicionário vazio. A chamada recursiva trata do número sem o último dígito e, no regresso, esse dígito é contado no dicionário devolvido. Assim cada dígito é processado uma vez, sem ciclos.

def mdc(x, y):
    while y:
        x, y = y, x % y
    return x

def calculator(expr):
    if len(expr) == 2:
        num, den = expr
    else:
        e1, op, e2 = expr
        e1 = calculator(e1)
        e2 = calculator(e2)
        if op == '*':
            num, den = e1[0] * e2[0], e1[1] * e2[1]
        else:
            num, den = e1[0] * e2[1], e1[1] * e2[0]
    d = mdc(num, den)
    return (num // d, den // d)

O caso base é um tuplo de dois elementos (a fracción). Num tuplo de três, calculam-se recursivamente as duas subexpressões e aplicam-se as regras: multiplicam-se numeradores com numeradores e denominadores com denominadores; na divisão, cruza-se. No fim, divide-se pelo máximo divisor comum para simplificar.

def fib(start, end):
    i = 1
    a, b = 1, 1
    while i <= end:
        if i >= start:
            yield a
        a, b = b, a + b
        i += 1

A sequência tem de ser calculada desde o início, independentemente de start, por isso o contador i começa em 1. Só se faz yield quando i >= start, e a, b = b, a + b avança dois termos de cada vez.

def generator(intlist):
    while intlist != []:
        yield intlist[0][0]
        if intlist[0][0] == intlist[0][1]:
            intlist = intlist[1:]
        else:
            intlist = [(intlist[0][0] + 1, intlist[0][1])] + intlist[1:]

Em cada passo, o primeiro valor do primeiro intervalo é devolvido com yield. Se min == max, o intervalo está esgotado e passa-se ao seguinte; senão, incrementa-se o min do primeiro intervalo, avançando para o próximo termo.