Guia Ejercicios PDF

Universidad de Santiago de Chile
Facultad de Ingeniería
Fundamentos de Computación y Programación
Autores: Cristóbal Acosta J. – Felipe Fuentes B.
Ejercicios Resueltos
Preparación PEP 1
Introducción
Esta guía posee ejercicios enunciados en clases, pero su solución no es necesariamente

la que debían responder en ese momento, sino que son soluciones más avanzadas con la
materia vista hasta la clase N°11, donde se ve la consolidación de iteración y recursión.
Para la solución de los problemas se hace lo siguiente:
● Se analiza cómo se puede resolver el problema.

● Se da la solución.
● Se genera una traza de la solución propuesta para cuando hay iteraciones o
recursividad.
También posee problemas planteados durante el semestre pasado, pero esta vez
resueltos en Python.
Esta guía fue desarrollada y revisada por los profesores Cristóbal Acosta y Felipe
Fuentes.
Observación:
Los ejercicios no representan a la respuestas solicitadas en las guías, sino que son la
solución de la parte de programación de algunos ejercicios.
1
Pregunta 1
Enunciado
Escriba la secuencia de instrucciones para calcular el promedio y la desviación estándar
de las edades, en meses, de los integrantes del grupo. Haga que al final se despliegue el
mensaje “La edad promedio del grupo es P mas/menos SD meses” (no use tildes, porque
Python podría reclamar).
Recuerde que el promedio se calcula con la fórmula:
Y la desviación estándar como:
∑ ( )
√
Donde ei son las edades de los miembros del grupo y N es el número de integrantes del
grupo.
Solución
Análisis
Lo primero que debemos hacer es ver qué cosas son resultados de funciones o son
elementos que el usuario y/o programador deben realizar. Entonces, ¿Qué cosas debe
definir el usuario, y que cosas es(son) resultado(s) de la(s) función (es)?
R: Los resultados de funciones son el promedio y la desviación estándar, todo lo

demás es ingresado por el usuario
Luego de haber respondido la pregunta anterior, nos preguntamos, ¿Qué valores serán
distintos para cada grupo?
R: Si nos fijamos bien, cada grupo va a tener de forma independiente la cantidad

de integrantes (N) y sus edades (ei), pero la cantidad de integrantes la definiremos
como una constante, pensando en que nuestro programa servirá siempre para
nuestro mismo grupo y lo utilizaremos en un futuro.
2
Entonces, ya tenemos que la constante global de nuestro problema será N, nuestras
funciones deberán calcular el Promedio y la Desviación Estándar, y que nuestras edades
serán variables.
Para la función que calcule el promedio tenemos:
● Entrada: Las edades de los integrantes (ei), estás deberán estar en meses.
● Salida: Un número entero o real1 que sea el promedio de las edades.
● Lógica: Sumo los números ingresados en los parámetros formales de mi función y
lo divido por mi constante N.
Para la función que calcule la desviación estándar tenemos:
● Entrada: Las edades de los integrantes (ei), estás deberán estar en meses.
● Salida: Un número entero o real que sea la desviación estándar de las edades.
● Lógica: Calculo la raíz cuadrada de la suma el cuadrado la diferencia entre los
números ingresados en los parámetros formales de mi función y el promedio entre
ellos y ese resultado lo divido por mi constante N.
Programa
####################################################
##
## Curso: Fundamentos de Computacion y Programacion
## Guia: Ejercicios resueltos para la PEP 1
## Semestre: 1-2013
## Autor: Felipe Fuentes - Cristobal Acosta
##
## Problema: Problema 1
## Objetivo: Calcular y retornar el promedio y
## desviacionestandar de las edades.
####################################################
####################################################
## Declaracion de constantes
####################################################
## Las constantes que se enuentran para nuestro programa son:

## N: Corresponde a la cantidad de alumnos en el grupo
## Por defecto valerá 4
N = 4
####################################################
## Declaracion de funciones
####################################################
1
Se habla de número real ya que es en teoría, pero debemos tener en claro que para
programación será un número de punto flotante. En programación solo se aproximan a números
reales.
3
## Funciones necesarias para nuestro problema:

## sqrt: Calcula la raíz cuadrada de un número
from math import sqrt
## Funciones Promedio
## Entrada: Tres números enteros
## Salida: Número flotante
## Lógica: Sumo los numeros, divido por N y retornamos
def promedio(e1, e2, e3, e4):
suma = float(e1+e2+e3+e4)
valorPromedio = suma/N
return valorPromedio
## Funciones Desviación Estándar

## Entrada: Tres números enteros
## Salida: Número flotante
## Lógica: Calculo el promedio, calculo 4 valores, los cuales serán
## iguales al cuadrado de la resta entre el valor y el promedio.
def desviacionEstandar(e1,e2,e3,e4):
prom=(e1+e2+e3+e4)/N
valor1=(e1-promedio)**2
#Sumo los valores obtenidos y divido por N
valorFinal=(valor1+valor2+valor3+valor4)/N
desvEstandar= sqrt(valorFinal)
return desvEstandar
####################################################
## Declaracion de Cuerpo principal
####################################################
## Solicito las edades en meses

valor1=input ("Ingrese edad 1 (en meses):")
## Calculo el resultado de la funcion

promedio = promedio(valor1, valor2, valor3, valor4)
desEstandar = desviacionEstandar(valor1, valor2, valor3, valor4)
## Muestro el resultado del calculo de la funcion
print "El promedio de las edades es: ", promedio, "y la DS es:
",desEstandar
4
Pregunta 2
Enunciado
Declare un par de variables x e y con valores 1 y 2 respectivamente. Luego utilice

funciones trigonométricas del módulo math para obtener el resultado de la siguiente
fórmula:
( ( ) ( ) ( )) ( ( ) ( ) ( ))
Además del resultado, anote todo el código requerido para obtener el resultado,
incluyendo los módulos importados.
Solución
Programa
####################################################
##
## Semestre: 1-2013
##
## Objetivo:
####################################################
####################################################
## Declaración de constantes
####################################################
####################################################
## Declaración de funciones
####################################################
## Importo las librerias necesarias

## Sen(x); Cos (x) y Tan(x)
from math import sin, cos, tan
####################################################
## Declaración de Cuerpo principal
####################################################
## Declaro las variables x e y con valores 1 y 2 respectivamente
5
x = 1
y = 2
## Calculo el resultado de la funcion

resultado = (sin (x) - cos (x) / tan (x))**2 - (sin (y) - cos (y) / tan
(y))**2
## Muuestro el resultado del calculo de la funcion
print "El resultado de la funcion es: ", resultado
6
Problema 3
Enunciado
Escriba una función que calcule la fórmula g( ) completa para un cierto valor de x y que
utilice la función calculaExponente().
( ) ( ) ( )
( )
Función calculaExponente()
def calculaExponente(x):
valorExponente = 2 * (x - 1) ** 2
return valorExponente
Solución
Programa
####################################################
##
## Semestre: 1-2013
##
## Objetivo: Calcular el valor de la funcion
## utilizando calculaExponente
####################################################
####################################################
####################################################
####################################################
####################################################
## Funcion: calculaExponente
## Entrada: numero entero x
## Logica: Calcula el valor que toma el exponente de la funcion (1)
## El exponente esta evaluado segun la formula
## 2(x-1)^2
## Salida: Valor del exponente dependiendo del valor de x
def calculaExponente(x):
valorExponente = 2 * (x - 1) ** 2
return valorExponente
7
## Funcion: funcion1
## Logica: Calcula el valor de la funcion 1 evaluada con x, la
funcion 1 es:
## 2^(2(x-1)^2) + 3^(2(x-1)^2) + 4^(2(x-1)^2)
## Existen tres valores a sumar
## Salida: Valor de la funcion 1 evaluada con x. Esto sera igual a
la suma de los tres valores
def funcion1(x):
valorExponente = calculaExponente (x)
resultado = 2**valorExponente + 3**valorExponente + 4**valorExponente
return resultado
####################################################
## Cuerpo principal
####################################################
## Llamo a la funcion y la evaluo con valores 1, 2 y 3

resultado1 = funcion1(1)
## Muestro los resultados obtenidos
print "El resultado para x=1 es:",resultado1
8
Problema 4
Enunciado
Escriba una función que defina una variable local con el mismo nombre que una variable
global, pero que utilice la variable global en la primera sentencia de su cuerpo. ¿Qué le
parece al intérprete de Python al intentar ejecutarla?
Solución
Programa
####################################################
##
## Semestre: 1-2013
##
## Objetivo:
####################################################
####################################################
####################################################
## Declaro mi variable global y de doy un valor aleatorio

VARIABLE_GLOBAL = 5
####################################################
####################################################
## Logica: En la primera sentencia de mi funcion utilizo la
## variable global
## En la segunda sentencia declaro una variable local
## con el mismo nombre de la variable global
## Salida: retorno el numero x que me entregaron como parametro
formal
def funcion1(x):
variableLocal = VARIABLE_GLOBAL + x
VARIABLE_GLOBAL = x * 2
return x
####################################################
## Cuerpo principal
9
####################################################
## Llamo a la funcion y la evaluo con valor 1

## Muestro el resultado obtenido

Respuesta código
El código cuando se ejecute debe lanzar un error, ya que se llama a la función1 y en la

primera línea de ésta se utiliza la variable global, pero en la línea siguiente Python genera
una nueva variable, ahora de forma local, con el mismo nombre que poseía la variable
global, por lo que el compilador se confunde y piensa que la variable local era la que se
estaba utilizando en la primera línea de la función, por lo que nos dirá que estamos
utilizando una variable y la declaramos después.
10
Problema 5
Enunciado
Escriba las sentencias necesarias para evaluar la fórmula ( ):
( ) ( ) ( ) ( ) ( ) ( )
( ) ( )
Solución
Análisis
Para calcular el exponente podemos utilizar una misma función, ya que lo único que varía
es el parámetro de entrada de la función.
Programa
####################################################
##
## Semestre: 1-2013
##
## Objetivo:
####################################################
####################################################
####################################################
####################################################
####################################################
##Importo las funciones necesarias desde la biblioteca math
from math import sin, tan
## Funcion: Exponente
## Entrada: Numero entero a
## Logica: Evalua la funcion: sin(a)+tan^2(a)
## Salida: Retorna el valor de la funcion evaluada con a
def exponente (a):
11
resultado = sin(a) + (tan(a))**2
return resultado
## Entrada: numeros entero x e y
## Logica: Evalua la formula de la pregunta 4 de la clase 4
## Salida: Retorno el valor de la función evaluada con x e y
def funcion1(x,y):
resultado1 = x**exponente(y)
resultado2 = y**exponente(x)
resultado3 = (x*y)**exponente(y)
resultadoFinal = resultado1 + resultado2 + resultado3
return resultadoFinal
####################################################
## Cuerpo principal
####################################################
## Llamo a la funcion y la evaluo con valores1 y 2

resultado1 = funcion1(1,2)
## Muestro el resultado obtenido

12
Problema 6
Enunciado
¿Cuál es el propósito del programa? Discuta y escriba algunas alternativas.
Programa
a = input ("primer argumento: ")

b = input ("segundo argumento: ")
c = a * b
z = 2 * a + 2 * b
print c
print z
Solución
Análisis
El propósito que tiene este programa es multiplicar la variable a con b, y también obtener
el resultado del doble de la suma entre a y b. Matemáticamente una de las opciones de
posible problema que solucionen es el cálculo del área de un rectángulo (la cual se
calcula como la multiplicación de base por altura) y el perímetro de éste (la suma de todos
sus lados).
13
Problema 7
Enunciado
Mejoren la legibilidad del siguiente programa que calcula el promedio de 3 valores

ingresados por teclado. Además marquen las secciones de código.
Código
x = input("v1:")
def p(z, y, x):
return (x + y + z) / 3.0
z = input("v2:")
y = input("v3:")
print p(x, z, y)
Solución
Análisis
Según las buenas prácticas de programación, primero se debe definir las constantes,
luego las funciones y finalmente hago el cuerpo principal. También los nombres deben ser
representativos, y el nombre de la función no lo es. Pero viendo que es lo que retorna,
esta suma los parámetros formales y los divide por 3.0, que es la cantidad de parámetros,
por lo que ésta calculando el promedio entre los parámetros formales.
14
Código
####################################################
##
## Semestre: 1-2013
##
## Objetivo:
####################################################
####################################################
####################################################
####################################################
####################################################
def promedio(z, y, x):
return (x + y + z) / 3.0
####################################################
## Cuerpo principal
####################################################
# pido la información
valor1 = input("Ingrese el primer valor (v1):")

valor2 = input("Ingrese el segundo valor (v2):")
valor3 = input("Ingrese el tercer valor (v3):")
# Realizo la lógica de mi función

resultado = p(valor1, valor2, valor3)
# Muestro el resultado
print “El resultado del promedio es:”, resultado
15
Problema 8
Enunciado
Escriban un programa en Python que implemente la siguiente función escalón:
Solución
Análisis
Se tiene que desarrollar una opción múltiple que sea capaz de decidir que opción tomar.
Tenemos tres opciones:
1 Si x es menor o igual que -1

2 Si x esta entre -1 y 1
3 Si x es mayor a 1
Como son tres opciones, utilizaremos if-elif-else
Programa
####################################################
##
## Semestre: 1-2013
##
## Objetivo:
####################################################
####################################################
####################################################
####################################################
16
####################################################
def escalon(x):
if x <= -1:
return 0
elif x >= 1:
return 1
else:
return (x + 1)/2
####################################################
## Cuerpo principal
####################################################
variable = input("Ingrese el valor de la variable x:")

resultado = escalon(variable)
print "El resultado de la funcion es:", resultado
17
Problema 9
Enunciado
En Chile, los ciudadanos que tiene una renta imponible anual menor o igual a $6.513.372
no pagan impuestos. Quienes tengan una renta superior a este monto, pagan un impuesto
global complementario equivalente al 5% de la renta imponible menos $325.668,6.-
Escriban una función en Python que calcule el impuesto global complementario de un
ciudadano chileno.
Solución
Análisis
Podemos ver que para la solución de este problema solo tenemos dos opciones cuando la
renta es menor o igual a $6.513.372 y la otra opción es cuando sea mayor.
Programa
####################################################
##
## Semestre: 1-2013
##
## Objetivo:
####################################################
####################################################
####################################################
# Constante de limite de quienes pagan y no pagan impuestos
RENTA_CORTE = 6513372
PORCENTAJE_IMPUESTOS = 0.05
DESCUENTO_IMPUESTOS = 325668.6
####################################################
####################################################
def pagoImpuestos(renta):
18
if renta > RENTA_CORTE:
return renta*PORCENTAJE_IMPUESTOS-DESCUENTO_IMPUESTOS
else:
return 0
####################################################
## Cuerpo principal
####################################################
rentaAnual = input("Ingrese su renta anual:")

impuestos = pagoImpuestos(rentaAnual)
print "El total de impuestos a pagar es de:", impuestos
19
Problema 10
Enunciado
Un colegio de Estación Central está enseñando a los niños de quinto básico el cálculo de
área y perímetro de diferentes figuras geométricas, y requiere de un programa escrito en
Python para que sus alumnos puedan verificar los resultados que obtienen. En particular,
están solicitando que el programa maneje círculos, triángulos rectángulos, rectángulos y
cuadrados. La siguiente tabla resume la materia vista por los alumnos:
Figura Fórmula Requiere Conocer
Círculo r: radio (en cm2)
: longitud de la base (en

cm2)
Triángulo Rectángulo
: longitud de la altura (en
√ cm2)
: longitud de la base (en

cm2)
Rectángulo
( ) : longitud de la altura (en
cm2)
Cuadrado a: longitud del lado (en cm2)
20
Solución
Análisis
Debemos hacer un menú, y según el menú la opción que debamos desarrollar. Y luego
desarrollamos funciones para el cálculo de cada una de las cosas.
Programa
####################################################
##
## Semestre: 1-2013
##
## Objetivo:
####################################################
####################################################
####################################################
# Constante de limite de quienes pagan y no pagan impuestos
from math import pi
area=0
perimetro=0
####################################################
####################################################
#Importo la raiz cuadrada
from math import sqrt
# Para el circulo
def areaCirculo (radio):
return pi*radio**2
def perimetroCirculo (radio):

return 2*pi*radio
# Para el triangulo
def areaTriangulo (base, altura):
return base*altura/2
def perimetroTriangulo (base, altura):

resultado1 = base + altura
resultado2 = base**2 + altura**2
resultado2 = sqrt(resultado2)
return resultado1 + resultado2
# Para el rectangulo
def areaRectangulo (base, altura):
return base*altura
def perimetroRectangulo (base, altura):

resultado1 = 2*(base + altura)
return resultado1
# Para el cuadrado
def areaCuadrado (lado):
return lado**2
def perimetroCuadrado (lado):
21
return 4*lado
#menu
def menu():
print "____________________________________________"
print " MENU"
print "____________________________________________"
print ""
print ""
print "Opcion 1: Calcular Area y perimetro de un circulo"
print "Opcion 2: Calcular Area y perimetro de un triangulo rectangulo"
print "Opcion 3: Calcular Area y perimetro de un rectangulo"
print "Opcion 4: Calcular Area y perimetro de un cuadrado"
print "Opcion 5: Salir"
print ""
print ""
opcionMenu = input ("Seleccione una opcion:")
return opcionMenu
####################################################
## Cuerpo principal
####################################################
opcion = -1
while opcion != 5:
opcion = menu()
if opcion == 1:#Se quiere calcular para un circulo
radioCirculo = input ("Ingrese el radio del circulo")
area = areaCirculo(radioCirculo)
perimetro = perimetroCirculo(radioCirculo)
elif opcion == 2:#Se quiere calcular para un triangulo
baseTriangulo = input ("Ingrese la base del triangulo:")
alturaTriangulo = input ("Ingrese la altura del triangulo:")
area = areaTriangulo(baseTriangulo, alturaTriangulo)
perimetro = perimetroTriangulo(baseTriangulo, alturaTriangulo)
elif opcion == 3:#Se quiere calcular para un rectangulo
baseRectangulo = input ("Ingrese la base del rectangulo:")
alturaRectangulo = input ("Ingrese la altura del rectangulo:")
area = areaRectangulo(baseRectangulo, alturaRectangulo)
perimetro = perimetroRectangulo(baseRectangulo, alturaRectangulo)
elif opcion == 4:#Se quiere calcular para un Cuadrado
ladoCuadrado = input ("Ingrese el lado del cuadrado:")
area = areaCuadrado(ladoCuadrado)
perimetro = perimetroCuadrado(ladoCuadrado)
elif opcion == 5:#Se quiere salir
print "Saliendo del programa"
else:
print "Opcion invalida, intente nuevamente"
if opcion >0 and opcion < 5:
print "El area de la figura es: ",area,"y su perimetro
es:",perimetro
print "Adios"
22
Problema 11
Enunciado
Creen un programa que muestre los números pares desde 0 hasta un n que el usuario
ingrese.
Solución
Programa
####################################################
##
## Semestre: 1-2013
##
## Objetivo:
####################################################
####################################################
####################################################
####################################################
####################################################
def paresIterativa(n):
contador = 0
while contador <= n:
print contador,
contador = contador+2
print "Fin"
return 0
def paresRecursiva(n, contador):

if contador > n:
print " Fin "
elif contador == n:
print contador, "Fin"
else:
print contador,
paresRecursiva(n,contador+2)
return 0
####################################################
23
## Cuerpo principal
####################################################
numero = input("¿Hasta que numero quiere obtener los pares?")
#Llamo a mis funciones y muestro el resultado

print "Iterativamente nos da:", paresIterativa(numero)
print "recursivamente nos da:", paresRecursiva(numero,0)
24
Problema 12
Enunciado
Creen una función en Python que realice, utilizando un ciclo while, el cálculo de la suma
de los primeros n enteros.
Solución
Programa
####################################################
##
## Semestre: 1-2013
##
## Objetivo:
####################################################
####################################################
####################################################
####################################################
####################################################
def sumaIterativa(n):
resultado = 0
contador = 0
resultado = resultado + contador
contador = contador+1
return resultado
def sumaRecursiva(n):
if n == 1:
return 1
else:
return n+sumaRecursiva(n-1)
####################################################
## Cuerpo principal
####################################################
numero = input("¿Hasta que numero quiere obtener la suma?")
25
print "Iterativamente nos da:", sumaIterativa(numero)
print "recursivamente nos da:", sumaRecursiva(numero)
26
Problema 14
Enunciado
Usando como base Recursivo.py, cree una función Fibonacci(n), que calcule el n-ésimo
número en la sucesión de Fibonacci, la cual se define por:
Solución
Análisis
Este programa se resuelve en el ejercicio siguiente, ya que se utiliza para poder calcular
el número áureo. De esa forma se permite ver el código de forma recursiva e iterativa a la
vez.
27
Problema 15
Enunciado
i ona i(n )
mero ureo (n) p i(n)
i ona i(n )
Entre mayor sea el valor n, mejor es la aproximación de . Necesitamos que cree un
programa para obtener aproximaciones de con un valor de n dado por el usuario. Usted
deberá usar una función recursiva para calcular del n-ésimo término de la secuencia de
Fibonacci para valores bajos de n, y una función iterativa para valores altos. El programa
debe determinar cuándo usar cada una, no el usuario.
Solución
Programa
# Programa que implementa las siguientes

# funciones:
# - fibonacci iterativo
# - fibonacci recursivo
# - funciÃ³n que calcula el nÃºmero Ã¡ureo
# Autores: CoordinaciÃ³n de FCyP

# Fecha: semestre 1/2013
# Funciones
# FunciÃ³n que implementa fibonacci (x)

# iterativo
# Entrada: x
# Salida: fibonacci (x)
# Requiere: x se considera nÃºmero
# natural
def calculaFibonacciIterativo (x):
if x == 0 or x == 1:
return x
contador = 1
# antecesor y anteAntecesor guardan
#los valores obtenidos por
# fibonacci (x-1) y fibonacci (x-2).
#antecesor = fibonacci (1)

antecesor = 1
#anteAntecesor = fibonacci (0)
anteAntecesor = 0
valor = 0
while contador < x:
# fibonacci (valor) = fibonacci (valor-2) + fibonacci (valor-
1)
valor = anteAntecesor + antecesor
# Para calcular el siguiente valor de fibonacci
# debemos asignar los valores correctos a
# antecesor y anteAntecesor
anteAntecesor = antecesor
28
antecesor = valor
contador += 1
return valor
# FunciÃ³n que implementa fibonacci (x)
# recursivo.
# Entrada: x
# Salida: fibonacci (x)
# Requiere: x se considera nÃºmero
# natural
def calculaFibonacciRecursivo (x):
if x == 0 or x == 1:
return x
else:
# x > 1
return calculaFibonacciRecursivo (x - 1) +
calculaFibonacciRecursivo (x - 2)
# FunciÃ³n que calcula el nÃºmero Ã¡ureo para

# un valor n. Mientras mÃ¡s grande el valor de n
# mejor es la aproximaciÃ³n.
# Entrada: n
# Salida: nÃºmero Ã¡ureo para n
# Requiere: n se considera nÃºmero
# natural mayor a 2
def calculaPhi (n):
# El lÃ-mite para utilizar fibonacci recursivo se fijÃ³
# teniendo en cuenta el rendimiento de la versiÃ³n iterativa.
# a partir de n=25, el rendimiendo de la versiÃ³n recursiva
# de fibonacci comienza a decaer en comparaciÃ³n a la versiÃ³n
# iterativa.
if n < 25:
return float (calculaFibonacciRecursivo
(n))/calculaFibonacciRecursivo (n - 1)
else:
return float (calculaFibonacciIterativo
(n))/calculaFibonacciIterativo (n - 1)
# Fin del programa
29
Problema 16
Enunciado
Construye un programa que, de forma recursiva, determine el máximo común divisor o
MCD (el mayor entero positivo que divide a ambos números de forma exacta) de dos
números mediante el algoritmo de Euclides y muestre el resultado por pantalla.
El algoritmo de Euclides es el siguiente:
● Dados dos enteros positivos m y n tales que m > n, hacer:

○ Obtener el resto (r) de m / n.
○ Si r = 0, el MCD es n.
○ En caso contrario, el MCD para m y n es igual al MCD entre n y r.
Solución
Programa
####################################################
##
## Semestre: 1-2013
##
## Objetivo:
####################################################
####################################################
####################################################
####################################################
####################################################
def euclides(m,n):
if m>n:
resto = m%n
if resto == 0:
return n
else:
return euclides (n,resto)
else:
print "error"
####################################################
## Cuerpo principal
####################################################
numeroM = input("Ingrese el numero m para calcular el MCD:")
numeroN = input("Ingrese el numero n para calcular el MCD:")
30
print "El MCD entre", numeroM,"y",numeroN,"es:",euclides(numeroM,numeroN)
31
Pregunta 17
Enunciado
Construya una función en python que entregue el resultado de la siguiente función

definida por intervalos:
( )
{
( )
Ejemplo para
Solución
Programa
# OPCION 1
def calculaDobleFactorial_1 (n):
paridad = n%2
factor = 1
contador = 1
acumulador = 1
while (factor < n):
factor = 2*contador - paridad
acumulador *= factor
contador += 1
return acumulador
# OPCION 2
def calculaDobleFactorial_2 (n):
factor = 1
contador = 1
acumulador = 1
if n%2 == 0:
while (factor < n):
factor = 2*contador
contador += 1
else:
while (factor < n):
factor = 2*contador - 1
contador += 1
return acumulador
32
Pregunta 18
Enunciado
Construya una función en python que entregue el resultado de la siguiente función:
La función corresponde a la pitatoria (multiplicatoria) de los primeros n números primos.

Para construir su programa utilice la función esPrimo (n) que retorna True (verdadero) si n
es primo o False (Falso) si n no es primo.
Ejemplo para
Solución
Programa
def esPrimo (n):
contador = 1
acumulador = 0
if n%contador == 0:
acumulador += 1
contador += 1
if acumulador == 2:
return True
else:
return False
def calculaPrimorial (n):
contador = 1
contadorPrimos = 1
acumulador = 1
while contadorPrimos < n:
if (esPrimo (contador)):
acumulador *= contador
contadorPrimos += 1
contador += 1
return acumulador
33
Pregunta 19
Enunciado
Construya una función en python que entregue el resultado de la siguiente función

definida por intervalos:
( ) {
∑
El resultado debe ser entregado con máximo 3 decimales.
Ejemplo para ( )
Solución
Programa
def calculaFuncion (n):
contador = 1
acumulador = 0
if (n == 0):
return 1
while (contador <= n):
acumulador += 1.0/contador
contador += 1
return round (n * acumulador, 3)
34
Pregunta 20
Enunciado
Construya una función en python que entregue el resultado de la serie de MacLaurin para
la función exponencial como se define a continuación:
Como la serie es infinita, la función debe recibir por parámetro n. Para construir su
programa utilice la función calculaFactorial (n) que retorna el factorial de n.
Ejemplo para
Solución
Programa
def calculaFactorial (n):

contador = 1
acumulador = 1
acumulador *= contador
contador += 1
return acumulador
def calculaExponencial (n, x):

contador = 0
acumulador = 0
while (contador <= n):
acumulador += float(x**contador)/calculaFactorial (contador)
contador += 1
return acumulador
35
Pregunta 22
Enunciado
Construya una función recursiva en python que entregue el resultado de la siguiente

función:
( ) ∏
Ejemplo para ( ) ( )
Solución
Programa
# --------------------------------------------
# OPCION 1: A través de iteración
# --------------------------------------------
def calculaFuncionIterativa (x, y, n):
contador = 1
acumulador = 1
acumulador *= x*y
contador += 1
return acumulador
# --------------------------------------------
# OPCION 2: A través de recursión
# --------------------------------------------
def calculaFuncionRecursiva (x, y, n):
if n == 1:
return x*y
else:
n -= 1
return x*y * calculaFuncionRecursiva (x, y, n)
# --------------------------------------------
# OPCION 3: Analizando la función, es posible
# utilizar xy^n
# --------------------------------------------
def calculaFuncion_3 (x, y, n):
return (x*y)**n
# --------------------------------------------
36

Guia Ejercicios PDF

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

Guia Ejercicios PDF

Cargado por

Copyright:

Formatos disponibles

Universidad de Santiago de Chile

Esta guía posee ejercicios enunciados en clases, pero su solución no es necesariamente

Para la solución de los problemas se hace lo siguiente:

● Se analiza cómo se puede resolver el problema.

Recuerde que el promedio se calcula con la fórmula:

Y la desviación estándar como:

R: Los resultados de funciones son el promedio y la desviación estándar, todo lo

R: Si nos fijamos bien, cada grupo va a tener de forma independiente la cantidad

Para la función que calcule el promedio tenemos:

## Las constantes que se enuentran para nuestro programa son:

## Funciones necesarias para nuestro problema:

## Funciones Desviación Estándar

## Solicito las edades en meses

## Calculo el resultado de la funcion

Declare un par de variables x e y con valores 1 y 2 respectivamente. Luego utilice

## Importo las librerias necesarias

## Declaro las variables x e y con valores 1 y 2 respectivamente

## Calculo el resultado de la funcion

## Llamo a la funcion y la evaluo con valores 1, 2 y 3

## Declaro mi variable global y de doy un valor aleatorio

## Llamo a la funcion y la evaluo con valor 1

## Muestro el resultado obtenido

El código cuando se ejecute debe lanzar un error, ya que se llama a la función1 y en la

Escriba las sentencias necesarias para evaluar la fórmula ( ):

## Llamo a la funcion y la evaluo con valores1 y 2

## Muestro el resultado obtenido

a = input ("primer argumento: ")

Mejoren la legibilidad del siguiente programa que calcula el promedio de 3 valores

valor1 = input("Ingrese el primer valor (v1):")

# Realizo la lógica de mi función

Escriban un programa en Python que implemente la siguiente función escalón:

1 Si x es menor o igual que -1

variable = input("Ingrese el valor de la variable x:")

# Realizo la lógica de mi función

rentaAnual = input("Ingrese su renta anual:")

Figura Fórmula Requiere Conocer

Círculo r: radio (en cm2)

: longitud de la base (en

: longitud de la base (en

Cuadrado a: longitud del lado (en cm2)

def perimetroCirculo (radio):

def perimetroTriangulo (base, altura):

def perimetroRectangulo (base, altura):

def paresRecursiva(n, contador):

#Llamo a mis funciones y muestro el resultado

# Programa que implementa las siguientes

# Autores: CoordinaciÃ³n de FCyP

# FunciÃ³n que implementa fibonacci (x)

#antecesor = fibonacci (1)

# FunciÃ³n que calcula el nÃºmero Ã¡ureo para

El algoritmo de Euclides es el siguiente:

● Dados dos enteros positivos m y n tales que m > n, hacer:

Construya una función en python que entregue el resultado de la siguiente función

Construya una función en python que entregue el resultado de la siguiente función:

La función corresponde a la pitatoria (multiplicatoria) de los primeros n números primos.

Construya una función en python que entregue el resultado de la siguiente función

El resultado debe ser entregado con máximo 3 decimales.

def calculaFactorial (n):

def calculaExponencial (n, x):

Construya una función recursiva en python que entregue el resultado de la siguiente

También podría gustarte