text:
Enumerate binary trees
Binary trees
A binary tree is a tree with nodes of three types:

terminal nodes, which have no children
unary nodes, which have one child each
binary nodes, which have two children each

We can represent them with the following grammar, given in BNF (Backus–Naur form):
<e> ::=
      <terminal>
    | <unary>
    | <binary>

<terminal> ::=
    "0"

<unary> ::=
    "(1" <e> ")"

<binary> ::=
    "(2" <e> " " <e> ")"

In this grammar the nodes are given in preorder and each node is represented by a digit which is the number of children it has.
Motzkin numbers
Motzkin numbers (OEIS) (Wikipedia) have many interpretations, but one interpretation is that the nth Motzkin number is the number of distinct binary trees with n nodes. A table of Motzkin numbers starts
N          Motzkin number M(N)
1          1
2          1
3          2
4          4
5          9
6         21
7         51
8        127
    ...

e.g. M(5) is 9, and the nine distinct binary trees with 5 nodes are
1      (1 (1 (1 (1 0))))
2      (1 (1 (2 0 0)))
3      (1 (2 0 (1 0)))
4      (1 (2 (1 0) 0))
5      (2 0 (1 (1 0)))
6      (2 0 (2 0 0))
7      (2 (1 0) (1 0))
8      (2 (1 (1 0)) 0)
9      (2 (2 0 0) 0)

Task
Take a single positive integer n as input and output all of the distinct binary trees with n nodes.
Examples for n from 1 to 5 with parenthesis included for readability
0

(1 0)

(1 (1 0))
(2 0 0)

(1 (1 (1 0)))
(1 (2 0 0))
(2 0 (1 0))
(2 (1 0) 0)

(1 (1 (1 (1 0))))
(1 (1 (2 0 0)))
(1 (2 0 (1 0)))
(1 (2 (1 0) 0))
(2 0 (1 (1 0)))
(2 0 (2 0 0))
(2 (1 0) (1 0))
(2 (1 (1 0)) 0)
(2 (2 0 0) 0)

Input
The input will be one positive integer.
Output
The output should be an intelligible representation of the distinct binary trees with that many nodes. It is not compulsory to use the exact string given by the BNF grammar above: it is sufficient that the syntax used give an unambiguous representation of the trees. E.g. you could use [] instead of (), an extra level of brackets [[]] instead of [], outer parenthesis are present or missing, extra commas or no commas, extra spaces, parenthesis or no parenthesis, etc.
All of these are equivalent:
(1 (2 (1 0) 0))
[1 [2 [1 0] 0]]
1 2 1 0 0
12100
(1 [2 (1 0) 0])
.:.--
*%*55
(- (+ (- 1) 1))
-+-11

Also a variation purposed by @xnor in a comment.
Since there is a way to translate this to a format that can be understood it is acceptable.
[[[]][]]  is (2 (1 0) 0)

To make this easier to understand convert some of the [] to () like so
[([])()]

Now if you start with
[]

then insert a binary which needs two expressions you get
 [()()] which is 2

and then for the first () insert a unary which needs one expression you get
 [([])()] which is 21

but since [] or () with no inner bracketing can represent 0 which needs no more expressions you can interpret it as
 2100

Note that answers should work theoretically with infinite memory, but will obviously run out of memory for an implementation-dependent finite input.
Variations of output
BNF             xnor       Christian   Ben
b(t, b(t, t))   [{}{{}{}}] (0(00))     (1, -1, 1, -1)
b(t, u(u(t)))   [{}{(())}] (0((0)))    (1, -1, 0, 0)
b(u(t), u(t))   [{()}{()}] ((0)(0))    (1, 0, -1, 0)
b(b(t, t), t)   [{{}{}}{}] ((00)0)     (1, 1, -1, -1)
b(u(u(t)), t)   [{(())}{}] (((0))0)    (1, 0, 0, -1)
u(b(t, u(t)))   [({}{()})] ((0(0)))    (0, 1, -1, 0)
u(b(u(t), t))   [({()}{})] (((0)0))    (0, 1, 0, -1)
u(u(b(t, t)))   [(({}{}))] (((00)))    (0, 0, 1, -1)
u(u(u(u(t))))   [(((())))] ((((0))))   (0, 0, 0, 0)

A possible place to check for duplicate trees
One place to check for a duplicate is with M(5).
This one tree was generated twice for M(5) from M(4) trees
(2 (1 0) (1 0))

the first by adding a unary branch to
(2 (1 0) 0)

and second by adding a unary branch to
(2 0 (1 0))

Understanding BNF
BNF is composed of simple rules:
<symbol> ::= expression

where on the left is a symbol name surrounded by <>.
On the right is the expression for constructing the symbol.
Some rules use other rules in the construction, e.g.
<e> ::= <terminal>

e can be a terminal
and some rules have characters that are used in constructing the symbol, e.g.
<terminal> ::= "0"

terminal is just the character zero.
Some rules have multiple ways of constructing them, e.g.
<e> ::=
      <terminal>
    | <unary>
    | <binary>

An e can be a <terminal> or a <unary> or a <binary>.
And some rules are a sequence of parts, e.g.
<unary> ::= "(1" <e> ")"

A unary is the characters (1 followed by what can be constructed for e followed by ).
You always start with the starting rule, which for this <e>.
Some simple examples:
The simplest sequence is just 0. So we start with the starting rule <e> and see that there are three choices:
  <terminal>
| <unary>
| <binary>

so take the first one <terminal>. Now a terminal has no choices and is 0.  So replace <terminal> with 0 in the <e> rule and you are done.
Then next one is (1 0). Start with <e> and use rule <unary> which has
"(1" <e> ")"

Now this needs an <e> so we go back to <e> and make a choice of one of the three, this time choosing, <terminal> which gives 0. Replacing 0 into (1 <e> ) gives (1 0), and this is replaced into <unary> so <e> is (1 0).

So, a binary tree? "a binary tree is a tree data structure in which each node has at most two children"

Your description is that of a binary tree. Binary trees do not need to have 2 children. It just means they have at most 2 children. I guess unary-binary is just a more specific term which doesn't really mean anything different.

Consider clarifying what "BNF" is for those of us who are not computer scientists

@GuyCoder My point is, if someone sees "BNF" and doesn't know what that means they may be put off and stop reading. Perhaps using the name instead of the acronym and adding a link to the Wikipedia would suffice

I think that since these are binary trees, they should be called binary trees. No sense creating a new term for something that already has a proper name.

@mbomb007 Name changed. I should get a peer-pressure award for that. :)

Just make sure that if your friends all jump off a binary bridge that you don't.

Not sure about the "this is just a binary tree" talk. In my opinion, if a node in a usual binary tree has only one descendant, you could still differentiate between it being the left or right one.

Haskell, 68 bytes
t 0=[""]
t 1=["0"]
t n=['(':x++y++")"|k<-[1..n-1],x<-t k,y<-t$n-k-1]

Terminal nodes are represented by 0, unary and binary nodes by (e) resp. (ee), so the two three-node trees are given as (00) and ((0)).
Examples:
*Main> t 5
["(0(00))","(0((0)))","((0)(0))","((00)0)","(((0))0)","((0(0)))","(((0)0))","(((00)))","((((0))))"]
*Main> length $ t 8
127
*Main> length $ t 15
113634

Pyth (24 21 19 bytes)
This is based on my Python 3 solution.
f!|sTf<sY0._T^}1_1t

It's my first time using Pyth so this is likely still golfable.
Example, output when input is 4:
[[1, 0, -1], [1, -1, 0], [0, 1, -1], [0, 0, 0]]

1 represents a binary node, 0 represents a unary node, and -1 represents a terminal node. There is an implied terminal node at the end of every tree.
Explanation:
f!|sTf<sY0._T^}1_1t
f                    filter
             ^    t  length n-1 lists of elements
              }1_1   from [1, 0, -1]
 !|                  for when both
   sT                sum of list is 0, and
     f    ._T        for each prefix of list,
      <sY0           sum of prefix is non-negative.

Of interest: Pyth source code

CJam (37 bytes)
0aa{_2m*2\f+1Y$f+++:e__&}qi:A*{,A=},p

Online demo. Note that this is not very efficient, and you probably don't want to try calculating input 5 online.
Dissection to follow.

brainfuck, 107 bytes
,>++>-[-[<-[<-[>>[[>+<-]<]>+>[[<+>>>>>+<<<<-]>]>>++>,++++>]>[<+>-[+>>]>[<->[.<<<
<<]+[->+]+>>>]]]]<[[,<]<]<]

Formatted:
,>++>-
[
  -
  [
    <-
    [
      <-
      [
        >>
        [[>+<-]<]
        >+>
        [[<+> >>>>+<<<<-]>]
        >>++>,++++>
      ]
      >
      [
        <+>-
        [
          +>>
        ]
        >
        [
          <->[.<<<<<]
          +[->+]
          +>>>
        ]
      ]
    ]
  ]
  <
  [
    [,<]
    <
  ]
  <
]

Try it online
Input is taken as a byte, and the tree 12100 is represented as \x01\x02\x03\x02: to convert back, translate tr/\x01\x02\x03/012/, reverse the string, and add a final 0. Trees are separated by \xfe. (The output can be made easier to read by e.g. changing the first - into -36 and the . into +47.-47, where -36 means a string of 36 - characters, etc.)
This approach makes use of the property (which Ben Frankel also used): considering the possible nodes as -1, 0, 1 and disregarding the final -1 node, a list represents a valid tree if and only if (1) all prefixes of the list have non-negative sum, and (2) the sum of the entire list equals 0. The first condition is maintained while generating intermediate nodes, so only the second condition needs to be checked at the end.
The tape is divided into 5-node cells,
i d x 0 0

where i is the index (descending from left to right), d is the partial sum, and x is the element.
Sketch of control flow:
take n and push initial node
while stack is non-empty:
    if rightmost node can be decremented:
        decrement rightmost node
        if there are less than n nodes:
            push new node
        else if valid tree:
            print
    else:
        backtrack (pop)

Note that sometimes a value is stored or initialized as one or two greater than the actual (conceptual) value and adjusted as needed.

JavaScript (Firefox 30-57), 79 bytes
f=(m,l=0)=>m?[for(n of[1,0,-1])if(l>n&l<=m+n)for(a of f(m-1,l-n))[...a,n]]:[[]]

Where -1 represents a terminal, 0 a unary node and 1 a binary node. Starts getting slow at m=14 on my PC. Recursively works back from the end of the tree.

The number of unaccounted-for nodes l is limited by the fact that there may only be 1 node left at the end.
The type of the next node n is limited by the need to have enough unaccounted-for nodes to be its children.

Python 3 (138 134 128 121 119 bytes)
from itertools import*
lambda n:[any(sum(t[:k])<0for k in range(n))|sum(t)or print(t)for t in product(*[[-1,0,1]]*~-n)]

Example output, for n=5:
(0, 0, 0, 0)
(0, 0, 1, -1)
(0, 1, -1, 0)
(0, 1, 0, -1)
(1, -1, 0, 0)
(1, -1, 1, -1)
(1, 0, -1, 0)
(1, 0, 0, -1)
(1, 1, -1, -1)

1 represents a binary node, 0 represents a unary node, and -1 represents a terminal node. There is an implied terminal node at the end of every tree.
The program starts taking too long at around n=17.

Prolog, 149 144 138 137 131 107 bytes
e(L,L)-->[0].

e([_|A],L)-->
    [1],
    e(A,L).

e([_,_|A],L)-->
    [2],
    e(A,B),
    e(B,L).

e(M,E):-
    length([_|L],M),
    e(L,[],E,[]).

?- e(5,S).
S = [1, 1, 1, 1, 0] ;
S = [1, 1, 2, 0, 0] ;
S = [1, 2, 0, 1, 0] ;
S = [1, 2, 1, 0, 0] ;
S = [2, 0, 1, 1, 0] ;
S = [2, 0, 2, 0, 0] ;
S = [2, 1, 0, 1, 0] ;
S = [2, 1, 1, 0, 0] ;
S = [2, 2, 0, 0, 0].

And to count the solutions
e_count(N,Count) :-
    length([_|Ls], N),
    findall(., phrase(e(Ls,[]),E), Sols),
    length(Sols, Count).

?- e_count(N,Count).
N = Count, Count = 1 ;
N = 2, Count = 1 ;
N = 3, Count = 2 ;
N = Count, Count = 4 ;
N = 5, Count = 9 ;
N = 6, Count = 21 ;
N = 7, Count = 51 ;
N = 8, Count = 127 ;
N = 9, Count = 323 ;
N = 10, Count = 835 ;
N = 11, Count = 2188 ;
N = 12, Count = 5798 ;
N = 13, Count = 15511 ;
N = 14, Count = 41835 ;
N = 15, Count = 113634

Python, 71 bytes
f=lambda n:{(a+b,)for k in range(n)for a in f(k)for b in f(n+~k)}or[()]

This represents trees as nested tuples such as ((((),), ()),), which can be transformed into ((())()) by removing commas, spaces, and the outermost ().
An earlier 76-byte version:
f=lambda n:{'('+a+b+')'for k in range(n)for a in f(k)for b in f(n+~k)}or['']

CJam, 38 bytes
Uses a different approach that Peter Taylor's  CJam answer.
3rim*{:(1\+[{1$+}*])\:(_:z#|!},

Output will be something like 1110120020102100. Each tree is a group of n digits (where n is the input number).
The basic idea is that we generate each possible string of digits 0, 1, and 2, and then filter only the ones that are well-formed trees.


text:
Make this dice game fair
This challenge is adapted from the British Informatics Olympiad.

Dice game
Two players are playing a dice game where they each roll a pair of dice, and the highest sum wins. The pairs of dice have the same number of sides, but do not have to have the same values on each side. Therefore, the game is fair if for both pairs of dice all possible sums can be made with equal probability.
For example, if Player 1 has the following dice:
{1,2,3,4,5,6} {1,2,3,4,5,6}

Then they can produce the following sums:
    1  2  3  4  5  6
 +------------------
1|  2  3  4  5  6  7
2|  3  4  5  6  7  8
3|  4  5  6  7  8  9
4|  5  6  7  8  9  10
5|  6  7  8  9  10 11
6|  7  8  9  10 11 12

If Player 2 has:
{1,2,2,3,3,4} {1,3,4,5,6,8}

They can produce:
    1  2  2  3  3  4
 +------------------
1|  2  3  3  4  4  5
3|  4  5  5  6  6  7
4|  5  6  6  7  7  8
5|  6  7  7  8  8  9
6|  7  8  8  9  9  10
8|  9  10 10 11 11 12

This game is fair as the minimum for both is 2, the maximum is 12, and each sum occurs the same number of times, e.g 7 can be made 6 ways with each pair.

Challenge
Write a program/function that takes two dice as input, and optionally an integer representing the number of sides each dice contain, and prints/returns a different pair of dice that could be used to play a fair game with the two input dice, or any falsey value if there is no solution different from the input.

Specifications

The number of sides on both dice must be the same, and equal to the number of sides on the input pair of dice. This number will always be an integer greater than or equal to 1.

The two dice returned can be the same, but the pair must not be the same as the input pair.

Different order pairs are not different; {1,2,3} {4,5,6} is the same as {4,5,6} {1,2,3}.

Your program does not need to produce a result quickly, as long as it will eventually produce correct output.

The values on the input pair of dice dice will always be integers between 1 and 9 inclusive, but the values returned can be any integer ≥1.

If there is more than one possible solution, only one needs to be returned.

Input/Output can be in any reasonable format.

Test Cases
6
1 2 2 3 3 4
8 6 5 4 3 1

1 2 3 4 5 6
1 2 3 4 5 6

4
1 1 1 1
1 4 5 8

1 1 4 4
1 1 5 5

3
1 3 5
2 4 6

False

8
1 2 3 4 5 6 7 8
1 2 3 4 5 6 7 8

Any of the following:

1 2 2 3 3 4 4 5       |    1 2 2 3 5 6 6 7   |    1 2 3 3 4 4 5 6
1 3 5 5 7 7 9 11      |    1 3 3 5 5 7 7 9   |    1 2 5 5 6 6 9 10

3-sided dice look cool: http://images2.sw-cdn.net/product/picture/625x465_2689455_2046022_1459303706.jpg

Will the die only contain digits, or can it also be higher than 9? I only see ruling about the sides being >=1, but is there a max? If it can be higher than 9, would you mind adding a test case for it?

@KevinCruijssen Updated, input will only contain digits, output can contain any integer ≥1.

Jelly, 34 bytes
+þµFṢ
ç©ṀRœċL}Œċµç/⁼®µÐf
,Ṣ€,Ṛ$ḟ@ç

Returns a list of all possible pairs of dice up to ordering of dice and faces* (excluding any that are the same dice as the input pair).
Try it online!
This is a brute-forcer, and is not efficient (too slow to even run the 6-face test case at TIO).
+þµFṢ - Link 1, sorted sums: dieA, dieB
 þ    - outer product with
+     -     addition (make a table of the sums, a list of lists)
  µ   - monadic chain separation
   F  - flatten into one list
    Ṣ - sort

ç©ṀRœċL}Œċµç/⁼®µÐf - Link 2, all possible fair dice pairs (including input): dieA, dieB
ç                  - call the last link (1) as a dyad
 ©                 - save the result to the register for later use too
  Ṁ                - maximum (the largest sum)
   R               - range [1,2,...,maxSum]
       }           - use right argument (dice B) to turn the monad into a dyad:
      L            -     length
    œċ             - all combinations with replacement (i.e. all dice with faces between 1 and maxSum inclusive [overkill, but golfier than less])
        Œċ         - all pairs of these dice
          µ        - monadic chain separation
               µÐf - filter keep:
            /      -     reduce with:
           ç       -         last link (1) as a dyad (the sorted sums of the current pair)
              ®    -     retrieve register value (the sorted sums of the input pair)
             ⁼     -     equal?

,Ṣ€,Ṛ$ḟ@ç - Main link: dieA, dieB
,         - pair - [dieA, dieB]
 Ṣ€       - sort €ach - [dieASorted, dieBSorted]
     $    - last two links as a monad:
    Ṛ     -     reverse - [dieBSorted, dieASorted]
   ,      -     pair - [[dieASorted, dieBSorted], [dieBSorted, dieASorted]]
        ç - call the last link (2) as a dyad (with dieA, dieB)
       @  - reversed @rguments:
      ḟ   -     filter out - removes any results that are equivalent to the input pair.

* i.e. if [[1,1,4,4],[1,1,5,5]] is a possibility (like in one of the examples) there wont be a [[1,1,5,5],[1,1,4,4] or [[1,4,1,4],[1,1,5,5]], etc.

Hmm, I have actually assumed dice will be in face order (either dice first), is that OK or not?

...I noticed a test case has a die that is not ordered so I removed the assumption.

C++14, 130 bytes
As unnamed lambda assuming M to be like std::vector<std::vector<int>>. Fair is 0, anything else is unfair.
#include<map>
[](auto&M){auto g=[](auto&v){std::map<int,int>m;for(int x:v)for(int y:v)m[x+y]++;return m;};return g(M[0])-g(M[1]);}

Ungolfed:
#include<map>

auto f=
[](auto&M){
 auto g=[](auto&v){
  std::map<int,int>m;
  for(int x:v)
   for(int y:v)
    m[x+y]++;
  return m;
 };
 return g(M[0])==g(M[1]);
}
;

Python, 228 bytes
from itertools import*;s,C=lambda x,y:sorted(sum([[i+j for j in y]for i in x],[])),combinations_with_replacement;f=lambda k,l,m:([[*a]for a in C([*C([*range(1,s(l,m)[-1])],k)],2)if(s(l,m)==s(*a))*~-([*a]in[[l,m],[m,l]])]+[0])[0]

This was from a long time ago; I could probably golf this a bit better now.

source: Stack Exchange

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

sort: votes


text:
ASCII Cayley Graph
While doing some research for a different challenge I'm formulating, I came across a Cayley graph, specifically this one. Since I'm one of the top ascii-art challenge writers, of course I had to make an ASCII art challenge for this.
Your challenge is to produce this ASCII art depiction of a Cayley graph of the free group on two generators as follows:
                                               +
                                              +++
                                             + | +
                                            ++-+-++
                                             + | +
                                          +    |    +
                                         +++   |   +++
                                        + |    |    | +
                                       ++-+----+----+-++
                                        + |    |    | +
                                         +++   |   +++
                                          +    |    +
                                   +           |           +
                                  +++          |          +++
                                 + | +         |         + | +
                                ++-+-++        |        ++-+-++
                                 + | +         |         + | +
                              +    |           |           |    +
                             +++   |           |           |   +++
                            + |    |           |           |    | +
                           ++-+----+-----------+-----------+----+-++
                            + |    |           |           |    | +
                             +++   |           |           |   +++
                              +    |           |           |    +
                                 + | +         |         + | +
                                ++-+-++        |        ++-+-++
                                 + | +         |         + | +
                    +             +++          |          +++             +
                   +++             +           |           +             +++
                  + | +                        |                        + | +
                 ++-+-++                       |                       ++-+-++
                  + | +                        |                        + | +
               +    |    +                     |                     +    |    +
              +++   |   +++                    |                    +++   |   +++
             + |    |    | +                   |                   + |    |    | +
            ++-+----+----+-++                  |                  ++-+----+----+-++
             + |    |    | +                   |                   + |    |    | +
              +++   |   +++                    |                    +++   |   +++
               +    |    +                     |                     +    |    +
        +           |                          |                          |           +
       +++          |                          |                          |          +++
      + | +         |                          |                          |         + | +
     ++-+-++        |                          |                          |        ++-+-++
      + | +         |                          |                          |         + | +
   +    |           |                          |                          |           |    +
  +++   |           |                          |                          |           |   +++
 + |    |           |                          |                          |           |    | +
++-+----+-----------+--------------------------+--------------------------+-----------+----+-++
 + |    |           |                          |                          |           |    | +
  +++   |           |                          |                          |           |   +++
   +    |           |                          |                          |           |    +
      + | +         |                          |                          |         + | +
     ++-+-++        |                          |                          |        ++-+-++
      + | +         |                          |                          |         + | +
       +++          |                          |                          |          +++
        +           |                          |                          |           +
               +    |    +                     |                     +    |    +
              +++   |   +++                    |                    +++   |   +++
             + |    |    | +                   |                   + |    |    | +
            ++-+----+----+-++                  |                  ++-+----+----+-++
             + |    |    | +                   |                   + |    |    | +
              +++   |   +++                    |                    +++   |   +++
               +    |    +                     |                     +    |    +
                  + | +                        |                        + | +
                 ++-+-++                       |                       ++-+-++
                  + | +                        |                        + | +
                   +++             +           |           +             +++
                    +             +++          |          +++             +
                                 + | +         |         + | +
                                ++-+-++        |        ++-+-++
                                 + | +         |         + | +
                              +    |           |           |    +
                             +++   |           |           |   +++
                            + |    |           |           |    | +
                           ++-+----+-----------+-----------+----+-++
                            + |    |           |           |    | +
                             +++   |           |           |   +++
                              +    |           |           |    +
                                 + | +         |         + | +
                                ++-+-++        |        ++-+-++
                                 + | +         |         + | +
                                  +++          |          +++
                                   +           |           +
                                          +    |    +
                                         +++   |   +++
                                        + |    |    | +
                                       ++-+----+----+-++
                                        + |    |    | +
                                         +++   |   +++
                                          +    |    +
                                             + | +
                                            ++-+-++
                                             + | +
                                              +++
                                               +

Input
No input, unless your language explicitly requires input to run.
Output
The ASCII art representation shown above.
MD5 Hashes
Since this is a pretty large output, to check your work here are some MD5 hashes of example forms of output (all are UTF-8 without BOM):

Square space padding, CR/LF linefeeds, and trailing newline -- 954B93871DAAE7A9C05CCDF79B00BF3C -- this is the representation used above.
Square space padding, CR/LF linefeeds, no trailing newline -- 28405EF91DA305C406BD03F9275A175C
Square space padding, LF linefeeds, and trailing newline -- 8CA65FB455DA7EE5A4C10F25CBD49D7E
Square space padding, LF linefeeds, no trailing newline -- FDB1547D68023281BB60DBEC82C8D281
No trailing spaces, CR/LF linefeeds, and trailing newline -- 77FDE8CE5D7BD1BDD47610BA23264A19
No trailing spaces, CR/LF linefeeds, no trailing newline -- EAD390C3EFD37F0FCACE55A84B793AB5
No trailing spaces, LF linefeeds, and trailing newline -- 1F6CAB740F87881EB2E65BED65D08C36
No trailing spaces, LF linefeeds, no trailing newline -- 7D41CE1E637619FEA9515D090BFA2E9C
If there is an additional MD5 you would like for comparison, please let me know and I'll create it and update the challenge.

Rules

Leading or trailing newlines or whitespace are all optional, so long as the characters themselves line up correctly.
Either a full program or a function are acceptable. If a function, you can return the output rather than printing it.
If possible, please include a link to an online testing environment so other people can try out your code!
Standard loopholes are forbidden.
This is code-golf so all usual golfing rules apply, and the shortest code (in bytes) wins.

I'm slightly surprised this isn't parametrised in any way - it looks as if it should be the sixth in a sequence.

This anarchy golf challenge is very similar.

@Neil I had considered doing so, but decided against it for fear that it would increase the difficulty too much for little gain.

Looks like the runs of -/|s follow the formula (2<<n)-n-2 rather than (1<<n)-1 which is what my original guess would have been.

@Neil They're actually Eulerian numbers, since that provided the best aesthetic.

Why in the "last iteration" it started to overlap ;-;

Cool highscores listing! I'm 6th in [tag:ascii-art]! I didn't know S.E. had this feature; neato.

JavaScript (ES6), 204 195 188 180 bytes

f=
_=>[...Array(9119)].map((_,i)=>~i%96?g(48+~(i/96),47-i%96,5):`
`,g=(x,y,z,n=(1<<z)-z)=>x|y?(x=x<0?-x:x)+(y=y<0?-y:y)<n?` |-+`[2*!x+!y]:z--?x>y?g(x-n,y,z):g(x,y-n,z):` `:`+`).join``
;document.write(`<pre>`+f())

Square space padding, LF linefeeds, and no trailing newline, although I haven't checked the MD5.

f=
m=>[...Array((w=(4<<m)-m*-~m-2)*~-w)].map((_,i)=>~i%w?g(w/2+~(i/w),w/2-i%w-1,m):`
`,g=(x,y,z,n=(1<<z)-z)=>x|y?(x=x<0?-x:x)+(y=y<0?-y:y)<n?` |-+`[2*!x+!y]:z--?x>y?g(x-n,y,z):g(x,y-n,z):` `:`+`).join``
<input type=number min=0 oninput=o.textContent=f(this.value)><pre id=o>+

Parametrised version for 222 216 207 199 bytes. Explanation: The output size is 9119 ASCII characters, including 46 newlines. (For the parametrised version, the output size is calculated including the trailing newline.) Each character is individually determined, firstly by checking whether a newline is due, otherwise by calling a function on the coordinates relative to the origin in the middle of the final diagram. The function recursively checks the point against the nearest crosses of each size to the point, and returns the appropriate character depending on whether the point is discovered to lie on the centre or axis of a cross.

Röda, 284 280 238 234 bytes
{a=[1,-1]t=[]seq 1,95|t+=[" "]*95,_
f={|x,y,i,d|{s=[27,12,5,2,1][i]i++
a|{|j|{seq y,y+s*j|t[_][x]="|"f x,y+s*j,i,2-j}if[d!=2+j]}_
a|{|j|{seq x,x+s*j|t[y][_]="-"f x+s*j,y,i,3-j}if[d!=3+j]}_}if[i<5]
t[y][x]="+"}f 47,47,0,0
t|print _&""}

Try it online!
This is an anonymous function. I used newlines instead of semicolons so it is very nicely formatted!
The recursive function f creates the graph in a two-dimensional array t, which is then printed at the last line.
I didn't find a way to calculate 27,12,5,2,1 in few bytes, so they are hard-coded.

Is there no way to calculate powers of 2?

@Neil A b_shiftl operator exists, but it's too long to be used in this program, I think.

Only thing I can think of is maybe base-3? Dunno how good Roda is at base conversion though... 10000110001200020001 -> 1168671727 doubt you can convert and split with less than 2 bytes though heh...

Charcoal, 50 43 bytes
Ｆ³²⁴«Ｐ++↷ＡＥ…¹¦⁵∧¬﹪ιＸ³κ⁻Ｘ²⁺κ¹⁺κ²εＦ⁺ε⮌ε¿κ«+κ↶

Try it online! Link is to verbose version of code. I originally tried various reflections and rotations but they either didn't do what I want or in some cases were buggy. I then tried a nested loop approach but I've now switched to this iterative method which works by drawing a number of lines between each inner cross depending on how many powers of 3 the step number is divisible by. It can even be readily modified to accept a size parameter at a cost of only 4 bytes:
ＮβＦ×⁴Ｘ³β«Ｐ++↷ＡＥ…·¹β∧¬﹪ιＸ³κ⁻Ｘ²⁺κ¹⁺κ²εＦ⁺ε⮌ε¿κ«+κ↶

Edit: I've since worked out how to use RotateShutterOverlap to achieve this task, but annoyingly it takes me 44 bytes:
Ａ⁰ηＦ⁶«ＡηγＡ⁻⁺Ｘ²ιηιηＪη⁰Ｐ-γ+¿γ⟲ＳＯ²⁶⁻×²γ¹»‖⟲ＳＯ⁹⁵

If RotateShutterOverlap accepted a variable rotations integer, that would reduce it to 40 bytes:
Ａ⁰ηＦ⁶«Ａ∨η¹γＡ⁻⁺Ｘ²ιηιηＪη⁰Ｐ+γ+⟲ＳＯ⎇‹ι⁵Ｌβ²⁴⁶γ

As it is, using a rotations list parameter takes 45 bytes:
Ａ⁰ηＦ⁶«Ａ∨η¹γＡ⁻⁺Ｘ²ιηιηＪη⁰Ｐ+γ+⟲ＳＯ⟦⁶×²⁺¹⁼⁵ι⟧⁻×²γ¹

This feels like cheating to me. :P

@HyperNeutrino Slightly less hardcoded version: Try it online! Or is that not what you meant?

:P I meant this is way too short and way too easy for Charcoal :P

@Neil :O This is amazing! I'm wondering if you could give an example of a buggy reflection/rotation so I can fix it

@ASCII-only In the case of a buggy reflection, I think only one of the diagonal reflections was working, but I can't remember which. I think the error was an undefined variable (probably too much copypasta).

@Neil Would you mind trying to reproduce the bug? I have testcases for reflection but it appears that I don't have enough

@ASCII-only It was ReflectMirror. I don't know about Reflect...Overlap, I can't work out how to get them to parse.

@Neil For the ...Overlap commands you need to specify the amount of overlap after the rest of the arguments

@ASCII-only I was trying ReflectOverlapOverlap([:UpLeft, :UpRight, :DownLeft, :DownRight], 0); but I don't even get a parse error, although I do for for (InputString()) Cast(Equals(i, "0")); for some reason...

Let us continue this discussion in chat.

05AB1E, 620 bytes
•1dOœ˜‘Av–Qs†ƒFã&äuÌÊ¹Ý2býádÙI’´Ëœ¼)Y»+™ß›[Vg“Ò¢Jù1no<V<*Ét*-¢&â-ßBÆ×090`11-øsµ–¶1VÛ==ü:¼÷ØûÍZ„æ¹=#ùÞV«¡fä&Îˆ'ëˆÝ=ä^‰¤?Êçù!ØèØr-3îÛ+êò‚û¢½°BéG¦U”Ü1žˆr6S‹“ŽKRK°A¹ª¿â9]}×u¬]ž„Îï›V¦Â¶4Ãï¢v£×é´Ü2Äžiqô>§17F*ÎañníÆ4]s8mÏ›HSÏ771í´‰d3´Þ|À]Uà{þñýqø’e„XÿF4–:Yl&uqžÍÒÿ¾u9¤jóHP‰çêoÒNŠX-°xpÒÿ*ejÏD0Ë+GnÊ-/§3ÜJÙˆƒÌ=ŒÒOX‰|O%wæ[n‹ã4)ôF+~´Ö{aÄ$(Þí¼”÷u–qÿBòfÂíÜìTó–xÝwû¾])<§O«\‚e°‡¾‹K…ZDPô;µ!ÃÂ²&Ô¼¨1gŠ—Ÿ¦©zW¢¾×4K±ÔÄ_ìûÄ‚3¶Ñ>‚bùn±œ×)ÙCâRöè£¶”ˆ1ßÑÍ®Ö±[ZéRïyÓxÓE¨cW˜{Ã’ùoE›¥ÚvA¨‹êÆýÑY½RÎ5´‘Ê™uåÄr"ãYð÷I!0¤)å‡ëž”>úèWò}é€@.ØñÈQ€ñ{Á„‘Ü’‰~Çñ=…|“ÚƒÄ¬cóÇkþÛÇ–š;{¡¦½ÕrÎé–àTz€Kì2à^|¢èˆÎxž“å$œ2ô»EidœþFrSS¥ÝÜ—X¡á~îþQ˜NÜGñ¥Q)aè•4B"1230"" +-|"‡48ôû€û»

Try it online!
All I did was cut the pattern into fourths, converted the symbols to base-4, compressed 1/4 of the pattern into base-214 and then flipped it over the lines of symmetry. I'm working on something smarter using the actual algorithm, but until I finish that this is what'll be here for me.

That's by far the largest 05AB1E answer I have seen. xD Usually it's close to 6.20 instead of 620 with answers in this language. ;)

@KevinCruijssen if it was asking for iteration 4 it would've been much-much smaller haha. Still working on the actual algorithm in 05AB1E... Bit harder than I thought.

Python 3, 264 bytes
def F(g,p,d,k):
 for c in'-|'[d.real!=0]*(2**k-k-1):g[p]=c;p+=d
 P(g,p,k-1)
def P(g,p,k):
 if'+'==g.setdefault(p,'+')and k:
  for d in[1,1j,-1,-1j]:F(g,p+d,d,k)
g={}
P(g,0j,5)
print('\n'.join(''.join(g.get(r+c*1j,' ')for c in range(-47,48))for r in range(-47,48)))

Uses a pair of mutually recursive functions. F draws the lines and P inserts the '+'s.  Can be golfed more, but out of time for now.

C, 236 bytes
char t[95][95],i=95;f(x,y,s,n,m){if(t[y][x]<33){m=~s+(1<<s);for(n=~m;n++<m;)t[y][x+n]='-',t[y+n][x]=n==0?'+':'|';if(s--)f(x+n,y,s),f(x-n,y,s),f(x,y+n,s),f(x,y-n,s);}}main(){memset(t,32,9025);f(47,47,5);while(i--)printf("%.95s\n",t[i]);}

Just building the character table recursively before displaying it.
Try it online!
Thanks @Neil for making me realize that the length of the branches follow an actual rule.

227 bytes

Deadfish~, 11547 bytes
{iii}ii{cccc}ccccccc{i}ic{d}d{cccc}ccccccc{dd}ddc{ii}ii{cccc}cccccc{i}iccc{d}d{cccc}cccccc{dd}ddc{ii}ii{cccc}ccccc{i}ic{d}dc{{i}d}iic{{d}i}ddc{i}ic{d}d{cccc}ccccc{dd}ddc{ii}ii{cccc}cccc{i}icciicddciicddcc{d}d{cccc}cccc{dd}ddc{ii}ii{cccc}ccccc{i}ic{d}dc{{i}d}iic{{d}i}ddc{i}ic{d}d{cccc}ccccc{dd}ddc{ii}ii{cccc}cc{i}ic{d}dcccc{{i}d}iic{{d}i}ddcccc{i}ic{d}d{cccc}cc{dd}ddc{ii}ii{cccc}c{i}iccc{d}dccc{{i}d}iic{{d}i}ddccc{i}iccc{d}d{cccc}c{dd}ddc{ii}ii{cccc}{i}ic{d}dc{{i}d}iic{{d}i}ddcccc{{i}d}iic{{d}i}ddcccc{{i}d}iic{{d}i}ddc{i}ic{d}d{cccc}{dd}ddc{ii}ii{ccc}ccccccccc{i}icciicddciiccccddciiccccddciicddcc{d}d{ccc}ccccccccc{dd}ddc{ii}ii{cccc}{i}ic{d}dc{{i}d}iic{{d}i}ddcccc{{i}d}iic{{d}i}ddcccc{{i}d}iic{{d}i}ddc{i}ic{d}d{cccc}{dd}ddc{ii}ii{cccc}c{i}iccc{d}dccc{{i}d}iic{{d}i}ddccc{i}iccc{d}d{cccc}c{dd}ddc{ii}ii{cccc}cc{i}ic{d}dcccc{{i}d}iic{{d}i}ddcccc{i}ic{d}d{cccc}cc{dd}ddc{ii}ii{ccc}ccccc{i}ic{d}d{c}c{{i}d}iic{{d}i}dd{c}c{i}ic{d}d{ccc}ccccc{dd}ddc{ii}ii{ccc}cccc{i}iccc{d}d{c}{{i}d}iic{{d}i}dd{c}{i}iccc{d}d{ccc}cccc{dd}ddc{ii}ii{ccc}ccc{i}ic{d}dc{{i}d}iic{{d}i}ddc{i}ic{d}dccccccccc{{i}d}iic{{d}i}ddccccccccc{i}ic{d}dc{{i}d}iic{{d}i}ddc{i}ic{d}d{ccc}ccc{dd}ddc{ii}ii{ccc}cc{i}icciicddciicddcc{d}dcccccccc{{i}d}iic{{d}i}ddcccccccc{i}icciicddciicddcc{d}d{ccc}cc{dd}ddc{ii}ii{ccc}ccc{i}ic{d}dc{{i}d}iic{{d}i}ddc{i}ic{d}dccccccccc{{i}d}iic{{d}i}ddccccccccc{i}ic{d}dc{{i}d}iic{{d}i}ddc{i}ic{d}d{ccc}ccc{dd}ddc{ii}ii{ccc}{i}ic{d}dcccc{{i}d}iic{{d}i}dd{c}c{{i}d}iic{{d}i}dd{c}c{{i}d}iic{{d}i}ddcccc{i}ic{d}d{ccc}{dd}ddc{ii}ii{cc}ccccccccc{i}iccc{d}dccc{{i}d}iic{{d}i}dd{c}c{{i}d}iic{{d}i}dd{c}c{{i}d}iic{{d}i}ddccc{i}iccc{d}d{cc}ccccccccc{dd}ddc{ii}ii{cc}cccccccc{i}ic{d}dc{{i}d}iic{{d}i}ddcccc{{i}d}iic{{d}i}dd{c}c{{i}d}iic{{d}i}dd{c}c{{i}d}iic{{d}i}ddcccc{{i}d}iic{{d}i}ddc{i}ic{d}d{cc}cccccccc{dd}ddc{ii}ii{cc}ccccccc{i}icciicddciiccccddcii{c}cddcii{c}cddciiccccddciicddcc{d}d{cc}ccccccc{dd}ddc{ii}ii{cc}cccccccc{i}ic{d}dc{{i}d}iic{{d}i}ddcccc{{i}d}iic{{d}i}dd{c}c{{i}d}iic{{d}i}dd{c}c{{i}d}iic{{d}i}ddcccc{{i}d}iic{{d}i}ddc{i}ic{d}d{cc}cccccccc{dd}ddc{ii}ii{cc}ccccccccc{i}iccc{d}dccc{{i}d}iic{{d}i}dd{c}c{{i}d}iic{{d}i}dd{c}c{{i}d}iic{{d}i}ddccc{i}iccc{d}d{cc}ccccccccc{dd}ddc{ii}ii{ccc}{i}ic{d}dcccc{{i}d}iic{{d}i}dd{c}c{{i}d}iic{{d}i}dd{c}c{{i}d}iic{{d}i}ddcccc{i}ic{d}d{ccc}{dd}ddc{ii}ii{ccc}ccc{i}ic{d}dc{{i}d}iic{{d}i}ddc{i}ic{d}dccccccccc{{i}d}iic{{d}i}ddccccccccc{i}ic{d}dc{{i}d}iic{{d}i}ddc{i}ic{d}d{ccc}ccc{dd}ddc{ii}ii{ccc}cc{i}icciicddciicddcc{d}dcccccccc{{i}d}iic{{d}i}ddcccccccc{i}icciicddciicddcc{d}d{ccc}cc{dd}ddc{ii}ii{ccc}ccc{i}ic{d}dc{{i}d}iic{{d}i}ddc{i}ic{d}dccccccccc{{i}d}iic{{d}i}ddccccccccc{i}ic{d}dc{{i}d}iic{{d}i}ddc{i}ic{d}d{ccc}ccc{dd}ddc{ii}ii{cc}{i}ic{d}d{c}ccc{i}iccc{d}d{c}{{i}d}iic{{d}i}dd{c}{i}iccc{d}d{c}ccc{i}ic{d}d{cc}{dd}ddc{ii}ii{c}ccccccccc{i}iccc{d}d{c}ccc{i}ic{d}d{c}c{{i}d}iic{{d}i}dd{c}c{i}ic{d}d{c}ccc{i}iccc{d}d{c}ccccccccc{dd}ddc{ii}ii{c}cccccccc{i}ic{d}dc{{i}d}iic{{d}i}ddc{i}ic{d}d{cc}cccc{{i}d}iic{{d}i}dd{cc}cccc{i}ic{d}dc{{i}d}iic{{d}i}ddc{i}ic{d}d{c}cccccccc{dd}ddc{ii}ii{c}ccccccc{i}icciicddciicddcc{d}d{cc}ccc{{i}d}iic{{d}i}dd{cc}ccc{i}icciicddciicddcc{d}d{c}ccccccc{dd}ddc{ii}ii{c}cccccccc{i}ic{d}dc{{i}d}iic{{d}i}ddc{i}ic{d}d{cc}cccc{{i}d}iic{{d}i}dd{cc}cccc{i}ic{d}dc{{i}d}iic{{d}i}ddc{i}ic{d}d{c}cccccccc{dd}ddc{ii}ii{c}ccccc{i}ic{d}dcccc{{i}d}iic{{d}i}ddcccc{i}ic{d}d{cc}c{{i}d}iic{{d}i}dd{cc}c{i}ic{d}dcccc{{i}d}iic{{d}i}ddcccc{i}ic{d}d{c}ccccc{dd}ddc{ii}ii{c}cccc{i}iccc{d}dccc{{i}d}iic{{d}i}ddccc{i}iccc{d}d{cc}{{i}d}iic{{d}i}dd{cc}{i}iccc{d}dccc{{i}d}iic{{d}i}ddccc{i}iccc{d}d{c}cccc{dd}ddc{ii}ii{c}ccc{i}ic{d}dc{{i}d}iic{{d}i}ddcccc{{i}d}iic{{d}i}ddcccc{{i}d}iic{{d}i}ddc{i}ic{d}d{c}ccccccccc{{i}d}iic{{d}i}dd{c}ccccccccc{i}ic{d}dc{{i}d}iic{{d}i}ddcccc{{i}d}iic{{d}i}ddcccc{{i}d}iic{{d}i}ddc{i}ic{d}d{c}ccc{dd}ddc{ii}ii{c}cc{i}icciicddciiccccddciiccccddciicddcc{d}d{c}cccccccc{{i}d}iic{{d}i}dd{c}cccccccc{i}icciicddciiccccddciiccccddciicddcc{d}d{c}cc{dd}ddc{ii}ii{c}ccc{i}ic{d}dc{{i}d}iic{{d}i}ddcccc{{i}d}iic{{d}i}ddcccc{{i}d}iic{{d}i}ddc{i}ic{d}d{c}ccccccccc{{i}d}iic{{d}i}dd{c}ccccccccc{i}ic{d}dc{{i}d}iic{{d}i}ddcccc{{i}d}iic{{d}i}ddcccc{{i}d}iic{{d}i}ddc{i}ic{d}d{c}ccc{dd}ddc{ii}ii{c}cccc{i}iccc{d}dccc{{i}d}iic{{d}i}ddccc{i}iccc{d}d{cc}{{i}d}iic{{d}i}dd{cc}{i}iccc{d}dccc{{i}d}iic{{d}i}ddccc{i}iccc{d}d{c}cccc{dd}ddc{ii}ii{c}ccccc{i}ic{d}dcccc{{i}d}iic{{d}i}ddcccc{i}ic{d}d{cc}c{{i}d}iic{{d}i}dd{cc}c{i}ic{d}dcccc{{i}d}iic{{d}i}ddcccc{i}ic{d}d{c}ccccc{dd}ddc{ii}iicccccccc{i}ic{d}d{c}c{{i}d}iic{{d}i}dd{cc}cccccc{{i}d}iic{{d}i}dd{cc}cccccc{{i}d}iic{{d}i}dd{c}c{i}ic{d}dcccccccc{dd}ddc{ii}iiccccccc{i}iccc{d}d{c}{{i}d}iic{{d}i}dd{cc}cccccc{{i}d}iic{{d}i}dd{cc}cccccc{{i}d}iic{{d}i}dd{c}{i}iccc{d}dccccccc{dd}ddc{ii}iicccccc{i}ic{d}dc{{i}d}iic{{d}i}ddc{i}ic{d}dccccccccc{{i}d}iic{{d}i}dd{cc}cccccc{{i}d}iic{{d}i}dd{cc}cccccc{{i}d}iic{{d}i}ddccccccccc{i}ic{d}dc{{i}d}iic{{d}i}ddc{i}ic{d}dcccccc{dd}ddc{ii}iiccccc{i}icciicddciicddcc{d}dcccccccc{{i}d}iic{{d}i}dd{cc}cccccc{{i}d}iic{{d}i}dd{cc}cccccc{{i}d}iic{{d}i}ddcccccccc{i}icciicddciicddcc{d}dccccc{dd}ddc{ii}iicccccc{i}ic{d}dc{{i}d}iic{{d}i}ddc{i}ic{d}dccccccccc{{i}d}iic{{d}i}dd{cc}cccccc{{i}d}iic{{d}i}dd{cc}cccccc{{i}d}iic{{d}i}ddccccccccc{i}ic{d}dc{{i}d}iic{{d}i}ddc{i}ic{d}dcccccc{dd}ddc{ii}iiccc{i}ic{d}dcccc{{i}d}iic{{d}i}dd{c}c{{i}d}iic{{d}i}dd{cc}cccccc{{i}d}iic{{d}i}dd{cc}cccccc{{i}d}iic{{d}i}dd{c}c{{i}d}iic{{d}i}ddcccc{i}ic{d}dccc{dd}ddc{ii}iicc{i}iccc{d}dccc{{i}d}iic{{d}i}dd{c}c{{i}d}iic{{d}i}dd{cc}cccccc{{i}d}iic{{d}i}dd{cc}cccccc{{i}d}iic{{d}i}dd{c}c{{i}d}iic{{d}i}ddccc{i}iccc{d}dcc{dd}ddc{ii}iic{i}ic{d}dc{{i}d}iic{{d}i}ddcccc{{i}d}iic{{d}i}dd{c}c{{i}d}iic{{d}i}dd{cc}cccccc{{i}d}iic{{d}i}dd{cc}cccccc{{i}d}iic{{d}i}dd{c}c{{i}d}iic{{d}i}ddcccc{{i}d}iic{{d}i}ddc{i}ic{d}dc{dd}ddc{iii}iiicciicddciiccccddcii{c}cddcii{cc}ccccccddcii{cc}ccccccddcii{c}cddciiccccddciicddcc{ddd}dddc{ii}iic{i}ic{d}dc{{i}d}iic{{d}i}ddcccc{{i}d}iic{{d}i}dd{c}c{{i}d}iic{{d}i}dd{cc}cccccc{{i}d}iic{{d}i}dd{cc}cccccc{{i}d}iic{{d}i}dd{c}c{{i}d}iic{{d}i}ddcccc{{i}d}iic{{d}i}ddc{i}ic{d}dc{dd}ddc{ii}iicc{i}iccc{d}dccc{{i}d}iic{{d}i}dd{c}c{{i}d}iic{{d}i}dd{cc}cccccc{{i}d}iic{{d}i}dd{cc}cccccc{{i}d}iic{{d}i}dd{c}c{{i}d}iic{{d}i}ddccc{i}iccc{d}dcc{dd}ddc{ii}iiccc{i}ic{d}dcccc{{i}d}iic{{d}i}dd{c}c{{i}d}iic{{d}i}dd{cc}cccccc{{i}d}iic{{d}i}dd{cc}cccccc{{i}d}iic{{d}i}dd{c}c{{i}d}iic{{d}i}ddcccc{i}ic{d}dccc{dd}ddc{ii}iicccccc{i}ic{d}dc{{i}d}iic{{d}i}ddc{i}ic{d}dccccccccc{{i}d}iic{{d}i}dd{cc}cccccc{{i}d}iic{{d}i}dd{cc}cccccc{{i}d}iic{{d}i}ddccccccccc{i}ic{d}dc{{i}d}iic{{d}i}ddc{i}ic{d}dcccccc{dd}ddc{ii}iiccccc{i}icciicddciicddcc{d}dcccccccc{{i}d}iic{{d}i}dd{cc}cccccc{{i}d}iic{{d}i}dd{cc}cccccc{{i}d}iic{{d}i}ddcccccccc{i}icciicddciicddcc{d}dccccc{dd}ddc{ii}iicccccc{i}ic{d}dc{{i}d}iic{{d}i}ddc{i}ic{d}dccccccccc{{i}d}iic{{d}i}dd{cc}cccccc{{i}d}iic{{d}i}dd{cc}cccccc{{i}d}iic{{d}i}ddccccccccc{i}ic{d}dc{{i}d}iic{{d}i}ddc{i}ic{d}dcccccc{dd}ddc{ii}iiccccccc{i}iccc{d}d{c}{{i}d}iic{{d}i}dd{cc}cccccc{{i}d}iic{{d}i}dd{cc}cccccc{{i}d}iic{{d}i}dd{c}{i}iccc{d}dccccccc{dd}ddc{ii}iicccccccc{i}ic{d}d{c}c{{i}d}iic{{d}i}dd{cc}cccccc{{i}d}iic{{d}i}dd{cc}cccccc{{i}d}iic{{d}i}dd{c}c{i}ic{d}dcccccccc{dd}ddc{ii}ii{c}ccccc{i}ic{d}dcccc{{i}d}iic{{d}i}ddcccc{i}ic{d}d{cc}c{{i}d}iic{{d}i}dd{cc}c{i}ic{d}dcccc{{i}d}iic{{d}i}ddcccc{i}ic{d}d{c}ccccc{dd}ddc{ii}ii{c}cccc{i}iccc{d}dccc{{i}d}iic{{d}i}ddccc{i}iccc{d}d{cc}{{i}d}iic{{d}i}dd{cc}{i}iccc{d}dccc{{i}d}iic{{d}i}ddccc{i}iccc{d}d{c}cccc{dd}ddc{ii}ii{c}ccc{i}ic{d}dc{{i}d}iic{{d}i}ddcccc{{i}d}iic{{d}i}ddcccc{{i}d}iic{{d}i}ddc{i}ic{d}d{c}ccccccccc{{i}d}iic{{d}i}dd{c}ccccccccc{i}ic{d}dc{{i}d}iic{{d}i}ddcccc{{i}d}iic{{d}i}ddcccc{{i}d}iic{{d}i}ddc{i}ic{d}d{c}ccc{dd}ddc{ii}ii{c}cc{i}icciicddciiccccddciiccccddciicddcc{d}d{c}cccccccc{{i}d}iic{{d}i}dd{c}cccccccc{i}icciicddciiccccddciiccccddciicddcc{d}d{c}cc{dd}ddc{ii}ii{c}ccc{i}ic{d}dc{{i}d}iic{{d}i}ddcccc{{i}d}iic{{d}i}ddcccc{{i}d}iic{{d}i}ddc{i}ic{d}d{c}ccccccccc{{i}d}iic{{d}i}dd{c}ccccccccc{i}ic{d}dc{{i}d}iic{{d}i}ddcccc{{i}d}iic{{d}i}ddcccc{{i}d}iic{{d}i}ddc{i}ic{d}d{c}ccc{dd}ddc{ii}ii{c}cccc{i}iccc{d}dccc{{i}d}iic{{d}i}ddccc{i}iccc{d}d{cc}{{i}d}iic{{d}i}dd{cc}{i}iccc{d}dccc{{i}d}iic{{d}i}ddccc{i}iccc{d}d{c}cccc{dd}ddc{ii}ii{c}ccccc{i}ic{d}dcccc{{i}d}iic{{d}i}ddcccc{i}ic{d}d{cc}c{{i}d}iic{{d}i}dd{cc}c{i}ic{d}dcccc{{i}d}iic{{d}i}ddcccc{i}ic{d}d{c}ccccc{dd}ddc{ii}ii{c}cccccccc{i}ic{d}dc{{i}d}iic{{d}i}ddc{i}ic{d}d{cc}cccc{{i}d}iic{{d}i}dd{cc}cccc{i}ic{d}dc{{i}d}iic{{d}i}ddc{i}ic{d}d{c}cccccccc{dd}ddc{ii}ii{c}ccccccc{i}icciicddciicddcc{d}d{cc}ccc{{i}d}iic{{d}i}dd{cc}ccc{i}icciicddciicddcc{d}d{c}ccccccc{dd}ddc{ii}ii{c}cccccccc{i}ic{d}dc{{i}d}iic{{d}i}ddc{i}ic{d}d{cc}cccc{{i}d}iic{{d}i}dd{cc}cccc{i}ic{d}dc{{i}d}iic{{d}i}ddc{i}ic{d}d{c}cccccccc{dd}ddc{ii}ii{c}ccccccccc{i}iccc{d}d{c}ccc{i}ic{d}d{c}c{{i}d}iic{{d}i}dd{c}c{i}ic{d}d{c}ccc{i}iccc{d}d{c}ccccccccc{dd}ddc{ii}ii{cc}{i}ic{d}d{c}ccc{i}iccc{d}d{c}{{i}d}iic{{d}i}dd{c}{i}iccc{d}d{c}ccc{i}ic{d}d{cc}{dd}ddc{ii}ii{ccc}ccc{i}ic{d}dc{{i}d}iic{{d}i}ddc{i}ic{d}dccccccccc{{i}d}iic{{d}i}ddccccccccc{i}ic{d}dc{{i}d}iic{{d}i}ddc{i}ic{d}d{ccc}ccc{dd}ddc{ii}ii{ccc}cc{i}icciicddciicddcc{d}dcccccccc{{i}d}iic{{d}i}ddcccccccc{i}icciicddciicddcc{d}d{ccc}cc{dd}ddc{ii}ii{ccc}ccc{i}ic{d}dc{{i}d}iic{{d}i}ddc{i}ic{d}dccccccccc{{i}d}iic{{d}i}ddccccccccc{i}ic{d}dc{{i}d}iic{{d}i}ddc{i}ic{d}d{ccc}ccc{dd}ddc{ii}ii{ccc}{i}ic{d}dcccc{{i}d}iic{{d}i}dd{c}c{{i}d}iic{{d}i}dd{c}c{{i}d}iic{{d}i}ddcccc{i}ic{d}d{ccc}{dd}ddc{ii}ii{cc}ccccccccc{i}iccc{d}dccc{{i}d}iic{{d}i}dd{c}c{{i}d}iic{{d}i}dd{c}c{{i}d}iic{{d}i}ddccc{i}iccc{d}d{cc}ccccccccc{dd}ddc{ii}ii{cc}cccccccc{i}ic{d}dc{{i}d}iic{{d}i}ddcccc{{i}d}iic{{d}i}dd{c}c{{i}d}iic{{d}i}dd{c}c{{i}d}iic{{d}i}ddcccc{{i}d}iic{{d}i}ddc{i}ic{d}d{cc}cccccccc{dd}ddc{ii}ii{cc}ccccccc{i}icciicddciiccccddcii{c}cddcii{c}cddciiccccddciicddcc{d}d{cc}ccccccc{dd}ddc{ii}ii{cc}cccccccc{i}ic{d}dc{{i}d}iic{{d}i}ddcccc{{i}d}iic{{d}i}dd{c}c{{i}d}iic{{d}i}dd{c}c{{i}d}iic{{d}i}ddcccc{{i}d}iic{{d}i}ddc{i}ic{d}d{cc}cccccccc{dd}ddc{ii}ii{cc}ccccccccc{i}iccc{d}dccc{{i}d}iic{{d}i}dd{c}c{{i}d}iic{{d}i}dd{c}c{{i}d}iic{{d}i}ddccc{i}iccc{d}d{cc}ccccccccc{dd}ddc{ii}ii{ccc}{i}ic{d}dcccc{{i}d}iic{{d}i}dd{c}c{{i}d}iic{{d}i}dd{c}c{{i}d}iic{{d}i}ddcccc{i}ic{d}d{ccc}{dd}ddc{ii}ii{ccc}ccc{i}ic{d}dc{{i}d}iic{{d}i}ddc{i}ic{d}dccccccccc{{i}d}iic{{d}i}ddccccccccc{i}ic{d}dc{{i}d}iic{{d}i}ddc{i}ic{d}d{ccc}ccc{dd}ddc{ii}ii{ccc}cc{i}icciicddciicddcc{d}dcccccccc{{i}d}iic{{d}i}ddcccccccc{i}icciicddciicddcc{d}d{ccc}cc{dd}ddc{ii}ii{ccc}ccc{i}ic{d}dc{{i}d}iic{{d}i}ddc{i}ic{d}dccccccccc{{i}d}iic{{d}i}ddccccccccc{i}ic{d}dc{{i}d}iic{{d}i}ddc{i}ic{d}d{ccc}ccc{dd}ddc{ii}ii{ccc}cccc{i}iccc{d}d{c}{{i}d}iic{{d}i}dd{c}{i}iccc{d}d{ccc}cccc{dd}ddc{ii}ii{ccc}ccccc{i}ic{d}d{c}c{{i}d}iic{{d}i}dd{c}c{i}ic{d}d{ccc}ccccc{dd}ddc{ii}ii{cccc}cc{i}ic{d}dcccc{{i}d}iic{{d}i}ddcccc{i}ic{d}d{cccc}cc{dd}ddc{ii}ii{cccc}c{i}iccc{d}dccc{{i}d}iic{{d}i}ddccc{i}iccc{d}d{cccc}c{dd}ddc{ii}ii{cccc}{i}ic{d}dc{{i}d}iic{{d}i}ddcccc{{i}d}iic{{d}i}ddcccc{{i}d}iic{{d}i}ddc{i}ic{d}d{cccc}{dd}ddc{ii}ii{ccc}ccccccccc{i}icciicddciiccccddciiccccddciicddcc{d}d{ccc}ccccccccc{dd}ddc{ii}ii{cccc}{i}ic{d}dc{{i}d}iic{{d}i}ddcccc{{i}d}iic{{d}i}ddcccc{{i}d}iic{{d}i}ddc{i}ic{d}d{cccc}{dd}ddc{ii}ii{cccc}c{i}iccc{d}dccc{{i}d}iic{{d}i}ddccc{i}iccc{d}d{cccc}c{dd}ddc{ii}ii{cccc}cc{i}ic{d}dcccc{{i}d}iic{{d}i}ddcccc{i}ic{d}d{cccc}cc{dd}ddc{ii}ii{cccc}ccccc{i}ic{d}dc{{i}d}iic{{d}i}ddc{i}ic{d}d{cccc}ccccc{dd}ddc{ii}ii{cccc}cccc{i}icciicddciicddcc{d}d{cccc}cccc{dd}ddc{ii}ii{cccc}ccccc{i}ic{d}dc{{i}d}iic{{d}i}ddc{i}ic{d}d{cccc}ccccc{dd}ddc{ii}ii{cccc}cccccc{i}iccc{d}d{cccc}cccccc{dd}ddc{ii}ii{cccc}ccccccc{i}ic{d}d{cccc}ccccccc

Try it online!
Because why not?

all_licenses: 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/


text:
This is the sort of challenge that bytes
I need to stop thinking of punny names
Your task is to create as many snippets (programs that have input and output built-in), functions or full programs as possible that sorts whatever your language's version of integer arrays is in ascending order, but for each program, you're only allowed to use the characters in ASCII (or your language's code page, if it's directly specified as not ASCII) which haven't been used in the previous programs.
This is an example answer (separate programs separated by newlines):
Derp
ASdFGHJKLAAA
qwEEERtyRty

In this (fictional language), my first answer is Derp, which used up D, e, r and p. In the second program, I'm not allowed to use those character again, but I can reuse as many characters I want. Same with the third program, and so on.
Each program must take an array of integers, so something like this (see input/output examples for valid input/output styles):
[3 4 -2 5 7 196 -44 -2]

And it must output the items in the array as an array, in ascending order:
[-44 -2 -2 3 4 5 7 196]

Your score will be the total amount of submissions. If there is a tie, the lowest bytecount (least amount of bytes in your code) wins!
Rules for programs:

All submissions must run correctly in one language version (so Python 2 != Python 3).
Your submissions can be snippets, functions, or full programs. You're even allowed to mix and match them - however, you must say which is which, and provide links to working submissions.
Please provide online links to all solutions, if possible.
All submissions must take an array (or a string delimited with any character) as input, and output the array sorted (in your language's array form or as a {any character}-delimited string.
You are not allowed to use any characters outside of ASCII (or your language's code page).

For example, these are valid inputs/outputs:
[1 2 3 4]    (Clojure style arrays)
[1, 2, 3, 4] (Python style arrays)
1 2 3 4 5    (Space-delimited - separated by spaces)
1#2#3#4#5    ("#"-delimited - separated by "#" characters)
1\n2\n3\n4\n (newline-delimited)

Specs for input:

You are guaranteed that the array contains only integers. However, there may be negative numbers, and numbers may repeat indefinitely.

The more puns the better!

You realise that anyone who can be bothered to solve this in Brainfuck gets a Lenguage solution with score 128? Alternatively, a single Glypho solution could score 42.

Related - Sort an integer-list

@Qwerp-Derp Maybe a bit tedious, but certainly doable. In fact, I expect I/O to be the most annoying part (if you don't allow reading input as a list of character codes).

Require that all programs run on a reasonable PC in under 5 minutes or something. This makes Language impractical.

@MartinEnder Fixed that issue.

@WheatWizard I was counting only 128 available characters since the challenge specifies ASCII.

I have 3 problems with the language restriction. (1) Restricting arbitrary classes of languages because they would be good at a challange is not fun.(2) most "Normal" programming languages like JavaScript (which already has an answer) do not meet the requirements, which is, certainly not the intent of the restriction, and once again, not fun. (3) I don't think it is really an observable requirement.  "Specific function" is not very observable, I could argue through several layers of abstraction that Glypho characters do indeed have specific functions that operate on a set of hidden variables.

@WheatWizard A Lenguage/Glypho solution would lead to other trivial solutions, which would win without any extra effort. That kinda detracts from the point of this challenge, IMO.

But you are disallowing all sorts of other languages (including some that have already answered) with your current answer just so you can ban two specific languages.  IMO this is a sign of a poor challenge.

@WheatWizard Fixed it with a new rule. Just not sure if it works, though.

@StewieGriffin What I mean by "covered by loopholes" is that illegal answers will get covered by loopholes, not Mathematica/Matlab answers. Sorry for the confusion.

Jelly, 10 programs, 65 bytes
Ṣ
¹Þ
Ụị
Œ!Ṃ
7778Ọv
Ẋ>2\S$¿
ĠFḣṪ¥@€
~Ṁ~rṀxLœ&
C»/ð+ÆNPÆfÆC_ḷ
<þḅ1‘WiþJḄ³ṫZḢ

There's some inevitable overlap with @Lynn's Jelly answer. Credits for the bogosort idea go to her.
Try it online! or verify uniqueness.
How they work
Ṣ               Main link. Argument: A (array)

Ṣ               Sort A.

¹Þ              Main link. Argument: A (array)

¹Þ              Sort A, using the identity function as the key.

Ụị              Main link. Argument: A (array)

Ụ               Grade up; yield all indices of A, sorted by their corr. values.
 ị              Index into A.

Œ!Ṃ             Main link. Argument: A (array)

Œ!              Yield all permutations of A.
  Ṃ             Minimum; yield the lexicographically smallest permutation.

7778Ọv          Main link. Argument: A (array)

7778Ọ           Unordinal; yield chr(7778) = 'Ṣ'.
     v          Evaluate with argument A.

Ẋ>2\S$¿         Main link. Argument: A (array)

      ¿         While the condition it truthy, execute the body.
 >2\S$            Condition:
     $              Combine the two links to the left into a monadic chain.
 >2\                  Perform pairwise greater-than comparison.
    S                 Sum; add the results.
                    This returns 0 iff A contains an unsorted pair of integers.
Ẋ                 Body: Shuffle A.

ĠFḣṪ¥@€         Main link. Argument: A (array)

Ġ               Group the indices of A by their sorted values.
 F              Flatten the result.
      €         Apply the link to the left to each index in the previous result,
                calling it with the index as left argument and A as the right one.
    ¥@            Combine the two links to the left into a dyadic chain and swap
                  its arguments, so A is left one and the index i is the right one.
  ḣ               Head; take the first i elements of A.
   Ṫ              Tail; yield the last of the first i, i.e., the i-th element of A.

~Ṁ~rṀxLœ&       Main link. Argument: A (array)

~               Take the bitwise NOT of all integers in A.
 Ṁ              Take the maximum.
  ~             Take the bitwise NOT of the maximum, yielding the minimum of A.
    Ṁ           Yield the maximum of A.
   r            Range; yield [min(A), ... max(A)].
      L         Yield the length of A.
     x          Repeat each integer in the range len(A) times.
       œ&       Take the multiset-intersection of the result and A.

C»/ð+ÆNPÆfÆC_ḷ  Main link. Argument: A (array)

C               Complement; map (x -> 1-x) over A.
 »/             Reduce by dyadic maximum, yielding 1-min(A).
   ð            Begin a new, dyadic chain. Arguments: 1-min(A), A
    +           Add 1-min(A) to all elements of A, making them strictly positive.
     ÆN         For each element n of the result, yield the n-th prime number.
       P        Take the product.
        Æf      Factorize the product into prime numbers, with repetition.
          ÆC    Prime count; count the number of primes less than or equal to p,
                for each prime p in the resulting factorization.
             ḷ  Yield the left argument, 1-min(A).
            _   Subtract 1-min(A) from each prime count in the result to the left.

<þḅ1‘WiþJḄ³ṫZḢ  Main link. Argument: A (array)

<þ              Construct the less-than matrix of all pairs of elements in A.
  ḅ1            Convert each row from base 1 to integer (sum each).
    ‘           Increment. The integer at index i now counts how many elements
                of A are less than or equal to the i-th.
     W          Wrap the resulting 1D array into an array.
        J       Yield the indices of A, i.e., [1, ..., len(A)].
      iþ        Construct the index table; for each array T in the singleton array
                to the left and index j to the right, find the index of j in T.
                This yields an array of singleton arrays.
         Ḅ      Unbinary; convert each singleton from base 2 to integer, mapping
                ([x]-> x) over the array.
          ³     Yield A.
           ṫ    Tail; for each integer i in the result of `Ḅ`, create a copy of A
                without its first i-1 elements.
            Z   Zip/transpose. The first column becomes the first row.
             Ḣ  Head; yield the first row.

Jelly, 8 programs
Ṣ                   Built-in sort.
¹Þ                  Sort-by the identity function.
Ụị                  Sort indices by values, then index into list.
Œ!Ṃ                 Smallest permutation.
7778Ọv              Eval Unicode 7778 (Ṣ).
ẊI>@-.S$$¿          Bogosort.
<;0œṡ0⁸ṁjµ/         Insertion sort.
AṀ‘¶+Ç©ṬT_©®³ċÐ€®x' A terrifying hack.

The last program is really annoying…
AṀ‘¶+Ç©               Add ® = abs(max(L)) + 1 to the entire list.
                      Now it’s offset to be entirely positive.
       Ṭ              Create a binary array with 1s at these indices.
        T             Find the indices of 1s in this array.
                      The result is sorted, but offset wrong, and lacks duplicates.
         _©®          Subtract the offset, saving this list to ®.
                      Now restore the duplicates:
            ³ċÐ€      Count occurences in the original list.
                ®x'   Repeat the elements of ® that many times.

If I can remove the œṡ from <;0œṡ0⁸ṁjµ/, there’s also this weird one: ²SNr²ZFœ&. Help is appreciated.

Roots → polynomial, polynomial → roots is genius!

It appears the output order is reversed. Luckily U is free

Ugh, negative integers… I’ll see what I can do about those

I think we need a bit more, but I don't know how we could improve it.

@ETHproductions Fixed, now.

You're missing ¹Þ.

Wow, bravo on that fix...

05AB1E, score = 6
05AB1E uses CP-1252 encoding.
Thanks to Kevin Cruijssen for program 4.
Thanks to Riley for inspiration to program 6.
Program 1
{               # sort

Try it online!
Program 2
`[Ž.^]¯

`               # flatten input list to stack
 [Ž  ]          # loop until stack is empty
   .^           # add top of stack to global list in sorted order
      ¯         # push global list

Try it online!
Program 3
WrZŠŠŸvy†

Wr              # get minimum value in input list and reverse stack
  ZŠ            # get maximum value in input list and swap move it to bottom of stack
    Š           # move input down 2 levels of the stack
     Ÿ          # create a range from max to min
      v         # for each y in range
       y†       # move any occurrence of it in the input list to the front

Try it online!
Program 4
œß

œ               # get a list of all permutations of input
 ß              # pop the smallest

Try it online!
Program 5
êDgFDNè¹sUXQOFXs}}\)

ê                      # sort with duplicates removed
 Dg                    # duplicate and get length
   F                   # for N in [0 ... len-1] do
    DNè                # duplicate and get the Nth element in the unique list
       ¹s              # push input and move the Nth element to top of stack
         UX            # save it in X
           Q           # compare each element in the list against the Nth unique element
            O          # sum
             FXs}      # that many times, push X and swap it down 1 level on stack
                 }     # end outer loop
                  \    # remove the left over list of unique items
                   )   # wrap stack in a list

Try it online!
Program 6
©€Ýé€¤þ((®€Ýé€¤(þ(Rì

©                        # store a copy of input in register
 €Ý                      # map range[0 ... n] over list
   é                     # sort by length
    €¤                   # map get_last_element over list
      þ((                # keep only non-negative numbers
                         # now we have all positive numbers sorted
         ®€Ýé€¤(þ(       # do the same thing again on input
                         # except now we only keep negative numbers
                  R      # reverse sorting for negative numbers
                   ì     # prepend the sorted negative numbers to the positive ones

Try it online!

œß Can be used for an additional score. Try it here.

@KevinCruijssen: Thanks! I was just looking at a œ solution, but I didn't even know about ß :)

I will be completely honest, I got it from here. ;)

I think you can add €Ýé€g

@Riley g is used in Program 5

@Riley Unless I'm doing something wrong, it gives an incorrect output

@KevinCruijssen You're right. I forgot about negatives.

Is there a way to get the tail and pop? €Ýé€¤ would work if ¤ popped the value instead if just getting it.

@Riley: I'm afraid not. It is often missed imo :(

@Riley: That inspired me to fix the next program I was working on a bit less ugly (although still horrible) :)

Couldn't you do one more solution using W, ß and Ž? ß (pop smallest element of list), à (pop greatest element of list)

Nevermind, only thing you haven't used in those are the pop smallest and pop largest.

@carusocomputing: I have a couple of solutions with pop largest, but it's hard to fit in a loop when I can't use ^ or } or .

Brachylog, score =  4   5
Program 1 - Shuffle sort

ṣ.↔:1≥₎∧|↰

We shuffle and check that the reverse of the list is non-increasing. If not we retry recursively.
Program 2 - Permutation sort

p≤₁

Output the first permutation which is non-decreasing.
Program 3 - Built-in

o

Order.
Program 4 - Built-in

≜ᵒ

Order by labeling. Since the integers in the list are already fixed, this does the same as o.
Program 5 - Min printing

g~kKt~lg~kK{⌋M&~cṪ↺Th[M]hẉTb↺c}ⁱ⁾

Here's an explanation for this monstrosity of Nature:
g~kK                                K = [Input list, a variable]
    t~lg~kK                         That variable is the length of the Input list
           {                  }ⁱ⁾   Iterate length-of-the-Input times on the Input:
            ⌋M                        M is the min of the input
              &~cṪ                    Ṫ is a triplet of lists which concatenate to the input
                 Ṫ↺Th[M]              T is Ṫ cyclically permuted once ccw; [M] is
                                        the first element of T
                        hẉ            Write M followed by a new line
                          Tb↺c        Remove the first element of T (i.e. [M]), cyclically
                                        pemute T once ccw and concatenate; this is
                                        the input for the next iteration

Crossed out 4 is still regular 4 :(

@NoOneIsHere I cheated and extended the line to circumvent that!

Tail recursion + bogosort. Looks like a recipe f- RecursionError: maximum call stack size exceeded

@Challenger5 Tail recursion is implemented well enough in Prolog so that this should not happen.

JavaScript, score 1 2
Doubled the score thanks to @ETHproductions who reminded me of string escapes
Snippet 1 (21 bytes, characters \ ,-.=>289`Facehilnorstux)
Function`return this.sort\x28\x28t,h\x29=>t-h\x29`.call

Snippet 2 (9117 bytes, characters (+)[!])
[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+(!![]+[])[+[]]+(+(+!+[]+[+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+[+!+[]])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]+!+[]]+(+(+!+[]+[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+[!+[]+!+[]]+[+[]])+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]+(![]+[])[+!+[]]+[[]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]([[]])+[]+(+(+!+[]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+[+[]])+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(!![]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]()[+!+[]+[+!+[]]]+([]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[!+[]+!+[]]+(![]+[])[+!+[]]+(+((+(+!+[]+[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+[!+[]+!+[]]+[+[]])+[])[+!+[]]+[+[]+[+[]]+[+[]]+[+[]]+[+[]]+[+[]]+[+[]]+[+[]]+[+[]]+[+!+[]]])+[])[!+[]+!+[]]+(+(+!+[]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+[+[]])+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]

You can test both versions in your browser's console. The first version is just a function, the second version is a snippet that needs the parentheses and argument added.
Examples
< {function snippet here}([1, -44, 65, -105, 12])
> [-105, -44, 1, 12, 65]

How?
The first snippet calls the sort method on the array you pass it. By default, the sort method sorts lexicographical, which is bad for integers (especially multi-digit negative numbers). As such, we have to pass it a callback in the form of an arrow function that takes two elements and subtracts the latter from the former. Depending on the resulting value, the two elements are rearranged: if it is smaller than 0, a will appear before b, if it is larger than 0, a will appear after b, and if it is 0, both elements will end up next to each other.
The second snippet is nothing more than an encoded version of the first snippet and it takes advantage of the fact that in JavaScript, object.function() equals object["function"](). It also uses empty arrays, ! operators and number casting to generate all kinds of strings, in which the needed characters for the function name can be found. Then the brackets are used once more to get the character at a certain index in the string, and all those characters are concatenated, resulting in the following JavaScript code:
[]["fill"]["constructor"]("return this.sort((a,b)=>a-b)")["call"]

[]["fill"] equals [].fill, whose ["constructor"] is the Function object. We then call that with a string (which is to be evaluated when the function is called), which is the first function, but notice that the argument has been replaced by this. To set the value of this to the argument, we need to call a function on this function, namely ["call"]. In conventional JavaScript, you would write this as:
function _() {
    return this.sort((a,b)=>a-b);
}
_.call(argument);

I bet it's possible to get a solution without parentheses, using backticks instead. Function`return a=>a.sort\x28\x28a,b\x29=>a-b\x29`  for example, but without using the chars you've already used

Not that it matters, but you could probably save a significant amount of bytes in the second snippet by introducing ' and doing e.g. '(' instead of whatever JSF generates that char. (also, use f and t as the vars instead of a and b, b literally costs about 3000 chars)

V, score 3, 4
This was a really fun challenge! Thankfully, vim has a builtin "sort" function, otherwise this would basically be impossible. Unfortunately, it since V/vim are string based it needs an argument to sort by numeric values. So I'm calling

Sort by numerical value n,

Sort by hexadecimal value x, and

Sort by floating point value f

Little side-note: When I write something like <esc> or <C-r>, this is a actually a single-byte. It represents unprintable characters, and since V unfortunately relies heavily on unprintable characters, this method makes everything easier. The TIO links have the -v flag, which makes the V interpreter read these as if they were the characters they represent.
Program 1, 2 bytes
ún

Try it online!
This calls the V specific sort function.
Program 2, 10 bytes
Qsor x
vi

This just calls 'sort' directly. The only interesting thing about this is that we do it from ex mode, which is a weird mode that emulates the text editor 'ex', V's great-great-grandfather. vi is a shortcut for visual, the command used to leave ex mode. This requires a trailing newline.
Try it online!
Program 3, 14 bytes
OSOR X<esc>V~DJ:<C-r>"

Try it online!
Alright, here is where the explanations start to get a little weird. If we can build up the text sor x, we can delete it and insert it into the current command with <C-r><register-name>. So we'll enter it uppercase.
O                       " Open a newline above the current line, and enter insert mode
 SOR X                  " From insert mode, enter 'SOR X'
      <esc>             " Leave insert mode
           V            " Select this whole line
            ~           " And toggle the case of every selected character ('u' would also work here)
             D          " Delete this line (into register '"')
              J         " Get rid of a newline
               :        " Enter command-line mode
                <C-r>"  " Insert register '"'
                        " Implicitly hit enter, running the 'sor x' command
                        " Implicitly print the buffer

Program 4, 19 bytes
YPC<C-v>58fbe a<C-c>g?_dd@1

Try it online!
And here is where the explanations start to get very weird. Similar to last time, we'll build the command up in normal mode so that we can use different keys.
YP                          " Create a copy of this line up one line. This is mostly so that we have a line to work with without messing with the numbers.
  C                         " Delete this line and enter insert mode
   <C-v>58                  " Insert ASCII '58' (which is ':')
          fbe a             " Insert 'fbe a'
               <C-c>        " Pretty much equivalent to <esc>
                    g?_     " ROT13 this line. Now the line is ':sor n'
                       dd   " Delete this whole line
                         @1 " And run it as if typed

CJam, score 4
Program 1: Built-in
$

Program 2: Eval'ed Built-in
36c~

36 is the ASCII value of $.
Program 3: Permutation Sort
e!0=

e!     e# Find unique permutations of the input
  0=   e# Take the first one, which happens to be in sorted order

Program 4: Min Values
[{__)\;\{_@_@<{\}&;}*^{1m<}{)\}?}h;]

Explanation of this unearthly monstrosity:
[             e# Begin working in an array
{             e# Do this block while the TOS is truthy (doesn't pop)
 __           e#  Duplicate TOS twice (the array)
 )\;          e#  Take the last element of the array
 \            e#  Swap top two elements, bringing the other array copy to the top
 {            e#  Reduce the array using this block
  _@_@<{\}&;  e#   The minimum of two values (e was already used, so can't use e<)
 }*           e#  (result is the minimum value from the array)
 ^            e#  Bitwise XOR of last element with minimum element;
              e#   if the numbers are the same, result is 0, otherwise non-zero
 {            e#  If non-zero (i.e. last element wasn't the minimum element)
  1m<         e#   Rotate the array 1 to the left
 }{           e#  Else
  )\          e#   Remove the last element and bring the array back to TOS
 }?           e#  (end if)
}h            e# (end do-while)
;             e# Remove the empty array left behind
]             e# End the array

Not sure how helpful it is but you can use (+ instead of 1m< if you want.

@MartinEnder I'm already using < in that snippet so it's probably better to stick with 1m<

Though I'm not sure I'll be able to do anymore anyway without using blocks...

Japt, score = 4
Program 1
n

Try it online!
Program 2
ñ

Try it online!
Program 3
s)$.sort((a,b)=>a-b

Try it online!
Program 4
Ov85d +110d

Try it online!

Nice one. I think you can save the U in the third program by doing s)$.sort(..., not sure if that's useful though.

@ETHproductions Thanks. I'm not really sure if I can do much more anyway; can't eval any more Japt or JS because O and $ have been used. I'm open for suggestions if you can think of any other ways of sorting! :)

Octave, 2 points
It's hard to compete with esolangs, but here goes:
I'm impressed if someone beats this. unique can be used to sort values, but it will strip out the duplicates. In order to insert the duplicates you would need parentheses, and they are heavily used in the bubble-sort. You'd also need @, which is used too.
Number 1:
This one is quite simple: Create an anonymous function, assigned to the variable ans.
@sort

Call it this way: ans([-5, 3, 0, -2, 100]). It doesn't work on tio, but it works on octave-online.

Number 2:
This is simply an implementation of bubble sort, without using the characters @sort. We can't make this a function, because of o, and we can't use input because of the t. We're therefore stuck with eval.
eval(['a=inpu',116,'("");']);i=1;k=0;
while~k,k=1;i=1;while i<numel(a),if a(i)>a(i+1),a([i+1,i]) = a([i,i+1]);k=0;
end,i++;end,end,a

eval(['a=inpu',116,'("");']); evaluates to: a=input("");, that we can use to enter our input vector. The rest is bubble-sorting without using for or mod. Note that this must be saved in a script and called from the GUI/CLI. You can't copy-paste it, because of input("") (it will use the rest of the code as input, thus fail miserably).

Haskell (lambdabot), 3 functions
sort

vv v|vvv:vvvv<-v=vv vvvv|v==v=v
vvvv==:vvv|vvvv==vv vvvv=vvv:vvvv|v:vv<-vvvv,vvv<v=vvv:v:vv|v:vv<-vvvv=v:vv==:vvv
vv=:vvvv|v:vvv<-vvvv=vv==:v=:vvv
vv=:v=vv
v vvv=vv vvv=:vvv

fix(ap(min).ap((++).flip(map)[1].(.(0*)).(+).minimum).(.ap(\\)(flip(map)[1].(.(0*)).(+).minimum)))

I'm using the lambdabot environment to avoid lots of import statements. Even sort needs import Data.List. lambdabot imports a bunch of modules by default. Besides the missing imports, it's standard Haskell code according to our rules.
Try it online!.
Function 1
sort

The library function from Data.List. Nothing much to say here.
Function 2
vv v|vvv:vvvv<-v=vv vvvv|v==v=v
vvvv==:vvv|vvvv==vv vvvv=vvv:vvvv|v:vv<-vvvv,vvv<v=vvv:v:vv|v:vv<-vvvv=v:vv==:vvv
vv=:vvvv|v:vvv<-vvvv=vv==:v=:vvv
vv=:v=vv
v vvv=vv vvv=:vvv

Function v implements an insert-sort.
I use pattern guards to avoid () for parameters. Compare vv v|vvv:vvvv<-v=... to vv(vvv:vvvv)=....
The first line, function vv is a helper function to create the empty list.  With it I don't have to use [] to write literal empty lists. More readable:
mkEmpty list | hd:tl <- list = mkEmpty tl | otherwise = list

(==:) is insert, which inserts an element into a sorted list, so that the resulting list is still sorted. More readable:
list `insert` el
  | list == []           = el:list
  | hd:tl <- list, el<hd = el:hd:tl
  | hd:tl <- list        = hd : tl `insert` el

(=:) is reduce. More readable:
acc `reduce` list
  | hd:tl <- list = (acc `insert` hd) `reduce` tl
acc `reduce` list = acc

And finally v which reduces the input list staring with []:
sort list = [] `reduce` list

Function 3
fix(ap(min).ap((++).flip(map)[1].(.(0*)).(+).minimum).(.ap(\\)(flip(map)[1].(.(0*)).(+).minimum)))

sort from Function 1 makes most of the list-walking functions (fold, scan, until) unavailable. Recursion needs = which is used in Function 2. The only option left is using the fixpoint combinator fix. I've started with
fix (\f x -> min x ([minimum x]++f(x\\[minimum x])))

which is a selection-sort. Turning it to point-free (I cannot use lambdas \f x ->..., because of the - which is used by the pattern gurads in Function 2) gives:
fix (ap min . ap ((++) . return . minimum) . (. ap (\\) (return . minimum)))

Making singleton lists out of a value with return is forbidden (same for pure), so I have to build my own function: \x -> map (\y -> x+0*y) [1] or point-free flip map[1].(.(0*)).(+). Replacing return yields
fix(ap(min).ap((++).flip(map)[1].(.(0*)).(+).minimum).(.ap(\\)(flip(map)[1].(.(0*)).(+).minimum)))

MATL, 3 programs
Program 1
S

This just uses the builtin function, with implicit input and display.
Try it at MATL online.
Program 2
`GGnZrd0<a}3M

This keeps generating random permutations of the inputs until all consecutive differences of the result are non-negative (this is bogosort, as noted by @c.z.). Running time is non-deterministic and its average increases very fast with input size (namely, (n!) for a size-n array with all entries different).
Try it at MATL Online.
Program 3
t:"tt_X>_=&)]&h

This is a loop that computes the minimum of the array, removes all elements equal to that value, and proceds with the rest. This is done as many times as the input size. If not all entries in the input are different, some of the iterations will be useless (but harmless), because the array will have already been emptied.
Try it at MATL online.

Nice lateral thinking!

Is that bogo-sort?

@c.z. googles bogo-sort Indeed! TIL

Pip, 4 programs
Program 1 - builtin
Snippet; assumes list in x.
SNx

(SN for Sort Numeric)
Program 2 - filter permutations
Snippet; assumes list in y. Very slow for inputs longer than about 7 items.
Y$<=_FIPMyPOy

       PMy     List of permutations of y
     FI        Filter on this lambda function:
 $<=_           Fold on less-than-or-equal
                (gives 1 if the permutation is sorted ascending, 0 otherwise)
Y              Yank that result back into y
               Filter returned a list of (one or more) permutations, so we need to
          POy  Pop the first one

Program 3 - eval
Snippet; assumes list in z.
V J C[83 78 122]

    C[83 78 122]  Apply chr to each number; yields ["S" "N" "z"]
  J               Join that list into a string
V                 Eval

Program 4 - MergeSort
Anonymous function; call with list as argument (like ({...} [1 2]) or f:{...} (f [1 2]).
{b:#a>o?(fa@(,#a/2))lc:#a>o?(fa@(#a/2,()))aa:lWb{Wb@0>c@0|b@0Qc@0{aAE:c@0c@>:o}t:bb:cc:t}aALc}

Ungolfed:
{
 ; If more than one element in a, b gets result of recursion with first half
 ; else b gets l (empty list)
 b: #a>o ? (f a@(,#a/2)) l
 ; If more than one element in a, c gets result of recursion with second half
 ; else c gets a
 c: #a>o ? (f a@(#a/2,())) a
 ; Now we merge b and c
 ; We'll put the results in a, which must be initialized to l (empty list)
 a:l
 ; Loop while b is nonempty
 W b {
  ; Loop while 0th element of c exists and is less than or equal to 0th element
  ; of b (note: Q is string equality)
  W b@0>c@0 | b@0Qc@0 {
   ; Append 0th element of c to a
   a AE: c@0
   ; Slice c from 1st element on and assign that back to c (removing 0th)
   c @>: o
  }
  ; Swap b and c
  t:b
  b:c
  c:t
 }
 ; When b is empty, we only need append the rest of c to a and return
 aALc
}

PowerShell, 2
|sort

Try it online!
This is a snippet that runs in (e.g.) PowerShell's equivalent of a REPL. The TIO link shows usage. The sort is an alias for the Sort-Object cmdlet.

PARAM($A)[ARRAY]::SORT($A);$A

Try it online!
PowerShell commands are case-insensitive, so we can use sort for one and SORT for the other. This takes an input array, sorts it in-place, and then outputs it.

Ruby, 2 programs
First - the straightforward:
->t{t.sort}

Second - the tricky part:
def w(g)
    eval ""<<103<<46<<115<<111<<114<<116
end

J
Program one: 3 bytes
/:~

as in /:~ 3,1,2,1 outputs 1 1 2 3

Try it online!
NOTE in J, negative numbers are preceded by _ not - so you can try 4,_10,56,_333 etc.
Program two: 5 bytes
|.\:~

I fixed up your answer so that the code is displayed properly. Nice answer! Also, the Try it online thing links to a webpage on TIO, to link a page in an answer you can do this: [displayed text](link).

Thanks! Just starting out so getting the hang of it slowly! Think it looks better now. Your help much appreciated. Richard

The programs you write may not share any characters; as-is, : and ~ occur in both of them.

PHP 7, 2 programs
Both programs can be golfed more.
Program 1, 254 bytes, characters ! "$&+.01:;=>?[]adeginoprtv
$a=$argv;0 .$a[1+1]?$i=$n=$d=0:print$a[1]and die;g:$r=0 .$a[++$i+1];$i=!$r?1:$i;$n=!$r?$n+1:$n;$v=$i+1;$d=$v>$d?$v:$d;$n>$d?print$a[$d]and die:0;$e=$d>$n&&$a[$i]>$a[$v];$t=$a[$i];$a[$i]=$e?$a[$v]:$a[$i];$a[$v]=$e?$t:$a[$v];$n==$d?print"$a[$i] ":0;goto g;

Bubble sort. Uses goto to create a loop as built-in loops require ().
Program 2, 155 bytes, characters #%'(),-67ACEFINORTUYZ^_{|}~
IF(CREATE_FUNCTION('','NEFTIEZIENAECCERCTZIENA~N~UEEFECTZIENAUERTEF~CFACTY~YRZIENAUE'^')))6()~(7)7~6-677|~(7)7%~#|~6)77|~(7)7|~77-)^))(-|~^~~~(7)7|~')()){}

IF(...){} avoids usage of ;. The main code is encoded with XOR, because $ has been already used in the previous program. The code:
global$argv;unset($argv[0]);sort($argv);echo join(' ',$argv);


text:
Pascal's Column Sums
Most everyone here is familiar with Pascal's Triangle. It's formed by successive rows, where each element is the sum of its two upper-left and upper-right neighbors. Here are the first 5 rows (borrowed from Generate Pascal's triangle):
    1
   1 1
  1 2 1
 1 3 3 1
1 4 6 4 1

We're going to take Pascal's Triangle and perform some sums on it (hah-ha). For a given input n, output the columnar sum of the first n rows of Pascal's Triangle. For example, for input 5, the output would be formed by
            1
          1   1
        1   2   1
      1   3   3   1
[+] 1   4   6   4   1
----------------------
    1 1 5 4 9 4 5 1 1

So the output would be [1, 1, 5, 4, 9, 4, 5, 1, 1].
Note that you don't necessarily need to generate Pascal's Triangle to calculate the summation - that's up to your implementation if it's shorter to do so or not.
Input
A single positive integer n with n >= 1 in any convenient format.
Output
The resulting array/list of the column-wise summation of the first n rows of Pascal's triangle, as outlined above. Again, in any suitable format.
Rules

Leading or trailing newlines or whitespace are all optional, so long as the characters themselves line up correctly.
Either a full program or a function are acceptable. If a function, you can return the output rather than printing it.
If possible, please include a link to an online testing environment so other people can try out your code!
Standard loopholes are forbidden.
This is code-golf so all usual golfing rules apply, and the shortest code (in bytes) wins.

Examples
[input]
[output]

1
[1]

2
[1, 1, 1]

3
[1, 1, 3, 1, 1]

5
[1, 1, 5, 4, 9, 4, 5, 1, 1]

11
[1, 1, 11, 10, 54, 44, 155, 111, 286, 175, 351, 175, 286, 111, 155, 44, 54, 10, 11, 1, 1]

MATL, 16 bytes
tZv=Gq:"t5BZ+]vs

Try it online!
Explanation
This repeatedly applies convolution to generate the rows. For example, for input n=5 we start with the first row
0 0 0 0 1 0 0 0 0

Convolving with [1 0 1] gives
0 0 0 1 0 1 0 0 0

Repeating the operation gives
0 0 1 0 2 0 1 0 0

then
0 1 0 3 0 3 0 1 0

etc. Concatenating these arrays vertically and computing the sum of each column gives the result.
t       % Input n implictly. Duplicate
Zv      % Symmetric range. Gives [1 2 3 4 5 4 3 2 1] for input 5
=       % Equal to (element-wise). Gives [0 0 0 0 1 0 0 0 0]. This is the first row
Gq:     % Push [1 2 ... n-1]
"       % For each. This executes the following code n-1 times
  t     %   Duplicate
  5B    %   Push 5 in binary, that is, [1 0 1]
  Z+    %   Convolution keeping size
]       % End
v       % Concatenate all results vertically
s       % Sum. Display implicitly.

Fatality! I can't cut my byte-count in half; a tip of the hat to you sir.

@carusocomputing Thanks :-) You know what they say about convolution...

CJam, 32 25 24 bytes
Thanks to Luis Mendo for saving 1 byte.
{(_0a*1+\{_(2$+.+}*]:.+}

Try it online!
Explanation
(       e# Decrement input N.
_0a*1+  e# Create a list of N-1 zeros and a 1. This is the top row with
        e# the required indentation.
\{      e# Run this block N-1 times.
  _     e#   Duplicate the last row.
  (     e#   Pull off a leading zero, shifting the row left.
  2$+   e#   Copy the full row and prepend that zero, shifting the row right.
  .+    e#   Element-wise addition, which results in the next row.
}*
]       e# Wrap all rows in a list.
:.+     e# Add up the columns by reducing element-wise addition over the rows.

Octave, 84 67 45  bytes
22 bytes saved thanks to Neil!
@(n)sum(spdiags(flip(tril(flip(pascal(n))))))

Try it online!
Explanation
The pascal function gives a matrix that contains the values in the Pascal triangle:
>> pascal(5)
ans =
     1     1     1     1     1
     1     2     3     4     5
     1     3     6    10    15
     1     4    10    20    35
     1     5    15    35    70

To extract the desired values we flip vertically (flip), keep the lower triangular part (tril ), and flip again. This gives
ans =
   1   1   1   1   1
   1   2   3   4   0
   1   3   6   0   0
   1   4   0   0   0
   1   0   0   0   0

spdiags then extracts the diagonals as columns
ans =
   1   1   1   1   1   0   0   0   0
   0   0   4   3   2   1   0   0   0
   0   0   0   0   6   3   1   0   0
   0   0   0   0   0   0   4   1   0
   0   0   0   0   0   0   0   0   1

and sum computes the sum of each column, which gives the result.

Can't you simplify that to @(n)sum(spdiags(flip(tril(flip(pascal(n))))))?

JavaScript (ES6), 90 87 86 84 82 bytes
Saved 3 bytes thanks to ETHproductions
f=(n,a=[1],b=a)=>n--?f(n,[...(F=x=>a.map((n,i)=>n+~~x[i-d]))(a,d=2),0,d=1],F(b)):b

Test cases

f=(n,a=[1],b=a)=>n--?f(n,[...(F=x=>a.map((n,i)=>n+~~x[i-d]))(a,d=2),0,d=1],F(b)):b

console.log(JSON.stringify(f(1)))
console.log(JSON.stringify(f(2)))
console.log(JSON.stringify(f(3)))
console.log(JSON.stringify(f(5)))
console.log(JSON.stringify(f(11)))

Mathematica, 59 57 bytes
Thanks to Martin Ender for finding a two-byte savings!
Binomial[i,(j+i)/2]~Sum~{i,Abs@j,b,2}~Table~{j,-b,b=#-1}&

Pure function taking a positive integer input and returning a list of integers. Literally produces all the relevant entries of Pascal's triangle and sums them appropriately.
Previous submission (which is a bit easier to read):
Table[Sum[Binomial[i,(j+i)/2],{i,Abs@j,b,2}],{j,-b,b=#-1}]&

JavaScript (ES6), 83 bytes

f=
n=>[...Array(n+--n)].map(g=(j=n,i,a)=>j--?g(j,i-1)+g(j,i+1)+(a?g(j,i,a):0):i-n?0:1)
<input type=number min=1 oninput=o.textContent=f(+this.value)><pre id=o>

1-indexing cost me a byte. Explanation: g(j-1,i-1)+g(j-1,i+1) recursively calculates Pascal's triangle until it reaches the first row, which is the base case. To obtain column sums, I use the fact that map actually passes a third parameter, so there is an extra recursive step when this is the case.

05AB1E, 34 32 28 25 24 bytes
-4 thanks to Emigna.
FN©ƒ®Ne0})¹®-Å0.ø˜¨ˆ}¯øO

Try it online!

FN©ƒ®Ne0})               # Generate, iteratively, the current pascal row, interspersed with 0's.
          ¹®-Å0          # Calculate the number of zeros to middle pad it.
               .ø˜¨ˆ}¯øO # Surround with the zeros, transpose and sum.

Basically all it does is generate this:
0 0 0 0 0 0 1 0 0 0 0 0 0
0 0 0 0 0 1 0 1 0 0 0 0 0
0 0 0 0 1 0 2 0 1 0 0 0 0
0 0 0 1 0 3 0 3 0 1 0 0 0
0 0 1 0 4 0 6 0 4 0 1 0 0

Transpose it:
0 0 0 0 0
0 0 0 0 1
0 0 0 1 0
0 0 1 0 4
0 1 0 3 0
1 0 2 0 6
0 1 0 3 0
0 0 1 0 4
0 0 0 1 0
0 0 0 0 1
0 0 0 0 0

Then sums each row:
0
1
1
5
4
9
4
5
1
1
0

If a leading and trailing 0 are not acceptable, ®>-Å isntead of ®-Å fixes it for a +1 byte penalty.

Result for 50:
[0, 1, 1, 50, 49, 1224, 1175, 19551, 18376, 229125, 210749, 2100384, 1889635, 15679951, 13790316, 97994765, 84204449, 523088334, 438883885, 2421229251, 1982345366, 9833394285, 7851048919, 35371393434, 27520344515, 113548602181, 86028257666, 327340174085, 241311916419, 851817398634, 610505482215, 2009517658701, 1399012176486, 4313184213360, 2914172036874, 8448367214664, 5534195177790, 15139356846901, 9605161669111, 24871748205410, 15266586536299, 37524050574849, 22257464038550, 52060859526501, 29803395487951, 66492351226050, 36688955738099, 78239857877649, 41550902139550, 84859704298201, 43308802158651, 84859704298201, 41550902139550, 78239857877649, 36688955738099, 66492351226050, 29803395487951, 52060859526501, 22257464038550, 37524050574849, 15266586536299, 24871748205410, 9605161669111, 15139356846901, 5534195177790, 8448367214664, 2914172036874, 4313184213360, 1399012176486, 2009517658701, 610505482215, 851817398634, 241311916419, 327340174085, 86028257666, 113548602181, 27520344515, 35371393434, 7851048919, 9833394285, 1982345366, 2421229251, 438883885, 523088334, 84204449, 97994765, 13790316, 15679951, 1889635, 2100384, 210749, 229125, 18376, 19551, 1175, 1224, 49, 50, 1, 1, 0]

-Å0 instead of >-Ý0* should work and € is not needed at the end.

And >F can be ƒ.

Nice catches, I always forget about Å, smart! I kept "ctrl+f" for "identity list" or something like that on the info.txt heh...

I have only recently started to remember that they exist :)

Why does the transpose turn it from 13 x 5 to 5 x 11? Where'd the other two columns/rows go?

@AdmBorkBork I C&P'd the result from n=6 for the non-transposed version of it and removed the last row, my bad. I hadn't done that on the transposed version, so they didn't match up.

PHP, 119 bytes
columns numbers from 1-input to input -1
for(;$r<$argn;$l=$t[+$r++])for($c=-$r;$c<=$r;$c+=2)$s[$c]+=$t[+$r][$c]=$r|$c?$l[$c+1]+$l[$c-1]:1;ksort($s);print_r($s);

Try it online!

@LuisMendo Thank You I have found the error and it saves 3 Bytes. Now it works with PHP Versions greater 5.5 . array_column is a new function in this version

It's nice when a correction turns out to be shorter :-)

Here are another 24 to 30 bytes: Save 13 bytes by swapping row and column count and dropping array_column().
$x=2*$j++-$i saves 7 bytes.
Looping $j down instead of up can save 1 (for($j=$i+1;$j--;)). And 3 more bytes can be golfed from the output.

@Titus it was so nice too use array_column

Some day it will save bytes.

Jelly, 12 bytes
Ḷµc€j€0Ṛṙ"NS

Try it online!
How it works
Ḷµc€j€0Ṛṙ"NS  Main link. Argument: k

Ḷ             Unlength; yield A := [0, ..., k-1].
 µ            New chain. Argument: A
  c€          Combinations each; compute nCr for each n and r in A, grouping by n.
    j€0       Join each resulting array [nC0, ..., nC(k-1)], separating by zeroes,
              yielding, [nC0, 0, ..., 0, nC(k-1)].
              Note that nCr = 0 whenever r > n.
       Ṛ      Reverse the resulting 2D array.
          N   Negate A, yielding [0, ..., -(k-1)].
        ṙ"    Zipwith rotate; for each array in the result to the left and the
              corresponding integer non-positive integer to the right, rotate
              the array that many units to the left.
           S  Take the columnwise sum.

Python 3, 201 184 bytes
def f(n):x,z,m=[1],[0],n-1;l=[z*m+x+z*m];exec("x=[*map(sum,zip(z+x,x+z))];l.append(z*(n-len(x))+[b for a in zip(x,z*len(x))for b in a][:-1]+z*(n-len(x)));"*m);return[*map(sum,zip(*l))]

Haskell, 118 112 104 bytes
6 14 bytes saved thanks to @nimi
z=zipWith(+)
p n|n<2=[1]|m<-p(n-1)=z(0:0:m)(m++[0,0])            -- Generate the nth triangle row.
f n=foldl1 z[d++p x++d|x<-[1..n],d<-[0<$[1..n-x]]]  -- Pad each row with 0s and then sum all the rows.

You can shorten the padding function# to r#n|d<-0<$[1..n]=d++r++d.

Oh, now you can inline #, because it's not recursive anymore: define f as f n=foldl1 z[d++p x++d|x<-[1..n],d<-[0<$[1..n-x]]] and dump #.

Python 2, 140 137 bytes
n=input()
x=[]
a=[0]*n+[1]+n*[0]
z=n%2
exec'x+=[a];a=[(i%2^z)*sum(a[i-1:i+2])for i in range(2*n+1)];z^=1;'*n
print map(sum,zip(*x))[1:-1]

Try it online! or Try it online!
For n=3
Starts with a list with n zeros surround an one - [[0, 0, 0, 1, 0, 0, 0]]
Generate the full pyramid
[[0, 0, 0, 1, 0, 0, 0],
 [0, 0, 1, 0, 1, 0, 0],
 [0, 1, 0, 2, 0, 1, 0]]

Rotate 90º and sum each row, discarding the first and the last one (only zeros)
[[0, 0, 0],
 [0, 0, 1],
 [0, 1, 0],
 [1, 0, 2],
 [0, 1, 0],
 [0, 0, 1],
 [0, 0, 0]]

Python 3.9+, 124 115 chars
s=range;f=lambda k:[sum([(q:=(lambda t:(k>(u:=n+x+t)>=0)*(t<1or u/t*q(~-t))))(x)for x in s(2*k)])for n in s(1-k,k)]

My previous answer didn't seem to work. Future me using python3.9+. The solution still uses the fact that the Pascal Triangle can be defined with binomial coefficents. Expanding it and defining the negatives as 0.
Also this is my first time golfing so I hope you forgive any faux-pas.
The binomial is not mine and was taken from here.

Python 3, 100 bytes
f=lambda n,r=0:r and[r]+(n and[r+n[0]+(r==n[0])]+f(n[1:],n[0]))or(n*[1]and[1]+f(f(n-1)[2::2],1))+[1]

Try it online!
This is really ugly mostly because I mashed together two separate functions. The outer one gets selected when r=0. It recursively calls itself to generate the previous row and then does the following: Discard every other entry. Add a 1 at the end and the beginning. Then have the inner function: Fill the gaps with the sums of the neighbouring entries and if the middle entry was among the discarded ones increment it by one.

Pari/GP, 31 bytes
n->Vec(((y=1+x^2)^n-x^n)/(y-x))

Try it online!
The sum of first \$n\$ rows is the coefficients of the polynomial \$\frac{(x^2+1)^n-x^n}{x^2+1-x}\$.

Wolfram Language (Mathematica), 40 bytes
(((y=x^2+1)^#-x^#)/(y-x)+O@x^(2#))[[3]]&

Try it online!