Funzioni 4 - esercizi con liste

Scarica zip esercizi

Naviga file online

stamparole

✪ Scrive una funzione stamparole che STAMPI tutte le parole in una frase

>>> stamparole("ciao come stai?")
ciao
come
stai?
Mostra soluzione
[1]:

# scrivi qui


stampari

✪ Scrivere una funzione stampari(lista) che STAMPI i numeri pari di una lista di numeri

>>> stampari([1,2,3,4,5,6])

2
4
6
Mostra soluzione
[2]:

# scrivi qui


cerca26

✪ Scrivere una funzione che RITORNA True se il numero 26 è contenuto in una lista di numeri

>>> cerca26( [1,26,143,431,53,6] )
True
Mostra soluzione
[3]:

# scrivi qui


stamprisec

✪ Scrivere una funzione stamprisec(stringa) che STAMPI la prima e la seconda parola di una frase

  • per ottenere una lista di parole usare il metodo delle stringhe .split()

>>> stamprisec("ciao come stai?")
ciao come
Mostra soluzione
[4]:

# scrivi qui


trepari

✪ Scrivi una funzione che STAMPI “si” se i primi tre elementi di una lista sono numeri pari. Altrimenti, la funzione deve STAMPARE “no”. Nel caso in cui la lista contenga meno di tre elementi, STAMPARE “non va bene”

>>> trepari([6,4,8,4,5])
True
>>> trepari([2,5,6,3,4,5])
False
>>> trepari([4])
non va bene
Mostra soluzione
[5]:

# scrivi qui


separa_ip

✪ Un indirizzo IP è una stringa in cui ci sono quattro sequenze di numeri (di lunghezza massima 3) separati “.”. Per esempio, 192.168.19.34 e 255.31.1.0 sono indirizzi IP. Scrivere una funzione che dato un indirizzo IP in input, STAMPI i numeri che compongono l’indirizzo IP (nota: non vale utilizzare il metodo .replace() )

>>> separa_ip("192.168.0.1")

192
168
0
1
Mostra soluzione
[6]:

# scrivi qui


media

✪ Data una lista di numeri interi, scrivi una funzione media(lista) che RITORNI la media aritmetica dei numeri che contiene. Se la lista passata alla funzione dovesse essere vuota, RITORNARE 0

>>> x = media([3,4,2,3])  # ( 10/4 => 3.0)
>>> x
3.0
>>> y = media([])
>>> y
0
>>> z = media([ 30, 28 , 20, 29 ])
>>> z
26.75
Mostra soluzione
[7]:

# scrivi qui


Funzioni con assert

ATTENZIONE

Gli esercizi che segueno contengono dei test con gli assert. Per capire come svolgerli, leggi prima Gestione errori e testing

Mappare

Parlando in genere, operazioni che mappano (o trasformano) prendono qualcosa in input e danno indietro lo stesso tipo di sequenza con gli elementi cambiati in qualche modo.

Presta attenzione se è richiesto tornare una NUOVA lista o MODIFICARE quella esistente.

Esercizio - nuoradf

✪ Prende una lista di interi in input e RITORNA una NUOVA lista con tutti i numeri raddoppiati.

  • Implementala con un for

Mostra soluzione
[8]:
def nuoradf(lst):
    raise Exception('TODO IMPLEMENT ME !')

# INIZIO TEST - NON TOCCARE !
# se hai scritto tutto il codice giusto, ed esegui la cella, python non dovrebbe lanciare AssertionError
assert nuoradf([]) == []
assert nuoradf([3]) == [6]
assert nuoradf([3,7,1]) == [6,14,2]

l = [3,7,1]
assert nuoradf(l) == [6,14,2]
assert l == [3,7,1]
# FINE TEST

Esercizio - radm

✪✪ Prende una lista di interi in input e la MODIFICA raddoppiando tutti i numeri.

Mostra soluzione
[9]:
def radm(lst):

    raise Exception('TODO IMPLEMENT ME !')

# INIZIO TEST - NON TOCCARE !
# se hai scritto tutto il codice giusto, ed esegui la cella, python non dovrebbe lanciare AssertionError
l = []
radm(l)
assert l == []

l = [3]
radm(l)
assert l == [6]

l = [3,7,1]
radm(l)
assert l == [6,14,2]
# FINE TEST

Esercizio - nuoradc

✪ Prende una lista di interi in input e RITORNA una NUOVA lista con tutti i numeri di raddoppiati

  • USA con una list comprehension

Mostra soluzione
[10]:
def nuoradc(lst):
    raise Exception('TODO IMPLEMENT ME !')

# INIZIO TEST - NON TOCCARE !
# se hai scritto tutto il codice giusto, ed esegui la cella, python non dovrebbe lanciare AssertionError
assert nuoradc([]) == []
assert nuoradc([3]) == [6]
assert nuoradc([3,7,1]) == [6,14,2]

l = [3,7,1]
assert nuoradc(l) == [6,14,2]
assert l == [3,7,1]
# FINE TEST

Esercizio - up

✪ Prende una lista di stringhe in input, e RITORNA una NUOVA lista con tutte le stringhe di lista in maiuscolo

  • USA una list comprehension

Mostra soluzione
[11]:
def up(lst):
    raise Exception('TODO IMPLEMENT ME !')

assert up([]) == []
assert up(['']) == ['']
assert up(['a']) == ['A']
assert up(['aA']) == ['AA']
assert up(['Ba']) == ['BA']
assert up(['Ba', 'aC']) == ['BA','AC']
assert up(['Ba dA']) == ['BA DA']

l = ['ciAo']
assert up(l) == ['CIAO']
assert l == ['ciAo']

Filtrare

In genere, le operazioni di filtraggio prendono qualcosa in input e danno indietro lo stesso tipo di cosa rimuovendo elementi secondo qualche criterio

Presta attenzione se è richiesto RITORNARE una NUOVA lista o MODIFICARE quella esistente.

Esercizio - rimtut

✪✪ RITORNA una NUOVA lista che ha gli elementi da list2 ECCETTO quelli di list1

Mostra soluzione
[12]:
def rimtut(list1, list2):
    raise Exception('TODO IMPLEMENT ME !')


assert rimtut([],[]) == []
assert rimtut(['a'], []) == []
assert rimtut([], ['a']) == ['a']
assert rimtut(['a'], ['a']) == []
assert rimtut(['b'], ['a']) == ['a']
assert rimtut(['a', 'b'], ['a','c','b']) == ['c']

orig_l1,orig_l2 = ['a','d'], ['a','c','d','b']
assert rimtut(orig_l1, orig_l2) == ['c', 'b']
assert orig_l1 == ['a','d']         # controlla che non modifichi l'originale
assert orig_l2 == ['a','c','d','b']

Esercizio - solmaf

✪ Prende una lista di stringhe e RITORNA una NUOVA lista che contiene solo le stringhe che sono tutte in lettere maiuscole (perciò tiene 'AB' ma non 'aB')

  • USA un ciclo for

Mostra soluzione
[13]:
def solmaf(lst):
    raise Exception('TODO IMPLEMENT ME !')


assert solmaf(["CD"]) == [ "CD"]
assert solmaf(["ab"]) == []
assert solmaf(["dE"]) == []
assert solmaf(["De"]) == []
assert solmaf(["ab","DE"]) == ["DE"]
orig = ["ab", "CD", "Hb", "EF"]
assert solmaf(orig) == [ "CD", "EF"]
assert orig == ["ab", "CD", "Hb", "EF"]

Esercizio - solmac

✪ Prende una lista di stringhe e RITORNA una NUOVA lista che contiene solo le stringhe che sono tutte in lettere maiuscole (perciò tiene 'AB' ma non 'aB')

  • USA una list comprehension

Mostra soluzione
[14]:
def solmac(lst):
    raise Exception('TODO IMPLEMENT ME !')

assert solmac(["CD"]) == [ "CD"]
assert solmac(["ab"]) == []
assert solmac(["dE"]) == []
assert solmac(["De"]) == []
assert solmac(["ab","DE"]) == ["DE"]
orig = ["ab", "CD", "Hb", "EF"]
assert solmac(orig) == [ "CD", "EF"]
assert orig == ["ab", "CD", "Hb", "EF"]

Ridurre

Parlando in genere, operazioni di riduzione (reduce) effettuano operazioni su sequenze di elementi e producono un risultato più piccolo.

In questi casi, operiamo su liste. Presta attenzione se è richiesti RITORNARE una NUOVA lista o MODIFICARE l’esistente.

Esercizio - somtut

✪ RITORNA la somma di tutti gli elementi in lista

  • Implementa come vuoi

Mostra soluzione
[15]:
def somtut(lst):
    raise Exception('TODO IMPLEMENT ME !')

assert somtut([]) == 0
assert somtut([7,5]) == 12
assert somtut([9,5,8]) == 22

Esercizio - somparif

✪ RITORNA la somma di tutti gli elementi pari in lst

  • USA un ciclo for

Mostra soluzione
[16]:
def somparif(lst):
    raise Exception('TODO IMPLEMENT ME !')

assert somparif([]) == 0
assert somparif([9]) == 0
assert somparif([4]) == 4
assert somparif([7,2,5,8]) == 10

Esercizio - somtutc

✪ RITORNA la somma di tutti gli elementi pari in lst

  • USA una list comprehension

  • SCRIVI una sola linea di codice

Mostra soluzione
[17]:
def sum_all_even_comp(lst):
    raise Exception('TODO IMPLEMENT ME !')

assert sum_all_even_comp([]) == 0
assert sum_all_even_comp([9]) == 0
assert sum_all_even_comp([4]) == 4
assert sum_all_even_comp([7,2,5,8]) == 10

Altri esercizi

contiene

✪ RITORNA True se elem è presente in lista, altrimenti RITORNA False

Mostra soluzione
[18]:
def contiene(lista, elem):
    raise Exception('TODO IMPLEMENT ME !')


assert contiene([],'a') == False
assert contiene(['a'],'a') == True
assert contiene(['a','b','c'],'b') == True
assert contiene(['a','b','c'],'z') == False

primi

✪ RITORNA una lista con i primi numeri da 0 incluso a n escluso.

  • Per esempio, primi(3) deve ritornare [0,1,2]

  • Se n < 0, ritorna la lista vuota

Ingredienti:

  • variabile lista da ritornare

  • variabile contatore

  • ciclo while (volendo ci sono anche altri modi)

  • return

Mostra soluzione
[19]:

def primi(n):
    raise Exception('TODO IMPLEMENT ME !')



assert primi(-1) == []
assert primi(-2) == []
assert primi(0) == []
assert primi(1) == [0]
assert primi(2) == [0,1]
assert primi(3) == [0,1,2]

primul

✪ RITORNA True se il primo elemento di lista è uguale all’ultimo, altrimenti RITORNA False

NOTA: Si può assumere che lista contenga sempre almeno un elemento.

Mostra soluzione
[20]:

def primul(lista):
    raise Exception('TODO IMPLEMENT ME !')

assert primul(['a']) == True
assert primul(['a','a']) == True
assert primul(['a','b']) == False
assert primul(['a','b','a']) == True
assert primul(['a','b','c','a']) == True
assert primul(['a','b','c','d']) == False

duplica

✪ RITORNA una NUOVA lista, in cui ciascun elemento della lista in ingresso è duplicato. Per esempio,

duplica(['ciao','mondo','python'])

deve ritornare

['ciao','ciao','mondo','mondo','python','python']

Ingredienti: - variabile per nuova lista - ciclo for - return

Mostra soluzione
[21]:
def duplica(lista):
    raise Exception('TODO IMPLEMENT ME !')


assert duplica([]) ==  []
assert duplica(['a']) == ['a','a']
assert duplica(['a','b']) == ['a','a','b','b']
assert duplica(['a','b','c']) == ['a','a','b','b','c','c']
assert duplica(['a','a']) == ['a','a','a','a']
assert duplica(['a','a','b','b']) == ['a','a','a','a','b','b','b','b']

hadup

✪✪ RESTITUISCE True se lista contiene l’elemento el più di una volta, altrimenti RESTITUISCE False.

  • NON usare il metodo .count, è troppo facile!

Mostra soluzione
[22]:
def hadup(el, lista):
    raise Exception('TODO IMPLEMENT ME !')

assert hadup("a", []) == False
assert hadup("a", ["a"]) == False
assert hadup("a", ["a", "a"]) == True
assert hadup("a", ["a", "a", "a"]) == True
assert hadup("a", ["b", "a", "a"]) == True
assert hadup("a", ["b", "a", "a", "a"]) == True
assert hadup("b", ["b", "a", "a", "a"]) == False
assert hadup("b", ["b", "a", "b", "a"]) == True

ord3

✪✪ RITORNA True se la lista fornita ha i primi tre elementi ordinati in modo crescente, False altrimenti

  • se lista ha meno di 3 elementi, ritorna False

Mostra soluzione
[23]:
def ord3(lista):
    raise Exception('TODO IMPLEMENT ME !')


assert ord3([5]) == False
assert ord3([4,7]) == False
assert ord3([4,6,9]) == True
assert ord3([4,9,7]) == False
assert ord3([9,5,7]) == False
assert ord3([4,8,9,1,5]) == True   # primi 3 elementi crescenti
assert ord3([9,4,8,10,13]) == False  # primi 3 elementi NON crescenti

filtrab

✪✪ Prende in input una lista di caratteri, e RITORNA una NUOVA lista contenente solo i caratteri 'a' e 'b' trovati scorrendo la lista originale

Esempio:

filtrab(['c','a','c','d','b','a','c','a','b','e'])

deve ritornare

['a','b','a','a','b']
Mostra soluzione
[24]:
def filtrab(lista):
    raise Exception('TODO IMPLEMENT ME !')


assert filtrab([]) == []
assert filtrab(['a']) == ['a']
assert filtrab(['b']) == ['b']
assert filtrab(['a','b']) == ['a','b']
assert filtrab(['a','b','c']) == ['a','b']
assert filtrab(['a','c','b']) == ['a','b']
assert filtrab(['c','a','b']) == ['a','b']
assert filtrab(['c','a','c','d','b','a','c','a','b','e']) == ['a','b','a','a','b']

l = ['a','c','b']
assert filtrab(l) == ['a','b'] # verifica che sia ritornata una NUOVA lista
assert l == ['a','c','b']      # verifica che la lista originale non sia stata modificata

collina

✪✪ RITORNA una lista in cui all’inizio sono presenti i primi numeri da uno a n in crescendo, e dopo n decrescono fino a 1. NOTA: n è contenuto una sola volta.

Per esempio,

collina(4)

deve ritornare

[1,2,3,4,3,2,1]

Ingredienti: - variabile per la lista da ritornare - due cicli for di seguito e funzioni range oppure due while di seguito

Mostra soluzione
[25]:
def collina(n):

    raise Exception('TODO IMPLEMENT ME !')

assert collina(0) == []
assert collina(1) == [1]
assert collina(2) == [1,2,1]
assert collina(3) == [1,2,3,2,1]
assert collina(4) == [1,2,3,4,3,2,1]
assert collina(5) == [1,2,3,4,5,4,3,2,1]

vetta

✪✪ Supponiamo che in una lista vengano salvate le altitudini di una strada di montagna prendendo una misura ogni 3 km (assumiamo che la strada sia costantemente in salita). Ad un certo punto, si arriverà alla vetta della montagna dove si misurerà l’altezza sul livello del mare. Chiaramente, esiste anche una strada per scendere (costantemente in discesa) e anche qui verrà misurata l’altitudine ogni 3 km.

Un esempio di misurazione è [100, 400, 800, 1220, 1600, 1400, 1000, 300, 40]

  • Scrivere una funzione che RITORNI il valore della lista che corrisponde alla misurazione presa in vetta

  • se la lista contiene meno di tre elementi, lanciare eccezione ValueError

>>> vetta([100,400, 800, 1220, 1600, 1400, 1000, 300, 40])
1600
Mostra soluzione
[26]:

def vetta(lista):
    raise Exception('TODO IMPLEMENT ME !')



assert vetta([5,40,7]) == 40
assert vetta([5,30,4]) == 30
assert vetta([5,70,70, 4]) == 70
assert vetta([5,10,80,25,2]) == 80
assert vetta([100,400, 800, 1220, 1600, 1400, 1000, 300, 40]) == 1600
try:
    vetta([])         # con questa lista anomala ci attendiamo che sollevi l'eccezione ValueError
    raise Exception("Non sarei dovuto arrivare fin qua !")
except ValueError:    # se solleva l'eccezione,si sta comportando come previsto e non facciamo niente
    pass

pari

✪✪ RITORNA una lista contenente gli elementi dalla lista di input alle posizioni pari, cominciando dalla zero che è considerato pari

  • si può assumere che la lista di input contenga sempre un numero pari di elementi

  • Suggerimento: ricordati che range può prendere tre parametri.

Mostra soluzione
[27]:
def pari(lista):
    raise Exception('TODO IMPLEMENT ME !')


assert pari([]) == []
assert pari(['a','b']) == ['a']
assert pari(['a','b','c','d']) == ['a', 'c']
assert pari(['a','b','a','c']) == ['a', 'a']
assert pari(['a','b','c','d','e','f']) == ['a', 'c','e']

mix

✪✪ RITORNA una nuova lista in cui gli elementi sono presi alternativamente da lista1 e da lista2. - si può assumere che lista1 e lista2 contengano lo stesso numero di elementi

Esempio:

mix(['a', 'b','c'], ['x', 'y','z'])

deve dare

['a', 'x', 'b','y', 'c','z']
Mostra soluzione
[28]:

def mix(lista1, lista2):
    raise Exception('TODO IMPLEMENT ME !')


assert mix([], []) == []
assert mix(['a'], ['x']) == ['a', 'x']
assert mix(['a'], ['a']) == ['a', 'a']
assert mix(['a', 'b'], ['x', 'y']) == ['a', 'x', 'b','y']
assert mix(['a', 'b','c'], ['x', 'y','z']) == ['a', 'x', 'b','y', 'c','z']

nostop

✪✪ Quando si analizza una frase, può essere utile processarla per rimuovere parole molto comuni, come per esempio gli articoli e le preposizioni: "un libro su Python" si può semplificare in "libro Python"

Le parole ‘poco utili’ vengono chiamate stopwords. Questo processo è per esempio eseguito dai motori di ricerca per ridurre la complessità della stringa di input fornita dall’utente.

Implementa una funzione che prende una stringa e RITORNA la stringa di input senza le stopwords

SUGGERIMENTO 1: le stringhe in Python sono immutabili ! Per rimuovere le parole devi creare una nuova stringa a partire dalla stringa di partenza.

SUGGERIMENTO 2: crea una lista di parole così:

lista = stringa.split()

SUGGERIMENTO 3: opera le opportune trasformazioni su lista, e poi costruisci la stringa da restituire con " ".join(lista)

Mostra soluzione
[29]:

def nostop(stringa, stopwords):
    raise Exception('TODO IMPLEMENT ME !')

assert nostop("un", ["un"]) == ""
assert nostop("un", []) == "un"
assert nostop("", []) == ""
assert nostop("", ["un"]) == ""
assert nostop("un libro", ["un"]) == "libro"
assert nostop("un libro su Python", ["un","su"]) == "libro Python"
assert nostop("un libro su Python per principianti", ["un","uno","il","su","per"]) == "libro Python principianti"
assert nostop("un libro\tsu Python\nper principianti", ["un","uno","il","su","per"]) == "libro Python principianti"

Esercizio - trez

✪✪ MODIFICA lst mettendo la lettera 'z' agli indici divisibili per 3.

>>> lst = ['f','c','s','g','a','w','a','b']
>>> trez(lst)
>>> lst
>>> ['z','c','s','z','a','w','z','b']
Mostra soluzione
[30]:
def trez(lst):
    raise Exception('TODO IMPLEMENT ME !')

l1 = []
trez(l1)
assert l1 == []
l2 = ['a']
trez(l2)
assert l2 == ['z']
l3 = ['a','b']
assert trez(['a','b']) == None  # non ritorna niente!
trez(l3)
assert l3 == ['z','b']
l4 = ['a','b','c']
trez(l4)
assert l4 == ['z','b','c']
l5 = ['a','b','c','d']
trez(l5)
assert l5 == ['z','b','c','z']
l6 = ['f','c','s','g','a','w','a','b']
trez(l6)
assert l6 == ['z','c','s','z','a','w','z','b']

Esercizi coi numeri

Esercizio - listoint

✪✪ Data una lista non vuota di cifre rappresentanti un intero non negativo, RITORNA un oggetto intero python.

Le cifre sono memorizzate con la cifra più significativa alla testa della lista, e ogni elemento della lista contiene una singola cifra.

Puoi assumere che l’intere non contenga nessuno zero a sinistra, eccetto il numero 0 stesso.

Esempi:

>>> listoint([3,7,5])
375
>>> listoint([2,0])
20
>>> listoint([0])
0

NON provare furberie tipo convertire tutta la lista ad una stringa, trucchi ‘sporchi’ come questi portano sempre a conseguenze indesiderate!

Il modo più opportuno è seguire le regole della matematica, considerando che

\[5746 = 5*1000 + 7*100 + 4 * 10 + 6 * 1\]

Per i nostri scopi, è meglio riscrivere la formula così:

\[5746 = 6 * 1 + 4 * 10 + 7*100 + 5*1000\]

In sostanza, stiamo facendo una somma \(4\) volte. Ogni volta, e cominciando dalla cifra meno significativa, la cifra in considerazione è moltiplicata per potenze progressive di 10, cominciando da \(10^0 = 1\) fino a \(10^4=1000\).

Per comprendere come potrebbe funzionare in Python, potremmo aggiungere progressivamente conti ad una variabile accumulatore c così:

c = 0

c = c + 6*1
c = c + 4*10
c = c + 7*100
c = c + 5*1000

In un modo più pythonico e conciso, potremmo scrivere:

c = 0

c += 6*1
c += 4*10
c += 7*100
c += 5*1000

Perciò prima di tutto per prendere i 6,4,7,5 potrebbe essere utile scansionare la lista in ordine inverso usando la funzione reversed (notare il ed alla fine!)

[31]:
for x in reversed([5,7,4,6]):
    print(x)
6
4
7
5

Una volte che abbiamo tale sequenza, abbiamo bisogno di un modo per prendere una sequenza di potenze progressivamente crescenti di 10. Per farlo, possiamo usare una variabile potenza:

[32]:
potenza = 1

for x in reversed([5,7,4,6]):
    print (potenza)
    potenza = potenza * 10
1
10
100
1000

Adesso dovresti avere tutti gli elementi necessari per implementare la funzione richiesta da te.

RICORDATI: se non puoi trovare una soluzione generica, prova con costanti e scrivi giù tutti i passaggi che fai. Poi nelle nuove celle prova a sostitutire le costanti con variabili e continua a sperimentare - è il metodo migliore per individuare possibili schemi di soluzione!

Mostra soluzione
[33]:
def listoint(lst):
    """ RITORNA un intero Python che è rappresentato dalla lista di cifre fornita,
        che rappresenta sempre un numero >= 0 e non ha zeri a sinistra eccetto
        per il caso speciale del numero 0
    """
    raise Exception('TODO IMPLEMENT ME !')

assert listoint([0]) == 0
assert listoint([1]) == 1
assert listoint([2]) == 2
assert listoint([92]) == 92
assert listoint([90]) == 90
assert listoint([5,7,4]) == 574

Esercizio - intolist

✪✪ Proviamo adesso l’operazione inversa, cioè, passare da un oggetto numero Python come 574 ad una lista [5,7,4]

Esempio:

>>> intolist(375)
[3,7,5]

>>> intolist(20)
[2,0]

>>> intolist(0)
[0]

Per farlo, dobbiamo sfruttare la divisione intera // e l’operatore modulo %.

Supponiamo di voler prender la cifra finale 4 dal 574. Per farlo, possiamo notare che il 4 è il resto della divisione intera tra 547 e 10:

[34]:
574 % 10
[34]:
4

Questo estra il quattro, ma se vogliamo trovare un algoritmo per il nostro problema, dobbiamo anche trovare un modo per ridurre progressivamente la dimensione del problema. Per farlo, possiamo sfruttare l’operatore di divisione intera //:

[35]:
574 // 10
[35]:
57

Adesso, dato un numero intero qualunque, dovresti sapere come:

  1. estrarre l’ultima cifra

  2. ridurre il problema per l’iterazione successiva

Questo dovrebbe essere sufficiente per procedere. Presta particolare attenzione al caso speciale dell’input 0

Mostra soluzione
[36]:
def intolist(num):
    """  Prende un numero intero >= 0 e RITORNA una lista di cifre rappresentanti il numero in base 10.
    """
    raise Exception('TODO IMPLEMENT ME !')

assert intolist(0) == [0]
assert intolist(1) == [1]
assert intolist(2) == [2]
assert intolist(92) == [9,2]
assert intolist(90) == [9,0]
assert intolist(574) == [5,7,4]

Esercizio - add one

Data una lista non vuota di cifre rappresentanti un intero non-negativo, aggiunge uno all’intero.

Le cifre sono memorizzate con la cifra più significativa alla testa della lista, e ogni elemento della lista contiene una cifra singola.

Puoi assumere che l’intero non contenga nessuno zero a sinistra, eccetto per il numero 0 stesso.

Per esempio:

 Input: [1,2,3]
Output: [1,2,4]

 Input: [3,6,9,9]
Output: [3,7,0,0]

 Input: [9,9,9,9]
Output: [1,0,0,0,0]

Ci sono due modi per risolvere l’esercizio: puoi convertire ad un oggetto intero Python, aggiungere 1, e quindi convertire indietro ad una lista, procedura che seguira implementando add_one_conv. L’altro modo è operare direttamente su una lista, usando una variabile di riporto, cosa che implementerai nella add_one_rip

Esercizio - add_one_conv

✪✪✪ Ti servono tre passi:

  1. Convertire ad un intero python proprio

  2. aggiungere 1 all’intero python

  3. convertire indietro a list, e ritornarla

Mostra soluzione
[37]:
def add_one_conv(lst):
    """
        Prende una lista di cifre rappresentanti un intero >= 0 senza zeri alla sinistra eccetto
        il numero zero stesso, e RITORNA una NUOVA lista rappresentante il valore di lst più uno.

        Implementala chiamando le funzioni già implementate.
    """
    raise Exception('TODO IMPLEMENT ME !')

assert add_one_conv([0]) == [1]
assert add_one_conv([1]) == [2]
assert add_one_conv([2]) == [3]
assert add_one_conv([9]) == [1, 0]
assert add_one_conv([5,7]) == [5, 8]
assert add_one_conv([5,9]) == [6, 0]
assert add_one_conv([9,9]) == [1, 0, 0]

Esercizio - add_one_rip

✪✪✪ Data una lista non vuota di cifre rappresentanti un intero non-negativo, aggiunge uno all’intero.

The cifre sono memorizzate con la cifra più significativa alla testa della lista, e ogni elemento della lista contiene una cifra singola.

Puoi assumere che l’intero non contenga nessuno zero a sinistra, eccetto per il numero 0 stesso.

Per esempio

>>> add_one_rip([1,2,3])
[1,2,4]

>>> add_one_rip([3,6,9,9])
[3,7,0,0]

>>> add_one_rip([9,9,9,9])
[1,0,0,0,0]

Per implementarla, opera direttamente sulla lista, usando una variabile riporto.

Segui semplicemente l’addizione come fatta alle scuole elementari. Comincia con l’ultima cifra e somma uno:

Se ottieni un numero \(<= 9\), quello è il risultato di sommare le ultime due cifre, e il resto è facile:

596+    riporto=0
001
----
  7     6 + 1 + riporto = 7
596+    carry=0
001
----
 97     9 + 0 + riporto = 9
596+    carry=0
001
----
 07     5 + 0 + riporto = 5

Se ottieni un numero più grande di 9, allora metti uno zero e setti riporto a uno:

3599+    riporto=0
0001
-----
   0     9 + 1 + riporto = 10    # >9,  scrivo zero e setto riporto a 1
3599+    riporto=1
0001
----
  00     9 + 0 + riporto = 10   # >9, scrivo zero e setto riporto a 1
3599+    riporto=1
0001
-----
 600     5 + 0 + riporto = 6    # <= 9, scrivo il risultato e setto il riporto a zero
3599+    riporto=0
0001
-----
3600     3 + 0 + riporto = 3    # <= 9, scrivo il risultato e setto il riporto a zero
Mostra soluzione
[38]:
def add_one_rip(lst):
    """
        Prende una lista di cifre rappresentanti un intero >= 0 senza zeri alla sinistra eccetto
        il numero zero stesso, e RITORNA una NUOVA lista rappresentante il valore di lst più uno.
    """
    raise Exception('TODO IMPLEMENT ME !')

assert add_one_rip([0]) == [1]
assert add_one_rip([1]) == [2]
assert add_one_rip([2]) == [3]
assert add_one_rip([9]) == [1, 0]
assert add_one_rip([5,7]) == [5, 8]
assert add_one_rip([5,9]) == [6, 0]
assert add_one_rip([9,9]) == [1, 0, 0]

Esercizio - collatz

✪✪✪✪ La congettura di Collatz dice che cominciando da una qualsiasi n, se si continua a fare ricorsivamente questi calcoli si ottiene una sequenza che finisce sempre con 1:

  • se n è pari, dividi n per 2

  • se n è dispari, moltiplicalo per 3 e aggiungi 1

  • ripeti finchè raggiungi il valore di 1

Esempio: per n = 3, la sequenza è [3 , 10 , 5 , 16 , 8 , 4 , 2 , 1] .

Scrivi un programma che crea una lista seq, tale per cui per ciascun valore di n tra 1 e 50, seq[n] contiene la lunghezza della sequenza generata. Nel caso di n = 3, la lunghezza è 8. Nel caso di n = 27, la lunghezza è 111.

Se devi controllare i tuoi risultati, puoi provare questo utile tool online

[39]:
def collatz():
    raise Exception("TODO IMPLEMENT ME!")

Prosegui

Continua con esercizi su funzioni e tuple