sur->mac

asdl/src/jcf_map/exercise/BinaryTreeMap.java

@@ -0,0 +1,43 @@
+package jcf_map.exercise;
+
+import java.util.Map;
+import java.util.TreeMap;
+
+import binary_tree.BinaryNode;
+
+public class BinaryTreeMap {
+	/*
+	 * Esercizio 1 - Esame del secondo parziale 8/1/2019
+	 * Scrivere un metodo generico statico ContaDuplicati che conta il numero 
+	 * di oggetti duplicati (non univoci) contenuti in un albero binario.
+	 * Il risultato è il conteggio totale degli elementi che risultano duplicati 
+	 * (non il numero totale di occorrenze, ma il numero di oggetti distinti che 
+	 * hanno almeno un duplicato)
+	 */
+	public static <T extends Comparable<? super T>> int ContaDuplicati(BinaryNode<T> node) {
+		int dup = 0;
+		TreeMap<T, Integer> mappa = new TreeMap<T, Integer>();
+		ContaDuplicati(node, mappa);
+		
+		for (T element : mappa.keySet()) {
+			int occurrency = mappa.get(element);
+			if (occurrency > 1) dup++;
+		}
+		
+		return dup;
+	}
+	
+	protected static <T> void ContaDuplicati(BinaryNode<T> node, TreeMap<T, Integer> mappa) {
+		if (node == null) return;
+		
+		if (node.getLeft() != null) ContaDuplicati(node.getLeft(), mappa);
+		if (node.getRight() != null) ContaDuplicati(node.getRight(), mappa);
+		
+		if (node.getData() == null) return;
+		
+		T data = node.getData();
+		if (mappa.get(data) == null) mappa.put(data, 1);
+		else mappa.put(data, mappa.get(data) + 1);
+	}
+	
+}

asdl/src/jcf_map/exercise/CompanyMap.java

@@ -0,0 +1,41 @@
+package jcf_map.exercise;
+
+import java.util.TreeMap;
+
+public class CompanyMap {
+	
+	/*
+	 * EX1 
+	 * Supponiamo che chi vengano forniti il nome e il numero 
+	 * di divisione di ciascun dipendente di un'azienda. 
+	 * Non ci sono nomi duplicati. Vorremmo memorizzare 
+	 * queste informazioni in ordine alfabetico per nome.
+	 */
+	/*
+	 * Spiegazione: si intende adoperare chiaramente un TreeMap.
+	 * In modo che vi sia una associazione chiave-valore e un ordinamento basato 
+	 * sulla chiave.
+	 * 	Chiave: String
+	 * Valore: Integer
+	 */
+	
+	public static void main(String[] main) {
+		new CompanyMap().run();
+	}
+	
+	public void run() {
+		TreeMap<String, Integer> mappaAssociazione = new TreeMap<String, Integer>();
+		
+		mappaAssociazione.put("Rossi Marco", 8);
+		mappaAssociazione.put("Bianchi Luca", 14);
+		mappaAssociazione.put("Esposito Andrea", 6);
+		mappaAssociazione.put("Ferrari Matteo", 6);
+		mappaAssociazione.put("Romano Giulia", 14);
+		mappaAssociazione.put("Ricci Alessia", 6);
+		
+		System.out.println("Stampa mappa associazione: ");
+		System.out.println(mappaAssociazione);
+		System.out.println("Numero di dipendenti: " + mappaAssociazione.size());
+	}
+	
+}

asdl/src/jcf_map/exercise/Dispari.java

@@ -0,0 +1,52 @@
+package jcf_map.exercise;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedList;
+
+public class Dispari<E extends Comparable<? super E>> {
+	
+	/*
+	 * Esercizio 1 - Esame del 5 settembre 2017
+	 * 
+	 * Una lista si dice dispari se ciascuno dei suoi oggetti appare un numero dispari di volte.
+	 * Ad esempio, la lista di interi [20, 5, 5, 20, 20] non è dispari, mentre lo è [5, 20, 5 , 5].
+	 * Si assuma una classe Dispari<E> con una sola variabile di instanza private LinkedList<E> myList.
+	 * Si implementi un metodo public boolean ordinaDispari() {} interno alla classe, 
+	 * che restituisce false se myLisy non è dispari, mentre ordina in modo crescente la lista 
+	 * e restituisce true se myList è dispari;
+	 * Si assuma che gli elementi presenti nella lista implementino l'interfaccia Comparable<T>
+	 */
+	
+	// Variabile di instanza
+	private LinkedList<E> myList = new LinkedList<E>();
+	
+	// Metodo di esercizio
+	public boolean isDispari() {
+		// Se la lista è vuota allora returna dispari
+		if (myList.isEmpty()) return true;
+		
+		// Contatore di elementi nella lista
+		HashMap<E, Integer> valori = new HashMap<E, Integer>();
+		
+		Iterator<E> it = myList.iterator();
+		while (it.hasNext()) {
+			E current = it.next();
+			if (valori.get(current) == null) valori.put(current, 1);
+			else valori.put(current, valori.get(current) + 1);
+		}
+		
+		// Controllo short circuit di disparità
+		for (E chiave : valori.keySet()) {
+			int valore = valori.get(chiave);
+			if (valore % 2 == 0) return false;
+		}
+		
+		// Arrivati qui la lista è dispari, manca solo l'ordinamento.
+		Collections.sort(myList);
+		return true;
+	}
+	
+	
+}