Olarak özel görelilik , ters yönde hareket eden başka bir nesne için bir hareketli nesne göreli hızı, aşağıdaki formül ile verilir:

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

Bu formülde, ve , nesnelerin hızlarının büyüklükleridir ve , ışık hızıdır (yaklaşık , bunun için yeterince yakın bir meydan okuma).$v$$u$$c$$3.0 \times 10^8 \,\mathrm m/\mathrm s$

Örneğin, bir nesne hareket ediyor v = 50,000 m/sve başka bir nesne hareket ediyor u = 60,000 m/solsaydı, her nesnenin diğerine göre hızı yaklaşık olarak olurdu s = 110,000 m/s. Bu Galilean göreliliği altında beklediğiniz şeydir (hızların eklenmesi). Bununla birlikte, eğer v = 50,000,000 m/sve u = 60,000,000 m/sgöreceli hız yaklaşık olarak olacaktır 106,451,613 m/s, bu da 110,000,000 m/sGalilean göreceliğinin öngördüğünden önemli ölçüde farklıdır .

Meydan okuma

Verilen iki tam sayı vve uöyle ki 0 <= v,u < c, yukarıdaki formülü kullanarak, göreceli katkı hızını hesaplayın c = 300000000. Çıktı ondalık değer veya azaltılmış kesir olmalıdır. Çıktı, 0.001ondalık bir değer için gerçek değer içinde ya da bir kesir için tam olmalıdır.

Test Durumları

Biçim: 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 bayt

sG3e8/pQ/

Çevrimiçi deneyin!

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 bayt

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

İki tamsayı alan ve tam bir kesir döndüren isimsiz bir işlev.

açıklama

Bu , bağımsız değişkenlere ve ayrı ayrı referans vermekten kaçınmamı sağlayan argüman dizisi ile## iki güzel numara kullanır . bir tür "paketlenmemiş liste" olan tüm bağımsız değişkenlerin bir dizisine genişler . İşte basit bir örnek:uv##

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

verir

{x, u, v, y}

Aynı şey keyfi işlevlerde de çalışır (çünkü {...}sadece kısayol List[...]):

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

verir

f[x, u, v, y]

Şimdi ##, operatör açısından, onları tek bir işlenen olarak ele alacak operatörlere de el verebiliriz. Daha sonra operatör tam formuna genişletilir f[...]ve ancak o zaman dizi genişletilir. Bu durumda +##olduğunu Plus[##]hangi Plus[u, v]bizim istediğimiz pay yani.

Öte yandan paydada ##, sol operatör olarak görünür /. Bunun nedeni çoğalır uve voldukça incedir. /şu şekilde uygulanır Times:

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

Yani aolup ##, bu sonradan genişletilmiş olur ve biz ile bitirmek

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

İşte, *^sadece Mathematica'nın bilimsel gösterim için operatörü.

Jöle, 9 bayt

÷3ȷ8P‘÷@S

Çevrimiçi deneyin! Alternatif olarak, kesirleri tercih ediyorsanız , M ile aynı kodu yürütebilirsiniz .

Nasıl çalışır

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

Python, her bir girişin ihtiyacı olan girdileri almak için korkunç int(input()) ama yine de benim çözümüm:

v, u int (giriş ()), int (giriş ()) =, baskı ((u + v) / (1 + v * u / 9e16))

@ Jakube sayesinde aslında tüm programa ihtiyacım yok, sadece fonksiyon. Dolayısıyla:

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

Oldukça açıklayıcı, girdi alın, hesaplar. C ^ 2 kullandım ve 9e16 (3e8 ** 2) 'den daha kısa olduğu için basitleştirdim.

Python2, 42 bayt

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

@Muddyfish sayesinde

J, 13 11 bayt

+%1+9e16%~*

kullanım

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

>>STDIN nerede ve <<STDOUT.

Matlab, 24 bayt

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

İki giriş alan anonim işlev. Hiçbir şey fantezi, sadece bütünlük için gönderildi.

CJam, 16 Bayt

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

Hala kaydedilecek baytlar olduğundan eminim

Dyalog APL , 11 bayt

+÷1+9E16÷⍨×

Toplamın payı ve [doksan katrilyon ile ürün arasındaki bölünmenin artışı]:

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

÷⍨"bölücüler" dir, "doksan katrilyon bölü n " de, yani n bölü bölü doksan katrilyon bölü.

Haskell, 24 bayt

Kullanılan bağlama bağlı olarak, kayan nokta veya kesirli sayı sağlayabilen tek bir işlev olarak ...

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

REPL'de örnek kullanım:

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

Pyke, 12 bayt

sQB9T16^*/h/

Burada deneyin!

Pyth, 14 bayt

csQhc*FQ*9^T16

Test odası.

Formül: sum(input) / (1 + (product(input) / 9e16))

Bonus: buraya tıklayın!

Javascript 24 bayt

@LeakyNun sayesinde 4 baytını tıraş etti

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

Oldukça basit

Julia, 22 bayt

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

Çevrimiçi deneyin!

Noether , 24 bayt

Sigara rakip

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

Burada deneyin!

Emmy Noether'in Einstein'ın denklemlerine (bu, E = mc^2vb.) Yol açan simetri fikirlerine öncülük ettiği göz önüne alındığında, Noether , meydan okuma için uygun bir dil gibi görünüyor .

Her neyse, bu temel olarak verilen denklemin lehçe gösterimini ters çevirmesidir.

TI-BASIC, 12 bayt

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

Girdiyi tarihinde olarak {U,V}alır Ans.

PowerShell, 34 bayt

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

Son derece basit uygulama. Yine de, $gerekli 6 sayesinde kimseye yetişme umudu yok .

Oracle SQL 11.2, 39 bayt

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

T-SQL, 38 bayt

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

Çevrimiçi deneyin!

Basit formül uygulaması.

ForceLang, 116 bayt

Rekabetçi değil, zorluk gönderildikten sonra eklenen dil işlevlerini kullanır.

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 bayt

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

dc, 21 bayt

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

Bu, hassasiyetin önceden ayarlandığını varsayar, örn 20k. Bu varsayımı yapamazsanız 3 bayt ekleyin.

Daha doğru bir sürüm

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

24 byte.

Her ikisi de formülün makul sadık transkripsiyonlarıdır, sadece dikkate değer golf 9I16^*c² kullanımıdır .

PHP, 44 45 bayt

Anonim işlev, oldukça basit.

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

Aslında 12 bayt

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

Çevrimiçi deneyin!

Açıklama:

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

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

Çevrimiçi deneyin!

İleri (gforth) , 39 bayt

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

Çevrimiçi deneyin!

Kod Açıklaması

: 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