Dado un vector mostrar el inverso

Aquí te muestro un ejemplo de cómo calcular el inverso de un vector en Java:

```java
public class Main {

    public static void main(String[] args) {
        double[] vector = {1, 2, 3, 4, 5};
        double[] inverso = calcularInverso(vector);

        System.out.println("Vector original: ");
        imprimirVector(vector);

        System.out.println("Inverso del vector: ");
        imprimirVector(inverso);
    }

    public static double[] calcularInverso(double[] vector) {
        int n = vector.length;
        double[] inverso = new double[n];

        // Calcular el determinante
        double determinante = calcularDeterminante(vector);

        // Verificar si el determinante es cero
        if (determinante == 0) {
            System.out.println("El vector no tiene inverso");
            return null;
        }

        // Calcular el inverso
        for (int i = 0; i < n; i++) {
            inverso[i] = calcularCofactor(vector, i) / determinante;
        }

        return inverso;
    }

    public static double calcularDeterminante(double[] vector) {
        int n = vector.length;
        double determinante = 0;

        if (n == 2) {
            determinante = vector[0] * vector[1] - vector[1] * vector[0];
        } else {
            for (int i = 0; i < n; i++) {
                double[][] subMatriz = new double[n - 1][n - 1];
                int k = 0;
                for (int j = 1; j < n; j++) {
                    int l = 0;
                    for (int h = 0; h < n; h++) {
                        if (h != i) {
                            subMatriz[k][l] = vector[h];
                            l++;
                        }
                    }
                    k++;
                }
                determinante += Math.pow(-1, i) * vector[i] * calcularDeterminante(subMatriz);
            }
        }

        return determinante;
    }

    public static double calcularCofactor(double[] vector, int i) {
        int n = vector.length;
        double cofactor = 0;
        double[][] subMatriz = new double[n - 1][n - 1];
        int k = 0;
        for (int j = 1; j < n; j++) {
            int l = 0;
            for (int h = 0; h < n; h++) {
                if (h != i) {
                    subMatriz[k][l] = vector[h];
                    l++;
                }
            }
            k++;
        }
        cofactor = Math.pow(-1, i) * calcularDeterminante(subMatriz);
        return cofactor;
    }

    public static void imprimirVector(double[] vector) {
        for (double elemento : vector) {
            System.out.print(elemento + " ");
        }
        System.out.println();
    }
}
```

Este código calcula el inverso de un vector de tamaño n, donde n es un número entero mayor o igual a 2. El algoritmo utilizado es el de Gauss-Jordan, que es una forma de calcular el inverso de una matriz cuadrada.

El código consta de varias funciones:

*   `calcularInverso`: Calcula el inverso de un vector.
*   `calcularDeterminante`: Calcula el determinante de una matriz cuadrada.
*   `calcularCofactor`: Calcula el cofactor de un elemento en una matriz cuadrada.
*   `imprimirVector`: Imprime un vector en la consola.

El código utiliza un enfoque iterativo para calcular el inverso del vector, lo que lo hace más fácil de entender y mantener. Sin embargo, es importante tener en cuenta que el algoritmo utilizado tiene una complejidad de tiempo de O(n!), lo que significa que puede ser lento para vectores de tamaño grande.

Es importante mencionar que el código asume que el vector de entrada es una matriz cuadrada, es decir, que tiene la misma cantidad de filas y columnas. Si el vector no es cuadrado, el código no funcionará correctamente.