Proceso recursivo para determinar cuantos dígitos pares ocupan posiciones impares (Java)

 

Problema:

Dado un numero entero n, escribir un proceso recursivo para determinar cuantos dígitos pares ocupan posiciones impares en n. Ej.: para n = 22005 el resultado es 2. Para n = 201414 , el resultado es 1.

Explicación:

2    2    0    0    5

1    2    3    4    5

el resultado es 2 porque 2 y 0 se encuentran en dígitos pares

2    0    1    4    1    4

1    2    3    4    5    6

el resultado es 1 porque 2 se encuentra en la posición 1

Para resolver este ejercicio es necesario utilizar varios métodos recursivos como se muestra a continuación:

    public static void main(String[] args) {        
       
        System.out.println(digitosParesEnImpares(201414));
    }
    
    public static int digitosParesEnImpares(int numero){
        boolean inicioImpar=esInicioImpar(numero);
        return digitosParesEnImpares(numero,inicioImpar);
    }    
    

    public static boolean esInicioImpar(int numero){
        if (numero==0){
            return false;
        }
        numero=numero/10;
        return !esInicioImpar(numero);
    }
    
    public static int digitosParesEnImpares(int numero, boolean flag{
        if (numero==0){

            return 0;
        }
        int aux=numero%10;
        numero=numero/10;
        if (aux%2==0&&flag){
            return digitosParesEnImpares (numero,!flag)+1;
        }else{
            return digitosParesEnImpares (numero,!flag);
        }
    }

El metodo digitosParesEnImpares (int numero) gestiona el flujo de las llamadas

• Primero, determina si la posición más baja del número es impar llamando a esInicioImpar(numero). El resultado se guarda en la variable inicioImpar.
• Luego, llama al método recursivo digitosParesEnImpares(numero, inicioImpar) que hará el conteo de los dígitos pares en posiciones impares.

El metodo esInicioImpar determina si el digito inicial es true o false

• Si el número es 0, retorna false, ya que no hay más dígitos.
• Si no, divide el número entre 10 para eliminar el dígito menos significativo y llama recursivamente a esInicioImpar(numero). La negación (!) indica que alterna entre las posiciones, dado que cada vez que eliminamos un dígito, cambiamos de posición par a impar, o de impar a par.

El método digitosParesEnImpares realiza el conteo de los dígitos pares en posiciones impares

• Si numero es 0, se detiene la recursión y retorna 0 (condición base).
• Toma el dígito menos significativo (aux = numero % 10).
• Divide el número entre 10 (numero = numero / 10) para quitar el dígito actual.
• Si el dígito (aux) es par (aux % 2 == 0) y la posición actual es impar (flag es true), suma 1 al resultado de la llamada recursiva.
• Si no, solo llama recursivamente sin sumar, pero invierte el valor del flag para alternar entre posiciones pares e impares.