特殊相対、反対方向に移動している別の物体に対して移動する物体の速度は、以下の式によって与えられます。

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

この式では、$v$と$u$はオブジェクトの速度の大きさであり、$c$は光速です（これは約$3.0 \times 10^8 \,\mathrm m/\mathrm s$、この課題に十分近い近似値）。

たとえば、あるオブジェクトがで動いていてv = 50,000 m/s、別のオブジェクトがで動いてu = 60,000 m/sいる場合、他のオブジェクトに対する各オブジェクトの速度はおよそになりますs = 110,000 m/s。これは、ガリレオ相対論（速度が単純に追加される）の下で予想されることです。ただし、v = 50,000,000 m/sおよびのu = 60,000,000 m/s場合、相対速度はおよそとなり、ガリレイ相対性理論によって予測された106,451,613 m/sものとは大幅に異なり110,000,000 m/sます。

チャレンジ

二つの整数所与vとuするように0 <= v,u < cして、上記の式を使用して、相対論的添加速度を計算し、c = 300000000。出力は、10進数値または小数部分でなければなりません。出力は0.001、10進値の場合は実際の値の範囲内であるか、小数部の場合は正確でなければなりません。

テストケース

フォーマット： 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バイト

sG3e8/pQ/

オンラインでお試しください！

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バイト

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

2つの整数を取り、正確な分数を返す名前のない関数。

説明

これは、引数シーケンス##で2つの素晴らしいトリックを使用します。これにより、個々の引数uを個別に参照することを回避できますv。すべての引数のシーケンスに##展開されます。これは、「ラップされていないリスト」のようなものです。以下に簡単な例を示します。

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

与える

{x, u, v, y}

同じことが任意の関数内でも機能します（の{...}省略形であるためList[...]）：

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

与える

f[x, u, v, y]

##これで、演算子に関する限り、最初にそれらを単一のオペランドとして扱う演算子に渡すこともできます。次に、演算子は完全な形式に展開され、f[...]その後、シーケンスが展開されます。この場合、+##is Plus[##]is Plus[u, v]、つまり必要な分子です。

一方、分母では##、の左側の演算子として表示され/ます。これが増大しu、vかなり微妙な理由。/の観点から実装されていますTimes：

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

ときそうaである##、それはその後拡大しますと、私たちは、で終わります

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

ここに、*^Mathematicaの科学的表記法の演算子があります。

ゼリー、9バイト

÷3ȷ8P‘÷@S

オンラインでお試しください！または、分数が必要な場合は、Mを使用して同じコードを実行できます。

使い方

÷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バイト

Pythonは、各入力が必要なときに入力を取得するのがひどいint(input()) ですが、とにかくここに私の解決策があります：

v、u = int（input（））、int（input（））; print（（v + u）/（1 + v * u / 9e16））

@Jakubeのおかげで、実際にはプログラム全体は必要ありません。関数だけが必要です。したがって：

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

むしろ自明で、入力を取得し、計算します。9e16は（3e8 ** 2）よりも短いので、c ^ 2を使用して簡略化しました。

Python2、42バイト

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

@muddyfishに感謝

J、13 11バイト

+%1+9e16%~*

使用法

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

>>STDINと<<STDOUT はどこにありますか。

Matlab、24バイト

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

2つの入力を受け取る無名関数。何も凝ったものではなく、完全性のために提出されました。

CJam、16バイト

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

ここに保存するバイトがあると確信しています

Dyalog APL、11バイト

+÷1+9E16÷⍨×

合計の端数と[90兆の除算の増分と積]：

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

÷⍨同様に「分割」、「90兆の分割であるNに等しい」、すなわちN 90兆で割りました。

Haskell、24バイト

使用されるコンテキストに応じて、浮動小数点または小数のいずれかを提供できる単一の関数として...

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

REPLでの使用例：

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

Pyke、12バイト

sQB9T16^*/h/

ここでお試しください！

Pyth、14バイト

csQhc*FQ*9^T16

テストスイート。

式： sum(input) / (1 + (product(input) / 9e16))

ボーナス：ここをクリックしてください！

JavaScript 24バイト

@LeakyNunのおかげで4バイトを削った

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

かなり簡単

ジュリア、22バイト

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

オンラインでお試しください！

いいえ、24バイト

非競合

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

ここでお試しください！

エミーヌーザーがアインシュタインの方程式（これなど）につながる対称性のアイデアを開拓したことを考えると、ノーザーは挑戦にとって適切な言語のようですE = mc^2。

とにかく、これは基本的に与えられた方程式を逆ポーランド記法に変換したものです。

TI-BASIC、12バイト

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

{U,V}onのリストとして入力を受け取りますAns。

PowerShell、34バイト

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

非常に簡単な実装。6が$必要なため、だれにでも追いつくことはできません。

Oracle SQL 11.2、39バイト

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

T-SQL、38バイト

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

オンラインでお試しください！

簡単な数式の実装。

ForceLang、116バイト

競合せず、チャレンジの投稿後に追加された言語機能を使用します。

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バイト

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

dc、21バイト

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

これは、たとえばで精度がすでに設定されていることを前提としています20k。想定できない場合は3バイトを追加します。

より正確なバージョンは

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

24バイトで。

どちらも式のかなり忠実な転写であり9I16^*、c²の使用が唯一の注目すべきゴルフです。

PHP、44 45バイト

匿名関数、かなり単純です。

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

実際には、12バイト

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

オンラインでお試しください！

説明：

;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バイト

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

オンラインでお試しください！

Forth（gforth）、39バイト

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

オンラインでお試しください！

コード説明

: 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