Fundamentos de Computación y Algoritmos

Introducción¶

Antes de escribir tu primera línea de código en C, es fundamental comprender algunos conceptos básicos sobre cómo funcionan las computadoras y cómo comunicarnos con ellas de manera efectiva. En este apunte, usaremos Python para ilustrar estos conceptos de forma clara y sencilla, aprovechando que vimos las bases en el curso de ingreso y aprovechando que el lenguaje es excelente para aprender a pensar como un programador.

¿Qué es una computadora?¶

Una computadora es una máquina electrónica diseñada para procesar información de manera automática, siguiendo instrucciones precisas y explícitas. A diferencia de los seres humanos, una computadora:

• No entiende ambigüedades: necesita instrucciones exactas y sin interpretación posible.

• No tiene intuición: hace exactamente lo que le decimos, ni más ni menos, sin asumir nada.

• Es extremadamente rápida: puede ejecutar millones (o incluso miles de millones) de instrucciones por segundo.

• Es absolutamente precisa: no comete errores de cálculo, aunque sí puede ejecutar instrucciones incorrectas que nosotros le proporcionemos.

• No se cansa: puede repetir la misma operación millones de veces sin degradación en su rendimiento.

Componentes básicos¶

Para entender cómo programar, es útil conocer los componentes principales de una computadora y cómo interactúan entre sí.

Hardware¶

El hardware son los componentes físicos de la computadora:

• Procesador (CPU): El “cerebro” que ejecuta las instrucciones. Realiza operaciones aritméticas, lógicas y de control. Su velocidad se mide en GHz (gigahertz).

• Memoria RAM: Memoria de acceso rápido donde se guardan temporalmente los datos y programas mientras se ejecutan. Es volátil: se borra cuando se apaga la computadora.

• Almacenamiento permanente: Disco duro (HDD) o unidad de estado sólido (SSD) donde se guardan archivos, programas y el sistema operativo de forma permanente.

• Dispositivos de entrada: Permiten introducir información (teclado, mouse, micrófono, cámara, sensores, etc.).

• Dispositivos de salida: Permiten obtener información (pantalla, impresora, altavoces, etc.).

Software¶

El software son los programas e instrucciones que controlan el hardware:

• Sistema operativo: Windows, Linux, macOS - el programa fundamental que controla el hardware y proporciona servicios básicos a otros programas. Actúa como intermediario entre el hardware y las aplicaciones.

• Programas o aplicaciones: Word, navegadores web, juegos, etc. Son software diseñado para realizar tareas específicas para el usuario.

• Código fuente: Las instrucciones que los programadores escriben en lenguajes de programación como Python o C. Este código debe ser traducido (compilado o interpretado) para que la computadora pueda ejecutarlo.

¿Qué es programar?¶

Programar es el arte y la ciencia de dar instrucciones precisas y detalladas a una computadora para que realice una tarea específica. Es un proceso creativo que requiere pensamiento lógico, atención al detalle y práctica constante.

Cuando programamos, debemos considerar:

1. ¿Qué problema queremos resolver? - Entender claramente el objetivo

2. ¿Qué datos necesitamos? - Identificar entradas y salidas

3. ¿Qué pasos seguir? - Diseñar el algoritmo

4. ¿Cómo traducirlo a código? - Escribir en un lenguaje de programación

5. ¿Funciona correctamente? - Probar y depurar

Analogía: La receta de cocina¶

Imagina que querés hacer un pastel y le das las instrucciones a alguien que nunca cocinó y que seguirá literalmente cada palabra que digás:

La computadora necesita el segundo tipo de instrucciones: específicas, ordenadas, sin ambigüedades y completamente detalladas.

Ejercicio inicial¶

¿Qué es un algoritmo?¶

Un algoritmo es una secuencia finita, ordenada y no ambigua de pasos bien definidos que resuelve un problema o realiza una tarea específica. Los algoritmos son la base fundamental de la programación.

Características de un buen algoritmo¶

Un algoritmo efectivo debe cumplir con las siguientes características:

Ejemplo detallado: Algoritmo para hacer café¶

Veamos un ejemplo cotidiano expresado como algoritmo formal:

┌─────────────────────────────────────────┐
│ Algoritmo: Hacer café                   │
├─────────────────────────────────────────┤
│ Entrada: ninguna                        │
│ Salida: una taza de café listo          │
├─────────────────────────────────────────┤
│ Pasos:                                  │
│                                         │
│ 1. Inicio                               │
│ 2. Verificar que haya agua en el        │
│    depósito de la cafetera              │
│ 3. Si NO hay agua:                      │
│    a. Llenar el depósito con 500ml      │
│       de agua                           │
│ 4. Verificar que haya un filtro limpio  │
│ 5. Si NO hay filtro:                    │
│    a. Colocar un filtro nuevo           │
│ 6. Agregar exactamente 2 cucharadas     │
│    (20g) de café molido en el filtro    │
│ 7. Colocar el filtro en la cafetera     │
│ 8. Encender la cafetera                 │
│ 9. Esperar 5 minutos                    │
│ 10. Verificar que la cafetera haya      │
│     terminado (luz apagada)             │
│ 11. Tomar una taza limpia               │
│ 12. Servir el café en la taza           │
│ 13. Fin                                 │
└─────────────────────────────────────────┘

Ejemplo matemático: Algoritmo para determinar si un número es par¶

┌─────────────────────────────────────────┐
│ Algoritmo: Verificar si N es par        │
├─────────────────────────────────────────┤
│ Entrada: un número entero N             │
│ Salida: mensaje indicando si es par     │
│         o impar                         │
├─────────────────────────────────────────┤
│ Pasos:                                  │
│                                         │
│ 1. Inicio                               │
│ 2. Pedir al usuario un número N         │
│ 3. Calcular el resto de dividir N / 2   │
│    (llamemos a este resto R)            │
│ 4. Si R es igual a 0:                   │
│    a. Mostrar "N es par"                │
│ 5. Si no (R no es 0):                   │
│    a. Mostrar "N es impar"              │
│ 6. Fin                                  │
└─────────────────────────────────────────┘

Este es el algoritmo traducido a código Python.

# 1. Pedir al usuario un número N
# Usamos int() para convertir el texto ingresado a un número entero
n = int(input("Ingrese un número: "))

# 2. Calcular el resto de dividir N / 2
# El operador '%' (módulo) nos da el resto de una división
resto = n % 2

# 3. Si el resto es igual a 0, el número es par
if resto == 0:
    # 3a. Mostrar "N es par"
    print(f"El número {n} es par.")
# 4. Si no, el número es impar
else:
    # 4a. Mostrar "N es impar"
    print(f"El número {n} es impar.")

# Leemos tres números
a = float(input("Ingrese el primer número: "))
b = float(input("Ingrese el segundo número: "))
c = float(input("Ingrese el tercer número: "))

# Opción 1: Usando condicionales
mayor = a
if b > mayor:
    mayor = b
if c > mayor:
    mayor = c

print(f"El mayor número es: {mayor}")

# Opción 2: Usando la función incorporada max()
# mayor = max(a, b, c)
# print(f"El mayor número es: {mayor}")

año = int(input("Ingrese un año: "))

# Un año es bisiesto si es divisible por 4,
# excepto los que son divisibles por 100,
# a menos que también sean divisibles por 400.
if (año % 400 == 0) or (año % 4 == 0 and año % 100 != 0):
    print(f"{año} es un año bisiesto.")
else:
    print(f"{año} no es un año bisiesto.")

n = int(input("Ingrese un número entero positivo: "))

if n < 0:
    print("Error: el factorial no está definido para números negativos.")
elif n == 0:
    print("El factorial de 0 es 1.")
else:
    factorial = 1
    # Usamos un bucle para multiplicar desde 1 hasta n
    for i in range(1, n + 1):
        factorial = factorial * i
    print(f"El factorial de {n} es: {factorial}")

Pensamiento lógico¶

El pensamiento lógico es la capacidad de razonar de manera coherente y estructurada. En programación, esto se traduce en tres estructuras fundamentales que aparecen en todos los algoritmos.

1. Secuencia¶

Las instrucciones se ejecutan una después de otra, en el orden exacto en que están escritas. El orden importa.

Ejemplo de la importancia del orden:

# 1. Poner agua en la olla
olla = ["agua"]
# 2. Poner la olla en el fuego
fuego_encendido = True
# 3. Esperar que hierva
agua_hirviendo = True
# 4. Agregar fideos
olla.append("fideos")
# 5. Cocinar 10 minutos
# 6. Escurrir
fideos_cocidos = True

# 1. Poner la olla vacía en el fuego
olla = []
fuego_encendido = True
# 2. Agregar fideos (a la olla vacía)
olla.append("fideos")
# 3. Poner agua
olla.append("agua")
# ... ¡Desastre!

2. Decisiones (Condicionales)¶

A veces necesitamos que el programa tome diferentes caminos dependiendo de una condición. Esto se representa con estructuras if...elif...else.

Ejemplo simple:

hace_frio = temperatura < 5

if hace_frio:
    print("Ponerme un abrigo")
else:
    print("Usar solo remera")

Ejemplo con condiciones anidadas:

tengo_hambre = True
hay_comida_en_casa = False

if tengo_hambre:
    if hay_comida_en_casa:
        print("Cocinar")
    else:
        print("Pedir delivery")
else:
    print("Continuar con mis actividades")

3. Repetición (Lazos o Bucles)¶

Cuando necesitamos hacer algo varias veces, usamos estructuras de repetición. Hay dos tipos principales:

Repetición con contador fijo (for)¶

Se usa cuando sabemos cuántas veces queremos repetir una acción.

# Repetir 10 veces
# range(10) genera números del 0 al 9
for i in range(10):
    print(f"Haciendo flexión de brazos número {i + 1}")

Repetición con condición (while)¶

Se usa cuando la repetición depende de que una condición sea verdadera.

platos_sucios = 3

while platos_sucios > 0:
    print(f"Lavando un plato... Quedan {platos_sucios - 1}")
    platos_sucios = platos_sucios - 1 # ¡Crucial no olvidar esto!

print("¡Todos los platos están limpios!")

Representación de datos¶

Las computadoras trabajan con información, y esa información puede ser de diferentes tipos. Es fundamental entender qué tipos de datos existen y cuándo usar cada uno.

Tipos de información fundamentales¶

1. Números enteros (int)¶

Números sin parte decimal, pueden ser positivos, negativos o cero.

Ejemplos:

• 5, -3, 0, 1000, -999

Usos comunes:

• Contar elementos (cantidad de estudiantes, productos, etc.)

• Índices y posiciones en listas

• Edades, años

• Cantidades exactas

Operaciones:

• Suma, resta, multiplicación

• División entera: 17 // 5 da como resultado 3

• Módulo (resto): 17 % 5 da como resultado 2

contador = 10
edad = 25
año = 2024
temperatura = -5

# Estos son de tipo float (decimal)
altura = 1.75
precio = 99.99

2. Números decimales (float)¶

Números que pueden tener parte decimal (reales o de punto flotante).

Ejemplos:

• 3.14, -0.5, 2.718, 1.0

Usos comunes:

• Mediciones (altura, peso, distancia)

• Cálculos con precisión (física, ingeniería)

• Precios con centavos

• Porcentajes

Operaciones:

• Todas las operaciones aritméticas normales

• División siempre da resultado decimal: 17.0 / 5.0 da 3.4

3. Cadenas de texto (str)¶

Secuencia de caracteres (letras, números, símbolos).

Ejemplos:

• Se escriben entre comillas simples o dobles: 'Hola', "Mundo", '@', "123"

Usos comunes:

• Nombres, apellidos, direcciones

• Mensajes al usuario

• Datos textuales en general

inicial = 'M'
signo = '+'
digito = '7'
espacio = ' '

nombre = "María"
mensaje = "Bienvenido"
direccion = "Calle 123"
frase = "Hola mundo"

4. Valores lógicos (bool)¶

Solo pueden tener dos valores: True (verdadero) o False (falso).

Usos comunes:

• Banderas (flags): indicar estados

• Resultados de comparaciones

• Condiciones en estructuras de control

Ejemplos en Python:

est_lloviendo = True
tiene_permiso = False
es_mayor_de_edad = True
archivo_existe = False

Variables: Las cajas de memoria¶

Una variable es un espacio en la memoria de la computadora donde guardamos información. Podemos pensar en ella como una caja etiquetada.

┌─────────────────────┐
│  edad               │  ← nombre de la variable (etiqueta)
│  tipo: int          │  ← tipo de dato que contiene
│                     │
│     25              │  ← valor actual guardado
└─────────────────────┘

Características fundamentales:

1. Nombre (identificador): Una palabra que usamos para referirnos a la variable

   • Debe ser descriptivo: edad es mejor que x

   • No puede empezar con número

   • No puede tener espacios ni símbolos especiales (excepto _)

   • Distingue mayúsculas: edad ≠ Edad ≠ EDAD

2. Tipo: Define qué clase de datos puede almacenar

   • En Python, el tipo es dinámico (se infiere del valor)

   • Determina qué operaciones se pueden hacer

3. Valor: El dato actual guardado

   • Puede cambiar durante la ejecución del programa

   • Debe ser compatible con el tipo

Ejemplos de variables en Python:

# Python infiere el tipo de dato automáticamente

# Variable de tipo entero (int)
edad = 20

# Variable de tipo decimal (float)
altura = 1.75

# Variable de tipo texto (str)
nombre = "Ana"

# Variable de tipo booleano (bool)
aprobado = True

El ciclo de vida de una variable¶

Operaciones básicas¶

Las operaciones son acciones que podemos realizar sobre los datos. Existen diferentes tipos según el tipo de dato.

Operaciones aritméticas¶

Operaciones matemáticas básicas sobre números:

Orden de operaciones (precedencia):

Al igual que en matemática, las operaciones tienen un orden de evaluación:

1. Paréntesis ()

2. Potencias **

3. Multiplicación, División, Módulo *, /, //, %

4. Suma, Resta +, -

# Ejemplo: 2 + 3 * 4
#          2 + 12        (primero multiplicación)
#          14            (luego suma)
print(2 + 3 * 4)  # Salida: 14

# Ejemplo: (2 + 3) * 4
#          5 * 4         (primero paréntesis)
#          20            (luego multiplicación)
print((2 + 3) * 4) # Salida: 20

Operaciones de comparación¶

Comparan dos valores y devuelven True o False:

Ejemplos:

edad = 20

print(edad > 18)     # True  (20 es mayor que 18)
print(edad == 20)    # True  (20 es igual a 20)
print(edad < 15)     # False (20 no es menor que 15)
print(edad >= 20)    # True  (20 es mayor o igual a 20)
print(edad != 25)    # True  (20 es diferente de 25)

Operaciones lógicas¶

Combinan condiciones booleanas:

Ejemplos prácticos:

edad = 20
tiene_dni = True

# ¿Puede votar?
if (edad >= 18) and (tiene_dni == True):
    print("Puede votar")

es_fin_de_semana = False
es_feriado = True

# ¿Hay clases?
if not (es_fin_de_semana or es_feriado):
    print("Hay clases")
else:
    print("No hay clases")

esta_lloviendo = True

# ¿Llevo paraguas?
if not esta_lloviendo:
    print("No es necesario llevar paraguas")
else:
    print("Mejor llevar paraguas")

Diagramas de flujo¶

Los diagramas de flujo son representaciones gráficas de algoritmos que nos ayudan a visualizar la lógica del programa de manera clara y estructurada. Siguen siendo una herramienta universal, independientemente del lenguaje de programación.

Símbolos estándar¶

(La descripción de los símbolos y los diagramas de ejemplo siguen siendo válidos, ya que representan la lógica del algoritmo, no el código).

De Algoritmos a Código con Python¶

El pseudocódigo es una forma de escribir algoritmos usando lenguaje natural estructurado. Es un paso intermedio útil. Ahora, veremos cómo traducir esos algoritmos directamente a código Python, que es un lenguaje de programación real y ejecutable.

Ejemplo completo 1: Calculadora simple¶

# Algoritmo: Calculadora Simple
# Descripción: Realiza operaciones básicas entre dos números

print("=== CALCULADORA SIMPLE ===")

# Leer los números y convertirlos a float (decimal)
numero1 = float(input("Ingrese el primer número: "))
numero2 = float(input("Ingrese el segundo número: "))

# Leer la operación
operacion = input("Ingrese la operación (+, -, *, /): ")

# Realizar el cálculo basado en la operación
if operacion == '+':
    resultado = numero1 + numero2
    print(f"Resultado: {numero1} + {numero2} = {resultado}")
elif operacion == '-':
    resultado = numero1 - numero2
    print(f"Resultado: {numero1} - {numero2} = {resultado}")
elif operacion == '*':
    resultado = numero1 * numero2
    print(f"Resultado: {numero1} × {numero2} = {resultado}")
elif operacion == '/':
    # Verificar la división por cero
    if numero2 != 0:
        resultado = numero1 / numero2
        print(f"Resultado: {numero1} ÷ {numero2} = {resultado}")
    else:
        print("Error: No se puede dividir por cero")
else:
    print("Error: Operación no válida")

Ejemplo completo 2: Tabla de multiplicar¶

# Algoritmo: Tabla de Multiplicar
# Descripción: Muestra la tabla de multiplicar de un número del 1 al 10

print("=== TABLA DE MULTIPLICAR ===")
numero = int(input("Ingrese un número: "))

print(f"Tabla del {numero}:")
print("─────────────────")

# Usamos un bucle 'for' que cuenta desde 1 hasta 10
for contador in range(1, 11):
    resultado = numero * contador
    # f-string para formatear la salida de manera prolija
    print(f"{numero} × {contador} = {resultado}")

Ejemplo completo 3: Adivinar número¶

# Algoritmo: Adivinar Número
# Descripción: El usuario intenta adivinar un número secreto

import random # Importamos la librería para generar números aleatorios

numero_secreto = random.randint(1, 100) # Número aleatorio entre 1 y 100
intentos_maximos = 5
intentos_realizados = 0
adivinado = False

print("=== ADIVINA EL NÚMERO ===")
print(f"Tenés {intentos_maximos} intentos para adivinar un número entre 1 y 100")

while intentos_realizados < intentos_maximos and not adivinado:
    intentos_realizados += 1
    print(f"\nIntento {intentos_realizados} de {intentos_maximos}:")
    
    intento = int(input("Ingresá tu número: "))
    
    if intento == numero_secreto:
        adivinado = True
        print("¡¡¡FELICITACIONES!!! ¡Adivinaste el número!")
        print(f"Lo lograste en {intentos_realizados} intentos")
    elif intento < numero_secreto:
        print("El número secreto es MAYOR")
    else:
        print("El número secreto es MENOR")

if not adivinado:
    print("\nGame Over. Te quedaste sin intentos.")
    print(f"El número secreto era: {numero_secreto}")

def celsius_a_fahrenheit(celsius):
    """Convierte temperatura de Celsius a Fahrenheit."""
    return celsius * 9/5 + 32

# --- Programa principal ---
c = float(input("Ingrese temperatura en Celsius: "))
f = celsius_a_fahrenheit(c)
print(f"{c}°C = {f}°F")

def es_triangulo(lado1, lado2, lado3):
    """Verifica si tres lados pueden formar un triángulo."""
    return (lado1 + lado2 > lado3) and \
           (lado1 + lado3 > lado2) and \
           (lado2 + lado3 > lado1)

# --- Programa principal ---
l1 = float(input("Lado 1: "))
l2 = float(input("Lado 2: "))
l3 = float(input("Lado 3: "))

if es_triangulo(l1, l2, l3):
    print("Los lados pueden formar un triángulo.")
else:
    print("Los lados NO pueden formar un triángulo.")

def mcd(a, b):
    """Calcula el Máximo Común Divisor usando el algoritmo de Euclides."""
    while b != 0:
        a, b = b, a % b
    return a

# --- Programa principal ---
num1 = int(input("Número 1: "))
num2 = int(input("Número 2: "))
print(f"El MCD es: {mcd(num1, num2)}")

def es_palindromo(palabra):
    """Verifica si una palabra es un palíndromo."""
    # Preparamos la palabra: minúsculas y sin espacios
    palabra = palabra.lower().replace(" ", "")
    # Comparamos la palabra con su inversa
    return palabra == palabra[::-1]

# --- Programa principal ---
texto = input("Ingrese una palabra o frase: ")
if es_palindromo(texto):
    print(f'"{texto}" es un palíndromo.')
else:
    print(f'"{texto}" no es un palíndromo.')

Ejercicios integradores¶

Errores comunes y cómo evitarlos¶

1. Secuencia incorrecta de instrucciones¶

El orden de las instrucciones es crucial. Un error común es no considerar el flujo lógico.

# Usa las variables antes de leerlas
resultado = a + b
a = int(input("a: "))
b = int(input("b: "))
print(resultado)

# Lee primero, calcula después
a = int(input("a: "))
b = int(input("b: "))
resultado = a + b
print(resultado)

2. Condiciones mal formuladas¶

# Más complejo de lo necesario
if edad > 18 or edad == 18:
    print("Mayor de edad")

# Simplificar condiciones
if edad >= 18:
    print("Mayor de edad")
else:
    print("Menor de edad")

3. Ciclos infinitos¶

Un ciclo infinito ocurre cuando la condición de salida nunca se cumple.

contador = 1
while contador <= 10:
    print(contador)
    # ¡Olvidamos incrementar contador!

contador = 1
while contador <= 10:
    print(contador)
    contador = contador + 1 # o contador += 1

4. Usar variables sin inicializarlas¶

# ¿Cuánto vale 'suma' al principio?
# Esto dará un error en Python.
suma = suma + 5

suma = 0 # Inicializamos la variable
suma = suma + 5
print(suma) # Ahora suma vale 5

La importancia de la práctica¶

Aprender a programar es como aprender a tocar un instrumento o un deporte:

• La teoría es importante, pero no suficiente

• Necesitás practicar para desarrollar la habilidad

• Vas a cometer errores - y está perfecto, es parte del aprendizaje

• La constancia es más importante que la intensidad

Próximos Pasos: El Lenguaje C¶

Ahora que comprendés estos conceptos fundamentales usando Python, estás mucho mejor preparado para abordar el lenguaje C. En el próximo apunte veremos:

• Cómo escribir estos mismos algoritmos en el lenguaje C

• La sintaxis más estricta y detallada de C

• El proceso de compilación y ejecución de programas

• Variables y tipos de datos estáticos en C

• Estructuras de control (if, while, for) en C

Recordá que toda la lógica que vimos aquí se aplica directamente a C. La principal diferencia será la sintaxis y la necesidad de gestionar la memoria de forma más explícita.

Glosario básico¶

Recursos adicionales¶

• Practicá resolviendo problemas simples en Python.

• Dibujá diagramas de flujo antes de empezar a codificar.

• Intentá “ejecutar” tus algoritmos mentalmente o en papel para seguir la lógica.

• Discutí tus soluciones con compañeros - hay muchas formas de resolver un problema.

Referencias y Lecturas Complementarias¶

Fundamentos de Algoritmos¶

• Cormen et al. (2009). Capítulos 3-4: Growth of Functions y Divide-and-Conquer.

• Sedgewick & Wayne (2011). Capítulo 1: Fundamentals. Introducción accesible con visualizaciones.

  • Disponible en: https://algs4.cs.princeton.edu/

Pensamiento Computacional¶

• Wing (2006). El artículo que popularizó el término “pensamiento computacional”.

• Aho & Ullman (1995). Conceptos fundamentales: algoritmos, estructuras de datos, lógica.

Resolución de Problemas¶

• Polya (2014). Clásico sobre heurísticas de resolución de problemas (1945).

• Bentley (1999). Columnas sobre diseño de algoritmos y resolución de problemas.

Recursos en Línea¶

• Khan Academy - Algorithms - https://www.khanacademy.org/computing/computer-science/algorithms

  • Curso interactivo sobre algoritmos básicos.

  • Visualizaciones y ejercicios progresivos.

• Visualgo - https://visualgo.net/

  • Visualización de algoritmos y estructuras de datos.

  • Muy útil para entender ejecución paso a paso.

• CS Unplugged - https://csunplugged.org/

  • Actividades para aprender conceptos sin computadora.

  • Ideal para desarrollar intuición algorítmica.

En el próximo apunte, Introducción a la programación en C, comenzaremos a traducir estos conceptos al lenguaje C y escribiremos nuestros primeros programas.