Problema com matrizes - Java
01/02/2020
0
Pessoal, bom dia!
Estou com a penúltima atividade da faculdade para entregar, mas não tenho ideia de como iniciar a resolução.
A questão é a seguinte:
Faça um programa que comece por pedir um valor N ao utilizador. De seguida, crie uma matriz de N x N e
preenche-a com valores inteiros aleatórios, entre 0 e 100.
Depois de apresentar a matriz inicial ao utilizador, deve percorrê-la, linha a linha, e substituir cada elemento
pela média (inteira) de todos os elementos seguintes da matriz. O último elemento, M{N,N}, ficará com o
valor ZERO.P á g i n a 2 | 3
Exemplo:
N = 3
Matriz inicial:
2 19 45
16 33 21
76 55 3
Matriz Final:
M{1,1} = (19+45+16+33+21+76+55+3)/8 = 33
M{1,2} = (45+16+33+21+76+55+3)/7 = 35
M{1,3} = (16+33+21+76+55+3)/6 = 34
M{2,1} = (33+21+76+55+3)/5 = 37
M{2,2} = (21+76+55+3)/4 = 38
M{2,3} = (76+55+3)/3 = 44
M{3,1} = (55+3)/2 = 29
M{3,2} = (3)/1 = 3
M{3,3} = 0
33 35 34
37 38 44
29 3 0
Estou com a penúltima atividade da faculdade para entregar, mas não tenho ideia de como iniciar a resolução.
A questão é a seguinte:
Faça um programa que comece por pedir um valor N ao utilizador. De seguida, crie uma matriz de N x N e
preenche-a com valores inteiros aleatórios, entre 0 e 100.
Depois de apresentar a matriz inicial ao utilizador, deve percorrê-la, linha a linha, e substituir cada elemento
pela média (inteira) de todos os elementos seguintes da matriz. O último elemento, M{N,N}, ficará com o
valor ZERO.P á g i n a 2 | 3
Exemplo:
N = 3
Matriz inicial:
2 19 45
16 33 21
76 55 3
Matriz Final:
M{1,1} = (19+45+16+33+21+76+55+3)/8 = 33
M{1,2} = (45+16+33+21+76+55+3)/7 = 35
M{1,3} = (16+33+21+76+55+3)/6 = 34
M{2,1} = (33+21+76+55+3)/5 = 37
M{2,2} = (21+76+55+3)/4 = 38
M{2,3} = (76+55+3)/3 = 44
M{3,1} = (55+3)/2 = 29
M{3,2} = (3)/1 = 3
M{3,3} = 0
33 35 34
37 38 44
29 3 0
João Medeiros
Curtir tópico
+ 0
Responder
Post mais votado
01/02/2020
Ok, vamos por partes, pelo visto você já sabe capturar a entrada e gerar a matriz com ela, só falta gerar os números aleatórios e criar a matriz final do exercício, para gerar os números aleatórios utilizamos o método random da biblioteca Math, ele gera um valor float aleatório positivo entre 0 e 1, mas para gerar números inteiros utilizamos um typecasting para int:
O problema dessa abordagem é que o typecasting vai sempre cortar tudo que estiver atrás da vírgula, então o resultado vai ser sempre zero(ou, numa possibilidade muuuuuito distante, será 1), então temos que multiplicar o número aleatório gerado pelo valor máximo que desejamos, se desejamos que o número aleatório não passe de 1000 por exemplo, esse valor máximo será 1000:
Agora o problema é que ainda há a possibilidade de 1000 * o número aleatório ser menor que 1, o que geraria o número zero, para definir o valor mínimo do número aleatório é só somar esse valor ao resultado da expressão acima, então, se quisermos um valor mínimo de 1, para criarmos uma função que nos dê um número aleatório entre 1 e 1000 faríamos assim:
Agora sobre criar a segunda matriz, primeiro criaremos ela e um arraylist, e cada vez que um número novo for adicionado à primeira matriz o adicionaremos ao arraylist também, utilizando o método add, assim:
Logo após o término desse loop, utilizaremos o método remove para remover o elemento na primeira posição(0) do arraylist, desse jeito:
Agora criaremos uma nova matriz com o mesmo tamanho da primeira, e efetuaremos um loop para preenchê-la, assim como fizemos com a primeira, mas com um detalhe, existem duas regras de preenchimento, SE o loop estiver em sua última iteração, será executada a primeira regra(o elemento se torna 0), SENÃO, será executada a segunda regra:
A segunda regra é bem simples, basta criar uma variável cujo valor é zero e fazer um loop iterando todos os números do arraylist e somando os mesmos à essa variável(lembrando que a variável será resetada para zero a cada iteração), em seguida é só adicionar à segunda matriz o valor dessa variável dividido pelo tamanho do arraylist, e pra finalizar, usar o método remove para remover o elemento na primeira posição(0) do arraylist, assim:
O código final ficaria assim então:
int i = (int)Math.random();
O problema dessa abordagem é que o typecasting vai sempre cortar tudo que estiver atrás da vírgula, então o resultado vai ser sempre zero(ou, numa possibilidade muuuuuito distante, será 1), então temos que multiplicar o número aleatório gerado pelo valor máximo que desejamos, se desejamos que o número aleatório não passe de 1000 por exemplo, esse valor máximo será 1000:
final int maximo = 1000; int i = (int)(Math.random() * maximo);
Agora o problema é que ainda há a possibilidade de 1000 * o número aleatório ser menor que 1, o que geraria o número zero, para definir o valor mínimo do número aleatório é só somar esse valor ao resultado da expressão acima, então, se quisermos um valor mínimo de 1, para criarmos uma função que nos dê um número aleatório entre 1 e 1000 faríamos assim:
final int minimo = 1; final int maximo = 1000; int i = (int)(Math.random() * maximo + minimo);
Agora sobre criar a segunda matriz, primeiro criaremos ela e um arraylist, e cada vez que um número novo for adicionado à primeira matriz o adicionaremos ao arraylist também, utilizando o método add, assim:
ArrayList<Integer> numerosDaMatriz = new ArrayList();
System.out.println("Insira um número: ");
int numero = scan.nextInt();
int[][] matriz = new int[numero][numero];
for(int i = 0; i < numero; i++){
for(int j = 0; j < numero; j++){
matriz[i][j] = (int)(Math.random() * maximo + minimo);
numerosDaMatriz.add(matriz[i][j]);
}
}
Logo após o término desse loop, utilizaremos o método remove para remover o elemento na primeira posição(0) do arraylist, desse jeito:
numerosDaMatriz.remove(0);
Agora criaremos uma nova matriz com o mesmo tamanho da primeira, e efetuaremos um loop para preenchê-la, assim como fizemos com a primeira, mas com um detalhe, existem duas regras de preenchimento, SE o loop estiver em sua última iteração, será executada a primeira regra(o elemento se torna 0), SENÃO, será executada a segunda regra:
numerosDaMatriz.remove(0);
int[][] matrizFinal = new int[numero][numero];
for(int i = 0; i < numero; i++){
for(int j = 0; j < numero; j++){
if(i == numero - 1 && j == numero - 1){
matrizFinal[i][j] = 0;
}else{
//segunda regra de preenchimento
}
}
}
A segunda regra é bem simples, basta criar uma variável cujo valor é zero e fazer um loop iterando todos os números do arraylist e somando os mesmos à essa variável(lembrando que a variável será resetada para zero a cada iteração), em seguida é só adicionar à segunda matriz o valor dessa variável dividido pelo tamanho do arraylist, e pra finalizar, usar o método remove para remover o elemento na primeira posição(0) do arraylist, assim:
int elementoMatrizFinal = 0;
for(int elemento : numerosDaMatriz){
elementoMatrizFinal += elemento;
}
matrizFinal[i][j] = elementoMatrizFinal/numerosDaMatriz.size();
numerosDaMatriz.remove(0);
O código final ficaria assim então:
import java.util.Scanner;
import java.util.ArrayList;
public class Main
{
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
ArrayList<Integer> numerosDaMatriz = new ArrayList();
final int minimo = 1;
final int maximo = 1000;
System.out.println("Insira um número: ");
int numero = scan.nextInt();
int[][] matriz = new int[numero][numero];
for(int i = 0; i < numero; i++){
for(int j = 0; j < numero; j++){
matriz[i][j] = (int)(Math.random() * maximo + minimo);
numerosDaMatriz.add(matriz[i][j]);
}
}
numerosDaMatriz.remove(0);
int[][] matrizFinal = new int[numero][numero];
for(int i = 0; i < numero; i++){
for(int j = 0; j < numero; j++){
if(i == numero - 1 && j == numero - 1){
matrizFinal[i][j] = 0;
}else{
int elementoMatrizFinal = 0;
for(int elemento : numerosDaMatriz){
elementoMatrizFinal += elemento;
}
matrizFinal[i][j] = elementoMatrizFinal/numerosDaMatriz.size();
numerosDaMatriz.remove(0);
}
}
}
for(int i = 0; i < numero; i++){
for(int j = 0; j< numero; j++){
System.out.println(matrizFinal[i][j]);
}
}
}
}
Sadasd
Responder
Mais Posts
01/02/2020
João Medeiros
Pessoal, bom dia!
Estou com a penúltima atividade da faculdade para entregar, mas não tenho ideia de como iniciar a resolução.
A questão é a seguinte:
Faça um programa que comece por pedir um valor N ao utilizador. De seguida, crie uma matriz de N x N e
preenche-a com valores inteiros aleatórios, entre 0 e 100.
Depois de apresentar a matriz inicial ao utilizador, deve percorrê-la, linha a linha, e substituir cada elemento
pela média (inteira) de todos os elementos seguintes da matriz. O último elemento, M{N,N}, ficará com o
valor ZERO.P á g i n a 2 | 3
Exemplo:
N = 3
Matriz inicial:
2 19 45
16 33 21
76 55 3
Matriz Final:
M{1,1} = (19+45+16+33+21+76+55+3)/8 = 33
M{1,2} = (45+16+33+21+76+55+3)/7 = 35
M{1,3} = (16+33+21+76+55+3)/6 = 34
M{2,1} = (33+21+76+55+3)/5 = 37
M{2,2} = (21+76+55+3)/4 = 38
M{2,3} = (76+55+3)/3 = 44
M{3,1} = (55+3)/2 = 29
M{3,2} = (3)/1 = 3
M{3,3} = 0
33 35 34
37 38 44
29 3 0
Estou com a penúltima atividade da faculdade para entregar, mas não tenho ideia de como iniciar a resolução.
A questão é a seguinte:
Faça um programa que comece por pedir um valor N ao utilizador. De seguida, crie uma matriz de N x N e
preenche-a com valores inteiros aleatórios, entre 0 e 100.
Depois de apresentar a matriz inicial ao utilizador, deve percorrê-la, linha a linha, e substituir cada elemento
pela média (inteira) de todos os elementos seguintes da matriz. O último elemento, M{N,N}, ficará com o
valor ZERO.P á g i n a 2 | 3
Exemplo:
N = 3
Matriz inicial:
2 19 45
16 33 21
76 55 3
Matriz Final:
M{1,1} = (19+45+16+33+21+76+55+3)/8 = 33
M{1,2} = (45+16+33+21+76+55+3)/7 = 35
M{1,3} = (16+33+21+76+55+3)/6 = 34
M{2,1} = (33+21+76+55+3)/5 = 37
M{2,2} = (21+76+55+3)/4 = 38
M{2,3} = (76+55+3)/3 = 44
M{3,1} = (55+3)/2 = 29
M{3,2} = (3)/1 = 3
M{3,3} = 0
33 35 34
37 38 44
29 3 0
Iniciei o código assim:
package tema7_2;
import java.util.Scanner;
public class Tema7_2 {
public static void main(String[] args) {
int n, i, j;
Scanner entrada = new Scanner(System.in);
System.out.println("Informe o tamanho da matriz: ");
n = entrada.nextInt();
int[][] matriz = new int[n][n];
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
System.out.print("Informe o " + (j + 1) + "º elemento da " + (i + 1) + "ª linha:");
matriz [i][j] = entrada.nextInt();
}
}
entrada.close();
}
}
Responder
01/02/2020
João Medeiros
Ok, vamos por partes, pelo visto você já sabe capturar a entrada e gerar a matriz com ela, só falta gerar os números aleatórios e criar a matriz final do exercício, para gerar os números aleatórios utilizamos o método random da biblioteca Math, ele gera um valor float aleatório positivo entre 0 e 1, mas para gerar números inteiros utilizamos um typecasting para int:
O problema dessa abordagem é que o typecasting vai sempre cortar tudo que estiver atrás da vírgula, então o resultado vai ser sempre zero(ou, numa possibilidade muuuuuito distante, será 1), então temos que multiplicar o número aleatório gerado pelo valor máximo que desejamos, se desejamos que o número aleatório não passe de 1000 por exemplo, esse valor máximo será 1000:
Agora o problema é que ainda há a possibilidade de 1000 * o número aleatório ser menor que 1, o que geraria o número zero, para definir o valor mínimo do número aleatório é só somar esse valor ao resultado da expressão acima, então, se quisermos um valor mínimo de 1, para criarmos uma função que nos dê um número aleatório entre 1 e 1000 faríamos assim:
Agora sobre criar a segunda matriz, primeiro criaremos ela e um arraylist, e cada vez que um número novo for adicionado à primeira matriz o adicionaremos ao arraylist também, utilizando o método add, assim:
Logo após o término desse loop, utilizaremos o método remove para remover o elemento na primeira posição(0) do arraylist, desse jeito:
Agora criaremos uma nova matriz com o mesmo tamanho da primeira, e efetuaremos um loop para preenchê-la, assim como fizemos com a primeira, mas com um detalhe, existem duas regras de preenchimento, SE o loop estiver em sua última iteração, será executada a primeira regra(o elemento se torna 0), SENÃO, será executada a segunda regra:
A segunda regra é bem simples, basta criar uma variável cujo valor é zero e fazer um loop iterando todos os números do arraylist e somando os mesmos à essa variável(lembrando que a variável será resetada para zero a cada iteração), em seguida é só adicionar à segunda matriz o valor dessa variável dividido pelo tamanho do arraylist, e pra finalizar, usar o método remove para remover o elemento na primeira posição(0) do arraylist, assim:
O código final ficaria assim então:
int i = (int)Math.random();
O problema dessa abordagem é que o typecasting vai sempre cortar tudo que estiver atrás da vírgula, então o resultado vai ser sempre zero(ou, numa possibilidade muuuuuito distante, será 1), então temos que multiplicar o número aleatório gerado pelo valor máximo que desejamos, se desejamos que o número aleatório não passe de 1000 por exemplo, esse valor máximo será 1000:
final int maximo = 1000; int i = (int)(Math.random() * maximo);
Agora o problema é que ainda há a possibilidade de 1000 * o número aleatório ser menor que 1, o que geraria o número zero, para definir o valor mínimo do número aleatório é só somar esse valor ao resultado da expressão acima, então, se quisermos um valor mínimo de 1, para criarmos uma função que nos dê um número aleatório entre 1 e 1000 faríamos assim:
final int minimo = 1; final int maximo = 1000; int i = (int)(Math.random() * maximo + minimo);
Agora sobre criar a segunda matriz, primeiro criaremos ela e um arraylist, e cada vez que um número novo for adicionado à primeira matriz o adicionaremos ao arraylist também, utilizando o método add, assim:
ArrayList<Integer> numerosDaMatriz = new ArrayList();
System.out.println("Insira um número: ");
int numero = scan.nextInt();
int[][] matriz = new int[numero][numero];
for(int i = 0; i < numero; i++){
for(int j = 0; j < numero; j++){
matriz[i][j] = (int)(Math.random() * maximo + minimo);
numerosDaMatriz.add(matriz[i][j]);
}
}
Logo após o término desse loop, utilizaremos o método remove para remover o elemento na primeira posição(0) do arraylist, desse jeito:
numerosDaMatriz.remove(0);
Agora criaremos uma nova matriz com o mesmo tamanho da primeira, e efetuaremos um loop para preenchê-la, assim como fizemos com a primeira, mas com um detalhe, existem duas regras de preenchimento, SE o loop estiver em sua última iteração, será executada a primeira regra(o elemento se torna 0), SENÃO, será executada a segunda regra:
numerosDaMatriz.remove(0);
int[][] matrizFinal = new int[numero][numero];
for(int i = 0; i < numero; i++){
for(int j = 0; j < numero; j++){
if(i == numero - 1 && j == numero - 1){
matrizFinal[i][j] = 0;
}else{
//segunda regra de preenchimento
}
}
}
A segunda regra é bem simples, basta criar uma variável cujo valor é zero e fazer um loop iterando todos os números do arraylist e somando os mesmos à essa variável(lembrando que a variável será resetada para zero a cada iteração), em seguida é só adicionar à segunda matriz o valor dessa variável dividido pelo tamanho do arraylist, e pra finalizar, usar o método remove para remover o elemento na primeira posição(0) do arraylist, assim:
int elementoMatrizFinal = 0;
for(int elemento : numerosDaMatriz){
elementoMatrizFinal += elemento;
}
matrizFinal[i][j] = elementoMatrizFinal/numerosDaMatriz.size();
numerosDaMatriz.remove(0);
O código final ficaria assim então:
import java.util.Scanner;
import java.util.ArrayList;
public class Main
{
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
ArrayList<Integer> numerosDaMatriz = new ArrayList();
final int minimo = 1;
final int maximo = 1000;
System.out.println("Insira um número: ");
int numero = scan.nextInt();
int[][] matriz = new int[numero][numero];
for(int i = 0; i < numero; i++){
for(int j = 0; j < numero; j++){
matriz[i][j] = (int)(Math.random() * maximo + minimo);
numerosDaMatriz.add(matriz[i][j]);
}
}
numerosDaMatriz.remove(0);
int[][] matrizFinal = new int[numero][numero];
for(int i = 0; i < numero; i++){
for(int j = 0; j < numero; j++){
if(i == numero - 1 && j == numero - 1){
matrizFinal[i][j] = 0;
}else{
int elementoMatrizFinal = 0;
for(int elemento : numerosDaMatriz){
elementoMatrizFinal += elemento;
}
matrizFinal[i][j] = elementoMatrizFinal/numerosDaMatriz.size();
numerosDaMatriz.remove(0);
}
}
}
for(int i = 0; i < numero; i++){
for(int j = 0; j< numero; j++){
System.out.println(matrizFinal[i][j]);
}
}
}
}
Muito obrigado, Daniel!
Responder
Clique aqui para fazer login e interagir na Comunidade :)
