Reunimos 13 exercícios, do iniciante ao avançado, que usam arrays. Vão do básico de arrays unidimensionais até arrays bidimensionais (matrizes), ordenação e busca binária. Escreva seu código no navegador e clique em "Corrigir": ele é executado com gcc de verdade em várias entradas e a saída é verificada.
Obs.: Executar e Corrigir enviam seu código ao Wandbox, um serviço externo e gratuito de compilação, que o executa com gcc.
"Executar" roda seu código com a entrada acima. "Corrigir" testa com 4 entradas preparadas.
scanf("%d", &a[i]); com for (i = 0; i < n; i++). Para mostrar, comece em i = n - 1 e volte até 0 com i--.#include <stdio.h> int main(void) { int n; int a[100]; scanf("%d", &n); for (int i = 0; i < n; i++) { scanf("%d", &a[i]); } for (int i = n - 1; i >= 0; i--) { printf("%d ", a[i]); } printf("\n"); return 0; }
i = n, você lê a[n], que fica fora do array (acesso fora dos limites é comportamento indefinido e pode mostrar lixo sem dar erro). A condição de término também precisa ser i >= 0, senão a[0] não é mostrado."Executar" roda seu código com a entrada acima. "Corrigir" testa com 5 entradas preparadas.
sum, com 0 e repita sum += a[i]; N vezes. Para a média, divida convertendo um dos lados para double: (double)sum / n.#include <stdio.h> int main(void) { int n; int a[100]; scanf("%d", &n); for (int i = 0; i < n; i++) { scanf("%d", &a[i]); } int sum = 0; for (int i = 0; i < n; i++) { sum += a[i]; } printf("Soma: %d\n", sum); printf("Média: %.2f\n", (double)sum / n); return 0; }
sum / n a operação é uma divisão entre inteiros e a parte decimal é descartada (5 / 3 dá 1). Escrevendo (double)sum / n, sum é convertido para double antes da divisão, e você obtém 1.666…. Já (double)(sum / n) converte depois de dividir e não adianta."Executar" roda seu código com a entrada acima. "Corrigir" testa com 4 entradas preparadas.
imax = 0 e, se a[i] > a[imax], atualize com imax = i. Na hora de mostrar, a posição é imax + 1.#include <stdio.h> int main(void) { int n; int a[100]; scanf("%d", &n); for (int i = 0; i < n; i++) { scanf("%d", &a[i]); } int imax = 0, imin = 0; for (int i = 1; i < n; i++) { if (a[i] > a[imax]) imax = i; if (a[i] < a[imin]) imin = i; } printf("Maior: %d (posição %d)\n", a[imax], imax + 1); printf("Menor: %d (posição %d)\n", a[imin], imin + 1); return 0; }
0, o resultado sai errado quando todos os números são negativos. O mais seguro é usar o primeiro elemento como valor inicial. E se a comparação for >=, a atualização acontece também com valores iguais, e a posição passa a ser a do último."Executar" roda seu código com a entrada acima. "Corrigir" testa com 4 entradas preparadas.
i ir de 0 até n - 2 e mostre a[i + 1] - a[i]. A condição do laço é i < n - 1.#include <stdio.h> int main(void) { int n; int a[100]; scanf("%d", &n); for (int i = 0; i < n; i++) { scanf("%d", &a[i]); } for (int i = 0; i < n - 1; i++) { printf("%d ", a[i + 1] - a[i]); } printf("\n"); return 0; }
a[i + 1], pense se i + 1 está dentro dos limites do array. Com a condição i < n, no final você lê a[n] (fora dos limites). Quando N=1, o laço não roda nenhuma vez e só a linha vazia é mostrada.Não encontrado"."Executar" roda seu código com a entrada acima. "Corrigir" testa com 5 entradas preparadas.
a[i] == x, se a posição ainda for −1, registre i; a quantidade aumenta 1 toda vez.#include <stdio.h> int main(void) { int n, x; int a[100]; scanf("%d", &n); for (int i = 0; i < n; i++) { scanf("%d", &a[i]); } scanf("%d", &x); int pos = -1, count = 0; for (int i = 0; i < n; i++) { if (a[i] == x) { if (pos == -1) pos = i; count++; } } if (count == 0) { printf("Não encontrado\n"); } else { printf("Primeira posição: %d\n", pos + 1); printf("Quantidade: %d\n", count); } return 0; }
break assim que encontrasse, mas neste exercício também é preciso contar, então o array é percorrido até o fim. Em compensação, a posição é registrada só na primeira vez (com pos = i toda vez, fica a última posição). Representar "não encontrado" com −1, um valor impossível como índice, é uma técnica clássica."Executar" roda seu código com a entrada acima. "Corrigir" testa com 5 entradas preparadas.
a[i] >= avg.#include <stdio.h> int main(void) { int n; int a[100]; scanf("%d", &n); for (int i = 0; i < n; i++) { scanf("%d", &a[i]); } int sum = 0; for (int i = 0; i < n; i++) { sum += a[i]; } double avg = (double)sum / n; printf("Média: %.2f\n", avg); for (int i = 0; i < n; i++) { if (a[i] >= avg) { printf("%d ", a[i]); } } printf("\n"); return 0; }
int avg = sum / n;, para a entrada 1 2 2 a média vira 1 e o 1 também é mostrado. Na comparação a[i] >= avg, o int é convertido para double antes de comparar.*. As faixas são 10: 0-9, 10-19, …, 80-89, 90-100 (a nota 100 entra em 90-100), e faixas sem ninguém também são mostradas, como "20-29:"."Executar" roda seu código com a entrada acima. "Corrigir" testa com 4 entradas preparadas.
int cnt[10] = {0}; para contar as pessoas de cada faixa. O número da faixa de uma nota s é s / 10, mas para 100 isso dá 10, então só nesse caso use 9.#include <stdio.h> int main(void) { int n; int a[100]; scanf("%d", &n); for (int i = 0; i < n; i++) { scanf("%d", &a[i]); } int cnt[10] = {0}; for (int i = 0; i < n; i++) { int k = a[i] / 10; if (k == 10) k = 9; cnt[k]++; } for (int k = 0; k < 10; k++) { if (k == 9) { printf("90-100: "); } else { printf("%d-%d: ", k * 10, k * 10 + 9); } for (int j = 0; j < cnt[k]; j++) { printf("*"); } printf("\n"); } return 0; }
cnt[10], fora dos limites. Inicialize o array de contagem com = {0} para zerar todos os elementos (arrays dentro de funções, se não forem inicializados, têm conteúdo indeterminado).Não há segundo maior valor"."Executar" roda seu código com a entrada acima. "Corrigir" testa com 5 entradas preparadas.
max; na 2ª, encontre "o maior entre os valores menores que max". Na 2ª passada, use uma variável (flag) que indique "ainda não encontrei nenhum".#include <stdio.h> int main(void) { int n; int a[100]; scanf("%d", &n); for (int i = 0; i < n; i++) { scanf("%d", &a[i]); } int max = a[0]; for (int i = 1; i < n; i++) { if (a[i] > max) max = a[i]; } int found = 0, second = 0; for (int i = 0; i < n; i++) { if (a[i] < max && (!found || a[i] > second)) { second = a[i]; found = 1; } } if (found) { printf("Segundo maior valor: %d\n", second); } else { printf("Não há segundo maior valor\n"); } return 0; }
second for fixo, como 0, o resultado falha quando todos os números são negativos. Por isso usamos found para "aceitar diretamente o primeiro valor encontrado"."Executar" roda seu código com a entrada acima. "Corrigir" testa com 4 entradas preparadas.
a[i][j] é "linha i, coluna j". Para a soma das linhas, coloque i no laço externo e percorra j; para a soma das colunas, coloque j no laço externo e percorra i. A variável da soma volta a 0 toda vez que se entra no laço externo.#include <stdio.h> int main(void) { int r, c; int a[10][10]; scanf("%d %d", &r, &c); for (int i = 0; i < r; i++) { for (int j = 0; j < c; j++) { scanf("%d", &a[i][j]); } } printf("Soma das linhas:"); for (int i = 0; i < r; i++) { int sum = 0; for (int j = 0; j < c; j++) { sum += a[i][j]; } printf(" %d", sum); } printf("\n"); printf("Soma das colunas:"); for (int j = 0; j < c; j++) { int sum = 0; for (int i = 0; i < r; i++) { sum += a[i][j]; } printf(" %d", sum); } printf("\n"); return 0; }
sum = 0 ficar fora do laço aninhado, a soma da linha anterior é carregada adiante e vira um total acumulado. Inverter os índices na soma das colunas, como a[j][i], também é um erro comum: quando R e C são diferentes, o programa lê fora dos limites."Executar" roda seu código com a entrada acima. "Corrigir" testa com 5 entradas preparadas.
j vai de 0 até n - 2 - i e, se a[j] > a[j + 1], os dois são trocados. Para trocar, use uma variável auxiliar tmp.#include <stdio.h> int main(void) { int n; int a[100]; scanf("%d", &n); for (int i = 0; i < n; i++) { scanf("%d", &a[i]); } int swaps = 0; for (int i = 0; i < n - 1; i++) { for (int j = 0; j < n - 1 - i; j++) { if (a[j] > a[j + 1]) { int tmp = a[j]; a[j] = a[j + 1]; a[j + 1] = tmp; swaps++; } } } for (int i = 0; i < n; i++) { printf("%d ", a[i]); } printf("\nTrocas: %d\n", swaps); return 0; }
a[j] = a[j + 1]; a[j + 1] = a[j];, a 1ª linha apaga o a[j] original e os dois ficam com o mesmo valor. Sempre guarde o valor em tmp. A cada volta do laço externo, o maior valor fica fixo na ponta direita, então o alcance do laço interno pode diminuir até n - 1 - i. Aliás, o número de trocas é igual ao número de pares "à esquerda e maior que ele" (o número de inversões).Passo k:", separado por espaço."Executar" roda seu código com a entrada acima. "Corrigir" testa com 4 entradas preparadas.
i = k - 1. Comece com imin = i, examine j = i + 1 até n - 1 e, se a[j] < a[imin], faça imin = j. No final, troque a[i] com a[imin] e mostre o array.#include <stdio.h> int main(void) { int n; int a[100]; scanf("%d", &n); for (int i = 0; i < n; i++) { scanf("%d", &a[i]); } for (int i = 0; i < n - 1; i++) { int imin = i; for (int j = i + 1; j < n; j++) { if (a[j] < a[imin]) imin = j; } int tmp = a[i]; a[i] = a[imin]; a[imin] = tmp; printf("Passo %d:", i + 1); for (int j = 0; j < n; j++) { printf(" %d", a[j]); } printf("\n"); } return 0; }
<=, quando houver vários menores é escolhido o mais à direita, e para a entrada 3 1 3 1 o passo a passo muda."Executar" roda seu código com a entrada acima. "Corrigir" testa com 5 entradas preparadas.
i (linha de C) e j (coluna de C) e, dentro deles, faça k ir de 0 a m−1 acumulando c[i][j] += a[i][k] * b[k][j];.#include <stdio.h> int main(void) { int n, m, p; int a[10][10], b[10][10], c[10][10]; scanf("%d %d %d", &n, &m, &p); for (int i = 0; i < n; i++) { for (int k = 0; k < m; k++) { scanf("%d", &a[i][k]); } } for (int k = 0; k < m; k++) { for (int j = 0; j < p; j++) { scanf("%d", &b[k][j]); } } for (int i = 0; i < n; i++) { for (int j = 0; j < p; j++) { c[i][j] = 0; for (int k = 0; k < m; k++) { c[i][j] += a[i][k] * b[k][j]; } } } for (int i = 0; i < n; i++) { for (int j = 0; j < p; j++) { printf("%d ", c[i][j]); } printf("\n"); } return 0; }
+= em c[i][j] sem inicializá-lo com 0 faz a soma começar de um valor indeterminado. Os limites dos laços são n para i, p para j e m para k. Se você trocar algum deles, o teste com matrizes quadradas pode passar, mas quando n, m e p forem diferentes o programa lê fora dos limites.Não encontrado" se ele não estiver no array. Use busca binária."Executar" roda seu código com a entrada acima. "Corrigir" testa com 4 entradas preparadas.
lo a hi (no início, 0 a N−1) e, enquanto lo <= hi, compare com o elemento do meio, mid, e corte o intervalo pela metade. Se a[mid] for menor, lo = mid + 1; se for maior, hi = mid - 1.#include <stdio.h> int main(void) { int n, q; int a[1000]; scanf("%d", &n); for (int i = 0; i < n; i++) { scanf("%d", &a[i]); } scanf("%d", &q); for (int t = 0; t < q; t++) { int x; scanf("%d", &x); int lo = 0, hi = n - 1, pos = -1; while (lo <= hi) { int mid = lo + (hi - lo) / 2; if (a[mid] == x) { pos = mid; break; } else if (a[mid] < x) { lo = mid + 1; } else { hi = mid - 1; } } if (pos >= 0) { printf("%d\n", pos + 1); } else { printf("Não encontrado\n"); } } return 0; }
lo = mid, o intervalo pode não diminuir e o laço vira infinito. Com a condição lo < hi, o laço termina sem examinar o último elemento restante. A busca pressupõe que o array esteja ordenado; se não estiver, é preciso ordenar antes.