У спеціальній відносності швидкість рухомого об’єкта відносно іншого об'єкта, що рухається у зворотному напрямку, задається формулою:

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

У цій формулі і - величини швидкостей об'єктів, а - швидкість світла (що становить приблизно 3,0 × 10 8$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

Математика, 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

Спробуйте в Інтернеті! З іншого боку , якщо ви віддаєте перевагу фракції, ви можете виконати один і той же код з М .

Як це працює

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

Швидше пояснюйте себе, отримуйте введення, обчислення. Я використав 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.

Матлаб, 24 байти

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

Анонімна функція, яка займає два входи. Нічого фантазійного, просто подано для повноти.

CJam, 16 байт

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

Я все ще впевнений, що тут можуть бути збережені байти

Діалог APL , 11 байт

+÷1+9E16÷⍨×

Частка суми і [приріст частки дев'яносто квадрильйонів і добутку]:

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

÷⍨є "ділить", як у "дев'яносто квадрильйонів ділить n ", тобто еквівалентно n, поділеному на дев'яносто квадрильйонів.

Хаскелл, 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

Пайк, 12 байт

sQB9T16^*/h/

Спробуйте тут!

Піт, 14 байт

csQhc*FQ*9^T16

Тестовий набір.

Формула: sum(input) / (1 + (product(input) / 9e16))

Бонус: натисніть тут!

Javascript 24 байти

Поголив 4 байти завдяки @LeakyNun

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}на 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)

Спробуйте в Інтернеті!

Четвертий (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