Escreva funções que calculam as seguintes operações sobre matrizes quadradas com dimensão 10 \times 10 :
  • adição de duas matrizes;
  • subtração de duas matrizes;
  • transposta de uma matriz e
  • multiplicação de duas matrizes.

Passo 1

O enunciado pede que sejam escritas funções que realizem quatro operações sobre matrizes quadradas de dimensão 10\times10:
  • adição de duas matrizes;
  • subtração de duas matrizes;
  • transposta de uma matriz;
  • multiplicação de duas matrizes.
Informações relevantes dadas:
  • Todas as matrizes têm dimensão 10\times10 (ou seja, 10 linhas e 10 colunas).
  • Deve-se retornar como resultado outra matriz 10\times10.
  • Não foi especificada linguagem, então será usada uma implementação prática e comum (Python) na resposta final.

Passo 2

O que significa cada operação — definição matemática bem mastigada (para entender antes de codificar):
  • Adição elemento a elemento: se A e B são matrizes 10\times10, a matriz soma C tem entradas
C_{ij} = A_{ij} + B_{ij},
para todo i=1,\dots,10 e j=1,\dots,10.
Explicação: pega-se a mesma posição em A e B e soma-se. É uma conta bem direta.
  • Subtração elemento a elemento: similar à soma,
C_{ij} = A_{ij} - B_{ij},
para todo i,j. Novamente, operação por posição.
  • Transposta: a transposta de A, denotada A^T, troca linhas por colunas:
(A^T)_{ij} = A_{ji},
ou seja, a linha i vira a coluna i. Se A tem entrada A_{2,5}, então A^T terá essa entrada em A^T_{5,2}.
  • Multiplicação de matrizes: produto C = A\cdot B com A e B 10\times10 é definido por
C_{ij} = \sum_{k=1}^{10} A_{ik}\,B_{kj},
para todo i,j. Explicação passo a passo: para computar a entrada na linha i e coluna j do produto, multiplica-se cada elemento da linha i de A pelo correspondente elemento da coluna j de B e soma-se tudo.
Vou ilustrar a multiplicação com um exemplo miniatura (para entender a mecânica): se A e B fossem 2\times2,
A = \begin{pmatrix} a_{11} & a_{12}\\\ a_{21} & a_{22} \end{pmatrix},\quad B = \begin{pmatrix} b_{11} & b_{12}\\\ b_{21} & b_{22} \end{pmatrix},
então
C_{11}=a_{11}b_{11}+a_{12}b_{21},\quad C_{12}=a_{11}b_{12}+a_{12}b_{22},
e assim por diante.

Passo 3

Como representar a matriz na prática (dicas para a prova e para implementar):
  • Uma forma simples é representar uma matriz como “lista de listas”: cada linha é uma lista com 10 elementos, e a matriz é uma lista com 10 dessas linhas.
  • Índices em notação matemática vão de 1 a 10, mas em implementações (por exemplo Python) os índices começam em 0. Assim, a entrada A_{ij} em matemática corresponde a A[i-1][j-1] em Python. Para evitar confusão na prova, saiba traduzir índices.
  • Antes de operar, sempre cheque que ambas matrizes têm 10 linhas e cada linha tem 10 colunas — isso evita erro de shape.

Passo 4

Algoritmos (explicados para poder fazer no papel se necessário):
  • Adição e subtração: percorrer todas as posições (i,j) e aplicar a operação. Em pseudo-passo:
    1. Para i=1 até 10:
    2. Para j=1 até 10:
    3. Calcule C_{ij}=A_{ij}\pm B_{ij}.
  • Transposta:
    1. Para i=1 até 10:
    2. Para j=1 até 10:
    3. Coloque em T_{ij} o valor A_{ji}.
  • Multiplicação (modo direto, que dá para aplicar na prova):
    1. Para cada i=1,\dots,10 (linha de A):
    2. Para cada j=1,\dots,10 (coluna de B):
    3. Calcule C_{ij} como soma acumulada: inicialize soma s=0; para k=1 até 10 faça s \leftarrow s + A_{ik}\,B_{kj}. Ao fim, C_{ij}=s.
Observação prática rápida: para multiplicar sem errar no papel, organize as linhas de A e colunas de B e vá calculando termo a termo, riscando quando somou para não perder a conta. Em prova sem calculadora, trabalhe com números inteiros pequenos e simplifique passo a passo.
Complexidade: para 10\times10 isso é perfeitamente viável — multiplicação faz 10^3=1000 multiplica-mais-soma no total.

Passo 5

Boas práticas para implementar as funções (o que eu sempre faço):
  • Validar tamanho de entrada e lançar erro amigável caso não sejam 10\times10.
  • Evitar alterar as matrizes de entrada (criar e retornar uma nova matriz).
  • Para multiplicação: uma micro-otimização é iterar em ordem que reduza acessos repetidos (por exemplo, fixar i e k e atualizar todas as colunas j usando o mesmo A_{ik}), mas para 10\times10 isso é só um detalhe. O importante é a clareza do código.

Passo 6

Resumo do que vai aparecer na resposta final (só para você saber o que encontrará):
  • Quatro funções em Python:
    • add_matrices(A,B)
    • subtract_matrices(A,B)
    • transpose_matrix(A)
    • multiply_matrices(A,B)
      Cada função recebe e retorna matrizes no formato lista de listas com 10 linhas e 10 colunas. As funções validarão dimensão e retornarão a nova matriz resultado.

Resposta

from typing import List

Matrix10 = List[List[float]]  # cada matriz é uma lista de 10 listas, cada uma com 10 números

def _check_10x10(M: Matrix10) -> None:
    if not isinstance(M, list) or len(M) != 10:
        raise ValueError("Matriz deve ter 10 linhas.")
    for row in M:
        if not isinstance(row, list) or len(row) != 10:
            raise ValueError("Cada linha da matriz deve ter 10 elementos.")

def add_matrices(A: Matrix10, B: Matrix10) -> Matrix10:
    """
    Retorna a soma de duas matrizes 10x10: C = A + B.
    """
    _check_10x10(A)
    _check_10x10(B)
    return [[A[i][j] + B[i][j] for j in range(10)] for i in range(10)]

def subtract_matrices(A: Matrix10, B: Matrix10) -> Matrix10:
    """
    Retorna a subtração de duas matrizes 10x10: C = A - B.
    """
    _check_10x10(A)
    _check_10x10(B)
    return [[A[i][j] - B[i][j] for j in range(10)] for i in range(10)]

def transpose_matrix(A: Matrix10) -> Matrix10:
    """
    Retorna a transposta de uma matriz 10x10: T = A^T.
    """
    _check_10x10(A)
    return [[A[j][i] for j in range(10)] for i in range(10)]

def multiply_matrices(A: Matrix10, B: Matrix10) -> Matrix10:
    """
    Retorna o produto de duas matrizes 10x10: C = A * B.
    Implementação com verificação de dimensão e multiplicação padrão.
    """
    _check_10x10(A)
    _check_10x10(B)
    # inicializa matriz zero 10x10
    C: Matrix10 = [[0.0 for _ in range(10)] for _ in range(10)]
    # iteração na ordem i, k, j para aproveitar o valor A[i][k] durante a atualização de várias colunas
    for i in range(10):
        for k in range(10):
            aik = A[i][k]
            # se aik for zero, podemos pular (micro-otimização)
            if aik == 0:
                continue
            row_bk = B[k]
            row_ci = C[i]
            for j in range(10):
                row_ci[j] += aik * row_bk[j]
    return C

Exercícios relacionados