Derivar funciones polinómicas es una de las operaciones más básicas en cálculo, pero también una excelente forma de entender cómo representar y manipular expresiones matemáticas en código.
En este artículo veremos cómo construir un programa en Java 21 capaz de recibir un polinomio introducido por el usuario y devolver su derivada simbólica.

El objetivo no es usar librerías matemáticas externas, sino aprovechar expresiones regulares, manipulación de cadenas y las características modernas del lenguaje para construir una solución directa y legible.

Concepto matemático

La derivada de un polinomio se calcula aplicando la regla general:

Por ejemplo:

El algoritmo debe reconocer los coeficientes, exponentes y signos de cada término para luego aplicar esta transformación.

Código completo

import java.util.*;
import java.util.regex.*;

public class DerivadaPolinomio {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Ingrese un polinomio (ejemplo: 3x^3 - 2x^2 + x - 5): ");
        String input = sc.nextLine().replaceAll("\\s+", "");
        sc.close();

        String derivada = derivarPolinomio(input);
        System.out.println("Derivada: " + derivada);
    }

    private static String derivarPolinomio(String polinomio) {
        List<String> terminos = dividirTerminos(polinomio);
        List<String> resultado = new ArrayList<>();

        for (String termino : terminos) {
            String derivado = derivarTermino(termino);
            if (!derivado.isEmpty()) resultado.add(derivado);
        }

        String derivada = String.join(" ", resultado)
                .replaceAll("\\+ -", "- ")
                .replaceAll("\\s+", " ");
        return derivada.isEmpty() ? "0" : derivada.trim();
    }

    private static List<String> dividirTerminos(String polinomio) {
        List<String> terminos = new ArrayList<>();
        Matcher m = Pattern.compile("([+-]?[^+-]+)").matcher(polinomio);
        while (m.find()) terminos.add(m.group());
        return terminos;
    }

    private static String derivarTermino(String termino) {
        if (!termino.contains("x")) return "";

        double coeficiente = 1.0;
        int exponente = 1;

        Matcher m = Pattern.compile("([+-]?\\d*(?:\\.\\d+)?)x(?:\\^(\\d+))?").matcher(termino);
        if (m.matches()) {
            String coefStr = m.group(1);
            String expStr = m.group(2);

            if (!coefStr.isEmpty() && !coefStr.equals("+") && !coefStr.equals("-"))
                coeficiente = Double.parseDouble(coefStr);
            else if (coefStr.equals("-"))
                coeficiente = -1.0;

            if (expStr != null)
                exponente = Integer.parseInt(expStr);
        }

        double nuevoCoef = coeficiente * exponente;
        int nuevoExp = exponente - 1;

        if (nuevoExp == 0)
            return formatearNumero(nuevoCoef);
        else if (nuevoExp == 1)
            return formatearNumero(nuevoCoef) + "x";
        else
            return formatearNumero(nuevoCoef) + "x^" + nuevoExp;
    }

    private static String formatearNumero(double num) {
        if (num == (int) num) return String.valueOf((int) num);
        return String.valueOf(num);
    }
}

Explicación paso a paso

1. Entrada del usuario
   Se lee el polinomio en formato texto y se eliminan los espacios para procesar cada término de forma limpia.

2. División de términos
   Se usa una expresión regular ([+-]?[^+-]+) para capturar cada bloque que representa un término, incluyendo su signo.

3. Derivación de cada término
   Se identifica el coeficiente y exponente usando Matcher y se aplica la regla

   

4. Formateo de salida
   Se reconstruye el polinomio derivado, limpiando signos redundantes y simplificando los casos donde el exponente resultante sea 0 o 1.

Ejemplo de ejecución

Entrada:

3x^3 - 2x^2 + x - 5

Salida:

Derivada: 9x^2 - 4x + 1