Funzioni 6 - esercizi con insiemi

Scarica zip esercizi

Naviga file online

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
{'na', 'ba'}

Esempio 2:

>>> trovate = set()
>>> sillabe("ricaricare", trovate)
>>> trovate
{'ri', 'ca', 're'}

Mostra soluzione

# scrivi qui
def sillabe(parola, t):
    for i in range(0, len(parola), 2):
        t.add(parola[i:i+2])

trovate = set()
sillabe("banana", trovate)
print(trovate)

trovate = set()
sillabe("ricaricare", trovate)
print(trovate)

{'ba', 'na'}
{'ri', 're', 'ca'}

# 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

# scrivi qui

def distingui(lona):
    s = set()
    ret = []

    for sottolista in lona:
        # Negli insiemi non possiamo mettere le liste perchè sono mutabili,
        # ma possiamo mettere le tuple
        tup = tuple(sottolista)

        #  Verificare se un elemento appartiene ad un insieme è molto veloce:
        #  è indipendente dalla dimensione dell'insieme!

        if tup not in s:
            ret.append(sottolista)
            #  Aggiungere un elemento ad un insieme è molto veloce:
            #  è indipendente dalla dimensione dell'insieme!
            s.add(tup)

    return ret

listona = [ ['d','d'],['a','b'],['d','d'],['c','a'],['c','a'],['d','d'],['a','b'] ]
#print('distinte:', distingui(listona))
#print('listona:', listona)

# scrivi qui

Esercizio - 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

def inter_for(insiemi):



    if len(insiemi) == 0:
        return set()

    primo = True

    for el in insiemi:
        if primo:
            ret = set(el)
            primo = False
        else:
            ret.intersection_update(el)
    return ret


# 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

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

def inter_fast(insiemi):



    if len(insiemi) == 0:
        return set()

    return set.intersection(*insiemi)


# 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

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