Crie uma nova matriz 3 \times 3 \times 2 e preencha com valores do teclado. Em seguida, multiplique todos os valores da matriz por 5.

Passo 1

O enunciado pede duas coisas claras:
  1. Criar uma nova matriz de dimensão \;3\times3\times2\; e preenchê‑la com valores lidos do teclado.
  2. Multiplicar todos os valores dessa matriz por 5 e mostrar o resultado.
Informações relevantes que já temos:
  • A matriz tem três dimensões: duas dimensões “espaciais” 3\times3 (linhas e colunas) e uma dimensão adicional de profundidade/componente com tamanho 2. Ou seja, o total de elementos é 3\cdot3\cdot2 = 18.
  • Os valores virão do teclado (entrada do usuário). Podemos assumir que cada valor é numérico (inteiro ou real).
  • Precisamos fazer uma multiplicação escalar: cada elemento será multiplicado por 5.

Passo 2

Entendendo o que é uma matriz \;3\times3\times2\; (explicação passo a passo, sem pressa)
  • Pense na matriz como duas “fatias” (ou camadas) de matrizes 3\times3. Então existem duas matrizes 3\times3: uma para a camada 0 e outra para a camada 1.
  • Para identificar um elemento usamos três índices. Vou usar a ordem (camada, linha, coluna). Em notação matemática, um elemento pode ser denotado por \;a_{k,i,j}\; onde:
    • \;k\in\{0,1\}\; é o índice da camada (tem 2 camadas),
    • \;i\in\{0,1,2\}\; é o índice da linha (3 linhas),
    • \;j\in\{0,1,2\}\; é o índice da coluna (3 colunas).
  • Na prática (por exemplo em Python), acessamos esse elemento como algo do tipo A[k][i][j].
Exemplo mental rápido: se eu escolher preencher a primeira camada ( k=0) com os números 1 a 9 ordenados por linha, a primeira camada seria a matriz
\begin{pmatrix} 1 & 2 & 3\\[4pt] 4 & 5 & 6\\[4pt] 7 & 8 & 9 \end{pmatrix}
e a segunda camada ( k=1) poderia ser outra 3\times3 diferente.]

Passo 3

Como ler valores do teclado (entrada do usuário) e armazenar na estrutura
  • Vamos pedir ao usuário para digitar os 18 valores, um por vez, indicando a posição (k,i,j) para não se perder.
  • Em Python, usamos a função input() para ler uma linha do teclado e float() (ou int()) para converter para número.
  • Estrutura de armazenamento simples: uma lista com 2 elementos, cada um sendo uma lista com 3 linhas, cada linha sendo outra lista com 3 colunas. Em código, isso fica como A = [ [ [0]*3 for i in range(3) ] for k in range(2) ].
  • Usamos três laços aninhados:
    • for k in range(2): percorre as camadas (k=0,1);
    • for i in range(3): percorre as linhas (i=0,1,2);
    • for j in range(3): percorre as colunas (j=0,1,2).
  • A cada iteração pedimos ao usuário o número e guardamos em A[k][i][j].
Dica prática (para a prova): siga sempre uma ordem fixa de leitura (por exemplo, camadas em ordem crescente, dentro de cada camada linhas em ordem crescente e dentro de cada linha colunas em ordem crescente). Isso evita confusão.

Passo 4

Multiplicando todos os valores por 5 — conceito e fórmula
  • A multiplicação por escalar é feita elemento a elemento. Se a matriz original é a_{k,i,j}, a matriz resultante b_{k,i,j} será dada por
b_{k,i,j} = 5 \cdot a_{k,i,j}
para todo k,i,j.
  • Na prática, percorremos novamente os três índices e substituímos (ou criamos uma nova matriz) com o valor multiplicado.
  • Podemos sobrescrever a mesma estrutura A (fazer A[k][i][j] = 5 * A[k][i][j]) ou criar B nova.

Passo 5

Implementação em código (programa completo em Python — este código lê do teclado, multiplica por 5 e mostra o resultado)
# Programa para criar uma "matriz" 3x3x2, preencher pelo teclado e multiplicar por 5

def ler_matriz_3x3x2():
    A = [ [ [0.0 for j in range(3)] for i in range(3) ] for k in range(2) ]
    for k in range(2):
        print(f"Preenchendo a camada {k} (uma matriz 3x3):")
        for i in range(3):
            for j in range(3):
                while True:
                    try:
                        entrada = input(f"Digite o valor para a posição (camada={k}, linha={i}, coluna={j}): ")
                        val = float(entrada)  # usa float para aceitar inteiros e reais
                        A[k][i][j] = val
                        break
                    except ValueError:
                        print("Entrada inválida. Digite um número (ex.: 3 ou 2.5).")
    return A

def multiplicar_por_escalar(A, escalar):
    # Modifica A in-place multiplicando por 'escalar'
    for k in range(2):
        for i in range(3):
            for j in range(3):
                A[k][i][j] = escalar * A[k][i][j]

def imprimir_matriz_3x3x2(A):
    for k in range(2):
        print(f"\nCamada {k}:")
        for i in range(3):
            linha = "  ".join(f"{A[k][i][j]:g}" for j in range(3))
            print(linha)

def main():
    A = ler_matriz_3x3x2()
    print("\nMatriz original:")
    imprimir_matriz_3x3x2(A)
    multiplicar_por_escalar(A, 5)
    print("\nMatriz após multiplicar todos os elementos por 5:")
    imprimir_matriz_3x3x2(A)

if __name__ == "__main__":
    main()
Explicação do código (passo a passo):
  • ler_matriz_3x3x2() cria a estrutura vazia A e pede 18 entradas do usuário, uma por posição (k,i,j). Usa float() para aceitar números com casas decimais.
  • multiplicar_por_escalar(A, escalar) percorre todos os elementos e faz a multiplicação in‑place.
  • imprimir_matriz_3x3x2(A) imprime cada camada como uma matriz 3\times3 legível.
  • main() executa a sequência: ler, mostrar original, multiplicar por 5, mostrar resultado.

Passo 6

Exemplo numérico (para fixar a ideia)
  • Suponha que eu, por exemplo, digitei os números 1 a 9 na camada 0 e 10 a 18 na camada 1. Ou seja, peguei estes valores (peguei esses números como exemplo):
\text{Camada }0 = \begin{pmatrix} 1 & 2 & 3\\[4pt] 4 & 5 & 6\\[4pt] 7 & 8 & 9 \end{pmatrix} \qquad \text{Camada }1 = \begin{pmatrix} 10 & 11 & 12\\[4pt] 13 & 14 & 15\\[4pt] 16 & 17 & 18 \end{pmatrix}
  • Multiplicando tudo por 5 (aplicando a fórmula \;b_{k,i,j}=5\cdot a_{k,i,j}\;), obtemos:
\text{Camada }0 \times 5 = \begin{pmatrix} 5 & 10 & 15\\[4pt] 20 & 25 & 30\\[4pt] 35 & 40 & 45 \end{pmatrix} \qquad \text{Camada }1 \times 5 = \begin{pmatrix} 50 & 55 & 60\\[4pt] 65 & 70 & 75\\[4pt] 80 & 85 & 90 \end{pmatrix}
  • Isso confirma que a operação foi aplicada a cada elemento individualmente.]

Passo 7

Dicas finais e variações rápidas
  • Na prova, se pedirem só o algoritmo, descreva os três loops aninhados e a operação b_{k,i,j}=5\cdot a_{k,i,j}.
  • Se for permitido usar bibliotecas (ex.: NumPy em Python), a implementação fica curtinha:
    • Criar: A = numpy.zeros((2,3,3))
    • Ler valores e preencher A[k,i,j]
    • Multiplicar: A *= 5
      Mas atenção: em prova de fundamentos geralmente pedem a versão com loops para testar compreensão de índices.
  • Sempre verifique o tipo de dado esperado (inteiro vs real) e trate entradas inválidas quando pedir dados ao usuário.

Resposta

# Programa para criar uma "matriz" 3x3x2, preencher pelo teclado e multiplicar por 5

def ler_matriz_3x3x2():
    A = [ [ [0.0 for j in range(3)] for i in range(3) ] for k in range(2) ]
    for k in range(2):
        print(f"Preenchendo a camada {k} (uma matriz 3x3):")
        for i in range(3):
            for j in range(3):
                while True:
                    try:
                        entrada = input(f"Digite o valor para a posição (camada={k}, linha={i}, coluna={j}): ")
                        val = float(entrada)
                        A[k][i][j] = val
                        break
                    except ValueError:
                        print("Entrada inválida. Digite um número (ex.: 3 ou 2.5).")
    return A

def multiplicar_por_escalar(A, escalar):
    for k in range(2):
        for i in range(3):
            for j in range(3):
                A[k][i][j] = escalar * A[k][i][j]

def imprimir_matriz_3x3x2(A):
    for k in range(2):
        print(f"\nCamada {k}:")
        for i in range(3):
            linha = "  ".join(f"{A[k][i][j]:g}" for j in range(3))
            print(linha)

def main():
    A = ler_matriz_3x3x2()
    print("\nMatriz original:")
    imprimir_matriz_3x3x2(A)
    multiplicar_por_escalar(A, 5)
    print("\nMatriz após multiplicar todos os elementos por 5:")
    imprimir_matriz_3x3x2(A)

if __name__ == "__main__":
    main()

Exercícios relacionados