Lenguajes de Programación — Guía Completa para Oposiciones

Código fuente
     ↓
[Análisis Léxico]     → Tokens
     ↓
[Análisis Sintáctico] → Árbol de Análisis (AST)
     ↓
[Análisis Semántico]  → Tabla de símbolos
     ↓
[Generación de Código Intermedio]
     ↓
[Optimización]
     ↓
[Generación de Código Máquina]
     ↓
Ejecutable (.exe / binario)

Ejemplo: -5 en 8 bits (complemento a 2)
  5 en binario = 00000101
  Invertir bits = 11111010
  Sumar 1       = 11111011  → Esto es -5

Estructura IEEE 754 (float, 32 bits):
[1 bit signo | 8 bits exponente | 23 bits mantisa]

ASCII: 'A' = 65, 'a' = 97, '0' = 48
Char en C: char c = 'A';   // almacena el valor 65

boolean activo = true;
boolean terminado = false;

// Enum en C
enum DiaSemana { LUNES, MARTES, MIERCOLES, JUEVES, VIERNES, SABADO, DOMINGO };
enum DiaSemana hoy = MIERCOLES;  // hoy vale 2 (empieza en 0)

// Puntero en C
int x = 10;
int *ptr = &x;   // ptr apunta a la dirección de x
printf("%d", *ptr);  // imprime 10 (desreferencia)

AND:           OR:            NOT:
A  B  A&&B    A  B  A||B    A   !A
T  T   T      T  T   T      T    F
T  F   F      T  F   T      F    T
F  T   F      F  T   T
F  F   F      F  F   F

int x = 5;
x++;    // Post-incremento: usa x (=5) luego suma 1 → x=6
++x;    // Pre-incremento: suma 1 primero → x=7, usa x (=7)
x--;    // Post-decremento
--x;    // Pre-decremento

1. () → Paréntesis
2. ! ~ ++ -- → Unarios
3. * / %      → Multiplicativos
4. + -        → Aditivos
5. << >>      → Desplazamiento
6. < <= > >=  → Relacionales
7. == !=      → Igualdad
8. &          → AND bit a bit
9. ^          → XOR bit a bit
10. |         → OR bit a bit
11. &&        → AND lógico
12. ||        → OR lógico
13. ?:        → Ternario
14. = += -=   → Asignación

SI condición ENTONCES
    instrucciones
SINO SI condición2 ENTONCES
    instrucciones
SINO
    instrucciones
FIN SI

int nota = 7;

if (nota >= 9) {
    System.out.println("Sobresaliente");
} else if (nota >= 7) {
    System.out.println("Notable");
} else if (nota >= 5) {
    System.out.println("Aprobado");
} else {
    System.out.println("Suspenso");
}
// Salida: Notable

nota = 7
if nota >= 9:
    print("Sobresaliente")
elif nota >= 7:
    print("Notable")
elif nota >= 5:
    print("Aprobado")
else:
    print("Suspenso")

// Java
int dia = 3;
switch (dia) {
    case 1:
        System.out.println("Lunes");
        break;
    case 2:
        System.out.println("Martes");
        break;
    case 3:
        System.out.println("Miércoles");
        break;
    default:
        System.out.println("Otro día");
}
// Salida: Miércoles

// Pseudocódigo
SEGUN variable HACER
    CASO valor1: instrucciones
    CASO valor2: instrucciones
    POR DEFECTO: instrucciones
FIN SEGUN

// condicion ? valor_si_true : valor_si_false
int max = (a > b) ? a : b;
String estado = (activo) ? "Activo" : "Inactivo";

// Si (a > 0) es false, NO se evalúa (b / a)
// Esto evita división por cero
if (a > 0 && b / a > 2) { ... }

// Si (x != null) es false, NO se evalúa x.length()
// Esto evita NullPointerException
if (x != null && x.length() > 0) { ... }

// Java
int i = 0;
while (i < 5) {
    System.out.println("Iteración: " + i);
    i++;
}
// Imprime 0, 1, 2, 3, 4

MIENTRAS condicion HACER
    instrucciones
FIN MIENTRAS

int i = 0;
do {
    System.out.println("Iteración: " + i);
    i++;
} while (i < 5);

HACER
    instrucciones
MIENTRAS condicion

// Java
for (int i = 0; i < 5; i++) {
    System.out.println("i = " + i);
}

// For mejorado (for-each) para colecciones
int[] numeros = {10, 20, 30, 40};
for (int n : numeros) {
    System.out.println(n);
}

# Python
for i in range(5):        # 0, 1, 2, 3, 4
    print(i)

for i in range(2, 10, 2): # 2, 4, 6, 8
    print(i)

PARA i DESDE 1 HASTA 10 PASO 1 HACER
    instrucciones
FIN PARA

for (int i = 0; i < 10; i++) {
    if (i == 3) continue;  // Salta el 3
    if (i == 7) break;     // Sale del bucle al llegar a 7
    System.out.print(i + " "); // Imprime: 0 1 2 4 5 6
}

n! = n × (n-1) × (n-2) × ... × 1
0! = 1  (caso base)

// Java - Recursivo
int factorial(int n) {
    if (n == 0) return 1;           // Caso base
    return n * factorial(n - 1);    // Caso recursivo
}
// factorial(5) = 5 × 4 × 3 × 2 × 1 = 120

// Java - Iterativo (equivalente)
int factorialIterativo(int n) {
    int resultado = 1;
    for (int i = 1; i <= n; i++) {
        resultado *= i;
    }
    return resultado;
}

F(0) = 0, F(1) = 1
F(n) = F(n-1) + F(n-2)

int fibonacci(int n) {
    if (n <= 1) return n;                       // Casos base
    return fibonacci(n - 1) + fibonacci(n - 2); // Caso recursivo
}
// fibonacci(6) = 0,1,1,2,3,5,8 → 8

factorial(4)
  → 4 * factorial(3)
        → 3 * factorial(2)
              → 2 * factorial(1)
                    → 1 * factorial(0)
                          → 1  (caso base)
                    → 1 * 1 = 1
              → 2 * 1 = 2
        → 3 * 2 = 6
  → 4 * 6 = 24

// Procedimiento (no devuelve nada)
void mostrarBienvenida(String nombre) {
    System.out.println("Bienvenido, " + nombre + "!");
}

// Función (devuelve un valor)
int sumar(int a, int b) {
    return a + b;
}

// Uso
mostrarBienvenida("Ana");     // Llama al procedimiento
int resultado = sumar(3, 5);  // Llama a la función → resultado = 8

void duplicar(int x) {
    x = x * 2;     // Solo modifica la copia local
    System.out.println("Dentro: " + x); // 10
}

int num = 5;
duplicar(num);
System.out.println("Fuera: " + num); // Sigue siendo 5

// En C, se simula con punteros
void duplicar(int *x) {
    *x = *x * 2;   // Modifica el valor en la dirección apuntada
}

int num = 5;
duplicar(&num);
printf("%d", num);  // num ahora es 10

// En Java: los objetos se pasan por referencia de valor
// (se pasa la referencia, no el objeto completo)
void modificar(int[] arr) {
    arr[0] = 99;  // Sí modifica el array original
}

int global = 100;  // Variable global

void ejemplo() {
    int local = 50;         // Variable local
    System.out.println(global); // OK: accede a la global
    System.out.println(local);  // OK: accede a la local
}
// Aquí NO se puede acceder a 'local'

Pila de llamadas para factorial(3):
┌─────────────────┐
│ factorial(0)=1  │  ← cima (último en entrar)
├─────────────────┤
│ factorial(1)=1  │
├─────────────────┤
│ factorial(2)=2  │
├─────────────────┤
│ factorial(3)=6  │  ← base
└─────────────────┘

int sumar(int a, int b) { return a + b; }
double sumar(double a, double b) { return a + b; }
int sumar(int a, int b, int c) { return a + b + c; }

sumar(1, 2);        // llama a la primera
sumar(1.5, 2.5);    // llama a la segunda
sumar(1, 2, 3);     // llama a la tercera

// Java
int[] notas = new int[5];          // Vector de 5 enteros (sin inicializar → todos 0)
int[] pares = {2, 4, 6, 8, 10};   // Con inicialización directa

pares[0] = 2;   // Primer elemento
pares[4] = 10;  // Último elemento
// pares[5] → ArrayIndexOutOfBoundsException (fuera de rango)

// C
int notas[5];                    // Declara 5 enteros
int pares[] = {2, 4, 6, 8, 10}; // Con inicialización
notas[0] = 7;                    // Acceso

# Python (listas dinámicas)
notas = [0] * 5            # Lista de 5 ceros
pares = [2, 4, 6, 8, 10]
print(pares[2])            # 6

int[] v = {5, 3, 8, 1, 9};

// Recorrido con for clásico
for (int i = 0; i < v.length; i++) {
    System.out.print(v[i] + " "); // 5 3 8 1 9
}

// Recorrido con for-each
for (int elem : v) {
    System.out.print(elem + " ");
}

// Búsqueda lineal: O(n)
int buscarLineal(int[] v, int objetivo) {
    for (int i = 0; i < v.length; i++) {
        if (v[i] == objetivo) return i;  // Devuelve el índice
    }
    return -1;  // No encontrado
}

// Búsqueda binaria (el vector debe estar ORDENADO): O(log n)
int buscarBinaria(int[] v, int objetivo) {
    int izq = 0, der = v.length - 1;
    while (izq <= der) {
        int medio = (izq + der) / 2;
        if (v[medio] == objetivo) return medio;
        else if (v[medio] < objetivo) izq = medio + 1;
        else der = medio - 1;
    }
    return -1;
}

// Bubble Sort: O(n²)
void burbuja(int[] v) {
    int n = v.length;
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (v[j] > v[j + 1]) {
                // Intercambio
                int temp = v[j];
                v[j] = v[j + 1];
                v[j + 1] = temp;
            }
        }
    }
}

// Matriz 3×3 en Java
int[][] matriz = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

// Acceso: matriz[fila][columna]
System.out.println(matriz[1][2]);  // 6 (fila 1, columna 2)

// Recorrido
for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
        System.out.print(matriz[i][j] + " ");
    }
    System.out.println();
}

// Definición del tipo registro
struct Alumno {
    char nombre[50];
    int edad;
    float nota;
};

// Uso
struct Alumno a1;
strcpy(a1.nombre, "María García");
a1.edad = 22;
a1.nota = 8.5;

// Acceso a campos con el operador punto (.)
printf("Nombre: %s\n", a1.nombre);
printf("Nota: %.1f\n", a1.nota);

TYPE
  TAlumno = RECORD
    nombre : STRING[50];
    edad   : INTEGER;
    nota   : REAL;
  END;

VAR
  alumno1 : TAlumno;

BEGIN
  alumno1.nombre := 'María';
  alumno1.edad   := 22;
  alumno1.nota   := 8.5;
END.

class Alumno {
    String nombre;
    int edad;
    double nota;
}

Alumno a = new Alumno();
a.nombre = "María García";
a.edad = 22;
a.nota = 8.5;

struct Alumno clase[30];  // Array de 30 alumnos

// Inicializar el primero
strcpy(clase[0].nombre, "Ana López");
clase[0].edad = 20;
clase[0].nota = 7.5;

// Recorrer y mostrar todos
for (int i = 0; i < 30; i++) {
    printf("%s - %d años - %.1f\n",
        clase[i].nombre, clase[i].edad, clase[i].nota);
}

┌─────────────────────────────┐
│       CABECERA              │  Nombre, metadatos, imports
├─────────────────────────────┤
│    DECLARACIONES GLOBALES   │  Constantes, tipos, variables globales
├─────────────────────────────┤
│    SUBPROGRAMAS             │  Funciones y procedimientos
├─────────────────────────────┤
│    PROGRAMA PRINCIPAL       │  Punto de entrada (main)
└─────────────────────────────┘

PROGRAMA nombre_del_programa

CONSTANTES
    PI = 3.14159
    MAX = 100

TIPOS
    TAlumno = REGISTRO
        nombre: CADENA
        nota: REAL
    FIN REGISTRO

VARIABLES
    edad: ENTERO
    nombre: CADENA

FUNCIÓN calcularArea(radio: REAL): REAL
INICIO
    DEVOLVER PI * radio * radio
FIN FUNCIÓN

PROCEDIMIENTO mostrar(texto: CADENA)
INICIO
    ESCRIBIR(texto)
FIN PROCEDIMIENTO

INICIO   // Programa principal
    nombre ← "Ana"
    edad ← 25
    mostrar("Hola, " + nombre)
    ESCRIBIR(calcularArea(5.0))
FIN

/* ====== Cabecera ====== */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* ====== Constantes ====== */
#define MAX 100
#define PI 3.14159

/* ====== Tipos definidos por el usuario ====== */
typedef struct {
    char nombre[50];
    int edad;
    float nota;
} Alumno;

/* ====== Variables globales ====== */
int contador = 0;

/* ====== Declaración de funciones ====== */
float calcularMedia(float notas[], int n);
void mostrarAlumno(Alumno a);

/* ====== Función principal ====== */
int main() {
    // Declaraciones locales
    float notas[] = {7.5, 8.0, 6.5, 9.0};
    Alumno a1;

    // Instrucciones
    strcpy(a1.nombre, "Carlos Ruiz");
    a1.edad = 21;
    a1.nota = calcularMedia(notas, 4);

    mostrarAlumno(a1);

    return 0;  // 0 indica ejecución exitosa
}

/* ====== Implementación de funciones ====== */
float calcularMedia(float notas[], int n) {
    float suma = 0;
    for (int i = 0; i < n; i++) suma += notas[i];
    return suma / n;
}

void mostrarAlumno(Alumno a) {
    printf("Nombre: %s\nEdad: %d\nNota: %.2f\n",
           a.nombre, a.edad, a.nota);
}

/* ====== Paquete e imports ====== */
package com.ejemplo;

import java.util.Scanner;

/* ====== Clase principal ====== */
public class GestionAlumnos {

    /* ====== Constantes de clase ====== */
    static final int MAX_ALUMNOS = 30;

    /* ====== Atributos de clase ====== */
    static int totalAlumnos = 0;

    /* ====== Método principal ====== */
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.print("Introduce una nota: ");
        double nota = sc.nextDouble();

        String calificacion = obtenerCalificacion(nota);
        System.out.println("Calificación: " + calificacion);

        sc.close();
    }

    /* ====== Métodos auxiliares ====== */
    static String obtenerCalificacion(double nota) {
        if (nota >= 9) return "Sobresaliente";
        else if (nota >= 7) return "Notable";
        else if (nota >= 5) return "Aprobado";
        else return "Suspenso";
    }

    static double calcularMedia(double[] notas) {
        double suma = 0;
        for (double n : notas) suma += n;
        return suma / notas.length;
    }
}

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Módulo de gestión de alumnos
"""

# ====== Imports ======
import sys

# ====== Constantes ======
MAX_ALUMNOS = 30
PI = 3.14159

# ====== Funciones ======
def calcular_media(notas: list) -> float:
    """Calcula la media de una lista de notas."""
    if not notas:
        return 0.0
    return sum(notas) / len(notas)

def obtener_calificacion(nota: float) -> str:
    """Devuelve la calificación textual de una nota."""
    if nota >= 9:
        return "Sobresaliente"
    elif nota >= 7:
        return "Notable"
    elif nota >= 5:
        return "Aprobado"
    else:
        return "Suspenso"

# ====== Programa principal ======
def main():
    notas = [7.5, 8.0, 9.5, 6.0, 5.5]
    media = calcular_media(notas)
    calificacion = obtener_calificacion(media)

    print(f"Media: {media:.2f}")
    print(f"Calificación: {calificacion}")

if __name__ == "__main__":
    main()

1. ESCRITURA      → El programador escribe el código fuente (.c, .java, .py)
2. COMPILACIÓN    → El compilador traduce a código objeto / bytecode
3. ENLAZADO       → El linker une código objeto con bibliotecas → ejecutable
4. CARGA          → El SO carga el ejecutable en memoria RAM
5. EJECUCIÓN      → La CPU ejecuta las instrucciones
6. FINALIZACIÓN   → El programa libera recursos y devuelve el control al SO

┌──────────────────────────────┐  Dirección alta
│          PILA (Stack)        │  Variables locales, marcos de función
│      (crece hacia abajo)     │
├──────────────────────────────┤
│                              │
│          MONTÓN (Heap)       │  Memoria dinámica (new, malloc)
│       (crece hacia arriba)   │
│                              │
├──────────────────────────────┤
│   SEGMENTO DE DATOS (.data)  │  Variables globales y estáticas
├──────────────────────────────┤
│   SEGMENTO DE CÓDIGO (.text) │  Instrucciones del programa
└──────────────────────────────┘  Dirección baja