Trong thuyết tương đối đặc biệt , vận tốc của một vật chuyển động so với một vật khác đang chuyển động ngược chiều được đưa ra theo công thức:

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

Trong công thức này, $v$ và $u$ là độ lớn của vận tốc của các vật và $c$ là tốc độ ánh sáng (xấp xỉ $3.0 \times 10^8 \,\mathrm m/\mathrm s$ , một xấp xỉ đủ gần cho thử thách này).

Ví dụ, nếu một đối tượng đang di chuyển v = 50,000 m/svà một đối tượng khác đang di chuyển u = 60,000 m/s, vận tốc của từng đối tượng so với đối tượng khác sẽ xấp xỉ s = 110,000 m/s. Đây là những gì bạn mong đợi dưới thuyết tương đối của Galilê (nơi vận tốc đơn giản thêm vào). Tuy nhiên, nếu v = 50,000,000 m/svà u = 60,000,000 m/s, vận tốc tương đối sẽ xấp xỉ 106,451,613 m/s, khác biệt đáng kể so với 110,000,000 m/sdự đoán của thuyết tương đối Galilê.

Các thách thức

Cho hai số nguyên vvà unhư vậy 0 <= v,u < c, tính vận tốc phụ gia tương đối tính, sử dụng công thức trên, với c = 300000000. Đầu ra phải là giá trị thập phân hoặc phần giảm. Đầu ra phải nằm trong 0.001giá trị thực cho giá trị thập phân hoặc chính xác cho một phân số.

Các trường hợp thử nghiệm

Định dạng: 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/

Hãy thử trực tuyến!

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

Toán học, 17 byte

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

Một hàm không tên lấy hai số nguyên và trả về một phân số chính xác.

Giải trình

Điều này sử dụng hai thủ thuật hay với chuỗi đối số## , cho phép tôi tránh tham chiếu các đối số riêng lẻ uvà vriêng rẽ. ##mở rộng thành một chuỗi tất cả các đối số, đó là một loại "danh sách chưa được bao bọc". Đây là một ví dụ đơn giản:

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

cho

{x, u, v, y}

Các công việc tương tự bên trong các hàm tùy ý (vì {...}chỉ là tốc ký List[...]):

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

cho

f[x, u, v, y]

Bây giờ chúng ta cũng có thể trao ##cho các toán tử, điều đầu tiên sẽ coi chúng là một toán hạng duy nhất theo như toán tử có liên quan. Sau đó, toán tử sẽ được mở rộng thành dạng đầy đủ của nó f[...]và chỉ sau đó là chuỗi được mở rộng. Trong trường hợp +##này Plus[##]là Plus[u, v], tức là tử số mà chúng ta muốn.

Mặt khác, trong mẫu số, ##xuất hiện dưới dạng toán tử bên trái của /. Lý do này nhân lên uvà vkhá tinh tế. /được thực hiện theo các điều khoản Times:

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

Vì vậy, khi alà ##, nó được mở rộng sau đó và chúng tôi kết thúc với

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

Ở đây, *^chỉ là toán tử của Mathicala cho ký hiệu khoa học.

Thạch, 9 byte

÷3ȷ8P‘÷@S

Hãy thử trực tuyến! Ngoài ra, nếu bạn thích các phần phân đoạn, bạn có thể thực thi mã cùng với M .

Làm thế nào nó hoạt động

÷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 rất tệ khi nhận đầu vào vì mỗi nhu cầu đầu vào int(input()) nhưng dù sao đây cũng là giải pháp của tôi:

v, u = int (đầu vào ()), int (đầu vào ()); in ((v + u) / (1 + v * u / 9e16))

Cảm ơn @Jakube tôi thực sự không cần toàn bộ prgrame, chỉ là chức năng. Vì thế:

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

Thay vì tự giải thích, có được đầu vào, tính toán. Tôi đã sử dụng c ^ 2 và đơn giản hóa là 9e16 ngắn hơn (3e8 ** 2).

Python2, 42 byte

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

Cảm ơn @muddyfish

J, 13 11 byte

+%1+9e16%~*

Sử dụng

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

Trong trường hợp >>là STDIN và <<là STDOUT.

Matlab, 24 byte

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

Hàm ẩn danh có hai đầu vào. Không có gì lạ mắt, chỉ cần nộp cho đầy đủ.

CJam, 16 byte

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

Tôi vẫn chắc chắn có byte được lưu ở đây

APL Dyalog , 11 byte

+÷1+9E16÷⍨×

Tỷ lệ của tổng và [gia số của các phần chín mươi triệu và sản phẩm]:

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

÷⍨là "chia", như trong "chín mươi triệu triệu chia n " tức là tương đương với n chia cho chín mươi triệu.

Haskell, 24 byte

Là một hàm duy nhất có thể cung cấp số dấu phẩy động hoặc số phân số, tùy thuộc vào bối cảnh sử dụng ...

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

Ví dụ sử dụng trong REPL:

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

Pyke, 12 byte

sQB9T16^*/h/

Hãy thử nó ở đây!

Bình thường, 14 byte

csQhc*FQ*9^T16

Bộ thử nghiệm.

Công thức: sum(input) / (1 + (product(input) / 9e16))

Tiền thưởng: bấm vào đây!

Javascript 24 byte

Đã tắt 4 byte nhờ @LeakyNun

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

Khá đơn giản

Julia, 22 byte

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

Hãy thử trực tuyến!

Noether , 24 byte

Không cạnh tranh

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

Hãy thử nó ở đây!

Noether dường như là một ngôn ngữ thích hợp cho thách thức được đưa ra rằng Emmy Noether đã đi tiên phong trong các ý tưởng về sự đối xứng dẫn đến các phương trình của Einstein (điều này, E = mc^2v.v.)

Dù sao, đây về cơ bản là một bản dịch của phương trình đã cho để đảo ngược ký hiệu đánh bóng.

TI-BASIC, 12 byte

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

Đưa đầu vào như một danh sách {U,V}trên Ans.

PowerShell, 34 byte

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

Thực hiện cực kỳ đơn giản. Mặc dù vậy, không có hy vọng bắt kịp với bất cứ ai, nhờ có 6 $yêu cầu.

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')

Hãy thử trực tuyến!

Thực hiện công thức đơn giản.

ForceLang, 116 byte

Không biên dịch, sử dụng chức năng ngôn ngữ được thêm sau khi thử thách được đăng.

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+/

Điều này giả định rằng độ chính xác đã được đặt, ví dụ với 20k. Thêm 3 byte nếu bạn không thể thực hiện giả định đó.

Một phiên bản chính xác hơn là

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

ở mức 24 byte.

Cả hai đều là phiên âm hợp lý của công thức, với việc chơi golf đáng chú ý duy nhất là sử dụng 9I16^*cho c².

PHP, 44 45 byte

Chức năng ẩn danh, khá đơn giản.

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

Trên thực tế, 12 byte

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

Hãy thử trực tuyến!

Giải trình:

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

Hãy thử trực tuyến!

Forth (gforth) , 39 byte

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

Hãy thử trực tuyến!

Giải thích mã

: 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