s1Eva_IIT2018_T3 Compras ‘Black Friday’

Ejercicio: 1Eva_IIT2018_T3 Compras ‘Black Friday’

propuesta de solución, contiene tarea.

# CCPG1001 Fundamentos de Programación FIEC-ESPOL
# 1Eva_IIT2018_T3 Compras ‘Black Friday’
# Tarea: descuentosPorSección
import random as rnd
import numpy as np

def calcularPrecio(unacompra,Codigo,Precio,Descuento):
    unprecio = 0
    if (unacompra in Codigo):
        donde = Codigo.index(unacompra)
        valor = Precio[donde]
        unprecio = valor - Descuento[donde]*valor/100
    return(unprecio)

def calcularTotal(compras,Codigo,Precio,Descuento):
    m = len(compras)
    totalpagar = 0
    i = 0
    while not(i>=m):
        unacompra = compras[i]
        unprecio = calcularPrecio(unacompra, Codigo,
                                  Precio, Descuento)
        totalpagar = totalpagar + unprecio
        i = i + 1
    return(totalpagar)

def hallarSecciones(compras,Codigo,Seccion):
    m = len(compras)
    visitar = []
    i = 0
    while not(i>=m):
        unacompra = compras[i]
        donde = Codigo.index(unacompra)
        unaseccion = Seccion[donde]
        if not(unaseccion in visitar):
            visitar.append(unaseccion)
        i = i + 1
    return(visitar)

def descuentosPorSección(Descuento,Seccion):
    remate = []
    # Tarea: Desarrollar
    return(remate)
    
# INGRESO
unacompra = input('codigo de una compra: ')

# Tarea: ingresar varias compras
compras = ['SKU-5675', 'PSS-4542']
Codigo  = ['CTR-2424', 'SKU-5675', 'PSS-4542']
Precio  = [ 56.65, 32.00, 22.22]
Descuento = [0, 50, 10]
Seccion = ['Ropa Niños', 'Juguetes', 'Hombre']

# PROCEDIMIENTO
unprecio   = calcularPrecio(unacompra, Codigo,
                            Precio,Descuento)
totalpagar = calcularTotal(compras, Codigo,
                           Precio,Descuento)
visitar = hallarSecciones(compras,Codigo, Seccion)
remate  = descuentosPorSección(Descuento, Seccion)

# SALIDA
print('El precio de : ',unacompra)
print(unprecio)
print('total a pagar de lista de compras: ', totalpagar)
print('tiendas a visitar: ',visitar)
print('remate de productos por seccion: ',remate)

resultado del algoritmo

codigo de una compra: CTR-2424
El precio de :  CTR-2424
56.65
total a pagar de lista de compras:  35.998
tiendas a visitar:  ['Juguetes', 'Hombre']
remate de productos por seccion:  []
>>> 

s1Eva_IIT2018_T2 Juego conocimiento (Ahorcado)

Ejercicio: 1Eva_IIT2018_T2 Juego conocimiento (Ahorcado)

Propuesta de solución, contiene tareas por completar.

Estado del juego:  F***
 adivine una letra: C
 Adivinaste...C

Estado del juego:  FC**
turno: 1
fallas:  0
 adivine una letra: M
 Adivinaste...M

Estado del juego:  FC*M
turno: 2
fallas:  0
 adivine una letra: A
 NO es una letra de palabra...

Estado del juego:  FC*M
turno: 3
fallas:  1
 adivine una letra: N
 Adivinaste...N

Estado del juego:  FCNM
turno: 4
fallas:  1
Felicitaciones, adivinó: FCNM
>>> 

Algoritmo en Python

Siguiendo las sugerencias, para dividir y simplificar el problema, primero se crean las funciones: escondeletras(secreta) y cambialetra(secreta,letra,estado).

Se inicia con la selección aleatoria de la palabra secreta y el sorteo de la letra pista, verificando que sea consonante.

Se actualiza la palabra secreta con la letra pista, y se inicia el juego.

# CCPG1001 Fundamentos de Programación FIEC-ESPOL
# 1Eva_IIT2018_T2 Juego conocimiento (Ahorcado)
# propuesta de solución: edelros@espol.edu.ec
# tarea: indiferente usar mayúsculas/minúsculas
#        contar solo letras adivinadas, no repetidas

import numpy as np
import random as rnd

def escondeletras(secreta):
    estado = ''
    n = len(secreta)
    i = 0
    while not(i>=n):
        estado = estado + '*'
        i = i + 1 
    return(estado)

def cambialetra(secreta,letra,estado):
    nuevoestado = ''
    n = len(secreta)
    i = 0
    while not(i>=n):
        if (secreta[i]==letra):
            nuevoestado = nuevoestado + letra
        else:
            nuevoestado = nuevoestado + estado[i]
        i = i + 1
    return(nuevoestado)

# PROGRAMA JUEGO
# selecciona secreta
palabras = ['ESPOL','FCNM','FIEC','FIMCP','FICT']
n = len(palabras)
sorteo  = int(rnd.random()*n)+0
secreta = palabras[sorteo]

# estado inicial del juego
estado = escondeletras(secreta)

# una letra como pista
consonante = 'BCDFGHJKLMNPQRSTVWXYZ'
m = len(secreta)
sorteo = int(rnd.random()*m)+0
pista = secreta[sorteo]
while not(pista in consonante):
    sorteo = int(rnd.random()*m)+0
    pista  = secreta[sorteo]
    
# actualiza estado del juego
estado = cambialetra(secreta,pista,estado)

# Control del Juego
turnomax = 2*m
gana  = 1
falla = 0
print('Estado del juego: ', estado)

turno = 1
while not(turno>turnomax or gana==m):
    letra = input(' adivine una letra: ')
    if (letra in secreta):
        gana    =  gana +1
        estado  = cambialetra(secreta,letra, estado)
        mensaje = ' Adivinaste...' + letra
    else:
        falla   = falla + 1
        mensaje = ' NO es una letra de palabra...'
    
    print(mensaje)
    print()
    print('Estado del juego: ', estado)
    print('turno:', turno)
    print('fallas: ', falla)
    turno = turno + 1

if (turno<=turnomax and gana==m):
    mensaje = 'Felicitaciones, adivinó: ' + secreta
else:
    mensaje = 'lo lamento, perdió..., la palabra era: '
    mensaje = mensaje + secreta

# SALIDA
print(mensaje)

Recuerde que se ha dejado como tarea, realizar las instrucciones para complir que:
– sea indiferente usar mayúsculas/minúsculas
– contar solo letras adivinadas, no repetidas

s1Eva_IT2018_T1 Busca especie con ADN

Ejercicio: 1Eva_IT2018_T1 Busca especie con ADN

Propuesta de solución en Python:

las secuencias que pertenecen son:  1
Secuencia:  ATTTGCTTGCTATTTAAACCGGTTATGCATAGCGC
indices de inversa: [0, 2, 7, 25, 29]
>>> 

Algoritmo en Python

# CCPG1001 Fundamentos de Programación FIEC-ESPOL
# 1Eva_IT2018_T1 Busca especie con ADN
# propuesta de solución: edelros@espol.edu.ec

# INGRESO
Listado = ['ATTTGCTTGCTATTTAAACCGGTTATGCATAGCGC', 
           'ATTAGCCGCTATCGA']
Referencia = 'CG'

# PROCEDIMIENTO
n = len(Listado)
tref = len(Referencia)
pertenece = []

i = 0
while not(i>=1):
    secuencia = Listado[i]
    indices   = []
    
    # calcula la inversa
    m = len(secuencia)
    inversa = ''
    j = m-1
    while not(j<0):
        inversa = inversa + secuencia[j]
        j = j-1
        
    # Analiza las partes, mitad
    mitad  = m//2
    veces1 = 0
    veces2 = 0
   
    j = 0    # primera mitad
    while not(j>=mitad):
        seccion = inversa[j:j+tref]
        if (seccion == Referencia):
            veces1 = veces1 + 1
            indices.append(j)
        j = j + 1

    j = mitad    # segunda mitad
    while not(j>=m):
        seccion = inversa[j:j+tref]
        if (seccion == Referencia):
            veces2 = veces2 + 1
            indices.append(j)
        j = j + 1

    # Revisa si pertenece a especie
    total = veces1 + veces2
    if (veces2==2 and total>=4):
        pertenece.append([secuencia, indices])

    # siguiente secuencia de listado
    i = i + 1 

# SALIDA
# print(pertenece)
tp = len(pertenece)
print('las secuencias que pertenecen son: ', tp)
i = 0
while not(i>=tp):
    print('Secuencia: ',pertenece[i][0])
    print('indices de inversa:',pertenece[i][1])
    i = i + 1

Tarea: Convertir a funciones las secciones de:

– Inversa de la secuencia creainversa(secuencia)

– Conteo de referencias en mitades de secuencia cuentareferencia(mitadsecuencia)

– Crear vector de índices donde se encuentra la referencia entregaindices(inversa)

s1Eva_IT2018_T2 Desempeño de jugadores mundial futbol

Ejercicio: 1Eva_IT2018_T2 Desempeño de jugadores mundial futbol

Propuesta de solución en Python:

Revisar las sugerencias en el enunciado, dividir el problema y simplificar las tablas para las pruebas de algoritmos, con lo que que se obtiene:

a) el pais con mas goles promedio:  Argentina
b) los jugadores efectivos de:  Brasil 0
c) jugadores amarrabalon:  ['Lionel Messi']
d) jugador con más pases acertados:  Lionel Messi
e) promedios mundiales:  [  33.66666667   88.33333333   64.          179.33333333]
f) : Lionel Messi no está por encima del promedio mundial
>>> 

visualizar la tabla de paises_jugadores es:

>>> pais_jugadores
[['Cristiano Ronaldo'], 
 ['Neymar Jr.'], 
 ['Lionel Messi']]

las instrucciones desarrolladas por literal son:

# CCPG1001 Fundamentos de Programación FIEC-ESPOL
# 1Eva_IT2018_T2 Desempeño de jugadores mundial futbol
import numpy as np

# INGRESO
desempeno = np.array([[ 32, 24, 45],
                      [ 90, 84, 91],
                      [ 54, 60, 78],
                      [187,239,112]])

paises = ['Portugal', 'Brasil', 'Argentina']
prtgl  = ['Cristiano Ronaldo']
brsl   = ['Neymar Jr.' ]
argntn = ['Lionel Messi']

pais_jugadores = [prtgl, brsl, argntn]

analizapais = 'Brasil'
analizaposeebalon = 76
analizajugador = 'Lionel Messi'

# PROCEDIMIENTO
tamano = np.shape(desempeno)
tdf    = tamano[0]
tdc    = tamano[1]
tp     = len(paises)

# tabla ubicapais[unpais] = [desde,hasta,cuantos]
ubicapais = np.zeros(shape=(tp,3),dtype=int)
desde  = 0
unpais = 0
while not(unpais>=tp):
    jugadores = pais_jugadores[unpais]
    cuantos   = len(jugadores)
    hasta     = desde + cuantos
    ubicapais[unpais,0] = desde
    ubicapais[unpais,1] = hasta
    ubicapais[unpais,2] = cuantos
    desde  = hasta
    unpais = unpais + 1
    
# Agrupa jugadores
todosjugadores = []
unpais =  0
while not(unpais>=tp):
    jugadores = pais_jugadores[unpais]
    cuantos   = len(jugadores)
    quien = 0
    while not(quien>=cuantos):
        todosjugadores.append(jugadores[quien])
        quien = quien + 1
    unpais = unpais +1

# a) pais con mas goles promedio
fila = 0 # fila goles anotados
golesanotados = desempeno[fila]
prmGolAnota = np.zeros(tp,dtype = float)
unpais = 0
while not(unpais>=tp):
    desde   = ubicapais[unpais,0]
    hasta   = ubicapais[unpais,1]
    cuantos = ubicapais[unpais,2]
    
    golpais = golesanotados[desde:hasta]
    prmGolAnota[unpais] = np.sum(golpais)/cuantos
    
    unpais = unpais + 1
    
goleador = np.argmax(prmGolAnota)
nombregoleador = paises[goleador]

# b) Contar jugadores con mayor efectividad
# al promedio de analizapais
# donde = paises.index(buscapais)
donde  = -1
unpais = 0
while not(unpais>=tp or donde>=0):
    if (paises[unpais] == analizapais):
        donde = unpais
    unpais = unpais + 1

# efectividad del pais analizado
fila = tdf-1 # tiros al arco (última de desempeno)
tirosdirectos = desempeno[fila]

desde = ubicapais[donde,0]
hasta = ubicapais[donde,1]

anotados = golesanotados[desde:hasta]
directos = tirosdirectos[desde:hasta]
efectivopais = np.sum(anotados)/np.sum(directos)

#jugadores efectivos del pais analizado
cuentaefectivos = 0
quien = desde
while not(quien>=hasta):
    unaefectividad = golesanotados[quien]/tirosdirectos[quien]
    if (unaefectividad > efectivopais):
        cuentaefectivos = cuentaefectivos+1
    quien = quien + 1

# c) posesion balón
fila = 2 # fila de posesión de balón
poseebalon = desempeno[fila]
amarrabalon = []
quien = 0
while not(quien>=tdc):
    if (poseebalon[quien]>analizaposeebalon):
        amarrabalon.append(todosjugadores[quien])
    quien = quien +1
    
# d) jugador con más pases acertados
fila = tdf-2
pasesacertados = desempeno[fila]
quienacierta   = np.argmax(pasesacertados)
nombreacierta  = todosjugadores[quienacierta]

# e) promedios mundiales
promediomundial = np.sum(desempeno,axis =1)/tdc

# f) jugadores superior a promedio mundial
# donde = todosjugadores.index(analizajugador)
donde = -1
quien = 0
while not(unpais>=tp or donde>=0):
    if (todosjugadores[quien] == analizajugador):
        donde = unpais
    quien = quien + 1

# verifica cumplimiento de parámetros
cumple = ' está '
fila = 0
while not(fila>=tdf):
    caracteristica = desempeno[fila,donde]
    if (caracteristica< promediomundial[fila]):
        cumple = ' no está '
    fila = fila+1
mensaje = analizajugador + cumple + 'por encima del promedio mundial'

# SALIDA
print('a) pais con mas goles promedio: ', nombregoleador)
print('b) jugadores efectivos de: ', analizapais, cuentaefectivos)
print('c) jugadores amarrabalon: ', amarrabalon)
print('d) jugador con más pases acertados: ', nombreacierta)
print('e) promedios mundiales: ', promediomundial)
print('f) :', mensaje)

Tarea: Realice las modificaciones necesarias para realizar las funciones para las secciones de:

– crear tabla ubicapais(paises_jugadores)

agrupajugadores(paises_jugadores)

use las funciones realizadas en el programa.

Considerar cuando la respuesta de los algoritmos de búsqueda es -1, no se encontró el elemento en el conjunto. En la propuesta no se valida ésta situación, por ejemplo, si se pone ‘espana’ y no se eneuentra en la tabla.

s1Eva_IIT2017_T3 Venta combustibles

Ejercicio: 1Eva_IIT2017_T3 Venta combustibles

Propuesta de solución en Python:

Se usan datos de prueba para probar la ejecución del algoritmo por cada literal. En el bloque de ingreso se pide solo un tipo de combustible (literal a) y una ciudad (literal b).

Se usa vector.index(dato) para ubicar la posición de un dato en el vector.

Como algunas respuestas tienen un número indeterminado de elementos se usan listas, al inicio vacias. Revise el uso de np.concatenate() para hacerlo con arreglos.

# CCPG1001 Fundamentos de Programación FIEC-ESPOL
# 1Eva_IIT2017_T3 Venta combustibles
import numpy as np

# INGRESO
venta = np.array([
    [ 239034,  678493,  896321,   32438,  554213],
    [4568321, 6745634, 9754008, 3242342, 3456123],
    [ 234773,   56743,  123678,    4783,   90874],
    [  45672,   45212,   90781,    3904,   90431]])

tipoGasolina = np.array(['Regular',
                         'Extra',
                         'Super',
                         'Premium'])

gasolinera  = np.array(['Primax Alborada',
                        'PS Los Ríos',
                        'Móbil Cumbayá',
                        'Lutexa Cia Ltda',
                        'PS Remigio Crespo'])

distrito = np.array(['distrito1',
                     'distrito2',
                     'distrito1',
                     'distrito2',
                     'distrito4'])

ciudad =  np.array(['Guayaquil',
                    'Babahoyo',
                    'Quito',
                    'Guayaquil',
                    'Cuenca'])

meta = 5000000

untipo    = input('un tipo de gasolina: ')
unaciudad = input('una ciudad: ')

# PROCEDIMIENTO
tipoGasolina = list(tipoGasolina)
gasolinera   = list(gasolinera)
distrito = list(distrito)
ciudad   = list(ciudad)

tamano = np.shape(venta)
n = tamano[0]
m = tamano[1]

# literal a
cual     = tipoGasolina.index(untipo)
cantidad = venta[cual,:]
prom_anual =  np.sum(cantidad)/m
menosprom  = []
for c in range(0,m,1):
    if (cantidad[c]<prom_anual):
        menosprom.append(gasolinera[c])

# literal b
cual  = ciudad.index(unaciudad)
anual = np.sum(venta, axis=0)
menosciudad = []
for c in range(0,m,1):
    if (ciudad[c] == unaciudad  and anual[c]<meta):
        menosciudad.append(gasolinera[c])
cuantas = len(menosciudad)

# literal c
cual = tipoGasolina.index('Premium')
cantidad = venta[cual,:]
nombres = []
valores = []
for c in range(0,m,1):
    if (distrito[c] == 'distrito2'):
        nombres.append(ciudad[c])
        valores.append(cantidad[c])

k = len(nombres)
mayor = np.argmax(np.array(valores))
mejorendistrito = nombres[mayor]

# SALIDA
print('literal a')
print('con menos ventas anuales que promedio: ')
print(menosprom)

print('literal b')
print('cantidad de estaciones de ' + unaciudad + ': ')
print(cuantas)

print('literal c')
print(nombres)
print(valores)
print(mejorendistrito)

Resultado del algoritmo

un tipo de gasolina: Regular
una ciudad: Guayaquil
literal a
con menos ventas anuales que promedio: 
['Primax Alborada', 'Lutexa Cia Ltda']
literal b
cantidad de estaciones de Guayaquil: 
1
literal c
['Babahoyo', 'Guayaquil']
[45212, 3904]
Babahoyo
>>> 

s1Eva_IIT2017_T1 Taller de juguetes en polo norte

Ejercicio: 1Eva_IIT2017_T1 Taller de juguetes en polo norte

Propuesta de solución en Python:

Los tiempos para finalizar las tareas se obtienen como la suma de los tiempos de inicio mas los tiempos de duración.

Para realizar la mayor cantidad de tareas, se usan los tiempos para finalizarlas, buscando la posición en la lista de la mayor. Al encontrarla se puede establecer el orden.

El proceso se repite para el resto de tareas, para que no se utilice la primera encontrada se elimina de la lista haciendo asignando el tiempo final con cero.

 

# CCPG1001 Fundamentos de Programación FIEC-ESPOL
# 1Eva_IIT2017_T1 Taller de juguetes en polo norte
import numpy as np

# INGRESO
tareas = ['pintar soldados',
          'hornear galletas',
          'armar muñecos',
          'cortar papel de regalo']
inicio   = [ 678, 200, 240, 423]
duracion = [ 300, 800, 456, 112]

# PROCEDIMIENTO
n = len(tareas)

# tiempo finaliza tarea
final = np.zeros(n,dtype=int)
i = 0
while not(i>=n):
    final[i] = inicio[i] + duracion[i]
    i = i + 1

# Determina el orden
finaliza = np.copy(final)
orden = np.zeros(n,dtype = int)
j = 0
while not(j>=n):
    
    mayor = 0
    i = 1
    while not(i>=n):
        if (final[i]>final[mayor]):
            mayor = i
        i = i + 1
    
    orden[j] = mayor
    final[mayor] = 0
    j = j + 1
    
# dias de trabajo
dia  = np.zeros(n,dtype = int)
cual = 1
suma = 0
j = 0
while not(j>=n):
    suma = suma + finaliza[j]
    if (suma>=1440):
        cual = cual + 1
        suma = finaliza[j]
    dia[j] = cual
    j = j + 1
   
# SALIDA
print('finaliza')
print(finaliza)

print('Tareas del dia')
s = 0
i = 0
while not(i>=n):
    cual = orden[i]
    s = s + finaliza[cual]
    print(i, cual, tareas[cual], s, dia[i])
    i = i + 1

Resultado del algoritmo

finaliza
[ 978 1000  696  535]
Tareas del dia
0 1 hornear galletas 1000 1
1 0 pintar soldados 1978 2
2 2 armar muñecos 2674 3
3 3 cortar papel de regalo 3209 3
>>> 

s1Eva_IIT2017_T2 Examen de sangre

Ejercicio: 1Eva_IIT2017_T2 Examen de sangre

Propuesta de solución en Python:

Para simplificar el ejercicio, se supondrá que el resultado corresponde al texto del ejemplo en el enunciado:

resultado = «Resultado de Laboratorio ‘Su Salud’ Nombre del paciente: José Aimas E-mail del paciente: jose.aimas@gmail.com Resultados del laboratorio: INR 1.25 segundos BGT 180.12 mmol/dL HGB 13 g/dL ESR 3.2 mm/hora RBC 4000024.2 cel/ul TA 1.5 ng/dL WBC 123233.23 cel/uL. Los valores de éste informe no representan un diagnóstico. Firma médico responsable: Dr. Juan Pozo»

El texto se analiza separando las partes usando los espacios ‘  ‘.

Se analiza cada una de las partes, considerando que los «indicadores buscados» tienen todas las letras en mayúsculas a diferencia del resto de partes o palabras. Por lo que se compara la conversión de la parte en mayúsculas y su forma original, si son iguales se encontró un indicador. Considere que si la parte es numérica, no se afecta al convertir en mayúscula.

Al encontrar un indicador, se lo separa en otra lista de solo indicadores.

# CCPG1001 Fundamentos de Programación FIEC-ESPOL
# 1Eva_IIT2017_T2 Examen de sangre
# Tarea: Encontrar nombre del médico

# INGRESO
resultado = "Resultado de Laboratorio 'Su Salud' Nombre del paciente: José Aimas E-mail del paciente: jose.aimas@gmail.com Resultados del laboratorio: INR 1.25 segundos BGT 180.12 mmol/dL HGB 13 g/dL ESR 3.2 mm/hora RBC 4000024.2 cel/ul TA 1.5 ng/dL WBC 123233.23 cel/uL. Los valores de éste informe no representan un diagnóstico. Firma médico responsable: Dr. Juan Pozo"

# PROCEDIMIENTO
partes = resultado.split(' ')
n = len(partes)

# Encontrar indicadores
numero = '0123456789'
indicador = []
i = 0
while not(i>=n):
    mayusculas   = partes[i].upper()
    sinconvertir = partes[i]
    unapalabra   = partes[i]
    unaletra     = unapalabra[0]
    if (mayusculas==sinconvertir and not(unaletra in numero)):
        indicador.append(partes[i])
    i = i + 1
m = len(indicador)

# Busca por indicadores
valor  = []
unidad = []
k = 0
while not(k>=m):
    i = 0
    while not(i>=n):
        if (partes[i]==indicador[k]):
            valor.append(partes[i+1])
            unidad.append(partes[i+2])
        i = i + 1
    k = k + 1

# SALIDA
print('INFORME DE LABORATORIO')
print('**********************')
i = 0
while not(i>=m):
    print(indicador[i],valor[i],unidad[i])
    i = i + 1

Resultado del algoritmo

INFORME DE LABORATORIO
**********************
INR 1.25 segundos
BGT 180.12 mmol/dL
HGB 13 g/dL
ESR 3.2 mm/hora
RBC 4000024.2 cel/ul
TA 1.5 ng/dL
WBC 123233.23 cel/uL.
>>> 

s1Eva_IT2017_T1 Palabras puntaje

Ejercicio: 1Eva_IT2017_T1 Palabras puntaje

Propuesta de solución en Python, revisar tema indicado como tarea:

Para iniciar el algoritmo se presenta un ejemplo de lo que se quiere de resultado del algoritmo: mostrar cada palabra y su puntaje.

Al final se muestra la palabra que obtuvo mayor puntaje.

palabra, puntaje:
CAS*A* 6
S*ASTR*E* 6
R*EY* 6
A*ZOTE* 14
Mayor puntaje: 
A*ZOTE* 14
>>> 

Algoritmo en Python

En el bloque de ingreso se ha optado por incluir las palabras del ejercio enunciado.

Para simplificar la identificación de las letras se convierten todas a mayusculas en caso que el usuario las escriba en minúsculas. Se utiliza un contador de «puntos» por cada «palabra».

Luego se procesa cada palabra, analizando cada letra para encontrar su puntaje equivalente.

# 1ra Evaluación I Término 2017
# Tema 1. puntaje de palabras
# Tarea: considere los '*'como doble puntaje
#        para letra anterior
import numpy as np

# INGRESO
# variaspalabras = input('Analizar: ')
variaspalabras ='CAS*A*,S*ASTR*E*,R*EY*,A*ZOTE*'

# PROCEDIMIENTO
abecedario = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
equivale = [1,3,3,2,1,4,2,4,1,9,5,1,3,1,1,3,
            10,1,1,1,1,4,4,9,4,10]

# unifica a mayúsculas
variaspalabras = variaspalabras.upper()

# separa las palabras por ','
palabras = variaspalabras.split(',')

n = len(palabras)

# arreglo de puntos por cada palabra
puntos = np.zeros(n,dtype=int)

i = 0
while (i<n):
    unapalabra = palabras[i]
    m = len(unapalabra)

    # Analiza palabra, letra por letra
    j = 0
    while (j<m):
        letra = unapalabra[j]
        if (letra in abecedario):
            donde = abecedario.index(letra)
            puntos[i] = puntos[i]+equivale[donde]
        j = j+1 # siguiente letra
    
    i = i+1  #siguiente palabra

# encuentra posición del máximo puntaje
cual = np.argmax(puntos)

# SALIDA
print('palabra, puntaje: ')
i = 0
while (i<n):
    print(palabras[i],puntos[i])
    i = i+1

print('Mayor puntaje: ')
print(palabras[cual],puntos[cual])

s1Eva_IT2017_T2 suscriptores de youtubers

Ejercicio: 1Eva_IT2017_T2 suscriptores de youtubers

Propuesta de solución en Python, procedimiento desarrollado por literal

# CCPG1001 Fundamentos de Programación FIEC-ESPOL
# 1Eva_IT2017_T2 suscriptores de youtubers
import numpy as np

# INGRESO
matriz = np.array([
    [  24771906, 5477807839,  21900,   262800],
    [ 184551280, 7046108694,  45500,   546000],
    [     76493,     798122,     36,      430],
    [    133538,   21104851,    156,     1900],
    [  18554394, 1967543913,   6700,    80000],
    [  12548964, 2034702069,  12200,    12200]])

espana  = ['elrubiosOMG','VEGETTA777']
ecuador = ['enchufetvLIVE','Kreizivoy']
mexico  = ['Yuya','Werevertumorro']

# PROCEDIMIENTO

# Literal a) ********
tamano = np.shape(matriz)
n = tamano[0]
m = tamano[1]

rentabilidad = np.zeros(n,dtype=float)
f = 0
while not(f>=n):
    rentabilidad[f] = matriz[f,m-1]/matriz[f,0]
    f = f + 1

cualganamas = np.argmax(rentabilidad)

todos = espana + ecuador + mexico
quienganamas = todos[cualganamas]

dondees = 'español'
if quienganamas in ecuador:
    dondees = 'ecuatoriano'
if quienganamas in mexico:
    dondees = 'mexicano'

# SALIDA
print('literal a: ')
print(rentabilidad)
print('el mas rentable es: ',cualganamas)
print('quien es mas rentable: ',quienganamas)
print('del pais: ', dondees)


# Literal b: ********
# Solo trabajo con espana
nsp = len(espana)
datoespana = matriz[0:nsp,:]
rentasp = datoespana[:,m-1]/datoespana[:,0]
cualsp  = np.argmax(rentasp)
quiensp = espana[cualsp]

# SALIDA b)
print('para espana: ')
print(cualsp)
print(quiensp)

# literal c) ********
ecmx=matriz[nsp:,0]
popecmx    = np.argmax(ecmx)
cuantoecmx = np.max(ecmx)

ganan = 0
suscritosp = matriz[0:nsp,0]
f = 0
while not(f>=nsp):
    if (suscritosp[f]>cuantoecmx):
        ganan = ganan + 1
    f = f + 1
    
# SALIDA c)
print('tienen mas en espana: ',ganan)

# literal d) ********
reproduce = matriz[:,1]
cuantosrp = 0
totalrp = 0
f = 0
while not(f>=n):
    if (reproduce[f]>1000000):
        cuantosrp = cuantosrp+1
        totalrp   = totalrp + reproduce[f]
    f = f + 1
promrp = totalrp/cuantosrp

# SALIDA d)
print('promedio mas un millon: ',promrp)
a=len(espana)
rentaec = rentabilidad[a:a+len(ecuador)]

resultado del algoritmo

literal a: 
[0.01060879 0.00295853 0.00562143 0.01422816 0.00431165 0.00097219]
el mas rentable es:  3
quien es mas rentable:  Kreizivoy
del pais:  ecuatoriano
para espana: 
0
elrubiosOMG
tienen mas en espana:  2
promedio mas un millon:  3309453473.2
>>> 

s1Eva_IIT2016_T1 Analiza una frase por vocales y consonantes

Ejercicio: 1Eva_IIT2016_T1 Analiza una frase por vocales y consonantes

Propuesta de solución en Python, para:

texto = 'Algunas Palabras pArA contar en un programa con algo de Python'

Igual número de consonantes y vocales: 
5
>>>

Para facilitar el trabajo con el texto, se convierten todas las letras a mayúsculas (upper).

En principio, se considera que las palabras se separan solo por espacios ‘  ‘, separando las palabras mediante split(‘  ‘). Queda como tarea considerar otras formas de separar palabras con ‘,’ y ‘.’

Las vocales y consonantes se referencian con los caracteres en mayúsculas.

El análisis se realiza por cada palabra, luego por cada letra, realizando el conteo de cada vocal y consonante.

El resultado se obtiene al comparar los contadores de vocal y consonante.

Algoritmo en Python

# CCPG1001 Fundamentos de Programación FIEC-ESPOL
# 1Eva_IIT2016_T1 Analiza frase por vocales y consonantes
# Solución propuesta: edelros@espol.edu.ec

# INGRESO
# texto = input('frase: ')
texto = 'Algunas Palabras pArA contar en un programa con algo de Python'

# PROCEDIMIENTO

# unificando todo mayúsculas
texto = texto.upper()

# Separa palabras por espacios
# Tarea: considerar ',' y '.'
partes = texto.split(' ')
m = len(partes)

vocales = 'AEIOU'
consonantes = 'BCDFGHJKLMNPQRSTVWXYZ'

cuenta = 0
j = 0
while not(j>=m):
    palabra = partes[j]

    # Analiza una palabra
    n = len(palabra)
    cvocal = 0  # contador vocal
    cconso = 0

    i=0
    while not(i>=n):
        letra = palabra[i]
        if letra in vocales:
            cvocal = cvocal + 1
        else:
            cconso = cconso + 1
        i = i + 1

    if (cvocal==cconso):
        cuenta = cuenta + 1
    j = j + 1

# SALIDA
print('Igual número de consonantes y vocales: ')
print(cuenta)