Foi feita uma pesquisa de audiência de canal de TV em várias casas de uma certa cidade num determinado dia. Para cada casa visitada, é fornecido o número do canal (4,5,10,13) e o número de pessoas que estavam assistindo naquela casa. Se a televisão estivesse desligada, nada era anotado, ou seja, esta casa não entrava na pesquisa. Fazer um programa que:
  • Leia um número indeterminado de dados, sendo que o “flag” corresponde ao número do canal igual a zero;
  • Calcule a porcentagem de audiência para cada emissora e escreva o número de cada canal e sua respectiva porcentagem;

Passo 1

O que o enunciado pede e quais informações são dadas:
  • O enunciado pede que se faça um programa que leia um número indeterminado de registros e, ao final, calcule a porcentagem de audiência de cada emissora e imprima o número do canal com sua respectiva porcentagem.
  • Cada registro da pesquisa contém dois dados: o número do canal e o número de pessoas assistindo naquela casa.
  • Os canais possíveis são (4,5,10,13).
  • O valor de flag que sinaliza o fim da leitura é o número do canal igual a (0).
  • Casas com a TV desligada não aparecem na pesquisa (logo não entram como registros).
  • Saída esperada: para cada um dos canais (4,5,10,13) mostrar a porcentagem da audiência relativa ao total de pessoas contabilizadas na pesquisa.
Resumindo, as perguntas explícitas do enunciado:
  • Como ler os dados até o flag (0)?
  • Como calcular a porcentagem de audiência de cada canal?
  • Como exibir o número do canal e sua porcentagem?

Passo 2

Estratégia geral (passo-a-passo do algoritmo, sem código ainda):
  1. Inicializar um contador de espectadores por canal; ou seja, armazenar para cada canal (4,5,10,13) o total de pessoas que marcaram esse canal. Vou chamar esses acumuladores de \text{A}_4,\\ \text{A}_5,\\ \text{A}_{10},\\ \text{A}_{13}.
  2. Inicializar o total de espectadores \text{T} como zero.
  3. Repetir a leitura de registros (cada registro tem: número do canal e número de pessoas):
    • Se o número do canal lido for (0), parar a leitura (esse é o flag).
    • Caso contrário, somar o número de pessoas ao acumulador do respectivo canal e somar também em \text{T}.
    • Se aparecer um número de canal diferente de (4,5,10,13) (erro de entrada), ignorar o canal ou tratar como inválido (a implementação que segue vai ignorar canais não esperados).
  4. Depois que a leitura terminar, calcular para cada canal a porcentagem de audiência \% usando a fórmula de porcentagem abaixo.
  5. Tratar o caso especial \text{T}=0 (nenhum telespectador contabilizado): evitar divisão por zero e, nesse caso, definir as porcentagens como 0\%.

Passo 3

Fórmula da porcentagem e explicação didática (a “aula” sobre o que estamos calculando):
  • Porcentagem significa “parte por cem”. Se um canal tem, por exemplo, \text{A}_4 espectadores e o total de espectadores é \text{T}, a porcentagem de audiência do canal 4 é:
\text{Porcentagem do canal 4} = \frac{\text{A}_4}{\text{T}} \times 100.
  • Aqui:
    • \text{A}_4 é o número total de pessoas que estavam assistindo ao canal (4).
    • \text{T} é o número total de pessoas contabilizadas na pesquisa (soma de todas as \text{A}_\text{canal}).
  • A multiplicação por 100 transforma a fração em porcentagem.
  • Se \text{T}=0, a fração não é definida; nesse caso, interpretamos que não houve espectadores na pesquisa e todas as porcentagens valem 0\%.
Exemplo simples para fixar: se \text{A}_4 = 30 e \text{T} = 120,
\frac{30}{120}\times100 = \frac{1}{4}\times100 = 25{,}00\%.
Ou seja, canal 4 tem 25{,}00\% da audiência.

Passo 4

Como implementar a leitura até o flag (conceito do sentinel) — aula curta:
  • Um “flag” ou “sentinela” é um valor especial que indica término de dados. Aqui o sentinel é o número do canal igual a (0).
  • Leitura típica: em loop, lê-se um par (\text{canal},\\ \text{pessoas}). Logo após ler \text{canal}, testa-se se \text{canal} = 0. Se for, sai do loop sem processar esse registro. Caso contrário, processa-se o registro.
  • Em problemas de programação que leem de entrada padrão, costuma-se ler linhas até o final ou até encontrar o sentinel. Se a entrada vier em linhas, cada linha pode ter dois inteiros separados por espaço; se vier em fluxo contínuo, lê-se dois inteiros por iteração.

Passo 5

Exemplo numérico completo (simulado) para ver as contas na prática:
Suponha que a sequência de registros lidos (cada par é (\text{canal},\\ \text{pessoas})) seja:
(4,30),\\ (5,45),\\ (10,15),\\ (13,10),\\ (0,0).
  • Acumular:
    • \text{A}_4 = 30
    • \text{A}_5 = 45
    • \text{A}_{10} = 15
    • \text{A}_{13} = 10
  • Total:
\text{T} = 30+45+15+10 = 100.
  • Porcentagens:
\text{P}_4 = \frac{30}{100}\times100 = 30{,}00\%,
\text{P}_5 = \frac{45}{100}\times100 = 45{,}00\%,
\text{P}_{10} = \frac{15}{100}\times100 = 15{,}00\%,
\text{P}_{13} = \frac{10}{100}\times100 = 10{,}00\%.
Observe que as porcentagens somam 100{,}00\% (verificação útil para detectar erros).

Passo 6

Formato de saída e arredondamento recomendados:
  • É comum apresentar as porcentagens com duas casas decimais, por exemplo: "Canal 4: 30.00 %".
  • Decida se haverá separador decimal com vírgula ou ponto conforme a exigência do exercício; aqui vou usar ponto decimal (formato comum em programação).
  • Imprimir cada linha com o número do canal e a porcentagem formatada com duas casas decimais.

Resposta

# Programa em Python que lê pares (canal, pessoas) até canal == 0
# e imprime a porcentagem de audiência para os canais 4, 5, 10 e 13.

import sys

def main():
    counts = {4: 0, 5: 0, 10: 0, 13: 0}
    total = 0

    # Leitura robusta: cada linha pode conter um ou mais pares; assumimos pares canal pessoas por linha
    for line in sys.stdin:
        parts = line.strip().split()
        if not parts:
            continue
        # Processar tokens em pares
        i = 0
        while i + 1 < len(parts):
            try:
                canal = int(parts[i])
                pessoas = int(parts[i + 1])
            except ValueError:
                # tokens inválidos: pular estes dois e seguir
                i += 2
                continue

            if canal == 0:
                # flag de parada: termina a leitura e sai completamente
                i = len(parts)  # força saída do while interno
                # esvazia o iterador do for lendo até o fim sem fazer nada
                # para terminar imediatamente a função:
                print_percentages(counts, total)
                return

            if canal in counts:
                counts[canal] += pessoas
            else:
                # canal não esperado: ignorar (ou poderia acumular separadamente)
                pass
            total += pessoas
            i += 2

    # Se chegou ao EOF sem encontrar canal == 0, imprime resultados também
    print_percentages(counts, total)

def print_percentages(counts, total):
    canais = [4, 5, 10, 13]
    if total == 0:
        for ch in canais:
            print(f"Canal {ch}: 0.00%")
    else:
        for ch in canais:
            pct = counts[ch] * 100.0 / total
            print(f"Canal {ch}: {pct:.2f}%")

if __name__ == "__main__":
    main()

Exercícios relacionados