soluzioni_esercizi_aggiuntivi.py

def primo_giorno_libero(impegnati):
    # Scorro tutti i possibili giorni del mese.
    # Se trovo un giorno del mese che non è impegnato e
    # nemmeno i due giorni successivi sono impegnati
    # allora ho trovato un giorno libero valido.
    for giorno in range(1, 31):
        if not giorno in impegnati:
            if not giorno + 1 in impegnati:
                if not giorno + 2 in impegnati:
                    return giorno
    return None

assert primo_giorno_libero([]) == 1
assert primo_giorno_libero([1, 3, 5]) == 6
assert primo_giorno_libero([1, 10]) == 2


def ordinata_crescente(lista):
    if lista == []:
        # Una lista vuota è ordinata in ordine crescente.
        return True
    else:
        # Altrimenti devo controllare che ogni valore
        # della lista sia maggiore o uguale al precedente.
        [prec, *resto] = lista
        for valore in resto:
            # Se trovo un valore minore del precedente so
            # per certo che la lista non è ordinata.
            if valore < prec:
                return False
            prec = valore

        # Se non ho mai trovato un valore più piccolo del
        # suo precedente allora significa che la lista è
        # ordinata.
        return True

assert ordinata_crescente([]) == True
assert ordinata_crescente([1, 1, 2, 3]) == True
assert ordinata_crescente([5, 15, 21]) == True
assert ordinata_crescente([-3, -1, 10]) == True
assert ordinata_crescente([9, 10, 2]) == False
assert ordinata_crescente([1, 3, 1, 2]) == False


def fibonacci(n):
    # Non ha senso chiedere un numero in posizione 0 o
    # negativa, in tal caso ritorno None.
    if n <= 0:
        return None
    # I primi due numeri della sequenza sono sempre 1.
    elif n == 1 or n == 2:
        return 1

    # Tutti i numeri dal terzo in poi si calcolano come la
    # somma dei due numeri precedenti.
    prec = 1
    ancora_prima = 1
    for _ in range(3, n + 1):
        numero = prec + ancora_prima
        ancora_prima = prec
        prec = numero
    return numero

assert fibonacci(-1) == None
assert fibonacci(0) == None
assert fibonacci(1) == 1
assert fibonacci(2) == 1
assert fibonacci(3) == 2
assert fibonacci(4) == 3
assert fibonacci(5) == 5
assert fibonacci(6) == 8
assert fibonacci(7) == 13
assert fibonacci(8) == 21
assert fibonacci(9) == 34


def conta(valori, cercato):
    conteggio = 0
    for valore in valori:
        if valore == cercato:
            conteggio += 1
    return conteggio

assert conta([1, 2, 3], 1) == 1
assert conta([True, True, False, True], True) == 3
assert conta(["a", 1, [], 2], "a") == 1
assert conta([], "a") == 0
assert conta(["b", "c", "d"], "a") == 0


def rimuovi_maggiori(valori, filtro):
    valori_minori = []
    for valore in valori:
        if valore != None and valore <= filtro:
            valori_minori.append(valore)
    return valori_minori

assert rimuovi_maggiori([], 10) == []
assert rimuovi_maggiori([1, 2, 3], 10) == [1, 2, 3]
assert rimuovi_maggiori([1, 2, 3], 2) == [1, 2]
assert rimuovi_maggiori([1, 2, 3, 10, 100], 3) == [1, 2, 3]
assert rimuovi_maggiori([1, 2, 3, 10, 100], 0) == []


def posizione_in_classifica(tempi, tempo):
    if tempo == None:
        # Se mi sono ritirato allora arriverò ultimo in
        # classifica.
        return len(tempi) + 1
    else:
        # Altrimenti posso ottenere la mia posizione
        # contando quanti hanno ottenuto un tempo minore
        # o uguale al mio.
        return len(rimuovi_maggiori(tempi, tempo)) + 1

tempi = [2.12, 2.15, 2.16, 3, 2.21, None, 2.19, None]
assert posizione_in_classifica(tempi, 2.13) == 2
assert posizione_in_classifica(tempi, 2.5) == 6
assert posizione_in_classifica(tempi, 2) == 1
assert posizione_in_classifica([], 2) == 1
assert posizione_in_classifica([1, 2, 3], None) == 4