""" Parcial de Python del primer cuatrimestre de 2025. """

from queue import LifoQueue as Pila

"""
* Ejercicio 1

Implementar la función prefijo_que_mas_suma:

problema prefijo_que_mas_suma (in s: seq⟨Z⟩) : Z {
  requiere: { |s| > 0 }
  asegura: { res = ∑ ki=0 s[i] para algún k tal que 0 ≤ k < |s|}
  asegura: { res ≥ ∑ ki=0 s[i] para todos los k tales que 0 ≤ k < |s|}
}

* NOTA: 1.62 / 2.00
======================================================================
FAIL: test_prefijo_neg_muy_grandes (__main__.Ej1Test.test_prefijo_neg_muy_grandes)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "./venv/lib/python3.12/site-packages/timeout_decorator/timeout_decorator.py", line 82, in new_function
    return function(*args, **kwargs)
           ^^^^^^^^^^^^^^^^^^^^^^^^^
  File "./correcciones/parcial-python-tt/test/tema1-test-ej1.py", line 94, in test_prefijo_neg_muy_grandes
    self.assertEqual(res, -100)
AssertionError: 0 != -100

======================================================================
FAIL: test_todos_negativos (__main__.Ej1Test.test_todos_negativos)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "./venv/lib/python3.12/site-packages/timeout_decorator/timeout_decorator.py", line 82, in new_function
    return function(*args, **kwargs)
           ^^^^^^^^^^^^^^^^^^^^^^^^^
  File "./correcciones/parcial-python-tt/test/tema1-test-ej1.py", line 59, in test_todos_negativos
    self.assertEqual(res, -1)
AssertionError: 0 != -1

======================================================================
FAIL: test_todos_negativos_ceros_final (__main__.Ej1Test.test_todos_negativos_ceros_final)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "./venv/lib/python3.12/site-packages/timeout_decorator/timeout_decorator.py", line 82, in new_function
    return function(*args, **kwargs)
           ^^^^^^^^^^^^^^^^^^^^^^^^^
  File "./correcciones/parcial-python-tt/test/tema1-test-ej1.py", line 66, in test_todos_negativos_ceros_final
    self.assertEqual(res, -1)
AssertionError: 0 != -1
"""

def prefijo_que_mas_suma(v: list[int]) -> int:
    max : int = 0
    sum : int = 0

    for elemento in v:
        sum += elemento

        if sum >= max:
            max = sum

    return max

"""
* Ejercicio 2

Todavía existen materias en la cuales los exámenes se entregan en papel. A medida que los estudiantes van entregando, van apoyando (apilando!) sobre el escritorio del docente sus exámenes, y en la primera hoja indican su nombre y la cantidad de hojas entregadas (además del enunciado). Esta información se almacena en una Pila de String x Z. Nos intersa conocer el nombre de la primera persona que entregó un examen en blanco (es decir, entregó 0 hojas además del enunciado).

problema primera_entrega_en_blanco (in examenes: Pila⟨ String x Z ⟩) : String {
  requiere:{ Las primeras componentes de examenes son strings no vacíos y todos distintos entre sí }
  requiere:{ Existe al menos un elemento p dentro de la pila examenes tal que p1=0 }
  asegura: { Sea p el primer elemento insertado en la pila examenes tal que p1=0. Entonces, res = p0 }
}

* NOTA: 0.00/2.00
"""

def primera_entrega_en_blanco(parciales: Pila[tuple[str, int]]) -> str:
    resultado : str = ""

    while not parciales.empty():
        nombre   : str = ""
        cantidad : int = 0
        (nombre, cantidad) = parciales.get()

        if cantidad == 0:
            resultado = nombre

    return resultado

"""
* Ejercicio 3

Implementar la función desplazar_columna_hacia_arriba:

problema desplazar_columna_hacia_arriba(inout A: seq⟨seq⟨Z⟩⟩, in col: Z) {
  requiere: { Todas las filas de A tienen la misma longitud (estrictamente positiva)}
  requiere: { |A| > 0}
  requiere: { 0 ≤ col < |A[0]| }
  modifica: { A }
  asegura: { A tiene exactamente las mismas dimensiones que A@pre }
  asegura: { A[i][j] = A@pre[i][j] para todo i, j en rango tal que col ≠ j }
  asegura: { A[i][col] = A@pre[i+1][col] para todo i tal que 0 ≤ i < |A|-1 }
  asegura: { A[|A|-1][col] = A@pre[0][col] }
}

* NOTA: 2.00/2.00
"""

def desplazar_columna_hacia_arriba(A: list[list[int]], col: int) -> None:
    for columna in range(len(A)):
        columna_actual : list[int] = A[columna]
        columna_vecina : list[int] = []

        if columna + 1 < len(A):
            columna_vecina = A[columna + 1]
            numero_actual : int = columna_actual[col]
            numero_vecino : int = columna_vecina[col]
            columna_actual[col] = numero_vecino
            columna_vecina[col] = numero_actual

    return

"""
* Ejercicio 4

A lo largo del año se realizaron diversas competencias de programación, las cuales van otorgando puntos y permiten generar un ranking entre los competidores, con el objetivo de entregar premios al final del año. En cada una de las competencias se selecciona a los 3 participantes con mejor desempeño, y se define el podio para cada una. Luego, se asignan los puntajes de la siguiente manera:

    Quien sale en primer puesto recibe 3 puntos
    Quien sale en segundo puesto recibe 2 puntos
    Quien sale en tercer puesto recibe 1 punto

Nuestro objetivo es, dada una lista de competencias y sus resultados, conocer el ranking actual.

problema armar_ranking (in podios: seq⟨Diccionario⟨Z,String⟩⟩): Diccionario⟨String,Z⟩ {
  requiere: { Cada diccionario de podios tiene como claves los valores 1, 2 y 3 (o algún subconjunto de los mismos)}
  requiere: { Sea d un diccionario de la secuencia podios , entonces d no contiene valores repetidos }
  asegura: { nom es clave de res si y sólo si existe un diccionario en podios tal que nom es valor de dicho diccionario}
  asegura: { Cada clave c de res tiene como valor la sumatoria de los puntos obtenidos por c en cada una de las competencias de podios (suma 3 puntos si salió primero, 2 puntos si salió segundo, 1 punto si salió tercero y 0 puntos si no estuvo en el podio de esa competencia)}
}

* NOTA: 2.50/2.50
"""

def armar_ranking(podios: list[dict[int, str]]) -> dict[str, int]:
    resultado : dict[str, int] = {}

    for podio in podios:
        for posicion in podio:
            puntaje : int = 0
            
            if posicion == 1:
                puntaje = 3
            elif posicion == 2:
                puntaje = 2
            elif posicion == 3:
                puntaje = 1
                    
            nombre = podio[posicion]
        
            if nombre in resultado:
                resultado[nombre] = puntaje + resultado[nombre]
            else:
                resultado[nombre] = puntaje

    return resultado

"""
* Ejercicio 5

Dada la siguiente especificación y una posible implementación de la misma, conteste marcando la opción correcta.

problema sumar_o_restar_uno (in n: Z): Z {
  requiere: { True }
  asegura: { Si n > 0, res = n+1}
  asegura: { Si n = 0, res = n}
  asegura: { Si n < 0, res = n-1}
}

def sumar_o_restar_uno(n: int) -> int:
   res: int = n
   if n > 0:
        res += 1
   else:
        res -= 1
   return res

[ ] El código es correcto, calcula lo pedido en la especificación para cualquier input
[ ] El código tiene un bug, y si hacemos un test suite que cubra todas las líneas lo detectaremos
[X] El código tiene un bug, pero es posible hacer un test suite que cubra todas las líneas y no detectar dicho bug

* NOTA: 0.75/0.75

* Ejercicio 6

Seleccione la opción correcta.

[ ] Si tengo 2 programas y los ejecuto con los mismos parámetros, el programa que tiene mayor cantidad de líneas de código ejecutará más operaciones que el que tiene menos líneas de código.
[ ] Dado un programa p que recibe una secuencia como parámetro, p([1]) ejecutará menos operaciones que p([0,1,2,3,4,5])
[X] No es posible afirmar ninguna de las opciones anteriores sin conocer el código de la/las función/funciones

* NOTA: 0.75/0.75
"""