Devo smettere di pensare a nomi punny

Il tuo compito è quello di creare quanti più frammenti (programmi che hanno input e output integrati), funzioni o programmi completi possibili che ordinino qualunque sia la versione della tua lingua di array di numeri interi in ordine crescente, ma per ogni programma, ti è consentito solo per utilizzare i caratteri in ASCII (o la tabella codici della tua lingua, se è direttamente specificato come non ASCII) che non sono stati utilizzati nei programmi precedenti.

Questa è una risposta di esempio (programmi separati separati da nuove righe):

Derp
ASdFGHJKLAAA
qwEEERtyRty

In questo (lingua di fantasia), la mia prima risposta è Derpche esaurito D, e, re p. Nel secondo programma, non sono autorizzato a riutilizzare quel personaggio, ma posso riutilizzare tutti i personaggi che voglio. Lo stesso con il terzo programma e così via.

Ogni programma deve prendere una matrice di numeri interi, quindi qualcosa del genere (vedi esempi di input / output per stili di input / output validi):

[3 4 -2 5 7 196 -44 -2]

E deve generare gli elementi nell'array come un array, in ordine crescente:

[-44 -2 -2 3 4 5 7 196]

Il tuo punteggio sarà l'importo totale degli invii. Se c'è un pareggio, vince il byte più basso (la quantità minima di byte nel tuo codice) vince!

Regole per i programmi:

• Tutti gli invii devono essere eseguiti correttamente in una versione in una lingua (quindi Python 2 != Python 3).
• I tuoi invii possono essere frammenti, funzioni o programmi completi. Puoi anche mescolarli e abbinarli, tuttavia devi dire quale è quale e fornire collegamenti a invii funzionanti.
• Fornire collegamenti online a tutte le soluzioni, se possibile.
• Tutti gli invii devono prendere una matrice (o una stringa delimitata con qualsiasi carattere) come input e generare la matrice ordinata (nella forma della matrice della propria lingua o come {any character}stringa delimitata.
• Non è consentito utilizzare caratteri al di fuori di ASCII (o della tabella codici della propria lingua).

Ad esempio, si tratta di ingressi / uscite validi:

[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)

Specifiche per l'input:

• Si garantisce che l'array contiene solo numeri interi. Tuttavia, potrebbero esserci numeri negativi e i numeri potrebbero ripetersi indefinitamente.

Gelatina , 10 programmi, 65 byte

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

C'è inevitabile sovrapposizione con la risposta Jelly di @ Lynn . I crediti per l'idea di bogosort vanno a lei.

Provalo online! o verifica l'unicità .

Come funzionano

Ṣ               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 programmi

Ṣ                   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.

L'ultimo programma è davvero fastidioso ...

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.

Se riesco a togliere la œṡda <;0œṡ0⁸ṁjµ/, c'è anche questo strano uno: ²SNr²ZFœ&. L'aiuto è apprezzato.

05AB1E , punteggio = 6

05AB1E utilizza la codifica CP-1252 .

Grazie a Kevin Cruijssen per il programma 4.
Grazie a Riley per l'ispirazione al programma 6.

Programma 1

{               # sort          

Provalo online!

Programma 2

`[Ž.^]¯

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

Provalo online!

Programma 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

Provalo online!

Programma 4

ϧ

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

Provalo online!

Programma 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

Provalo online!

Programma 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

Provalo online!

Brachylog , punteggio =  4  5

Programma 1: riordino casuale

ṣ.↔: 1≥₎∧ | ↰

Mischiamo e controlliamo che il retro dell'elenco non sia in aumento. In caso contrario, riproveremo in modo ricorsivo.

Programma 2 - Ordinamento permutazione

p≤₁

Emette la prima permutazione che non è in diminuzione.

Programma 3: integrato

o

Ordine.

Programma 4: integrato

≜ᵒ

Ordina per etichettatura. Poiché i numeri interi nell'elenco sono già corretti, ciò fa lo stesso di o.

Programma 5 - Stampa minima

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

Ecco una spiegazione per questa mostruosità della natura:

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

JavaScript, punteggio 1 2

Raddoppiato il punteggio grazie a @ETHproductions che mi ha ricordato delle fughe di stringhe

Snippet 1 (21 byte, caratteri \ ,-.=>289`Facehilnorstux)

Function`return this.sort\x28\x28t,h\x29=>t-h\x29`.call

Snippet 2 (9117 byte, caratteri (+)[!])

[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+(!![]+[])[+[]]+(+(+!+[]+[+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+[+!+[]])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]+!+[]]+(+(+!+[]+[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+[!+[]+!+[]]+[+[]])+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]+(![]+[])[+!+[]]+[[]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]([[]])+[]+(+(+!+[]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+[+[]])+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(!![]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]()[+!+[]+[+!+[]]]+([]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[!+[]+!+[]]+(![]+[])[+!+[]]+(+((+(+!+[]+[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+[!+[]+!+[]]+[+[]])+[])[+!+[]]+[+[]+[+[]]+[+[]]+[+[]]+[+[]]+[+[]]+[+[]]+[+[]]+[+[]]+[+!+[]]])+[])[!+[]+!+[]]+(+(+!+[]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+[+[]])+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]

Puoi testare entrambe le versioni nella console del tuo browser. La prima versione è solo una funzione, la seconda versione è uno snippet che richiede l'aggiunta di parentesi e argomento.

Esempi

< {function snippet here}([1, -44, 65, -105, 12])
> [-105, -44, 1, 12, 65]

Come?

Il primo frammento chiama il metodo di ordinamento sull'array in cui lo si passa. Per impostazione predefinita, il metodo di ordinamento ordina lessicografico, il che è negativo per gli interi (specialmente i numeri negativi a più cifre). Come tale, dobbiamo passare un callback sotto forma di una funzione freccia che prende due elementi e sottrae il secondo dal primo. A seconda del valore risultante, i due elementi vengono riorganizzati: se è più piccolo di 0, aapparirà prima b, se è più grande di 0, aapparirà dopo b, e se è 0, entrambi gli elementi finiranno uno accanto all'altro.

Il secondo snippet non è altro che una versione codificata del primo snippet e sfrutta il fatto che in JavaScript è object.function()uguale object["function"](). Utilizza inoltre matrici, !operatori e casting numerici vuoti per generare tutti i tipi di stringhe, in cui è possibile trovare i caratteri necessari per il nome della funzione. Quindi le parentesi vengono utilizzate ancora una volta per ottenere il carattere in corrispondenza di un determinato indice nella stringa e tutti questi caratteri vengono concatenati, ottenendo il seguente codice JavaScript:

[]["fill"]["constructor"]("return this.sort((a,b)=>a-b)")["call"]

[]["fill"]è uguale a [].fill, di chi ["constructor"]è l' Functionoggetto. Quindi lo chiamiamo con una stringa (che deve essere valutata quando viene chiamata la funzione), che è la prima funzione, ma notiamo che l'argomento è stato sostituito da this. Per impostare il valore thisdell'argomento, dobbiamo chiamare una funzione su questa funzione, vale a dire ["call"]. In JavaScript convenzionale, dovresti scrivere questo come:

function _() {
    return this.sort((a,b)=>a-b);
}
_.call(argument);

V , punteggio 3 , 4

Questa è stata una sfida davvero divertente! Per fortuna, vim ha una funzione "sort" incorporata, altrimenti sarebbe praticamente impossibile. Sfortunatamente, poiché V / vim sono basati su stringhe ha bisogno di un argomento per ordinare in base a valori numerici. Quindi sto chiamando

• Ordina per valore numerico n,

• Ordina per valore esadecimale xe

• Ordina per valore in virgola mobile f

Piccola nota a margine: quando scrivo qualcosa di simile <esc>o <C-r>, questo è in realtà un singolo byte. Rappresenta caratteri non stampabili e poiché S purtroppo si basa fortemente su caratteri non stampabili, questo metodo semplifica tutto. I collegamenti TIO hanno il -vflag, che fa leggere all'interprete V come se fossero i personaggi che rappresentano.

Programma 1, 2 byte

ún

Provalo online!

Questo chiama la funzione di ordinamento specifica V.

Programma 2, 10 byte

Qsor x
vi

Questo chiama semplicemente 'ordina' direttamente. L'unica cosa interessante di questo è che lo facciamo dalla exmodalità, che è una strana modalità che emula l'editor di testo "ex", il trisavolo di V. viè una scorciatoia per visualil comando usato per uscire dalla modalità ex. Ciò richiede una nuova riga finale.

Provalo online!

Programma 3, 14 byte

OSOR X<esc>V~DJ:<C-r>"

Provalo online!

Bene, qui è dove le spiegazioni iniziano a diventare un po ' strane. Se riusciamo a costruire il testo sor x, possiamo eliminarlo e inserirlo nel comando corrente con <C-r><register-name>. Quindi lo inseriremo in maiuscolo.

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

Programma 4, 19 byte

YPC<C-v>58fbe a<C-c>g?_dd@1

Provalo online!

Ed ecco dove le spiegazioni iniziano a diventare molto strane. Simile all'ultima volta, costruiremo il comando in modalità normale in modo da poter usare chiavi diverse.

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, punteggio 4

Programma 1: incorporato

$

Programma 2: Eval'ed integrato

36c~

36 è il valore ASCII di $.

Programma 3: Ordinamento permutazione

e!0=

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

Programma 4: valori minimi

[{__)\;\{_@_@<{\}&;}*^{1m<}{)\}?}h;]

Spiegazione di questa mostruosità ultraterrena:

[             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

Japt , punteggio = 4

Programma 1

n

Provalo online!

Programma 2

ñ

Provalo online!

Programma 3

s)$.sort((a,b)=>a-b

Provalo online!

Programma 4

Ov85d +110d

Provalo online!

Ottava, 2 punti

È difficile competere con gli esolang, ma ecco qui:

Sono impressionato se qualcuno batte questo. uniquepuò essere utilizzato per ordinare i valori, ma eliminerà i duplicati. Per inserire i duplicati sono necessarie le parentesi, che vengono utilizzate pesantemente nell'ordinamento a bolle. Avresti anche bisogno @, che viene utilizzato anche.

Numero 1:

Questo è abbastanza semplice: crea una funzione anonima, assegnata alla variabile ans.

@sort

Chiamare in questo modo: ans([-5, 3, 0, -2, 100]). Non funziona su tio, ma funziona su ottave-online .

Numero 2:

Questa è semplicemente un'implementazione di bubble sort, senza usare i personaggi @sort. Non possiamo renderlo una funzione, a causa di o, e non possiamo usare a inputcausa di t. Siamo quindi bloccati 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,'("");']);valuta:, a=input("");che possiamo usare per inserire il nostro vettore di input. Il resto è lo smistamento delle bolle senza usare foro mod. Si noti che questo deve essere salvato in uno script e chiamato dalla GUI / CLI. Non è possibile copiarlo e incollarlo, a causa di input("")(utilizzerà il resto del codice come input, quindi fallirà miseramente).

Haskell (lambdabot), 3 funzioni

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)))

Sto usando l'ambiente lambdabot per evitare molte importdichiarazioni. Anche i sortbisogni import Data.List. lambdabot importa un gruppo di moduli per impostazione predefinita. Oltre ai dispersiimports , è il codice Haskell standard secondo le nostre regole.

Provalo online! .

Funzione 1

sort

La funzione di libreria da Data.List. Non c'è molto da dire qui.

Funzione 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

La funzione vimplementa un tipo di inserimento.

Uso i pattern guard per evitare i ()parametri. Confronta vv v|vvv:vvvv<-v=...con vv(vvv:vvvv)=....

La prima riga, funzione vvè una funzione di supporto per creare l'elenco vuoto. Con esso non devo usare []per scrivere liste vuote letterali. Più leggibile:

mkEmpty list | hd:tl <- list = mkEmpty tl | otherwise = list

(==:)è insert, che inserisce un elemento in un elenco ordinato, in modo che l'elenco risultante sia ancora ordinato. Più leggibile:

list `insert` el
  | list == []           = el:list
  | hd:tl <- list, el<hd = el:hd:tl
  | hd:tl <- list        = hd : tl `insert` el

(=:)è ridurre. Più leggibile:

acc `reduce` list
  | hd:tl <- list = (acc `insert` hd) `reduce` tl
acc `reduce` list = acc

E infine vciò riduce l'elenco di input che fissa con []:

sort list = [] `reduce` list

Funzione 3

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

sortda Funzione 1 rende la maggior parte delle funzioni lista-walking ( fold, scan, until) non disponibili. Esigenze di ricorsione =utilizzate nella funzione 2. L'unica opzione rimasta è utilizzare il combinatore del punto di fissaggio fix. Ho iniziato con

fix (\f x -> min x ([minimum x]++f(x\\[minimum x])))

che è un ordinamento per selezione. Trasformandolo in point-free (non posso usare lambdas \f x ->..., a causa del -quale viene utilizzato dai pattern gurad in Funzione 2) si ottiene:

fix (ap min . ap ((++) . return . minimum) . (. ap (\\) (return . minimum)))

Fare elenchi singleton su un valore con returnè proibito (lo stesso per pure), quindi devo costruire la mia funzione: \x -> map (\y -> x+0*y) [1]o senza punti flip map[1].(.(0*)).(+). Sostituzione dei returnrendimenti

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

MATL , 3 programmi

Programma 1

S

Questo utilizza solo la funzione integrata, con input e display impliciti.

Provalo su MATL online .

Programma 2

`GGnZrd0<a}3M

Questo continua a generare permutazioni casuali degli input fino a quando tutte le differenze consecutive del risultato non sono negative (questo è bogosort , come notato da @cz ). Il tempo di esecuzione non è deterministico e la sua media aumenta molto rapidamente con le dimensioni di input (ovvero, 𝒪 ( n! ) Per un array size- n con tutte le voci diverse).

Provalo su MATL Online .

Programma 3

t:"tt_X>_=&)]&h

Questo è un ciclo che calcola il minimo dell'array, rimuove tutti gli elementi uguali a quel valore e procede con il resto. Questo viene fatto tante volte quante sono le dimensioni dell'input. Se non tutte le voci nell'input sono diverse, alcune iterazioni saranno inutili (ma innocue), poiché l'array sarà già stato svuotato.

Provalo su MATL online .

Pip , 4 programmi

Programma 1 - integrato

Frammento; assume l'elenco in x.

SNx

( SNper Ordinamento numerico)

Programma 2 - permutazioni del filtro

Frammento; assume l'elenco in y. Molto lento per input più lunghi di circa 7 articoli.

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

Programma 3 - valutazione

Frammento; assume l'elenco 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

Programma 4 - MergeSort

Funzione anonima; chiama con la lista come argomento (come ({...} [1 2])o 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

Provalo online!

Questo è un frammento che viene eseguito (ad esempio) nell'equivalente di PowerShell di un REPL. Il collegamento TIO mostra l'utilizzo. Il sortè un alias per il Sort-Objectcmdlet.

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

Provalo online!

I comandi di PowerShell non fanno distinzione tra maiuscole e minuscole, quindi possiamo usarli sortper uno e SORTper l'altro. Questo prende un array di input, lo ordina sul posto e quindi lo emette.

Ruby, 2 programmi

Innanzitutto, il semplice:

->t{t.sort}

Secondo - la parte difficile:

def w(g)
    eval ""<<103<<46<<115<<111<<114<<116
end

J

Programma uno: 3 byte

/:~

come nelle /:~ 3,1,2,1uscite1 1 2 3

Provalo online!

NOTA in J, i numeri negativi sono preceduti da _ not - quindi puoi provare 4, _10,56, _333 ecc.

Programma due: 5 byte

|.\:~

PHP 7, 2 programmi

Entrambi i programmi possono essere giocati a golf di più.

Programma 1, 254 byte, caratteri ! "$&+.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;

Ordinamento delle bolle. Utilizza gotoper creare un loop come richiesto dai loop integrati ().

Programma 2, 155 byte, caratteri #%'(),-67ACEFINORTUYZ^_{|}~

IF(CREATE_FUNCTION('','NEFTIEZIENAECCERCTZIENA~N~UEEFECTZIENAUERTEF~CFACTY~YRZIENAUE'^')))6()~(7)7~6-677|~(7)7%~#|~6)77|~(7)7|~77-)^))(-|~^~~~(7)7|~')()){}

IF(...){}evita l'uso di ;. Il codice principale è codificato con XOR, perché $è già stato utilizzato nel programma precedente. Il codice:

global$argv;unset($argv[0]);sort($argv);echo join(' ',$argv);