Cómo definir una sucesión

01 · Punto de partida

Mostrar términos no siempre define el patrón

La lista 1, 2, 4, 8, … sugiere potencias de dos. Sin embargo, también podría continuar con 16, 15 o cualquier otro número si inventamos una regla compatible con los cuatro datos iniciales. Una cantidad finita de términos no determina por sí sola una sucesión infinita.

Definir una sucesión significa proporcionar información suficiente para obtener un único valor en cada índice permitido. Para ello debemos precisar:

• ¿Cuál es el primer índice: 0, 1 u otro?
• ¿Qué índices pertenecen al dominio?
• ¿Cómo se calcula el término aₙ?
• Si la regla usa términos anteriores, ¿cuáles son los valores iniciales?
• ¿El procedimiento termina y produce un resultado único?

02 · Componentes de la definición

Regla, dominio y condiciones iniciales

La expresión algebraica es solo una parte. Compare estas definiciones:

Si no se declara el dominio, queda la duda de si n comienza en 0 o en 1. En n = 0 la división no está definida. Una versión completa es:

Nombre

Identifica la sucesión, por ejemplo (aₙ).

Dominio de índices

Declara qué valores puede tomar n.

Regla

Determina el valor asociado a cada índice.

Condiciones iniciales

Fijan los primeros términos cuando los demás dependen de ellos.

03 · Definición explícita

Calcular directamente el término n

Una fórmula es explícita cuando expresa aₙ en función del índice n, sin necesitar términos anteriores. Por ejemplo:

Esta sucesión comienza con 5, 8, 11, 14, …. Para obtener a₁₀₀₀ sustituimos directamente n = 1000; no hace falta calcular los 999 términos previos.

Ventaja computacional

Si la fórmula requiere una cantidad constante de operaciones, consultar un término cuesta aproximadamente lo mismo sin importar cuán grande sea n. Esta propiedad permite acceso directo.

04 · Definición recursiva

Construir cada término desde los anteriores

Una definición recursiva especifica uno o más términos iniciales y una regla para construir los siguientes. La sucesión anterior también puede escribirse:

La condición inicial inicia el proceso. Sin a₁ = 5, sabríamos que dos términos consecutivos difieren en tres, pero existirían infinitas sucesiones posibles.

Dependencia de más de un término

Fibonacci necesita dos condiciones iniciales porque la regla consulta dos posiciones anteriores:

Obtenemos 0, 1, 1, 2, 3, 5, 8, …. Cambiar cualquiera de los valores iniciales genera otra sucesión aunque mantengamos la misma recurrencia.

05 · Definición por casos

Usar una regla según el índice

Algunas sucesiones se describen naturalmente con reglas diferentes. Por ejemplo:

Para n ≥ 1 produce −1, 1, −3, 2, −5, 3, …. Los casos deben cubrir todo el dominio y no deben asignar resultados incompatibles al mismo índice.

function terminoPorCasos(n) {
  validarIndice(n, 1);
  return n % 2 === 0 ? n / 2 : -n;
}

function validarIndice(n, minimo) {
  if (!Number.isInteger(n) || n < minimo) {
    throw new RangeError(`n debe ser un entero mayor o igual que ${minimo}`);
  }
}

console.log(Array.from({ length: 6 }, (_, i) => terminoPorCasos(i + 1)));

La expresión n % 2 === 0 traduce la condición matemática «n es par». Definir por casos no significa improvisar: cada rama forma parte de una única función sobre los índices.

06 · Definición algorítmica

Cuando el procedimiento es la regla

No toda sucesión tiene una fórmula elemental conveniente. Puede definirse mediante un algoritmo que, dada la entrada n, produce un resultado único. Ejemplos:

• El número de bits iguales a 1 en la representación binaria de n.
• La cantidad de divisores positivos de n.
• El número de comparaciones que ejecuta un algoritmo con una entrada concreta de tamaño n.
• El valor generado en la iteración n de una simulación determinista.

function cantidadDeDivisores(n) {
  if (!Number.isInteger(n) || n < 1) throw new RangeError("Índice inválido");

  let cantidad = 0;
  for (let divisor = 1; divisor * divisor <= n; divisor += 1) {
    if (n % divisor === 0) {
      cantidad += divisor * divisor === n ? 1 : 2;
    }
  }
  return cantidad;
}

console.log(Array.from({ length: 10 }, (_, i) => cantidadDeDivisores(i + 1)));
// 1, 2, 2, 3, 2, 4, 2, 4, 3, 4

Una descripción algorítmica debe precisar entradas, pasos y salida. Si utiliza azar sin fijar su estado, una misma entrada podría producir valores diferentes y ya no definiría una sucesión determinista ordinaria.

07 · Cambiar de representación

Explícita y recursiva pueden describir lo mismo

Para justificar la fórmula explícita aritmética, expandimos la recurrencia:

La equivalencia exige que ambas definiciones usen el mismo índice inicial. La fórmula aₙ = a₀ + nd corresponde a una sucesión que comienza en 0; no debe mezclarse sin ajuste con a₁ + (n−1)d.

08 · Implementación

Programar definiciones explícitas y recursivas

Acceso directo con una fórmula

function terminoGeometrico(primerTermino, razon, n) {
  if (!Number.isInteger(n) || n < 1) throw new RangeError("Índice inválido");
  return primerTermino * razon ** (n - 1);
}

console.log(terminoGeometrico(4, 0.5, 8)); // 0.03125

Construcción iterativa desde una recurrencia

function primerosFibonacci(cantidad) {
  if (!Number.isInteger(cantidad) || cantidad < 0) {
    throw new RangeError("Cantidad inválida");
  }

  const terminos = [];
  if (cantidad >= 1) terminos.push(0);
  if (cantidad >= 2) terminos.push(1);
  for (let n = 2; n < cantidad; n += 1) {
    terminos.push(terminos[n - 1] + terminos[n - 2]);
  }
  return terminos;
}

console.log(primerosFibonacci(10));

El índice del arreglo coincide aquí con la convención F₀ = 0. Declarar esa coincidencia ayuda a evitar desplazamientos.

Recursión de código no es lo mismo que definición recursiva

Una recurrencia matemática puede implementarse con un bucle. Una función de JavaScript que se llama a sí misma es recursiva en sentido computacional, pero no es obligatoria:

function fibonacciLento(n) {
  if (n < 2) return n;
  return fibonacciLento(n - 1) + fibonacciLento(n - 2);
}

console.log(fibonacciLento(10)); // 55

Esta versión recalcula muchas veces los mismos valores y su costo crece muy rápido. La definición es clara, pero la implementación ingenua es ineficiente.

09 · Costo computacional

La representación influye en el algoritmo

Si necesitamos muchos términos recursivos, podemos conservar resultados. La memoización evita repetir cálculos:

function crearFibonacciMemoizado() {
  const memoria = [0, 1];
  return function fibonacci(n) {
    if (!Number.isInteger(n) || n < 0) throw new RangeError("Índice inválido");
    for (let i = memoria.length; i <= n; i += 1) {
      memoria[i] = memoria[i - 1] + memoria[i - 2];
    }
    return memoria[n];
  };
}

const fibonacci = crearFibonacciMemoizado();
console.log(fibonacci(10)); // 55
console.log(fibonacci(50)); // reutiliza los términos calculados

Guardar resultados consume memoria. La elección depende de si consultaremos términos aislados, un prefijo completo o muchos índices repetidos.

10 · Exploración

Laboratorio: una regla, dos representaciones

Elegí una familia y modificá sus parámetros. El laboratorio calcula el último término mediante fórmula explícita y también avanzando desde el valor inicial.

Los puntos representan términos discretos. El último se destaca para comparar el resultado de ambos métodos.

Preguntas para explorar

1. En la aritmética, ¿qué ocurre al usar una diferencia negativa o cero?
2. En la geométrica, probá razones negativas y observá los signos.
3. ¿Cambiar el índice modifica la regla o solo el término consultado?
4. ¿Por qué ambos métodos deben coincidir para todos los índices?

11 · Estrategia

Cómo elegir una representación

Una sucesión puede admitir varias definiciones equivalentes. La mejor no es necesariamente la más corta: es la que vuelve clara la propiedad que necesitamos estudiar y permite un cálculo adecuado.

12 · Comprensión

Confusiones frecuentes

13 · Práctica guiada

Ejercicios de comprensión

Ejercicio 1: completar definiciones

Indicá qué falta en cada caso: aₙ=1/(n−2); bₙ=bₙ₋₁+4; c=(2,4,8,…).

Ejercicio 2: dos representaciones

Una sucesión comienza en a₁=7 y cada término aumenta 5. Escribí definiciones recursiva y explícita, y calculá a₂₀.

Ejercicio 3: corregir índices

function termino(n) {
  return 3 * 2 ** (n - 1);
}
const primeros = Array.from({ length: 5 }, (_, n) => termino(n));

console.log(primeros); // [1.5, 3, 6, 12, 24]: comienza con n = 0

La función espera n≥1, pero el arreglo comienza en cero. Corregí la generación.

const termino = n => 3 * 2 ** (n - 1);
const primeros = Array.from(
  { length: 5 },
  (_, posicion) => termino(posicion + 1)
);
console.log(primeros); // [3, 6, 12, 24, 48]

Ejercicio 4: diseñar una recurrencia

Una cuenta tiene saldo inicial de 1000 y cada mes aumenta un 2 % y luego recibe un depósito fijo de 50. Definí la sucesión desde n=0 e implementá los primeros doce meses.

const saldos = [1000];
for (let n = 1; n <= 12; n += 1) {
  saldos[n] = 1.02 * saldos[n - 1] + 50;
}
console.log(saldos);

14 · Síntesis

Ideas para recordar

En el próximo tema aprenderemos a generar y visualizar sucesiones con JavaScript mediante tablas, arreglos, generadores y gráficos discretos.