Calculez la vitesse relativiste

10

En relativité restreinte , la vitesse d'un objet en mouvement par rapport à un autre objet qui se déplace dans la direction opposée est donnée par la formule:

s=v+u1+vu/c2.

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

Dans cette formule, v et u sont les amplitudes des vitesses des objets, et c est la vitesse de la lumière (qui est d'environ 3.0×108m/s , une approximation assez proche pour ce défi).

Par exemple, si un objet se déplaçait vers v = 50,000 m/s, et un autre objet se déplaçait vers u = 60,000 m/s, la vitesse de chaque objet par rapport à l'autre serait approximativement s = 110,000 m/s. C'est ce que vous attendez de la relativité galiléenne (où les vitesses s'ajoutent simplement). Cependant, si v = 50,000,000 m/set u = 60,000,000 m/s, la vitesse relative serait approximativement 106,451,613 m/s, ce qui est significativement différent de celui 110,000,000 m/sprédit par la relativité galiléenne.

Le défi

Étant donné deux nombres entiers vet utels que 0 <= v,u < c, calculer la vitesse additive relativiste, en utilisant la formule ci-dessus, avec c = 300000000. La sortie doit être une valeur décimale ou une fraction réduite. La sortie doit être inférieure à 0.001la valeur réelle pour une valeur décimale ou exacte pour une fraction.

Cas de test

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)
code-golf physics code-golf abstract-algebra code-golf number arithmetic integer code-golf ascii-art number code-golf number-theory primes code-golf arithmetic grid code-golf code-golf sequence code-golf kolmogorov-complexity compression code-golf math number arithmetic array-manipulation code-golf primes hexagonal-grid complex-numbers code-golf number counting code-golf math number arithmetic Mego
la source
7
s/velocity/Velocity of an Unladen Swallow/g
mbomb007
1
"Relativité gallilienne"? La mécanique gaillilienne, peut-être, mais j'appellerais votre phrase un oxymore (peut-être aussi un rétronyme anachronique). Bonne question PPCG, cependant!
Toby Speight
6
@TobySpeight en.wikipedia.org/wiki/Galilean_invariance
Mego

Réponses:

6

MATL , 9 octets

sG3e8/pQ/

Essayez-le en ligne!

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
Luis Mendo
la source
11

Mathematica, 17 octets

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

Une fonction sans nom prenant deux entiers et retournant une fraction exacte.

Explication

Cela utilise deux belles astuces avec la séquence d'arguments## , ce qui me permet d'éviter de référencer les arguments individuels uet vséparément. ##se développe en une séquence de tous les arguments, qui est en quelque sorte une "liste non enveloppée". Voici un exemple simple:

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

donne

{x, u, v, y}

La même chose fonctionne à l'intérieur des fonctions arbitraires (car {...}c'est juste un raccourci pour List[...]):

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

donne

f[x, u, v, y]

Maintenant, nous pouvons également remettre ##aux opérateurs qui les traiteront d'abord comme un seul opérande en ce qui concerne l'opérateur. Ensuite, l'opérateur sera développé à sa forme complète f[...], et ce n'est qu'à ce moment que la séquence sera développée. Dans ce cas, +##c'est Plus[##]qui est Plus[u, v], c'est-à-dire le numérateur que nous voulons.

Dans le dénominateur, en revanche, ##apparaît comme l'opérateur de gauche de /. La raison pour laquelle cela se multiplie uet vest plutôt subtile. /est mis en œuvre en termes de Times:

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

Alors, quand il aest ##, il se développe ensuite et nous nous retrouvons avec

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

Ici, *^est juste l'opérateur de Mathematica pour la notation scientifique.

Martin Ender
la source
4

Gelée, 9 octets

÷3ȷ8P‘÷@S

Essayez-le en ligne! Sinon, si vous préférez fractions, vous pouvez exécuter le même code avec M .

Comment ça fonctionne

÷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.
Dennis
la source
3

Python3, 55 31 29 octets

Python est horrible pour obtenir des entrées selon les besoins de chaque entrée, int(input()) mais voici ma solution quand même:

v, u = int (entrée ()), int (entrée ()); print ((v + u) / (1 + v * u / 9e16))

Grâce à @Jakube, je n'ai pas vraiment besoin de tout le pré-jeu, juste de la fonction. Par conséquent:

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

Plutôt explicite, obtenez des entrées, des calculs. J'ai utilisé c ^ 2 et simplifié car 9e16 est plus court que (3e8 ** 2).

Python2, 42 octets

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

Merci à @muddyfish

George
la source
1
Si vous utilisez python2, vous pouvez supprimer le int(input())et le remplacer par input(), vous pouvez également déposer les crochets autour de l'instruction print
Blue
@Jakube Comment obtiendriez-vous les entrées? OP dit "Étant donné deux entiers v et u"
George
@Jakube Oui, c'est ainsi que j'utiliserais lambda, mais OP demande implicitement tout le programme et pas seulement une fonction. c'est à dire qu'il a une entrée et une sortie
George
@Jakube bien dans ce cas, je joue un peu au golf. À votre santé!
george
Vous pouvez en avoir lambda u,v:(v+u)/(1+v*u/9e16), et cela fonctionne pour Python 2 et 3.
mbomb007
2

J, 13 11 octets

+%1+9e16%~*

Usage

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

Où >>est STDIN et <<STDOUT.

Leaky Nun
la source
2

Matlab, 24 octets

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

Fonction anonyme qui prend deux entrées. Rien d'extraordinaire, juste soumis pour être complet.

sintax
la source
Je vous suggère de supprimer "régulier" du titre. Si une boîte à outils était utilisée, elle devrait être mentionnée; vous pouvez donc dire "Matlab" en toute sécurité. Oh et bienvenue chez PPCG!
Luis Mendo
2

CJam, 16 octets

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

Je suis toujours sûr qu'il y a des octets à enregistrer ici

A Simmons
la source
Voici deux de ces octets:q~d]_:+\:*9e16/)/
Martin Ender
@MartinEnder Merci, je ne savais pas dtravailler comme ça, mais je ne peux pas croire que j'ai manqué l'opérateur d'incrémentation ....
Un Simmons
1 octet de moins avec entrée tableau:q~_:+\:*9.e16/)/
Luis Mendo
2

Dyalog APL , 11 octets

+÷1+9E16÷⍨×

La fraction de la somme et [l'incrément des divisions de quatre-vingt-dix quadrillions et du produit]:

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

÷⍨est "divise", comme dans "quatre-vingt-dix quadrillions divise n ", c'est-à-dire équivalent à n divisé par quatre-vingt-dix quadrillions.

Adam
la source
C'est sûrement 11 caractères, pas des octets, car je suis sûr que certains de ces symboles ne sont pas en ASCII?
Jules
@Jules En UTF-8, certes, mais APL a ses propres pages de codes, qui sont antérieures à Unicode de quelques décennies.
Dennis
2

Haskell, 24 octets

En tant que fonction unique qui peut fournir un nombre à virgule flottante ou fractionnaire, selon le contexte dans lequel il est utilisé ...

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

Exemple d'utilisation dans REPL:

*Main> r 20 30
49.999999999999666
*Main> default (Rational)
*Main> r 20 30 
7500000000000000 % 150000000000001
Jules
la source
Enregistrez deux octets en définissant u#vau lieu de r u v.
Zgarb
1

Pyth, 14 octets

csQhc*FQ*9^T16

Suite de tests.

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

Bonus: cliquez ici!

Leaky Nun
la source
5
Il n'est vraiment pas nécessaire d'inclure "FGITW" sur chaque solution qui est la première d'un défi.
Mego
Désolé, je l'ai supprimé.
Leaky Nun
1

Javascript 24 octets

Rasé de 4 octets grâce à @LeakyNun

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

Assez simple

Bálint
la source
v=>u=>(v+u)/(1+v*u/9e16)Ça irait ?
Leaky Nun
@LeakyNun oui ce serait selon ce méta post
Patrick Roberts
1

Noether , 24 octets

Non compétitif

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

Essayez-le ici!

Noether semble être un langage approprié pour le défi étant donné qu'Emmy Noether a été le pionnier des idées de symétrie qui conduisent aux équations d'Einstein (ceci, E = mc^2etc.)

Quoi qu'il en soit, il s'agit essentiellement d'une traduction de l'équation donnée en notation polonaise inverse.

Beta Decay
la source
1

TI-BASIC, 12 octets

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

Prend entrée comme une liste de {U,V}sur Ans.

Scott Milner
la source
0

PowerShell, 34 octets

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

Mise en œuvre extrêmement simple. Aucun espoir de rattraper qui que ce soit, cependant, grâce aux 6 $requis.

AdmBorkBork
la source
0

Oracle SQL 11.2, 39 octets

SELECT (:v+:u)/(1+:v*:u/9e16)FROM DUAL;
Jeto
la source
0

T-SQL, 38 octets

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

Essayez-le en ligne!

Mise en œuvre simple de la formule.

Ross Presser
la source
0

ForceLang, 116 octets

Non compétitif, utilise la fonctionnalité de langue ajoutée après la publication du défi.

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
SuperJedi224
la source
0

TI-Basic, 21 octets

Prompt U,V:(U+V)/(1+UV/9ᴇ16
Timtech
la source
N'est-ce pas la Evaleur de 2 octets?
Leaky Nun
3
Veuillez vérifier par vous-même d'abord ... tibasicdev.wikidot.com/e-ten
Timtech
0

dc, 21 octets

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

Cela suppose que la précision a déjà été définie, par exemple avec 20k. Ajoutez 3 octets si vous ne pouvez pas faire cette hypothèse.

Une version plus précise est

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

à 24 octets.

Les deux sont des transcriptions raisonnablement fidèles de la formule, le seul golf notable étant l'utilisation de 9I16^*for c².

Toby Speight
la source
0

PHP, 44 45 octets

Fonction anonyme, assez simple.

function($v,$u){echo ($v+$u)/(1+$v*$u/9e16);}
Xanderhall
la source
3
Vous avez besoin c^2dans le dénominateur ... c'est-à-dire, 9e16ou équivalent.
AdmBorkBork
0

En fait, 12 octets

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

Essayez-le en ligne!

Explication:

;8╤3*ì*πu@Σ/
;             dupe input
 8╤3*ì*       multiply each element by 1/(3e8)
       πu     product, increment
         @Σ/  sum input, divide sum by product
Mego
la source
0

Forth (gforth) , 39 octets

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

Essayez-le en ligne!

Explication du code

: 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
reffu
la source