[3,0] Criar um programa que leia um vetor com n elementos, identifique e imprima seus elementos positivos;

Passo 1

O enunciado pede: criar um programa que leia um vetor com n elementos, identifique e imprima seus elementos positivos.
Informações importantes que o enunciado fornece (ou que precisamos assumir para implementar):
  • O tamanho do vetor é n (valor lido na entrada).
  • O vetor contém n elementos (vamos assumir elementos inteiros para ficar simples; se fossem reais o raciocínio é o mesmo mudando o tipo).
  • Devemos imprimir apenas os elementos estritamente positivos (ou seja, maiores que 0).
  • Não foi dito o formato exato da saída; adotaremos um formato prático: listar os positivos separados por espaço numa linha ou imprimir uma mensagem se não houver positivos.

Passo 2

Entendendo as informações que vamos usar (explicação didática):
  • Vamos guardar os n elementos em um vetor (array). Em programação um vetor é uma sequência de posições, indexadas por um índice i. Em C (por exemplo) os índices vão tipicamente de 0 até n-1. Isso significa que o primeiro elemento é a[0] e o último é a[n-1].
  • Para ler os elementos percorremos o vetor e, para cada posição i, lemos um valor e armazenamos em a[i].
  • Para identificar os positivos usamos uma condição simples: testar se a[i] > 0. O operador > compara dois números; a expressão a[i] > 0 é verdadeira quando a[i] é maior que 0.

Passo 3

Como estruturar o programa (passos lógicos que você aplica na prova):
  1. Ler o inteiro n. Verificar que n é maior que 0 (caso contrário é inválido ou podemos terminar).
  2. Alocar um vetor com n posições. Cada posição armazenará um inteiro (no nosso caso).
  3. Usar um laço para ler cada elemento a[i] para i = 0,1,\dots,n-1.
  4. Usar outro laço para percorrer o vetor e, a cada a[i], testar a[i] > 0. Se verdadeiro, imprimir a[i].
  5. Se durante a verificação não encontrarmos nenhum positivo, imprimir uma mensagem tipo “Nenhum elemento positivo.”.

Passo 4

Explicando o laço (for) e a condição (if) de maneira simples e passo a passo:
  • O laço for tem essa ideia: repetir uma ação começando com i=0, enquanto i < n, e em cada passo aumentar i em 1. Em pseudo-estrutura:
\text{for }(i=0; \; i<n; \; i++)\\ \{ \\ \text{fazer algo com }a[i]\\ \}
Aqui i++ significa "incrementa i em 1".
  • A condição para checar positivo é:
\text{if }(a[i] > 0)\\ \{ \\ \text{imprimir }a[i]\\ \}
Note que usamos > e não \ge, porque queremos números estritamente maiores que 0.

Passo 5

Como imprimir de forma bonita (sugestão prática para prova):
  • Podemos imprimir todos os positivos na mesma linha, separados por espaços. Para evitar espaço extra no final, usamos uma variável auxiliar \text{found} que indica se já imprimimos algum positivo; se \text{found}=0 imprimimos o primeiro sem espaço à esquerda, depois para os seguintes imprimimos um espaço antes.
  • Alternativa: imprimir cada positivo em sua própria linha; isso é ainda mais simples e também aceito em muitos contextos.

Passo 6

Exemplo concreto para fixar (faça mentalmente, como exercício):
Suponha n=5 e o vetor lido seja [ -2,\, 0,\, 7,\, 3,\, -1 ].
  • Percorrendo: a[0]=-2 (não é >0), a[1]=0 (não é >0), a[2]=7 ( >0 → imprimir 7), a[3]=3 ( >0 → imprimir 3), a[4]=-1 (não).
  • Saída (na linha): “7 3”
    Se nenhum elemento fosse positivo, por exemplo [ -1,\, 0,\, -3 ], imprimimos “Nenhum elemento positivo.”.

Passo 7

Complexidade e justificativa rápida (para prova):
  • Lemos n elementos (um laço de n iterações) e fazemos mais um laço de n iterações para verificar positivos. Portanto o algoritmo é linear: tempo proporcional a n, ou seja, complexidade O(n). Isso é eficiente e esperado para esse problema.

Passo 8

Tratamento de casos extremos e validações úteis:
  • Se n \le 0 podemos encerrar com uma mensagem de erro ou simplesmente não processar nada.
  • Se houver restrição de memória para vetores muito grandes, poderia-se processar elemento-a-elemento sem armazenar tudo (ler um valor e já testar se é positivo), economizando memória. Essa variação faz apenas um laço e não usa vetor — útil em prova se pedirem economia de memória.

Passo 9

Últimos detalhes antes do código final — resumo das escolhas que fiz:
  • Tipo dos elementos: inteiros.
  • Estratégia: ler n, ler vetor, percorrer para imprimir positivos, caso não exista imprimir mensagem.
  • Impressão: positivos separados por espaço em uma linha, terminando com quebra de linha.

Resposta

#include <stdio.h>
#include <stdlib.h>
int main(void) {
int n;
if (scanf("%d", &n) != 1) return 0;
if (n <= 0) {
printf(“Tamanho invalido.\n”);
return 0;
}
int *a = malloc(n * sizeof(int));
if (!a) return 1;

for (int i = 0; i < n; i++) {
    if (scanf("%d", &a[i]) != 1) { free(a); return 0; }
}

int found = 0;
for (int i = 0; i < n; i++) {
    if (a[i] > 0) {
        if (found) printf(" ");
        printf("%d", a[i]);
        found = 1;
    }
}

if (!found) {
    printf("Nenhum elemento positivo.");
}
printf("\n");

free(a);
return 0;
}

Exercícios relacionados