Etiqueta: ejercicios resueltos python

  • s1Eva_IIT2005_T4 Juego escaleras y serpientes

    Ejercicio: 1Eva_IIT2005_T4 Juego escaleras y serpientes

    Algoritmo: [ mientras-repita ] [ repita-hasta ] ; [ diagrama flujo ]escaleraserpiente

    En un primer bosquejo, no se considera el lanzar la moneda para ver cuál jugador inicia, semejante al ajedrez en que las fichas blancas salen primero sin considerar el nombre del jugador.

    Para determinar las posiciones de las fichas en el tablero, se usarán acumuladores para cada jugador A y B, usando como variables “fichaa” y “fichab”.

    # jugador A
    dadoa = int(rnd.random()*6)+1
    fichaa = fichaa + dadoa
    

    Serán necesarios otras variables como el contador para el turno, cada jugador dispondrá de una variable generada de forma aleatoria dadoa, dadob, que simula un dado de 6 caras.

    Se lanza el dado para el jugador A, se avanza acumulando conforme a los puntos del dado, se valida el premio o castigo para luego repetir el proceso para el jugador B, repitiendo el proceso hasta que alguna ficha se ubique o pase la casilla de “llegada”.

        if (fichaa==4 or fichaa==9 or fichaa==29 or fichaa==34 or fichaa==46):
            fichaa = fichaa + 3
        if (fichaa==8 or fichaa==19 or fichaa==38 or fichaa==50 or fichaa==60):
            fichaa = fichaa - 3
    

    Terminado el proceso anterior, se determina cuál jugador ganó, observe que se supone que gana tiene inicialmente el valor de 0, para tener la opción de registrar un empate.

    Al final se muestran los resultados del juego simulado.

    Tarea: Resolver con el lanzamiento de la moneda para ver cuál inicia.

    Algoritmo: [ mientras-repita ] [ repita-hasta ] ; [ diagrama flujo ]

    ..


    Algoritmo en Python: Mientras-Repita

    Primero se presenta la solución usando lazo “Mientras-Repita”, luego se muestra la versión con el lazo “Repita-Hasta” que se puede escribir en otros lenguajes de programación.

    # ICM00794-Fundamentos de Computación - FCNM-ESPOL
    # 1Eva_IIT2005_T4 Juego escaleras y serpientes
    # Propuesta de solución: edelros@espol.edu.ec
    
    import random as rnd
    
    # INGRESO
    # Sortear quién empieza
    
    # PROCEDIMIENTO
    llegada = 64
    fichaa = 0
    fichab = 0
    
    turno = 0
    while (fichaa<llegada or fichab<llegada):
    
        # jugador A
        dadoa = int(rnd.random()*6)+1
        fichaa = fichaa + dadoa
        if (fichaa==4 or fichaa==9 or fichaa==29 or fichaa==34 or fichaa==46):
            fichaa = fichaa + 3
        if (fichaa==8 or fichaa==19 or fichaa==38 or fichaa==50 or fichaa==60):
            fichaa = fichaa - 3
    
        #jugador B
        dadob = int(rnd.random()*6)+1
        fichab = fichab + dadob
        if (fichab==4 or fichab==9 or fichab==29 or fichab==34 or fichab==46):
            fichab = fichab + 3
        if (fichab==8 or fichab==19 or fichab==38 or fichab==50 or fichab==60):
            fichab = fichab - 3
    
        turno = turno + 1
    
    # Revisa ganador
    gana = 0
    if fichaa > fichab:
        gana = 1
    if fichab > fichaa:
        gana = 2
    
    # SALIDA
    print('gana el jugador: ')
    print(gana)
    print('turnos jugados:')
    print(turno)
    

    Ejecución del algoritmo

    gana el jugador: 
    2
    turnos jugados:
    16
    >>> 
    gana el jugador: 
    2
    turnos jugados:
    16
    >>> 
    

    Algoritmo: [ mientras-repita ] [ repita-hasta ] ; [ diagrama flujo ]
    ..


    Algoritmo en Python: Repita-Hasta

    # ICM00794-Fundamentos de Computación - FCNM-ESPOL
    # 1Eva_IIT2005_T4 Juego escaleras y serpientes
    # Propuesta de solución. edelros@espol.edu.ec
    
    import random as rnd
    
    # INGRESO
    # Sortear quién empieza 
    # PROCEDIMIENTO
    
    llegada = 64
    fichaa = 0
    fichab = 0
    
    turno = 0
    while not(fichaa>=llegada or fichab>=llegada):
    
        # jugador A
        dadoa = int(rnd.random()*6)+1
        fichaa = fichaa+dadoa
        if (fichaa==4 or fichaa==9 or fichaa==29 or fichaa==34 or fichaa==46):
            fichaa = fichaa+3
        if (fichaa==8 or fichaa==19 or fichaa==38 or fichaa==50 or fichaa==60):
            fichaa = fichaa - 3
    
        #jugador B
        dadob = int(rnd.random()*6)+1
        fichab = fichab + dadob
        if (fichab==4 or fichab==9 or fichab==29 or fichab==34 or fichab==46):
            fichab = fichab + 3
        if (fichab==8 or fichab==19 or fichab==38 or fichab==50 or fichab==60):
            fichab = fichab - 3
    
        turno = turno+1
    
    gana = 0
    if fichaa>fichab:
        gana = 1
    
    if fichab>fichaa:
        gana = 2
    
    # SALIDA
    print('gana el jugador: ')
    print(gana)
    print('turnos jugados:')
    print(turno)
    

    Algoritmo: [ mientras-repita ] [ repita-hasta ] ; [ diagrama flujo ]
    ..


    Diagrama de Flujo

     

    Algoritmo: [ mientras-repita ] [ repita-hasta ] ; [ diagrama flujo ]

    Propuesta de solución:

    ejercicios resueltos Python parc_iit2005_t4 pdf

    ejercicios resueltos Matlab parc_iit2005_t4 pdf

  • s1Eva_IIT2005_T3 Entrenamiento atleta: promedios

    Ejercicio: 1Eva_IIT2005_T3 Entrenamiento atleta: promedios

    [ algoritmo ] [ diagrama flujo ]

    Pedir la cantidad de mediciones n a tabular

    n = int(input('¿días a cronometrar?: '))
    

    Ingresar todos los tiempos en un arreglo de n elementos.

    # Inicia tabla de tiempos
    tiempo = np.zeros((n+1),dtype=int)
    dia = 1
    while (dia<=n):
        print('tiempo[' + str(dia) + ']: ')
        tiempo[dia] = float(input(''))
        dia = dia + 1
    

    Empezar con el promedio anual, acumular en s todos los tiempos.

    # Promedio anual
    s = 0
    dia = 1
    while (dia<=n):
        s = s + tiempo[dia]
        dia = dia+1
    

    El promedio anual se obtiene con la suma s al dividirla para n.

    pranual = s/n

    Para el promedio mensual, desarrollar el algoritmo para el primer mes (día 1 al 30) y luego revisar la relación que existe entre el primer día del mes y el número del mes, revisar también para el último día del mes.

    Determinar la relación también para los días de la semana y el número de la semana, comparar resultados.

    Tarea: completar el algoritmo, pues la solución propuesta no desarrolla el promedio semanal.

    En el caso de Python, es necesario declarar el vector, al menos con valores de 0. Como la primera posición del arreglo es 0 y no existe el día 0, se aumentará el tamaño del vector en 1, a fin de usar el indicador de día de forma más natural.

    Se requiere importar la librería Numpy, para trabajar con los arreglos.

    [ algoritmo ] [ diagrama flujo ]
    ..


    Algoritmo en Python

    # ICM00794-Fundamentos de Computación - FCNM-ESPOL
    # 1Eva_IIT2005_T3 Entrenamiento atleta: promedios
    # Propuesta de solución. edelros@espol.edu.ec
    # Tarea: realizar promedio por semana
    
    import numpy as np
    
    # INGRESO
    n = int(input('¿días a cronometrar?: '))
    
    # Inicia tabla de tiempos
    tiempo = np.zeros((n+1),dtype=int)
    dia = 1
    while (dia<=n):
        print('tiempo[' + str(dia) + ']: ')
        tiempo[dia] = float(input(''))
        dia = dia + 1
    
    # PROCEDIMIENTO
    
    # Promedio anual
    s = 0
    dia = 1
    while (dia<=n):
        s = s + tiempo[dia]
        dia = dia+1
    pranual = s/n
    
    # Promedio mensual
    mes = 1
    maxmes = int(n/30)
    while (mes<=maxmes):
        s = 0
        dia = 1+30*(mes-1)
        while (dia<=(30*mes)):
            s = s+tiempo[dia]
            dia = dia+1
        prm[mes] = s/30
        mes = mes+1
    
    # SALIDA
    print('Promedio anual: ')
    print(pranual)
    print('Promedio mensual: ')
    mes = 1
    if maxmes==0:
        print('Meses completos: 0')
    while (mes<=maxmes):
        print(prm[mes])
        mes = mes+1
    
    # Se modificó el algoritmo para
    # probar con n de pocos días.
    

    Ejecución del algoritmo

    ¿días a cronometrar?: 5
    tiempo[1]: 
    20
    tiempo[2]: 
    18
    tiempo[3]: 
    23
    tiempo[4]: 
    19
    tiempo[5]: 
    22
    Promedio anual: 
    20.4
    Promedio mensual: 
    Meses completos: 0
    >>> 
    

    [ algoritmo ] [ diagrama flujo ]
    ..


    Diagrama de Flujo

    [ algoritmo ] [ diagrama flujo ]

    Propuesta de solución en Python, también en Matlab:

    ejercicios resueltos Python parc_iit2005_t3 pdf

    ejercicios resueltos Matlab parc_iit2005_t3 pdf

  • s1Eva_IIT2005_T2 Negocio piramidal

    Ejercicio: 1Eva_IIT2005_T2 Negocio piramidal

    [ algoritmo ] [ diagrama flujo ]

    Para la solución, considere las operaciones descritas en el orden lógico de ejecución: depósitos, comisiones e intereses pagados para calcular el saldo.

    siendo x la cantidad de depositantes.

    deposito = invitado*x
    comision = 0.20*deposito
    interespaga = 0.10*x*participa
    saldo = saldo+deposito-comision-interespaga
    participa = participa+invitado

    El control de participantes e invitados permitirá calcular apropiadamente los depósitos de los invitados y los intereses pagados a los participantes.

    Los meses se cuentan para cada iteración hasta que se cumpla la condición que los intereses pagados sean mayores al saldo.

    while (interespaga<=saldo):

    [ algoritmo ] [ diagrama flujo ]
    ..


    Algoritmo en Python

    # ICM00794-Fundamentos de Computación - FCNM-ESPOL
    # 1Eva_IIT2005_T2 Negocio piramidal
    # Propuesta de solución: edelros@espol.edu.ec
    
    # INGRESO
    x = int(input('cantidad por depositante: '))
    n = int(input('personas en el mercado: '))
    
    # PROCEDIMIENTO
    mes = 0
    invitado = 1
    participa = 0
    
    saldo = 0
    interespaga = 0
    while (interespaga<=saldo):
        deposito = invitado*x
        comision = 0.20*deposito
        interespaga = 0.10*x*participa
        saldo = saldo+deposito-comision-interespaga
        participa = participa+invitado
    
        if (participa<=(n/2)):
            invitado = participa
        else:
            invitado = 0
        
        mes = mes+1
    
    # SALIDA
    print('meses con saldo disponible: ')
    print(mes)
    

    Ejecución del algoritmo

    cantidad por depositante: 100
    personas en el mercado: 1000
    meses con saldo disponible: 
    17
    >>>

    [ algoritmo ] [ diagrama flujo ]
    ..


    Diagrama de Flujo


    [ algoritmo ] [ diagrama flujo ]

    Propuesta de solución en Python, también en Matlab:

    ejercicios resueltos Python parc_iit2005_t2 py_pdf

    ejercicios resueltos Matlab parc_iit2005_t2 pdf

  • s2Eva_IT2005_T4 Registrar mejores calificaciones

    Ejercicio: 2Eva_IT2005_T4 Registrar mejores calificaciones

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

    Se propone realizar el ejercicio mediante el uso de menú, separando las actividades, permitiendo luego añadir opciones.

    Tarea: validar en el ingreso que las notas sean entre 0 y 100, y encontrar los datos de calificación más alta y más baja

    Algoritmo en Python

    # ICM00794-Fundamentos de Computación - FCNM-ESPOL
    # 2Eva_IT2005_T4 Registrar mejores calificaciones
    # propuesta: edelros@espol.edu.ec
    
    # Se usará menú y diccionario para cada registro
    # Tarea: opcion 4 con nota mas alta y mas baja
    # Tarea: aumentar opciones para grabar o leer archivo
    # Tarea: Se puede hacer también con listas y sin menu
    
    lista = []
    suma = 0
    
    opcion = '0'
    while not(opcion=='5'):
        print('1. Ingresar registro')
        print('2. Ingresar ponderaciones')
        print('3. Calcular calificaciones')
        print('4. Mostrar lista y extremos')
        print('5. Salir')
        
        opcion = input('-cual opcion: ')
        
        if (opcion=='1'):
            print('REGISTRO ******')
            nombre   = input('nombre:  ')
            leccion  = int(input('leccion:  '))
            proyecto = int(input('proyecto: '))
            examen   = int(input('examen:   '))
            estudiante = {'nombre':nombre,
                          'leccion':leccion,
                          'proyecto':proyecto,
                          'examen':examen,
                          'calif':0}
            lista.append(estudiante)
            
        elif (opcion=='2'):
            print('PONDERACION')
            pondlecc = int(input('% leccion:  '))
            pondproy = int(input('% proyecto: '))
            pondexam = int(input('% examen:   '))
            suma = pondlecc + pondproy + pondexam
            while not(suma==100):
                print('ponderación no suma 100')
                pondlecc = int(input('% leccion:  '))
                pondproy = int(input('% proyecto: '))
                pondexam = int(input('% examen:   '))
                suma = pondlecc + pondproy + pondexam
            
        elif (opcion=='3'):
            print('CALCULAR')
            tamano = len(lista)
            if (suma==100):
                for i in range(0,tamano,1):
                    suma = lista[i]['leccion']*pondlecc
                    suma = suma + lista[i]['proyecto']*pondproy
                    suma = suma + lista[i]['examen']*pondexam
                    prom = suma/100
                    lista[i]['calif'] = prom
                print('Recalculadas las notas, proceder a mostrar')
            else:
                print('** las ponderaciones no son validas **')
                print('** volver a opcion de ponderaciones **')
            
        elif (opcion=='4'):
            print('LISTA')
            tamano = len(lista)
            print('nombre, leccion, proyecto, examen, calif')
            for i in range(0,tamano,1):
                texto = lista[i]['nombre'] + ', ' + str(lista[i]['leccion'])
                texto = texto + ', '+str(lista[i]['proyecto'])
                texto = texto + ', ' + str(lista[i]['examen'])
                texto = texto +', '+str(lista[i]['calif']) 
                print(texto)
    
        elif (opcion=='5'):
            print('Gracias por usar el software...')
    
        else:
            print('** NO es una opcion disponible **')
    

    resultado de algoritmo

    1. Ingresar registro
    2. Ingresar ponderaciones
    3. Calcular calificaciones
    4. Mostrar lista y extremos
    5. Salir
    -cual opcion: 1
    REGISTRO ******
    nombre:  juan
    leccion:  50
    proyecto: 70
    examen:   80
    1. Ingresar registro
    2. Ingresar ponderaciones
    3. Calcular calificaciones
    4. Mostrar lista y extremos
    5. Salir
    -cual opcion: 1
    REGISTRO ******
    nombre:  Maria
    leccion:  70
    proyecto: 60
    examen:   90
    1. Ingresar registro
    2. Ingresar ponderaciones
    3. Calcular calificaciones
    4. Mostrar lista y extremos
    5. Salir
    -cual opcion: 2
    PONDERACION
    % leccion:  30
    % proyecto: 20
    % examen:   50
    1. Ingresar registro
    2. Ingresar ponderaciones
    3. Calcular calificaciones
    4. Mostrar lista y extremos
    5. Salir
    -cual opcion: 3
    CALCULAR
    Recalculadas las notas, proceder a mostrar
    1. Ingresar registro
    2. Ingresar ponderaciones
    3. Calcular calificaciones
    4. Mostrar lista y extremos
    5. Salir
    -cual opcion: 4
    LISTA
    nombre, leccion, proyecto, examen, calif
    juan, 50, 70, 80, 69.0
    Maria, 70, 60, 90, 78.0
    1. Ingresar registro
    2. Ingresar ponderaciones
    3. Calcular calificaciones
    4. Mostrar lista y extremos
    5. Salir
    -cual opcion: 5
    Gracias por usar el software...
    >>> 
    

    ejercicios resueltos Python final_it2005_t4 pdf

    ejercicios resueltos Matlab final_it2005_t4 pdf

  • s2Eva_IT2005_T3 Adivina palabra (ahorcado)

    Ejercicio: 2Eva_IT2005_T3 Adivina palabra (ahorcado)

    Algoritmo en Python

    # 2Eva_IT2005_T3 Adivina palabra (ahorcado)
    # ICM00794-Fundamentos de Computación - FCNM-ESPOL
    # propuesta: edelros@espol.edu.ec
    
    def esvocal(letra):
        letra = letra.upper()
        vocal = 'AEIOU'
        tipo = 0
        if letra in vocal:
            tipo = 1
        return(tipo)
    
    # INGRESO
    palabra = input('¿Cuál palabra?: ')
    m = len(palabra)
    while m>9:
        print(' palabra de hasta 9 letras')
        palabra = input('¿Cuál palabra?: ')
        m = len(palabra)
    
    # PROCEDIMIENTO
    m = len(palabra)
    palabra = palabra.upper()
    cadena  = ''
    vocal ='AEIOU'
    falla = 0
    
    i = 0
    while i<m:
        cadena = cadena + str(i+1)
        i = i + 1
    
    # una letra
    j = 0
    while (j<m) and falla<5:
        letra = palabra[j]
        cual  = esvocal(letra)
        if cual==1:
            pista = ' es vocal'
        else:
            pista = ' es consonante'
        print(cadena)
        print(str(j+1)+pista + ', fallas:'+str(falla))
    
        unaletra = input('¿cuál letra?: ')
        unaletra = unaletra.upper()
    
        if unaletra == letra:
            print(' adivinado..!')
            j = j + 1
            nueva = palabra[0:j]+cadena[j:]
            cadena = nueva
        else:
            print(' fallaste, no es la letra..!')
            falla = falla + 1
    
    if falla>=5:
        print(' Fallaste 5 veces, perdiste..!')
    else:
        print(' Felicitaciones, ganaste...!!')
    

    Tarea: validar que el ingreso del usuario sea de una sola letra.

    resultado del algoritmo

    ¿Cuál palabra?: conocimiento
     palabra de hasta 9 letras
    ¿Cuál palabra?: sabiduria
    123456789
    1 es consonante, fallas:0
    ¿cuál letra?: s
     adivinado..!
    S23456789
    2 es vocal, fallas:0
    ¿cuál letra?: i
     fallaste, no es la letra..!
    S23456789
    2 es vocal, fallas:1
    ¿cuál letra?: o
     fallaste, no es la letra..!
    S23456789
    2 es vocal, fallas:2
    ¿cuál letra?: a
     adivinado..!
    SA3456789
    3 es consonante, fallas:2
    ¿cuál letra?: x
     fallaste, no es la letra..!
    SA3456789
    3 es consonante, fallas:3
    ¿cuál letra?: y
     fallaste, no es la letra..!
    SA3456789
    3 es consonante, fallas:4
    ¿cuál letra?: z
     fallaste, no es la letra..!
     Fallaste 5 veces, perdiste..!
    >>>
    
  • s2Eva_IT2005_T2 Calcular potencia recursiva

    Ejercicio: 2Eva_IT2005_T2 Calcular potencia recursiva

    literal a

    Al ejecutar el algoritmo se obtiene:

    >>> potenciaR(2,7)
    128
    >>> potenciaR(2,0)
    1
    >>> potenciaR(2,8)
    256
    >>>

    literal b

    p(2) =  17

    Algoritmo en Python

    # 2Eva_IT2005_T2 Calcular potencia recursiva
    
    def potenciaR(base,exponente):
        if exponente == 0:
            z = 1
        if exponente == 1:
            z= base
        if exponente>1:
            z = base*potenciaR(base,exponente-1)
        return(z)
    
    # literal b
    # INGRESO
    a = [1,2,3]
    x = 2
    
    # PROCEDIMIENTO
    n = len(a)
    total = 0
    for i in range(0,n,1):
        termino = a[i]*potenciaR(x,i)
        total = total + termino
    
    # SALIDA
    print('p('+str(x)+') = ',total)
    
  • s2Eva_IT2005_T1 Completar cadena con padright

    Ejercicio: 2Eva_IT2005_T1 Completar cadena con padright

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

    La solución se simplifica al iniciar el resultado con el “mensaje” dado y a partir del siguiente espacio copiar el carácter tantas veces sea necesario hasta completar el n'esimo espacio.

    Algoritmo en Python

    # ICM00794-Fundamentos de Computación - FCNM-ESPOL
    # 2Eva_IT2005_T1 Completar cadena con padright
    # Propuesta: edelros@espol.edu.ec
    
    def padright(mensaje,caracter,n):
        t = len(mensaje)
        z = mensaje
        siguiente = t + 1
        for i in range(siguiente,n,1):
            z = z + caracter
        return (z)
    

    prueba de la función, luego de ejecutar algoritmo

    >>> padright('Hola mundo','-',20)
    'Hola mundo---------'
    >>> 
    

    ejercicios resueltos Python final_it2005_t1 pdf

    ejercicios resueltos Matlab final_it2005_t1 pdf

  • s1Eva_IT2005_T4 Lanza penales

    Ejercicio: 1Eva_IT2005_T4 Lanza penales

    [ algoritmo ] [ diagrama flujo ]

    Propuesta de solución en Python

    Se realiza el control de goles conseguidos en cada lanzamiento de balón, contando los lanzamientos hasta que se alcancen 5 .

    conseguido = 0
    lanza = 0
    while not(lanza==5):

    El área dónde patea el balón el jugador se ingresa por teclado y la posición del arquero se obtiene de un aleatorio.

        # Patea
        print('Penal número: ', lanza)
        patea = int(input('donde patea: '))
        while not(patea>=1 and patea<=6):
            patea = int(input('OE!..donde patea: '))
    
        # Arquero
        arquero = int(rnd.random() * 6) +1

    Se analiza si hubo gol siempre que donde se patea sea diferente donde está el arquero, con lo que se contabiliza los goles conseguidos.

        # Gol/tapa
        if not(patea==arquero):
            gol = 1
        else:
            gol = 0
    
        conseguido = conseguido + gol
        lanza = lanza + 1

    [ algoritmo ] [ diagrama flujo ]
    ..


    Algoritmo en Python

    # ICM00794-Fundamentos de Computación - FCNM-ESPOL
    # 1Eva_IT2005_T4 Lanza penales
    
    import random as rnd
    
    conseguido = 0
    lanza = 0
    while not(lanza==5):
    
        # Patea
        print('Penal número: ', lanza)
        patea = int(input('donde patea: '))
        while not(patea>=1 and patea<=6):
            patea = int(input('OE!..donde patea: '))
    
        # Arquero
        arquero = int(rnd.random() * 6) +1
    
        # Gol/tapa
        if not(patea==arquero):
            gol = 1
        else:
            gol = 0
    
        conseguido = conseguido + gol
        lanza = lanza + 1
    
        # Resultado
        print('patea, arquero, gol/tapa')
        print(patea, arquero, gol)
    
    print('*** Goles conseguidos: ', conseguido)
    

    Ejemplo de resultado del algoritmo:

    Penal número:  0
    donde patea: 3
    patea, arquero, gol/tapa
    3 3 0
    Penal número:  1
    donde patea: 2
    patea, arquero, gol/tapa
    2 6 1
    Penal número:  2
    donde patea: 1
    patea, arquero, gol/tapa
    1 1 0
    Penal número:  3
    donde patea: 2
    patea, arquero, gol/tapa
    2 4 1
    Penal número:  4
    donde patea: 3
    patea, arquero, gol/tapa
    3 5 1
    *** Goles conseguidos:  3
    >>>

    [ algoritmo ] [ diagrama flujo ]
    ..


    Diagrama de Flujo

    diagrama de flujo ejercicio resuelto

    [ algoritmo ] [ diagrama flujo ]

  • s1Eva_IT2005_T3 Arreglo aleatorio binario a decimal

    Ejercicio: 1Eva_IT2005_T3 Arreglo aleatorio binario a decimal

    Propuesta de solución en Python 1Eva_IT2005_T3 binario a Decimal

    Use un vector de n casillas,

    Las casillas pueden iniciar en cero,para luego llenarlas de números aleatorios una por una,

    B = np.zeros(n,dtype=int)
    

    Junto a la operación anterior, podría realizar las operaciones requeridas en el enunciado.

    B[i] = int(rnd.random()*2)+0
    

    De ser necesario repasar: Binario a Decimal – Algoritmo

    Algoritmo en Python

    # ICM00794-Fundamentos de Computación - FCNM-ESPOL
    # 1Eva_IT2005_T3 Arreglo aleatorio binario a decimal
    # Tarea: contar los 1's, literal a)
    
    import numpy as np
    import random as rnd
    
    # INGRESO
    n = int(input('cuantos componentes n: '))
    
    # PROCEDIMIENTO
    B = np.zeros(n,dtype=int)
    decimal = 0
    i = 0
    while (i<n):
        B[i] = int(rnd.random()*2)+0
        # orden de binarios es izquierda a derecha
        posicion = n-1-i  
        decimal  = decimal+B[i]*(2**posicion)
        i = i+1
    
    # SALIDA
    print('Arreglo de binarios B[i]:')
    print(B)
    print('equivale en decimal:',decimal)
    

    Resultados de algoritmo realizados para un byte (8 bits):

    cuantos componentes n: 8
    Arreglo de binarios B[i]:
    [0 0 1 0 1 0 1 0]
    equivale en decimal: 42
    >>> 
    cuantos componentes n: 8
    Arreglo de binarios B[i]:
    [1 1 1 1 1 1 1 1]
    equivale en decimal: 255
    >>> 
    cuantos componentes n: 8
    Arreglo de binarios B[i]:
    [0 0 1 1 1 1 1 0]
    equivale en decimal: 62
    >>> 
    
  • s2Eva_IIT2004_T3 Reciclar vasos

    Ejercicio: 2daEva_IIT2004_T3 Reciclar vasos

    algoritmo: [ mientras-repita ] [ repita-hasta ]
    diagrama flujo: [ mientras-repita ] [ repita-hasta ]

    Se requiere usar el concepto de cociente y residuo, pues un vaso reciclado entero se obtiene con 4 vasos. Menos de 4 vasos a reciclar no producen un vaso entero, por lo que no se usan en el proceso y quedan separados como sobrantes a ser acumulados en el próximo ciclo.

    algoritmo: [ mientras-repita ] [ repita-hasta ]
    diagrama flujo: [ mientras-repita ] [ repita-hasta ]

    ..


    Algoritmo en Python: Bucle mientras-repita

    # ICM00794-Fundamentos de Computación - FCNM-ESPOL
    # 2Eva_IIT2004_T3 Reciclar vasos
    # Solucion propuesta para 1ra Eval. sin Funciones
    
    # INGRESO
    n = int(input('Cuantos vasos usados:'))
    factor = int(input('nuevos/reciclado:'))
    
    # PROCEDIMIENTO
    total=0
    while (n>=factor):
        reciclado = n//factor
        sobra = n%factor
        total = total + reciclado
        n = reciclado + sobra
    
    # SALIDA
    print('total reciclados: ', total)
    

    algoritmo: [ mientras-repita ] [ repita-hasta ]
    diagrama flujo: [ mientras-repita ] [ repita-hasta ]
    ..


    Diagrama de Flujo: Mientras-Repita

    Reciclar vasos 01

    algoritmo: [ mientras-repita ] [ repita-hasta ]
    diagrama flujo: [ mientras-repita ] [ repita-hasta ]
    ..


    Algoritmo en Python: Bucle repita-hasta

    # ICM00794-Fundamentos de Computación - FCNM-ESPOL
    # 2Eva_IIT2004_T3 Reciclar vasos
    # Solucion propuesta para 1ra Eval. sin Funciones
    
    # INGRESO
    n = int(input('Cuantos vasos usados:'))
    factor = int(input('nuevos/reciclado:'))
    
    # PROCEDIMIENTO
    total = 0
    while not(n<factor):
        reciclado = n//factor
        sobra = n%factor
        total = total + reciclado
        n = reciclado + sobra
    
    # SALIDA
    print('total reciclados: ', total)
    

    resultado del algoritmo

    Cuantos vasos usados:70
    nuevos/reciclado:4
    total reciclados:  23
    >>>
    Cuantos vasos usados:7000
    nuevos/reciclado:4
    total reciclados:  2333
    >>>
    

    algoritmo: [ mientras-repita ] [ repita-hasta ]
    diagrama flujo: [ mientras-repita ] [ repita-hasta ]
    ..


    Diagrama de Flujo: Repita-Hasta

    algoritmo: [ mientras-repita ] [ repita-hasta ]
    diagrama flujo: [ mientras-repita ] [ repita-hasta ]


    Propuesta de solución con diagrama de flujo, Python y otra versión con Matlab

    ejercicios resueltos Python final_iit2004_t3 pdf

    ejercicios resueltos Matlab final_iit2004_t3 pdf