Nella relatività speciale , la velocità di un oggetto in movimento rispetto a un altro oggetto che si muove nella direzione opposta è data dalla formula:

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

In questa formula, ed sono le grandezze delle velocità degli oggetti, e è la velocità della luce (che è di circa , una stretta sufficiente approssimazione per questo sfida).$v$$u$$c$$3.0 \times 10^8 \,\mathrm m/\mathrm s$

Ad esempio, se un oggetto si stesse muovendo a v = 50,000 m/s, e un altro oggetto si stesse muovendo a u = 60,000 m/s, la velocità di ciascun oggetto rispetto all'altro sarebbe approssimativamente s = 110,000 m/s. Questo è ciò che ti aspetteresti dalla relatività galileiana (dove le velocità si aggiungono semplicemente). Tuttavia, se v = 50,000,000 m/se u = 60,000,000 m/s, la velocità relativa sarebbe approssimativamente 106,451,613 m/s, che è significativamente diversa da quella 110,000,000 m/sprevista dalla relatività galileiana.

La sfida

Dati due numeri interi ve utali che 0 <= v,u < c, calcolare la velocità additiva relativistica, usando la formula sopra, con c = 300000000. L'output deve essere un valore decimale o una frazione ridotta. L'output deve essere all'interno 0.001del valore effettivo per un valore decimale o esatto per una frazione.

Casi test

Formato: 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/

Provalo online!

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 byte

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

Una funzione senza nome che prende due numeri interi e restituisce una frazione esatta.

Spiegazione

Questo utilizza due simpatici trucchi con la sequenza degli argomenti## , che mi consente di evitare di fare riferimento ai singoli argomenti ue vseparatamente. ##si espande in una sequenza di tutti gli argomenti, che è una sorta di "elenco da scartare". Qui c'è un semplice esempio:

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

dà

{x, u, v, y}

Lo stesso funziona all'interno di funzioni arbitrarie (poiché {...}è solo una scorciatoia per List[...]):

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

dà

f[x, u, v, y]

Ora possiamo anche consegnare ##agli operatori che per primi li tratteranno come un singolo operando per quanto riguarda l'operatore. Quindi l'operatore verrà espanso nella sua forma completa f[...]e solo allora la sequenza verrà espansa. In questo caso +##è Plus[##]qual è Plus[u, v], cioè il numeratore che vogliamo.

Nel denominatore invece, ##appare come l'operatore di sinistra di /. Il motivo si moltiplica ued vè piuttosto sottile. /è implementato in termini di Times:

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

Quindi, quando lo aè ##, si espande in seguito e finiamo con

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

Qui, *^è solo l'operatore di Mathematica per la notazione scientifica.

Gelatina, 9 byte

÷3ȷ8P‘÷@S

Provalo online! In alternativa, se si preferisce frazioni, è possibile eseguire lo stesso codice con M .

Come funziona

÷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 è terribile per ottenere input di cui ogni input ha bisogno int(input()) ma ecco comunque la mia soluzione:

v, u = int (ingresso ()), int (ingresso ()); stampa ((v + u) / (1 + v * u / 9e16))

Grazie a @Jakube in realtà non ho bisogno dell'intero prgrame, ma solo della funzione. Quindi:

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

Piuttosto autoesplicativo, ottenere input, calcolare. Ho usato c ^ 2 e ho semplificato il fatto che 9e16 è più corto di (3e8 ** 2).

Python2, 42 byte

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

Grazie a @muddyfish

J, 13 11 byte

+%1+9e16%~*

uso

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

Dov'è >>STDIN ed <<è STDOUT.

Matlab, 24 byte

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

Funzione anonima che accetta due input. Niente di speciale, appena presentato per completezza.

CJam, 16 byte

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

Sono ancora sicuro che ci siano byte da salvare qui

Dyalog APL , 11 byte

+÷1+9E16÷⍨×

La frazione della somma e [l'incremento delle divisioni di novanta quadrilioni e il prodotto]:

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

÷⍨è "divide", come in "novanta quadrilioni divide n " cioè equivalente a n diviso per novanta quadrilioni.

Haskell, 24 byte

Come singola funzione che può fornire un numero in virgola mobile o un numero frazionario, a seconda del contesto in cui viene utilizzato ...

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

Esempio di utilizzo in REPL:

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

Pyke, 12 byte

sQB9T16^*/h/

Provalo qui!

Pyth, 14 byte

csQhc*FQ*9^T16

Suite di test.

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

Bonus: clicca qui!

Javascript 24 byte

Rimozione di 4 byte grazie a @LeakyNun

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

Abbastanza diretto

Julia, 22 byte

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

Provalo online!

Noether , 24 byte

Fuori concorso

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

Provalo qui!

Noether sembra essere un linguaggio appropriato per la sfida dato che Emmy Noether ha aperto la strada alle idee di simmetria che hanno portato alle equazioni di Einstein (questo,E = mc^2 ecc.)

Comunque, questa è fondamentalmente una traduzione dell'equazione data per invertire la notazione polacca.

TI-BASIC, 12 byte

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

Accetta input come un elenco di {U,V}on Ans.

PowerShell, 34 byte

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

Implementazione estremamente semplice. Nessuna speranza di mettersi al passo con nessuno, però, grazie ai 6 $richiesti.

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

Provalo online!

Implementazione semplice della formula.

ForceLang, 116 byte

Non competitiva, utilizza la funzionalità della lingua aggiunta dopo la pubblicazione della sfida.

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

Ciò presuppone che la precisione sia già stata impostata, ad es. Con 20k . . Aggiungi 3 byte se non puoi fare questo presupposto.

Una versione più accurata è

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

a 24 byte.

Entrambe sono trascrizioni ragionevolmente fedeli della formula, con l'unico golf notevole l'uso di 9I16^*per c².

PHP, 44 45 byte

Funzione anonima, abbastanza semplice.

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

In realtà, 12 byte

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

Provalo online!

Spiegazione:

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

Provalo online!

Forth (gforth) , 39 byte

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

Provalo online!

Spiegazione del codice

: 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