Pontíficia Universidade Católica de Goiás

Departamento de Ciências da Computação

Laboratório de Programação – Prof. Roldão

Aluna: Lorenna Oliveira e Oliveira Sariedine

Ex. Lista de exercícios sobre vetores

1) Elabore um algoritmo para ler uma sequência de 20 valores inteiros positivos e

armazená-los em um vetor VET. Imprimir o vetor.

#include <stdio.h>

#define TAMANHO 20

int main() {
int VET[TAMANHO];
int i;

printf("Digite 20 valores inteiros positivos:\n");

// Lê os valores e os armazena no vetor

for (i = 0; i < TAMANHO; i++) {
do {
printf("Digite o valor %d: ", i + 1);
scanf("%d", &VET[i]);
if (VET[i] <= 0) {
printf("Por favor, insira um valor inteiro positivo.\n");
}
} while (VET[i] <= 0);
}

// Imprime os valores armazenados no vetor

printf("Valores armazenados no vetor:\n");
for (i = 0; i < TAMANHO; i++) {
printf("%d ", VET[i]);
}
printf("\n");

return 0;
}
2) Dado um vetor, comparar todos os seus elementos um a um e ordená-los em ordem
crescente e decrescente.

#include <stdio.h>

#define TAMANHO 10 // Tamanho do vetor, pode ser alterado conforme necessário

// Função para trocar dois elementos de posição no vetor

void trocar(int *a, int *b) {
int temp = *a;
*a = *b;
*b = temp;
}

// Função para ordenar o vetor em ordem crescente

void ordenarCrescente(int vetor[], int tamanho) {
int i, j;
for (i = 0; i < tamanho - 1; i++) {
for (j = i + 1; j < tamanho; j++) {
if (vetor[i] > vetor[j]) {
trocar(&vetor[i], &vetor[j]);
}
}
}
}

// Função para ordenar o vetor em ordem decrescente

void ordenarDecrescente(int vetor[], int tamanho) {
int i, j;
for (i = 0; i < tamanho - 1; i++) {
for (j = i + 1; j < tamanho; j++) {
if (vetor[i] < vetor[j]) {
trocar(&vetor[i], &vetor[j]);
}
}
}
}

// Função para imprimir o vetor

void imprimirVetor(int vetor[], int tamanho) {
int i;
for (i = 0; i < tamanho; i++) {
printf("%d ", vetor[i]);
}
printf("\n");
}
int main() {
int vetor[TAMANHO] = {9, 5, 7, 2, 1, 8, 3, 6, 10, 4}; // Exemplo de vetor inicial

printf("Vetor original: ");

imprimirVetor(vetor, TAMANHO);

ordenarCrescente(vetor, TAMANHO);
printf("Vetor ordenado em ordem crescente: ");
imprimirVetor(vetor, TAMANHO);

ordenarDecrescente(vetor, TAMANHO);
printf("Vetor ordenado em ordem decrescente: ");
imprimirVetor(vetor, TAMANHO);

return 0;
}

3) Elabore um algoritmo para ler um vetor VET de 20 valores inteiros positivos e gerar dois
outros vetores VP e VI onde: VP conterá apenas os valores pares de VET, e VI conterá apenas
os valores ímpares. Imprimir VET, VP e VI

#include <stdio.h>

#define TAMANHO 20

int main() {
int VET[TAMANHO];
int VP[TAMANHO], VI[TAMANHO]; // Vetores para armazenar valores pares e ímpares
int contadorPares = 0, contadorImpares = 0;
int i;

printf("Digite 20 valores inteiros positivos:\n");

// Lê os valores e os armazena no vetor VET

for (i = 0; i < TAMANHO; i++) {
do {
printf("Digite o valor %d: ", i + 1);
scanf("%d", &VET[i]);
if (VET[i] <= 0) {
printf("Por favor, insira um valor inteiro positivo.\n");
}
} while (VET[i] <= 0);
}

// Separa os valores pares e ímpares em VP e VI, respectivamente

for (i = 0; i < TAMANHO; i++) {
if (VET[i] % 2 == 0) { // Se o número for par
VP[contadorPares] = VET[i];
contadorPares++;
 } else { // Se o número for ímpar
VI[contadorImpares] = VET[i];
contadorImpares++;
}
}

// Imprime o vetor VET

printf("\nVET: ");
for (i = 0; i < TAMANHO; i++) {
printf("%d ", VET[i]);
}
printf("\n");

// Imprime o vetor VP (valores pares)

printf("\nVP (Valores pares de VET): ");
for (i = 0; i < contadorPares; i++) {
printf("%d ", VP[i]);
}
printf("\n");

// Imprime o vetor VI (valores ímpares)

printf("\nVI (Valores ímpares de VET): ");
for (i = 0; i < contadorImpares; i++) {
printf("%d ", VI[i]);
}
printf("\n");

return 0;
}

4) Elabore um algoritmo para armazenar em um vetor KV todos os valores inteiros positivos

desde 1 até 50. Transportar todos os elementos primos do vetor KV para um vetor PV.
Imprimir os dois vetores.

#include <stdio.h>

#define TAMANHO_KV 50 // Tamanho do vetor KV

// Função para verificar se um número é primo

int ehPrimo(int num) {
if (num <= 1) {
return 0; // Números menores ou iguais a 1 não são primos
}
for (int i = 2; i * i <= num; i++) {
if (num % i == 0) {
return 0; // Se for divisível por algum número além de 1 e ele mesmo, não é primo
}
}
return 1; // Se não for divisível por nenhum número além de 1 e ele mesmo, é primo
}

int main() {
int KV[TAMANHO_KV]; // Vetor para armazenar todos os valores de 1 a 50
int PV[TAMANHO_KV]; // Vetor para armazenar números primos
int contadorPV = 0; // Contador para elementos do vetor PV

// Preenchendo o vetor KV com números de 1 a 50

for (int i = 0; i < TAMANHO_KV; i++) {
KV[i] = i + 1;
}

// Transportando elementos primos para o vetor PV

for (int i = 0; i < TAMANHO_KV; i++) {
if (ehPrimo(KV[i])) {
PV[contadorPV] = KV[i];
contadorPV++;
}
}

// Imprimindo o vetor KV
printf("Vetor KV (Valores de 1 a 50):\n");
for (int i = 0; i < TAMANHO_KV; i++) {
printf("%d ", KV[i]);
}
printf("\n");

// Imprimindo o vetor PV (valores primos)

printf("\nVetor PV (Valores primos de 1 a 50):\n");
for (int i = 0; i < contadorPV; i++) {
printf("%d ", PV[i]);
}
printf("\n");

return 0;
}

5) Elabore um algoritmo para ler um vetor V de 20 valores inteiros positivos, calcular e

imprimir o fatorial de todos os elementos pares do vetor, e calcular e imprimir a potência de
5 de todos os valores ímpares do vetor.

#include <stdio.h>

#define TAMANHO_KV 50 // Tamanho do vetor KV

// Função para verificar se um número é primo

int ehPrimo(int num) {
if (num <= 1) {
return 0; // Números menores ou iguais a 1 não são primos
 }
for (int i = 2; i * i <= num; i++) {
if (num % i == 0) {
return 0; // Se for divisível por algum número além de 1 e ele mesmo, não é primo
}
}
return 1; // Se não for divisível por nenhum número além de 1 e ele mesmo, é primo
}

int main() {
int KV[TAMANHO_KV]; // Vetor para armazenar todos os valores de 1 a 50
int PV[TAMANHO_KV]; // Vetor para armazenar números primos
int contadorPV = 0; // Contador para elementos do vetor PV

// Preenchendo o vetor KV com números de 1 a 50

for (int i = 0; i < TAMANHO_KV; i++) {
KV[i] = i + 1;
}

// Transportando elementos primos para o vetor PV

for (int i = 0; i < TAMANHO_KV; i++) {
if (ehPrimo(KV[i])) {
PV[contadorPV] = KV[i];
contadorPV++;
}
}

// Imprimindo o vetor KV
printf("Vetor KV (Valores de 1 a 50):\n");
for (int i = 0; i < TAMANHO_KV; i++) {
printf("%d ", KV[i]);
}
printf("\n");

// Imprimindo o vetor PV (valores primos)

printf("\nVetor PV (Valores primos de 1 a 50):\n");
for (int i = 0; i < contadorPV; i++) {
printf("%d ", PV[i]);
}
printf("\n");

return 0;
}

6) Construa um contador N que varie de 1 a 10 e construa um vetor A(N)=N2. Imprima N e

A(N)

#include <stdio.h>

int main() {
int N = 1;
 int A[10]; // Vetor A com tamanho 10

while (N <= 10) {

A[N - 1] = N * N; // A[N] recebe o valor de N^2
printf("N = %d, A[N] = %d\n", N, A[N - 1]);
N++;
}

return 0;
}

7) Apresente um algoritmo que receba uma sequência de 9 valores, atribua-os a um vetor e

imprima-os na sequência contrária da que foi recebida.

#include <stdio.h>

#define TAMANHO 9

int main() {
int vetor[TAMANHO];
int i;

printf("Digite 9 valores:\n");

// Lê os valores e os armazena no vetor

for (i = 0; i < TAMANHO; i++) {
printf("Digite o valor %d: ", i + 1);
scanf("%d", &vetor[i]);
}

// Imprime os valores do vetor na ordem contrária

printf("\nValores na sequência contrária:\n");
for (i = TAMANHO - 1; i >= 0; i--) {
printf("%d ", vetor[i]);
}
printf("\n");

return 0;
}

8) Construa um programa que leia um Número (N) de nomes de pessoas e suas respectivas
idades e guarde esses dados em dois vetores distintos. Imprima o nome e a idade de cada
pessoa na mesma linha. Em seguida escolha um número (índice do vetor) e imprima o nome
e a idade da pessoa correspondente a este número

#include <stdio.h>
#include <string.h>

#define MAX_PESSOAS 100 // Definindo o máximo de pessoas a serem armazenadas

int main() {
char nomes[MAX_PESSOAS][50]; // Vetor para armazenar nomes (máximo de 100 nomes
com 50 caracteres)
int idades[MAX_PESSOAS]; // Vetor para armazenar idades
int N, i, indice;

printf("Digite a quantidade de pessoas: ");

scanf("%d", &N);

// Lendo nomes e idades das pessoas e armazenando nos vetores

for (i = 0; i < N; i++) {
printf("Digite o nome da pessoa %d: ", i + 1);
scanf("%s", nomes[i]);
printf("Digite a idade da pessoa %d: ", i + 1);
scanf("%d", &idades[i]);
}

// Imprimindo nomes e idades de todas as pessoas

printf("\nNomes e idades das pessoas:\n");
for (i = 0; i < N; i++) {
printf("%s - %d anos\n", nomes[i], idades[i]);
}

// Solicitando um número (índice do vetor)

printf("\nEscolha um numero (indice do vetor): ");
scanf("%d", &indice);

// Verificando se o índice está dentro dos limites do vetor

if (indice >= 0 && indice < N) {
// Imprimindo o nome e a idade da pessoa correspondente ao índice escolhido
printf("\nNome e idade da pessoa no indice %d: %s - %d anos\n", indice, nomes[indice],
idades[indice]);
} else {
printf("\nIndice invalido!\n");
}

return 0;
}

9) Faça um algoritmo que leia dois vetores de mesma dimensão e realize a soma entre eles.

Ex: vetor1=( 2, 4, 10, 11, 8, 6) , vetor2 = ( 4, 3, 1, 2, 0, 1) , vetor resultante = (6, 7,11, 13, 8, 7)

#include <stdio.h>

#define TAMANHO 6 // Defina o tamanho dos vetores conforme necessário

int main() {
int vetor1[TAMANHO], vetor2[TAMANHO], vetorResultado[TAMANHO];
int i;
 // Lendo os valores do primeiro vetor
printf("Digite os valores do primeiro vetor:\n");
for (i = 0; i < TAMANHO; i++) {
printf("Digite o valor %d: ", i + 1);
scanf("%d", &vetor1[i]);
}

// Lendo os valores do segundo vetor

printf("\nDigite os valores do segundo vetor:\n");
for (i = 0; i < TAMANHO; i++) {
printf("Digite o valor %d: ", i + 1);
scanf("%d", &vetor2[i]);
}

// Realizando a soma dos elementos dos dois vetores

for (i = 0; i < TAMANHO; i++) {
vetorResultado[i] = vetor1[i] + vetor2[i];
}

// Exibindo o vetor resultante da soma

printf("\nVetor resultante da soma:\n");
for (i = 0; i < TAMANHO; i++) {
printf("%d ", vetorResultado[i]);
}
printf("\n");

return 0;
}
10) Ler uma variável de 15 elementos numéricos e verificar se existem elementos iguais a 25.
Se existirem, escrever as posições em que estão armazenados.

#include <stdio.h>

#define TAMANHO 15

int main() {
int variavel[TAMANHO];
int i;
int encontrou = 0; // Variável para verificar se o número 25 foi encontrado

// Lendo os valores para a variável

printf("Digite os 15 elementos numericos:\n");
for (i = 0; i < TAMANHO; i++) {
printf("Digite o elemento %d: ", i + 1);
scanf("%d", &variavel[i]);
}

// Verificando se existem elementos iguais a 25 e exibindo suas posições

printf("\nPosicoes onde o numero 25 esta armazenado:\n");
for (i = 0; i < TAMANHO; i++) {
if (variavel[i] == 25) {
printf("Posicao %d\n", i + 1);
 encontrou = 1; // Marcando que o número 25 foi encontrado
}
}

// Caso nenhum número 25 tenha sido encontrado

if (!encontrou) {
printf("Nao ha elementos iguais a 25 na variavel.\n");
}

return 0;
}

11) Elabore e implemente um algoritmo que faça um cadastro de materiais de construção. Os

itens devem ser lidos e armazenados. Para cada item deve ser associado o nome do produto,
um código e a quantidade existente em estoque. Depois escolha um código e imprima o
nome do item e da quantidade existente correspondente a este código.

#include <stdio.h>
#include <string.h>

#define MAX_ITENS 50 // Defina o máximo de itens a serem cadastrados

// Definição da estrutura do material de construção

struct MaterialConstrucao {
char nome[50];
int codigo;
int quantidade;
};

int main() {
struct MaterialConstrucao itens[MAX_ITENS];
int numItens, i, codigoEscolhido;

printf("Digite o numero de itens a serem cadastrados: ");

scanf("%d", &numItens);

// Cadastro dos itens de construção

for (i = 0; i < numItens; i++) {
printf("\nDigite o nome do produto %d: ", i + 1);
scanf("%s", itens[i].nome);
printf("Digite o codigo do produto %d: ", i + 1);
scanf("%d", &itens[i].codigo);
printf("Digite a quantidade em estoque do produto %d: ", i + 1);
scanf("%d", &itens[i].quantidade);
}

// Escolha do código para imprimir informações do item correspondente

printf("\nDigite um codigo para visualizar o nome e a quantidade correspondente: ");
scanf("%d", &codigoEscolhido);
 // Procurando o código fornecido nos itens cadastrados
int encontrado = 0;
for (i = 0; i < numItens; i++) {
if (itens[i].codigo == codigoEscolhido) {
printf("\nNome do item com codigo %d: %s\n", codigoEscolhido, itens[i].nome);
printf("Quantidade em estoque: %d\n", itens[i].quantidade);
encontrado = 1;
break;
}
}

// Se o código não for encontrado nos itens cadastrados

if (!encontrado) {
printf("\nCodigo nao encontrado nos itens cadastrados.\n");
}

return 0;
}

12) Deseja-se publicar o número de acertos de cada aluno em uma prova em forma de testes.
A prova consta de 5 questões, cada uma com cinco alternativas identificadas por A, B,C, D e
E. Para isso são dados: o cartão gabarito, o cartão respostas para cada aluno, contendo o seu
número e as respostas. Faça um algoritmo que resolva o problema e imprima os resultados.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define NUM_ALUNOS 5 // Defina o número de alunos

#define NUM_QUESTOES 5 // Defina o número de questões

// Estrutura para armazenar as respostas de cada aluno

struct Aluno {
int numero;
char respostas[NUM_QUESTOES];
};

int main() {
char gabarito[NUM_QUESTOES] = {'A', 'B', 'C', 'D', 'E'}; // Cartão gabarito
struct Aluno alunos[NUM_ALUNOS]; // Cartões de resposta dos alunos
int i, j;

// Leitura das respostas de cada aluno

for (i = 0; i < NUM_ALUNOS; i++) {
printf("Informe o numero do aluno %d: ", i + 1);
scanf("%d", &alunos[i].numero);

printf("Informe as respostas do aluno %d (A, B, C, D ou E, sem espaços): ",

alunos[i].numero);
 scanf("%s", alunos[i].respostas);
}

// Verificação do número de acertos de cada aluno

printf("\nRESULTADOS DOS ALUNOS:\n");
for (i = 0; i < NUM_ALUNOS; i++) {
int acertos = 0;
printf("Aluno %d: ", alunos[i].numero);

for (j = 0; j < NUM_QUESTOES; j++) {

if (alunos[i].respostas[j] == gabarito[j]) {
acertos++;
}
}

printf("Acertos: %d\n", acertos);

}

return 0;
}

13) Faça um algoritmo que calcula a média das notas de 10 alunos e determine o número de
alunos que tiveram nota superior a média calculada; o aluno que teve a maior nota e o aluno
que teve a menor nota. Imprima uma lista com o nome dos alunos e a nota na ordem
decrescente de notas juntamente com seus respectivos nomes.

#include <stdio.h>
#include <string.h>

#define NUM_ALUNOS 10 // Defina o número de alunos

// Estrutura para armazenar informações dos alunos

struct Aluno {
char nome[50];
float nota;
};

int main() {
struct Aluno alunos[NUM_ALUNOS];
float somaNotas = 0, media;
float maiorNota = 0, menorNota = 10;
int alunosAcimaMedia = 0;
int indiceMaiorNota = -1, indiceMenorNota = -1;
int i;

// Leitura das notas e nomes dos alunos

for (i = 0; i < NUM_ALUNOS; i++) {
printf("Digite o nome do aluno %d: ", i + 1);
scanf("%s", alunos[i].nome);
 printf("Digite a nota do aluno %d: ", i + 1);
scanf("%f", &alunos[i].nota);

// Calcula a soma das notas para calcular a média posteriormente

somaNotas += alunos[i].nota;

// Verifica a maior nota e seu respectivo índice

if (alunos[i].nota > maiorNota) {
maiorNota = alunos[i].nota;
indiceMaiorNota = i;
}

// Verifica a menor nota e seu respectivo índice

if (alunos[i].nota < menorNota) {
menorNota = alunos[i].nota;
indiceMenorNota = i;
}
}

// Calcula a média das notas

media = somaNotas / NUM_ALUNOS;

// Determina o número de alunos com notas acima da média

for (i = 0; i < NUM_ALUNOS; i++) {
if (alunos[i].nota > media) {
alunosAcimaMedia++;
}
}

// Imprime a lista ordenada com os nomes dos alunos e suas notas

printf("\nNumero de alunos com nota acima da media: %d\n", alunosAcimaMedia);
printf("Aluno com a maior nota: %s - %.2f\n", alunos[indiceMaiorNota].nome,
alunos[indiceMaiorNota].nota);
printf("Aluno com a menor nota: %s - %.2f\n", alunos[indiceMenorNota].nome,
alunos[indiceMenorNota].nota);

return 0;
}

14) A FEIS deseja saber se existem alunos cursando, simultaneamente, as disciplinas ICC e
cálculo numérico. Existem disponíveis na unidade de entrada os números de matrícula de ICC
(máximo 60 alunos) e Cálculo Numérico (máximo 80). Cada conjunto dos números de
matrícula dos alunos de uma disciplina tem a matrícula fictícia 9999 no final. Formular um
algoritmo que imprima o número de matrícula dos alunos que estão cursando estas
disciplinas simultaneamente. Obs: O exercício trata da ocorrência de um elemento em um
conjunto em outro conjunto.

#include <stdio.h>
#define MAX_ALUNOS_ICC 60 // Número máximo de alunos em ICC
#define MAX_ALUNOS_CALC_NUM 80 // Número máximo de alunos em Cálculo Numérico

int main() {
int matricula;
int matriculas_icc[MAX_ALUNOS_ICC];
int matriculas_calc_num[MAX_ALUNOS_CALC_NUM];
int i, j;

// Leitura das matrículas de ICC

printf("Digite as matriculas dos alunos de ICC (9999 para finalizar):\n");
for (i = 0; i < MAX_ALUNOS_ICC; i++) {
scanf("%d", &matricula);
if (matricula == 9999) {
break;
}
matriculas_icc[i] = matricula;
}

// Leitura das matrículas de Cálculo Numérico

printf("\nDigite as matriculas dos alunos de Calculo Numerico (9999 para finalizar):\n");
for (j = 0; j < MAX_ALUNOS_CALC_NUM; j++) {
scanf("%d", &matricula);
if (matricula == 9999) {
break;
}
matriculas_calc_num[j] = matricula;
}

// Verifica se existem alunos cursando simultaneamente ICC e Cálculo Numérico

printf("\nAlunos cursando simultaneamente ICC e Calculo Numerico:\n");
for (i = 0; i < MAX_ALUNOS_ICC && matriculas_icc[i] != 9999; i++) {
for (j = 0; j < MAX_ALUNOS_CALC_NUM && matriculas_calc_num[j] != 9999; j++) {
if (matriculas_icc[i] == matriculas_calc_num[j]) {
printf("%d\n", matriculas_icc[i]);
}
}
}

return 0;
}

15) Implemente um programa que lê 10 inteiros do teclado ou para quando dois inteiros
consecutivos sejam digitados. Após a leitura o programa deverá imprimir o maior, o menor, a
média e a soma dos números digitados.

#include <stdio.h>

int main() {
int numeros[10];
 int i, maior, menor;
int soma = 0;
float media;
int tamanho = 0;

printf("Digite 10 inteiros ou pare quando dois inteiros consecutivos forem digitados:\n");

// Leitura dos números e verificação do critério de parada

for (i = 0; i < 10; i++) {
scanf("%d", &numeros[i]);
tamanho++;

if (i > 0 && numeros[i] == numeros[i - 1]) {

tamanho--; // Desconsidera o último número repetido
break;
}
}

// Verifica o maior e o menor número

maior = menor = numeros[0];
for (i = 0; i < tamanho; i++) {
soma += numeros[i];

if (numeros[i] > maior) {

maior = numeros[i];
}
if (numeros[i] < menor) {
menor = numeros[i];
}
}

// Calcula a média dos números

media = (float)soma / tamanho;

// Imprime o maior, o menor, a média e a soma dos números

printf("\nMaior numero: %d\n", maior);
printf("Menor numero: %d\n", menor);
printf("Media dos numeros: %.2f\n", media);
printf("Soma dos numeros: %d\n", soma);

return 0;
}

16) Tentando descobrir se um dado era viciado, um dono de cassino honesto o lançou n
vezes. Dados os n resultados dos lançamentos, determinar o número de ocorrências em cada
face.

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main() {
int n;
int i;

printf("Digite o numero de lancamentos do dado: ");

scanf("%d", &n);

// Inicializa um array para armazenar o número de ocorrências de cada face do dado

int frequencia[6] = {0}; // Inicializa todos os elementos com zero

// Lança o dado n vezes e conta o número de ocorrências de cada face

srand(time(NULL)); // Semente para geração de números aleatórios
for (i = 0; i < n; i++) {
int resultado = rand() % 6 + 1; // Gera um número aleatório de 1 a 6 (faces do dado)
frequencia[resultado - 1]++; // Incrementa o contador para a face correspondente
}

// Imprime o número de ocorrências de cada face do dado

printf("\nOcorrencias de cada face do dado:\n");
for (i = 0; i < 6; i++) {
printf("Face %d: %d vezes\n", i + 1, frequencia[i]);
}

return 0;
}

17) Um usuário deseja obter todos os números primos, em ordem crescente, de uma série de
20 número aleatórios, não seriados.Elabore um programa que solucione esse problema, e
imprima a seqüência digitada pelo usuário, a seqüência dos números primos em ordem
crescente e a seqüência dos números não utilizados (não primos).

#include <stdio.h>
#include <stdbool.h>

bool ehPrimo(int numero) {

if (numero <= 1) {
return false;
}
for (int i = 2; i * i <= numero; i++) {
if (numero % i == 0) {
return false;
}
}
return true;
}

int main() {
int numeros[20];
int primos[20], naoPrimos[20];
int qtdPrimos = 0, qtdNaoPrimos = 0;
 int i;

printf("Digite uma sequencia de 20 numeros: \n");

for (i = 0; i < 20; i++) {
scanf("%d", &numeros[i]);
if (ehPrimo(numeros[i])) {
primos[qtdPrimos] = numeros[i];
qtdPrimos++;
} else {
naoPrimos[qtdNaoPrimos] = numeros[i];
qtdNaoPrimos++;
}
}

// Imprime a sequência digitada pelo usuário

printf("\nSequencia digitada pelo usuario: ");
for (i = 0; i < 20; i++) {
printf("%d ", numeros[i]);
}

// Imprime a sequência dos números primos em ordem crescente

printf("\nNumeros primos em ordem crescente: ");
for (i = 0; i < qtdPrimos; i++) {
printf("%d ", primos[i]);
}

// Imprime a sequência dos números não primos em ordem crescente

printf("\nNumeros nao primos em ordem crescente: ");
for (i = 0; i < qtdNaoPrimos; i++) {
printf("%d ", naoPrimos[i]);
}

return 0;
}

18) Faça um programa que utilize uma estrutura de repetição para ler 50 números
armazenando-os em um vetor e calcule e exiba a média aritmética deles. Em seguida o
programa deve apresentar todos os valores armazenados no vetor que sejam menores que a
média.

#include <stdio.h>

int main() {
int numeros[50];
int i;
float media = 0;
int soma = 0;
int menoresQueMedia[50];
int quantidadeMenores = 0;

printf("Digite 50 numeros:\n");
 // Leitura dos números e cálculo da média
for (i = 0; i < 50; i++) {
scanf("%d", &numeros[i]);
soma += numeros[i];
}

media = (float)soma / 50; // Calcula a média

// Encontra os valores menores que a média e os armazena em um vetor separado

for (i = 0; i < 50; i++) {
if (numeros[i] < media) {
menoresQueMedia[quantidadeMenores] = numeros[i];
quantidadeMenores++;
}
}

// Imprime a média aritmética

printf("\nMedia aritmetica dos numeros: %.2f\n", media);

// Imprime os valores menores que a média

printf("Valores menores que a media: ");
for (i = 0; i < quantidadeMenores; i++) {
printf("%d ", menoresQueMedia[i]);
}

return 0;
}

19) Desenvolva um programa que leia um vetor unidimensional de 10 números inteiro e

exiba-o verticalmente, trocando os elementos entre si, dois a dois, ou seja, os de índices par
com os de índice ímpar.

#include <stdio.h>

int main() {
int vetor[10];
int i, temp;

printf("Digite 10 numeros inteiros:\n");

// Leitura dos números e armazenamento no vetor

for (i = 0; i < 10; i++) {
scanf("%d", &vetor[i]);
}

printf("\nVetor original:\n");

// Exibe o vetor original

for (i = 0; i < 10; i++) {
 printf("%d\n", vetor[i]);
}

// Troca os elementos dois a dois (índices pares com índices ímpares)

for (i = 0; i < 9; i += 2) {
temp = vetor[i];
vetor[i] = vetor[i + 1];
vetor[i + 1] = temp;
}

printf("\nVetor com elementos trocados:\n");

// Exibe o vetor com os elementos trocados

for (i = 0; i < 10; i++) {
printf("%d\n", vetor[i]);
}

return 0;
}

20) Construa um programa que gere um vetor VI, que receba um número par de elementos e
multiplique os mesmos devolvendo o array resultante.

Por exemplo, o array de entrada com os valores {1, 23, 10, 5, 7, 11} resulta no array de saída

{23, 50, 77}.

#include <stdio.h>

#define MAX 100

// Função para gerar o vetor resultante

void multiplicaElementos(int arr[], int n, int resultante[]) {
int j;
for (j = 0; j < n - 1; j += 2) {
resultante[j / 2] = arr[j + 1] * arr[j + 2];
}
}

int main() {
int vetorEntrada[MAX];
int vetorSaida[MAX / 2]; // Tamanho será metade do vetor de entrada

int tamanho;
int i;

printf("Digite um numero par de elementos para o vetor: ");

scanf("%d", &tamanho);

if (tamanho % 2 != 0 || tamanho <= 0 || tamanho > MAX) {

printf("Por favor, digite um numero par e valido (maximo %d).\n", MAX);
 return 1;
}

printf("Digite os %d elementos do vetor:\n", tamanho);

for (i = 0; i < tamanho; i++) {
scanf("%d", &vetorEntrada[i]);
}

// Verifica se o tamanho é par e gera o vetor resultante

if (tamanho % 2 == 0) {
multiplicaElementos(vetorEntrada, tamanho, vetorSaida);

printf("\nVetor resultante apos multiplicacao dos elementos:\n");

for (i = 0; i < tamanho / 2; i++) {
printf("%d ", vetorSaida[i]);
}
printf("\n");
}

return 0;
}

21) Dados dois vetores x e y, ambos com n elementos, determinar ambos, são exatamente
iguais.

#include <stdio.h>

#define MAX 100

// Função para verificar se dois vetores são iguais

int saoIguais(int vetor1[], int vetor2[], int tamanho) {
int i;
for (i = 0; i < tamanho; i++) {
if (vetor1[i] != vetor2[i]) {
return 0; // Retorna 0 se encontrar elementos diferentes
}
}
return 1; // Retorna 1 se os vetores forem exatamente iguais
}

int main() {
int n;
int vetorX[MAX], vetorY[MAX];
int i;

printf("Digite o tamanho dos vetores: ");

scanf("%d", &n);

printf("Digite os elementos do vetor X:\n");

 for (i = 0; i < n; i++) {
scanf("%d", &vetorX[i]);
}

printf("Digite os elementos do vetor Y:\n");

for (i = 0; i < n; i++) {
scanf("%d", &vetorY[i]);
}

// Verifica se os vetores X e Y são exatamente iguais

if (saoIguais(vetorX, vetorY, n)) {
printf("Os vetores X e Y sao exatamente iguais.\n");
} else {
printf("Os vetores X e Y nao sao exatamente iguais.\n");
}

return 0;
}

22) Dada uma sequência de n termos que contenha os números reais (0.0, 1.5, -1.7, 2.3 e 3.0)
determinar os números que compõem a sequência e o número de vezes que cada um deles
ocorre na mesma.

Exemplo: n = 8

Sequência: [-1.7, 3.0, 0.0, 1.5, 0.0, -1.7, 2.3, -1.7] Saída:-1.7 ocorre 3 vezes

3.0 ocorre 1 vez 0.0 ocorre 2 vezes 1.5 ocorre 1 vez 2.3 ocorre 1 vez 34

#include <stdio.h>

#define MAX 100

int main() {
int n;
double sequencia[MAX];
int contagem[MAX];

printf("Digite o numero de termos na sequencia: ");

scanf("%d", &n);

printf("Digite os numeros da sequencia:\n");

int i;
for (i = 0; i < n; i++) {
scanf("%lf", &sequencia[i]);
contagem[i] = 0; // Inicializa a contagem para cada termo como 0
}

// Contagem de ocorrências de cada número na sequência

int j;
 for (i = 0; i < n; i++) {
if (contagem[i] != -1) {
int count = 1;
for (j = i + 1; j < n; j++) {
if (sequencia[i] == sequencia[j]) {
count++;
contagem[j] = -1; // Marcando termo repetido para não ser contado novamente
}
}
contagem[i] = count;
}
}

// Exibindo a contagem de ocorrências de cada número na sequência

printf("\nResultado da sequencia:\n");
for (i = 0; i < n; i++) {
if (contagem[i] != -1) {
printf("%.1lf ocorre %d vez(es)\n", sequencia[i], contagem[i]);
}
}

return 0;
}