Categoría: Soluciones

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

Ejercicio: 1Eva_IT2013_T4 Tabular atención al cliente

Para el ejercicio por simplicidad, en el bloque de ingreso se tabula también la «evaluación» del cliente para el servicio en un arreglo

Propuesta de solución en Python:

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 1Eva_IT2013_T4 Tabular atención al cliente
# Tarea: literal c)
#  calcular promedio dentro de procedimiento
#  mostrar clientes con atencion menor al promedio en SALIDA
import numpy as np

# INGRESO
n = int(input('cuantos clientes: '))
atencion = np.zeros(n+1, dtype=int)
cuenta   = np.zeros(6, dtype=int) # de 0 a 5
cliente  = 1
while not(cliente>n):
    pregunta = 'CLIENTE '+str(cliente)+' evalue: '
    nota = int(input(pregunta))
    
    if (nota>=1 and nota<n):
        atencion[cliente] = nota
        cuenta[nota] = cuenta[nota] + 1
    cliente = cliente + 1

# Algoritmo Mayor
mayor = 1  
nota  = 2 
while not(nota>5):
    if (cuenta[nota]>cuenta[mayor]):
        mayor = nota
    nota = nota + 1
    
# SALIDA
print('las evaluaciones fueron: ')
print(cuenta)
print('mayor: ',mayor)
print('evaluacion [mayor]: ',cuenta[mayor])

resultado esperado:

cuantos clientes: 5
CLIENTE 1 evalue: 1
CLIENTE 2 evalue: 1
CLIENTE 3 evalue: 1
CLIENTE 4 evalue: 2
CLIENTE 5 evalue: 2
las evaluaciones fueron: 
[0 3 2 0 0 0]
mayor:  1
evaluacion [mayor]:  3
>>> 

Tarea: literal c,  calcular promedio y seleccionar clientes que presentaron evaluación menor al promedio

Ejercicio: 1Eva_IT2013_T1 Primos gemelos

Para facilitar el ejercicio, pues no se dispone de una lista de números primos, se inicia generando usa secuencia ordenada de números naturales a partir del 2 hasta el número n donde se desea realizar la observación.

Se simplifica el procedimiento de generar la secuencia usando la función de numpy para generar un rango entre un intervalo [a,b) y dando el incremento: np.arange(a,b,incremento). Siendo un lado del intervalo no incluyente, pues se define con paréntesis, se añade el límite usando n+1.

Sobre la secuencia, se usa un algoritmo de búsqueda de números primos realizado en clase para obtener un vector que tenga solo números primos. Otro ejemplo como repaso, puede revisar el ejercicio de la Criba de Eratóstenes.

La búsqueda de primos gemelos consiste en comparar dos números consecutivo del vector soloprimos. Si la diferencia entre ellos es 2, se econtraron los números buscados. La respuesta se puede dar por medio de un nuevo vector o lista, o semejante al ejercicio de la Criba de Eratóstenes se puede usar un arreglo de banderas.

Instrucciones en Python

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 1Eva_IT2013_T1 Primos gemelos
import numpy as np

# INGRESO
n = int(input('límite n: '))

# PROCEDIMIENTO
# intervalo de búsqueda de números primos
secuencia = np.arange(2,n+1,1)
tamano = len(secuencia)

# supone que todos son primos
cumple = np.ones(tamano, dtype=int)

# revisa cada número de secuencia
posicion = 0
while (posicion<tamano):
    n = secuencia[posicion]
    
    # PROCEDIMIENTO esprimo 
    esprimo = 1
    divisor = 2
    while not(divisor>=n or esprimo==0):
        r = n%divisor
        if (r == 0):
            esprimo = 0
        divisor = divisor + 1
        
    cumple[posicion] = esprimo
    posicion = posicion + 1

cuantos = np.sum(cumple)
soloprimos = np.zeros(cuantos,dtype=int)

# separa solo los primos
posicion = 0
i = 0
while not(posicion>=tamano):
    if (cumple[posicion]==1):
        soloprimos[i] = secuencia[posicion]
        i = i + 1
    posicion = posicion + 1

# SALIDA

# BUSCA GEMELOS
i = 0
while not(i>=(cuantos-1)):
    sigue = i + 1
    diferencia = soloprimos[sigue] - soloprimos[i]
    if (diferencia==2):
        print('pareja gemelo: ')
        print(soloprimos[i],soloprimos[sigue])
    i = i + 1
    
# revisando resultados
print('secuencia: ', secuencia)
print('cumple:    ', cumple)
print('soloprimos:', soloprimos)

resultado del algoritmo

pareja gemelo: 
3 5
pareja gemelo: 
5 7
secuencia  [2 3 4 5 6 7 8 9]
cumple:    [1 1 0 1 0 1 0 0]
soloprimos: [2 3 5 7]
>>>