Esame #2 - 2023/2024

[alem1105]

func1: 2 punti

Si definisca la funzione func1(a_list) che viene fornita una lista di liste
non vuote come parametro. La funzione modifica la lista data direttamente,
sostituendo ciascuna sottolista con il prodotto degli elementi della stessa.
Inoltre, la funzione restituisce il numero di sottoliste.

Ad esempio, se L = [[1, 2, 3], [-1, 2, 3], [2, 2, -2]],
dopo aver chiamato func1(L), il valore di L sarà [6, -6, -8]
(poiché 1 * 2 * 3 = 6, -1 * 2 * 3 = -6 e 2 * 2 * -2 = -8),
e la funzione restituirà 3.
---------------------------------------------------------------------------------------
func2: 2 punti

Si scriva una funzione func2(a_dictionary) che prenda un dizionario
come parametro, in cui:

    - le chiavi sono singoli caratteri alfabetici
    - gli elementi sono liste di numeri interi

La funzione restituisce il carattere per il quale la lista di interi
corrispondente ha la somma più alta. Se più caratteri hanno la stessa
somma massima, viene restituito il primo in ordine alfabetico.

Ad esempio, func2({"a": [3, 2, 2], "b": [4, 2, 3], "c": [-4, 2, 2]})
restituisce "b", poiché la lista [4, 2, 3] ha la somma più alta
tra tutte le liste nel dizionario.
---------------------------------------------------------------------------------------
func3: 2 punti

Si definisca una funzione func3(list_A, list_B) che prende due liste
con lo stesso numero di stringhe in input. La funzione restituisce
una terza lista di stringhe. Ogni stringa nella posizione i
nella lista risultante contiene i caratteri comuni tra le due stringhe
nella posizione i in list_A e list_B, tutti in minuscolo,
in ordine alfabetico, e ignorando la maiuscola o minuscola che
avevano nelle stringhe in list_A e list_B. I caratteri comuni tra le
due stringhe nelle due liste possono trovarsi in qualsiasi posizione
all'interno delle stringhe. Le stringhe in list_A e list_B non possono
contenere caratteri ripetuti, indipendentemente dalla loro maiuscola o minuscola.

Ad esempio, se list_A = ["aBd", "baC", "cAb"] e list_B = ["bcE", "dca", "eDf"],
la funzione restituisce: ["b", "ac", ""].
---------------------------------------------------------------------------------------
func4: 6 punti

Si definisca una funzione func4(input_txt, output_txt) che prende
due nomi di file come parametri. La funzione legge il file di testo
input_txt e restituisce il numero di parole più lunghe di 3 caratteri
contenute nel file. Le parole possono essere separate da qualsiasi
numero di spazi o nuove righe.

La funzione scrive il file di testo output_txt che contiene
le parole contate dalla funzione in ordine inverso, una per riga.

Ad esempio, se input_txt contiene il seguente testo:

The          quick
           brown fox            jumps
    over

                 the     lazy             dog

La funzione restituisce 5, poiché ci sono 5 parole più lunghe di 3 caratteri
(quick, brown, jumps, over, lazy) e scrive il file:

lazy
over
jumps
brown
quick
---------------------------------------------------------------------------------------
func5: 8 points
Si scriva una funzione func5(imagefile, output_imagefile, color) che prende
in ingresso due stringhe che rappresentano due nomi di file di immagini PNG.
L'immagine nel file 'imagefile' contiene esclusivamente segmenti orizzontali
bianchi su uno sfondo nero e ha larghezza massima di 256 pixel.
Ogni riga ha al più un segmento bianco.
La funzione deve creare una nuova immagine con le stesse dimensioni e
gli stessi segmenti dell'immagine in ingresso, in cui il colore dei
segmenti con lunghezza minima e massima è modificato.
Il colore da utilizzare (R, G, B) è definito in questo modo:
    - il canale R corrisponde alla lunghezza del segmento con lunghezza minima
    - il canale B corrisponde alla lunghezza del segmento con lunghezza massima
    - il canale G corrisponde al valore che si ottiene dal valore medio delle
      lunghezze di tutti i segmenti (si utilizzi la divisione intera).

L'immagine così ottuenuta deve essere salvata in formato PNG nel file con
percorso output_imagefile.

La funzione ritorna il numero di segmenti colorati nell'immagine in output.
---------------------------------------------------------------------------------------
Ex1: 6 punti

Si definisca una funzione ex1(target_folder), ricorsiva o che utilizzi almeno una
funzione ricorsiva, che prenda in input il percorso di una cartella di destinazione.
La funzione scandisce in modo ricorsivo la cartella target_folder e tutte
le sue sottocartelle, restituendo una lista di coppie (percorso, conteggio), in cui:
- il percorso è il percorso completo di una delle sottocartelle della cartella target_folder
(nidificate a qualsiasi livello >= 0 all'interno della cartella di destinazione;
la cartella di destinazione può essere considerata una sottocartella di se stessa,
per cui il livello=0);
- il conteggio è il numero di file di testo contenuti nella sottocartella
(i file di testo sono file il cui nome termina con ".txt").

La lista restituita è ordinata in base al valore del contatore dei file, in ordine decrescente;
se due o più cartelle contengono lo stesso numero di file, vengono ordinate in ordine alfabetico.

Le uniche due funzioni che possono essere importate nella soluzione sono: os.listdir e os.path.isdir.

Ad esempio, se la struttura della cartella è la seguente:

A
|-B
| |-C
| | |-c1.txt
| | |-c2.txt
| |
| |-b1.txt
| |-b2.txt
| |-b3.txt
|
|-D
| |-d1.txt
| |-d2.txt
|
|-E
| |-e1.txt
|
|-a1.txt
|-a2.txt
|-a3.txt

La funzione restituisce la lista:

[("A", 3), ("A/B", 3), ("A/B/C", 2), ("A/D", 2), ("A/E", 1)]
---------------------------------------------------------------------------------------
Ex2: 6 marks

Si definisca una funzione ex2(T) che prende come parametro la radice T
di un albero binario, memorizzato come un oggetto BinaryTree definito
nel file tree.py. La funzione è ricorsiva o utilizza almeno una
funzione ricorsiva. I valori nell'albero sono interi.
La funzione restituisce la terna (L, S, D), dove:
- L è il numero di foglie;
- S è il numero di nodi con un solo nodo figlio;
- D è il numero di nodi con due nodi figli.

Ad esempio, se T è:

                T       
          ______2______  
         |             | 
      __ 7__        ___15___  
     |      |      |       | 
    _4      3     _0_      5_  
   |             |   |       | 
   2             8   3      -9 

La funzione restituisce: (5, 2, 4)

[alem1105]

def func1(a_list):
    for i in range(len(a_list)):
        prodotto = 1
        for elem in a_list[i]:
            prodotto *= elem
        a_list[i] = prodotto

    return len(a_list)

def func2(a_dictionary):
    to_return = []
    for key in a_dictionary:
        to_return.append((key, sum(a_dictionary[key])))
    to_return = sorted(to_return, key=lambda x: (-x[1], x[0]))
    return to_return[0][0]

def func3(list_A, list_B):
    to_return = []
    for coppia in zip(list_A, list_B):
        set1 = set(coppia[0].lower())
        set2 = set(coppia[1].lower())
        comuni = set1.intersection(set2)
        comuni = sorted(list(comuni))
        to_return.append(''.join(comuni))
    return to_return

def func4(input_txt, output_txt):
    with open(input_txt, 'r', encoding='utf-8') as file:
        testo = file.read()
    words = [elem for elem in testo.replace('\t', ' ').replace('\n', ' ').split(' ') if elem != '' and len(elem) > 3]
    to_print = ''
    for elem in words[::-1]:
        to_print += f'{elem}\n'
    with open(output_txt, 'w', encoding='utf-8') as file:
        file.write(to_print)
    return len(words)

def func5(imagefile, output_imagefile):
    img = images.load(imagefile)

    lengths = []

    for l in range(len(img)):
        for p in range(len(img[0])):
            if img[l][p] == (255, 255, 255):
                length = 0
                while p < len(img[0]) and img[l][p] == (255, 255, 255):
                    length += 1
                    p += 1
                lengths.append(length)
                break

    r, b, g = min(lengths), max(lengths), sum(lengths) // len(lengths)
    to_return = 0

    for l in range(len(img)):
        for p in range(len(img[0])):
            if img[l][p] == (255, 255, 255):
                length = 0
                start = p
                while p < len(img[0]) and img[l][p] == (255, 255, 255):
                    length += 1
                    p += 1
                if length == max(lengths) or length == min(lengths):
                    img[l][start:p] = [(r, g, b)] * (p-start)
                    to_return += 1
                else:
                    img[l][start:p] = [(255, 255, 255)] * (p - start)
                break

    images.save(img, output_imagefile)
    return to_return

def ex1(target_folder, to_return=None):
    if to_return is None:
        to_return = []
    files = 0
    for elem in os.listdir(target_folder):
        percorso = f'{target_folder}/{elem}'
        if percorso.endswith('.txt'):
            files += 1
        elif os.path.isdir(percorso):
            ex1(percorso, to_return)
    to_return.append((target_folder, files))
    return sorted(to_return, key=lambda x:(-x[1],x[0]))

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

    if not T.left and not T.right:
        to_return[0] += 1
    if (T.left and not T.right) or (T.right and not T.left):
        to_return[1] += 1
    elif T.left and T.right:
        to_return[2] += 1

    if T.left:
        ex2(T.left, to_return, i+1)
    if T.right:
        ex2(T.right, to_return, i+1)

    if i == 0:
        return tuple(to_return)