[Question]
  [
*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.
  
[Answer]
# [Jelly](https://github.com/DennisMitchell/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](https://codegolf.stackexchange.com/a/113067/12012). Credits for the bogosort idea go to her.
[Try it online!](https://tio.run/nexus/jelly#Aa4AUf//4bmiCsK5w54K4buk4buLCsWSIeG5ggo3Nzc44buMdgrhuoo@MlxTJMK/CsSgRuG4o@G5qsKlQOKCrAp@4bmAfnLhuYB4TMWTJgpDwrsvw7Arw4ZOUMOGZsOGQ1/huLcKPMO@4biFMeKAmFdpw75K4biEwrPhuata4bii/zEwUuKBuOG5m8S/w5DigqxH//9bMywgNCwgLTIsIDUsIDcsIDE5NiwgLTQ0LCAtMl0 "Jelly ‚Äì TIO Nexus") or [verify uniqueness](https://tio.run/nexus/jelly#AX4Agf//4bu0UeKCrEbhuaLFknJH////4bmiCsK5w54K4buk4buLCsWSIeG5ggo3Nzc44buMdgrhuoo@MlxTJMK/Cn7huYB@cuG5gHhMxZMmCkPCuy/DsCvDhk5Qw4Zmw4ZDX@G4two8w77huIUx4oCYV2nDvkrhuITCs@G5q1rhuKI "Jelly ‚Äì TIO Nexus").
### 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.
```
[Answer]
# 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.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), score = 6
**05AB1E** uses [CP-1252](http://www.cp1252.com/) encoding.
Thanks to *Kevin Cruijssen* for program 4.  
Thanks to *Riley* for inspiration to program 6.
**Program 1**
```
{               # sort          
```
[Try it online!](https://tio.run/nexus/05ab1e#@1/9/3@0sY6CiY6CrpGOgqmOgrmOgqGlGZBrAhaLBQA)
**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!](https://tio.run/nexus/05ab1e#@58QfXSvXlzsofX//0cb6yiY6CjoGukomOoomOsoGFqaAbkmYLFYAA)
**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!](https://tio.run/nexus/05ab1e#@x9eFHV0ARDuKKt81LDg//9oYx0FEx0FXSMdBVMdBXMdBUNLMyDXBCwWCwA)
**Program 4**
```
≈ì√ü
≈ì               # get a list of all permutations of input
 √ü              # pop the smallest
```
[Try it online!](https://tio.run/nexus/05ab1e#@3908uH5//9HG@somOgo6BrpKJjqKJjrKBhamgG5JmCxWAA)
**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!](https://tio.run/nexus/05ab1e#@394lUu6m4vf4RWHdhaHRgT6u0UU19bGaP7/H22so2Cio6BrpKNgqqNgrqNgaGkG5JqAxWIB)
**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!](https://tio.run/nexus/05ab1e#@39o5aOmNYfnHgZRh5Yc3qehcWgdsogGUCjo8Jr//6ONdRRMdBR0jXQUTHUUzHUUDC3NgFwTsFgsAA)
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), score = ~~¬†4~~  ¬†5
### Program 1 - Shuffle sort
[```
·π£.‚Üî:1‚â•‚Çé‚àß|‚Ü∞
```](https://tio.run/nexus/brachylog2#@/9w52K9R21TrAwfdS591NT3qGN5zaO2Df//RxvrmOjEG@mY6pjrGFqa6cSbgLix/6MA)
We shuffle and check that the reverse of the list is non-increasing. If not we retry recursively.
### Program 2 - Permutation sort
[```
p‚â§‚ÇÅ
```](https://tio.run/nexus/brachylog2#@1/wqHPJo6bG//@jjXVMdOKNdEx1zHUMLc104k1A3Nj/UQA)
Output the first permutation which is non-decreasing.
### Program 3 - Built-in
[```
o
```](https://tio.run/nexus/brachylog2#@5///3@0sY6JTryRjqmOuY6hpZlOvAmIG/s/CgA)
Order.
### Program 4 - Built-in
[```
‚âú·µí
```](https://tio.run/nexus/brachylog2#@/@oc87DrZP@/4821jHRiTfSMdUx1zG0NNOJNwFxY/9HAQA)
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}‚Å±‚Åæ
```](https://tio.run/nexus/brachylog2#@59el@1dUpcDoqof9XT7qtUlP9y56lHbrpCMaN/YjIe7OkOSgLzk2keNGx817vv/P9pYx0Qn3kjHVMdcx9DSTCfeBMSN/Q8A)
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
```
[Answer]
# 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);
```
[Answer]
# [V](https://github.com/DJMcMayhem/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!](https://tio.run/nexus/v#@394V97//4ZcplwmRobGXGaWZuZcukaGAA)
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!](https://tio.run/nexus/v#@x9YnF@kUMFVlsn1/78hlymXiZGhMZeZpZk5l66RIQA)
### Program 3, 14 bytes
```
OSOR X<esc>V~DJ:<C-r>"
```
[Try it online!](https://tio.run/nexus/v#@@8f7B@kEGGTWpxsF1bn4mVl46xbZKf0/78hlymXiZGhMZeZpZk5l66R4X/dMgA)
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!](https://tio.run/nexus/v#@x8Z4GzjrFtmZ2qRlpSqkAhkJ9ul28enpDgY/v9vyGXKZWJkaMxlZmlmzqVrZPhftwwA)
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
```
[Answer]
# CJam, score 4
### [Program 1: Built-in](https://tio.run/nexus/cjam#K6z7r/K/4H@0oYKpgpmCkYKFgkksAA)
```
$
```
### [Program 2: Eval'ed Built-in](https://tio.run/nexus/cjam#K6z7b2yWXPe/4H@0oYKpgpmCkYKFgkksAA)
```
36c~
```
36 is the ASCII value of `$`.
### [Program 3: Permutation Sort](https://tio.run/nexus/cjam#K6z7n6poYPu/4H@0oYKpgpmCkYKFgkksAA)
```
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](https://tio.run/nexus/cjam#K6z7H10dH68ZYx1THe8Q72BTHVOrZl2rFVdtmGtTW60ZU2tfm2Ed@7/gf7ShgqmCmYKRgoWCSSwA)
```
[{__)\;\{_@_@<{\}&;}*^{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
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), score = 4
**Program 1**
```
n
```
[Try it online!](https://tio.run/nexus/japt#@5/3/3@0sY6CiY6CrpGOgqmOgrmOgqGlGZBrAhaLBQA)
**Program 2**
```
√±
```
[Try it online!](https://tio.run/nexus/japt#@3944///0cY6CiY6CrpGOgqmOgrmOgqGlmZArglYLBYA)
**Program 3**
```
s)$.sort((a,b)=>a-b
```
[Try it online!](https://tio.run/nexus/japt#@1@sqaJXnF9UoqGRqJOkaWuXqJv0/3@0sY6CiY6CrpGOgqmOgrmOgqGlGZBrAhaLBQA)
**Program 4**
```
Ov85d +110d
```
[Try it online!](https://tio.run/nexus/japt#@@9fZmGaoqBtaGiQ8v9/tLGOgomOgq6RjoKpjoK5joKhpRmQawIWiwUA)
[Answer]
# 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](http://octave-online.net/).
---
### 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).
[Answer]
## 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!](https://tio.run/nexus/haskell#hYzBTsMwDIbveQofOCQsixgTQ1TzaYgTPMG2Q8Q0ydKaVG3mcei7FyfdYEgILFn@/X@/TXUT2wTPPnn3Sl1SNBqrGFIbD@4tBr@7mCX1cgzviWIYOuzEVIoZuGfmSpqXU8ZsSPWMKIvKGrEqTpFnjpebPg85lLL5xZlUPwhmOb6Rj/h9@MULvQpgFjCiMgpSJ9zTh/aNrikYJ1NPJsbtDySOb8x6tnXa6btbY5wWICmqj7UsObvZGP1v1Jih9hQAYRcVQNNSSHADHazndjqzC3tvH@zcPtnH7RXmv/HpFzx8Ag "Haskell ‚Äì TIO Nexus").
### 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)))
```
[Answer]
# [MATL](https://github.com/lmendo/MATL), 3 programs
### Program 1
```
S
```
This just uses the builtin function, with implicit input and display.
Try it at [MATL online](https://matl.io/?code=S&inputs=%5B3+4+-2+5+7+196+-44+-2%5D&version=19.8.0).
### 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](https://en.wikipedia.org/wiki/Bogosort), as noted by [@c.z.](https://codegolf.stackexchange.com/users/67047/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](https://matl.io/?code=%60GGnZrd0%3Ca%7D3M&inputs=%5B3+4+-2+5+7+196%5D&version=19.8.0).
### 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](https://matl.io/?code=t%3A%22tt_X%3E_%3D%26%29%5D%26h&inputs=%5B3+4+-2+5+7+196+-44+-2%5D&version=19.8.0).
[Answer]
# [Pip](https://github.com/dloscutoff/pip), 4 programs
### [Program 1](https://tio.run/nexus/pip#q7CKNrY2sdY1sja1Nrc2tDSz1jUxsTYACsT@D/ar@P//v24BAA) - builtin
Snippet; assumes list in `x`.
```
SNx
```
(`SN` for Sort Numeric)
### [Program 2](https://tio.run/nexus/pip#q7SKNrY2sdY1sja31jUxsTYAMmP/R6rY2Ma7eQb4Vgb4V/7//1@3AAA) - 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](https://tio.run/nexus/pip#q7KKNrY2sdY1sja1Nrc2tDSz1jUxsTYACsRa/w9T8FJwjrYwVjC3UDA0Mor9//@/bgEA) - 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](https://tio.run/nexus/pip#TcixCsIwEADQj@mSg4bGGiveQUyHbl2cOojD3YFToR26xXx7jJvTg2dKEmw4bHfz5mjahrseYNW/@1VrAIAZ10XSItEFje5TfVQTjxNWNQbc8oEiqIpH5nHWXJ5n8mR7utCVTreBrPfkarygFLt/AQ) - 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
}
```
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 2
```
|sort
```
[Try it online!](https://tio.run/nexus/powershell#@2@sY6Kja6RjqmOuY2hppqNrAuLWFOcXlfz/DwA "PowerShell ‚Äì TIO Nexus")
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!](https://tio.run/nexus/powershell#@x/gGOToq6HiqBntGBTkGBlrZRXsHxQCErBWcfz//7@GsY6Jjq6RjqmOuY6hpZmOrgmIqwkA "PowerShell ‚Äì TIO Nexus")
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.
[Answer]
# Ruby, 2 programs
First - the straightforward:
```
->t{t.sort}
```
Second - the tricky part:
```
def w(g)
    eval ""<<103<<46<<115<<111<<114<<116
end
```
[Answer]
# J
**Program one: 3 bytes**
```
/:~
```
as in `/:~ 3,1,2,1` outputs `1 1 2 3`
[Try it online!](https://tio.run/nexus/j#@///v75VnYKxjpGOoY7J17x83eTE5IxUAA "J ‚Äì TIO Nexus")
NOTE in J, negative numbers are preceded by \_ not - so you can try 4,\_10,56,\_333 etc.
**Program two: 5 bytes**
```
|.\:~
```
[Answer]
# 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);
```
]