Gabarito de Lista de Exercícios
Reescreva o exemplo acima, realizando a cada leitura um teste para ver se a dimensão do vetor não foi ultrapassada. Caso o usuário entre com 100 números, o programa deverá abortar o loop de leitura automaticamente. O uso do Flag não deve ser retirado.
Solução:
Basta acrescentar ao teste no final do loop, uma verificação
se contador <= 100.
#include <stdio.h>
main ()
{
int num[100]; /* Declara um vetor de inteiros de 100 posicoes
*/
int count=0;
int totalnums;
do
{
printf ("\nEntre com
um numero (-999 p/ terminar): ");
scanf ("%d",&num[count]);
count++;
} while ((num[count-1]!=-999)&&
(count <= 100) );
totalnums=count-1;
printf ("\n\n\n\t Os números que você digitou foram:\n\n");
for (count=0;count<totalnums;count++)
{
printf (" %d",num[count]);
}
}
Solução:
Aí segue o programa segundo o enunciado requere. Uma string
para cada palavra. Logo em seguida, é apresentada uma solução
para o exercício com recursos mais avançados e código
mais compactado.
/* Le 5 strings: Versao 1 ----------------------------*/
#include <stdio.h>
#include <string.h>
#define TAM 15
main()
{
char str1[TAM], str2[TAM], str3[TAM], str4[TAM], str5[TAM];
char str[TAM*5];
int aux;
/* Le todas as strings */
printf("\n\n Digite 5 palavras, teclando <ENTER> ao final de
cada uma:\n");
gets(str1);
gets(str2);
gets(str3);
gets(str4);
gets(str5);
/* Zera (inicializa) a string str, colocando um '\0' logo na
primeira posicao..
*/
str[0] = '\0';
/* Concatena as strings */
strcat(str, str1);
strcat(str, str2);
strcat(str, str3);
strcat(str, str4);
strcat(str, str5);
/* Apresenta o resultado */
printf("\n\n Resultado: %s\n",str);
}
-------------------------------------------------------
/* Le 5 strings: Versao 2 ----------------------------*/
#include <stdio.h>
#include <string.h>
#define TAM 15
#define MAX 5
main()
{
char palavra[TAM], frase[TAM*MAX];
int i;
/* Inicializa a string frase */
frase[0] = '\0';
printf("\n\n Digite 5 palavras, teclando <ENTER> ao final de cada uma:\n");
/* Le todas as strings */
for (i=0; i<MAX; i++)
{
gets(palavra);
strcat(frase, palavra);
}
/* Apresenta o resultado */
printf("\n\n Resultado: %s\n",frase);
}
Solução:
A solução deste problema é parecida com o anterior,
porém mais complicada. Vamos por partes...
#include <stdio.h>
#include <string.h>
#define TAM 15
#define MAX 15
main()
{
char matriz[TAM][MAX], str[TAM*MAX];
int acumula, i;
/* Primeiro, inicializamos str */
str[0] = '\0';
printf("\n\n Digite 15 palavras, teclando <ENTER> ao final de
cada uma:\n");
for (i=0; i<TAM; i++)
{
/* Trata do tamanho das strings: Se for maior que
o tamanho
maximo, refaz a leitura... */
do { gets(matriz[i]); } while ( ( strlen(matriz[i])
) > MAX);
strcat(str, matriz[i]);
}
/* Apresenta o resultado */
printf("\n\n Resultado: %s\n",str);
}
#include <stdio.h>
#include <string.h>
#define TAM 20
main ()
{
char s[TAM];
int c, i, j;
for (i=0, j=strlen(s)-1; i<j; i++, j--) /* Atencao a mudanca..*/
{
c = s[i];
s[i] = s[j];
s[j] = c;
}
}
Solução:
A função inverte a string fornecida. Assim, obtém-se:
a) "Ah! Eu to maluco!" => "!oculam ot uE !hA"
b) "5*4+(3^3)+4*5" =>
"5*4+)3^3(+4*5"
Comentários:
- a função começa com i no início
e j no final da string. A medida que i incrementa e j
decrementa, o conteúdo das posições i e j
é trocado, resultando na string invertida.
- repare que a função é válida para strings
de comprimento par ou ímpar: Se for par, existirão 2 elementos
medianos, que serão trocados; se for ímpar, ao atingir o
elemento mediano, a string já estará toda invertida.
- todo string é terminado com \0 (caracter nulo), que não
é contado pela função strlen(). Se um string s
possui n caracteres (descontando o \0), strlen(s) = n, e existirão
elementos no string de s[0] ate s[n-1].
Exercicio 2:
O que imprime o programa a seguir? Tente entendê-lo e responder.
A seguir, execute-o e comprove o resultado.
# include <stdio.h>
main()
{
int t, i, M[3][4];
for (t=0; t<3; ++t)
for (i=0; i<4; ++i)
M[t][i] = (t*4)+i+1;
for (t=0; t<3; ++t)
{
for (i=0; i<4; ++i)
printf ("%3d ", M[t][i]);
printf ("\n");
}
}
Solução:
Este programa carrega uma matriz bidimensional 4x3 com os números
de 1 a 12, e escreve-os linha por linha. Assim, M[0][0]=1, M[0][1]=2, M[0][2]=3,
M[0][3]=4, M[1][0]=5 e assim por diante. O valor de M[2][3], última
posição, sera' 12.
Comentários:
Matrizes bidimensionais são armazenadas em uma matriz linha-coluna,
onde o primeiro índice indica a linha e o segundo, a coluna. Isto
significa que o índice mais a direita varia mais rapidamente que
o índice mais a esquerda quando acessamos os elementos da matriz
na ordem em que eles estão realmente armazenados na memória.
Exercicio 3:
Faça um programa que ordene um vetor de inteiros de N
posições. Para isto você precisará usar um loop.
Verifique o número de iterações até que o programa
consiga finalmente ordenar o vetor (sugestões: use N=6, N=8 e N=12).
Solução:
Este é um dos problemas clássicos de computação.
Ordenação de vetores. Existem vários algorítmos
para este tipo de aplicação, que apresentam diferentes níveis
de otimização na resolução do problema. O algorítmo
usado aqui não é dos melhores mas tem a vantagem de ser facilmente
entendido. Para cada posição do vetor o programa faz um loop.
A cada vez que o loop e rodado, procura-se o menor valor a partir de onde
o vetor ainda não esta ordenado. Quando este valor é encontrado,
ele é colocado na primeira posição 'desordenada',
e o valor que estava lá é levado para onde foi tirado o outro.
Quando o programa acaba de varrer o vetor, ele está ordenado.
O número de iterações é N+(N-1)+(N-2)+..+1.
#include <stdio.h>
#define N 12
main()
{
int vet[N] = { 9, 7, 5, 4, 2, 1, 5, 3, 10, 15, 2, 0};
int i, j, mark;
int menor, contador =0;
/* Apresenta o vetor inicialmente... */
printf("\n\nVetor Inicial: ");
for (i=0; i<N; i++)
printf("\n%d", vet[i]);
/* Processa o vetor */
for(mark =0 ; mark<N ; mark++)
{
menor = 1000000;
for(j=mark; j<N; j++)
{
if (menor > vet[j])
{
menor = vet[j];
vet[j] = vet[mark];
vet[mark] = menor;
}
contador++;
}
}
/* Apresenta os resultados */
printf("\n\nVetor final: ");
for (i=0; i<N; i++)
printf("\n%d", vet[i]);
printf("\nIteracoes: %d", contador);
}
Solução:
/* --------------------------------------------------------
Multiplicacao de Matrizes: Versao 1 --------------------
Multiplica as matrizes 1 e 2, colocando o resultado
na
matriz 3
--------------------------------------------------------
*/
#include <stdio.h>
# define MAX_DIM 10 /* Dimensao maxima */
main()
{
int mat1[MAX_DIM][MAX_DIM], /* Matrizes 1 e 2 serao lidas
*/
mat2[MAX_DIM][MAX_DIM],
mat3[MAX_DIM][MAX_DIM]; /* Matriz 3: Resultado
da multiplicacao */
int linha1, coluna1; /* Dimensoes das matrizes */
int linha2, coluna2;
int linha3, coluna3;
int i, j, t;
printf("\n\n-------- Multiplicacao de Matrizes: Versao 1\n");
printf("------------------------------------------------\n");
/* Le e compara as dimensoes das matrizes.
So abandona o loop se as dimensoes forem validas
Atencao aa condicao...
*/
do
{
printf("\nDimensoes da matriz 1 (max %dX%d): ", MAX_DIM,
MAX_DIM);
scanf("%d%d", &linha1, &coluna1);
printf("\nDimensoes da matriz 2 (max %dX%d): ", MAX_DIM,
MAX_DIM);
scanf("%d%d", &linha2, &coluna2);
if ( ((linha1>MAX_DIM) || (coluna1>MAX_DIM) ||
(linha2>MAX_DIM) ||
(coluna2>MAX_DIM) )
&& (coluna1 != linha2) )
printf("\nDimensoes Invalidas! Tente de novo..\n");
} while ( ((linha1>MAX_DIM) || (coluna1>MAX_DIM) ||
(linha2>MAX_DIM)
|| (coluna2>MAX_DIM) )
&& (coluna1 != linha2) );
/* Le a Matriz 1: */
printf("\n\nDigite a Matriz 1:\n");
for (i = 0; i < linha1; i++)
{
printf("\n linha %d: %d elementos\n", i+1, coluna1);
for (j=0; j<coluna1; j++)
scanf("%d", &mat1[i][j]);
}
/* Le a Matriz 2: */
printf("\n\nDigite a Matriz 2:\n");
for (i = 0; i < linha2; i++)
{
printf("\n linha %d: %d elementos\n", i+1, coluna2);
for (j=0; j<coluna2; j++)
scanf("%d", &mat2[i][j]);
}
/* Imprime as Matrizes Lidas... */
printf("\n\n==> Matriz 1 :\n");
for (i = 0; i < linha1; i++)
{
for (j=0; j<coluna1; j++)
printf("%d\t", mat1[i][j]);
printf("\n");
}
printf("\n\n==> Matriz 2 :\n");
for (i = 0; i < linha2; i++)
{
for (j=0; j<coluna2; j++)
printf("%d\t", mat2[i][j]);
printf("\n");
}
/* Calculo da Matriz resposta, segundo o algoritmo apresentado
na lista de exercicios:
----------------------------------------------------------*/
/* Dimensoes da matriz de resposta: */
linha3 = linha1;
coluna3 = coluna2;
/* Primeiro e preciso iniciar a matriz com zeros..*/
for (i=0; i<linha3; i++)
for (j=0; j<coluna3; j++)
mat3[i][j] = 0;
/* Multiplicacao..*/
for(i=0; i< linha3; i++)
for(j=0; j< coluna3; j++)
for(t=0; t< linha2; t++) /* linha2,
que e igual a coluna1.. */
mat3[i][j] += mat1[i][t]*mat2[t][j];
/* Imprime a Matriz Calculada... */
printf("\n\n==> Matriz 3 :\n");
for (i = 0; i < linha3; i++)
{
for (j=0; j<coluna3; j++)
printf("%d\t", mat3[i][j]);
printf("\n");
}
}
Veja se você entendeu bem o programa, respondendo a você mesmo: Por que é necessário zerar a terceira matriz antes de comecar a multiplicação?
Exercício 2:
Refaça o programa da pagina c530.html,
ordenando as strings lidas por tamanho (menores primeiro, maiores depois).
Solução:
A solução usada será criar uma matriz que armazene
os tamanhos das strings e a posição de cada string no vetor
de strings. Em seguida, iremos reorganizar crescentemente a coluna relativa
aos tamanhos (fizemos um exercício destes estes dias), conservando
a relação com a coluna das posições no vetor
de strings.
Finalmente, iremos concatenar as strings. Veja o esquema abaixo...
----------------------------------------------------------------
i matriz de inteiros(tamanhos[][]) matriz de
*strings(str[])
----------------------------------------------------------------
0 [i=0] [strlen(str[i])
str[i]
1 [i=1] [strlen(str[i])
str[i]
:
14 [i=14] [strlen(str[i])
str[i]
/* -----------------------------------------------------
Ordena palavras: Versao 1.0 -------------------------
-----------------------------------------------------
*/
#include <stdio.h>
#include <string.h>
#define N 15
main()
{
char str[N][30], frase[N*30]; /* Matriz de strings,
string final */
int tamanho[2][N];
int i, j, aux;
int menor, aux2;
/* Leitura das strings ---------------------- */
printf("\n\nEntre com %d strings (max 30 caracteres):", N);
for( i=0; i<N; i++)
{
printf("\nstring %d: ",i);
gets(str[i]);
tamanho[0][i] = i;
if ((tamanho[1][i] = strlen(str[i])) > 30) i--; /*Checa
o tamanho*/
}
/* Ordena a matriz de tamnhos --------------- */
for(aux =0 ; aux<N ; aux++)
{
menor = 31;
/* nenhuma string e maior que 30 */
for(j=aux; j<N; j++)
if (menor > tamanho[1][j])
{
/* move o menor tamanho
para a posicao corrente */
menor = tamanho[1][j];
tamanho[1][j] = tamanho[1][aux];
tamanho[1][aux] = menor;
/* move indice do menor
tamanho */
aux2 = tamanho[0][j];
tamanho[0][j] = tamanho[0][aux];
tamanho[0][aux] = aux2;
}
}
/* Se voce desejar ver a matriz de tamanhos, basta tirar os
comentarios nesta parte...
*/
/* ---------------------------------
printf("\n\nMatriz de tamanhos.. ");
for (j=0; j<N; j++)
printf("\n%d\t%d", tamanho[0][j], tamanho[1][j]);
----------------------------------------------------
*/
/* Concatena as strings em ordem de tamanho... --------- */
frase[0] = '\0';
for(i=0; i<N; i++)
strcat(frase, str[tamanho[0][i]]);
/* Apresenta o resultado final... ---------------------- */
printf("\n\nResultado:\n%s", frase);
}