Trabajo Práctico 5 (TP5)

1/6/23, 22:58 Trabajo práctico 5 (TP5)
Pregunta 1
Sin cambios desde el último intento
Puntúa como 1
Defina una función de nombre leer_palabra que no acepta ningún argumento y devuelve una palabra leída por teclado. La función debe
solicitar se ingrese por teclado una palabra, en caso de que la cadena ingresada no sea una única palabra debe volver a solicitar hasta que se
ingrese una cadena correcta. Una vez ingresada la palabra, la función debe devolverla como valor de retorno. Debe considerar palabra toda
cadena que contenga únicamente, y al menos una, letras mayúsculas y/o minúsculas (No debe contener números, símbolos o espacios).
Por ejemplo:
Test Entrada Resultado
print yu23 Ingrese una palabra: Ingrese una palabra: Ingrese una palabra: Ingrese una palabra: Ingrese una
leer_palabra() tou rou palabra: Ingrese una palabra: yupi
_asd
_s dd
tuy 4
yupi
Respuesta: (sistema de penalización: 0 %)
Reiniciar respuesta
1 import re
2 ▼ def leer_palabra():
3 ▼ while True:
4 palabra = raw_input("Ingrese una palabra: ")
5 ▼ if re.match("^[A-Za-z]+$", palabra):
6 return palabra
7
Comprobar
Test Entrada Esperado Se obtuvo
 print yu23 Ingrese una palabra: Ingrese una palabra: Ingrese una palabra: Ingrese una palabra: 
leer_palabra() tou rou Ingrese una palabra: Ingrese una palabra: Ingrese una palabra: Ingrese una palabra:
_asd Ingrese una palabra: Ingrese una palabra: Ingrese una palabra: Ingrese una palabra:
_s dd yupi yupi
tuy 4
yupi
 print arbol Ingrese una palabra: arbol Ingrese una palabra: arbol 
leer_palabra()
Todas las pruebas superadas. 
https://fcefyn.aulavirtual.unc.edu.ar/mod/quiz/attempt.php?attempt=1820570&cmid=231660 1/51
Pregunta 2
Puntúa como 1
Defina una función de nombre leer_valor que no acepta ningún argumento y devuelve un número flotante leído por teclado. La función debe
solicitar se ingrese por teclado un número flotante mayor o igual a 0 y menor o igual a 100, en caso de que el valor ingresado esté fuera de
rango se debe volver a solicitar hasta que se ingrese un valor correcto. Una vez ingresado el valor, la función debe devolverlo como valor de
retorno.
Por ejemplo:
print -3.12 Ingrese un valor en el rango [0.0,100.0]: Ingrese un valor en el rango [0.0,100.0]: Ingrese un valor en
leer_valor() -0.12 el rango [0.0,100.0]: Ingrese un valor en el rango [0.0,100.0]: 56.432
100.12
56.432
Reiniciar respuesta
1 ▼ def leer_valor():
2 ▼ while True:
3 ▼ try:
4 valor = float(raw_input("Ingrese un valor en el rango [0.
5 ▼ if 0 <= valor <= 100:
6 return valor
7 ▼ else:
8 print
9 ▼ except ValueError:
10 print
Comprobar
 print -3.12 Ingrese un valor en el rango [0.0,100.0]: Ingrese un valor en el Ingrese un valor 
leer_valor() -0.12 rango [0.0,100.0]: Ingrese un valor en el rango [0.0,100.0]: Ingrese en el rango
100.12 un valor en el rango [0.0,100.0]: 56.432 [0.0,100.0]:
56.432 Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:56.432
 print -1 Ingrese un valor en el rango [0.0,100.0]: Ingrese un valor en el Ingrese un valor 

leer_valor() -123 rango [0.0,100.0]: Ingrese un valor en el rango [0.0,100.0]: Ingrese en el rango
-1 un valor en el rango [0.0,100.0]: Ingrese un valor en el rango [0.0,100.0]:
-123 [0.0,100.0]: Ingrese un valor en el rango [0.0,100.0]: Ingrese un Ingrese un valor
-1 valor en el rango [0.0,100.0]: Ingrese un valor en el rango en el rango
-123 [0.0,100.0]: Ingrese un valor en el rango [0.0,100.0]: Ingrese un [0.0,100.0]:
-1 valor en el rango [0.0,100.0]: Ingrese un valor en el rango Ingrese un valor
-123 [0.0,100.0]: Ingrese un valor en el rango [0.0,100.0]: Ingrese un en el rango
-1 valor en el rango [0.0,100.0]: Ingrese un valor en el rango [0.0,100.0]:
-123 [0.0,100.0]: 34.1 Ingrese un valor
-1 en el rango
-123 [0.0,100.0]:
-1 Ingrese un valor
-123 en el rango
-1 [0.0,100.0]:
-123 Ingrese un valor
-1 en el rango
-123 [0.0,100.0]:
-1 Ingrese un valor
-123 en el rango
-1 [0.0,100.0]:
100.2 en el rango
100.1 [0.0,100.0]:
101 Ingrese un valor
123.12 en el rango
1235.12 [0.0,100.0]:
34.1 en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:

Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:

Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:34.1
-9.12 un valor en el rango [0.0,100.0]: Ingrese un valor en el rango [0.0,100.0]:
-0.1 valor en el rango [0.0,100.0]: Ingrese un valor en el rango en el rango
-9.12 [0.0,100.0]: Ingrese un valor en el rango [0.0,100.0]: Ingrese un [0.0,100.0]:
-0.1 [0.0,100.0]: Ingrese un valor en el rango [0.0,100.0]: Ingrese un en el rango
-9.12 valor en el rango [0.0,100.0]: Ingrese un valor en el rango [0.0,100.0]:
-12 [0.0,100.0]: 100.0 Ingrese un valor
-0.1 en el rango
-9.12 [0.0,100.0]:
-0.1 en el rango
-9.12 [0.0,100.0]:
-0.1 en el rango
-9.12 [0.0,100.0]:
100 en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:

Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:100.0
-9.12 un valor en el rango [0.0,100.0]: Ingrese un valor en el rango [0.0,100.0]:
-12 [0.0,100.0]: 0.0 Ingrese un valor
-0.1 en el rango
-9.12 [0.0,100.0]:
-0.1 en el rango
-9.12 [0.0,100.0]:
-0.1 en el rango
-9.12 [0.0,100.0]:
0.0 en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:

Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:
Ingrese un valor
en el rango
[0.0,100.0]:0.0
Your code must pass all tests to earn any marks. Try again.
Mostrar diferencias
Pregunta 3
Puntúa como 1
Defina una función de nombre entero_positivo que no acepta ningún argumento y devuelve un número entero positivo leído por teclado. La
función debe solicitar se ingrese por teclado un número entero positivo, en caso de que el valor ingresado sea negativo o cero se debe volver a
solicitar hasta que se ingrese un valor positivo. Una vez ingresado el valor positivo, la función debe devolverlo como valor de retorno.
Por ejemplo:
print -1 Ingrese un entero positivo: Ingrese un entero positivo: Ingrese un entero positivo: Ingrese un
entero_positivo() -12 entero positivo: Ingrese un entero positivo: Ingrese un entero positivo: Ingrese un entero
-3 positivo: Ingrese un entero positivo: 1
0
0
0
0
1
Reiniciar respuesta
1 ▼ def entero_positivo():
2 ▼ while True:
3 numero = int(raw_input("Ingrese un entero positivo: "))
4 ▼ if numero > 0:
5 return numero
6
7
Comprobar
 print -1 Ingrese un entero positivo: Ingrese un Ingrese un entero positivo: Ingrese un 

entero_positivo() -12 entero positivo: Ingrese un entero entero positivo: Ingrese un entero
-3 positivo: Ingrese un entero positivo: positivo: Ingrese un entero positivo:
0 Ingrese un entero positivo: Ingrese un Ingrese un entero positivo: Ingrese un
0 entero positivo: Ingrese un entero entero positivo: Ingrese un entero
0 positivo: Ingrese un entero positivo: 1 positivo: Ingrese un entero positivo: 1
0
1
 print 45 Ingrese un entero positivo: 45 Ingrese un entero positivo: 45 

entero_positivo()
Pregunta 4
Puntúa como 1
Defina una función de nombre area_circunferencia que, dado un valor decimal r recibido como argumento de la función , devuelva el área de
la circunferencia con radio r. Nota: se debe usar el valor de pi provisto por la biblioteca matemática (math).
Por ejemplo:
Test Resultado
print area_circunferencia(1.5) 7.06858347058
Reiniciar respuesta
1 from math import pi

2 ▼ def area_circunferencia(r):
3 return pi * (r ** 2)
Comprobar
Test Esperado Se obtuvo
 print area_circunferencia(1.5) 7.06858347058 7.06858347058 
Pregunta 5
Puntúa como 1
Realice una función de nombre contar_palabras_cortas() que reciba como argumento una cadena cualquiera y devuelva la cantidad de palabras
presentes en la cadena con longitudes de hasta 5 caracteres.
Por ejemplo:
Test Resultado
print contar_palabras_cortas('mi cadena') 1
print contar_palabras_cortas('nuestra cadena') 0
print contar_palabras_cortas('uno 23') 2
Reiniciar respuesta
1 ▼ def contar_palabras_cortas(cadena):
2 palabras = cadena.split()
3 contador = 0
4 ▼ for palabra in palabras:
5 ▼ if len(palabra) <= 5:
6 contador += 1
7 return contador
Comprobar
 print contar_palabras_cortas('mi cadena') 1 1 
 print contar_palabras_cortas('nuestra cadena') 0 0 
 print contar_palabras_cortas('uno 23') 2 2 
 print contar_palabras_cortas('prueba de ejercicio 123456') 1 1 
 print contar_palabras_cortas('informatica ingenieria') 0 0 
 print contar_palabras_cortas('casos de prueba generales 45678') 3 3 
Pregunta 6
Puntúa como 1
Realice una función de nombre palabra_mas_repetida() que reciba como argumento una cadena cualquiera que representa un texto y devuelva
la primera palabra que más veces aparece en el mismo (no debe diferenciar mayúsculas de minúsculas). La palabra debe devolverse siempre en
minúscula.
Por ejemplo:
Test Resultado
print palabra_mas_repetida('si La la re mi do') la
print palabra_mas_repetida('si re la La RE MI do') re
print palabra_mas_repetida('1 11 la 4 5 6 11 3 11') 11
Reiniciar respuesta
1 from collections import Counter

2
3 ▼ def palabra_mas_repetida(cadena):
4 palabras = cadena.lower().split()
5 contador = Counter(palabras)
6 palabra_mas_repetida = min(contador, key=lambda x: (-contador[x],
7 return palabra_mas_repetida
Comprobar
 print palabra_mas_repetida('si La la re mi do') la la 
 print palabra_mas_repetida('si re la La RE MI do') re re 
 print palabra_mas_repetida('si re la La MI do DO Do') do do 
 print palabra_mas_repetida('mi si MI do Do') mi mi 
 print palabra_mas_repetida('No No Si Nop si Nop Nop') nop nop 
 print palabra_mas_repetida('1 11 la 4 5 6 11 3 11') 11 11 
 print palabra_mas_repetida('1 hola 123 4 5 6 hola 3 hola') hola hola 
Pregunta 7
Puntúa como 1
Realice una función de nombre verificar_clave() que reciba como argumento una cadena cualquiera que representa una contraseña y devuelva
True si dicha cadena cumple con todas las medidas de seguridad que se detallan a continuación, y False si la cadena no cumple con al menos
una de estas medidas.
Medidas de seguridad:
Longitud mínima de seis (6) caracteres

Longitud máxima de doce (12) caracteres
Contiene al menos una (1) letra mayúscula entre A y Z
Contiene al menos dos (2) letras minúsculas entre a y z
Contiene al menos de cuatro (4) números entre 0 y 9
Por ejemplo:
Test Resultado
print verificar_clave('MiClave2016') True
print verificar_clave('MiClaveSegura2016') False
print verificar_clave('miclave2016') False
print verificar_clave('MICLAVE2016') False
print verificar_clave('MiClave16') False
print verificar_clave('mica') False

1 ▼ def verificar_clave(clave):
2 ▼ if len(clave) < 6 or len(clave) > 12:
3 return False
4
5 mayusculas = 0
6 minusculas = 0
7 numeros = 0
8
9 ▼ for caracter in clave:
10 ▼ if caracter.isupper():
11 mayusculas += 1
12 ▼ elif caracter.islower():
13 minusculas += 1
14 ▼ elif caracter.isdigit():
15 numeros += 1
16
17 ▼ if mayusculas >= 1 and minusculas >= 2 and numeros >= 4:
18 return True
19
20 return False
Comprobar
 print verificar_clave('MiClave2016') True True 
 print verificar_clave('MiClaveSegura2016') False False 
 print verificar_clave('miclave2016') False False 
 print verificar_clave('MICLAVE2016') False False 
 print verificar_clave('MiClave16') False False 
 print verificar_clave('mica') False False 
 print verificar_clave('TUClave016') False False 
 print verificar_clave('TUclave1234') True True 
Pregunta 8
Puntúa como 1
Defina una función de nombre son_amigos que, dado dos valores entero a y b recibidos como argumentos de la función, devuelva el valor
lógico (booleano) True si a y b son números amigos, o el valor False si no lo son. Dos números amigos son dos números enteros positivos a y b
tales que la suma de los divisores propios de uno es igual al otro número y viceversa. Por ejemplo, 220 y 284 son números amigos ya que los
divisores propios de:
220 son 1, 2, 4, 5, 10, 11, 20, 22, 44, 55 y 110, que suman 284
284 son 1, 2, 4, 71 y 142, que suman 220.
Por ejemplo:
Test Resultado
print son_amigos(220, 284) True
Reiniciar respuesta
1 ▼ def son_amigos(a, b):

2 sum_div_a = sum(divisores_propios(a))
3 sum_div_b = sum(divisores_propios(b))
4 return sum_div_a == b and sum_div_b == a
5
6 ▼ def divisores_propios(n):
7 divisores = []
8 ▼ for i in range(1, n):
9 ▼ if n % i == 0:
10 divisores.append(i)
11 return divisores
12
Comprobar
 print son_amigos(220, 284) True True 
 print son_amigos(120, 184) False False 
 print son_amigos(1184, 1210) True True 
 print son_amigos(1200, 1284) False False 
Pregunta 9
Puntúa como 1
Defina una función de nombre tipo_triangulo que, dado 3 valores decimales a, b y c recibidos como argumentos de la función, devuelva una
cadena con el tipo de triángulo. a, b y c corresponden a la longitud de sus lados. En el caso que todos sus lados sean iguales, se debe devolver
la cadena 'equilatero' (sin acento). Si dos de sus lados son iguales pero el otro no lo es, se debe devolver la cadena 'isosceles' (sin acento). Si
todos sus lados son diferentes, entonces debe devolver la cadena 'escaleno'.
Por ejemplo:
Test Resultado
print tipo_triangulo(1.5, 2, 1.5) isosceles
Reiniciar respuesta
1 ▼ def tipo_triangulo(a, b, c):

2 ▼ if a == b == c:
3 return 'equilatero'
4 ▼ elif a == b or b == c or a == c:
5 return 'isosceles'
6 ▼ else:
7 return 'escaleno'
8
9
Comprobar
 print tipo_triangulo(1.5, 2, 1.5) isosceles isosceles 
 print tipo_triangulo(1.5, 1.5, 1.5) equilatero equilatero 
 print tipo_triangulo(1.3, 1.2, 1.5) escaleno escaleno 
 print tipo_triangulo(1, 1.5, 1.5) isosceles isosceles 
 print tipo_triangulo(1.5, 1.5, 2.5) isosceles isosceles 
Pregunta 10
Puntúa como 1
Defina una función de nombre tipo_triangulo que, dado 3 valores decimales a, b y c recibidos como argumentos de la función, devuelva una
cadena con el tipo de triángulo. a, b y c corresponden a la amplitud de sus ángulos internos (expresados en grados). En el caso que uno de sus
ángulos sea recto (igual a 90), se debe devolver la cadena 'rectangulo' (sin acento). Si en cambio todos sus ángulos son menores que 90
grados, se debe devolver la cadena 'acutangulo' (sin acento). Si uno de sus ángulos es mayor que 90 grados, entonces debe devolver la cadena
'obtusangulo' (sin acento).
Por ejemplo:
Test Resultado
print tipo_triangulo(90, 30, 60) rectangulo
Reiniciar respuesta
1 ▼ def tipo_triangulo(a, b, c):

2 ▼ if a == 90 or b == 90 or c == 90:
3 return 'rectangulo'
4 ▼ elif a < 90 and b < 90 and c < 90:
5 return 'acutangulo'
6 ▼ else:
7 return 'obtusangulo'
Comprobar
 print tipo_triangulo(90, 30, 60) rectangulo rectangulo 
 print tipo_triangulo(60, 80, 40) acutangulo acutangulo 
 print tipo_triangulo(120, 40, 20) obtusangulo obtusangulo 
 print tipo_triangulo(30, 30, 120) obtusangulo obtusangulo 
 print tipo_triangulo(30, 60, 90) rectangulo rectangulo 
Pregunta 11
Puntúa como 1
Implemente una función recursiva que calcule el máximo común divisor entre dos números enteros mediante el algoritmo de Euclides. Deberá
definir la función mcd (a,b) tal que cumpla con la siguiente definición.
Función :
Si entonces:
El resultado es
En otro caso:
El resultado es
Nota: mod representa a la función (módulo).
Por ejemplo:
Test Resultado
print mcd(16,4) 4

1 ▼ def mcd(a, b):
2 ▼ if b == 0:
3 return a
4 ▼ else:
5 return mcd(b, a % b)
6
Comprobar
 print mcd(16,4) 4 4 
 print mcd(2366,273) 91 91 
 print mcd(450,360) 90 90 
 print mcd(180,150) 30 30 
 print mcd(48,36) 12 12 
Pregunta 12
Puntúa como 1
Defina una función de nombre promedio_lista que calcule el promedio de una lista de números recibida como argumento de la función, y
devuelva su valor. En el caso que la lista esté vacía el valor devuelto debe ser 0.
Por ejemplo:
Test Resultado
print promedio_lista([4, 5, 6]) 5.0
print promedio_lista([5, 6]) 5.5
print promedio_lista([]) 0
Reiniciar respuesta
1 ▼ def promedio_lista(lista):
2 ▼ if len(lista) == 0:
3 return 0
4 ▼ else:
5 return float(sum(lista)) / len(lista)
6
7
Comprobar
 print promedio_lista([4, 5, 6]) 5.0 5.0 
 print promedio_lista([5, 6]) 5.5 5.5 
 print promedio_lista([]) 0 0 
Pregunta 13
Puntúa como 1
Defina una función de nombre mas_repetido que devuelva el elemento que más se repite de una lista de números recibida como argumento de
la función.
Por ejemplo:
Test Resultado
print mas_repetido([4, 5, 4, 6]) 4
Reiniciar respuesta
1 from collections import Counter

2
3 ▼ def mas_repetido(lista):
5 return None
6
7 contador = Counter(lista)
8 elemento_mas_comun = contador.most_common(1)[0][0]
9 return elemento_mas_comun
Comprobar
 print mas_repetido([4, 5, 4, 6]) 4 4 
 print mas_repetido([5, 6, 6]) 6 6 
 print mas_repetido([1, 2, 3, 3, 1, 2, 1]) 1 1 
Pregunta 14
Puntúa como 1
Defina una función de nombre producto_lista que calcule la productoria de una lista de números recibida como argumento de la función, y
devuelva su valor. En el caso que la lista esté vacía el valor devuelto debe ser 1. Recordar que la productoria implica hacer el producto de todos
los elementos de la lista.
Por ejemplo:
Test Resultado
print producto_lista([]) 1
print producto_lista([4, 5]) 20
print producto_lista([4, 5, -2]) -40
print producto_lista([4.5, -2]) -9.0
Reiniciar respuesta
1 ▼ def producto_lista(lista):
3 return 1
4
5 resultado = 1
6 ▼ for num in lista:
7 resultado *= num
8
9 return resultado
Comprobar
 print producto_lista([]) 1 1 
 print producto_lista([4, 5]) 20 20 
 print producto_lista([4, 5, -2]) -40 -40 
 print producto_lista([4.5, -2]) -9.0 -9.0 
Pregunta 15
Puntúa como 1
Realice una función de nombre contar_primos() que reciba como argumento una lista de números enteros y devuelva la cantidad de números
primos que hay en la lista.
Por ejemplo:
Test Resultado
print contar_primos([1,2,3]) 2
print contar_primos([1,4,4,6]) 0
Reiniciar respuesta
1 ▼ def contar_primos(lista):
2 cantidad_primos = 0
3
4 ▼ for num in lista:
5 ▼ if es_primo(num):
6 cantidad_primos += 1
7
8 return cantidad_primos
9
10 ▼ def es_primo(num):
11 ▼ if num < 2:
12 return False
13
14 ▼ for i in range(2, int(num ** 0.5) + 1):
15 ▼ if num % i == 0:
16 return False
17
18 return True
19
Comprobar
 print contar_primos([1,2,3]) 2 2 
 print contar_primos([1,4,4,6]) 0 0 
 print contar_primos([1,7,9,11]) 2 2 
 print contar_primos([1,7,9,11,13]) 3 3 
 print contar_primos([1,7,9,11,31,37]) 4 4 
 print contar_primos([1,7,9,11,15,31,37,43]) 5 5 
Pregunta 16
Puntúa como 1
Realizar una función AinterseccionB(A,B) donde A y B son listas de números enteros.
La función retornará una lista que contendrá la intersección de A con B. Dicha lista deberá estar ordenada de menor a mayor. Tanto A como B
pueden tener elementos repetidos, la lista, que retorna la función, no debe tener elementos repetidos, de haberlos quedará solo uno.
Por ejemplo:
Test Resultado
print AinterseccionB([1,2,3],[6,4,2,3]) [2, 3]
Reiniciar respuesta
1 ▼ def AinterseccionB(A, B):

2 interseccion = list(set(A) & set(B))
3 interseccion.sort()
4 return interseccion
Comprobar
 print AinterseccionB([1,2,3],[6,4,2,3]) [2, 3] [2, 3] 
 print AinterseccionB([],[1,2,3]) [] [] 
 print AinterseccionB([5,2,3],[]) [] [] 
 print AinterseccionB([],[]) [] [] 
 print AinterseccionB([3,21,6],[3,1,6,1]) [3, 6] [3, 6] 
 print AinterseccionB ([1,2,1,22],[11,22,33,44]) [22] [22] 
Pregunta 17
Puntúa como 1
Defina una función de nombre listas_iguales que, dado dos listas a y b recibidas como argumentos de la función, devuelva el valor lógico
(booleano) True si las listas son iguales (tienen los mismos valores y en la misma posición) , o el valor False si no lo son.
Por ejemplo:
Test Resultado
print listas_iguales([1, 2], [1, 2]) True
Reiniciar respuesta
1 ▼ def listas_iguales(a, b):

2 return a == b
3
Comprobar
 print listas_iguales([1, 2], [1, 2]) True True 
 print listas_iguales([2, 1], [1, 2]) False False 
 print listas_iguales([1, 2, 3], [1, 2]) False False 
 print listas_iguales([1, 3, 2], [1, 3, 2]) True True 
Pregunta 18
Puntúa como 1
Defina una función de nombre sumar_columnas que, dado una lista de listas (una matriz) recibida como argumento de la función, devuelva una
nueva lista con la suma de cada columna de la matriz.
Por ejemplo:
Test Resultado
print sumar_columnas([[1, 2], [3, 4]]) [4, 6]
Reiniciar respuesta
1 ▼ def sumar_columnas(matriz):
2 num_columnas = len(matriz[0])
3 suma_columnas = [0] * num_columnas
4
5 ▼ for fila in matriz:
6 ▼ for i, valor in enumerate(fila):
7 suma_columnas[i] += valor
8
9 return suma_columnas
Comprobar
 print sumar_columnas([[1, 2], [3, 4]]) [4, 6] [4, 6] 
 print sumar_columnas([[1, 2], [3, 4], [2, 3]]) [6, 9] [6, 9] 
 print sumar_columnas([[1, 2, 3], [4, 2, 3]]) [5, 4, 6] [5, 4, 6] 
 print sumar_columnas([[1, -1, 0], [4, 10, 3]]) [5, 9, 3] [5, 9, 3] 
Pregunta 19
Puntúa como 1
Defina una función de nombre mezclar_listas que, dado dos listas a y b recibidas como argumentos de la función, devuelva una nueva lista que
contenga en forma alternada un elemento de la lista a y otro de la lista b. Si las listas tienen diferentes cantidad de elementos, la función debe
devolver una lista vacía.
Por ejemplo:
Test Resultado
print mezclar_listas([1, 2], [1, 2]) [1, 1, 2, 2]
Reiniciar respuesta
1 ▼ def mezclar_listas(a, b):

2 ▼ if len(a) != len(b):
3 return []
4
5 mezcla = []
6
7 ▼ for i in range(len(a)):
8 mezcla.append(a[i])
9 mezcla.append(b[i])
10
11 return mezcla
12
Comprobar
 print mezclar_listas([1, 2], [1, 2]) [1, 1, 2, 2] [1, 1, 2, 2] 
 print mezclar_listas([2, 1], [1, 2]) [2, 1, 1, 2] [2, 1, 1, 2] 
 print mezclar_listas([1, 2, 3], [1, 2]) [] [] 
 print mezclar_listas([1, 3, 2], [1, 3, 2]) [1, 1, 3, 3, 2, 2] [1, 1, 3, 3, 2, 2] 
Pregunta 20
Puntúa como 1
Genere una función llamada acumular_filas(matriz) que reciba una matriz de enteros y devuelva una nueva con las siguientes características:
La nueva matriz debe modificar cada elemento de una fila por la suma acumulada de ese elemento y de todos los elementos anteriores en la
misma fila.
Por ejemplo : para la fila 1,2,3,4 la fila correspondiente en la nueva matriz será 1,3,6,10
Para la matriz
[[0, 1, 2, 3], [4, 5, 6, 7], [1, 1, 0, 3]]

Deberá devolver la matriz
[[0, 1, 3, 6], [4, 9, 15, 22], [1, 2, 2, 5]]
Por ejemplo:
Test Resultado
print acumular_filas([[0, 1, 2, 3], [4, 5, 6, 7], [1, 1, 0, 3]]) [[0, 1, 3, 6], [4, 9, 15, 22], [1, 2, 2, 5]]

1 ▼ def acumular_filas(matriz):
2 nueva_matriz = []
3
5 suma_acumulada = 0
6 nueva_fila = []
7
8 ▼ for elemento in fila:
9 suma_acumulada += elemento
10 nueva_fila.append(suma_acumulada)
11
12 nueva_matriz.append(nueva_fila)
13
14 return nueva_matriz
Comprobar
 print acumular_filas([[0, 1, 2, 3], [4, 5, 6, 7], [[0, 1, 3, 6], [4, 9, 15, 22], [[0, 1, 3, 6], [4, 9, 15, 22], 
[1, 1, 0, 3]]) [1, 2, 2, 5]] [1, 2, 2, 5]]
 print acumular_filas([[0,10,2,3],[0,10,2,3], [[0, 10, 12, 15], [0, 10, 12, [[0, 10, 12, 15], [0, 10, 12, 
[0,10,2,3]]) 15], [0, 10, 12, 15]] 15], [0, 10, 12, 15]]
 print acumular_filas([[10, 100, 200, 3], [0, 1, 60, [[10, 110, 310, 313], [0, 1, [[10, 110, 310, 313], [0, 1, 
150], [0, 100, 10, 3]]) 61, 211], [0, 100, 110, 113]] 61, 211], [0, 100, 110, 113]]
 print acumular_filas([[0,0,0,0],[0,0,0,0], [[0, 0, 0, 0], [0, 0, 0, 0], [[0, 0, 0, 0], [0, 0, 0, 0], 
[0,0,0,0]]) [0, 0, 0, 0]] [0, 0, 0, 0]]
 print acumular_filas([[0,10,-20,10],[0,-10,20,-10], [[0, 10, -10, 0], [0, -10, 10, [[0, 10, -10, 0], [0, -10, 10, 
[20,-100,80,-10]]) 0], [20, -80, 0, -10]] 0], [20, -80, 0, -10]]
Pregunta 21
Puntúa como 1
Genere una función llamada marcar_pares(matriz) que reciba una matriz de enteros y devuelva una nueva matriz con las siguientes
características:
Igual dimensión que la matriz original

A cada elemento par de la matriz original le corresponderá un 1 en la nueva matriz
A cada elemento impar de la matriz original le corresponderá un 0 en la nueva matriz.
Para la matriz
[[1, 2], [2, 3], [0, 10]]

[[0, 1], [1, 0], [1, 1]]
Por ejemplo:
Test Resultado
print marcar_pares([[1, 2], [2, 3], [0, 10]]) [[0, 1], [1, 0], [1, 1]]

1 ▼ def marcar_pares(matriz):
2 nueva_matriz = []
3
5 nueva_fila = []
6
8 ▼ if elemento % 2 == 0:
9 nueva_fila.append(1) # Par
10 ▼ else:
11 nueva_fila.append(0) # Impar
12
14
Comprobar
 print marcar_pares([[1, 2], [2, 3], [0, 10]]) [[0, 1], [1, 0], [1, 1]] [[0, 1], [1, 0], [1, 1]] 
 print marcar_pares([[1,2,3,4],[0,10,2,3],[0,10,2,3]]) [[0, 1, 0, 1], [1, 1, 1, 0], [[0, 1, 0, 1], [1, 1, 1, 0], 
[1, 1, 1, 0]] [1, 1, 1, 0]]
 print marcar_pares([[-100,2,-300,4],[-1000,0,-2,100], [[1, 1, 1, 1], [1, 1, 1, 1], [[1, 1, 1, 1], [1, 1, 1, 1], 
[-10,0,-200,300]]) [1, 1, 1, 1]] [1, 1, 1, 1]]
 print marcar_pares([[0,0,0,0],[0,0,0,0],[0,0,0,0]]) [[1, 1, 1, 1], [1, 1, 1, 1], [[1, 1, 1, 1], [1, 1, 1, 1], 
[1, 1, 1, 1]] [1, 1, 1, 1]]
 print marcar_pares([[0,10,-20,10],[0,-10,20,-10], [[1, 1, 1, 1], [1, 1, 1, 1], [[1, 1, 1, 1], [1, 1, 1, 1], 
[20,-100,80,-10]]) [1, 1, 1, 1]] [1, 1, 1, 1]]
Pregunta 22
Puntúa como 1
Genere una función llamada marcar_mayores(matriz) que reciba una matriz de enteros y devuelva una nueva matriz con las siguientes
características:
Igual dimensión que la matriz original

A cada elemento mayor a 10 y menor a 20 de la matriz original le corresponderá un 1 en la nueva matriz
A cada elemento mayor o igual a 20 de la matriz original le corresponderá un 0 en la nueva matriz.
A cualquier otro elemento le corresponderá -1
Para la matriz
[[10, 21], [15, 3], [0, 20]]

[[-1, 0], [1, -1], [-1, 0]]
Por ejemplo:
Test Resultado
print marcar_mayores([[10, 21], [15, 3], [0, 20]]) [[-1, 0], [1, -1], [-1, 0]]

1 ▼ def marcar_mayores(matriz):
2 nueva_matriz = []
3
5 nueva_fila = []
6
8 ▼ if elemento > 10 and elemento < 20:
9 nueva_fila.append(1) # Entre 10 y 20 (exclusivos)
10 ▼ elif elemento >= 20:
11 nueva_fila.append(0) # Mayor o igual a 20
12 ▼ else:
13 nueva_fila.append(-1) # Otro caso
14
16
Comprobar
 print marcar_mayores([[10, 21], [15, 3], [0, 20]]) [[-1, 0], [1, -1], [-1, 0]] [[-1, 0], [1, -1], [-1, 0]] 
 print marcar_mayores([[11,20,13,24],[0,10,20,31], [[1, 0, 1, 0], [-1, -1, 0, 0], [[1, 0, 1, 0], [-1, -1, 0, 0], 
[10,10,12,13]]) [-1, -1, 1, 1]] [-1, -1, 1, 1]]
 print marcar_mayores([[-100,2,-300,4], [[-1, -1, -1, -1], [-1, -1, -1, [[-1, -1, -1, -1], [-1, -1, 
[-1000,0,-2,100],[-10,0,-200,300]]) 0], [-1, -1, -1, 0]] -1, 0], [-1, -1, -1, 0]]
 print marcar_mayores([[0,0,0,0],[0,0,0,0], [[-1, -1, -1, -1], [-1, -1, -1, [[-1, -1, -1, -1], [-1, -1, 
[0,0,0,0]]) -1], [-1, -1, -1, -1]] -1, -1], [-1, -1, -1, -1]]
 print marcar_mayores([[0,10,-20,10],[0,-10,20,-10], [[-1, -1, -1, -1], [-1, -1, 0, [[-1, -1, -1, -1], [-1, -1, 0, 
[20,-100,80,-10]]) -1], [0, -1, 0, -1]] -1], [0, -1, 0, -1]]
Pregunta 23
Puntúa como 1
Genere una función llamada promediar_filas(matriz) que reciba una matriz de enteros y devuelva una nueva de flotantes con las siguientes
características:
La nueva matriz debe modificar cada elemento de una fila por el promedio del resto de los elementos de la fila matriz original.
Por ejemplo : para la fila 1,2,3,4 la misma fila en la nueva matriz será 3.00,2.66,2.33,2.00
Para la matriz
[[1, 2], [2, 3], [0, 10]]

[[2.0, 1.0], [3.0, 2.0], [10.0, 0.0]]
Por ejemplo:
Test Resultado
print promediar_filas([[1,2],[2,3],[0,10]]) [[2.0, 1.0], [3.0, 2.0], [10.0, 0.0]]

1 ▼ def promediar_filas(matriz):
2 nueva_matriz = []
3
5 suma_elementos = sum(fila)
6 cantidad_elementos = len(fila)
7 promedio = suma_elementos / cantidad_elementos
8
9 nueva_fila = [promedio] * cantidad_elementos
11
Comprobar
 print promediar_filas([[1,2],[2,3], [[2.0, 1.0], [3.0, 2.0], [10.0, 0.0]] [[1, 1], [2, 2], 
[0,10]]) [5, 5]]
 print promediar_filas([[1,2,3,4], [[3.0, 2.6666666666666665, 2.3333333333333335, 2.0], [[2, 2, 2, 2], [3, 

[0,10,2,3],[0,10,2,3]]) [5.0, 1.6666666666666667, 4.333333333333333, 4.0], 3, 3, 3], [3, 3, 3,
[5.0, 1.6666666666666667, 4.333333333333333, 4.0]] 3]]
 print promediar_filas([[-100,2,-300,4], [[-98.0, -132.0, -31.333333333333332, [[-99, -99, -99, 

[-1000,0,-2,100],[-10,0,-200,300]]) -132.66666666666666], [32.666666666666664, -99], [-226, -226,
-300.6666666666667, -300.0, -334.0], -226, -226], [22,
[33.333333333333336, 30.0, 96.66666666666667, 22, 22, 22]]
-70.0]]
 print promediar_filas([[0,0,0,0], [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, [[0, 0, 0, 0], [0, 
[0,0,0,0],[0,0,0,0]]) 0.0, 0.0, 0.0]] 0, 0, 0], [0, 0, 0,
0]]
 print promediar_filas([[0,10,-20,10], [[0.0, -3.3333333333333335, 6.666666666666667, [[0, 0, 0, 0], [0, 

[0,-10,20,-10],[20,-100,80,-10]]) -3.3333333333333335], [0.0, 3.3333333333333335, 0, 0, 0], [-3, -3,
-6.666666666666667, 3.3333333333333335], [-10.0, -3, -3]]
30.0, -30.0, 0.0]]
Mostrar diferencias
Pregunta 24
Puntúa como 1
Genere una función llamada multiplicar_matrices(m1, m2) que reciba como argumentos dos matrices de números flotantes y devuelva una
nueva matriz, cuyo resultado sea el producto matricial entre m1 y m2. Si la operación no puede ser realizada, deberá devolver una lista vacía.
Por ejemplo:
Test Resultado
print multiplicar_matrices([[1,1], [0,1]], [[1,0],[1,1]]) [[2.0, 1.0], [1.0, 1.0]]
print multiplicar_matrices([[1,0,2],[1,1,2]], [[1,1], [0,1]]) []
print multiplicar_matrices([[1,-2,3], [1,0,-1]], [[4],[5],[6]]) [[12.0], [-2.0]]
Reiniciar respuesta
1 ▼ def multiplicar_matrices(m1, m2):

2 filas_m1 = len(m1)
3 columnas_m1 = len(m1[0])
6
7 ▼ if columnas_m1 != filas_m2:
8 return []
9
10 resultado = [[0.0] * columnas_m2 for _ in range(filas_m1)]
11
12 ▼ for i in range(filas_m1):
13 ▼ for j in range(columnas_m2):
14 ▼ for k in range(filas_m2):
15 resultado[i][j] += m1[i][k] * m2[k][j]
16
17 return resultado
18
Comprobar
 print multiplicar_matrices([[1,1], [0,1]], [[1,0], [[2.0, 1.0], [1.0, 1.0]] [[2.0, 1.0], [1.0, 1.0]] 
[1,1]])
 print multiplicar_matrices([[1,0],[1,1]], [[1,1], [[1.0, 1.0], [1.0, 2.0]] [[1.0, 1.0], [1.0, 2.0]] 
[0,1]])
 print multiplicar_matrices([[1,0,2],[1,1,2]], [[1,1], [] [] 

[0,1]])
 print multiplicar_matrices([[1,4,7], [2,5,8], [[30.0, -26.0, 10.0], [36.0, [[30.0, -26.0, 10.0], [36.0, 
[3,6,9]], [[1,-1,2], [2,-1,2], [3,-3,0]]) -31.0, 14.0], [42.0, -36.0, -31.0, 14.0], [42.0, -36.0,
18.0]] 18.0]]
 print multiplicar_matrices([[1,-2,3], [1,0,-1]], [[12.0], [-2.0]] [[12.0], [-2.0]] 

[[4],[5],[6]])
 print multiplicar_matrices([[1,0,2], [0,2,0], [[5.0], [-2.0], [-1.0]] [[5.0], [-2.0], [-1.0]] 

[0,1,3]], [[5],[-1],[0]])
 print multiplicar_matrices([[1,-2,3]], [[4],[5],[6]]) [[12.0]] [[12.0]] 
 print multiplicar_matrices([[1,3,-1], [0, 2,-5], [1, [[-4.0, -7.0], [-25.0, -19.0], [[-4.0, -7.0], [-25.0, 
2, 3]], [[1,2],[0,-2],[5,3]]) [16.0, 7.0]] -19.0], [16.0, 7.0]]
Pregunta 25
Puntúa como 1
Genere una función llamada sumar_matrices(m1, m2) que reciba como argumentos dos matrices de números flotantes y devuelva una nueva
matriz, cuyo resultado sea la suma de las dos matrices (elemento a elemento).
Por ejemplo:
Test Resultado
print sumar_matrices([[1,1], [0,1]], [[1,0],[1,1]]) [[2, 1], [1, 2]]
print sumar_matrices([[1.1,0.3,2.56],[1.1,1.32,2.65]], [[1.1,9.1,1], [0,0,1.1]]) [[2.2, 9.4, 3.56], [1.1, 1.32, 3.75]]
print sumar_matrices([[11.12,-2.312,31.1], [1.1,0,-1.1]], [[11.12,-2.312,31.1], [[22.24, -4.624, 62.2], [2.2, 0,

[1.1,0,-1.1]]) -2.2]]
Reiniciar respuesta
1 ▼ def sumar_matrices(m1, m2):

6
7 ▼ if filas_m1 != filas_m2 or columnas_m1 != columnas_m2:
8 return []
9 resultado = [[0.0] * columnas_m1 for _ in range(filas_m1)]
10
13 resultado[i][j] = m1[i][j] + m2[i][j]
14
15 return resultado
Comprobar
 print sumar_matrices([[1,1], [0,1]], [[1,0],[1,1]]) [[2, 1], [1, 2]] [[2, 1], [1, 2]] 
 print sumar_matrices([[1,0],[1,1]], [[1,1], [0,1]]) [[2, 1], [1, 2]] [[2, 1], [1, 2]] 
 print sumar_matrices([[1.1,0.3,2.56],[1.1,1.32,2.65]], [[2.2, 9.4, 3.56], [1.1, [[2.2, 9.4, 3.56], 

[[1.1,9.1,1], [0,0,1.1]]) 1.32, 3.75]] [1.1, 1.32, 3.75]]
 print sumar_matrices([[1,4,7], [2,5,8], [3,6,9]], [[1,-1,2], [[2, 3, 9], [4, 4, 10], [[2, 3, 9], [4, 4, 10], 
[2,-1,2], [3,-3,0]]) [6, 3, 9]] [6, 3, 9]]
 print sumar_matrices([[11.12,-2.312,31.1], [1.1,0,-1.1]], [[22.24, -4.624, 62.2], [[22.24, -4.624, 62.2], 

[[11.12,-2.312,31.1], [1.1,0,-1.1]]) [2.2, 0, -2.2]] [2.2, 0, -2.2]]
Pregunta 26
Puntúa como 1
Genere una función llamada son_iguales(m1, m2) que recibe dos matrices m1 y m2 con valores flotantes y devuelve True si las dos matrices
son iguales y False en caso contrario. Debe comprobar que las matrices tengan igual número de filas e igual número e columnas y luego se
debe comprobar que todos los elementos sean iguales. Se debe considerar que dos elementos son iguales si la diferencia entre ellos es menor
a 0.000001.
Por ejemplo:
Test Resultado
print son_iguales([[1,1], [0,1]], [[1,0],[1,1]]) False
print son_iguales([[1,1], [0,1]], [[1,1,0.1],[0,1,0.1]]) False
print son_iguales([[1.1000000001,0.3,2.560000001,6.1],[1.1,1.32,2.65,6.1]],[[1.1,0.3,2.56,6.1],[1.1,1.32,2.65,6.1]]) True
Reiniciar respuesta
1 ▼ def son_iguales(m1, m2):

6
7 ▼ if filas_m1 != filas_m2 or columnas_m1 != columnas_m2:
8 return False
9
12 ▼ if abs(m1[i][j] - m2[i][j]) >= 0.000001:
13 return False
14
15 return True
Comprobar
Se
Test Esperado
obtuvo
 print son_iguales([[1,1], [0,1]], [[1,0],[1,1]]) False False 
 print son_iguales([[1,1], [0,1]], [[1,1],[0,1]]) True True 
 print son_iguales([[1,1], [0,1]], [[1,1,0.1],[0,1,0.1]]) False False 
 print son_iguales([[1.1,0.3,2.56,6.1],[1.1,1.32,2.65,6.1]],[[1.1,0.3,2.56,6.1], True True 

[1.1,1.32,2.65,6.1]])
 print son_iguales([[1.1000000001,0.3,2.560000001,6.1],[1.1,1.32,2.65,6.1]], True True 

[[1.1,0.3,2.56,6.1],[1.1,1.32,2.65,6.1]])
 print son_iguales([[1.1001,0.3,2.560001,6.1],[1.1,1.32,2.65,6.1]],[[1.1,0.3,2.56,6.1], False False 

[1.1,1.32,2.65,6.1]])
 print son_iguales([[1.100001,0.3,2.560001,6.1],[1.1,1.32,2.65,6.1]],[[1.1,0.3,2.56,6.1], False False 

[1.1,1.32,2.65,6.1]])
Pregunta 27
Puntúa como 1
Genere una función llamada mostrar_enmascarada(mat, mascara) que recibe dos matrices de igual tamaño. La primera (mat) es una matriz
de valores flotantes y la segunda (mascara) es una matriz de elementos booleanod (True o False). La función debe mostrar por pantalla los
valores de la matriz mat en formato de matriz con dos decimales y 7 espacios en total para todas aquellas posiciones en las que en la matriz
mascara el valor sea True y debe mostrar una "x" en las posiciones donde mascara contenga un False.
Por ejemplo:
si mat es [[1.1233, 5.123, 9.0], [8.12, 7.12345, -1.5]] y mascara es [[True, False, False], [True, True, False]], se debe mostrar por pantalla:
1.12 x x
8.12 5.12 x
Por ejemplo:
Test Resultado
mostrar_enmascarada([[1,1], [0,1]], [[True,True],[True,True]]) 1.00 1.00

0.00 1.00
mostrar_enmascarada([[1.1,0.3,2.56],[1.1,1.32,2.65]], [[True,False,True],[True, True, False]]) 1.10 x 2.56

1.10 1.32 x
mostrar_enmascarada([[11.12,-2.312,31.1]], [[True,False,True]]) 11.12 x 31.10
Reiniciar respuesta
1 ▼ def mostrar_enmascarada(mat, mascara):

2 filas = len(mat)
3 columnas = len(mat[0])
4
5 ▼ if filas != len(mascara) or columnas != len(mascara[0]):
6 print("Error: Las matrices deben tener las mismas dimensiones
7 return
8
9 ▼ for i in range(filas):
10 ▼ for j in range(columnas):
11 ▼ if mascara[i][j]:
12 valor = "{:.2f}".format(mat[i][j])
13 print(f"{valor:7}", end="")
14 ▼ else:
15 print(" x ", end="")
16 print()
Comprobar
 mostrar_enmascarada([[1,1], [0,1]], [[True,True],[True,True]]) 1.00 1.00 ***Error*** 

0.00 1.00 File "__tester__.python2", line 13
print(f"{valor:7}", end="")
^
SyntaxError: invalid syntax
Prueba cancelada debido a un error.

Mostrar diferencias
Pregunta 28
Puntúa como 1
Sopa de letras: Encontrar palabra en filas
Defina la función encontrar_en_filas que recibe como argumento una matriz de caracteres (sopa_letras), y una cadena de caracteres (palabra).
La función deberá buscar la ocurrencia de palabra en las filas de la matriz, tanto escrita de izquierda a derecha como de derecha a izquierda. Al
finalizar deberá retornar una matriz dónde cada fila almacenará el indice de fila, columna de inicio y columna de final de cada ocurrencia de la
palabra en la matriz. En caso de que no se encuentre la palabra en la matriz deberá retornar una lista vacía.
Ejemplo
Dada la sopa de letras que se muestra en el dibujo y si la palabra a buscar fuera "PAPA", usted debería encontrar 3 ocurrencias de la palabra en
filas de izquierda a derecha (las cuáles están resaltadas en amarillo) y 1 ocurrencia de derecha a izquierda (resaltada en verde).
Si usted resolvió el problema(*), es decir obtiene las mismas casos de ocurrencia de la palabra pero en distinto orden, considere lo siguiente:
1) Los casos están ordenados por el número de fila. Es decir, casos de índice de fila menor aparecen primero.
2) Entre dos casos de una misma fila, primero aparecen los de izquierda a derecha y luego los de derecha a izquierda.
3) Los casos de izquierda a derecha, como así también de derecha a izquierda, están ordenados de acuerdo a su ocurrencia siguiendo el
orden de lectura indicado. Es decir, un casos de izquierda a derecha deberá aparecer primero cuando el índice de inicio es menor y un caso
de derecha a izquierda deberá aparecer primero cuando el índice de inicio es mayor.
Estas consideraciones no implican la implementación de un algoritmo de ordenamiento, sino mas bien el orden en el que usted deberá ir
insertando los resultados a la matriz resultante.
(*) Si NO resolvió el problema, la aclaración que viene pueda que lo confunda.
Por ejemplo:
Test Resultado
sopa = [ [[4, 2, 5], [4, 4, 7], [4, 6, 3], [7, 4, 7]]

['A','S','U','S','A','N','A','B'],
['B','U','S','U','S','A','N','A'],
['C','S','P','E','R','R','O','S'],
['D','A','G','A','T','O','S','S'],
['E','N','P','A','P','A','P','A'],
['F','A','A','R','B','O','L','S'],
['L','M','P','I','N','T','A','S'],
['L','M','A','V','P','A','P','A']
]
print encontrar_en_filas(sopa, 'PAPA')
sopa = [ []
['A','S','U','S','A','N','A','B'],
['B','U','S','U','S','A','N','A'],
['C','S','P','E','R','R','O','S'],
['D','A','G','A','T','O','S','S'],
['E','N','P','A','P','A','P','A'],
['F','A','A','R','B','O','L','S'],
['L','M','P','I','N','T','A','S'],
['L','M','A','V','P','A','P','A']
]
print encontrar_en_filas(sopa, 'SUSANO')
Test Resultado
#En este caso la matriz no es cuadrada [[4, 2, 5]]

sopa = [
['A','S','U','S','A','N'],
['B','U','S','U','S','A'],
['C','S','P','E','R','R'],
['D','A','G','A','T','O'],
['E','N','P','A','P','A'],
['F','A','A','R','B','O'],
['L','M','P','I','N','T'],
['L','M','A','V','P','A']
]
Reiniciar respuesta
1 ▼ def encontrar_en_filas(sopa_letras, palabra):

2 #escriba su codigo aqui
3 return
Comprobar
 sopa = [ [[4, 2, 5], [4, 4, 7], [4, 6, 3], [7, 4, 7]] None 
['A','S','U','S','A','N','A','B'],
['B','U','S','U','S','A','N','A'],
['C','S','P','E','R','R','O','S'],
['D','A','G','A','T','O','S','S'],
['E','N','P','A','P','A','P','A'],
['F','A','A','R','B','O','L','S'],
['L','M','P','I','N','T','A','S'],
['L','M','A','V','P','A','P','A']
]
 sopa = [ [[0, 1, 6], [1, 2, 7]] None 

['A','S','U','S','A','N','A','B'],
['B','U','S','U','S','A','N','A'],
['C','S','P','E','R','R','O','S'],
['D','A','G','A','T','O','S','S'],
['E','N','P','A','P','A','P','A'],
['F','A','A','R','B','O','L','S'],
['L','M','P','I','N','T','A','S'],
['L','M','A','V','P','A','P','A']
]
print encontrar_en_filas(sopa, 'SUSANA')
 sopa = [ [[2, 2, 6]] None 

['A','S','U','S','A','N','A','B'],
['B','U','S','U','S','A','N','A'],
['C','S','P','E','R','R','O','S'],
['D','A','G','A','T','O','S','S'],
['E','N','P','A','P','A','P','A'],
['F','A','A','R','B','O','L','S'],
['L','M','P','I','N','T','A','S'],
['L','M','A','V','P','A','P','A']
]
print encontrar_en_filas(sopa, 'PERRO')
 sopa = [ [[2, 2, 7]] None 

['A','S','U','S','A','N','A','B'],
['B','U','S','U','S','A','N','A'],
['C','S','P','E','R','R','O','S'],
['D','A','G','A','T','O','S','S'],
['E','N','P','A','P','A','P','A'],
['F','A','A','R','B','O','L','S'],
['L','M','P','I','N','T','A','S'],
['L','M','A','V','P','A','P','A']
]
print encontrar_en_filas(sopa, 'PERROS')
 sopa = [ [[6, 2, 7]] None 

['A','S','U','S','A','N','A','B'],
['B','U','S','U','S','A','N','A'],
['C','S','P','E','R','R','O','S'],
['D','A','G','A','T','O','S','S'],
['E','N','P','A','P','A','P','A'],
['F','A','A','R','B','O','L','S'],
['L','M','P','I','N','T','A','S'],
['L','M','A','V','P','A','P','A']
]
print encontrar_en_filas(sopa, 'PINTAS')
 sopa = [ [[5, 2, 6]] None 

['A','S','U','S','A','N','A','B'],
['B','U','S','U','S','A','N','A'],
['C','S','P','E','R','R','O','S'],
['D','A','G','A','T','O','S','S'],
['E','N','P','A','P','A','P','A'],
['F','A','A','R','B','O','L','S'],
['L','M','P','I','N','T','A','S'],
['L','M','A','V','P','A','P','A']
]
print encontrar_en_filas(sopa, 'ARBOL')
 sopa = [ [[0, 1, 2], [0, 3, 2], [1, 2, 3], [1, 4, 3], [1, 2, 1]] None 
['A','S','U','S','A','N','A','B'],
['B','U','S','U','S','A','N','A'],
['C','S','P','E','R','R','O','S'],
['D','A','G','A','T','O','S','S'],
['E','N','P','A','P','A','P','A'],
['F','A','A','R','B','O','L','S'],
['L','M','P','I','N','T','A','S'],
['L','M','A','V','P','A','P','A']
]
print encontrar_en_filas(sopa, 'SU')
 sopa = [ [[6, 4, 3]] None 

['A','S','U','S','A','N','A','B'],
['B','U','S','U','S','A','N','A'],
['C','S','P','E','R','R','O','S'],
['D','A','G','A','T','O','S','S'],
['E','N','P','A','P','A','P','A'],
['F','A','A','R','B','O','L','S'],
['L','M','P','I','N','T','A','S'],
['L','M','A','V','P','A','P','A']
]
print encontrar_en_filas(sopa, 'NI')
 sopa = [ [] None 
['A','S','U','S','A','N','A','B'],
['B','U','S','U','S','A','N','A'],
['C','S','P','E','R','R','O','S'],
['D','A','G','A','T','O','S','S'],
['E','N','P','A','P','A','P','A'],
['F','A','A','R','B','O','L','S'],
['L','M','P','I','N','T','A','S'],
['L','M','A','V','P','A','P','A']
]
print encontrar_en_filas(sopa, 'SUSANO')
 #En este caso la matriz no es cuadrada [[4, 2, 5]] None 

sopa = [
['A','S','U','S','A','N'],
['B','U','S','U','S','A'],
['C','S','P','E','R','R'],
['D','A','G','A','T','O'],
['E','N','P','A','P','A'],
['F','A','A','R','B','O'],
['L','M','P','I','N','T'],
['L','M','A','V','P','A']
]
 #En este caso la matriz no es cuadrada [] None 

sopa = [
['A','S','U','S','A','N'],
['B','U','S','U','S','A'],
['C','S','P','E','R','R'],
['D','A','G','A','T','O'],
['E','N','P','A','P','A'],
['F','A','A','R','B','O'],
['L','M','P','I','N','T'],
['L','M','A','V','P','A']
]
print encontrar_en_filas(sopa, 'BALNEARIO')
 sopa = [ [[0, 0, 7], [7, 0, 7]] None 

['E','L','E','F','A','N','T','E'],
['B','U','S','U','S','A','N','A'],
['C','S','P','E','R','R','O','S'],
['D','A','G','A','T','O','S','S'],
['E','N','P','A','P','A','P','A'],
['F','A','A','R','B','O','L','S'],
['L','M','P','I','N','T','A','S'],
['E','L','E','F','A','N','T','E'],
]
print encontrar_en_filas(sopa, 'ELEFANTE')
 sopa = [ [[0, 7, 0], [7, 7, 0]] None 

['E','T','N','A','F','E','L','E'],
['B','U','S','U','S','A','N','A'],
['C','S','P','E','R','R','O','S'],
['D','A','G','A','T','O','S','S'],
['E','N','P','A','P','A','P','A'],
['F','A','A','R','B','O','L','S'],
['L','M','P','I','N','T','A','S'],
['E','T','N','A','F','E','L','E'],
]
 sopa = [ [[0, 0, 7], [7, 7, 0]] None 

['E','L','E','F','A','N','T','E'],
['B','U','S','U','S','A','N','A'],
['C','S','P','E','R','R','O','S'],
['D','A','G','A','T','O','S','S'],
['E','N','P','A','P','A','P','A'],
['F','A','A','R','B','O','L','S'],
['L','M','P','I','N','T','A','S'],
['E','T','N','A','F','E','L','E'],
]
También se han fallado algunas pruebas ocultas.

Mostrar diferencias
Pregunta 29
Puntúa como 1
El método Bífido es un cifrado fraccionario. Es decir que cada letra viene representada por una o más letras o símbolos. El método comienza
utiliza un alfabeto ordenado o desordenado en una matriz 5×5.
Por ej, para la clave de cifrado "qwerty" tendremos:
Aclaración : como la matriz es de 5x5 debemos unir los caracteres i y j en una sola posición. El contexto nos permitirá distinguir cual de las dos
letras se pretendía cifrar.
Las primeras posiciones son ocupadas por los valores de la clave y el resto se completan con las letras faltantes del alfabeto ingles (en orden
alfabético).
Para cifrar el texto en claro se escriben los equivalentes numéricos de cada letra, utilizando sus "coordenadas". Si por ejemplo el texto es:
informatica
El equivalente numérico será :
34 43 31 44 14 42 22 15 34 24 22
es decir la i está en la fila 3 columna 4 de la matriz , la n en la fila 4 columna 3 , y así sucesivamente.
El equivalente numérico se divide en dos de la siguiente forma:
34433144144
22215342422
y se combina nuevamente intercalando un dígito de la primer mitad con uno de la segunda:
32 42 42 31 35 13 44 42 14 42 42
volviendo a consultar la tabla resulta en el mensaje cifrado:
gmmfkeomrmm
Implemente una función cifrar (matriz,cadena) que reciba la matriz 5x5 (se probará con varias matrices para diferentes claves) y una cadena.
La función debe devolver la cadena con el mensaje cifrado. La cadena debe convertirse a minúsculas.
Por ejemplo:
Test Resultado
print cifrar(crear_matriz("qwerty"),"informatica") gmmfkeomrmm
Reiniciar respuesta
1 ▼ def cifrar (matriz,cadena):

2
3 return
Comprobar
 print cifrar(crear_matriz("qwerty"),"informatica") gmmfkeomrmm None 
 print cifrar(crear_matriz("asdfg"),"informatica") evktfqowqkk None 
 print cifrar(crear_matriz("cifra"),"python") qaxust None 
 print cifrar(crear_matriz("python"),"python") phpdye None 
 print cifrar(crear_matriz("python"),"enigma") gtcyfm None 
Mostrar diferencias
Pregunta 30
Puntúa como 1
Ejercicio Integrador
1. Implemente la función mostrar_matriz que recibe como parámetro una matriz y la muestra en forma matricial (una fila debajo de la otra)
escribiendo cada valor en 5 lugares.
2. Implemente la función máximo_matriz que recibe como parámetros una matriz de valores numéricos y debe retornar el valor mas grande
de la matriz.
3. Implemente una función extraer_columna que dada una matriz y un entero i, devuelva una lista con todos los valores de la columna i-
esima de la matriz.
4. Escriba una función, que no reciba parámetros, con nombre main que haga los siguientes pasos:
i) Le pida al usuario que ingrese dos valores enteros N y M.
ii) Cree una matriz de N filas y M columnas y solicite al usuario valores para cada posición de la matriz.
iii) Imprima el mensaje "La matriz ingresada es: " y luego invoque a la función mostrar_matriz para imprimir por pantalla la matriz
iv) Calcule el valor máximo de la matriz, llamando a la función maximo_matriz

v) Por último, por cada columna de la matriz informe si el valor máximo calculado en el punto 3-i) se encuentra o no en la
columna, tal cómo se muestra en los ejemplos de ejecución.
Por ejemplo:
main() 4 La matriz ingresada es:

2 1 2
1 3 1
2 1 2
3 2 2
1
1 El valor 3 es el maximo de la matriz y esta presente en la columna 0
2 El valor 3 es el maximo de la matriz y NO esta presente en la columna 1
2
2
Reiniciar respuesta
1 ▼ def mostrar_matriz(matriz):
2▼ for fila in matriz:
3▼ for valor in fila:
4 print("{:5}".format(valor), end="")
5 print()
6
7 ▼ def maximo_matriz(matriz):
8 max_valor = float('-inf')
9▼ for fila in matriz:
10 max_fila = max(fila)
11 ▼ if max_fila > max_valor:
12 max_valor = max_fila
13 return max_valor
14
15 ▼ def extraer_columna(matriz, i):
16 columna = []
18 columna.append(fila[i])
19 return columna
20
21 ▼ def main():
22 N = int(input("Ingrese el numero de filas: "))
23 M = int(input("Ingrese el numero de columnas: "))
24
25 matriz = []
26 ▼ for _ in range(N):
27 fila = []
28 ▼ for _ in range(M):
29 valor = float(input("Ingrese un valor para la matriz: "))
30 fila.append(valor)
31 matriz.append(fila)
32
3
33 print("La matriz ingresada es:")
34 mostrar_matriz(matriz)
35
36 max_valor = maximo_matriz(matriz)
37 print("El valor maximo de la matriz es:", max_valor)
38
39 ▼ for i in range(M):
40 columna = extraer_columna(matriz, i)
41 ▼ if max_valor in columna:
42 print("El valor maximo esta en la columna", i+1)
43 ▼ else:
44 print("El valor maximo no esta en la columna", i+1)
Comprobar
 main() 4 La matriz ingresada es: ***Error*** 

2 1 2 File "__tester__.python2", line 4
1 3 1 print("{:5}".format(valor),
2 1 2 end="")
3 2 2 ^
1 SyntaxError: invalid syntax
1 El valor 3 es el maximo de la matriz y esta presente en la
2 columna 0
2 El valor 3 es el maximo de la matriz y NO esta presente en la
2 columna 1
Prueba cancelada debido a un error.

Mostrar diferencias

Trabajo Práctico 5 (TP5)

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Trabajo Práctico 5 (TP5)

Cargado por

Copyright:

Formatos disponibles

1/6/23, 22:58 Trabajo práctico 5 (TP5)

Test Entrada Resultado

Respuesta: (sistema de penalización: 0 %)

Test Entrada Esperado Se obtuvo

Todas las pruebas superadas. 

Test Entrada Resultado

Respuesta: (sistema de penalización: 0 %)

Test Entrada Esperado Se obtuvo

Test Entrada Esperado Se obtuvo

 print -1 Ingrese un valor en el rango [0.0,100.0]: Ingrese un valor en el Ingrese un valor 

Test Entrada Esperado Se obtuvo

Test Entrada Esperado Se obtuvo

Test Entrada Esperado Se obtuvo

Test Entrada Esperado Se obtuvo

Test Entrada Esperado Se obtuvo

Test Entrada Esperado Se obtuvo

Test Entrada Resultado

Respuesta: (sistema de penalización: 0 %)

Test Entrada Esperado Se obtuvo

 print -1 Ingrese un entero positivo: Ingrese un Ingrese un entero positivo: Ingrese un 

 print 45 Ingrese un entero positivo: 45 Ingrese un entero positivo: 45 

Todas las pruebas superadas. 

print area_circunferencia(1.5) 7.06858347058

Respuesta: (sistema de penalización: 0 %)

1 from math import pi

Test Esperado Se obtuvo

 print area_circunferencia(1.5) 7.06858347058 7.06858347058 

 print area_circunferencia(2.5) 19.6349540849 19.6349540849 

 print area_circunferencia(3.0) 28.2743338823 28.2743338823 

Todas las pruebas superadas. 

print contar_palabras_cortas('mi cadena') 1

print contar_palabras_cortas('nuestra cadena') 0

print contar_palabras_cortas('uno 23') 2

Respuesta: (sistema de penalización: 0 %)

Test Esperado Se obtuvo

 print contar_palabras_cortas('mi cadena') 1 1 

 print contar_palabras_cortas('nuestra cadena') 0 0 

 print contar_palabras_cortas('uno 23') 2 2 

 print contar_palabras_cortas('prueba de ejercicio 123456') 1 1 

 print contar_palabras_cortas('informatica ingenieria') 0 0 

 print contar_palabras_cortas('casos de prueba generales 45678') 3 3 

Todas las pruebas superadas. 

print palabra_mas_repetida('si La la re mi do') la

print palabra_mas_repetida('si re la La RE MI do') re

print palabra_mas_repetida('1 11 la 4 5 6 11 3 11') 11

Respuesta: (sistema de penalización: 0 %)

1 from collections import Counter

Test Esperado Se obtuvo

 print palabra_mas_repetida('si La la re mi do') la la 

 print palabra_mas_repetida('si re la La RE MI do') re re 

 print palabra_mas_repetida('si re la La MI do DO Do') do do 

 print palabra_mas_repetida('mi si MI do Do') mi mi 

 print palabra_mas_repetida('No No Si Nop si Nop Nop') nop nop 

 print palabra_mas_repetida('1 11 la 4 5 6 11 3 11') 11 11 

 print palabra_mas_repetida('1 hola 123 4 5 6 hola 3 hola') hola hola 

Todas las pruebas superadas. 

Longitud mínima de seis (6) caracteres

print verificar_clave('MiClave2016') True

print verificar_clave('MiClaveSegura2016') False

print verificar_clave('miclave2016') False

print verificar_clave('MICLAVE2016') False

print verificar_clave('MiClave16') False

print verificar_clave('mica') False