/
segundo_parcial.py
173 lines (149 loc) · 6.96 KB
/
segundo_parcial.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
"""
1) Acomodar [2 puntos]
El próximo 19 de Noviembre se realizará en Argentina la segunda vuelta de las
elecciones presidenciales. En esta competirán solo 2 listas (Lista UP; Lista
LLA). En la mayor parte del país los salones de las escuelas ofician de cuartos
oscuros. En ellos, las autoridades de mesa colocan las boletas sobre los
pupitres. Dado que esta elección se realizará en una eṕoca donde muy
probablemente haga mucho calor, no será raro el caso en el cual las boletas se
vuelen y mezclen a causa de ventiladores prendidos a máxima potencia. Cuando
esto ocurra, las autoridades deberán entrar al cuarto oscuro, juntar todas las
boletas, acomodarlas por partido y volver a distribuirlas en sus lugares.
Implementar una función acomodar que tome una lista con strings que
representan el nombre de lista (UP o LLA) y devuelva una lista con la misma
cantidad de elementos de cada uno de los posibles strings pero agrupadas, las
de Lista UP al principio y las de lista LLA al final.
No está permitido utilizar las funciones sort() y reverse().
problema acomodar (in s: seq<String>) : seq<String> {
requiere: { Todos los elementos de s son o bien "LLA" o bien "UP"}
asegura: {|res| = |s|}
asegura: { Todos los elementos de res son o bien "LLA" o bien "UP"}
asegura: {res contiene la misma cantidad de elementos "UP" que s}
asegura: {res contiene todas las apariciones de "UP" antes de las
apariciones de "LLA"}
}
Por ejemplo, dada
s = ["LLA", "UP", "LLA", "LLA", "UP"]
se debería devolver res = ["UP", "UP", "LLA", "LLA", "LLA"]
2) Posición umbral [2 puntos]
Durante una noche en un restaurant pasan varios grupos de diversa cantidad de
personas. Para llevar control de esto, el dueño va anotando en su libreta
cuánta gente entra y sale. Para hacerlo rápido decide que la mejor forma de
llevarlo adelante es escribir un número al lado del otro, usando números
positivos para los grupos que entran y negativos para los que salen. Gracias a
estas anotaciones el dueño es capaz de hacer análisis del flujo de clientes.
Por ejemplo, le interesa saber en qué momento de la noche superó una
determinada cantidad de clientes totales que ingresaron (sin importar cuántos
hay en el momento en el local).
Implementar la función pos_umbral, que dada una secuencia de enteros (puede
haber negativos) devuelve la posición en la cual se supera el valor de umbral,
teniendo en cuenta sólo los elementos positivos. Se debe devolver -1 si el
umbral no se supera en ningún momento
problema pos_umbral (in s: seq<Z>, in u: Z) : Z {
requiere: u ≥ 0
asegura: {res=-1 si el umbral no se supera en ningún momento }
asegura: {Si el umbral se supera en algún momento, res es la primera
posición tal que la sumatoria de los primeros res+1 elementos
(considerando solo aquellos que son positivos) es estrictamente mayor que
el umbral u }
Por ejemplo, dadas
s = [1,-2,0,5,-7,3]
u = 5
se debería devolver res = 3
3) Columnas repetidas [3 puntos]
Implementar la función columnas_repetidas, que dada una matriz no vacía de m
columnas (con m par y m ≥ 2) devuelve True si las primeras m/2 columnas son
iguales que las últimas m/2 columnas. Definimos a una secuencia de secuencias
como matriz si todos los elementos de la primera secuencia tienen la misma
longitud.
problema columnas_repetidas(in mat:seq<seq<Z>> ) : Bool {
requiere: {|mat| > 0}
requiere: {todos los elementos de mat tienen igual longitud m, con m > 0
(los elementos de mat son secuencias)}
requiere: {todos los elementos de mat tienen longitud par (la cantidad de
columnas de la matriz es par)}
asegura: {(res = true) <=> las primeras m/2 columnas de mat son iguales a
las últimas m/2 columnas}
}
Por ejemplo, dada la matriz
m = [[1,2,1,2],[-5,6,-5,6],[0,1,0,1]]
se debería devolver res = true
TIP: para dividir un número entero x por 2 y obtener como resultado un número
entero puede utilizarse la siguiente instrucción: int(x/2)
4) Rugby 4 naciones [3 puntos]
Desde hace más de 10 años existe en el mundo del rugby un torneo que disputan
anualmente 4 selecciones del sur global (Argentina, Australia, Nueva Zelanda y
Sudáfrica). Este torneo se llama "The rugby championship" o comunmente "4
naciones", ya que suplantó al viejo "3 naciones".
Implementar la función cuenta_posiciones_por_nacion que dada la lista de
naciones que compiten en el torneo, y el diccionario que tiene los resultados
de los torneos anuales en el formato año:posiciones_naciones, donde año es un
número entero y posiciones_naciones es una lista de strings con los nombres de
las naciones, genere un diccionario de naciones:#posiciones, que para cada
Nación devuelva la lista de cuántas veces salió en esa posición.
Tip: para crear una lista con tantos ceros como naciones se puede utilizar la
siguiente sintaxis lista_ceros = [0]*len(naciones)
problema cuenta_posiciones_por_nacion(in naciones: seq<String>, in torneos:
dict<Z,seq<String>>: dict<String,seq<Z>> {
requiere: {naciones no tiene elementos repetidos}
requiere: {Los valores del diccionario torneos son permutaciones de la
lista naciones (es decir, tienen exactamente los mismos elementos que
naciones, en cualquier orden posible)}
asegura: {res tiene como claves los elementos de naciones}
asegura: {El valor en res de una nación es una lista de |naciones|
elementos que indica en la posición i cuántas veces salió esa nación en la
i-ésima posición.}
}
Por ejemplo, dados
naciones= ["arg", "aus", "nz", "sud"]
torneos= {2023:["nz", "sud", "arg", "aus"], 2022:["nz", "sud", "aus", "arg"]}
se debería devolver res = {"arg": [0,0,1,1], "aus": [0,0,1,1], "nz": [2,0,0,0],
"sud": [0,2,0,0]}
"""
# Ejercicio 1
def acomodar(s1: list) -> list:
res: list = []
for boleta_up in s1:
if boleta_up == "UP":
res.append(boleta_up)
for boleta_lla in s1:
if boleta_lla == "LLA":
res.append(boleta_lla)
return res
# Ejercicio 2
def pos_umbral(s: list, u: int) -> int:
res: int = -1
gente_ingresada: int = 0
i: int = 0
while gente_ingresada <= u and i < len(s):
if s[i] > 0:
gente_ingresada += s[i]
if gente_ingresada > u:
res = i
i += 1
return res
# Ejercicio 3
def columnas_repetidas(m: list) -> bool:
res: bool = True
for elem in m:
if not columnas_simetricas(elem):
res = False
return res
return res
def columnas_simetricas(s: list) -> bool:
primera_mitad: list = []
segundo_mitad: list = []
for i in range(len(s) // 2):
primera_mitad.append(s[i])
for j in range(len(s) // 2, len(s)):
segundo_mitad.append(s[j])
return primera_mitad == segundo_mitad
# Ejercicio 4
def cuenta_posiciones_por_nacion(naciones: list, torneos: dict) -> dict:
res: dict = {}
for nacion in naciones:
res[nacion] = [0] * len(naciones)
for anio in torneos.keys():
for i in range(len(torneos[anio])):
res[torneos[anio][i]][i] += 1
return res