Hi peoples, criei uma condição simples para soma de arrays do tipo int que funciona perfeitamente para o que eu preciso, mas eu gostaria de criar uma solução recursiva porém não tenho idéia de como fazer isso.
Será que alguém pode me ajudar nessa parte de recursividade que sou péssimo.
Já adianto que isso não é nenhum exercício de faculdade é apenas para que eu possa entender outras soluções.
Valeu.
public static void somaArray(int[]...arrayInt) {
int iterator = arrayInt.length;
int soma = 0;
for (int i = 0; i < iterator; i++) {
for (int j = 0; j < arrayInt[i].length; j++) {
soma += arrayInt[i][j];
}
}
System.out.println(soma);
}
//public static int somaArrayRecursivo(int[]...arrayInt) {}
public static void main(String[] args) {
int[]i1 = {5,1};
int[]i2 = {1,1,1,1,1};
somaArray(i1, i2);
}
Não é por nada não, mas métodos recursivos não funcionam muito bem com arrays, e sim com algumas linguagens mais orientadas a listas (onde você pode definir uma sublista que é um pedaço de uma lista, que tem um elemento a menos).
Entendi thanks pela dica mas é que a dificuldade de fazer isso para mim é tão grande que estou empenhado a entender e ver se encontro uma solução recursiva para isso até mesmo porque gosto de conhecer outras soluções para o mesmo problema independente se é otmizado ou não, o bom é conhecer bem o que se faz hoje em dia de diversas formas, e isso é mais um desafio que estou enfrentando e gostaria de passar por ele com a ajuda que vier.
[quote=CyberX]Entendi thanks pela dica mas é que a dificuldade de fazer isso para mim é tão grande que estou empenhado a entender e ver se encontro uma solução recursiva para isso até mesmo porque gosto de conhecer outras soluções para o mesmo problema independente se é otmizado ou não, o bom é conhecer bem o que se faz hoje em dia de diversas formas, e isso é mais um desafio que estou enfrentando e gostaria de passar por ele com a ajuda que vier.
[quote=CyberX]Hi peoples, criei uma condição simples para soma de arrays do tipo int que funciona perfeitamente para o que eu preciso, mas eu gostaria de criar uma solução recursiva porém não tenho idéia de como fazer isso.
Será que alguém pode me ajudar nessa parte de recursividade que sou péssimo.
Já adianto que isso não é nenhum exercício de faculdade é apenas para que eu possa entender outras soluções.
Valeu.
public static void somaArray(int[]...arrayInt) {
int iterator = arrayInt.length;
int soma = 0;
for (int i = 0; i < iterator; i++) {
for (int j = 0; j < arrayInt[i].length; j++) {
soma += arrayInt[i][j];
}
}
System.out.println(soma);
}
//public static int somaArrayRecursivo(int[]...arrayInt) {}
public static void main(String[] args) {
int[]i1 = {5,1};
int[]i2 = {1,1,1,1,1};
somaArray(i1, i2);
}
Tks.[/quote]
Com esse código que fiz dar para você continuar e fazer o resto. Este que fiz resolve para uma dimensão, para maiores vai ter colocar mais parâmetros no método e alterá-lo. Essa é uma coisa chata quando se usa recursão, mas acho um ótimo exercício! Fazia tempo que não mexia com esses conceitos!
public class Main {
public static int somarArrayRec(int a[],int indice,int tamanho,int somar){
int somatorio = (a[indice]=a[indice]+somar);
if(indice < tamanho-1){
return somarArrayRec(a,indice+1,tamanho,a[indice]);
}
return somatorio;
}
public static void main(String[] args) {
int a[]={1,2,3,4,5};
System.out.println( somarArrayRec(a,0,a.length,0));
}
}
Vamos tentar com algo mais simples (a essência de criar algoritmos recursivos é partir do caso mais simples e ver se, por indução, você consegue resolver o caso complicado.
Vamos somar um vetor unidimensional recursivamente.
Como sabemos, de antemão, que não é fácil criar listas com um elemento a menos em Java, vamos então usar uma outra abordagem.
A primeira coisa é definir os casos extremos e mais simples:
A soma de um vetor vazio é zero.
A soma de um vetor de um elemento é esse próprio elemento, ou seja, vetor[0].
A segunda coisa é definir o que fazer no caso de indução (ou seja, você tem um problema menor e quer saber como resolver o problema maior a partir dele).
No caso de um vetor:
A soma de um vetor que vai de 0 até N - 1 é igual ao primeiro elemento mais a soma do vetor que vai de 1 até N - 1.
Isso seria algo como:
class SomaRecursiva {
public static int soma (int[] vetor, int inicio) {
if (inicio >= vetor.length)
return 0; // "a soma de um vetor vazio é zero"
else if (inicio - 1 == vetor.length)
return vetor[inicio]; // a soma de um vetor de um elemento é o próprio elemento"
else
return vetor[inicio] + soma (vetor, inicio + 1);
}
public static void main (String[] args) {
int[] vetor = {1, 2, 3, 4};
System.out.println (soma (vetor, 0)); // deve resultar 10
}
}
Você viu que, como em Java não é trivial representar uma lista que tem um elemento a menos, eu tive de passar um parâmetro chamado “inicio” que indica a partir de onde eu quero começar a olhar o vetor. Não consegui um mapeamento muito direto do algoritmo em si para a linguagem.
E é por isso que certas coisas são meio difíceis de representar em Java, porque ela não é uma linguagem muito adequada para representar essas relações recursivas.
:lol: :lol: :lol:
O meu tá mais enxuto, mas tem mais parâmetros!! :lol: :lol: :lol:
[code]
public class Main {
public static int somarArrayRec(int a[],int indice,int tamanho,int somar){
int somatorio = (a[indice]=a[indice]+somar);
if(indice < tamanho-1){
return somarArrayRec(a,indice+1,tamanho,a[indice]);
}
return somatorio;
}
public static void main(String[] args) {
int a[]={1,2,3,4,5};
System.out.println( somarArrayRec(a,0,a.length,0));
}
[quote=fabioEM]
O meu tá mais enxuto, mas tem mais parâmetros!! :lol: :lol: :lol: [/quote]
Sei. O seu destrói o array de entrada e o meu não. Você gostaria de ter um efeito colateral desses (um método que calcule a soma e também bagunçasse o array de entrada)?
[quote=entanglement]Vamos tentar com algo mais simples (a essência de criar algoritmos recursivos é partir do caso mais simples e ver se, por indução, você consegue resolver o caso complicado.
Vamos somar um vetor unidimensional recursivamente.
Como sabemos, de antemão, que não é fácil criar listas com um elemento a menos em Java, vamos então usar uma outra abordagem.
A primeira coisa é definir os casos extremos e mais simples:
A soma de um vetor vazio é zero.
A soma de um vetor de um elemento é esse próprio elemento, ou seja, vetor[0].
A segunda coisa é definir o que fazer no caso de indução (ou seja, você tem um problema menor e quer saber como resolver o problema maior a partir dele).
No caso de um vetor:
A soma de um vetor que vai de 0 até N - 1 é igual ao primeiro elemento mais a soma do vetor que vai de 1 até N - 1.
Isso seria algo como:
class SomaRecursiva {
public static int soma (int[] vetor, int inicio) {
if (inicio >= vetor.length)
return 0; // "a soma de um vetor vazio é zero"
else if (inicio - 1 == vetor.length)
return vetor[inicio]; // a soma de um vetor de um elemento é o próprio elemento"
else
return vetor[inicio] + soma (vetor, inicio + 1);
}
public static void main (String[] args) {
int[] vetor = {1, 2, 3, 4};
System.out.println (soma (vetor, 0)); // deve resultar 10
}
}
Você viu que, como em Java não é trivial representar uma lista que tem um elemento a menos, eu tive de passar um parâmetro chamado “inicio” que indica a partir de onde eu quero começar a olhar o vetor. Não consegui um mapeamento muito direto do algoritmo em si para a linguagem.
E é por isso que certas coisas são meio difíceis de representar em Java, porque ela não é uma linguagem muito adequada para representar essas relações recursivas. [/quote]
Já estava partindo desse princípio já havia feito a soma dos valores de um array recursivamente consegui fazer sem maiores problemas, diga-se de passagem foi bem fácil o problemas mesmo era com array bidimensionais, mas estou tentando e assim que eu chegar à um resultado postarei aqui.
Tks.
[quote=entanglement][quote=fabioEM]
O meu tá mais enxuto, mas tem mais parâmetros!! :lol: :lol: :lol: [/quote]
Sei. O seu destrói o array de entrada e o meu não. Você gostaria de ter um efeito colateral desses (um método que calcule a soma e também bagunçasse o array de entrada)? [/quote]
[quote=fabioEM]Bom já que se não postou a solução, está aí a minha para o array de 2 dimensões! Aproveitei e coloquei a de um também!
public class Main {
/*Método sobrecarregado para somar recursivamente array bidimensional
*/
public static int somarArrayRec(int a[][],int indexLinha,int indexColuna,int somar){
int somatorio = a[indexLinha][indexColuna]+somar;
if(indexLinha < a.length-1 ){
return somarArrayRec(a,indexLinha+1,indexColuna,somatorio);
}else{
indexLinha=0;
if(indexColuna < a[indexLinha].length-1){
return somarArrayRec(a,indexLinha,indexColuna+1,somatorio);
}
}
return somatorio;
}
/*soma recursivamente array de uma dimensão
*/
public static int somarArrayRec(int a[],int indice,int somar){
int somatorio = (a[indice]+somar);
if(indice < a.length-1){
return somarArrayRec(a,indice+1,somatorio);
}
return somatorio;
}
public static void main(String[] args) {
int b[][]= new int[][]{{1,1},
{1,1},
{1,9}};
System.out.println("total "+ somarArrayRec(b,0,0,0));
for(int i=0;i<b.length;i++){
for(int y=0;y<b[i].length;y++){
System.out.println(""+ b[i][y]);
}
}
}
}
Modéstia a pates mas tá show, código simples e enxuto! :lol: :lol: :lol: :lol: :lol:
>[/quote]
Muito interessante sua solução valeu por compartilhar.
O único detalhe é que só funciona para arrays com os mesmos tamanhos se eu adicionar mais uma posição no array o resultado é o mesmo se for na posição 1 ou ocorre erro na posição 0.
Mas valeu mesmo por compartilhar.
Darei uma olhada e entenderei como funciona melhor a recursividade.
CyberX
Bom eu olhei o tópico “Bidimensional”=duas dimensões.
Agora, para fazer para X dimensões o buraco é mais embaixo. Mas te passo a bola da vez! :lol: