[Question]
  [
# Summary
Videos which are sped up every time a particular word is said exist for everything from [the Bee Movie](https://www.youtube.com/watch?v=JMG1Nl7uWko) to the classic [Rick Roll](https://www.youtube.com/watch?v=ZXpThNX9IRc). The goal for this challenge is to figure out how much you'd have to slow down the sped-up video in order to match the duration of the original video.
For example, the original Bee Movie has a duration of 95 minutes. The sped up version is 5:40 or ~5.667 minutes. 95/5.667 = 16.76. We'd have to play the sped up version 16.76x slower in order for the overall duration to match the original movie.
# Inputs
Your program must take in 3 inputs:
1. The duration of the original video (Bee Movie was 95 minutes)
2. The speedup factor per occurence (Bee Movie was 15% or .15)
3. A list of timestamps of occurrences (Bee movie has more than I care to look up/list)
The exact way these are passed in is flexible: 3 separate parameters is my default assumption, but if you want to take in a single list of values and pop the duration/speedup factor off the front that's fine, or take a single string in JSON or whatever format floats your boat, etc.
For the duration: seconds, minutes, or some builtin duration type are all fine.
For the speedup factor of the bee movie, any of 15, .15, or 1.15 could be used to represent the 15% speedup.
You can assume the occurrences are ordered in the most convenient manner, but there *can* be duplicate values (such as multiple characters talking over one another in a movie).
# Output
A scaling factor to make the durations of the original and sped-up video match. The exact format is flexible.
# Examples
```
{"duration": 10, "speedup-factor": 2, "occurrences": [1,2,3,4,5,6,7,8,9]} -> {"slowdown-factor": 5.004887585532747}
{"duration": 500, "speedup-factor": 1.15, "occurrences": [1,2,3, ..., 497, 498, 499]} -> {"slowdown-factor": 65.21739130434779}
{"duration": 100, "speedup-factor": 3, "occurrences": [0]} -> {"slowdown-factor": 3}
{"duration": 100, "speedup-factor": 3, "occurrences": [0, 0, 0]} -> {"slowdown-factor": 27}
{"duration": 100, "speedup-factor": 100, "occurrences": [99.99]} -> {"slowdown-factor": 1.0000990098}
```
Notes: First two generated programmatically with `100/(sum(1/(2**i) for i in range(10)))` and `500/(sum(1/(1.15**i) for i in range(500)))`. 4th example: 3 \* 3 \* 3 = 27x speedup, occurring right at the start of the video. Last example calculated by hand with `100/(99.99 + .01/100)`
# Note
I've kept most of the examples fairly simple, but I believe they cover all the relevant edge cases (a program which solves all of them should be totally correct). If I've left things ambiguous or difficult to parse, let me know and I'll add comments!
  
[Answer]
# [Python 2](https://docs.python.org/2/), 47 bytes
```
lambda m,r,l:m/reduce(lambda u,x:u/r+x-x/r,l,m)
```
[Try it online!](https://tio.run/##fdbNahxXFIXReZ6ih1JSsWrvU/0nyJMoHjixjAWWY4RFnKdXeikeBAKB5jZU9TfpVfee@vLX149/fO7Lh19@ffn07vG39@92j8vT8un28ebp/v3z7/dX368@L99un2@efvr287eby/3l8frlz48Pn@53uf3y9PD56@7D1Y8Pn788f726vn65yvpmXXa13J2X3WnZHZfdYdntl9227OZya9nl7fUPV/v19Zd5k8utu@18@fF2PlmOloNFdN4sY6kllku4nRQnxUlxUpwUJ8VJcVKcFCfFUXFUHBVHxVFxVBwVR8VRcVQcFAfFQXFQHBQHxUFxUBwUB8VesVfsFXvFXrFX7BV7xV6xV2yKTbEpNsWm2BSbYlNsik0xilGMYhSjGMUoRjGKUVRRRRVVVFFFFVVUUUUUUUQRBaktiiiiiCKKVbEqVsWqWBWrYlWsilWxXophPsyH@TAf5sN8mA/zYT7Mh/kwH@bDfJgP82E@zIf5MB/mw3yYD/NhPsyH@TAf5sN8mA/zYT7Mh/kwH@bDfJgP82E@zIf5MB/mw3yYD/NhPsyH@TAf5sN8mA/zYT7Mh/kwH@bDfJgP82E@zIf5MB/mw3yYD/NhPsyH@TAf5sN8mA/zYT7Mh/kwH@bDfJgP82E@zIf5MB/mw3yYD/NhPsyH@TAv8zIv8zIv8zIv8zIv8zIv8zIv8zIv8zIv8zIv8zIv8zIv8zIv8zIv8zIv8zIv8zIv8zIv8zIv8zIv8zIv8zIv8zIv8zIv8zIv8zIv8zIv8zIv8zIv8zIv8zIv8zIv8zIv8zIv8zIv8zIv8zIv8zIv8zIv8zIv8zIv8zIv8zIv8zIv8zIv8zIv8zIv8zIv8zIv8zIv8zIP8zAP8zAP8zAP8zAP8zAP8zAP8zAP8zAP8zAP8zAP8zAP8zAP8zAP8zAP8zAP8zAP8zAP8zAP8zAP8zAP8zAP8zAP8zAP8zAP8zAP8zAP8zAP8zAP8zAP8zAP8zAP8zAP8zAP8zAP8zAP8zAP8zAP8zAP8zAP8zAP8zAP8zAP8zAP8zAP8zAP8zAP8zAP8zAP8zAP8zBHThw4b9y0YbNGTRo0Z8yUITNGTBgwX7x04bJFSxYsV6xUoTJFShQoT5w0YbJESRIkR4wUITJE@DqdX18yvA4Y8Ea2IWysGpRGn2FmPBk4Roih4Jh3cDuKHa6OSwegI80h5dhxkDgabHbb14a0xWwa28CD7VH18HmcPCDIIWLxR1/@w/97xco/r1jz@jK2/vfKsvP51/XvX3fn85vz@e313w "Python 2 – Try It Online")
Takes timestamps sorted in descending order.
The idea is to compute the video duration as a polynomial in the inverse speedup rate `1/r` using [Horner's method](https://en.wikipedia.org/wiki/Horner%27s_method) with coefficients given by the sorted timestamps. This avoids needing to explicitly take the differences of consecutive timestamps. We then divide the duration of the original video by the resulting duration to get the desired slowdown factor.
**53 bytes**
```
f=lambda m,r,l:l==[]or r/(l.pop()*(r-1)/m+1/f(m,r,l))
```
[Try it online!](https://tio.run/##fdbNahxXFIXReZ6ihi2nLdU@u/rP4CcRHjgkxgZJFsIh5OmVXkoGgUCguQ1d9U161b2nnv/88fX707y@fvn48Pnxl18/L4/7l/3Dh4ePH@8/fX9ZXu52D7fP3593N@92L@9zc/f4c@6@7N5uurl5/ePrt4fflnx4fvn29GP5snv37en59x@765Vd1tt1v4zl/rJfzvvltF@O@@WwX7b90uul/ZJPNz/tDuvbnbnN9dL9drnevF3OlpPlaBFdNkstY4nlGm5nxVlxVpwVZ8VZcVacFWfFWXFSnBQnxUlxUpwUJ8VJcVKcFEfFUXFUHBVHxVFxVBwVR8VRcVAcFAfFQXFQHBQHxUFxUBwUm2JTbIpNsSk2xabYFJtiU1RRRRVVVFFFFVVUUcUoRjGKUYxiFKMYxShGEUUUUURBaosiiiiiiGJVrIpVsSpWxapYFatiVazXoszLvMzLvMzLvMzLvMzLvMzLvMzLvMzLvMzLvMzLvMzLvMzLvMzLvMzLvMzLvMzLvMzLvMzLvMzLvMzLvMzLvMzLvMzLvMzLvMzLvMzLvMzLvMzLvMzLvMzLvMzLvMzLvMzLvMzLvMzLvMzLvMzLvMzLvMzLvMzLvMzLvMzLvMzLvMzLvMzLvMzLvMzLvMzLvMzLvMzLfJgP82E@zIf5MB/mw3yYD/NhPsyH@TAf5sN8mA/zYT7Mh/kwH@bDfJgP82E@zIf5MB/mw3yYD/NhPsyH@TAf5sN8mA/zYT7Mh/kwH@bDfJgP82E@zIf5MB/mw3yYD/NhPsyH@TAf5sN8mA/zYT7Mh/kwH@bDfJgP82E@zIf5MB/mw3yYD/NhPsyH@TAf5sN8mA/zYT7Mh/kwH@bDfJgP82E@zMM8zMM8zMM8zMM8zMM8zMM8zMM8zMM8zMM8zMM8zMM8zMM8zMM8zMM8zMM8zMM8zMM8zMM8zMM8zMM8zMM8zMM8zMM8zMM8zMM8zMM8zMM8zMM8zMM8zMM8zMM8zMM8zMM8zMM8zMM8zMM8zMM8zMM8zMM8zMM8zMM8zMM8zMM8zMM8zMM8zMM8zMM8zMM8zMM8zMM8zJETB84bN23YrFGTBs0ZM2XIjBETBswXL124bNGSBcsVK1WoTJESBcoTJ02YLFGSBMkRI0WIDBG@Tee3lwyvAwa8kW0IG6sGpdFnmBlPBo4RYig45h3cjmKHq@PSAehIc0g5dhwkjgab3fa1IW0xm8Y28GB7VD18HicPCHKIWPzR1//w/16x8vcrVt9extb//rJffP71@z9f95fL7eXy6eYv "Python 2 – Try It Online")
An attempt to write the function fully recursively. While the new duration itself has a clean recursive expression, we want to get the slowdown factor which divides the original duration by the new duration, and this is messier to express recursively.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 10 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
;ŻIṚḅ⁵İ¤÷@
```
A full program accepting `timestamps original-duration speedup-factor` which prints the necessary slowdown-factor.
**[Try it online!](https://tio.run/##ATYAyf9qZWxsef//O8W7SeG5muG4heKBtcSwwqTDt0D///9bMSwyLDMsNCw1LDYsNyw4LDld/zEw/zI "Jelly – Try It Online")**
### How?
Get a list of the durations of film separated by the occurrences (including any zero-length segments), reverse and convert from base slowdown-factor (where this slowdown-factor is the inverse of the given `speedup-factor`), then divide the `original-duration` by that.
```
;ŻIṚḅ⁵İ¤÷@ - Main link: timestamps S, original-duration T
;          - concatenate (T) to (S) -> S+[T]
 Ż         - prefix with a zero (the start of the film) -> [0]+S+[T]
  I        - deltas -> [S[1]-0, S[2]-S[1], ..., S[n]-S[n-1], T-S[n]]
   Ṛ       - reverse -> [T-S[n], S[n]-S[n-1], ..., S[2]-S[1], S[1]-0]
       ¤   - nilad followed by link(s) as a nilad:
     ⁵     -   3rd argument = speedup-factor
      İ    -   inverse -> 1/speedup-factor - call this F
    ḅ      - convert from base -> (T-S[n])×F^(n)+(S[n]-S[n-1])×F^(n-1)+...+(S[2]-S[1])×F^1+(S[1]-0)×F^0
         @ - using swapped arguments (with implicit right argument T):
        ÷  -   division -> T/((T-S[n])×F^(n)+(S[n]-S[n-1])×F^(n-1)+...+(S[2]-S[1])×F^1+(S[1]-0)×F^0)
           - implicit print
```
[Answer]
# [Haskell](https://www.haskell.org/), 32 bytes
```
m%r=(m/).foldr(\x u->u/r+x-x/r)m
```
[Try it online!](https://tio.run/##fdbNThxXEIbhva@iF7E0KA101ff1nxRyI4QFcoxjZcZBA5ZY5NozqbfIIlKkSBa24C0w5@lzTv/2@PL75@Pxcjl9PN8dTrdXN09/HH89H355G75f//z99vzj2/Xb7fnqdHn9/PL6MtwN94eYbqZxSD7cR/1jHDQOHod5HJZxWMdhG4f94Wo8zFOXcRPz/6VVUNXXo4KoIiphJiqKqqKyqC75uXyf6rK6rC6ry@qyuqwuq1N1qk78wOpUnapTdapO1ak6V@fqXJ35n1Xn6lydq3N1rm6ubq5urm6ubuZXqG6ubq5urm6ubqluqW6pbqluqW7hd61uqW6pbqlurW6tbq1urW6tbq1uZVGqW6tbq9uq26rbqtuq26rbqtuq21i96rbq9ur26vbq9ur26vbq9ur26naWudeZhZ5Y6YmlnljricWeWO2J5Z5Y74kFn5h4p2GicVqnedqngVqoiTAKkCJbkwmcAqhAKqAKrAKsQCvgCrxC/QAwAVlgFqAFagFb4BbABXIBXbifGSbQC/gCvwAwEAwIA8MAMVCMuR8zJoAMJAPKwDLADDQDzsAzAI2ln0wmMA1QA9WANXANYAPZgDawjbUfZibgDXwD4EA4IA6MA@RAOWCOrZ9/JpAOqAPrADvQDrgD7wA8EI@9t0zvGTYN5ol5Yp6YJ@aJeWKemCfmGb3NmMA8MU/ME/PEPDFPzLP3ZW/M953JRO/N3py9O3t79v7sDYp5Yp6Yp3ozM4F5Yp6YJ@aJeWKemCfmiXm69z8TmCfmiXlinpgn5ol5Yp6Y59xHBhOYJ@aJeWKemCfmiXlinpjn0qcME5gn5ol5Yp6YJ@aJeWKemOfaBxMTmCfmiXlinpgn5ol5Yp6Y59ZnGROYJ@aJeWKemCfmiXlinpjn3sdfn38cgJgLc2EuzIW5MBfmwlyYK/rIZAJzYS7MhbkwF@bCXJgLc2WfskxgLsyFuTAX5sJcfSr3sdzn8vvBzEQfzX029@Hcp3Mfz5gLc2EuzOU@y5nAXJgLc2EuzIW5MBfmwlxzH/9MYC7MhbkwF@bCXJgLc2GupW8MJjAX5sJcmAtzYS7Mhbkw19qXDBOYC3NhLsyFuTAX5sJcmGvre4kJzIW5MBfmwlyYC3NhLsy191XWdxmXGebG3Jgbc2NuzI25MTfmjr7@mMDcmBtzY27MjbkxN@bG3Nk3JhOYG3NjbsyNuTE35sbcmFt9yTKBuTE35sbcmLvv5L6U@1bua/n9Xmaib@a@mvtu7ssZc2NuzI25MffcVzkTmBtzY27MjbkxN@bG3Jh76dufCcyNuTE35sbcmBtzY27MvfYLAxOYG3NjbsyNuTE35sbcmHvrdwwmMDfmxtyYG3NjbsyNuTH33q8l/YoV769Y6pex6b@fGQf@/Ovz//x1v@83fIeHD093h49XH06PX7/Vy93z@eu31@GH4f5pOA3n4Tj8ORxO43k8Xv103S@AD5e/Pj0dH7@8XK4/PT//DQ "Haskell – Try It Online")
Port of [my Python answer](https://codegolf.stackexchange.com/a/207815/20260).
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/) 18.0, 15 [bytes](https://github.com/abrudz/SBCS)
```
÷⊥⍥÷∘(⊃÷2-/,∘0)
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNrShJzUtJTfn/qG@qi2fYo7YJhv8Pb3/UtfRR71Ig3TFD41FX8@HtRrr6OkCOgeb/NKCSR719QNFD640ftU0E6gsOcgaSIR6ewf@NFNIUDA0ULBUsFMwVzBRMFUwUjBWMFAy5DPUMTYFyj3r2PurdbGpgwGUMVmmggMQCQS4QC8K3tNSztAQA "APL (Dyalog Extended) – Try It Online")
# [J](http://jsoftware.com/), 16 bytes
```
#.&.:%{.%2-/\,&0
```
[Try it online!](https://tio.run/##TYpBCsIwFET3OcVDaYvQfH/SRvsDrgRXrly7Ltgr9PBpqhsZZnjDzFIOQjdzy3Q9Sq72wv31fJSjtJKbVZroz@@@1XIqkZmgGBNXLiRGBiLBBQmpbknVf6SmG75P5Y92uZ1@3UzMNg "J – Try It Online")
Inline tacit functions that take the speedup on the left, and `duration,occurrences` on the right in descending order.
Both code use the same algorithm:
```
÷⊥⍥÷∘(⊃÷2-/,∘0)
    ∘(        )  On the right argument,
           ,∘0   Append zero
        2-/      Take pairwise differences
      ⊃÷         Divide each number above by the head
                 (division by zero is handled by system setting ⎕DIV←1,
                 which gives 0.)
 ⊥⍥÷             Take reciprocal of both args and do base conversion
÷                Take reciprocal of that
#.&.:%{.%2-/\,&0
\----/\--------/  2-train, so apply the right part on the right arg
             ,&0  Append zero
         2-/\     Take pairwise differences
      {.%         Divide each number above by the head
                  (division by zero gives built-in infinity,
                  whose reciprocal is again zero.)
  &.:%            Apply % (reciprocal) to both args
#.                Base conversion
  &.:%            Undo %, which is the same as applying % again
```
[Answer]
# [J](http://jsoftware.com/), 20 bytes
Takes the speedup on the left, and the occurrences, length on the right. Calculates the speedup factor.
```
{:@]%%@[#.2-/\0|.@,]
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/q60cYlVVHaKV9Yx09WMMavQcdGL/a/43UkhT0DDUztSz1NRRMDTgMtQzNIUJmVgCBU0NDLiMgSIGOoYwFgiCeUAM5Fta6llagvgA "J – Try It Online")
### How it works
```
 {:@]%%@[#.2-/\0|.@,] 2 f 50 100
               0   ,] prepend 0:   0 50 100
                |.@   reverse:     100 50 0
           2-/\       differences: 50 50
      %@[             1/n:         0.5
         #.           to base:     75
 {:@]                 last element:100
     %                100/75:      1.3333
```
[Answer]
# [R](https://www.r-project.org/), 49 bytes
```
function(d,f,o)d/diff(c(0,o,d))%*%f^-c(0,seq(!o))
```
[Try it online!](https://tio.run/##RYyxDsIwDER3vqIMlWzkFifQIQh@haXGKEsNpHx/cJAQsiz5nu/uVe2xZlsKSL7ntVxixI1256Gr@l7m9gIhJUPZS1aFGZiMBLHf9Xodmiy3J2wNsSoEpkjhlLwDJmYKY5hcH9OXBCcH4v/Z0j74I21TGt1dPw "R – Try It Online")
Takes the original `d`uration, the speedup `f`actor, and the `o`currences.
Calculates the time between each occurrence `diff(c(0,o,d))`, then multiplies them with the appropriate speedup factors `f^-c(0,seq(!o))` and sums them as a dot product `%*%`. Finally divides `d` by that result.
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 14 bytes
```
chQu+c-GHeQHEh
```
[Try it online!](https://tio.run/##K6gsyfj/PzkjsFQ7WdfdIzXQwxXI1zA0MNAz0FEw1jPQ5Io2iP2XX1CSmZ9X/F83BQA "Pyth – Try It Online")
Port of [@xnor's answer](https://codegolf.stackexchange.com/a/207815/91267) to [Pyth](https://github.com/isaacg1/pyth)
## Explanation
```
chQu+c-GHeQHEh
 hQ             : First element from first input
c               : divided by
   u            : value got by reducing from left to right
            E   : the second input
             h  : with default value as first input
                : on lambda G, H:
      -GH       :    G - H
     c   eQ     :    divided by second element from first input
    +      H    :    plus H
```
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), ~~35~~ 33 bytes
```
s#/Fold[#/s+#2&,{##}-{##2,0}]&
```
[Try it online!](https://tio.run/##RU1LCsIwFNz3Gg@ycbTpT81CiRuXouuQRdAWC1ahrQsJuYQ38IQeISYiuJhh5s0MrzPjue7M2B6Nb1Z@eD9flG5vl5OidJhQzmCJ3DRQDu4084d7W49y37fXUX2j9U41irQKDa01k1LaxObIOASWWGCOCiUKhJNDYrNZVqHiHJu@Nw9FDKUQsJFCTsR0bBVhz8PDv8TPRhMhxEwIlzj/AQ "Wolfram Language (Mathematica) – Try It Online")
Takes input as `f[s][d,o]`, where `o` is a sequence of arguments in decreasing order.
[Answer]
# [Io](http://iolanguage.org/), 49 bytes
Port of xnor's Python answer.
```
method(m,r,l,m/l prepend(m)reduce(u,x,u/r+x-x/r))
```
[Try it online!](https://tio.run/##hdbNahxXFIXRuZ@ihhKpWLXPruqfQN4ks1gmBvkH2Qa/vaIlmySDhEBzG9T9adCr7j333cent8svvy6/Pb2///LHxzc379fH9WF9f/ewfHq8/3T/4fkvt4/3b77@fn/zdf22fr17/Onbz9/uHm9vn97eZHu9rctYHt59/nJzXZfLupzX5bQux7rs69Lnj9clt7efHt99@PLw4dWrtzfH9pLldY4f3X59LvfrxXK2nCz@w3W31DKWWJ7j/aK4KC6Ki@KiuCguioviorgozoqz4qw4K86Ks@KsOCvOirPipDgpToqT4qQ4KU6Kk@KkOCkOxaE4FIfiUByKQ3EoDsWh2BW7Ylfsil2xK3bFrtgVu6KKKqqooooqqqiiiipGMYpRjGIUoxjFKEYxiiiiiCIKWnsUUUQRRRSbYlNsik2xKTbFptgUm2J7Lsq8zMu8zMu8zMu8zMu8zMu8zMu8zMu8zMu8zMu8zMu8zMu8zMu8zMu8zMu8zMu8zMu8zMu8zMu8zMu8zMu8zMu8zMu8zMu8zMu8zMu8zMu8zMu8zMu8zMu8zMu8zMu8zMu8zMu8zMu8zMu8zMu8zMu8zMu8zMu8zMu8zMu8zMu8zMu8zMu8zMu8zMu8zMu8zMu8zMu8zIf5MB/mw3yYD/NhPsyH@TAf5sN8mA/zYT7Mh/kwH@bDfJgP82E@zIf5MB/mw3yYD/NhPsyH@TAf5sN8mA/zYT7Mh/kwH@bDfJgP82E@zIf5MB/mw3yYD/NhPsyH@TAf5sN8mA/zYT7Mh/kwH@bDfJgP82E@zIf5MB/mw3yYD/NhPsyH@TAf5sN8mA/zYT7Mh/kwH@bDfJgP82E@zIf5MB/mwzzMwzzMwzzMwzzMwzzMwzzMwzzMwzzMwzzMwzzMwzzMwzzMwzzMwzzMwzzMwzzMwzzMwzzMwzzMwzzMwzzMwzzMwzzMwzzMwzzMwzzMwzzMwzzMwzzMwzzMwzzMwzzMwzzMwzzMwzzMwzzMwzzMwzzMwzzMwzzMwzzMwzzMwzzMwzzMwzzMwzzMwzzMwzzMwzzMwzzMwxw5ceC8cdOGzRo1adCcMVOGzBgxYcB88dKFyxYtWbBcsVKFyhQpUaA8cdKEyRIlSZAcMVKEyBDhy3R@uWS4DhjwRrYhbKwalEafYWY8GThGiKHgmHdwO4odro5LB6AjzSHl2HGQOBpsdtvXhrTFbBrbwIPtUfXweZw8IMghYvFDP/@G/33fWv5x4cr3C1f/uqdt//f5unj967d@vH2/711fX69/f@vpTw "Io – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~15~~ 11 bytes
*-4 bytes thanks to @KevinCruijssen's port of @JonathanAllan's Jelly answer*
```
ª0š¥RIzβ¹s/
```
[Try it online!](https://tio.run/##yy9OTMpM/f//0CqDowsPLQ3yrDq36dDOYv3//w0NuKINdYx0jHVMdEx1zHTMdSx0LGO5jAA "05AB1E – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 18 bytes
```
¤UćV0š¥εyYNm/}OXs/
```
Explaination:
```
¤UćV0š¥εyYNm/}OXs/
¤U                       Extract tail and save duration in X
  ćV                     Extract head and save speedup factor in Y
    0š                   Prepand 0 to the timestamps list
      ¥                  Deltas
       ε     }           map
        y                foreach element
         YNm             factor ** index of element
            /            element / (factor ** index of element) => this will be the duration of this section
              O          sum all up
               Xs        push duration before the result
                 /       division
```
### Input:
A list of numbers in the format: `[speedup_factor, ... timestamps_in_minutes ... , duration_in_minutes]`
### Output:
How much we need to slow down in minutes.
[Try it online!](https://tio.run/##yy9OTMpM/f//0JLQI@1hBkcXHlp6bmtlpF@ufq1/RLH@///RRjqGOkY6xjomOqY6ZjrmOhY6ljqGBrEA)
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~74~~ 69 bytes
Saved 5 bytes thanks to [ceilingcat](https://codegolf.stackexchange.com/users/52904/ceilingcat)!!!
```
float f(d,s,o,n,a)float*o,s,a;{for(a=d;n--;)a=a/s+o[n]-o[n]/s;s=d/a;}
```
[Try it online!](https://tio.run/##XZLbbqMwEIbveQpkKRKQoTGnBdax9mLVp0hQ5QbYGlFTYRRFG/HsqW0OKsEyMP7@GY89c/H/XS6PR912bLBrpwQJHQhgrlnxOmUzcq@73mG0JML3icsoO8h9dxKFr18HSSQtD4yMj6@ei8FplT931Z/XTp6cYsKPguz33DWS2kE7uSsR8D/IRr8RgvbEC5eM1pTHUMnhTZ4Keg8hUiPAeATLNo9hHdYwAI1jSOAXpJBB/iQKtejZMzKLoMYTiDXIc8jXMN4ETCLztjBHnr/R/I3XWNXtq7oNVal9kheM4yxLkyxJojCNU5VtmEKgljHOczWzkVgmgtEHWJ90mSqkQUIjyf9XXb0c/jCZ3pLUhoZbGm5ptKXRlsZbGqv0Lh@s93qdAzrfXsPzLf@rZoLgpxkhpWxAEOuTceGU7t2ydeUbVfnmOG@xXM2yx2Krvmi0g13S@S6aAgSdD98URKGpLySdO0MJvI4u5VHWla6960JF1yooVFbtwGjN3qVz9StXR1ubsLZ38iwQXKE/Gd3xJSi0ZLTGxzc "C (gcc) – Try It Online")
Port of [xnor](https://codegolf.stackexchange.com/users/20260/xnor)'s [Python answer](https://codegolf.stackexchange.com/a/207815/9481).
]