Faça um programa que leia 10 números inteiros usando for. O programa deve somar apenas os números positivos digitados pelo usuário.
Ao final, mostre:
Soma dos positivos: X
Quantidade de números negativos: Y
Quantidade de zeros: Z

Passo 1

O enunciado pede que você escreva um programa que:
  • Leia exatamente 10 números inteiros digitados pelo usuário (um por vez), usando um laço do tipo for.
  • Some apenas os números positivos digitados.
  • Conte quantos números negativos foram digitados.
  • Conte quantos zeros foram digitados.
  • Ao final, mostre exatamente as três linhas abaixo, substituindo X, Y e Z pelos valores obtidos:
    Soma dos positivos: X
    Quantidade de números negativos: Y
    Quantidade de zeros: Z
Informações relevantes dadas:
  • Número de entradas: 10 valores inteiros.
  • Operações a realizar: soma seletiva (apenas positivos) e contagem de negativos e zeros.
  • Formato de saída: três linhas com os rótulos acima.

Passo 2

Plano de solução (o que o programa precisa ter, em termos de variáveis e estrutura):
  • Um laço for que percorra 10 iterações (uma por número lido).
  • Uma variável acumuladora para a soma dos positivos; inicializar com 0, por exemplo chamada sum_positive.
  • Dois contadores para contagens: negative_count e zero_count, ambos iniciados em 0.
  • Em cada iteração:
    • Ler o número (converter para inteiro).
    • Testar se é maior que zero → então adicionar ao acumulador.
    • Senão, testar se é igual a zero → então incrementar contador de zeros.
    • Senão (ou seja, menor que zero) → incrementar contador de negativos.
  • Ao final do laço, imprimir os três valores no formato pedido.
Essa organização (acumulador + contadores + laço + decisões) é a forma padrão e direta para esse tipo de problema.

Passo 3

Conceitos usados e explicação didática (mastigada) dos blocos principais:
  1. Laço for:
  • É uma estrutura que repete um bloco de código um número conhecido de vezes. No nosso caso precisamos repetir 10 vezes.
  • Em Python, por exemplo, usamos for i in range(10): para repetir algo 10 vezes (os valores de i vão de 0 a 9).
  1. Entrada do usuário e conversão:
  • input() lê uma linha do teclado como texto (string).
  • Para transformar em inteiro usamos int(input()). Se o usuário digitar um inteiro válido, obtemos um valor do tipo inteiro que podemos comparar e somar.
  1. Acumulador e contadores:
  • Acumulador (sum_positive): guarda a soma atual dos números que são positivos. Inicialmente 0. Quando encontramos um número positivo n, fazemos sum_positive += n (equivalente a sum_positive = sum_positive + n).
  • Contadores (negative_count, zero_count): iniciam em 0. Quando ocorre um evento (número negativo ou zero) incrementamos com negative_count += 1.
  1. Estrutura condicional:
  • Usamos if, elif, else (em Python) para decidir em qual caso o número se encaixa:
    • if n > 0: → positivo
    • elif n == 0: → zero
    • else: → negativo

Passo 4

Escrevendo o programa passo a passo (explicando cada linha). Vou usar Python porque é curto e claro; o mesmo raciocínio serve para outras linguagens.
Código (com explicação linha a linha depois):
sum_positive = 0
negative_count = 0
zero_count = 0

for i in range(10):
    n = int(input())
    if n > 0:
        sum_positive += n
    elif n == 0:
        zero_count += 1
    else:
        negative_count += 1

print("Soma dos positivos:", sum_positive)
print("Quantidade de números negativos:", negative_count)
print("Quantidade de zeros:", zero_count)
Explicação linha a linha:
  • sum_positive = 0 — cria o acumulador da soma dos positivos e inicializa em 0.
  • negative_count = 0 — contador de números negativos, inicia em 0.
  • zero_count = 0 — contador de zeros, inicia em 0.
  • for i in range(10): — inicia um laço que vai executar o bloco dentro dele exatamente 10 vezes. A variável i não é usada, só controla o número de iterações.
  • n = int(input()) — lê uma linha digitada pelo usuário e converte para inteiro; esse é o número que vamos analisar.
  • if n > 0: — se n for maior que zero, é positivo.
    • sum_positive += n — adiciona n ao acumulador dos positivos.
  • elif n == 0: — se não era maior que zero e é igual a zero, então é zero.
    • zero_count += 1 — incrementa contador de zeros.
  • else: — se não é positivo nem zero, só resta ser negativo.
    • negative_count += 1 — incrementa contador de negativos.
  • print("Soma dos positivos:", sum_positive) — mostra a soma dos positivos no formato pedido.
  • print("Quantidade de números negativos:", negative_count) — mostra a quantidade de negativos.
  • print("Quantidade de zeros:", zero_count) — mostra a quantidade de zeros.
Observações práticas:
  • O enunciado não exige prompts (textos pedindo para o usuário digitar). Em provas, muitas vezes só se espera ler 10 valores; por isso o input() puro está OK.
  • Se quiser, na prática você pode pedir “Digite um número:” antes de cada leitura, mas isso muda um pouco o formato de entrada/saída.

Passo 5

Exemplo de execução manual para você entender como o programa age:
Suponha que o usuário digite, em sequência, os 10 valores:
3, -1, 0, 5, 10, -2, -3, 0, 7, -4
Vamos acompanhar:
  • Iteração 1: n = 3 → positivo → sum_positive = 3
  • Iteração 2: n = -1 → negativo → negative_count = 1
  • Iteração 3: n = 0 → zero → zero_count = 1
  • Iteração 4: n = 5 → positivo → sum_positive = 3 + 5 = 8
  • Iteração 5: n = 10 → positivo → sum_positive = 8 + 10 = 18
  • Iteração 6: n = -2 → negativo → negative_count = 2
  • Iteração 7: n = -3 → negativo → negative_count = 3
  • Iteração 8: n = 0 → zero → zero_count = 2
  • Iteração 9: n = 7 → positivo → sum_positive = 18 + 7 = 25
  • Iteração 10: n = -4 → negativo → negative_count = 4
Saída final mostrada:
Soma dos positivos: 25
Quantidade de números negativos: 4
Quantidade de zeros: 2

Passo 6

Dicas rápidas para a prova e erros comuns:
  • Não esqueça de inicializar os acumuladores/contadores com 0 antes do laço — se não fizer isso, vai dar erro ou resultado errado.
  • Use exatamente 10 leituras (nem mais, nem menos) — for i in range(10): é a forma direta.
  • Atenção ao teste elif n == 0:: se você colocar apenas if n > 0: ... if n == 0: ... else: ... sem elif, a lógica pode continuar executando o else indevidamente em algumas linguagens; em Python o elif deixa claro que são casos mutuamente exclusivos.
  • Em linguagens que exigem checagem de erro na conversão de string para inteiro (como C), trate a leitura adequadamente. Em prova de lógica/programação é comum usar Python por ser mais direto.

Passo 7

Encorajamento final: você já tem o esqueleto correto — laço para 10 entradas, acumulador para positivos e dois contadores. Se praticar esse padrão (leitura → decisão → atualização de acumulador/contador) em alguns exercícios, vai ficar automático na prova. Vai dar certo — respira, copia o código, e testa uma vez antes da prova para ganhar confiança!

Resposta

sum_positive = 0
negative_count = 0
zero_count = 0

for i in range(10):
    n = int(input())
    if n > 0:
        sum_positive += n
    elif n == 0:
        zero_count += 1
    else:
        negative_count += 1

print("Soma dos positivos:", sum_positive)
print("Quantidade de números negativos:", negative_count)
print("Quantidade de zeros:", zero_count)

Exercícios relacionados