Curso de C

Gabarito de Lista de Exercícios

 Aula 4: Matrizes e strings

Clique aqui para acessar a Lista 4

 

Exercício 1: Página c510.html

Enunciado:
#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);
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]);
        }
}

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]);
        }
}
 
 

Exercício 1: Página c520.html

Enunciado:
Faça um programa que leia várias palavras pelo teclado, e armazene cada palavra em uma string. Depois, concatene todas as strings lidas numa única string. Por fim apresente esta como resultado ao final do programa.

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);
}
 
 

Exercício 1: Página c530.html

Enunciado:
Faça um programa que leia 15 strings e as armazene numa matriz de strings. Depois de lidas, as strings devem ser concatenadas numa só string (use um laço e verifique o tamanho das strings) e só então devem ser apresentadas na tela.

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);
}
 
 

Exercício de Fixação:

Exercício 1:
O que o programa a seguir faz? Qual é o resultado obtido se a string fornecida for
        a) "Ah! Eu to maluco!"
        b) "5*4+(3^3)+4*5"

#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);
}
 

Desafio:

Exercício 1:
Implemente um programa que faça a multiplicação de 2 matrizes. Para isto, crie 3 matrizes inteiras com um bom tamanho (tipo 10X10). O programa deverá perguntar ao usuário sobre os tamanhos das matrizes que ele deseja multiplicar (e informá-lo dos limites). Para que a multiplicação seja possível, as matrizes precisam ter coordenadas compatíveis, ou seja, o número de colunas da primeira matriz deve ser igual ao número de linhas da segunda. Sendo assim, o seu programa deverá verificar se as dimensões das matrizes são compatíveis (e estão dentro dos limites). Se não, o programa deverá enviar uma mensagem orientando, e pedir novamente as dimensões. Se as dimensões estiverem corretas, o programa deverá solicitar que o usuário digite as duas matrizes, e executar a sua multiplicação. O resultado deverá ser armazenado na terceira matriz, que deverá ser apresentada como resultado.

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);
}

  Sumário

Dúvidas? Dê uma olhadinha em nosso FAQ

Perguntas para a lista do Curso de C
Curso de C do CPDEE/UFMG - 1996-1998