Issuu

6.1

Linguagem C

25.ª Edição Atualizada e Aumentada

6.2

6.3

EXERCÍCIOS PROPOSTOS – SOLUÇÃO

6.1.1 Os índices do array variam entre 0 e 9 , e não entre 1 e 10

6.1.2 Depois de terminado o ciclo, o valor de i é 10 , logo v[10] = 101, o que vai causar problemas, pois o array termina no índice 9

6.1.3 A dimensão de um array não pode ser negativa.

6.1.4 A declaração de um array obriga a que todas as dimensões sejam explicitadas (erro de compilação). Não se podem declarar arrays sem dimensão. Se o programador não sabe que dimensão usar para um array, como poderá um simples computador saber?

6.1.5 O número de elementos que está a realizar a inicialização do array é superior à dimensão do array

6.1.6 Se colocar um ponto e vírgula a seguir ao #define, todas as ocorrências de MAX serão substituídas por 30; (ponto e vírgula incluído), o que irá provocar erros de sintaxe. Exemplo: int v[30;]; . Experimente executar o comando cc -E nome-do-prog.c para ver o resultado do pré-processamento do ficheiro.

1: #include <stdio.h>

3: float max(float v[ ], int n)

4: {

5: float maior = v[0];

6: for (int i=1; i<n; i++)

7: if (v[i]>maior)

8: maior = v[i];

9: return maior; 10: }

11:

12: int main(void)

13: { 14: float x[] = {10.0, 20.0, 15.0, -50.0, 27.0}; 15:

16: printf("O maior dos 3 primeiros elementos = %f\n", max(x, 3)); 17: printf("O maior dos 5 primeiros elementos = %f\n", max(x, 5));

18:

19: return 0; 20: } PROG0611.C

1: #include<stdio.h>

2: #include<stdlib.h>

3: #include<locale.h> 4:

5: #define MAX 3

7: void transpose(int v[MAX][MAX])

8: {

9: for(int row=0; row<MAX; row++)

10: for(int col=row+1; col<MAX; col++)

11: {

12: int tmp = v[row][col];

13: v[row][col] = v[col][row]; 14: v[col][row] = tmp; 15: }

16: }

17:

18: void print(int v[MAX][MAX])

19: {

20: for(int row=0; row<MAX; row++)

21: { 22: for(int col=0; col<MAX; col++)

23: printf(" Mat[%d][%d] = %d\n", row, col, v[row][col]);

24: putchar('\n');

25: }

26: }

27:

28: int main()

29: {

30: int mat[MAX][MAX] = { {1, 2, 3}, 31: {4, 5, 6}, 32: {7, 8, 9}

33: };

34:

35: puts("Matriz original");

36: print(mat);

37:

38: transpose(mat);

39: puts("Matriz transposta");

40: print(mat);

41:

42: return 0; 43: }

De notar que a troca de elementos na matriz deve ser realizada apenas para metade dos valores, pois em cada troca são deslocados dois valores.

10: for(int col=row+1; col<MAX; col++)

1: #include <stdio.h>

3: #define DIM 3 4: #define BRANCO ' ' 5:

6: // Declaração das funções

7: void inic(char tab[ ][DIM]); 8: void mostrar(char tab[DIM][DIM]);

10: int linha_vencedora(char linha[], char ch); 11: int coluna_vencedora(char mat[DIM][DIM], int n_col, char ch);

12: int diagonal_vencedora(char mat[DIM][DIM], char ch);

13:

14: int ganhou(char tab[DIM][DIM], char ch);

15:

16: /* Inicializa o tabuleiro */ 17: void inic(char tab[ ][DIM]) // Omitir uma dimensão

PROG0612.C

18: {

19: for(int i=0; i<DIM; i++)

20: for(int j=0; j<DIM; j++)

21: tab[i][j]=BRANCO;

22: }

23:

24: /* Mostra o tabuleiro */

25: void mostrar(char tab[DIM][DIM]) // Ambas as Dimensões

26: {

27: for (int i=0; i<DIM; i++)

28: {

29: for (int j=0; j<DIM; j++)

30: printf(" %c %c", tab[i][j], j==DIM-1? ' ' : '|');

31:

32: if (i!=DIM-1)

33: printf("\n-----------");

34: putchar('\n');

35: }

36: }

37:

38: /* Verifica se a linha está preenchida com o char ch) */

39: /* Devolve um valor lógico */

40: int linha_vencedora(char linha[], char ch)

41: {

42: return linha[0]==linha[1] && 43: linha[1]==linha[2] && 44: linha[0]==ch;

45: }

46:

47: /* Verifica se a coluna n_col está totalmente preenchida */

48: /* com o char ch */

49: int coluna_vencedora(char mat[DIM][DIM], int n_col, char ch)

50: {

51: return mat[0][n_col]==mat[1][n_col] && 52: mat[1][n_col]==mat[2][n_col] &&

53: mat[0][n_col]==ch;

54: }

55:

56: /* Verifica se alguma das diagonais está totalmente */

57: /* preenchida com o char ch */

58: int diagonal_vencedora(char mat[DIM][DIM], char ch)

59: {

60: return (mat[0][0]==mat[1][1] && 61: mat[1][1]==mat[2][2] &&

62: mat[0][0]==ch)

63: ||

64: (mat[0][2]==mat[1][1] && 65: mat[1][1]==mat[2][0] && 66: mat[0][2]==ch);

67: }

68:

69: /* Verifica se o jogagor associado ao char ch */

70: /* ganhou o jogo */

71: int ganhou(char tab[DIM][DIM], char ch)

72: {

73: if (linha_vencedora(tab[0], ch) || linha_vencedora(tab[1], ch) || linha_vencedora(tab[2], ch))

74: return 1;

75: if (coluna_vencedora(tab, 0, ch) || coluna_vencedora(tab, 0, ch) || coluna_vencedora(tab, 0, ch))

76: return 1;

77: if (diagonal_vencedora(tab, ch))

78: return 1;

79: return 0;

80: }

81:

82:

83: int main(void)

6.5

84: { 85: char tabuleiro[DIM][DIM];

86: int pos_x, pos_y; 87: char ch = 'X'; // Símbolo a usar na primeira jogada

88: int n_jogadas = 0;

89: 90: inic(tabuleiro);

91: while (1) // Ciclo Infinito

92: { 93: mostrar(tabuleiro); 94:

95: printf("\nIntroduza a posição de jogo (Linha Coluna): "); 96: scanf("%d %d", &pos_x, &pos_y);

97:

98: if (pos_x>DIM || pos_y >DIM)

99: {

100: printf("\n\nValores inválidos\n\n"); 101: continue; // Próxima iteração do ciclo 102: }

103:

104: pos_x--; pos_y--; // Pois os índices do tab começam em 0 105:

106: if (tabuleiro[pos_x][pos_y]==BRANCO) // Posição livre no tabuleiro

107: { 108: tabuleiro[pos_x][pos_y] = ch = ((ch == '0') ? 'X' : '0');

109: n_jogadas++;

110: if (ganhou(tabuleiro, ch)) /* Basta testar o char corrente */ 111: {

112: printf("Ganhou o jogador '%c'\n", ch); 113: break; 114: }

115: }

116: else

117: printf("Posição já ocupada\nJogue Novamente!!!\n"); 118:

119: if (n_jogadas==DIM*DIM)

120: {

121: printf("EMPATE!!!"); 122: break;

123: }

124: }

125:

126: mostrar(tabuleiro);

127: return 0; 128: }

char *memcpy(char *dest, char *orig, int n)

{ for (int i=0; i<n; i++) dest[i] = orig[i]; return dest; }

6.6 De notar que esta função terá de devolver um valor lógico, que indique se os arrays possuem, exatamente, os mesmos valores nas n primeiras posições:

int memcmp(char *s1, char *s2, int n)

{ for (int i=0; i<n; i++) if (s1[i] != s2[i]) return 0; // Não são iguais

GALO.C

6.7

return 1; // Todos elementos são iguais }

Esta solução é semelhante à anterior. A única diferença é o facto de que devemos ignorar se os carateres se encontram em maiúsculas ou minúsculas. Para tal, recorremos à função toupper (ou tolower ), que converte qualquer caráter para maiúsculas (ou para minúsculas).

NOTA

Para ter acesso à função tupper, o seu código deverá conter o #include <ctype.h>

#include <ctype.h>

int memicmp(char *s1, char *s2, int n)

{ for (int i=0; i<n; i++) if (toupper(s1[i])!= toupper(s2[i]))

return 0; // Não são iguais

return 1; // Todos os elementos são iguais }