[Question]
  [
Given a list with number, output the ranges like this:
Input: `[0, 5, 0]` would become `[0, 1, 2, 3, 4, 5, 4, 3, 2, 1, 0]`.
This is mapping a range through the array, so we first have to create the range `[0, 5]`, which is `[0, 1, 2, 3, 4, 5]`. After that, we use the `5` to create the range `[5, 0]`. Appended at our previous range, this gives us:
```
[0, 1, 2, 3, 4, 5, 4, 3, 2, 1, 0]
```
Let's observe a test case with two same digits next to each other:
```
[3, 5, 5, 3], ranges:
[3, 5] = 3, 4, 5
[5, 5] = 5 (actually [5, 5] due to overlapping)
[5, 3] = 5, 4, 3
```
So this would give us `[3, 4, 5, 5, 4, 3]`.
Some other test cases:
```
[1, 9] > [1, 2, 3, 4, 5, 6, 7, 8, 9]
[10, -10] > [10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10]
[3, 0, 0, -3] > [3, 2, 1, 0, 0, -1, -2, -3]
[1, 3, 5, 7, 5, 3, 1, -1, -3] > [1, 2, 3, 4, 5, 6, 7, 6, 5, 4, 3, 2, 1, 0, -1, -2, -3]
```
Input will always have at least 2 integers.
Shortest answer wins!
  
[Answer]
# 05AB1E, 1 byte
```
Ÿ
```
[Try it online!](http://05ab1e.tryitonline.net/#code=xbg&input=WzMsIDAsIDAsIC0zXQ)
### How it works
It's a built-in.
[Answer]
# Javascript, ~~99~~ ~~95~~ 93 bytes
~~4~~ 6 bytes off thanks [@Neil](https://codegolf.stackexchange.com/users/17602/neil).
```
a=>a.reduce((x,y)=>x.concat(b.map?b=y:[...Array(y<b?b-y:y-b||1)].map(_=>b+=y<b?-1:y>b)),b=[])
```
```
f=
a=>a.reduce(
    (x,y)=>
        x.concat(
            b.map?b=y
            :[...Array(y<b?b-y:y-b||1)]
                .map(_=>b+=y<b?-1:y>b)
        )
    ,b=[])
G.addEventListener('click',_=>O.innerHTML=f(JSON.parse(I.value)));
```
```
<input id=I value="[3,5,5,3]"><button id=G>Go</button><pre id=O>
```
[Answer]
# JavaScript (SpiderMonkey 30+), ~~81~~ 76 bytes
```
([n,...a])=>[n,...[for(i of a)for(j of Array(i<n?n-i:i-n||1))n+=i<n?-1:i>n]]
```
Tested in Firefox 44. Uses ES6's awesome argument destructuring capabilities and ES7's array comprehensions (which have sadly been removed from the ES7 spec).
[Answer]
# JavaScript (ES6) 66 ~~72~~
A recursive function that repeatedly adds values inside the array to fill the gaps between near numbers
```
f=l=>l.some((x,i)=>(z=l[i-1]-x)*z>1&&l.splice(i,0,x+z/2|0))?f(l):l
```
**Test**
```
f=l=>l.some((x,i)=>(z=l[i-1]-x)*z>1&&l.splice(i,0,x+z/2|0))?f(l):l
console.log=x=>O.textContent+=x+'\n'
;[[1,9],[10,-10],[3,0,0,-3],[1, 3, 5, 7, 5, 3, 1, -1, -3]]
.forEach(t=>console.log(t+' -> ' +f(t)))
```
```
<pre id=O></pre>
```
[Answer]
# C, 120 + 12 = 132 bytes
```
i,j,k;f(a,n)int*a;{a[0]--;for(i=0;i<n-1;i++)for(k=0,j=a[i]-a[i+1]?a[i]:a[i]-1;j-a[i+1];)printf("%i ",j+=a[i+1]>j?1:-1);}
```
Example call:
```
f(a,sizeof(a)/4);        // I've added 12 bytes because of ",sizeof(a)/4"
```
Test live on [**ideone**](http://ideone.com/bViLqb).
[Answer]
## Python 2, 77 bytes
```
lambda n:n[0:1]+sum([range(x,y,2*(y>x)-1)[1:]+[y]for(x,y)in zip(n,n[1:])],[])
```
[Try it online](http://ideone.com/fork/Wl6sRo)
Thanks to Neil, DenkerAffe, and Erwan for pointing out improvements that I missed
[Answer]
# Perl, 47 bytes
Includes +3 for `-p` (code contains `$'` so space and `-` count too)
Give the list of numbers on STDIN:
```
fluctuating.pl <<< "3 5 5 3"
```
`fluctuating.pl`:
```
#!/usr/bin/perl -p
($n=$&+($'<=>$&))-$'&&s/\G/$n / while/\S+ /g
```
The temporary variable and all these parenthesis feel suboptimal...
[Answer]
## Haskell, ~~63~~ 55 bytes
```
g(a:b:r)=[a|a==b]++[a..b-1]++[a,a-1..b+1]++g(b:r)
g x=x
```
Usage example: `g [3,5,5,3]` -> `[3,4,5,5,4,3]`.
It's a modification of [my answer](https://codegolf.stackexchange.com/a/73640/34531)  to a [related challenge](https://codegolf.stackexchange.com/q/73636/34531). Again, the main work is done by concatenating the list from `a` upwards to `b-1` and from `a` downwards to `b+1` (where one list will be empty) and a recursive call. To handle the `a==b` case where both lists are empty, we prepend `[a|a==b]` which evaluates to `[a]` if `a==b` and `[]` otherwise.
[Answer]
# R, ~~86~~ ~~82~~ 75 bytes
```
function(x)rep((y<-rle(unlist(Map(seq,head(x,-1),x[-1]))))$v,pmax(1,y$l-1))
```
saved 4 bytes using rep not rep.int (code golf not performance!)
saved another 7 bytes by using built-in partial matching when using `$` (and collapsing function definition to 1 line
[Answer]
# Ruby, ~~116~~ 82 bytes
```
->n{o,*m=n;o=[o];m.zip(n).map{|t,u|o+=[[u],[*u+1..t],[*t..u-1].reverse][t<=>u]};o}
```
My first ever golf.
Edit: Thanks manatwork for the awesome suggestions.
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 12 bytes
Saved 16 bytes thanks to [@ETHproductions](https://codegolf.stackexchange.com/users/42545/ethproductions)!
```
ä!õ ËsE©DÊ>1
```
[Test it online](https://ethproductions.github.io/japt/?v=1.4.5&code=5CH1IMtzRalEyj4x&input=WzEsIDMsIDUsIDcsIDUsIDMsIDEsIC0xLCAtM10=)
[Answer]
# Perl 6, 94 bytes
I'm not super happy with this right now, I'll probably take another shot later
```
{reduce {|@^a[0..*-2],|@^b},map {@_[0]!= @_[1]??(@_[0]...@_[1])!!(@_[0],@_[1])},.rotor(2=>-1)}
```
[Answer]
# PHP 5.4, 86 bytes
This is meant to be used as an included file, that returns the result.
The values are passed as commandline parameters.
```
<?for($i=1;$i<$argc-1;$R=array_merge($R?:[],range($argv[$i++],$argv[$i++])));return$R;
```
Not exactly pretty or anything, but does the job.
[Answer]
# [Python 3](https://docs.python.org/3/), 76 bytes
First attempt at a Python answer.
The basic idea is to repeatedly identify pairs in the sequence where the difference is larger than a step and insert one (and only one) additional element to complete the sequence in the right direction. Repeat until all differences between consecutive elements are between +1 and -1.
```
d=diff
while any(d(x)**2>1):i=argmax(d(x)**2);x[:i+1]+=[x[i]+sign(d(x)[i])]
```
[Try it online!](https://tio.run/##Ncm9DsIgFEDhnae4IxQGqyxi8EUIQxOkvY38hGKEp0dj4ni@k3vdUrwMX1KA@Aq5A4acSoWJkKaNFFKcxFVISzpoMHY47dB78t7w@YAldupoY9N0vs9MoV7KGpb2N3ZrRiGfLdemGbT8wDX@5jeYJcOnAjtghKYI5IKx0p2N8QE "Python 3 – Try It Online")
[Answer]
## Lua, 156 Bytes
A function that takes an array in parameter and return the extended array.
```
function f(t)r={}for i=2,#t
do x,y=t[i-1],t[i]r[#r+1]=x==y and x or nil
z=x>y and-1or 1
x=x==r[#r]and x+z or x
for j=x,y,z
do r[#r+1]=j end end
return r end
```
### Ungolfed and explanations
```
function f(t)
  r={}                        -- Initialise an empty array
  for i=2,#t                  -- Iterate over the parameter array
  do
    x,y=t[i-1],t[i]           -- x and y are shorter names than t[i-1]
    r[#r+1]=                  -- when there's a range like [5,5]
      x==y and x or nil       -- put this number once in the array
    z=x>y and-1or 1         -- determine the step value
    x= x==r[#r]               -- prevent repeating the last value of r
          and x+z or x        -- by incrementing/decrementing x
    for j=x,y,z               -- iterate from t[i-1] to t[i] by step z (-1 or 1)
    do
      r[#r+1]=j               -- put j into the array r
    end
  end
  return r                    -- return the extended array
end
```
For ease of use, you can use the following function to print the array returned by `f()`.
```
function printArray(t)
  print("["..table.concat(t,",").."]")
end
```
When testing this submission, you can call it like:
```
printArray(f( {0,5,0,3,4,4,7,3,-3} ))
> [0,1,2,3,4,5,4,3,2,1,0,1,2,3,4,4,5,6,7,6,5,4,3,2,1,0,-1,-2,-3]
```
[Answer]
# Mathcad, 62 "bytes"
[![enter image description here](https://i.stack.imgur.com/nGDGu.jpg)](https://i.stack.imgur.com/nGDGu.jpg)
As Mathcad uses a 2D "whiteboard" and special operators (eg, summation operator, integral operator), and saves in an XML format, an actual worksheet may contain several hundred (or more) characters. For the purposes of Code Golf, I've taken a Mathcad "byte count" to be the number of characters or operators that the user must enter to create the worksheet.
Converting the function definition to a straight program, and replacing the variable lst with a single character name, gives a total of 62 "bytes". With the function, using a single character rather than the full name, this increases to 65 "bytes" for the definition and a further 4 "bytes" for each call (assuming that creation of the list itself isn't included in the overall byte count (Using Mathcad's built-in tables is another way of inputting the list).
[Answer]
## PHP, 144 bytes
```
function f($r){$m=[];for($i=0;++$i<count($r);){$d=array_pop($m);$n=$r[$i];$p=$r[$i-1];$m=array_merge($m,$p==$n?[$p,$n]:range($p,$n));}return$m;}
```
**Exploded view**
```
function f($r) {
  $m = [];
  for ($i=0; ++$i < count($r); ) {
    $d = array_pop($m);
    $n = $r[$i];
    $p = $r[$i-1];
    $m = array_merge($m, $p==$n ? [$p,$n]
                                : range($p,$n));
  }
  return $m;
}
```
**Input / function call**
```
f([ bound1, bound2, bound3, ... ]);
```
**Output**
```
[int, int, int, int, ...]
```
It's messy and chunky, and I'll try to optimize it later. It creates a `range()` from each pair of adjacent value pairs, then stitches them together (after `pop`ing off the end of the previous cumulative `Array`).
[Answer]
**Perl6, 21**
.join is short for $\_.join
```
say EVAL .join: "..."
```
**Test (rakudo)**
```
perl6 -MMONKEY-SEE-NO-EVAL -e'say EVAL @*ARGS.join: "..."' 1 3 5 7 5 3 1 -1 -3
```
**Output**
```
(1 2 3 4 5 6 7 6 5 4 3 2 1 0 -1 -2 -3)
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 10 bytes
```
,r⁼?2\Ṗ;¥/
```
[Try it online!](https://tio.run/##y0rNyan8/1@n6FHjHnujmIc7p1kfWqr//3D70UkPd874/z/aUEfBWEfBVEfBHEwC2UARXRA2jgUA "Jelly – Try It Online")
[Answer]
# [R](https://www.r-project.org/), 74 bytes
Another R solution
```
function(x){b=x[1];z=c();for(a in x[-1]){z=c(z,c(b:(a-sign(a-b))));b=a};z}
```
[Try it online!](https://tio.run/##Fcg9CoAwDEDh3VN0TKCCQidLTiIObaDSpYI/UCOePda3fPB2TaTpKnzmrUDFJ1Kdx8ULMaBP2w7B5GLq3I8LPv8VyxAnCP2R19KI2PKRwuvl1duQYXDW2cE67IQS3NhxOEFQ9QM "R – Try It Online")
]