[Question]
  [
Here's the challenge. Write some code to output all the integers in a range. Sounds easy, but here's the tricky part. It will start with the lowest number, then the highest. Then the lowest number which isn't yet in the array. Then the highest which isn't yet in it. 
## Example:
Lets take 1 to 5 as our start 
The numbers are [1, 2, 3, 4, 5].
We take the first, so [1]. Remaining numbers are [2, 3, 4, 5]. 
We take the last, new array is [1, 5]. Remaining numbers are [2, 3, 4]. 
We take the first, new array is [1, 5, 2]. Remaining numbers are [3, 4]. 
We take the last, new array is [1, 5, 2, 4]. Remaining numbers are [3]. 
We take the first, new array is [1, 5, 2, 4, 3]. No numbers remaining, we're done.
Output [1, 5, 2, 4, 3]
## Rules:
* This is code golf, write it in the fewest bytes, any language.
* No standard loopholes.
* Links to an online interpreter, please? (E.g. <https://tio.run/>)
* Two inputs, both integers. Low end of range, and high end of range.
* I don't mind what the data type of the output is, but it must show the numbers in the correct order.
## Examples
Low: 4
High: 6
Result:
4
6
5
---
Low: 1
High: 5
Result:
1
5
2
4
3
---
Low: -1
High: 1
Result:
-1
1
0
---
Low: -1
high: 2
Result:
-1
2
0
1
---
Low: -50
High: 50
Result:
-50
50
-49
49
-48
48
-47
47
-46
46
-45
45
-44
44
-43
43
-42
42
-41
41
-40
40
-39
39
-38
38
-37
37
-36
36
-35
35
-34
34
-33
33
-32
32
-31
31
-30
30
-29
29
-28
28
-27
27
-26
26
-25
25
-24
24
-23
23
-22
22
-21
21
-20
20
-19
19
-18
18
-17
17
-16
16
-15
15
-14
14
-13
13
-12
12
-11
11
-10
10
-9
9
-8
8
-7
7
-6
6
-5
5
-4
4
-3
3
-2
2
-1
1
0
---
Happy golfing!
  
[Answer]
# [R](https://www.r-project.org/), ~~38~~ ~~37~~ 36 bytes
```
function(a,b)rbind(a:b,b:a)[a:b-a+1]
```
[Try it online!](https://tio.run/##XdHNSsNAFMXxfZ/igJsGc2DunZl8CD6JuGiVQjcVij5//VeRYsMvEG7ISXLP@XJ4vhy@Tm@fx4/Tdjfuh/P@eHrf7p724/5pN7xw4d1jvF4O2zZOg67Hg5om9c1hG2P/G4W6khuVsWOM4Xfs4E75neVtliqK67SXsZfhZ9qL4LYKbovgNgtuk@DWBbcmuFXBjdemNrodhLUQ3Irgugqui@A6C66T4NoFVz6dzFqFu7CagmsIrkVwroJzEZyz4JwEJ7sgM5twF5ZVcKbgZBdkZhEcq@BYBMcsOCbB0YW7sGiCowqOFBzsnMxgxUXyKpG58ACnZwmeRIX/w2hAlMjSRI/8pwSnaOvaGUWKKi/f "R – Try It Online")
* -1 byte thanks to @user2390246
* -1 byte thanks to @Kirill L.
Exploiting the fact that R stores matrices column-wise
[Answer]
# [Haskell](https://www.haskell.org/), 30 bytes
```
a%b=a:take(b-a)(b:(a+1)%(b-1))
```
[Try it online!](https://tio.run/##bctBCoAgEEbhfaf4FwkzRJCRLYQOM5KQZBbV/c1t0fJ98Ba5Vh9jzqLcJPaW1ZNrhclZkkazKqWZ8yYhYcK8VzjOkG7UIMUYML5Bw7yByg79Y/3XTMcwXZUf "Haskell – Try It Online")
[Answer]
# [R](https://www.r-project.org/), ~~65~~ ~~64~~ ~~61~~ 60 bytes
-1 byte thanks to Robert S.
-4 more thanks to digEmAll
```
x=scan();z=x:x[2];while(sum(z|1)){cat(z[1],"");z=rev(z[-1])}
```
[Try it online!](https://tio.run/##K/r/v8K2ODkxT0PTusq2wqoi2ijWujwjMydVo7g0V6OqxlBTszo5sUSjKtowVkdJCaSqKLUMyNU1jNWs/W/EZcr1HwA "R – Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), 39 bytes
```
a#b|a>b=a:b#(a-1)|a<b=a:b#(a+1)|1>0=[a]
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P1E5qSbRLsk20SpJWSNR11CzJtEGxtMG8gztDGyjE2P/5yZm5inYKhQUZeaVKKgoaOgaayooKxj/BwA "Haskell – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), 44 bytes
```
f=lambda a,b:[a]*(a==b)or[a]+f(b,a-cmp(a,b))
```
[Try it online!](https://tio.run/##Lcw7CoAwEATQ3lNsuasrGDEWQk4iFhslKGgSgo2njx@s3sAME69zDb7N2ZldDrsICNthlKlEMcZSSE@uHFqWej4iPi1RdiG9O9g8jNhxTwyoWL/UitVv@6kb1g1NQwEQ0@ZPcN9JvgE "Python 2 – Try It Online")
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~59~~ 48 bytes
```
param($a,$b)(($z=0..($b-$a))|%{$a+$_;$b-$_})[$z]
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/vyCxKDFXQyVRRyVJU0NDpcrWQE9PQyVJVyVRU7NGtVolUVsl3hrEj6/VjFapiv3//7@GrqHmfyMA "PowerShell – Try It Online")
~~*(Seems long...)*~~
Takes input `$a` and `$b`, constructs the range `0 .. ($b-$a)`, stores that into `$z`, then loops through that range. The looping through that range is just used as a counter to ensure we get enough iterations. Each iteration, we put `$a` and `$b` on the pipeline with addition/subtraction. That gives us something like `1,5,2,4,3,3,4,2,5,1` so we need to slice into that from `0` up to the `$b-$a` (i.e., the count) of the original array so we're only left with the appropriate elements. That's left on the pipeline and output is implicit.
*-11 bytes thanks to mazzy.*
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 6 bytes
```
ŸDvć,R
```
[Try it online!](https://tio.run/##yy9OTMpM/f//6A6XsiPtOkH//0frmhromBrEAgA "05AB1E – Try It Online")
**Explanation**
```
Ÿ        # push range [min ... max]
 D       # duplicate
  v      # for each element in the copy
   ć,    # extract and print the head of the original list
     R   # and then reverse it
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 14 bytes
```
òV
íUs w)c vUl
```
[Try it online!](https://tio.run/##y0osKPn///CmMK7Da0OLFco1kxXKQnP@/9c1NeAyNQAA "Japt – Try It Online")
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 7 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
É╓ÅìΔà▲
```
[Run and debug it](https://staxlang.xyz/#p=90d68f8dff851e&i=4+6%0A1+5%0A-1+1%0A-1+2%0A-50+50&a=1&m=2)
[Answer]
# [R](https://www.r-project.org/), 51 bytes
```
function(x,y,z=x:y)matrix(c(z,rev(z)),2,,T)[seq(z)]
```
[Try it online!](https://tio.run/##K/qfZvs/rTQvuSQzP0@jQqdSp8q2wqpSMzexpCizQiNZo0qnKLVMo0pTU8dIRydEM7o4tRDIi/2fpmGiY6bJlaZhqGMKonQNdQyhtBGYNjXQMTXQ/A8A "R – Try It Online")
Explanation:
For a sequence `x:y` of length `N`, create a two-by-N matrix consisting of the sequence x:y in the top row and y:x in the bottom row `matrix(c(z,rev(z)),2,,T)`. If we select the first `N` elements of the matrix `[seq(z)]`, they will be chosen by column, giving the required output.
[Outgolfed by digEmAll](https://codegolf.stackexchange.com/a/179869/66252)
[Answer]
# [cQuents](https://github.com/stestoltz/cQuents), 19 bytes
```
#|B-A+1&A+k-1,B-k+1
```
[Try it online!](https://tio.run/##Sy4sTc0rKf7/X7nGSddR21DNUTtb11DHSTdb2/D/f11DBUMA "cQuents – Try It Online")
Note that it does not work on TIO right now because TIO's interpreter is not up to date.
## Explanation
```
#|B-A+1&A+k-1,B-k+1
                      A is the first input, B is the second input
#|B-A+1               n = B - A + 1
       &              Print the first n terms of the sequence
                      k starts at 1 and increments whenever we return to the first term
        A+k-1,         Terms alternate between A + k - 1 and
              B-k+1     B - k + 1
                       increment k
```
[Answer]
## Haskell, 39 bytes
```
f(a:b)=a:f(reverse b)
f x=x
a#b=f[a..b]
```
[Try it online!](https://tio.run/##bci9CoAgFAbQ3af4oAYdCotsCHySaLiSkvSLRfT21lp0xjPQPtppitFxaozQ1Dge7GnDbmEEc7j0xSgx2rWU56aLM/kFGv3KsAW/HEjBE4EK9TsKqHfwrHj258rvKSmgJIs3 "Haskell – Try It Online")
[Answer]
# Haskell, 30 bytes
```
l%h=l:take(h-l)(h:(l+1)%(h-1))
```
Usage: `3%7` gives `[3,7,4,6,5]
For the inputs `l, h` the function calls recursively with the inputs `l+1, h-1`, and adds `l,h` to the beggining.
Instead of any halting condition, the code uses `take(h-l)` to shorten the sequence to the right length (which would otherwise be an infinite sequence of increasing and decreasing numbers).
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 46 bytes
```
a=>b=>{for(;a<=b;Write(a+(b>a++?b--+"":"")));}
```
Saved 4 bytes thanks to dana!
[Try it online!](https://tio.run/##Sy7WTS7O/O9Wmpdsk5lXouOYXJKZnwdi2tml2f5PtLVLsrWrTssv0rBOtLFNsg4vyixJ1UjU1kiyS9TWtk/S1dVWUrJSUtLU1LSu/W/NlaZhqKlhqmnNBVbok5mXqqEJFTXRtP4PAA "C# (Visual C# Interactive Compiler) – Try It Online")
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 65 bytes
```
void z(int a,int b){if(a<=b){Write(a+(b>a?b+"":""));z(a+1,b-1);}}
```
[Try it online!](https://tio.run/##Sy7WTS7O/P@/LD8zRaFKIzOvRCFRB0QmaVZnpmkk2tgCGeFFmSWpGonaGkl2ifZJ2kpKVkpKmprWVUAhQ50kXUNN69ra/1UahjqmmtZcYMU@mXmpGkAOSNBE0/o/AA "C# (Visual C# Interactive Compiler) – Try It Online")
[Answer]
# JVM bytecode (OpenJDK asmtools JASM), 449 bytes
```
enum b{const #1=Method java/io/PrintStream.print:(I)V;static Method a:(II)V stack 2 locals 4{getstatic java/lang/System.out:"Ljava/io/PrintStream;";astore 3;ldc 0;istore 2;l:iload 2;ldc 1;if_icmpeq t;aload 3;iload 0;invokevirtual #1;iinc 0,1;iinc 2,1;goto c;t:aload 3;iload 1;invokevirtual #1;iinc 1,-1;iinc 2,-1;c:aload 3;ldc 32;i2c;invokevirtual java/io/PrintStream.print:(C)V;iload 0;iload 1;if_icmpne l;aload 3;iload 0;invokevirtual #1;return;}}
```
Ungolfed (and slightly cleaner)
```
 enum b {    
    public static Method "a":(II)V stack 5 locals 4 {
        getstatic "java/lang/System"."out":"Ljava/io/PrintStream;";
        astore 3;
        ldc 0;
        istore 2;
    loop:
        iload 2;
        ldc 1;
        if_icmpeq true;
    false:
        aload 3;
        iload 0;
        invokevirtual "java/io/PrintStream"."print":"(I)V";
        iinc 0,1;
        iinc 2,1;
        goto cond;
    true:
        aload 3;
        iload 1;
        invokevirtual "java/io/PrintStream"."print":"(I)V";
        iinc 1,-1;
        iinc 2,-1;
        goto cond;
    cond:
        iload 0;
        iload 1;
        if_icmpne loop;
        aload 3;
        iload 0;
        invokevirtual "java/io/PrintStream"."print":"(I)V";
        return;
    }
}
```
Standalone function, needs to be called from Java as `b.a(num1,num2)`.
## Explanation
This code uses the method parameters as variables, as well as a boolean in local #3 deciding which number to output. Each loop iteration either the left or right is output, and that number is incremented for the left or decremented for the right. Loop continues until both numbers are equal, then that number is output.
...I have a distinct feeling I'm *massively* outgunned on the byte count
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), ~~56~~ 54 bytes
This is my first time golfing!
```
f[a_,b_]:=(c=a~Range~b;Drop[c~Riffle~Reverse@c,a-b-1])
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78/z8tOjFeJyk@1spWI9k2KDEvPTU6UScp1tqlKL8gOigzLS0nNTpZJyi1LLWoONUhOVYnUTdJ1zBW839AUWZeiUNatImOglksF4xnqKNgiuDpArmGqFyj2P8A "Wolfram Language (Mathematica) – Try It Online")
Saved 2 bytes using infix notation.
Explanation:
```
f[a_,b_]:=                                   \function of two variables
c=a~Range~b;                                 \list of integers from a to b 
                           Reverse@c         \same list in reverse
                  c~Riffle~Reverse@c         \interleave the two lists
             Drop[c~Riffle~Reverse@c,a-b-1]  \drop last |a-b-1| elements (note a-b-1 < 0)
```
Alternatively, we could use `Take[...,b-a+1]` for the same result. 
Tests:
```
f[4, 6]
f[1, 5]
f[-1, 1]
f[-1, 2]
```
Ouput:
```
{4, 6, 5}
{1, 5, 2, 4, 3}
{-1, 1, 0}
{-1, 2, 0, 1}
```
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf), 6 bytes
```
↨_x^─▀
```
[Try it online!](https://tio.run/##y00syUjPz0n7//9R24r4irhHUxoeTWv4/99EwYzLUMGUS9dQwRBEGHHpmhoomBoAAA "MathGolf – Try It Online")
## Explanation with `(1, 5)`
```
↨        inclusive range from a to b    [1, 2, 3, 4, 5]
 _       duplicate TOS                  [1, 2, 3, 4, 5], [1, 2, 3, 4, 5]
  x      reverse int/array/string       [1, 2, 3, 4, 5], [5, 4, 3, 2, 1]
   ^     zip top two elements on stack  [[1, 5], [2, 4], [3, 3], [4, 2], [5, 1]]
    ─    flatten array                  [1, 5, 2, 4, 3, 3, 4, 2, 5, 1]
     ▀   unique elements of string/list [1, 5, 2, 4, 3]
```
The reason why this works is due to the fact that all elements in the output should be unique, so the unique elements operator will filter out the second half of the array, producing the correct output.
[Answer]
# [APL (dzaima/APL)](https://github.com/dzaima/APL), 21 bytes
```
⌈⊢+.5×-+∘(⌽×¯1*)∘⍳1+-
```
[Try it online!](https://tio.run/##SyzI0U2pSszMTfz/P@1R24RHPR2PuhZp65kenq6r/ahjhsajnr2Hpx9ab6ilCeQ96t1sqK37/7@ZQpqCCZcpkDTkMgSSQHkuIyhtagBmmBr8yy8oyczPK/6vWwwA "APL (dzaima/APL) – Try It Online")
[Answer]
# Japt, 7 bytes
Takes input as an array.
```
rõ
ÊÆÔv
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.6&code=cvUKysbUdg==&input=WzEsNV0=) or [run all test cases](https://ethproductions.github.io/japt/?v=1.4.6&code=cvUKysbUdg==&input=WwpbNCw2XQpbMSw1XQpbLTEsMV0KWy0xLDJdClstNTAsNTBdCl0KLW1S)
```
         :Implicit input of array U=[low,high]
r        :Reduce by
 õ       :  Inclusive, reversed range (giving the range [high,low])
\n       :Reassign to U
Ê        :Length
 Æ       :Map the range [0,Ê)
  Ô      :  Reverse U
   v     :  Remove the first element
```
[Answer]
# [MATL](https://github.com/lmendo/MATL), 8 bytes
```
&:t"1&)P
```
[Try it online!](https://tio.run/##y00syfn/X82qRMlQTTPg/39DLlMA "MATL – Try It Online")
### Explanation
```
&:      % Take two inputs (implicit). Two-input range
t       % Duplicate
"       % For each
  1&)   %   Push first element, then an array with the rest
  P     %   Reverse array
        % End (implicit). Display (implicit)
```
[Answer]
# JavaScript, 40 bytes
```
l=>g=h=>h>l?[l++,h--,...g(h)]:h<l?[]:[l]
```
[Try It Online!](https://tio.run/##LchLDoMgFEDROavoEOKDSFM6MEIXgi/BWBUNBVObRldPP3F0bu7cvtu1e07Li8d07/Ogc9Bm1F4bb8LNhqIAzzkIIUbqGVa@/l6sbMDcpbim0IuQRmoJsRe4IhArQf3gEuTh@a8qQZVICIpHu1BqN9iRaTPQjdGdiTlN0cHJHdXEJjqWPw)
[Answer]
# [Forth (gforth)](http://www.complang.tuwien.ac.at/forth/gforth/Docs-html/), 52 bytes
```
: f 2dup - 1+ 0 do dup . i 2 mod 2* 1- - swap loop ;
```
[Try it online!](https://tio.run/##JYxBCgIxFEP3PcVjlsov0@q4cMC7iKUqKP1UZY5ff@kieYSQ5FK/D7nnjtbOZGL6KULYM5MKPXmeRN4lEXcEsfazXZVXKcpqIx2jA74O8xPIhcnubpXVuRNH1C0E84B0xIFlRkza/g "Forth (gforth) – Try It Online")
### Explanation
Loop from 0 to (End - Start). Place End and Start on top of the stack.
Each Iteration:
* Output the current number
* Add (or subtract) 1 from the current number
* Switch the current number with the other number
### Code Explanation
```
: f           \ start new word definition
  2dup -      \ get the size of the range (total number of integers)
  1+ 0        \ add 1 to the size because forth loops are [Inclusive, Exclusive) 
  do          \ start counted loop from 0 to size+1
    dup .     \ output the current top of the stack
    i 2 mod   \ get the index of the loop modulus 2
    2* 1-     \ convert from 0,1 to -1,1
    -         \ subtract result from top of stack (adds 1 to lower bound and subtracts 1 from upper)
    swap      \ swap the top two stack numbers 
  loop        \ end the counted loop
;             \ end the word definition
```
[Answer]
# [Julia 0.7](http://julialang.org/), 29 bytes
```
f(a,b)=[a:b b:-1:a]'[1:1+b-a]
```
[Try it online!](https://tio.run/##yyrNyUw0//8/TSNRJ0nTNjrRKkkhyUrX0CoxVj3a0MpQO0k3MfZ/QVFmXklOnkaahomOmaYmF4JvqGOKwtc11DFEFzBCFTA10DE10NT8DwA "Julia 0.7 – Try It Online")
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 15 bytes
```
⟦₂{∅|b↔↰T&hg,T}
```
Input is a 2-element list [lo, hi]. Note that underscore is used for negative numbers. [Try it online!](https://tio.run/##SypKTM6ozMlPN/r//9H8ZY@amqofdbTWJD1qm/KobUOIWka6Tkjt///R8YY6prH/IwA "Brachylog – Try It Online")
### Explanation
```
⟦₂               2-argument inclusive range: [1,5] -> [1,2,3,4,5]
  {           }  Call this recursive predicate to calculate the output:
   ∅               Base case: the input is empty list; nothing to do
    |              Otherwise (recursive case):      [1,2,3,4,5]
     b             Behead the input list            [2,3,4,5]
      ↔            Reverse                          [5,4,3,2]
       ↰           Call the predicate recursively   [5,2,4,3]
        T          Label the result T
         &         Also, with the input list,
          h        Take the head                    1
           g       Wrap it in a list                [1]
            ,T     Append T from earlier            [1,5,2,4,3]
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 5 bytes
```
ŸÂ.ιÙ
```
Takes input as upper first.
Explanation:
```
ŸÂ.ιÙ   //full program
Ÿ       //push [min .. max]                stack: [[4, 5, 6]]
 Â      //push range and reversed range    stack: [[4, 5, 6], [6, 5, 4]]
  .ι    //interleave                       stack: [[4, 6, 5, 5, 6, 4]]
    Ù   //deduplicate                      stack: [[4, 6, 5]]
```
[Try it online!](https://tio.run/##yy9OTMpM/f//6I7DTXrndh6e@f@/GZcJAA "05AB1E – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/) `-ln`, 37 bytes
```
@.=$_..<>;say shift@.,$/,[[email protected]](/cdn-cgi/l/email-protection)@.
```
[Try it online!](https://tio.run/##K0gtyjH9/99Bz1YlXk/Pxs66OLFSoTgjM63EQU9HRV@nIL/AQa88IzMn1UHv/39dI1MuI9N/@QUlmfl5xf91fU31DAwN/uvm5AEA "Perl 5 – Try It Online")
[Answer]
# [Java (JDK)](http://jdk.java.net/), 52 bytes
```
(l,h,o)->{for(int i=0;l<=h;i^=1)o.add(i<1?l++:h--);}
```
[Try it online!](https://tio.run/##ZY4xa8MwEIV3/4obpUYWydClilOyZGqnjKUF1bbic2XJSOeUEPzbXdlJoVDQIe59d@9dq886b6uvCbveB4I29XIgtPJBZf80M7iS0LsZllbHCK8aHVwzAHRUB6PLGg5LD3D2WIFhCYAVM4dG/PF6wUjguUqzY6p@@LRYQiRN6Vt2u9mbHSmgO729gw6nyO/eKcQUE7OiEZ7nu6vxYQnCYq3stmgUfhQb7qWuKobbzbNdrZ6aPOdqnNRicEsfCApw9TfsQ9CXWWP8xo00LH9ci/Tmsbt6vESqO5kE2aeryDr2C8dsnH4A "Java (JDK) – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 6 bytes
```
rạṂ¥Þ,
```
[Try it online!](https://tio.run/##ARwA4/9qZWxsef//cuG6oeG5gsKlw54s////LTUw/zUw "Jelly – Try It Online")
[Answer]
# [Clean](https://github.com/Ourous/curated-clean-linux), 48 bytes
```
import StdEnv
$a b|a<>b=[a: $b(a+sign(b-a))]=[a]
```
[Try it online!](https://tio.run/##S85JTcz7n5ufUpqTqpCbmJn3PzO3IL@oRCG4JMU1r4xLJVEhqSbRxi7JNjrRSkElSSNRuzgzPU8jSTdRUzMWKBj7P7gkEajeVkFFQdfUQMHU4P@/5LScxPTi/7qePv9dKvMSczOTiwE "Clean – Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~37~~ ~~36~~ 33 bytes
```
f=->a,b{a>b ?[]:[a,b]|f[a+1,b-1]}
```
[Try it online!](https://tio.run/##KypNqvz/P81W1y5RJ6k60S5JwT461ioayImtSYtO1DbUSdI1jK39H80VbaJjFqvDFW2oYwqidA11DKG0EZg2NdAxNYjlitVLTUzOqK4BmlBToJAGNqn2PwA "Ruby – Try It Online")
Recursive version with 3 bytes saved by G B.
### [Ruby](https://www.ruby-lang.org/), 38 bytes
```
->a,b{d=*c=a..b;c.map{d.reverse!.pop}}
```
[Try it online!](https://tio.run/##Lcy7CoAgFADQ3a@oNW4XjWwJ@xFxUDNaIjEKwvx2e9B0thN2c@ZJ5HrQYOIoKis0ouktLtrHEYM7XNhciX71KWVJZAudAiIZ8JeaAfttPjkFThVR6LSd4/Wsly8m@ahSvgE "Ruby – Try It Online")
Non-recursive version.
]