Esame #1 - 2023/2024

[alem1105]

func1: 2 points
Si definisca la funzione func1(int_list, n) che prende in
ingresso una lista di interi e un intero n. La funziona restituisce un
dizionario in cui le chiavi sono gli interi della lista int_list che hanno
un numero di ripetizioni maggiore o uguale a n e i valori sono il
numero di ripetizioni all'interno della lista int_list.

Esempio:
    func1([4, 4, 10, 4, 2, 1, 2], 2) deve restituire il dizionario
    {4: 3, 2: 2}
---------------------------------------------------------------------
func2: 2 points
Si definisca una funzione func2(dict1, a, b) che prende in ingresso
un dizionario che ha chiavi e valori di tipo stringa e due stringhe di
lunghezza uno. La funzione deve restituire una lista composta dalle
sole stringhe del dizionario corrispondenti a una chiave che inizia
con un carattere compreso fra i caratteri a e b, ignorando sempre
la distinzione fra maiuscole e minuscole.
La lista ritornata deve essere ordinata per numero di caratteri decrescente
e, in caso di parità, in ordine alfabetico.
Esempio:
    func2({'Car':'GoOd', 'floor':'bAd', 'Wild':'EXCELLENT', 'air':'Bad', 'cocoon':'greaT'}, 'c', 'G')
    deve restituire la lista ['greaT', 'GoOd', 'bAd']

---------------------------------------------------------------------
func3: 2 points
Si definisca una funzione func3(str1, str2) che prende in ingresso due stringhe
della stessa lunghezza e costruisce una nuova stringa str3 ottenuta
intervallando i caratteri di str1 con quelli di str2 rovesciata.
Inoltre, i caratteri di str1 devono cambiare da maiuscolo in minuscolo, e
viceversa.
La funzione restituisce la stringa così costruita.
Esempio:
    func3('gLIde', 'yoWLS')) deve restituire la stringa 'GSlLiWDoEy'
---------------------------------------------------------------------
func4: 6 points
Si definisca una funzione func4(input_filename, output_filename, expr) che
prende in ingresso due stringhe che rappresentano due nomi di file e una
terza stringa expr.
Il file indicato da input_filename contiene una serie di parole separate
da spazi, tabulazioni o a capo.
La funzione deve individuare all'interno del contenuto di input_filename tutte
le righe che contegono una parola uguale a 'expr', ignorando la distinzione
fra maiuscole e minuscole e riportarle nello stesso ordine all'interno di un
nuovo file con nome 'output_filename'.
Infine, la funzione deve ritornare un dizionario in cui:
    - le chiavi sono i numeri delle righe del file input_filename individuate
    - i valori sono triple contenenti rispettivamente:
        - il numero di caratteri totali della riga-chiave
        - il numero di parole della riga-chiave
        - il numero totale di spazi, tabulazioni e caratteri di a capo
          della riga-chiave

Nota: le righe iniziano dal numero 1.
Esempio
Se nel file 'func4_test1.txt' sono presenti le seguenti tre righe
cat bat    rat
Condor baT
Cat cAr CAR
la funzione func4('func4_test1.txt', 'func4_out1.txt', 'CAt') dovrà scrivere
nel file 'func4_out1.txt' le seguenti 2 righe:
cat bat    rat
Cat cAr CAR

e ritornare il dizionario {1: (15, 3, 6), 3: (11, 3, 2)}.
---------------------------------------------------------------------
func5: 8 punti

Si scriva una funzione chiamata func5 che, presa in input un'immagine RGB,
conti e restituisca il numero di pixel "isolati" non neri. Per pixel "isolato"
si intende un pixel che è preceduto e seguito da pixel neri
(ossia, dato un pixel P, esiste almeno un pixel nero che lo precede
 e uno che lo segue).

Nel caso in cui un pixel P si trovi sul bordo sinistro o destro dell'immagine
(ossia, si trovi nella prima o nell'ultima colonna), esso sarà considerato
"isolato" solo se il pixel successivo o precedente è nero. Inoltre, la
funzione dovrà salvare un'immagine RGB con la stessa larghezza e altezza
dell'immagine di input, nella quale saranno copiati solo i pixel isolati.

Ad esempio, se B rappresenta un pixel nero e * rappresenta
un pixel non nero, data l'immagine:

BB*BBBB*
*BBB*BBB
B*BB**B*
BBBBBB*B
*BBB**BB

La funzione restituisce 8 e salva l'immagine:

BB*BBBB*
*BBB*BBB
B*BBBBB*
BBBBBB*B
*BBBBBBB
---------------------------------------------------------------------
Ex1: 6 punti

Si definisca la funzione ex1(dirin), ricorsiva o che utilizza funzioni 
o metodi ricorsivi, avendo come argomento una stringa che indica il
percorso di una directory esistente.

La funzione esaminerà dirin e tutte le sue sottocartelle (a qualsiasi
livello), e conterà il numero di caratteri numerici trovato nei
file con estensione '.txt' presenti in qualsiasi cartella.

La funzione restituisce una lista di stringhe rappresentanti i percorsi
relativi alla directory dirin dei file in cui sono stati trovati i
caratteri numerici.
La lista dei percorsi dei file è ordinata in ordine decrescente in base
al numero di caratteri numerici trovati nei vari file.
Se due o più file hanno lo stesso numero di caratteri numerici,
si deve usare l'ordine crescente della profondità del file all'interno
della directory dirin.
In caso di parità, si deve usare l'ordine alfabetico.
Un file '.txt' che non contiene caratteri numerici non viene inserito
nella lista ritornata.

AVVISO 1: Si consiglia di utilizzare le funzioni os.listdir,
os.path.isfile e os.path.isdir e NON la funzione os.join in
Windows. Utilizzare la concatenazione tra stringhe con il carattere '/'.

AVVISO 2: è vietato utilizzare la funzione os.walk

Ad esempio, la funzione ex1('ex1/A') deve restituire la lista
['ex1/A/B/3odd74B.txt', 'ex1/A/C/e3dd7Ag22.txt', 'ex1/A/3cmi4G3ev.txt',
   'ex1/A/gkfep28.txt', 'ex1/A/C/n3ks22.txt']
---------------------------------------------------------------------
Ex2: 6 punti

Si definisca la funzione ex2(root), ricorsiva o che usa un metodo
ricorsivo, che prende in ingresso il nodo root che è la radice di
un albero binario costituito da nodi del tipo BinaryTree,
come definito nel modulo tree.py.
La funzione deve ritornare il numero di nodi dell'albero che hanno
un valore superiore alla somma dei nodi dei suoi sottoalberi.

Esempio:

        root      
    ______25______ 
   |             |  
   8__        ___2___ 
      |      |       |  
      3      9       1  

      expected = 2, ovvero i nodi 25 e 8


Altro esempio:

              root       
          ______2______  
         |             | 
      __ 7__        ___15___  
     |      |      |       | 
    _4_     3_    _0_     _5_  
   |   |      |  |   |   |   | 
   2   -1     1  8   3   2  -9 

       expected = 4, ovvero i nodi 4, 3, 15 e 5

[alem1105]

def func1(int_list, n):
    to_return = {}
    for elem in int_list:
        if int_list.count(elem) >= n:
            to_return[elem] = int_list.count(elem)
    return to_return


def func2(dict1, a, b):
    to_return = []
    for elem in dict1:
        if a.lower() <= elem[0].lower() <= b.lower():
            to_return.append(dict1[elem])
    return sorted(to_return, key=lambda x: (-len(x), x))


def func3(str1, str2):
    to_return = ''
    str2 = str2[::-1]
    for i in range(min(len(str1), len(str2))):
        to_return += str1[i].swapcase() + str2[i]
    return to_return


def func4(input_filename, output_filename, expr):
    lines = []
    to_return = {}
    with open(input_filename, 'r', encoding='utf-8') as file:
        for i, line in enumerate(file):
            if expr.lower() in line.lower():
                lines.append((i + 1, line))
    to_print = ''
    for elem in lines:
        to_print += elem[1]
        to_return[elem[0]] = (
            len(elem[1]), len([w for w in elem[1].replace('\t', ' ').replace('\n', ' ').split(' ') if w != '']),
            sum([elem[1].count(' '), elem[1].count('\t'), elem[1].count('\n')]))
    with open(output_filename, 'w', encoding='utf-8') as file:
        file.write(to_print)
    return to_return


def func5(input_file_name, output_file_name):
    img = images.load(input_file_name)
    isolated = 0
    img2 = [[(0, 0, 0) for _ in range(len(img[0]))] for _ in range(len(img))]

    for l in range(len(img)):
        for p in range(len(img[0])):
            if img[l][p] != (0, 0, 0):

                if p == 0 and img[l][p + 1] == (0, 0, 0):
                    isolated += 1
                    img2[l][p] = img[l][p]
                elif p == len(img[0]) - 1 and img[l][p - 1] == (0, 0, 0):
                    isolated += 1
                    img2[l][p] = img[l][p]
                elif img[l][p - 1] == (0, 0, 0) and img[l][p + 1] == (0, 0, 0):
                    isolated += 1
                    img2[l][p] = img[l][p]

    images.save(img2, output_file_name)
    return isolated


def ex1(dirin, to_return=None, i=0):
    if to_return is None:
        to_return = []

    for elem in os.listdir(dirin):
        percorso = f'{dirin}/{elem}'
        if percorso.endswith('.txt'):
            numerici = 0
            with open(percorso, 'r', encoding='utf-8') as file:
                testo = file.read()
            for char in testo:
                if char.isdigit():
                    numerici += 1
            if numerici:
                to_return.append((percorso, numerici, i))
        elif os.path.isdir(percorso):
            ex1(percorso, to_return, i + 1)

    if i == 0:
        to_return = sorted(to_return, key=lambda x: (-x[1], x[2], x[0]))
        to_return = [elem[0] for elem in to_return]
        return to_return


def ex2(root, to_return=None, i=0):
    if to_return is None:
        to_return = []

    somma = 0

    if root.right:
        somma += ex2(root.right, to_return, i + 1)
    if root.left:
        somma += ex2(root.left, to_return, i + 1)

    if root.left or root.right:
        if root.value > somma:
            to_return.append(0)

    somma += root.value

    if i == 0:
        return len(to_return)

    return somma