domingo, 21 de octubre de 2012

Algoritmo recursivo en Java para descomponer un número en sus factores primos

Este es el algoritmo para descomponer un numero dado en sus factores primos:


import java.util.Scanner;

/**
 * @date
 * @author Wilmer Lopez
 */
public class ProgramacionV {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        Scanner leer = new Scanner(System.in);
        System.out.println("Ingrese un numero");
        int m = leer.nextInt();
        System.out.println("Los factores primo son:");
        FactoresPrimos(m);
        System.out.println("\n");
    }
 
    /**
     *
     * @param n
     */
    public static void FactoresPrimos(int n){
        if (esPrimo(n)){
         System.out.print("*"+n+" ");
         return;
        }
        int factor1 = (int) Math.sqrt(n);
        while (n % factor1 !=0) {
            factor1++;
        }
        FactoresPrimos(factor1);
        FactoresPrimos(n/factor1);

    }
 
    /**
     *
     * @param numero
     * @return
     */
    public static boolean esPrimo(int numero){
        int contador = 2;
        boolean primo=true;
        while ((primo) && (contador!=numero)){
          if (numero % contador == 0) {
                primo = false;
            }
          if (numero == 1) {
                primo = true;
                return primo;
            }
          contador++;
        }
        return primo;
  }

}

2 comentarios:

  1. tienes un while en una funcion recursiva ?!?!?!?!?!

    public class Ej4
    {
    ArrayList nums=new ArrayList();
    public void task(int num)
    {
    int lim=(int)(Math.sqrt(num));
    if(Esprimo(num))
    {
    nums.add(1);
    nums.add(num);
    }
    else
    {
    task(num,lim,2);
    }
    prin();
    }
    private void task(int num,int lim,int div)
    {
    if(div<=lim)
    {
    if(Esprimo(num))
    {
    nums.add(num);


    }
    else
    {
    if(num%div==0)
    {
    nums.add(div);
    task(num/div,lim,div);

    }
    else
    {
    task(num,lim,++div);
    }
    }
    }

    }
    private boolean Esprimo(int num, int div)
    {
    boolean res=true;
    if(div>1&&res==true)
    {
    if((num%div)==0)
    {
    res=false;
    }
    else
    {
    res= Esprimo(num,div-1);
    }
    }
    return res;
    }
    boolean Esprimo(int num)
    {
    int aux;
    aux = (int)(Math.sqrt(num));
    boolean resultado = true;
    return Esprimo(num, aux);
    }
    public void agregar(int num)
    {
    nums.add(num);
    }
    public void prin()
    {
    for(int i=0;i<nums.size();i++)
    {
    System.out.println(nums.get(i));
    }
    }


    public static void main(String args[])throws IOException
    {
    BufferedReader scan=new BufferedReader(new InputStreamReader(System.in));
    Ej4 oz=new Ej4();
    int num=Integer.parseInt(scan.readLine());

    oz.task(num);

    }
    }

    ResponderEliminar
  2. Es recursivo cuando se utiliza para realizar una llamada a una función desde la misma función.

    ResponderEliminar