En la relatividad especial , la velocidad de un objeto en movimiento en relación con otro objeto que se mueve en la dirección opuesta viene dada por la fórmula:

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

En esta fórmula, y son las magnitudes de las velocidades de los objetos, y es la velocidad de la luz (que es aproximadamente , una aproximación lo suficientemente cercana para esto desafío).$v$$u$$c$$3.0 \times 10^8 \,\mathrm m/\mathrm s$

Por ejemplo, si un objeto se movía a v = 50,000 m/s, y otro objeto se movía a u = 60,000 m/s, la velocidad de cada objeto en relación con el otro sería aproximadamente s = 110,000 m/s. Esto es lo que cabría esperar con la relatividad galileana (donde las velocidades simplemente se suman). Sin embargo, si v = 50,000,000 m/sy u = 60,000,000 m/s, la velocidad relativa sería aproximadamente 106,451,613 m/s, que es significativamente diferente a la 110,000,000 m/spredicha por la relatividad galileana.

El reto

Dado dos enteros vy utal que 0 <= v,u < c, calcule la velocidad aditiva relativista, usando la fórmula anterior, con c = 300000000. La salida debe ser un valor decimal o una fracción reducida. La salida debe estar dentro 0.001del valor real para un valor decimal, o exacto para una fracción.

Casos de prueba

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 bytes

sG3e8/pQ/

Pruébalo en línea!

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

Una función sin nombre que toma dos enteros y devuelve una fracción exacta.

Explicación

Esto usa dos buenos trucos con la secuencia de argumentos## , lo que me permite evitar hacer referencia a los argumentos individuales uy por vseparado. ##se expande a una secuencia de todos los argumentos, que es una especie de "lista sin envolver". Aquí hay un ejemplo simple:

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

da

{x, u, v, y}

Lo mismo funciona dentro de funciones arbitrarias (ya que {...}es solo una abreviatura de List[...]):

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

da

f[x, u, v, y]

Ahora también podemos pasar ##a operadores que primero los tratarán como un solo operando en lo que respecta al operador. Luego, el operador se expandirá a su forma completa f[...], y solo entonces se expandirá la secuencia. En este caso +##es Plus[##]cuál es Plus[u, v], es decir, el numerador que queremos.

En el denominador, por otro lado, ##aparece como el operador izquierdo de /. La razón de esto se multiplica uy ves bastante sutil. /se implementa en términos de Times:

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

Entonces, cuando aes así ##, se expande después y terminamos con

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

Aquí, *^es solo el operador de Mathematica para la notación científica.

Jalea, 9 bytes

÷3ȷ8P‘÷@S

Pruébalo en línea! Alternativamente, si se prefiere fracciones, se puede ejecutar el mismo código con M .

Cómo funciona

÷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 es horrible para obtener entradas, ya que cada entrada necesita, int(input()) pero aquí está mi solución de todos modos:

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

Gracias a @Jakube, en realidad no necesito todo el programa, solo la función. Por lo tanto:

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

Más bien se explica por sí mismo, obtiene entradas, computa. He usado c ^ 2 y simplifiqué que como 9e16 es más corto que (3e8 ** 2).

Python2, 42 bytes

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

Gracias a @muddyfish

J, 13 11 bytes

+%1+9e16%~*

Uso

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

Donde >>está STDIN y <<es STDOUT.

Matlab, 24 bytes

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

Función anónima que toma dos entradas. Nada lujoso, solo presentado para completar.

CJam, 16 bytes

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

Todavía estoy seguro de que hay bytes para guardar aquí

Dyalog APL , 11 bytes

+÷1+9E16÷⍨×

La fracción de la suma y [el incremento de las divisiones de noventa cuatrillones y el producto]:

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

÷⍨es "divide", como en "noventa cuatrillones divide n ", es decir, equivalente a n dividido entre noventa cuadrillones.

Haskell, 24 bytes

Como una sola función que puede proporcionar un punto flotante o un número fraccionario, dependiendo del contexto en el que se use ...

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

Ejemplo de uso en REPL:

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

Pyke, 12 bytes

sQB9T16^*/h/

Pruébalo aquí!

Pyth, 14 bytes

csQhc*FQ*9^T16

Banco de pruebas.

Fórmula: sum(input) / (1 + (product(input) / 9e16))

Bono: haga clic aquí!

Javascript 24 bytes

Afeitado 4 bytes gracias a @LeakyNun

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

Muy claro

Julia, 22 bytes

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

Pruébalo en línea!

Noether , 24 bytes

No competidora

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

Pruébalo aquí!

Noether parece ser un lenguaje apropiado para el desafío dado que Emmy Noether fue pionero en las ideas de simetría que condujeron a las ecuaciones de Einstein (esto,E = mc^2 etc.)

De todos modos, esto es básicamente una traducción de la ecuación dada a la notación polaca inversa.

TI-BASIC, 12 bytes

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

Toma de entrada como una lista de {U,V}sobre Ans.

PowerShell, 34 bytes

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

Implementación extremadamente sencilla. Sin embargo, no hay esperanza de alcanzar a nadie, gracias a los 6 $requeridos.

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

Pruébalo en línea!

Implementación directa de fórmulas.

ForceLang, 116 bytes

Sin competencia, utiliza la funcionalidad de idioma agregada después de que se publicó el desafío.

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

dc, 21 bytes

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

Esto supone que la precisión ya se ha establecido, por ejemplo, con 20k. Agregue 3 bytes si no puede hacer esa suposición.

Una versión más precisa es

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

a 24 bytes.

Ambas son transcripciones razonablemente fieles de la fórmula, y el único juego de golf notable es el uso de 9I16^*for c².

PHP, 44 45 bytes

Función anónima, bastante sencilla.

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

En realidad, 12 bytes

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

Pruébalo en línea!

Explicación:

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

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

Pruébalo en línea!

Adelante (gforth) , 39 bytes

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

Pruébalo en línea!

Explicación del código

: 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