Dada uma matriz real \(A_{m \times n}\), verificar se existem elementos repetidos em \(A\).
Obs.: Esse problema é o exercício 4 da lista de exercícios sobre matrizes.
#### Solução
#include <stdio.h>
#define MAX 100
#define TRUE 1
#define FALSE 0
int main() {
float A[MAX][MAX], num;
int m, n, i, j, k, l, achou;
printf("Digite o numero de linhas e o número de colunas da matriz A: ");
scanf("%d %d", &m, &n);
for (i = 0; i < m; i++)
for (j = 0; j < n; j++){
printf("Digite o elemento da posicao (%d,%d): ", i+1, j+1);
scanf("%f", &num);
A[i][j] = num;
}
achou = FALSE;
for (i = 0; !achou && i < m; i++)
for (j = 0; !achou && j < n; j++) {
/* Procura o elemento da posicao (i,j) nas posicoes seguintes da matriz */
k = i;
l = j + 1;
while (!achou && k < m) {
while (!achou && l < n) {
if (A[i][j] == A[k][l])
achou = TRUE;
l++;
}
l = 0;
k++;
}
}
if (achou)
printf("Há elementos repetidos na matriz.\n");
else
printf("Não há elementos repetidos na matriz.\n");
return 0;
}
Um sistema de equações lineares com \(nl\) equações pode ser representado por uma matriz \(A_{nl \times nc}\), onde cada equação tem \(nc\) coeficientes.
Um vetor real \(X\) com \(nc\) elementos é apresentado como resultado de um sistema de equações lineares \(A X = B\), onde \(B\) é um vetor real com \(nl\) elementos.
Escreva um programa que leia \(A\), \(X\) e \(B\), e calcula e imprime o erro quadrático médio da solução \(X\), dado por \(\sum_i{(((AX)[i] - B[i])^2) / nl}\).
Para resolver esse problema, implemente e utilize as seguintes funções:
void le_vetor(float V[MAX], int nc);
que lê \(nc\) reais e carrega em \(V\).
void le_vetor(float V[MAX], int nc){
int i;
printf("Digite %d numeros: ", nc);
for (i = 0; i < nc; i++)
scanf("%f", &V[i]);
}
void le_matriz(float M[MAX][MAX], int nl, int nc);
que lê \(nl x nc\) reais e carrega em \(M\).
Pode ser interessante utilizar a função do item (a).
void le_matriz(float M[MAX][MAX], int nl, int nc){
int i;
for(i = 0; i < nl; i++) {
printf("Linha %d da matriz\n", i);
le_vetor(M[i], nc);
}
}
void mult(float A[MAX][MAX], float X[MAX], float Y[MAX], int nl, int nc);
que recebe uma matriz real \(A_{nl \times nc}\) e um vetor real \(X\) com \(nc\) elementos, e devolve em \(Y\) o produto \(A \times X\).
void mult(float A[MAX][MAX], float X[MAX], float Y[MAX], int nl, int nc){
int i,j;
for (i = 0; i < nl; i++) {
Y[i] = 0;
for (j = 0; j < nc; j++)
Y[i] += A[i][j] * X[j];
}
}
#include <stdio.h>
#define MAX 100
void le_vetor(float V[MAX], int nc);
void le_matriz(float M[MAX][MAX], int nl, int nc);
void mult(float A[MAX][MAX], float X[MAX], float Y[MAX], int nl, int nc);
int main(){
int nl, nc, i;
float A[MAX][MAX], X[MAX], B[MAX], Y[MAX], soma;
printf("Digite o numero de equacoes no sistema: ");
scanf("%d", &nl);
printf("Digite o numero de coeficientes de cada equacao: ");
scanf("%d", &nc);
printf("Entrada dos elementos da matriz A de coeficientes do sistema\n");
le_matriz(A,nl, nl);
printf("Entrada dos elementos do vetor X\n");
le_vetor(X,nc);
printf("Entrada dos elementos do vetor B\n");
le_vetor(B,nl);
mult(A,X,Y,nl,nc);
soma = 0;
for (i = 0; i < nl; i++)
soma += (Y[i] - B[i]) * (Y[i] - B[i]);
printf("O erro quadratico medio da solucao X eh: %f", soma/nl);
return 0;
}
Dizemos que uma matriz quadrada inteira é um quadrado mágico se a soma dos elementos de cada linha, a soma dos elementos de cada coluna e a soma dos elementos das diagonais principal e secundária são todas iguais.
Exemplo: A matriz
é um quadrado mágico.
Dada uma matriz quadrada \(A_{n \times n}\) , verificar se \(A\) é um quadrado mágico.
Obs.: Esse problema é o exercício 7 da lista de exercícios sobre matrizes.
#### Solução
#include <stdio.h>
#define MAX 100
#define TRUE 1
#define FALSE 0
void le_matriz(int M[MAX][MAX], int nl, int nc);
void le_vetor(int V[MAX], int nc);
int main(){
int n, i, j, soma_inicial, soma1, soma2, igual = TRUE;
int A[MAX][MAX];
printf("Digite a ordem da matriz A: ");
scanf("%d", &n);
if (n == 0)
return 0;
printf("Entrada dos elementos da matriz A\n");
le_matriz(A, n, n);
soma_inicial = 0;
soma2 = 0;
for (j = 0; j < n; j++){
soma_inicial += A[0][j];
soma2 += A[j][0];
}
igual = soma_inicial == soma2;
for (i = 1; igual && i < n; i++) {
/* soma1 => contem a soma da linha i
soma2 => contem a soma da coluna i */
soma1 = 0;
soma2 = 0;
for (j = 0; j < n; j++){
soma1 += A[i][j];
soma2 += A[j][i];
}
igual = (soma1 == soma2 && soma2 == soma_inicial);
}
if (igual){
/* Calcula a soma das diagonais*/
soma1 = 0;
soma2 = 0;
for (j = 0; j < n; j++){
soma1 += A[j][j];
soma2 += A[j][n-j-1];
}
igual = (soma1 == soma2 && soma2 == soma_inicial);
}
if (igual)
printf("A eh um quadrado magico!\n");
else
printf("A nao eh um quadrado magico!\n");
return 0;
}
void le_vetor(int V[MAX], int nc){
int i;
printf("Digite %d numeros: ", nc);
for (i = 0; i < nc; i++)
scanf("%d", &V[i]);
}
void le_matriz(int M[MAX][MAX], int nl, int nc){
int i;
for(i = 0; i < nl; i++) {
printf("Linha %d da matriz\n", i);
le_vetor(M[i], nc);
}
}
Dizemos que uma matriz \(A_{n \times n}\) é um quadrado latino de ordem \(n\) se em cada linha e em cada coluna aparecem todos os inteiros \(1,2,3,\ldots,n\) (ou seja, cada linha e coluna é permutação dos inteiros \(1,2,\ldots,n\)).
Escreva uma função que recebe como parâmetros um inteiro \(n\), um vetor \(V\) com \(n\) inteiros e verifica se em \(V\) ocorrem todos os inteiros de \(1\) a \(n\).
Usando a função acima, verifique se uma dada matriz inteira \(A_{n \times n}\) é um quadrado latino de ordem \(n\).
#include <stdio.h>
#define MAX 100
#define TRUE 1
#define FALSE 0
void le_matriz (int mat[][MAX], int nlinhas, int ncolunas);
void imprime_matriz (int mat[][MAX], int nlinhas, int ncolunas);
int pertence(int v[], int n, int elemento);
int eh_latina(int v[], int n);
void main (void)
{
int i, j, n, eh_quad_latino, v[MAX], m[MAX][MAX];
printf ("Entre com a dimensao da matriz: ");
scanf ("%d", &n);
le_matriz (m,n,n);
printf("\n\nMatriz lida:\n");
imprime_matriz (m,n,n);
eh_quad_latino = TRUE; /* a matriz e' um quadrado latino ate' que
* se prove o contrario
*/
for (i = 0; i < n && eh_quad_latino == TRUE; i++)
/* verifica se a linha m[i] da matriz e' "latina" */
eh_quad_latino = eh_latina(m[i], n);
for (j = 0; j < n && eh_quad_latino == TRUE; j++)
{
/* verifica se a coluna j da matriz m e' "latina" */
/* copia coluna j para o vetor auxiliar v */
for (i = 0; i < n; i++)
v[i] = m[i][j];
eh_quad_latino = eh_latina(v,n);
}
if (eh_quad_latino == TRUE)
printf("\n\nA matriz e' um quadrado latino.\n");
else
printf("\n\nA matriz nao e' um quadrado latino.\n");
return 0;
}
/*
* Leitura de uma matriz inteira mat de dimensao nlinhas x ncolunas
*/
void le_matriz (int mat[][MAX], int nlinhas, int ncolunas)
{
int i, j;
for (i = 0; i < nlinhas; i++)
{
/* leitura da i-esima linha */
printf("Entre com os elementos da linha no. %d\n", i+1);
for (j = 0; j < ncolunas; j++)
scanf("%d", &mat[i][j]); /* nao esqueca o '&'! */
}
}
/*
* Imprime uma matriz mat de dimensao nlinhas x ncolunas
*/
void imprime_matriz (int mat[][MAX], int nlinhas, int ncolunas)
{
int i, j;
for (i = 0; i < nlinhas; i++)
{
/* imprime a i-esima linha */
for (j = 0; j < ncolunas; j++)
printf("%4d", mat[i][j]);
/* muda de linha */
printf("\n");
}
}
/*
* Funcao que recebe como parametro um vetor v de tamanho n
* e devolve TRUE (1) se o o parametro elemento pertence ao vetor;
* caso contrario a funcao devolve FALSE (0).
*/
int pertence(int v[], int n, int elemento)
{
int i;
for (i = 0; i < n; i++)
if (v[i] == elemento)
return TRUE;
return FALSE;
}
/*
* Funcao que recebe como parametros um vetor v e um inteiro n
* e retorna TRUE (1) se todos os inteiros entre 1 e n ocorrem nas
* n primeiras posicoes do vetor v, caso contrario a funcao
* retorna FALSE (0).
*/
int eh_latina (int v[], int n)
{
int i;
for (i = 0; i < n; i++)
if (pertence(v,n,i+1) == FALSE)
return FALSE;
return TRUE;
}