Leia valores reais para uma matriz M de dimensões M \times N (informadas previamente pelo usuário). Depois apresente esses valores conforme o formato do exercício anterior.

Passo 1

O enunciado pede que a gente leia valores reais para uma matriz de dimensões M \times N, onde M (número de linhas) e N (número de colunas) são informados previamente pelo usuário. Depois devemos apresentar esses valores “no formato do exercício anterior”, ou seja, exibindo a matriz com suas linhas e colunas (cada linha numa linha de saída), mantendo a ordem de entrada.
Informações relevantes dadas:
  • O usuário informa M e N.
  • Devemos ler M \times N números reais.
  • Devemos mostrar esses valores formatados como matriz (linha por linha).

Passo 2

Como representar a matriz em memória (explicação didática):
  • Vamos usar uma lista de listas (estrutura comum em linguagens como Python). Cada elemento da lista externa representa uma linha.
  • Denotando os elementos por a_{ij}, i indica a linha ( 1 \le i \le M) e j indica a coluna ( 1 \le j \le N). Na implementação em programação normalmente usamos índices começando em zero, mas conceitualmente pense em i=1..M e j=1..N.
  • Vantagem: acessar o elemento da linha i coluna j é feito com algo como matrix[i][j] (ou matrix[i-1][j-1] se você pensa em i,j começando em 1).

Passo 3

Como ler as dimensões M e N (boas práticas e validação):
  • Precisamos aceitar apenas inteiros positivos para M e N. Se o usuário digitar algo inválido (texto, número negativo, zero), devemos pedir novamente.
  • Em pseudocódigo:
    • repetir até obter M válido: ler entrada, tentar converter para inteiro, verificar M>0.
    • mesmo para N.
  • Por que validar? Em prova/concursos, entradas inválidas podem quebrar o programa; a validação garante robustez (e não é muito custo).

Passo 4

Como ler os M\times N valores reais — estratégias e escolha:
  • Estratégia A (mais interativa): para cada posição (i,j) pedir um número separado. Simples, mas muito verbosa para o usuário.
  • Estratégia B (mais prática): para cada linha i pedir uma linha com N valores separados por espaço. Isso reduz prompts e é comum em exercícios/programação competitiva.
  • Eu escolho a Estratégia B porque é mais prática e rápida na prova: para cada linha você digita N números, o programa separa e converte para float.
  • Validações a fazer para cada linha:
    • O usuário deve fornecer exatamente N tokens (se der menos ou mais, pedimos novamente).
    • Cada token deve ser convertível para número real (float). Se não for, pedimos novamente.
  • Implementação conceitual com laços:
    • para i de 1 até M:
      • enquanto True:
        • ler uma linha de texto
        • dividir em tokens
        • se número de tokens != N: avisar e repetir
        • tentar converter tokens para floats; se falhar avisar e repetir
        • se tudo certo: armazenar como linha e sair do while

Passo 5

Como apresentar (formatar) os valores na saída:
  • O enunciado quer a apresentação no formato de matriz (cada linha aparece numa linha). Uma forma clara e comum:
    • imprimir cada linha com os N valores separados por um espaço.
    • opcional: controlar a formatação numérica (por exemplo, duas casas decimais) para saída mais legível. Isso evita muitos dígitos não desejados.
  • Exemplo de formato por linha (com 2 casas decimais):
    1.50 0.00 -3.25
    4.00 2.33 5.10
  • Em programação usamos algo como ’ '.join("{:.2f}".format(x) for x in row) para cada linha.
  • Importante: se o exercício anterior tiver um formato diferente (tipo largura fixa), dá para ajustar a string de formatação; aqui eu uso duas casas decimais como escolha razoável e amplamente aceitável.

Passo 6

Detalhes de implementação e explicação das partes do código (linha a linha, pensando em Python):
  • Função de leitura de inteiro positivo:
    • laço infinito que tenta converter a entrada em inteiro e checa se é maior que zero; em erro, mostra mensagem e repete.
  • Leitura das linhas da matriz:
    • para cada linha i (vai de 0 a M-1 no código):
      • pede ao usuário uma linha com N valores
      • faz split() para obter tokens
      • se len(tokens) != N -> mensagem de erro e continuar pedindo
      • tenta converter cada token em float; se der ValueError -> mensagem de erro e repetir
      • se correto, adiciona a lista de floats como a linha i
  • Impressão:
    • definimos um formato (por exemplo, duas casas: “{:.2f}”) e aplicamos a cada elemento, juntando com espaço e imprimindo linha por linha.

Passo 7

Algumas variações e observações rápidas para sua prova:
  • Se o enunciado exigir outra formatação (ex.: 1 casa decimal, ou largura fixada), troque “{:.2f}” por “{:.1f}” ou “{:8.2f}”.
  • Se for aceitar entradas em notação científica, float() já cuida disso.
  • Se preferir ler elemento a elemento (um por um), use dois laços aninhados e leia float(input(…)) em cada iteração.
  • Teste mental: para M=2, N=3 e entrada das linhas “1 2 3” e “4.5 -1 0”, a saída (com 2 casas) será:
    1.00 2.00 3.00
    4.50 -1.00 0.00

Resposta

def read_positive_int(prompt):
    while True:
        try:
            v = int(input(prompt))
            if v <= 0:
                print("Digite um inteiro positivo.")
            else:
                return v
        except ValueError:
            print("Entrada inválida. Digite um inteiro.")

def read_matrix(M, N):
    matrix = []
    for i in range(M):
        while True:
            line = input(f"Digite {N} valores reais para a linha {i+1}, separados por espaço: ").strip()
            parts = line.split()
            if len(parts) != N:
                print(f"Número de valores incorreto (esperado {N}). Tente novamente.")
                continue
            try:
                row = [float(x) for x in parts]
                matrix.append(row)
                break
            except ValueError:
                print("Entrada inválida. Use números reais (ex: 1.5). Tente novamente.")
    return matrix

def print_matrix(matrix, decimals=2):
    fmt = ("{:." + str(decimals) + "f}").format
    for row in matrix:
        print(' '.join(fmt(x) for x in row))

def main():
    M = read_positive_int("Número de linhas (M): ")
    N = read_positive_int("Número de colunas (N): ")
    mat = read_matrix(M, N)
    print("Matriz:")
    print_matrix(mat, decimals=2)

if __name__ == "__main__":
    main()

Exercícios relacionados