Etiqueta: ejercicio programacion python

Ejercicio: 3Eva_IT2003_T1 Raíces enteras positivas del polinomio

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

El problema se separa en sus partes principales.
Primero la función para encontrar las raíces enteras, usando un contador que
aumenta cuando encuentra que el polinomio evaluado en x tienen valor de 0.

En el programa, para ingresar el polinomio se almacenan solo los coeficientes,
el término i–ésimo también indica el exponente de coeficiente[i]*xi.

Nota: No se incluye la forma de realizar la gráfica en la solución presentara
para el examen.

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 3Eva_IT2003_T1 Raíces enteras positivas del polinomio
# propuesta de solución: edelros@espol.edu.ec

import numpy as np

def numraices(grado,coeficiente,a,b):
    encontre=0
    x = a
    while (x<=b):
        p = 0
        i = 0
        while (i<=grado):
            p = p + coeficiente[i]*(x**i)
            i = i + 1
        if (p==0):
            encontre = encontre+1
        x = x + 1
    return (encontre)

# PROGRAMA -----------------

# INGRESO
n = int(input("grado polinomio: "))
coeficiente = np.zeros(n+1,dtype=float)
for i in range(0,n+1,1):
    coeficiente[i] = float(input("coeficiente["+str(i)+"]: "))
print("Rango de busqueda: [a,b]")
a = int(input("a: "))
b = int(input("b: "))

# PROCEDIMIENTO
resultado = numraices(n,coeficiente,a,b)

# SALIDA
print("numero de raices enteras:")
print(resultado)

resultado del algoritmo

grado polinomio: 7
coeficiente[0]: 0
coeficiente[1]: -336
coeficiente[2]: 356
coeficiente[3]: 208
coeficiente[4]: -337
coeficiente[5]: 127
coeficiente[6]: 19
coeficiente[7]: 1
Rango de busqueda: [a,b]
a: -10
b: 40
numero de raices enteras:
1
>>> 

ejercicios resueltos Python mejo_it2003_t1 pdf

ejercicios resueltos Matlab mejo_it2003_t1 pdf

Ejercicio: 3Eva_IT2002_T3 Determinar productos iguales entre vendedores

Se usan listas de prueba para desarrollar el algoritmo, siendo:

vendedor1 = ['pera','manzana','uva']
vendedor2 = ['durazno','pera','naranja']

se obtiene:

ambos venden:
pera
>>> 

Tarea: Desarrollar el literal a, usando archivos.

Intrucciones en Python

# 3Eva_IT2002_T3 Determinar productos iguales entre vendedores
# desarrollo con listas, solo literal b
# Tarea, desarrollar literal a

# INGRESO
vendedor1 = ['pera','manzana','uva']
vendedor2 = ['durazno','pera','naranja']

# PROCEDIMIENTO
n = len(vendedor1)
m = len(vendedor2)
ambos = []
for i in range(0,n,1):
    for j in range(0,m,1):
        if vendedor1[i] == vendedor2[j]:
            ambos.append(i)

# SALIDA
w = len(ambos)
print('ambos venden:')
for k in range(0,w,1):
    cual = ambos[k]
    print(vendedor1[cual])

Ejercicio: 3Eva_IT2002_T1 Triunfos, empates y derrotas por Goles

Instrucciones en Python

explicación en video:

# 3Eva_IT2002_T1 Triunfos, empates y derrotas por Goles
import numpy as np

# INGRESO
goles = np.array([[0,4,2,1],
                  [5,0,3,2],
                  [0,2,0,1],
                  [1,0,2,0]])

# PROCEDIMIENTO
tamano = np.shape(goles)
n = tamano[0]
m = tamano[1]
triunfos = np.zeros(shape=(n,m),dtype=int)
ttriunfos = np.zeros(n,dtype=int)
# calcular los triunfos
i = 0
while not(i>=n):
    j = 0
    while not(j>=m):
        if (goles[i,j] > goles[j,i]):
            triunfos[i,j] = 1
            triunfos[j,i] = 0
        j = j + 1
    i = i + 1
# calcular total de triunfos
i = 0
while not(i>=n):
    j = 0
    while not(j>=m):
        ttriunfos[i] = ttriunfos[i] + triunfos[i,j]
        j = j + 1
    i = i + 1

# calcular empates
empates = np.zeros(shape=(n,m),dtype=int)
tempates = np.zeros(n,dtype=int)
i = 0
while not(i>=n):
    j = 0
    while not(j>=m):
        if (goles[i,j] == goles[j,i]) and (i!=j):
            empates[i,j] = 1
            empates[j,i] = 1
        j = j + 1
    i = i + 1
# calcular total de empates
i = 0
while not(i>=n):
    j = 0
    while not(j>=m):
        tempates[i] = tempates[i] + empates[i,j]
        j = j + 1
    i = i + 1

# Derrotas
derrotas = (n-1)*np.ones(n,dtype=int)
derrotas = derrotas - ttriunfos - tempates

# SALIDA
print(triunfos)
print(' triunfos por equipo: ')
print(ttriunfos)
print(empates)
print(' empates por equipo:')
print(tempates)
print(' derrotas por equipo:')
print(derrotas)

Ejercicio: 3Eva_IT2000_T2 Matriz: puntos por goles en campeonato

Desarrollado en Python a partir el ejercicio 3Eva_IT2002_T1 Triunfos, empates y derrotas por Goles

goles=np.array([[0, 3, 1, 2, 1],
                [1, 0, 3, 2, 3],
                [0, 2, 0, 1, 1],
                [1, 0, 2, 0, 1],
                [3, 4, 1, 2, 0]])

complementando la solución del ejercicio de triunfos empates y derrotas se obtiene para los datos ingresados:

 triunfos por equipo: 
[3 2 0 1 3]
 empates por equipo:
[0 0 1 0 1]
 derrotas por equipo:
[1 2 3 3 0]
puntos por equipo:
[ 9  6  1  3 10]
>>> 

Instrucciones en Python

# 3Eva_IT2000_T2 Matriz: puntos por goles en campeonato
import numpy as np

# INGRESO
goles=np.array([[0, 3, 1, 2, 1],
                [1, 0, 3, 2, 3],
                [0, 2, 0, 1, 1],
                [1, 0, 2, 0, 1],
                [3, 4, 1, 2, 0]])

# PROCEDIMIENTO
tamano = np.shape(goles)
n = tamano[0]
m = tamano[1]
triunfos = np.zeros(shape=(n,m),dtype=int)
ttriunfos = np.zeros(n,dtype=int)
# calcular los triunfos
i = 0
while not(i>=n):
    j = 0
    while not(j>=m):
        if (goles[i,j] > goles[j,i]):
            triunfos[i,j] = 1
            triunfos[j,i] = 0
        j = j + 1
    i = i + 1
# calcular total de triunfos
i = 0
while not(i>=n):
    j = 0
    while not(j>=m):
        ttriunfos[i] = ttriunfos[i] + triunfos[i,j]
        j = j + 1
    i = i + 1

# calcular empates
empates = np.zeros(shape=(n,m),dtype=int)
tempates = np.zeros(n,dtype=int)
i = 0
while not(i>=n):
    j = 0
    while not(j>=m):
        if (goles[i,j] == goles[j,i]) and (i!=j):
            empates[i,j] = 1
            empates[j,i] = 1
        j = j + 1
    i = i + 1
# calcular total de empates
i = 0
while not(i>=n):
    j = 0
    while not(j>=m):
        tempates[i] = tempates[i] + empates[i,j]
        j = j + 1
    i = i + 1

# Derrotas
derrotas = (n-1)*np.ones(n,dtype=int)
derrotas = derrotas - ttriunfos - tempates

# puntos totales
puntos_triunfos = ttriunfos*3
puntos_empates  = tempates*1
puntos = puntos_triunfos+puntos_empates 

# SALIDA
print(triunfos)
print(' triunfos por equipo: ')
print(ttriunfos)
print(' empates por equipo:')
print(tempates)
print(' derrotas por equipo:')
print(derrotas)
print('puntos por equipo:')
print(puntos)

Ejercicio: 3Eva_IT2000_T1 Validar caracteres tipo numérico

Resultado esperado realizando la función de usuario

>>> esnumero('a')
'no es numerico'
>>> esnumero('1')
True
>>> esnumero('15')
'varios caracteres'
>>> 

>>> tresdigitos('12a')
0
>>> tresdigitos('123')
1

Instrucciones en Python

# 3Eva_IT2000_T1 Validar caracteres tipo numérico

def esnumero(caracter):
    numeros = ['0','1','2','3','4','5','6','7','8','9']
    n = len(caracter)
    if n == 1:
        esnumerico = 'no es numerico'
        enlista = caracter in numeros
        if enlista ==1:
            esnumerico = enlista
    else:
        esnumerico = 'varios caracteres'
    return(esnumerico)

def tresdigitos(cadena):
    n = len(cadena)
    revisa = 0
    for i in range(0,n,1):
        if esnumero(cadena[i])==1:
            revisa =  revisa + 1
    sontres= 0
    if revisa ==3 and n==3:
        sontres = 1
    return(sontres)

Ejercicio: 2Eva_IIT2013_T2 Verificar secuencia ADN

Propuesta de solución en Python:

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 2Eva_IIT2013_T2 Verificar secuencia ADN
# propuesta: edelros@espol.edu.ec

def ordenados(cadena):
    n = len(cadena)
    cadena  = cadena.upper()
    validos = 'ACGT'
    pares   = 0

    # solo hasta penúltimo
    i = 0
    while not(i>=(n-1)): 
        elemento  = cadena[i]
        elemento2 = cadena[i+1]
        if (elemento<=elemento2):
            pares = pares + 1
        i = i + 1
        
    # validar elementos en cadena
    noADN = 0
    i = 0
    while not(i>=n):
        elemento = cadena[i]
        if not(elemento in validos):
            noADN = noADN - 1
        i = i + 1

    # corrige de ser necesario
    if (noADN<0): 
        pares = noADN
        
    return(pares)

Ejemplo

>>> cadena='CCGAATCGTA'
>>> ordenados(cadena)
6
>>> cadena='CBGAATCGWA'
>>> ordenados(cadena)
-2

Ejercicios: 1Eva_IIT2013_T3 Juego Semillero

Propuesta de solución en Python, realizada solo para dos jugadores.

Observe que al lanzar dos dados, el intervalo de valores posibles es [2,12].

dado1 = int(rnd.random()*6)+1
dado2 = int(rnd.random()*6)+1
suma  = dado1 + dado2

La variable quien determina el turno del jugador.

Se lanzan los dados como números aleatorios, se acumula los puntos para cada jugador y se resta la cantidad de fichas del semillero.

if (suma<=semillero):
    A = A + suma
    semillero = semillero -suma
else:
    A = A +semillero
    semillero = 0

Se cambia el turno del jugador y se repite el proceso.

    # cambia jugador
    if (quien==1):
        quien = 2
    else:
        quien = 1

TAREA: Implementar con arrreglos para n jugadores.

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 1Eva_IIT2013_T3 Juego Semillero
# usando solo dos jugadores
import random as rnd

# INGRESO
apuesta = int(input('cuantas canicas: '))
while not(apuesta>=20):
    apuesta = int(input('mas de 20 canicas: '))

# PROCEDIMIENTO
semillero = 2*apuesta
A = 0
B = 0
quien = 1
while not(semillero<=0):

    # Juega A
    if (quien==1):
        dado1 = int(rnd.random()*6)+1
        dado2 = int(rnd.random()*6)+1
        suma  = dado1 + dado2
        if (suma<=semillero):
            A = A + suma
            semillero = semillero -suma
        else:
            A = A +semillero
            semillero = 0

    # Juega B
    if (quien==2):
        suma = int(rnd.random()*11)+2
        if (suma<=semillero):
            B = B + suma
            semillero = semillero - suma
        else:
            B = B + semillero
            semillero = 0
            
    # cambia jugador
    if (quien==1):
        quien = 2
    else:
        quien = 1

# Determina ganador
gana = 1
if (A < B):
    gana = 2
if (B==A):
    gana = 0
    
# SALIDA
print('canicas de A: ', A)
print('canicas de B: ', B)
print('estado semillero: ', semillero)
print('jugador ganador: ', gana)

Ejecución del algoritmo

cuantas canicas: 20
canicas de A:  25
canicas de B:  15
estado semillero:  0
jugador ganador:  1
>>> 
cuantas canicas: 20
canicas de A:  20
canicas de B:  20
estado semillero:  0
jugador ganador:  0
>>> 
cuantas canicas: 20
canicas de A:  22
canicas de B:  18
estado semillero:  0
jugador ganador:  1
>>> 

Ejercicios: 1Eva_IIT2013_T2 Números palíndromo con Python

Literal a. Para invertir los dígitos de un número, se usan residuo y el cociente para extraer cada dígito y rearmarlo en otro número con posiciones invertidas.

Sec compara el número de forma inversa para verificar si el igual al número original, siendo solamente así un número palíndromo.

Tarea: implementar el literal b a partir de la solución del literal a.

Para iniciar la búsqueda de los números palíndromos se inicia con dos dígitos es decir numero=10. Se aplica el algoritmo al número y se repite el proceso con un lazo hasta llegar al millón-1

Instrucciones en Python

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 1Eva_IIT2013_T2 Números palíndromo

# INGRESO
numero = int(input('numero a revisar: '))

# PROCEDIMIENTO
numcopia = numero
cociente = numero

# invierte dígitos del número
invertido = 0
while not(cociente<=0):
    numcopia = cociente
    cociente = numcopia//10
    residuo  = numcopia%10
    invertido = invertido*10 + residuo

# revisa si el número es igual a invertido
if (invertido == numero):
    palindromo = 1
else:
    palindromo = 0

# SALIDA
print('numero invertido: ', invertido)
print('Palindromo:', palindromo)

Ejecución del algoritmo

numero a revisar: 1991
numero invertido:  1991
Palindromo: 1
>>> 
numero a revisar: 2112
numero invertido:  2112
Palindromo: 1
>>> 
numero a revisar: 2020
numero invertido:  202
Palindromo: 0
>>> 

Ejercicio: 2Eva_IT2013_T2 Una Tabla de Bingo con arreglos

2Eva_IT2013_T1 Función sorteoentre(k,a,b)

Propuesta de solución en Python, continua desde tema 1:

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# propuesta: edelros@espol.edu.ec

# 2Eva_IT2013_T1 Una Tabla de Bingo
import random as rnd
import numpy as np

def sorteoentre(k,a,b):
    suertudos = []
    i = 0
    while not(i>=k):
        sorteo = int(rnd.random()*(b-a+1))+a
        if not(sorteo in suertudos):
            suertudos.append(sorteo)
            i = i+1
    return(suertudos)

# 2Eva_IT2013_T2 Una Tabla de Bingo
n = 5
#Rango inicial de B [1,15]
a = 1  
b = 15
incremento = 15

# PROCEDIMIENTO
tabla = np.zeros(shape=(n,n),dtype=int)
columna = 0
while not(columna>=n):
    datos = sorteoentre(n,a,b)
    for fila in range(0,n,1):
        tabla[fila,columna]=datos[fila]
    a = a + incremento
    b = b + incremento
    columna = columna + 1
    
# corrige el cero en la posicion central
mitad = n//2
tabla[mitad,mitad] = 0

# SALIDA
print(tabla)

Ejemplo:

>>> ================================ RESTART ==========
>>> 
[[ 4 28 37 51 63]
 [15 18 45 56 74]
 [13 23  0 48 69]
 [ 2 20 34 58 72]
 [ 3 16 32 50 71]]
>>> ================================ RESTART ==========
>>> 
[[ 2 17 37 58 75]
 [13 24 45 53 65]
 [ 7 19  0 51 73]
 [15 23 36 52 69]
 [ 3 30 39 47 67]]
>>>

 

Ejercicio: 2Eva_IT2013_T1 Función sorteoentre(k,a,b)

Solución propuesta en Python, continúa en Tema 2.

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 2Eva_IT2013_T1 Una Tabla de Bingo
# propuesta: edelros@espol.edu.ec

import random as rnd
import numpy as np

def sorteoentre(k,a,b):
    suertudos = []
    i = 0
    while not(i>=k):
        sorteo = int(rnd.random()*(b-a+1))+a
        if not(sorteo in suertudos):
            suertudos.append(sorteo)
            i = i+1
    return(suertudos)

resultado del algoritmo

>>> sorteoentre(5,1,15)
[11, 14, 7, 10, 6]
>>> sorteoentre(5,16,30)
[17, 18, 26, 30, 27]
>>>