Ich muss aufhören, an lustige Namen zu denken

Ihre Aufgabe ist es, so viele Snippets (Programme mit eingebauter Ein- und Ausgabe), Funktionen oder vollständige Programme zu erstellen, die die Version von Ganzzahl-Arrays in Ihrer Sprache in aufsteigender Reihenfolge sortieren. Für jedes Programm sind Sie jedoch nur berechtigt Verwenden der Zeichen in ASCII (oder der Codepage Ihrer Sprache, wenn diese direkt als nicht ASCII angegeben ist), die in den vorherigen Programmen nicht verwendet wurden.

Dies ist eine Beispielantwort (separate Programme, die durch Zeilenumbrüche getrennt sind):

Derp
ASdFGHJKLAAA
qwEEERtyRty

In dieser (fiktiven Sprache), meine erste Antwort ist Derp, die aufgebraucht D, e, rund p. Im zweiten Programm darf ich diese Zeichen nicht mehr verwenden, aber ich kann so viele Zeichen wiederverwenden, wie ich möchte. Dasselbe gilt für das dritte Programm und so weiter.

Jedes Programm muss ein Array von Ganzzahlen haben, also so etwas wie dieses (gültige Eingabe- / Ausgabestile finden Sie in den Eingabe- / Ausgabebeispielen):

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

Und es muss die Elemente im Array in aufsteigender Reihenfolge als Array ausgeben:

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

Ihre Punktzahl ist die Gesamtzahl der Einsendungen. Bei einem Gleichstand gewinnt der niedrigste Bytecount (die geringste Anzahl von Bytes in Ihrem Code)!

Regeln für Programme:

• Alle Einsendungen müssen korrekt in einer Sprachversion laufen (so Python 2 != Python 3).
• Ihre Einsendungen können Ausschnitte, Funktionen oder vollständige Programme sein. Du darfst sie sogar mischen und anpassen - du musst jedoch sagen, welche welche ist und Links zu funktionierenden Einsendungen bereitstellen.
• Bitte stellen Sie nach Möglichkeit Online-Links zu allen Lösungen zur Verfügung.
• Bei allen Einsendungen muss ein Array (oder eine mit einem beliebigen Zeichen begrenzte Zeichenfolge) als Eingabe verwendet und das Array sortiert (in der {any character}Arrayform Ihrer Sprache oder als durch -begrenzte Zeichenfolge) ausgegeben werden.
• Sie dürfen keine Zeichen außerhalb von ASCII (oder der Codepage Ihrer Sprache) verwenden.

Dies sind beispielsweise gültige Ein- / Ausgaben:

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

Angaben zur Eingabe:

• Es wird garantiert, dass das Array nur Ganzzahlen enthält. Es kann jedoch negative Zahlen geben und Zahlen können sich unbegrenzt wiederholen.

Jelly , 10 Programme, 65 Bytes

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

Es gibt unvermeidliche Überschneidungen mit der Antwort von @ Lynn's Jelly . Credits für die bogosort Idee gehen an sie.

Probieren Sie es online! oder überprüfen Sie die Eindeutigkeit .

Wie sie arbeiten

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

Gelee, 8 Programme

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

Das letzte Programm ist echt nervig ...

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.

Wenn ich das entfernen œṡvon <;0œṡ0⁸ṁjµ/, gibt es auch diese sonderbaren: ²SNr²ZFœ&. Hilfe wird geschätzt.

05AB1E , Punktzahl = 6

05AB1E verwendet die CP-1252- Codierung.

Vielen Dank an Kevin Cruijssen für Programm 4.
Vielen Dank an Riley für die Inspiration für Programm 6.

Programm 1

{               # sort          

Probieren Sie es online!

Programm 2

`[Ž.^]¯

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

Probieren Sie es online!

Programm 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

Probieren Sie es online!

Programm 4

ϧ

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

Probieren Sie es online!

Programm 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

Probieren Sie es online!

Programm 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

Probieren Sie es online!

Brachylog , Score =  4  5

Programm 1 - Zufallssortierung

ṣ._button: 1≥₎∧ | ↰

Wir mischen und überprüfen, ob die umgekehrte Liste nicht aufsteigend ist. Wenn nicht, versuchen wir es erneut.

Programm 2 - Permutationssortierung

p≤₁

Gibt die erste Permutation aus, die nicht abnimmt.

Programm 3 - Eingebaut

O

Bestellung.

Programm 4 - Eingebaut

≜ᵒ

Bestellung durch Etikettierung. Da die Ganzzahlen in der Liste bereits festgelegt sind, gilt dies auch füro .

Programm 5 - Min. Drucken

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

Hier ist eine Erklärung für diese Ungeheuerlichkeit der Natur:

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, Punktzahl 1 2

Verdoppelte die Punktzahl dank @ETHproductions, die mich an String-Fluchten erinnerten

Snippet 1 (21 Bytes, Zeichen \ ,-.=>289`Facehilnorstux)

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

Snippet 2 (9117 Bytes, Zeichen (+)[!])

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

Sie können beide Versionen in der Konsole Ihres Browsers testen. Die erste Version ist nur eine Funktion, die zweite Version ist ein Ausschnitt, dem Klammern und Argumente hinzugefügt werden müssen.

Beispiele

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

Wie?

Das erste Snippet ruft die Sortiermethode für das übergebene Array auf. Standardmäßig sortiert die Sortiermethode lexikografisch, was für Ganzzahlen (insbesondere für mehrstellige negative Zahlen) schlecht ist. Als solches müssen wir ihm einen Rückruf in Form einer Pfeilfunktion übergeben, die zwei Elemente nimmt und letztere von ersteren subtrahiert. Abhängig vom resultierenden Wert werden die beiden Elemente neu angeordnet: Wenn es kleiner als 0 ist, awird vor b, wenn es größer als 0 ist, awird nach angezeigtb und wenn er 0 ist, werden beide Elemente nebeneinander angezeigt.

Das zweite Snippet ist nichts anderes als eine codierte Version des ersten Snippets und nutzt die Tatsache, dass in JavaScript object.function()gleich ist object["function"](). Außerdem werden leere Arrays, !Operatoren und Zahlenumwandlungen verwendet, um alle Arten von Zeichenfolgen zu generieren, in denen die erforderlichen Zeichen für den Funktionsnamen gefunden werden können. Dann werden die Klammern erneut verwendet, um das Zeichen an einem bestimmten Index in der Zeichenfolge abzurufen, und alle diese Zeichen werden verkettet, was den folgenden JavaScript-Code ergibt:

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

[]["fill"]gleich [].fill, wessen ["constructor"]ist das FunctionObjekt. Wir nennen das dann mit einem String (der beim Aufruf der Funktion ausgewertet werden soll), der die erste Funktion ist. Beachten Sie jedoch, dass das Argument durch ersetzt wurde this. Um den Wert von thisauf das Argument zu setzen, müssen wir eine Funktion für diese Funktion aufrufen, nämlich ["call"]. In herkömmlichem JavaScript würden Sie dies wie folgt schreiben:

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

V , Punktzahl 3 , 4

Das war eine wirklich lustige Herausforderung! Zum Glück hat vim eine eingebaute "sort" -Funktion, sonst wäre dies im Grunde unmöglich. Leider benötigt V / vim ein Argument, um nach numerischen Werten zu sortieren, da es auf Strings basiert. Also rufe ich an

• Nach Zahlenwert sortieren n,

• Nach Hexadezimalwert sortieren xund

• Nach Gleitkommawert sortieren f

Kleine Randnotiz: Wenn ich so etwas wie <esc>oder schreibe <C-r>, ist das eigentlich ein Einzelbyte. Es stellt nicht druckbare Zeichen dar, und da V leider stark auf nicht druckbare Zeichen angewiesen ist, erleichtert diese Methode alles. Die TIO-Links haben das -vFlag, wodurch der V-Interpreter diese als die Zeichen liest, die sie darstellen.

Programm 1, 2 Bytes

ún

Probieren Sie es online!

Dies ruft die V-spezifische Sortierfunktion auf .

Programm 2, 10 Bytes

Qsor x
vi

Dies ruft direkt "sortieren" auf. Das einzig interessante daran ist, dass wir es aus dem exModus heraus tun , der ein seltsamer Modus ist, der den Texteditor 'ex' emuliert, Vs Ur-Ur-Großvater. viist eine Abkürzung für visualden Befehl zum Verlassen des Ex-Modus. Dies erfordert einen nachgestellten Zeilenumbruch.

Probieren Sie es online!

Programm 3, 14 Bytes

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

Probieren Sie es online!

Okay, hier fangen die Erklärungen an, ein bisschen komisch zu werden. Wenn wir den Text aufbauen können sor x, können wir ihn löschen und mit in den aktuellen Befehl einfügen <C-r><register-name>. Also werden wir es in Großbuchstaben eingeben.

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

Programm 4, 19 Bytes

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

Probieren Sie es online!

Und hier fangen die Erklärungen an, sehr seltsam zu werden. Ähnlich wie beim letzten Mal bauen wir den Befehl im normalen Modus auf, damit wir verschiedene Tasten verwenden können.

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

Programm 1: Eingebaut

$

Programm 2: Eval'ed Built-in

36c~

36 ist der ASCII-Wert von $.

Programm 3: Permutationssortierung

e!0=

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

Programm 4: Mindestwerte

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

Erklärung dieser überirdischen Monstrosität:

[             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 , Score = 4

Programm 1

n

Probieren Sie es online!

Programm 2

ñ

Probieren Sie es online!

Programm 3

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

Probieren Sie es online!

Programm 4

Ov85d +110d

Probieren Sie es online!

Oktave, 2 Punkte

Es ist schwer, mit Esolangs zu konkurrieren, aber hier ist es:

Ich bin beeindruckt, wenn jemand das schlägt. uniquekann zum Sortieren von Werten verwendet werden, entfernt jedoch die Duplikate. Um die Duplikate einzufügen, müssten Klammern angegeben werden, die bei der Blasensortierung häufig verwendet werden. Du würdest auch brauchen@ , was auch gebraucht wird.

Nummer 1:

Dies ist ganz einfach: Erstellen Sie eine anonyme Funktion, die der Variablen zugewiesen ist ans.

@sort

Nennen Sie es auf diese Weise: ans([-5, 3, 0, -2, 100]). Es funktioniert nicht mit tio, aber mit octave-online .

Nummer 2:

Dies ist einfach eine Implementierung der Blasensortierung, ohne die Zeichen zu verwenden @sort. Wir können dies nicht zu einer Funktion machen o, und wir können es nicht benutzen, inputweil t. Wir sind daher fest mit 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,'("");']);a=input("");ergibt :, mit dem wir unseren Eingabevektor eingeben können. Der Rest ist Blasensortieren ohne foroder mod. Beachten Sie, dass dies in einem Skript gespeichert und über die GUI / CLI aufgerufen werden muss. Sie können es wegen nicht kopieren-einfügen input("")(es wird den Rest des Codes als Eingabe verwenden, also kläglich scheitern).

Haskell (Lambdabot), 3 Funktionen

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

Ich benutze die Lambdabot-Umgebung, um viele importAussagen zu vermeiden . Sogar sortBedürfnisse import Data.List. lambdabot importiert standardmäßig eine Reihe von Modulen. Neben den Vermisstenimports , ist es Standard-Haskell-Code nach unseren Regeln.

Probieren Sie es online! .

Funktion 1

sort

Die Bibliotheksfunktion von Data.List. Hier gibt es nicht viel zu sagen.

Funktion 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

Funktion vimplementiert eine Einfügesortierung.

Ich benutze Pattern Guards, um ()Parameter zu vermeiden . Vergleichen Sie vv v|vvv:vvvv<-v=...mit vv(vvv:vvvv)=....

Die vvFunktion in der ersten Zeile ist eine Hilfsfunktion zum Erstellen der leeren Liste. Damit muss ich keine []leeren Listen schreiben. Besser lesbar:

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

(==:)ist Einfügen, wodurch ein Element in eine sortierte Liste eingefügt wird, sodass die resultierende Liste weiterhin sortiert ist. Besser lesbar:

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

(=:)ist zu reduzieren. Besser lesbar:

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

Und zum Schluss, vwas die Eingabeliste reduziert, die auf Folgendes verweist []:

sort list = [] `reduce` list

Funktion 3

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

sortvon Funktion 1 macht die meisten der Listen-Walking - Funktionen ( fold, scan, until) nicht verfügbar. Rekursionsanforderungen, =die in Funktion 2 verwendet werden. Die einzige verbleibende Option ist die Verwendung des Fixpunktkombinators fix. Ich habe angefangen mit

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

das ist eine auswahlsorte. Wenn Sie es auf Punktfrei stellen (ich kann keine Lambdas verwenden \f x ->..., da dies von den -Musterguraden in Funktion 2 verwendet wird), erhalten Sie Folgendes:

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

Das Erstellen von Singleton-Listen aus einem Wert mit returnist verboten (dasselbe gilt für pure), daher muss ich meine eigene Funktion erstellen: \x -> map (\y -> x+0*y) [1]oder ohne Punkte flip map[1].(.(0*)).(+). Ersetzen returnAusbeuten

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

MATL , 3 Programme

Programm 1

S

Dies verwendet nur die eingebaute Funktion mit impliziter Eingabe und Anzeige.

Probieren Sie es bei MATL online .

Programm 2

`GGnZrd0<a}3M

Dadurch werden so lange zufällige Permutationen der Eingaben generiert, bis alle aufeinander folgenden Differenzen des Ergebnisses nicht mehr negativ sind (dies ist , wie von bemerkt, eine falsche Reihenfolge) @cz angegeben ). Die Laufzeit ist nicht deterministisch und ihr Durchschnitt steigt mit der Eingabegröße sehr schnell an (d. H. 𝒪 ( n! ) Für ein Array der Größe n mit unterschiedlichen Einträgen).

Probieren Sie es bei MATL Online aus .

Programm 3

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

Dies ist eine Schleife, die das Minimum des Arrays berechnet, alle Elemente entfernt, die diesem Wert entsprechen, und mit dem Rest fortfährt. Dies erfolgt so oft wie die Eingabegröße. Wenn nicht alle Einträge in der Eingabe unterschiedlich sind, sind einige der Iterationen nutzlos (aber harmlos), da das Array bereits geleert wurde.

Probieren Sie es bei MATL online .

Pip , 4 Programme

Programm 1 - eingebaut

Snippet; nimmt Liste in an x.

SNx

( SNfür numerische Sortierung)

Programm 2 - Permutationen filtern

Snippet; nimmt Liste in an y. Sehr langsam für Eingaben, die länger als ca. 7 Elemente sind.

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

Programm 3 - Auswertung

Snippet; nimmt Liste in an 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

Programm 4 - MergeSort

Anonyme Funktion; Aufruf mit Liste als Argument (wie ({...} [1 2])oder 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

Probieren Sie es online!

Dies ist ein Snippet, das in (z. B.) PowerShell-Entsprechung einer REPL ausgeführt wird. Der TIO-Link zeigt die Verwendung an. Das sortist ein Alias für das Sort-ObjectCmdlet.

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

Probieren Sie es online!

Powershell - Befehle sind Groß- und Kleinschreibung, so dass wir verwenden können , sortfür eine und SORTfür den anderen. Das nimmt ein Eingabearray, sortiert es an Ort und Stelle und gibt es dann aus.

Ruby, 2 Programme

Erstens - das Unkomplizierte:

->t{t.sort}

Zweitens - der schwierige Teil:

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

J

Programm eins: 3 Bytes

/:~

wie in /:~ 3,1,2,1Ausgaben1 1 2 3

Probieren Sie es online!

HINWEIS: In J werden negative Zahlen mit _ not vorangestellt. Sie können also 4, _10,56, _333 usw. versuchen.

Programm zwei: 5 Bytes

|.\:~

PHP 7, 2 Programme

Beide Programme können mehr golfen werden.

Programm 1, 254 Bytes, Zeichen ! "$&+.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;

Blase sortieren. Verwendet goto, um eine Schleife zu erstellen, wie es integrierte Schleifen erfordern() .

Programm 2, 155 Bytes, Zeichen #%'(),-67ACEFINORTUYZ^_{|}~

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

IF(...){}vermeidet die Verwendung von ;. Der Hauptcode wird mit XOR codiert, da $er bereits im vorherigen Programm verwendet wurde. Der Code:

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