[ Resolvido ] Problema de lógica na matriz

57 respostas
olivercld

nao estou conseguindo, fazer este algoritmo podem me ajudar? antes minha matriz estava imprimindo agora nao esta mais eu ja me perdi.
alguem me explica como eu faço a troca da diagonal secundaria com principal ? como eu chamo pois nao estou acertando, o exercicio ainda nao esta terminado so me ajudem por gentileza apos trocar a diagonal secundaria com principal tenho mais coisas para fazer nessa matriz e vou postando minha duvida ok.

import javax.swing.JOptionPane;

public class Matriz_bidimen {

	public static void main(String[] args) {
		int matO[][] = new int[10][10];
		// int matB[][] = new int[10][10];

		// int cont = 0;
		int temp;
		String mensagem = " ";
		int linha, coluna;

		JOptionPane.showMessageDialog(null, "Matriz : ");

		for (linha = 0; linha < 10; linha++)
			for (coluna = 0; coluna < 10; coluna++) {
				// cont++;
				// matO[linha][coluna] = cont;

				matO[linha][coluna] = Integer.parseInt(JOptionPane
						.showInputDialog(null, " DIGITE VALORES DA MAT["
								+ linha + "] [" + coluna + "] : "));

				// mensagem = mensagem + "\n valores" + matO[linha][coluna];
				// JOptionPane.showMessageDialog(null, mensagem);

			}
				// apresentando a matriz 
		for (linha = 0; linha < 10; linha++)
			for (coluna = 0; coluna < 10; coluna++) {

				mensagem = mensagem + "\n mat[" + linha + "][" + coluna
						+ "] : " + matO[linha][coluna];

			}
		JOptionPane.showMessageDialog(null, "mensagem");
		
		
			// troca a diagonal secundaria pela primaria
		for (linha = 0; linha < 10; linha++)
			for (coluna = 0; coluna < 10; coluna++) {
				if (linha + coluna == 9) {
					
				temp = matO[linha][9 ];
				matO[linha][9] =  // receber a diagonal principal ?

				}
			}
	}
}

57 Respostas

rafaelbortoletto

Bom, a diagonal principal de uma matriz vai do canto superior esquerdo para o canto inferior direito da matriz. Então, basta fazer um loop que leia os valores.

O Exemplo abaixo imprime o que seria a diagonal principal da sua matriz:

for(int linhaColuna =0; linhaColuna < 10; linhaColuna++){

System.out.println( mat0[linhaColuna][linhaColuna] );

}
olivercld
obrigado rafaelbortoletto  pela gentileza de responder, eu nao entendi muito bem oque quis dizer,entendi que a principal e linha e igual coluna , so que minha duvida e como faço a troca entre elas, nao consigo dar continuidade no exercicio pelo fato que nao estou sabendo como faz e nao e por falta de tentar, no caso o exercicio pede para que leia uma matriz do tamanho que falei 10x10, troque a diagonal secundaria com a principal, essa e meu problema, no meu caso eu faria assim:

if(linha + coluna == 9) {

temp = matrizO[coluna][9];

matO[coluna][9] = matO[0][coluna];

matO[0][coluna] = temp;

00 01 02 03 04 05 06 07 08 09
10 11 12 13 14 15 16 17 18 19

olivercld

por gentileza alguem me explica issopor favor ? troca da diagonal sec com a principal

so esta a metade do codigo …

}
		int linha1 = 0;
		int coluna1 = 0;
		int l = 2 - 1;
		int c = 0;
		int[][] x = new int[2][2];
		for (int linha = 0; linha < 2; linha++) {
			x[l][c] = matriz[linha1][coluna1];
			linha1++;
			coluna1++;
			l--;
			c++;
		}

		for (int linha = 0; linha < 2; linha++) {
			for (int coluna = 0; coluna < 2; coluna++) {
				System.out.println("Matriz x [" + linha + "][" + coluna + "]: "
						+ x[linha][coluna]);
			}
		}

		int lin1 = 0;
		int col1 = 1;
		int li = 2 - 1;// nao entendi aqui ainda
		int co = 0;
		int[][] O = new int[2][2];
		for (int coluna = 0; coluna < 2; coluna++) {
			O[li][co] = matriz[lin1][col1];
			lin1++;
			col1--;
			l++;
			c--;
		}
		for (int linha = 0; linha < 2; linha++) {
			for (int coluna = 0; coluna < 2; coluna++) {
				System.out.println("Matriz x [" + linha + "][" + coluna + "]: "
						+ O[linha][coluna]);
			}
		}
	}

}
olivercld
olivercld:
por gentileza alguem me explica issopor favor ? troca da diagonal sec com a principal

so esta a metade do codigo ...

}
		int linha1 = 0;
		int coluna1 = 0;
		int l = 2 - 1;
		int c = 0;
		int[][] x = new int[2][2];
		for (int linha = 0; linha < 2; linha++) {
			x[l][c] = matriz[linha1][coluna1];
			linha1++;
			coluna1++;
			l--;
			c++;
		}

		for (int linha = 0; linha < 2; linha++) {
			for (int coluna = 0; coluna < 2; coluna++) {
				System.out.println("Matriz x [" + linha + "][" + coluna + "]: "
						+ x[linha][coluna]);
			}
		}

		int lin1 = 0;
		int col1 = 1;
		int li = 2 - 1;// nao entendi aqui ainda
		int co = 0;
		int[][] O = new int[2][2];
		for (int coluna = 0; coluna < 2; coluna++) {
			O[li][co] = matriz[lin1][col1];
			lin1++;
			col1--;
			l++;
			c--;
		}
		for (int linha = 0; linha < 2; linha++) {
			for (int coluna = 0; coluna < 2; coluna++) {
				System.out.println("Matriz x [" + linha + "][" + coluna + "]: "
						+ O[linha][coluna]);
			}
		}
	}

}
:?: :?:
G

Cara, sem querer ser chato…

Isso nao é tão commplicado de fazer, li tua dúvida e fiquei imaginando como fazer. Aí peguei um tempinho aqui e fiz. Seguinte :

voce cria uma matriz. Ai tem que ser quadrada, correto? para que existam diagonais iguais. daí você anda pela matriz, só pelas colunas (entao so precisa um “for”) e troca o item inicial matriz[linha][coluna] => matriz[0][0] troca por matriz[0][coluna_max]

daí você vai ter que somar (+ 1) na linha e subtrair (-1) na coluna. Assim vai poder trocar, colocando a coluna principal no lugar da secundaria e a secundaria na principal.

Você quer que eu mande ou quer pensar um pouco mais ainda? imagina que tem uma matriz 3x3. as operacoes que vc tem que fazer sao:
trocar mat[0][0] por mat[0][2]
trocar mat[1][1] por mat[1][1] --> isso nao e necessario, mas colocar um “if” pra testar isso nem vale a pena, fica testando direto uma coisa que so acontece 1X. é perda de processamento
trocar mat[2][0] por mat[2][2]

daí tu ve que pode usar um “for” só, que vai indexar as linhas. Tu faz tb duas variaveis auxiliares, pra poder indexar as colunas (que marcam os elementos que vc quer trocar). Aí voce comça com varAux1=0 e varAux2=2 (no caso de mat3X3)
agora tu usa o “for” pra andar pelas linhas. as colunas vao ser indicadas pelas variaveis auxiliares, uma vai ser somada e a outra vai ser subtraida de “1”. Assim, essas variaveis vao fazer um “X” na tua matriz, trocando a diagonal principal pela secundaria, sacou?

Tenta fazer aí e se tu nao conseguir manda email : [email removido]

G

ah, foi mal mas eu nao li essa solução que tu colocasse ai nao, ta mt complicada. Daquela que o cara tem que fazer o desenho e sair acompanhando com o lapis hehehe.

Parece que ta funcionando, ne? isso aí de 2 - 1 é porque a matriz tem 2 linhas e 2 colunas, só que como java indexa partindo de 0, entao na verdade os índices são 0 e 1 (um é o maior valor, que é 2-1 = 1), sacou? se vc colocar até 2 vai estourar o tamanho da matriz.

Valeu, cara! Tenta aí e meu email ta disponibilizado, qualquer coisa, se tu nao conseguir, da um toque ai! Tamos aqui pra ajudar nas duvidas! =)

olivercld

obrigado gpmdf2, vou tentar aqui essa ultima que postei ainda tenho de mecher qulquer coisa te mando email posto aqui blz valeu pela ajuda, tu sabe como é neh iniciante tem duvida demais vou tentando aqui la pelas madrugadas eu mando posto blz faloww

G

blz, cara.

olha so, apenas um dica : procura deixar tuas coisas o mais simples possivel, tem gente que se empolga mt com programação e faz uma tempestade em copo d’agua por qualquer coisa. Tipo o cara pergunta uma coisa simples e os caras mandam centenas de tutoriais, paginas pra pesquisar e tudo o mais, mesmo podendo mandar um exemplo pronto com uma coisa facil pra poder ajudar a galera.

nao to querendo dizer pra você para de pesquisar e ficar so esperando, pra ser preguiçoso. so quero falar que muita gente complica o que é fácil (nao podiam mandar um exemplo pequeno, bem explicativo pra o cara poder ter uma ideia e botar pra frente o que ele precisa?).

só pra tu ter idéia, pra andar por uma diagonal numa matriz (a diag. principal) você só tem que fazer um “for”. Ao inves de usar 2 “for”, que é o que a gente faz quando se quer andar por uma matriz e passar por todos os elementos dela, é só usar um “for” apenas e ao inves de fazer matriz[i][j], fazer matriz[i][i].

Pronto, só isso! Se vc desenhar a matriz no lapis vai ver que a diagonal principal é quando os indices sao iguais. Tenta olhar teu problema e verificar os detalhes dele, entende? Montar uma lógica pra outra diagonal e pronto. Depois que tu entender teu problema e colocar ele como um algoritmo, um modelo na linguagem que vc ta usando, ta feito! Como te disse, pode perguntar aí qualquer coisa. O bom é vc tentar sozinho. Qualquer coisa, tamos aí!

tenta com uma matriz pequena que com uma maior sai do mesmo jeito. Aí embaixo da uma olhada nas linhas e colunas :

[00][01][01]
[10][11][11]
[20][21][22]

ta vendo que a diagonal principal tem os dois indices iguais? Sacou o que eu falei? Tenta ver os detalhes que vc vai conseguir. Avisa ai quando resolver teu problema! Valeu!

olivercld

:lol:

obrigado gpmdf2 vou fazer oque vc falou, vou tentar com uma matriz menor, tou quase pgando o jeito, bom percebi sim que a principal e linha e igual coluna, estou tentando ok e o meu muito obrigado a todos que ajudou principalmente vc gpmdf2.

bom a essa matriz a troca de diagonais e apenas primeira coisa a fazer ainda dentro dssa mesma matriz tenho mais coisas mais trocas de elementos e asim que conseguirr desenrolar o primeiro passo para o segundo passo …

aqui stou eu pelas madrugadas unico teMpo para praticar, ate mesmo dormindo em cima do teclado

“Espera no ALTÍSSIMO, anima-te, e ele fortalecerá o teu coração; espera, pois, no ALTÍSSIMO. Salmos 27:14”

olivercld

ta a principal eu entendi, linha = = coluna

[00] [01] [01]  
     [10] [11] [11]  // nao entendi porque tem 2,   [0] [ 1]  [ 0] [1] na linha debaixo tem [1][ 1] [1] [1]
     [20] [21] [22]  

não seria assim 

     [00] [01] [02]  
     [10] [11] [12]  
     [20] [21] [22] 

  fazendo assim coluna[1] + linha [0] = 2 /  linha [1] + coluna [1] = 2  /, coluna[0] + linha [2] = 2 e dessa forma que seria minha secundaria ? fazendo assim da certo so especificando na matematica ela seria 3 linhas 3 coluna no algoritmo segui  esse ritimo que  falei acima  seria assim ?   gpmdf2

eis me aqui pela madrugada…

olivercld

outra duvida como é a triangular superior de uma matriz ou seja da principal para cima ela e numeros positivos da diagonal para baixo ela e numeros negativos certo? é para inverter ou seja troca las de lugar como seria exemplo a superior passa a ser inferior vise versa. ?

olivercld

seria dessa forma e certo que essa e uma 3x3:

matriz[2][1] = matriz[1][2];  
matriz[3][1] = matriz[1][3];  
matriz[3][2] = matriz[2][3];

dessa forma vai ficar muito grande minha matriz nesse caso eu tenho a matriz 10x10 vai ficar enorme, tem outro jeito de fazer ?

olivercld

olivercld:
seria dessa forma e certo que essa e uma 3x3:

matriz[2][1] = matriz[1][2];  
matriz[3][1] = matriz[1][3];  
matriz[3][2] = matriz[2][3];

dessa forma vai ficar muito grande minha matriz nesse caso eu tenho a matriz 10x10 vai ficar enorme, tem outro jeito de fazer ?

G
[00][01][01]  
[10][11][11]  
[20][21][22]

a matriz que eu tinha escrito acima ta desse jeito porque ta errada, mesmo huahauuhauhuahauha. Escrevi na pressa e nem vi que tinha elementos com linhas e colunas iguais!

[00][01][02]  
[10][11][12]  
[20][21][22]

Vamos tomar como exemplo uma matriz que nao esteja troncha daquele jeito, ne? Vamos la… O que temos de comum na triangular de cima?

  1. se for a diag. superior secundaria
    ando pela matriz toda e se o elemento atual atende : j >= i , entao ele pertence. Resultado (os numeros que estao com “.” no final sao os da diagonal superior):
0.0.0.0.
0 0.0.0.
0 0 0.0.
0 0 0 0.
  1. se for o da diagonal principal o triangulo, eu fiz uma variavel pra limitar ate onde devo andar. Esse foi facil mas um pouco mais trabalhos, entao vou te dar o algoritmo p vc estudar em casa (uma colhe de cha, ne? hauhuahuha)
    resultado :
0.0.0.0.
0.0.0.0 
0.0.0 0 
0.0 0 0

Algoritmo :

public static void imprimeTriangularCima(int lin, int col, int[][] mat) {

        /*
         *o algoritmo recebe uma matriz e espera que vc de o numero de linhas e colunas, blz? 
         *vc pode ainda colocar uma verificação no inicio, com um "if", caso o user passe linhas != colunas (porque ai nao e quadrada, entao nao tem diagonal, ne isso? ) 
         */
        
        /*
         * um limidator que indica ate onde devo marcar na matriz
         */
        int limiter = col;

        
        // começo a andar pela matriz
        for (int i = 0; i < lin; i++) {
                // se eu passei pra uma outra linha da matriz, entao devo limitar um pouco ate onde vou, correto? olha ai o limitador ajudando! =)
                limiter--;
            for (int j = 0; j < col; j++) {

                // se o J esta dentro dos limites, imprima como sendo da parte de cima!
                if (j <= limiter) {
                    System.out.print(mat[i][j] + ".");
                } else {
                    // se nao, imprima como sendo normal (fora do escopo que eu quero)
                    System.out.print(mat[i][j] + " ");
                }

                // se cheguei no fim da linha, pule uma linha (pra imprimir a matriz certinha na tela, ao inves de uma linha so, cheia de numeros)
                if (j == lin - 1) {
                    System.out.println("");
                }
            }
        }
    } // fim do algoritmo

Desculpa qq coisa ai se n ficou mt claro, programo mt bem nao… =( mas acho que da pra ajudar bastante!
só uma dica pra chamar o metodo :

olivercld

cara tu é um irmão obrigado gpmdf2, nao sabe como estou aqui a dias tentando fazer e nao da certo, o algoritmo que estou aqui e mais ou menos dessa forma que vc fez, vou passar ele no eclipse ver como vou fazendo implemantando praticando, se possivel passar no meu caderninho de praticas aqui qu faço assim escrevo no caderno e logo apos passo no eclipse, na matriz eu tenho de fazer 1º trocar diagonal secundaria 2º trocar 3 linha pela 9 coluna, 3º inverter o memso qu trocar a tringular superior com a triangular inferior. ainda estou na de trocar a 3 linha com 9 coluna pa vc ta facilqu ja entende eu aidna nao estou qurendo entnder praticando e com a ajuda sua e do pessoal do blog.

ao final quando terminar postarei a matriz aqui ou posso passar em pdf e passo o link aqui o que vc acha ?

hã e como aidna estou fazendo vao surgir duvidas erros qu nao saberei neste sabado e domingo vou mecher denovo na matriz.

obrigado pelas explicaçoes, masi vou nessa que ja e altas horas da madruga nem consigo pensar ate a proxima breve duvida.
postarei masi erros e duvidas ok abraços grande.

G

qnd eu comecei a programar matrizes era o que mais me esquentava a cabeça, depois isso passa um pouco, porque vc vai ter coisas muito mais dificeis pra se preocupar huahuhauhauhauha.

com esse exemplo de percorrer a matriz tu ja mata esses de trocar os triangulos, po. saca so, se tu percorrer e sabe quem tu quer encontrar, quando tu encontrar, guar num vetor[x] e aumenta o x;

assim quando tu quiser colocar em outro lugar (tipo o outro triangulo) é so andar por ele e sair lendo o array. naquele teste que imprime o “.” caso ele seja do triangulo, tu pode colocar um “continue”, ai o loop reinicia, assim nao precisa processar o resto do loop, se tu nao quiser andar por mais nada isso e util porque ele ve se o cara nao for do triangulo, tu manda reiniciar o loop, sacou?

tipo… é do triangulo? entao vai fazendo o algoritmo se nao for, vai pra proxima iteracao.

tu acho que mexer com matrizes é bom p desenvolver a logica. tu nao queres me adicionar no msn, nao? to procurando gente pra estudar umas coisas viajadas ai e ja que tu parece gostar a gnt podia se juntar. sao uns projetinhos bem legais. se quiser me avisa que tem mando meu msn

G

ei véi…

só pra disseminar o caos…

eu tava andando pelo forum e vi a duvida de um cara… ele queria fazer isso:

0000*0000
000***000
00*****00
0*******0
*********
0*******0
00*****00
000***000
0000*0000

huahuahuhauhuauhuhauhauhuaha.

eu achei o exercicio legal. Ve se tu acha a resposta ai.

olivercld

caraca esse exercicio e dificil, bom no caso de fazer um grupo de estudo eu concordo ate eu ia te chamar,ja que chamo tou dentro, e so que a uma diferença eu sei quase nada e tu ja esta bem adiantado, tipo essa matriz eu tenho de fazer ela ate segunda feira por isso estou batendo forte em cima, uma que quero aprender eu tenho de explicar ela outra e que ela tem de fazer 3 açao dentro dela primeiro troca de diagonais 2 troca de linha por coluna 3 troca de diagonais. e ai estou no troca de linha por coluna esta dando alguns erros.
faz assim mu horario que tenho pra praticar são esses:

depois da facul entro as 23:10 em diante no caso eu moro no MATO GROSSO é uma hora a menos doque SP RJ PR nao sei onde tu moras, e no meio da semana depois das 16 horas ate as 18 horas que ai vou pra faculdade, enfim tenho pouco tempo para praticar ha casos de muitos trabahos de outras materis do curso e focar so em uma coisa fica dificil, masi mesmo assim com pouco tmepo pratico pouco mais faço, eu leio apostilas pego exemplos passo no caderno depois para pc, entao tenho interesse e gosto sim, eu nao entro muito em msn mais se for pra estudar abro uma exceção manda ai que adc.
mais tou aqui sempre no forum e de grande ajuda, e que ajuda otimo este forum.

kara a duvida do kara ai ele quer mostrar aquele monte de 000 ? daquela maneira ? nao eesta tao facil. hehe

olivercld

então no caso da matriz eu ja tenho meio caminho andado e so fazer um metodo pra que depois chamo na principal, o que quero e trocar Tringular superior com a Inferior

exemplo uma 3x3

00 01 02
10 12 13
20 22 23

quero pegar os valores acima da principal esses  01 02  13
                                                                           
inverter(trocar)
 por valores abaixo da principal                            10 20   22
                                                                            
pegar os valores da de cima trocar com a debaixo as triangulares
Vingdel

Bom dia, olivercld!

Adoro ficar aqui resolverndo problemas desse tipo e parei para ver o seu das diagonais, apesar do sono eu resolvi e deixei sua classe mais genérica, possibilitando trabalhar com qualquer matriz quadrada, veja o resultado:

import javax.swing.JOptionPane;  

public class Matriz_bidimen {  
	static int num_lin = 4, num_col = 4;
	public static void main(String[] args) {  
		int matO[][] = new int[num_lin][num_col];  
		// int matB[][] = new int[10][10];  

		// int cont = 0;  
		int temp;  
		String mensagem = " ", texto = "";  
		int linha, coluna;  

		JOptionPane.showMessageDialog(null, "Matriz : ");  

		for (linha = 0; linha < num_lin; linha++)  
			for (coluna = 0; coluna < num_col; coluna++) {  
				// cont++;  
				// matO[linha][coluna] = cont;  

				matO[linha][coluna] = Integer.parseInt(JOptionPane  
						.showInputDialog(null, " DIGITE VALORES DA MAT["  
								+ linha + "] [" + coluna + "] : "));  

				// mensagem = mensagem + "\n valores" + matO[linha][coluna];  
				// JOptionPane.showMessageDialog(null, mensagem);  

			}  
		// apresentando a matriz		
		for (linha = 0; linha < num_lin; linha++){
			texto = texto +"\n";
			for (coluna = 0; coluna < num_col; coluna++) {  

				mensagem = mensagem + "\n mat[" + linha + "][" + coluna  
				+ "] : " + matO[linha][coluna];
				texto = texto +" "+ matO[linha][coluna];

			}  }
		JOptionPane.showMessageDialog(null, mensagem);
		mensagem = "";  
		JOptionPane.showMessageDialog(null, texto);
		texto="";

		// troca a diagonal secundaria pela primaria  
		for (linha = 0; linha < num_lin; linha++)  
			for (coluna = 0; coluna < num_col; coluna++) {  
				if (linha + coluna == (num_col-1)) {  
					temp = matO[linha][(num_col-1)-linha];
					//System.out.println(linha+""+coluna+": "+temp);
					matO[linha][(num_col-1)-linha] = matO[linha][linha];
					matO[linha][linha] = temp;
				}  
			}
		// apresentando a matriz   
		for (linha = 0; linha < num_lin; linha++){
			texto = texto +"\n";
			for (coluna = 0; coluna < num_col; coluna++) {  

				mensagem = mensagem + "\n mat[" + linha + "][" + coluna  
				+ "] : " + matO[linha][coluna];
				texto = texto +" "+ matO[linha][coluna];

			}  }
		JOptionPane.showMessageDialog(null, mensagem);  
		JOptionPane.showMessageDialog(null, texto);
	}
}

OBS: basicamente trabalhei em cima do seu código, e usei variaveis para setar o alcance da matriz deixando o código mais abrangente, não ficando limitado a matriz 10x10.

Espero que isso ajude... o que diz respeito a tua dúvida seria essa parte do código:

// troca a diagonal secundaria pela primaria  
		for (linha = 0; linha < num_lin; linha++)  
			for (coluna = 0; coluna < num_col; coluna++) {  
				if (linha + coluna == (num_col-1)) {  
					temp = matO[linha][(num_col-1)-linha];
					//System.out.println(linha+""+coluna+": "+temp);
					matO[linha][(num_col-1)-linha] = matO[linha][linha];
					matO[linha][linha] = temp;
				}  
			}

Abraço e bons estudos!

EDIT, na verdade APPEND (lol):

Salve, olivercld!

Voltei! Bom, fiz a parte de trocar a 3º linha pela 9º coluna, mas ao final surge a grande questão no indice 2,8 fica o valor da 3º linha ou o da 9º coluna? hehe, vou te mostrar o antes e depois e vc vai entender melhor, caso já não tenha entendido:

[img]http://img580.imageshack.us/img580/7245/lin3xcol9antes.png[/img] [img]http://img715.imageshack.us/img715/8848/lin3xcol9depois.png[/img]
ANTES DA TROCA[color=white]...................................................[/color]DEPOIS DA TROCA

Veja na imagem que ilustra depois da troca, de acordo com os calores que usei, no índice sublinhado de vermelho, qual valor deveria existir: 2 ou 8?

A pergunta surge pois antes de ser feita a troca, o valor da intersessão era 2, porém depois da troca dois valores disputam o indice: 2 ou 8?

Se fosse para trocar linha n por coluna n não haveria esse probleminha. Faça uma análise e se possível tire essa dúvida com teu professor.

De qualquer forma segue o código que trata da troca:
// troca linha 3 com coluna 9
		for(int indice = 0; indice < num_col; indice++ ){
			temp = matO[2][indice];
			matO[2][indice] = matO[indice][8];
			matO[indice][8] = temp;			
		}

Aguardo sua análise para possível modificação do código.

Abraço!

G

e ai, velho! ve so, temos um outro amigo ai que ta ajudando. =)
sobre teu problema com as diagonais, pessoalmente gostei dessa forma aqui que eu fiz :

o metodo mostraMatriz eu nao coloquei porque é aquele que eu ja te passei, ne? ele serve pra td quanto e tipo de matriz. Eu nao olhei muito o metodo do nosso amigo, porque eu ia procurar escrever uma matriz pequena aqui e ver o que faz matO[linha][(num_col-1)-linha] = matO[linha][linha];

eu num gosto mt dessas formulas assim n… =(
basicamente ta explicado o que eu faço quando vou trocar as diagonais, ficou mt facinho e o cara entende logo de cara, acho que ficou massa.

Sou de Pernambuco.

public static void main(String[] args) {

        /*
         * Gostei dessa solução aqui que eu encontrei, ve se tu aprova ai :
         */

        final int TAMANNHO = 3;
        int mat[][] = new int[TAMANNHO][TAMANNHO];

        // uso uma variavel pra dar os valores pra matriz
        int valoresPraMatriz = 0;
        for (int i = 0; i < TAMANNHO; i++) {
            for (int j = 0; j < TAMANNHO; j++) {
                mat[i][j] = valoresPraMatriz++;
            }
        }

        // mostro a matriz e uma pula umas linhas pra prox. matriz n ficar colada com ela qnd for mostrar
        mostraMatriz(mat, TAMANNHO, TAMANNHO);
        System.out.println("\n\n");


        /*
         * a unica parte que precisamos pensar é aqui, ento vamos botar nosso tico e teco p funfar :
         * nao e necessario pegar a propria diagonal, porque seus elementos n vao ser trocados por nenhum
         * entao começamos o "i" pela segunda linha (e começarmos pela primeira nao da erro, mas ele nao faz NADA. entao pra que usar a linha1???)
         * Se tu colocar na ponta do lapis, vai ser que a diagonal inferior é quando i > j
         * Ainda na ponta do lapis, vai ver que uma diagonal (inferior) tu usa matriz[i][j] e a outra funciona como matriz[j][i]
         * Sabe o que isso quer dizer? é que nem grafico de coordenadas polares meu amigo, depois que o cara encontra um o outro é só espelhar
         * Em outras palavras, se tu tem a inferior (que eh facil demais de conseguir) o outro tu tb ja tem, entao so precisa UM for
         * Olha ai, que coisa maravilhosa! huahuahuahuha Sem complicação, sai na hora que nem caldo de cana na barraca!
         * Espero ter ajudado!
         */
        int temp = 0;
        for (int i = 1; i < TAMANNHO; i++) {
            for (int j = 0; j < TAMANNHO; j++) {

                if (i > j) { // Se i > j, to numa diagonal inferior
                    temp = mat[i][j];
                    mat[i][j] = mat[j][i];
                    mat[j][i] = temp;
                } else {
                    /*
                     * Se ele nao aende ao conjunto que a gente procura, entao ele volta
                     * pro cabeçalho do FOR. aqui nao é nem tao necessario, porque nao tenho mais nada pra baixo
                     * mas, se tivesse, seria interessante nao precisar passar pelo codigo, ja que eu n tinha q usar...
                     * mesmo que sejam expressoes condicionais e elas nao executem codigo que eu n preciso, ficar
                     * testando coisas come processamento. 
                     */
                    continue;
                }

            }
        }

        mostraMatriz(mat, TAMANNHO, TAMANNHO);

    }

saída :

012
345
678

036
147
258

pelo que entendi era isso que vc queria, ne? Ve ai se to certo, se entendi direito. Eu nao testei mt nao, mas pelo que vejo funciona bem. Eu nao testei mais porque to com preguiça de mudar o metodo mostraMatriz pra deixar numeros maiores (com 2 caracteres ou mais) bonitinhos. Como ele foi feito pra numeros com um caractere, se numeros grandes forem usados ele deixa as coisas meio tortas. é só tu testar que numero maximo ele escreve e ai colocar mais espaços huauhauuha.

Se tu quiser alterar o tamanho da matriz so muda a constante TAMANHO e pronto. Ve ai se tu aprova! me add no msn : [email removido]

Vingdel

Bom dia, gpmdf2!

Ele quer mais ou menos isso mesmo, porém você fez a troca da linha e da coluna com indice iguais, ou seja, linha 2 e coluna 2, porém no caso dele, ele vai ter que trocar a linha 3 pela coluna 9, não mantendo a mesma intersessão e isso gera o problema que eu coloquei na edição da minha última postagem.

0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 1 1 1 1 1 0 1 2 3 4 0 1 2 1 4 2 2 2 2 2 === lin 2 por col 4 ===> 2 2 2 1 2 ou 2 2 2 1 2 ? 3 3 3 3 3 3 3 3 1 3 3 3 3 1 3 4 4 4 4 4 4 4 4 1 4 4 4 4 1 4

Entende o problema de trocar linha por coluna de índices diferentes? Se fosse linha e coluna com índices iguais não haveria esse problema pois os números envolvidos seriam sempre iguais.

Abraço!

G

oi, Vingdel

o que ele pediu :

exemplo uma 3x3  
  
00 01 02  
10 12 13  
20 22 23  
  
quero pegar os valores acima da principal esses  01 02  13  
                                                                             
inverter(trocar)  
por valores abaixo da principal                            10 20   22  
                                                                              
pegar os valores da de cima trocar com a debaixo as triangulares

entao pra mim, se ele disse que quer pegar os numeros 01 02 13 , que estao no triangulo acima da diagonal principal

e trocar pelo triangulo que tem abaixo (10 20 22), entao ele quer isso que mostrei…

fiz o que eu entendi que ele pediu. =/ Deixa ele explicar melhor pra ver o que e que ele quer mesmo, entao…

G

o que eu fiz foi pegar o triangulo de cimda da diagonal e botar pra baixo e o de baixo botar pra cima…

foi isso que entendi do pedido… deixa ver uma explicação melhor do problema, relaxa, senta ai, come uns salgadinhos e vamo tocar um pouco de guitarra! hauhuahua

Valeu!!!

Vingdel

gpmdf2:
o que eu fiz foi pegar o triangulo de cimda da diagonal e botar pra baixo e o de baixo botar pra cima…

foi isso que entendi do pedido… deixa ver uma explicação melhor do problema, relaxa, senta ai, come uns salgadinhos e vamo tocar um pouco de guitarra! hauhuahua

Valeu!!!

Opa, foi mal então, você já está mais a frente do que eu. Eu tava falando da segunda parte do que ele tem que fazer, troca linha com coluna essa de inverter os triângulhos seria a proxima fase, mas antes tem que ser decidido o dilema dos dois valores na troca da linha pela coluna. Leia o que eu escrevi atentamente para você entender.

OBS.: Na minha opinião, o exercício foi mal formulado… Eu anularia essa questão em concurso… hehehe

Abraço!

olivercld

galera toda ajuda e bem vinda, estou aqui implementando odigo que ja tenho ok ja ja eu posto aqui da dando alguns erros jaja eu posto e o que falaram esta certo agora estou trabalhando na troca da 3 linha que em java parte do 0 entao vou fazer if(linha == 2) que e a terceira linha e trocar pela 9º coluna, depois disso e igual que o gpmdf2 falou de trocar a triangular superior com a diagonal inferior de maneira alguma quero a diagonal principal apena valores acima dela e valores abaixo dela e trocar e como o gpmdf2 fez, a de troca de linha por coluna e exatamente o que o amigo Vingdel fez, tu esta certo e exatamnte que eu quero fazer
entao deixa eu implementar no codigo que ja tenho aqui e ao final posto aqui o codigo blz

brothers e uma emoçao eim voçes me ajudando owww :lol: hehe calma ai ja eu posto codigo que tneho aqui.

olivercld

testam essa matriz esta fazendo exatamente a troca de diagonais, tive ajuda claro sozinho nao conseguia. aqui vai o codigo

public class EstruturaMatriz {
	private int dimensao = 0;
	
	public EstruturaMatriz(int dimensao){
		this.dimensao = dimensao;
		int[][] matriz = new int[dimensao][dimensao];
	}
	
	public int[][] trocaLinhasColunas(int[][] matriz){
		int[][] matrizAux = new int[dimensao][dimensao];
		
		for (int linha = 0; linha < dimensao; linha++) {
			for (int coluna = 0; coluna < dimensao; coluna++) {
				matrizAux[coluna][linha] = matriz[linha][coluna];
			}
		}
		return matrizAux;
	}
	
	public int[][] trocaDiagonais(int[][] matriz){
		int[][] matrizAux = new int[dimensao][dimensao];
		
		for (int linha = 0; linha < dimensao; linha++) {
			for (int coluna = 0; coluna < dimensao; coluna++) {
				matrizAux[linha][coluna] = matriz[linha][coluna];
			}
		}
		int linha1 = 0;
		int coluna1 = 0;
		int l = dimensao - 1;
		int c = 0;
		for (int linha = 0; linha < dimensao; linha++) {
			matrizAux[l][c] = matriz[linha1][coluna1];
			linha1++;
			coluna1++;
			l--;
			c++;
		}
		int lin1 = dimensao-1;
		int col1 = 0;
		int li = 0;// nao entendi aqui ainda
		int co = 0;
		for (int coluna = 0; coluna < dimensao; coluna++) {
			matrizAux[li][co] = matriz[lin1][col1];
			lin1--;
			col1++;
			li++;
			co++;
		}
		return matrizAux;
	}
	
	public void imprimeMatriz(int[][] matriz){
		System.out.println("Matriz: ");
		for (int linha = 0; linha < matriz.length; linha++)
		{
			System.out.print("| ");
			for (int coluna = 0; coluna < matriz.length; coluna++) {
				System.out.print(matriz[linha][coluna]+"   ");
			}
			System.out.print(" |");
			System.out.println();
		}
		System.out.println(" |");
	}
}

agora a main principal onde chamo da classe estrutura da matriz

import java.util.Scanner;

public class Matriz {

	public static void main(String[] args) {
		Scanner digite = new Scanner(System.in);
		System.out.println("Digite a dimensão da Matriz: ");
		int dimMatriz = digite.nextInt();
		int[][] matriz = new int[dimMatriz][dimMatriz];
		EstruturaMatriz estMatriz = new EstruturaMatriz(dimMatriz);
		
		//leitura dos valores e armazenamento na matriz
		for (int linha = 0; linha < dimMatriz; linha++) {
			for (int coluna = 0; coluna < dimMatriz; coluna++) {
				System.out.println("Digite valor da matriz na posicao ["
						+ (linha+1) + "][" + (coluna+1) + "]: ");
				matriz[linha][coluna] = digite.nextInt();
			}
		}
		System.out.println("leitura dos valores e armazenamento na matriz");
		estMatriz.imprimeMatriz(matriz);
		
		System.out.println("troca diagonais");
		int[][] matrizResultado = estMatriz.trocaDiagonais(matriz);
		//estMatriz.imprimeMatriz(estMatriz.trocaDiagonais(matriz));
		estMatriz.imprimeMatriz(matrizResultado);
		
		System.out.println("troca linhas por colunas");
		estMatriz.imprimeMatriz(estMatriz.trocaLinhasColunas(matriz));
	}
}

AGORA e que vem os erros eu continuei implementando pra fazer a troca de linha com coluna depois troca das triangulares como os amigos me explicaram so que continua dando erros toscos aqui vai o mesmo codigo so que com implementação a mais as duas classes a estrutura e a main
aqui estão os erros:

public class EstruturaMatriz {
	private int dimensao = 0;

	public EstruturaMatriz(int dimensao) {
		this.dimensao = dimensao;
		int[][] matriz = new int[dimensao][dimensao];
	}

	// troca linhas por colunas --> transposta
	public int[][] trocaLinhasColunas(int[][] matriz) {
		int[][] matrizAux = new int[dimensao][dimensao];

		for (int linha = 0; linha < dimensao; linha++) {
			for (int coluna = 0; coluna < dimensao; coluna++) {
				matrizAux[coluna][linha] = matriz[linha][coluna];
			}
		}
		return matrizAux;
	}

	// troca das diagonais secundaria pela principal
	public int[][] trocaDiagonais(int[][] matriz) {
		int[][] matrizAux = new int[dimensao][dimensao];

		for (int linha = 0; linha < dimensao; linha++) {
			for (int coluna = 0; coluna < dimensao; coluna++) {
				matrizAux[linha][coluna] = matriz[linha][coluna];
			}
		}
		int linha1 = 0;
		int coluna1 = 0;
		int l = dimensao - 1;
		int c = 0;
		for (int linha = 0; linha < dimensao; linha++) {
			matrizAux[l][c] = matriz[linha1][coluna1];
			linha1++;
			coluna1++;
			l--;
			c++;
		}
		int lin1 = dimensao - 1;
		int col1 = 0;
		int li = 0;//
		int co = 0;
		for (int coluna = 0; coluna < dimensao; coluna++) {
			matrizAux[li][co] = matriz[lin1][col1];
			lin1--;
			col1++;
			li++;
			co++;
		}
		return matrizAux;
	}// fim do metodo troca diagonais

	// troca 3 linha com 9º coluna
	public int[][] troca3Linha8Coluna(int[][] matriz) {
		int[][] matrizAux = new int[dimensao][dimensao];
		for (int linha = 0; linha < dimensao; linha++) {
			for (int coluna = 0; coluna < dimensao; coluna++) {

				matrizAux = matriz[2][coluna];// dando erro 
				matriz[2][coluna] = matriz[coluna][8];
				matriz[coluna][8] = matrizAux;// dando erro

			}

		}
		return matrizAux;
	}

	// troca triangular superior com triangular inferior
	public int[][] trocatriangularsuperior(int[][] matriz) {
		int[][] matrizAux = new int[dimensao][dimensao];
		for (int linha = 0; linha < dimensao; linha++) {
			for (int coluna = 0; coluna < dimensao; coluna++) {

				if (linha > coluna) {// estou triangular inferior
                    matrizAux = matriz[linha][coluna];  //erro 
                    matriz[linha][coluna] = matriz[coluna][linha];
                    matriz[coluna][linha] = matrizAux;
				}
				else{  // realmente eu preciso desse else  ? e o continue? 
					
					continue;
				}
			}
		}
		return matrizAux;
		 EstruturaMatriz(matriz, dimensão, dimensão); // neste caso eu nao quero chamala aqui quero chamala na main principal 
	}

	// metodo imprime
	public void imprimeMatriz(int[][] matriz) {
		System.out.println("Matriz: ");
		for (int linha = 0; linha < matriz.length; linha++) {
			System.out.print("| ");
			for (int coluna = 0; coluna < matriz.length; coluna++) {
				System.out.print(matriz[linha][coluna] + "   ");
			}
			System.out.print(" |");
			System.out.println();
		}
		System.out.println(" |");
	}
}
import java.util.Scanner;

public class Matriz {

	public static void main(String[] args) {
		Scanner digite = new Scanner(System.in);
		System.out.println("Digite a dimensão da Matriz: ");
		int dimMatriz = digite.nextInt();
		int[][] matriz = new int[dimMatriz][dimMatriz];
		EstruturaMatriz estMatriz = new EstruturaMatriz(dimMatriz);

		// leitura dos valores e armazenamento na matriz
		for (int linha = 0; linha < dimMatriz; linha++) {
			for (int coluna = 0; coluna < dimMatriz; coluna++) {
				System.out.println("Digite valor da matriz na posicao ["
						+ (linha + 1) + "][" + (coluna + 1) + "]: ");
				matriz[linha][coluna] = digite.nextInt();
			}
		}
		System.out.println("leitura dos valores e armazenamento na matriz");
		estMatriz.imprimeMatriz(matriz);

		// imprime valores da diagonais
		System.out.println("troca diagonais");
		int[][] matrizResultado = estMatriz.trocaDiagonais(matriz);
		// estMatriz.imprimeMatriz(estMatriz.trocaDiagonais(matriz));
		estMatriz.imprimeMatriz(matrizResultado);
		
		

		// recebe o metodo troca 3 linha pela nona coluna
		System.out.println("troca linha por coluna");
		int[][] matrizResultado = estaMatriz.troca3Linha8Coluna(matriz);// ocorre o 
		                          //erro aqui na hora em que chamo o metodo troca 3 linha por coluna
		estMatriz.imprimeMatriz(matrizResultado);

		System.out.println("troca linhas por colunas -->( Transposta )");
		estMatriz.imprimeMatriz(estMatriz.trocaLinhasColunas(matriz));
	}
}


grato pela ajuda: poderiam me dizer oque estou errando neste codigo abaixo, estou fazendo como vcs falaram o primeiro codigo acima esta ok trocando as diagonais eu continuei e claro pra fazer o a troca de 3 linha pela 8 coluna depois triangular superior pla inferior
G

cara…

eu to com algumas duvidas… primeiro, o length acho que nao funciona pra pegar o tamanho da matriz. Se nao me engano, java faz matrizes como vetores de vetores.

tentei dar um joptionpane.showmessagedialog (ele faz um popup na tela com alg informacao que se passe pra ele) e ele nao mostrou um numero, mas uma coisa bem doida, acho que ele pega o toString do objeto, entao nao retorna um numero.

tem um jeito facil de fazer o que vc quer, pegar o tamanho, mas eu acho melhor vc pegar a informacao que o usuario te passou, ele te informou isso logo no inicio do programa, ne? entao usa!

segundo no metodo que eu te mostrei pra trocar os triangulos de baixo e de cima :

o que eu mandei :

int temp = 0;
        for (int i = 1; i < TAMANNHO; i++) {
            for (int j = 0; j < TAMANNHO; j++) {

                if (i > j) { // Se i > j, to numa diagonal inferior
                    temp = mat[i][j];
                    mat[i][j] = mat[j][i];
                    mat[j][i] = temp;
                } else {
                    continue;
                }
            }
        }

o que vc colocou :

// troca triangular superior com triangular inferior  
    public int[][] trocatriangularsuperior(int[][] matriz) {  
        int[][] matrizAux = new int[dimensao][dimensao];  
        for (int linha = 0; linha < dimensao; linha++) {  
            for (int coluna = 0; coluna < dimensao; coluna++) {  
  
                if (linha > coluna) {// estou triangular inferior  
                    matrizAux = matriz[linha][coluna];  //erro   
                    matriz[linha][coluna] = matriz[coluna][linha];  
                    matriz[coluna][linha] = matrizAux;  
                }  
                else{  // realmente eu preciso desse else  ? e o continue?   
                      
                    continue;  
                }  
            }  
        }  
        return matrizAux;  
         EstruturaMatriz(matriz, dimensão, dimensão); // neste caso eu nao quero chamala aqui quero chamala na main principal   
    }

vc pode me explicar por que vc trocou o meu inteiro “temp” por uma matriz??? tipo… vc ta tentando atribuir um INTEIRO matriz[linha][coluna] a uma matriz (matrizAux)
Assim realmente vai dar erro.

eu recomendo que vc de uma olhada nas alterações que vc fez e veja o que a dando erro, porque se a gnt mandou os codigos, a gente fez alguns testes unitarios (testes bem especificos) antes de te mandar. Se nao ta funcionando acho que é por causa de alterações pequenas assim… Nao tem como nao funcionar. Procura direitinho ai as coisa que vc alterou e arruma que funfa! vc tem que prestar atenção no que ta fazendo!

ah, o continue eu tinha explicado quando te mandei. se vc tivesse mais coisas pra baixo, o continue te ajuda, pq ja que nao tem nada mais pra fazer, nao precisa continuar nessa iteração do for. mas como nao tem nada, realmente ai nao precisa. Foi so uma dica, saca? resumindo, eu acho que ta tudo funcionando, sim. vc so precisa ver o que vc alterou e prestar atencao no que ta fazendo. lembre que em programação uma linha faz mt diferença;

G

tu mudasse algumas coisas e eu acho que nao prestou me atencao no que tava fazendo.

por exemplo, no metodo de trocar os triangulos de cima pelos de baixo, eu criei uma variavel INT e vc ta usando uma matriz INT[][].

ai vc usa essa matriz no lugar da variavel, indexando ela nao sei como… =/ ai nao rola, ne?

p length de uma matriz acho que nao sai assim como vc ta usando nao, posso ate estar enganado, mas coloquei aqui um JOptionPane.showMessageDialog e ele mostrou uma coisa bem doida.

tem um jeito de fazer isso, pra poder pegar o tamanho da matriz, mas se vc tem a informacao que o usuario deu, pra que isso? tem algum problema em usar direto o que o usuario passou?

ve ai direitinho essas alterações que vc fez e ve se ta batendo com o que foi estudado antes. blz? =)

G

eita, tinha dado um erro aqui no browser e eu pensei que nao tinha enviado a mensagem anterior

huahuhauhhuauhauhuahuhuaha foi mal! :shock:

Vingdel

Boa Noite, oliver!

Encontei vários equivocos teus e notei que você entendeu pouca coisa do que te explicamos e dos nosso exemplos.

Vamos iniciar pelo início:

  1. A primeira coisa estranha que identifico é que você logo de cara cria uma matriz no método main() e em seguida instancia a classe EstruturaMatriz, que por sua vez em seu construtor cria outra matriz, aí você já possui duas matrizes, coisa que não vejo necessidade.

Seguindo com o estudo do seu código vejo que você trabalha com a matriz criada no main(), porém usando os métodos da classe EstruturaMatriz, creio que você esteja confundido as coisas. Acho legal você dar uma revisada no código nesse instante antes de continuar com a implementação do mesmo.

Te adicionei no MSN, se for possível você ficar online seria mais rápido e dinâmico para tratarmos dos erros.

OBS.: Pessoal, quando forem fazer postagens seguidas, editem a postagem anterior, senão a moderação vai vir pegar no pé de vocês…

Abraço!

G

foi mal aê, como eu disse, nao sabia que tinha enviado a mensagem porque tinha dado um erro de conexão aqui…

Como eu disse, depois que vi que tinham uns erros no método que enviei, saquei que as modificações é que tinham bugado as coisas. Aí nem olhei mais nada. Mas se ele tem 2 matrizes, então uma ta sem usar. Eu pensei que a classe recebia uma matriz e ele tinha feito só pra poder ter uma classe tipo Utils pra poder manipular a matriz…

Mas aí realmente, tem uma matriz só voando, sem fazer nada…

Se vc prestar mais atenção, vai terminar o que precisa repidinho, oliver!

olivercld

estou quase conseguindo,

consegui metodo inverter ou trocar a s triangulares agora falta o de trocar a 3 linha apenas com a nona coluna como disseram e meio estranho … bom estou caindo de sono.

valeu galeraaa abraços

olivercld

esta dando um erro na hora de rodar a matriz
aqui na classe estrutura da matriz na hora que implementei isso naodeu nem um erro e nem na hora de chamar mais depois que digitei os valres da matriz imprimiu a matriz blz, so que na hora de mostrar os restantes dos processos deu erro eu nao entendi porque deu errro

// troca 3 linha com 9º coluna
	public static int[][] trocaComColuna(int[][] matr, int Tam) {
		int temp = 0;
		for (int coluna = 0; coluna < Tam; coluna++) {

			temp = matr[2][coluna];
			matr[2][coluna] = matr[coluna][8];// aqui ta dando erro nao entendi.
			matr[coluna][8] = temp;

		}
		/*
		 * for (int linha = 0; linha < Tam; linha++) { for (int coluna = 0;
		 * coluna < Tam; coluna++) { temp[][] = matriz[linha][coluna];// erro
		 */
		return matr;
	}
// imprime valores trocados da terceira linha com 9 coluna
		System.out.println("troca da linha pela coluna");
		estMatriz.imprimeMatriz(EstruturaMatriz.trocaComColuna(matriz,dimMatriz));// ta dando erro na hora de chamar aqui e la

nao deu nem um erro na compilação mais na hora de rodar deu erro na hora de chamar aqui na classe main

Vingdel

olivercld:
esta dando um erro na hora de rodar a matriz
aqui na classe estrutura da matriz na hora que implementei isso naodeu nem um erro e nem na hora de chamar mais depois que digitei os valres da matriz imprimiu a matriz blz, so que na hora de mostrar os restantes dos processos deu erro eu nao entendi porque deu errro

// troca 3 linha com 9º coluna
	public static int[][] trocaComColuna(int[][] matr, int Tam) {
		int temp = 0;
		for (int coluna = 0; coluna < Tam; coluna++) {

			temp = matr[2][coluna];
			matr[2][coluna] = matr[coluna][8];// aqui ta dando erro nao entendi.
			matr[coluna][8] = temp;

		}
		/*
		 * for (int linha = 0; linha < Tam; linha++) { for (int coluna = 0;
		 * coluna < Tam; coluna++) { temp[][] = matriz[linha][coluna];// erro
		 */
		return matr;
	}
// imprime valores trocados da terceira linha com 9 coluna
		System.out.println("troca da linha pela coluna");
		estMatriz.imprimeMatriz(EstruturaMatriz.trocaComColuna(matriz,dimMatriz));// ta dando erro na hora de chamar aqui e la

nao deu nem um erro na compilação mais na hora de rodar deu erro na hora de chamar aqui na classe main

olivercld, pelo visto você não corrigiu o que eu falei de estar com duas matrizes sem necessidade, os métodos da classe EstruturaMatriz não precisam receber uma matriz como argumento, afinal a matriz está sendo criada dentro da propria classe. Não to entendendo como você ta raciocinando, você ta fazendo muuuita coisa desnecessária. Já estou com o código pronto aqui, o código está criando a matriz, trocando diagonal secundária por primária, trocando linha por coluna e trocando triângulos.

A respeito da troca de linha n por coluna m (linha por coluna com índices diferentes), conversei com um amigo que estuda matemática sobre isso e ele confirmou que isso não é possível, pois gera erro em dois índices da matriz.

Se você quiser o código pronto é só falar que posto aqui.

Abraço!

G

codigo pra trocar a linha pela coluna, era so o que tava faltando fazer :

int temp = -1;
        for (int i = 0; i < tamanho; i++) {
                temp = mat[2][i];
                mat[2][i] = mat[i][8];
                mat[i][8] = temp;
       }

eu acho que ja mandaram esse codigo, mas era so o que tava faltando e fiquei com vontade de fazer hehehe. da pra deixar parametrizado, pra nao ter que ser usado so por uma matriz 10x10, mas por qualquer uma.
no caso de falar com o cara da matematica, acho que o exercicio nao requer conhecimento matematico, é só pra estudar como mexer com matrizes, mesmo. entao nao tem problema se perder um valor, é só pra questao de estudo. nao precisa esquentar com isso.

todos os algoritmos tao ai, so que precisa ver ai o que tu ta fazendo, porque os erros gerados tao sendo causados pelas tuas modificações… =/

eu tava vendo essa coisa da matriz, realmente tu usa uma matriz na classe e uma no metodo principal. Entao a da classe fica sem ser usada.

Vingdel

gpmdf2:
codigo pra trocar a linha pela coluna, era so o que tava faltando fazer :

int temp = -1;
        for (int i = 0; i < tamanho; i++) {
                temp = mat[2][i];
                mat[2][i] = mat[i][8];
                mat[i][8] = temp;
       }

eu acho que ja mandaram esse codigo, mas era so o que tava faltando e fiquei com vontade de fazer hehehe. da pra deixar parametrizado, pra nao ter que ser usado so por uma matriz 10x10, mas por qualquer uma.
no caso de falar com o cara da matematica, acho que o exercicio nao requer conhecimento matematico, é só pra estudar como mexer com matrizes, mesmo. entao nao tem problema se perder um valor, é só pra questao de estudo. nao precisa esquentar com isso.

todos os algoritmos tao ai, so que precisa ver ai o que tu ta fazendo, porque os erros gerados tao sendo causados pelas tuas modificações… =/

eu tava vendo essa coisa da matriz, realmente tu usa uma matriz na classe e uma no metodo principal. Entao a da classe fica sem ser usada.

Realmente, gpmdf2, não requer conhecimento matemático pois estamos trabalhando com raciocínio lógico, mas existe a possibilidade de fazer o algorítmo usando as propriedades matemáticas e se a prova real for feita com um algorítmo desse, com certeza todo resultado do olivercld vai estar errado. Essa é minha única preocupação.

Dia desses, encontrei um site que propoe problemas e os visitantes tem que resolver com um algorítmo, no final o site apresenta um código com raciocínio lógico e um outro com propriedades matemáticas sendo aplicadas, achei muito 10.

Abraço!

olivercld

certo. mais me explica o uso do temp -1; ?? porque esta iniciando ele com - 1.

olivercld

[list]
olivercld, pelo visto você não corrigiu o que eu falei de estar com duas matrizes sem necessidade, os métodos da classe EstruturaMatriz não precisam receber uma matriz como argumento, afinal a matriz está sendo criada dentro da propria classe.
[/list]

eu ja tirei so que quando eu tiro da erros…

olivercld
Matriz:

Exception in thread main java.lang.NullPointerException

at EstruturaMatriz.imprimeMatriz(EstruturaMatriz.java:86)

at Matriz.main(Matriz.java:29)

olha o erro que dá.

Vingdel
olivercld:
Matriz: Exception in thread "main" java.lang.NullPointerException at EstruturaMatriz.imprimeMatriz(EstruturaMatriz.java:86) at Matriz.main(Matriz.java:29)

olha o erro que dá.

Esse erro está acontecendo pois você está trabalhando de forma errada. Você já tem uma instância da classe EstruturaMatriz, então você não tem que chamar o método assim:
EstruturaMatriz.imprimeMatriz();
Você tem que chamar ele assim:
imprimeMatriz();
Mas meu amigo, na verdade, para ficar tudo certinho, você vai ter que fazer seu código todo trabalhar com a matriz criada pela classe EstruturaMatriz, ou seja, você vai ter que reformular todos os métodos além de criar os que faltam.

Basicamente você vai ter que tornar os métodos da clase EstruturaMatriz métodos sem valor de retorno (void), além disso você vai tirar os argumentos de todos os métodos, pois esses argumentos estão servindo para receber a matriz que está vindo classe Matriz.

Por exemplo o método para trocar a linha 3 pela coluna 9 ficaria assim:

public void trocaColuna() {   
	int temp = 0;   
	for (int indice = 0; indice < dimensao; indice++) {  
		temp = matriz[2][indice]; 
		matriz[2][indice] = matriz[indice][8];
		matriz[indice][8] = temp;

	}
}

[color=red]OBS.:[/color] Esse método pode ser mais genérico, se você passar como parâmetros os índices da linha e da coluna para ele. Assim ele não trabalharia com índices fixos como como está acima.

Daí você chamaria ele no método main da classe Matriz simplesmente assim:

trocaColuna();

Abraço!

olivercld

estou tentando…

G

na verdade ele pode chamar dessa forma : EstruturaMatriz.metodoQualquer(parametros);

bastando pra isso trabalhar com um metodo estatico.

Mas concordo que como e classe se chama EstruturaMAtriz e ele tem um matriz dentro dela, o melhor seria instanciar a classe e chamar o metodo. O que pode ta acontecendo é que ele ta usando uma das matrizes erroneamente.

se ele usou o metodo da forma que passei, com a assinatura recebendo uma matriz e o tamanho dela, nao tem como dar errado. a nao ser que ele esteja passando uma matriz que nao esteja instanciada (que seja null).

o problema que ele mostrou é que tinha um objeto nulo, ne? entao tem que ser a matriz. A nao ser que ele tenha feito mais alguma alteração que bugou o metodo… =/

Vingdel

Olivercld,

Segue o código com tudo que você precisa, use o código da melhor forma possível, porem só peço que mantenha os créditos do mesmo.

Classe com o métodos que manipulam a Matriz:
/* 
 * Construção de um Matriz 
 * Autor: Delano Lima (Vingdel)
 * Email: [email removido]
 * Data: 04/05/2011
 */

import java.util.Scanner;
import java.util.Random;

public class EstruturaMatriz {
	Scanner entrada = new Scanner(System.in);
	Random numero = new Random();
	private int dimensao = 0;
	public int[][] matriz;
	// CONTRUTOR DA CLASSE
	public EstruturaMatriz(){
		System.out.println("Digite a dimensão da Matriz: ");
		dimensao = entrada.nextInt();

		matriz = new int[dimensao][dimensao];

		// POPULANDO A MATRIZ
		/*
		System.out.println("Leitura dos valores da matriz");
		for (int linha = 0; linha < dimensao; linha++) {
			for (int coluna = 0; coluna < dimensao; coluna++) {
				System.out.println("Digite valor da matriz na posicao ["
						+ (linha+1) + "][" + (coluna+1) + "]: ");
				matriz[linha][coluna] = entrada.nextInt();
			}
		} */
		for (int linha = 0; linha < dimensao; linha++) {
			for (int coluna = 0; coluna < dimensao; coluna++) {
				matriz[linha][coluna] = numero.nextInt(10);
			}
		}
	}

	// TROCA LINHA POR COLUNA [OK]
	// Processo só indicado para linha e coluna de mesmo índice
	public void trocaLinhasColunas(){
		System.out.println("Digite a linha: ");
		int linha = entrada.nextInt();
		System.out.println("Digite a coluna: ");
		int coluna = entrada.nextInt();
		for(int indice = 0; indice < dimensao; indice++ ){
			int temp = matriz[linha-1][indice];
			matriz[linha-1][indice] = matriz[indice][coluna-1];
			matriz[indice][coluna-1] = temp;
		}
	}
	
	// TROCA DIAGONAL SECUNDARIA COM PRIMARIA [OK]  
	public void trocaDiagonais(){  
		for (int linha = 0; linha < dimensao; linha++)  
			for (int coluna = 0; coluna < dimensao; coluna++) {  
				if (linha + coluna == (dimensao-1)) {
					int temp = matriz[linha][(dimensao-1)-linha];
					//System.out.println(linha+""+coluna+": "+temp);
					matriz[linha][(dimensao-1)-linha] = matriz[linha][linha];
					matriz[linha][linha] = temp;
				}
			}
	}
	
	// TROCA TRIANGULOS
	public void trocaTriangulos(){
		int temp;
		for(int linha = 0; linha < dimensao; linha++)
			for(int coluna = 0; coluna < dimensao; coluna++){
				if(coluna > linha){
					temp = matriz[linha][coluna];
					matriz[linha][coluna] = matriz[coluna][linha]; 
					matriz[coluna][linha] = temp; 
				}	
			}
	}

	// IMPRIME MATRIZ [OK]
	public void imprimeMatriz(){
		System.out.println("Matriz: ");
		for (int linha = 0; linha < dimensao; linha++){
			System.out.print("|");
			for (int coluna = 0; coluna < dimensao; coluna++) {
				System.out.print(" "+matriz[linha][coluna]+" ");
			}
			System.out.print("|");  
			System.out.println();
		}
	}
}
Classe com o método main:
/* 
 * Construção de um Matriz 
 * Autor: Delano Lima (Vingdel)
 * Email: [email removido]
 * Data: 04/05/2011
 */

public class Matriz {

	public static void main(String[] args) {
		EstruturaMatriz estMatriz = new EstruturaMatriz();
		estMatriz.imprimeMatriz();

		System.out.println("Troca diagonais");
		estMatriz.trocaDiagonais();
		estMatriz.imprimeMatriz();

		System.out.println("Troca linha por coluna\n");
		estMatriz.trocaLinhasColunas();
		estMatriz.imprimeMatriz();

		System.out.println("Troca triangulos");
		estMatriz.trocaTriangulos();
		estMatriz.imprimeMatriz();
	}
}
Meu camarada, observe cada linha das duas classes e entenda o que cada uma faz, estude, mas estude bastante, pois querer fazer o que for em JAVA, sem ao menos uma base, é quase impossível. Portanto pegue umas apostilas que se encontram pela net, consulte sempre a documentação JAVA e pratique para que você possa estar sempre evoluindo.

Qualquer coisa que não tenha ficado entendido é só perguntar.

Abraço e boa sorte!

olivercld
// TROCA LINHA POR COLUNA [OK]   
    // Processo só indicado para linha e coluna de mesmo índice   
    public void trocaLinhasColunas(){   
        System.out.println("Digite a linha: ");  // vai pedir para digitar a matriz novamente pq? 
        int linha = entrada.nextInt();   
        System.out.println("Digite a coluna: ");   
        int coluna = entrada.nextInt();   
        for(int indice = 0; indice < dimensao; indice++ ){   
            int temp = matriz[linha-1][indice];   // porque linha -1 ?   
            matriz[linha-1][indice] = matriz[indice][coluna-1];    //coluna -1 ?  
            matriz[indice][coluna-1] = temp;   
        }   
    }   

me explique onde eu comentei nao entendi.
obrigado

[list]
estude, mas estude bastante, pois querer fazer o que for em JAVA, sem ao menos uma base, é quase impossível. Portanto pegue umas apostilas que se encontram pela net, consulte sempre a documentação JAVA e pratique para que você possa estar sempre evoluindo
[/list]

concordo com voçe, não e falta de praticar, eu pratico tenho apostilas tenho agora o livro, eu tenho dificuldade, o que prejudica e o tempo e conciliar trabalho, trabalhos de faculdade de outras materias, provas o tempo que vou ter para estudar melhor vai ser nas ferias de julho e dezembro, vou continuar porque quero aprender se eu estudar rpaticar e rpaticar e nao conseguir evoluir bom acho que é o caso de eu partir pra outra area. Bom não sei bom o tempo dirá isso.
obrigadão a vcs que me ajudaram.

Vingdel

olivercld, boa tarde!

Segunda vez que vejo você perguntando do “-1”, você tem implicância com o “-1”? rsrsrs, brincadeira!!!

Nessas linhas:System.out.println("Digite a linha: "); // vai pedir para digitar a matriz novamente pq? int linha = entrada.nextInt();Simplemente pede para o usuário digitar a linha que ele quer trocar, para o seu exercício basta digitar “3”.

Caso você queira mudar isso para que não peça a linha basta você substituir essas duas linhas por:int linha = 3;O mesmo aconte com a coluna.

Agora quanto ao seu “-1”… hehhee int temp = matriz[linha-1][indice]; // porque linha -1 ? matriz[linha-1][indice] = matriz[indice][coluna-1]; //coluna -1 ? matriz[indice][coluna-1] = temp;Nas linhas acima, as variáveis linha e coluna são reduzidas em -1 pois alí tratam do índice, ou seja, como a linha é a 3 o índice tem que ser 2. linha-1 seria 3-1. entendeu? Lembre-se que os índices dos arrays em java começam de 0 (zero) e a matriz começa em 1.

O mesmo aconte com a coluna.

Abraço!

olivercld

entendido vou estudar mais isso ai, é seguinte la onde eu vou pedir para o usuario digitar alinha e a coluna que eu qeuro so uma duvida caso eu queira por exemplo quero a 5 linha troca com a 7 coluna por exemplo vai funcionar vai nhe?

Vingdel

Bom dia, olivercld!

Sim, vai funcionar.

Foi por isso que fiz assim, para funcionar com qualquer linha/coluna, desde que seja menor que a dimensão da matriz.

Inclusive esse código pode ser melhorado nesse sentido, de forma que se o usuário digite uma linha/coluna maior que a dimensão da matriz gere um alerta e volte a pedir a linha/coluna correta.

Abraço!

G

eu só teria algumas observações a fazer…

Como vc ainda ta meio enrolado em java, é bom lembrar que o exercício que foi pedido é pra pegar um linha e uma coluna estática, que são a linha 2 e a coluna 8, ne? ou a 2 e a 9? algo assim…

entao quando vc coloca esse codigo pra o usuario entrar com a linha e a colunas que ele quer, ficameio perigoso, porque ele pode colocar QUALQUER valor. se ele coloca 100 e manda o algoritmo rodar, vai bugar! Se teu professor for meio chato ele vai fazer esse teste e ai vc chega la cheio de moral e tal e o negocio buga…

segundo, já que estao falando de melhorias, esses algoritmos aqui ainda podem ser melhorados :
TROCA DIAGONAL SECUNDARIA COM PRIMARIA - da pra fazer com UM “for” so :

public static void trocaDiagonais(int[][] mat, int tamanho) {
        int diagonalSecundaria = tamanho - 1;
        int temp = -1;

        for (int i = 0; i < tamanho; i++) {
            temp = mat[i][i];
            mat[i][i] = mat[i][diagonalSecundaria];
            mat[i][diagonalSecundaria] = temp;

            diagonalSecundaria--;
        }
    }

isso é importante pra desempenho.

em TROCA LINHA POR COLUNA:
na linha int temp = matriz[linha-1][indice];, essa variavel int temp ta sendo criada dentro do for. isso nao faz com que a cada iteração java tente alocar um espaço de memoria pra ela, nao? porque ela ta sendo CRIADA dentro do for… ela pode ficar fora do for (ser criada fora e apenas usada no for). tb nao é preciso calcular esse
(linha-1) toda vez, mas isso é só uma operação a mais, entao nao tem tanta importancia…

na minha visao o bug de pedir a linha e coluna e o outro melhoramento la de um for so sao as coisas mais criticas…

olivercld

tenho muito a aprender com vcs obrigado pela ajuda tirar as duvidas os erros e tudo, sem querer citar nomes e desmerecer ninguem eu agradeço a todos.

Vingdel

Disponha, olivercld!

Estamos aqui para aprender juntos.

Surgindo mais dúvidas é só postar que garanto que vai haver alguém para te ajudar.

Se seu problema já estiver resolvido, por favor, edite o nome do tópico deixando-o assim: “[RESOLVIDO] Problema de lógica na matriz”, dessa forma esse tópico torna-se uma referência para alguém com a mesma dúvida caracterizando que a solução foi encontrada.

Abraço e bons estudos!

olivercld

´so um pequeno problema vc ja inicializou a matriz co m random e eu quero que o usuario digite ela toda, fiu tentar arrumar nao cnsegui du alguns erros…

quando tiver quase la eu edito pode deixar.

G

cara, tu ja tem esse codigo, rapaz!

lembra q te mandaram la um que le a matriz? sei la em que metodo tinha.

tu le o tamanho do pelo teclado e cria matriz[tamanho][tamanho]

depois tu faz:

for (int i = 0; i < tamanho; i++) 
     for (int j = 0; j < tamanho; j++) {
         le um numero aqui 
         matriz[i][j] = numero;
     }

foi mal mas eu nao lembro como e que le do teclado, quase nao faço isso… mas tb ja tem em algum lugar por ai nos exemplos.

Vingdel

olivercld:
´so um pequeno problema vc ja inicializou a matriz co m random e eu quero que o usuario digite ela toda, fiu tentar arrumar nao cnsegui du alguns erros…

quando tiver quase la eu edito pode deixar.

oliver, bom dia!
Amigão, no código que te mandei tem isso feito já, só está como comentário, você só precisa descomentar. Fiz a parte com Random só para agilizar nos testes, afinal ficar digitando uma matriz com dimensão maior que 3 ou 4 toda vez que for testar é chato demais… rsrrs

Seguinte no códifo que te mandei está assim, ache essa parte lá:

// POPULANDO A MATRIZ /* System.out.println("Leitura dos valores da matriz"); for (int linha = 0; linha < dimensao; linha++) { for (int coluna = 0; coluna < dimensao; coluna++) { System.out.println("Digite valor da matriz na posicao [" + (linha+1) + "][" + (coluna+1) + "]: "); matriz[linha][coluna] = entrada.nextInt(); } } */ for (int linha = 0; linha < dimensao; linha++) { for (int coluna = 0; coluna < dimensao; coluna++) { matriz[linha][coluna] = numero.nextInt(10); } }

Para tirar o Random e o programa pedir os valores ao usuário, você deleta os dois for que estão fora do comentário e descomenta o que sobrou. Vai ficar assim:

// POPULANDO A MATRIZ System.out.println("Leitura dos valores da matriz"); for (int linha = 0; linha < dimensao; linha++) { for (int coluna = 0; coluna < dimensao; coluna++) { System.out.println("Digite valor da matriz na posicao [" + (linha+1) + "][" + (coluna+1) + "]: "); matriz[linha][coluna] = entrada.nextInt(); } }

Abraço!

olivercld

foi mal gente, realmente nao parei essa ansiedade me atrapalha… vou dormi uma semana dormindo quas dia amanheçendo…

G

cara, tu ta mt estressado

faz o seguinte : compra uma guitarra, uma pedaleira bem massa p colocar uns efeitos e pega umas musicas p tocar huahuhauhua

relaxa ai, véi!

olivercld

pois é a ansiedade de aprender algo, ta me matando corpo nao responde mais so ando cansado, vou com calma estudando aos poucos rs e muita coisa acumula trabalhos ai fico doido hehehe.

no caso de tocar guitarra putz ai ferrou eu nao sei, ja toquei bateria.

ok vou colocar tópico resolvido fica em aberto para outros que tiverem duvidas . estou fazendo agora a matriz determinante hehe.

valeu.

Criado 23 de abril de 2011
Ultima resposta 7 de mai. de 2011
Respostas 57
Participantes 4