Add files via upload

Author: noranta4

ASD2016-ProgrammingExercises-A.Panconesi.pdf

@@ -0,0 +1,72 @@
+__author__ = 'Antonio Norelli'
+
+#CORSO DI ALGORITMI E STRUTTURE DATI 2016
+#esPROG1
+#STABLE MARRIAGE
+
+###############################################################################
+
+import sys
+orig_stdout = sys.stdout #servira' per stampare su file
+
+#acquisizione dati in due dizionari
+
+men_pref = {}
+wmen_pref = {}
+men_status = {}
+wmen_status = {}
+
+with open('men.txt') as f:
+    n_men = int(f.readline())
+    for man in range(n_men):
+        rank_man = map(int, f.readline().split())
+        id_m = rank_man.pop(0)
+        men_pref[id_m] = rank_man
+        men_status[id_m] = 0 #libero
+
+with open('women.txt') as f:
+    n_wmen = int(f.readline())
+    for wman in range(n_wmen):
+        rank_wman = map(int, f.readline().split())
+        id_w = rank_wman.pop(0)
+        wmen_pref[id_w] = rank_wman
+        wmen_status[id_w] = 0
+
+#algoritmo
+
+
+def matching(men_pref, men_status, wmen_pref, wmen_status):
+    while 0 in men_status.values(): #finche' ci sono uomini liberi
+        for m in men_pref: #scansione uomini
+            if men_status[m] == 0: #se libero
+                for w in men_pref[m]: #scansione della sua lista di preferenze
+                    if wmen_status[w] == 0: #se la donna e' libera
+                        men_status[m] = w #match
+                        wmen_status[w] = m
+                        break #smetti di scorrere la lista di preferenze
+                    else: #se la donna non e' libera
+                        if wmen_pref[w].index(wmen_status[w]) > wmen_pref[w].index(m): #se preferisce questo uomo a quello con cui sta
+                            men_status[wmen_status[w]] = 0 #l'uomo con cui sta torna libero
+                            wmen_status[w] = m #match
+                            men_status[m] = w
+                            break #smetti di scorrere la lista di preferenze
+    return men_status
+
+def output(dict_couples):
+    f = file('marriage.txt', 'w')
+    sys.stdout = f
+    for i in dict_couples:
+        print i, '\t', dict_couples[i]
+
+
+#esecuzione
+
+
+output(matching(men_pref, men_status, wmen_pref, wmen_status))
+
+
+
+
+
+
+

ProgrammingAssignment2.pdf

@@ -0,0 +1,83 @@
+__author__ = 'Antonio Norelli'
+
+#CORSO DI ALGORITMI E STRUTTURE DATI 2016
+#esPROG2
+#STRONGLY CONNECTED COMPONENTS
+
+###############################################################################
+
+
+#acquisizione dati e costruzione del grafo inverso
+
+
+import sys
+orig_stdout = sys.stdout #servira' per stampare su file
+
+graph = {}
+node_v = {} #valore nodo: 0 se non visitato 1 se visitato n<0 postnumber
+inv_graph = {} #grafo inverso
+inv_node_v = {}
+
+with open('graph.txt') as f: #acquisizione grafo su dizionario
+    n_nodes = int(f.readline())
+    for node in range(n_nodes):
+        reachable_nodes = map(int, f.readline().split())
+        id_n = reachable_nodes.pop(0)
+        graph[id_n] = set(reachable_nodes)
+        inv_graph[id_n] = set() #inizializzazione grafo inverso, valore nodi grafo e grafo inverso
+        node_v[id_n] = 0
+        inv_node_v[id_n] = 0
+
+for node in graph: #costruzione grafo inverso
+    for reachable in graph[node]:
+        inv_graph[reachable].add(node)
+
+
+#funzione depth first search
+
+
+def dfs(graph, start, node_v):
+    global clock #variabile globale per il postnumber
+    global stack #variabile globale con l'insieme dei nodi visitati in una dfs
+    node_v[start] = 1 #marcato come visitato
+    for node in graph[start]: #per ogni nodo raggiungibile
+        if node_v[node] == 0: #se non visitato
+            dfs(graph, node, node_v) #esegui una dfs
+    node_v[start] = clock #postnumber quando si blocca la dfs
+    stack.append(start)
+    clock -= 1
+    return node_v
+
+
+#dfs sul grafo inverso per ottenere la lista ordinata rev_rank su cui eseguire la seconda dfs
+
+
+clock = -1
+rev_rank = []
+for node in graph:
+    if inv_node_v[node] == 0:
+        stack = [] #inizializzazione stack
+        inv_node_v = dfs(inv_graph, node, inv_node_v)
+        rev_rank.extend(stack) #costruzione del rank (inverso)
+
+clock = -1
+group = {} #componenti fortemente connesse
+rank_comp = 0 #rank componente = max of postnumbers = postnumber of start in the dfs
+component = [] #inizializzazione rank e componente
+
+for node in reversed(rev_rank): #seconda dfs
+    if node_v[node] == 0: #se non visitato
+        stack = [] #inizializzazione variabile
+        node_v = dfs(graph, node, node_v)
+        rank_comp = node_v[node]
+        group[-rank_comp] = stack #memorizzazione delle scc
+
+
+#output
+
+
+f = file('scc.txt', 'w')
+sys.stdout = f
+print len(group)
+for component in sorted(group, reverse=True):
+    print str(group[component])[1:-1]

antonio_norelli_solutions/antonio_norelli_1612487_1.py

@@ -0,0 +1,46 @@
+__author__ = 'Antonio Norelli'
+
+#I build a dictionary with the sorted strings (EX. hte -> eht) as keys
+#every key is associated to a list with all the anagrams in the input_string of the key
+#I scan the dictonary and I append every item of every list to the result
+
+#COST n = number of strings, m = average lenght of a string
+#build the dictionary: O(n*m*log(m)) (sort letters of every string in alphabetical order)
+#value of a key is computable in O(1) because dict is implemented in python as hash table
+#assemble the result: O(n*log(n)) if alphabetical order is necessary (sort dict O(n*log(n)), scan dict O(n))
+#                     O(n) if alphabetical order is not necessary
+#total = O(n*m*log(m)) if alphabetical order is not necessary
+#        O(MAX(n*m*log(m), n*log(n))) if alphabetical order is necessary
+
+#................................................................................................................
+
+#SAMPLE INPUT
+
+input_strings = ['ab', 'ciao', 'the', 'iaoc', 'caio', 'ot', 'hte', 'ba', 'ab', 'go']
+
+#PROGRAM
+
+def sort_by_anagrams(list_of_strings):
+    dict_of_anagrams = {}
+    for string in list_of_strings:
+        sorted_string = ''.join(sorted(string))
+        if sorted_string in dict_of_anagrams:
+            dict_of_anagrams[sorted_string].append(string)
+        else:
+            dict_of_anagrams[sorted_string] = [string]
+    result = []
+    for anagram in sorted(dict_of_anagrams): #if alphabetical order is not necessary delete this and next sorted call
+        for string in sorted(dict_of_anagrams[anagram]):
+            result.append(string)
+    return result
+
+print sort_by_anagrams(input_strings)
+
+
+
+
+
+
+
+
+

antonio_norelli_solutions/antonio_norelli_1612487_2.py

@@ -0,0 +1,73 @@
+__author__ = 'Antonio Norelli'
+
+#I create a new class using a list of lists and performing operations with built-in function append(item) and pop()
+#I have two values to use properly the SetOfStacks:
+#item_last_stack (# of item in the last stack) and stack (index of currently stack)
+
+#COST all single operations are O(1),
+#I think python compiler memorizes the size of every list and do in O(1) also append(item) and len(list)
+
+#................................................................................................................
+
+#PROGRAM
+
+class SetOfStacks(object):
+    def __init__(self, threshold): #threshold included in the declaration
+        self.threshold = threshold
+        self.set = [[]]
+        self.item_last_stack = 0
+        self.stack = 0
+    def push(self, item):
+        if self.item_last_stack < self.threshold: #if last stack isn't full
+            self.set[self.stack].append(item)
+            self.item_last_stack += 1
+        else:
+            self.stack += 1
+            self.set.append([]) #create a new stack
+            self.set[self.stack].append(item)
+            self.item_last_stack = 1
+    def pop(self): #possible situation: [[], [0,1], [], []] before pop we have to delete the last two empty stacks
+        while self.item_last_stack == 0: #while the last stack is empty
+            del self.set[-1] #delete last stack
+            self.stack -= 1
+            self.item_last_stack = len(self.set[self.stack])
+        self.item_last_stack -= 1
+        return self.set[self.stack].pop()
+    def popAt(self, index):
+        if self.stack < index:
+            print 'Sorry, but this stack does not exist'
+        if len(self.set[index]) == 0:
+            print 'This stack is empty'
+        else:
+            return self.set[index].pop()
+
+#SAMPLE INPUT AND USE
+
+sample = SetOfStacks(3)
+
+for i in range(10):
+    sample.push(i)
+print 'Sample SetOfStacks: ', sample.set, '\n'
+
+print 'pop five times on sub-stack 1 \nrunning...'
+for i in range(5):
+    sample.popAt(1)
+print '... \nresult: ', sample.set, '\n'
+
+print 'push new item 42'
+sample.push(42)
+print 'result: ', sample.set, '\n'
+
+print 'pop six times'
+for i in range(6):
+    sample.pop()
+print 'result: ', sample.set
+
+
+
+
+
+
+
+
+

antonio_norelli_solutions/antonio_norelli_1612487_3.py

@@ -0,0 +1,38 @@
+__author__ = 'Antonio Norelli'
+
+#Assuming binary tree stored in an array where the father of array[i] is array[int((array[i]-1)/2))]:
+#EXAMPLE:   array = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K']
+#indexes of array = [ 0 ,  1 ,  2 ,  3 ,  4 ,  5 ,  6 ,  7 ,  8 ,  9 ,  10]
+#A father of B, C; B father of D, E; C father of F, G...
+
+#COST O(log(n)) where n is the lenght of the array
+
+#................................................................................................................
+
+#SAMPLE INPUT
+
+input_alb_bin = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K']
+input_node_a = 'H'
+input_node_b = 'D'
+
+#PROGRAM
+
+def find_index(alb_bin, node_a, node_b): #find indexes of two nodes in input
+    index_a = alb_bin.index(node_a)
+    index_b = alb_bin.index(node_b)
+    return [index_a, index_b]
+
+def find_ancestor(indexes): #indexes = [index_a, index_b]
+    while True:
+        if indexes[0] < indexes[1]: #change deeper node with his father
+            indexes[1] = int((indexes[1]-1)/2)
+        elif indexes[1] < indexes[0]:
+            indexes[0] = int((indexes[0]-1)/2)
+        else: #if the two nodes are the same, return one of them
+            return indexes[0]
+
+print 'common ancestor is:', input_alb_bin[find_ancestor(find_index(input_alb_bin, input_node_a, input_node_b))]
+
+
+
+

antonio_norelli_solutions/antonio_norelli_1612487_4.py

@@ -0,0 +1,48 @@
+__author__ = 'Antonio Norelli'
+
+#Take the total, you have at least one solution with:
+#0 coin of the largest size... i coins of the largest size... q coins of the largest size where q=int(total/(largest size))
+#now for every combination from 0 to q coins of the largest size, remaining are total-i*(largest size)=total'
+#and you have at least one solution with:
+#0 coin of the second largest size... i coins of the  second largest size... q' coins of the second largest size
+# where q'=int(total'/(second largest size))
+#and so on
+#when your total' is 0 or you are working with the smallest size there is only one solution
+#and you add it to the global variable result
+
+#COST there are at least k calls of the recursive function where k=result
+#An upperbound for the result is n*(n/5)*(n/10)*(n/25)
+#It's impossible to have a solution with more than n pennies, n/5 nikels, n/10 dimes, n/25 quarters...
+#So the cost is O(n^4)
+
+#................................................................................................................
+
+#SAMPLE INPUT
+
+cents = 100
+
+#PROGRAM
+
+#cicli = 0 #use the commented lines if you want the number of calls of combination function
+
+sizes = [1, 5, 10, 25]
+result = 0
+
+def combinations(remaining, j): #j is the index of the actual coin size
+    global sizes
+    global result
+
+    #global cicli
+    #cicli += 1
+
+    current_value = sizes[j]
+    if remaining == 0 or j == 0: #if remaining is 0 or you are working with the smallest size there is only one solution
+        result += 1
+        return
+    for i in range(int(remaining/current_value)+1): #at least one solution with i coins of the current value
+        combinations(remaining-i*current_value, j-1) #recall the function with remaining and next smaller coin value
+
+combinations(cents, len(sizes)-1)
+print 'number of ways of representing', cents, 'cents:', result
+
+#print cicli