In der speziellen Relativitätstheorie ist die Geschwindigkeit eines sich bewegenden Objekts relativ zu einem anderen Objekt, das sich in die entgegengesetzte Richtung bewegt, durch die Formel gegeben:

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

In dieser Formel sind $v$ und die Größen der Geschwindigkeiten der Objekte und ist die Lichtgeschwindigkeit (die ungefähr 3,0 × 10 8 beträgt$u$$c$$3.0 \times 10^8 \,\mathrm m/\mathrm s$ , eine Annäherung nahe genug für diese Herausforderung).

Wenn sich beispielsweise ein Objekt bewegt v = 50,000 m/sund ein anderes Objekt sich bewegt u = 60,000 m/s, wäre die Geschwindigkeit jedes Objekts relativ zum anderen ungefähr s = 110,000 m/s. Dies ist, was Sie unter der galiläischen Relativitätstheorie erwarten würden (wo Geschwindigkeiten einfach addieren). Wenn v = 50,000,000 m/sund jedoch, wäre u = 60,000,000 m/sdie Relativgeschwindigkeit ungefähr 106,451,613 m/s, was sich signifikant von der 110,000,000 m/sdurch die galiläische Relativitätstheorie vorhergesagten unterscheidet .

Die Herausforderung

Wenn zwei ganze Zahlen vund usolche gegeben sind 0 <= v,u < c, berechnen Sie die relativistische Additivgeschwindigkeit unter Verwendung der obigen Formel mit c = 300000000. Die Ausgabe muss entweder ein Dezimalwert oder ein reduzierter Bruch sein. Die Ausgabe muss innerhalb 0.001des tatsächlichen Werts für einen Dezimalwert oder genau für einen Bruch liegen.

Testfälle

Format: 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 Bytes

sG3e8/pQ/

Probieren Sie es online aus!

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 Bytes

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

Eine unbenannte Funktion, die zwei Ganzzahlen verwendet und einen exakten Bruch zurückgibt.

Erläuterung

Dies verwendet zwei nette Tricks mit der Argumentsequenz## , wodurch ich vermeiden kann, auf die einzelnen Argumente uund vseparat zu verweisen . ##Erweitert sich zu einer Folge aller Argumente, die eine Art "entpackte Liste" darstellt. Hier ist ein einfaches Beispiel:

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

gibt

{x, u, v, y}

Das gleiche funktioniert in beliebigen Funktionen (da {...}ist nur eine Abkürzung für List[...]):

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

gibt

f[x, u, v, y]

Jetzt können wir auch ##Operatoren übergeben, die sie für den Operator zunächst als einen einzelnen Operanden behandeln. Dann wird der Operator in seine vollständige Form erweitert f[...], und erst dann wird die Sequenz erweitert. In diesem Fall +##ist Plus[##]dies Plus[u, v]der Zähler, den wir wollen.

Im Nenner hingegen ##erscheint als linker Operator von /. Der Grund dafür ist multipliziert uund veher subtil. /wird implementiert in Bezug auf Times:

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

Also, wenn es aist ##, wird es danach erweitert und wir enden mit

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

Hier *^ist nur Mathematicas Operator für die wissenschaftliche Notation.

Gelee, 9 Bytes

÷3ȷ8P‘÷@S

Probieren Sie es online aus! Wenn Sie Brüche bevorzugen, können Sie alternativ denselben Code mit M ausführen .

Wie es funktioniert

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

Python ist schrecklich, um Eingaben zu erhalten, wie jede Eingabe benötigt, int(input()) aber hier ist trotzdem meine Lösung:

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

Dank @Jakube brauche ich eigentlich nicht das ganze Programm, nur die Funktion. Daher:

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

Eher selbsterklärend, Eingaben erhalten, rechnen. Ich habe c ^ 2 verwendet und vereinfacht, dass 9e16 kürzer als (3e8 ** 2) ist.

Python2, 42 Bytes

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

Danke an @muddyfish

J, 13 11 Bytes

+%1+9e16%~*

Verwendungszweck

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

Wo >>ist STDIN und <<ist STDOUT.

Matlab, 24 Bytes

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

Anonyme Funktion, die zwei Eingaben akzeptiert. Nichts Besonderes, nur der Vollständigkeit halber eingereicht.

CJam, 16 Bytes

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

Ich bin mir immer noch sicher, dass hier Bytes gespeichert werden müssen

Dyalog APL , 11 Bytes

+÷1+9E16÷⍨×

Der Bruchteil der Summe und [das Inkrement der Teilungen von neunzig Billiarden und des Produkts]:

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

÷⍨ist "dividiert", wie in "neunzig Billiarden dividiert n ", dh äquivalent zu n geteilt durch neunzig Billiarden.

Haskell, 24 Bytes

Als einzelne Funktion, die je nach Kontext, in dem sie verwendet wird, entweder eine Gleitkomma- oder eine Bruchzahl bereitstellen kann ...

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

Anwendungsbeispiel in REPL:

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

Pyke, 12 Bytes

sQB9T16^*/h/

Probieren Sie es hier aus!

Pyth, 14 Bytes

csQhc*FQ*9^T16

Testsuite.

Formel: sum(input) / (1 + (product(input) / 9e16))

Bonus: hier klicken!

Javascript 24 Bytes

Dank @LeakyNun 4 Bytes rasiert

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

Ziemlich einfach

Julia, 22 Bytes

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

Probieren Sie es online aus!

Noether , 24 Bytes

Nicht konkurrierend

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

Probieren Sie es hier aus!

Noether scheint eine geeignete Sprache für die Herausforderung zu sein, da Emmy Noether Pionierarbeit für die Symmetrieideen geleistet hat, die zu Einsteins Gleichungen führen (dies E = mc^2usw.).

Auf jeden Fall ist dies im Grunde eine Übersetzung der gegebenen Gleichung in die umgekehrte polnische Notation.

TI-BASIC, 12 Bytes

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

Nimmt die Eingabe als eine Liste von {U,V}auf Ans.

PowerShell, 34 Byte

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

Extrem unkomplizierte Implementierung. Keine Hoffnung, jemanden einzuholen, dank der 6 $erforderlichen.

Oracle SQL 11.2, 39 Bytes

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

T-SQL, 38 Bytes

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

Probieren Sie es online aus!

Einfache Formelimplementierung.

ForceLang, 116 Bytes

Nicht konkurrierend, verwendet Sprachfunktionen, die hinzugefügt wurden, nachdem die Herausforderung veröffentlicht wurde.

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 Bytes

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

Gleichstrom, 21 Bytes

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

Dies setzt voraus, dass die Genauigkeit bereits eingestellt wurde, z 20k. B. mit . Fügen Sie 3 Bytes hinzu, wenn Sie diese Annahme nicht treffen können.

Eine genauere Version ist

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

bei 24 Bytes.

Beide sind einigermaßen getreue Transkriptionen der Formel, wobei das einzige bemerkenswerte Golfspiel die Verwendung 9I16^*für c² ist.

PHP, 44 45 Bytes

Anonyme Funktion, ziemlich einfach.

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

Eigentlich 12 Bytes

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

Probieren Sie es online aus!

Erläuterung:

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

Probieren Sie es online aus!

Forth (gforth) , 39 Bytes

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

Probieren Sie es online aus!

Code Erklärung

: 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