Problema

Diseña un algoritmo que calcule la hora dentro de un segundo. El reloj cuenta con horas, minutos y segundos (HH MM SS). Es un reloj digital y sigue el siguiente formato. Hora en formato 24 horas, 24 horas = 00; 60 minutos = 00; 60 segundos = 00. Así que las 00 00 00 equivale a las 12 pm en punto.

Ejemplo 1
Entrada: 09 05 30
Salida:  09 05 31

Ejemplo 2
Entrada: 10 59 59
Salida:  11 00 00

Consejo: Antes de escribir código debes saber cómo se resuelve el problema. Piensa en cómo lo resuelves sin código. Haz el algoritmo paso a paso en un papel o en el editor de código. Luego compara tu solución con la del artículo.

1. Análisis

Piden calcular la hora del reloj agregando un segundo. Debo seguir el formato sugerido. Además, hay que tomar en cuenta los casos límite en los que puede caer el algoritmo para poder solucionar correctamente esta tarea.

• Horas: después de las 23 sigue 00.

• Minutos: después de los 59 sigue 00.

• Segundos: después de los 59 sigue 00.

• Considerar el acarreo de una unidad de segundos a minutos, cuando los segundos dados coincidan con 59.

• Considerar el acarreo de una unidad de minutos a horas, cuando los minutos dados coincidan con 59 y reciba el acarreo de una unidad procedente de los segundos.

El acarreo es importante, porque recordemos que 60 segundos añaden un minuto; 60 minutos añaden 1 hora.

Ejemplo de caso normal:

01 10 11 - el siguiente segundo actualiza la hora a: 01 10 12.

Ejemplo de caso con acarreo:

03 59 59 - el siguiente segundo actualiza la hora a: 04 00 00.

2. Diseño del algoritmo

1. Idea de solución

La idea de solución es sencilla: sumar un segundo a la hora dada y considerar los casos especiales para que se muestre la hora en el formato indicado. Los casos especiales los manejamos con estructuras de condición.

2. Diseño

# variables:
horas, minutos, segundos, hh, mm, ss

iniciar
    sumar 1 a segundos
    si segundos = 60 entonces
        segundos ← 00
        sumar 1 a minutos
        si minutos = 60 entonces
            minutos ← 00
            sumar 1 a horas
            si horas = 24 entonces
                horas ← 00
            fin si
        fin si
    fin si

    imprimir(horas.formatedas, minutos.formateados, segundos.formateados)
fin

En las ramas condicionales hemos cubierto todas los escenarios. Al imprimir hemos inidicado que las horas, minutos y segundos van formateados. No lo hemos desarrollado. Eso lo haremos en el código.

3. Comprobación en seco

3. Codificación

Una vez que tenemos diseñado y probado el algortimos es hora de traducirlo a código. Manos al teclado!

# entrada
horas = 11
minutos = 59
segundos = 00

# algoritmo
segundos += 1
if segundos == 60:
    segundos = 0
    minutos += 1
    if minutos == 60:
        minutos = 0
        horas += 1
        if horas == 24:
            horas = 0

print(f"{str(horas).zfill(2)} {str(minutos).zfill(2)} {str(segundos).zfill(2)}")

El método str(numero) convierte a tipo cadena un número.

El método zfill es un método interno de Python que sirve para para rellenar una cadena numérica con ceros a la izquierda hasta que alcance un ancho especificado por el argumento que recibe. Esto asegura que la representación en cadena del número tenga una longitud mínima. Por ejemplo, si la cadena es "0", entonces "00"; si "1", entonces "01"; si "20", entonces "20", ya no necesita relleno.

Fíjate que unimos el método zfill a str(numero). Primero str(numero) convierte cadena el número. Luego, zfill formatea esta cadena. Por último, guardamos el resultado en la variable correspondiente.

Ejecuta el programa, o haz la comprobación en seco.

4. Complejidad

Tiempo: O(1) constante

Porque no recorremos una colección.

Espacio: O(1) constante

Porque no usamos estructura de datos extra.

Conclusión

En resumen, en este artículo diseñamos y codificamos el algoritmo base de un reloj digital y cumplimos con el formato que se nos pidió. Pon atención en que, para resolverlo, listamos los casos límite o escenarios que podría tener. Con estructuras condicionales manejamos estos escenarios. Conocer estos escenarios es muy importante para tu programa o software para que tengan el comportamiento esperado. Al codificar, usamos el método zfill dePython que rellena una cadena de números con ceros a la izquierda.

Reto: Diseña el algoritmo y el programa en Python de un reloj para que funcione las 24 horas.

Bibliografía

Joyanes Aguilar, L. (2008). Fundamentos de programación. Madrid: McGraw-Hill.

Diseña un algoritmo que imprima el número más grande de tres números dados.

Ejemplo 1
Entrada: 1, 2, 3
Salida: 9

Ejemplo 2
Entrada: 10, 15, 8
Salida: 15

Consejo: Antes de escribir código debes entender cómo se resuelve el problema. Piensa en cómo lo harías sin usar código. Realiza el algoritmo paso a paso en un papel o en el editor de código. Luego compara tu solución con la del artículo.

1. Análisis

Nos piden determinar cuál es el número más grande de tres números dados.

Pero, ¿qué pasa hay números iguales?

• Si los tres números son iguales, imprimir cualquiera.

• Si dos números son iguales, imprimir cualquiera que cumpla la condición de ser mayor que el tercer número.

2. Diseño del algoritmo

1. Idea de solución

La idea es simple, comparar los tres números entre sí para decidir el mayor.

2. Diseño

Usamos variable mayor para guardar temporalmente el número más grande cada vez que hacemos una comparación. Al final, mayor tendrá el resultado.

A, B, C = 1, 2, 3
mayor = infinito negativo

si A >= mayor entonces
    mayor ← A
fin si
si B >= mayor entonces
    mayor ← B
fin si
si C >= mayor entonces
    mayor ← C
fin si

print(mayor)

3. Comprobación en seco

3. Codificación

A, B, C = 1, 2, 3
mayor = -float('inf')

if A >= mayor:
    mayor = A
if B >= mayor:
    mayor = B
if C >= mayor:
    mayor = C

print(mayor)

Inicializamos mayor como infinito negativo. Esto representa el valor menor que puede tener un número en Python. Cualquier número diferente a infinito negativo es superior a este. Así podemos actualizar el valor de mayor en cada comparación.

Comparamos cada número contra la variable mayor. Actualizamos el valor de esta.

Al final, imprimimos mayor.

4. Complejidad

Tiempo: O(1) constante

Por que no hay una colección que recorrer.

Espacio: O(1) constante

Por que no hay una estructura de datos adicional.

Conclusión

En conclusión, hemos diseñado un algoritmo sencillo y eficaz para determinar el número más grande entre tres números dados. A través de un análisis detallado y un diseño claro, hemos demostrado cómo comparar los números y actualizar una variable para encontrar el mayor. La implementación en código es directa y eficiente, con una complejidad constante tanto en tiempo como en espacio. Este enfoque no solo resuelve el problema de manera efectiva, sino que también es fácil de entender y aplicar en diversas situaciones.

Bibliografía

Joyanes Aguilar, L. (2008). Fundamentos de programación. Madrid: McGraw-Hill.

Problema

Dado un día del mes, determinar qué día de la semana es asumiendo que el primer día del mes es lunes.

Ejemplo 1
Entrada: 15
Salida: lunes

Ejemplo 2
Entrada: 28
Salida: domingo

Ejemplo 3
Entrada: 11
Salida: jueves

Consejo: Antes de escribir código debes saber cómo se resuelve el problema. Piensa en cómo lo resuelves sin código. Haz el algoritmo paso a paso en un papel o en el editor de código. Luego compara tu solución con la del artículo.

1. Análisis

El problema nos pide saber qué día de la semana es a partir de un día del mes. El primer día del mes corresponde a lunes. En otras palabras, se nos pide hacer un mapeo del día del mes que nos dan al día de la semana correspondiente. Por ejemplo, si me dan el día 9 de mes la respuesta sería martes.

Vamos a explicarlo con pelotas y con 7 cajas para guardar las pelotas. Dentro de cada caja caben varias pelotas. Las reglas:

Sólo puedes poner una pelota en la caja a la vez. La siguiente pelota va en la siguiente caja. No puedes saltar de caja. Cuando terminas de recorrer las 7 cajas vuelves a poner la siguiente pelota en la primera caja.

Las pelotas representa el día dado. Supongamos que nos dan 9 pelotas, el día 9 del mes.

| Lun 🟢 | Mar 🔵 | Mié 🟡 | Jue 🟠 | Vie 🟣 | Sáb 🟤 | Dom🔴 |

| Lun 🟢 | Mar 🔵 | Mié | Jue | Vie | Sáb | Dom |

2. Diseño del algoritmo

1. Idea de solución

Como primer paso, tengo que encontrar una operación que me permita obtener del día del mes las 7 cajas o valores de forma constante.

Una primera idea, sería usar la división: 9 / 1 = 9; 9 / 2 = 4.5; y no avanzo con mi objetivo.

Otra idea es usar el resto o residuo de la división. ¿Por qué? Porque en este caso, la operación resto nos devuelve un número comprendido entre 0 y 7. Allí tenmos los 7 valores que necesitmamos. Por ejemplo, el residuo de 9 dividido 7 es 2.

Luego, el segundo paso es mapear estos 7 valores a los días de la semana.

Este es el mapeo:

Si deciden cambiar el día de referencia, es decir, que el primer día de la semana sea jueves, entonces debemos ajustar el mapeo y listo. El valor 0 sería para miércoles, el jueves el 1, viernes 2, etc.

2. Diseño

Para resolver este problema sigue estos pasos:

1. Obtener el residuo del día del mes entre 7.

2. Mapear el resultado al día de la semana.

3. Imprimir el día de la semana.

diaMes = x
residuo = diaMes Modulo 7
segun sea residuo:
'0' -> diaSemana = domingo
'1' -> diaSemana = lunes
'2' -> diaSemana = martes
... 
imprimir(diaSemana)

La operación residuo también se conoce como módulo.

En el algoritmo estoy usando según sea que representa la estructura switch que existe en muchos lenguajes de programación.

3. Comprobación en seco

3. Codificación

dia_mes = 2

residuo = dia_mes % 7

if residuo == 1:
    dia_semana = "lunes"
elif residuo == 2:
    dia_semana = "martes"
elif residuo == 3:
    dia_semana = "miércoles"
elif residuo == 4:
    dia_semana = "jueves"
elif residuo == 5:
    dia_semana = "viernes"
elif residuo == 6:
    dia_semana = "sábado"
else:
    dia_semana = "domingo"

print(dia_semana)

El código mapea el valor del residuo de la división del día del mes por 7 e imprime como resultado el día de la semana.

Python no tiene la sentencia switch. Por eso usamos la estructura if-elif-else.

Existen otras formas de resolver el problema, por ejemplo, usando una lista con los días de la semana. Pero en esencia, el problema se resuelve de la misma forma. Usa el operador residuo de la división y el mapeo a los días de la semana usando esa lista.

def dia_de_la_semana(dia_mes):
    dias_semana = ["domingo", "lunes", "martes", "miércoles", "jueves", "viernes", "sábado"]
    return dias_semana[dia_mes % 7]

# Ejemplo de uso
dia = 15
print(f"El día {dia} del mes es {dia_de_la_semana(dia)}")

4. Complejidad

Tiempo: O(1) constante

Porque no se recorre ninguna colección.

Espacio: O(1) constante

Porque no se utilizó una estructura de datos extra.

Conclusión

En conclusión, hemos abordado el problema de determinar el día de la semana a partir de un día específico del mes, asumiendo que el primer día del mes es lunes. A través del análisis y diseño del algoritmo, hemos identificado que el uso del operador residuo de la división es una solución eficiente para mapear los días del mes a los días de la semana. La implementación en código demuestra que este enfoque es tanto simple como efectivo, con una complejidad constante en términos de tiempo y espacio. Este método puede ser fácilmente adaptado a diferentes días de referencia, lo que lo hace versátil y útil en diversas aplicaciones.

Bibliografía

Joyanes Aguilar, L. (2008). Fundamentos de programación. Madrid: McGraw-Hill.

Problema

Saber si un año dado es bisiesto o no.

Ejemplo 1
Entrada: 1000
Salida: false

Ejemplo 2
Entrada: 2000
Salida: true

Consejo: Antes de escribir código debes saber cómo se resuelve el problema. Piensa en cómo lo resuelves sin código. Haz el algoritmo paso a paso en un papel o en el editor de código. Luego compara tu solución con la del artículo.

1. Análisis

El problema nos da un año y debemos definir si es una año bisiesto o no. La salida es true o false.

Un año es el tiempo que tarda la tierra en dar una vuelta al sol. Un año bisiesto es un año que tiene 366 días y no 365.

¿Cómo determinar si un año es bisiesto o no? Para entender mejor este tema, investiguemos qué nos dice Copilot de Microsoft Bing. Copilot nos dice que según el calendario gregoriano un año es bisiesto si cumple estas tres reglas:

1. Ser divisible por 4

2. No ser divisible por 100

3. Pero si es divisible por 100, debe ser divisible por 400.

2. Diseño del algoritmo

1. Idea de solución

La fórmula compacta que nos da Copilot es:

bisiesto = (año mod 4 = 0) Y (año mod 100 ≠ 0 O año mod 400 = 0)

Si el año es divisible entre 4 y no divisible entre 100, entonces es bisiesto. Pero ¿qué pasa con los años que son divisibles entre 100? Todavía pueden ser bisiestos si son divisibles entre 400.

año mod 4 = 0

si año es divisible entre 4

(año mod 100 ≠ 0 O año mod 400 = 0)

El operador lógico O maneja dos condiciones.

• Si no es divisible entre 100

• Si es divisible entre 400

Basta con que una sea verdadera para que la expresión sea verdadera.

El operador lógico Y une las dos partes de la fórmula. Ambas tienen que ser verdaderas para que la expresión sea verdadera.

2. Diseño

Un primer acercamiento, siguiendo las reglas de los años bisiesto, sería:

bisiesto = false
si año es divisible por 4 entonces
    si año no es divisible por 100 entonces 
        bisiesto = true
    sino // si el año es divisible por 100
        si año es divisble por 400 entonces 
            bisiesto = true
fin si
imprimir(bisiesto)

Este pseudocódigo es entendible por sí solo, pero es verboso. La fórmula compacta nos dice lo mismo.

3. Comprobación en seco

3. Codificación

Codificamos aquí solo la fórmula compacta. Pasa a código el pseudocódigo que presentamos arriba y pruébalo.

year = int(input("Ingresa el año: "))
bisiesto = (year % 4 == 0) and (year % 100 != 0 or year % 400 == 0)
print(bisiesto)

4. Complejidad

Tiempo: O(1) constante

Porque no recorremos una colección.

Espacio: O(1) constante

Porque no usamos estructura de datos extra.

Conclusión

En conclusión, determinar si un año es bisiesto es una tarea sencilla cuando se conocen las reglas del calendario gregoriano. Presentamos dos algoritmos, uno más descriptivo en pseudocódigo; el otro, más compacto tipo fórmula. Además, explicamos cómo funciona una condición compuesta con los operadores lógicos and y or.

Bibliografía

Joyanes Aguilar, L. (2008). Fundamentos de programación. Madrid: McGraw-Hill.

Problema

Detecta si un número dado es decimal o entero.

Ejemplo 1
Entrada: 4
Salida: entero

Ejemplo 2
Entrada: 3.1416
Salida: decimal

Consejo: Antes de escribir código debes saber cómo se resuelve el problema. Piensa en cómo lo resuelves sin código. Haz el algoritmo paso a paso en un papel o en el editor de código. Luego compara tu solución con la del artículo.

1. Análisis

Nos piden detectar si un número dado es decimal o entero.

Los números enteros incluyen los números naturales, sus opuestos negativos, y el cero. Es decir, números positivos, negativos y el cero. Por ejemplo, 1, -1, 0.

Los números decimales constan de una parte entera y de una fracción decimal. La parte entera y decimal se separa por una convención que puede ser un punto o una coma dependiendo del país. Entonces, un número decimal sería 1.5.

2. Diseño del algoritmo

1. Idea de solución

Se me ocurren tres ideas de solución.

A. Preguntar si el número contiene un punto o una coma, puesto que estos son los separadores de la parte entera de la parte decimal.

B. Truncar el número a la parte entera y preguntar si el número es igual al número truncado. Si es igual, es entero. Si es diferente, es decimal.

C. Usar el operador módulo para saber si el número tiene residuo. Si tiene residuo es decimal, de lo contrario, es entero.

Elegimos la opción B.

2. Diseño

1. Comparar el número contra el número truncado
    1.1 Si es igual entonces es entero,
    1.2 De lo contrario, es decimal
2. Guardar resultado
3. Imprimir resultado

3. Comprobación en seco

3. Codificación

Casi todos los lenguajes poseen ya una función para truncar un número. Solo tenemos que utilizarla. En el caso de Python hay varias opciones. Un par de ellas son:

• usar int(). Esto convierte el número a entero.

• usar math.trunc() de la librería math

numero = 3.1416
if numero == int(numero):
    resultado = "entero"
else:
    resultado = "decimal"
print(resultado)

4. Complejidad

Tiempo: O(1) constante

Es constante porque no hay una colección que recorrer.

Espacio: O(1) constante

Es constante porque no hay una estructura de datos adicional.

Conclusión

En resumen, en este artículo analizamos y diseñamos un algoritmo para determinar si un número es entero o decimal. Tuvimos tres ideas de solución y seleccionamos una para desarrollar: comparar el número dado contra el número truncado. Aprendimos que para truncar un número en Python podemos usar el método int(). ¿Conoces otras formas de resolver este problema? ¡Coméntalas!

Bibliografía

Joyanes Aguilar, L. (2008). Fundamentos de programación. Madrid: McGraw-Hill.

Problema

Calcula la suma de los diez primeros números pares. Genera estos números, pero solo imprime el resultado de la suma.

Ejemplo 
Entrada: 2,4,6,8,10,12,14,16,18,20
Salida: 110

Consejo: Antes de escribir código debes saber cómo resolver el problema. Piensa en cómo lo resolverías sin código. Haz el algoritmo paso a paso en papel o en el editor de código. Luego, compara tu solución con la del artículo.

1. Análisis

Nos piden calcular la suma de los diez primeros números pares. Tenemos que saber cuáles son los números pares. Los números pares son aquellos números que son divisibles o múltiplos de 2. Por ejemplo, 8.

Los diez primeros números pares van del 2 al 20. Nos piden generarlos para hacer la suma.

2. Diseño del algoritmo

1. Idea de solución

Se me ocurren dos ideas de solución:

A. Recorrer cada número del 1 al 20 incluido y evaluar si es divisible entre 2. Si lo es, es par. Luego, hago una sumatoria con todos los pares.

B. Recorrer los números de dos en dos hasta llegar al 20 incluido. Eso asegura que son pares. Luego, hago la sumatoria.

Elijo la opción B, parece más sencilla.

2. Diseño

1. Inicializar una variable sumatoria en 0.
2. Usar un ciclo for que recorra los números desde 2 hasta 20, con un salto de 2 en 2.
3. En cada iteración, sumar el valor actual a sumatoria.
4. Imprimir el resultado final de sumatoria.

3. Comprobación en seco

3. Codificación

Ahora vamos a implementar nuestro algoritmo en Python.

# Suma 10 primeros números pares
sumatoria = 0
for i in range(2, 21, 2):
    sumatoria += i
print(sumatoria)

En el ciclo recorremos los primeros 10 números pares. Comenzamos en 2 y saltamos de dos en 2 hasta llegar al 20 incluido.

Range genera una secuencia de números y tiene 3 parámetros:

• Inicio: en 2.

• Parada: en 21, para que incluya el último número par, el 20. Este parámetro no es inclusivo. Si lo dejamos en 20, llegaría hasta el 19.

• Paso: de 2 en 2.

En cada paso del ciclo hacemos la sumatoria del acumulado con el valor actual de i. Voilá.

4. Complejidad

Tiempo: O(n) lineal

Es lineal porque necesitamos recorrer la colección de números pares.

Espacio: O(1) constante

Es constante porque no generamos ninguna estructura de datos extra.

Conclusion

En este artículo analizamos, diseñamos y codificamos en Python un algoritmo para calcular la suma de los diez primeros números pares. De dos ideas de solución escogimos una: recorrer los números de dos en dos hasta llegar al 20. Se te ocurre otra solución. Inténtala y comenta.

Bibliografía

Joyanes Aguilar, L. (2008). Fundamentos de programación. Madrid: McGraw-Hill.

Resuelve la ecuación de primer grado con los datos de entrada. Escribe el resultado, o si el resultado es indeterminado o imposible.

$$ax + b = 0$$

Consejo: Antes de escribir código debemos saber cómo se resuelve el problema. Piensa en cómo lo resuelves sin código. Haz el algoritmo paso a paso en un papel o en el editor de código. Luego compara tu solución con la del artículo.

1. Análisis

Nos piden resolver una ecuación de primer grado. Los valores conocidos -entrada- son a, b. Para resolver la ecuación tenemos que saber qué es y cómo se resuelven. De lo contrario, estamos atorados. Repasemos.

Ecuación de primer grado

• Una ecuación de primer grado es una igualdad matemática que tiene una o más incógnitas.

• El grado de la ecuación lo recibe de la potencia a la que está elevada la incógnita. Por ejemplo, x^2 es una ecuación de segundo grado.

• El grado nos dice el número de soluciones que tiene la ecuación. Una ecuación de primer grado solo tiene una solución.

La ecuación que nos pasan tiene la forma de a * x + b = 0. El cálculo consiste en:

1. Agrupar los términos que llevan x en la primera parte de la ecuación (antes del signo =). Los que no, los pasamos a la segunda parte.

2. Despejar x.

3. Resolver la operación.

Recuerda que si pasamos un término de un lado a otro de la ecuación, se realizan operaciones opuestas. Si suman, pasan restando. Si multiplican, pasan dividiendo.

Con eso resolvemos la ecuación. Pero, la solución puede caer en tres casos o escenarios diferentes. Los casos son:

• Si a es diferente de 0, resolvemos la operación.

• Si a = 0 y b diferente de 0, la solución es imposible.

• Si a = 0 y b = 0, la solución es indeterminada.

El 0 es problemático porque la ecuación despejada termina siendo 0/0, o -b/0.

Este problema nos da los casos o escenarios en los que puede caer el programa. En muchas ocasiones, estos casos no vienen dados. Debemos pensar en ellos y encontrarlos.

2. Diseño del algoritmo

1. Idea de solución

Usar un condicional compuesto para resolver el problema. En la primera rama, evaluamos el caso feliz, donde a diferente de 0. En la segunda rama, evaluamos los casos donde la solución es imposible o indeterminada.

2. Diseño

Observamos que no nos piden resolver paso a paso la ecuación. Luego, el despeje de x lo podemos hacer manualmente.

Primer diseño

Pseudocódigo

3. Comprobación en seco

3. Codificación

def resolver_ecuacion(a, b):
    if a != 0:
        return -b / a
    elif a == 0 and b != 0:
        return "imposible"
    elif a == 0 and b == 0:
        return "indeterminada"

# Ejemplos de uso
print(resolver_ecuacion(0, 3))  # imposible
print(resolver_ecuacion(0, 0))  # indeterminada
print(resolver_ecuacion(2, 4))  # -2

4. Complejidad

Tiempo: O(1) constante

No hay una colección de datos, es una entrada sola.

Espacio: O(1) constante

No hay una estructura de datos extra que ocupe espacio en memoria.

Conclusión

Hemos analizado y resuelto una ecuación de primer grado considerando diferentes escenarios. La implementación en código refleja los casos posibles: solución única, solución imposible o solución indeterminada.

Bibliografía

Joyanes Aguilar, L. (2008). Fundamentos de programación. Madrid: McGraw-Hill.

Determina si un número es decimal. Pide al usuario un número. Devuelve verdadero si es decimal; de lo contrario, devuelve falso.

Ejemplo 1
Entrada: 3.1416
Salida: true

Ejemplo 2
Entrada: 80
Salida: false

Consejo: Antes de escribir código debes saber cómo se resuelve el problema a mano. Piensa en cómo lo resuelves sin código. Haz el algoritmo paso a paso en un papel o en el editor de código. Luego, compara con el artículo.

1. Análisis

Debemos pedir un número al usuario, luego calcular si es decimal o no y devolver verdadero o falso según el caso.

Suponemos que la entrada de dato es correcta.

2. Diseño del algoritmo

1. Idea de solución

Se me ocurren dos ideas de solución.

1. Comparar el número contra el número truncado a la parte entera. Si son iguales, es entero; de lo contrario, decimal.

2. Usar el operador módulo con 1. Si el resultado es diferente de 0, entonces es decimal.

Elegí la primera porque trabajamos con el operador módulo en el problema anterior.

2. Diseño

Primer diseño

1. Leer el número
2. Calcular si es decimal
3. Escribir el resultado

Refinamiento

1. Pedir el número
2. Leer el número
3. Truncar el número
4. Comparar el número contra el número truncado
5. Escribir el resultado

¿Cómo truncar un número?

Truncar un número es reducir el número de dígitos decimales.

La mayoría de lenguajes de programación tienen incorporada esta tarea. Suele llamarse Truncar().

Las tareas que vienen implementadas por el lenguaje se llaman funciones internas. Nos facilitan la vida porque no tenemos que desarrollarlas.

Pseudocódigo

# variables
real: numero
cadena: entrada

inicio
    escribir("Ingresa un número (decimal o entero): ")
    leer(entrada)
    // convertir número a decimal
    si numero <> Truncar(numero)
        escribir(true)
    si no
        escribir(false)
    fin si
fin

Observa que en lugar de escribir una condición compuesta

si numero <> Truncar(numero)
    escribir(true)
si no
    escribir(false)
fin si

podemos mejorar nuestro código usando este patrón para ahorrarnos el si no [else]

esDecimal ← false
si numero <> Truncar(numero)
    esDecimal ← true
fin si

escribir(esDecimal)

Pasos

1. Declaramos una variable con el estado/acción que tendría el bloque si no: esDecimal ← false.

2. Eliminamos el bloque si no.

3. Dentro del bloque si, actualizamos el valor de esDecimal al estado que le corresponde: esDecimal ← true.

El código es más compacto y legible. Además, separamos la salida del cálculo; la función escribir() quedó fuera del bloque si.

Refactorizar

Lo que acabamos de hacer se llama refactorizar. Refactorizar es reesctructurar el código sin cambiar su comportamiento. Esto sirve para mejorar la calidad, legibilidad y mantenibilidad del código.

Siempre que puedas, refactoriza tu código. Es una excelente práctica para mejorar. Casi siempre podemos encontrar elementos defectuosos, repetidos o innecesarios.

Al final, no te olvides de comprobar que el programa funciona. Recuerda que el mejor algoritmo o programa es el que funciona; no el que se ve más bonito.

Refactorizar es reesctructurar el código sin cambiar su comportamiento.

3. Comprobación en seco

3. Codificación

En ocasiones hay que modificar el algoritmo para traducirlo al lenguaje de programación.

Convertir entrada a tipo numérico

En este caso, tenemos que hacer un paso extra, convertir la entrada del usuario a un tipo numérico. ¿Por qué? Porque, por defecto, las entradas de usuario son de tipo cadena, aunque sean números.

Tipos de datos numéricos

Hay lenguajes que tienen diferentes tipos de datos numéricos dependiendo de si son decimales o enteros, y de la longitud de datos que pueden guardar.

entrada = input("Ingresa un número -decimal o entero-: ")
numero = float(entrada)

esDecimal = False
if numero != int(numero):
    esDecimal = True

print(esDecimal)

Comentarios:

• La funcion input() sirve para leer una entrada de usuario. Puede recibir como argumento un mensaje para el usuario que se imprime en consola.

• La función float() convierte una cadena o número entero a número decimal.

• Convertimos la entrada a float para no perder datos. Si convertimos la entrada a entero, y el usuario ingresó un número decimal, perderíamos datos.

• La funcion int() convierte una cadena a entero. Sirve también para truncar la parte decimal de un número.

• En lugar de int(), también se puede usar la función math.trunc().

4. Complejidad

Tiempo: O(1) constante

No hay una colección de datos, es una entrada sola.

Espacio: O(1) constante

No hay una estructura de datos extra que ocupe espacio en memoria.

Bibliografía

Joyanes Aguilar, L. (2008). Fundamentos de programación. Madrid: McGraw-Hill.

Determina en un conjunto de 5 números naturales:

1. ¿Cuántos son menores de 15?

2. ¿Cuántos son mayores de 500?

3. ¿Cuántos están comprendidos entre 25 y 50?

Ejemplo 1
Entrada: 2,1000,500,20,800
Salida:
    menores 15: 1
    mayores 500: 2
    entre 25 y 50: 0

Ejemplo 2
Entrada: 300, 45, 1, 600, 10
Salida:
    menores 15: 2
    mayores 500: 1
    entre 25 y 50: 1

Consejo: Antes de escribir código debes saber cómo se resuelve el problema a mano. Piensa en cómo lo resuelves. Haz el algoritmo paso a paso en un papel o en el editor de código.

1. Análisis

Nos dan una lista de 10 números enteros naturales. El cálculo es contar cuántos elementos cumplen cada una de las condiciones.

En el rango entre 25 y 50, el 50 está incluído.

Suponemos que los elementos de la entrada son válidos.

2. Diseño del algoritmo

1. Idea de solución

Recorrer cada elemento de la lista y preguntar si se cumplen las condiciones.

2. Diseño

Primer diseño

1. Preguntar si el número es menor a A
2. Preguntar si el número es mayor a B
3. Preguntar si el número está entre C y D

Estructuras de decisión: condicionales

Estas estructuras nos permiten condicionar qué va a pasar o no en el algoritmo. Si la condición se cumple, se ejecuta una acción. Las condicionales imitan la decisiones humanas. Con ellas añadimos inteligencia al algoritmo, una capacidad de decisión.

Las condiciones se resuelven en verdadero o falso.

Hay 3 tipos de condiciones:

• Condicional simple: Ejecuta una acción si la condición es verdadera.

si condición
    acción 1
fin si

• Condicional doble o compuesta: Ejecuta una acción si la condición es verdadera; otra ación, si es falsa.

si condición
    acción 1
si no 
    acción 2
fin si

• Condicional múltiple: Ejecuta diferentes acciones dependiendo de sus codiciones respectivas. Cada condición es una rama. El flujo se detiene cuando se cumple una condición; no se evalúan las restantes.

si condición 1
    acción 1
pero si condición 2
    acción 2
pero si condición 3
    acción 3
por defecto
    acción 4
fin si

En este problema tenemos 3 condicionales simples porque cada condición es independiente.

Pseudocódigo

# variables
lista ← [entrada]
enteros contadorA = 0 
        contadorB = 0
        contadorC = 0
        A = 15
        B = 500
        C = 25
        D = 50

inicio
    para cada elemento en lista hacer
        si elemento < A entonces
            contadorA++
        fin si
        si elemento > B entonces
            contadorB++
        fin si
        si elemento >= C Y elemento <= D entonces
            contadorC++
        fin si
    fin para cada

    escribir('Menores a {A}: {contadorA}')
    escribir('Mayores a {B}: {contadorB}')
    escribir('Entre {C} y {D}: {contadorc}')
fin

Agregamos flexibilidad al algoritmo al colocar en constantes los valores de las condiciones. Así, podemos cambiar esos valores y el programa seguirá funcionando.

3. Comprobación en seco

Comprueba el algoritmo con la segunda entrada del problema.

3. Codificación

# entrada 
lista = lista = [2,1000,500,20,800]
contador_a = 0
contador_b = 0
contador_c = 0
A = 15
B = 500
C = 25
D = 50

# cálculo
for elemento in lista:
    if elemento < A:
        contador_a += 1
    if elemento > B:
        contador_b += 1
    if elemento >= C and elemento <= D:
        contador_c += 1

# salida
print(f"Menores a {A}: {contador_a}")
print(f"Mayores a {B}: {contador_b}")
print(f"Entre {C} Y {D}: {contador_c}")

4. Complejidad

Tiempo: O(n)

Es lineal porque recorre una vez la lista para realizar el cálculo.

Espacio: O(1)

Es constante porque no utiliza una estructura de datos extra.

Bibliografía

Joyanes Aguilar, L. (2008). Fundamentos de programación. Madrid: McGraw-Hill.

Dados 10 números enteros:

1. Imprime la suma de los números pares.

2. Imprime cuántos números pares hay.

3. Imprime el promedio de los números impares.

Ejemplo 1
Entrada: 1,2,3,4,5,6,7,8,9,10
Salida: 
    suma pares: 30
    números pares: 5
    promedio impares: 5

Ejemplo 2
Entrada: 11,12,13,14,15,16,17,18,19,20
Salida:
    suma pares: 80
    números pares: 5
    promedio impares: 15

Consejo

Antes de escribir código debes saber cómo se resuelve el problema a mano. Piensa en cómo lo resuelves. Haz el plan o algoritmo en un papel o en el editor de código.

1. Análisis

Nos dan una lista de 10 números. Debemos hacer los 3 cálculos solicitados: suma de los pares, número de pares y promedio de los impares.

Suponemos que son naturales y que todos los elementos de la entrada son válidos.

2. Diseño del algoritmo

1. Idea de solución

Recorrer la lista y hacer los cálculos correspondientes.

2. Diseño

Primer diseño

1. Calcular suma de pares
2. Calcular número de pares
3. Calcular el promedio de los impares

Refinamiento

1. si par, entonces
2. guardar valor en un acumulador
3. aumentar el contador de pares
4. si impar, entonces
5. guardar valor en un acumulador
6. aumentar el contador de impares
7. repetir por cada elemento de la lista
8. calcular promedio
9. imprimir resultado: 
    suma pares, 
    cantidad pares, 
    promedio impares

En este problema, necesitamos saber calcular 3 cosas:

• ¿Cómo calcular el promedio?

• ¿Cómo calcular si un número es par?

• ¿Cómo guardar valores acumulativamente en una variable?

Calcular el promedio

El promedio es la suma de los elementos de un conjunto dividido entre el número de ellos.

(1+2+3+4+5+6+7+8+9+10) / 10

Calcular si un número es par con el operador módulo

El operardor módulo o resto es una operación que devuelve el resto de la división entre dos números. En otras palabras, es lo que sobra en la división cuando no es exacta. Por ejemplo, el resto de 5 / 2 es 1.

• División entera de 5 / 2 = 2

• Módulo o resto de 5 / 2 = 1

El operador módulo se suele usar para

• verificar si un número es divisible entre otro

• obtener el último dígito de un número

Representamos el operador módulo con mod o el símbolo %.

¿Cómo sabemos si un número es par? Aquí hacemos dos operaciones.

• Primero, calculamos el módulo 1 % 2.

• Luego, comparamos si el resultado es igual a 0.

Expresamos las dos operaciones de forma abreviada así: 1 % 2 == 0.

1 % 2     #  1
1 == 0    # falso

1 módulo 2 es 1. 1 no es igual a 0. Por lo tanto, 1 no es par.

2 % 2     # 0
0 == 0    # verdadero

2 módulo 2 es 0. 0 es igual a 0. Por lo tanto, 2 es par.

Variable acumuladora

Una variable acumuladora sirve para almacenar y actualizar valores. La diferencia con una variable normal es que agrega un nuevo valor al que ya tiene.

Generalmente, usamos las variables acumuladoras dentro de ciclos. Cada iteración del ciclo suma un nuevo valor.

Patron de código de variable acumuladora

nombre ← valor inicial + valor actual

El valor inicial suele ser 0 porque es un valor neutro.

Aquí utilizamos un par de variables acumuladoras; una para guardar la suma de los elementos pares, otra la de los impares.

Pseudocódigo

# variables
lista [entrada]
entero 
    SumaPares ← 0, SumaImpares ← 0, 
    ContadorPares ← 0, ContadorImpares ← 0

inicio
    por cada elemento en lista
        si elemento == par entonces (elemnto % 2 == 0)
            SumaPares ← SumaPares + elemento
            ContadorPares++
        fin si
        si no 
            SumaImpares ← SumaImpares + elemento
            ContadorImpares++
        fin si no
    fin por cada
    escribir('suma pares:', SumaPares)
    escribir('número pares:', ContadorPares)
    escribir('promedio impares:',SumaImpares/ContadorImpares)
fin

3. Comprobación en seco

Comprueba el algoritmo con la segunda entrada del problema.

3. Codificación

# entrada
lista = [1,2,3,4,5,6,7,8,9,10]

sumaPares = 0
sumaImpares = 0
contadorPares = 0
contadorImpares = 0
promedioImpares = 0

# cálculo
for elemento in lista:
    if elemento % 2 == 0:
      sumaPares = sumaPares + elemento
      contadorPares+=1
    else:
      sumaImpares = sumaImpares + elemento
      contadorImpares+=1

promedioImpares = sumaImpares/contadorImpares

# salida
print("Suma pares> ", sumaPares)
print("Cantidad pares> ", contadorPares)
print("Promedio impares> ", promedioImpares)

4. Complejidad

Tiempo: O(n)

Es lineal porque recorre una vez la lista para realizar el cálculo.

Espacio: O(1) constante

Es constante porque no utiliza una estructura de datos extra.

Bibliografía

Joyanes Aguilar, L. (2008). Fundamentos de programación. Madrid: McGraw-Hill.

Calcula los x primeros múltiplos de un número dado llamado base. x y base deben ser ingresados por teclado. Imprime el resultado.

Ejemplo 1
Entrada: x = 4, base = 4
Salida: 4, 8, 12, 16

Ejemplo 2
Entrada: x = 3, base = 5
Salida: 5, 10, 15

1. Análisis

• Los múltiplos son números que son se obtienen al mutiplicar un número por otro. En palabras simples, nos piden calcular la tabla de multiplicar de un número base, del 1 hasta el número x.

• Entrada son números enteros. Salida son números enteros.

• Asumimos que el cálculo incluye el número x, y que todas las entradas son válidas.

2. Diseño del algoritmo

1. Idea de solución

• Usar un ciclo para resolver el problema porque la solución es repetir una multiplicación.

• El problema no pide una estructura de datos.

2. Diseño

Primer diseño

1. Pedir al usuario x y base
2. Multiplicar 1 x base
2. Multiplicar 2 x base...
x. Multiplicar x x base

Refinamiento 1

1. Pedir x
2. Pedir base
3. Multiplicar base * i
4. Escribir resultado
5. Repetir hasta que i sea igual o menor a x

Refinamiento 2

1. Pedir x
leer x
Convertir x a entero
Guardar valor entero en x
2. Pedir base
leer base
Convertir base a entero
Guardar valor entero en base
4. Escribir base * i
5. Repetir hasta que i sea igual o menor a x

Los datos que ingresa el usuario, aunque sean números, son de tipo cadena. Debemos convertirlos a enteros para manejarlos como tal. Esto lo hacemos con una función interna del lenguaje de programación a la que llamamos, arbitrariamente, ConvertirEntero().

Inicializamos i en 1, porque el problema comienza en 1.

Pseudocódigo

Algoritmo Obtner múltiplos
# variables
enteros: x, base, i ← 1

inicio
    escribir("Escribe el número de multiplos: ")
    x ← ConvertirEntero(leer(x))
    escribir("Escribe la base: ")
    base ← ConvertirEntero(leer(base))

    mientras i <= x hacer
        escribir(base * i)
        i++
    fin mientras
fin

3. Comprobación en seco

Ejemplo 1

El programa se comporta de la forma deseada.

3. Codificación

He aquí la codificación en Python.

# Programa Calcular los primeros x múltiplos

print("Escribe el número de múltiplos:", end=" ")
x = input()
x = int(x)

print("Escribe el número:", end=" ")
base = input()
base = int(base)

i = 1
while i <= x:
    print(base * i)
    i+=1

4. Complejidad

Tiempo: O(n) -lineal- porque depende el número de múltiplos x.

Espacio: O(1) -constante- porque no se necesita una estructura de datos adicional.

Bibliografía

Joyanes Aguilar, L. (2008). Fundamentos de programación. Madrid: McGraw-Hill.

Dada una lista de calificaciones, calcula el promedio de un salón de clases. Las calificaciones son números enteros.

Ejemplo 1
Entrada: [10,9,9,8,5]
Salida: 8.2

Ejemplo 2
Entrada: [8,7,9,10,6]
Salida: 8

1. Análisis

• Entrada es una lista de números enteros; la salida es un número decimal.

• Piden calcular el promedio. El promedio es la suma de los datos divididos por el número de estos.

• Asumimos que las calificaciones miden del 0 al 10, que la lista no puede estar vacía, y que todos los datos son correctos.

2. Diseño

1. Idea de solución

• Usar la función interna Suma(). Pero eso hace todo el trabajo. Por lo tanto, queda fuera.

• Usar un ciclo para obtener el promedio. Elegimos esta.

2. Diseño del algoritmo

La técnica para resolver problemas de programación consiste en dividir el problema en problemas más simples.

Luego, refinamos el diseño para lograr pasos concretos hasta completar todos los pasos necesarios para resolver el problema.

El primer diseño

1. Sumar las calificaciones
2. Obtener el promedio

Primer refinamiento

1. Sumar las calificaciones
    1. Sumar una calificación con la siguiente
    2. Guardar el resultado de la suma
2. Repetir la suma hasta sumar todas las calificaciones
3. Dividir el resultado de la suma por la cantidad de calificaciones
4. Escribir el promedio

Segundo refinamiento

Inicializamos la variable suma en 0 para guardar el resultado de las sumas. 0 es un valor neutro. Al sumar 0 + un número, obtenemos el número.

Sumamos la calificación actual a suma. Esto porque visitamos una calificación de la lista de calificaciones a cada paso del ciclo. Al final, suma contendrá la suma de todas las calificaciones.

1. Sumar las calificaciones 
    1. Asignar 0 a suma
    2. Sumar la calificación actual a suma
    3. Guardar el resultado de la suma
2. Repetir la suma hasta sumar todas las calificaciones
3. Dividir el resultado de la suma por la cantidad de calificaciones 
4. Escribir el promedio

Tercer refinamiento

Organicemos las variables que usaremos:

• En la variable tamaño guardamos el número de elementos de la lista de calificaciones.

• Asignamos 0 a suma.

• Asignamos 0 a i que es la variable de control del ciclo.

Usaremos un ciclo mientras. El ciclo se va a repetir mientras i < tamaño.

En cada paso del ciclo se ejecuta:

• suma ← suma + calificaciones[i]

• i++

Ejecutemos en seco dos pasos del ciclo para ver qué estamos haciendo.

Diseño final en pseudocódigo

Algoritmo Promedio:

# Variables
array[n] enteros: calificaciones
real: suma ← 0
entero: i ← 0
        tamaño ← Longitud(calificaciones)

inicio
    mientras i < tamaño hacer
        suma ← suma + calificaciones[i]
        i++
    fin mientras
    escribir(suma / tamaño)
fin

3. Comprobación en seco

Ejecutamos en seco el algoritmo para comprobarlo paso a paso.

Ejemplo 1

Promedio = 8.2

Al parecer, nuestro algoritmo es correcto. Hicimos un buen trabajo.

Ahora es tu turno. Ejecuta en seco el algoritmo con los datos del ejemplo 2.

3. Codificación

Una vez que tenemos el algoritmo, podemos traducirlo a cualquier lenguaje de programación. He aquí el algoritmo codificado en Python.

# Programa Promedio
# variables
calificaciones = [10,9,9,8,5]
tamanio = len(calificaciones)
suma = 0

# Obtener la suma de las calificaciones
i = 0
while i < tamanio:
    suma = suma + calificaciones[i]
    i+=1 

# Salida
print(suma/tamanio)

Comprueba el programa ejecutándolo. Si encuentras errores, es necesario depurar el programa. Depurar es estudiar el código para encontrar el error y solucionarlo.

4. Complejidad

Tiempo: O(n) (lineal) porque el algoritmo debe recorrer cada elemento de la lista.

Espacio: O(1) (constante) porque el algoritmo no utiliza una estructura de datos adicional.

Bibliografía

Joyanes Aguilar, L. (2008). Fundamentos de programación. Madrid: McGraw-Hill.

En breve, este es el marco de trabajo:

1. Asegúrate de entender bien el problema.

2. Diseña el algoritmo

   1. Piensa en una idea que pueda resolverlo. Incluye una estructura de datos y una técnica que ayuden a la solución.

   2. Diseña el algoritmo. Desarrolla esa idea. Es un proceso de dividir el problema en problemas más simples. Luego, refina los pasos hasta tener pasos que se traduzcan en operacionese concretas. Los pasos deben estar completos.

   3. Ejecuta en seco el algortimo.

3. Codifica: Traduce a código el algoritmo, ejecútalo y comprueba el programa.

Introducción

¿Cuántas veces vemos un problema de leetcode o de algún libro de fundamentos de programación y no sabemos cómo afrontarlo?

Cuando estudiaba en la universidad, acudí con un par de compañeros a algunas sesiones de coding dojo en una empresa de software de mi ciudad llamada Michelada.io. En estas sesiones se proponía un problema, había un tiempo de 30 minutos para resolverlo, al final se compartían las respuestas.

Uno de esos problemas fue convertir un número arábigo a número romano. Recuerdo que me quedé en blanco. No tenía ni idea de cómo comenzar. Mis amigos tuvieron éxito; otros no terminaron, pero tenían idea de cómo continuar.

Me sentí desanimado por este hecho. ¿Qué pasó? ¿Eso significaba que la programación no era para mí, o que debía renunciar a mi proyecto de ser ingeniero de software? Pues no.

No poder resolver un problema no significa que seamos tontos, o que no seamos aptos para programar. Significa que todavía no tenemos demasiada exposición a estos problemas, que necesitamos practicar para mejorar esta habilidad.

Acotar el problema

Estamos limitando los problemas a problemas de tipo LeetCode.

Generalmente, estos problemas se resuelven eligiendo las estructuras de datos apropiadas, diseñando un algoritmo y codificando la solución en tu lenguaje de programación favorito.

Es una realidad que los problemas de software reales son diferentes a estos ejercicios tipo LeetCode. Sin embargo, desde mi punto de vista, estos ejercicios ayudan a:

• Repasar estructuras de datos.

• Diseñar algoritmos.

• Apropiarnos de la sintaxis.

• Probar en seco un programa.

• Practicar para entrevistas técnicas.

• Aumentar la confianza en nuestras habilidades.

Marco de trabajo

Este es el marco de trabajo:

1. Analizar el problema.

2. Diseñar el algoritmo.

3. Codificar.

Desarrollemos más estos tres pasos.

1 Analizar el problema

Aristóteles decía que un “error pequeño al inicio se convierte en un error mayor al final”. Si no entendemos el problema, sus partes y límites, no tiene sentido seguir adelante.

¿Qué analizamos aquí? Todo problema de programación se resume en tres partes:

• Entrada de datos.

• Procesamiento de esos datos.

• Salida de datos.

Debemos entender cuáles son los datos de entrada, cuál es el resultado esperado (porque con ese comprobaremos si nuestro cálculo es correcto) y qué procesamiento vamos a dar a los datos.

Adicionalmente, debemos pensar en los límites o restricciones que tenga el problema. Por ejemplo, ¿los datos son enteros o decimales? ¿Son positivos o negativos? ¿Existen casos límites que exijan una atención especial?

Por último, debemos confirmar nuestras suposiciones. Un enunciado del problema puede ser ambiguo, no explicitar todo lo que debería, o podemos entender una palabra con otro significado al del problema.

El análisis nos dice qué debemos hacer.

2 Diseñar el algoritmo

Programar es diseñar algoritmos para resolver un problema. Es la etapa creativa e intelectual y la más importante.

El algoritmo nos dice cómo se resuelve el problema.

Aterricemos unos pasos para diseñar el algoritmo:

1. Idea de solución.

2. Diseño y refinamiento de pasos.

3. Comprobación en seco.

Idea de solución

Después de entender el problema, debemos buscar un recurso, idea o técnica que ayude a resolverlo. Es una idea inicial, no está desarrollada.

La idea inlcuye una técnica de solución y, si es necesario, una estructura de datos.

Existen muchas formas de resolver un mismo problema, así que elige la idea que te parezca más fácil. Por ejemplo, para hallar el área de un triángulo hay varias fórmulas; pero la más común es (b x h) / 2.

¿De dónde sacamos esta idea? Puedes conocerla por aprendizaje o experiencia, deducirla por razonamiento, o pedir ayuda a chat GPT.

Diseño y refinamiento de pasos

Hasta ahora la idea es genérica y abstracta. Pero las computadoras entienden operaciones concretas. El problema no se resolverá si no hay instrucciones concretas y si no están completas.

1. Divide y vencerás: Divide el problema en problemas más simples.

2. Refina los pasos: Refina o itera sobre tu diseño hasta que tengas pasos concretos.

Escribe los pasos del algoritmo. Existen muchas formas de representar el algoritmo:

• Lenguaje natural.

• Pseudocódigo.

• Diagrama de flujo.

• Diagrama Nassi-Schneiderman.

• Fórmula matemática.

Elige una, la que más se te facilite. Yo prefiero el pseudocódigo.

Ejecutar en seco

Ejecutar en seco sirve para probar manualmente el flujo de tu algoritmo. Es decir, seguimos los valores de las variables en cada paso del algoritmo.

¿Cómo hacemos esto? Haz una tabla con los valores que toman las variables en cada paso del algoritmo. Compara el resultado final con la salida.

Esto es un ejemplo de un algoritmo que saca el promedio de las notas de estudiantes con las notas [10,9,9,8,5]. Salida = 8.2.

Al ejecutar el algoritmo en seco, comprobamos que el resultado es correcto.

3 Codificar

Codificar es el último paso de este marco de trabajo. Codificar es traducir a código el algoritmo diseñado.

1. Traduce el algoritmo. Revisa si tienes que ajustar el algoritmo a casos particulares del lenguaje de programación.

2. Ejecuta y comprueba el resultado. Si es el caso, depura el programa para corregir errores.

3. Analiza su complejidad de tiempo y espacio. Usamos la notación big O. Esto nos dice qué tan eficiente es un algoritmo.

Conclusión

En este artículo expliqué un marco de trabajo para resolver problemas de programación tipo LeetCode.

Se resume en entender el problema, diseñar un algoritmo y codificarlo.

Programar es como redactar una novela. Codificar es como escribir (en el sentido de trazar letras o palabras) no te hace un escritor. Nuestro error es pensar que por saber sintaxis y conceptos de programación ya sabemos programar.

Sin embargo, programar es pensar en cómo resolver un problema usando herramientas computacionales. En otras palabras, es sobre todo diseñar algoritmos.

Un par consejos:

• Comienza practicando problemas fáciles, luego aumenta la dificultad.

• Comienza escribiendo a mano el diseño del algoritmo, o en el editor de código si no quieres hacerlo a mano. No lo dejes el diseño en aire, es decir, hacerlo sólo mentalmente. Escribir nos da claridad y nos facilita traducirlo a código.

En los siguientes artículos, resolveré problemas usando este marco de trabajo. Si te interesa, puedes suscribirte y seguirme. ¡Hasta la próxima!

Bibliografía

Joyanes Aguilar, L. (2008). Fundamentos de programación. Madrid: McGraw-Hill.

Stepwise refinement. (s/f-b). Cornell.edu. Recuperado el 18 de noviembre de 2022, de Stepwise refinement[1]

Stepwise refinement. (s/f-a). Uct.ac.za. Recuperado el 18 de noviembre de 2022, de Stepwise refinement[2]