Aula09 - ex1-3 added

1ano/fp/aula09/countLetters2.py

@@ -0,0 +1,33 @@
+import sys
+
+
+def main():
+    letters = countLetters(sys.argv[1])
+    
+    # Print the results
+    for c in sorted(letters, key=letters.get, reverse=True):
+        print(c, letters[c])
+
+    # Print the most used letter and the number of times it's used
+    usedTheMostCount = max(letters.values())
+    usedTheMost = [letter for letter in letters.keys() if letters[letter] == usedTheMostCount][0]
+    print(f"A letra mais usada foi '{usedTheMost}', usada {usedTheMostCount} vezes.")
+
+
+def countLetters(filename):
+    # Read the file and count the letters
+    letters = {}
+    with open(filename, 'r') as f:
+        for c in f.read():
+            if c.isalpha():
+                c = c.lower()
+                if c not in letters:
+                    letters[c] = 0
+                letters[c] += 1
+    
+    # Returns the dictionary with the letters
+    return letters
+
+
+if __name__ == "__main__":
+    main()

1ano/fp/aula09/insertionSort.py

@@ -0,0 +1,51 @@
+
+# This function sorts a list (like list.sort)
+# using the insertion sort algorithm.
+# Modify it to accept a key= keyword argument that works like in list.sort.
+
+def insertionSort(lst):
+    # Traverse elements starting at position 1
+    for i in range(1, len(lst)):
+        # We know that lst[:i] is sorted
+        x = lst[i]    # x is the element to insert next
+        # Elements in lst[:i] that are > x must move one position ahead
+        j = i - 1
+        while j >= 0 and lst[j] > x:
+            lst[j + 1] = lst[j]
+            j -= 1
+        # Then put x in the last emptied slot
+        lst[j + 1] = x
+        # Now we know that lst[:i+1] is sorted
+    return
+
+
+
+def main():
+    # Original list
+    lst0 = ["paulo", "augusto", "maria", "paula", "bernardo", "tito"]
+    print("lst0", lst0)
+
+    # sort in lexicographic order:
+    lst = lst0.copy()
+    insertionSort(lst)
+    print("lst1", lst)
+    assert lst == sorted(lst0)
+
+    # sort by length (requires key= argument):
+    lst = lst0.copy()
+    insertionSort(lst, key=len)
+    print("lst2", lst)
+    assert lst == sorted(lst0, key=len)
+
+    # sort by length, than lexicographic order:
+    myorder = lambda s:(len(s), s)
+    lst = lst0.copy()
+    insertionSort(lst, key=myorder)
+    print("lst3", lst)
+    assert lst == sorted(lst0, key=myorder)
+
+    print("All tests OK!")
+
+if __name__ == "__main__":
+    main()
+

1ano/fp/aula09/median.py

@@ -0,0 +1,15 @@
+def main():
+    lst = [1, 2, 4, 5]
+    print(median(lst))
+
+
+def median(lst):
+    lst = sorted(lst, reverse=True)
+    if len(lst) % 2 == 0:
+        return (lst[len(lst) // 2] + lst[len(lst) // 2 - 1]) / 2
+    else:
+        return lst[len(lst) // 2]
+
+
+if __name__ == '__main__':
+    main()

1ano/fp/aula09/polynomial.py

@@ -0,0 +1,39 @@
+# COMPLETE a função abaixo.
+# Veja os exemplos de utilização e resultados esperados.
+
+# polynomial2(a,b,c) deve devolver uma função f tal que
+# f(x) seja o polinómio de segundo grau ax²+bx+c.
+def polynomial2(a, b, c):
+    ...
+
+
+# DESAFIO EXTRA:
+# Crie uma versão generalizada que cria polinómios de qualquer grau.
+# (Não é tão fácil com expressões lambda.)
+
+# polynomial(a), onde a=[a0, a1, ..., an], deve devolver uma função f tal que
+# f(x) seja o polinómio a0*x**n + a1*x**(n-1) + ... + an.
+def polynomial(coefs):
+    ...
+
+
+def main():
+    xx = [0, 1, 2, 3]   # Valores de x a testar
+
+    print("\nTestes à função polynomial2:")
+    p = polynomial2(1, 2, 3)    # creates p(x)=x²+2x+3
+    print([p(x) for x in xx])   # [3, 6, 11, 18]
+
+    q = polynomial2(2, 0, -2)   # creates q(x)=2x²-2
+    print([q(x) for x in xx])   # [-2, 0, 6, 16]
+
+    print("\nTestes à função polynomial:")
+    r = polynomial([1, 2, 3])   # same as p(x)
+    print([r(x) for x in xx])   # [3, 6, 11, 18]
+
+    s = polynomial([1, -1, 0, 100])     # creates s(x)=x³-x²+100
+    print([s(x) for x in xx])           # [100, 100, 104, 118]
+
+if __name__ == "__main__":
+    main()
+

1ano/fp/aula09/tabelaFutebol.py

@@ -0,0 +1,85 @@
+
+# Tabela classificativa da Primeira Liga de futebol de Portugal em 2018-11-30.
+# (Descarregada de https://www.resultados.com/futebol/portugal/primeira-liga/)
+
+tabela = [
+    ("Rio Ave", 5, 3, 2, 17, 13),
+    ("Tondela", 2, 3, 5, 12, 14),
+    ("Moreirense", 5, 1, 4, 11, 14),
+    ("Feirense", 2, 3, 5, 7, 11),
+    ("Maritimo", 3, 1, 6, 6, 13),
+    ("Benfica", 6, 2, 2, 19, 11),
+    ("Setubal", 4, 2, 4, 13, 11),
+    ("Portimonense", 3, 2, 5, 12, 18),
+    ("Guimaraes", 4, 3, 3, 15, 12),
+    ("Boavista", 2, 3, 5, 8, 14),
+    ("Nacional", 2, 3, 5, 10, 19),
+    ("Belenenses", 2, 6, 2, 7, 8),
+    ("Santa Clara", 4, 2, 4, 17, 16),
+    ("FC Porto", 8, 0, 2, 21, 6),
+    ("Braga", 6, 3, 1, 19, 10),
+    ("Sporting", 7, 1, 2, 18, 10),
+    ("Aves", 3, 1, 6, 11, 15),
+    ("Chaves", 2, 1, 7, 9, 17)
+]
+
+# Cada registo na tabela classificativa contém:
+#   Nome, Vitórias, Empates, Derrotas, Golos Marcados e Golos Sofridos
+# Pode usar estes identificadores para os campos:
+N, V, E, D, GM, GS = 0, 1, 2, 3, 4, 5
+
+
+def printTabela(tabela):
+    print()
+    print("{:19s} {:>3} {:>3} {:>3} {:>3} {:>3}:{:<3} {:>3}".format(
+            "Equipa", "J", "V", "E", "D", "GM", "GS", "P"))
+    for reg in tabela:
+        nome,v,e,d,gm,gs = reg
+        print("{:19s} {:3d} {:3d} {:3d} {:3d} {:3d}:{:<3d} {:3d}".format(
+                nome, numJogos(reg), v, e, d, gm, gs, pontos(reg)))
+
+
+# numJogos é uma função definida por uma expressão lambda que,
+# dado um registo de uma equipa, devolve o número de jogos que a equipa jogou.
+numJogos = lambda reg: reg[V]+reg[E]+reg[D]
+
+
+# a)
+# Complete a expressão lambda para definir uma função que,
+# dado um registo de uma equipa, devolva o número de pontos da equipa.
+# (Cada vitória vale 3 pontos, cada empate vale 1 ponto.)
+pontos = lambda reg: reg[V]*3+reg[E]
+
+
+def main():
+    # Teste:
+    print(tabela[3][N], numJogos(tabela[3]))  # Feirense 10?
+
+    print(tabela[-1][N], pontos(tabela[-1]))  # Chaves 7?
+
+
+    # Mostra a tabela classificativa original, não ordenada:
+    printTabela(tabela)
+
+    # b)
+    # Acrescente os argumentos adequados à função sorted para
+    # obter uma tabela ordenada por ordem decrescente de pontos:
+    tab = sorted(tabela, key=pontos, reverse=True)
+    printTabela(tab)
+
+    # c)
+    # Acrescente os argumentos adequados à função sorted para
+    # obter uma tabela ordenada por ordem decrescente da diferença GM-GS:
+    tab = sorted(tabela, key=lambda reg: reg[GM]-reg[GS], reverse=True)
+    printTabela(tab)
+
+    # d)
+    # Acrescente os argumentos adequados à função sorted para
+    # obter uma tabela ordenada por ordem decrescente de pontos e,
+    # se iguais, por ordem da diferença GM-GS:
+    tab = sorted(tabela, key=lambda reg: (pontos(reg), reg[GM]-reg[GS]), reverse=True)
+    printTabela(tab)
+
+
+if __name__ == "__main__":
+    main()