Funzioni 4 - esercizi con liste
Scarica zip esercizi
stamparole
✪ Scrive una funzione stamparole
che STAMPI tutte le parole in una frase
>>> stamparole("ciao come stai?")
ciao
come
stai?
[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
[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
[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
[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
[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
[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
[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
[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
[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
[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
[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
[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
[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
[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
[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
[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
[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
[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!
[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, ritornaFalse
[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']
[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
USA un ciclo
while
terminando la ricerca appena trovi la vettaNON USARE la funzione
max
(troppo facile!)
[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.
[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']
[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)
[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']
[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
Per i nostri scopi, è meglio riscrivere la formula così:
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!
[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:
estrarre l’ultima cifra
ridurre il problema per l’iterazione successiva
Questo dovrebbe essere sufficiente per procedere. Presta particolare attenzione al caso speciale dell’input 0
[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:
Convertire ad un intero python proprio
aggiungere
1
all’intero pythonconvertire indietro a list, e ritornarla
[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
[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, dividin
per2
se
n
è dispari, moltiplicalo per3
e aggiungi1
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