Na relatividade especial , a velocidade de um objeto em movimento em relação a outro objeto que está se movendo na direção oposta é dada pela fórmula:

s = ( v + u ) / ( 1 + v * u / c ^ 2)

Nesta fórmula, e são as magnitudes das velocidades dos objetos e é a velocidade da luz (que é aproximadamente , uma aproximação suficientemente próxima para isso. desafio).$v$$u$$c$$3.0 \times 10^8 \,\mathrm m/\mathrm s$

Por exemplo, se um objeto estava se movendo em v = 50,000 m/se outro objeto u = 60,000 m/s, a velocidade de cada objeto em relação ao outro seria aproximadamente s = 110,000 m/s. É o que você esperaria da relatividade galileana (onde as velocidades simplesmente acrescentam). No entanto, se v = 50,000,000 m/se u = 60,000,000 m/s, a velocidade relativa seria aproximadamente 106,451,613 m/s, o que é significativamente diferente do 110,000,000 m/sprevisto pela relatividade galileana.

O desafio

Dado dois números inteiros ve utal que 0 <= v,u < c, calcule a velocidade aditiva relativística, usando a fórmula acima, com c = 300000000. A saída deve ser um valor decimal ou uma fração reduzida. A saída deve estar dentro 0.001do valor real para um valor decimal ou exata para uma fração.

Casos de teste

Formato: v, u -> exact fraction (float approximation)

50000, 60000 -> 3300000000000/30000001 (109999.99633333346)
50000000, 60000000 -> 3300000000/31 (106451612.90322581)
20, 30 -> 7500000000000000/150000000000001 (49.999999999999666)
0, 20051 -> 20051 (20051.0)
299999999, 299999999 -> 53999999820000000000000000/179999999400000001 (300000000.0)
20000, 2000000 -> 4545000000000/2250001 (2019999.1022226212)
2000000, 2000000 -> 90000000000/22501 (3999822.2301231055)
1, 500000 -> 90000180000000000/180000000001 (500000.9999972222)
1, 50000000 -> 90000001800000000/1800000001 (50000000.972222224)
200000000, 100000000 -> 2700000000/11 (245454545.45454547)

MATL , 9 bytes

sG3e8/pQ/

Experimente online!

s      % Take array [u, v] implicitly. Compute its sum: u+v
G      % Push [u, v] again
3e8    % Push 3e8
/      % Divide. Gives [u/c, v/c]
p      % Product of array. Gives u*v/c^2
Q      % Add 1
/      % Divide. Display implicitly

Mathematica, 17 bytes

+##/(1+##/9*^16)&

Uma função sem nome, recebendo dois números inteiros e retornando uma fração exata.

Explicação

Isso usa dois bons truques com a sequência de argumentos## , o que me permite evitar referenciar os argumentos individuais ue vseparadamente. ##expande para uma sequência de todos os argumentos, que é uma espécie de "lista desembrulhada". Aqui está um exemplo simples:

{x, ##, y}&[u, v]

dá

{x, u, v, y}

O mesmo funciona em funções arbitrárias (já que {...}é apenas uma abreviação de List[...]):

f[x, ##, y]&[u, v]

dá

f[x, u, v, y]

Agora também podemos entregar ##aos operadores que primeiro os tratarão como um único operando no que diz respeito ao operador. Em seguida, o operador será expandido para sua forma completa f[...]e somente então a sequência será expandida. Neste caso, +##é Plus[##]o que é Plus[u, v], ou seja, o numerador que queremos.

No denominador, por outro lado, ##aparece como o operador esquerdo de /. A razão pela qual isso se multiplica ue vé bastante sutil. /é implementado em termos de Times:

FullForm[a/b]
(* Times[a, Power[b, -1]] *)

Então, quando aé ##, ele é expandido depois e acabamos com

Times[u, v, Power[9*^16, -1]]

Aqui, *^é apenas o operador do Mathematica para notação científica.

Geléia, 9 bytes

÷3ȷ8P‘÷@S

Experimente online! Alternativamente, se você preferir frações, você pode executar o mesmo código com M .

Como funciona

÷3ȷ8P‘÷@S  Main link. Argument: [u, v]

÷3ȷ8       Divide u and v by 3e8.
    P      Take the product of the quotients, yielding uv ÷ 9e16.
     ‘     Increment, yielding 1 + uv ÷ 9e16.
        S  Sum; yield u + v.
      ÷@   Divide the result to the right by the result to the left.

Python3, 55 31 29 bytes

Python é péssimo para obter entradas conforme cada entrada precisa, int(input()) mas aqui está a minha solução de qualquer maneira:

v, u = int (entrada ()), int (entrada ()); print ((v + u) / (1 + v * u / 9e16))

Graças ao @Jakube, na verdade não preciso de todo o programa, apenas da função. Conseqüentemente:

lambda u,v:(v+u)/(1+v*u/9e16)

Bastante auto-explicativo, obtenha entradas, calcule. Eu usei c ^ 2 e simplifiquei que, como 9e16 é menor que (3e8 ** 2).

Python2, 42 bytes

v,u=input(),input();print(v+u)/(1+v*u/9e16)

Obrigado a @muddyfish

J, 13 11 bytes

+%1+9e16%~*

Uso

>> f =: +%1+9e16%~*
>> 5e7 f 6e7
<< 1.06452e8

Onde >>está STDIN e <<está STDOUT.

Matlab, 24 bytes

@(u,v)(u+v)/(1+v*u/9e16)

Função anônima que recebe duas entradas. Nada extravagante, apenas enviado para ser completo.

CJam, 16 bytes

q~_:+\:*9.e16/)/

Ainda tenho certeza de que há bytes a serem salvos aqui

Dyalog APL , 11 bytes

+÷1+9E16÷⍨×

A fração da soma e [o incremento das divisões de noventa quadrilhões e do produto]:

┌─┼───┐         
+ ÷ ┌─┼──────┐  
    1 + ┌────┼──┐
        9E16 ÷⍨ ×

÷⍨é "divide", como em "noventa quadrilhões divide n ", isto é, equivalente a n dividido por noventa quadrilhões.

Haskell, 24 bytes

Como uma única função que pode fornecer um ponto flutuante ou um número fracionário, dependendo do contexto em que é usado ...

r u v=(u+v)/(1+v*u/9e16)

Exemplo de uso no REPL:

*Main> r 20 30
49.999999999999666
*Main> default (Rational)
*Main> r 20 30 
7500000000000000 % 150000000000001

Pyke, 12 bytes

sQB9T16^*/h/

Experimente aqui!

Pitão, 14 bytes

csQhc*FQ*9^T16

Suíte de teste.

Fórmula: sum(input) / (1 + (product(input) / 9e16))

Bônus: clique aqui!

Javascript 24 bytes

Raspou 4 bytes graças a @LeakyNun

v=>u=>(v+u)/(1+v*u/9e16)

Bem direto

Julia, 22 bytes

u\v=(u+v)/(1+u*v/9e16)

Experimente online!

Noether , 24 bytes

Não concorrente

I~vI~u+1vu*10 8^3*2^/+/P

Experimente aqui!

Noether parece ser uma linguagem apropriada para o desafio, uma vez que Emmy Noether foi pioneira nas idéias de simetria que levam às equações de Einstein (isso, E = mc^2etc.)

De qualquer forma, isso é basicamente uma tradução da equação fornecida para inverter a notação de polimento.

TI-BASIC, 12 bytes

:sum(Ans/(1+prod(Ans/3ᴇ8

Toma entrada como uma lista de {U,V}on Ans.

PowerShell, 34 bytes

param($u,$v)($u+$v)/(1+$v*$u/9e16)

Implementação extremamente direta. Porém, não há esperança de encontrar alguém, graças aos 6 $requeridos.

Oracle SQL 11.2, 39 bytes

SELECT (:v+:u)/(1+:v*:u/9e16)FROM DUAL;

T-SQL, 38 bytes

DECLARE @U REAL=2000000, @ REAL=2000000;
PRINT FORMAT((@U+@)/(1+@*@U/9E16),'g')

Experimente online!

Implementação simples de fórmula.

ForceLang, 116 bytes

Não-competitivo, usa a funcionalidade de idioma adicionada após o lançamento do desafio.

def r io.readnum()
set s set
s u r
s v r
s w u+v
s c 3e8
s u u.mult v.mult c.pow -2
s u 1+u
io.write w.mult u.pow -1

TI-Basic, 21 bytes

Prompt U,V:(U+V)/(1+UV/9ᴇ16

dc, 21 bytes

svddlv+rlv*9/I16^/1+/

Isso pressupõe que a precisão já foi definida, por exemplo, com 20k. Adicione 3 bytes se não puder fazer essa suposição.

Uma versão mais precisa é

svdlv+9I16^*dsc*rlv*lc+/

em 24 bytes.

Ambos são transcrições razoavelmente fiéis da fórmula, sendo o único golfe notável o uso de 9I16^*para c².

PHP, 44 45 bytes

Função anônima, bem direta.

function($v,$u){echo ($v+$u)/(1+$v*$u/9e16);}

Na verdade, 12 bytes

;8╤3*ì*πu@Σ/

Experimente online!

Explicação:

;8╤3*ì*πu@Σ/
;             dupe input
 8╤3*ì*       multiply each element by 1/(3e8)
       πu     product, increment
         @Σ/  sum input, divide sum by product

Java (JDK) , 24 bytes

u->v->(u+v)/(1+u*v/9e16)

Experimente online!

Quarto (gforth) , 39 bytes

: f 2dup + s>f * s>f 9e16 f/ 1e f+ f/ ;

Experimente online!

Código Explicação

: f            \ start a new work definition
  2dup +       \ get the sum of u and v
  s>f          \ move to top of floating point stack
  * s>f        \ get the product of u and v and move to top of floating point stack
  9e16 f/      \ divide product by 9e16 (c^2)
  1e f+        \ add 1
  f/           \ divide the sum of u and v by the result
;              \ end word definition