00 · Programar desde cero
Aprender a programar · Ruta de Aprendizaje
Si nunca has programado, este es tu punto de partida. Si ya escribes ciclos con soltura, salta directo al módulo 01.
Antes de empezar. No necesitas haber programado antes. Los ejemplos usan C++; el módulo 01 - Tu primer programa explica cómo ejecutarlos.
🎯 Objetivos
Al terminar este módulo sabes:
- Guardar información en variables y tomar decisiones con
if. - Repetir trabajo con
forywhile(y saber cuál usar). - Escribir funciones y manejar texto (strings) en lo básico.
📖 La lección
Puedes recorrer esta página en tres partes: leer y calcular, decidir y repetir y funciones. El texto y los atajos quedan como ampliación al final.
Para ejecutar el primer programa sin instalar nada, abre el editor de USACO Guide, elige C++, pega el programa completo, escribe 4 en Input y pulsa Run. Output debe mostrar 5. El módulo 01 explica después cómo repetir este proceso con archivos en tu computador; no necesitas terminarlo antes de seguir aquí.
Qué es programar
Un algoritmo es una lista de instrucciones que, ejecutadas al pie de la letra — incluso sin pensar — logran un objetivo. Ese “sin pensar” es la clave: es lo que permite que las ejecute un computador. Programar es escribir esas instrucciones en un lenguaje que la máquina entienda; el nuestro es C++.
Dónde se escriben las instrucciones
Este programa completo lee un número y escribe el siguiente:
#include <bits/stdc++.h>
using namespace std;
int main() {
int numero;
cin >> numero;
cout << numero + 1 << "\n";
return 0;
}#include habilita las herramientas de la biblioteca y using namespace std;
permite escribir sus nombres sin el prefijo std::. La ejecución empieza en
main: sus llaves delimitan las instrucciones. cin >> lee un dato;
cout << escribe y "\n" termina la línea. Con entrada 4, la salida es 5.
return 0; termina el programa normalmente.
Los fragmentos de variables, condiciones y ciclos que siguen van dentro de
main. Las definiciones de funciones van antes de main y se llaman
desde él. Un comentario // supone: indica los datos que el fragmento espera
que hayas declarado y leído. Para compilar este archivo, sigue el módulo
01 - Tu primer programa.
Variables: la memoria de tu programa
Una variable guarda un dato y puede cambiar (por eso el nombre). Cada una tiene un tipo según lo que guarda:
int edad = 15; // número entero
double promedio = 6.4; // número con decimales
string nombre = "Isidora"; // texto
bool aprobada = true; // verdadero o falso
edad = edad + 1; // una variable puede cambiar: por eso se llama así(Para enteros grandes existe long long — lo vas a necesitar pronto, el
módulo 02 te dirá por qué.)
Una compra, paso a paso. Hay 3 entradas a 2000 pesos cada una. Dentro de main, int cantidad = 3; int precio = 2000; int total = cantidad * precio; guarda 6000 en total. Si luego escribes cantidad = 4;, total no se recalcula solo:
| Instrucción recién ejecutada | cantidad | precio | total |
|---|---|---|---|
| calcular el total | 3 | 2000 | 6000 |
| cambiar la cantidad | 4 | 2000 | 6000 |
total = cantidad * precio; | 4 | 2000 | 8000 |
Una variable guarda un valor, no una fórmula que se mantiene actualizada.
Condicionales: decidir
Como en la vida: si llueve, llevo paraguas; si no, salgo sin él.
// supone: int a, b; // dos enteros ya leídos
if (a > b) {
cout << "gana a\n";
} else if (b > a) {
cout << "gana b\n";
} else {
cout << "empate\n";
}
// condiciones compuestas: && es "y", || es "o", ! es "no"
if (a % 2 == 0 && b % 2 == 0) cout << "ambos pares\n";Léelo como un camino con bifurcaciones: cada pregunta se hace solo si la anterior falló, y apenas una rama se cumple, las demás ni se miran.
Si el diagrama no cabe, deslízalo horizontalmente.
⚠️ El error más clásico de la historia: == compara, = asigna.
Un if (a = b) compila… y hace cualquier cosa menos lo que querías.
(El % de arriba es el resto de la división: a % 2 es 0 exactamente
cuando a es par. Guárdalo — aparece en todas partes.)
Ciclos: repetir
La regla del pulgar: si sabes cuántas veces repetir, usa for (corre 10
vueltas a la cancha); si solo sabes cuándo parar, usa while (corre
hasta cansarte).
// supone: int n; // ya leído
long long suma = 0;
for (int i = 1; i <= n; i++) // repite con i = 1, 2, ..., n
suma += i;
El for tiene tres partes: inicio (i = 1), condición (i <= n) y paso
(i++). El inicio corre una sola vez; después el ciclo es siempre el
mismo giro: pregunta, cuerpo, paso, pregunta…
Si el diagrama no cabe, deslízalo horizontalmente.
Para n = 3, el for suma 1, después 2 y después 3: suma pasa por
0 → 1 → 3 → 6. i++ avanza al siguiente entero y la condición decide si
hay otra vuelta.
Ahora queremos dividir un entero no negativo por dos hasta llegar a cero. La pregunta que repetimos es «¿todavía queda un valor positivo?»:
// supone: int n; // n >= 0
int x = n, pasos = 0;
while (x > 0) {
x /= 2;
pasos++;
}Con el while pasa lo mismo, solo que tú escribes el paso a mano dentro del
cuerpo. i++ suma uno; suma += i equivale a suma = suma + i;
x /= 2 equivale a x = x / 2. Entre enteros positivos, la división
quita la parte decimal: 3 / 2 da 1. Para n = 6:
| vuelta | x al empezar | x tras dividir por 2 | pasos |
|---|---|---|---|
| 1 | 6 | 3 | 1 |
| 2 | 3 | 1 | 2 |
| 3 | 1 | 0 | 3 |
Ahora x > 0 es falso y el ciclo termina. A diferencia de una condición
sola, reducir un entero positivo en cada vuelta explica por qué termina.
Hacer estas trazas a mano, con un ejemplo chico, es la herramienta número uno para entender un ciclo ajeno (o encontrar el error en uno tuyo). ⚠️ Y si olvidas actualizar la variable de la condición, el ciclo es infinito — tu programa se queda pegado para siempre.
Para acumular varias compras, inicia total = 0 antes del ciclo. En cada vuelta lees una nueva cantidad y haces total += cantidad * precio. Con cantidades 3 y 4 y precio 2000, el acumulador pasa por 0 → 6000 → 14000. Reiniciarlo dentro del ciclo perdería la primera compra.
Funciones: ponerle nombre a un trabajo
Una función recibe datos, hace un trabajo y devuelve un resultado. Sirven para no repetir código y para pensar en pedazos:
long long area_rectangulo(long long ancho, long long alto) {
return ancho * alto;
}
bool es_par(long long n) {
return n % 2 == 0;
}Se usan por su nombre: area_rectangulo(3, 4) vale 12. En el módulo
09 las funciones revelarán su superpoder: llamarse a sí
mismas.
Una llamada completa, con la definición antes de main:
#include <iostream>
using namespace std;
int costo(int cantidad, int precio) { return cantidad * precio; }
int main() {
cout << costo(3, 2000) << "\n";
cout << costo(4, 2000) << "\n";
}Imprime 6000 y 8000. Cada llamada recibe sus propios parámetros: en la primera cantidad=3; en la segunda cantidad=4. return entrega el resultado a quien llamó.
Ampliación: strings y atajos
Un atajo que verás por todos lados: cuando el if/else solo elige entre
dos valores, se puede escribir en una línea con ? y : —
cout << (a > b ? "gana a" : "gana b"); significa “si a > b, usa lo de
antes de los dos puntos; si no, lo de después”. Es la misma decisión, escrita
corto.
En la compra anterior, if (total > 7000) cout << "supera el presupuesto\n"; muestra el mensaje para 8000, pero no para 6000. La condición usa el valor guardado en ese momento.
Un string guarda texto, y por dentro es una secuencia de letras que puedes
recorrer igual que números:
string palabra;
cin >> palabra; // lee UNA palabra (corta en el espacio)
cout << palabra.size() << "\n"; // su largo
cout << palabra[0] << "\n"; // su primera letra (¡desde 0!)
int vocales = 0;
for (char c : palabra) // recorrer letra por letra
if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') vocales++;
string invertida = "";
for (int i = (int)palabra.size() - 1; i >= 0; i--)
invertida += palabra[i]; // pegar las letras de atrás hacia adelante
if (palabra == invertida) cout << "palindromo\n"; // comparar con == funcionaEse ciclo junta tres ideas de este módulo: recorrer hacia atrás, += para
concatenar texto, y comparar strings con ==.
Si el diagrama no cabe, deslízalo horizontalmente.
Dos detalles de ese código que verás en todas partes. Las posiciones parten
en 0, así que la última letra está en size() - 1, no en size(). Y el
(int) delante de palabra.size() convierte el largo a un entero común:
size() devuelve un tipo sin signo, y con una palabra vacía size() - 1
no daría −1 sino un número gigante. Con el (int), la resta se hace en
enteros normales y el ciclo simplemente no corre.
📌 Fíjate en la forma for (char c : palabra) del contador de vocales: es el
for para recorrer colecciones (“para cada letra c de palabra…”).
Funciona igual con vectores (for (int x : numeros)) y lo usarás durante toda
la ruta. Cuando necesites la posición además del valor, vuelve al for con
índice, como en el ciclo de arriba.
Dato curioso de regalo: prueba el programa con la palabra “reconocer”.
🏋️ Práctica
Práctica directa: Una compra
Lee dos enteros: cantidad (0 a 100) y precio (1 a 10000). Imprime el total. Entrada: 3 2000. Salida: 6000.
Idea para comprobar tu solución
Multiplica los dos datos; cambia la cantidad a 0 y el total debe ser 0. No necesitas arreglos.
Aplicar en problemas
Los problemas siguientes requieren traducir un enunciado y pueden combinar otras ideas. Su procedencia e idioma no indican un orden obligatorio de dificultad.
Problemas OCI reales, en español. Las instrucciones para enviar están en el módulo 01 — puedes leerlo en paralelo:
| # | Problema | Fase | Qué practica |
|---|---|---|---|
| 1 | Bus de turismo | Regional 2018 | paridad con % y un if |
| 2 | Partido de ping-pong | Nacional 2015 | simular con ciclos |
| 3 | La tarea de matemática | Nacional 2017 | ciclos con contadores |
| 4 | La calculadora del almacén | Regional 2017 | recorrer y comparar un string |
| 5 | ⭐ El cifrado de César | Nacional 2020 | strings + 26 contadores (requiere los arreglos del módulo 03) |
Un ejemplo para pensar
Un contador parte en cuenta = 0 y recorre la palabra casa. Por cada
letra igual a 'a', aumenta cuenta en uno. ¿Qué cambia si se inicializa
cuenta = 0 dentro del ciclo, justo antes del if?
Compara el código y predice su salida antes de ejecutarlo:
string palabra = "casa";
// A: inicializar una vez.
int cuentaA = 0;
for (char letra : palabra) {
if (letra == 'a') cuentaA++;
cout << cuentaA << " ";
}
cout << "\n";
// B: inicializar al comenzar cada vuelta.
for (char letra : palabra) {
int cuentaB = 0;
if (letra == 'a') cuentaB++;
cout << cuentaB << " ";
}
cout << "\n";Seguir el valor entre vueltas
Con la inicialización fuera, el contador vale 0, 1, 1 y 2 después de cada letra: conserva lo acumulado. Dentro del ciclo, vuelve a cero en cada vuelta y los valores finales son 0, 1, 0 y 1. Solo recuerda la última letra. La ubicación de una instrucción decide cuántas veces se ejecuta.