ESTRUCTURAS ITERATIVAS

Tipos de Bucles en R

R proporciona tres tipos principales de bucles:
•for: Cuando sabes exactamente cuántas veces quieres repetir algo
•while: Cuando quieres repetir mientras una condición sea verdadera
•repeat: Para crear bucles infinitos con control de salida manual

Bucles for

Anatomía de un Bucle for

#for (variable_iteracion in secuencia) {
  # Cuerpo del bucle: código que se ejecuta en cada iteración
  # La variable_iteracion toma el valor de cada elemento de la secuencia
#}

Componentes clave:
•for: Palabra clave que inicia el bucle
•variable_iteracion: Variable que almacena el valor actual en cada iteración
•in: Operador que conecta la variable con la secuencia
•secuencia: Conjunto de elementos sobre los que se itera
•{}: Delimitadores que contienen el código a ejecutar

Proceso de Ejecución en R

# Ejemplo de seguimiento paso a paso
numeros <- c(10, 20, 30)
for (numero in numeros) {
  resultado <- numero * 2
  print(paste("Número:", numero, "- Doble:", resultado))
}
## [1] "Número: 10 - Doble: 20"
## [1] "Número: 20 - Doble: 40"
## [1] "Número: 30 - Doble: 60"
# Proceso interno:
# Iteración 1: numero = 10, resultado = 20, imprime "Número: 10 - Doble: 20"
# Iteración 2: numero = 20, resultado = 40, imprime "Número: 20 - Doble: 40"
# Iteración 3: numero = 30, resultado = 60, imprime "Número: 30 - Doble: 60"
# Fin del bucle

Proceso de Ejecución en Python

numeros = [10, 20, 30]
for numero in numeros:
    resultado = numero * 2
    print(f"Número: {numero} - Doble: {resultado}")
## Número: 10 - Doble: 20
## Número: 20 - Doble: 40
## Número: 30 - Doble: 60

Tipos de Secuencias para Iterar

1. Secuencias Numéricas en R

# Usando el operador : para crear secuencias
cat("=== SECUENCIAS NUMÉRICAS BÁSICAS ===\n")
## === SECUENCIAS NUMÉRICAS BÁSICAS ===
# Secuencia ascendente
cat("Conteo del 1 al 5:\n")
## Conteo del 1 al 5:
for (i in 1:5) {
  cat(sprintf("Número: %d\n", i))
}
## Número: 1
## Número: 2
## Número: 3
## Número: 4
## Número: 5
# Secuencia descendente
cat("\nConteo descendente del 5 al 1:\n")
## 
## Conteo descendente del 5 al 1:
for (i in 5:1) {
  cat(sprintf("Número: %d\n", i))
}
## Número: 5
## Número: 4
## Número: 3
## Número: 2
## Número: 1
# Usando seq() para mayor control
cat("\nNúmeros pares del 2 al 10:\n")
## 
## Números pares del 2 al 10:
for (i in seq(2, 10, by = 2)) {
  cat(sprintf("Número par: %d\n", i))
}
## Número par: 2
## Número par: 4
## Número par: 6
## Número par: 8
## Número par: 10
# Secuencia con decimales
cat("\nSecuencia decimal:\n")
## 
## Secuencia decimal:
for (valor in seq(0.5, 2.5, by = 0.5)) {
  cat(sprintf("Valor: %.1f\n", valor))
}
## Valor: 0.5
## Valor: 1.0
## Valor: 1.5
## Valor: 2.0
## Valor: 2.5

1. Secuencias Numéricas en Python

# Usando range() para crear secuencias
print("=== SECUENCIAS NUMÉRICAS BÁSICAS ===")
## === SECUENCIAS NUMÉRICAS BÁSICAS ===
# Secuencia ascendente
print("Conteo del 1 al 5:")
## Conteo del 1 al 5:
for i in range(1, 6):  # range(inicio, fin) - fin es exclusivo
    print(f"Número: {i}")
## Número: 1
## Número: 2
## Número: 3
## Número: 4
## Número: 5
# Secuencia descendente
print("\nConteo descendente del 5 al 1:")
## 
## Conteo descendente del 5 al 1:
for i in range(5, 0, -1):  # range(inicio, fin, paso)
    print(f"Número: {i}")
## Número: 5
## Número: 4
## Número: 3
## Número: 2
## Número: 1
# Usando range() con paso para mayor control
print("\nNúmeros pares del 2 al 10:")
## 
## Números pares del 2 al 10:
for i in range(2, 11, 2):  # range(2, 11, 2) = 2, 4, 6, 8, 10
    print(f"Número par: {i}")
## Número par: 2
## Número par: 4
## Número par: 6
## Número par: 8
## Número par: 10
# Secuencia con decimales usando numpy
print("\nSecuencia decimal:")
## 
## Secuencia decimal:
import numpy as np
for valor in np.arange(0.5, 3.0, 0.5):  # np.arange(inicio, fin, paso)
    print(f"Valor: {valor:.1f}")
## Valor: 0.5
## Valor: 1.0
## Valor: 1.5
## Valor: 2.0
## Valor: 2.5

2. Vectores de Caracteres en R

# Iterando sobre texto
cat("\n=== PROCESAMIENTO DE TEXTO ===\n")
## 
## === PROCESAMIENTO DE TEXTO ===
# Lista de estudiantes:
# Vector de nombres
estudiantes <- c("Ana María", "Pedro José", "Lucía Carmen", "Miguel Ángel")
cat("Lista de estudiantes:\n")
## Lista de estudiantes:
for (nombre in estudiantes) {
  # Procesar cada nombre
  num_palabras <- length(strsplit(nombre, " ")[[1]])
  num_caracteres <- nchar(nombre)
  cat(sprintf("- %s: %d palabras, %d caracteres\n",
              nombre, num_palabras, num_caracteres))
}
## - Ana María: 2 palabras, 9 caracteres
## - Pedro José: 2 palabras, 10 caracteres
## - Lucía Carmen: 2 palabras, 12 caracteres
## - Miguel Ángel: 2 palabras, 12 caracteres
# Días de la semana con información
dias_semana <- c("Lunes", "Martes", "Miércoles", "Jueves", "Viernes", "Sábado", "Domingo")
tipos_dia <- c("Laboral", "Laboral", "Laboral", "Laboral", "Laboral", "Fin de semana", "Fin de semana")
cat("\nCalendario semanal:\n")
## 
## Calendario semanal:
for (i in 1:length(dias_semana)) {
  dia <- dias_semana[i]
  tipo <- tipos_dia[i]
  emoji <- if (tipo == "Laboral") "maletin" else "fiesta"
  cat(sprintf("%s %s - %s\n", emoji, dia, tipo))
}
## maletin Lunes - Laboral
## maletin Martes - Laboral
## maletin Miércoles - Laboral
## maletin Jueves - Laboral
## maletin Viernes - Laboral
## fiesta Sábado - Fin de semana
## fiesta Domingo - Fin de semana

2. Vectores de Caracteres en Python

# Iterando sobre texto
print("\n=== PROCESAMIENTO DE TEXTO ===")
## 
## === PROCESAMIENTO DE TEXTO ===
# Lista de estudiantes:
# Lista de nombres
estudiantes = ["Ana María", "Pedro José", "Lucía Carmen", "Miguel Ángel"]
print("Lista de estudiantes:")
## Lista de estudiantes:
for nombre in estudiantes:
    # Procesar cada nombre
    num_palabras = len(nombre.split())
    num_caracteres = len(nombre)
    print(f"- {nombre}: {num_palabras} palabras, {num_caracteres} caracteres")
## - Ana María: 2 palabras, 9 caracteres
## - Pedro José: 2 palabras, 10 caracteres
## - Lucía Carmen: 2 palabras, 12 caracteres
## - Miguel Ángel: 2 palabras, 12 caracteres
# Días de la semana con información
dias_semana = ["Lunes", "Martes", "Miércoles", "Jueves", "Viernes", "Sábado", "Domingo"]
tipos_dia = ["Laboral", "Laboral", "Laboral", "Laboral", "Laboral", "Fin de semana", "Fin de semana"]
print("\nCalendario semanal:")
## 
## Calendario semanal:
for i in range(len(dias_semana)):
    dia = dias_semana[i]
    tipo = tipos_dia[i]
    print(f"{dia} - {tipo}")
## Lunes - Laboral
## Martes - Laboral
## Miércoles - Laboral
## Jueves - Laboral
## Viernes - Laboral
## Sábado - Fin de semana
## Domingo - Fin de semana

3. Listas Complejas en R

# Trabajando con estructuras de datos complejas
cat("\n=== PROCESAMIENTO DE LISTAS ===\n")
## 
## === PROCESAMIENTO DE LISTAS ===
# Lista de información de empleados
empleados <- list(
  list(
    nombre = "Carlos Mendoza",
    departamento = "Ventas",
    salario = 45000,
    años_experiencia = 3,
    certificaciones = c("Ventas Avanzadas", "CRM")
  ),
  list(
    nombre = "María González",
    departamento = "IT",
    salario = 65000,
    años_experiencia = 7,
    certificaciones = c("Java", "Python", "Scrum Master")
  ),
  list(
    nombre = "Roberto Silva",
    departamento = "Marketing",
    salario = 50000,
    años_experiencia = 5,
    certificaciones = c("Google Ads", "Analytics", "SEO")
  )
)

cat("=== REPORTE DE EMPLEADOS ===\n")
## === REPORTE DE EMPLEADOS ===
for (i in 1:length(empleados)) {
  emp <- empleados[[i]]
  # Calcular información derivada
  salario_mensual <- emp$salario / 12
  nivel_experiencia <- if (emp$años_experiencia >= 5) "Senior" else if (emp$años_experiencia >= 2) "Intermedio" else "Junior"
  cat(sprintf("\n--- EMPLEADO %d ---\n", i))
  cat(sprintf("Nombre: %s\n", emp$nombre))
  cat(sprintf("Departamento: %s\n", emp$departamento))
  cat(sprintf("Salario anual: $%s\n", format(emp$salario, big.mark = ",")))
  cat(sprintf("Salario mensual: $%s\n", format(round(salario_mensual), big.mark = ",")))
  cat(sprintf("Experiencia: %d años (%s)\n", emp$años_experiencia, nivel_experiencia))
  cat(sprintf("Certificaciones (%d):\n", length(emp$certificaciones)))
  for (cert in emp$certificaciones) {
    cat(sprintf("• %s\n", cert))
  }
}
## 
## --- EMPLEADO 1 ---
## Nombre: Carlos Mendoza
## Departamento: Ventas
## Salario anual: $45,000
## Salario mensual: $3,750
## Experiencia: 3 años (Intermedio)
## Certificaciones (2):
## • Ventas Avanzadas
## • CRM
## 
## --- EMPLEADO 2 ---
## Nombre: María González
## Departamento: IT
## Salario anual: $65,000
## Salario mensual: $5,417
## Experiencia: 7 años (Senior)
## Certificaciones (3):
## • Java
## • Python
## • Scrum Master
## 
## --- EMPLEADO 3 ---
## Nombre: Roberto Silva
## Departamento: Marketing
## Salario anual: $50,000
## Salario mensual: $4,167
## Experiencia: 5 años (Senior)
## Certificaciones (3):
## • Google Ads
## • Analytics
## • SEO

3. Listas Complejas en Python

print("\n=== PROCESAMIENTO DE LISTAS ===")
## 
## === PROCESAMIENTO DE LISTAS ===
# Lista de información de empleados
empleados = [
    {
        "nombre": "Carlos Mendoza",
        "departamento": "Ventas",
        "salario": 45000,
        "años_experiencia": 3,
        "certificaciones": ["Ventas Avanzadas", "CRM"]
    },
    {
        "nombre": "María González",
        "departamento": "IT",
        "salario": 65000,
        "años_experiencia": 7,
        "certificaciones": ["Java", "Python", "Scrum Master"]
    },
    {
        "nombre": "Roberto Silva",
        "departamento": "Marketing",
        "salario": 50000,
        "años_experiencia": 5,
        "certificaciones": ["Google Ads", "Analytics", "SEO"]
    }
]

print("=== REPORTE DE EMPLEADOS ===")
## === REPORTE DE EMPLEADOS ===
for i, emp in enumerate(empleados, 1):
    # Calcular información derivada
    salario_mensual = emp["salario"] / 12
    if emp["años_experiencia"] >= 5:
        nivel_experiencia = "Senior"
    elif emp["años_experiencia"] >= 2:
        nivel_experiencia = "Intermedio"
    else:
        nivel_experiencia = "Junior"
    
    print(f"\n--- EMPLEADO {i} ---")
    print(f"Nombre: {emp['nombre']}")
    print(f"Departamento: {emp['departamento']}")
    print(f"Salario anual: ${emp['salario']:,.0f}")
    print(f"Salario mensual: ${round(salario_mensual):,.0f}")
    print(f"Experiencia: {emp['años_experiencia']} años ({nivel_experiencia})")
    print(f"Certificaciones ({len(emp['certificaciones'])}):")
    for cert in emp["certificaciones"]:
        print(f"• {cert}")
## 
## --- EMPLEADO 1 ---
## Nombre: Carlos Mendoza
## Departamento: Ventas
## Salario anual: $45,000
## Salario mensual: $3,750
## Experiencia: 3 años (Intermedio)
## Certificaciones (2):
## • Ventas Avanzadas
## • CRM
## 
## --- EMPLEADO 2 ---
## Nombre: María González
## Departamento: IT
## Salario anual: $65,000
## Salario mensual: $5,417
## Experiencia: 7 años (Senior)
## Certificaciones (3):
## • Java
## • Python
## • Scrum Master
## 
## --- EMPLEADO 3 ---
## Nombre: Roberto Silva
## Departamento: Marketing
## Salario anual: $50,000
## Salario mensual: $4,167
## Experiencia: 5 años (Senior)
## Certificaciones (3):
## • Google Ads
## • Analytics
## • SEO

Procesamiento de Datos Financieros en R

# Sistema de análisis financiero
cat("\n=== ANÁLISIS FINANCIERO TRIMESTRAL ===\n")
## 
## === ANÁLISIS FINANCIERO TRIMESTRAL ===
# Datos de ventas por trimestre
meses <- c("Enero", "Febrero", "Marzo", "Abril", "Mayo", "Junio",
           "Julio", "Agosto", "Septiembre", "Octubre", "Noviembre", "Diciembre")
ventas_2024 <- c(125000, 138000, 142000, 156000, 149000, 163000,
                 178000, 171000, 165000, 183000, 195000, 210000)
# Metas mensuales progresivas
metas <- c(120000, 125000, 130000, 135000, 140000, 145000,
           150000, 155000, 160000, 165000, 170000, 175000)
# Análisis detallado por mes
total_ventas <- 0
total_metas <- 0
meses_exitosos <- 0
mejor_mes <- ""
mejor_rendimiento <- 0

cat("REPORTE MENSUAL DETALLADO:\n")
## REPORTE MENSUAL DETALLADO:
cat(sprintf("%-12s %12s %12s %12s %10s %s\n", "Mes", "Ventas", "Meta", "Diferencia", "% Meta", "Estado"))
## Mes                Ventas         Meta   Diferencia     % Meta Estado
cat(strrep("-", 80), "\n")
## --------------------------------------------------------------------------------
for (i in 1:length(meses)) {
  mes <- meses[i]
  venta <- ventas_2024[i]
  meta <- metas[i]
  diferencia <- venta - meta
  porcentaje_meta <- (venta / meta) * 100
  # Actualizar totales
  total_ventas <- total_ventas + venta
  total_metas <- total_metas + meta
  # Determinar estado
  if (venta >= meta) {
    meses_exitosos <- meses_exitosos + 1
    estado <- " ÉXITO"
  } else {
    estado <- " Bajo"
  }
  # Buscar mejor rendimiento
  if (porcentaje_meta > mejor_rendimiento) {
    mejor_rendimiento <- porcentaje_meta
    mejor_mes <- mes
  }
  # Formatear y mostrar resultados
  cat(sprintf("%-12s $%10s $%10s %+10s %9.1f%% %s\n",
              mes,
              format(venta, big.mark = ","),
              format(meta, big.mark = ","),
              format(diferencia, big.mark = ","),
              porcentaje_meta,
              estado))
}
## Enero        $   125,000 $   120,000      5,000     104.2%  ÉXITO
## Febrero      $   138,000 $   125,000     13,000     110.4%  ÉXITO
## Marzo        $   142,000 $   130,000     12,000     109.2%  ÉXITO
## Abril        $   156,000 $   135,000     21,000     115.6%  ÉXITO
## Mayo         $   149,000 $   140,000      9,000     106.4%  ÉXITO
## Junio        $   163,000 $   145,000     18,000     112.4%  ÉXITO
## Julio        $   178,000 $   150,000     28,000     118.7%  ÉXITO
## Agosto       $   171,000 $   155,000     16,000     110.3%  ÉXITO
## Septiembre   $   165,000 $   160,000      5,000     103.1%  ÉXITO
## Octubre      $   183,000 $   165,000     18,000     110.9%  ÉXITO
## Noviembre    $   195,000 $   170,000     25,000     114.7%  ÉXITO
## Diciembre    $   210,000 $   175,000     35,000     120.0%  ÉXITO
# Resumen anual
cat(strrep("-", 80), "\n")
## --------------------------------------------------------------------------------
porcentaje_anual <- (total_ventas / total_metas) * 100
superavit_total <- total_ventas - total_metas
cat(sprintf("%-12s $%10s $%10s %+10s %9.1f%%\n",
            "TOTAL AÑO",
            format(total_ventas, big.mark = ","),
            format(total_metas, big.mark = ","),
            format(superavit_total, big.mark = ","),
            porcentaje_anual))
## TOTAL AÑO   $ 1,975,000 $ 1,770,000    205,000     111.6%
cat("\n=== RESUMEN EJECUTIVO ===\n")
## 
## === RESUMEN EJECUTIVO ===
cat(sprintf(" Total vendido: $%s\n", format(total_ventas, big.mark = ",")))
##  Total vendido: $1,975,000
cat(sprintf(" Total de metas: $%s\n", format(total_metas, big.mark = ",")))
##  Total de metas: $1,770,000
cat(sprintf(" Rendimiento anual: %.1f%%\n", porcentaje_anual))
##  Rendimiento anual: 111.6%
cat(sprintf(" Meses exitosos: %d de %d\n", meses_exitosos, length(meses)))
##  Meses exitosos: 12 de 12
cat(sprintf("Mejor mes: %s (%.1f%% de la meta)\n", mejor_mes, mejor_rendimiento))
## Mejor mes: Diciembre (120.0% de la meta)
if (porcentaje_anual >= 100) {
  cat(" ¡Felicitaciones! Se superaron las metas anuales\n")
} else {
  deficit <- total_metas - total_ventas
  cat(sprintf(" Área de mejora: $%s por debajo de la meta\n", format(deficit, big.mark = ",")))
}
##  ¡Felicitaciones! Se superaron las metas anuales

Procesamiento de Datos Financieros en Python

print("\n=== ANÁLISIS FINANCIERO TRIMESTRAL ===")
## 
## === ANÁLISIS FINANCIERO TRIMESTRAL ===
meses = ["Enero", "Febrero", "Marzo", "Abril", "Mayo", "Junio",
         "Julio", "Agosto", "Septiembre", "Octubre", "Noviembre", "Diciembre"]
ventas_2024 = [125000, 138000, 142000, 156000, 149000, 163000,
               178000, 171000, 165000, 183000, 195000, 210000]
metas = [120000, 125000, 130000, 135000, 140000, 145000,
         150000, 155000, 160000, 165000, 170000, 175000]

total_ventas = 0
total_metas = 0
meses_exitosos = 0
mejor_mes = ""
mejor_rendimiento = 0

print("REPORTE MENSUAL DETALLADO:")
## REPORTE MENSUAL DETALLADO:
print(f"{'Mes':<12} {'Ventas':>12} {'Meta':>12} {'Diferencia':>12} {'% Meta':>10} {'Estado':<10}")
## Mes                Ventas         Meta   Diferencia     % Meta Estado
print("-" * 80)
## --------------------------------------------------------------------------------
for i in range(len(meses)):
    mes = meses[i]
    venta = ventas_2024[i]
    meta = metas[i]
    diferencia = venta - meta
    porcentaje_meta = (venta / meta) * 100
    
    total_ventas += venta
    total_metas += meta
    
    if venta >= meta:
        meses_exitosos += 1
        estado = "ÉXITO"
    else:
        estado = "Bajo"
    
    if porcentaje_meta > mejor_rendimiento:
        mejor_rendimiento = porcentaje_meta
        mejor_mes = mes
    
    print(f"{mes:<12} ${venta:>10,} ${meta:>10,} {diferencia:>+10,} {porcentaje_meta:>9.1f}% {estado:<10}")
## Enero        $   125,000 $   120,000     +5,000     104.2% ÉXITO     
## Febrero      $   138,000 $   125,000    +13,000     110.4% ÉXITO     
## Marzo        $   142,000 $   130,000    +12,000     109.2% ÉXITO     
## Abril        $   156,000 $   135,000    +21,000     115.6% ÉXITO     
## Mayo         $   149,000 $   140,000     +9,000     106.4% ÉXITO     
## Junio        $   163,000 $   145,000    +18,000     112.4% ÉXITO     
## Julio        $   178,000 $   150,000    +28,000     118.7% ÉXITO     
## Agosto       $   171,000 $   155,000    +16,000     110.3% ÉXITO     
## Septiembre   $   165,000 $   160,000     +5,000     103.1% ÉXITO     
## Octubre      $   183,000 $   165,000    +18,000     110.9% ÉXITO     
## Noviembre    $   195,000 $   170,000    +25,000     114.7% ÉXITO     
## Diciembre    $   210,000 $   175,000    +35,000     120.0% ÉXITO
print("-" * 80)
## --------------------------------------------------------------------------------
porcentaje_anual = (total_ventas / total_metas) * 100
superavit_total = total_ventas - total_metas

print(f"{'TOTAL AÑO':<12} ${total_ventas:>10,} ${total_metas:>10,} {superavit_total:>+10,} {porcentaje_anual:>9.1f}%")
## TOTAL AÑO    $ 1,975,000 $ 1,770,000   +205,000     111.6%
print("\n=== RESUMEN EJECUTIVO ===")
## 
## === RESUMEN EJECUTIVO ===
print(f" Total vendido: ${total_ventas:,}")
##  Total vendido: $1,975,000
print(f" Total de metas: ${total_metas:,}")
##  Total de metas: $1,770,000
print(f" Rendimiento anual: {porcentaje_anual:.1f}%")
##  Rendimiento anual: 111.6%
print(f" Meses exitosos: {meses_exitosos} de {len(meses)}")
##  Meses exitosos: 12 de 12
print(f"Mejor mes: {mejor_mes} ({mejor_rendimiento:.1f}% de la meta)")
## Mejor mes: Diciembre (120.0% de la meta)
if porcentaje_anual >= 100:
    print(" ¡Felicitaciones! Se superaron las metas anuales")
else:
    deficit = total_metas - total_ventas
    print(f" Área de mejora: ${deficit:,} por debajo de la meta")
##  ¡Felicitaciones! Se superaron las metas anuales

Sistema de Gestión Académica en R

# Procesamiento de calificaciones estudiantiles
cat("\n=== SISTEMA DE GESTIÓN ACADÉMICA ===\n")
## 
## === SISTEMA DE GESTIÓN ACADÉMICA ===
# Base de datos de estudiantes
estudiantes_db <- list(
  list(nombre = "Ana Rodríguez", id = "EST001",
       materias = list(
         "Matemáticas" = list(parcial1 = 85, parcial2 = 88, final = 92, asistencia = 95),
         "Física" = list(parcial1 = 78, parcial2 = 82, final = 85, asistencia = 90),
         "Química" = list(parcial1 = 90, parcial2 = 87, final = 94, asistencia = 98)
       )),
  list(nombre = "Pedro Martínez", id = "EST002",
       materias = list(
         "Matemáticas" = list(parcial1 = 75, parcial2 = 79, final = 82, asistencia = 88),
         "Física" = list(parcial1 = 82, parcial2 = 85, final = 88, asistencia = 92),
         "Química" = list(parcial1 = 77, parcial2 = 80, final = 83, asistencia = 85)
       )),
  list(nombre = "Lucía Fernández", id = "EST003",
       materias = list(
         "Matemáticas" = list(parcial1 = 92, parcial2 = 94, final = 96, asistencia = 100),
         "Física" = list(parcial1 = 88, parcial2 = 91, final = 93, asistencia = 95),
         "Química" = list(parcial1 = 95, parcial2 = 92, final = 97, asistencia = 98)
       ))
)
# Función para calcular nota final
calcular_nota_final <- function(parcial1, parcial2, final, asistencia) {
  # 25% cada parcial, 40% examen final, 10% asistencia
  nota <- (parcial1 * 0.25) + (parcial2 * 0.25) + (final * 0.40) + (asistencia * 0.10)
  return(round(nota, 2))
}
# Función para determinar letra y estado
obtener_calificacion <- function(nota) {
  if (nota >= 90) {
    return(list(letra = "A", estado = "Excelente", puntos = 4.0))
  } else if (nota >= 80) {
    return(list(letra = "B", estado = "Bueno", puntos = 3.0))
  } else if (nota >= 70) {
    return(list(letra = "C", estado = "Satisfactorio", puntos = 2.0))
  } else if (nota >= 60) {
    return(list(letra = "D", estado = "Mínimo", puntos = 1.0))
  } else {
    return(list(letra = "F", estado = "Reprobado", puntos = 0.0))
  }
}

# Procesar todos los estudiantes
cat("REPORTE ACADÉMICO DETALLADO\n")
## REPORTE ACADÉMICO DETALLADO
cat(strrep("=", 60), "\n")
## ============================================================
for (estudiante in estudiantes_db) {
  cat(sprintf("\nESTUDIANTE: %s (ID: %s)\n", estudiante$nombre, estudiante$id))
  cat(strrep("-", 50), "\n")
  total_puntos <- 0
  materias_cursadas <- 0
  materias_aprobadas <- 0
  # Procesar cada materia
  for (materia_nombre in names(estudiante$materias)) {
    materia_data <- estudiante$materias[[materia_nombre]]
    # Calcular nota final
    nota_final <- calcular_nota_final(
      materia_data$parcial1,
      materia_data$parcial2,
      materia_data$final,
      materia_data$asistencia
    )
    # Obtener calificación
    calificacion <- obtener_calificacion(nota_final)
    # Actualizar contadores
    materias_cursadas <- materias_cursadas + 1
    total_puntos <- total_puntos + calificacion$puntos
    if (calificacion$puntos > 0) {
      materias_aprobadas <- materias_aprobadas + 1
    }
    # Mostrar detalles de la materia
    cat(sprintf(" %s:\n", materia_nombre))
    cat(sprintf(" Parcial 1: %d | Parcial 2: %d | Final: %d | Asistencia: %d%%\n",
                materia_data$parcial1, materia_data$parcial2,
                materia_data$final, materia_data$asistencia))
    cat(sprintf("→ Nota final: %.2f (%s) - %s\n",
                nota_final, calificacion$letra, calificacion$estado))
    # Identificar áreas de mejora
    if (nota_final < 80) {
      if (materia_data$asistencia < 90) {
        cat("  Recomendación: Mejorar asistencia\n")
      }
      if (materia_data$final < materia_data$parcial1 || materia_data$final < materia_data$parcial2) {
        cat("  Recomendación: Prepararse mejor para exámenes finales\n")
      }
    }
    cat("\n")
  }
  # Calcular GPA
  gpa <- if (materias_cursadas > 0) round(total_puntos / materias_cursadas, 2) else 0
  # Determinar estado académico
  if (gpa >= 3.5) {
    estado_academico <- " Lista de Honor"
  } else if (gpa >= 3.0) {
    estado_academico <- " Buen Rendimiento"
  } else if (gpa >= 2.0) {
    estado_academico <- " Rendimiento Satisfactorio"
  } else {
    estado_academico <- " Necesita Mejora"
  }
  # Resumen del estudiante
  cat(" RESUMEN ACADÉMICO:\n")
  cat(sprintf(" GPA: %.2f/4.0\n", gpa))
  cat(sprintf(" Materias cursadas: %d\n", materias_cursadas))
  cat(sprintf(" Materias aprobadas: %d\n", materias_aprobadas))
  cat(sprintf(" Tasa de aprobación: %.1f%%\n", (materias_aprobadas / materias_cursadas) * 100))
  cat(sprintf(" Estado académico: %s\n", estado_academico))
  cat(strrep("=", 60), "\n")
}
## 
## ESTUDIANTE: Ana Rodríguez (ID: EST001)
## -------------------------------------------------- 
##  Matemáticas:
##  Parcial 1: 85 | Parcial 2: 88 | Final: 92 | Asistencia: 95%
## → Nota final: 89.55 (B) - Bueno
## 
##  Física:
##  Parcial 1: 78 | Parcial 2: 82 | Final: 85 | Asistencia: 90%
## → Nota final: 83.00 (B) - Bueno
## 
##  Química:
##  Parcial 1: 90 | Parcial 2: 87 | Final: 94 | Asistencia: 98%
## → Nota final: 91.65 (A) - Excelente
## 
##  RESUMEN ACADÉMICO:
##  GPA: 3.33/4.0
##  Materias cursadas: 3
##  Materias aprobadas: 3
##  Tasa de aprobación: 100.0%
##  Estado académico:  Buen Rendimiento
## ============================================================ 
## 
## ESTUDIANTE: Pedro Martínez (ID: EST002)
## -------------------------------------------------- 
##  Matemáticas:
##  Parcial 1: 75 | Parcial 2: 79 | Final: 82 | Asistencia: 88%
## → Nota final: 80.10 (B) - Bueno
## 
##  Física:
##  Parcial 1: 82 | Parcial 2: 85 | Final: 88 | Asistencia: 92%
## → Nota final: 86.15 (B) - Bueno
## 
##  Química:
##  Parcial 1: 77 | Parcial 2: 80 | Final: 83 | Asistencia: 85%
## → Nota final: 80.95 (B) - Bueno
## 
##  RESUMEN ACADÉMICO:
##  GPA: 3.00/4.0
##  Materias cursadas: 3
##  Materias aprobadas: 3
##  Tasa de aprobación: 100.0%
##  Estado académico:  Buen Rendimiento
## ============================================================ 
## 
## ESTUDIANTE: Lucía Fernández (ID: EST003)
## -------------------------------------------------- 
##  Matemáticas:
##  Parcial 1: 92 | Parcial 2: 94 | Final: 96 | Asistencia: 100%
## → Nota final: 94.90 (A) - Excelente
## 
##  Física:
##  Parcial 1: 88 | Parcial 2: 91 | Final: 93 | Asistencia: 95%
## → Nota final: 91.45 (A) - Excelente
## 
##  Química:
##  Parcial 1: 95 | Parcial 2: 92 | Final: 97 | Asistencia: 98%
## → Nota final: 95.35 (A) - Excelente
## 
##  RESUMEN ACADÉMICO:
##  GPA: 4.00/4.0
##  Materias cursadas: 3
##  Materias aprobadas: 3
##  Tasa de aprobación: 100.0%
##  Estado académico:  Lista de Honor
## ============================================================

Sistema de Gestión Académica en Python

print("\n=== SISTEMA DE GESTIÓN ACADÉMICA ===")
## 
## === SISTEMA DE GESTIÓN ACADÉMICA ===
estudiantes_db = [
    {
        "nombre": "Ana Rodríguez", 
        "id": "EST001",
        "materias": {
            "Matemáticas": {"parcial1": 85, "parcial2": 88, "final": 92, "asistencia": 95},
            "Física": {"parcial1": 78, "parcial2": 82, "final": 85, "asistencia": 90},
            "Química": {"parcial1": 90, "parcial2": 87, "final": 94, "asistencia": 98}
        }
    },
    {
        "nombre": "Pedro Martínez", 
        "id": "EST002",
        "materias": {
            "Matemáticas": {"parcial1": 75, "parcial2": 79, "final": 82, "asistencia": 88},
            "Física": {"parcial1": 82, "parcial2": 85, "final": 88, "asistencia": 92},
            "Química": {"parcial1": 77, "parcial2": 80, "final": 83, "asistencia": 85}
        }
    },
    {
        "nombre": "Lucía Fernández", 
        "id": "EST003",
        "materias": {
            "Matemáticas": {"parcial1": 92, "parcial2": 94, "final": 96, "asistencia": 100},
            "Física": {"parcial1": 88, "parcial2": 91, "final": 93, "asistencia": 95},
            "Química": {"parcial1": 95, "parcial2": 92, "final": 97, "asistencia": 98}
        }
    }
]

def calcular_nota_final(parcial1, parcial2, final, asistencia):
    nota = (parcial1 * 0.25) + (parcial2 * 0.25) + (final * 0.40) + (asistencia * 0.10)
    return round(nota, 2)

def obtener_calificacion(nota):
    if nota >= 90:
        return {"letra": "A", "estado": "Excelente", "puntos": 4.0}
    elif nota >= 80:
        return {"letra": "B", "estado": "Bueno", "puntos": 3.0}
    elif nota >= 70:
        return {"letra": "C", "estado": "Satisfactorio", "puntos": 2.0}
    elif nota >= 60:
        return {"letra": "D", "estado": "Mínimo", "puntos": 1.0}
    else:
        return {"letra": "F", "estado": "Reprobado", "puntos": 0.0}

print("REPORTE ACADÉMICO DETALLADO")
## REPORTE ACADÉMICO DETALLADO
print("=" * 60)
## ============================================================
for estudiante in estudiantes_db:
    print(f"\nESTUDIANTE: {estudiante['nombre']} (ID: {estudiante['id']})")
    print("-" * 50)
    
    total_puntos = 0
    materias_cursadas = 0
    materias_aprobadas = 0
    
    for materia_nombre, materia_data in estudiante["materias"].items():
        nota_final = calcular_nota_final(
            materia_data["parcial1"],
            materia_data["parcial2"],
            materia_data["final"],
            materia_data["asistencia"]
        )
        
        calificacion = obtener_calificacion(nota_final)
        materias_cursadas += 1
        total_puntos += calificacion["puntos"]
        
        if calificacion["puntos"] > 0:
            materias_aprobadas += 1
        
        print(f" {materia_nombre}:")
        print(f" Parcial 1: {materia_data['parcial1']} | Parcial 2: {materia_data['parcial2']} | Final: {materia_data['final']} | Asistencia: {materia_data['asistencia']}%")
        print(f"→ Nota final: {nota_final:.2f} ({calificacion['letra']}) - {calificacion['estado']}")
        
        if nota_final < 80:
            if materia_data["asistencia"] < 90:
                print("  Recomendación: Mejorar asistencia")
            if materia_data["final"] < materia_data["parcial1"] or materia_data["final"] < materia_data["parcial2"]:
                print("  Recomendación: Prepararse mejor para exámenes finales")
        print()
    
    gpa = round(total_puntos / materias_cursadas, 2) if materias_cursadas > 0 else 0
    
    if gpa >= 3.5:
        estado_academico = "Lista de Honor"
    elif gpa >= 3.0:
        estado_academico = "Buen Rendimiento"
    elif gpa >= 2.0:
        estado_academico = "Rendimiento Satisfactorio"
    else:
        estado_academico = "Necesita Mejora"
    
    print(" RESUMEN ACADÉMICO:")
    print(f" GPA: {gpa}/4.0")
    print(f" Materias cursadas: {materias_cursadas}")
    print(f" Materias aprobadas: {materias_aprobadas}")
    print(f" Tasa de aprobación: {(materias_aprobadas/materias_cursadas*100):.1f}%")
    print(f" Estado académico: {estado_academico}")
    print("=" * 60)
## 
## ESTUDIANTE: Ana Rodríguez (ID: EST001)
## --------------------------------------------------
##  Matemáticas:
##  Parcial 1: 85 | Parcial 2: 88 | Final: 92 | Asistencia: 95%
## → Nota final: 89.55 (B) - Bueno
## 
##  Física:
##  Parcial 1: 78 | Parcial 2: 82 | Final: 85 | Asistencia: 90%
## → Nota final: 83.00 (B) - Bueno
## 
##  Química:
##  Parcial 1: 90 | Parcial 2: 87 | Final: 94 | Asistencia: 98%
## → Nota final: 91.65 (A) - Excelente
## 
##  RESUMEN ACADÉMICO:
##  GPA: 3.33/4.0
##  Materias cursadas: 3
##  Materias aprobadas: 3
##  Tasa de aprobación: 100.0%
##  Estado académico: Buen Rendimiento
## ============================================================
## 
## ESTUDIANTE: Pedro Martínez (ID: EST002)
## --------------------------------------------------
##  Matemáticas:
##  Parcial 1: 75 | Parcial 2: 79 | Final: 82 | Asistencia: 88%
## → Nota final: 80.10 (B) - Bueno
## 
##  Física:
##  Parcial 1: 82 | Parcial 2: 85 | Final: 88 | Asistencia: 92%
## → Nota final: 86.15 (B) - Bueno
## 
##  Química:
##  Parcial 1: 77 | Parcial 2: 80 | Final: 83 | Asistencia: 85%
## → Nota final: 80.95 (B) - Bueno
## 
##  RESUMEN ACADÉMICO:
##  GPA: 3.0/4.0
##  Materias cursadas: 3
##  Materias aprobadas: 3
##  Tasa de aprobación: 100.0%
##  Estado académico: Buen Rendimiento
## ============================================================
## 
## ESTUDIANTE: Lucía Fernández (ID: EST003)
## --------------------------------------------------
##  Matemáticas:
##  Parcial 1: 92 | Parcial 2: 94 | Final: 96 | Asistencia: 100%
## → Nota final: 94.90 (A) - Excelente
## 
##  Física:
##  Parcial 1: 88 | Parcial 2: 91 | Final: 93 | Asistencia: 95%
## → Nota final: 91.45 (A) - Excelente
## 
##  Química:
##  Parcial 1: 95 | Parcial 2: 92 | Final: 97 | Asistencia: 98%
## → Nota final: 95.35 (A) - Excelente
## 
##  RESUMEN ACADÉMICO:
##  GPA: 4.0/4.0
##  Materias cursadas: 3
##  Materias aprobadas: 3
##  Tasa de aprobación: 100.0%
##  Estado académico: Lista de Honor
## ============================================================

Simulación y Modelado en R

# Simulación de crecimiento poblacional
cat("\n=== SIMULACIÓN DE CRECIMIENTO POBLACIONAL ===\n")
## 
## === SIMULACIÓN DE CRECIMIENTO POBLACIONAL ===
# Parámetros de simulación
poblacion_inicial <- 10000
tasa_natalidad <- 0.025  # 2.5% anual
tasa_mortalidad <- 0.015  # 1.5% anual
tasa_migracion <- 0.008  # 0.8% anual (inmigración neta)
años_simulacion <- 20
# Variables para tracking
poblacion_actual <- poblacion_inicial
historial_poblacion <- numeric(años_simulacion + 1)
historial_poblacion[1] <- poblacion_inicial
cat("SIMULACIÓN A 20 AÑOS:\n")
## SIMULACIÓN A 20 AÑOS:
cat(sprintf("Población inicial: %s habitantes\n", format(poblacion_inicial, big.mark = ",")))
## Población inicial: 10,000 habitantes
cat(sprintf("Tasa de natalidad: %.1f%% anual\n", tasa_natalidad * 100))
## Tasa de natalidad: 2.5% anual
cat(sprintf("Tasa de mortalidad: %.1f%% anual\n", tasa_mortalidad * 100))
## Tasa de mortalidad: 1.5% anual
cat(sprintf("Migración neta: %.1f%% anual\n\n", tasa_migracion * 100))
## Migración neta: 0.8% anual
cat(sprintf("%-6s %12s %8s %8s %8s %12s\n",
            "Año", "Población", "Nacim.", "Muertes", "Migrac.", "Crecimiento"))
## Año     Población   Nacim.  Muertes  Migrac.  Crecimiento
cat(strrep("-", 65), "\n")
## -----------------------------------------------------------------
for (año in 1:años_simulacion) {
  # Calcular cambios poblacionales
  nacimientos <- round(poblacion_actual * tasa_natalidad)
  muertes <- round(poblacion_actual * tasa_mortalidad)
  migracion <- round(poblacion_actual * tasa_migracion)
  # Aplicar cambios
  poblacion_anterior <- poblacion_actual
  poblacion_actual <- poblacion_actual + nacimientos - muertes + migracion
  crecimiento_neto <- poblacion_actual - poblacion_anterior
  # Guardar en historial
  historial_poblacion[año + 1] <- poblacion_actual
  # Mostrar resultados del año
  cat(sprintf("%-6d %12s %8s %8s %8s %+12s\n",
              año,
              format(poblacion_actual, big.mark = ","),
              format(nacimientos, big.mark = ","),
              format(muertes, big.mark = ","),
              format(migracion, big.mark = ","),
              format(crecimiento_neto, big.mark = ",")))
  # Análisis de tendencias cada 5 años
  if (año %% 5 == 0) {
    crecimiento_periodo <- poblacion_actual - historial_poblacion[año - 4]
    tasa_crecimiento_periodo <- ((poblacion_actual / historial_poblacion[año - 4]) ^ (1/5) - 1) * 100
    cat(sprintf("  Crecimiento últimos 5 años: %s (%.2f%% anual promedio)\n",
                format(crecimiento_periodo, big.mark = ","),
                tasa_crecimiento_periodo))
  }
}
## 1            10,180      250      150       80          180
## 2            10,362      254      153       81          182
## 3            10,549      259      155       83          187
## 4            10,739      264      158       84          190
## 5            10,932      268      161       86          193
##   Crecimiento últimos 5 años: 932 (1.80% anual promedio)
## 6            11,128      273      164       87          196
## 7            11,328      278      167       89          200
## 8            11,532      283      170       91          204
## 9            11,739      288      173       92          207
## 10           11,950      293      176       94          211
##   Crecimiento últimos 5 años: 1,018 (1.80% anual promedio)
## 11           12,166      299      179       96          216
## 12           12,385      304      182       97          219
## 13           12,608      310      186       99          223
## 14           12,835      315      189      101          227
## 15           13,066      321      193      103          231
##   Crecimiento últimos 5 años: 1,116 (1.80% anual promedio)
## 16           13,302      327      196      105          236
## 17           13,541      333      200      106          239
## 18           13,785      339      203      108          244
## 19           14,033      345      207      110          248
## 20           14,286      351      210      112          253
##   Crecimiento últimos 5 años: 1,220 (1.80% anual promedio)
# Análisis final
crecimiento_total <- poblacion_actual - poblacion_inicial
tasa_crecimiento_anual_promedio <- ((poblacion_actual / poblacion_inicial) ^ (1/años_simulacion) - 1) * 100
duplicacion_años <- log(2) / log(1 + (tasa_crecimiento_anual_promedio / 100))
cat(strrep("-", 65), "\n")
## -----------------------------------------------------------------
cat("\nANÁLISIS FINAL DE LA SIMULACIÓN:\n")
## 
## ANÁLISIS FINAL DE LA SIMULACIÓN:
cat(sprintf("Población final: %s habitantes\n", format(poblacion_actual, big.mark = ",")))
## Población final: 14,286 habitantes
cat(sprintf("Crecimiento total: %s habitantes (%.1f%%)\n",
            format(crecimiento_total, big.mark = ","),
            (crecimiento_total / poblacion_inicial) * 100))
## Crecimiento total: 4,286 habitantes (42.9%)
cat(sprintf("Tasa de crecimiento anual promedio: %.2f%%\n", tasa_crecimiento_anual_promedio))
## Tasa de crecimiento anual promedio: 1.80%
cat(sprintf("Tiempo estimado para duplicar población: %.1f años\n", duplicacion_años))
## Tiempo estimado para duplicar población: 38.9 años
# Proyecciones adicionales
if (tasa_crecimiento_anual_promedio > 0) {
  población_en_50_años <- poblacion_inicial * (1 + tasa_crecimiento_anual_promedio / 100) ^ 50
  cat(sprintf("Proyección a 50 años: %s habitantes\n",
              format(round(población_en_50_años), big.mark = ",")))
}
## Proyección a 50 años: 24,394 habitantes

Simulación y Modelado en Python

import math

print("\n=== SIMULACIÓN DE CRECIMIENTO POBLACIONAL ===")
## 
## === SIMULACIÓN DE CRECIMIENTO POBLACIONAL ===
poblacion_inicial = 10000
tasa_natalidad = 0.025
tasa_mortalidad = 0.015
tasa_migracion = 0.008
años_simulacion = 20

poblacion_actual = poblacion_inicial
historial_poblacion = [0] * (años_simulacion + 1)
historial_poblacion[0] = poblacion_inicial

print("SIMULACIÓN A 20 AÑOS:")
## SIMULACIÓN A 20 AÑOS:
print(f"Población inicial: {poblacion_inicial:,} habitantes")
## Población inicial: 10,000 habitantes
print(f"Tasa de natalidad: {tasa_natalidad*100:.1f}% anual")
## Tasa de natalidad: 2.5% anual
print(f"Tasa de mortalidad: {tasa_mortalidad*100:.1f}% anual")
## Tasa de mortalidad: 1.5% anual
print(f"Migración neta: {tasa_migracion*100:.1f}% anual\n")
## Migración neta: 0.8% anual
print(f"{'Año':<6} {'Población':>12} {'Nacim.':>8} {'Muertes':>8} {'Migrac.':>8} {'Crecimiento':>12}")
## Año       Población   Nacim.  Muertes  Migrac.  Crecimiento
print("-" * 65)
## -----------------------------------------------------------------
for año in range(1, años_simulacion + 1):
    nacimientos = round(poblacion_actual * tasa_natalidad)
    muertes = round(poblacion_actual * tasa_mortalidad)
    migracion = round(poblacion_actual * tasa_migracion)
    
    poblacion_anterior = poblacion_actual
    poblacion_actual = poblacion_actual + nacimientos - muertes + migracion
    crecimiento_neto = poblacion_actual - poblacion_anterior
    
    historial_poblacion[año] = poblacion_actual
    
    print(f"{año:<6} {poblacion_actual:>12,} {nacimientos:>8,} {muertes:>8,} {migracion:>8,} {crecimiento_neto:>+12,}")
    
    if año % 5 == 0 and año >= 5:
        crecimiento_periodo = poblacion_actual - historial_poblacion[año - 5]
        tasa_crecimiento_periodo = ((poblacion_actual / historial_poblacion[año - 5]) ** (1/5) - 1) * 100
        print(f"  Crecimiento últimos 5 años: {crecimiento_periodo:,} ({tasa_crecimiento_periodo:.2f}% anual promedio)")
## 1            10,180      250      150       80         +180
## 2            10,362      254      153       81         +182
## 3            10,549      259      155       83         +187
## 4            10,739      264      158       84         +190
## 5            10,932      268      161       86         +193
##   Crecimiento últimos 5 años: 932 (1.80% anual promedio)
## 6            11,128      273      164       87         +196
## 7            11,328      278      167       89         +200
## 8            11,532      283      170       91         +204
## 9            11,739      288      173       92         +207
## 10           11,950      293      176       94         +211
##   Crecimiento últimos 5 años: 1,018 (1.80% anual promedio)
## 11           12,166      299      179       96         +216
## 12           12,385      304      182       97         +219
## 13           12,608      310      186       99         +223
## 14           12,835      315      189      101         +227
## 15           13,066      321      193      103         +231
##   Crecimiento últimos 5 años: 1,116 (1.80% anual promedio)
## 16           13,302      327      196      105         +236
## 17           13,541      333      200      106         +239
## 18           13,785      339      203      108         +244
## 19           14,033      345      207      110         +248
## 20           14,286      351      210      112         +253
##   Crecimiento últimos 5 años: 1,220 (1.80% anual promedio)
print("-" * 65)
## -----------------------------------------------------------------
crecimiento_total = poblacion_actual - poblacion_inicial
tasa_crecimiento_anual_promedio = ((poblacion_actual / poblacion_inicial) ** (1/años_simulacion) - 1) * 100
duplicacion_años = math.log(2) / math.log(1 + (tasa_crecimiento_anual_promedio / 100))

print("\nANÁLISIS FINAL DE LA SIMULACIÓN:")
## 
## ANÁLISIS FINAL DE LA SIMULACIÓN:
print(f"Población final: {poblacion_actual:,} habitantes")
## Población final: 14,286 habitantes
print(f"Crecimiento total: {crecimiento_total:,} habitantes ({(crecimiento_total/poblacion_inicial)*100:.1f}%)")
## Crecimiento total: 4,286 habitantes (42.9%)
print(f"Tasa de crecimiento anual promedio: {tasa_crecimiento_anual_promedio:.2f}%")
## Tasa de crecimiento anual promedio: 1.80%
print(f"Tiempo estimado para duplicar población: {duplicacion_años:.1f} años")
## Tiempo estimado para duplicar población: 38.9 años
if tasa_crecimiento_anual_promedio > 0:
    población_en_50_años = poblacion_inicial * (1 + tasa_crecimiento_anual_promedio / 100) ** 50
    print(f"Proyección a 50 años: {round(población_en_50_años):,} habitantes")
## Proyección a 50 años: 24,394 habitantes

Procesamiento Secuencial Dependiente

ANÁLISIS DE SERIES TEMPORALES en R

# Cálculos que dependen de iteraciones anteriores
cat("\n=== ANÁLISIS DE SERIES TEMPORALES ===\n")
## 
## === ANÁLISIS DE SERIES TEMPORALES ===
# Datos de ventas mensuales
ventas_mensuales <- c(100000, 108000, 95000, 112000, 125000, 118000,
                      135000, 142000, 128000, 155000, 168000, 175000)
meses_nombres <- c("Ene", "Feb", "Mar", "Abr", "May", "Jun",
                   "Jul", "Ago", "Sep", "Oct", "Nov", "Dic")
# Variables para cálculos acumulativos
ventas_acumuladas <- numeric(length(ventas_mensuales))
variacion_mensual <- numeric(length(ventas_mensuales))
promedio_movil_3 <- numeric(length(ventas_mensuales))
cat("ANÁLISIS DE TENDENCIAS DE VENTAS:\n")
## ANÁLISIS DE TENDENCIAS DE VENTAS:
cat(sprintf("%-4s %10s %12s %10s %12s %s\n",
            "Mes", "Ventas", "Acumulado", "Variación", "Prom.Móvil", "Tendencia"))
## Mes      Ventas    Acumulado Variación  Prom.Móvil Tendencia
cat(strrep("-", 75), "\n")
## ---------------------------------------------------------------------------
for (i in 1:length(ventas_mensuales)) {
  mes <- meses_nombres[i]
  venta_actual <- ventas_mensuales[i]
  # Ventas acumuladas
  if (i == 1) {
    ventas_acumuladas[i] <- venta_actual
    variacion_mensual[i] <- 0  # No hay mes anterior
  } else {
    ventas_acumuladas[i] <- ventas_acumuladas[i - 1] + venta_actual
    variacion_mensual[i] <- ((venta_actual - ventas_mensuales[i - 1]) / ventas_mensuales[i - 1]) * 100
  }
  # Promedio móvil de 3 meses
  if (i >= 3) {
    promedio_movil_3[i] <- mean(ventas_mensuales[(i - 2):i])
  } else {
    promedio_movil_3[i] <- NA
  }
  # Determinar tendencia
  if (i == 1) {
    tendencia <- "Inicio"
  } else if (variacion_mensual[i] > 5) {
    tendencia <- " Alza fuerte"
  } else if (variacion_mensual[i] > 0) {
    tendencia <- " Crecimiento"
  } else if (variacion_mensual[i] > -5) {
    tendencia <- " Leve baja"
  } else {
    tendencia <- " Baja fuerte"
  }
  # Mostrar resultados
  variacion_str <- if (i == 1) " - " else sprintf("%+.1f%%", variacion_mensual[i])
  promedio_str <- if (is.na(promedio_movil_3[i])) " - " else sprintf("%8.0f", promedio_movil_3[i])
  cat(sprintf("%-4s %10s %12s %10s %12s %s\n",
              mes,
              format(venta_actual, big.mark = ","),
              format(ventas_acumuladas[i], big.mark = ","),
              variacion_str,
              promedio_str,
              tendencia))
}
## Ene       1e+05        1e+05         -            -  Inicio
## Feb     108,000      208,000      +8.0%           -   Alza fuerte
## Mar      95,000      303,000     -12.0%       101000  Baja fuerte
## Abr     112,000      415,000     +17.9%       105000  Alza fuerte
## May     125,000      540,000     +11.6%       110667  Alza fuerte
## Jun     118,000      658,000      -5.6%       118333  Baja fuerte
## Jul     135,000      793,000     +14.4%       126000  Alza fuerte
## Ago     142,000      935,000      +5.2%       131667  Alza fuerte
## Sep     128,000    1,063,000      -9.9%       135000  Baja fuerte
## Oct     155,000    1,218,000     +21.1%       141667  Alza fuerte
## Nov     168,000    1,386,000      +8.4%       150333  Alza fuerte
## Dic     175,000    1,561,000      +4.2%       166000  Crecimiento
# Análisis de resultados
cat(strrep("-", 75), "\n")
## ---------------------------------------------------------------------------
crecimiento_anual <- ((ventas_mensuales[12] - ventas_mensuales[1]) / ventas_mensuales[1]) * 100
promedio_mensual <- mean(ventas_mensuales)
mejor_mes_idx <- which.max(ventas_mensuales)
peor_mes_idx <- which.min(ventas_mensuales)
cat("\nRESUMEN ANUAL:\n")
## 
## RESUMEN ANUAL:
cat(sprintf("Ventas totales: $%s\n", format(sum(ventas_mensuales), big.mark = ",")))
## Ventas totales: $1,561,000
cat(sprintf("Promedio mensual: $%s\n", format(round(promedio_mensual), big.mark = ",")))
## Promedio mensual: $130,083
cat(sprintf("Crecimiento anual: %.1f%%\n", crecimiento_anual))
## Crecimiento anual: 75.0%
cat(sprintf("Mejor mes: %s ($%s)\n", meses_nombres[mejor_mes_idx], format(ventas_mensuales[mejor_mes_idx], big.mark = ",")))
## Mejor mes: Dic ($175,000)
cat(sprintf("Peor mes: %s ($%s)\n", meses_nombres[peor_mes_idx], format(ventas_mensuales[peor_mes_idx], big.mark = ",")))
## Peor mes: Mar ($95,000)

ANÁLISIS DE SERIES TEMPORALES en Python

print("\n=== ANÁLISIS DE SERIES TEMPORALES ===")
## 
## === ANÁLISIS DE SERIES TEMPORALES ===
ventas_mensuales = [100000, 108000, 95000, 112000, 125000, 118000,
                    135000, 142000, 128000, 155000, 168000, 175000]
meses_nombres = ["Ene", "Feb", "Mar", "Abr", "May", "Jun",
                 "Jul", "Ago", "Sep", "Oct", "Nov", "Dic"]

ventas_acumuladas = [0] * len(ventas_mensuales)
variacion_mensual = [0] * len(ventas_mensuales)
promedio_movil_3 = [0] * len(ventas_mensuales)

print("ANÁLISIS DE TENDENCIAS DE VENTAS:")
## ANÁLISIS DE TENDENCIAS DE VENTAS:
print(f"{'Mes':<4} {'Ventas':>10} {'Acumulado':>12} {'Variación':>10} {'Prom.Móvil':>12} {'Tendencia':<10}")
## Mes      Ventas    Acumulado  Variación   Prom.Móvil Tendencia
print("-" * 75)
## ---------------------------------------------------------------------------
for i in range(len(ventas_mensuales)):
    mes = meses_nombres[i]
    venta_actual = ventas_mensuales[i]
    
    if i == 0:
        ventas_acumuladas[i] = venta_actual
        variacion_mensual[i] = 0
    else:
        ventas_acumuladas[i] = ventas_acumuladas[i-1] + venta_actual
        variacion_mensual[i] = ((venta_actual - ventas_mensuales[i-1]) / ventas_mensuales[i-1]) * 100
    
    if i >= 2:
        promedio_movil_3[i] = sum(ventas_mensuales[i-2:i+1]) / 3
    else:
        promedio_movil_3[i] = None
    
    if i == 0:
        tendencia = "Inicio"
    elif variacion_mensual[i] > 5:
        tendencia = "Alza fuerte"
    elif variacion_mensual[i] > 0:
        tendencia = "Crecimiento"
    elif variacion_mensual[i] > -5:
        tendencia = "Leve baja"
    else:
        tendencia = "Baja fuerte"
    
    variacion_str = " - " if i == 0 else f"{variacion_mensual[i]:+.1f}%"
    promedio_str = " - " if promedio_movil_3[i] is None else f"{promedio_movil_3[i]:8.0f}"
    
    print(f"{mes:<4} {venta_actual:>10,} {ventas_acumuladas[i]:>12,} {variacion_str:>10} {promedio_str:>12} {tendencia:<10}")
## Ene     100,000      100,000         -            -  Inicio    
## Feb     108,000      208,000      +8.0%           -  Alza fuerte
## Mar      95,000      303,000     -12.0%       101000 Baja fuerte
## Abr     112,000      415,000     +17.9%       105000 Alza fuerte
## May     125,000      540,000     +11.6%       110667 Alza fuerte
## Jun     118,000      658,000      -5.6%       118333 Baja fuerte
## Jul     135,000      793,000     +14.4%       126000 Alza fuerte
## Ago     142,000      935,000      +5.2%       131667 Alza fuerte
## Sep     128,000    1,063,000      -9.9%       135000 Baja fuerte
## Oct     155,000    1,218,000     +21.1%       141667 Alza fuerte
## Nov     168,000    1,386,000      +8.4%       150333 Alza fuerte
## Dic     175,000    1,561,000      +4.2%       166000 Crecimiento
print("-" * 75)
## ---------------------------------------------------------------------------
crecimiento_anual = ((ventas_mensuales[11] - ventas_mensuales[0]) / ventas_mensuales[0]) * 100
promedio_mensual = sum(ventas_mensuales) / len(ventas_mensuales)
mejor_mes_idx = ventas_mensuales.index(max(ventas_mensuales))
peor_mes_idx = ventas_mensuales.index(min(ventas_mensuales))

print("\nRESUMEN ANUAL:")
## 
## RESUMEN ANUAL:
print(f"Ventas totales: ${sum(ventas_mensuales):,}")
## Ventas totales: $1,561,000
print(f"Promedio mensual: ${round(promedio_mensual):,}")
## Promedio mensual: $130,083
print(f"Crecimiento anual: {crecimiento_anual:.1f}%")
## Crecimiento anual: 75.0%
print(f"Mejor mes: {meses_nombres[mejor_mes_idx]} (${ventas_mensuales[mejor_mes_idx]:,})")
## Mejor mes: Dic ($175,000)
print(f"Peor mes: {meses_nombres[peor_mes_idx]} (${ventas_mensuales[peor_mes_idx]:,})")
## Peor mes: Mar ($95,000)

Bucles while

Los bucles while representan una estructura de control fundamental que se ejecuta mientras una condición específica permanezca verdadera.
A diferencia de los bucles for, que iteran sobre secuencias predefinidas, los bucles while continúan ejecutándose hasta que una condición cambie, lo que los hace ideales para situaciones donde no sabemos exactamente cuántas iteraciones necesitaremos.

Anatomía de un Bucle while en R

# Estructura básica
#while (condición) {
# Cuerpo del bucle
# Código que se ejecuta mientras la condición sea TRUE
# IMPORTANTE: Debe incluir algo que eventualmente cambie la condición
#}

Anatomía de un Bucle while en Python

# Estructura básica
# while condición:
#     # Cuerpo del bucle
#     # Código que se ejecuta mientras la condición sea True
#     # IMPORTANTE: Debe incluir algo que eventualmente cambie la condición

Proceso de Ejecución en R

# Ejemplo paso a paso
contador <- 1
while (contador <= 3) {
  print(paste("Iteración:", contador))
  contador <- contador + 1  # CRÍTICO: actualizar la variable de control
}
## [1] "Iteración: 1"
## [1] "Iteración: 2"
## [1] "Iteración: 3"
# Proceso interno:
# Evaluación 1: contador(1) <= 3 → TRUE → ejecutar cuerpo → contador = 2
# Evaluación 2: contador(2) <= 3 → TRUE → ejecutar cuerpo → contador = 3
# Evaluación 3: contador(3) <= 3 → TRUE → ejecutar cuerpo → contador = 4
# Evaluación 4: contador(4) <= 3 → FALSE → terminar bucle

Proceso de Ejecución en Python

# Ejemplo paso a paso
contador = 1
while contador <= 3:
    print(f"Iteración: {contador}")
    contador = contador + 1  # CRÍTICO: actualizar la variable de control
## Iteración: 1
## Iteración: 2
## Iteración: 3

# Proceso interno:
# Evaluación 1: contador(1) <= 3 → True → ejecutar cuerpo → contador = 2
# Evaluación 2: contador(2) <= 3 → True → ejecutar cuerpo → contador = 3
# Evaluación 3: contador(3) <= 3 → True → ejecutar cuerpo → contador = 4
# Evaluación 4: contador(4) <= 3 → False → terminar bucle

Contadores y Acumuladores en R

# Sistema de contador simple
cat("=== CONTADOR BÁSICO ===\n")
## === CONTADOR BÁSICO ===
numero <- 1
suma_total <- 0
cat("Sumando números del 1 al 5:\n")
## Sumando números del 1 al 5:
while (numero <= 5) {
  suma_total <- suma_total + numero
  cat(sprintf("Sumando %d: total = %d\n", numero, suma_total))
  numero <- numero + 1
}
## Sumando 1: total = 1
## Sumando 2: total = 3
## Sumando 3: total = 6
## Sumando 4: total = 10
## Sumando 5: total = 15
cat(sprintf("Suma final: %d\n", suma_total))
## Suma final: 15
# Contador con condición más compleja
cat("\n=== SUMA HASTA LÍMITE ===\n")
## 
## === SUMA HASTA LÍMITE ===
suma <- 0
contador <- 1
limite <- 100
cat(sprintf("Sumando números hasta que la suma supere %d:\n", limite))
## Sumando números hasta que la suma supere 100:
while (suma <= limite) {
  suma <- suma + contador
  cat(sprintf("Suma = %d (agregando %d)\n", suma, contador))
  contador <- contador + 1
}
## Suma = 1 (agregando 1)
## Suma = 3 (agregando 2)
## Suma = 6 (agregando 3)
## Suma = 10 (agregando 4)
## Suma = 15 (agregando 5)
## Suma = 21 (agregando 6)
## Suma = 28 (agregando 7)
## Suma = 36 (agregando 8)
## Suma = 45 (agregando 9)
## Suma = 55 (agregando 10)
## Suma = 66 (agregando 11)
## Suma = 78 (agregando 12)
## Suma = 91 (agregando 13)
## Suma = 105 (agregando 14)
cat(sprintf("Se necesitaron %d números para superar %d\n", contador - 1, limite))
## Se necesitaron 14 números para superar 100

Contadores y Acumuladores en Python

# Sistema de contador simple
print("=== CONTADOR BÁSICO ===")
## === CONTADOR BÁSICO ===
numero = 1
suma_total = 0
print("Sumando números del 1 al 5:")
## Sumando números del 1 al 5:
while numero <= 5:
    suma_total += numero  # Equivalente a suma_total = suma_total + numero
    print(f"Sumando {numero}: total = {suma_total}")
    numero += 1  # Operador de incremento más conciso
## Sumando 1: total = 1
## Sumando 2: total = 3
## Sumando 3: total = 6
## Sumando 4: total = 10
## Sumando 5: total = 15
print(f"Suma final: {suma_total}")
## Suma final: 15
# Contador con condición más compleja
print("\n=== SUMA HASTA LÍMITE ===")
## 
## === SUMA HASTA LÍMITE ===
suma = 0
contador = 1
limite = 100
print(f"Sumando números hasta que la suma supere {limite}:")
## Sumando números hasta que la suma supere 100:
while suma <= limite:
    suma += contador
    print(f"Suma = {suma} (agregando {contador})")
    contador += 1
## Suma = 1 (agregando 1)
## Suma = 3 (agregando 2)
## Suma = 6 (agregando 3)
## Suma = 10 (agregando 4)
## Suma = 15 (agregando 5)
## Suma = 21 (agregando 6)
## Suma = 28 (agregando 7)
## Suma = 36 (agregando 8)
## Suma = 45 (agregando 9)
## Suma = 55 (agregando 10)
## Suma = 66 (agregando 11)
## Suma = 78 (agregando 12)
## Suma = 91 (agregando 13)
## Suma = 105 (agregando 14)
print(f"Se necesitaron {contador-1} números para superar {limite}")
## Se necesitaron 14 números para superar 100

Búsqueda y Validación en R

# Sistema de búsqueda secuencial
cat("\n=== BÚSQUEDA EN LISTA ===\n")
## 
## === BÚSQUEDA EN LISTA ===
productos <- c("Laptop", "Mouse", "Teclado", "Monitor", "Auriculares")
producto_buscado <- "Monitor"
indice <- 1
encontrado <- FALSE
cat(sprintf("Buscando '%s' en la lista:\n", producto_buscado))
## Buscando 'Monitor' en la lista:
while (indice <= length(productos) && !encontrado) {
  producto_actual <- productos[indice]
  cat(sprintf("Revisando posición %d: %s\n", indice, producto_actual))
  if (producto_actual == producto_buscado) {
    encontrado <- TRUE
    cat(sprintf("¡Encontrado! '%s' está en la posición %d\n", producto_buscado, indice))
  } else {
    indice <- indice + 1
  }
}
## Revisando posición 1: Laptop
## Revisando posición 2: Mouse
## Revisando posición 3: Teclado
## Revisando posición 4: Monitor
## ¡Encontrado! 'Monitor' está en la posición 4
if (!encontrado) {
  cat(sprintf("'%s' no se encontró en la lista\n", producto_buscado))
}

# Validación de entrada con bucle while
cat("\n=== VALIDACIÓN DE ENTRADA ===\n")
## 
## === VALIDACIÓN DE ENTRADA ===
# Simulación de validación de edad
entradas_simuladas <- c("abc", "-5", "150", "25")  # Simular entradas del usuario
indice_entrada <- 1
edad_valida <- FALSE
edad <- NA
cat("Solicitando edad válida (18-100 años):\n")
## Solicitando edad válida (18-100 años):
while (!edad_valida && indice_entrada <= length(entradas_simuladas)) {
  entrada <- entradas_simuladas[indice_entrada]
  cat(sprintf("Entrada del usuario: '%s'\n", entrada))
  # Intentar convertir a número
  edad_convertida <- suppressWarnings(as.numeric(entrada))
  if (is.na(edad_convertida)) {
    cat("Error: Debe ingresar un número válido\n")
  } else if (edad_convertida < 18) {
    cat("Error: Debe ser mayor de 18 años\n")
  } else if (edad_convertida > 100) {
    cat("Error: Edad no puede ser mayor a 100 años\n")
  } else {
    edad <- edad_convertida
    edad_valida <- TRUE
    cat(sprintf("Edad válida aceptada: %d años\n", edad))
  }
  indice_entrada <- indice_entrada + 1
}
## Entrada del usuario: 'abc'
## Error: Debe ingresar un número válido
## Entrada del usuario: '-5'
## Error: Debe ser mayor de 18 años
## Entrada del usuario: '150'
## Error: Edad no puede ser mayor a 100 años
## Entrada del usuario: '25'
## Edad válida aceptada: 25 años
if (!edad_valida) {
  cat("No se pudo obtener una edad válida después de varios intentos\n")
}

Búsqueda y Validación en Python

# Sistema de búsqueda secuencial
print("\n=== BÚSQUEDA EN LISTA ===")
## 
## === BÚSQUEDA EN LISTA ===
productos = ["Laptop", "Mouse", "Teclado", "Monitor", "Auriculares"]
producto_buscado = "Monitor"
indice = 0  # Python usa índices base 0 (no base 1 como R)
encontrado = False
print(f"Buscando '{producto_buscado}' en la lista:")
## Buscando 'Monitor' en la lista:
while indice < len(productos) and not encontrado:
    producto_actual = productos[indice]
    print(f"Revisando posición {indice + 1}: {producto_actual}")  # +1 para mostrar posición humana
    if producto_actual == producto_buscado:
        encontrado = True
        print(f"¡Encontrado! '{producto_buscado}' está en la posición {indice + 1}")
    else:
        indice += 1
## Revisando posición 1: Laptop
## Revisando posición 2: Mouse
## Revisando posición 3: Teclado
## Revisando posición 4: Monitor
## ¡Encontrado! 'Monitor' está en la posición 4
if not encontrado:
    print(f"'{producto_buscado}' no se encontró en la lista")

# Validación de entrada con bucle while
print("\n=== VALIDACIÓN DE ENTRADA ===")
## 
## === VALIDACIÓN DE ENTRADA ===
# Simulación de validación de edad
entradas_simuladas = ["abc", "-5", "150", "25"]
indice_entrada = 0
edad_valida = False
edad = None  # Equivalente a NA en R
print("Solicitando edad válida (18-100 años):")
## Solicitando edad válida (18-100 años):
while not edad_valida and indice_entrada < len(entradas_simuladas):
    entrada = entradas_simuladas[indice_entrada]
    print(f"Entrada del usuario: '{entrada}'")
    
    # Intentar convertir a número (manejo de errores más explícito)
    try:
        edad_convertida = float(entrada)
        if edad_convertida < 18:
            print("Error: Debe ser mayor de 18 años")
        elif edad_convertida > 100:
            print("Error: Edad no puede ser mayor a 100 años")
        else:
            edad = int(edad_convertida)  # Convertir a entero
            edad_valida = True
            print(f"Edad válida aceptada: {edad} años")
    except ValueError:  # Capturar error de conversión
        print("Error: Debe ingresar un número válido")
    
    indice_entrada += 1
## Entrada del usuario: 'abc'
## Error: Debe ingresar un número válido
## Entrada del usuario: '-5'
## Error: Debe ser mayor de 18 años
## Entrada del usuario: '150'
## Error: Edad no puede ser mayor a 100 años
## Entrada del usuario: '25'
## Edad válida aceptada: 25 años

if not edad_valida:
    print("No se pudo obtener una edad válida después de varios intentos")

Bucles repeat

Los bucles repeat crean bucles infinitos que deben terminarse explícitamente con break.
Se ejecutan al menos una vez, garantizado.

Estructura Básica en R

#repeat {
# código a ejecutar
# if (condición_de_salida) {
# break
# }
#}

Estructura Básica en Python

# Estructura básica
# while True:
#     # código a ejecutar
#     if condición_de_salida:
#         break

Ejemplo en R

contador <- 1
repeat {
  print(paste("Iteración:", contador))
  contador <- contador + 1
  if (contador > 3) {
    break
  }
}
## [1] "Iteración: 1"
## [1] "Iteración: 2"
## [1] "Iteración: 3"

Ejemplo en Python

contador = 1
while True:
    print(f"Iteración: {contador}")
    contador += 1
    if contador > 3:
        break
## Iteración: 1
## Iteración: 2
## Iteración: 3

Menús Interactivos en R

repeat {
  cat("1. Opción A\n2. Opción B\n3. Salir\n")
  # opcion <- readline("Seleccione: ")
  opcion <- "3"  # Simulación
  if (opcion == "1") {
    print("Ejecutando opción A")
  } else if (opcion == "2") {
    print("Ejecutando opción B")
  } else if (opcion == "3") {
    print("Saliendo...")
    break
  } else {
    print("Opción inválida")
  }
}
## 1. Opción A
## 2. Opción B
## 3. Salir
## [1] "Saliendo..."

Menús Interactivos en Python

while True:
    print("1. Opción A")
    print("2. Opción B")
    print("3. Salir")
    opcion = "3"  # Simulación
    # opcion = input("Seleccione: ")
    
    if opcion == "1":
        print("Ejecutando opción A")
    elif opcion == "2":
        print("Ejecutando opción B")
    elif opcion == "3":
        print("Saliendo...")
        break
    else:
        print("Opción inválida")
## 1. Opción A
## 2. Opción B
## 3. Salir
## Saliendo...

Procesamiento Hasta Condición en R

suma <- 0
repeat {
  numero <- sample(1:10, 1)  # Número aleatorio
  suma <- suma + numero
  print(paste("Sumando:", numero, "Total:", suma))
  if (suma >= 20) {
    print("Meta alcanzada")
    break
  }
}
## [1] "Sumando: 8 Total: 8"
## [1] "Sumando: 9 Total: 17"
## [1] "Sumando: 9 Total: 26"
## [1] "Meta alcanzada"

Procesamiento Hasta Condición en Python

import random
suma = 0
while True:
    numero = random.randint(1, 10)
    suma += numero
    print(f"Sumando: {numero} Total: {suma}")
    if suma >= 20:
        print("Meta alcanzada")
        break
## Sumando: 5 Total: 5
## Sumando: 2 Total: 7
## Sumando: 3 Total: 10
## Sumando: 9 Total: 19
## Sumando: 1 Total: 20
## Meta alcanzada

Control de bucles

Declaraciones de Control

break - Terminar Bucle

Termina inmediatamente el bucle más interno y continúa con la siguiente instrucción.

Ejemplo 1 en R:

# Buscar primer número par mayor que 10
for (i in 1:20) {
  if (i > 10 && i %% 2 == 0) {
    print(paste("Primer par mayor que 10:", i))
    break
  }
}
## [1] "Primer par mayor que 10: 12"

Ejemplo 1 en Python:

for i in range(1, 21):
    if i > 10 and i % 2 == 0:
        print(f"Primer par mayor que 10: {i}")
        break
## Primer par mayor que 10: 12

next - Saltar Iteración

Salta el resto de la iteración actual y continúa con la siguiente.

Ejemplo 2 en R:

# Procesar solo números impares
for (i in 1:10) {
  if (i %% 2 == 0) {
    next  # Saltar números pares
  }
  print(paste("Número impar:", i))
}
## [1] "Número impar: 1"
## [1] "Número impar: 3"
## [1] "Número impar: 5"
## [1] "Número impar: 7"
## [1] "Número impar: 9"

Ejemplo 2 en Python:

for i in range(1, 11):
    if i % 2 == 0:
        continue
    print(f"Número impar: {i}")
## Número impar: 1
## Número impar: 3
## Número impar: 5
## Número impar: 7
## Número impar: 9

Bucles Anidados con Control

Ejemplo 3 en R:

# Matriz: salir de bucle interno vs externo
for (i in 1:3) {
  print(paste("Fila", i))
  for (j in 1:3) {
    if (i == 2 && j == 2) {
      print("Saltando elemento (2,2)")
      next  # Solo salta esta iteración del bucle interno
    }
    print(paste(" Columna", j))
  }
}
## [1] "Fila 1"
## [1] " Columna 1"
## [1] " Columna 2"
## [1] " Columna 3"
## [1] "Fila 2"
## [1] " Columna 1"
## [1] "Saltando elemento (2,2)"
## [1] " Columna 3"
## [1] "Fila 3"
## [1] " Columna 1"
## [1] " Columna 2"
## [1] " Columna 3"

Ejemplo 3 en Python:

for i in range(1, 4):
    print(f"Fila {i}")
    for j in range(1, 4):
        if i == 2 and j == 2:
            print("Saltando elemento (2,2)")
            continue
        print(f" Columna {j}")
## Fila 1
##  Columna 1
##  Columna 2
##  Columna 3
## Fila 2
##  Columna 1
## Saltando elemento (2,2)
##  Columna 3
## Fila 3
##  Columna 1
##  Columna 2
##  Columna 3