text:
Smallest Prime with a Twist (A068103)
The task at hand is, given a number n, find the smallest prime that starts with AT LEAST n of the number 2 at the beginning of the number. This is a sequence I found on  OEIS (A068103).
The first 17 numbers in the sequence are given below, if you want more I'll have to actually go implement the sequence, which I don't mind doing.
0  = 2
1  = 2
2  = 223
3  = 2221
4  = 22229
5  = 2222203
6  = 22222223                # Notice how 6 and 7 are the same!
7  = 22222223                # It must be **AT LEAST** 6, but no more than necessary.
8  = 222222227
9  = 22222222223             # Notice how 9 and 10 are the same!
10 = 22222222223             # It must be **AT LEAST** 9, but no more than necessary.
11 = 2222222222243
12 = 22222222222201
13 = 22222222222229
14 = 222222222222227
15 = 222222222222222043
16 = 222222222222222221

Just thought this would be a cool combination of string manipulation, prime detection and sequences. This is code-golf, lowest byte count will be declared the winner probably at the end of the month.

Is there a lower limit to how high of an input we must support?

Is there a time limit?

@ETHProductions sorry, went away rather quickly after writing this one. If you must limit your input, the limitation must be backed wit ha logical argument of why the language does not support numbers higher than x. For instance if your language only supports 32-bit integers, you may explain that.

Brachylog, 12 11 bytes
:2rj:Acb#p=

Try it online!
This translates into Brachylog surprisingly directly. This is a function, not a full program (although giving the interpreter Z as a command-line argument causes it to add the appropriate wrapper to make the function into a program; that's what I did to make the TIO link work). It's also fairly unfortunate that j appears to be -1-indexed and needs a correction to allow for that.
You can make a reasonable argument that the = isn't necessary, but I think that given the way the problem's worded, it is; without, the function's describing the set of all prime numbers that start with the given number of 2s, and without some explicit statement that the program should do something with this description (in this case, generating the first value), it probably doesn't comply with the spec.
Explanation
:2rjbAcb#p=
:2rj         2 repeated a number of times equal to the input plus one
    :Ac      with something appended to it
       b     minus the first element
        #p   is prime;
          =  figure out what the resulting values are and return them

When used as a function returning an integer, nothing ever requests values past the first, so the first is all we have to worry about.
One subtlety (pointed out in the comments): :Acb and b:Ac are mathematically equivalent (as one removes from the start and the other adds to the end, with the region in between never overlapping); I previously had b:Ac, which is more natural, but it breaks on input 0 (which I'm guessing is because c refuses to concatenate an empty list to anything; many Brachylog builtins tend to break on empty lists for some reason). :Acb ensures that c never has to see an empty list, meaning that the case of input 0 can now work too.

@muddyfish: It does. However, it didn't work for 0, for no apparent reason (Brachylog appears to be allergic to zeroes for some reason; I suspect the c is responsible). That said, it's easy enough to fix, so I'll fix that now.

b:Ac does not work because for input 0 you get 2b:Ac: 2b gives 0 and you can't use c with a leading zero. The reason for this is to avoid infinite loops in the general case where you could always prepend a zero and have the same results.

Also, you can shorten this by one byte by writing :2rj instead of ,2:?j

I forgot about r; that's just a plain improvement. I understand what's going on with c (you don't want infinitely many results when run backwards); however, a likely improvement there is to disallow degenerate inputs only if they're unbound, whilst allowing them when the input is already bound to a degenerate value.

This is definitely doable and I will add it in the Github tracker. Though concatenate's implementation is already almost 100 lines long which is a lot for a Prolog predicate.

Awesome solution! Please consider using relation instead of function: You can use this more generally, also with variable arguments.

@mat: The proper term in Prolog would be "predicate". However, In this case I'm only "claiming" the special case when it's used like a function, due to PPCG rules that require a program or function to be submitted. (Besides, this wouldn't really run "in reverse" properly, because all numbers start with at least 0 leading 2s.)

Java (OpenJDK 8), 164 110 bytes
a->{int i=0;for(;!(i+"").matches("2{"+a+"}.*")|new String(new char[i]).matches(".?|(..+)\\1+");i++);return i;}

Thanks to @FryAmTheEggman for a bunch of bytes!
Try it online!

Could you explain how a primarily checking regex works?

I have no idea. It's not mine, and I don't know who the original creator is. I just now that is takes a string of length n and matches if n isn't prime.

Do you know what the original source is? Where did you learn about it? Have you tested your code?

I'm just asking because it sounds sketch

I have not, I'm on my phone and won't be home for a while. Here's a StackOverflow explaining it.

@Pavel That primality checking regex makes this answer freaking amazing, even if you didn't make it. You should add that to the "Tips for Golfing in Java" thread.

I can't test the code right now but I'm pretty sure the regex works like this: new String(new char[i])) makes a unary string of length equal to the number. Then the regex matches a composite numbers by checking if repeating a set of digits fits the whole string (basically trial division). If I'm correct, that means you should be able to golf the second part not to have a ?, I'll let you know for sure when I get to a computer.

I end up having to write a special case for 0, so it could probably be golfed more.

This seems to work for 120. Very slow for larger numbers.

Pyth, 12 bytes
f&!x`T*Q\2P_

In pseudocode:
f                key_of_first_truthy_value( lambda T:
  !                  not (
   x`T*Q\2               repr(T).index(input()*'2')
                     )
 &                   and
          P_T        is_prime(T)
                 )

Loops the lambda starting from T=1, incrementing by 1 until the condition is satisfied. The string of 2s must be a substring from the beginning of the string, i.e. the index method needs to return 0. If the substring is not found it returns -1 which conveniently is also truthy, so no exceptional case exists.
You can try it online here, but the server only allows up to an input of 4.

Perl, 50 bytes
49 bytes of code + -p flag.
++$\=~/^2{$_}/&&(1x$\)!~/^1?$|^(11+)\1+$/||redo}{

Supply the input without final newline. For instance:
echo -n 4 | perl -pE '++$\=~/^2{$_}/&&(1x$\)!~/^1?$|^(11+)\1+$/||redo}{'

This take a while to run a numbers greater than 4 as it test every number (there are 2 test: the first one /^2{$_}/ checks if there is enough 2 at the beginning, and the second one (1x$\)!~/^1?$|^(11+)\1+$/ tests for primality (with very poor performances)).

Haskell, 73 bytes
f n=[x|x<-[2..],all((>0).mod x)[3..x-1],take n(show x)==([1..n]>>"2")]!!0

Usage example: f 3 -> 2221.
Brute force. [1..n]>>"2" creates a list of n 2s which is compared to the first n chars in the string representation of the current prime.

Mathematica, 103 bytes
ReplaceRepeated[0,i_/;!IntegerDigits@i~MatchQ~{2~Repeated~{#},___}||!PrimeQ@i:>i+1,MaxIterations->∞]&

Unnamed function taking a nonnegative integer argument # and returning an integer. It literally tests all positive integers in turn until it finds one that both starts with # 2s and is prime. Horribly slow for inputs above 5.
previous result: Mathematica, 155 bytes
Mathematica would be better for golfing if it weren't so strongly typed; we have to explicitly switch back and forth between integer/list/string types.
(d=FromDigits)[2&~Array~#~Join~{1}//.{j___,k_}/;!PrimeQ@d@{j,k}:>({j,k+1}//.{a__,b_,10,c___}->{a,b+1,0,c}/.{a:Repeated[2,#-1],3,b:0..}->{a,2,0,b})]/. 23->2&

This algorithm operates on lists of digits, strangely, starting with {2,...,2,1}. As long as those aren't the digits of a prime number it adds one to the last digit, using the rule {j___,k_}/;!PrimeQ@d@{j,k}:>({j,k+1} ... and then manually implements carrying-the-one-to-the-next-digit as long as any of the digits equal 10, using the rule {a__,b_,10,c___}->{a,b+1,0,c} ... and then, if we've gone so far that the last of the leading 2s has turned into a 3, starts over with another digit on the end, using the rule {a,b+1,0,c}/.{a:Repeated[2,#-1],3,b:0..}->{a,2,0,b}. The /. 23->2 at the end just fixes the special case where the input is 1: most primes can't end in 2, but 2 can. (A few errors are spat out on the inputs 0 and 1, but the function finds its way to the right answer.)
This algorithm is quite fast: for example, on my laptop it takes less than 3 seconds to compute that the first prime starting with 1,000 2s is 22...220521.

Pyth, 17 bytes
f&q\2{<`T|Q1}TPTh

Can't seem to solve over n = 4 online, but it's correct in theory.
Explanation
               Th    Starting from (input)+1,
f                    find the first T so that
      <              the first
          Q          (input) characters
         | 1         or 1 character, if (input) == 0
       `T            of T's string representation
     {               with duplicates removed
  q\2                equal "2",
 &                   and
            }T       T is found in
              PT     the list of T's prime factors.

Perl 6, 53 bytes
{($/=2 x$^n-1)~first {+($/~$_) .is-prime&&/^2/},0..*}

Try it
Expanded:
{
  ( $/ = 2 x $^n-1 )       # add n-1 '2's to the front (cache in ｢$/｣)
  ~
  first {
    +( $/ ~ $_ ) .is-prime # find the first that when combined with ｢$/｣ is prime
    &&
    /^2/                   # that starts with a 2 (the rest are in ｢$/｣)
  },
  0..*
}

Jelly, 14 bytes
D=2×\S:³aÆPµ1#

Very inefficient. Try it online!

Sage, 69 68 bytes
lambda n:(x for x in Primes()if '2'*len(`x`)=>'2'*n==`x`[:n]).next()

Uses a generator to find the first (hence smallest) of infinitely many terms.

Pyke, 14 bytes
.fj`Q\2*.^j_P&

Try it here!
.fj            - first number (asj)
   `    .^     -   str(i).startswith(V)
    Q\2*       -    input*"2"
             & -  ^ & V
          j_P  -   is_prime(j)

12 bytes after bugfix and a new feature
~p#`Q\2*.^)h

Try it here!
~p           - all the primes
  #       )h - get the first where...
   `    .^   - str(i).startswith(V)
    Q\2*     -  input*"2"

Japt, 20 bytes
L²o@'2pU +Xs s1)nÃæj

Test it online! It finishes within two seconds on my machine for all inputs up to 14, and after that it naturally loses precision (JavaScript only has integer precision up to 253).
Many thanks to @obarakon for working on this :-)
Explanation
                       // Implicit: U = input integer, L = 100
L²o                    // Generate the range [0...100²).
   @             Ã     // Map each item X through the following function:
    '2pU               //   Take a string of U "2"s.
         +Xs s1)n      //   Append all but the first digit of X, and cast to a number.
                       // If U = 3, we now have the list [222, 222, ..., 2220, 2221, ..., 222999].
                  æ    // Take the first item that returns a truthy value when:
                   j   //   it is checked for primality.
                       // This returns the first prime in the forementioned list.
                       // Implicit: output result of last expression

In the latest version of Japt, this can be 12 bytes:
_n j}b!+'2pU   // Implicit: U = input integer
_   }b         // Return the first non-negative bijective base-10 integer that returns
               // a truthy value when run through this function, but first,
      !+       //   prepend to each integer
        '2pU   //   a string of U '2's.
               // Now back to the filter function:
 n j           //   Cast to a number and check for primality.
               // Implicit: output result of last expression

Test it online! It finishes within half a second on my machine for all inputs up to 14.

Great solution!

This fails on the input 5, since you never test 2222203, only 222223 and soon thereafter 2222210. It also fails on any input that requires three or more additional digits after the string of 2s, such as the input 15.

@GregMartin Darn, you're right. Fixed at the cost of 5 bytes.

This fixes the test cases, but the algorithm still assumes that one will never have to add more than three digits to find a prime, which can be false for larger inputs.

@GregMartin This works for all test cases up to 14, and JS runs into integer precision problems at case 15. I don't think the algorithm needs to be theoretically correct past 2^53, but perhaps I'm wrong...

Fair enough, the OP did comment that limitations forced by language features are acceptable.

PHP, 76 bytes
for($h=str_pad(2,$i=$argv[1],2);$i>1;)for($i=$p=$h.++$n;$p%--$i;);echo$p?:2;

takes input from command line argument. Run with -r.
breakdown
for($h=str_pad(2,$i=$argv[1],2) # init $h to required head
    ;$i>1;                      # start loop if $p>2; continue while $p is not prime
)
    for($i=$p=$h.++$n               # 1. $p = next number starting with $h
                                    #    (first iteration: $p is even and >2 => no prime)
    ;$p%--$i;);                     # 2. loop until $i<$p and $p%$i==0 ($i=1 for primes)
echo$p?:2;                      # print result; `2` if $p is unset (= loop not started)

Bash (+coreutils), 53 bytes
Works up to 2^63-1 (9223372036854775807),
takes considerable time to finish for N > 8.
Golfed
seq $[2**63-1]|factor|grep -Pom1 "^2{$1}.*(?=: \S*$)"

Test
>seq 0 7|xargs -L1 ./twist

2
2
223
2221
22229
2222203
22222223
22222223

Python 3, 406 bytes
w=2,3,5,7,11,13,17,19,23,29,31,37,41
def p(n):
 for q in w:
  if n%q<1:return n==q
  if q*q>n:return 1
 m=n-1;s,d=-1,m
 while d%2==0:s,d=s+1,d//2
 for a in w:
  x=pow(a,d,n)
  if x in(1,m):continue
  for _ in range(s):
   x=x*x%n
   if x==1:return 0
   if x==m:break
  else:return 0
 return 1
def f(i):
 if i<2:return 2
 k=1
 while k:
  k*=10;l=int('2'*i)*k
  for n in range(l+1,l+k,2):
   if p(n):return n

test code
for i in range(31):
    print('{:2} = {}'.format(i, f(i)))

test output
 0 = 2
 1 = 2
 2 = 223
 3 = 2221
 4 = 22229
 5 = 2222203
 6 = 22222223
 7 = 22222223
 8 = 222222227
 9 = 22222222223
10 = 22222222223
11 = 2222222222243
12 = 22222222222201
13 = 22222222222229
14 = 222222222222227
15 = 222222222222222043
16 = 222222222222222221
17 = 222222222222222221
18 = 22222222222222222253
19 = 222222222222222222277
20 = 2222222222222222222239
21 = 22222222222222222222201
22 = 222222222222222222222283
23 = 2222222222222222222222237
24 = 22222222222222222222222219
25 = 222222222222222222222222239
26 = 2222222222222222222222222209
27 = 2222222222222222222222222227
28 = 222222222222222222222222222269
29 = 2222222222222222222222222222201
30 = 222222222222222222222222222222053

I decided to go for speed over a fairly large range, rather than byte size. :) I use a deterministic Miller-Rabin primality test which is guaranteed up to 3317044064679887385961981 with this set of witnesses. Larger primes will always successfully pass the test, but some composites may also pass, although the probability is extremely low. However, I also tested the output numbers for i > 22 using pyecm an Elliptic Curve factorization program, and they appear to be prime.

First off: submissions need to have a probability 1 chance of correct output. secondofly, this is codegolf, so you actually have to go for byte size. Other than that, nice

@DestructibleWatermelon Thanks! Fair point about going for byte size. I guess I could inline the p() call... OTOH, it'd be hard to write a significantly smaller program that can give correct output for i > 20 in under a second (that doesn't "cheat" by calling a built-in primality checker). :)

Many programs cannot handle a 33 digit number (n:=30). Given that OP's golden standard goes up to 18 digits only and there is no limit otherwise set by him/her it is reasonable to assume that n:=30 is good enough IMO.

@PM2Ring It doesn't need to be in "under a second". Make the code as short as you can, and ignore speed altogether. That's the spirit of [code-golf]. I'll change my downvote to an upvote once it's golfed.

actually, if it does produce correct output up to the limit, then the answer does work with probability one.

Python 3, 132 bytes
def f(x):
 k=10;p=2*(k**x//9)
 while x>1:
  for n in range(p*k,p*k+k):
   if all(n%q for q in range(2,n)):return n
  k*=10
 return 2

Any hope of performance has been sacrificed for a smaller byte count.

Husk, 10 bytes
ḟo`€R⁰2dİp

Try it online!
A bit slow due to uusing the infinite list of primes.

Java, 163 bytes
BigInteger f(int a){for(int x=1;x>0;x+=2){BigInteger b=new BigInteger(new String(new char[a]).replace("\0","2")+x);if(b.isProbablePrime(99))return b;}return null;}

test code
    public static void main(String[] args) {
    for(int i = 2; i < 65; i++)
        System.out.println(i + " " + new Test20170105().f(i));
    }

output:
2 223
3 2221
4 22229
5 2222219
6 22222223
7 22222223
8 222222227
9 22222222223
10 22222222223
11 2222222222243
12 22222222222229
13 22222222222229
14 222222222222227
15 222222222222222143
16 222222222222222221
17 222222222222222221
18 22222222222222222253
19 222222222222222222277
20 2222222222222222222239
21 22222222222222222222261
22 222222222222222222222283
23 2222222222222222222222237
24 22222222222222222222222219
25 222222222222222222222222239
26 2222222222222222222222222213
27 2222222222222222222222222227
28 222222222222222222222222222269
29 22222222222222222222222222222133
30 222222222222222222222222222222113
31 222222222222222222222222222222257
32 2222222222222222222222222222222243
33 22222222222222222222222222222222261
34 222222222222222222222222222222222223
35 222222222222222222222222222222222223
36 22222222222222222222222222222222222273
37 222222222222222222222222222222222222241
38 2222222222222222222222222222222222222287
39 22222222222222222222222222222222222222271
40 2222222222222222222222222222222222222222357
41 22222222222222222222222222222222222222222339
42 222222222222222222222222222222222222222222109
43 222222222222222222222222222222222222222222281
44 2222222222222222222222222222222222222222222297
45 22222222222222222222222222222222222222222222273
46 222222222222222222222222222222222222222222222253
47 2222222222222222222222222222222222222222222222219
48 22222222222222222222222222222222222222222222222219
49 2222222222222222222222222222222222222222222222222113
50 2222222222222222222222222222222222222222222222222279
51 22222222222222222222222222222222222222222222222222289
52 2222222222222222222222222222222222222222222222222222449
53 22222222222222222222222222222222222222222222222222222169
54 222222222222222222222222222222222222222222222222222222251
55 222222222222222222222222222222222222222222222222222222251
56 2222222222222222222222222222222222222222222222222222222213
57 222222222222222222222222222222222222222222222222222222222449
58 2222222222222222222222222222222222222222222222222222222222137
59 22222222222222222222222222222222222222222222222222222222222373
60 222222222222222222222222222222222222222222222222222222222222563
61 2222222222222222222222222222222222222222222222222222222222222129
62 2222222222222222222222222222222222222222222222222222222222222227
63 2222222222222222222222222222222222222222222222222222222222222227
64 2222222222222222222222222222222222222222222222222222222222222222203

582.5858 milliseconds
Explanation: loops over integers and adds them as strings to the root string, which is the given "2's" string, and verifies if it's prime or not.

isProbablePrime has occasional false positives. That would invalidate the answer, as there are circumstances in which it returns the wrong value.

The probability of mistake is less than 2^-99 (see documentation).

@SamCle88 small probability or not, this is wrong on a technicality. isProbablePrime is not acceptable for prime verification and has been denied on other challenges.


text:
Print all ASCII alphanumeric characters without using them
Challenge
Print the following characters:
abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890

The catch is that you may not use any one of them in your code.
You may print them in arbitrary order, with or without a leading or trailing newline, but you may not print any other characters.
Rules

You may not use any characters from the set mentioned above
You may use any other characters
No cheating
Standard loopholes banned
This is code-golf, shortest answer wins.

Clarifications

If your language uses a different charset, you may not use codepoints in that charset that correspond to alphanumeric characters.
Returning a string from a function is considered a valid form of output.
You may return a char array.

This is somewhat ambiguous. If you mean output those raw bytes without those bytes in your code, then you should specify that you can't use the codepoints of these characters, even if they map to something else in your language's codepage.

So this means that I cannot use any letters or numbers in my source code. Well, that pretty much takes out any non-esoteric languages.

What if the language is just raw bytes (as opcodes) that don't have a representation? Am I free to use any characters?

Duplicates allowed?

@wat if the ASCII codes are printed does it matter if their underlying data type is int as opposed to actually being a char? That is, can we output the numerical values, or must it be seen on the screen as the printable characters?

@briantist it's fine if they're internally represented by ints, but the characters themselves have to be printed.

@R.Kap Javascript could work, provided you don't think of it as eso

If the code accesses an external file, do you intend to also prohibit those characters (or their codepoints) from appearing in the file?

Is it OK to output some characters several times? Or should the output be exactly 26+26+10 characters?

@user2428118 no

@anatolyg no;yes

I meant my question seriously

@FlipTack You can't use the bytes that correspond to the ASCII codes of those characters.

Trying to think of a way to achieve this in Perl 5, supposedly one of the most punctuation-laden of languages, but it's actually quite hard to do anything without letters and numbers. Something like $\->$&($")can eliminate the need to spell outprint(if you can get the values "STDOUT", "print" (or "say"), and your desired output into the three variables).STDOUTis a key in%::, but how does one find it there without fororgrep` or anything of the sort?

I like the clarification "Rules: No cheating"

Why didn’t https://codegolf.stackexchange.com/a/105784/78446 win

@ArvinSingh I didn't see it. Fixed.

V, 8 7 bytes
1 byte saved thanks to @DJMcMayhem by putting it all in one regex statement
¬/{Ó×ü_

Try it online!
Outputs:
0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Note: × is not x or X, it is 0xd7
Hexdump:
00000000: ac2f 7bd3 d7fc 5f                        ./{..._

Explanation
¬/{            " inserts every character in the range / to {

Now the output looks like:
/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{

We have to remove all the non-alphanumeric characters and the _ (since it is not included in \W), so let's do that using regex
Ó×ü_           " removes every character that is non-alphanumeric or an underscore _
               " vim equivalent of :s/\W\|_//g

Amazing! +1 for beating me to it. :) Also, You could simplify it down to one regex if you did Ó×ü_ (which is equivalent to :s/\W\|_//g)

Octave, 52 46 40 bytes
['['-('"':'+'),'{'-(_='!':':'),_+'@','']

This evaluates to
9876543210ZYXWVUTSRQPONMLKJIHGFEDCBAabcdefghijklmnopqrstuvwxyz

Explanation
Here we are using the fact that characters are implicitly converted to integers when arithmetic operations like +- or the range function : are applied. When concatenated with an empty string ([...,'']), the numbers again are converted to characters.
Try it online!

+1 for being the first non-esoteric language in a challenge very suited to esolangs.

A big +1, not for using Octave (it's quite straight forward), but for golfing this very well, and using _ as a variable! I had no idea it was possible... Nice!

When concatenated with an empty string ([...,'']), the numbers again are converted to characters.... very nice

brainfuck, 77 76 75 72 bytes
++++++++[>+>++++++>++++>-<<<<-]>++[>.+<-]>>[>+>++>+++<<<-]>++[>+.>+.<<-]

Try it online!
How it works
The interpreter begins with a tape of 0 cells.
++++++++

This sets the first cell to 8, leaving the tape in the following state.
   8
   ^

[>+>++++++>++++>-<<<<-]

This increments the second cell once, the third cell 6 times, the fourth cell 4 times, decrements the fifth cell once, then goes back to the beginning of the tape and decrements the first cell. After 8 iterations, the tape looks like follows.
  0   8  48  32  -8
  ^

>++

We advance to the second cell and increment it twice, getting ready to print the digits.
  0  10  48  32  -8
      ^

[>.+<-]

This prints the third cell, increments it, then goes back to the second cell and decrements it. After 10 iterations, we've printed 0123456789 and the tape looks like follows.
  0   0  58  32  -8
      ^

>>

Time to prep the tape for the letters! We begin by advancing two cells.
  0   0  58  32  -8   0   0
              ^

[>+>++>+++<<<-]

This increments the fifth cell once, the sixth cell twice, the seventh cell thrice, then goes back to the fourth cell and decrements it. After 32 iterations, the tape looks like follows.
  0   0  58   0  24  64  96
              ^

>++

As a last step before printing the letters, we advance to the fifth cell and increment it twice.
  0   0  58   0  26  64  96
                  ^

[>+.>+.<<-]

Finally, we advance to the sixth cell to increment and print it, do the same for the seventh cell, then go back to the fifth cell and decrement it. After 26 iterations, we've printed Aa...Zz.

Nice golf! I'll link to your answer

Ruby, 42 bytes
->{[*?/...?:,*?@...?[,*?`...?{]-[?/,?@,?`]}

A function that returns a char array. A program that outputs just the characters is 49 bytes:
$><<([*?/...?:,*?@...?[,*?`...?{]-[?/,?@,?`])*''

This simply uses the ascii characters on either side of the relevant ranges to define a range. For example, ?/...?: means the characters between a forward slash and a colon, excluding the end. To get rid of the beginnings, we subtract an array containing the three beginning characters.

Nice work. I saw this just as I came to post my 60 byte version using the same idea.

You can save one byte with slightly different ranges:
$><<([(?/...?{)]-[(?:..?@),(?[..?`),?/])''

This really is pretty.  Well, ugly.  You know what I mean.  Nicely done.

6502 machine language, 74 70 68 bytes
Hex dump (6502 programs are generally not relocatable; the code here is stored starting at location $0603):
0600:          a9 24 0a 8d 20 06 8d 21 06 8d 23 06 8d
0610: 25 06 09 20 8d 1a 06 8d 1c 06 ea aa ea a8 a9 00
0620: ea ea 98 ea 8a ea a2 ff a9 7b a0 60 20 3a 06 a9
0630: 5b a0 40 20 3a 06 a9 3a a0 2f 85 80 c8 e8 98 95
0640: 00 c8 c4 80 d0 f7 60

You can see that this uses none of the prohibited bytes: $41 through $5a, $61 through $7a, or $30 through $39.
This is a function with no arguments that, when called, returns a pointer to the character array "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" at the top of the stack, in accordance with standard 6502 calling conventions.
By way of explanation, here's a disassembly:

Address  Hexdump   Disassembly
-------------------------------
$0603    a9 24     LDA #$24
$0605    0a        ASL A
$0606    8d 20 06  STA $0620
$0609    8d 21 06  STA $0621
$060c    8d 23 06  STA $0623
$060f    8d 25 06  STA $0625
$0612    09 20     ORA #$20
$0614    8d 1a 06  STA $061a
$0617    8d 1c 06  STA $061c
$061a    ea        NOP
$061b    aa        TAX
$061c    ea        NOP
$061d    a8        TAY
$061e    a9 00     LDA #$00
$0620    ea        NOP
$0621    ea        NOP
$0622    98        TYA
$0623    ea        NOP
$0624    8a        TXA
$0625    ea        NOP
$0626    a2 ff     LDX #$ff
$0628    a9 7b     LDA #$7b
$062a    a0 60     LDY #$60
$062c    20 3a 06  JSR $063a
$062f    a9 5b     LDA #$5b
$0631    a0 40     LDY #$40
$0633    20 3a 06  JSR $063a
$0636    a9 3a     LDA #$3a
$0638    a0 2f     LDY #$2f
$063a    85 80     STA $80
$063c    c8        INY
$063d    e8        INX
$063e    98        TYA
$063f    95 00     STA $00,X
$0641    c8        INY
$0642    c4 80     CPY $80
$0644    d0 f7     BNE $063d
$0646    60        RTS

The machine-language code is self-modifying.  For stack manipulation, I needed to use PHA and PLA to push and pop the accumulator, but these instructions have opcodes $48 and $68, which are prohibited (they're the ASCII codes for the letters 'H' and 'h'). So, for PHA, I take the number $24, do an arithmetic shift left (ASL), and store the resulting $48 in the four spots in the code where it needs to be executed.  Then, for PLA, I use a bitwise OR on the $48 in the accumulator to compute $68, and store it in the two spots in the code where it's needed.
There were several instructions other than PHA and PLA that I also couldn't use because their opcodes happen to be the same as ASCII letters or digits, but I found direct workarounds for those others.
The desired character array is computed and stored starting at location 0 (it doesn't really matter where it's stored since we just need to be sure that a pointer to it is returned the top of the stack).
You can try this out at Nick Morgan's 6502 assembler and emulator.  Here's a screenshot; the monitor box at the bottom shows the output string (in locations $00 through $3D) after the program is run.

Haskell, 75 72 63 58 56 bytes
__=[__|[_',ä]<-["/:","@[","`{"],__<-[_'..],_'<__,__<ä]

Try it online! Call with __. Output:
0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Thanks to xnor who suggested __ and _' as two byte variable names instead of (!) or similar, saving 9 bytes. I especially like how _' breaks the syntax highlighting. And thanks again to xnor for generalizing the ranges, saving another 4 bytes.
Edit: I found out that Unicode chars are allowed as identifiers in Haskell, so e.g. ä, ö, ... can also be used as two byte identifiers. Since there was one three byte identifier left in the program I replaced it by ä, saving another 2 bytes.
Explanation:
__ and _' are valid variable names. From the language specification:

An identifier consists of a letter followed by zero or more letters, digits, underscores, and single quotes. [...] Underscore, _, is treated as a lower-case letter, and can occur wherever a lower-case letter can. However, _ all by itself is a reserved identifier, used as wild card in patterns.

So the code is equivalent to
s = [x|[a,b]<-["/:", "@[", "`{"], x<-[a..], a<x, x<b]

In the list comprehension a gets bound to '/' and b to ':' ("/:" is equivalent to ['/',':'], so the pattern matching succeeds). Then the range [a..] builds the string of all characters greater equal '/':
"/0123456789:;<=>?@ABCDE ... \1114110\1114111"

For each character x in this string it's then checked whether '/'<x and x<':', resulting in the chars 0123456789. Then a and b are bound to @
 and [, yielding the chars ABCDEFGHIJKLMNOPQRSTUVWXYZ and so on.

You can use __ and _' as variables.

@xnor Thanks, I didn't know about the Underscore is treated as a lower-case letter rule.

You can save some bytes by generalizing the ranges: _'_=[__|[_',__']<-["`{","@[","/:"],__<-[_'..],_'<__,__<__'] (in normal variables z=[x|[a,b]<-["`{","@[","/:"],x<-[a..],a<x,x<b]).

@xnor Thanks again! Great idea to combine the start and end of the ranges into a string. I also tried to generalize the ranges but always ended up longer without this idea. An additional byte can be saved by binding the string to __ instead of _'_  even though __ is used as identifier inside the list comprehension.

Perl (5.10 or 5.12), 30 29 bytes
This program consists mostly of unprintable characters, so here's a hexdump:
00000000: 5f 3d 7e 7e 22 d7 c0 84 8c 9e 86 df 9e d1 d1 85 _=~~"...........
00000010: d3 be d1 d1 a5 d3 cf d1 d1 c6 82 d6 22          ............"

This program's very simple: we're regexing (=~) an underscore (_; thanks @Dennis for pointing out that this works) against a regex. The regex is specified as an expression, rather than literally; specifically, we're taking the bitwise complement (~) of a string. Reversing the bitwise complement to get at the underlying string, we get the following regex that's being executed:
(?{say a..z,A..Z,0..9})

In Perl versions 5.10 and 5.12, the (?{…}) syntax was an experimental syntax for allowing regexes to run arbitrary code at runtime. In this case, we use it to run a straightforward Perl program to print the desired output. (Versions earlier than 5.10 can't be used because they don't have say.)
Modern versions of Perl have disabled (?{…}) by default for security reasons, but if you have such a version of Perl, you can disable the check (and thus run this program) via -Mre=eval as a command-line argument (together with the standard -M5.010 that specifies the version of the language to implement, and which doesn't count against the bytecount).

Java (OpenJDK 9), 277 bytes
Yes, Java, you read that well!
$->""+($='='+'=')+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+($='-'+'-')+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+($='_'-'&')+--$+--$+--$+--$+--$+--$+--$+--$+--$

Try it online!
This prints the ranges, but reversed, since the order has no importance.
zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDCBA9876543210

I played on the absence of "no input" rule to implicitly define a char which is required to make the whole thing work. If that's cheating, please say so.
Ungolfed & testing
public class PCG105781 {
  interface X { String apply(char x); }

  public static void main(String[] args) {
    X x = $
        -> "" // Force the result as a String.
        // The line below appends "zyxwvutsrqponmlkjihgfedcba"
        // '=' + '=' is 122 as int. $=122 casts 122 as a char, 'z'
        + ($ = '=' + '=') + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$
        // The line below appends "ZYXWVUTSRQPONMLKJIHGFEDCBA"
        // '-' + '-' is 90 as int. $=90 casts 90 as a char, 'Z'
        + ($ = '-' + '-') + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$
        // The line below appends "9876543210"
        // '_' - '&' is 57 as int. $=57 casts 57 as a char, '9'
        + ($ = '_' - '&') + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$
      ;

    System.out.println(x.apply('_'));
  }
}

Wait, what?? I'm short than all of the JavaScript solutions? o_O

That's because JavaScript doesn't have char, otherwise it'd be a piece of cake. And to be fair, my answer is shorter than your initial answer. Take a look at my explanation for all the overhead I have to go through.

@PatrickRoberts To be fair, we should compare initial edit to initial edit or last edit to last edit, not initial edit to last... ;) I carefully read what was done for JavaScript, especially because I didn't understand how I could get a shorter answer than all of the JS ones.

Actually 8 5 4 bytes
'>┘▀

How it works:
 '>    Pushes > onto the stack as a string
           STACK: [>]
    ┘  Converts the top item of the stack to it's ordinal
           STACK: [62]
     ▀ Push all digits from base n(top item of the stack)
           STACK: [012...xyz]

Print is implicit at the end of the program.
Edit 1: Replaced putting the alphabet in lower/uppercase and then the number range(10) with just getting base 62's printable characters.
Edit 2: changed ">" to '> thanks to Mego :) saved 1 byte.
Try it online!

'> is a byte shorter than ">".

@Mego yep it is, edited :) thanks.

PHP, 69 bytes
<?=~"ÏÎÍÌËÊÉÈÇÆ¾½¼»º¹¸·¶µ´³²±°¯®¬«ª©¨§¦¥žœ›š™˜—–•”“’‘ŽŒ‹Š‰ˆ‡†…";

The code is stylized using Windows-1252 here. Below is a reversible xxd hexdump.
00000000: 3c 3f 3d 7e 22 cf ce cd cc cb ca c9 c8 c7 c6 be  <?=~"...........
00000010: bd bc bb ba b9 b8 b7 b6 b5 b4 b3 b2 b1 b0 af ae  ................
00000020: ad ac ab aa a9 a8 a7 a6 a5 9e 9d 9c 9b 9a 99 98  ................
00000030: 97 96 95 94 93 92 91 90 8f 8e 8d 8c 8b 8a 89 88  ................
00000040: 87 86 85 22 3b                                   ...";

Try it online!

Brainfuck, 89 85 bytes
Because brainfuck ignores alphanumeric characters anyway, this is just a constant-output challenge... (Edit: See Dennis' Solution for a version which is 10 bytes shorter)
+[-[--<]>>--]++++++++++[<+.>-]<++++++++>+[-[---<]>>-]<-<<+++++[>+++++<-]>+[>.+<<<.+>>-]

Try it online!
This code is a good example of basic counted loops in brainfuck:
+[-[--<]>>--]   Create value 47: char just before '0'
++++++++++      Set adjacent cell to 10: to be used as a counter

[               While the counter is not 0:
 <+.              Increment and print the char
    >-            Decrement the counter
       ]        (End loop: Exits when all digits have been printed)

<++++++++>           The char is now at '9' so add 8 to make it 'A'
+[-[---<]>>-]<-      In another cell create lowercase 'a'
<<+++++[>+++++<-]>+  Create 26: the number of times to loop

[                While the counter is not 0:
 >.+               Print and increment the lowercase char
    <<<.+          Print and increment the uppercase char
         >>-       Decrement the counter
            ]    (End loop: Exits when all letters have been printed)

Note that this uses wrapping shortcuts to generate numbers, meaning that the interpreter needs to have 8-bit wrapping cells (such as the one I linked to).

Brainfuck was the first language I thought of. Shame I don't know it. Nice answer.

JavaScript (ES6), 983 bytes
Turns out in ES6 there's a lot of characters you can use in JavaScript variable names! Works great after you exhaust the six 1-2 byte variable names with $ and _.
_=~[]
$={}
Á=++_
À=![]+""
Â=À[_]
Ã=++_
Ä=À[_]
Å=++_
Æ=($+"")[_]
Ç=(_[_]+"")[_]
È=++_
É=(!""+"")[_]
Ë=++_
Ì=++_
Ê=($+"")[_]
Í=++_
µ=++_
Î=++_
Ï=++_
_="\\"
Ð=$.$
È_=(!""+"")[Ã]
Å_=$+""
Ñ=Å_[Ã]
Ò=(Ð+"")[Ã]
__=Å_[Í]
Ó=(!""+"")[Å]
$_=Å_[Ì]+Ñ+Ò+(!$+"")[È]+__+È_+Ó+Å_[Ì]+__+Ñ+È_
$$=È_+(!""+"")[È]+__+Ó+È_+Ò
$=Á[$_][$_]
$($($$+"\""+Ê+Ñ+_+Ã+Ì+Í+_+Ã+Í+È+Ñ+À[Å]+É+"."+À[Å]+Ñ+_+Ã+Ë+µ+"('"+Ä+Æ+Ê+Ç+É+Â+_+Ã+Ë+µ+_+Ã+Ì+Á+_+Ã+Ì+Ã+_+Ã+Ì+Å+_+Ã+Ì+È+À[Å]+_+Ã+Ì+Ì+_+Ã+Ì+Í+Ñ+_+Ã+Í+Á+_+Ã+Í+Ã+_+Ã+Í+Å+_+Ã+Í+È+__+Ó+_+Ã+Í+Í+_+Ã+Í+µ+_+Ã+µ+Á+_+Ã+µ+Ã+_+Ã+µ+Å+_+Ã+Á+Ã+_+Ã+Á+Å+_+Ã+Á+È+_+Ã+Á+Ë+_+Ã+Á+Ì+_+Ã+Á+Í+_+Ã+Á+µ+_+Ã+Ã+Á+_+Ã+Ã+Ã+_+Ã+Ã+Å+_+Ã+Ã+È+_+Ã+Ã+Ë+_+Ã+Ã+Ì+_+Ã+Ã+Í+_+Ã+Ã+µ+_+Ã+Å+Á+_+Ã+Å+Ã+_+Ã+Å+Å+_+Ã+Å+È+_+Ã+Å+Ë+_+Ã+Å+Ì+_+Ã+Å+Í+_+Ã+Å+µ+_+Ã+È+Á+_+Ã+È+Ã+_+Ã+È+Å+Ã+Å+È+Ë+Ì+Í+µ+Î+Ï+Á+"')\"")())()

JavaScript, 1223 bytes
This was my answer before I learned about the above.
_=~[]
$={}
___=++_
____=![]+""
$$$$=____[_]
__$=++_
$_$_=____[_]
_$_=++_
$_$$=($+"")[_]
$$_$=(_[_]+"")[_]
_$$=++_
$$$_=(!""+"")[_]
$__=++_
$_$=++_
$$__=($+"")[_]
$$_=++_
$$$=++_
$___=++_
$__$=++_
_="\\"
_$_$=$.$
_$$_=(!""+"")[__$]
_$__=$+""
_$=_$__[__$]
__$_=(_$_$+"")[__$]
__=_$__[$$_]
___$=(!""+"")[_$_]
$_=_$__[$_$]+_$+__$_+(!$+"")[_$$]+__+_$$_+___$+_$__[$_$]+__+_$+_$$_
$$=_$$_+(!""+"")[_$$]+__+___$+_$$_+__$_
$=___[$_][$_]
$($($$+"\""+$$__+_$+_+__$+$_$+$$_+_+__$+$$_+_$$+_$+____[_$_]+$$$_+"."+____[_$_]+_$+_+__$+$__+$$$+"('"+$_$_+$_$$+$$__+$$_$+$$$_+$$$$+_+__$+$__+$$$+_+__$+$_$+___+_+__$+$_$+__$+_+__$+$_$+_$_+_+__$+$_$+_$$+____[_$_]+_+__$+$_$+$_$+_+__$+$_$+$$_+_$+_+__$+$$_+___+_+__$+$$_+__$+_+__$+$$_+_$_+_+__$+$$_+_$$+__+___$+_+__$+$$_+$$_+_+__$+$$_+$$$+_+__$+$$$+___+_+__$+$$$+__$+_+__$+$$$+_$_+_+__$+___+__$+_+__$+___+_$_+_+__$+___+_$$+_+__$+___+$__+_+__$+___+$_$+_+__$+___+$$_+_+__$+___+$$$+_+__$+__$+___+_+__$+__$+__$+_+__$+__$+_$_+_+__$+__$+_$$+_+__$+__$+$__+_+__$+__$+$_$+_+__$+__$+$$_+_+__$+__$+$$$+_+__$+_$_+___+_+__$+_$_+__$+_+__$+_$_+_$_+_+__$+_$_+_$$+_+__$+_$_+$__+_+__$+_$_+$_$+_+__$+_$_+$$_+_+__$+_$_+$$$+_+__$+_$$+___+_+__$+_$$+__$+_+__$+_$$+_$_+__$+_$_+_$$+$__+$_$+$$_+$$$+$___+$__$+___+"')\"")())()

I ran console.log('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890') through jjencode and golfed the result manually. There are definitely more optimizations that can be done.

Hey, FYI I posted http://codegolf.stackexchange.com/a/105854/42091 because I put a lot of work into it and I think it's sufficiently different from your answer.

No problem, looking good!

Nice! That last update helped me get over 100 bytes off mine!

If you change your encoding to ISO8859-1, and leave it exactly like this, it will be 769 bytes.

Befunge, 73 72 59 57 55 53 bytes
"{"< ^+`"`"\+*`\":"\`"/":\*`\"["\`"@":::::-!!
#@_^,_!

Try it online!
This is a single loop counting down from { (i.e. one character after z). On the first iteration, the "{"< sequence pushes two copies of { onto the stack - one being the the initial loop counter, and the other being used to decrement that counter using the sequence !!- (two NOTs make 1, which is then subtracted) . On subsequent iterations, the loop counter is already on the stack, so only one { is required to setup the decrement sequence.
The rest of the code is just a long boolean expression calculating if the character is in range. If it is, the branch on the second line splits left to write out the value. If not, the right branch wraps around to test if we've reached zero and should terminate. The two branches merge in the middle to go up and repeat the loop. Note that all vertical direction commands go upwards, since we can't use a v, but that's fine because the instruction pointer automatically wraps at the top of the playfield.
Thanks to Mistah Figgins for initially coming up with a better technique for the loop increment.
But special thanks to Jo King for an even better approach counting down rather than up, as well as a more compact branch layout.

If there is nothing else except the counter on the stack, you can change your increment part to  !+  If there is, you can do  :!!+. for non-zero values

-2 bytes by rearranging the check at the beginning of the line

@JoKing Well spotted. We can't use the v since this is restricted-source, but it still works just as well with a ^. Thanks.

-2 bytes by counting down instead of up, and using the extra copy of the counter on the second line to check if the loop is over (remembered about the restricted source this time ;) )

@JoKing Wow, you really are way better at this golfing than me! Thanks again.

Self-modifying Brainfuck, 32 bytes
<[-<+.>]<<[-<+.>]<<[-<+.>]`@/

Try it online!
xxd -r-reversible hexdump (contains unprintables):
00000000: 3c5b 2d3c 2b2e 3e5d 3c3c 5b2d 3c2b 2e3e  <[-<+.>]<<[-<+.>
00000010: 5d3c 3c5b 2d3c 2b2e 3e5d 601a 401a 2f0a  ]<<[-<+.>]`.@./.

What does the @/ do?

@TuukkaX The last 6 characters \\x1a@\x1a/\n` are there because their codepoints are really useful in golfing. You can't remove them.

@downvoter: If you stumble upon this post, please remove your downvote. This has been since fixed.

I'm glad I'm not the only one who uses SMBF. :)

@mbomb007 Practicality :) I was thinking of BF, and them SMBF came to mind, so that I have the codepoints ready. The restriction didn't cost me bytes, as I used +. instead of .+.

Jelly, 17 16 bytes
“:[{“/@`‘Ḷḟ"/ỌḊ€

Try it online!
How it works
“:[{“/@`‘Ḷḟ"/ỌḊ€  Main link. No arguments.

“:[{“/@`‘         Yield [[58, 91, 123], [47, 64, 96]].
         Ḷ        Unlength; map each n to [0, ..., n-1].
          ḟ"/     Reduce by vectorizing filter-false.
                  This yields [[47, ..., 57], [64, ..., 90], [96, ..., 122]].
             Ọ    Unordinal; replace each n with the corr. Unicode character.
              Ḋ€  Deqeue each; remove the first character of each of the three
                  generated strings ('/', '@', and '`').

Because jelly has its own codepage, it would help if you attached a hexdump, for easy verification that you're not using the banned bytes

@FlipTack IIRC Jelly's codepage is compatible with printable ASCII.

@FlipTack Pietu1998 is right. And even if he weren't, the spec bans characters, not bytes.

@Dennis In fact, it bans bytes per the comments, although this is still valid (ASCII-compatible).

Julia 0.4, 46 bytes
_()=['¥':'®';'¶':'Ï';'Ö':'ï'].-['~'-'	']

This is a generic function that returns a character array.
Try it online!
Alternate version, 47 bytes, ASCII-only
_(_=_==_)=['/'+_:':'-_;'@'+_:'['-_;'`'+_:'{'-_]

Try it online!

JavaScript (ES6), 812 745 657 650 536 520 416 bytes
(À=(Á=!($={})+(Ø=""))[Â=_=+[]],Ã=(Ä=!_+Ø)[Å=++_],Æ=(Ç=$+Ø)[_],È=(É=$.$+Ø)[_],Ê=Ä[Ë=++_],Ì=Ä[Í=++_],Î=++_,Ï=Ç[Ð=++_],Ñ=Ç[Ò=++_],Ó=++_,$=$[Ô=Ï+Æ+È+Á[Í]+Ñ+Ã+Ê+Ï+Ñ+Æ+Ã][Ô],$($((Õ=Ã+Ä[Í]+Ñ+Ê+Ã+È)+`"${Ù=($=À)+Æ+(Ö=Ô[Ð])}($ ${[Æ+$+"[["+Î+ ++_,Ø+Ð+_+"],["+Ò+Ð,Ø+ ++_+Å+"],["+_+Ó,Ú=Ø+Å+Ë+Í]}]])${Ù}(_=$[Â];_<$[Å];)Ø+=${(_="\\")+Ú+Ñ+Ö+(Û=(_=_+Å)+Ð)+Å+Ô[Ë]+_+Î+Ó}.${$+Ö+Æ+Û+Ð+_+Â+Í+Û+Â+Á[Å]+Ö+_+Â+Í+Æ+É[Ë]+Ì}(_++);${Õ} Ø"`)()))

Edit: Using ISO8859-1 encoding, this solution is 416 bytes instead of 520 bytes. The full program is 432 bytes, taking into account the extra 16 bytes for
f=\r\n
416 byte submission here\r\n
alert(f())

This is a function submission, as opposed to a full program. I spent quite a long time golfing JJEncode (hat-tip to darrylyeo for that), but instead of golfing
console.log('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890')

I golfed
for($ of[[48,58],[65,91],[97,123]])for(_=$[0];_<$[1];)Ø+=String.fromCharCode(_++);return Ø

where Ø is initialized to "" in the overhead.
Rewritten with comma operators converted to newlines:
À=(Á=!($={})+(Ø=""))[Â=_=+[]]
Ã=(Ä=!_+Ø)[Å=++_]
Æ=(Ç=$+Ø)[_]
È=(É=$.$+Ø)[_]
Ê=Ä[Ë=++_]
Ì=Ä[Í=++_]
Î=++_
Ï=Ç[Ð=++_]
Ñ=Ç[Ò=++_]
Ó=++_
$=$[Ô=Ï+Æ+È+Á[Í]+Ñ+Ã+Ê+Ï+Ñ+Æ+Ã][Ô]
// function that returns string
$($((Õ=Ã+Ä[Í]+Ñ+Ê+Ã+È)+`"${Ù=($=À)+Æ+(Ö=Ô[Ð])}($ ${[Æ+$+"[["+Î+ ++_,Ø+Ð+_+"],["+Ò+Ð,Ø+ ++_+Å+"],["+_+Ó,Ú=Ø+Å+Ë+Í]}]])${Ù}(_=$[Â];_<$[Å];)Ø+=${(_="\\")+Ú+Ñ+Ö+(Û=(_=_+Å)+Ð)+Å+Ô[Ë]+_+Î+Ó}.${$+Ö+Æ+Û+Ð+_+Â+Í+Û+Â+Á[Å]+Ö+_+Â+Í+Æ+É[Ë]+Ì}(_++);${Õ} Ø"`)())

Explanation
This script starts by initializing a few built-in types and coercing them into strings. The strings we can get without using alphanumeric characters are:
{}+""     -> "[object Object]"
!{}+""    -> "false"
!+[]+""   -> "true"
{}[{}]+"" -> "undefined"

From these strings, and the necessary digits in order to reference individual characters, we can obtain the strings return and constructor, which can be used like:
$={}[Ô="constructor"][Ô]
$(("return"+`"encoded script"`)())

The object's constructor is Object(), and its constructor is Function(), which we can use essentially like eval().
In this case, the encoded script to be executed is the nested for loops concatenating all the alphanumeric characters to a string using their code points and returning it.
For alphabetical characters in the encoded script that can't be accessed using the built-ins, JJEncode uses octal escapes to represent them, then decodes the entire string by returning it from an inner function. The outer function can then be called to execute the source.
Demo

f=
(À=(Á=!($={})+(Ø=""))[Â=_=+[]],Ã=(Ä=!_+Ø)[Å=++_],Æ=(Ç=$+Ø)[_],È=(É=$.$+Ø)[_],Ê=Ä[Ë=++_],Ì=Ä[Í=++_],Î=++_,Ï=Ç[Ð=++_],Ñ=Ç[Ò=++_],Ó=++_,$=$[Ô=Ï+Æ+È+Á[Í]+Ñ+Ã+Ê+Ï+Ñ+Æ+Ã][Ô],$($((Õ=Ã+Ä[Í]+Ñ+Ê+Ã+È)+`"${Ù=($=À)+Æ+(Ö=Ô[Ð])}($ ${[Æ+$+"[["+Î+ ++_,Ø+Ð+_+"],["+Ò+Ð,Ø+ ++_+Å+"],["+_+Ó,Ú=Ø+Å+Ë+Í]}]])${Ù}(_=$[Â];_<$[Å];)Ø+=${(_="\\")+Ú+Ñ+Ö+(Û=(_=_+Å)+Ð)+Å+Ô[Ë]+_+Î+Ó}.${$+Ö+Æ+Û+Ð+_+Â+Í+Û+Â+Á[Å]+Ö+_+Â+Í+Æ+É[Ë]+Ì}(_++);${Õ} Ø"`)()))
console.log(f())

bash (on linux), 507 493 490 485 bytes
this stores an array of characters in the global variable __
: {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_
__=(/????/????/??/??)
___=${__%??}
__=(${__[@]#$___?})
____=${___#/*/?}
____=${____%?/*/}
_____=${____%?}
____=${____#?}
___=${___%??/}
______=($___*_??)
______=${______#$___???????}
______=${______%??_*}
_______=($___$_____???*)
_______=${_______#$___??}
_______=${_______%????}
___=$#
___=$((++___))$((___+++++___+___--))$___
$_____$_______$______$____{,} ___="\({$______..$'\\$___'}\)"
__=(${__[@]} ${___[@]} ${___[@]^})

it needs to be executed on a freshly booted linux machine with /proc,
or something like a pid namespace
explanation:
# {var}>file opens a file descriptor >= 10 to that file
: {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_
# at startup no pid is > 999 so there's no other /proc/pid/fd/??
__=(/????/????/??/??)                                 # /proc/self/fd/1[0-9]
___=${__%??}                                          # /proc/self/fd/
__=(${__[@]#$___?})                                   # {0..9}
____=${___#/*/?}                                      # elf/fd/
____=${____%?/*/}                                     # el
_____=${____%?}                                       # e
____=${____#?}                                        # l
___=${___%??/}                                        # /proc/self/
______=($___*_??)                                     # /proc/self/timerslack_ns
______=${______#$___???????}                          # ack_ns
______=${______%??_*}                                 # a
_______=($___$_____???*)                              # /proc/self/environ
_______=${_______#$___??}                             # viron
_______=${_______%????}                               # v

___=$#                                                # 0
___=$((++___))$((___+++++___+___--))$___              # 172 (z in octal)

# eval eval                   ___="\({a..$'\172'}\)"
$_____$_______$______$____{,} ___="\({$______..$'\\$___'}\)"
#   {0..9}   {a..z}    {A..Z}
__=(${__[@]} ${___[@]} ${___[@]^})

to try it out we can add declare -p __ at the end to display the result
$ sudo unshare --fork --pid --mount-proc bash golf
declare -a __=([0]="0" [1]="1" [2]="2" [3]="3" [4]="4" [5]="5" [6]="6" [7]="7" [8]="8" [9]="9" [10]="a" [11]="b" [12]="c" [13]="d" [14]="e" [15]="f" [16]="g" [17]="h" [18]="i" [19]="j" [20]="k" [21]="l" [22]="m" [23]="n" [24]="o" [25]="p" [26]="q" [27]="r" [28]="s" [29]="t" [30]="u" [31]="v" [32]="w" [33]="x" [34]="y" [35]="z" [36]="A" [37]="B" [38]="C" [39]="D" [40]="E" [41]="F" [42]="G" [43]="H" [44]="I" [45]="J" [46]="K" [47]="L" [48]="M" [49]="N" [50]="O" [51]="P" [52]="Q" [53]="R" [54]="S" [55]="T" [56]="U" [57]="V" [58]="W" [59]="X" [60]="Y" [61]="Z")

+1.  I think you should state this as Bash on Linux as other OSes (e.g. MacOS) don't have /proc.  In fact /proc is not strictly necessary on Linux, though you'd probably be hard pressed to find a modern distro without it.

This stores the output as a global variable, which isn't allowed.

C, 128 bytes
Yes, C. And it even is shorter than a few of the esoteric ones.
__($$,_,$,_$,$_){$>_$?_$=_$?!$:$,$=*(""-_+$_++)&*"{":_;_$?*(""-_+$$++)=$++:_;$&&__($$,_,$,_$,$_);}_(_){__(_,"",_,!!_,"½´ÞÅþå");}

Call _ on a sufficiently large, empty char * buffer.
May be a teensy wee bit compiler dependent. Tested using GCC; file was saved in codepage 1252.

05AB1E, 18 15 11 bytes
-4 thanks to Adnan, because if the input size is 1, 05AB1E will use 0 for b on first command.
•£•Ýç©á®þ«˜

Try it online!
•£•Ÿ            # Push [0..122] using implicit 0 and the base-214 of `£`.
    ç           # Convert to ASCII chars.
     ©          # Store full array in register.
      á         # Push the same array with ONLY letters.
       ®        # Push contents of register (char)[0..122].
        þ       # Push only the digits.
         «˜     # Concat to list, flatten it.

I tried so many different approaches, but the key points here that made it hard:
- Basic commands will not work, only extended and a select few of the basics.
- Extended commands are pretty complex.
- Eval (.V) will not work.
- To push numbers you can do a base 214 compression.
- ALL sequence pushes (E.G. žK) won't work.
- ALL number pushes won't work, except for compression and the -1 an empty register pushes.

You may print them in arbitrary order says the challenge.

Does •£•Ýç©á®þ«˜ also work?

@Adnan nice, didn't know it uses 0 when there is no b.

Brain-Flak, 171 bytes
Includes +3 for -A
(((((()()()){}){}){}){})(((()()())){}{}){({}[()]<(({})())>)}{}(({})(()()()()){})(((((()()()){}){}){}())<{({}[()]<(({})())>)}{}(({})(()()()){}())>){({}[()]<(({})())>)}{}

Try it online!
(((((()()()){}){}){}){}) # push 48
(((()()())){}{})         # push 9
{({}[()]<                # for 9..0
(({})())                 # pop a, push a, push a+1
>)}{}                    # end for
(({})(()()()()){})       # pop a, push a, push a + 8
(((((()()()){}){}){}())< # push 26 and save a 26 for later
{({}[()]<                # for 26..0
(({})())                 # pop a, push a, push a+1
>)}{}                    # end for
(({})(()()()){}())       # pop a, push a, push a + 7
>)                       # push that 26 that we held
{({}[()]<                # for 26..0
(({})())                 # pop a, push a, push a+1
>)}{}                    # end for

There is probably a way to do this without having to repeat the add 1 "function".

J, 171 bytes
(+:>.+:^^*_){.".(':',~(+:+:>.^*_){(*:>.^*_)!:(+:<.^+:*_)''),',',(":(>:*:+:+:+:*_),(<.^<:^<:^*_),<:*:<.^+:*_),'+/',('.',~(+:<.+:^*_){(*:>.^*_)!:(+:<.^+:*_)''),":+:<.*:>:^*_

Ow... my brain hurts... Try it online!
Here's so you can see all of it one line (it won't run, though, with line breaks.)
(+:>.+:^^*_){.".(':',~(+:+:>.^*_){(*:>.^*_)!:(+:<.^+:*_)''),',',(":(>:*:+:+:+:*_),(<.^<:^<:^*
_),<:*:<.^+:*_),'+/',('.',~(+:<.+:^*_){(*:>.^*_)!:(+:<.^+:*_)''),":+:<.*:>:^*_

Only guaranteed to work with J version j805/j64/linux/release/commercial/www.jsoftware.com/2016-12-11T08:02:52, in that order. (Only the first 12 characters matter.)
Explanation
Most of the program is devoted to constant generation. With those constants replaced with their values, the program looks like this:
(62){.".(':',~(12){(9)!:(14)''),',',(":(65),(97),48),'+/',('.',~(10){(9)!:(14)''),":26

With some parentheses removed, and some numbers made nicer:
62{.".(':',~12{9!:14''),',',(":65 97 48),'+/',('.',~10{9!:14''),":26

This is composed of a bunch of , and ,~s, which append and prepend arguments. Here are the separate values:

":26
('.',~10{9!:14'')
'+/'
(":65 97 48)
','
(':',~12{9!:14'')

1 is 26 as a string.
9!:14'' generates the following string on TIO:
j805/j64/linux/release/commercial/www.jsoftware.com/2016-12-11T08:02:52

with 2, we obtain the 10th character (i from linux), and add a . to the end of it, yielding i..
3 and 5 are self-explanatory.
4 is the list of numbers 65 97 48 as a string.
6 is similar to 2, except it's the 12th character (u from linux) and adds a : to the end, yielding u:.
This, all together, yields u:,65 97 48+/i.26. ". evaluates this, giving us:
ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789:;<=>?@ABCDEFGHI

(Note: +/ is tabulated addition.)
Then, with 62{., we take the first 62 characters from this, giving us ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.

You can get the constant 14 using <:<.^^*_ which saves a byte. Also, I tried generating the entire range and removing the symbols to get ':;<=>?@[\]^_`'-.~".(':',~(+:+:>.^*_){(*:>.^*_)!:(<:<.^^*_)''),":(#@}.@}.@}.@,~(+#\)],,~)(*:@#$])'+++++' at 104 bytes. I'm sure it can get much shorter

Brainfuck, 55 bytes
+++[[<+>->++<]>]<<[-<->]<<<<++[->>+.>+.<<<]<--[->>.+<<]

Output:
aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ0123456789

Try it online!

Initializes the tape to 3·2n, and works from there.
+++[[<+>->++<]>]    initialize the tape
                    |   0 |   3 |   6 |  12 |  24 |  48 |  96 | 192 | 128 |   0 |   0 |
                                                                                ^
<<[-<->]            subract 128 from 192
                    |   0 |   3 |   6 |  12 |  24 |  48 |  96 |  64 |   0 |   0 |   0 |
                                                                        ^
<<<<++              increment 24 twice
                    |   0 |   3 |   6 |  12 |  26 |  48 |  96 |  64 |   0 |   0 |   0 |
                                                ^
[->>+.>+.<<<]       output aAbBcC ~ zZ
                    |   0 |   3 |   6 |  12 |   0 |  48 | 122 |  90 |   0 |   0 |   0 |
                                                ^
<--[->>.+<<]        decrement 12 twice; output 0 ~ 9
                    |   0 |   3 |   6 |   0 |   0 |  58 | 122 |  90 |   0 |   0 |   0 |
                                          ^

Perl 6, 43 bytes
{|('`'^..^'{'),|('@'^..^'['),|('/'^..^':')}

A lambda that returns a list of characters.
Explanation:
   '`'                                       # The character before "a" (in Unicode order)
          '{'                                # The character after "z"
      ^..^                                   # Endpoint-exclusive range between them
 |(          )                               # Slip the range into the outer list
               |('@'^..^'[')                 # Same thing for "A" to "Z"
                             |('/'^..^':')}  # Same thing for "0" to "9"

Depends on a bugfix to the Rakudo Perl 6 interpreter which was only committed to the git repo today, and isn't part of an official Rakudo release yet. In fact, I encountered the bug while answering this challenge, and managed to get fixed with the help of one of the Perl 6 core devs. The rules of this site, as I understand them, did't allow answers to compete in such a situation, so I marked it as noncompeting but now it's fine.

41 bytes

MAWP, 197 bytes
Here's a funny solution.
__________________________________________________________________________________________________________________________;;;;;;;;;;;;;;;;;;;;;;;;;;%%%%%%;;;;;;;;;;;;;;;;;;;;;;;;;;%%%%%%%;;;;;;;;;;

MAWP almost exclusively uses alphanumeric characters to print values, so instead we spam the _(stack length) operator to generate ASCII values till 122.
The rest is printing the required characters and removing the unnecessary ASCII values. The whole thing is printed in reverse to conserve bytes.
Try it!

Python 3, 2188 bytes
_=('/')
((('')-_)+(('‘')-_)+(('’')-_)+(('“')-_)+(('”')-_)+(('•')-_)+(('–')-_)+(('—')-_)+((':')+_)+((';')+_)+(('<')+_)+(('=')+_)+(('>')+_)+(('?')+_)+(('@')+_)+(('Ÿ')-_)+((' ')-_)+(('¡')-_)+(('¢')-_)+(('£')-_)+(('¤')-_)+(('¥')-_)+(('¦')-_)+(('§')-_)+(('¨')-_)+(('©')-_)+(('')+_)+(('')+_)+(('')+_)+(('')+_)+(('')+_)+(('')+_)+(('')+_)+(('')+_)+(('')+_)+(('')+_)+(('')+_)+(('')+_)+(('')+_)+(('')+_)+((' ')+_)+(('!')+_)+(('"')+_)+(('#')+_)+(('$')+_)+(('%')+_)+(('&')+_)+(("'")+_)+(('(')+_)+((')')+_)+(('*')+_)+(('+')+_)+(('')+_)+(('')+_)+(('')+_)+(('')+_)+(('')+_)+(('')+_)+(('')+_)+(('	')+_)+(('''
''')+_)+(('')+_),='')

The code contains some unprintable characters that may not display properly. See the TIO link for the actual code.
Try it online!
There doesn't seem to be a way to do any sort of looping without access to keywords, so I had to make this monster.
Here is an explanation of why this works.

Various golfing suggestions: `` is 12 bytes while ᶜʰʳ is only 7. Also, you could put something like ª=ᶜʰʳ;º=ºʳᵈ at the top to save tons of bytes. You could replace ord('''\n''') with something like -~ord('\t'). If you set _=ord('[') and both add and subtract from it, then all arguments to ord could be ASCII. All that aside, it is possible to loop with builtins. This answer has two 119-byte solutions, one that loops with map, range, etc., and one that __import__s the string module.

PHP 7.0+, 110 bytes
God bless bitwise strings!
<?=($__='`@`@'^'*/).')(($_='->.<:'^'__@[_')('>'^_,'%'^_)),$__($_('|'^'=','|'^'&')),$__($_(':'^"\n",';'^']'^_));

Replace the \n with a real *NIX-style newline.
It is present in the code to avoid problems with newlines, but isn't counted in the score.
This throws a bunch of warnings, but those could be supressed by appending an @ in front of every stray _.

Warning free, 113 bytes
<?=($__='`@`@'^'*/).')(($_='->.<:'^'__@[_')('>'^@_,'%'^@_)),$__($_('|'^'=','|'^'&')),$__($_(':'^"\n",';'^']'^@_));

65c02 machine language + Apple ][ ROM, 25 bytes
A9 E0 20 0F 80 A9 C0 20 0F 80 A2 0A A9 AF 2C A2 1A 1A 20 ED FD CA D0 F9 60

Prints abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.
Should start at $8000.
Disassembly
8000-   A9 E1       LDA   #$E0
8002-   20 0F 80    JSR   $800F
8005-   A9 C1       LDA   #$C0
8007-   20 0F 80    JSR   $800F
800A-   A2 0A       LDX   #$0A
800C-   A9 B0       LDA   #$AF
800E-   2C          HEX   2C     ; SKIPS NEXT 2 BYTES
800F-   A2 1A       LDX   #$1A
8011    1A          INC
8012-   20 ED FD    JSR   $FDED
8015-   CA          DEX
8016-   D0 F9       BNE   $8011
8018-   60          RTS

This violates the codepoint rule- you're just using the characters in a different character set. Bytes are OK as long as they aren't iterals or read by the code.

@wat Ah, OK. I've edited my code so that it doesn't use any machine code bytes that map to alphanumeric characters in "normal" (positive) ASCII and doesn't use any positive or negative ASCII alphanumeric literals; is it valid now?

I guess so... ._.

@wat The code points in ascending order used currently are 10, 15, 26, 32, 44, 96, 128, 162, 169, 175, 192, 202, 208, 224, 237, 249, 253, which maps to the characters ↵.. ,`.¢©¯ÀÊÐàíùý where the .s are unprintable characters. It's valid

MarioLANG, 255 233 199 bytes
+
+
+
+
+
+
+
+
)
><
+"
+
+(
+(
+(
+(
++
+)
)+
++
++
++
+)
++
++
++
++
++
++
++
+)
()
()
-
[!)+)+)-)--)+++((
=#==============
>((+(+      >((+
"======<    "====<
![-)).).((((![-)).
#===========#=====

Try it online!
The more time Mario spends in the air, the less floor you have to draw and the less characters you use for the solution...

C (clang), 116 bytes
"Arbitrary order" indeed.
The function _ takes a pointer to target string as an argument. Since that pointer is to int, it is assumed that sizeof(int) == 4.
In the TiO link the result is printed as-is, as well as sorted, for easier ocular inspection.
$;*ö;Å(å,ä){(å+=$)<ä?*ö++=å,Å(å,ä):$;}_(*ä){ö=ä;$='&&&&'^'$$$$';Å('?_@`','[{\\|');$+=$;Å('/.-,','?>=<');*--ö&=';:';}

Try it online!

Python 3, 119 114 bytes
ᵖʳⅰₙｔ(*ﬁˡｔₑʳ(ﬆʳ.ⅰˢªˡₙｕᵐ,ᵐªｐ(ᶜʰʳ,ʳªⁿｇₑ(ºʳｄ('{')))),ˢᵉᵖ='')

Try it online!
-5 from using ﬁ and ﬆ ligatures thanks to m90. I'm going to write ﬆr in my Python code from now on.
Python 3, 119 117 bytes
_=ﬆʳⁱⁿᵍ=ºʳᵈ('>');ᵖʳⁱⁿᵗ(__ⁱᵐᵖºʳᵗ__([*ᵛªʳˢ()][~_+_]).ᵖʳⁱⁿᵗªᵇˡᵉ[:_])

Try it online!

cheaty as hell, +1

I think these can be shortened by taking further advantage of the NFKC normalisation to get multiple letters from one codepoint in certain places, using U+FB01 LATIN SMALL LIGATURE FI and U+FB06 LATIN SMALL LIGATURE ST.

@m90 You're right. It's a shame ㏌ and ㏑ aren't classified as letters, even though they normalize to letters.

JavaScript, 371 bytes
(ÿ=(À=!($={})+(ø=""))[ò=ì=+[]],ý=(Þ=!ò+ø)[++ì],ó=(Ó=$+ø)[ì],Ú=$.$+ø,ú=Þ[í=ì+ì],é=Þ[î=í+ì],ç=Ó[Ì=î+í],þ=Þ[ò],Î=Ì+í,$=$[Ç=ç+ó+Ú[ì]+À[î]+þ+ý+ú+ç+þ+ó+ý][Ç],$($((È=ý+é+þ+ú+ý+Ú[ì])+`"${ÿ+ó+ý}(_=ò;_<Ì<<Ì;)ø+=${(ß="\\")+ì+í+î+þ+ý+(Ð=(ð=ß+ì)+Ì)+ì+Ç[í]+(æ=ð+í*í+Î)}.${ÿ+ý+ó+Ð+Ì+ð+ò+î+Ð+ò+À[ì]+ý+ð+ò+î+ó+Ú[í]+é}(_++);${È} ø.${ý+é+ð+í*î+ò+À[í]+À[ì]+ç+é}(/${ß+ß+ð+í+Î}|_/${æ},'')"`)()))()

The (...)() scaffolding is only there to make it easier to paste it into the F12 console, and doesn't count toward the total, as per the rules. Output:
"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"

This is based on the same method as the other JavaScript solutions: using string coercion to get at some internal string constants to build a string to get at the constructor of the constructor of an object. A constructor is a function, so its constructor is Function, which allows us to build a new one, essentially like eval.
One difference with previous solutions is that I tried to use more ‘sensible’ variable names, which made it easier to try out new ideas:
ç   c         Ç   constructor        ò   0      ß   \
é   e         Ó   [object Object]    ì   1      ð   \1
ó   o         Ú   undefined          í   2      Ð   \15
þ   t         Þ   true               î   3
ú   u                                Ì   5
                                     Î   7
ÿ   f         À   false
ý   r         È   return
æ   \147 = g

The trick that ended up saving the most was to first generate way too much and then filtering out all the characters I didn't need.

Does this print with the "s around the text?

It looks like you're using ISO-8859-1 charset. Am I wrong? Can you clarify?

Javascript, 1273 1351 1610 bytes
This solution works essentially the same way as the other two answers on this thread here and here, where it uses letters from the true, false, undefined, and [object Object] strings to build the functions that it needs to generate the other letters.
Since a good number of the letters are already put into the object, I tried adding all of the remaining minuscule letters and the numbers to the object, and then applied toUpperCase to all of the values in the object to generate the missing majuscule letters.
Update:
I was able to improve the way that the octal values were being set, but they're still taking up 13 x 30 bytes (or they will be 30 bytes each after I changes the numbers to different keys), each one now follows this general pattern: $.ž=\'\\'+$.一+$.七+$.二+'\';.
An additional 49 bytes can be easily taken out by switching the keys for the numbers to 2 byte characters.
Current submission:
$=~[];_={ť:!""+"",ň:![]+"",û:$._+'',ô:{}+"",ø:''};$={零:++$,ƒ:_.ň[$],ť:_.ť[$],一:++$,â:_.ň[$],ř:_.ť[$],ô:_.ô[$],ň:_.û[$],二:++$,ľ:_.ň[$],û:_.ť[$],ƅ:_.ô[$],ď:_.û[$],三:++$,ŝ:_.ň[$],ĵ:_.ô[$],四:++$,ě:_.ň[$],五:++$,ĉ:_.ô[$],î:_.û[$],六:++$,七:++$,八:++$,Ô:_.ô[$],九:++$};_.ĉ=$.ĉ+$.ô+$.ň+$.ŝ+$.ť+$.ř+$.û+$.ĉ+$.ť+$.ô+$.ř;_.ř=$.ř+$.ě+$.ť+$.û+$.ř+$.ň;_.ƒ=(0)[_.ĉ][_.ĉ];_.ƒ(_.ƒ(_.ř+' "$.Û=\'\\'+$.一+$.二+$.五+'\';$.Ĉ=\'\\'+$.一+$.零+$.三+'\';$.Ě=\'\\'+$.一+$.零+$.五+'\';$.ĝ=\'\\'+$.一+$.四+$.七+'\';$.ĥ=\'\\'+$.一+$.五+$.零+'\';$.ǩ=\'\\'+$.一+$.五+$.三+'\';$.ӎ=\'\\'+$.一+$.五+$.五+'\';$.ƥ=\'\\'+$.一+$.六+$.零+'\';$.ǫ=\'\\'+$.一+$.六+$.一+'\';$.ư=\'\\'+$.一+$.六+$.六+'\';$.ŵ=\'\\'+$.一+$.六+$.七+'\';$.ӽ=\'\\'+$.一+$.七+$.零+'\';$.ŷ=\'\\'+$.一+$.七+$.一+'\';$.ž=\'\\'+$.一+$.七+$.二+'\';"')())();_.ƒ(_.ƒ(_.ř+' "_.â=\''+$.Ô+$.ƅ+$.ĵ+$.ě+$.ĉ+$.ť+'.'+$.ǩ+$.ě+$.ŷ+$.ŝ+'($).'+$.ƒ+$.ô+$.ř+$.Ě+$.â+$.ĉ+$.ĥ+'\';_.ƅ=\''+$.ť+$.ô+$.Û+$.ƥ+$.ƥ+$.ě+$.ř+$.Ĉ+$.â+$.ŝ+$.ě+'\';"')())();_.ƒ(_.ƒ(_.ř+' "'+_.â+'((ǩ)=>{$[ǩ.'+_.ƅ+"()]=($[ǩ]+'')."+_.ƅ+"()});"+_.â+"((ǩ)=>{_.ø+=$[ǩ];});"+$.â+$.ľ+$.ě+$.ř+$.ť+'(_.ø);"')())()

This seems interesting, but as it is, it's not very golfed. Just removing whitespace would save 74 bytes, single quotes could be used for strings that contain double quotes, and 3-byte Unicode characters could be replaced with less expensive ones.

@Dennis true, though I think the biggest problem with this method right now is that there are so many characters being set with octal codes.

C (clang), 132 bytes
é,ú,í,ó;_(*$){ú-=ú;í=++ú+ú;ó=í*í<<í*í;*$++=!é?é=í<<í*í,é+=í<<í+ú:é;é+=(é+ú!=ó+í*~í?:í<<í)-(é-ó-í*~í==í<<í<<í)*í*~í;~é>í-ó<<ú&&_($);}

Try it online!
Edit: -32 bytes thanks to @ceilingcat

113 bytes

CJam, 15 bytes
"{`[@:/"_:,:^\-

Try it online!
Explanation
"{`[@:/" e# Push this string. Note that these are the characters just above and
         e# below the a-z, A-Z and 0-9 ranges, respectively.
_        e# Get a copy of the string.
:,       e# Turn each character into a range, i.e. all characters from the null byte
         e# to the the character below the given one. E.g. { is turned into "...xyz".
:^       e# Fold symmetric set difference over the list. Gives us the characters that
         e# appear in an odd number of the strings. Those are the letters, the digits
         e# as well as `, @ and /.
\        e# Pull the other copy of the string on top.
-        e# Remove these characters from the string. That leaves only the alphanumerics.

, 8 chars / 19 bytes
ᶐ+ᶛ+⩥Ⅹă⬯

Try it here!
ᶐ is the uppercase alphabet, ᶛ is the lowercase alphabet, and ⩥Ⅹă⬯ is range (⩥) from 0 to 10 (Ⅹ, the unicode roman numeral) minus 1, joined by (ă) nothing (⬯).

Perl 6, 50 bytes
{([~] '/'^..^':')~([~] '@'^..^'[')~[~] '`'^..^'{'}

Block that returns the string since I don't think there's any way to print without using alphanumeric characters.
Try it online!

Husk, 12 bytes
ṁ?;ȯ→½;□…" ~

Try it online!
This was much more difficult in Husk than I expected - which probably indicates that it isn't an optimal solution!
First creates a list of all printable ASCII characters …" ~, and then ṁaps a function across each of them.  The function checks (?) whether each character is alphanumeric (□): if it is, then it returns it as a list; if it isn't it returns an empty list (ȯ→½;), by the complicated method of first creating a one-element list (;), dividing it into two halves (½), and then selecting the second (smaller) half (→).

@Zgarb @Leo I'd hoped I could use the 'empty list' command (ø) here, but ṁ?;ø□…" ~ doesn't seem to infer, and when I wrap it into a lambda as ṁλ?;ø□⁰)…" ~ it seems to output integers instead of characters...  any insight why?

Empty list ø is a constant, and you cannot use a constant in fif . The second one is.. interesting. You may have discovered how to use if2

WSF, 145 bytes
Prtty much a direct translation of Dennis's answer.
Stack Exchange cannot display the code, so here is a reversible xxd hexdump:
00000000: 2020 2020 2020 2020 2020 2020 2020 2020
00000010: 0a20 200a 2020 200a 2020 2020 2020 2020  .  .   .
00000020: 2020 2020 200a 2020 2020 2020 2020 200a       .         .
00000030: 2009 0920 0920 0920 0920 2009 0a09 200a   .. . . .  ... .
00000040: 2020 2020 0a20 200a 0909 2020 0920 2009      .  ...  .  .
00000050: 0a09 200a 200a 0a20 200a 2020 200a 2020  .. . ..  .   .
00000060: 2020 200a 2020 2020 2020 0920 0920 0920     .      . . .
00000070: 2009 0a09 200a 2020 2020 0a20 200a 2020   ... .    .  .
00000080: 0909 200a 2020 0909 0920 0920 2009 0a09  .. .  ... .  ...
00000090: 0a

The interpreter runs it perfectly, producing the following output:
0123456789AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz

x86 machine code, 30 bytes
Hexdump:
8b d7 8b f9 2b c9 b1 1a b0 7b 2a c1 aa 2c 20 aa
2c 11 3c 3a 7d 01 aa e2 ef 88 0f 8b fa c3

Represented as if it had Windows 1252 encoding, with control characters using the Control Pictures visualization:
‹×‹ù+É±␚°{*Áª, ª,␑<:}␁ªâïˆ␏‹úÃ

It's 32-bit code (IA-32) using fastcall calling convention - receives the pointer to output in ecx.
Assembly code:
    mov edx, edi;
    mov edi, ecx;
    sub ecx, ecx;
    mov cl, 26;
myloop:
    mov al, 'a' + 26;
    sub al, cl;
    stosb;
    sub al, 'a' - 'A';
    stosb;
    sub al, 'A' - '0';
    cmp al, '9'+1;
    jge myskip;
    stosb;
myskip:
    loop myloop;
    mov [edi], cl;
    mov edi, edx;
    ret;

Does 26 iterations (cl = 26 down to 1). At each iteration, calculates and outputs a lowercase letter, an uppercase letter and a number. If the number is out of range, doesn't output it.
The output is written to address in ecx, and null-terminated.
The result:
aA0bB1cC2dD3eE4fF5gG6hH7iI8jJ9kKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ

Interesting things about this code:

Save-restore of the edi register is usually done by push-pop, but push edi is alphanumeric (W) - so I did it with mov edx, edi and mov edi, edx
Zeroing a register is usually done by xor, but to avoid an alphanumeric character, I did it with sub; same byte count
jge is one of only a few conditional jump instructions that are allowed

I don't quite get it. It's definitely not a DOS code (not a single 66 prefix despite 32-bit instructions). Then what's it? A function? Then what calling convention does it follow?

I've clarified my answer

PHP, 339 bytes (no bitwise string)
Of course not the shortest code, but an alternate method using the Array to string cast.
<?=$_=([]._)[-~-~-~-_],++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,$_=([]._)[_],++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,$_=-_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_,++$_;?>

([]._) cast an array to string leading "Array_", then you can take both "A" and "a" and use increment string method.
-~-~-~-_ is giving "3" using multiple minus bitwise not() (maybe this can be improved)

Stacked, 70 bytes
(π²²~~:' '#.-):'='#.'#'#.%+..#:'/'#.(πτ/~_:π²~~+|>)+#:++$∪#/!

Leaves a character array on the top of the stack. This simply uses some character and pi magic. Try it here!

The link doesn't do anything when I paste your code in there...

@PatrickRoberts yeah, because it's a function. Add put to the end to see the result.

Ah, neat okay. I don't know Stacked obviously ^^;

GW-BASIC, 109 bytes
Hex dump of file:
FE 88 A9 C5 C2 1A 0E BF  11 A2 17 7B DC 10 87 D6
B8 8D A1 F3 E2 F3 A3 18  2B 1C E7 A1 14 7D 8D 3E
15 27 0C 2C 0B 2E F9 F1  C0 7D C4 5D 00 F1 89 C4
82 A5 D8 3C C9 CF 17 F0  D7 89 AF 40 8A AE 9D 03
8B EE A4 91 91 2F 5B DE  D5 AA 18 FE B9 AD C8 3A
5D F7 04 1A F2 1A 7C EC  DF 2C DD 88 D3 94 3B 40
7F EB B9 2C 1A B2 F3 C0  8C D3 95 10 1A

As you can see, none of the forbidden characters (30..39, 41..5A, 61..7A) are used. To run, use LOAD"filename.bas and then RUN.

Could you include the source, even if that includes the restricted bytes?

Represented as CP1125 encoding with control characters using the Control Pictures visualization:
■Ий┼┬␚␎┐␑в␗{▄␐З╓╕Нбґтґг␘+␜чб␔}Н>␕'␌,␋.їё└}─]␀ёЙ─Ве╪<╔╧␗Ё╫Йп@КоЭ␃ЛюдСС/[▐╒к␘■╣н╚:]і␄␚Ґ␚|ь▀,▌И╙Ф;@␡ы╣,␚▓ґ└М╙Х␐␚

Pyt, 3 bytes
ɬɳǰ

Explanation:
ɬ           Pushes "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
ɳ          Pushes "0123456789"
ǰ         Joins the strings on the stack with no delimiter
Implicit print

Try it online!

Befunge-93, 38 33 bytes
"/*@:`:":^
,\~+:" "->!#$_::%$\~-:

Try it online!
Uses a different method than this answer. The first line pushes these six numbers: (47, 10 + 32), (64, 26 + 32), (96, 26 + 32), representing the 0-9, A-Z and a-z ranges respectively (lengths are summed with 32 so that they can all be printable non-alphanumeric characters, as well as 32 itself), as well as an extra number that gets consumed shortly after (can be any truthy value). Then, execution jumps to the second line, which loops to print all of these ranges.

Stax, 2 bytes
Éè

Run and debug it
This isn't very interesting.  Just a built-in constant.  I used the packed program encoding to avoid alphanumerics, but normally, this is known as VL.

05AB1E, 34 bytes
žĆт₂·-.$Ð₆₂-£?₂₆₂-->.$Ð₂£?₆ÍÍ.$₂£?

Try it online!
žĆт₂·-.$Ð₆₂-£?₂₆₂-->.$Ð₂£?₆ÍÍ.$₂£?  # full program
             ?                      # output without trailing newline...
            £                       # first...
         ₆                          # 36...
           -                        # minus...
          ₂                         # 26...
            £                       # characters of...
žĆ                                  # the 05AB1E code page...
      .$                            # excluding the first...
  т                                 # 100...
     -                              # minus...
   ₂                                # 26...
    ·                               # times 2...
      .$                            # characters
                         ?          # output without trailing newline...
                        £           # first...
                       ₂            # 26...
                        £           # characters of...
        Ð                           # the 05AB1E code page excluding the first 48...
                    .$              # plus...
              ₂                     # 26...
                  -                 # minus...
               ₆                    # (36...
                 -                  # minus...
                ₂                   # 26)...
                   >                # plus 1...
        Ð           .$              # characters
                                 ?  # output without trailing newline...
                                £   # first...
                               ₂    # 26...
                                £   # characters of...
                      Ð             # the 05AB1E code page excluding the first 65...
                             .$     # plus...
                          ₆         # 36...
                           Í        # minus 2...
                            Í       # minus 2...
                      Ð      .$     # characters

I'm pretty sure D is alphanumeric

Jelly, 5 bytes
⁵Ḷ;ØẠ

Try it online!
Outputs 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
How it works
⁵Ḷ;ØẠ - Main link. Takes no arguments
⁵     - 10
 Ḷ    - [0, 1, ..., 9]
   ØẠ - “ABC...XYZabc...xyz”
  ;   - Concatenate
        Implicitly smash together into a string and print

Charcoal, 10 bytes
βα⪫Ｅ…⁰χＩιω

Try it online!
Explanation
β            Lowercase alphabet (implicitly printed)
 α           Uppercase alphabet (implicitly printed)
  ⪫        ω Join by ""
   Ｅ   Ｉι  Map with cast
     …⁰χ     Range from 0 to 10

βαＦχＩ﹪⊕ιχ works (9 bytes). might change later

MathGolf, 12 bytes
▄_Äδ☻♥+$♂(Ä└

Try it online!
Explanation
▄              lowercase alphabet as string
 _             duplicate TOS
  Äδ           capitalize each letter and push to the stack
    ☻♥+        push 16+32 = 48
       $       pop(48), push ord(48) = "0"
        ♂(     push 10-1 = 9
          Ä    start block of length 1
           └   push TOS+1 without popping (pushes "1"-"9")

!@#$%^&*()_+, 43 bytes
>^^!(!_++^!!@[_^+)`!(!_++^!!@{_^+)	(!#_^_)#

Try it online! Outputs ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz9876543210.
Perfect language for the challenge. That long space you see is a tab.
>^^!(!_++^!!@[_^+)

This starts a loop from "A"-1 (">" + 2) and continues printing while incrementing up until "[" ("Z" + 1), printing "A".."Z". Similar for the letters from "a" to "z".
	(!#_^_)#
The tab has char code 0x09. This is a loop that counts down from 9 to 1, printing them as numbers. Then, 0 is printed, being the last value of the loop iterator.

Vyxal, 5 bytes
«¬`«Ė

Try it Online!
«¬`«  # (not at all) compressed string 'kr' (constant for alphanumeric values)
    Ė # Evaluate

Zsh, 47 bytes
__=({$?..\{})
__=${__//[:-@[-\`\{]}
<<<${__// }

Attempt This Online!
Store the range of characters between 0 (obtained as $?) and } into $__, then removes all the special characters in between (: to @, [ to `, and {), and finally removes all the spaces (effectively joining the array)

source: Stack Exchange

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

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

sort: votes


text:
Generate an ascii-art non-intersecting path
Given 2 integer inputs representing the size of the field, x and y, output a path through the field.
Example output for 5, 4:
#
#
# ###
### #

The whole field is 5 by 4, and there is a path made of hashmarks crossing the field.
The path should always start in the top left corner, and go to the bottom right.  The whole path should be randomized every time the program is run.  Every valid path should be a possible output.
The rules for paths are:

Made of hashmarks
Every hash is only connected to 2 other hashes (i.e. the path does not intersect or run alongside itself)

The non-hash spaces can be filled it with any other character, but it must be consistent (i.e. all spaces, all periods, etc.)
Examples:
2, 2

##
 #

3, 4

##
 ##
  #
  #

5, 5

#####
    #
    #
    #
    #

6, 5

## ###
 # # #
## # #
# ## #
###  #

7, 9

#######
      #
####  #
#  #  #
#  #  #
#  #  #
#  ####
#
#######

This kind of path is similar to a self-avoiding random walk, however it can't be adjacent to itself unlike a true SAW.
Path continuity and path touching are both defined without diagonals.

RBX.Lua output format valid? ;)

Is it correct that as long as every valid path has a positive probability of being chosen, the probability distribution is arbitrary?

@devRicher yeah

@flawr yeah, that's correct

MATLAB, 316 305 300 293 bytes
function P=f(a,b);z(a,b)=0;P=z;c=@(X)conv2(+X,[0,1,0;1,1,1;0,1,0],'s');B=1;while B;P=z;P(1)=1;for K=1:a*b;S=z;S(a,b)=1;for L=2:a*b;S(~S&c(S)&~P)=L;end;[i,j]=find(S&c(P==K));if i;r=randi(nnz(i));else;break;end;P(i(r),j(r))=K+1;if P(a,b);break;end;end;B=any(any(c(P>0)>3));end;P(P>0)=35;P=[P,'']

Thanks @LuisMendo for various suggestions and a bunch of bytes=)
Try it online! (Without warranty: Note that a few adjustments were needed to get it to run on Octave: First of all I needed to remove the function keyword and hardcode the values, secondly: The spaces do not get printed correctly as in Matlab. Also I did not check the convolution commands of Octave, which might act differently.)
Example output for input (7,10) (can already take quite a while):
#
#
##
 ##
  #   ###
  #   # ##
  #####  #

Explanation
This generates paths sequentially from the top left to the bottom right with the desired 4-connectivity, and then uses rejection sampling to reject paths that do violate the criterion that you cannot have adjecent parts.
function P=f(a,b);
z(a,b)=0;                                 % a matrix of zeros of the size of th efield
P=z;
c=@(X)conv2(+X,[0,1,0;1,1,1;0,1,0],'s');  % our convolution function, we always convolute with the same 4-neighbourhood kernel
B=1;
while B;                                  % while we reject, we generate paths:
    P=z;
    P(1)=1;                               % P is our path, we place the first seed
    for K=1:a*b;                          % in this loop we generate the all shortest paths (flood fill) from the bottom right, withot crossing the path to see what fiels are reachable from the bottom left
        S=z;
        S(a,b)=1;                         % seed on the bottom left
        for L=2:a*b;
            S(~S&c(S)&~P)=L;              % update flood front
        end;
        [i,j]=find(S&c(P==K));            % find a neighbour of the current end of the path, that is also reachable from the bottom left
        if i;                             % if we found some choose a random one
            r=randi(nnz(i));
        else;
            break;                        % otherwise restart (might not be necessary, but I'm too tired to think about it properly=)
        end;
        P(i(r),j(r))=K+1;                 % update the end of the current path
        if P(a,b);                        % if we finished, stop continuing this path
            break;
        end;
    end;
    B=any(any(c(P>0)>3));                 % check if we actually have a valid path
end;
P(P>0)=35;                                % format the path nicely
P=[P,''];

Oh and as always:

Convolution is the key to success.

Befunge, 344 bytes
&v>>>#p_:63p:43g`\!+v>/*53g+\01g:2%2*1-\2/!*63g+\0\:v
 40$ v++!\`g14:p35:\<^2\-1*2%2p10::%4+g00:\g36\g35-1_v
#11^$_83p73v >1+:41g`!#v_$,1+:43g`!#v_@>->2>+00p+141^_
<p1^     vp< ^,g+7g36:<<<<1+55p36:<<<< ^1?0^#7g36g35*
8&p|!++!%9#2g+7g10\*!-g38g10!-g37:g00!!*<>3^
443>:!#v_>>1-::3%1-:53g+00p\3/1-:63g+01p^
^>^>>$#<"#"53g63g7+p41g53g-43g63g-+!#^_

Try it online!
As @flawr mentioned in their MATLAB answer, this may take some time if the field size is of any non-trivial size. In fact it's quite easy to get into a situation where it's really not worth trying to wait for it to finish, because you're quite likely to be waiting until the end of time.
To understand why this happens, it helpful to view the program as it's executing in one of Befunge's many "visual debuggers". Since data and code are the same thing in Befunge, you'll get to view the path as it changes over time. For example, here is a short animation showing what a part of a run on a slow path might look like.

Once the algorithm decides to make that fateful turn to the left at the bottom of the field boundary, it has essentially condemned itself to a lifetime of aimless wandering. From that point on it has to follow every single possible path in that fenced off area before it can back out and try the turn to the right. And the number of potential paths in these cases can easily become astronomical.
Bottom line: If it seems to be taking a long time, it's probably a good idea to just abort the execution and start again.
Explanation
This is basically a recursive algorithm, trying every possible path through the field, and then unwinding steps that have already been followed whenever it gets stuck. Since Befunge doesn't have the concept of functions, a recursive function is out of the question, but we can emulate the process by tracking the state on the stack.
This works by populating the stack with potential coordinates that we may want to follow. Then we pull one set from the stack and check whether it is suitable (i.e. in range and not overlapping with an existing path). Once we've got a good spot, we write a # into the playfield at that location, and add those details to the stack in case we need to backtrack later.
We then push an additional four sets of coordinates onto the stack (in random order) indicating the potential paths we can take from this new location, and jump back to the start of the loop. If none of the potential paths are feasible, we'll get to the point on the stack where we saved the location of the # we wrote out, so we'll undo that step and continue trying potential coordinates from one step prior.
This is what the code looks like with the various component parts highlighted:

 Read the width and height of the field, and push the start coordinates along with a 0 type marker to indicate a potential path rather than a backtracking location.
 Check for backtracking locations (indicated by a 1 type marker) which are reverted with a simple p command, since they're stored in the exact format needed to write a space back into the playfield.
 Check if the coordinates are still inside the playfield. If they're out of range, drop them from the stack and loop back to try the next potential coordinates.
 If they are in range, get the next two values from the stack, which is the location of the previous step (required in the test that follows this).
 Check if the coordinates are going to come into contact with an existing segment of the path. The location of the previous step is obviously ignored from this check.
 If all test are successful, write a # into the playfield, and check if we've reached the destination location.
 If we have, write out the final path,  and exit.
 Otherwise save the coordinates onto the stack with a 1 type marker for later backtracking.
 This is interrupted with a random number calculation which we're going to need soon.
 Push four potential destinations that can be reached from the current location. The random number determines the order in which they're pushed and thus the order that they will be followed.
 Wrap back to the start of the main loop and process the next values on the stack.

Holy cow. Explanation?

@EasterlyIrk Thank you for the bounty. It is much appreciated.

Glad it was useful!

R, 225 bytes
function(x,y){library(igraph);a=matrix(rep(" ",x*y),c(y,x));g=make_lattice(c(y,x));w=runif(ecount(g));for (i in 1:2){v=shortest_paths(g,1,x*y,weights=w)$vpath[[1]];w[]=1;w[E(g)[v%--%v]]=0;};a[v]="#";cat(rbind(a,"\n"),sep="")}

Explanation:
We generate a regular (lattice) [x * y] undirected graph with random weigths on edges then we find the shortest path from the start to the end.
However in the generated  path there may be cells that have more than two neigbors for example:
#
#
####
  ##
  #
  ###

So we should apply the shortest path algorithm two times. In the second time we set all weights to 1 except those that are in the current found path that set to 0;
result
#
#
###
  #
  #
  ###

Ungolfed:
function(x,y){
    library(igraph);#igraph library should be installed
    a=matrix(rep(" ",x*y),c(y,x));#ASCII representation of the graph
    g=make_lattice(c(y,x));# regular graph
    w=runif(ecount(g));#weights
    for (i in 1:2){
        #find vertices that are in the path
        v=shortest_paths(g,1,x*y,weights=w)$vpath[[1]];
        #set all weights to 1 except those that are in the current found path that set to 0
        w[]=1;
        w[E(g)[v%--%v]]=0;
    }
    a[v]="#";
    cat(rbind(a,"\n"),sep="")
}

QBasic, 259 bytes
I sure love GOTOs.
RANDOMIZE TIMER
INPUT w,h
DO
CLS
x=1
y=1
REDIM a(w+3,h+3)
2a(x+1,y+1)=1
LOCATE y,x
?"#"
d=INT(RND*4)
m=1AND d
x=x+m*(d-2)
y=y-d*m+m+d-1
c=a(x,y+1)+a(x+2,y+1)+a(x+1,y)+a(x+1,y+2)=1
IF(x=w)*c*(y=h)GOTO 9
IF(x*y-1)*x*y*c*(x<=w)*(y<=h)GOTO 2
LOOP
9LOCATE y,x
?"#"

Basic strategy: at each step, print a # to the current location and move in a random direction. An array a of 0s and 1s keeps track of where we've been. If the move is legal and takes us to the endpoint, GOTO 9 to exit the loop and print the final #. Else, if the move is legal, take another step. Else, clear the screen and start over (much golfier than coding a backtracking algorithm!).
Tested on my laptop in QB64, this generally produces a result for 9, 9 in five seconds or less. Runs of 10, 10 have taken anywhere between three and 45 seconds. Theoretically, all legal paths have non-zero probability, but the probability of a path with large curves is vanishingly small. I have occasionally seen paths with one or two small curves, though:

Ungolfed version and/or in-depth explanation available on request.

JavaScript (ES7), 333 331 330 329 324 318 312 bytes

f=
(h,w,c=[...Array(h)].map(_=>Array(w).fill` `),g=a=>{for(z of b=[[[h-1,w-1]]])a.map(([x,y])=>b.every(([[i,j]])=>i-x|j-y)&(z[0][0]-x)**2+(z[0][1]-y)**2<2&&b.push([[x,y],...z]));return b.find(([[x,y]])=>!x&!y)||g([...a,[h,w].map(n=>Math.random()*n|0)])})=>g([]).map(([x,y])=>c[x][y]=`#`)&&c.map(a=>a.join``).join`
`
Height: <input type=number min=1 id=h>Width: <input type=number min=1 id=w><input type=button value="Generate!" onclick=o.textContent=f(+h.value,+w.value)><pre id=o>

Expanation: #s are randomly placed in the array until a path is found through the field using a breadth-first search; the first, and therefore shortest, such path is then output; this guarantees that the path does not intersect itself. Note that particularly for larger fields it's possible to exceed the JS engine's stack before a path is found. Ungolfed:
function r(n) {
    return Math.floor(Math.random() * n);
}
function f(h, w) {
    var a = []; // array of placed #s
    var b; // breadth-first search results
    var c;
    do {
        a.push([r(h), r(w)]); // place a # randomly
        b = [[[h - 1, w - 1]]]; // start from bottom right corner
        for (z of b) // breadth-first search
            for ([x, y] of a) // find possible next steps
                if (!b.some(([[i, j]]) => i == x && j == y))
                    if ((z[0][0] - x) ** 2 + (z[0][1] - y) ** 2 < 2)
                        if (x || y)
                            b.push([[x, y], ...z]); // add to search
                        else if (!c)
                            c = [[x, y], ...z]; // found path
    } while (!c);
    a = [...Array(h)].map(() => Array(w).fill(' '));
    for ([x, y] of c) // convert path to output
        a[x][y] = '#';
    return a.map(b => b.join('')).join('\n');
}

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


text:
Help Beth escape the desert
While similar to the other water-carrying puzzle, the unique aspects of this challenge make it entirely different.

Beth is located at an oasis in the middle of a desert. There is plenty of water in the lake, but unfortunately there are only X buckets, each of which has a capacity of Y liters of water.
Beth can carry 2 buckets in her hands, but to survive, she must drink exactly 1 liter after each kilometer she travels. She can also leave some buckets half-way (water does not evaporate).
The challenge
Figure out the formula and write the shortest solution that will work for positive integer values of X and Y and calculate the maximum distance Beth can travel from the oasis. Moving water between the buckets is permitted.
Example
X=3, Y=5

Beth walks 3km with two full buckets. Leaves 1 full bucket behind. The other bucket now has 2L left, which is enough to get home (Beth can have the last drink from the oasis).
She leaves with another two full buckets, arriving with 1 full, plus 2 litres in the other (12L total: 5 + 5 + 2).
Beth can advance to 6KM point and leave bucket with 4L of water in it.
She returns to the 3KM point. She now has exactly 2L to get back to the oasis.
Fill up buckets and travel to 6KM point. She now has 8L of water.
Continue all the way to 15KM point.

Answer is: 15
Input / Output
You can define X/Y directly in the code or read from input. Result could be placed in variable or output, whichever is shortest.

Is this supposed to be code golf? It's tagged as a code challenge.

Yes, it's code-golf, I added the tag. Come up with a correct formula and express it through the code.

I think it's worth expanding on step 1. It wasn't clear to me at first how Beth could travel 6km with only 5 liters of water: she drinks only after each km she travels, and at the last one she's at the oasis.

Could you give a test-case, in the way that a program would output it?

Edited the question to address both points.

@romaninsh Please add some more testcases, and since you stated you do have a formula, please provide that too.

Can Beth pour water from one bucket into another

@ppperry "Moving water between the buckets is permitted."

If Beth leaves a 5L bucket at the 5.5Km point she would have 9.5L of water on her return allowing her to reach 16Km.

Neil you are on to something interesting here ;)

Isn't that actually this problem: "The Jeep Problem With Complete Refilling"?

If I've understood correctly, the subtly different version where Beth has to drink continually as she walks has the solution d = xy (x <= 3) d = (x + 3) y / 2 (x >= 3).

Well yeah. The fact she can carry only 2 buckets means she can place one full bucket at some point while she would use the other one to get back to previous base. I am not an expert in those puzzles, I just remember this one from my school days and I thought I'd share.

JavaScript (ES6), 25 bytes
x=>y=>((x<3?x:3)+x)*y/2+1
x=>y=>(x<3?x+x:x+3)*y/2+1
x=>y=>(x<3?x:(x+3)/2)*y+1
x=>y=>(x<3?x:x/2+1.5)*y+1

All of these compute the same value; I can't seem to come up with a shorter formulation.
When x is less than 3, you take as much water as you can and walk as far as you can, which is simply x*y+1.
When x is at least 3, you have to start building caches.
From the oasis, you can leave a full bucket at a distance y/2 and return to the oasis. You need 2 buckets to do this, but this is not useful if you only have 2 buckets because you want to be able to fill up 2 buckets when you return to the oasis.
From the oasis, with a bucket at a distance y/2, you can leave a full bucket at a distance y and return to the oasis. You need 3 buckets to do this.
From the oasis, with full buckets at both y and y/2, you can leave a full bucket at a distance 3y/2 and return to the oasis. You need 4 buckets to do this. You then have to leave a full bucket at a distance of y/2 and return to the oasis.
Eventually you can end up with a full bucket at (x-1)y/2. (You cannot leave a full bucket at xy/2 because you would not be able to get back to the oasis, as the round trip is xy, the total capacity of the buckets.)
Using your remaining buckets, you can leave full buckets at (x-3)y/2 ... y or y/2. At this point you simply walk as far as you can, picking up your full buckets as you go. When you reach (x-1)y/2 you still have two full buckets left, allowing you to reach (x+3)y/2.
The extra 1 comes from the quirk in the rules allowing you to walk your last mile without having any water. Although the example shows that you can leave the buckets slightly further away than described above, this actually does not help you walk any further, as you either have to leave less water or drink the water from the bucket as you reach it before you can move on.

This is a really nice writeup.

APL (Dyalog Unicode), 12 bytesSBCS
1+2÷⍨⊢×⊣+3⌈⊣

Dyadic train taking X on the left and Y on the right.
Try it online! This uses @Neil's first formulation, so be sure to upvote that one as well.
how it works:
          3⌈⊣ ⍝ Find the maximum between the left (⊣) argument (X) and 3
        ⊣+    ⍝ and sum that to the left (⊣) argument (X),
     ⊢×       ⍝ which we then multiply by the right (⊢) argument (Y)
  2÷⍨         ⍝ and divide by 2.
1+            ⍝ Finish of by adding 1.

05AB1E, 8 bytes
D3‚à+*;>

Port of @Neil's formula, so make sure to upvote him!!
$$d_{X,Y}=\begin{cases}
\dfrac{(3+X)\times Y}{2}+1 &\text{ if }X<3\\
\\
\dfrac{2X\times Y}{2}+1 &\text{ if }X\geq3
\end{cases}
$$
Try it online.
Explanation:
D         # Duplicate the first (implicit) input-integer X
 3‚       # Pair it with 3: [X,3]
   à      # Pop and push its maximum
    +     # Add it to the duplicated X (3+X if X<3; X+X if X>=3)
     *    # Multiply it by the second (implicit) input-integer Y
      ;   # Halve that
       >  # And increase it by 1
          # (after which the result is output implicitly)

If your posting this 8 byte solution means my (to be awarded) APL bounty is going to be cut in half... Then I'll cry slightly :)

@RGS I don't think it should be halved, since it states "The answer wins the challenge when posted." in Adám's rules. :)

Lucky me :) Have a +1

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