Teoría: algoritmos y diagramas de flujo

Esta página resume ideas clave para aprender a pensar en pasos y representar un problema con un diagrama de flujo. Está pensada para usarla junto con DF Creator (simulación, lecturas, decisiones y bucles).

¿Qué es un algoritmo?

Un algoritmo es una secuencia finita de pasos bien definidos que, partiendo de unas entradas, produce un resultado (salida). Debe ser:

• Finito: en algún momento termina.
• Preciso: cada paso se entiende sin ambigüedad.
• Ordenado: el orden importa.

Diagrama de flujo

Un diagrama de flujo muestra el camino del algoritmo: empieza, hace cosas, puede decidir, puede repetir y termina. Sirve para:

• Explicar la lógica a otras personas (o a vos mismo dentro de unos meses).
• Detectar casos olvidados (¿qué pasa si los dos números son iguales?).
• Planificar antes de programar.

En la práctica educativa conviene tener siempre un Inicio y un Fin, y que cada símbolo tenga entrada y salida coherente con el flujo (sin “callejones” sueltos).

Símbolos básicos (resumen)

Variables

Definición. Una variable es un nombre simbólico asociado a un valor que puede cambiar durante la ejecución del algoritmo (por eso “variable”).

Declaración y asignación

• Declarar (en pseudocódigo o en clase): decidir el nombre y, a veces, el tipo o el valor inicial.
• Asignar: guardar un valor en la variable, por ejemplo n = 5 o total = total + x.
• Leer / ingresar: el valor llega desde afuera (teclado, sensor, archivo). En diagrama suele ir en E/S.

Nombres válidos (regla práctica)

Usá letras, números y guion bajo; el primer carácter no debe ser un número. Ejemplos: edad, suma_total, i. Evitá espacios en el nombre.

Tipos de datos (idea general)

Operadores

Los operadores son símbolos que combinan valores y producen un resultado. En expresiones del simulador y en pseudocódigo suelen usarse las mismas ideas que en JavaScript.

Aritméticos

Comparación (relacionales)

Lógicos

Estructura condicional (if / else)

Definición. Una estructura condicional elige qué camino seguir según si una condición es verdadera o falsa. Es la base del si–sino (if–else).

En diagrama de flujo

El rombo representa la pregunta. Debe haber al menos dos salidas (por ejemplo Sí y No) hacia bloques distintos que luego pueden volver a unirse.

Condiciones útiles en clase

• Comparación: a == b, a != b, a >= b.
• Paridad: n % 2 == 0 (par), n % 2 != 0 (impar).
• Combinar: edad >= 18 && tieneDNI.

Si – sino si – sino (varias ramas)

Cuando hay varias opciones excluyentes, se encadenan condiciones: si no se cumple la primera, se prueba la segunda, etc.; al final puede ir un sino para “cualquier otro caso”.

si condición1 entonces
  acción A
sino si condición2 entonces
  acción B
sino
  acción C
fin si

En diagrama: varios rombos en cadena o una decisión con más de dos salidas bien etiquetadas.

Bucles: while, for y do–while

Definición general. Un bucle (ciclo o lazo) repite un bloque de instrucciones mientras se cumple una regla. Siempre hay que asegurar que en algún momento la condición deje de cumplirse (o haya un break explícito), para que el algoritmo no quede infinito.

Mientras (while)

Definición. Evalúa la condición al principio. Si es verdadera, ejecuta el cuerpo y vuelve a evaluar. Si al entrar la condición es falsa, el cuerpo no se ejecuta ninguna vez.

mientras condición hacer
  (cuerpo del bucle)
fin mientras

En diagrama: rombo o hexágono al inicio del ciclo, cuerpo, y flecha de vuelta a la condición.

Para (for)

Definición. Un for agrupa en un encabezado lo típico de un contador: inicialización, condición y actualización (paso) después de cada vuelta. Es muy usado cuando sabés cuántas vueltas dar o recorrés un rango.

para i desde 1 hasta n hacer
  (cuerpo)
fin para

// Forma clásica (tres partes):
para (i = 1; i <= n; i = i + 1) hacer
  (cuerpo)
fin para

En diagrama: tres procesos/condiciones (inicio i, mientras i <= n, al final i = i + 1) conectados alrededor del cuerpo.

Hacer – mientras (do–while)

Definición. Primero ejecuta el cuerpo y después pregunta si repite. Por tanto el cuerpo se ejecuta al menos una vez, aunque la condición sea falsa desde el principio (a diferencia del while estándar).

hacer
  (cuerpo)
mientras condición

En diagrama: el cuerpo va antes del rombo que pregunta si se vuelve al inicio del bloque.

Resumen comparativo

En DF Creator el símbolo Bucle / repetición y las flechas de retorno sirven para modelar la vuelta al inicio del ciclo; la condición va en el hexágono.

Contador

Un contador es una variable entera que cuenta cuántas veces pasó algo o en qué “vuelta” del ciclo estás.

Patrón típico

1. Inicializar: i = 1 (o i = 0, según el enunciado).
2. Condición: i <= n.
3. Cuerpo: lo que querés repetir.
4. Actualizar: i = i + 1 (o i = i - 1 si contás hacia atrás).

Ejemplo mental. Contar del 1 al 5: empezás en 1, repetís mientras i <= 5, y en cada vuelta sumás 1.

Inicializar i = 1
Mientras i <= n
  (acción)
  i = i + 1
Fin mientras

Acumulador

Un acumulador guarda un resultado parcial que se va construyendo en cada repetición (suma de números, producto, conteo de aprobados, etc.). No es lo mismo que un contador:

• Contador: suele sumar 1 (o un paso fijo).
• Acumulador: suma (o combina) valores variables: suma = suma + x.

Patrón típico (suma de 1 a n)

1. i = 1, suma = 0
2. Mientras i <= n: suma = suma + i, luego i = i + 1
3. Mostrar suma

Funciones (subprogramas)

Definición. Una función (o procedimiento / subrutina) es un bloque de instrucciones con nombre que podés llamar desde varios lugares del algoritmo. Sirve para no repetir código, ordenar el problema en partes y probar cada parte por separado.

Elementos típicos

• Nombre: identifica la función (ej. calcularPromedio, esPar).
• Parámetros: datos que “entran” a la función (ej. promedio(a, b, c)).
• Cuerpo: los pasos que hace la función.
• Valor de retorno (opcional): un resultado que “sale” hacia quien llamó (ej. devolver suma / n).

Llamada a función

Definición. Una llamada es usar el nombre de la función con los argumentos concretos en ese momento. El flujo “salta” al cuerpo de la función y al terminar suele volver al punto siguiente de la llamada, a veces trayendo un valor.

función doble(x):
  devolver x * 2

// Uso:
resultado = doble(5)   // resultado vale 10

Función vs diagrama de flujo

En papel podés dibujar un diagrama aparte para cada función y en el diagrama principal un solo bloque “llamar a …”. En DF Creator el símbolo Proceso predefinido sugiere esa idea a nivel visual; la simulación detallada de “subdiagramas” depende de la herramienta, pero el concepto es el mismo.

Procedimiento (sin retorno)

A veces solo importa hacer algo (imprimir, guardar) y no devolver un valor. Eso se llama a veces procedimiento. La idea de “bloque reutilizable con nombre” es la misma.

Cómo se relaciona con DF Creator

En el simulador de la aplicación podés usar, entre otras cosas:

• Entrada en un paralelogramo: Leer a y b o Leer n.
• Valores iniciales en un cuadrado variable o proceso: líneas x = 10.
• Salida: imprimir("Texto " + a).
• JSON de entradas para completar variables que no declaraste en el diagrama.
• Rombo / bucle: condición con expresiones como en esta guía.

Si el simulador avisa que falta algo, suele ser porque falta condición, faltan dos salidas en una decisión, o faltan datos de entrada para variables usadas en Leer.

Recursividad

La recursividad es cuando un algoritmo (o una función) se define en términos de sí mismo, pero siempre con un caso más “chico” hasta llegar a un caso base que se resuelve directo sin volver a llamarse.

Ideas clave

• Caso base: condición de parada (ejemplo factorial: n <= 1 → resultado 1).
• Caso recursivo: el problema se reduce (ejemplo: n * factorial(n - 1)).
• Peligro: si falta el caso base o la reducción no avanza, el proceso no termina.

Recursión vs repetición (iteración)

• Iteración (while/for): suele ser más fácil de seguir en diagrama de flujo.
• Recursión: muy elegante para problemas “auto-similares” (árboles, divide y vencerás).

En muchos cursos primero se enseña iteración con contador/acumulador y después recursión, cuando ya dominás el flujo y el estado de las variables.

// Idea factorial (pseudocódigo)
función factorial(n):
  si n <= 1 entonces
    devolver 1
  sino
    devolver n * factorial(n - 1)

Errores comunes (y cómo evitarlos)

• Rombo vacío o ambiguo: siempre escribí la condición completa.
• Una sola flecha saliendo del rombo: agregá la rama alternativa.
• Olvidar inicializar el acumulador o el contador antes del bucle.
• Condición del bucle mal planteada: que el contador realmente avance hacia el fin.
• Mezclar roles: no uses el acumulador como si fuera solo un contador, salvo que el enunciado lo pida.