24

Dadas as posições e velocidades bidimensionais de um par de bolas de bilhar logo antes do impacto, calcule suas velocidades após uma colisão perfeitamente elástica . As esferas são consideradas esferas ideais (ou equivalentemente: círculos) com o mesmo raio, mesma massa, densidade uniforme e sem atrito.

A entrada consiste em 8 números: p0x,p0y,v0x,v0y,p1x,p1y,v1x,v1yonde p0x,p0yé o centro da primeira bola, v0x,v0ysua velocidade e da mesma forma p1x,p1y,v1x,v1ypara a segunda bola. Você pode aceitar entrada em qualquer ordem e estruturado de qualquer maneira conveniente, por exemplo, como uma matriz 2x2x2, ou talvez uma matriz 2x2 para pe duas matrizes de comprimento-2 para v0e v1. Também é bom usar números complexos (se o seu idioma os suportar) em vez de pares xy. No entanto, você não deve receber entradas em um sistema de coordenadas diferente do cartesiano, ou seja, polar não é permitido.

Observe que o raio de uma bola de bilhar é metade da distância entre p0x,p0ye p1x,p1y, portanto, não é dado como uma parte explícita da entrada.

Escreva um programa ou função que produza ou retorne 4 números em qualquer representação cartesiana conveniente: os valores pós-colisão de v0x,v0y,v1x,v1y.

Um possível algoritmo é:

encontre a linha normal que passa pelos dois centros
encontre a linha tangente que passa pelo ponto médio entre os dois centros e é perpendicular à linha normal
mudar o sistema de coordenadas e quebrar v0x,v0ye v1x,v1yem seus componentes tangencial e normal v0t,v0nev1t,v1n
trocar os componentes normais de v0e v1, preservando seus componentes tangenciais
voltar ao sistema de coordenadas original

Testes (resultados arredondados para 5 casas decimais):

   p0x   p0y   v0x   v0y   p1x   p1y   v1x   v1y ->      v0x'       v0y'       v1x'       v1y'
[-34.5,-81.8, 34.7,-76.1, 96.2,-25.2, 59.2,-93.3] [  49.05873, -69.88191,  44.84127, -99.51809]
[ 36.9, 77.7,-13.6,-80.8, -7.4, 34.4, 15.1,-71.8] [   5.57641, -62.05647,  -4.07641, -90.54353]
[-51.0, 17.6, 46.1,-80.1, 68.6, 54.0,-35.1,-73.9] [ -26.48927,-102.19239,  37.48927, -51.80761]
[-21.1,-52.6,-77.7, 91.5, 46.0, 94.1, 83.8, 93.7] [ -48.92598, 154.40834,  55.02598,  30.79166]
[ 91.3, -5.3, 72.6, 89.0, 97.8, 50.5, 36.2, 85.7] [  71.73343,  81.56080,  37.06657,  93.13920]
[-79.9, 54.9, 92.5,-40.7,-20.8,-46.9,-16.4, -0.9] [  47.76727,  36.35232,  28.33273, -77.95232]
[ 29.1, 80.7, 76.9,-85.1,-29.3,-49.5,-29.0,-13.0] [  86.08581, -64.62067, -38.18581, -33.47933]
[ 97.7,-89.0, 72.5, 12.4, 77.8,-88.2, 31.5,-34.0] [  33.42847,  13.97071,  70.57153, -35.57071]
[-22.2, 22.6,-61.3, 87.1, 67.0, 57.6,-15.3,-23.1] [ -58.90816,  88.03850, -17.69184, -24.03850]
[-95.4, 15.0,  5.3, 39.5,-54.7,-28.5, -0.7,  0.8] [  21.80656,  21.85786, -17.20656,  18.44214]
[ 84.0,-26.8,-98.6,-85.6,-90.1, 30.9,-48.1, 37.2] [ -89.76828, -88.52700, -56.93172,  40.12700]
[ 57.8, 90.4, 53.2,-74.1, 76.4,-94.4,-68.1,-69.3] [  51.50525, -57.26181, -66.40525, -86.13819]
[ 92.9, 69.8,-31.3, 72.6,-49.1,-78.8,-62.3,-81.6] [-123.11680, -23.48435,  29.51680,  14.48435]
[-10.3,-84.5,-93.5,-95.6, 35.0, 22.6, 44.8, 75.5] [ -11.12485,  99.15449, -37.57515,-119.25449]
[ -3.9, 55.8,-83.3,  9.1, -2.7,-95.6, 37.7,-47.8] [ -82.84144, -48.75541,  37.24144,  10.05541]
[-76.5,-88.4,-76.7,-49.9, 84.5, 38.0,  4.2, 18.4] [   6.52461,  15.43907, -79.02461, -46.93907]
[ 64.2,-19.3, 67.2, 45.4,-27.1,-28.7, 64.7, -4.3] [  59.66292,  44.62400,  72.23708,  -3.52400]
[  9.8, 70.7,-66.2, 63.0,-58.7, 59.5, 83.7,-10.6] [  68.07646,  84.95469, -50.57646, -32.55469]
[ 62.9, 46.4, 85.0, 87.4, 36.3,-29.0,-63.0,-56.3] [  23.53487, -86.82822,  -1.53487, 117.92822]
[ -5.5, 35.6, 17.6,-54.3, -2.2, 66.8,-15.2, 11.8] [  24.15112,   7.63786, -21.75112, -50.13786]

Vitórias mais curtas. Sem brechas.

obrigado @Anush por ajudar a corrigir a cor de fundo do diagrama

code-golf geometry linear-algebra physics ngn
fonte

16

Python 3 , 67 66 bytes, 53 bytes

def f(p,v,q,w):p-=q;d=((v-w)/p).real*p;return v-d,w+d

Experimente online!

-1 byte graças a @ngn

-13 bytes graças a @Neil

Esta função frecebe quatro números complexos como entrada e retorna dois números complexos. A versão ungolfed é mostrada a seguir.

Ungolfed

def elastic_collision_complex(p1, v1, p2, v2):
    p12 = p1 - p2
    d = ((v1 - v2) / p12).real * p12
    return v1 - d, v2 + d

Experimente online!

A fórmula de computação é derivada com base na fórmula de vetor 2D no wiki . Como $m_1=m_2$ , a fórmula pode ser simplificada para

{\begin{cases} v_{1}^{'} = v_{1} - d v \\ v_{2}^{'} = v_{2} + d v \end{cases}

$\left\{\begin{array}{l} v_1'=v_1-dv \\ v_2'=v_2+dv\end{array}\right.$

Vamos $x_{12}=x_1-x_2$ e $v_{12}=v_1-v_2$ , temos

d v = \frac{⟨ v_{12}, x_{12} ⟩}{‖ x_{12} ‖^{2}} x_{12} = \frac{R e (v_{12} \cdot \bar{x_{12}})}{x_{12} \cdot \bar{x_{12}}} x_{12} = R e (\frac{v_{12} \cdot \bar{x_{12}}}{x_{12} \cdot \bar{x_{12}}}) x_{12} = R e (\frac{v_{12}}{x_{12}}) x_{12}

$dv=\frac{\langle v_{12}, x_{12}\rangle}{\|x_{12}\|^2}x_{12} = \frac{Re(v_{12}\cdot\overline{x_{12}})}{x_{12}\cdot \overline{x_{12}}}x_{12}=Re\left(\frac{v_{12}\cdot\overline{x_{12}}}{x_{12}\cdot \overline{x_{12}}}\right)x_{12}=Re\left(\frac{v_{12}}{x_{12}}\right)x_{12}$

No programa ungolfed, p12, v1 - v2, dcorrespondem aos $x_{12}$ , $y_{12}$ , e $dv$ , respectivamente.

Joel
fonte

1

bem feito! essa abordagem parece diferente da resposta perl6 de Ramillies, que também usa números complexos. você pode salvar um byte se substituir r=p-qpor p-=qe continuar a usar em pvez de r, como na resposta js de Neil

ngn

1

@ngn, parece diferente, mas é o mesmo, como Joel observa corretamente. Eu escrevi a fórmula de uma forma que era boa para o golfe em Perl 6, e Joel presumivelmente usou uma que era melhor para o Python. De qualquer forma, não achei que mais alguém tivesse uma solução usando números complexos de forma independente. Bom trabalho!

Ramillies em

3

Bom, mas se você usasse o algoritmo na pergunta, levaria apenas 53 bytes ...

Neil

1

@ Neil Obrigado pela sua dica. O cálculo é bastante simplificado agora.

Joel

3

Estou gostando muito de todas as suas ótimas soluções e explicações detalhadas!

xnor 26/08

11

JavaScript (Node.js) , 90 88 bytes

(m,n,o,p,q,r,s,t,u=(q-=m)*q+(r-=n)*r,v=o*q+p*r-s*q-t*r)=>[o-(q*=v/u),p-(v*=r/u),s+q,t+v]

Experimente online! O link inclui o conjunto de testes. Explicação: q,rsão redirecionados como o vetor de diferença entre os centros e ué o quadrado do seu comprimento. vé a diferença nos produtos de ponto de o,pe s,tcom q,r, assim v/ucomo o fator de escala q,rque fornece a quantidade de velocidade transferida de o,ppara s,t. Editar: salvou 2 bytes graças a @Arnauld.

Neil
fonte

eu não esperava que alguém simplificasse o algoritmo tão rapidamente, muito bem! aqui está uma visualização da sua solução (com a melhoria de Arnauld)

ngn

@ngn Link errado?

Neil

O log de dutos do @Neil gitlab diz que deveria estar lá. ctrl + f5? setas controlam a bola vermelha. mudança acelera. testado em firefox e cromo. aviso: som.

ngn

@ngn Ah, trabalhando agora, obrigado! (Eu já peguei um 404 antes. Além disso, eu estava usando uma guia particular, por isso não tinha som por padrão, embora não o achasse intrusivo. E sou inútil em Asteroids, caso contrário, pediria uma sessão de fotos "chave ...)

Neil

8

Perl 6 ,75 64 63. 61 bytes

11 bytes salvos mudando de mappara for, dispensando a necessidade de colocar as coisas em variáveis intermediárias para o mapver.

1 byte salvo ao mudar ($^a-$^c)².&{$_/abs}para ($^a-$^c).&{$_/.conj}.

2 bytes salvos graças a @nwellnhof.

{(.($^b+$^d,{$_/.conj}($^a-$^c)*($b-$d).conj)/2 for *-*,*+*)}

Experimente online!

Explicação

Quando o post original disse que a entrada poderia ser números complexos, era muito difícil resistir ... Portanto, são necessários 4 números complexos (posição 1, velocidade 1, posição 2, velocidade 2) e retornam as velocidades como números complexos.

$d = p_1 - p_0$

$v_0/d$ $v_1/d$ $d$

\begin{aligned} v_{0}^{'} & = d (ℜ \frac{v_{1}}{d} + i ℑ \frac{v_{0}}{d}), \\ v_{1}^{'} & = d (ℜ \frac{v_{0}}{d} + i ℑ \frac{v_{1}}{d}) \end{aligned}

$\begin{align*} v_0' &= d \left( \Re \frac{v_1}{d} + \mathrm{i} \Im \frac{v_0}{d} \right), \\ v_1' &= d \left( \Re \frac{v_0}{d} + \mathrm{i} \Im \frac{v_1}{d} \right) \end{align*}$

ℜ

$\Re$

ℑ

$\Im$

⋆

$\star$

v_{0}^{'} = d (ℜ \frac{v_{1}}{d} + i ℑ \frac{v_{0}}{d}) = d [\frac{1}{2} (\frac{v_{1}}{d} + \frac{v_{1}^{⋆}}{d^{⋆}}) + \frac{1}{2} (\frac{v_{0}}{d} - \frac{v_{0}^{⋆}}{d^{⋆}})] = = \frac{d}{2} (\frac{v_{0} + v_{1}}{d} - \frac{v_{0}^{⋆} - v_{1}^{⋆}}{d^{⋆}}) = \frac{1}{2} (v_{0} + v_{1} - \frac{d}{d^{⋆}} (v_{0}^{⋆} - v_{1}^{⋆})) .

$v_0' = d \left( \Re \frac{v_1}{d} + \mathrm{i} \Im \frac{v_0}{d} \right) = d \left[ \frac 1 2 \left( \frac{v_1}{d} + \frac{v_1^\star}{d^\star} \right) + \frac 1 2 \left( \frac{v_0}{d} - \frac{v_0^\star}{d^\star} \right) \right] =\ = \frac d 2 \left( \frac{v_0 + v_1}{d} - \frac{v_0^\star - v_1^\star}{d^\star} \right) = \frac 1 2 \left( v_0 + v_1 - \frac{d}{d^\star} (v_0^\star - v_1^\star) \right).$

v_{1}^{'}

$v_1'$

v_{0} \leftrightarrow v_{1}

$v_0 \leftrightarrow v_1$

v_{1}^{'} = \frac{1}{2} [v_{0} + v_{1} + \frac{d}{d^{⋆}} (v_{0}^{⋆} - v_{1}^{⋆})] .

$v_1' = \frac 1 2 \left[ v_0 + v_1 + \frac{d}{d^\star} \left(v_0^\star - v_1^\star\right) \right].$

E é isso. Tudo o que o programa faz é apenas esse cálculo, um pouco de golfe.

Ramillies
fonte

muito legal!

ngn

Eu não sei muito sobre Perl, mas acho que você pode mesclar os dois cálculos conjugados em um para economizar alguns bytes.

Joel

1

@ Joel - Infelizmente, tenho certeza que não posso. O primeiro conjugado está atuando ($^a-$^c)(e somente dentro de um lambda que normaliza esse número), o segundo atua ($b-$d). Então eles não podem realmente ser reconciliados. Eu poderia criar uma função que chamaria apenas .conj, mas que adicionaria apenas bytes (porque eu uso muito a $_variável, que possui a propriedade nice, é possível chamar métodos nela sem especificá-la: em .conjvez de $_.conj).

Ramillies

@ Ramillies Obrigado pela explicação.

Joel

Como a magnitude de δ é relevante? Você está apenas dividindo por δ, trocando os componentes reais e depois multiplicando por δ novamente.

Neil

3

Gelatina , 16 bytes

_/×ḋ÷²S¥_/ʋ¥N,$+

Experimente online!

Um link diádico, tendo como argumento esquerdo uma lista das posições iniciais [[p0x, p0y], [p1x, p1y]]e seu argumento direito, as velocidades iniciais [[v0x, v0y], [v1x, v2y]]. Retorna uma lista das velocidades finais[[v0x', v0y'], [v1x', v2y']]

Com base no algoritmo usado pela resposta JavaScript de @ Neil, certifique-se de votar também nessa!

Nick Kennedy
fonte

3

C (gcc) , 140 132 bytes

f(m,n,o,p,q,r,s,t,a)float*a,m,n,o,p,q,r,s,t;{q-=m;r-=n;m=q*q+r*r,n=o*q+p*r-s*q-t*r;q*=n/m;*a++=o-q;n*=r/m;*a++=p-n;*a++=s+q;*a=t+n;}

Experimente online!

Basicamente, uma porta da resposta JavaScript de @ Neil, mas o @ceilingcat reduzia 8 bytes reutilizando de maneira inteligente me narmazenando temporários.

G. Sliepen
fonte

2

Python 2 , 97 92 bytes

m,n,o,p,q,r,s,t=input()
q-=m
r-=n
a=o*q+p*r-s*q-t*r
a/=q*q+r*r
print o-a*q,p-a*r,s+a*q,t+a*r

Experimente online!

Versão modificada da abordagem de Neil.

Erik, o Outgolfer
fonte

1

C (gcc) , 77 72 bytes

f(p,v,q,w,a)_Complex*a,p,v,q,w;{p-=q;p*=creal((v-w)/p);*a=v-p;a[1]=w+p;}

Experimente online!

Com base na implementação python do @Joel

teto
fonte

0

APL (Dyalog Classic) , 21 bytes

⊢/-{,∘-⍨×/(9○÷⍨)\-⌿⍵}

Experimente online!

com base na resposta de @ Joel

in: matriz complexa 2x2, out: par complexo

ngn
fonte

Colisão de bolas de bilhar

Respostas:

Python 3 , 67 66 bytes, 53 bytes

Ungolfed

JavaScript (Node.js) , 90 88 bytes

Perl 6 ,75 64 63. 61 bytes

Explicação

Gelatina , 16 bytes

C (gcc) , 140 132 bytes

Python 2 , 97 92 bytes

C (gcc) , 77 72 bytes

APL (Dyalog Classic) , 21 bytes