Funzioni 6 - esercizi con insiemi

Esercizio - sillabe

Scrivi una funzione sillabe che data una stringa parola costituita solo da bisillabe e un insieme trovate passato alla funzione, trova tutte le bisillabe distinte e le mette nell’insieme trovate.

  • NOTA: la funzione sillabe NON ritorna nulla !

Esempio 1:

>>> trovate = set()
>>> sillabe("banana", trovate)
>>> trovate
{'an', 'ba'}

Esempio 2:

>>> trovate = set()
>>> sillabe("bonobo", trovate)
>>> trovate
{'bo', 'on'}
Mostra soluzione
[1]:

# scrivi qui


Esercizio - distingui

✪✪ Scrivi una funzione distingui che data una lista listona contenente sottoliste di due caratteri ciascuna, RITORNA una NUOVA LISTA contenente tutte le sottoliste distinte (ignorando quindi le sottoliste duplicate)

  • la lista ritornata deve avere gli elementi nello stesso ordine in cui li si è trovati in listona

  • per sapere velocemente se una sottolista è già stata incontrata o meno, usare un insieme

  • NON effettuare ricerche in liste (quindi niente count, index, in in liste - sono lenti) !

  • NON effettuare rimozioni da liste (quindi niente remove da liste - è lenta) !

  • SUGGERIMENTO: le liste sono mutabili, possiamo metterle in un insieme? Se non è possibile, come possiamo fare?

Esempio:

>>> listona = [ ['d','d'],['a','b'],['d','d'],['c','a'],['c','a'],['d','d'],['a','b'] ]
>>> distingui( listona)
[['d', 'd'], ['a', 'b'], ['c', 'a']]
#NOTA: la variabile listona NON deve essere modificata:
>>> listona
[ ['d','d'],['a','b'],['d','d'],['c','a'],['c','a'],['d','d'],['a','b'] ]
Mostra soluzione
[2]:
# scrivi qui


Esercizio - intersectron

intersectron

Dati una lista insiemi contenente un numero arbitrario di insiemi, RITORNA un NUOVO insieme che contiene gli elementi comuni a tutti gli insiemi.

Per risolvere l’esercizio, si può intersecare un insieme alla volta con un ciclo for (lento) oppure la tecnica descritta qui (breve ed efficace).

  • prova a risolvere in entrambi i modi

  • ATTENTO alla lista vuota !

  • il tuo codice deve funzionare con un qualsiasi numeri di insiemi (l’immagine è solo un esempio)

Mostra soluzione
[3]:
def inter_for(insiemi):

    raise Exception('TODO IMPLEMENT ME !')

# INIZIO TEST - NON TOCCARE !
assert inter_for([]) == set()
assert inter_for([set(),set()]) == set()
assert inter_for([set(),set(),set()]) == set()
assert inter_for([{'a'},{'a'},{'a'}]) == {'a'}
assert inter_for([{'a','b'},{'b'},{'b'}]) == {'b'}
assert inter_for([{'a'},{'a','b'},{'a'}]) == {'a'}
assert inter_for([{'c'},{'c'},{'c','b'}]) == {'c'}
assert inter_for([{'a','b'},{'a','b'},{'a','b'}]) == {'a','b'}
assert inter_for([{'a','b','c'},{'a','b','c','d'},{'b','c','d'}, {'b','c'}]) == {'b','c'}
# verifica che non abbiamo modificato gli insiemi di input
s = {'a','b'}
assert inter_for([s,{'b','c'}]) == {'b'}
assert s == {'a','b'}
# FINE TEST
Mostra soluzione
[4]:
def inter_fast(insiemi):

    raise Exception('TODO IMPLEMENT ME !')

# INIZIO TEST - NON TOCCARE !
assert inter_fast([]) == set()
assert inter_fast([set(),set()]) == set()
assert inter_fast([set(),set(),set()]) == set()
assert inter_fast([{'a'},{'a'},{'a'}]) == {'a'}
assert inter_fast([{'a','b'},{'b'},{'b'}]) == {'b'}
assert inter_fast([{'a'},{'a','b'},{'a'}]) == {'a'}
assert inter_fast([{'c'},{'c'},{'c','b'}]) == {'c'}
assert inter_fast([{'a','b'},{'a','b'},{'a','b'}]) == {'a','b'}
assert inter_fast([{'a','b','c'},{'a','b','c','d'},{'b','c','d'}, {'b','c'}]) == {'b','c'}
# verifica che non abbiamo modificato gli insiemi di input
s = {'a','b'}
assert inter_fast([s,{'b','c'}]) == {'b'}
assert s == {'a','b'}
# FINE TEST

Prosegui

Continua con esercizi su funzioni e dizionari