Dalam relativitas khusus , kecepatan objek bergerak relatif terhadap objek lain yang bergerak berlawanan arah diberikan oleh rumus:

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

Dalam rumus ini, dan adalah besarnya kecepatan benda, dan adalah kecepatan cahaya (yaitu sekitar , perkiraan yang cukup dekat untuk ini tantangan).$v$$u$$c$$3.0 \times 10^8 \,\mathrm m/\mathrm s$

Misalnya, jika satu objek bergerak pada v = 50,000 m/s, dan objek lain bergerak pada u = 60,000 m/s, kecepatan masing-masing objek relatif terhadap yang lain akan sekitar s = 110,000 m/s. Inilah yang Anda harapkan di bawah relativitas Galilea (di mana kecepatan ditambahkan begitu saja). Namun, jika v = 50,000,000 m/sdan u = 60,000,000 m/s, kecepatan relatifnya akan mendekati 106,451,613 m/s, yang secara signifikan berbeda dari yang 110,000,000 m/sdiprediksi oleh relativitas Galilea.

Tantangan

Diberikan dua bilangan bulat vdan usedemikian rupa 0 <= v,u < c, hitung kecepatan aditif relativistik, dengan menggunakan rumus di atas, dengan c = 300000000. Output harus berupa nilai desimal atau fraksi tereduksi. Output harus dalam 0.001nilai aktual untuk nilai desimal, atau tepat untuk sebagian kecil.

Uji Kasus

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 byte

sG3e8/pQ/

Cobalah 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 byte

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

Fungsi tanpa nama mengambil dua bilangan bulat dan mengembalikan pecahan yang tepat.

Penjelasan

Ini menggunakan dua trik yang bagus dengan urutan argumen## , yang memungkinkan saya untuk menghindari referensi argumen individu udan vsecara terpisah. ##meluas ke urutan semua argumen, yang merupakan semacam "daftar tidak terbuka". Ini adalah contoh sederhana:

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

memberi

{x, u, v, y}

Pekerjaan yang sama di dalam fungsi arbitrer (karena {...}hanya singkatan untuk List[...]):

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

memberi

f[x, u, v, y]

Sekarang kita juga dapat menyerahkan ##kepada operator yang pertama-tama akan memperlakukan mereka sebagai operan tunggal sejauh menyangkut operator. Kemudian operator akan diperluas ke bentuk penuh f[...], dan hanya dengan demikian barulah urutannya diperluas. Dalam hal ini +##adalah Plus[##]yang mana Plus[u, v], yaitu pembilang yang kita inginkan.

Di penyebut di sisi lain, ##muncul sebagai operator kiri /. Alasannya berlipat ganda udan vagak halus. /diimplementasikan dalam hal Times:

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

Jadi ketika aadalah ##, hal itu akan diperluas setelah itu dan kami berakhir dengan

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

Di sini, *^hanya operator Mathematica untuk notasi ilmiah.

Jelly, 9 byte

÷3ȷ8P‘÷@S

Cobalah online! Atau, jika Anda lebih suka pecahan, Anda dapat mengeksekusi kode yang sama dengan M .

Bagaimana itu bekerja

÷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 byte

Python mengerikan untuk mendapatkan input karena setiap input membutuhkan int(input()) tetapi inilah solusi saya:

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

Berkat @ Jakube saya tidak benar-benar membutuhkan seluruh prgrame, hanya fungsinya. Karenanya:

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

Cukup jelas sendiri, dapatkan input, hitung. Saya telah menggunakan c ^ 2 dan menyederhanakannya karena 9e16 lebih pendek dari (3e8 ** 2).

Python2, 42 byte

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

Berkat @muddyfish

J, 13 11 byte

+%1+9e16%~*

Pemakaian

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

Di mana >>STDIN dan <<STDOUT.

Matlab, 24 byte

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

Fungsi anonim yang mengambil dua input. Tidak ada yang mewah, hanya dikirimkan untuk kelengkapan.

CJam, 16 Bytes

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

Saya masih yakin ada byte yang harus disimpan di sini

Dyalog APL , 11 byte

+÷1+9E16÷⍨×

Fraksi penjumlahan dan [pertambahan pembagian sembilan puluh kuadriliun dan produk]:

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

÷⍨adalah "membagi", seperti dalam "sembilan puluh kuadriliun membagi n " yaitu setara dengan n dibagi dengan sembilan puluh kuadriliun.

Haskell, 24 byte

Sebagai fungsi tunggal yang dapat memberikan titik apung atau angka fraksional, tergantung pada konteks di mana itu digunakan ...

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

Contoh penggunaan dalam REPL:

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

Pyke, 12 byte

sQB9T16^*/h/

Coba di sini!

Pyth, 14 byte

csQhc*FQ*9^T16

Suite uji.

Rumus: sum(input) / (1 + (product(input) / 9e16))

Bonus: klik di sini!

Javascript 24 byte

Dicukur 4 byte berkat @LeakyNun

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

Cukup mudah

Julia, 22 byte

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

Cobalah online!

Noether , 24 byte

Non-bersaing

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

Coba di sini!

Noether tampaknya menjadi bahasa yang tepat untuk tantangan mengingat Emmy Noether memelopori ide-ide simetri yang mengarah pada persamaan Einstein (ini, E = mc^2dll.)

Bagaimanapun, ini pada dasarnya adalah terjemahan dari persamaan yang diberikan untuk membalikkan notasi polish.

TI-BASIC, 12 byte

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

Mengambil input sebagai daftar {U,V}aktif Ans.

PowerShell, 34 byte

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

Implementasi yang sangat mudah. Tidak ada harapan untuk mengejar ketinggalan dengan siapa pun, berkat 6 yang $diperlukan.

Oracle SQL 11.2, 39 byte

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

T-SQL, 38 byte

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

Cobalah online!

Implementasi formula langsung.

ForceLang, 116 byte

Noncompeting, menggunakan fungsionalitas bahasa yang ditambahkan setelah tantangan diposting.

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 byte

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

dc, 21 byte

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

Ini mengasumsikan bahwa ketepatan sudah diatur, misalnya dengan 20k. Tambahkan 3 byte jika Anda tidak dapat membuat asumsi itu.

Versi yang lebih akurat adalah

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

pada 24 byte.

Keduanya transkripsi formula yang cukup beriman, dengan satu-satunya golf terkenal adalah penggunaan 9I16^*untuk c².

PHP, 44 45 byte

Fungsi anonim, cukup mudah.

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

Sebenarnya, 12 byte

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

Cobalah online!

Penjelasan:

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

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

Cobalah online!

Keempat (gforth) , 39 byte

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

Cobalah online!

Penjelasan Kode

: 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