Muszę przestać myśleć o pieprzonych nazwiskach

Twoim zadaniem jest utworzenie jak największej liczby urywków (programów z wbudowanymi wejściami i wyjściami), funkcji lub pełnych programów, które sortują w rosnącej kolejności w dowolnej wersji językowej tablic liczb całkowitych, ale dla każdego programu dozwolone są tylko używać znaków w ASCII (lub stronie kodowej twojego języka, jeśli jest to bezpośrednio określone jako nie ASCII), które nie były używane w poprzednich programach.

Oto przykładowa odpowiedź (osobne programy oddzielone znakiem nowej linii):

Derp
ASdFGHJKLAAA
qwEEERtyRty

W tym języku (fikcyjnej), moja pierwsza odpowiedź brzmi Derp, co zużyte D, e, ri p. W drugim programie nie mogę ponownie użyć tej postaci, ale mogę ponownie użyć dowolnej liczby znaków. To samo z trzecim programem i tak dalej.

Każdy program musi przyjmować tablicę liczb całkowitych, więc coś takiego: (patrz przykłady wejść / wyjść dla prawidłowych stylów wejścia / wyjścia):

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

I musi wyprowadzać elementy w tablicy jako tablicę, w porządku rosnącym:

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

Twój wynik będzie całkowitą liczbą zgłoszeń. W przypadku remisu wygrywa najniższa liczba bajtów (najmniejsza liczba bajtów w kodzie)!

Zasady dla programów:

• Wszystkie zgłoszenia muszą działać poprawnie w jednej wersji językowej (tak Python 2 != Python 3).
• Twoje zgłoszenia mogą być fragmentami, funkcjami lub pełnymi programami. Możesz nawet mieszać i dopasowywać je - musisz jednak powiedzieć, który jest, i podać linki do działających zgłoszeń.
• Jeśli to możliwe, podaj linki online do wszystkich rozwiązań.
• Wszystkie zgłoszenia muszą przyjmować tablicę (lub ciąg rozdzielony dowolnym znakiem) jako dane wejściowe i wysyłać tablicę posortowaną (w formie tablic w języku użytkownika lub jako {any character}ciąg -delimitowany.
• Nie wolno używać żadnych znaków poza ASCII (lub stroną kodową Twojego języka).

Na przykład są to prawidłowe wejścia / wyjścia:

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

Dane wejściowe:

• Masz gwarancję, że tablica zawiera tylko liczby całkowite. Mogą jednak występować liczby ujemne i liczby mogą się powtarzać w nieskończoność.

Galaretka , 10 programów, 65 bajtów

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

Nieuniknione nakładanie się odpowiedzi Jelly na @ Lynn . Kredyty za pomysł Bogosort idą do niej.

Wypróbuj online! lub zweryfikuj niepowtarzalność .

Jak oni pracują

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

Galaretka, 8 programów

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

Ostatni program jest naprawdę denerwujący…

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.

Jeśli mogę usunąć œṡz <;0œṡ0⁸ṁjµ/, istnieje również to dziwne jeden: ²SNr²ZFœ&. Pomoc jest doceniana.

05AB1E , wynik = 6

05AB1E wykorzystuje kodowanie CP-1252 .

Podziękowania dla Kevina Cruijssena za program 4.
Dziękujemy Riley za inspirację do programu 6.

Program 1

{               # sort          

Wypróbuj online!

Program 2

`[Ž.^]¯

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

Wypróbuj online!

Program 3

WrZŠŠŸvy†

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

Wypróbuj online!

Program 4

ϧ

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

Wypróbuj online!

Program 5

êDgFDNè¹sUXQOFXs}}\)

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

Wypróbuj online!

Program 6

©€Ý逤þ((®€Ý逤(þ(Rì

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

Wypróbuj online!

Brachylog , wynik =  4  5

Program 1 - Sortowanie losowe

ṣ.*: 1≥₎∧ | ↰

Przetasujemy i sprawdzamy, czy rewers listy nie rośnie. Jeśli nie, próbujemy rekurencyjnie.

Program 2 - Sortowanie permutacyjne

p≤₁

Wyprowadza pierwszą permutację, która nie maleje.

Program 3 - Wbudowany

o

Zamówienie.

Program 4 - Wbudowany

≜ᵒ

Zamów przez etykietowanie. Ponieważ liczby całkowite na liście są już ustalone, działa to tak samo jak o.

Program 5 - Min. Drukowanie

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

Oto wyjaśnienie tej potworności Natury:

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

Podwoił wynik dzięki @ETHproductions, który przypomniał mi o ucieczkach z łańcucha

Snippet 1 (21 bajtów, znaki \ ,-.=>289`Facehilnorstux)

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

Snippet 2 (9117 bajtów, znaki (+)[!])

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

Możesz przetestować obie wersje w konsoli przeglądarki. Pierwsza wersja to tylko funkcja, druga wersja to fragment, który wymaga dodania nawiasów i argumentów.

Przykłady

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

W jaki sposób?

Pierwszy fragment wywołuje metodę sortowania w tablicy, którą przekazujesz. Domyślnie metoda sortowania sortuje leksykograficzne, co jest złe dla liczb całkowitych (szczególnie wielocyfrowych liczb ujemnych). W związku z tym musimy przekazać mu wywołanie zwrotne w postaci funkcji strzałki, która pobiera dwa elementy i odejmuje ten drugi od poprzedniego. W zależności od wartości wynikowej dwa elementy są przestawiane: jeśli jest mniejsza niż 0, apojawi się wcześniej b, jeśli jest większa niż 0, apojawi się później b, a jeśli jest 0, oba elementy kończą się obok siebie.

Drugi fragment jest niczym więcej niż zakodowaną wersją pierwszego fragmentu i wykorzystuje fakt, że w JavaScript object.function()jest równy object["function"](). Wykorzystuje również puste tablice, !operatory i rzutowanie liczb do generowania wszelkiego rodzaju ciągów znaków, w których można znaleźć potrzebne znaki dla nazwy funkcji. Następnie nawiasy są używane ponownie, aby uzyskać znak o określonym indeksie w ciągu, a wszystkie te znaki są łączone, co powoduje następujący kod JavaScript:

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

[]["fill"]równa [].fill, którego ["constructor"]jest Functionprzedmiotem. Następnie wywołujemy to za pomocą ciągu znaków (który ma być oceniany przy wywołaniu funkcji), co jest pierwszą funkcją, ale zauważmy, że argument został zastąpiony przez this. Aby ustawić wartość thisargumentu, musimy wywołać funkcję w tej funkcji, a mianowicie ["call"]. W tradycyjnym JavaScript napisałbyś to jako:

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

V , wynik 3 , 4

To było naprawdę zabawne wyzwanie! Na szczęście vim ma wbudowaną funkcję „sortowania”, w przeciwnym razie byłoby to w zasadzie niemożliwe. Niestety, ponieważ V / vim są oparte na łańcuchach, potrzebuje argumentu do sortowania według wartości liczbowych. Więc dzwonię

• Sortuj według wartości liczbowej n,

• Sortuj według wartości szesnastkowej xi

• Sortuj według wartości zmiennoprzecinkowych f

Mała uwaga: kiedy piszę coś w stylu <esc>lub <C-r>, jest to właściwie jeden bajt. Reprezentuje znaki niedrukowalne, a ponieważ V niestety w dużej mierze opiera się na znakach niedrukowalnych, ta metoda ułatwia wszystko. Łącza TIO mają -vflagę, dzięki czemu interpreter V odczytuje je tak, jakby były znakami, które reprezentują.

Program 1, 2 bajty

ún

Wypróbuj online!

To wywołuje funkcję sortowania specyficzną dla V.

Program 2, 10 bajtów

Qsor x
vi

To po prostu wywołuje „sortowanie” bezpośrednio. Jedyną interesującą rzeczą jest to, że robimy to z extrybu, który jest dziwnym trybem, który emuluje edytor tekstu „ex”, prapradziadek V. vijest skrótem do visualpolecenia służącego do opuszczania trybu ex. Wymaga to końca nowej linii.

Wypróbuj online!

Program 3, 14 bajtów

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

Wypróbuj online!

Dobra, tutaj wyjaśnienia stają się trochę dziwne. Jeśli możemy zbudować tekst sor x, możemy go usunąć i wstawić do bieżącego polecenia za pomocą <C-r><register-name>. Więc wprowadzimy to wielkimi literami.

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 bajtów

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

Wypróbuj online!

I tutaj wyjaśnienia stają się bardzo dziwne. Podobnie jak ostatnim razem, zbudujemy polecenie w trybie normalnym, abyśmy mogli używać różnych klawiszy.

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

Program 1: Wbudowany

$

Program 2: Wbudowany moduł Eval'ed

36c~

36 to wartość ASCII dla $.

Program 3: Sortowanie permutacyjne

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. Wartości

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

Wyjaśnienie tej nieziemskiej potworności:

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

Program 1

n

Wypróbuj online!

Program 2

ñ

Wypróbuj online!

Program 3

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

Wypróbuj online!

Program 4

Ov85d +110d

Wypróbuj online!

Oktawa, 2 punkty

Trudno konkurować z esolangami, ale oto:

Jestem pod wrażeniem, jeśli ktoś to pokona. uniquemożna użyć do sortowania wartości, ale usunie duplikaty. Aby wstawić duplikaty, potrzebujesz nawiasów i są one często używane w sortowaniu bąbelkowym. Ty też będziesz potrzebować@ , który również jest używany.

Numer 1:

Ta jest dość prosta: Utwórz anonimową funkcję przypisaną do zmiennej ans.

@sort

Nazwijmy to w ten sposób: ans([-5, 3, 0, -2, 100]). Nie działa w trybie Tio, ale działa w trybie oktawa-online .

Numer 2:

Jest to po prostu implementacja sortowania bąbelkowego, bez użycia znaków @sort. Nie możemy uczynić tej funkcji z tego powodu oi nie możemy jej używać z inputpowodu t. Dlatego utknęliśmy z 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,'("");']);ocenia na:, a=input("");że możemy użyć, aby wprowadzić nasz wektor wejściowy. Reszta to sortowanie bąbelkowe bez użycia forlub mod. Pamiętaj, że należy to zapisać w skrypcie i wywołać z GUI / CLI. Nie możesz go skopiować i wkleić z powoduinput("") (wykorzysta resztę kodu jako dane wejściowe, a zatem nie powiedzie się źle).

Haskell (lambdabot), 3 funkcje

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

Używam środowiska lambdabot, aby uniknąć wielu importinstrukcji. Nawet sortpotrzebujeimport Data.List . lambdabot domyślnie importuje wiązkę modułów. Oprócz brakującego imports, to standardowy kod Haskell zgodnie z naszymi zasadami.

Wypróbuj online!.

Funkcja 1

sort

Funkcja biblioteki z Data.List . Nie ma tu nic do powiedzenia.

Funkcja 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

Funkcjonować v implementuje sortowanie wstawek.

Używam osłon wzorców, aby unikać ()parametrów. Porównaćvv v|vvv:vvvv<-v=... z vv(vvv:vvvv)=....

Pierwszy wiersz, funkcja vvjest funkcją pomocniczą do utworzenia pustej listy. Dzięki temu nie muszę []pisać dosłownie pustych list. Bardziej czytelny:

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

(==:)jest wstawianie, które wstawia element do posortowanej listy, dzięki czemu lista wynikowa jest nadal posortowana. Bardziej czytelny:

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

(=:)jest redukcja. Bardziej czytelny:

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

I wreszcie, vco zmniejsza listę danych wejściowych za pomocą []:

sort list = [] `reduce` list

Funkcja 3

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

sortz funkcją 1 sprawia, że większość funkcji list-spacerowych ( fold, scan, until) niedostępne. Potrzeby rekurencyjne, =które są używane w Funkcji 2. Jedyną opcją, która pozostała, jest użycie kombinacji punktów stałych fix. Zacząłem od

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

który jest sortowaniem według wyboru. Przekształcenie go w tryb bez punktów (nie mogę używać lambda \f x ->..., ponieważ -gurady wzorcowe w Funkcji 2) dają:

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

Tworzenie list singletonów z wartości za pomocą returnjest zabronione (to samo dla pure), więc muszę zbudować własną funkcję: \x -> map (\y -> x+0*y) [1]lub bez punktów flip map[1].(.(0*)).(+). Zamiana returnplonów

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

MATL , 3 programy

Program 1

S

To po prostu korzysta z wbudowanej funkcji, z niejawnym wprowadzaniem i wyświetlaniem.

Wypróbuj w MATL online .

Program 2

`GGnZrd0<a}3M

Powoduje to generowanie losowych permutacji danych wejściowych, dopóki wszystkie kolejne różnice wyniku nie będą ujemne (to jest bogosort , jak zauważył @cz ). Czas działania jest niedeterministyczny, a jego średnia wartość rośnie bardzo szybko wraz z rozmiarem wejściowym (mianowicie 𝒪 ( n! ) Dla rozmiaru n tablicy rozmiar z różnymi wpisami).

Wypróbuj w MATL Online .

Program 3

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

Jest to pętla, która oblicza minimum tablicy, usuwa wszystkie elementy równe tej wartości i postępuje z resztą. Odbywa się to tyle razy, ile rozmiar wejściowy. Jeśli nie wszystkie wpisy na wejściu są różne, niektóre iteracje będą bezużyteczne (ale nieszkodliwe), ponieważ tablica zostanie już opróżniona.

Wypróbuj w MATL online .

Pip , 4 programy

Program 1 - wbudowany

Skrawek; zakłada listę w x.

SNx

( SNdla Sort Numeric)

Program 2 - permutacje filtrów

Skrawek; zakłada listę w y. Bardzo wolny dla wejść dłuższych niż około 7 pozycji.

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

Skrawek; zakłada listę w z.

V J C[83 78 122]

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

Program 4 - MergeSort

Funkcja anonimowa; wywołanie z listą jako argumentem (jak ({...} [1 2])lub 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}

Nie golfowany:

{
 ; 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

Wypróbuj online!

Jest to fragment, który działa w (np.) Odpowiedniku REPL programu PowerShell. Łącze TIO pokazuje użycie. sortJest aliasem dla Sort-Objectcmdlet.

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

Wypróbuj online!

Polecenia programu PowerShell nie rozróżniają wielkości liter, więc możemy używać sortjednego i SORTdrugiego. Pobiera tablicę wejściową, sortuje ją w miejscu, a następnie wysyła.

Ruby, 2 programy

Po pierwsze - proste:

->t{t.sort}

Po drugie - trudna część:

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

jot

Program pierwszy: 3 bajty

/:~

jak w /:~ 3,1,2,1wyjściach1 1 2 3

Wypróbuj online!

UWAGA w J, liczby ujemne poprzedza _ nie - możesz więc wypróbować 4, _10,56, _333 itd.

Program drugi: 5 bajtów

|.\:~

PHP 7, 2 programy

Oba programy można bardziej grać w golfa.

Program 1, 254 bajty, znaki ! "$&+.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;

Sortowanie bąbelkowe. Wykorzystuje gototworzenie pętli zgodnie z wymaganiami wbudowanych pętli ().

Program 2, 155 bajtów, znaki #%'(),-67ACEFINORTUYZ^_{|}~

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

IF(...){}unika używania ;. Główny kod jest zakodowany za pomocą XOR, ponieważ $był już używany w poprzednim programie. Kod:

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