algoritmo combinatorial recursivo

24/03/2017

0

Saudações,
Preciso converter um algoritmo iterativo com parâmetros estáticos em um combiantorial com parâmetro dinâmico.
O exemplo é esse:

    public class UmParDeInteiros{
        public int de;
        public int ate;

        public UmParDeInteiros(int i, int j){
            this.de = i;
            this.ate = j;
        }
    }
    
    //em main()
    ArrayList<UmParDeInteiros> UmArrayDeParDeInteiros;

    //combinação a 3 em algoritmo iterativo parametros estaticos
    for(int s1de=0; s1de<2; s1de++){//entrada
        for(int s1ate=4; s1ate<7; s1ate++){//internos
            UmArrayDeParDeInteiros.add(new UmParDeInteiros(s1de,s1ate));
            for(int s2de=0; s2de<2; s2de++){//entrada
                for(int s2ate=4; s2ate<7; s2ate++){//internos
                    UmArrayDeParDeInteiros.add(new UmParDeInteiros(s2de,s2ate));
                    for(int s3de=0; s3de<2; s3de++){//entrada
                        for(int s3ate=4; s3ate<7; s3ate++){//internos
                            UmArrayDeParDeInteiros.add(new UmParDeInteiros(s3de,s3ate));
                            for(UmParDeInteiros s:UmArrayDeParDeInteiros){
                                System.out.print("("+s.de+","+s.ate+")");
                            }
                            System.out.println();
                            UmArrayDeParDeInteiros.remove(UmArrayDeParDeInteiros.size()-1);
                        }
                    }
                    UmArrayDeParDeInteiros.remove(UmArrayDeParDeInteiros.size()-1);
                }
            }
            CombLayerDeEntrada.remove(UmArrayDeParDeInteiros.size()-1);
        }
    }


/*SAIDA
(0,4)(0,4)(0,4)
(0,4)(0,4)(0,5)
(0,4)(0,4)(0,6)
(0,4)(0,4)(1,4)
(0,4)(0,4)(1,5)
(0,4)(0,4)(1,6)
(0,4)(0,5)(0,4)
(0,4)(0,5)(0,5)
(0,4)(0,5)(0,6)
.......
*/

   
    //combinação a 2 em algoritmo iterativo parametros estaticos
    for(int s1de=0; s1de<2; s1de++){//entrada
        for(int s1ate=4; s1ate<7; s1ate++){//internos
            UmArrayDeParDeInteiros.add(new UmParDeInteiros(s1de,s1ate));
            for(int s2de=0; s2de<2; s2de++){//entrada
                for(int s2ate=4; s2ate<4; s2ate++){//internos
                    UmArrayDeParDeInteiros.add(new UmParDeInteiros(s2de,s2ate));
                    for(UmParDeInteiros s:UmArrayDeParDeInteiros){
                        System.out.print("("+s.de+","+s.ate+")");
                    }
                    System.out.println();
                    UmArrayDeParDeInteiros.remove(UmArrayDeParDeInteiros.size()-1);
                }
            }
            CombLayerDeEntrada.remove(UmArrayDeParDeInteiros.size()-1);
        }
    }


Estou tentando fazer um algoritmo recursivo com parametros pra este problema,
porque a solução combinatorial parece que é mais natural pra recursividade, a entrada pode variar,
por exemplo, combinação de 5 3 a 3, combinacao de 10 8 a 8, etc
porem não obtive sucesso ate agora. Alguém, pode ajudar com uma solução? Pode ser em c, c++ ou
qualquer linguagem parecida.
Obrigado.
Aquiles Braganca

Aquiles Braganca

Responder

Assista grátis a nossa aula inaugural

Assitir aula

Saiba por que programar é uma questão de
sobrevivência e como aprender sem riscos

Assistir agora

Utilizamos cookies para fornecer uma melhor experiência para nossos usuários, consulte nossa política de privacidade.

Aceitar