text:
Interleave numbers from 1 to n, with the same numbers reversed
A simple one:
Take a positive integer n less than 1000, and output the integers from 1 to n interleaved with the integers from n to 1. You must concatenate the numbers so that they appear without any delimiters between them.
Test cases:
n = 1
11

n = 4
14233241

n = 26
12622532442352262172081991810171116121513141413151216111710189198207216225234243252261

n = 100
110029939849759669579489399210911190128913881487158616851784188319822081218022792378247725762675277428732972307131703269336834673566366537643863396240614160425943584457455646554754485349525051515052495348544755465645574458435942604161406239633864376536663567346833693270317130722973287427752676257724782379228021812082198318841785168615871488138912901191109299389479569659749839921001

This is code-golf so the shortest submission in bytes in each language wins. Explanations are encouraged.

JavaScript (ES6), 30 bytes
f=(n,k=1)=>n?f(n-1,k+1)+n+k:''

How?
This is pretty straightforward but it's worth noting that the string is built from tail to head. An empty string at the beginning is appended last and allows the coercion of the final result to a string to happen.
Below is the detail of the recursion for f(4):
f(4) =                                            // initial call
f(4, 1) =                                         // applying the default value to k
f(3, 2) + 4 + 1 =                                 // recursive call #1
(f(2, 3) + 3 + 2) + 4 + 1 =                       // recursive call #2
((f(1, 4) + 2 + 3) + 3 + 2) + 4 + 1 =             // recursive call #3
(((f(0, 5) + 1 + 4) + 2 + 3) + 3 + 2) + 4 + 1 =   // recursive call #4
((('' + 1 + 4) + 2 + 3) + 3 + 2) + 4 + 1 =        // n = 0 --> end of recursion
'' + 1 + 4 + 2 + 3 + 3 + 2 + 4 + 1 =              // final sum
'14233241'                                        // final result

Test cases

f=(n,k=1)=>n?f(n-1,k+1)+n+k:''

console.log(f(1))
console.log(f(4))
console.log(f(26))
console.log(f(100))

Python 2, 46 bytes
lambda n:''.join(`x+1`+`n-x`for x in range(n))

Thanks to ovs for 4 bytes
Try it online!
Explanation:
lambda n:''.join(`x+1`+`n-x`for x in range(n))
lambda n:                                      # anonymous lambda taking one parameter n
                 `x+1`+`n-x`                   # `x` is repr(x) which is equivalent to str(x) for integers less than INT_MAX
                            for x in range(n)  # integers x in [0, n)

Two bytes more in Python 3: f'{x}{n-~-x}'

@L3viathan That's a new feature added in 3.6.

Python 3.6 is not Python 3?

@L3viathan It is, but it's a specific version. Python 3.5 and below don't have that string interpolation feature.

It is the most recent version. Generator comprehensions, which you use, were added in Python 2.4, Python 2.3 and below don't have that feature, but you still categorize your answer as "Python 2".

@L3viathan That's because Python 2.7 is in wide use. The same cannot be said for 3.6 yet. For example, the Ubuntu Main repo only has 3.5. 2.4 was released in 2004; 3.6 was released 5 months ago. There's a stark difference.

lambda n:''.join('x+1'+'n-x'for x in range(n)) for 46 bytes .(replace the ' in the list comprehension with backticks)

@ovs hey, you can escape the backtick -> \\x+1\\`renders to`x+1``

Bash, 25 bytes
printf %s`seq $1 -1 1|nl`

Try it online!
Prints decreasing sequence, number lines increasing and printf joins lines
Space delimited, 20 bytes :
seq $1 -1 1|nl|xargs

if that is not acceptable i can change it for seq $1 -1 1|nl|tr -d ' \n\t' 8 bytes more

The 20 byte submission is invalid.  My upvote is for the 25 byte submission.

As Digital Trauma noted, the 20-byte solution is invalid.

time printf %s'seq 1000000 -1 1|nl'; grep name /proc/cpuinfo
real    0m7.985s user    0m6.092s sys     0m0.392s model name      : Intel(R) Pentium(R) D CPU 3.00GHz model name      : Intel(R) Pentium(R) D CPU 3.00GHz

-5 thanks to Ørjan Johansen
Haskell, 33 bytes
f n=do a<-[1..n];[a,n-a+1]>>=show

Try it online!

(1) A do expression is shorter than >>= plus a lambda. (2) However, the shows can be combined by using >>=show.

R, 35 bytes
n=scan();cat(rbind(1:n,n:1),sep="")

Try it online
rbind(1:n,n:1) creates a 2 row matrix with 1 to n in the first row and n to 1 in the second. The cat function collapses this matrix, reading down each column.

Note that this only works in interactive mode, and requires the user to enter n on the command line (instead of passing via stdin).

@ssdecontrol Yes, I think that's usually allowed, but I'm fairly new here, could be wrong.

I think it's generally acceptable, but NB, to run it properly in TIO you have to put the input(s) in the Footer field (and it's always good to include a link!) https://tio.run/nexus/r#@59nW5ycmKehaZ2cWKJRlJSZl6JhaJWnk2dlqKlTnFpgq6Sk@d/0PwA

05AB1E, 6 5 bytes
Saved a byte using the new interleave built-in as suggested by rev
LÂ.ιJ

Try it online!
Explanation
L        # range [1 ... input]
 Â       # create a reversed copy
  .ι     # interleave the lists
    J    # join

A user by the name of rev suggested LÂ.ιJ.

@JonathanFrech: I know the consensus now is that we can use features newer than the challenge, but I'm usually hesitant to edit old answers because a new built-in completes the challenge better. There are so many answers in all that could be improved that way :)

Well, I only was the messenger; possible @rev should post their own answer.

@JonathanFrech: I didn't mean it as a reproach. Rev did it correctly when he suggested the edit as it is better to edit an existing answer than post a new one whenever a new built-in is made. I really should get better at fixing old answers, at least when suggestions are made.

Haskell, 65 48 47 bytes
1 byte saved thanks to Laikoni:
f n=show=<<(\(l,r)->[l,r])=<<zip[1..][n,n-1..1]

6 bytes saved thanks to nimi:
f n=show=<<(\(l,r)->[l,r])=<<zip[1..n][n,n-1..1]

Previous answer and explanation:
f n=concatMap show$concatMap(\(l,r)->[l,r])(zip[1..n][n,n-1..1])

There's already a better Haskell answer here, but I'm new to both Haskell and code golfing, so I may as well post it :)
This function zips the list [1..n] with its reverse, resulting in a list of tuples.
[(1,n),(2,n-1),(3,n-2)..(n,1)]

Then it uses concatMap to map a lambda to this list of tuples that results in a list of lists...
[[1,n],[2,n-1],[3,n-2]..[n,1]]

...and concatenates it.
[1,n,2,n-1,3,n-2..n,1]

Then a final concatMap maps show to the list and concatenates it into a single string.
f 26
"12622532442352262172081991810171116121513141413151216111710189198207216225234243252261"

The infix function =<< is the same  (within the list monad) as concatMap: f n=show=<<(\(l,r)->[l,r])=<<zip[1..n][n,n-1..1].

Your current solution is only 48 bytes. 2) You can drop the n in [1..n]: Try it online!

Dang off-by-one errors... 2) Good call!

Whitespace, 71 bytes

Try it online!
Explanation
sssn  ; push 0 - seed the stack with 0 (this will be our 1->n counter, a)
sns   ; dup
tntt  ; getnum - read n (stored on the heap)
sns   ; dup
ttt   ; retr - pull n onto the stack (this will be our n->1 counter, b)
nssn  ; label 'loop'
snt   ; swap - bring a to the top
ssstn ; push 1
tsss  ; add - increment a
sns   ; dup
tnst  ; putnum - output a as a number
snt   ; swap - bring b to the top
sns   ; dup
tnst  ; putnum - output b as a number
ssstn ; push 1
tsst  ; sub - decrement b
sns   ; dup
ntstn ; jez 'exit' if b is 0
nsnn  ; jmp 'loop'

The first couple of instructions are needed to set up the stack correctly, Whitespace's input commands write to the heap so we need to copy b (the input value) back onto the stack. We start with a = 0 since it is shorter to declare 0 instead of 1 (saves a byte) and we only need to reorder the increment instruction to cope. After that we just loop and increment a, output a, output b, decrement b, until b reaches 0 (checked after the decrement).

this could be much more golfed if you removed all that trailing whitespace :P

CJam, 10 bytes
ri,:)_W%]z

Try it online!
Explanation
ri   e# Read input and convert to integer N.
,    e# Turn into range [0 1 ... N-1].
:)   e# Increment to get [1 2 ... N].
_W%  e# Duplicate and reverse the copy.
]    e# Wrap both in an array to get [[1 2 ... N] [N ... 2 1]]
z    e# Transpose to get [[1 N] [2 N-1] ... [N-1 2] [N 1]]
     e# This list is printed implicitly at the end of the program,
     e# but without any of the array structure (so it's essentially flattened,
     e# each number is converted to a string and then all the strings
     e# are joined together and printed).

Ruby, 29 bytes
->n{n.times{|x|$><<x+1<<n-x}}

Explanation:
->n{n.times{|x|                # x in range [0..n-1]
               $><<            # output on console
                   x+1<<n-x}}  # x+1, then n-x

Try it online!

Pyth, 7 bytes
jksC_BS

Try it online: Demonstration
Explanation:
jksC_BSQ   implicit Q (=input number) at the end
      SQ   create the range [1, ..., Q]
    _B     bifurcate by inversion, this gives [[1, ..., Q], [Q, ..., 1]]
  sC       zip and flatten result
jk         join to a string

Octave, 29 bytes
@(n)printf("%d",[1:n;n:-1:1])

Try it online!

My implementation was so, so much longer! Nice! =)

Scala, 43 bytes
It's not the best but it's my first code golf.
n=>1.to(n).foldLeft("")((s,x)=>s+x+(n-x+1))

Perl 6, 20 bytes
{[~] 1..*Z~($_...1)}

Test it
With an input of 100000 this takes roughly 10 seconds, including compilation and printing the output.
Expanded:
{                # bare block lambda with implicit parameter ｢$_｣

  [~]            # reduce using concatenation operator ｢&infix:«~»｣
                 # (shorter than ｢join '',｣)

    1 .. *       # Range from 1 to infinity

    Z~           # zip using concatenation operator

    ( $_ ... 1 ) # deduced sequence starting at the input
                 # going down to 1
}

The Z~ needs the ~ because otherwise it generates a list of lists which will stringify with spaces.
There is no need to limit the Range starting at 1, because Z stops when any of the input lists run out.
This saves two bytes (a space would be needed after $_)

Java 61 bytes
(int n)->{for(int i=0;i<n;System.out.print(i+1+""+(n-i++)));}

Also, welcome to PPCG! :)

We allow anonymous functions, so (int n)->{//for loop} should work here.

Is that better?

Yep!  You can potentially put your System.out.print() in the last statement of the for loop, but it gets complicated because you are using i twice (and you need to increment it in the expression).

I put the print inside the loop and incremented i at the last possible place then checked it with the Test cases to make sure it worked, thanks @NathanMerrill

don't need the parens around int n iirc. Or int  for that matter.

Jelly, 5 bytes
RṚĖVV

Try it online!
How it works
RṚĖVV  Main link. Argument: n

R      Range; yield [1, ..., n].
 Ṛ     Reverse; yield [n, ..., 1].
  Ė    Enumerate; yield [[1, n], ..., [n, 1]].
   V   Eval; convert each flat array to a string, interpret it as a Jelly program,
       and yield the output. This concatenates the integers in each pair, yielding
       a flat array of integers
    V  Repeat the previous step, concatenating the intgegers from before.

Aceto, 25 22 bytes
)&
pX`=
(pl0
id@z
r}Z)

Explanation:
We read an integer and put it on two stacks.
id
r}

On one, we call range_up (Z), on the other range_down (z), then we set a catch mark to be able to return to this place later:
  @z
  Z)

We then check if the current stack is empty and exit if so:
 X`=
  l0

Otherwise, we print from both stacks and jump back to the catch mark:
)&
p
(p

Röda, 21 19 bytes
{seq 1,_<>seq _1,1}

Try it online!
This is an anonymous function that takes input from the stream.
Explanation
{seq 1,_<>seq _1,1}               Anonymous function, takes integer n from the stream
        <>                        Interleave
 seq 1,_                            the range 1 .. n with
          seq _1,1                  the range n .. 1

V, 20 bytes
ywo1@"ñykPjñkògJ

Try it online!
Explain:
yw                    ' Copy the input number (for looping later)
  o1                 ' Insert a 1 under the input (on a newline)
     @"               ' [Copy register] number of times
       ñ      ñ       ' Do the thing inside of this loop
        ykP           ' Copy the current line and line above it, and paste above both
           j        ' decrement the current (top) number, and increment the one below
               k      ' Go to the top line
                ògJ   ' recursively join all of the lines

Cubix, 17 bytes
....1I>sO)su.@?(O

Try it online!
cubified:
    . .
    . .
1 I > s O ) s u
. @ ? ( O . . .
    . .
    . .

Pushes 1, reads in the input (I), then enters the loop which swaps the top of the stack, outputs it, increments, swaps, outputs the top of the stack, decrements, and stops if the top of the stack is 0.

Clojure, 61 bytes
#(let[a(range 1(+ 1 %))](apply str(interleave a(reverse a))))

Literally does what is asked. I believe it can be outgolfed by a less trivial solution.
See it online

PHP, 36 35 29 bytes
for(;$argn;)echo++$i,$argn--;

Saved one byte thanks to Jörg Hülsermann.

Saved six bytes thanks to Christoph.

Uhm... for(;$argn;)echo++$i,$argn--; ?

Brachylog, 10 9 bytes
⟦₁g↔ᶻczcc

Try it online!
Explanation
⟦₁           [1, …, Input]
  g↔ᶻc       [[1, …, Input],[Input, …, 1]]
      z      Zip
       cc    Concatenate twice

R, 41 bytes
pryr::f(for(i in 1:x){cat(i);cat(x-i+1)})

pryr::f() creates a function that takes one input. Loops over 1:x and prints each element of 1:x along with each element of x:1. Prints to STDOUT.

+1, nice use of pryr

@ssdecontrol its pretty much staple replacement of function(x) :)

MATL, 13 11 9 bytes
2 bytes saved thanks to @Luis
:tPv1eVXz

Try it at MATL Online
Explanation
        % Implicitly grab input as a number, N
:       % Create an array from 1..N
tP      % Create a reversed copy
v       % Vertically concatenate the two
1e      % Reshape it into a row vector
V       % Convert to a string
Xz      % Remove whitespace and implicitly display

@LuisMendo Ah! I thought there was a function that removed whitespace but couldn't find it. Thanks!

Common Lisp, 63 54 bytes
(lambda(n)(dotimes(i n)(format t"~a~a"(1+ i)(- n i))))

Try it online!

K (ngn/k), 16 bytes
{,//$r,'|r:1+!x}

Try it online!

r,'|r: -> +|:\

MathGolf, 5 bytes
{îkï-

Try it online!
Explanation:
{      Run a for loop over implicit input
 î     Push 1 based index of loop
  k    Push inputted number
   ï-  Subtract 0 based index of loop
       Implicitly output all this joined together

I've been able to find 13 programs of length 5 which yield the same result: ╒{ïí,, ╒{ïk,, ╒{íï-, ╒{kï-, ╒{┐í,, ╒{┐k,, ╒x{î\ , {îïí,, {îïk,, {îíï-, {îkï-, {î┐í,, {î┐k,. However, I have not been able to find any program of length 4 or less. I haven't done a full search, but it is very probable that 5 bytes is optimal for MathGolf.

Forth (gforth), 41 bytes
: f 1+ dup 1 do i 1 .r 1- dup 1 .r loop ;

Try it online!
Explanation
Loops from 1 to n and outputs the index as well as n-index in a right-aligned space of size 1 (forces no space after output)
Code Explanation
: f               \ start new word definition
  1+ dup 1        \ set up arguments to loop from 1 to n
  do              \ start loop
    i 1 .r        \ output the index in a right-aligned space of size 1
    1- dup        \ subtract 1 from current value of n and duplicate
    1 .r          \ output new n in right-aligned space of size 1
  loop            \ end loop
;                 \ end word definition

Mouse-2002, 32 30 bytes
-2 moved conditional to start of loop (z.^ ... ) instead of (... z.0>^)
?n:n.z:(z.^a.1+a:a.!z.!z.1-z:)

Try it online!
Explanation:
?n:                                 ~ get input and store in n
   n.z:                             ~ copy n into z
       (z.^                         ~ stop if z equals 0
           a.1+a:                   ~ add 1 to a
                 a.!                ~ print a
                    z.!             ~ print z
                       z.1-z:)      ~ substract 1 from z

Vyxal, 5 4 bytes
ɾḂYṅ

Try it Online!
Explained
ɾḂYṅ
ɾ     # range of [1,input+1]
 Ḃ    # dupe and reverse
   Y  # interleave
    ṅ # join with no spaces

:Ṙ can be substituted into Ḃ, saving one byte.

tinylisp 2, 46 32 bytes
(\(N)(} ,(m u({ ,(z(1to N)(to1 N

An anonymous function that takes an integer and returns a string. Try it at Replit. Example session:
tl2> (\(N)(} ,(m u({ ,(z(1to N)(to1 N
(() (N) (} , (m u ({ , (z (1to N) (to1 N))))))
tl2> (def interleave-numbers _)
interleave-numbers
tl2> (interleave-numbers 4)
"14233241"

Explanation
(\(N)(} ,(m u({ ,(z(1to N)(to1 N))))))
(\                                   ) ; Lambda function
  (N)                                  ; that takes an integer N:
                 (z              )     ;  Zip together these two lists:
                   (1to N)             ;   Numbers from 1 to N
                          (to1 N)      ;   Numbers from N to 1
             ({ ,                 )    ;  Right fold on list/string concatenation
         (m u                      )   ;  Map unparse (convert to string) to each number
     (} ,                           )  ;  Left fold on list/string concatenation

The reason for the different folds is that right fold is more efficient, but by default it starts with an empty list, which when concatenating strings would make the result a list of charcodes instead of a string. Left-folding strings, by contrast, results in a string.

Braingolf v0.7, 18 bytes
VR.MUvU&,R{vMR}>&_

Try it online!
Explanation:
VR.MUvU&,R{vMR}>&_  Implicit input of n to stack
VR                  Create new stack then return to main
  .M                Duplicate n and move duplicate to new stack
    U               Replace stack with 1-n, where n is last item on stack
     vU             Replace 2nd stack with 1-n
       &,           Reverse second stack
         R          Return to main
          {   }     Map loop, runs for each item in the stack
           vMR      Move to next stack, move last item to main stack
               >    Cleanup after loop
                &_  Print all items in stack with no delimiter

Japt -P, 11 8 bytes
Saved 2 byte thanks to @Shaggy
õ í1õU)c

Try it online!
Explanation:
õ í1õU)c
õ              Range [1...Input]
  í            Pair with:
   1õU           Range [Input...1]
      )c       Flatten
-P             Join into a string

Use the -P flag to save a byte. Link

@Shaggy Thanks! When I wrote it, I tried this and assumed it wasn't joining due to a bug.

8 bytes

Powershell, 37 bytes
param($n)-join(1..$n|%{$_,($n-$_+1)})

Jelly, 6 bytes
RżU$FV

Try it online!
Explanation:
         Example: n = 6
R        Create a range from 1 to n             [1, 2, 3, 4, 5, 6]
  U$     and a reversed copy of that same range [6, 5, 4, 3, 2, 1]
 ż       and interleave them                    [ [1, 6], [2, 5, ... ]
    F    Flatten the list                       [1, 6, 2, 5, 3, 4 ...]
     V   And Eval: Jelly code consisting of only numbers would simply print those numbers,

Retina, 20 bytes
.+
$*__
\B
$.`$.'
_

Try it online! Includes test cases. Explanation: Each pair of numbers sums to n+1, so we convert n to unary and add 1. Then, we match between each pair of _s, counting the number of _s to the left and right. This generates the pairs of numbers. Finally we delete the _s now that they've served their purpose.

><>, 16 12+3 = 19 15  bytes
l:n}:n1-:?!;

Input is expected on the stack, so +3 bytes for the -v flag.
Thanks to @TealPelican for pointing out a very clever way to save 4 bytes by using the size of the stack itself - on the first iteration it'll be 1, then 2, then 3... That way, the first number in each pair manages itself, no manual incrementing required!
Previous version:
1:n1+$:n1-:?!;$!

Try it online!

Surprisingly I came up with something fairly similar before checking the answers for ><> but you can save a few bytes by replacing the; 1+$ with } and then removing the final; $! at the end to come up with this; l:n}:n1-:?!;

ln:n1-::?!;

Actually, 9 bytes
R;R@Z♂iεj

Try it online!, or run all test cases
Explanation:
R;R@Z♂iεj
R          range(1, n+1)
 ;R        duplicate and reverse
   @Z      swap and zip
     ♂i    make 1D
       εj  join with empty string

QBIC, 18 bytes
[:|Z=Z+!a$+!b-a+1$

Explanation
[:|       FOR a = 1 to n
Z=Z+      Add to Z$
!b$+      a cast of the loop counter as string
!b-a+1$   and a cast of (n+1) minus the loop counter to string
          Z$ is printed implicitly at the end of QBIC

Mathematica, 36 32 bytes
Row@Riffle[x=Range@#,Reverse@x]&

thanks Martin

#+1-x is more efficient than Reverse@x. ------- Note: Row does not even make it a string, just a formatting. It looks identical to a string on some platforms, but it show as multiplication sign between on Wolfram sandbox. However it takes less bytes than ToString/@(""<>...) or ""<>ToString/@....

CJam, 13 12 bytes
1 byte removed thanks to Martin Ender
ri:X{_)X@-}%

Try it online!
Explanation
ri               e# Read integer n
  :X             e# Copy n into variable X
     {     }%    e# Map over the array [0 1 2 ... n-1]
      _          e# Duplicate
       )         e# Add 1
        X        e# Push n
         @       e# Rotate
          -      e# Subtract

AWK, 34 30 bytes
{for(i=1;i<=$1;i++)printf i$1-i+1}
{for(;i<$1;i++)printf i+1$1-i}

Try it online!

could shave 4 with {for(;i<$1;i++)printf i+1$1-i}

Perl 5, 28 bytes
27 bytes code + 1 byte for -a.
map{print$_,"@F"+1-$_}1..$_

Try it online!

Perl 5, 25 21 + 1 = 26 22 bytes
Takes input from stdin, without a trailing newline.
Runs with the -n flag:
print++$x.$_--while$_

4 bytes saved thanks to Dada.

It doesn't work for numbers greater than 9. That's because the precedence of . is higher than the one of +. Adding parenthesis around $_+1 would solve this. Also, you can remove the parenthesis around $_--. But even shorter, you can take the input without final newline (with echo -n for instance), and then you can do print++$x.$_--while$_.

C (gcc), 43 bytes
a;f(n){for(a=1;n;a++)printf("%d%d",a,n--);}

Try it online!

You can save a byte by putting the ++ on the a in the printf.

Python 3, 51 bytes
lambda n:''.join("%d%d"%(x+1,n-x)for x in range(n))

Try it online!
Port of Mego's Python 2 answer.

Japt -mP, 8 6 bytes
°Us+N´

Try it
           :For each U in the range [0,input)
°U         : Prefix increment U
  s        : Convert to a string
   +       : Append
    N´     :  Postfix decrement the (singleton) array of inputs
           :Implicitly join and output

C# (.NET Core), 53 bytes
a=>{for(int i=0;++i<=a;)Console.Write(i+""+(a-i+1));}

Try it online!
Uses an Action delegate to pull in the input and not require a return.
Ungolfed:
a => {
    for(int i = 0; ++i <= a;)           // initialize i and increment until a
        Console.Write(i + "" + (a - i + 1));    // output i and "inverse" of i
                                                    // empty string required to set as string
                                                    // parentheses required because C# is dumb and can't figure out what a minus sign is supposed to do without them
}

Kotlin, 52 50 bytes
fun g(e:Int)=(1..e).forEach{print("$it${e-it+1}")}

Try it online
Older version, the one above also prints it, the one below produces a string.
fun y(n:Int)=(1..n).joinToString(""){"$it${n-it+1}"}

Try it online!

APL (Dyalog Unicode), 10 bytesSBCS
(∊⍪,⌽)⍕¨∘⍳

Try it online!
Explanation:
(∊⍪,⌽)⍕¨∘⍳  ⍝ Monadic function train
       ⍕¨∘⍳  ⍝ Generate integers from 1 to input, convert each to string
             ⍝ Call this vector "X"
  ⍪          ⍝ "Table" X, making a single-column matrix
   ,⌽       ⍝ Reverse X and concatenate it with the above table
             ⍝ This results in a two-column matrix with integers from
             ⍝ 1 to N and N to 1 side-by-side
 ∊           ⍝ "Enlist" the above - left-to-right, top-to-bottom,
             ⍝ recursively concatenate all items in the matrix

Don't forget to claim your bounty!

here's a shorter one: ∊⍕¨⌽,⌸⌽⍳⎕

Zsh, 32 bytes
repeat $1 printf $[++i]$[$1+1-i]

Try it online!
I like trying to beat Bash+coreutils with pure zsh, but sadly that is not the case here.

Cooler, but one byte longer (33 bytes):
a=({$1..1})
<<<${(j::)${(n)a}:^a}

Try it online!

Pyt, 5 bytes
řĐ↔Žǰ

Try it online!
ř          implicit input (n); push [1,2,...,n]
 Đ         duplicate top of stack
  ↔        flip the array at the top of the stack
   Ž       interleave the two arrays
    ǰ      join the contents of the array to create a string; implicit print

Ly, 12 bytes
Rsrp[ul,s`u]

Try it online!
This one generates the 1..N series on the stack, and it generates the N..1 numbers by manipulating an accumulator on the backup cell.
R             - Generate range of 0..N (where N is from STDIN)
 s            - Save the upper limit to the backup cell
  rp          - Reverse the stack, delete the "0"
    [      ]  - While the stack isn't empty
     u        - Print next number in the range
      l,s     - Load backup cell, decrement and save
         `u   - Increment and print

Pip, 10 bytes
-2 bytes thanks to DLosc!
Y\,ayWVRVy

Try It Online!

Pip, 12 bytes
(Y++,a)WVRVy

How?
(Y++,a)WVRVy  : One arg(integer n)
     a        : First arg
    ,         : Inclusive range from 1
  ++          : Increment
 Y            : Yank
         RV   : Alias for unary reverse
           y  : Yanked range
       WV     : Weave two iterables together, alternating their items

Try It Online!

10 bytes

Go, 90 bytes
import."fmt"
func f(n int)(o string){for i:=1;i<=n;i++{o+=Sprintf("%d%d",i,n-i+1)};return}

Attempt This Online!

Julia 1.0, 33 22 bytes
~x=join([1:x x:-1:1]')

Try it online!

The forward and reverse sequences are collected from ranges.
This method of interleaving arrays in Julia can be adapted for code golf.
The print command is vectorized with the "dot" operator so that no delimiters are shown.

-9 bytes thanks to MarcMush: avoid reshaping the array
-2 bytes thanks to MarcMush: replace print. with join

I think ~x=print.([1:x x:-1:1]') works

You can also use join instead of print.()

J, 18 bytes
[:;],.&<&":&>:&i.-

Try it online!

Clojure, 52 bytes
#(apply str(mapcat(fn[i][(inc i)(- % i)])(range %)))

Concatenates pair-wise integers (head and tail of the seq).

Python 2.7, 39 bytes
x=''.join(`i+1`+`n-i`for i in range(n))

I think you must either use input or make this a lambda. Assuming the variable exists in the workspace is not acceptable I'm afraid.

Pyke, 9 bytes
SD_],sm`s

Try it here!

Mathematica, 52 bytes
As a traditional function:
f[x_] := StringJoin[ToString /@ Riffle[Range[x], Reverse[Range[x]]]]

As an anonymous function
(x = Range[#]; StringJoin[ToString /@ Riffle[x, Reverse[x]]]) &

As a code block that accepts the input in the variable n
x = Range[n]; StringJoin[ToString /@ Riffle[x, Reverse[x]]]

The code is pretty simple -- generate the list of integers with Range[], interleave this list (using Riffle[]) with a copy of the list that has been reversed, then convert all the integers to strings and concatenate them with StringJoin[].
Could have done it in 30 bytes if we were allowed to leave the answer in the form of a list (thus, {1,4,2,3,3,2,4,1} rather than "14233241"). Also, in the hypothetical Mthmtca with short command names it would have been something like 21 bytes.
Performance is tolerable for n <= 1,000,000. I didn't test past that.

This should be a function that takes an integer argument, rather than having a 4 hardcoded.

This isn't golfed either, which makes it invalid

@cat if you think you can write it more concisely, please do so. If you can't, why do you think it's not golfed?

Yeah, f[x_]:=StringJoin[ToString/@Riffle[Range[x],Reverse[Range[x]]]], I think I counted the close braces right from my phone. Either way I know for a fact that MMA doesn't rely on whitespace, and I can say that as a communiry member

None of these are 52 bytes, even with whitespace stripped. I get 56 bytes for the middle one (the last one not being valid).

R, 43 39 37 bytes
This is an anonymous function.
function(n)cat(rbind(1:n,n:1),sep="")

It's 35 bytes if I use pryr::f() like in the other answer:
pryr::f(cat(rbind(1:n,n:1),sep=""))

but needs to be installed (Enter install.packages("pryr") in the R console).

You could save some bytes by not defining s and just using 1:n directly.

you can also save a couple bytes by removing the curly braces from your first answer

Hexagony, 15 bytes
{?\"!\{$.(.@).!

Embiggened:
   { ? \
  " ! \ {
 $ . ( . @
  ) . ! .
   . . .

Try it online!

Python 2, 67 bytes
A simple one, just for the collection :)
n=input()+1
i=1
s=""
while i<n:
    s+=`i`+`n-i`
    i+=1
print s

you can use while i<n:s+=`i`+`n-i`;i+=1 to golf off some bytes

LOGO, 48 bytes
to f :n
for[i 1 :n][(type :i :n+1-:i)]show "
end

Define a function f that when invoke with parameter = number n, print the result string.

braingasm, 9 bytes
;[>+:<:-]

Simple: Read a number from stdin to the current cell; While the current cell is not zero, go to next cell (initially 0), increase it, output its value, go back, output that value and decrease it.

Java 8, 53 52 bytes
n->{for(int i=1;n>0;System.out.print(n--+""+i++));};

Try it online!

-1 bytes thanks to Sara J!

52 bytes

@SaraJ thanks, I forgot about the for-loop trick

Kotlin, 44 bytes
{n->(1..n).joinToString(""){"$it${n-it+1}"}}

{n->                                          // n is Int input
    (1..n)                                    // range from 1 to end
          .joinToString("")                   // join items with no separator
                           {                  // transform by
                            "$it${n-it+1}"    // current number and number from end of range
                                          }}

Lambda that takes an Int and returns a String.
Try it online!

42 (btw it's basically identical to the other kotlin answer)

dc, 17 bytes
[znddn1-d0<M]dsMx

Try it online!

APL(NARS), 13 chars, 26 bytes
{∊k,¨⌽k←⍕¨⍳⍵}

How to use & test:
  f←{∊k,¨⌽k←⍕¨⍳⍵}
  f 1
11
  f 26
12622532442352262172081991810171116121513141413151216111710189198207216225234243252261

Ink, 47 bytes
=f(n)
~temp i=n
-(l)
~i--
{n-i}{1+i}{i:->l}->->

Try it online!

Stax, 5 bytes
çK^↑Ñ

Run and debug it

Arturo, 36 bytes
$[n][""loop 1..n'x->~"|n-x-1||x|"++]

Try it
$[n][             ; a function taking an argument n
  ""              ; place an empty string on the stack
  loop 1..n'x->   ; foreach x in 1 to n...
    ~"|n-x-1||x|" ; interpolate x and n-x-1 into a string
    ++            ; append it to the string on the stack
]                 ; end function

Thunno J, \$ 10 \log_{256}(96) \approx \$ 8.23 bytes
R1+DrsZZ.J

Explanation
R1+DrsZZ.J  # Implicit input                  STACK (example for n=10)
R1+         # range(0, n) + 1                 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
   Dr       # Duplicate and reverse           [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
     sZZ    # Swap and zip together           [[1, 10], [2, 9], [3, 8], [4, 7], [5, 6], [6, 5], [7, 4], [8, 3], [9, 2], [10, 1]]
        .J  # Join each inner list            ['110', '29', '38', '47', '56', '65', '74', '83', '92', '101']
            # J flag joins the final list     '1102938475665748392101'
            # Implicit output

Screenshot

Fig, \$6\log_{256}(96)\approx\$ 4.939 bytes
OYax$a

Try it online!
OYax$a
 Y     # Interleave
  ax   # [1, n]
    $a # With [1, n] reversed
O      # Join

Thunno 2 J, 3 bytes
RḲI

Attempt This Online!
Explanation
RḲI  # Implicit input       ->  4
R    # Range: push [1..n]   ->  [1,2,3,4]
 Ḳ   # Bifurcate this list  ->  [1,2,3,4]  [4,3,2,1]
  I  # Interleave           ->  [1,4,2,3,3,2,4,1]
     # Join and output      ->  "14233241"


text:
How many goals has Steven Gerrard scored?
Steven Gerrard was born on 30th of May 1980. He is now 37 years old. Happy birthday, Steven!
To celebrate his anniversary, your goal is to remind him the number of goals he has scored each year in premiere league for Liverpool.
He doesn't want to remember the goals scored before or after playing for Liverpool. It is like scoring 0 goals.
Input
The starting year of football season.
Output
The number of goals scored by Steven during this season for Liverpool.
List of seasons and goals
1998–99     0
1999–2000   1
2000–01     7
2001–02     3
2002–03     5
2003–04     4
2004–05     7
2005–06     10
2006–07     7
2007–08     11
2008–09     16
2009–10     9
2010–11     4
2011–12     5
2012–13     9
2013–14     13
2014–15     9

Example
Input    Output
2002     5
2017     0
1990     0
2014     9

This is code-golf so the shortest submission in bytes in each language wins. Explanations are encouraged.

Do we have to return 0 if the date is out of the range or can we throw an exception?

@TheLethalCoder Steven Gerrard prefers to say that he has scored 0 goals. No exception

05AB1E, 25 24 bytes
•3ßÎó‚4Ëǝï•17в15ÝƵÊØ+Ikè

Try it online!
or as a Test suite
Explanation
•3ßÎó‚4Ëǝï•                 # push the number 69255401071877657848
           17в              # convert to list of base-17 digits
                            # produces the list [1,7,3,5,4,7,10,7,11,16,9,4,5,9,13,9,0]

              15Ý           # push the range [0 ... 15]
                 ƵÊØ+       # add the 303rd prime (1999) to each
                     Ik     # get the index of the input in this list
                            # or -1 if outside the range
                       è    # get the element at that index in first list

JavaScript (ES6), 47 43 42 39 bytes
y=>+'0723135148933694'[y-1999]+y%20%9|0

How?
We compute an approximation x of the number of goals for a given year y with the formula:
x = y % 20 % 9

This is actually a very bad approximation, but it's always less than or equal to the expected value v and never less than v - 9, which allows to encode the difference with a single decimal digit.
y    | y % 20 | x = y % 20 % 9 | v  | v - x
-----+--------+----------------+----+------
1999 |     19 |              1 |  1 |     0
2000 |      0 |              0 |  7 |     7
2001 |      1 |              1 |  3 |     2
2002 |      2 |              2 |  5 |     3
2003 |      3 |              3 |  4 |     1
2004 |      4 |              4 |  7 |     3
2005 |      5 |              5 | 10 |     5
2006 |      6 |              6 |  7 |     1
2007 |      7 |              7 | 11 |     4
2008 |      8 |              8 | 16 |     8
2009 |      9 |              0 |  9 |     9
2010 |     10 |              1 |  4 |     3
2011 |     11 |              2 |  5 |     3
2012 |     12 |              3 |  9 |     6
2013 |     13 |              4 | 13 |     9
2014 |     14 |              5 |  9 |     4

Demo

let f =

y=>+'0723135148933694'[y-1999]+y%20%9|0

for(y = 1997; y <= 2017; y++) {
  console.log(y, f(y))
}

Very nicely done.

Wait. You're computing the number of goals from the input year, instead of indexing in a hard-coded database?

@Blacksilver I need a first approximation to lower the range of stored values from 1-16 to 0-9. But there's still a hard-coded lookup table to store the differences with these computed values.

JavaScript, 44 Bytes
y=>parseInt("173547a7bg9459d9"[y-1999],17)|0

Welcome to PPCG. Nice first answer :)

PHP, 44 Bytes
<?=intval(_173547a7bg9459d9[$argn-1998],17);

Try it online!

Bash, 97 93 Bytes
a=(1 7 3 5 4 7 10 7 11 16 9 4 5 9 13 9)
((2014<$1||$1<1999))&&(echo 0)||(echo $[a[$1-1999]])

PowerShell, 65 Bytes
(($g=(1,7,3,5,4,7,10,7,11,16,9,4,5,9,13,9)["$args"-1999]),0)[!$g]

uses a ternary/array format to return 0 if the year isn't in the array.
This is so long because powershell doesn't have any else return 0 format, and the full array is required, if he scored 9 or less goals in each year we could shave a lot off this by indexing into a string instead.

C#, 79 72 bytes
y=>new[]{0,1,7,3,5,4,7,10,7,11,16,9,4,5,9,13,9}[y>2014|y<1999?0:y-1998];

Braingolf v0.6, 48 bytes
#ߎ-V173547#
792+82*945994+9&,0R!?1-[v>R]v_:0_|;

This is a weird one.
The character ߎ has the ordinal 1998, making #ߎ the Braingolf literal for 1998, which is then subtracted from the input.
Explanation:
#ߎ-V173547#
792+82*945994+9&,0R!?1-[v>R]v_:0_|;  Implicit input of n
#ߎ-                                  Subtract 1998 from n
   V                                 Create a new stack and switch to it
    173547                           Digit literals 1, 7, 3, 5, 4 and 7
          #<newline>                 Integer literal 10
792                                  Digit literals 7, 9 and 2
   +                                 Sum the last 2 items (9 and 2) to make 11
    82*                              Digit literals 8 and 2 multiplied to make 16
       9459                          Digit literals 9, 4, 5 and 9
           94+                       Digit literals 9 and 4 summed to make 13
              9                      Digit literal 9
               &,                    Reverse stack
                 0                   Digit literal 0
                  R                  Return to main stack
                   !?                If n != 0
                     1-              Decrement n
                       [...]         Loop, repeat n+1 times
                        v>           Move to next stack and rotate to the right
                          R          Return to main stack
                            v_       Move to next stack and output last item
                              :      Else
                               0_    Push zero and output
                                 |   Endif
                                  ;  Suppress implicit output

JavaScript (ES6), 50 41 bytes
y=>+`0x${"06243696af8348c8"[y-1999]}`+1|0

Try it

f=
y=>+`0x${"06243696af8348c8"[y-1999]}`+1|0
oninput=_=>o.innerText=f(+i.value)
o.innerText=f(i.value=1998)
<input id=i type=number><p id=o>

Python 2, 59 58 bytes
Inspired by this answer.
lambda x:1997<x<2015and int('173547a7bg9459d9'[x-1999],17)

Try it online!

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

sort: votes


text:
Remove the Salutations
Challenge
Hi, given a string as input, remove any salutations found at the start of the string.
The program which performs the most correct substitutions in under 50 bytes wins.
Salutations
Hey, a salutation is defined as one of the following words:

hi
hey
hello
dear
greetings
hai
guys
hii
howdy
hiya
hay
heya
hola
hihi
salutations

The first letter may be capitalised.
There will always be a comma and/or a single space following the salutation which must also be removed. The comma and the space may be in any order (,<space> or <space>,) and both should be removed.
The greeting and the following word will only ever be separated by a comma and/or single space.
You must then capitalise the first letter of the word which would have followed the salutation. Even if no replacement has taken place, you should still capitalise the first word of the output.
Capitalisation only applies to lowercase alphabetical characters (abcdefghijklmnopqrstuvwxyz). You should leave any other character as it was.
The salutation will always be at the start of the string. You should not replace a salutation which is not at the start.
There may not always be a salutation.
Your code must be under 50 bytes.
Examples
Input > Output

Salutations, what's going on? > What's going on?
hello i have quetions how does juice an avocado > I have quetions how does juice an avocado
How d'you do > How d'you do
Hey,You! > You!
hola cows eat hay > Cows eat hay
hey Hi there! > Hi there!
hihi ,guys > Guys

Test battery
Hola, there are 1000 different inputs in total:

The test battery can be found here where each input is separated by a newline: https://github.com/beta-decay/Remove-Substitutions-Battery/blob/master/inputs.txt
The corresponding correct outputs are here: https://github.com/beta-decay/Remove-Substitutions-Battery/blob/master/replaced.txt

A Bash command to retrieve both the above is
wget https://raw.githubusercontent.com/beta-decay/Remove-Substitutions-Battery/master/{inputs,replaced}.txt

Winning
Howdy, the program with the most correct substitutions from the 1000 inputs above wins.
You must put the percentage of the inputs your program handles correctly in your header like so:
# Language Name, percentage%

I'm not completely sure why Jeff made this a thing, but it makes a nice challenge nevertheless.

s=>System.Text.RegularExpressions.Regex.Replace(); 50 bytes before even a pattern is specified, that's C# out then. (With a regex approach of course)

Python is also out (with regex) :(

You can always return the given input for a score of 31.3%.

Urge to edit out the salutation at the beginning of the challenge rising. ;)

Fun anecdote: I originally started my first post on PPCG with "Hello, world! :)" but noticed as soon as I posted it that SE removed the entirety of that line except the ":)". I was of course mortified that I had done something wrong and immediately removed the smiley as well. Not a trace was left in the revision history, and to this day you and I are the only ones who know about it...

@ETHproductions That was your first post? Wow, I congratulate you :D

GNU sed, 78% 100%
/^\w*[wd]\b/!s/^[dghs][eruaio]\w*\W\+//i
s/./\U&/

(49 bytes)
The test battery is quite limited: we can count which words appear first on each line:
$ sed -e 's/[ ,].*//' inputs.txt | sort | uniq -ic
 40 aight
 33 alright
 33 dear
 33 g'd
 41 good
 36 greetings
 35 guys
 31 hai
 33 hay
 27 hello
 33 hey
 37 heya
 43 hi
 34 hihi
 29 hii
 35 hiya
 45 hola
 79 how
 37 howdy
 33 kowabunga
 39 salutations
 32 speak
 34 sweet
 40 talk
 36 wassup
 34 what's
 38 yo

The salutations to be removed begin with d, g, h or s (or uppercase versions thereof); the non-salutations beginning with those letters are
 33 g'd
 41 good
 79 how
 32 speak
 34 sweet

Ignoring lines where they appear alone, that's 220 false-positives.
So let's just remove initial words beginning with any of those four letters.
When we see an initial word beginning with any of those (/ ^[dghs]\w*), case-insensitively (/i), and followed by at least one non-word character (\W\+), then replace with an empty string.  Then, replace the first character with its uppercase equivalent (s/./\U&/).
That gives us
s/^[dghs]\w*\W\+//i
s/./\U&/

We can now refine this a bit:

The largest set of false-positives is how, so we make the substitution conditional by prefixing with a negative test:
 /^[Hh]ow\b/!

We can also filter on the second letter, to eliminate g'd, speak and sweet:
s/^[dghs][eruaio]\w*\W\+//i

That leaves only good as a false positive.  We can adjust the prefix test to eliminate words ending in either w or d:
/^\w*[wd]\b/!

Demonstration
$ diff -u <(./123478.sed inputs.txt) replaced.txt | grep ^- | wc -l
0

Retina, 68% 72.8% (old) 74.8% 77.5% (new test battery)
i`^h(a[iy]|eya?|i(h?i|ya|)|ello)[ ,]+

T`l`L`^.

Try it online! Edit: Gained 4.8% (old) 2.7% (new) coverage with help from @MartinEnder's tips.

I think you can do [ ,]+  to squeeze out a few more bytes. You can also extract the h from the alternation.

not sure but i\^h(a[iy]|eya?|i(h?i?|ya))[ ,]+` might work meaning you have 8 bytes to spare

@ASCII-only h?i? saves nothing over h?i| and it would match hih (although I don't know whether that's even in the test cases).

Actually, it does save a byte if you do ih?i?|iya.

Maybe i\^h(a[iy]|eya?|ih?i|iya|ola|ello)[ ,]+` then

Would i\^([dghs]\w+)[ ,]+` be cheating?

@manatwork How many false positives does that yield?

@MartinEnder, didn't counted, but the result matches replaced.txt by MD5.

@manatwork That's a bad set of test cases then. You don't even need the parentheses.

Never mind, but maybe i\^h(i|a[iy]|eya?|ih?i|iya|ello)[ ,]+` will be slightly better

Hey, I've changed to a new test battery, can you update your answer with your new score? Thanks

@BetaDecay Updated.

PHP, 60.6%
50 Bytes

<?=ucfirst(preg_replace("#^[dh]\w+.#i","",$argn));

Try it online!
PHP, 59.4%
49 Bytes

<?=ucfirst(preg_replace("#^h\w+,? #i","",$argn));

Try it online!
PHP, 58.4%
50 Bytes

<?=ucfirst(preg_replace("#^[gh]\w+.#i","",$argn));

Try it online!

60.1%: #^[gh]\w+.#

Hey, I've changed to a new test battery, can you update your answer with your new score? Thanks

@BetaDecay is updated

Vim, 55.4% 44.4%
df,<<vgU

Explanation:
df,    Delete until and including the first comma
<<     Remove leading spaces
vgU    Uppercase first letter

Hey, I've changed to a new test battery, can you update your answer with your new score? Thanks

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/


text:
Randomize the scalars of an array
You must fill an array with every number from 0-n inclusive. No numbers should repeat. However they must be in a random order.
Rules
All standard code-golf rules and standard loopholes are banned
The array must be generated pseudo-randomly. Every possible permutation should have a equal probability.
Input
n in any way allowed in the I/O post on meta.
Output
The array of numbers scrambled from 0-n inclusive.

the output can be separated by newlines?

@Riley opps that was meant to be gone sorry.

@DrnglVrgs yes it can

By "numbers" I assume you mean "integers"?

Does it have to be an array, or is a list also acceptable?

@KevinCruijssen if a array is not possible (ahem python) then lists are fine. They are basically the same :P

@2EZ4RTZ And if an array is possible, but longer than using a List? ;)

@KevinCruijssen IMO lists = array but with searching support. So sure use a list

Perl 6, 14 bytes
{pick *,0..$_}

Try it
Expanded:
{           # bare block lambda with implicit parameter ｢$_｣

  pick      # choose randomly without repeats
    *,      # Whatever (all)
    0 .. $_ # Range from 0, to the input (inclusive)
}

05AB1E, 3 bytes
Ý.r

Try it online!
Ý   # Make a list from 0 to input
 .r # Shuffle it randomly

Pyth, 3 bytes
.Sh

Demonstration
.S is shuffle. It implicitly casts an input integer n to the range [0, 1, ..., n-1]. h is +1, and the input is taken implicitly.

R, 16 bytes
sample(0:scan())

reads from stdin. sample randomly samples from the input vector, returning a (pseudo)random sequence.
Try it online!

Jelly, 3 bytes
0rẊ

Try it online!
Explanaion:
0rẊ
0r  Inclusive range 0 to input.
  Ẋ Shuffle.
    Implicit print.

Alternate solution, 3 bytes
‘ḶẊ

Explanation:
‘ḶẊ
‘   Input +1
 Ḷ  Range 0 to argument.
  Ẋ Shuffle.

Try it online!

Python 2, 51 bytes
lambda n:sample(range(n+1),n+1)
from random import*

Try it online!
There is random.shuffle() but it modifies the argument in place instead of returning it...

You can use random.shuffle

@cairdcoinheringaahing Yeah, but that wouldn't work. For example, lambda n:shuffle(range(n+1)) wouldn't write the output anywhere.

PHP, 42 Bytes
$r=range(0,$argn);shuffle($r);print_r($r);

Try it online!

Bash, 18 11 bytes
shuf -i0-$1

Try it online!

If newlines are allowed we can forget the echo part

Japt, 4 bytes
ò öx

Try it online

    :Implicit input of integer U
ò   :Generate array of 0 to U.
öx  :Generate random permutation of array.
    :Implicit output of result.

Gosh darn it, I thought öx would be enough until I noticed the "inclusive" part. (You could replace the x with almost anything else, btw)

@ETHproductions, that was my first thought too.

MATL, 4 bytes
QZ@q

Try it online!
Explanation
Q     % Implicitly input n. Add 1
Z@    % Random permutation of [1 2 ... n+1]
q     % Subtract 1, element-wise. Implicitly display

CJam, 7 6 bytes
1 byte removed thanks to Erik the Outgolfer.
{),mr}

This is an anonymous block (function) that takes an integer from the stack and replaces it with the result. Try it online!
Explanation
{     e# Begin block
)     e# Increment: n+1
,     e# Range: [0 1 ... n]
mr    e# Shuffle
}     e# End block

Isn't {),mr} 1 byte shorter?

@EriktheOutgolfer Indeed! Thanks

Mathematica, 24 bytes
RandomSample@Range[0,#]&

Brachylog, 2 bytes
⟦ṣ

Try it online!
Explanation
⟦     Range from 0 to Input
 ṣ    Shuffle

C#, 76 bytes
using System.Linq;i=>new int[i+1].Select(x=>i--).OrderBy(x=>Guid.NewGuid());

This returns an IOrderedEnumerable, I hope that's okay, or else I need a few more bytes for a .ToArray()

Java 8, 114 111 97 bytes
import java.util.*;n->{List l=new Stack();for(;n>=0;l.add(n--));Collections.shuffle(l);return l;}

-3 bytes and bug-fixed thanks to @OlivierGrégoire.
-4 bytes thanks to @Jakob.
-10 bytes by removing .toArray().
Explanation:
Try it here.
import java.util.*;        // Required import for List, Stack and Collections
n->{                       // Method with integer parameter and Object-array return-type
  List l=new Stack();      //  Initialize a List
  for(;n>=0;l.add(n--));   //  Loop to fill the list with 0 through `n`
  Collections.shuffle(l);  //  Randomly shuffle the List
  return l;                //  Convert the List to an Object-array and return it
}                          // End of method

Bug: doesn't include n. Fix and golf: for(n++;--n>=0;l.add(n));. Also, I say you don't need to return an array. Array and list are the same in most language, so just return the list.

@OlivierGrégoire Woops.. That's what you get for not checking properly and just posting.. Thanks for the bug-fix (and 4 bytes saved in the process).

Well, three actually, because I edited again, having myself introduced another bug: > should be >=.

-4 bytes: use a Stack instead of a Vector and change your loop to for(;n>=0;l.add(n--));. And returning a java.util.List is definitely fine.

Ruby, 20 bytes
->n{[*0..n].shuffle}

Ohm, 2 bytes
#╟

Try it online!

This is a better link.

Pyth, 4 Bytes
.S}0

Try it here!

You can golf to 3 bytes. .S with an integer argument is the same as .SU, and [0..n] can be coded as Uh, so you can use .SUh, which then becomes .Sh.

@EriktheOutgolfer thanks for the hint, but as someone has alread posted the solution you propose I will leave this as this.

Well, it's borderline whether that should've been a separate answer or not, but I believe it counts as a dupe, so even it being allowed, I'd consider it just builtin substitution, so nah, I didn't want to post separate, but isaacg did.

C, 75 bytes
a[99],z,y;f(n){if(n){a[n]=--n;f(n);z=a[n];a[n]=a[y=rand()%(n+1)];a[y]=z;}}

Recursive function that initializes from the array's end on the way in, and swaps with a random element before it on the way out.

What if n > 98?

It would fail, of course, but input range wasn't specified in the problem.  Please don't make me malloc :)

change a into a para to fit the rule more?

67 bytes

Charcoal, 33 bytes
Ａ…·⁰ＮβＦβ«ＡβδＡ‽δθＰＩθ↓Ａ⟦⟧βＦδ¿⁻θκ⊞βκ

Try it online! Link is to verbose version of code.
Apparently it takes 17 bytes to remove an element from a list in Charcoal.
Edit: These days it only takes three bytes, assuming you want to remove all occurrences of the item from the list. This plus other Charcoal changes cut the answer down to 21 bytes: Try it online!

Yikes that is a lot

APL (Dyalog), 5 bytes
?⍨1+⊢

Try it online!
Assumes ⎕IO←0, which is default on many machines.
Explanation
⊢ the right argument
1+ add 1 to it
?⍨ generate numbers 0 .. 1+⊢-1 and randomly deal them in an array so that no two numbers repeat

q/kdb+, 11 bytes
Solution:
{(0-x)?1+x}

Example:
q){(0-x)?1+x}10
5 9 7 1 2 4 8 0 3 10
q){(0-x)?1+x}10
6 10 2 8 4 5 9 0 7 3
q){(0-x)?1+x}10
9 6 4 1 10 8 2 7 0 5

Explanation:
Use the ? operator with a negative input to give the full list of 0->n without duplicates:
{(0-x)?1+x} / solution
{         } / lambda expression
         x  / implicit input
       1+   / add one
      ?     / rand
 (0-x)      / negate x, 'dont put item back in the bag'

TI-83 BASIC, 5 bytes (boring)
randIntNoRep(0,Ans

Yep, a builtin. randIntNoRep( is a two-byte token, and Ans is one byte.
More fun, 34 bytes:
Ans→N
seq(X,X,0,N→L₁
rand(N+1→L₂
SortA(L₂,L₁
L₁

Straight from tibasicdev. Probably golfable, but I haven't found anything yet.
What this does: Sorts a random array, moving elements of the second arg (L₁ here) in the same way as their corresponding elements.

Go, 92 bytes
Mostly losing to the need to seed the PRNG.
import(."fmt";."math/rand";."time")
func f(n int){Seed(Now().UnixNano());Println(Perm(n+1))}

Try it online!

JavaScript (ES6), 51 bytes
n=>[...Array(n+1).keys()].sort(_=>.5-Math.random())

I don't think this is uniform; I've tried f(5) 10 times and 5 has been one of the last two items every time.

Just ran it again a couple of times myself and got 1,5,4,0,2,3 & 1,0,2,5,3,4. EDIT: And a few more https://prnt.sc/fe0goe

Just ran a quick test which runs f(5) 1e5 times and finds the average position of each number in the results. The resulting array was [ 1.42791, 1.43701, 2.00557, 2.6979, 3.3993, 4.03231 ], so I don't think it's uniform. (code)

I think I have a 93 byte solution that could work.  n=>(a=[...Array(n).keys(),n++]).reduce((a,v,i)=>([a[i],a[j]]=[a[j=n*Math.random()|0],v],a),a)?

Sorting on the result of random() isn't uniform. See (for example) https://en.wikipedia.org/wiki/BrowserChoice.eu#Criticism

@kamoroso94 Strictly speaking, shuffling using n* isn't uniform either, you need to use i* for a truly random shuffle.

Aceto, 15 14 16 bytes
@lXp
Y!`n
zi&
0r

Push zero on the stack, read an integer, construct a range and shuffle it:
Y
zi
0r

Set a catch mark, test length for 0, and (in that case) exit:
@lX
 !`

Else print the value, a newline, and jump back to the length test:
   p
   n
  &

(I had to change the code because I realized I misread the question and had constructed a range from 1-n, not 0-n.)

8th, 42 36 34 bytes
Code
>r [] ' a:push 0 r> loop a:shuffle

SED (Stack Effect Diagram) is n -- a
Usage and example
ok> 5 >r [] ' a:push 0 r> loop a:shuffle .
[2,5,0,3,1,4]

Javascript (ES6), 68 bytes
n=>[...Array(n+1)].map((n,i)=>[Math.random(),i]).sort().map(n=>n[1])

Creates an array of form
[[Math.random(), 0],
 [Math.random(), 1],
 [Math.random(), 2],...]

Then sorts it and returns the last elements in the new order

J, 11 Bytes
(?@!A.i.)>:

Explanation:
         >:   | Increment
(?@!A.i.)     | Fork, (f g h) n is evaluated as (f n) g (h n)
      i.      | Integers in range [0,n) inclusive
 ?@!          | Random integer in the range [0, n!)
    A.        | Permute right argument according to left

Examples:
    0 A. i.>:5
0 1 2 3 4 5
    1 A. i.>:5
0 1 2 3 5 4
    (?@!A.i.)>: 5
2 3 5 1 0 4
    (?@!A.i.)>: 5
0 3 5 1 2 4

Tcl, 90 bytes
proc R n {lsort -c {try expr\ rand()>.5 on 9} [if [incr n -1]+2 {concat [R $n] [incr n]}]}

Try it online!

Tcl, 96 bytes
proc R n {proc f a\ b {expr rand()>.5}
set i -1
while \$i<$n {lappend L [incr i]}
lsort -c f $L}

Try it online!

Try to outgolf got the same byte count: https://tio.run/##DcmxCoMwFEbh3af4hwztoLSFbuITOLkaBxsDvXCJl5uUtkiePWY68J3kuBTR3WFCwBF9AqG9N983sYc11JvKvIr4sGHETMEpaMkNx10TWoejTv7XWLzgf6IWuobtch26Z84wYy7ySRHzhMdtKSc

JavaScript ES6, 60 bytes, uniform distribute

f=n=>n?(z=f(n-1),z[n]=z[y=Math.random()*-~n|0],z[y]=n,z):[0]

s={};
for(i=0; i<1000; i++) k=f(2), s[k]=-~s[k];
for(i in s) console.log(i, s[i]);

AWK, 82 80 bytes
{for(n=$1+2;++j<n;$j=j-1);for(srand();--n;){t=$(i=int(n*rand()+1));$i=$n;$n=t}}1

Try it online!
AWK doesn't have a built-in shuffle, so this is the best I could come up with.
The srand() call is needed to prevent each execution from returning the same randomized sequence.
Thanks go to @ceilingcat for moving the call to srand() and the arithmetic tweaks to save 2 bytes.

@ceilingcat if we keep managing to shave off 2 bytes every 5 years, then in 200 years we'll have a 0-byte solution :-)

Thunno 2, 3 bytes
Ėµr

Try it online!
Explanation
Ėµr  # Implicit input
Ė    # Push [0..input]
 µr  # Random shuffle
     # Implicit output

Factor, 25 bytes
[ dup [0,b] swap sample ]

Try it online!
        ! 10
dup     ! 10 10
[0,b]   ! 10 { 0 1 2 3 4 5 6 7 8 9 10 }
swap    ! { 0 1 2 3 4 5 6 7 8 9 10 } 10
sample  ! { 3 6 9 10 4 8 2 5 7 0 }

Arturo, 17 bytes
$=>[shuffle@0..&]

Try it!
$=>[          ; a function where input is assigned to &
    0..&      ; a range from 0 to input inclusive
    @         ; reify the range (make it a concrete array)
    shuffle   ; shuffle it
]             ; end function

RProgN 2, 3 bytes
0Rñ

Explained
0Rñ
0R  # Range of numbers 0-n (Implicit input)
  ñ # Shuffle, Implicit output.

Try it online!

Perl 5, 21 bytes
@a{0..<>}=$,=$/;say%a

Try it online!

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
Miller-Rabin Strong Pseudoprimes
Given a non-negative integer N, output the smallest odd positive integer that is a strong pseudoprime to all of the first N prime bases.
This is OEIS sequence A014233.
Test Cases (one-indexed)
1       2047
2       1373653
3       25326001
4       3215031751
5       2152302898747
6       3474749660383
7       341550071728321
8       341550071728321
9       3825123056546413051
10      3825123056546413051
11      3825123056546413051
12      318665857834031151167461
13      3317044064679887385961981

Test cases for N > 13 are not available because those values have not been found yet. If you manage to find the next term(s) in the sequence, be sure to submit it/them to OEIS!
Rules

You may choose to take N as a zero-indexed or a one-indexed value.
It's acceptable for your solution to only work for the values representable within your language's integer range (so up to N = 12 for unsigned 64-bit integers), but your solution must theoretically work for any input with the assumption that your language supports arbitrary-length integers.

Background
Any positive even integer x can be written in the form x = d*2^s where d is odd. d and s can be computed by repeatedly dividing n by 2 until the quotient is no longer divisible by 2. d is that final quotient, and s is the number of times 2 divides n.
If a positive integer n is prime, then Fermat's little theorem states:

In any finite field Z/pZ (where p is some prime), the only square roots of 1 are 1 and -1 (or, equivalently, 1 and p-1).
We can use these three facts to prove that one of the following two statements must be true for a prime n (where d*2^s = n-1 and r is some integer in [0, s)):

The Miller-Rabin primality test operates by testing the contrapositive of the above claim: if there is a base a such that both of the above conditions are false, then n is not prime. That base a is called a witness.
Now, testing every base in [1, n) would be prohibitively expensive in computation time for large n. There is a probabilistic variant of the Miller-Rabin test that only tests some randomly-chosen bases in the finite field. However, it was discovered that testing only prime a bases is sufficient, and thus the test can be performed in an efficient and deterministic manner. In fact, not all of the prime bases need to be tested - only a certain number are required, and that number is dependent on the size of the value being tested for primality.
If an insufficient number of prime bases are tested, the test can produce false positives - odd composite integers where the test fails to prove their compositeness. Specifically, if a base a fails to prove the compositeness of an odd composite number, that number is called a strong pseudoprime to base a. This challenge is about finding the odd composite numbers who are strong psuedoprimes to all bases less than or equal to the Nth prime number (which is equivalent to saying that they are strong pseudoprimes to all prime bases less than or equal to the Nth prime number).

Sandbox post (now deleted)

Is an algorithm that test all odd value from 1 to result for strong pseudo-primality allowed by the rules?

@user202729 I don't see why it wouldn't be. What would make you think it is?

I would suggest making this a [tag:fastest-code] question because most answers will simply be brute force.

@NeilA. I disagree that this would be better as fastest code. While it's true that answers will almost certainly be brute force (since another algorithm hasn't yet been developed and I don't expect PPCG to do so), code golf is much simpler, has a much lower barrier for entry (since the submitters can score their own solutions), doesn't require me to run and score every solution (and deal with the exorbitant runtimes), and the problem is interesting enough as a golf challenge.

Python 2, 633 465 435 292 282 275 256 247 bytes
0-indexed

Question your implementation and try something new

Converting from a function to a program saves some bytes somehow...
If Python 2 gives me a shorter way to do the same thing, I'm going to use Python 2. Division is by default integer, so an easier way to divide by 2, and print doesn't need parentheses.
n=input()
f=i=3
z={2}
a=lambda:min([i%k for k in range(2,i)])
while n:
 if a():z|={i};n-=1
 i+=2
while f:
 i+=2;d,s,f=~-i,0,a()
 while~d&1:d/=2;s+=1
 for y in z:
  x=y**d%i
  if x-1:
   for _ in[]*s:
    x*=x
    if~x%i<1:break
   else:f=1
print i

Try it online!
Python is notoriously slow compared to other languages.
Defines a trial division test for absolute correctness, then repeatedly applies the Miller-Rabin test until a pseudoprime is found.
Try it online!
EDIT: Finally golfed the answer
EDIT: Used min for the trial division primality test and changed it to a lambda. Less efficient, but shorter. Also couldn't help myself and used a couple of bitwise operators (no length difference). In theory it should work (slightly) faster.
EDIT: Thanks @Dave. My editor trolled me. I thought I was using tabs but it was being converted to 4 spaces instead. Also went through pretty much every single Python tip and applied it.
EDIT: Switched to 0-indexing, allows me to save a couple of bytes with generating the primes. Also rethought a couple of comparisons
EDIT: Used a variable to store the result of the tests instead of for/else statements.
EDIT: Moved the lambda inside the function to eliminate the need for a parameter.
EDIT: Converted to a program to save bytes
EDIT: Python 2 saves me bytes! Also I don't have to convert the input to int

+1 for the way you handled a^(d*2^r) mod n!

Are you aware that you can use single-space (or single-tab) indentation in Python to save… a whole lot of bytes, actually

@Dave: This is using 1 tab per indentation level

I think your IDE is messing with you and saving spaces while telling you it's using tabs; when I replace them for single spaces, I get a byte count of just 311 bytes! Try it online!

@Dave: Ok, that's weird, thanks, I'll update the answer.

Can't you use if~-x rather than if x!=1?

@Challenger5: x is not a boolean (i.e. it can be something other than 0 or 1

Is x a number?

@Challenger5. Yes. It represents the expression on the left side of the congruence statements.

@NeilA. Then I don't understand your comment that x can be something other than 0 or 1. My technique should work on all numbers.

Let us continue this discussion in chat.

C, 349 295 277 267 255 bytes
N,i;__int128 n=2,b,o,l[999];P(m){i<N&&P(m<2?l[i++]=n:n%m?m-1:n++);}main(r){for(P(scanf("%d",&N));r|!b;)for(++n,b=i=N;i--&&b;){for(b=n-1,r=0;~b&1;b/=2)++r;for(o=1;b--;o=o*l[i]%n);for(b=o==1;r--;o=o*o%n)b|=o>n-2;for(o=r=1;++o<n;r&=n%o>0);}printf("%llu",n);}

Takes 1-based input on stdin, e.g.:
echo "1" | ./millerRabin

It certainly isn't going to discover any new values in the sequence any time soon, but it gets the job done. UPDATE: now even slower!

Slightly faster and shorter, with inspiration from Neil A's answer (a^(d*2^r) == (a^d)^(2^r))
Significantly slower again after realising that all solutions to this challenge will be odd, so there is no need to explicitly enforce that we only check odd numbers.
Now using GCC's __int128, which is shorter than unsigned long long while also working with larger numbers! Also on little-endian machines, the printf with %llu still works fine.

Less-minified
N,i;
__int128 n=2,b,o,l[999];
P(m){i<N&&P(m<2?l[i++]=n:n%m?m-1:n++);}
main(r){
    for(P(scanf("%d",&N));r|!b;)
        for(++n,b=i=N;i--&&b;){
            for(b=n-1,r=0;~b&1;b/=2)++r;
            for(o=1;b--;o=o*l[i]%n);
            for(b=o==1;r--;o=o*o%n)b|=o>n-2;
            for(o=r=1;++o<n;r&=n%o>0);
        }
    printf("%llu",n);
}

(Outdated) Breakdown
unsigned long long                  // Use the longest type available
n=2,N,b,i,d,p,o,                    // Globals (mostly share names with question)
l[999];                             // Primes to check (limited to 999, but if you
                                    // want it to be "unlimited", change to -1u)
m(){for(o=1;p--;o=o*l[i]%n);}       // Inefficiently calculates (l[i]^p) mod n

// I cannot possibly take credit for this amazing prime finder;
// See https://codegolf.stackexchange.com/a/5818/8927
P(m){i<N&&P(m<2?l[i++]=n:n%m?m-1:n++);}

main(r){
    for(
        P(scanf("%llu",&N));        // Read & calculate desired number of primes
        r|!b;){                     // While we haven't got an answer:
        n=n+1|1;                    // Advance to next odd number
        for(b=1,i=N;i--&&b;){       // For each prime...
            for(d=n-1,r=0;~d&1;d/=2)++r; // Calculate d and r: d*2^r = n-1
            // Check if there exists any r such that a^(d*2^r) == -1 mod n
            // OR a^d == 1 mod n
            m(p=d);
            for(b=o==1;r--;b|=o==n-1)m(p=d<<r);
            // If neither of these exist, we have proven n is not prime,
            // and the outer loop will keep going (!b)
        }
        // Check if n is actually prime;
        // if it is, the outer loop will keep going (r)
        for(i=r=1;++i<n;r&=n%i!=0);
    }
    printf("%llu",n);               // We found a non-prime; print it & stop.
}

As mentioned, this uses 1-based input. But for n=0 it produces 9, which follows the related sequence https://oeis.org/A006945. Not any more; now it hangs on 0.
Should work for all n (at least until the output reaches 2^64) but is incredibly slow. I have verified it on n=0, n=1 and (after a lot of waiting), n=2.

I make a breakthrough on my solution, and then you just one-up me... Nice!

@NeilA. Sorry! I was playing with shorter int types before you posted your update. I'm sure you'll find 2 bytes somewhere though; this is turning out to be surprisingly competitive considering it's 2 different non-golfing languages :D

252 bytes

Perl + Math::Prime::Util, 81 + 27 = 108 bytes
1 until!is_provable_prime(++$\)&&is_strong_pseudoprime($\,2..nth_prime($_));$_=""

Run with -lpMMath::Prime::Util=:all (27-byte penalty, ouch).
Explanation
It's not just Mathematica that has a builtin for basically anything. Perl has CPAN, one of the first large library repositories, and that has a huge collection of ready-made solutions for tasks like this one. Unfortunately, they aren't imported (or even installed) by default, meaning that it's basically never a good option to use them in code-golf, but when one of them happens to fit the problem perfectly…
We run through consecutive integers until we find one that's not prime, and yet a strong pseudoprime to all integer bases from 2 to the nth prime. The command-line option imports the library that contains the builtin in question, and also sets implicit input (to line-at-a-time; Math::Prime::Util has its own builtin bignum library that doesn't like newlines in its integers). This uses the standard Perl trick of using $\ (output line separator) as a variable in order to reduce awkward parses and allow the output to be generated implicitly.
Note that we need to use is_provable_prime here to request a deterministic, rather than probabilistic, prime test. (Especially given that a probabilistic prime test is likely using Miller-Rabin in the first place, which we can't expect to give reliable results in this case!)
Perl + Math::Prime::Util, 71 + 17 = 88 bytes, in collaboration with @Dada
1until!is_provable_prime(++$\)&is_strong_pseudoprime$\,2..nth_prime$_}{

Run with -lpMntheory=:all (17 byte penalty).
This uses a few Perl golfing tricks that I either didn't know (apparently Math::Prime::Util has an abbreviation!), knew about but didn't think of using (}{ to output $\ implicitly once, rather than "$_$\" implicitly every line), or knew about but somehow managed to misapply (removing parentheses from function calls). Thanks to @Dada for pointing these out to me. Apart from that, it's identical.

Of course a golf-ish language comes and beats the rest. Well done!

You can use ntheory instead of Math::Prime::Util. Also, }{ instead of ;$_="" should be fine. And you can omit the space after 1 and the parenthesis of a few function calls. Also, & works instead of &&. That should give 88 bytes: perl -Mntheory=:all -lpe '1until!is_provable_prime(++$\)&is_strong_pseudoprime$\,2..nth_prime$_}{'

I'd completely forgotten about }{. (Strangely enough, I remembered the parenthesis thing but it's been a while since I golfed in Perl and couldn't remember the rules for leaving it out.) I didn't know about the ntheory abbreviation at all, though.