[Question]
  [
You should write a program or function that given a list of positive integers multiplies each element with the smallest positive integer possible to create a strictly increasing list.
For example if the input is
```
5 4 12 1 3
```
the multiplications will be
```
5*1=5 4*2=8 12*1=12 1*13=13 3*5=15
```
and the output will be the increasing list
```
5 8 12 13 15
```
## Input
* A list of positive integers containing at least 1 element
## Output
* A list of positive integers
## Examples
```
9 => 9
1 2 => 1 2
2 1 => 2 3
7 3 => 7 9
1 1 1 1 => 1 2 3 4
5 4 12 1 3 => 5 8 12 13 15
3 3 3 8 16 => 3 6 9 16 32
6 5 4 3 2 1 => 6 10 12 15 16 17
9 4 6 6 5 78 12 88 => 9 12 18 24 25 78 84 88
8 9 41 5 12 3 5 6 => 8 9 41 45 48 51 55 60
15 8 12 47 22 15 4 66 72 15 3 4 => 15 16 24 47 66 75 76 132 144 150 153 156
```
This is code golf so the shortest program or function wins.
*Fun fact: the last element of the output for the input `N, N-1, ... ,1` seems to be the `(N+1)th` element of the sequence [A007952](http://oeis.org/A007952). If you find a proof, you are welcomed to include it in your golf answer or post it as a comment.*
  
[Answer]
## [Jelly](https://github.com/DennisMitchell/jelly), ~~6~~ 5 [bytes](https://github.com/DennisMitchell/jelly/blob/master/docs/code-page.md)
```
:‘×µ\
```
First Jelly answer ~~before @Dennis wakes up and beats me.~~ [Try it online!](http://jelly.tryitonline.net/#code=OuKAmMOXwrVc&input=&args=WzMsIDMsIDMsIDgsIDE2XQ)
### Explanation
```
:          Integer division, m//n
 ‘         Increment, (m//n+1)
  ×        Multiply, (m//n+1)*n
   µ       Turn the previous links into a new monadic chain
    \      Accumulate on the array
```
Thanks to @Dennis for -1 byte.
[Answer]
# JavaScript (ES6), 28
**Edit** As suggested by @Patrick Roberts, `p` can be a uninitialized parameter. Same byte count but avoid using a global variable
```
(a,p)=>a.map(n=>p=n*-~(p/n))
```
**TEST**
```
f=(a,p)=>a.map(n=>p=n*-~(p/n))
console.log=x=>O.textContent+=x+'\n'
;[
[[9], [ 9]],
[[1, 2], [ 1, 2]],
[[2, 1], [ 2, 3]],
[[7, 3], [ 7, 9]],
[[1, 1, 1, 1], [ 1, 2, 3, 4]],
[[5, 4, 12, 1, 3], [ 5, 8, 12, 13, 15]],
[[3, 3, 3, 8, 16], [ 3, 6, 9, 16, 32]],
[[6, 5, 4, 3, 2, 1], [ 6, 10, 12, 15, 16, 17]],
[[9, 4, 6, 6, 5, 78, 12, 88], [ 9, 12, 18, 24, 25, 78, 84, 88]],
[[8, 9, 41, 5, 12, 3, 5, 6], [ 8, 9, 41, 45, 48, 51, 55, 60]],
[[15, 8, 12, 47, 22, 15, 4, 66, 72, 15, 3, 4], [ 15, 16, 24, 47, 66, 75, 76, 132, 144, 150, 153, 156]]
].forEach(t=>{
  var i=t[0],k=t[1],r=f(i),ok=(k+'')==(r+'')
  console.log(i + ' => ' + r + (ok?' OK':'FAIL expecting '+x))
})
```
```
<pre id=O></pre>
```
[Answer]
# Python 2, 67 64 bytes
First try at code-golfing, so tips are appreciated.
```
def m(l):
 for x in range(1,len(l)):l[x]*=l[x-1]/l[x]+1
 print l
```
[Answer]
# PHP, ~~55~~ ~~46~~ ~~42~~ 41 bytes
Uses ISO 8859-1 encoding.
```
for(;$a=$argv[++$i];)echo$l+=$a-$l%$a,~ß;
```
Run like this (`-d` added for aesthetics only):
```
php -d error_reporting=30709 -r 'for(;$a=$argv[++$i];)echo$l+=$a-$l%$a,~ß;' 10 10 8
```
* Saved 1 byte thx to Ismael Miguel.
* Saved 8 bytes by using modulo instead of floor
* Saved 4 bytes thx to Ismael Miguel (for instead of foreach)
* Saved a byte by using `~ß` to yield a space.
[Answer]
# Haskell (~~30~~ ~~28~~ 25 bytes)
```
scanl1(\x y->y*div x y+y)
```
### Expanded version
```
f :: Integral n => [n] -> [n]
f xs = scanl1 increaseOnDemand xs
 where
   increaseOnDemand :: Integral n => n -> n -> n
   increaseOnDemand acc next = next * (1 + acc `div` next)
```
### Explanation
`scanl1` enables you to fold a list and accumulate all intermediate values into another list. It's a specialization of `scanl`, which has the following type:
```
scanl  :: (acc  -> elem -> acc)  -> acc -> [elem] -> [acc]
scanl1 :: (elem -> elem -> elem) ->        [elem] -> [elem]
scanl1 f (x:xs) = scanl f x xs
```
Therefore, all we need is a suitable function that takes two the last element of our list (`acc` in the expanded version) and the one we wish to process (`next` in the expanded version) and return a suitable number.
We can easily derive this number by dividing the accumulator through the next one and flooring the result. `div` takes care of that. Afterwards, we simply have to add `1` to ensure that the list is actually increasing (and that we don't end up with `0`).
[Answer]
# C++, ~~63~~ ~~60~~ 57 bytes
```
void s(int*f,int*e){for(int c=*f;++f!=e;c=*f+=c/ *f**f);}
```
Works inplace given a range `[first, last)`. Originally written as template variant, but that was longer:
```
template<class T>void s(T f,T e){for(auto c=*f;++f!=e;c=*f+=c/ *f**f);}
```
### Extended version
```
template <class ForwardIterator>
void sort(ForwardIterator first, ForwardIterator last){
    auto previous = *first;
    for(++first; first != last; ++first){
        auto & current = *first;
        current += current * (current / previous);
        previous = current;
    }
}
```
[Answer]
## Mathematica, ~~36~~ 32 bytes
```
 #2(Floor[#1/#2]+1)&~FoldList~#&
```
## Test
```
#2(Floor[#1/#2]+1)&~FoldList~#& /@ {{5, 4, 12, 1, 3}, 
   {15, 8, 12, 47, 22, 15, 4, 66, 72, 15, 3, 4}}
(* {{5, 8, 12, 13, 15}, {15, 16, 24, 47, 66, 75, 76, 132, 144, 
  150, 153, 156}} *)
```
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 12 bytes
```
{≤.;?%0∧}ᵐ<₁
```
Weird enough trying to multiply each variable by a number will start at trying to multiply by 2 and not 0 or 1. This seems to work though and beats both other Brachylog implementations
# Explanation
```
{       }ᵐ          --  Map each number
 ≤.                 --      to a number greater or equal to the original
  .;?%0             --      and a multiple of the original
       ∧            --      no more constraints
          <₁        --  so that the list is strictly increasing
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/r/v/pR5xI9a3tVg0cdy2sfbp1g86ip8f//aENTBQsFQyMFE3MFIyMFIM9EwcxMwRzMNFYwif0fBQA "Brachylog – Try It Online")
[Answer]
## CJam, 13 bytes
```
q~{\_p1$/)*}*
```
Input as a CJam-style list. Output is linefeed separated.
[Test it here.](http://cjam.aditsu.net/#code=q~%7B%5C_p1%24%2F)*%7D*&input=%5B15%208%2012%2047%2022%2015%204%2066%2072%2015%203%204%5D)
### Explanation
```
q~    e# Read and evaluate input.
{     e# Fold this block over the list (i.e. "foreach except first")...
  \   e#   Swap with previous value.
  _p  e#   Duplicate and print previous value.
  1$  e#   Copy current value.
  /   e#   Integer division.
  )*  e#   Increment and multiply current value by the result.
}*
```
The final value is left on the stack and printed automatically at the end.
[Answer]
## Perl, 17 + 3 = 20 bytes
```
$p=$_*=$==1+$p/$_
```
Requires `-p` and `-l` flags:
```
$ perl -ple'$p=$_*=$==1+$p/$_' <<< $'15\n8\n12\n47\n22\n15\n4\n66\n72\n15\n3\n4'
15
16
24
47
66
75
76
132
144
150
153
156
```
Explanation:
```
# '-p' reads each line into $_ and auto print
# '-l' chomp off newline on input and also inserts a new line when printing
# When assigning a number to `$=` it will automatic be truncated to an integer
# * Added newlines for each assignment 
$p=
  $_*=
    $==
      1+$p/$_
```
[Answer]
## Python (3.5), ~~63~~ 62 bytes
```
def f(a):
 r=[0]
 for i in a:r+=i*(r[-1]//i+1),
 return r[1:]
```
## Test
```
>>> print('\n'.join([str(i)+' => '+str(f(i)) for i in [[9],[1,2],[2,1],[7,3],[1,1,1,1],[5,4,12,1,3],[3,3,3,8,16],[6,5,4,3,2,1],[9,4,6,6,5,78,12,88],[8,9,41,5,12,3,5,6],[15,8,12,47,22,15,4,66,72,15,3,4]]]))
[9] => [9]
[1, 2] => [1, 2]
[2, 1] => [2, 3]
[7, 3] => [7, 9]
[1, 1, 1, 1] => [1, 2, 3, 4]
[5, 4, 12, 1, 3] => [5, 8, 12, 13, 15]
[3, 3, 3, 8, 16] => [3, 6, 9, 16, 32]
[6, 5, 4, 3, 2, 1] => [6, 10, 12, 15, 16, 17]
[9, 4, 6, 6, 5, 78, 12, 88] => [9, 12, 18, 24, 25, 78, 84, 88]
[8, 9, 41, 5, 12, 3, 5, 6] => [8, 9, 41, 45, 48, 51, 55, 60]
[15, 8, 12, 47, 22, 15, 4, 66, 72, 15, 3, 4] => [15, 16, 24, 47, 66, 75, 76, 132, 144, 150, 153, 156]
```
## Previous solution
some recursive solutions but larger 
```
(68 bytes) f=lambda a,i=0:[i,*f(a[1:],a[0]*(i//a[0]+1))][i==0:]if a!=[]else[i]
(64 bytes) f=lambda a,i=0:a>[]and[i,*f(a[1:],a[0]*(i//a[0]+1))][i<1:]or[i]
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 37 bytes
```
o(int*_){for(;*++_;)*_*=_[~0]/ *_+1;}
```
[Try it online!](https://tio.run/##bVDLasMwEDw3X2EMBUneUst6WEGkxfmCHHJLgykuKTnULml6Ms6vuyspbu24GIR3dmZ3dqqH96rq@4Yc6zMraXtoTsSyJCktZSVblbtLun@MWJlw2/UbzyoC6/OExYHEbUwtKywd6vs3iIEVSULtAHUvNZK6xTbowb1r2g7tKIqwvSEFtY17Bvzy9IsP0Oo5QGuEvs9fJPZzP16PNaHt4m5L3IbdnrZLSDsYF9SO2xyyMSGUU0oGfEzJQMwoucfgr/xvUfhulgmQM6pCjLutk6EKjEcFcDWTCHAfEvRYIkCjE8TE/CoNbo2Am@s08NSvUU7H85luiSoNTp17P8ZMA3ZaA5mEzDOMDIzpEIO2JMcZ3CWgYOL62pToz4BCFvbTeZ7XPGQOmbeLtjTk/jeECiMq3oKWkOs4aAxPw0y4xKAV3qtcqDrs6Pof "C (gcc) – Try It Online")
[Answer]
# TI-Basic, ~~43~~ ~~40~~ 37 bytes
```
Prompt A
For(I,1,dim(ʟA
ʟA(I)(1+int(Ans/ʟA(I→ʟA(I
End
ʟA
```
-6 bytes thanks to [MarcMush](https://codegolf.stackexchange.com/users/98541/marcmush).
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 54 bytes
```
:_{h_.|[L:T],LhH,(T_,IH;0:$Ie*H=:T>I),Lb:I:1&:[I]rc.}.
```
### Explanation
```
:_{...}.                § Call sub-predicate 1 with [Input, []] as input. Unify its output
                        § with the output of the main predicate
§ Sub-predicate 1
h_.                     § If the first element of the input is an empty list, unify the
                        § output with the empty list
|                       § Else
[L:T],LhH,              § Input = [L,T], first element of L is H
    (T_,IH              §     If T is the empty list, I = H
    ;                   §     Else
    0:$Ie*H=:T>I),      §     Enumerate integers between 0 and +inf, stop and unify the
                        §     enumerated integer with I only if I*H > T
Lb:I:1&                 § Call sub-predicate 1 with input [L minus its first element, I]
:[I]rc.                 § Unify the output of the sub-predicate with
                        § [I|Output of the recursive call]
```
[Answer]
# Pyth, 11
```
t.u*Yh/NYQ0
```
[Test Suite](http://pyth.herokuapp.com/?code=t.u%2AYh%2FNYQ0&input=%5B5%2C%204%2C%2012%2C%201%2C%203%5D&test_suite=1&test_suite_input=%5B9%5D%0A%5B1%2C%202%5D%0A%5B2%2C%201%5D%0A%5B7%2C%203%5D%0A%5B1%2C%201%2C%201%2C%201%5D%0A%5B5%2C%204%2C%2012%2C%201%2C%203%5D%0A%5B3%2C%203%2C%203%2C%208%2C%2016%5D%0A%5B6%2C%205%2C%204%2C%203%2C%202%2C%201%5D%0A%5B9%2C%204%2C%206%2C%206%2C%205%2C%2078%2C%2012%2C%2088%5D%0A%5B8%2C%209%2C%2041%2C%205%2C%2012%2C%203%2C%205%2C%206%5D%0A%5B15%2C%208%2C%2012%2C%2047%2C%2022%2C%2015%2C%204%2C%2066%2C%2072%2C%2015%2C%203%2C%204%5D&debug=0)
Does a cumulative reduce, a reduce that returns all intermediate values, starting with `0`. Since the input is guaranteed to contain only positive integers, this is ok. In each step, we take the old value, divide it by the new value and add `1`, then we multiply by the new value.
[Answer]
# C, 79 bytes
```
p;main(x,v)char**v;{for(;*++v;printf("%d ",p=((x+p-1)/x+!(p%x))*x))x=atoi(*v);}
```
## Ungolfed
```
p; /* previous value */
main(x,v) char**v;
{
    /* While arguments, print out x such that x[i] > x[i-1] */
    for(;*++v; printf("%d ", p = ((x+p-1)/x + !(p%x)) * x))
        x = atoi(*v);
}
```
[Answer]
## PowerShell, 26 bytes
```
$args[0]|%{($l+=$_-$l%$_)}
```
Takes input as an explicit array, e.g., `> .\sort-by-multiplying.ps1 @(6,5,4,3,2,1)` via `$args[0]`.
We then for-loop over that with `|%{...}` and each iteration perform *magic*. Nah, just kidding, we use the same modulo trick as other answers (props to @aross because I spotted it [there](https://codegolf.stackexchange.com/a/71553/42963) first).
The encapsulating parens `(...)` ensure that the result of the math operation is placed on the pipeline, and thus output. If we left those off, nothing would be output since the `$l` variable is garbage-collected after execution finishes.
### Example
```
PS C:\Tools\Scripts\golfing> .\sort-by-multiplying.ps1 @(8,9,1,5,4)
8
9
10
15
16
```
[Answer]
# [Julia 1.0](http://julialang.org/), 27 bytes
```
!L=(x=0;L.|>i->x=(x÷i+1)i)
```
[Try it online!](https://tio.run/##PU9LboMwFNz7FBMWEagU4S@mFey6qJRLkIZIrhBFhEoseq8eoAejz4@0tmSP38zzzHv/HEIn1207nJp0bcrnU/HVhsd2pdfPd3iQWci268eMgDBi7rvLEMb@lmYCtLr8jAa3aQhLkfKVhhxJ0yZZtv8zdfOtL9LXccnD3jNTx6FjOM1hXIYx7dC0mP/oQ4Mzjsd/NnlZp/5t6S9PSHKcM9GPl62OLbWQUBHQJRSdBBW0qKAjrFiw711EdSMsDGRUs8jC80tDWqERNxVcpDQc6oi1Eg6xTePu4iBLbrORl5WoiXWIqor/854DssZDGShmvCFGeCKMJK2MiSzY7V405ONhiaV6KeQ9n6mg2I5sHCqGNAzPxRnIgjSRIyOKpEliaFBLOW0czv0C "Julia 1.0 – Try It Online")
[Answer]
# [Factor](https://factorcode.org), 35 bytes
```
[ 0 [ tuck /i 1 + * ] accumulate* ]
```
[Attempt This Online!](https://ato.pxeger.com/run?1=VY3NDsFAFIUjsepTnMSO-JkO7eABxMZGrMRiMhkhtKpmFiJ9EptueCeexu2UYu7innPPlzPX-1oqc0jzZ62-mE9nkxF2Oo31HpE0G5z00epY6ROSVBtzTtJtbDD2vIsHehcMkb0Vg19pn9xHh-A_TDkfP0AfrIC_CHcjwILqFDiO_7UO6RK4JBRFhRBVJIqQUUJnTutbxAZwcD-E7xeOOgKETnIymZfdrFm3xaOxRA9LGKt26G7p3xaaWEEqZSO7l0aTK9FbJBN0Sp3n5X4B)
[Answer]
# [PARI/GP](https://pari.math.u-bordeaux.fr), 25 bytes
```
a->i=0;[i=c*(i\c+1)|c<-a]
```
[Attempt This Online!](https://ato.pxeger.com/run?1=LY9BCsIwEEWvErpqdAKmaZMUbS9Sg4RCJSASSl0I3sRNQcQzuPMa3saZRgby_7yfH8j9Ff0YDsc4PwbWPC_TIOzbizY0m20Xmn6Vh32_lvzW74R3Kf9-fIyna-6ZaFkcw3lCm9GSsSH3nAPrutrhKaEgKUCSGFAJLkO2ghIkpilQQGNBato0UKrgX65x0UDQWOpYS9QCcokQiUJZmrKC5UppoMA2PaM1mMUqKJ3j6R_znPQH)
[Answer]
# [Desmos](https://desmos.com/calculator), 78 bytes
```
n->min(n,i.length)+1,o->join(o,i[n]floor(o[n-1]/i[n]+1))
i=\ans_0
n=2
o=[i[1]]
```
[Try It On Desmos!](https://www.desmos.com/calculator/bozvnxcqyl)
[Try It On Desmos! - Prettified](https://www.desmos.com/calculator/z0abv2uhes)
[Answer]
# [Rust](https://www.rust-lang.org/), 59 bytes
```
|mut l:Vec<u8>|{for i in 1..l.len(){l[i]*=l[i-1]/l[i]+1};l}
```
[Try it online!](https://tio.run/##fc5LCoMwEADQvaeIrrSdWuInplrbW3QjLopECMS02FgEzdnTxH1lYD7wZphx@ijTSzQ8uQyjxRNMobk26zApJMoH664Tva1L/xoRR1wiHMciFsxZ0fD2UNt8wu3ZDUesK6FN5b1HLpWQfhgs5V0HMIdf1vlNDhngBDCkbRT9VReriI0cCuo4pXuagvXYYitTW8gexjlsJ7MCEvuH@4cQKLY2hWxb1eYH "Rust – Try It Online")
I am still learning rust, but I am sure there is a better solution using `iter()`. Also I am using `u8` because the examples don't have output value greater than 512.
[Answer]
# [Uiua](https://uiua.org), 9 [bytes](https://www.uiua.org/pad?src=U0JDUyDihpAgK0BcMOKKlwpEZWNvZGUg4oaQIOKHjOKKjy0x4pa9wrEu4o2Y4ouv4oav4oqCwq8x4qe74ouv4qe7LOKHjOKItSjihpjCrzHii68rMjU2KSAtQFwwKzEKJnAg4oqCIjggYml0IGVuY29kaW5nOlx0IiBTQkNTICLih4ziio8tMeKWvcKxLuKNmOKLr-KGr-KKgsKvMeKnu-KLr-Knuyzih4ziiLUo4oaYwq8x4ouvKzI1NikiIOKKgitAXDDih6ExMjkiLiziiLY74oiYwqzCscKv4oy14oia4peL4oyK4oyI4oGFPeKJoDziiaQ-4omlKy3Dl8O34pe_4oG_4oKZ4oan4oal4oig4qe74paz4oeh4oqi4oeM4pmt4ouv4o2J4o2P4o2W4oqa4oqb4oqd4pah4oqU4omF4oqf4oqC4oqP4oqh4oav4oaZ4oaY4oa74per4pa94oyV4oiK4oqXL-KIp1xc4oi14omh4oi64oqe4oqg4o2l4oqV4oqc4oip4oqT4oqD4oqZ4ouF4o2Y4o2c4o2a4qyaJz_ijaPijaQh4o6L4oas4pqCzrfPgM-E4oiefl9bXXt9KCnCr0AkXCLihpB8IyIKJnAg4oqCImRlY29kZWQ6XHQiIERlY29kZSAiwqPCsS0xwrjChy7DjMKlwrPCsMKIMcKfwqXCnyzCo8K_KMK1wogxwqUrMjU2KSIg4oqCK0BcMOKHoTEyOSIuLOKItjviiJjCrMKxwq_ijLXiiJril4vijIrijIjigYU94omgPOKJpD7iiaUrLcOXw7fil7_igb_igpnihqfihqXiiKDip7vilrPih6HiiqLih4zima3ii6_ijYnijY_ijZbiipriipviip3ilqHiipTiiYXiip_iioLiio_iiqHihq_ihpnihpjihrvil6vilr3ijJXiiIriipcv4oinXFziiLXiiaHiiLriip7iiqDijaXiipXiipziiKniipPiioPiipnii4XijZjijZzijZrirJonP-KNo-KNpCHijovihqzimoLOt8-Az4TiiJ5-X1tde30oKcKvQCRcIuKGkHwjIg==)
```
\(×+1⌊÷,)
```
[Try it!](https://uiua.org/pad?src=ZiDihpAgXCjDlysx4oyKw7csKQoKZiBbOV0KZiBbMSAyXQpmIFsyIDFdCmYgWzEgMSAxIDFdCmYgWzUgNCAxMiAxIDNd)
```
\(×+1⌊÷,)
\(      )  # scan by
       ,   # over
      ÷    # divide
     ⌊     # floor
   +1      # increment
  ×        # multiply
```
[Answer]
# [Uiua](https://www.uiua.org/), 8 bytes
```
\(-⊃◿+∶)
```
[Try it online!](https://www.uiua.org/pad?src=ZiDihpAgXCgt4oqD4pe_K-KItikKCmYgWzldCmYgWzEgMl0KZiBbMiAxXQpmIFsxIDEgMSAxXQpmIFs1IDQgMTIgMSAzXQ==)
Given the previous value `x` and the next value `y`, the transformed `y` is the same as `(x+y) - (x+y)%y == (x+y) - x%y`.
```
\(-⊃◿+∶)    input: a vector of positive integers
\(      )    scan by: (input: [x y])
       :       swap [y x]
   ⊃◿+        fork (mod, add) [x%y x+y]
  -            subtract [x+y-x%y]
```
[Answer]
# Japt, 11 bytes
```
Uå@Y*-~(X/Y
```
[Test it online!](http://ethproductions.github.io/japt?v=master&code=VeVAWSotfihYL1k=&input=WzUgNCAxMiAxIDNd)
### How it works
```
          // Implicit: U = input array of integers
Uå@       // Cumulative reduce: map each previous value X and current value Y to:
-~(X/Y    //  floor(X/Y+1).
          // Implicit: output last expression
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 11 bytes
Code:
```
R`[=sŽDŠ/ò*
```
[Try it online!](http://05ab1e.tryitonline.net/#code=UmBbPXPFvUTFoC_Dsio&input=WzIsIDMsIDMsIDIsIDQsIDVd)
Explanation:
```
R            # Reverse input
 `           # Flatten the list
  [          # While loop
   =         # Print the last item
    s        # Swap the last two items
     Ž       # If the stack is empty, break
      D      # Duplicate top of the stack
       Š     # Pop a,b,c and push c,a,b
        /    # Divide a / b
         ò   # Inclusive round up
          *  # Multiply the last two items
```
Uses CP-1252 encoding.
[Answer]
## [Minkolang 0.15](https://github.com/elendiastarman/Minkolang), 17 bytes
```
nd1+?.z0c:1+*d$zN
```
[Try it here!](http://play.starmaninnovations.com/minkolang/?code=nd1%2B%3F%2Edz%24r%3A1%2B*d%24zN&input=15%208%2012%2047%2022%2015%204%2066%2072%2015%203%204)
### Explanation
```
nd                   Take number from input and duplicate it
  1+                 Add 1
    ?.               Stop if top of stack is 0 (i.e., when n => -1 because input is empty).
      z              Push value from register
       0c            Copy first item on stack
         :           Pop b,a and push a//b
          1+         Add 1
            *        Multiply
             d$z     Duplicate and store in register
                N    Output as number
```
Essentially, the register keeps the latest member of the ascending list and this is divided by the input and incremented to get the multiplier for the next member. The toroidal feature of Minkolang's code field means that it loops horizontally without the need for `()` or `[]` loops.
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 21 bytes
```
l~lCℕ₁ᵐ≤ᵛ~+?&;Cz≜×ᵐ<₁
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/r/P6cux/lRy9RHTY0Pt0541Lnk4dbZddr2atbOVY865xyeDhS0Acr9/x9tqmCiYGikYKhgHPs/CgA "Brachylog – Try It Online")
Uses the sum of input values as [the upper bound](https://math.stackexchange.com/a/2873481/85653) for coefficients C. Pretty slow, times out on TIO for input list lengths beyond 5 or 6 (also depending on the sum of the values). But not as slow as my original version, which requires tiny lists of upto 3 elements, with tiny values, to not time out:
### 21 bytes
```
l~l.&+^₂⟦₁⊇.;?z/ᵐℕ₁ᵐ∧
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/r/P6cuR09NO@5RU9Oj@cseNTU@6mrXs7av0n@4dcKjlqlAARCjY/n//9HGOgpAZKijYBT7PwoA "Brachylog – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), 53 bytes
```
lambda a:reduce(lambda b,v:b+[b[-1]/v*v+v],a,[0])[1:]
```
[Try it online!](https://tio.run/##LYzBDoIwEETP@hW9ATJGS6GUJvgjtQdQiE0UCEESvx631WyyO/N2Z6fP8hiHbOvr6/ZsXu29YY2eu/v71sV/32LVbWpac@T2tB7WdLVoYM42MVzbrR9n5pgbmDGVheHIqGfg1EuIQEKRKpCD0ypgAV8KXJKR8DuBX64iLeFZqXxAKYIKhDkxAoKGj/EC4SAvkVHU/5ASZZACubV6v5tmNyzMIaovEfrYJdsX "Python 2 – Try It Online")
`k*x>y` implies `k>y/x`; so the smallest `k` can be is `k=floor(y/x)+1`. Since in Python 2.7, integer division is already taken as `floor`, we want `k=y/x+1`, and `k*x = (y/x+1)*x = y/x*x+x`.
[Answer]
# [K (oK)](https://github.com/JohnEarnest/ok), 11 bytes
```
{y*1+_x%y}\
```
[Try it online!](https://tio.run/##HYs7DsMwDEOvwqXoDxlkObJSXSVAtiwZujYoenaXMjiIfCKP6X30vr@@50Oe2@dy/ta@43pbQlCiQKJB6YdiRoUQEilSDrEwJFdke6EzJGmeVfdwEAoJo/JYyIzxrA2Fo1yboQ2rqPf@Bw "K (oK) – Try It Online")
]