Guía 1 — Ejercicios en Python

random.randint(a, b) devuelve un entero $N$ con $a \le N \le b$: a diferencia de range(a, b), incluye el extremo superior. Equivale a random.randrange(a, b + 1).

Con $a = 1$ y $b = 10$ hay 10 resultados posibles: $\{1, 2, \dots, 10\}$, justo el rango del juego. Para reales en $[0, 1)$ está random.random(), y para reales en $[a, b]$, random.uniform(a, b).

Intento 1: 3 ≠ 5, se agrega a la lista y sigue. Intento 2: 5 = 5, acierta: se agrega el 5, gana la máquina y el bucle se corta con break. Los intentos 3 a 5 no ocurren.

Lista final: [3, 5]. La opción A reproduce la errata del ejemplo de la guía; la C olvida cortar el bucle; la D agrega el número a la lista sólo cuando falla.

Solución de referencia completa:

import random

numero = int(input("Ingrese un número: "))
intentos = []
ganador = "Humano"
for _ in range(5):
    n = random.randint(1, 10)
    intentos.append(n)
    print("Es el", n, "!")
    if n == numero:
        ganador = "Máquina"
        break
print(ganador, "ganó el juego")
print("Los números fueron:", intentos)

2 ≠ 7 (lista [2]), 9 ≠ 7 (lista [2, 9]), 7 = 7: se agrega y gana la máquina (lista [2, 9, 7]). El bucle se corta: los dos valores restantes nunca se generan.

En general, si la máquina acierta en el intento $k$ la lista tiene $k$ elementos; si no acierta nunca, tiene 5.

A es correcta: range(5) da exactamente 5 vueltas (0 a 4) y el break corta apenas acierta.

B: range(1, 5) da sólo 4 vueltas (1, 2, 3, 4).

C: con intento de 0 a 5 inclusive, while intento <= 5 da 6 vueltas. Tendría que ser while intento < 5.

D: el if quedó fuera del bucle (sangría), así que sólo compara el último intento. Si la máquina acierta en el segundo intento y falla en el quinto, declara ganador al humano; además nunca corta antes.

En cada intento la máquina acierta con probabilidad $\frac{1}{10}$ y falla con $\frac{9}{10}$. El humano gana sólo si fallan los 5 intentos independientes:

Errores típicos: sumar $5 \cdot \frac{1}{10} = 0{,}5$ (vale sólo si la máquina no repite números) o responder $0{,}5905$, que es la probabilidad de que gane el humano.

B: print separa sus argumentos con un espacio y muestra la lista con su representación [3, 5, 1, 4, 1].

A lanza TypeError: no se puede concatenar str con list. C funciona, pero falta el espacio después de los dos puntos. D desempaqueta la lista e imprime Los números fueron: 3 5 1 4 1, sin corchetes ni comas.

input() siempre devuelve una cadena: si el usuario escribe 5, numero vale "5". randint devuelve un int, y en Python un entero nunca es igual a una cadena: 5 == "5" es False.

Solución: convertir al leer, numero = int(input("Ingrese un número: ")).

Las otras opciones son falsas: randint devuelve int; == compara valores (además, 5.0 == 5 es True); y los tipos de C están al revés.

En Python True vale 1 y False vale 0 en las cuentas, así que 8.65 + True + False da 9.65.

Los índices arrancan en 0: nombre → 0, apellido → 1, DNI → 2, vive cerca → 3, hermanos → 4, promedio → 5. El promedio también es t[-1], pero la pregunta pide el índice positivo. t[6] (contar desde 1) lanza IndexError.

C: los booleanos suman como 0 o 1, así que t[5] + t[3] + t[4] es el promedio más los bonos. Una versión más explícita es t[5] + (1 if t[3] else 0) + (1 if t[4] else 0).

A cuenta los índices desde 1: t[6] lanza IndexError.

B: sin paréntesis, el operador condicional agarra toda la expresión y queda (t[5] + 1) if t[3] else (1 if t[4] else 0). Si vive cerca, ignora a los hermanos; si no vive cerca, pierde el promedio. Con el ejemplo da bien (9.65) de casualidad, pero con True, True da 9.65 en vez de 10.65.

D: and tiene menor precedencia que +: queda (t[5] + t[3]) and t[4], que devuelve t[4] (un booleano) cuando la suma no es cero.

D: sorted devuelve una lista nueva (no toca la original), reverse=True ordena de mayor a menor puntaje y [:n] toma los primeros n.

A ordena de menor a mayor: devuelve los n peores. B devuelve todos menos los n mejores. C: list.sort() ordena en el lugar y devuelve None, así que None[:n] lanza TypeError (y además modifica la lista original).

Solución de referencia:

def puntaje(t):
    return t[5] + t[3] + t[4]

def mejores(inscriptos, n):
    return sorted(inscriptos, key=puntaje, reverse=True)[:n]

De mayor a menor: Elena (10,20), Carla (10,10), Diego (9,95), Ana (9,90), Bruno (9,80). Los 3 primeros: Elena, Carla, Diego.

A ordena sólo por promedio (olvida los bonos); C son los 3 peores (falta reverse=True); D toma $N+1$ elementos.

El tercero de la lista ordenada es Diego: $9{,}95 + 0 + 0 = 9{,}95$. Ana (9,90) queda primera afuera.

Puntajes: $f$: $8{,}50 + 1 + 0 = 9{,}50$; $g$: $9{,}50 + 0 + 0 = 9{,}50$. Empatan.

sorted es estable: los elementos con igual clave conservan su orden relativo, también con reverse=True (no es lo mismo que ordenar y después dar vuelta con [::-1], que sí devolvería [g]). Como f está primero en la lista, queda primero.

Si la cátedra quisiera otro desempate (por ejemplo, mayor promedio), habría que ponerlo en la clave: key=lambda t: (puntaje(t), t[5]).

Filas impares del 1 al 15: 1, 3, 5, 7, 9, 11, 13, 15 → 8 filas de 18. Filas pares: 2, 4, …, 14 → 7 filas de 20.

Error típico: tomar 8 filas pares y 7 impares (da $8 \cdot 20 + 7 \cdot 18 = 286$).

C: f recorre los números de fila reales, del 1 al 15 (range(1, 16)). La fila 1 (impar) queda con 18 butacas en platea[0], la fila 2 con 20 en platea[1], etc.

A usa el índice 0–14 para decidir la paridad: la fila 1 (índice 0, «par») queda con 20. B crea sólo 14 filas. D invierte 18 y 20.

B: hay que restar 1 porque las listas se indexan desde 0. Primero se elige la fila y después la butaca.

A ocupa la butaca siguiente de la fila siguiente, y falla con la fila 15. C intercambia fila y butaca (con butaca 16 o más, ni siquiera existe esa «fila»). D es sintaxis de numpy: en una lista, platea[a, b] lanza TypeError.

Solución de referencia:

def crear_platea():
    return [["L"] * (20 if f % 2 == 0 else 18) for f in range(1, 16)]

def reservar(platea, fila, butaca):
    if not (1 <= fila <= len(platea)) or not (1 <= butaca <= len(platea[fila - 1])):
        print(f"La Fila {fila} butaca {butaca} no existe")
        return
    if platea[fila - 1][butaca - 1] == "O":
        print(f"La Fila {fila} butaca {butaca} ya esta ocupada")
        return
    platea[fila - 1][butaca - 1] = "O"

def mostrar(platea):
    for i, fila in enumerate(platea, start=1):
        for j, estado in enumerate(fila, start=1):
            print(f"La Fila {i} butaca {j} esta {estado}")

La fila 15 es impar, así que tiene 18 butacas: la butaca 19 no existe (platea[14][18] lanza IndexError). Las filas 14 y 2 son pares (20 butacas) y la fila 1 tiene 18, así que las otras tres existen.

Las tres primeras reservas ocupan 3 butacas distintas. La cuarta encuentra la butaca ocupada: imprime el mensaje y retorna, sin ocupar nada.

Error típico: descontar las 4 llamadas (daría 280).

[fila] * 15 no copia la lista interna: crea 15 referencias a la misma lista. Modificar platea[0][0] modifica la butaca 1 de las 15 «filas», porque son el mismo objeto.

Por eso la fila se construye con una comprensión ([["L"] * n for ...]), que crea una lista nueva en cada vuelta. El ["L"] * 18 interno no tiene el problema, porque las cadenas son inmutables.

C: enumerate(..., start=1) entrega el número de fila y de butaca contando desde 1, y el elemento a la vez.

A numera desde 0 (La Fila 0 butaca 0 esta O). B suma 1 dos veces (La Fila 2 butaca 2 esta O). D usa números de fila como índices: arranca por platea[1] (la fila 2) y termina en IndexError.