Sección 0
Lo esencial para programar bien (antes de seguir subiendo nivel)
PSInt: pensar y modelar
C#: escribir y ejecutar
Meta: coherencia + pruebas
Navegación: ← → · Pantalla completa: F
¿Qué significa “fundamentos”?
En este curso, “fundamentos” no es memorizar sintaxis: es poder explicar qué entra, qué se calcula, qué sale y por qué es correcto.
- PSInt te ayuda a modelar sin distraerte con detalles del lenguaje.
- C# te obliga a ser preciso con tipos, entradas y estructura del programa.
- La prueba de escritorio (y casos de prueba) es tu evidencia de calidad.
Algoritmo: definición operativa
Un algoritmo es una secuencia finita de pasos, ordenados y no ambiguos, que transforman entradas en salidas.
- Finito: debe terminar.
- No ambiguo: un paso no puede interpretarse de 2 formas.
- Verificable: puedes probarlo con casos.
Señales de que tu algoritmo está “verde”:
- Usas variables sin definirlas (nombre, tipo, propósito).
- Te saltas pasos (“obvio que da…”).
- Solo probaste 1 ejemplo “bonito”.
IPO: tu contrato
Regla práctica: si un dato no está en “Entradas”, no puede aparecer mágicamente en “Proceso”.
Variables: nombre + tipo + propósito
En PSInt
Definir precioBase Como Real
Definir ivaPct Como Real
Definir total Como Real
PSInt suele ser más flexible, pero tú debes ser disciplinado con el significado.
En C#
decimal precioBase;
decimal ivaPct;
decimal total;
En C# el tipo “manda”: si escoges mal el tipo, te complicas el cálculo y la validación.
Regla práctica (muy usada en ingeniería):
- Dinero → decimal.
- Conteo (personas, ítems, horas enteras) → int.
- Texto (códigos, ciudades) → string.
- Verdadero/falso → bool.
Mapa PSInt ↔ C# (equivalencias)
| Concepto |
PSInt |
C# (consola) |
Notas importantes |
| Inicio del programa |
Proceso / FinProceso |
static void Main(...){...} |
Todo se ejecuta dentro de Main (por ahora). |
| Salida |
Escribir |
Console.WriteLine(...) |
WriteLine imprime y salta línea. |
| Entrada |
Leer x |
Console.ReadLine() + Parse/TryParse |
ReadLine devuelve texto; toca convertir a número. |
| Condicional |
Si / SiNo / FinSi |
if (...) { ... } else { ... } |
En C# importan las llaves { }. |
| Selección |
Segun |
switch o tipo switch { ... } |
Ideal cuando decides por “categoría”. |
| Lógicos |
Y / O / No |
&& / || / ! |
Cuando mezclas AND/OR, usa paréntesis. |
Operadores y precedencia (por qué importan)
Errores típicos de principiantes:
- Confundir porcentaje con valor (10 vs 0.10).
- Olvidar paréntesis en fórmulas largas.
- Asumir que el computador “entiende la intención”.
Regla simple para evitar el 80% de errores:
- Si hay duda, escribe paréntesis.
- Divide la fórmula en pasos y nómbralos.
- Haz una prueba de escritorio con números fáciles.
Ejemplo (porcentaje):
ivaValor = precioBase * (ivaPct / 100)
No: ivaValor = precioBase * ivaPct / 100 // puede ser correcto, pero es más fácil equivocarse al leerlo
Entrada y salida: la diferencia clave
En PSInt
Leer horas
Escribir "Total:", total
PSInt “te deja” leer directamente números.
En C#
string s = Console.ReadLine() ?? "";
if (!int.TryParse(s, out int horas))
{
Console.WriteLine("Entrada inválida");
return;
}
C# lee texto: convertir/validar es parte del programa (no es opcional si quieres calidad).
Decisiones: Si/SiNo ↔ if/else
PSInt
Si edad >= 18 Entonces
Escribir "Mayor de edad"
SiNo
Escribir "Menor de edad"
FinSi
C#
if (edad >= 18)
{
Console.WriteLine("Mayor de edad");
}
else
{
Console.WriteLine("Menor de edad");
}
Idea central: una condición produce verdadero/falso, y eso define la rama ejecutada.
Condiciones compuestas (AND/OR/NOT)
PSInt
Si (edad >= 18) Y (edad <= 65) Entonces
Escribir "Rango válido"
FinSi
En PSInt: Y/O/NO.
C#
if ((edad >= 18) && (edad <= 65))
{
Console.WriteLine("Rango válido");
}
En C#: &&, || y ! (usa paréntesis para intención explícita).
Consejo de legibilidad: si la condición es larga, nómbrala.
bool esRangoValido = (edad >= 18) && (edad <= 65);
if (esRangoValido) { ... }
Prueba de escritorio (la evidencia)
La prueba de escritorio responde:
- ¿Mi algoritmo hace lo que dice el enunciado?
- ¿Mis fórmulas tienen coherencia numérica?
- ¿Estoy cubriendo casos normales y bordes?
Cómo se hace (disciplina):
- Elige un caso con números reales.
- Calcula paso a paso, sin “saltos mentales”.
- Repite con un caso borde (0, umbral exacto, etc.).
Tabla típica:
precioBase | ivaPct | descPct | ivaValor | subtotal | descValor | total
--------- | ------ | ------- | -------- | -------- | -------- | -----
Ejemplo (PSInt): IVA + descuento
Idea: convertir en pasos para que sea verificable.
- Primero IVA → valor.
- Luego subtotal.
- Luego descuento.
- Luego total.
Leer precioBase
Leer ivaPct
Leer descuentoPct
ivaValor = precioBase * (ivaPct / 100)
subtotal = precioBase + ivaValor
descuentoValor = subtotal * (descuentoPct / 100)
total = subtotal - descuentoValor
Escribir total
Ejemplo (C#): mismo algoritmo
En C#, lo clave es: tipos + lectura + conversión.
using System;
class Program
{
static void Main(string[] args)
{
Console.Write("Precio base: ");
if (!decimal.TryParse(Console.ReadLine(), out decimal precioBase))
{
Console.WriteLine("Entrada inválida.");
return;
}
Console.Write("IVA (%): ");
if (!decimal.TryParse(Console.ReadLine(), out decimal ivaPct))
{
Console.WriteLine("Entrada inválida.");
return;
}
Console.Write("Descuento (%): ");
if (!decimal.TryParse(Console.ReadLine(), out decimal descuentoPct))
{
Console.WriteLine("Entrada inválida.");
return;
}
decimal ivaValor = precioBase * (ivaPct / 100m);
decimal subtotal = precioBase + ivaValor;
decimal descuentoValor = subtotal * (descuentoPct / 100m);
decimal total = subtotal - descuentoValor;
Console.WriteLine($"Total: {total}");
}
}
Nota: el separador decimal (punto/coma) depende de la configuración regional del sistema.
Checklist de calidad (antes de entregar)
Modelo
- IPO completo (sin datos mágicos).
- Variables con nombre y propósito.
- Fórmulas en pasos (no un “bloque” ilegible).
Evidencia
- Al menos 2 casos: normal + borde.
- Resultados coherentes (sanity check).
- Si hay if/else: probaste ambas ramas.
Si pasas este checklist, tu código tiende a ser correcto y mantenible.
Mini-actividad (10–15 min)
Objetivo: traducir un PSInt simple a C# sin cambiar la lógica.
- Escoge un ejercicio previo (temperatura, IVA, parqueadero, etc.).
- Escribe IPO.
- Escribe pseudocódigo (PSInt).
- Reescribe en C# con tipos correctos + TryParse.
- Documenta 2 pruebas: normal y borde.
Entrega: código + 2 casos (con explicación del cálculo esperado).
Ticket de salida (5 min)
- Escribe 1 diferencia entre “entrada” y “variable”.
- ¿Qué tipo usarías para dinero en C# y por qué?
- Escribe 1 caso borde que deberías probar en tu mini-actividad.
Siguiente paso: aplicar todo esto a decisiones más complejas (tablas de decisión y reglas con prioridad).