Faça um programa que leia duas matrizes de nl linhas por nc colunas (de números reais), some as duas matrizes, e depois mostre a matriz resultante.
O programa deve ter duas funções. A primeira deve receber como parâmetros o número de linhas e o número de colunas, e retornar a matriz criada e preenchida pelo usuário. A segunda função deve receber duas matrizes como parâmetros e retornar uma matriz como resultado da soma das duas matrizes.
O programa também deve ter um procedimento que será responsável por receber os dados dos números de linhas e colunas das matrizes, criar as duas matrizes usando a primeira função duas vezes (uma para cada matriz criada), somar as duas matrizes com a segunda função, e por fim mostrar na tela a matriz resultante.
Entradas:
  1. Número de linhas e número de colunas da matriz de reais
  2. Os números reais da duas matrizes, uma de cada vez
Saídas:
  1. Os números da matriz somada resultante
Exemplo de Entrada:
23
1.5 \quad 0 \quad-4.1
0.917 .8
-0.1 13.1
\begin{array}{lll}0.1 & 9 & 2.2\end{array}
Exemplo de Saída:
1.4 1 -1
11010

Passo 1

O problema pede um programa que leia duas matrizes de números reais com o mesmo tamanho e mostre a matriz soma. Vou deixar bem claro o que é pedido e quais dados temos.
  • Entradas:
    • O número de linhas e o número de colunas da matriz; chamo-os de nl e nc.
    • Em seguida, os nl\times nc números reais da primeira matriz A, lidos linha a linha.
    • Depois, os nl\times nc números reais da segunda matriz B, lidos linha a linha.
  • Saída:
    • A matriz resultante C=A+B, impressa linha a linha, cada linha com nc números separados por espaço.
Observações importantes (do enunciado e para evitar surpresas na prova):
  • O enunciado exige duas funções e um procedimento (que organiza a execução). Vou cumprir isso.
  • Os números reais podem vir com formatos como 0.8, .8, -4.1, etc. O programa deve aceitar esses formatos.
  • Na prova, geralmente a entrada vem pelo stdin (sem prompts interativos), então o programa será escrito para ler da entrada padrão.

Passo 2

Decisão de método e estruturas de dados (explicação prática e simples).
  • Representação da matriz: uma matriz será uma lista de listas. Cada linha é uma lista com nc floats; a matriz tem nl linhas.
    • Exemplo: uma matriz 2\times 3 pode ser representada como [[1.5, 0.0, -4.1], [0.917, 0.8, -0.1]].
  • Funções exigidas:
    1. create_matrix(nl, nc) — recebe nl e nc e retorna a matriz preenchida pelo usuário (no nosso caso, lendo a entrada). Esta função monta a estrutura e converte os valores para float.
    2. add_matrices(A, B) — recebe duas matrizes e retorna a matriz soma C com C[i][j] = A[i][j] + B[i][j].
  • Procedimento principal:
    • Ler nl e nc.
    • Chamar create_matrix(nl, nc) duas vezes para obter A e B.
    • Chamar add_matrices(A, B) para obter C.
    • Mostrar C linha a linha.

Passo 3

Como ler a entrada de forma robusta (sem depender de quebras de linha específicas).
  • Estratégia: ler todo o conteúdo da entrada padrão e dividir em “tokens” usando espaços e quebras de linha. Assim qualquer arranjo de números (por linha, vários números por linha, espaços irregulares) será tratado corretamente.
  • Depois, interpretar os tokens sequencialmente: os dois primeiros tokens serão nl e nc (inteiros). Em seguida, os próximos nl\times nc tokens são os elementos de A, e logo depois outros nl\times nc tokens são os elementos de B.
  • Conversão: cada token que representa número real será convertido com float(token). Formatos como .8 são aceitos por float().

Passo 4

Explicação detalhada da função create_matrix(nl, nc).
  • Objetivo: construir e retornar uma matriz com nl linhas e nc colunas, consumindo os próximos nl\times nc tokens da entrada.
  • Passos lógicos dentro da função:
    1. Para cada linha i de 0 a nl-1, criar uma lista vazia row.
    2. Para cada coluna j de 0 a nc-1, pegar o próximo token da entrada, convertê-lo para float e acrescentar a row.
    3. Acrescentar row à matriz.
    4. No final, retornar a matriz.
Nota didática: é importante checar que existem tokens suficientes; o código que forneço assume que a entrada tem a quantidade correta de números (como normalmente acontece em provas). Em casos reais, poderia-se adicionar verificações e mensagens de erro.

Passo 5

Explicação detalhada da função add_matrices(A, B).
  • Objetivo: receber duas matrizes compatíveis (mesmas dimensões) e retornar a soma elemento a elemento.
  • Como fazer:
    1. Obter nl (número de linhas) como len(A) e nc como len(A[0]) (assumindo matriz não vazia).
    2. Criar matriz C vazia.
    3. Para cada i em 0..nl-1, criar uma linha rowC onde rowC[j] = A[i][j] + B[i][j].
    4. Acrescentar rowC em C.
    5. Retornar C.
Didática: somar matrizes é só somar cada posição correspondente. Não tente somar linhas inteiras como strings — isso é aritmética posição a posição.

Passo 6

Formato de saída: como imprimir os números de forma limpa.
  • Em provas, costuma-se aceitar vários formatos, mas é bonito e prático remover zeros desnecessários (por exemplo imprimir 1 em vez de 1.0).
  • Estratégia usada no programa: para cada número x:
    • Se x for quase inteiro (diferença abs para round(x) menor que 1e-9), imprimir como inteiro: int(round(x)).
    • Caso contrário, imprimir com um número limitado de casas significativas, removendo zeros finais. Implemento uma função auxiliar format_number(x) que faz isso usando '{:.10f}'.format(x) e eliminando zeros finais e ponto decimal se preciso.

Passo 7

Resumo do procedimento principal (o “main” do programa) e explicação do fluxo completo.
  • Fluxo:
    1. Ler todo o stdin e dividir em tokens.
    2. Ler nl e nc a partir dos dois primeiros tokens (conversão para int).
    3. Tornar esses tokens acessíveis globalmente (ou por índice) para que create_matrix consiga consumir os próximos números.
    4. Chamar create_matrix(nl, nc) para A.
    5. Chamar create_matrix(nl, nc) para B.
    6. Chamar add_matrices(A, B) para obter C.
    7. Imprimir C linha a linha, com elementos separados por espaço, usando format_number.
  • Observações práticas:
    • O programa que eu forneço organiza os tokens em uma lista tokens e mantém um índice global pos para controlar qual token já foi lido. A função create_matrix usa esse índice global para encontrar os próximos números, respeitando a exigência de receber apenas nl e nc como parâmetros.
    • Se a entrada estiver bem formada (quantidade correta de números), o programa funciona corretamente. Se faltar número, ocorrerá um erro ao tentar acessar token inexistente — em provas normalmente isso não acontece.

Resposta

# Programa em Python para ler duas matrizes reais nl x nc, somá-las e imprimir o resultado.
# Há duas funções: create_matrix(nl, nc) e add_matrices(A, B).
# Há um procedimento principal que orquestra a leitura, criação, soma e impressão.

import sys

# Lista de tokens e posição atual (variáveis globais usadas por create_matrix)
tokens = sys.stdin.read().strip().split()
pos = 0

def create_matrix(nl, nc):
    """
    Recebe nl e nc e retorna uma matriz nl x nc preenchida com os próximos tokens.
    Usa as variáveis globais tokens e pos para consumir os números sequencialmente.
    """
    global pos, tokens
    mat = []
    for i in range(nl):
        row = []
        for j in range(nc):
            if pos >= len(tokens):
                # Se faltar entrada, lançar erro (em provas não é esperado tratar)
                raise ValueError("Entrada insuficiente para preencher a matriz")
            # Converte token para float (aceita formatos como .8, 0.8, -4.1)
            val = float(tokens[pos])
            pos += 1
            row.append(val)
        mat.append(row)
    return mat

def add_matrices(A, B):
    """
    Recebe duas matrizes A e B (mesmas dimensões) e retorna a soma C = A + B.
    """
    nl = len(A)
    nc = len(A[0]) if nl > 0 else 0
    C = []
    for i in range(nl):
        rowC = []
        for j in range(nc):
            rowC.append(A[i][j] + B[i][j])
        C.append(rowC)
    return C

def format_number(x):
    """
    Formata um float para impressão:
    - se for quase inteiro, imprime como inteiro;
    - caso contrário, usa até 10 casas decimais e remove zeros finais.
    """
    if abs(x - round(x)) < 1e-9:
        return str(int(round(x)))
    s = "{:.10f}".format(x).rstrip('0').rstrip('.')
    if s == "-0":
        s = "0"
    return s

def main():
    global pos, tokens
    if len(tokens) < 2:
        raise ValueError("Entrada deve conter pelo menos nl e nc")
    # Ler nl e nc (dois primeiros tokens)
    nl = int(tokens[0])
    nc = int(tokens[1])
    pos = 2
    # Criar as duas matrizes
    A = create_matrix(nl, nc)
    B = create_matrix(nl, nc)
    # Somar
    C = add_matrices(A, B)
    # Imprimir resultado: cada linha em uma linha, elementos separados por espaço
    for row in C:
        line = " ".join(format_number(x) for x in row)
        print(line)

if __name__ == "__main__":
    main()

Exercícios relacionados