s2Eva_IT2009_T3 Mejores vendedores por categoría

Ejercicio: 2Eva_IT2009_T3 Mejores vendedores por categoría

Propuesta de solución en Python: py_pdf, también en versión matlab: m_pdf

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 2Eva_IT2009_T3 Mejores vendedores por categoría
# Propuesta: edelros@espol.edu.ec

import numpy as np

# INGRESO
n = int(input('cuantos vendedores: '))
m = int(input('cuantos productos: '))

ventas = np.zeros(shape=(n+1,m+1),dtype=int)
precio = np.zeros(shape=(m+1),dtype=float)
for f in range(1,n+1,1):
    for c in range(1,m+1,1):
        ventas[f,c] = int(input('ventas['+str(f)+','+str(c)+']: '))
for pd in range(1,m+1,1):
    precio[pd] = float(input('Precio['+str(pd)+']: '))

# PROCEDIMIENTO

#categoria ventas
unidades = np.zeros(shape=(n+1),dtype=int)
for f in range(1,n+1,1):
    for c in range(1,m+1,1):
        unidades[f] = unidades[f]+ventas[f,c]
mventas = 1
for f in range(1,n+1,1):
    if unidades[f]>unidades[mventas]:
        mventas = f

# categoria montos
monto = np.zeros(shape=(n+1),dtype=float)
for f in range(1,n+1,1):
    for c in range(1,m+1,1):
        monto[f] = monto[f] + ventas[f,c]*precio[c]
mmonto = 1
for f in range(2,n+1,1):
    if monto[f]>monto[mmonto]:
        mmonto = f

# SALIDA
print('Mejor vendedor/unidades', mventas)
print('Mejor vendedor/monto', mmonto)

ejercicios resueltos Python 2eva_it2009_t3 pdf

ejercicios resueltos Matlab 2eva_it2009_t3 pdf

s1Eva_IT2009_T1 Suma de serie con signo alternado

Ejercicio: 1Eva_IT2009_T1 Suma de serie con signo alternado

Propuesta de solución en Python: python.pdf, también versión en matlab.pdf

Solicitar el número n, calcular cada término i-ésimos y acumularlos en una variable s.

El signo se puede alternar multiplicando una variable signo por -1. También se puede usar (-1)i+1 para alternar el signo.

1-\frac{1}{2}+\frac{1}{3}-\frac{1}{4}+\frac{1}{5}+\text{...}+\frac{1}{n}

observe:

(-1)^{(1+1)}1+(-1)^{(2+1)}\frac{1}{2}+(-1)^{(3+1)}\frac{1}{3}+ ...

La primera solución se presenta usando el lazo “Mientras-Repita”

Lazo mientras-repita:

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 1Eva_IT2009_T1 Suma de serie con signo alternado
# Propuesta de solución. edelros@espol.edu.ec

# INGRESO
n = int(input('¿Cuántos términos?: '))

# PROCEDIMIENTO
i = 1
s = 0
signo = 1
while (i<=n):
    s = s + signo*(1/i)
    i = i + 1
    signo = (-1)*signo

# SALIDA
print(s)

resultado del algoritmo

¿Cuántos términos?: 5
0.7833333333333332
>>> 
== RESTART: D:\MATG1052Ejemplos\unprograma.py ==
¿Cuántos términos?: 10
0.6456349206349207
>>> 

Diagrama de Flujo Mientras-Repita

Suma de serie con signo alternado 01


lazo repita-hasta:

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 1Eva_IT2009_T1 Suma de serie con signo alternado
# Propuesta de solución. edelros@espol.edu.ec

# INGRESO
n = int(input('¿Cuántos términos?: '))

# PROCEDIMIENTO
i = 1
s = 0
signo = 1
while not(i>n):
    s = s + signo*(1/i)
    i = i + 1
    signo = (-1)*signo

# SALIDA
print(s)

Diagrama de Flujo Repita-Hasta

Suma de serie con signo alternado 02

ejercicios resueltos Python 1Eva_IT2009_T1 pdf

ejercicios resueltos Matlab 1eva_it2009_t1 pdf

s2Eva_IIT2008_T3 Crear un Calendario

Ejercicio: 2Eva_IIT2008_T3 Crear un Calendario

Propuesta de solución en Python: py_pdf, también en versión matlab: m_pdf

Solución presentada junto a video de concepto:

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 2Eva_IIT2008_T3 Crear un Calendario
# Propuesta: edelros@espol.edu.ec

import numpy as np

dprimer = int(input('¿día de inicio del mes?: '))
diasmes = int(input('¿días del mes?: '))

# El calendario vacío al inicio
calendario = np.zeros(shape=(6,7), dtype=int)
c = dprimer - 1
f = 0
dia = 1
while (f<=5 and dia<=diasmes):
    while (c<=6 and dia<=diasmes):
        calendario[f,c] = dia
        dia = dia + 1
        c = c + 1
    f = f + 1
    c = 0

print('   D  L  M  M  J  V  S')
print(calendario)
# Tarea: Validar primer día del mes entre 1 y 7, 
#    y número de días del mes entre 28 y 31

resultado del algoritmo

¿día de inicio del mes?: 4
¿días del mes?: 31
   D  L  M  M  J  V  S
[[ 0  0  0  1  2  3  4]
 [ 5  6  7  8  9 10 11]
 [12 13 14 15 16 17 18]
 [19 20 21 22 23 24 25]
 [26 27 28 29 30 31  0]
 [ 0  0  0  0  0  0  0]]
>>> 

ejercicios resueltos Python 2eva_iit2008_t3 pdf

ejercicios resueltos Matlab 2eva_iit2008_t3 pdf

s2Eva_IIT2008_T2 Etiquetar a robots (R2D2)

Ejercicio: 2Eva_IIT2008_T2 Etiquetar a robots (R2D2)

Propuesta de solución en Python: py_pdf, también en versión matlab: m_pdf

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 2Eva_IIT2008_T2 Etiquetar a robots (R2D2)
# Propuesta: edelros@espol.edu.ec

import random as rnd

def nrobot(n):
    # Referencias para seleccionar simbolos
    letra='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    numero='0123456789'

    nletras  = len(letra)
    mnumeros = len(numero)

    # formar cadena
    z = ''
    i = 1
    letravocal = 1
    while (i<=n):
        if letravocal==1:
            a = int(rnd.random()*nletras)
            z = z + letra[a]
            letravocal = 0
        else:
            a = int(rnd.random()*mnumeros)
            z = z + numero[a]
            letravocal = 1
        i = i + 1
        
    return (z)

resultado del algoritmo

>>> nrobot(4)
'V2F6'
>>> nrobot(4)
'F9U3'
>>> nrobot(4)
'P9L8'
>>> nrobot(4)
'L1K0'
>>> nrobot(4)
'J1J4'
>>> 

ejercicios resueltos Python 2eva_iit2008_t2 pdf

ejercicios resueltos Matlab 2eva_iit2008_t2 pdf

s2Eva_IIT2008_T1 Carrera de caracoles

Ejercicio: 2Eva_IIT2008_T1 Carrera de caracoles
Propuesta de solución en Python para dos caracoles A y B:

Cada caracol inicia en el punto de partida

A = 0 
B = 0 
t = 0

El movimiento de cada caracol se simula con un número aleatorio.

mueveA = int(rnd.random()*5)-1
A = A + mueveA

Intrucciones en Python

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 2Eva_IIT2008_T1 Carrera de caracoles
# solo dos caracoles

import random  as rnd

# INGRESO
meta = int(input('meta maxima: '))

# PROCEDIMIENTO
A = 0
B = 0
t = 0
while (A<meta and B<meta):
    mueveA = int(rnd.random()*5)-1
    A = A + mueveA
    
    mueveB = int(rnd.random()*5)-1
    B = B + mueveB
    
    t = t + 1

gana = 0
if (A>B):
    gana = 1
if (B>A):
    gana = 2
    
# SALIDA
print('ganó el caracol: ',gana)
print('tiempo transcurrido: ', t)

Resultado del algoritmo

meta maxima: 50
ganó el caracol:  2
tiempo transcurrido:  38
>>> 
meta maxima: 50
ganó el caracol:  1
tiempo transcurrido:  39
>>> 

Carrera para n caracoles use un vector e indices entre 1 y n

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 2Eva_IIT2008_T1 Carrera de caracoles
import random  as rnd
import numpy as np

# INGRESO
meta = int(input('meta maxima: '))
n = int(input('cuantos jugadores: '))

# PROCEDIMIENTO
# no se usa la posicion 0, caracoles entre[1,n]
posicion = np.zeros(n+1, dtype = int)

t    = 0
gana = 0
while not(gana>0):
    
    jugador = 0
    while not(jugador>=n):

        mueve = int(rnd.random()*5)-1
        posicion[jugador] = posicion[jugador] + mueve
        
        if (posicion[jugador]>meta):
            gana = jugador

        jugador = jugador +1
    
    t = t + 1

# SALIDA
print('posiciones finales:')
print(posicion)
print('ganó el caracol: ',gana)
print('tiempo transcurrido: ', t)

resultado de algoritmo

meta maxima: 50
cuantos jugadores: 5
posiciones finales:
[38 44 44 32 51  0]
ganó el caracol:  4
tiempo transcurrido:  39
>>> 
meta maxima: 50
cuantos jugadores: 5
posiciones finales:
[46 52 42 33 35  0]
ganó el caracol:  1
tiempo transcurrido:  36
>>> 

s1Eva_IIT2008_T1 Odometro OCTAL

Ejercicio: 1Eva_IIT2008_T1 Odometro OCTAL

Propuesta de solución en Python: py_pdf, también en matlab: m_pdf

Se usa el concepto para cambio de base numérica, se extrae cada dígito para acumular el valor ponderando por cada posición referenciada con la variable i.

Si se usa residuo de la división para 10, el primer digito a extraer es el menos significativo (unidades).

Se acumulan los valores de acuerdo a la ponderación o peso por posición y se repite hasta que no queden dígitos que ponderar.

Para repasar: Bases Numéricas Introducción

Tarea: validar que el número es octal (rango de dígitos entre 0-7)-

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 1Eva_IIT2008_T1 Odometro OCTAL
# Propuesta de solución. edelros@espol.edu.ec
# Tarea: Validar que el ingreso sea en octal.

# INGRESO
octal = int(input('¿numero en octal?: '))

# PROCEDIMIENTO
i = 0
decimal = 0
while (octal>0):
    r = octal%10
    octal = octal//10
    decimal = decimal+r*(8**i)
    i = i + 1

# SALIDA
print('valor en decimal: ')
print(decimal)

Resultado del algoritmo

Observación: Tener en cuenta que no se ha validado que el número octal solo debe tener dígitos entre 0 y 7.

¿numero en octal?: 27
valor en decimal: 
23
>>> 
¿numero en octal?: 14
valor en decimal: 
12
>>> 

Diagrama de Flujo

ejercicios resueltos Python 1eva_iit2008_t1 pdf

ejercicios resueltos Matlab 1eva_iit2008_t1 pdf

s2Eva_IT2008_T2 Validar cédula ecuatoriana

Ejercicio: 2Eva_IT2008_T2 Validar cédula ecuatoriana

Propuesta de solución en Python: py_pdf, también en versión matlab: m_pdf

Resultado del algoritmo

>>> vcedula('0909407173')
1
>>> vcedula('0909407174')
0
>>> 

Instrucciones en Python

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 2Eva_IT2008_T2 Validar cédula ecuatoriana
# Propuesta de solución: edelros@espol.edu.ec

def vcedula(texto):
    # sin ceros a la izquierda
    nocero = texto.strip("0")
    
    cedula = int(nocero,0)
    verificador = cedula%10
    numero = cedula//10
    
    # mientras tenga números
    suma = 0
    while (numero > 0):
        
        # posición impar
        posimpar = numero%10
        numero   = numero//10
        posimpar = 2*posimpar
        if (posimpar  > 9):
            posimpar = posimpar-9
        
        # posición par
        pospar = numero%10
        numero = numero//10
        
        suma = suma + posimpar + pospar
    
    decenasup = suma//10 + 1
    calculado = decenasup*10 - suma
    if (calculado  >= 10):
        calculado = calculado - 10

    if (calculado == verificador):
        validado = 1
    else:
        validado = 0
        
    return (validado)

ejercicios resueltos Python 2eva_it2008_t2 pdf

ejercicios resueltos Matlab 2eva_it2008_t2 pdf

s1Eva_IT2008_T3 Simular Precio del Petróleo

Ejercicio: 1Eva_IT2008_T3 Simular Precio del Petróleo

Propuesta de solución en Python: py_pdf  promedio valores grafico

También como diagrama en pdf y en versión matlab: m_pdf

Se ingresa la cantidad de días del mes, o se puede considerar directamente 30, también es opcional ingresar el rango de precio mínimo y precio máximo, que son los límites del número aleatorio.

Para la pregunta a) se calcula el promedio como el acumulado de precios de cada día dividido para los n días.

Enla pregunta b) se usa el algoritmo del menor, con la hipótesis que el díamenor es el primero, y que el precio menor es el máximo posible, a fin que se reemplace con el primer menor encontrado.

Se deja la pregunta c) como tarea a fin de que se desarrolle el problema usando un arreglo.

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 1Eva_IT2008_T3 Simular Precio del Petróleo
# Propuesta: edelros@espol.edu.ec
# Tarea: Realizar el literal c)

import random as rnd

# INGRESO
n = int(input('días del mes: '))

# PROCEDIMIENTO
prcmax = 150
prcmin = 130
rango  = prcmax-prcmin+1
diamenor = 1
pmenor = prcmax

dia = 1
total = 0
while (dia<=n):
    precio = int(rnd.random()*rango)+prcmin
    total  = total+precio

    if (precio<pmenor):
        diamenor = dia
        pmenor   = precio

    dia = dia+1

promedio = total/n

# SALIDA
print('promedio: ')
print(promedio)
print('día de menor precio:')
print(diamenor)

Versión Usando Arreglos:

Propuesta de solución Python: py_pdf, también en versión matlab: m_pdf

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 1Eva_IT2008_T3 Simular Precio del Petróleo
# Tema 3. Precio petroleo-Arreglo
# Propuesta: edelros@espol.edu.ec

import random as rnd
import numpy as np

# INGRESO
n = int(input('días del mes: '))

# PROCEDIMIENTO
prcmax = 150
prcmin = 130
rango  = prcmax-prcmin+1
precio = np.zeros((n+1),dtype=int)

# algoritmo del promedio
total = 0
dia   = 1
while (dia<=n):
    precio[dia] = int(rnd.random()*rango)+prcmin
    total = total + precio[dia]
    dia   = dia + 1

promedio = total/n

# algoritmo del menor
diamenor = 1
dia = 1
while (dia<=n):
    if precio[dia]<precio[diamenor]:
        diamenor = dia
    dia = dia + 1

# algoritmo precio superior al promedio
superior = 0
dia = 1
while (dia<=n):
    if precio[dia]>promedio:
        superior = superior + 1
    dia = dia + 1

# SALIDA
print('promedio: ')
print(promedio)
print('día de menor precio:')
print(diamenor)
print('días con precio sobre promedio:')
print(superior)

Resultado del algoritmo

días del mes: 30
promedio: 
140.06666666666666
día de menor precio:
14
días con precio sobre promedio:
16
>>> 

Diagrama de Flujo

Simular Precio del Petróleo 02 Simular Precio del Petróleo 03

ejercicios resueltos Python 1eva_it2008_t3 pdf

ejercicios resueltos Python 1eva_it2008_t3_flujo pdf

ejercicios resueltos Matlab 1eva_it2008_t3 pdf

s1Eva_IT2008_T2 Criba de Eratóstenes con Python

Ejercicio: 1Eva_IT2008_T2 Criba de Eratóstenes

Propuesta de solución en Python: py_pdf, también en versión matlab: m_pdf

Llenar un arreglo de marcas o tachado con la hipótesis que todos son primos(1).

# PROCEDIMIENTO
marcado = np.zeros((n+1),dtype=int)
# hipotesis: todos son primos
criba = 2
while (criba<=n):
    marcado[criba] = 1
    criba = criba+1

La prueba de hipótesis consiste en usar un indicador para el número de criba, y otro indicador i para anular marcando con cero (0) las posiciones de los múltiplos.

Inicie eliminando los múltiplos de 2, para luego cambiar a los múltiplos de 3, etc.

Mostrar como resultado solo aquellos números mantienen en marcas válidas (1).

Tarea: Analizar si es necesario hacer funcionar el algoritmo de la prueba de hipótesis hasta n o un número menor. Realizar la validación que n sea mayor que 1.

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 1Eva_IT2008_T2 Criba de Eratóstenes
# Propuesta: edelros@espol.edu.ec

import numpy as np

# INGRESO
n = int(input('primos menores que: '))

# PROCEDIMIENTO
marcado = np.zeros((n+1),dtype=int)

# hipotesis: todos son primos
criba = 2
while (criba<=n):
    marcado[criba] = 1
    criba = criba+1

# no son primos los múltiplos 
criba = 2
while (criba<=n):

    # revisa el primer múltiplo
    i = criba * 2
    while (i<=n):
        marcado[i] = 0
        i = i + criba
    criba = criba+1

# SALIDA
criba = 2
while (criba<=n):
    if marcado[criba]==1:
        print(criba)
    criba = criba+1

resultado del algoritmo

primos menores que: 30
2
3
5
7
11
13
17
19
23
29
>>> 

diagrama de flujo Criba de Eratóstenes 01

diagrama de flujo Criba de Eratóstenes 02

diagrama de flujo Criba de Eratóstenes 03


Otra forma de plantear el algoritmo

# 1ra Evaluación I Término 2008
# Tema 2. Criba de Eratóstenes
import numpy as np

# INGRESO
n = int(input('cuantos numeros analiza: '))

# PROCEDIMIENTO
# vector de números naturales
natural = np.zeros(n, dtype=int)
posicion =  0
while not(posicion>=n):
    natural[posicion] = posicion
    posicion = posicion +1

# hipotesis todos cumplen
cumple = np.ones(n,dtype = int)

# Tarea: analiza cada posición
posicion = 2
# elimina multiplos / no cumplen
contador = 2
tacha  = posicion *contador
while not(tacha>(n-1)):
    tacha  = posicion *contador
    if tacha<(n-1):
        cumple[tacha] = 0
    contador = contador +1

# SALIDA
# solo valores de la posicion 2 en adelante
print(natural[2:])
print(cumple[2:])

mostrando el siguiente resultado:

cuantos numeros analiza: 50
[ 2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19
 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37
 38 39 40 41 42 43 44 45 46 47 48 49]
[1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0
 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1]
>>> 

ejercicios resueltos Python 1eva_it2008_t2 pdf

ejercicios resueltos Matlab 1eva_it2008_t2 pdf

s1Eva_IT2008_T1 Teorema de Wilson

Ejercicio1Eva_IT2008_T1 Teorema de Wilson

Se usa el concepto de residuo de la división para determinar si el número es primo. La bandera usada es «esprimo» que inicia con el supuesto de ser verdadero ó 1.

Solo si el número resulta ser primo, se aplican las operaciones de Wilson

Instrucciones en Python

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 1Eva_IT2008_T1 Teorema de Wilson

# INGRESO
n = int(input('ingrese numero primo: '))
while not(n>0):
    n = int(input('ingrese numero positivo: '))

# PROCEDIMIENTO

# revisa esprimo 
esprimo = 1
divisor = 2
while not(divisor>=n or esprimo==0):
    r = n%divisor
    if (r == 0):
        esprimo = 0
    divisor = divisor + 1

wilson = -1
if esprimo == 1:
    
    # factorial
    factor = 1
    i = 1
    while not(i>=n):
        factor = factor*i
        i = i + 1
    
    # revisa Wilson 
    residuo = (factor + 1) % n
    if residuo == 0:
        wilson = 1
    else:
        wilson = 0

# SALIDA
print('cumple Wilson: ', wilson)

resultado del algoritmo

ingrese numero primo: 7
cumple Wilson:  1
>>> 
== RESTART: D:\Ejemplos\unprograma.py ==
ingrese numero primo: 13
cumple Wilson:  1
>>> 
== RESTART: D:\Ejemplos\unprograma.py ==
ingrese numero primo: 8
cumple Wilson:  -1
>>>