ในทฤษฎีสัมพัทธภาพพิเศษความเร็วของวัตถุเคลื่อนที่ที่สัมพันธ์กับวัตถุอื่นที่เคลื่อนที่ในทิศทางตรงกันข้ามนั้นได้รับจากสูตร:

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ผลลัพธ์จะต้องเป็นค่าทศนิยมหรือเศษส่วนที่ลดลง เอาต์พุตต้องอยู่ภายใน0.001ค่าจริงสำหรับค่าทศนิยมหรือแน่นอนสำหรับเศษส่วน

กรณีทดสอบ

รูปแบบ: 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)&

ฟังก์ชันที่ไม่มีชื่อซึ่งรับค่าจำนวนเต็มสองค่าและส่งคืนเศษส่วนที่แน่นอน

คำอธิบาย

ใช้สองเทคนิคที่ดีกับลำดับการโต้เถียง##ซึ่งช่วยให้ฉันหลีกเลี่ยงการอ้างอิงแต่ละอาร์กิวเมนต์uและvแยกกัน ##ขยายไปยังลำดับของอาร์กิวเมนต์ทั้งหมดซึ่งเป็นประเภทของ "รายการที่ไม่ได้เปิด" นี่คือตัวอย่างง่ายๆ:

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

จะช่วยให้

{x, u, v, y}

งานเดียวกันในฟังก์ชั่นตามอำเภอใจ (เนื่องจาก{...}เป็นเพียงการจดชวเลขList[...]):

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

จะช่วยให้

f[x, u, v, y]

ตอนนี้เราสามารถส่ง##ผู้ปฏิบัติงานซึ่งจะถือว่าพวกเขาเป็นตัวถูกดำเนินการครั้งแรกเท่าที่ผู้ประกอบการเกี่ยวข้อง จากนั้นตัวดำเนินการจะถูกขยายเป็นแบบเต็มf[...]และจากนั้นจะขยายลำดับเท่านั้น ในกรณีนี้+##คือPlus[##]อะไร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

ลองออนไลน์! อีกวิธีหนึ่งถ้าคุณต้องการเศษส่วนคุณสามารถเรียกใช้รหัสเดียวกันด้วย MM

มันทำงานอย่างไร

÷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()) แต่นี่คือโซลูชันของฉัน:

โวลต์, U = int (input ()), int (input ()); พิมพ์ ((V + U) / (1 + V * u / 9e16))

ขอบคุณ @Jakube ฉันไม่ต้องการ prgrame ทั้งหมดเพียงแค่ฟังก์ชั่น ดังนั้น:

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

ค่อนข้างอธิบายตนเองรับอินพุตคำนวณ ฉันใช้ c ^ 2 และทำให้เข้าใจง่ายว่าเนื่องจาก 9e16 นั้นสั้นกว่า (3e8 ** 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)

ฟังก์ชั่นไม่ระบุชื่อที่รับสองอินพุต ไม่มีอะไรแฟนซีส่งเพียงเพื่อความสมบูรณ์

CJam, 16 ไบต์

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

ฉันยังมั่นใจว่ามีไบต์ที่จะบันทึกที่นี่

Dyalog APLขนาด 11 ไบต์

+÷1+9E16÷⍨×

เศษส่วนของผลรวมและ [การเพิ่มขึ้นของการหารเก้าสิบ quadrillion และผลิตภัณฑ์]:

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

÷⍨คือ "หาร" เช่นเดียวกับใน "เก้าสิบ quadrillion หารn " คือเทียบเท่ากับnหารด้วยเก้าสิบ quadrillion

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 ไบต์

ลบออก 4 ไบต์ด้วย @LeakyNun

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

ค่อนข้างตรงไปตรงมา

Julia, 22 ไบต์

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

ลองออนไลน์!

Noether , 24 ไบต์

ไม่ใช่การแข่งขัน

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

ลองที่นี่!

ดูเหมือนว่า Noether จะเป็นภาษาที่เหมาะสมสำหรับความท้าทายเนื่องจากEmmy Noetherเป็นผู้บุกเบิกแนวคิดเรื่องสมมาตรซึ่งนำไปสู่สมการของ Einstein (เช่นนี้E = mc^2เป็นต้น)

อย่างไรก็ตามนี่คือการแปลของสมการที่กำหนดไว้เพื่อย้อนกลับสัญลักษณ์การขัด

TI-BASIC ขนาด 12 ไบต์

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

จะเข้าเป็นรายการของบน{U,V}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