ADTFI102

Semana 6 – Solución Guía 3

EJERCICIOS:

A continuación, se presentan una serie de ejercicios relacionados con el trabajo que deben desempeñar para la empresa
“Los Mejores Programas S.A.”, dedicada al desarrollo de programas computacionales en Python en donde se resuelven
problemas de todo tipo. En esta oportunidad, se ha acercado un grupo de personas de la comuna donde se ubica la
empresa, buscando en conjunto, la solución a diversos problemas que han reunido en un solo documento. Estos problemas
varían desde analizar si un número es primo, hasta entregar el vuelto en una caja de supermercado con la menor cantidad
de billetes y monedas.

A través de los siguientes ejercicios deberán dar respuesta a lo requerido por el usuario:

1. Construye un programa en Python que muestre la tabla de multiplicar de un valor n ingresado por el usuario,
considerando los resultados desde el 1 al 15.

A continuación, se muestran 3 ejemplos de funcionamiento (el texto en azul lo ingresa el usuario): (llama al archivo:
ATDFI102_s5_01_nombregrupo.py).
 SOLUCIÓN:

## BLOQUE PRINCIPAL:

## Entrada de datos:
n = int(input("Ingresa el número: "))

## Proceso - Salida de datos:

print(f"\nTabla de multiplicar:")
print("~~~~~~~~~~~~~~~~~~~~")
i = 1
while i <= 15:
print(f" {n} * {i} = {n*i}")
i = i+1
print()

2. Construye un programa en Python que muestre cada código ASCII y su correspondiente carácter.

A continuación, se muestra un fragmento del funcionamiento (recuerda que hay caracteres que no son “imprimibles”):
(llama al archivo: ATDFI102_s5_02_nombregrupo.py)
SOLUCIÓN:

## BLOQUE PRINCIPAL:

## Entrada de Datos:
## -

## Proceso - Salida de Datos:

codigo = 0
while codigo <= 255:
caracter = chr(codigo)
print(f"codigo {codigo} - caracter {caracter}")
 codigo = codigo+1

3. Construye un programa en Python que le permita al usuario adivinar un número secreto entre 0 y 300 (que tú,
programador, defines). Si no acierta, el programa debe decir por pantalla si debe ingresar un número mayor o menor
para acercarse al número meta. Cuando el usuario acierte, el programa debe, además, indicar en cuántos intentos
logró adivinar el usuario.

A continuación, se muestran 2 ejemplos de funcionamiento (el texto en azul lo ingresa el usuario): (llama al archivo:
ATDFI102_s5_03_nombregrupo.py).
SOLUCIÓN:

## BLOQUE PRINCIPAL:

## Entrada de Datos - Proceso - Salida de Datos:

secreto = 27
numero = 0
intento = 0

while numero != secreto:

numero = int(input("Ingresa un número entre 0 y 300: "))
if numero < secreto:
print(f"Ingresa un número mayor")
if numero > secreto:
print(f"Ingresa un número menor")
intento = intento+1

print(f"\n¡Acertaste en {intento} intento(s)!\n")

4. Construye un programa en Python que calcule y muestre la cantidad de dígitos que posee un número entero mayor
a 0 ingresado por el usuario.

A continuación, se muestran 4 ejemplos de funcionamiento (el texto en azul lo ingresa el usuario): (llama al archivo:
ATDFI102_s5_04_nombregrupo.py).

SOLUCIÓN:

## BLOQUE PRINCIPAL:

## Entrada de datos:
#Validación:
numero = 0
while numero <= 0:
numero = int(input("Ingresa un número: "))

## Proceso:
 copia = numero

cont = 0
while numero > 0:
numero = numero//10 #corta el último dígito
cont = cont+1

## Salida de datos:
print(f"\nEl número {copia} tiene {cont} dígito(s).\n")

5. Construye un programa en Python que reciba desde el usuario una cantidad de dinero mayor a 0 expresada en
pesos chilenos, e indique cuántas y cuáles monedas requiere para construir dicha cantidad. Considera monedas
de $500, $100, $50, $10, $5, $1.

A continuación, se muestran 3 ejemplos de funcionamiento (el texto en azul lo ingresa el usuario): (llama al archivo:
ATDFI102_s5_05_nombregrupo.py).
SOLUCIÓN:

## BLOQUE PRINCIPAL:

## Entrada de Datos:
dinero = int(input("Ingresa la cantidad de dinero: "))

## Proceso:
copia = dinero
moneda500 = 0
moneda100 = 0
moneda50 = 0
moneda10 = 0
moneda5 = 0
moneda1 = 0

while dinero > 0:

if dinero >= 500:
dinero = dinero-500
moneda500 = moneda500+1
elif dinero >= 100:
dinero = dinero-100
moneda100 = moneda100+1
elif dinero >= 50:
dinero = dinero-50
moneda50 = moneda50+1
 elif dinero >= 10:
dinero = dinero-10
moneda10 = moneda10+1
elif dinero >= 5:
dinero = dinero-5
moneda5 = moneda5+1
elif dinero >= 1:
dinero = dinero-1
moneda1 = moneda1+1

## Salida de Datos:
print(f"\nCantidad de monedas para ${copia}:")
if moneda500 != 0:
print(f"{moneda500} moneda(s) de $500")
if moneda100 != 0:
print(f"{moneda100} moneda(s) de $100")
if moneda50 != 0:
print(f"{moneda50} moneda(s) de $50")
if moneda10 != 0:
print(f"{moneda10} moneda(s) de $10")
if moneda5 != 0:
print(f"{moneda5} moneda(s) de $5")
if moneda1 != 0:
print(f"{moneda1} moneda(s) de $1\n")
6. Construye un programa en Python que encuentre y muestre el valor mayor de una secuencia de n valores
ingresados por el usuario. El valor de n también lo debe ingresar el usuario.

A continuación, se muestran 3 ejemplos de funcionamiento (el texto en azul lo ingresa el usuario): (llama al archivo:
ATDFI102_s5_06_nombregrupo.py).

SOLUCIÓN:

## BLOQUE PRINCIPAL:

## Entrada de datos:
n = int(input("Ingresa la cantidad de números: "))

## Proceso:
i = 1
while i <= n:
numero = float(input(f"Ingresa el número {i}: "))
if i == 1: #primer valor ingresado.
 mayor = numero
else:
if numero > mayor:
mayor = numero
i = i+1

## Salida de datos:
print(f"\nEl valor mayor es: {mayor}\n")

7. Construye un programa en Python que permita evaluar un polinomio de grado n ingresado por el usuario. Para
esto, el usuario debe determinar el valor en el que desea evaluar, el grado del polinomio y cada uno de sus
coeficientes (Recuerda que el grado de un polinomio corresponde a la mayor potencia que posee x).

A continuación, se muestran 3 ejemplos de funcionamiento (el texto en azul lo ingresa el usuario): (llama al archivo:
ATDFI102_s5_07_nombregrupo.py)
SOLUCIÓN:

## BLOQUE PRINCIPAL:

## Entrada de datos:
n = int(input("Grado del polinomio: "))
x = float(input("Valor para evaluar el polinomio: "))

## Proceso:
exponente = n
acumulador = 0

while exponente >= 0:

coeficiente = float(input(f"Coeficiente x^{exponente}:
"))
acumulador += coeficiente*x**exponente
exponente = exponente-1

## Salida de datos:
print(f"\nPolinomio evaluado en {x}: {acumulador}\n")
8. Construye un programa en Python que determine y muestre los divisores que posee un número entero mayor a 1
ingresado por el usuario.

A continuación, se muestran 3 ejemplos de funcionamiento (el texto en azul lo ingresa el usuario): (llama al archivo:
ATDFI102_s5_08_nombregrupo.py).

SOLUCIÓN:

## BLOQUE PRINCIPAL:

## Entrada de datos:

#Validación:
numero = 0
while numero <= 1:
numero = int(input("Ingresa un número: "))
 ## Proceso - Salida de datos:
print("\nDivisor 1: 1")
mitad = numero/2
divisor = 2
cont = 2

while divisor <= mitad:

if numero%divisor == 0: #determina si es un divisor de
"numero"
print(f"Divisor {cont}: {divisor}")
cont = cont+1
divisor = divisor+1

print(f"Divisor {cont}: {numero}\n")

9. Construye un programa en Python que indique si un número entero es primo o compuesto, a partir de un número
mayor 1 ingresado por el usuario.
A continuación, se muestran 3 ejemplos de funcionamiento (el texto en azul lo ingresa el usuario):
(llama al archivo: ATDFI102_s5_09_nombregrupo.py).

SOLUCIÓN:

## BLOQUE PRINCIPAL:

## Entrada de datos:
#Validación:
numero = 0
while numero <= 1:
numero = int(input("Ingresa un número: "))

## Proceso:
divisor = 2
cont = 0
mitad = numero/2
while divisor <= mitad:
 if numero%divisor == 0:
cont = cont+1
divisor = divisor+1

## Salida de datos:
if cont == 0:
print(f"\nEl número {numero} es primo.\n")
else:
print(f"\nEl número {numero} es compuesto.\n")

10. Construye un programa en Python que calcule la raíz n-esima de un número entero ingresado por el usuario. El
índice de la raíz (n), también lo debe ingresar el usuario. El resultado debe mostrarse con 3 decimales y no puedes
utilizar el operador **.

A continuación, se muestran 3 ejemplos de funcionamiento (el texto en azul lo ingresa el usuario): (llama al archivo:
ATDFI102_s5_10_nombregrupo.py).
 SOLUCIÓN:

## BLOQUE PRINCIPAL:

## Entrada de datos:
numero = int(input("Ingresa un número: "))
n = int(input("Ingresa el valor de n: "))

## Proceso:
#"limiteInf" y "limiteSup", delimitan el rango de valores donde se buscará la raíz
enésima.
#Inicialmente se asume que la raíz enésima será el primera enésimo del rango de
búsqueda.

limiteInf = 0
limiteSup = numero
raizN = (limiteInf + limiteSup)/n

while abs(raizN**n - numero) >= 0.0001: #se usa "abs" porque la resta puede dar
negativa
if raizN**n > numero:
limiteSup = raizN
else:
limiteInf = raizN
raizN = (limiteInf + limiteSup)/2

## Salida de datos:
print(f"\nRaíz {n} de {numero} es {round(raizN, 3)}\n")

11. Construye un programa en Python que calcule el logaritmo en base x, de un número. Tanto la base como el número
lo debe ingresar el usuario. El resultado debe tener 3 decimales de precisión. (Recuerda que calcular un logaritmo
en base x de un número, corresponde a encontrar el exponente al que debes elevar x para conseguir el número).

A continuación, se muestran 4 ejemplos de funcionamiento (el texto en azul lo ingresa el usuario): (llama al archivo:
ATDFI102_s5_11_nombregrupo.py).
 SOLUCIÓN:

## BLOQUE PRINCIPAL:

## Entrada de datos:
numero = int(input("Ingresa un número: "))
base = int(input("Ingresa la base del logaritmo: "))

## Proceso:

#"limiteInf" y "limiteSup", delimitan el rango de valores donde se buscará el

logaritmo.
#Inicialmente se asume que el logaritmo será el punto medio de ese rango de
búsqueda.

limiteInf = 0
limiteSup = numero/base
log = (limiteInf + limiteSup)/2

while abs(base**log - numero) >= 0.0001: #se usa "abs" porque la resta puede dar
negativa
if base**log > numero:
limiteSup = log
 else:
limiteInf = log
log = (limiteInf + limiteSup)/2

## Salida de datos:
print(f"\nLog (base {base}) de {numero}: {round(log, 3)}\n")

12. Construye un programa en Python que permita calcular el VAN de un proyecto en cada período hasta que sea
positivo. Para esto, el usuario deberá ingresar el monto de la inversión inicial (llamado I0 en la fórmula mostrada),
la tasa de interés (llamada r en la fórmula mostrada), y cada flujo neto (llamado F1, F2, …, Fn en la fórmula mostrada).
Luego del ingreso de un flujo el programa deberá mostrar el VAN acumulado hasta ese período.

Por si no lo sabes:
En finanzas, el VAN o Valor Actual Neto es un indicador de la rentabilidad que tendrá un proyecto. Se calcula
mediante la siguiente fórmula:

𝑛
𝐹𝑡 𝐹1 𝐹2 𝐹𝑛
𝑉𝐴𝑁 = −𝐼0 + ∑ = −𝐼0 + + + ⋯ +
(1 + 𝑟 )𝑡 (1 + 𝑟)1 (1 + 𝑟)2 (1 + 𝑟 )𝑛
𝑡=1

A continuación, se muestran 2 ejemplos de funcionamiento (el texto en azul lo ingresa el usuario): (llama al archivo:
ATDFI102_s5_12_nombregrupo.py).
SOLUCIÓN:

## BLOQUE PRINCIPAL:

## Entrada de Datos - Proceso - Salida de Datos:

I0 = float(input("Inversión inicial: "))
r = float(input("Tasa en %: "))

VAN = -I0
t = 1
while VAN <= 0:
 Ft = float(input(f"Flujo mes {t}: "))
VAN = VAN + Ft/((1+r/100)**t)
print(f"VAN = {round(VAN,1)}")
t = t+1

13. Construye un programa en Python que solicite dos números enteros, m y n (ambos mayores a 1) y, a partir de ellos,
“dibuje” el borde de un rectángulo de asteriscos de m asteriscos de ancho, por n asteriscos de alto.

A continuación, se muestran 3 ejemplos de funcionamiento (el texto en azul lo ingresa el usuario): (llama al archivo:
ATDFI102_s5_13_nombregrupo.py).
SOLUCIÓN:

## BLOQUE PRINCIPAL:

## Entrada de Datos:
m = 0
while m <= 1:
m = int(input("Ancho del rectángulo: "))

n = 0
while n <= 1:
n = int(input("Alto del rectángulo: "))

## Proceso - Salida de Datos:

#borde superior:
i = 1
while i <= m:
print("*", end="")
i = i+1

j = 2
while j < n:
print("\n*", end="") #borde izquierdo

i = 2
while i < m:
print(" ", end="") #espacios centrales
 i = i+1

print("*", end="") #borde derecho

j = j+1

print()
#borde inferior:
i = 1
while i <= m:
print("*", end="")
i = i+1
print("\n")

14. Construye un programa en Python que permita administrar las ventas de una fábrica de mermeladas. El detalle
de sus posibles ventas es:

Tipo de Envase Capacidad (Kg) Precio ($)

BOLSA ¼ 300
BOLSA ½ 500
FRASCO 1 1200
FRASCO 2 2400

Se necesita construir el siguiente menú (y los cálculos asociados):

A. Ingresar venta
B. Kilos vendidos
C. Frascos vendidos
 D. Ingreso por bolsas
E. Salir

Para la opción A, deberás construir un submenú, que permita mostrar las combinaciones de bolsas y frascos de
mermeladas que se pueden comprar.

A continuación, se muestra un ejemplo de funcionamiento que corresponde al ingreso de varias ventas, y luego a la
revisión de los resúmenes de las opciones B, C y D. Debes seguir la secuencia de izquierda a derecha (el texto en
azul lo ingresa el usuario): (llama al archivo: ATDFI102_s5_14_nombregrupo.py)
SOLUCIÓN:

## BLOQUE PRINCIPAL:

## Entrada de datos - Proceso - Salida de datos:

numFrascos = 0
ventaPorBolsas = 0
numKilos = 0.0
op = "A"
while op != "E":
print("\t\t\tMENU")
print("\t\t\t~~~~\n")
print("\t\tA. Ingresar venta")
print("\t\tB. Kilos vendidos")
print("\t\tC. Frascos vendidos")
print("\t\tD. Ingresos por bolsas")
print("\t\tE. Salir")
op = input("\n\t\tIngresa una opción: ")
op = op.upper()
if op == "A":
opVenta = -1
while opVenta != 5:
print("\n\t\t\tVENTAS")
print("\t\t\t~~~~~~\n")
print("\t\t1. Bolsa de 0.25 Kg. ($300)")
print("\t\t2. Bolsa de 0.5 Kg. ($500)")
print("\t\t3. Frasco de 1 Kg. ($1200)")
 print("\t\t4. Frasco de 2 Kg. ($2400)")
print("\t\t5. Salir")
opVenta = int(input("\n\t\tIngresa una opción: "))
if 1 <= opVenta <= 4:
cantidad = int(input("\t\tIngresa la cantidad:
"))
if opVenta == 1:
ventaPorBolsas = ventaPorBolsas +
300*cantidad
numKilos = numKilos + 0.25*cantidad
elif opVenta == 2:
ventaPorBolsas = ventaPorBolsas +
500*cantidad
numKilos = numKilos + 0.5*cantidad
elif opVenta == 3:
numFrascos = numFrascos + cantidad
numKilos = numKilos + 1.0*cantidad
elif opVenta == 4:
numFrascos = numFrascos + cantidad
numKilos = numKilos + 2.0*cantidad
elif op == "B":
print(f"\t\tKilos vendidos: {numKilos} Kgs.")
elif op == "C":
print(f"\t\tTotal de frascos vendidos: {numFrascos}")
elif op == "D":
print(f"\t\tIngresos por bolsas: ${ventaPorBolsas}")
print("")