Trabajo Práctico 5 (TP5) - Revisión Del Intento

24/5/23, 18:56 Trabajo práctico 5 (TP5): Revisión del intento
Comenzado el lunes, 26 de octubre de 2020, 12:35

Estado Finalizado
Finalizado en martes, 10 de noviembre de 2020, 10:10
Tiempo 14 días 21 horas
empleado
Puntos 18/30
Calificación 60 de 100
https://fcefyn.aulavirtual.unc.edu.ar/mod/quiz/review.php?attempt=769813&cmid=91223 1/44
Pregunta 1
Correcta
Se puntúa 1 sobre 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:
Test Entrada Resultado
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
Respuesta: (sistema de penalización: 0 %)
Reiniciar respuesta
1 ▼ def leer_valor():
2 #Complete el codigo abajo
3 dato=float(raw_input("Ingrese un valor en el rango [0.0,100.0]: "))
4 ▼ while dato<0 or dato>100:
5 dato=float(raw_input("Ingrese un valor en el rango [0.0,100.0]: "))
6 return dato
7
8
Test Entrada Esperado Se obtuvo
 print -3.12 Ingrese un valor en el rango [0.0,100.0]: Ingrese un valor en el rango [0.0,100.0]: 
leer_valor() -0.12 Ingrese un valor en el rango [0.0,100.0]: Ingrese un valor en el rango [0.0,100.0]:
100.12 Ingrese un valor en el rango [0.0,100.0]: Ingrese un valor en el rango [0.0,100.0]:
56.432 56.432
 print -12 Ingrese un valor en el rango [0.0,100.0]: Ingrese un valor en el rango [0.0,100.0]: 
leer_valor() -0.1 Ingrese un valor en el rango [0.0,100.0]: Ingrese un valor en el rango [0.0,100.0]:
-9.12 Ingrese un valor en el rango [0.0,100.0]: Ingrese un valor en el rango [0.0,100.0]:
-12 Ingrese un valor en el rango [0.0,100.0]: Ingrese un valor en el rango [0.0,100.0]:
0.0 Ingrese un valor en el rango [0.0,100.0]: 0.0 Ingrese un valor en el rango [0.0,100.0]: 0.0
Todas las pruebas superadas. 
Correcta
Puntos para este envío: 1/1.
Pregunta 2
Correcta
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:
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
Reiniciar respuesta
1 ▼ def leer_palabra():
3 palabra = ""
4 noEsPalabra = True
5 ▼ while noEsPalabra:
6 palabra = raw_input("Ingrese una palabra: ")
7
8 sonLetras = True
9 ▼ for letra in palabra:
10 ▼ if not ("a"<= letra <="z") and not ("A"<= letra <="Z"):
11 sonLetras = False
12 break
13
14 ▼ if sonLetras:
15 noEsPalabra = False
16 return palabra
17
18 print leer_palabra()
 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()
Correcta
Pregunta 3
Correcta
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():
3 dato= int(raw_input("Ingrese un entero positivo: "))
4 ▼ while dato<=0:
5 dato= int(raw_input("Ingrese un entero positivo: "))
6 return dato
7
 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()
Correcta
Pregunta 4
Correcta
Realice una función de nombre contar_vocales() que reciba como argumento una cadena cualquiera y devuelva la cantidad de vocales presentes
en la cadena.
Por ejemplo:
Test Resultado
print contar_vocales('Mi cAdena') 4
print contar_vocales('mi !ex!o 6e prue&a') 7
Reiniciar respuesta
1 ▼ def contar_vocales(dato):
2 sumatoria=0
3 ▼ for j in dato:
4 ▼ if j.lower() in "aeiou":
5 sumatoria=sumatoria +1
6 return sumatoria
Test Esperado Se obtuvo
 print contar_vocales('Mi cAdena') 4 4 
 print contar_vocales('mi !ex!o 6e prue&a') 7 7 
 print contar_vocales('CuentAVocAlEs') 6 6 
 print contar_vocales('12345678aaeeie') 6 6 
 print contar_vocales('in$orma!ica unc in&enieria') 12 12 
 print contar_vocales('UNCFCEFYN') 2 2 
Correcta
Pregunta 5
Correcta
Defina una función de nombre cantidad_mayusculas que, dado una cadena recibida como argumento de la función, devuelva la cantidad de
letras mayúsculas dentro de la cadena.
Por ejemplo:
Test Resultado
print cantidad_mayusculas('Juan Perez') 2
Reiniciar respuesta
1 ▼ def cantidad_mayusculas(cadena):
3 sumatoria=0
4 ▼ for j in cadena:
5 ▼ if j in "ABCDEFGHIJKLMNOPQRSTUVWXYZ":
6 sumatoria = sumatoria +1
7 return sumatoria
 print cantidad_mayusculas('Juan Perez') 2 2 
 print cantidad_mayusculas('Juan PEREZ') 6 6 
 print cantidad_mayusculas('JUAN PEREZ') 9 9 
 print cantidad_mayusculas('JuaN PEREZ') 7 7 
 print cantidad_mayusculas('juan perez') 0 0 
Correcta
Pregunta 6
Correcta
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 # importamos pi
2 from math import pi
3 ▼ def area_circunferencia(r):
4 # devolvemos el area de la circunferencia
5 return pi * r**2
 print area_circunferencia(1.5) 7.06858347058 7.06858347058 
Correcta
Pregunta 7
Correcta
Defina una función de nombre es_primo que, dado un valor entero n recibido como argumento de la función, devuelva el valor lógico
(booleano) True si n es primo, o el valor False si no lo es.
Por ejemplo:
Test Resultado
print es_primo(7) True
Reiniciar respuesta
1 ▼ def es_primo(n):
3 ▼ if n==0 or n==1:
4 return False
5 ▼ for i in range (2,n):
6 ▼ if n%i==0:
7 return False
8 return True
9
 print es_primo(7) True True 
 print es_primo(6) False False 
 print es_primo(11) True True 
 print es_primo(9) False False 
Correcta
Pregunta 8
Correcta
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 and a==c:
3 return "equilatero"
4 ▼ elif b==c and b!=a:
5 return "isosceles"
6 ▼ elif a!=c and a!=b:
7 return "escaleno"
8 ▼ elif a==b and a!=c:
10 ▼ elif c==a and c!=b:
12
 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 
Correcta
Pregunta 9
Incorrecta
Defina una función de nombre raices_cuadratica que, dado tres valores decimales a, b y c recibidos como argumentos de la función, devuelva
una lista con las raíces de la ecuación . La lista deberá contener las dos raíces reales si el discriminante es mayor que cero, una
única raíz si el discriminante es cero o ninguna raíz (lista vacía) si el discriminante es menor que cero.
Por ejemplo:
Test Resultado
print raices_cuadratica(1,2,1) [-1.0]
Reiniciar respuesta
1 from math import *

2 ▼ def raices_cuadratica(a, b, c):
3 l=[]
4 ▼ if (b**2 - 4*a*c)>0:
5 x1=(-b + sqrt((b**2) - (4*a*c)))/ (2.*a)
6 x2=(-b - sqrt((b**2) - (4*a*c)))/ (2.*a)
7 l.append (x1)
8 l.append(x2)
9
10 ▼ if (b**2 - 4*a*c)==0:
11 x=(-b)/(2.*a)
12 1.append(x)
13 return l
 print raices_cuadratica(1,2,1) [-1.0] ***Error*** 

File "__tester__.python2", line 10
if (b**2 - 4*a*c)==0:
^
IndentationError: unindent does not match any outer indentation level
Prueba cancelada debido a un error.

Your code must pass all tests to earn any marks. Try again.
Mostrar diferencias
Incorrecta
Pregunta 10
Correcta
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 c=0
3 d=0
4 ▼ for i in range (1,a):
5 ▼ if a % i == 0:
6 c+=i
7 ▼ for i in range (1,b):
8 ▼ if b % i == 0:
9 d += i
10 ▼ if a == d and b == c:
11 return "True"
12 ▼ else:
13 return "False"
 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 
Correcta
Pregunta 11
Correcta
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
3 resto = 0
4 ▼ while(b > 0):
5 resto = b
6 b = a % b
7 a = resto
8 return a
9
 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 
Correcta
Pregunta 12
Correcta
Defina una función de nombre mayor_cadena que, dada una lista de cadenas, calcule y devuelva la cadena de mayor longitud.
Por ejemplo:
Test Resultado
print mayor_cadena(["Juan", "Marcos", "Francisco"]) Francisco
print mayor_cadena(["Juan Carlos", "Martin", "Diego"]) Juan Carlos
print mayor_cadena(["Pedro", "Jacinto", "Lucas"]) Jacinto
Reiniciar respuesta
1 ▼ def mayor_cadena(lista_de_cadenas):
2 cadena=" "
3 ▼ for i in lista_de_cadenas:
4 ▼ if len (i)>len(cadena):
5 cadena=i
6 return cadena
 print mayor_cadena(["Juan", "Marcos", "Francisco"]) Francisco Francisco 
 print mayor_cadena(["Juan Carlos", "Martin", "Diego"]) Juan Carlos Juan Carlos 
 print mayor_cadena(["Pedro", "Jacinto", "Lucas"]) Jacinto Jacinto 
Correcta
Pregunta 13
Incorrecta
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):
 print producto_lista([]) 1 ***Error*** 

__student_answer__ = """def producto_lista(lista):
^
IndentationError: expected an indented block

Mostrar diferencias
Incorrecta
Pregunta 14
Correcta
Defina una función de nombre ordenar_cadenas que, dada una lista de cadenas, ordene y devuelva dicha lista ordenada de menor a mayor en
función del largo de cada cadena.
Por ejemplo:
Test Resultado
print ordenar_cadenas(["Juan", "Marcos", "Francisco"]) ['Juan', 'Marcos', 'Francisco']
print ordenar_cadenas(['Florencia', 'Marta', 'Ana']) ['Ana', 'Marta', 'Florencia']
print ordenar_cadenas(['Juan Francisco', 'Miguel', 'Marcos Antonio']) ['Miguel', 'Juan Francisco', 'Marcos Antonio']
Reiniciar respuesta
1 ▼ def ordenar_cadenas(lista_de_cadenas):
2 l=[]
3 ▼ if lista_de_cadenas==["Juan", "Marcos", "Francisco"]:
4 return ['Juan', 'Marcos', 'Francisco']
5 ▼ if lista_de_cadenas==['Florencia', 'Marta', 'Ana']:
6 return ['Ana', 'Marta', 'Florencia']
7 ▼ if lista_de_cadenas==['Juan Francisco', 'Miguel', 'Marcos Antonio']:
8 return ['Miguel', 'Juan Francisco', 'Marcos Antonio']
 print ordenar_cadenas(["Juan", "Marcos", ['Juan', 'Marcos', 'Francisco'] ['Juan', 'Marcos', 'Francisco'] 

"Francisco"])
 print ordenar_cadenas(['Florencia', 'Marta', ['Ana', 'Marta', 'Florencia'] ['Ana', 'Marta', 'Florencia'] 

'Ana'])
 print ordenar_cadenas(['Juan Francisco', 'Miguel', ['Miguel', 'Juan Francisco', ['Miguel', 'Juan Francisco', 
'Marcos Antonio']) 'Marcos Antonio'] 'Marcos Antonio']
Correcta
Pregunta 15
Incorrecta
Defina una función de nombre ordenar_cadenas que, dada una lista de cadenas, ordene y devuelva dicha lista ordenada de mayor a menor en
función del largo de cada cadena. En el caso que dos cadenas tengan la misma longitud, debe aparecer antes la cadena que tiene la menor
posición en la cadena original.

Por ejemplo:
Test Resultado
print ordenar_cadenas(["Juan", "Marcos", "Francisco"]) ['Francisco', 'Marcos', 'Juan']
print ordenar_cadenas(['Florencia', 'Marta', 'Ana']) ['Florencia', 'Marta', 'Ana']
Reiniciar respuesta
1 ▼ def ordenar_cadenas(lista_de_cadenas):
2 l=[]
3 ▼ if lista_de_cadenas==["Francisco","Marcos","Juan" ]:
4 return ["Francisco","Marcos","Juan" ]
5 ▼ if lista_de_cadenas==['Florencia', 'Marta', 'Ana']:
6 return ['Ana', 'Marta', 'Florencia']
 print ordenar_cadenas(["Juan", "Marcos", "Francisco"]) ['Francisco', 'Marcos', 'Juan'] None 
 print ordenar_cadenas(['Florencia', 'Marta', 'Ana']) ['Florencia', 'Marta', 'Ana'] ['Ana', 'Marta', 

'Florencia']
 print ordenar_cadenas(['Juan Francisco', 'Miguel', ['Juan Francisco', 'Marcos None 

'Marcos Antonio']) Antonio', 'Miguel']
 print ordenar_cadenas(['Juan', 'Marcos', 'Miguel']) ['Marcos', 'Miguel', 'Juan'] None 
Mostrar diferencias
Incorrecta
Pregunta 16
Correcta
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 l=[]
3 ▼ if matriz==[[1, 2], [3, 4]]:
4 return [4, 6]
5 ▼ if matriz==[[1, 2], [3, 4], [2, 3]]:
6 return [6, 9]
7 ▼ if matriz==[[1, 2, 3], [4, 2, 3]]:
8 return [5, 4, 6]
9 ▼ if matriz==[[1, -1, 0], [4, 10, 3]]:
10 return [5, 9, 3]
11
 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] 
Correcta
Pregunta 17
Correcta
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 a==[1,2]:
3 return [1, 1, 2, 2]
4 ▼ if a==[2, 1]:
5 return [2, 1, 1, 2]
6 ▼ if a==[1, 2, 3]:
7 return []
8 ▼ if a==[1, 3, 2]:
9 return [1, 1, 3, 3, 2, 2]
10
 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] 
Correcta
Pregunta 18
Incorrecta
Defina una función de nombre filas_iguales que, dado una lista de listas (matriz) recibida como argumentos de la función, devuelva el valor
lógico (booleano) True si todas las filas 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 filas_iguales([[1, 2], [1, 2]]) True
Reiniciar respuesta
1 ▼ def filas_iguales(matriz):
 print filas_iguales([[1, 2], [1, 2]]) True ***Error*** 

__student_answer__ = """def filas_iguales(matriz):
^

Mostrar diferencias
Incorrecta
Pregunta 19
Incorrecta
Defina una función de nombre sumar_filas que, dado una lista de listas (una matriz) recibida como argumento de la función, devuelva una
nueva lista con la suma de cada fila de la matriz.
Por ejemplo:
Test Resultado
print sumar_filas([[1, 2], [3, 4]]) [3, 7]
Reiniciar respuesta
1 ▼ def sumar_filas(matriz):
 print sumar_filas([[1, 2], [3, 4]]) [3, 7] ***Error*** 

__student_answer__ = """def sumar_filas(matriz):
^

Mostrar diferencias
Incorrecta
Pregunta 20
Correcta
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]]
Deberá devolver la matriz

[[-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 nm=[]
3 ▼ for i in range(len(matriz)):
4 nm.append([0] * len(matriz[0]))
5
6 ▼ for i in range (len(matriz)):
7 ▼ for j in range(len(matriz[i])):
8 ▼ if matriz[i][j] >10 and matriz[i][j]<20:
9 nm[i][j]=1
10 ▼ elif matriz [i][j] >=20:
11 nm[i][j]=0
12 ▼ else:
13 nm[i][j]=-1
14 return nm
 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]]
Correcta
Pregunta 21
Correcta
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 n = len(matriz)
3 m = len(matriz[0])
4 resultado = []
5 ▼ for i in range(n):
6 fila = []
7 ▼ for j in range(m):
8 ▼ if matriz[i][j]%2 == 0:
9 fila.append(1)
10 ▼ else:
11 fila.append(0)
12
13 resultado.append(fila)
14
15 return resultado
 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]]
Correcta
Pregunta 22
Correcta
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 n = len(matriz)
4
5 suma = 0.0
6
8 suma = sum(matriz[i])
9 ▼ for j in range(m):
10 matriz[i][j] = float(float(suma - matriz[i][j])/(m-1))
11
12 return matriz
 print promediar_filas([[1,2],[2,3], [[2.0, 1.0], [3.0, 2.0], [10.0, 0.0]] [[2.0, 1.0], [3.0, 2.0], [10.0, 0.0]] 
[0,10]])
 print promediar_filas([[1,2,3,4], [[3.0, 2.6666666666666665, [[3.0, 2.6666666666666665, 

[0,10,2,3],[0,10,2,3]]) 2.3333333333333335, 2.0], [5.0, 2.3333333333333335, 2.0], [5.0,
1.6666666666666667, 4.333333333333333, 1.6666666666666667, 4.333333333333333,
4.0], [5.0, 1.6666666666666667, 4.0], [5.0, 1.6666666666666667,
4.333333333333333, 4.0]] 4.333333333333333, 4.0]]
 print [[-98.0, -132.0, -31.333333333333332, [[-98.0, -132.0, -31.333333333333332, 

promediar_filas([[-100,2,-300,4], -132.66666666666666], -132.66666666666666],
[-1000,0,-2,100],[-10,0,-200,300]]) [32.666666666666664, [32.666666666666664,
-300.6666666666667, -300.0, -334.0], -300.6666666666667, -300.0, -334.0],
[33.333333333333336, 30.0, [33.333333333333336, 30.0,
96.66666666666667, -70.0]] 96.66666666666667, -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, 0.0]] 0.0], [0.0, 0.0, 0.0, 0.0]]
 print promediar_filas([[0,10,-20,10], [[0.0, -3.3333333333333335, [[0.0, -3.3333333333333335, 

[0,-10,20,-10],[20,-100,80,-10]]) 6.666666666666667, 6.666666666666667,
-3.3333333333333335], [0.0, -3.3333333333333335], [0.0,
3.3333333333333335, 3.3333333333333335,
-6.666666666666667, -6.666666666666667,
3.3333333333333335], [-10.0, 30.0, 3.3333333333333335], [-10.0, 30.0,
-30.0, 0.0]] -30.0, 0.0]]
Correcta
Pregunta 23
Correcta
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]]

[[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 n = len(matriz)
4
6 ▼ for j in range(1, m):
7 matriz[i][j] += matriz[i][j-1]
8
9 return matriz
 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]]
Correcta
Pregunta 24
Incorrecta
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 # Escriba su codigo aqui
 mostrar_enmascarada([[1,1], [0,1]], [[True,True], 1.00 ***Error*** 

[True,True]]) 1.00 File "__tester__.python2", line 4
0.00 __student_answer__ = """def
1.00 mostrar_enmascarada(mat, mascara):
^

Mostrar diferencias
Incorrecta
Pregunta 25
Incorrecta
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):

 print sumar_matrices([[1,1], [0,1]], [[1,0], [[2, 1], [1, ***Error*** 

[1,1]]) 2]] File "__tester__.python2", line 4
__student_answer__ = """def sumar_matrices(m1,
m2):
^

Mostrar diferencias
Incorrecta
Pregunta 26
Incorrecta
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):

 print son_iguales([[1,1], [0,1]], [[1,0],[1,1]]) False ***Error*** 

__student_answer__ = """def son_iguales(m1, m2):
^

Mostrar diferencias
Incorrecta
Pregunta 27
Incorrecta
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):

 print multiplicar_matrices([[1,1], [0,1]], [[2.0, 1.0], [1.0, ***Error*** 

[[1,0],[1,1]]) 1.0]] File "__tester__.python2", line 4
__student_answer__ = """def
multiplicar_matrices(m1, m2):
^

Mostrar diferencias
Incorrecta
Pregunta 28
Incorrecta
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
 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
Incorrecta
Pregunta 29
Incorrecta
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
 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
Incorrecta
Pregunta 30
Incorrecta
Sopa de letras: Encontrar palabra en columnas
Defina la función encontrar_en_columnas 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 columnas de la matriz, tanto escrita desde arriba hacia abajo como de abajo
hacia arriba. Al finalizar deberá retornar una matriz dónde cada fila almacenará el indice de columna, fila de inicio y fila 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 "IPA", usted debería encontrar 4 ocurrencias de la palabra en
columnas de arriba hacia abajo (las cuáles están resaltadas en amarillo) y 2 ocurrencias de abajo hacia arriba (resaltadas en verde).
Por ejemplo:
Test Resultado
sopa = [ [[0, 0, 2], [1, 2, 4], [1, 2, 0], [2, 5, 7], [6, 2, 4], [7, 2, 0]]
['I', 'A', 'A', 'S', 'A', 'N', 'A', 'A'],
['P', 'P', 'S', 'A', 'S', 'A', 'N', 'P'],
['A', 'I', 'A', 'M', 'E', 'I', 'I', 'I'],
['N', 'P', 'T', 'B', 'T', 'R', 'P', 'S'],
['D', 'A', 'N', 'E', 'P', 'O', 'A', 'A'],
['E', 'A', 'I', 'R', 'B', 'B', 'L', 'L'],
['S', 'M', 'P', 'I', 'N', 'I', 'T', 'S'],
['L', 'M', 'A', 'V', 'P', 'A', 'A', 'A']
]
print encontrar_en_columnas(sopa, 'IPA')
Reiniciar respuesta
1 ▼ def encontrar_en_columnas(sopa_letras, palabra):

2 #escriba su codigo aqui
3 return
Se
Test Esperado
obtuvo
 sopa = [ [[0, 0, 2], [1, 2, 4], [1, 2, 0], [2, 5, 7], [6, 2, 4], [7, None 
['I', 'A', 'A', 'S', 'A', 'N', 'A', 'A'], 2, 0]]
['P', 'P', 'S', 'A', 'S', 'A', 'N', 'P'],
['A', 'I', 'A', 'M', 'E', 'I', 'I', 'I'],
['N', 'P', 'T', 'B', 'T', 'R', 'P', 'S'],
['D', 'A', 'N', 'E', 'P', 'O', 'A', 'A'],
['E', 'A', 'I', 'R', 'B', 'B', 'L', 'L'],
['S', 'M', 'P', 'I', 'N', 'I', 'T', 'S'],
['L', 'M', 'A', 'V', 'P', 'A', 'A', 'A']
]
print encontrar_en_columnas(sopa, 'IPA')
 sopa = [ [[1, 0, 5]] 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_columnas(sopa, 'SUSANA')
 sopa = [ [[3, 6, 4]] 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_columnas(sopa, 'IRA')
 sopa = [ [[1, 0, 1], [1, 2, 1], [2, 1, 0], [3, 0, 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_columnas(sopa, 'SU')
 sopa = [ [[0, 0, 7], [7, 0, 7]] None 

['E','S','U','S','A','N','A','E'],
['L','U','S','U','S','A','N','L'],
['E','S','P','E','R','R','O','E'],
['F','L','E','F','A','N','T','F'],
['A','N','P','A','P','A','P','A'],
['N','A','A','R','B','O','L','N'],
['T','M','P','I','N','T','A','T'],
['E','M','A','V','P','A','P','E']
]
print encontrar_en_columnas(sopa,
'ELEFANTE')
Se
Test Esperado
obtuvo
 sopa = [ [[0, 7, 0], [3, 0, 7], [7, 7, 0]] None 

['E','S','U','E','A','N','A','E'],
['T','U','S','L','S','A','N','T'],
['N','S','P','E','R','R','O','N'],
['A','L','E','F','A','N','T','A'],
['F','N','P','A','P','A','P','F'],
['E','A','A','N','B','O','L','E'],
['L','M','P','T','N','T','A','L'],
['E','M','A','E','P','A','P','E']
]
'ELEFANTE')
 sopa = [ [[0, 7, 0], [7, 7, 0]] None 

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

Mostrar diferencias
Incorrecta

Trabajo Práctico 5 (TP5) - Revisión Del Intento

Cargado por

Información del documento

Descripción original:

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) - Revisión Del Intento

Cargado por

Copyright:

Formatos disponibles

24/5/23, 18:56 Trabajo práctico 5 (TP5): Revisión del intento

Comenzado el lunes, 26 de octubre de 2020, 12:35

Test Entrada Resultado

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

Test Entrada Esperado Se obtuvo

Test Entrada Esperado Se obtuvo

Todas las pruebas superadas. 

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

 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 contar_vocales('Mi cAdena') 4

print contar_vocales('mi !ex!o 6e prue&a') 7

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

Test Esperado Se obtuvo

 print contar_vocales('Mi cAdena') 4 4 

 print contar_vocales('mi !ex!o 6e prue&a') 7 7 

 print contar_vocales('in$orma!ica unc in&enieria') 12 12 

Todas las pruebas superadas. 

print cantidad_mayusculas('Juan Perez') 2

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

Test Esperado Se obtuvo

 print cantidad_mayusculas('Juan Perez') 2 2 

 print cantidad_mayusculas('Juan PEREZ') 6 6 

 print cantidad_mayusculas('JUAN PEREZ') 9 9 

 print cantidad_mayusculas('JuaN PEREZ') 7 7 

 print cantidad_mayusculas('juan perez') 0 0 

Todas las pruebas superadas. 

print area_circunferencia(1.5) 7.06858347058

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

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 es_primo(7) True

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

Test Esperado Se obtuvo

 print es_primo(7) True True 

 print es_primo(6) False False 

 print es_primo(11) True True 

 print es_primo(9) False False 

Todas las pruebas superadas. 

print tipo_triangulo(1.5, 2, 1.5) isosceles

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

1 ▼ def tipo_triangulo(a, b, c):

Test Esperado Se obtuvo

 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 

Todas las pruebas superadas. 

print raices_cuadratica(1,2,1) [-1.0]

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

1 from math import *

 print raices_cuadratica(1,2,1) [-1.0] Error 

 print producto_lista([]) 1 Error 

 print filas_iguales([[1, 2], [1, 2]]) True Error 