에서는 상대성 , 반대 방향으로 이동되는 다른 개체에 이동체의 속도는 수식에 의해 주어진다 :

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. 출력은 10 진수 값이거나 분수를 줄여야합니다. 출력은 0.00110 진수 값의 실제 값 내에 있거나 분수의 경우 정확해야합니다.

테스트 사례

체재: 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개별적으로 참조하는 것을 피할 수 있습니다 . "unwrapped list"의 일종 인 모든 인수 시퀀스 로 ##확장됩니다 . 다음은 간단한 예입니다.

{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]]

여기서, *^과학적 표기법 단지 티카의 연산자입니다.

젤리, 9 바이트

÷3ȷ8P‘÷@S

온라인으로 사용해보십시오! 또는 분수를 선호하는 경우 M을 사용하여 동일한 코드를 실행할 수 있습니다 .

작동 원리

÷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 바이트

파이썬은 각 입력이 필요할 때 입력을 얻는 것이 끔찍 int(input()) 하지만 여기에 내 솔루션이 있습니다.

v, u = int (input ()), int (input ()); print ((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÷⍨×

합계의 비율과 [90 십억과 곱의 나누기 증분] :

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

÷⍨"90 분의 1 나누기 n " 에서와 같이, "분할"은, 즉 n 을 90 조로 나눈 것과 같다 .

하스켈, 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/

여기 사용해보십시오!

Pyth, 14 바이트

csQhc*FQ*9^T16

테스트 스위트.

공식: sum(input) / (1 + (product(input) / 9e16))

보너스 : 여기를 클릭하십시오!

자바 스크립트 24 바이트

@LeakyNun 덕분에 4 바이트가 줄었습니다.

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

여기 사용해보십시오!

에미 노 에르 (Emy Noether) 가 아인슈타인의 방정식 (이것 E = mc^2등)으로 이끄는 대칭 개념을 개척 했다는 점을 감안할 때, 도전에 대한 적절한 언어 인 것 같습니다 .

어쨌든, 이것은 기본적으로 주어진 방정식을 연마 표기법으로 변환 한 것입니다.

TI-BASIC, 12 바이트

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

{U,V}on 의 목록으로 입력 을 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 기본, 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)

온라인으로 사용해보십시오!

4 번째 (2 번째) , 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