[Question]
  [
# Objective
Given a dimension of an SI unit, convert the Lorentz-Heaviside version of a Planck unit \$1\$ into SI metric.
# What is a Planck unit?
[Planck units](https://en.wikipedia.org/wiki/Planck_units) are a set of units of measurement. It defines five fundamental constants of the universe as dimensionless \$1\$.
# What is a dimension?
There are five types of fundamental dimension: `L`, `M`, `T`, `Q`, and `Θ` (U+0398; Greek Capital Letter Theta).
`L` stands for length and corresponds to SI unit m (meter).
`M` stands for mass and corresponds to SI unit kg (kilogram).
`T` stands for time and corresponds to SI unit s (second).
`Q` stands for electric charge and corresponds to SI unit C (Coulomb).
`Θ` stands for temperature and corresponds to SI unit K (Kelvin).
A dimension is a multiplicative combination of these. For example, SI unit V (volt) is same as kg·m²·C/s⁴ and thus corresponds to dimension `L²MQ/T⁴`.
# Planck to SI
\$1\$ as Planck unit can be converted to SI metric as follows:
$$
1 = 5.72938×10^{−35} \space [\text{m}] = 6.13971×10^{−9} \space [\text{kg}] = 1.91112×10^{−43} \space [\text{s}] = 5.29082×10^{−19} \space [\text{C}] = 3.99674×10^{31} \space [\text{K}]
$$
# Input and Output
A dimension is given as the input. Its type and format doesn't matter. In particular, it can be an size-5 array of signed integers, each integer representing the exponent of a fundamental dimension.
The Planck unit \$1\$ is to be converted to the SI unit that corresponds to the inputted dimension, and then outputted. The output type and format doesn't matter.
# Examples
Let's say the input format is a tuple of five integers, representing `L`, `M`, `T`, `Q`, and `Θ`, respectively.
For example, If the input is \$(2,1,-1,-2,0)\$, it corresponds to SI unit Ohm, and thus:
$$
1 = \frac{(5.72938×10^{−35})^2 × (6.13971×10^{−9})}{(1.91112×10^{−43})×(5.29082×10^{−19})^2} \space [\text{Ω}]
$$
So the output is approximately \$376.730\$.
For another example, if the input is \$(-2,-1,3,0,1)\$, it corresponds to SI unit K/W, and thus:
$$
1 = \frac{(1.91112×10^{−43})^3 × (3.99674×10^{31})}{(5.72938×10^{−35})^2 × (6.13971×10^{−9})} \space [\text{K/W}]
$$
So the output is approximately \$1.38424×10^{−20}\$.
Note that, if the input is \$(0,0,0,0,0)\$, the output must be \$1\$.
  
[Answer]
# [Python 3](https://docs.python.org/3/), ~~118~~ \$\cdots\$ ~~85~~ 80 bytes
Saved a whopping 29 bytes thanks to [Surculose Sputum](https://codegolf.stackexchange.com/users/92237/surculose-sputum)!!!  
Saved 4 bytes thanks to [Arnauld](https://codegolf.stackexchange.com/users/58563/arnauld)!!!  
Saved 5 bytes thanks to [xnor](https://codegolf.stackexchange.com/users/20260/xnor)!!! 
```
lambda a,b,c,d,e:399674e26**e/174539e29**a/162874e3**b/523253e37**c/189007e13**d
```
[Try it online!](https://tio.run/##TYkxDsIwDEV3TsHYWEaJ7aZpkLgJS9K4AgnaCnXh9CEDSOi/5b@3vffbukidL9f6SM9c0jFhxgkL6lliHEKvPACopdB7icoRIFkaeGxFALL1LOxFJQBMlsboXFBqpdTtdV/2bu4YCU8NRmfM4WfbbVLQIf1Zh98ZUz8 "Python 3 – Try It Online")
[Answer]
## [Frink](https://frinklang.org/), 76 bytes
```
f[a,b,z,d,e]:=l_P^a m_P^b(4π)^((a-b+z-e)/2)t_P^z(ℏ c epsilon0)^(d/2)T_P^e
```
Example usage:
```
f[2,1,-1,-2,0]
376.73031366686987155 m^2 s^-3 kg A^-2 (electric_resistance)
f[-2,-1,3,0,1]
1.3842382138391631282e-20 m^-2 s^3 kg^-1 K (thermal_resistance)
```
(As a bonus, it outputs a description of the unit of the result!)
Frink has the constants `plancklength`, `planckmass`, `plancktime`, and `plancktemperature` built in, with abbreviations `l_P`, `m_P`, `t_P`, and `T_P` respectively. Unfortunately, these are the Gaussian versions of the units, and the challenge specifies that we must use the Lorentz-Heaviside versions. This is a factor of \$\sqrt{4\pi}\$ conversion for each unit, which is consolidated into the `(4π)^((a-b+z-e)/2)` expression in the solution. (This expression is placed in the middle of the code to save a byte by letting us remove the space between `m_P^b` and `t_P^z`.)
Incidentally, `4π` is exactly as long as `4pi` in UTF-8, so it doesn't actually save any bytes -- it just looks fancier. :P
Finally, Frink inexplicably lacks the built-in unit `planckcharge`, so we calculate the Lorentz-Heaviside version directly ourselves as `(ℏ c epsilon0)^(1/2)` (this time, `ℏ` actually saves a byte over `hbar`!).
[Answer]
# Fortran (2008), 133 bytes
At least for this challenge there should be a Fortran solution.
Takes input as integer array.
```
real(real64)function h(I)
use iso_fortran_env
integer I(5)
h=product([572938d-40,613971d-14,191112d-48,529082d-24,399674d26]**I)
end
```
A slightly longer and less accurate function uses the logarithm (stolen from @xnor):
```
real(real64)function f(I)
use iso_fortran_env
integer I(5)
f=exp(sum([-7884487d-5,-1890850d-5,-9836347d-5,-42083140d-5,7276562d-5]*I))
end
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~35~~ 34 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
“~VHð¡ȷ‘I⁵*×“®ƬØʋ¥4ẋİ8nCaḌ’bȷ6¤*⁸P
```
A monadic Link accepting a list of the five exponents, `[L, M, T, Q, Θ]`, which yields a floating-point number.
**[Try it online!](https://tio.run/##AVkApv9qZWxsef//4oCcflZIw7DCoci34oCYSeKBtSrDl@KAnMKuxqzDmMqLwqU04bqLxLA4bkNh4biM4oCZYsi3NsKkKuKBuFD///9bLTIsIC0xLCAzLCAwLCAxXQ "Jelly – Try It Online")**
### How?
```
“~VHð¡ȷ‘I⁵*×“®ƬØʋ¥4ẋİ8nCaḌ’bȷ6¤*⁸P - Link: list of numbers       [L, M, T, Q, Θ]
“~VHð¡ȷ‘                           - list of code-page indices   [126, 86, 72, 24, 0, 26]
        I                          - differences                 [-40,-14,-48,-24,26]
         ⁵                         - ten                         10
          *                        - exponentiate                [1e-40, 1e-14, 1e-48, 1e-24, 1e26]
                              ¤    - nilad followed by link(s) as a nilad:
            “®ƬØʋ¥4ẋİ8nCaḌ’        -   base 250 number           572938613971191112529082399674
                            ȷ6     -   10^6                      1000000
                           b       -   convert from base         [572938,613971,191112,529082,399674]
           ×                       - multiply (vectorises)       [5.72938e-35,6.13971e-09,1.91112e-43,5.29082e-19,3.99674e31]
                                ⁸  - chain's left argument       [L, M, T, Q, Θ]
                               *   - exponentiate                [5.72938e-35^L,6.13971e-09^M,1.91112e-43^T,5.29082e-19^Q,3.99674e31^Θ]
                                 P - product                     5.72938e-35^L×6.13971e-09^M×1.91112e-43^T×5.29082e-19^Q×3.99674e31^Θ
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~31~~ 29 bytes
```
•¿NkˆSSÀ¯j5ÄΣDt₁ñµ•8ô6°/₃-*O°
```
[Try it online!](https://tio.run/##yy9OTMpM/f//UcOiQ/v9sk@3BQcfbji0Psv0cMu5xS4lj5oaD288tBUoa3F4i9mhDfqPmpp1tfwPbfj/P9pIx1BHF4iMdAxiAQ "05AB1E – Try It Online")
-2 thanks to @Kevin Cruijssen
inspired by @xnor.
explanation:
```
•¿NkˆSSÀ¯j5ÄΣDt₁ñµ•8ô6°/₃- compressed list [-34.241893, -8.211853000000005, -42.718713, -18.276477999999997, -82.33983, -94.999995]
* multiply by the implicit input (e.g. [-68.48378600000001, -8.211852999999998, 42.718713, 36.552955999999995, 0.0])
O sum (e.g. 2.576029999999996)
° raise 10 to the power of that (e.g. 376.729821659)
```
# Old Solution, ~~36~~ ~~35~~ 34 bytes
```
"7Q/Gy"Ç₃-*O°•7“µ$₁$´*h$Ć²E•6ôImP*
```
-1 thanks to @Expired Data
[Try it online!](https://tio.run/##yy9OTMpM/f9fyTxQ371S6XD7o6ZmXS3/QxseNSwyf9Qw59BWlUdNjSqHtmhlqBxpO7TJFShudniLZ26A1v//0UY6hjq6QGSkYxALAA "05AB1E – Try It Online")
explanation:
```
"7Q/Gy"Ç₃- compressed list [-40,-14,-48,-24,26]
* multiply (vectorize) with the implicit input - [-80, -14, 48, 48, 0]
O sum - 2
° 10^ - 100
•7“µ$₁$´*h$Ć²E• compressed number 572938613971191112529082399674
6ô split into groups of length 6 - [572938,613971,191112,529082,399674]
I push input to the stack, to get [2, 1, -1, -2, 0] [572938,613971,191112,529082,399674] 100
m power (vectorize) - [328257951844, 613971, 5.232533802168362e-6, 3.5723502030270884e-12, 1]
P product - 3.7672911312918473
* multiply - 376.72911312918473, and then implicitly output
```
[Answer]
# [Perl 5](https://www.perl.org/) `-pa`, ~~84~~ 80 bytes
*@Arnauld and I both realized that you can save bytes by removing the decimal points.*
```
$\=1;map$\*=$_**$F[$i++],572938E-40,6.13971E-9,191112E-48,529082E-24,399674E26}{
```
[Try it online!](https://tio.run/##Dcg9DsIwDEDhq2TIlDoodn6tqmO4BEWoA0OlQiNgQ706JtIbPr12f21RRM8Tjo@l6dlM@maMPl/0OgxXiJnYl2qDg3RCzxmrZUBGROq3QCR2pZMCeOaUQ6V0fEVIobI9Uu63t8@6P99il7b9AQ "Perl 5 – Try It Online")
[Answer]
# [dc](https://www.gnu.org/software/bc/manual/dc-1.05/html_mono/dc.html), ~~85~~ ~~81~~ ~~78~~ ~~75~~ 70 bytes
```
16iFFk1F875AI15^*?^35C8BI18^*?^/9B5431E?^/3C1109I1E^*?^/1A3ADDIA^*?^/p
```
[Try it online!](https://tio.run/##HYg7DoAgEAX7PYqNPBCFyvBN9hJYaGNsvH@zIskUM3OdIljvWh9Ut9nAsG3am7HJRYb7ffbRLgalm0mA8owyPoIJOXMY8Yoo0gQ6Opo@ "dc – Try It Online")
Or try a [test suite](https://tio.run/##Tc5NCsIwEAXgfU/xFi5UEDuN0XYl6R/kDmJJk4EWxYou3Hj32EaFMjC87y2Gac2z86@uvzIebBwMWlg4cAS4YVzAkm03YGEC8EU7h53DzcErvOEsNoyTp31f1xeq04NUmuR5fTwLWaS5pnTK2yyXO0HVmERBFGeaqtCTEqostQq4@//18OCNPaFJ0BAE4ihGAprQJGP@TfQB) that shows the sample cases listed in the challenge. (This is a bash script that runs the dc program on each test data set in turn.)
---
*Saved 4 bytes by removing the decimal points, thanks to @Arnauld.*
*Had to add 1 byte also though, because I had inadvertently omitted a digit in one of the constants.*
*Saved 3 more bytes by changing constants to hexadecimal.*
*Thanks to @Noodle9 for pointing out that using division instead of multiplication can shorten this. That, plus careful attention to how many significant digits were needed throughout, yielded a savings of 5 additional bytes.*
---
**Input on stdin, one number per line, in base 16, in the following order:**
```
Θ
L
M
T
Q
```
This is the OP's order except the last one there is moved to the first position instead.
(The challenge says, "A dimension is given as the input. Its type and format doesn't matter." Also, hexadecimal input won't make a difference in practice given the problem domain, because we're not going to have a dimensional exponent outside the range -9 to 9. And this is allowed anyway by ["Yes, I/O in unary, binary, octal, decimal or hexadecimal should be acceptable by default"](https://codegolf.meta.stackexchange.com/a/5367/59825), which got the required support of at least 5 net votes, and at least twice as many upvotes as downvotes -- in this case, 20 upvotes, 8 downvotes, and 12 net votes.)
**Output on stdout, in base 10 as usual, with *lots* of decimal places :) .**
---
**If you try this out,** note that when you enter negative numbers in dc, they're written with an initial `_` character instead of `-`, since `-` is reserved for the binary subtraction operator. And don't forget to put `Θ` first, and to enter them all in hexadecimal! (Output is still in decimal.)
[Answer]
# JavaScript (ES7), ~~81~~ 76 bytes
*Saved 5 bytes thanks to @Noodle9*
Seems like the direct formula is the shortest way... ¯\\_(ツ)\_/¯
Takes input as 5 distinct arguments.
```
(a,b,c,d,e)=>399674e26**e/174539e29**a/162874e3**b/523253e37**c/189007e13**d
```
[Try it online!](https://tio.run/##VclBDsIgEEDRvSeByVRgppSyqHehMDWaphhrvD6yNfmr/57pm878frw@w1GLtG1pKuGKGQuKXm4c4xRGoQlAjAuj5ygUAZJxE81dGGA1npg8CweAbNwcrQ3iupSW63HWXa57vatNEToceoRW68u/9dmJ0aLTuv0A "JavaScript (Node.js) – Try It Online")
---
# JavaScript (ES7), 86 bytes
Using `reduce()` adds ~~5~~ 10 bytes.
Takes input as an array.
```
a=>a.reduce((p,c,i)=>p*([572938e8,613971e34,191112,529082e24,399674e74][i]/1e48)**c,1)
```
[Try it online!](https://tio.run/##XclNDoMgEEDhfU8CZvyZAQUWehHjguDY2Bgh2vb6lHWTt3rfy3/9Ha49veszrpy3Mftx8s3F6yewEAkC7HKcUiXm3pBTli0MqJxBVhrQISJBT66zxKRBOTcYzUYv8760yNrKqgqAMod43vHg5ohPsYmZAKEuEXSLlI8/Lbuggg6waP4B "JavaScript (Node.js) – Try It Online")
[Answer]
# Mathematica, 260 bytes
Using a different method than the OP's. In particular, Table 2 at <https://en.wikipedia.org/wiki/Planck_units#Definition>
Many opportunities for cleanup (e.g., shrink name to `c`, saving 6 bytes), but seems pointless. Newlines and indenting are inessential and are only present for presentation. Two spaces are required, at the end of the `BoltzmannConstant` line and at the end of the `ElectricConstant` line.
```
convert=Function[{L,M,T,Q,t}, 
  N[UnitConvert[
    Quantity["BoltzmannConstant"]^-t 
      Sqrt[
        (4Pi)^(L-M+T-t) 
        Quantity["SpeedOfLight"]^(-3L+M-5T+Q+5t) 
        Quantity["ElectricConstant"]^Q 
        Quantity["GravitationalConstant"]^(L-M+T-t) 
        Quantity["ReducedPlanckConstant"]^(L+M+T+Q+t)
      ]
  ],6]
]
```
Checking:
```
convert[2, 1, -1, -2, 0]
(*  376.730 kg m^2/(s^3A^2)  *)
(*  FullForm: Quantity[376.730, ("Kilograms" ("Meters")^2)/(("Amperes")^2 ("Seconds")^3)]  *)
convert[-2, -1, 3, 0, 1]
(*  1.3842\[Times]10^-20 s^3K/(kg m^2)  *)
(*  FullForm: Quantity[1.3842\[Times]10^-20, ("Kelvins"*"Seconds"^3)/("Kilograms"*"Meters"^2)]  *)
convert[0, 0, 0, 0, 0]
(*  1.00000  *)
```
Notice that this code uses a curated source of consensus scientific values of the constants, and the output will change as those values change. Of relevance to the Challenge (and exemplified in the above samples), the gravitational constant is only 6.674 30(15) \*10^(-11) m^3 /(kg s^2), so is only known to four significant digits. This impacts the precision of length, mass, and time (except in combinations where this term cancels) in the Challenge, although the Challenge does not acknowledge this limitation of precision in those constants.
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~124~~ 101 bytes
*-23 bytes thanks to mazzy*
```
$t=1
$args|%{$t/=[math]::pow((174539e29,162874e3,523253e37,189007e13, 2502039161917e-44)[$i++],$_)}
$t
```
[Try it online](https://tio.run/##NYhBCoMwEEX3niKLaVGMNDOTGCN4EpHiItaCRdGAC@vZrSDl/cX7bxpXPy@9H4YDumo7IFQYQTu/lu9tg/Co6k8b@qYsp3GNY7TasPPkJOZUWO1ZGmIy7NlKLJxS1iNLMooUO8zRofWZ1kkN7zRtJDyTPYJw7NFdQCdIoMjOkVBXOO38LJTAK6g/xw8).
[Answer]
# Java 8, 118 bytes
```
Math M=null;(a,b,c,d,e)->M.pow(399674e26,e)/M.pow(174539e29,a)/M.pow(162874e3,b)/M.pow(523253e37,c)/M.pow(189007e13,d)
```
Port of [*@Noodle9*'s Python answer](https://codegolf.stackexchange.com/a/201792/52210), so make sure to upvote him!!
[Try it online.](https://tio.run/##hZDBjoIwEIbvPsUcS3ZAaBUkhn0DvHjc7KGU2RUXCpGiMRufnR3Q9Wra/O388zXp/Ed91v6x/BlNrfsecl3Z3wVAZR2dvrQh2E0lQNkORU1gBHdA46TFrGbWclbytgzfFiy5dgfIMzvU9RaWS3iLJBRXRz24FtyB5sI37WAd0zuwkMEoNBZosETy/Pc86NqLUGkaJyuSMXvLuxUlq7VKSaaon1YsN0wpLP6dtVRyrUglaJ7QJg3DhCKFpTdup092PFNloHfa8XFuqxIaDkDs3amy3x@foL379FMs0GSWLvNVzHMC7K@9oyZoBxd0/MLVVjSBDYyQGKHPW2LovWIZYlRhiNFLNsTH8h5J38Y/)
[Answer]
# TI-83 Basic, 62 tokens
Using list operations:
```
prod({5.72938ᴇ−35,6.13971ᴇ−9,1.91112ᴇ−43,5.29082ᴇ−19,3.99674ᴇ31}^Ans
```
where
```
prod(                 Multiply all list elements together (1 token)
     { ... }          Constants in list (59 tokens)
            ^         Power using 2 lists as arguments (1 token)
             Ans      Input list stored in answer variable (1 token)
```
Example:
```
| {2,1,-1,-2,0}    | Give input
|    {2 1 -1 -2 0} |
| prgmPLANCK       | Run program
|      376.7291131 | Result
```
Second example unfortunately returns 0, because of insufficient precision on calculator.
[Answer]
# [Fortran (GFortran)](https://gcc.gnu.org/fortran/), ~~95~~ 90 bytes
```
READ*,I,J,K,L,M
PRINT*,399674D26**M/174539D29**I/162874D3**J/523253D37**K/189007D13**L
END
```
[Try it online!](https://tio.run/##Jck7CsMwDADQPafwLGRsSbEdjQVlcH6U0At0SbcWQu/vBro9eMfn/J7Pt38df7S2jzcDrDjhjAuu3X2v2wNQVHPpjTPAGqj0SdRYAWqgzMM1AjCFxMJJTArAHGjQGIvRNUs3btaaZ@fJiYuOfg "Fortran (GFortran) – Try It Online")
Input on stdin, output on stdout.
*Thanks to @Noodle9 for saving 5 bytes by pointing out that using division instead of multiplication can shorten this.*
]