Problemas com Arranjos em Java

[paulo raposo]

Prezados amigos,

 

Estou tendo problemas de arranjos em java e nao consigo executar estes 3 problemas abaixo, poderiam ajudar-me, por favor ? Se conhecerem, me informem a fonte destes problemas para estudar os demais das listas que devem existir. Obrigado

 

Ex. 1-Escreva um método chamado contagemElementos que receba como parâmetro
um arranjo de inteiros chamado valores e um inteiro chamado x e
retorna o número de vezes que o valor x aparece dentro do arranjo valores.
Implemente uma solução que iteraja pelos elementos do arranjo
(e não pelos índices)

 

Ex-2-Escreva um método chamado contagemMaior que recebe dois arranjos
de inteiros como parâmetros (chamados arranjo1 e arranjo2), encontra o
valor do maior elemento do arranjo1, veri1ca quantas vezes esse valor
ocorre no arranjo2 e imprime uma frase da seguinte forma:
O numero yyy aparece zzz vezes no arranjo2.

 

Ex.3-Escreva um método chamado contagemTodos que recebe dois arranjos
de inteiros como parâmetros (chamados arranjo1 e arranjo2), e para cada
elemento do arranjo1 veri1ca quantas vezes esse elemento ocorre no
arranjo2 e imprime uma frase da seguinte forma:
O numero yyy aparece zzz vezes no arranjo2.

 

[dcm50]

solução 1: fazer um laço de FOR de i até o tamanho do array e, dentro do laço, comparar o valor de cada elemento com o valor de x. Se for igual, adiciona +1 ao contador.

 

solução 2: fazer um laço de FOR para cada arranjo e verificar qual é o maior valor do arranjo1. Guarde esse valor numa variável para comparar com os elementos do arranjo2 e adicionar +1 ao contador quando necessário

 

solução 3: fazer um laço de FOR dentro de outro laço de FOR, comparar os elementos de cada índice e adicionar ao contador quando necessário.

[paulo raposo]

 DCM 50, muito obrigado !!

 

Posso abusar das suas respostas ?

Vou estudá-las e montar as sentenças logicas, poderia depois me ajudar a verificar se estão certas ?

 

Abraços.

Paulo

[dcm50]

claro, pode mandar!

[paulo raposo]

 

Ola amigo DCM 50, boa tarde,

Seguem as respostas, porém tenho dificuldade em sentenças, poderia por favor ajudar-me ?

 

solução 1: fazer um laço de FOR de i até o tamanho do array e, dentro do laço, comparar o valor de cada elemento com o valor de x. Se for igual, adiciona +1 ao contador.

 

/*Escrevendo um método chamado contagemElementos que receba como parâmetro
um arranjo de inteiros chamado valores e um inteiro chamado x */

 

static int contagemElementos (int [] arranjo, int x) {

 

// pega cada elemento da array de indice i até a  largura total de elementos do array

   for (int i =0 ;  i <= n.lenght; i++ )  {

 

//compara o numero de cada elemento da array com o numero inteiro x

    if (n == x)

 

//quando faz esta comparação , nao sei como adicionar 1 ao contador

 

System.out.println (" Existem" ??? " numeros de vezes que x aparece dentro do arranjo de valores) ; }

}

}

###############################################################################################

solução 2: fazer um laço de FOR para cada arranjo e verificar qual é o maior valor do arranjo1. Guarde esse valor numa variável para comparar com os elementos do arranjo2 e adicionar +1 ao contador quando necessário

 

/*Escreva um método chamado contagemMaior que recebe dois arranjos
de inteiros como parâmetros (chamados arranjo1 e arranjo2)*/

 

static int contagemMaior (int [] arranjo1, int [] arranjo 2) {

 

//fazendo um laço for para cada arranjo e verificando qual o maior valor do arranjo 1

 

//copiei esta sentença para achar o maior valor do arranjo 1, mas nao sei exatamente como a sentença acha o maior valor, poderia me explicar ?

int max = arranjo 1[]

  for (int=1, i< arranjo1.lenght, i++)

   (if arranjo 1 > max)

        max = arranjo ;

 

//nao sei como guardar na memoria. , chamarei este valor de y.

 

"comparar com os elementos do arranjo2 e adicionar +1 ao contador quando necessário"

 

// pega cada elemento arranjo 2 e compara com y

   for (int i =0 ;  i <= arranjo2.lenght; i++ )  {

 

//compara o numero de cada elemento do arranjo 2 com y

    if (n == y)

 

//quando faz esta comparação , nao sei como adicionar 1 ao contador

 

System.out.println (" O numero yyy aparece zzz vezes no arranjo2.") ;  }

}

}

###################################################################################################

  solução 3: fazer um laço de FOR dentro de outro laço de FOR, comparar os elementos de cada índice e adicionar ao contador quando necessário.

 

//Escreva um método chamado contagemTodos que recebe dois arranjos
de inteiros como parâmetros (chamados arranjo1 e arranjo2)

 

static int contagemTodos (int [] arranjo1, int [] arranjo 2) {

 

//criação do for para o arranjo1 e arranjo 2 e comparar os elementos

for (int=1, i< arranjo1.lenght, i++)

   for (int=1, i< arranjo2.lenght, i++)

// nao sei como como comparar cada indice e saber quais elementos do arranjo 1 sao iguais do arranjo 2...???

 

##############################################################################################

 

Please help me !

 

 

 

 

   

[dcm50]

//solução 1

public int contagemElemento (int [] arranjo, int x){
  int cont = 0; //aqui esta o seu contador
  for (int i=0; i<arranjo.lenght; i++){
    if (x == arranjo[i]){
      cont++; //aqui está adicionando +1 ao teu contador
    }
  return x;
}
//--------------
  
//solução 2
public void contagemMaior (int [] arranjo1, int [] arranjo2){
  int maior = 0;
  int cont = 0;
  
  for (int i = 0; i<arranjo1.lenght; i++){
    if (arranjo1[i] > maior){
      maior = arranjo[i];
    }
  }
  
  for (int j = 0; j<arranjo2.lenght; j++){
  	if (maior == arranjo2[j]){
      cont++;
    }
  }  
  System.out.println("O número "+maior+" aparece "+cont+" vezes no arranjo2");
}
  
  
//--------------

//solução 3
public void contagemMaior(int [] arranjo1, int [] arranjo2){
  int cont;
  
  for(int i = 0; i<arranjo1.lenght; i++){
    cont = 0;
    for (int j = 0; j<arranjo2.lenght; j++){
      if (arranjo1[i] == arranjo2[j]){
        cont++;
      }
      System.out.println("O número "+arranjo[i]+" aparece "+cont+" vezes no arranjo2");
    }
  }
}

      
        
  

@paulo raposo tão aí as soluções

[paulo raposo]

Muitissimo obrigado, agora vou estudar cada passo destes.

[dcm50]

não sei se estão 100% certos.

se tiver algo errado ou que tu nao tenha entendido, me avise

[paulo raposo]

obrigado, tentarei compilar

[dcm50]

arrumei a solução 3, eu tinha feito um negocio errado e ajustei.

[paulo raposo]

Ola DCM50, como vai ?

 

Esta semana, estou estudando array de array, arranjo de arranjo como uma matriz de (i) linhas e (j) colunas e tenho alguns exercicios propostos que, por favor, gostaria muito pudesse me corrigir, como fizestes na semana passada . Para teres ideia, foi de imenso valor para meus estudos, por isso te agradeço do fundo do coração.

 

Exercicio 01

Escreva um método chamado contaCaracteres que recebe como parâmetro um arranjo de arranjos de caracteres chamado palavras (o qual representa um conjunto de palavras) e deverá retornar o número total de caracteres presentes nesse arranjo de arranjos.

// indices i e j sao linhas e colunas do arranjo do arranjo palavras

static contaCaracteres (char [ ] [ ] palavras,)  {
   int c;
     c== (palavras [ i ]) * (palavras  [ j ]);
        return (+ c) ;

                                }

 

Exercicio 02

Escreva um método chamado contaLetra que recebe como parâmetros um arranjo de arranjos de caracteres chamado palavras e um caractere chamado letra e deverá retornar a quantidade de vezes que o caractere
letra aparece dentro do arranjo de arranjos.

 

// indices i e j sao linhas e colunas do arranjo do arranjo palavras

static contaLetra (char [ ] [ ] palavras, char  letra)  {
int c=0;
int d=0;
int total ;
for (char letra [ i] [j] =0 ;  i <= char letra [j] . lenght ; i ++) {
  if (char [j] == letra) c++;
                                               }
return (c++);
                                                                           } 

Exercicio 03

Escreva um método chamado avaliaMatriz que receba como parâmetro uma matriz bidimensional de elementos do tipo double (chamada matriz) e imprime três valores (um por linha): a média de todos os elementos da matriz, o menor valor da matriz e o maior valor da matriz. Você pode assumir que a referência à matriz passada como parâmetro terá valor
diferente de null e que a respectiva matriz terá mais de um elemento. Dica: você só precisará percorrer a matriz inteira uma única vez para realizar essas operações.

 

// carrega os valores da matriz com i linhas e j colunas
public static void avaliaMatriz (double [ ] [ ] matriz ) {
  double media;
  int c=0  ;
  double menor=0;
  double maior=0;
  double soma=0 ;
   for ( double [j] matriz =0 , matriz [j] <= matriz [j].lenght, matriz [j] ++) c++  { { {
            if (matriz [j] < menor  );
              menor  == matriz [j]; }
           if (matriz [j] > maior );
                  maior== matriz [j]; } 
           soma= soma+ matriz ]j];
             }
      media = soma/c++ ;
System.out.println (" A media de todos os elementos da matriz é igual a " /t +media);
System.out.println (" O menor valor da matriz é igual a " /t +menor);
System.out.println (" O maior valor da matriz é igual a " /t +maior);
}   
                } 

 

Exercicio 04

Escreva um método chamado soma3 que receba como parâmetros três matrizes de inteiros (chamadas m1, m2 e m3) e retorna null caso essas matrizes tenham dimensões diferentes. Caso contrário, deverá criar e retornar a referência a matriz correspondente a soma das três matrizes passadas como parâmetro.

 

public static void soma3 (int [ ] [ ] m1, int [ ] [ ] m2, int [ ] [ ] m3) {
    if ( m1 != m2 != m3) ;
      return (null);
       else
        int m4 [ ] [ ] ;
           m4  = m1+m2+m3;
             return (+m4) ;
      }

              

 

Obrigado !!!