W szczególnej teorii względności prędkość poruszającego się obiektu w stosunku do innego obiektu poruszającego się w przeciwnym kierunku jest podana wzorem:

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

W tym wzorze i są wielkościami prędkości obiektów, a jest prędkością światła (która wynosi około , co jest wystarczająco bliskim przybliżeniem wyzwanie).$v$$u$$c$$3.0 \times 10^8 \,\mathrm m/\mathrm s$

Na przykład, jeśli jeden obiekt się porusza v = 50,000 m/s, a inny obiekt się porusza u = 60,000 m/s, prędkość każdego obiektu względem drugiego będzie w przybliżeniu s = 110,000 m/s. Tego można się spodziewać przy względności Galilejskiej (gdzie prędkości po prostu dodają). Jednak jeśli v = 50,000,000 m/si u = 60,000,000 m/s, prędkość względna byłaby w przybliżeniu 106,451,613 m/s, co znacznie różni się od 110,000,000 m/sprzewidywanej na podstawie względności Galileusza.

Wyzwanie

Biorąc pod uwagę dwie liczby całkowite vi utakie 0 <= v,u < c, oblicz relatywistyczną prędkość addytywną, stosując powyższy wzór, z c = 300000000. Dane wyjściowe muszą być wartością dziesiętną lub ułamkiem zmniejszonym. Dane wyjściowe muszą zawierać się w granicach 0.001wartości rzeczywistej dla wartości dziesiętnej lub dokładnej dla ułamka.

Przypadki testowe

Format: 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 bajtów

sG3e8/pQ/

Wypróbuj 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 bajtów

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

Funkcja bez nazwy, która przyjmuje dwie liczby całkowite i zwraca dokładną część ułamkową.

Wyjaśnienie

Używa to dwóch fajnych sztuczek z sekwencją argumentów## , co pozwala mi uniknąć odwoływania się do poszczególnych argumentów ui vosobno. ##rozwija się do sekwencji wszystkich argumentów, która jest jakby „nieopakowaną listą”. Oto prosty przykład:

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

daje

{x, u, v, y}

To samo działa w przypadku dowolnych funkcji (ponieważ {...}jest to tylko skrót List[...]):

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

daje

f[x, u, v, y]

Teraz możemy również przekazać ##operatorom, którzy najpierw traktują ich jako pojedynczy operand, jeśli chodzi o operatora. Następnie operator zostanie rozwinięty do pełnej postaci f[...]i dopiero wtedy sekwencja zostanie rozszerzona. W tym przypadku +##jest Plus[##]to Plus[u, v], co jest , tzn. Licznik, który chcemy.

Z drugiej strony w mianowniku ##pojawia się jako operator po lewej stronie /. Powód tego się zwielokrotnia ui vjest raczej subtelny. /jest wdrażany w zakresie Times:

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

Więc kiedy ajest ##, zostaje później rozszerzony i ostatecznie

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

Tutaj *^jest tylko operatorem Mathematica dla notacji naukowej.

Galaretka, 9 bajtów

÷3ȷ8P‘÷@S

Wypróbuj online! Ewentualnie, jeśli wolisz frakcje, można wykonać ten sam kod z M .

Jak to działa

÷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 bajtów

Python jest okropny w uzyskiwaniu danych wejściowych, ponieważ każde z nich potrzebuje, int(input()) ale oto moje rozwiązanie:

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

Dzięki @Jakube tak naprawdę nie potrzebuję całej gry, tylko funkcję. W związku z tym:

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

Raczej zrozumiałe, uzyskaj dane wejściowe, obliczenia. Użyłem c ^ 2 i uprościłem, że ponieważ 9e16 jest krótszy niż (3e8 ** 2).

Python2, 42 bajty

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

Dzięki @muddyfish

J, 13 11 bajtów

+%1+9e16%~*

Stosowanie

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

Gdzie >>jest STDIN i <<STDOUT.

Matlab, 24 bajty

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

Anonimowa funkcja, która pobiera dwa dane wejściowe. Nic szczególnego, po prostu poddane kompletności.

CJam, 16 bajtów

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

Nadal jestem pewien, że są tu bajty do zapisania

Dyalog APL , 11 bajtów

+÷1+9E16÷⍨×

Ułamek sumy i [przyrost podziałów dziewięćdziesięciu biliardów i iloczyn]:

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

÷⍨to „dzieli”, jak w „dziewięćdziesięciu biliardach dzieli n ”, tj. jest równoważne n podzielone przez dziewięćdziesiąt biliardów.

Haskell, 24 bajty

Jako pojedyncza funkcja, która może zapewnić liczbę zmiennoprzecinkową lub liczbę ułamkową, w zależności od kontekstu, w którym jest używana ...

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

Przykładowe użycie w REPL:

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

Pyke, 12 bajtów

sQB9T16^*/h/

Wypróbuj tutaj!

Pyth, 14 bajtów

csQhc*FQ*9^T16

Zestaw testowy.

Formuła: sum(input) / (1 + (product(input) / 9e16))

Bonus: kliknij tutaj!

Javascript 24 bajty

Wygolono 4 bajty dzięki @LeakyNun

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

Całkiem proste

Julia, 22 bajty

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

Wypróbuj online!

Noether , 24 bajty

Nie konkuruje

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

Wypróbuj tutaj!

Wydaje się, że Noether jest odpowiednim językiem dla tego wyzwania, biorąc pod uwagę, że Emmy Noether była pionierem idei symetrii, które prowadzą do równań Einsteina (to E = mc^2itp.)

W każdym razie jest to w zasadzie tłumaczenie danego równania na odwrotną notację polską.

TI-BASIC, 12 bajtów

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

Bierze wkład w postaci listy {U,V}na Ans.

PowerShell, 34 bajty

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

Niezwykle prosta implementacja. Nie ma jednak nadziei na dogonienie kogoś dzięki $wymaganym 6 .

Oracle SQL 11.2, 39 bajtów

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

T-SQL, 38 bajtów

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

Wypróbuj online!

Prosta implementacja formuły.

ForceLang, 116 bajtów

Niekonkurencyjny, wykorzystuje funkcjonalność języka dodaną po opublikowaniu wyzwania.

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 bajtów

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

dc, 21 bajtów

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

Zakłada się, że precyzja została już ustawiona, np 20k. Za pomocą . Dodaj 3 bajty, jeśli nie możesz przyjąć tego założenia.

Bardziej dokładna wersja to

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

24 bajty.

Oba są dość wiernymi transkrypcjami formuły, a jedynym znaczącym golfem jest użycie 9I16^*c².

PHP, 44 45 bajtów

Funkcja anonimowa, dość prosta.

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

Właściwie 12 bajtów

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

Wypróbuj online!

Wyjaśnienie:

;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 bajty

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

Wypróbuj online!

Dalej (gforth) , 39 bajtów

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

Wypróbuj online!

Objaśnienie kodu

: 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