'''
Progettate una o piu' delle seguenti funzioni
(all'inizio di ogni funzione viene specificato il numero di punti assegnato dal grader a quella funzione)
Il punteggio complessivo dato dal grader e' il voto della prova di recupero.
La somma dei punteggi ottenibili con gli esercizi e' maggiore di 30, chi supera il 30 otterra' il punteggio 32.

NOTA: il grader testa tutte le funzioni, quindi stampera' degli errori per le funzioni non implementate
'''

from copy import deepcopy,copy

def es1(testo,k):
    '''
    1) 2 punti
    la funzione es1(testo,k) che, presi in input:
    - una stringa di testo contenente  unicamente spazi e parole con i 26 caratteri alfabetici  da 'a' a 'z'
    - un intero  positivo k,
    restituisce una versione crittografata della stringa di testo.
    Nella stringa crittografata ciascun carattere diverso dallo spazio viene sostituito da un nuovo carattere.
    Il nuovo carattere e' determinato dal valore di k e dalla posizione i che il carattere
    originario occupa nell'ordinamento lessicografico dei 26 caratteri. Piu' precisamente
    il nuovo carattere e' quello che occupa la posizione (i+k)%26 dell'ordinamento
    lessicografico dei 26 caratteri.
    Ad esempio per k=2  (ogni occorrenza di 'a' diviene 'c', ogni occorrenza di  'b' diviene 'd' ...
    ogni occorrenza di 'z' diviene 'b'.
    quindi per testo= 'lo zaino pesa' e k=2 viene restituita  la stringa  'nq bckpq rguc'
    '''
    # inserisci qui il tuo codice
    newStr = []
    lista_char = [chr(x) for x in range(97, ord('z')+1)]
    print(len(lista_char))
    for x in testo:
        if x == ' ':
            newStr+= ' '
            continue
        newStr+= lista_char[(ord(x)+k-97)%26]
    return "".join(newStr)




###############################################################################################

def es2(dizionario):
    '''
    2) 2 punti
    la funzione es2(dizionario) che, preso in input:
    - un dizionario  avente per chiavi degli interi e per attributi liste di interi,
    restituisce un nuovo dizionario.
    Il nuovo dizionario ha per chiavi  gli interi presenti nelle liste-attributo del dizionario
    di partenza  e per attributo chiavi  del dizionario  di partenza.
    L'attributo  da associare alla chiave x nel nuovo dizionario viene determinato  in base
    alla regola seguente: tra tutte le chiavi di dizionario che hanno x tra gli elementi della
    loro lista attributo viene selezionata la chiave y  che ha il valore massimo e y
    diviene l'attributo di x nel nuovo dizionario.
    Ad esempio per dizionario={1:[1,2,3],2:[1,2,4]} la funzione restituisce il
    nuovo dizionario {1: 2, 2: 2, 3: 1, 4: 2}
    '''
    # inserisci qui il tuo codice
    newDict = dict()
    setNum = set()
    for x in dizionario:
        for y in dizionario[x]:
            if y in newDict:
                newDict[y] = max(newDict[y],x)
            newDict[y] = x
    return newDict

# es2({1:[1,2,3],2:[1,2,4]})











###############################################################################################

def es3(tabella):
    '''
    3) 4 punti
    la funzione es3(tabella) che presa in input:
    - una tabella  di interi (rappresentata tramite lista di liste in cui ciascuna lista e' una riga della tabella)
    modifica distruttivamente la tabella e restituisce il numero totale di elementi che la tabella contiene.
    Al termine della funzione, a seguito della modifica,  gli elementi nella tabella
    debbono risultare ordinati in modo crescente per colonna.
    Ad esempio per tabella=[[3,2,1,0],[2,1,3,5],[1,3,2,1]] la funzione restituisce 12 e
    la tabella risulta modificata come segue: [[1, 1, 1, 0], [2, 2, 2, 1], [3, 3, 3, 5]]
    '''
    # inserisci qui il tuo codice
    numCols = len(tabella[0])
    numRows = len(tabella)
    columns = [[] for x in range(numCols)]
    # print(columns)
    for x in range(len(tabella)):
        for y in range(numCols):
            columns[y].append(tabella[x][y])
    for x in range(len(columns)):
        columns[x].sort()
    for x in range(len(columns)):
        for y in range(len(columns[0])):
            tabella[y][x] = columns[x][y]
    return len(tabella)*len(tabella[0])

# es3([[3,2,1,0],[2,1,3,5],[1,3,2,1]])






###############################################################################################

def getcoord(tab,x):
    a = []
    for i in range(len(tab)):
        for j in range(len(tab[0])):
            if tab[i][j] == x:
                a = [i,j]
    return a
def getCols(tab,x):
    a = []
    a= getcoord(tab,x)
    numcols = []
    cols = len(tab)
    for i in range(len(tab)):
        numcols.append(tab[i][a[1]])
    return numcols
def getRows(tab,x):
    numrows= []
    b = []
    b = getcoord(tab,x)
    for i in range(len(tab)):
        if i != b[0]: continue
        for j in range(len(tab[0])):
            if [i,j] == b: continue
            numrows.append(tab[i][j])
    return numrows
def es4(matrice):
    '''
    4) 4 punti
    la funzione es4(matrice) che, presa in input:
    - una matrice quadrata di interi (rappresentata tramite lista di liste in cui ciascuna lista e' una riga della tabella)
    modifica distruttivamente la matrice e restituisce la somma dei valori presenti nella matrice.
    Al termine della funzione il valore matrice[i][j] per ogni riga i e colonna j della matrice
    risulta sostituito con la somma dei valori presenti nela riga i e nella colonna j
    della matrice originale.
    Ad esempio  per  matrice=[[1,2,3],[4,5,6],[7,8,9]] la funzione  restituisce il valore 45 e
    la matrice risulta modificata come segue: [[17, 19, 21], [23, 25, 27], [29, 31, 33]]
    '''
    # inserisci qui il tuo codice
    newMatr = [[[] for _ in range(len(matrice[0]))] for x in range(len(matrice))]
    summ = 0
    for i in range(len(matrice)):
        for j in range(len(matrice[0])):
            summ+= matrice[i][j]
    print(summ)
    for i in range(len(matrice)):
        for j in range(len(matrice[0])):
            # print(getCols(matrice,matrice[i][j]),getRows(matrice,matrice[i][j]))
            newMatr[i][j] = sum(getCols(matrice,matrice[i][j]))+sum(getRows(matrice,matrice[i][j]))
    for i in range(len(matrice)):
        for j in range(len(matrice[0])):
            matrice[i][j] = newMatr[i][j]

    return summ
# es4([[1,2,3],[4,5,6],[7,8,9]])









###############################################################################################

'''
In tutti gli esercizi che seguono avremo a che fare con  dei files in formato json che
contengono informazioni su una serie di film.
Nel seguito indicheremo questo tipo di file come file di film.
Il file di film e' un dizionario e le chiavi del dizionario sono stringhe.
Ogni stringa contiene il titolo e l'anno di realizzazione di un film (le due informazioni
sono separate dal carattere ;). attributo di ogni chiave e' un dizionario.
Il dizionario contiene quattro chiavi: 'ATTORI', 'REGISTI', 'GENERI', 'PAESI'.
A ciascuna di queste chiavi e' associata una lista.
Ad 'ATTORI' e' associata la lista con i nomi degli attori che hanno partecipato al film.
A 'REGISTI' e' associata la lista con i nomi dei registi del film.
A 'GENERI' e' associata la lista coi generi cinematografici a cui il film e' riconducibile.
A 'PAESI' e' associata la lista dei paesi in cui il film e' stato lavorato.

ecco di seguito un esempio di voce all'interno di un  file di film:

'The Hill;1965': {'ATTORI': ['Sean Connery',
                              'Harry Andrews',
                              'Ian Bannen',
                              'Alfred Lynch',
                              'Ossie Davis',
                              'Roy Kinnear',
                              'Jack Watson',
                              'Ian Hendry',
                              'Michael Redgrave',
                              'Norman Bird',
                              'Neil McCarthy',
                              'Howard Goorney',
                              'Tony Caunter'],
                   'GENERI': ['Drama', 'War'],
                   'PAESI': ['UK'],
                   'REGISTI': ['Sidney Lumet']}

'''
import json
import pprint

def getFilmsbyGenere(d, g):
    l = []
    for key in d:
        for k in d[key]:
            if k != 'GENERI': continue
            if g in d[key][k]:
                s = key.find(';')
                l.append(key[:s])
    l.sort()
    return l
def es5(fname,fname1):
    '''
    5) 6 punti
    la funzione  es5(fname,fname1) che, preso in input l'indirizzo fname di un  file di film,
    costruisce un dizionario che  registra poi  in formato json all'indirizzo fname1 e
    restituisce  la lista (ordinata lessicograficamente) con tutti i generi cinematografici
    presente nel file dei film.
    Il dizionario  ha per chiavi  delle stringhe  e per attributi delle liste.
    Le chiavi del dizionario sono i generi cinematografici dei film presenti nel file dei film.
    Nelle liste attributo ci sono i nomi dei film che sono riconducibili a quel genere
    cinematografico (ciascuna di queste liste deve risultare ordinata lessicograficamente).
    '''
    # inserisci qui il tuo codice
    d = json.load(open(fname))
    generi = []
    newd = dict()
    for key in d:
        for k in d[key]:
            if k != 'GENERI': continue
            for x in d[key][k]:
                if x not in generi:
                    generi.append(x)
    for g in generi:
        newd[g] = getFilmsbyGenere(d,g)
    generi.sort()
    with open(fname1,'w') as f:
        json.dump(newd,f)
    return generi












###############################################################################################

def es6(fname,fname1):
    '''
    6) 6 punti
    la funzione es6(fname,fname1) che, preso in input l'indirizzo fname di un  file di film
    costruisce un dizionario che  registra poi  in formato json all'indirizzo fname1.
    Il dizionario  ha per chiavi  degli interi e per
    attributi delle liste. Le chiavi del dizionario sono gli anni in cui sono stati realizzati
    i film presenti nel file di film e l'attributo di un dato anno e' la lista dei film del file
    girati in quell'anno ( ciascuna  lista deve essere ordinata lessicograficamente).
    La funzione ritorna la coppia (tupla) con il primo e ultimo anno trovato.
    '''
    # inserisci qui il tuo codice
    d = json.load(open(fname))
    newd = dict()
    for key in d:
        if key[key.find(';')+1:] not in newd:
            newd[key[key.find(';')+1:]] = []
        newd[key[key.find(';')+1:]].append(key[:key.find(';')])
    for key in newd:
        newd[key].sort()
    a = newd.keys()
    with open(fname1,'w') as f:
        json.dump(newd,f)
    return (int(min(a)), int(max(a)))














###############################################################################################

def getAttori(d):
    l = []
    for key in d:
        for k in d[key]:
            if k != 'ATTORI': continue
            for a in d[key][k]:
                if a not in l:
                    l.append(a)
    return l

def generiAttore(d,a):
    g = []
    for key in d:
        if a in d[key]['ATTORI']:
            for ge in d[key]['GENERI']:
                g.append(ge)
    return g

def es7(fname,fname1):
    '''
    7) 6 punti
    la funzione es7(fname,fname1) che, preso in input l'indirizzo fname di un
    file di film, costruisce un dizionario che  registra poi  in formato json all'indirizzo fname1.
    Il dizionario  ha per chiavi  e attributi delle stringhe.
    Le chiavi del dizionario sono  nomi di attori che hanno recitato nei film presenti nel file di film.
    Ad ogni attore viene associato il genere di film in cui l'attore e'
    specializzato (vale a dire il genere che predomina tra i generi dei film in cui ha recitato).
    Nel caso in cui per l'attore non ci sia un genere che predomina sugli altri, allora l'attore non
    deve comparire nel dizionario.
    La funzione torna la coppia (tupla) con il primo ed ultimo attore in ordine alfabetico.
    '''
    # inserisci qui il tuo codice
    d = json.load(open(fname))
    newd = dict()
    la = getAttori(d)
    finald = dict()
    for a in la:
        newd[a] = generiAttore(d,a)
    for a in newd:
        lgcount = {}
        for el in newd[a]:
            lgcount[el] = newd[a].count(el)
        listVal = list(lgcount.values())
        if listVal.count(max(listVal))>1:
            continue
        for el in lgcount:
            if lgcount[el] == max(listVal):
                finald[a] = el

    listaA = list(finald.keys())
    listaA.sort()

    with open(fname1,'w') as f:
        json.dump(finald, f)
    return (listaA[0],listaA[-1])









###############################################################################################

class Scheda_attore:
    '''
    8) 6 punti
    l'esercizio richiede di implementare la classe Scheda_attore composta da un inizializzatore e due metodi
    '''
    def __init__(self, nome, films=set(), generi=set(), registi=set(), anni=set()):
        '''Ciascun oggetto  della classe ha 4 attributi da specificare al momento
        della creazione: nome, films, generi e registi.
        Il primo attributo (nome) e' una stringa (il nome di un attore) gli altri tre sono insiemi.
         - films e' l'insieme dei film in cui l'attore ha recitato.
         - generi e' l'insieme dei generi dei film in cui l'attore ha recitato
         - registi  e' l'insieme  dei registi che hanno diretto l'attore
         - anni e' l'insieme degli anni in cui ha fatto film. '''
        # inserisci qui il tuo codice
        self.nome = nome
        self.films = films
        self.generi =generi
        self.registi = registi
        self.anni = anni






    def get_generi(self):
       '''il metodo get_generi restituisce una lista contenente i generi della scheda in ordine lessicografico.'''
       # inserisci qui il tuo codice
       l= list(self.generi)
       return l.sort()





    def aggiungi_film(self, film, titolo, anno):
        '''il metodo aggiungi_film aggiunge i dati di un film alla scheda dell'attore, se ha fatto parte del film.
            film:   dizionario con le informazioni del film
            titolo: titolo del film
            anno:   anno di produzione del film
        '''
        if self.nome in film['ATTORI'] :
           self.films.add(titolo)
           self.generi.update(film['GENERI'])
           self.registi.update(film['REGISTI'])
           self.anni.add(anno)







    def aggiorna_scheda(self, fname):
        '''il metodo aggiorna_scheda , dato l'indirizzo di un file di film aggiorna gli attributi della scheda
        tenendo conto degli eventuali film presenti nel file dei film in cui compare l'attore della scheda.
        Per farlo usa il metodo aggiungi_film'''
        # inserisci qui il tuo codice
        d = json.load(open(fname))
        for k in d:
            titolo = k[k.find(';')+1:]
            anno =  k[:k.find(';')]

            self.aggiungi_film( d[k], anno, titolo)