coluna_por_linha_explicado

#include <stdio.h>

main(){

int i,j,linhas,colunas,coluna_usuario,valor_usuario;
int matriz[3][3]={1,2,3,4,5,6,7,8,9},matriz_definida[50][50],aux[50][50];

/*Vamos imprimir a primeira matriz normalmente.*/
puts("PRIMEIRA MATRIZ\n");

for(i=0;i<=2;i++){
    puts("\n");
    for(j=0;j<=2;j++)
        printf(" %d ",matriz[i][j]);
}
puts("\n");
puts("\n");

/*Agora vamos imprimir uma matriz, onde todas as colunas dessa matriz são iguais à 2ª coluna da primeira matriz.*/
puts("MATRIZ FORMADA COMPLETAMENTE PELA COLUNA 2 DA MATRIZ ANTERIOR\n");
for(i=0;i<=2;i++){
    puts("\n");
    for(j=0;j<=2;j++)
        printf(" %d ",matriz[i][1]);
}
puts("\n");

/*Percebe-se que a coluna 1 é o vetor-coluna[i][0], pois pega i linhas e só repete a coluna 1. Dessa forma,
pra imprimir uma matriz formada apenas pela coluna que você desejar, tem-se o algoritmo:
matriz[i][coluna desejada],
lembrando que aqui contamos desde a coluna 0 até a coluna 2, por causa do laço for.*/

puts("\n");
/*Aqui, tentamos imprimir essa matriz nova, formada apenas pela coluna 2, pelo número dois, só para fins de curiosidade.*/
puts("MATRIZ ACIMA, MULTIPLICADA POR DOIS\n");
for(i=0;i<=2;i++){
    puts("\n");
    for(j=0;j<=2;j++)
        printf(" %d ",matriz[i][1]*2);
}
puts("\n");
puts("\n");

/*Com esse raciocínio, podemos estender isso para o conceito de multiplicação da matriz por qualquer número,
 no algoritmo abaixo:
matriz[i][coluna desejada]*numero_desejado*/
/*Agora tentemos imprimir apenas uma coluna da matriz quadrada de ordem 3 (lembrando que o usuário pode entrar com uma
matriz de qualquer ordem*/

puts("COLUNA-ESPECIFICA DA PRIMEIRA MATRIZ. NO CASO, COLUNA 2\n");
for(i=0;i<=2;i++){
    puts("\n");
    for(j=1;j<=1;j++)
        printf(" %d ",matriz[i][1]);
}
puts("\n");

/*Com o algoritmo acima, conseguimos imprimir apenas uma coluna da matriz, ou seja, um vetor-coluna. No caso,
é o vetor-coluna respectivo à matriz[i][1]. Funciona dessa maneira: Criamos o laço for de i normalmente, segundo o
tamanho da matriz, e criamos o laço for do j, com j variando de 1 até j<=1. Assim, j sempre repetirá o laço na mesma
coluna. No caso, escolhemos a coluna 2, a segunda coluna.*/

/*O ponto crucial é tentar imprimir a PRIMEIRA MATRIZ com a coluna multiplicada no lugar da coluna original.*/

/*Primeiro definimos a matriz original sem a coluna especificada.*/
puts("\n");
/*Isso imprime a matriz[i][j] com a coluna [i][1] zerada.Primeiro, definimos a matriz auxiliar igual à matriz[i][j].*/
for(i=0;i<=2;i++){
    for(j=0;j<=2;j++)
        aux[i][j]=matriz[i][j];
}

/*Assim, podemos alterar o valor da matriz auxiliar, dizendo que ela será a matriz[i][j] menos a matriz[i][1], isso
tudo sem alterar o valor da matriz original. Desta forma, ela imprimirá a primeira matriz sem a coluna especificada.*/
for(i=0;i<=2;i++){
    for(j=1;j<=1;j++)
        aux[i][j]=matriz[i][j]-matriz[i][1];
}

puts("MATRIZ SEM A COLUNA DOIS\n");
for(i=0;i<=2;i++){
    puts("\n");
    for(j=0;j<=2;j++)
        printf(" %d ",aux[i][j]);
}
puts("\n");

/*Queremos agora outra coisa. Uma maneira de multiplicar a coluna especificada (coluna 2), por um valor (no caso:2).*/
/*Então, devemos determinar uma maneira de imprimir a nova aux[i][j] (agora sem a coluna específica) com a coluna nova
e multiplicada por 2. Em outras palavras:
aux[i][j]=matriz[i][j]-matriz[i][1]+matriz[i][1]*2.*/

/*O que ocorre acima é: a auxiliar é a matriz[i][j] sem a coluna específica + a coluna específica multiplicada por 2. Ou seja,
primeiro tira a coluna, fica zero, então, soma zero + a própria coluna que está sendo multiplicada por 2.*/

/*Primeiro, retornemos ao valor original da aux[i][j], pois alteramos ele no algoritmo anterior acima.*/
for(i=0;i<=2;i++){
    for(j=0;j<=2;j++)
        aux[i][j]=matriz[i][j];
}

/*Isso é para fins explicativos. Mas você não precisará ficar sempre alterando e retornando os valores originais da
sua matriz. Agora, o nosso novo algoritmo funcionará.*/
for(i=0;i<=2;i++){
    for(j=1;j<=1;j++)
        aux[i][j]=matriz[i][j]-matriz[i][1]+matriz[i][1]*2;
}
puts("\n");

puts("MATRIZ COM A COLUNA DOIS MULTIPLICADA POR 2\n");
for(i=0;i<=2;i++){
    puts("\n");
    for(j=0;j<=2;j++)
        printf(" %d ",aux[i][j]);
}
puts("\n");

/**###########################################################################################################**/
/**------------------------------ALGORITMO PARA UMA MATRIZ DE TAMANHO QUALQUER--------------------------------**/
/**###########################################################################################################**/

/*Temos agora todas as ferramentas para estender esse conceito para uma matriz qualquer definida pelo usuário. Sigamos a
lógica:

O usuário entrará com um número i de linhas e j de colunas. Assim, devemos ter as variáveis "linhas" e "colunas". Na hora
do laço de determinação da matriz, os "for" de i e j irão de 0 até <=linhas/colunas. Façamos o teste.*/

puts("\n");
puts("Entre com o numero de linhas da sua matriz\n");
scanf("%d",&linhas);
puts("Entre com o numero de colunas da sua matriz\n");
scanf("%d",&colunas);
puts("\n");

linhas=linhas-1;
colunas=colunas-1;

puts("\n");
puts("Defina os elementos de sua matriz\n");
for(i=0;i<=linhas;i++){
   for(j=0;j<=colunas;j++)
        scanf("%d",&matriz_definida[i][j]);
}
puts("\n");

puts("\n");
puts("MATRIZ QUALQUER DEFINIDA PELO USUARIO\n");
for(i=0;i<=linhas;i++){
    puts("\n");
    for(j=0;j<=colunas;j++)
        printf(" %d ",matriz_definida[i][j]);
}
puts("\n");

/*Já entendemos o conceito de coluna específica e valor específico a ser multiplicado por ela. Agora o usuário
define esse números. Então, devemos ter as variáveis: coluna_usuario e valor_usuario.*/
puts("Qual eh a coluna que voce quer multiplicar?\n");
scanf("%d",&coluna_usuario);
puts("Por qual valor voce quer multiplica-la?\n");
scanf("%d",&valor_usuario);

coluna_usuario=coluna_usuario-1;

/*Agora vamos definir essa matriz da forma que aprendemos acima. Então,ela é definida da linha i=0 até i<=linhas, e
da coluna j=0 até a coluna j<=coluna_usuario.*/
puts("\n");
puts("MATRIZ FORMADA APENAS DA COLUNA DITA ACIMA\n");
for(i=0;i<=linhas;i++){
    puts("\n");
    for(j=0;j<=colunas;j++)
        printf(" %d ",matriz_definida[i][coluna_usuario]);
}
puts("\n");

/*Fica simples multiplicar essa coluna por um número, no caso, valor_usuario.
Primeiro, retornemos ao valor original da aux[i][j] mais uma vez, já que ele já foi alterado.*/
for(i=0;i<=linhas;i++){
    for(j=0;j<=colunas;j++)
        aux[i][j]=matriz_definida[i][j];
}

/*Agora, façamos a operação que aprendemos lá em cima. Ou seja, tirar uma coluna específica da matriz digitada pelo usuário.*/
for(i=0;i<=linhas;i++){
    for(j=coluna_usuario;j<=coluna_usuario;j++)
        aux[i][j]=matriz_definida[i][j]-matriz_definida[i][coluna_usuario];
}
/*Imprimamos isso:*/
puts("\n");
puts("MATRIZ SEM A COLUNA ESPECIFICA\n");
for(i=0;i<=linhas;i++){
    puts("\n");
    for(j=0;j<=colunas;j++)
        printf(" %d ",aux[i][j]);
}
puts("\n");

/*Só falta repetir o processo para imprimir a auxiliar como a matriz[i][j] com a coluna especifica
 multiplicada pelo valor_usuario.*/
/*Como sempre, retornando o valor original da auxiliar:*/
for(i=0;i<=linhas;i++){
    for(j=0;j<=colunas;j++)
        aux[i][j]=matriz_definida[i][j];
}

/*Agora, aplicando o algoritmo conhecido de multiplicar por um valor específico:*/
for(i=0;i<=linhas;i++){
    for(j=coluna_usuario;j<=coluna_usuario;j++)
        aux[i][j]=matriz_definida[i][j]-matriz_definida[i][coluna_usuario]+matriz_definida[i][coluna_usuario]*valor_usuario;
}

/*E agora, imprimir essa matriz:*/
puts("\n");
puts("MATRIZ COM A COLUNA ESPECIFICA MULTIPLICADA PELO VALOR ESPECIFICO\n");
for(i=0;i<=linhas;i++){
    puts("\n");
    for(j=0;j<=colunas;j++)
        printf(" %d ",aux[i][j]);
}
puts("\n");

puts("-----------------------FIM------------------------");

system("pause");
return 0;

}