Esercizi con soluzioni in python - Programming for Data Science

Programming for data science - Python

Esame 18/07 - Es 1

def drop_duplicate(L):
res=[]
for elem in L:
j = i
for elem2 in L[i:]:
if elem==elem2:
L[j] = -1
j += 1
if elem != -1:
res.append(elem)
i += 1
return res

def intersezione(L,s):
intersez=[]
for elem in L:
if elem in s:
intersez.append(elem)
return intersez

def max_value_intersect(L,S):
L=drop_duplicate(L)
massimo=(0,0,0,0)
for s in S:
s=drop_duplicate(s)
intersez=intersezione(L,s)
somma=0
for elem in intersez:
somma+=elem
if somma>massimo[3]:
massimo=(L,s,intersez,somma)
return massimo

lista=[2,1,5,8,8,4,2]
insieme=[[4,5,7],[1,2,3],[8,9]]
print(max_value_intersect(lista,insieme))

Programming for data science - Python 1 - Es 2

NB: per trovare il numero di occorrenze di un elemento in una stringa basta fare stringa.count(elem)

from itertools import permutations
def KMer(stringa,k):
lista=permutations(stringa,k)
newset=set()
diz={}
for elem in lista:
newset.add("".join(elem))
for elem in newset:
cnt=stringa.count(elem)
if cnt != 0:
diz[elem]=cnt
return diz
KMer('GTAGAGTAGT',3)

Oppure con REGEX

from itertools import permutations
import re
def KMer(stringa,k):
diz={}
lista=list(stringa)
x=permutations(lista,k)
newlist=[]
for elem in set(x):
newlist.append("".join(elem))
for elem in newlist:
a=re.findall(elem,stringa)
if len(a)!=0:
diz[elem]=len(a)
return diz
print(KMer("GTAGAGTAGT",3))

Senza permutazioni

def KMer2(stringa, k):
diz = {}
for i in range(len(stringa) - k + 1):
parola = stringa[i:i+k]
diz[parola] = diz.get(parola, 0) + 1
return diz
print(KMer2('GTAGAGTAGT',3))

Test 1 Es 1

Un anno è bisestile se è divisibile per 4 e non per 100 a meno che non sia divisibile per 400.

def countBisestile(year1,year2):
cnt=0
while(year1<year2):
print(year1)
if (year1%4==0 and year1%100!=0) or year1%400==0:
cnt+=1
year1+=1
return cnt
year1=2016
year2=2028
print(countBisestile(year1,year2))

Test 2 Es 1

def gby(data):
agg = {}
for student in data:
for exam, grade in student.items():
if exam not in agg:
agg[exam] = (1, grade)
else:(number, total) = agg[exam]
agg[exam] = (number+1, total+grade)
res={}
for exam,(number,total) in agg.items():
res[exam]=total/number
return res
data=[{'pds':25,'dm':30,'log':25},{'pds':20,'dm':21,'log':16},{'pds':18,'dm':25,'log':32}]
print(gby(data))

Soluzione alternativa

def gdb(data):
dict_media = dict()
n_esami = dict()
for elem in data:
for key in elem:
if key not in dict_media:
dict_media[key]=elem[key]
n_esami[key] = 1
else:
dict_media[key]+=elem[key]
n_esami[key] += 1
dict_media[key] = dict_media[key]/n_esami[key]
return dict_media
data = [{'pds':20, 'dm':30}, {'log':28, 'pds':30}]
x = gdb(data)
print(x)

Test 4 Es 2

Modo 1

lista=[3,1,3,1,3,2]
lista = sorted(lista, key=lista.count, reverse=True)
print(lista)

Modo 2

diz={}
for elem in lista:
diz[elem]=diz.get(elem,0)+1
lista.sort(key=lambda el:diz[el], reverse=True)
print(lista)

Es 2 List comprehension

def nequals(lista):
lista1=[lista.count(elem) for elem in lista]
return lista1
print(nequals(lista))
lista=['a','b','a','c','a','b']

Senza list comprehension

def nequals1(lista):
res=[]
for elem in lista:
res.append(lista.count(elem))
return res

Esame 3/04 Es 2

text="ciao come stai come va ciao andre"
lista=text.split()
diz={}
for index,elem in enumerate(lista):
if elem not in diz:
diz[elem]={'SP':set(),'SN':set()}
if index-1>=0:
diz[elem]['SP'].add(lista[index-1])
if index+1<len(lista):
diz[elem]['SN'].add(lista[index+1])
print(diz)

maxSP=0
maxSN=0
for elem in diz:
if(len(diz[elem]['SP']) > maxSP):
maxSP=(len(diz[elem]['SP']))
if(len(diz[elem]['SN']) > maxSN):
maxSN=(len(diz[elem]['SN']))
SPnew=set()
SNnew=set()
for elem in diz:
if len(diz[elem]['SP'])==maxSP:
SPnew.add(elem)
if len(diz[elem]['SN'])==maxSN:
SNnew.add(elem)
print(SPnew,SNnew)

Esame 15/01 Es 2

1. Modality calculation

def mode(lista):
diz={}
moda=[]
for elem in lista:
diz[elem]=diz.get(elem,0)+1
massimo=max(diz.values())
for key,value in diz.items():
if value==massimo:
moda.append(key)
return moda
lista=[1,4,5,6,5,4,1]
print(mode(lista))

2. Interval calculation

def minint2(lista):
if len(lista) == 0:
return 0
if len(lista) == 1:
return lista[0]
primo_int = lista[0]
minint_altri = minint2(lista[1:])
return (min(primo_int[0], minint_altri[0]), max(primo_int[1], minint_altri[1]))
print(minint2([(2, 4), (3, 5), (3, 6)]))

Media pesata di una lista (ricorsione)

def avg(a, i):
if i==0:
return 0
return a[i-1]/i + avg(a,i-1)

def wagv(a):
return avg(a, len(a))

Oppure

def wagv2(a):
n = len(a)
if n == 0:
return 0
return a[n - 1] / n + wagv2(a[: n - 1])
a=[1,2,5,6]
print(avg(a,4))

Test 5 Es 1

Considera una lista L di terne (e, s, v) dove e è una stringa con il nome di un corso universitario, s è un ID studente, e v è il voto dello studente che ha superato l'esame del corso. Scrivi una funzione Python summary(L) che restituisce un dizionario che mappa:

• La coppia ("avg", e) alla media dei voti per il corso e
• La coppia ("top", e) alla lista degli studenti che hanno superato l'esame con il punteggio più alto

esami=[('pds', 1, 28),('dm', 1, 22), ('pds', 2, 25), ('pds', 3, 28), ('dm', 3, 30)]
diz={}
countdiz={}
maxvoto={}

for esame,ids,voto in esami:
if ('avg',esame) not in diz:
diz[('avg',esame)]=voto
countdiz[esame]=1
maxvoto[esame]=[voto]
else:
diz[('avg',esame)]+=voto
countdiz[esame]+=1
maxvoto[esame].append(voto)

for media,esame in diz:
diz[(media,esame)]=diz[(media,esame)]/countdiz[esame]
for esame in maxvoto:
maxvoto[esame]=max(maxvoto[esame])
for esame,ids,voto in esami:
if ('top',esame) not in diz:
diz[('top',esame)]=[]
if voto==maxvoto[esame]:
diz[('top',esame)].append(ids)
print(diz)

Oppure

def summary (L):
nuovo_diz = {}
voto_massimo = 0
for esame, stud_id, voto in L:
if ('avg', esame) not in nuovo_diz:
nuovo_diz[('avg', esame)] = {"somma":0, "count":0}
nuovo_diz[('avg', esame)]["somma"]+=voto
nuovo_diz[('avg', esame)]["count"]+=1
if ('top',esame) not in nuovo_diz:
nuovo_diz[('top',esame)] = []
if voto >= voto_massimo:
voto_massimo = voto
nuovo_diz[('top',esame)].append(stud_id)
print(nuovo_diz[('avg', esame)]["count"])
for media, esame in nuovo_diz:
if media == 'avg':
nuovo_diz[(media, esame)] = nuovo_diz[(media, esame)]["somma"]/nuovo_diz[(media, esame)]["count
return nuovo_diz
print(summary([('pds', 1, 28), ('pds', 2, 25), ('pds', 3, 28), ('dm', 1, 22), ('dm', 3, 30)]))

Es 1 Test 3 Conversioni binario

Sviluppa una funzione Python binextract(n, i, j) dove n, i, e j sono interi non negativi, che restituisce il numero rappresentato dai bit dall'ith (incluso) al jth (escluso) della rappresentazione binaria di n. Ad esempio, binextract(283, 2, 5) restituisce 6 perché 283₁₀ = 100011011 e 110₂ = 6. Successivamente, sviluppa una funzione Python binpack(n, m, i) dove n, m, e i sono interi non negativi, che restituisce il numero ottenuto impostando i bit di n a partire dall'ith (incluso) alla rappresentazione binaria di m. Ad esempio, binpack(283, 12, 2) restituisce 307 perché 283₁₀ = 100011011, 12=1100 e 100110011 = 307

def convBase2(n):
base=2
lista=[]
while n/base>0:
lista.append(n%base)
n=n//base
lista.reverse()
return lista

def convBase10(lista):
risultato=0
i=0
base=2
lista.reverse()
for elem in lista:
risultato+=elem*(base**i)
i+=1
return risultato

def binextract(n,i,j):
lista=convBase2(n)
newlist=[]
for elem in lista[i:j]:
newlist.append(elem)
risultato=convBase10(newlist)
return risultato

def binpack(n,m,i):
lista=convBase2(m)
lista2=convBase2(n)
x=0
for z in range(i,len(lista)+i):
lista2[z]=lista[x]
x+=1
risultato=convBase10(lista2)
return risultato
print(binextract(283,2,5))
print(binpack(283,12,2))

Test 1 Es 2 Conversione

Sviluppa due funzioni Python:

• encode(listn) che codifica una lista listn di qualsiasi numero naturale x restituendo una lista listn8 di soli numeri naturali y che rappresentano un'espansione in base 128 dei numeri di input x (usa 0, 1, 2, …, 127 come cifre). Usa un numero speciale non compreso in [0, 127) come separatore tra le codifiche di numeri successivi.
• decode(listn8) che decodifica una lista listn8 prodotta da encode() restituendo una lista listn di numeri naturali tale che: decode(encode(listn)) == listn è vero per ogni lista listn di numeri naturali.

def encode(lista):
newlist=[]
base=128
for elem in lista:
while elem/base>0:
newlist.append(elem%base)
elem=elem//base
newlist.append("-")
return newlist

def decode(lista):
newlist=[]
k=0
i=0
somma = 0
while i < len(lista):
if lista[i] != '-':
somma += lista[i] * (128**k)
k+=1
else:
k=0
newlist.append(somma)
somma = 0
i+=1
return newlist
lista=[12,578,300,201]
print(encode(lista))
print(decode(encode(lista)))

Test 27/06/2019

Scrivi una funzione che converte il numero in binario e calcola la lunghezza della massima sottosequenza adiacente di 1.

def convBase2(n):
base=2
lista=[]
while n/base>0:
lista.append(n%base)
n=n//base
lista = lista[::-1]
return lista

def ones(x):
binario = convBase2(x)
count = 0
massimo = 0
for elem in binario:
if elem == 0:
count = 0
else:
count += 1
if count > massimo:
massimo = count
return massimo
print(ones(215))

Esercizio: implementare una classe che calcola il GDC

def GCD(a,b):
x=a
y=b
while y!=0:
r=x%y
x=y
y=r
return x

class Fraction():
def __init__(self, top, bottom):
self.num = top
self.den = bottom
def __str__(self):
return str(self.num)+"/"+str(self.den)