O produto escalar de dois vetores tridimensionais é definido como
\vec{u} \cdot \vec{v}=u_{x} v_{x}+u_{y} v_{y}+u_{z} v_{z}
a) Escreva um programa que defina uma a função escvetor(u,v) para calcular o produto \vec{u} \cdot \vec{v}. Ela deve receber os vetores como listas com 3 elementos cada e retornar uma variável de ponto flutuante.
b) Generalize a sua função para que ela funcione com um vetores de dimensão arbitrária, por exemplo, bidimensional, tridimensional, quadridimensional etc.
Dica: Para escrever uma função que aceite dimensão arbitrária use o método sum aplicado em um comprehension que varre os índices do vetor e cria uma lista onde cada elemento é o resultado da multiplicação das componentes corresondentes de cada vetor.
Por exemplo:
Teste Resultado
print('%.2f'%escvetor([4,5,3], [3,2,1])) 25.00
print('%.2f' %escvetor( [4,4],[1,-2] )) -4.00
Resposta: (penalty regime: 0 \% )

Passo 1

O enunciado pede duas coisas bem claras:
  1. Escrever um programa (em Python) que defina uma função chamada escvetor(u, v) que calcule o produto escalar de dois vetores tridimensionais. A função deve receber os vetores como listas com 3 elementos cada e retornar um número de ponto flutuante.
  2. Generalizar a função para que funcione para vetores de dimensão arbitrária (2D, 3D, 4D, …).
Informações relevantes dadas no enunciado:
  • A definição do produto escalar é \vec{u}\cdot\vec{v}=u_x v_x + u_y v_y + u_z v_z.
  • Os vetores virão na forma de listas Python com os componentes (por exemplo, [4,5,3]).
  • A sugestão é usar sum com uma comprehension que percorre índices e multiplica componentes correspondentes.
  • Testes esperados: \vec{u}=[4,5,3], \vec{v}=[3,2,1] deve produzir 25.00; e \vec{u}=[4,4], \vec{v}=[1,-2] deve produzir -4.00.

Passo 2

Vamos entender passo a passo o que é o produto escalar (a parte matemática que você precisa ter na cabeça).
  • Dados dois vetores com componentes \vec{u}=(u_1,u_2,u_3) e \vec{v}=(v_1,v_2,v_3), o produto escalar é
\vec{u}\cdot\vec{v}=u_1 v_1 + u_2 v_2 + u_3 v_3.
  • Cada termo é o produto das componentes correspondentes; depois somamos tudo.
    Exemplo numérico (pequena “aula” com um exemplo concreto):
  • Para \vec{u}=[4,5,3] e \vec{v}=[3,2,1]:
    • multiplicações par a par: 4\cdot3=12, 5\cdot2=10, 3\cdot1=3
    • soma: 12+10+3=25
    • portanto \vec{u}\cdot\vec{v}=25.

Passo 3

Estratégia para implementar em Python (parte (a), função para 3D):
  • Receber duas listas u e v com exatamente 3 elementos cada.
  • Calcular o produto das componentes correspondentes e somar.
  • Garantir que o retorno seja float.
  • Fazer uma checagem simples de tamanho para evitar erros óbvios na prova (se os comprimentos forem diferentes, lançar uma exceção ou tratar como erro).

Passo 4

Implementação passo a passo da versão 3D (explicando cada linha do código).
Código (versão dedicada a 3D):
def escvetor(u, v):
    """
    Produto escalar para vetores tridimensionais.
    Recebe u e v como listas com 3 elementos cada.
    Retorna float.
    """
    # checar se ambos têm exatamente 3 componentes
    if len(u) != 3 or len(v) != 3:
        raise ValueError("As listas devem ter exatamente 3 elementos.")
    # calcular soma dos produtos
    resultado = 0.0
    resultado += u[0] * v[0]  # primeiro termo u_x * v_x
    resultado += u[1] * v[1]  # segundo termo u_y * v_y
    resultado += u[2] * v[2]  # terceiro termo u_z * v_z
    return float(resultado)
Explicação das linhas:
  • if len(u) != 3 or len(v) != 3: verifica o comprimento das listas.
  • resultado = 0.0 inicia a soma como float.
  • Cada resultado += u[i] * v[i] multiplica componentes correspondentes e acumula.
  • return float(resultado) garante que o retorno é de ponto flutuante.

Passo 5

Testando a função 3D e mostrando como você faria na prova sem complicação.
Exemplo com formatação pedida no enunciado:
print('%.2f' % escvetor([4,5,3], [3,2,1]))  # deve mostrar 25.00
Raciocínio manual (para acompanhar o código):
  • 4\cdot3=12, 5\cdot2=10, 3\cdot1=3 12+10+3=25'25.00'.

Passo 6

Agora a generalização (parte (b)): o objetivo é permitir vetores de qualquer dimensão.
  • Ideia: percorrer todos os índices de 0 até len(u)-1 e somar u[i]*v[i].
  • Importante: antes de multiplicar, checar se len(u) == len(v). Se não forem iguais, isso não representa um produto escalar bem definido; então tratamos como erro.
Implementação genérica usando a sugestão do enunciado (comprehension + sum):
def escvetor(u, v):
    """
    Produto escalar para vetores de dimensão arbitrária.
    Recebe u e v como listas (ou iteráveis indexáveis) do mesmo tamanho.
    Retorna float.
    """
    if len(u) != len(v):
        raise ValueError("As listas devem ter o mesmo tamanho.")
    # comprehension que cria uma sequência de produtos u[i]*v[i], somada por sum
    resultado = sum(u[i] * v[i] for i in range(len(u)))
    return float(resultado)
Observações:
  • range(len(u)) gera os índices 0,1,2,...,len(u)-1.
  • u[i] * v[i] é o produto das componentes correspondentes.
  • sum(...) soma todos os produtos. Isso é exatamente a generalização da fórmula do produto escalar.

Passo 7

Explicando alternativas e por que escolhi essa implementação:
  • Poderíamos usar zip(u, v) como sum(x*y for x, y in zip(u, v)). Isso é frequentemente mais elegante e lida naturalmente com iteráveis.
  • Usei range(len(u)) porque o enunciado sugeriu uma comprehension que varre índices — é exatamente isso e é fácil de explicar e reproduzir manualmente numa prova (você escreve o loop dos índices).
  • Ambas as alternativas (com range ou com zip) são corretas; a principal exigência é checar tamanhos iguais se quiser sinalizar erro quando não batem.

Passo 8

Exemplos de uso da versão geral (para você copiar e colar e testar rápido):
print('%.2f' % escvetor([4,5,3], [3,2,1]))   # saída esperada: 25.00
print('%.2f' % escvetor([4,4], [1,-2]))      # saída esperada: -4.00
print('%.2f' % escvetor([1,2,3,4], [4,3,2,1]))  # exemplo 4D: 20.00
Passo a passo (manual) para o segundo exemplo:
  • Para [4,4] e [1,-2]: 4\cdot1=4 e 4\cdot(-2)=-8. Soma 4+(-8)=-4. Assim ' -4.00'.

Passo 9

Dicas rápidas para a prova (truques práticos e erros comuns):
  • Sempre antes de começar a somar produtos, verifique se os vetores têm o mesmo tamanho; isso evita trapalhadas.
  • Se estiver sem tempo, escreva direto sum(u[i]*v[i] for i in range(len(u))) — é curto e seguro.
  • Se quiser evitar a checagem de tamanhos e confiar no avaliador, use zip(u, v); atenção: zip corta no menor comprimento sem avisar, então pode mascarar erros de entrada.
  • Lembre-se de retornar float, porque a saída pedida é de ponto flutuante (no Python, sum pode retornar int se tudo for inteiro).

Passo 10

Resumo final do que entreguei:
  • Uma versão inicial específica para 3D (útil para entender passo a passo).
  • Uma versão generalizada que atende ao que o enunciado exige e aos testes apresentados.

Resposta

def escvetor(u, v):
“”"
Produto escalar para vetores de dimensão arbitrária.
Recebe u e v como listas (ou iteráveis indexáveis) do mesmo tamanho.
Retorna float.
“”"
if len(u) != len(v):
raise ValueError(“As listas devem ter o mesmo tamanho.”)
resultado = sum(u[i] * v[i] for i in range(len(u)))
return float(resultado)

Exemplos de teste:

print(’%.2f’ % escvetor([4,5,3], [3,2,1])) -> 25.00

print(’%.2f’ % escvetor([4,4], [1,-2])) -> -4.00

Exercícios relacionados