Apunte de Programación

Certamen 2
Leonardo Ramírez
• Estructuras de Datos: Listas, Tuplas, Diccionarios y conjuntos
• Función Range
• Ciclo for (recorrer)
• Match o Coincidencia
• Funciones Avanzadas
 Estructuras Datos
Son una utilidad de Python dispuesta para almacenar y guardar cualquier tipo de Dato, tanto
así que pueden contenerse entre sí. Cada una posee un tipo de paréntesis, asiéndolos fácil
de identificar.

Listas [ ] : se caracterizan por su aspecto de modificación ordenada, ya que mantienen la

relación dato-posición, a menos que se le modifique.

Tuplas ( ): se caracterizan por su estructura de “Paquete”, este se puede desarmar para

trabajarlos individualmente, o usarlos en grupo; además de su imposibilidad de modificarse.
Estas también trabajan meramente por posición, y son muy útiles cuando no son muy
extensas.

Diccionarios { : } : se caracterizan por utilizar una relación llave-dato. Debido a esto no

necesitan orden, ya que al tener una llave se puede sacar su dato relacionado.

Conjuntos set() : Igual que en matemáticas, carecen de orden alguno y su única

peculiaridad es la pertenencia , utilizando operaciones matemáticas de conjuntos como la
unión, intersección, etc.
 Listas [ ]
Estructura de datos caracterizada por trabajar netamente con posiciones. Debido a esto,
son similares a los strings, solo que estos últimos solamente puede contener un caracter al
momento de recorrerlos, en cambio las listas pueden contener cualquier tipo o estructura de
datos por posición. Por ejemplo: x=["a",1,True,[None,2.3],complex(2,34)]

Como se ve, las listas pueden contener otra lista en su estructura, esto pasa con todas las
estructuras de Datos.

Cuidado al momento de copiar listas, al momento de modificar una se modificarán

ambas, para que esto no pase, se debe crear una copia de la lista con la función de tipeo
list():

a = [5, 1, 4] a = [5, 1, 4]
b = a b = list(a)
b[0] = 1000 b[0] = 1000
a => [1000, 1, 4] a => [5, 1, 4]
MALO CORRECTO
 Operador Comando Observación/Descripción
Este comando sirve tanto como para crear una lista vacía:
Crear lista=list() a=list(), como enlistar algo : a=list((1,2,3,4,5))

Agregar elemento lista.append(x) Este comando agrega un elemento a la lista en su ultima posición
Conseguir elemento por
posición Elemento=lista[posición] Permite obtener fácilmente un elemento, sabiendo su posición
Concatenar listas Lista1+lista2 Similar a sumar strings. No es conmutativo y guarda el orden.

Extensión(largo) len(lista) Cuenta cuantos elementos tiene la lista, independiente de su tipo.

Pertenencia Elemento in lista Verifica si el elemento está dentro de la lista.

Cantidad de cierto elemento lista.count(elemento) Cuenta cuantas veces se repite un elemento en la lista.
Encontrar posición de cierto
elemento lista.index(elemento) Encuentra la posición del primer elemento que coincida.

Remover elemento lista.remove(elemento) Remueve el primer elemento pedido de la lista

Invertir lista lista.reverse() Invierte el orden de una lista.

Si quieres ordenar de mayor a menor, aplica .sort() y luego
Ordenar de menor a mayor lista.sort() .reverse()
Insertar elemento en la Similar al .append(), solo que se inserta en una posición
posición X lista.insert(x,elemento) arbitraria.
Buscar el max o min valor
en la lista max(lista)/min(lista) Todos los elementos deben ser del mismo tipo de dato.
 Slicing o Corte de Listas
Al igual que con strings, también se puede usar el slicing con listas, ya que son ordenadas. Después de
un corte, los elementos resultantes quedan en una lista (Literalmente es como cortar la lista en partes).
Operador Comando Descripción Ejemplos
Se obtienen los elementos desde el inicio
hasta la posición j, sin contarla (no se obtiene [1,4,9,16,25,36,49][:4] >>>
Desde el inicio A[:j] el elemento j, sino el anterior a este) [1,4,9,16]
Se obtienen los elementos desde la posición i [1,4,9,16,25,36,49][4:] >>>
Hasta el final A[i:] hasta el final. [25,36,49]

Se obtienen los elementos desde la posición i

hasta la posición j, sin contarla (no se obtiene [1,4,9,16,25,36,49][2:5] >>>
Entrecortar A[i:j] el elemento j, sino el anterior a este) [9,16,25]
Se obtienen los elementos desde el inicio [1,4,9,16,25,36,49][::3] >>>
Salto A[::k] hasta el final, cada k posiciones [1,16,49]
Se obtienen los elementos desde la posición i
hasta la posición j, sin contarla (no se obtiene
Entrecortar con el elemento j, sino el anterior a este), cada k [1,4,9,16,25,36,49][2:5:2] >>>
Salto A[i:j:k] posiciones. [9,25]
 Función range()
Esta función es usada para crear una lista de números enteros.

Al igual que muchas funciones, esta se debe asignar a un valor si se quiere guardar,
aunque su uso más recurrente para este curso será dentro de un ciclo for. Estas dos juntas,
tienden a sustituir a los contadores en los programas; aunque ambos tienen características
diversas en otros casos.

Se debe tener mucho cuidado con la sintaxis del range, una mala distribución de
parámetros puede provocar no solo errores al correr, sino que la eliminación de otras
variables a su paso.

range(5) >>> [0,1,2,3,4]

range(3,7) >>> [3,4,5,6]

range(2,13,3) >>> [2,5,8,11]

 Sintaxis de la Función range()
El range tiene tres elementos que se deben tomar en cuenta siempre, todos respectos a los datos que se le asignan dentro
del paréntesis:

• Cuando al range se le asigna un solo dato, este seria el dato de llegada(este no se incluye en la lista):

range(9) >>> [0, 1, 2, 3, 4, 5, 6, 7, 8]

• Cuando se le pasan dos datos, al primero se le llama el dato inicio, y el segundo el de llegada:

range(2,9) >>> [2, 3, 4, 5, 6, 7, 8]

• Cuando al range se le pasan datos, van en este orden, Inicio, llegada, y salto. Este ultimo es cuanto se le suma al de
inicio hasta que llegue al ultimo. (En las dos anteriores por default es de 1):

range(1,8,3) >>> [1, 4, 7]

• Hay Casos especiales, como cuando un dato es negativo:

range(-1,5,2) >>>[-1, 1, 3] / range(10,0,-1) >>>[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

• Cuando el dato de inicio es mayor al dato de llegada, la lista queda vacía, pero no tira error: range(3,1)>>> []
 Tuplas ( )
Estructura de Datos caracterizada por su manera de guardar datos en paquetes, y su
imposibilidad de modificarse propiamente.

Las tuplas se ocupan para dejar datos anexados entre si: fechas de nacimientos, nombres
de alumnos, ruta de viaje, etc. De manera que la tupla sea una “estructura tipo”. Por
ejemplo, yo quiero guardar todas las fechas de los cumpleaños de mis amigos, así que
guardare todos estos de datos en tuplas de forma que sea (“nombre”,”día”,”mes”):

cumpleaños=[(“Pedro”,”01”,”Abril”),(Luis,”22”,”Mayo”),(”Leo”,”12”,”D
iciembre”)]

La organización-tipo será el uso más practico para las tuplas durante el curso.
 Operador Comando Observaciones
Tipear tuple(x) Convierte a la estructura x en una tupla
Desempaquetar elemento1,elemento2,... =tupla Más útil cuando organizas todas tus tuplas en el mismo
esquema; y cuando su extensión es breve.
Conseguir por tupla[posición] Este comando trabaja mejor cuando tus tuplas siguen cierto
posición esquema de orden, ya que al sacar un elemento por posición,
siempre sabrás cual será la salida.
Comparar tupla1==tupla2 Ojo con este comando, solo será True, si todos los elementos
y posiciones son iguales.
Concatenar tupla1+tupla2 Junta las tuplas, en el orden dado.
len(tupla) Obtiene cuantos elementos tiene la tupla.
Extensión(largo)
Multiplicar tupla*entero Concatena una tupla consigo misma una cierta cantidad de
veces
Pertenencia elemento in tupla True si el elemento está en la tupla
Cantidad tupla.count(elemento) Obtiene cuantas veces se encuentra el elemento en la tupla.

Posición tupla.index(elemento) Obtiene la posición elemento en la tupla. (Si se encuentra más

de una vez, retorna la posición menor).
max/min max(tupla) / min(tupla) Obtiene el elemento de mayor/menor valor en la tupla.
 Diccionarios { : }
Un diccionario es un tipo de datos que sirve para asociar pares de objetos. Un diccionario
puede ser visto como una colección de llaves, cada una de las cuales tiene asociada un
valor. Las llaves no están ordenadas, deben ser inmutables (Números, strings, booleanos o
tuplas) y no se repeten. La única manera de acceder a un valor es a través de su llave
asociada.

El aspecto de los diccionarios es muy particular comparado con el resto de las estructuras
de datos, puesto a que poseen una sintaxis peculiar: diccionario={llave:dato,llave2:dato,…}

telefonos = {'Pepito': 5552437, 'Jaimito': 5551428, 'Yayita':

5550012}

Los diccionarios son excepcionales para ir guardando muchos datos que se necesitan ir
relacionando entre ellos a medida que se obtiene la información. Para esto, existe un
método especial para ir guardando estos datos de a uno, en una lista, conjunto, suma o
contador (Ver diccionarios avanzados en paltitas).
 Operador Comando Observación

Crear D=dict() Como en todas las estructuras, el diccionario tiene su propia abreviación de tipo en
python.
Acceder a valores D[llave] Este es el comando fundamental de diccionarios; con el, se puede acceder a
cualquier dato del diccionario
Modificar/agregar D[llave]=Dat Si a un dato se le asigna una llave inexistente, se crea el vinculo llave-dato; si
dato o existía, se modifica.
Eliminar elementos del D[llave] Para eliminar una llave con su dato respectivo. Revisa bien para no eliminar llaves
importantes.
Largo len() Cuenta la cantidad de llaves del diccionario, independiente de su elemento.

Lista de datos dict.items() Forma una lista de tuplas, [(llave1,dato1),(llave2,dato2),…]

Lista de Llaves dict.keys() Forma una lista con todas las llaves de un diccionario. No se repiten entre si.

Lista de valores dict.values( Forma una lista con todos los valores del diccionario. Si se pueden repetir entre sí.
)
 Conjuntos set( )
Un conjunto es una colección sin orden de valores no repetidos. Los conjuntos de Python
son análogos a los conjuntos matemáticos. El tipo de estructura que representa a los
conjuntos se llama set. El tipo set es mutable: una vez que se ha creado un conjunto, puede
ser modificado.

Los conjuntos no incluyen elementos repetidos, y que los elementos no quedan en el mismo
orden en que fueron agregados. Entonces, si tienes una lista y quieres sacarle los repetidos,
pásala a conjunto y de vuelta a lista.

La principal característica de los conjuntos es la pertenencia y almacenamiento. Además,

existen comandos muy útiles para conjuntos no disponibles en otras estructuras, como la
resta e intersección.
 Operador Comando Observaciones

Crear set() Comando para transformar estructuras o crear un conjunto vacío (c=set() ).

Añadir dato conj.add(elemento) Similar al .append() (No confundir).

Eliminar conj.remove(elemento
elemento ) Elimina un elemento del conjunto(genera error si el elemento no esta).

Pertenencia elemento in conj True si el elemento pertenece al conjunto; de lo contrario False.

Diferencia A-B Elementos en A que no estén en B.

Unión A|B Elementos en A o en B.

Intersección A&B Elementos en A y que a su vez están en B.

Diferencia
simétrica A^B Elementos en a A en B, que no están en ambos.

Subconjunto A<=B True si A es subconjunto de B; de lo contrario False.

Supraconjunto A>=B True si A es supraconjunto de B; de lo contrario False.

Equivalente para todas las estructuras. Cuenta cuantos elementos posee el
Largo len(conj) conjunto conj.
Equivalente para todas las estructuras. True si y solo si A y B contienen los
Comparación A==B mismos elementos.
 Ciclo for
El ciclo for, es una ciclo muy útil al momento de utilizar las estructuras de datos. Este itera con la
siguiente sintaxis:

for variable in estructura:

secuencias…

Esta sintaxis es parecida a la del while e if, ya que no necesita una asignación y se realiza en una línea
singular del programa, seguido de : ; sin embargo, el ciclo for no recibe ninguna condición, por lo que
es simplemente un ciclo que recorre todos los datos de la estructura hasta su término, cuando sucede
esto, el ciclo termina. Puede variar su sintaxis si la estructura es una tupla(*).

Lo que realiza el ciclo for, es asignar la variable a un dato de la estructura a la vez, en cierto orden:
por posición si es lista o tupla, o al azar si es un conjunto o diccionario.

Esto lo hace muy útil al momento de hacer combinaciones u operar estructuras, ya que ahorra la
necesidad de ocupar un while, un contador y una asignación por posición, que no es posible en todas las
estructuras.
 Ejemplo
Se necesita recorrer una lista de tuplas con la estructura [(Número, cuadrado),…] como por ejemplo:
L=[(1,1),(2,4),(3,9),(4,16),(5,25),…] para generar una nueva lista, que tenga la estructura
[(Número,Cuadrado,Cubo),…]. Para obtener los datos, se debe recorrer la lista, obtener el número en la
posición 0, elevarlo al cubo, y añadir lo tres datos obtenidos en una tupla, y esta a una lista nueva.
Q=[]
for numero,cuadrado in L:
cubo=numero**3
Q.append((numero,cuadrado,cubo))

En un ciclo for, las tuplas se pueden desempaquetar, colocando las variables de cada dato a asignar en
vez de solo una. Dentro del ciclo, el programa correrá secuencialmente al igual que en un ciclo while,
hasta llegar al final y volver a empezar. A una vuelta en un ciclo for se le llama iteración. A diferencia del
while, el ciclo for termina cuando allá recorrido todos los elementos de la estructura de datos dada, ni
antes ni después.
 Patrones Comunes:
Match o coincidencia
A diferencia de los algoritmos comunes ya conocidos, tales como el contador, suma,etc. Que se basan en
la compilación de cierta información, este Algoritmo está centrado como un método de búsqueda de esa
información, para generar una relación entre distintas estructuras de datos a través de una clave. Supón
tienes las dos listas a continuación:

Rol=[(“Leo”,“201660620-3”),(“Pedro”,”201555001-7”),(“Renzo”,”201655089-1”),…]
Notas=[(”201655089-1”,55),(”201555001-7”,30),(“201660620-3”,100) ]
La manera de relacionar estas listas es a través de un Match. Esto se logra debido a que hay un dato
clave, presente en ambas listas, en este caso el nombre. Si yo tengo la relación Nombre-Rol, y la relación
Rol-Nota; podré hacer posible la relación Nombre-Nota. Esto es posible siempre y cuando haya un dato
clave presente en estas dos lista.

Incluso si se tiene otra lista: Numeros=[(Celular,nombre),…] se puede generar un match Celular-

Nota a partir de los datos claves. Entonces, los Match se pueden hacer a través de cualquier cantidad de
listas, siempre y cuando entre dos de ellas haya un dato clave.
 Funciones Recursivas
Se denomina recursiva a aquellas funciones que en su algoritmo, hacen referencia a sí
misma.

Las llamadas recursivas suelen ser muy útiles, pero debido a su facilidad de caer en
iteraciones infinitas, deben utilizarse solo cuando sea necesario.

Las funciones recursivas siempre deben tener dos o más return, y a lo menos uno “fijo”, o
sea, que retorne un valor sabido a priori (no recursivo).
 Funciones con parámetros por omisión
¿Como la función range puede aceptar desde uno hasta tres parámetros sin tirar error? Porque es una
función con parámetros por omisión.

Una función tiene parámetros por omisión cuando puede recibir una diversa cantidad de estos, y
dependiendo de esta cantidad, asume valores por default, un ejemplo sería:

def f1(a,b=2,c=1):
return (a**b)%c
print f1(2), f1(2,5), f1(2,5,9)
>>>4 32 5

Ojo que todos los parámetros por omisión tienen que estar al lado derecho, o arrojará error:

def f2(a,b=3,c): ➔ Error / def f2(a,c,b=3): ➔ Correcto

Además, al igual que en todas las funciones, importará el orden de los parámetros puestos en la función,
por lo que fíjate muy bien en el orden tanto de los parámetros no definidos como en los por omisión.
 Paltitas
[+Paltas, - Pera]

Ejercicios Tipo Certamen:

De ahora en adelante, los ejercicios suelen ser muy mecánicos, cayendo en una o más de
la siguientes categorías:

1. Búsqueda
2. Modificar
3. Ordenar
4. Diccionarios Avanzados
5. Condiciones Múltiples

Cada una de estas tiene una forma particular de resolverse, por lo que entender como se
hacen es crucial.
 1)Búsqueda
Tipo más común de ejercicio.

Consiste en compilar todos los elementos de una estructura de datos,

generalmente en una lista o diccionario, que cumplen cierta condición; por lo
que el uso del algoritmo común de Match o Coincidencia resulta muy útil

Su dificultad recae en la complejidad de las estructuras de datos que poseen la

información, o lo engorroso que es comprobar las condiciones.

Todos los ejercicios, en alguna medida, pertenecen a este tipo, sólo que en
muchos, la compilación de los datos es meramente el primer paso para realizar
su propósito último, como es el ordenar, modificar, condiciones múltiples.
 Ejemplo Búsqueda
Supón tienes la lista de tuplas, y quieres buscar a todos los que tengan nota
mayor o igual a 55, por lo que debes generar un programa:
Notas=[(“Leo”,100), (“Javier”,80),(“Natalia”,70),
(“Diego”,55),(“Pedro”,30)]

Para ello, se debe filtrar los datos que me interesan según la condición que me
dan, y agregar los que cumplen esa condición.
 2)Modificar

Tipo de ejercicio menos usado, y el de menor dificultad.

Consiste en realizar modificar una estructura de datos determinada.
La forma más fácil es generando una nueva lista, traspasando los datos
modificados de la lista inicial a la nueva.
Se pueden modificar tanto un elemento en particular de la lista inicial
(match), o bien todos con respecto a cierta operatoria.
 Ejemplo Modificar
Supón tienes la lista de tuplas, y quieres restarle 10 de nota a cada uno, por lo que debes
generar un programa:

Notas=[(“Leo”,100),(“Javier”,80),(“Natalia”,70),(“Diego”,55),(“Pedro
”,30)]

Siempre que quieras modificar una estructura de datos, es recomendable siempre crear una
nueva, a la cual se le añadirán los datos que fueron modificados de la primera. Por lo que
simplemente debes recorrer la lista inicial, modificar los datos y luego agregarlos a la lista
nueva, entregando esta última como resultado. Este método debiera funcionar para todos
los casos. (Ver pregunta 2c 2015-2).
 3)Ordenar

Similar al algoritmo común máximo/mínimo visto anteriormente; y

segundo más común.
Consiste en generar una lista con los elementos ordenados
(ascendente o descendentemente) de otra estructura de datos cuyos
elementos no están listos inmediatamente para ser ordenados.
O bien, entregar el mayor (o menor) elemento según el parámetro de
orden; en ambos casos se realiza de manera muy similar, pero cambia si
existe el caso de empate*.
 Ejemplo Ordenar
Supón tienes la siguiente lista de tuplas, [(nombre,nota),…]

Notas=[(“Leo”,100),(“Javier”,80),(“Natalia”,70),(“Diego”,55),(“Pedro”,30)]

La cual está ordenada de orden descendente, según su nota. La pregunta a resolver es la

siguiente: Si yo quiero añadir la siguiente tupla (“Renzo”,75), manteniendo el orden de la
lista, ¿como lo hago?:

Cada vez que necesites hacer algo similar, simplemente agrega y vuelve a ordenar la lista.
La dificultad es que el parámetro de orden no esta en la primera posición de la tupla, por lo
que se necesitará generar otra lista con otra plantilla de tupla, para luego reordenarla y
volver a su plantilla original. Como ejemplo haremos el ejercicio de crear la función
agregar(Notas,nva_tupla) la cual debe retornar la lista Notas, ordenada y con la
nueva tupla que se quiere agregar. (Ver pregunta 2a del certamen 2016-1)
Primero simplemente agregamos la nva_tupla:
Notas.append(nva_tupla)
Ahora solo tendremos que volver a ordenar los parámetros, para ello organizamos la lista
como (nota,nombre).
L=[]
for nombre,nota in Notas:
L.append((nota,nombre))

Ahora ordenando la lista L:

L.sort()
L.reverse() #si es de mayor a menor

Luego se debe volver al orden inicial; como el ciclo for al recorrer listas la recorre por
posición, la posición de la tupla no se vera afectado al invertirla otra vez, haciendo el mismo
procedimiento anterior:
Notas=[]
for nota,nombre in L:
Notas.append((nombre,nota))
return Notas
 4) Diccionarios Avanzados
No es un tipo de ejercicio propiamente tal, sino que una forma de compilación a
base de un diccionario, donde este se caracteriza por poder guardar
cantidades aditivas de información en los datos de cada llave.
En otras palabras, se refiere a que cada llave posee como dato un elemento para
guardar aún más información, sin necesidad de usar listas o diccionarios extras.
Estos datos para guardar información suelen usarse como contadores,
sumas, listas o conjuntos, vinculados con la llave, los cuales se modificarán
durante el ciclo.
Además, se caracteriza por habilitar la modificación más amplia de diccionario,
usando los datos como pseudo variables: Dicc[llave]+=1 , Dicc[llave].append(x),
etc.
 Ejemplo Diccionarios avanzados
Los diccionarios son la mejor estructura de datos para almacenar información, debido a su
naturaleza llave:dato. Debido a esto, es muy conveniente que estos datos sean también
una estructura, tales como un conjunto o una lista para almacenar más información por
llave. Supón se tiene el siguiente diccionario:

Colores={“Leo”:[“Azul”,”Verde”],”Pedro”:[“Rojo”,”Azul”],
”Renzo”:[“Verde”,”Rojo”],…}

Donde la llave es un nombre, y los datos una lista de sus colores favoritos, si se quisiera
hacer al revés, la llave es el color y el dato una lista de las personas a la que les gusta, se
necesitará usar un patrón para agregarlos a partir del primer diccionario. (Ver pregunta 2b
2015-1)
Se genera un diccionario nuevo, se recorre el diccionario inicial para tener los pares llave-
dato, como estos datos son listas, también se deben recorrer uno a uno. Con esta
información, se irá escribiendo el diccionario nuevo a medida que se vaya recorriendo el
otro.

Además se empleará un condicional para que no se sobrescriban las llaves en caso de

encontrar más de una vez un color. De este modo, la primera vez que encontremos uno,
se generara el par llave:lista, y de ahí, cada vez que nos topemos con tal simplemente
se añadirá a la existente. Esta es la clave del método.
 5)Condiciones Múltiples
Se caracterizan por ser aparentemente más difíciles, ya que son equivalentes a
realizar múltiples Búsquedas en el mismo ciclo o ejercicio.
Debido a que esta, la mejor forma de abordarlos es realizar una compilación de todos
los elementos que cumplan solo una de las condiciones (una búsqueda simple para
cada condición), guardando todos los datos que cumplan una condición en un
conjunto. Luego, los elementos que cumplan todas las condiciones serán los
que resulten de intersectar todos los conjuntos generados.
(1 Conjunto≡1 Búsqueda≡ 1 Condición) Si un elemento está presente en todas las
estructuras generadas es porque cumple con todas las condiciones impuestas.
 Ejemplo Condiciones Múltiples
Se tiene una lista de tuplas, con la estructura (alumno,paralelo):

alumnos=[('11111111-1’,101),('22222222-2’,102),('12345678-9’,101),(‘12908321-
1’,103),('14909876-k’,102),('16342768-2’,101),('18324768-1’,103),('19546987-
9’,’101),('19321901-3’,103),('18567091-5’,102),('18618137-8’,101)('18462819-
4’,102)]

Además, Se tiene una lista de tuplas con la estructura (alumno,nota):

Final=('11111111-1’,55),('22222222-2’,77),(’12908321-1’,65),('16342768-
2’,100),('19321901-3,60), ('18567091-5’,90),('18462819-4’,59),('12345678-
9’,40),('14909876-k’,54),('18324768-1’,10),('19546987-9’,0),('18618137-8’,30)]

Se le pide hacer la función por_paralelo(alumnos,final,paralelo) que recibe ambas listas y un número de

paralelo. La función debe retornar un conjunto con todos los roles de alumnos que hayan aprobado, que
sean del paralelo dado.
Las condiciones a tomar son:

1.Que el estudiante haya aprobado.

2.Que el estudiante sea del paralelo.

Entonces, se crean don conjuntos, uno para

cada condición.

En la primera parte, se buscarán todos los

estudiantes con nota mayor o igual a 55. Y
luego a todos los del paralelo.

Finalmente, sólo se entregan la intersección

de ambos conjuntos.

Sin conjuntos, se reemplazan con listas, y al

final, genera un conjunto de los elementos
que están en todas las listas creadas.