Punny isimlerini düşünmekten vazgeçmeliyim

Göreviniz, dilinizin tamsayı dizileri sürümünün yükselen bir sırada olmasına rağmen sıralamada sıralanan her türlü parçacığı (giriş ve çıkış yerleşik programları), işlevleri veya tam programları oluşturmaktır. Önceki programlarda kullanılmamış karakterleri ASCII’de (veya doğrudan ASCII olarak belirtilmemişse, dilinizin kod sayfasında) kullanmak için.

Bu örnek bir cevaptır (yeni satırlarla ayrılmış ayrı programlar):

Derp
ASdFGHJKLAAA
qwEEERtyRty

Bu (hayali dilinde) olarak, İlk yanıtım Derp, kullanıldıktan hangi D, e, rve p. İkinci programda, bu karakteri tekrar kullanmama izin verilmiyor, ancak istediğim kadar karakteri tekrar kullanabilirim. Üçüncü programla aynı, vb.

Her program bir tamsayı dizisi almalıdır, buna benzer bir şey (geçerli giriş / çıkış stilleri için giriş / çıkış örneklerine bakın):

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

Ayrıca dizideki öğeleri artan düzende dizge olarak çıkarmalıdır:

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

Puanınız toplam başvuru sayısı olacaktır. Bir bağ varsa, en düşük bayt sayısı (kodunuzdaki en az bayt miktarı) kazanır!

Programlar için kurallar:

• Tüm başvurular bir dil sürümünde (yani Python 2 != Python 3) doğru şekilde çalışmalıdır .
• Gönderileriniz snippet'ler, işlevler veya tam programlar olabilir. Bunları karıştırmanıza ve eşleştirmenize bile izin veriyorsunuz - ancak hangisinin hangisi olduğunu söylemelisiniz ve çalışma gönderimlerine bağlantılar sağlamalısınız.
• Mümkünse, lütfen tüm çözümlere çevrimiçi bağlantılar sağlayın.
• Tüm başvurular bir dizi (veya herhangi bir karakterle sınırlandırılmış bir dize) giriş olarak almak ve sıralanan diziyi (dilinizin dizi biçiminde veya {any character}sınırlandırılmış bir dize olarak çıktılamak zorundadır).
• ASCII dışında bir karakter (veya dilinizin kod sayfası) kullanamazsınız.

Örneğin, bunlar geçerli girdiler / çıktılar:

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

Giriş için özellikler:

• Dizinin yalnızca tam sayı içerdiğini garanti edersiniz. Bununla birlikte, negatif sayılar olabilir ve sayılar süresiz olarak tekrarlanabilir.

Jöle , 10 program, 65 bayt

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

@ Lynn'in Jelly cevabıyla ilgili kaçınılmaz örtüşme var . Bogosort fikrinin kredisi ona gidiyor.

Çevrimiçi deneyin! veya benzersizliğini doğrulayın .

Onlar nasıl çalışır

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

Jöle, 8 program

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

Son program gerçekten can sıkıcı…

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.

Ben kaldırabilir Eğer œṡgelen <;0œṡ0⁸ṁjµ/de bu tuhaf bir tane var: ²SNr²ZFœ&. Yardım takdir edilir.

05AB1E , skor = 6

05AB1E , CP-1252 kodlamasını kullanır .

Program 4 için Kevin Cruijssen
sayesinde . Program 6 için ilham için Riley sayesinde .

Program 1

{               # sort          

Çevrimiçi deneyin!

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

Çevrimiçi deneyin!

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

Çevrimiçi deneyin!

4. Program

ϧ

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

Çevrimiçi deneyin!

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

Çevrimiçi deneyin!

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

Çevrimiçi deneyin!

Brachylog , skor =  4  5

Program 1 - Karışık sıralama

ṣ.↔: 1≥₎∧ | ↰

Karıştırır ve listenin tersinin artmadığını kontrol ederiz. Olmazsa, özyinelemeyle yeniden deneyin.

Program 2 - Permütasyon düzeni

p≤₁

Azalmayan ilk permütasyonun çıktısını alın.

Program 3 - Dahili

O

Sipariş.

Program 4 - Dahili

≜ᵒ

Etiketleyerek sipariş edin. Listedeki tamsayılar zaten sabit olduğundan, bu aynı şekildedir o.

Program 5 - Min yazdırma

g, ~ Kkt ug ~ kK {⌋M ve ~ cṪ↺Th [M] hẉTb↺c} ⁱ⁾

İşte doğanın bu canavarlığı için bir açıklama:

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

Bana dize kaçanları hatırlatan @ETHproductions sayesinde sayı iki katına çıktı

Metin Parçacığı 1 (21 bayt, karakter \ ,-.=>289`Facehilnorstux)

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

Snippet 2 (9117 bayt, karakter (+)[!])

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

Her iki sürümü de tarayıcınızın konsolunda test edebilirsiniz. İlk versiyon sadece bir fonksiyondur, ikinci versiyon ise parantez ve eklenen argümanı gerektiren bir snippet'tir.

Örnekler

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

Nasıl?

İlk pasaj, ilettiğiniz dizideki sort yöntemini çağırır. Varsayılan olarak, sıralama yöntemi tamsayılar (özellikle çok basamaklı negatif sayılar) için kötü olan sözlük türünü sıralar. Bu nedenle, onu iki eleman alan ve ikincisini eskisinden çıkartan bir ok işlevi biçiminde geri çağırmayı geçmemiz gerekir. Elde edilen değere bağlı olarak, iki eleman yeniden düzenlenir: 0'dan küçükse, daha aönce görünecektir b, 0'dan büyükse asonra görünecektir bve 0 ise, her iki öğe yan yana sona erecektir.

İkinci snippet, ilk snippet'in kodlanmış bir sürümünden başka bir şey değildir ve JavaScript’te object.function()eşit olması gerçeğinden yararlanır object["function"](). Ayrıca !, işlev adı için gereken karakterlerin bulunabileceği her türlü dizgeyi üretmek için boş diziler, operatörler ve sayı dökümünü kullanır . Ardından parantez, karakteri dizgideki belirli bir dizinde bulmak için bir kez daha kullanılır ve tüm bu karakterler bir araya getirilerek aşağıdaki JavaScript kodu elde edilir:

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

[]["fill"]eşittir [].fill, olan ["constructor"]bir Functionnesne. Daha sonra, ilk işlev olan (işlev çağrıldığında değerlendirilecek olan) bir dize ile çağırıyoruz, ancak argümanın yerini aldığına dikkat edin this. thisArgüman değerini ayarlamak için , bu fonksiyona yani bir fonksiyon çağırmamız gerekir ["call"]. Geleneksel JavaScript'te bunu şöyle yazacaksınız:

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

V , skor 3 , 4

Bu gerçekten eğlenceli bir mücadele oldu! Neyse ki, vim yerleşik bir "sort" işlevine sahip, aksi takdirde bu temelde imkansız olurdu. Ne yazık ki, V / vim string tabanlı olduğu için sayısal değerlere göre sıralamak için bir argümana ihtiyaç duyar. Bu yüzden arıyorum

• Sayısal değere göre sırala n,

• Onaltılık değere göre sırala xve

• Kayan nokta değerine göre sırala f

Küçük not: <esc>veya gibi bir şey yazdığımda <C-r>, bu aslında bir tek bayt. Yazdırılamayan karakterleri temsil eder ve V ne yazık ki yazdırılamayan karakterlere çok güvendiğinden, bu yöntem her şeyi kolaylaştırır. TIO bağlantıları -v, V yorumlayıcısının bunları temsil ettikleri karaktermiş gibi okumasını sağlayan bayrak içerir.

Program 1, 2 bayt

ún

Çevrimiçi deneyin!

Bu, V'ye özgü sıralama işlevini çağırır .

Program 2, 10 bayt

Qsor x
vi

Bu sadece doğrudan 'sort' olarak adlandırılır. Bununla ilgili ilginç olan tek şey, ondan yapmamız.ex , V'nin en büyük büyük büyükbabası olan 'ex' metin editörünü taklit eden tuhaf bir mod olan moddan . eski moddan çıkmak için kullanılan komutun vikısayolu visual. Bu izleyen bir yeni hat gerektirir.

Çevrimiçi deneyin!

Program 3, 14 bayt

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

Çevrimiçi deneyin!

Tamam, işte açıklamalar biraz garipleşmeye başladı. Metni oluşturabilirsek sor x, onu silebilir ve ile o anki komuta ekleyebiliriz <C-r><register-name>. Böylece büyük harf gireceğiz.

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 bayt

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

Çevrimiçi deneyin!

Ve işte açıklamalar çok garipleşmeye başladı. Geçen seferki gibi, komutu normal modda oluşturacağız, böylece farklı anahtarlar kullanabiliriz.

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

Program 1: Dahili

$

Program 2: Değerlendirilen Yerleşik

36c~

36, ASCII'nin değeridir $.

Program 3: Permütasyon Sıralama

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. Değerler

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

Bu gerçekdışı canavarlığın açıklaması:

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

Program 1

n

Çevrimiçi deneyin!

Program 2

ñ

Çevrimiçi deneyin!

Program 3

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

Çevrimiçi deneyin!

4. Program

Ov85d +110d

Çevrimiçi deneyin!

Oktav, 2 puan

İzolanlarla rekabet etmek zor, ama işte:

Birisi bunu yenerse çok etkilendim. uniquedeğerleri sıralamak için kullanılabilir, ancak kopyaları çıkaracaktır. Kopyaları yerleştirmek için parantez içine ihtiyacınız olacak ve bunlar kabarcık sıralamasında yoğun olarak kullanılıyor. Ayrıca ihtiyacınız olacak@ , kullanılmış olan .

1 numara:

Bu oldukça basittir: Değişkene atanmış isimsiz bir işlev oluşturun ans.

@sort

Bu şekilde Çağrı: ans([-5, 3, 0, -2, 100]). Tio üzerinde çalışmıyor, ancak oktav-çevrimiçi üzerinde çalışıyor .

2 numara:

Bu sadece karakterleri kullanmadan, baloncuk sıralama bir uygulamasıdır @sort. Biz nedeniyle, bu işlev yapamaz ove biz kullanamazsınız inputçünkü t. Bu yüzden sıkışıp kaldık 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,'("");']);değerlendirir: a=input("");girdi vektörümüzü girmek için kullanabiliriz. Gerisi forveya kullanmadan bubble-sıralama olduğunu mod. Bunun bir komut dosyasına kaydedilmesi ve GUI / CLI'den çağrılması gerektiğini unutmayın. Çünkü kopyala-yapıştıramazsınız input("")( çünkü kodun geri kalanını girdi olarak kullanır, bu nedenle başarısız olur).

Haskell (lambdabot), 3 işlev

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

Çok fazla ifadeden kaçınmak için lambdabot ortamını kullanıyorum import. sortİhtiyaçları bile import Data.List. lambdabot, varsayılan olarak bir demet modülü içe aktarır. Eksik yanı sıraimports kurallarımıza göre standart Haskell kodu.

Çevrimiçi deneyin! .

İşlev 1

sort

Gelen kütüphane işlevi Data.List. Burada söylenecek fazla bir şey yok.

İşlev 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

İşlev vbir insert-sorti uygular.

()Parametreleri önlemek için kalıp koruyucuları kullanıyorum . Karşılaştırma vv v|vvv:vvvv<-v=...için vv(vvv:vvvv)=....

İlk satır, fonksiyon vvboş liste oluşturmak için yardımcı bir fonksiyondur. Bununla beraber, []kelimenin tam anlamıyla boş listeler yazmak için kullanmak zorunda değilim . Daha okunabilir:

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

(==:)bir listeyi bir eleman ekler, böylece sonuçta elde edilen liste hala sıralanır. Daha okunabilir:

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

(=:)azalır. Daha okunabilir:

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

Ve nihayet vşunlarla başlayarak girdi listesini azaltır []:

sort list = [] `reduce` list

İşlev 3

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

sortFonksiyon 1 liste yürüyen fonksiyonları (en yapar fold, scan, untilkullanılamaz). =İşlev 2'de kullanılan özyineleme ihtiyaçları . Geriye kalan tek seçenek fixpoint birleştiriciyi kullanmak fix. İle başladım

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

Bu bir seçim sıralama. (Ben lambdas kullanamaz noktaya içermeyen doğru çevirerek \f x ->...yüzünden, -hangi Fonksiyonu 2'de desen gurads tarafından kullanılır) verir:

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

Singleton listelerini bir değerden çıkarmak returnyasaktır (bunun için de aynıdır pure), bu yüzden kendi işlevimi oluşturmam gerekiyor: \x -> map (\y -> x+0*y) [1]veya puansız flip map[1].(.(0*)).(+). Değiştirme returnverimleri

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

MATL , 3 program

Program 1

S

Bu sadece yerleşik girişi ve gösterimi ile yerleşik işlevi kullanır.

MATL çevrimiçi olarak deneyin .

Program 2

`GGnZrd0<a}3M

Bu, sonucun ardışık tüm farklılıkları negatif olmayana kadar girdilerin rasgele permütasyonlarını oluşturmaya devam eder (bu, @cz tarafından belirtildiği gibi, bogosort'tur ). Süresi belirli olmayan ve ortalama artışlar çok hızlı girdi büyüklüğü (yani 𝒪 (ile n! A boyutu-için) n farklı tüm girişlere dizisi).

MATL Online'da deneyin .

Program 3

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

Bu, dizinin minimumunu hesaplayan, bu değere eşit olan tüm elemanları silen ve gerisi ile yapılan işlemleri yapan bir döngüdür. Bu, giriş boyutu kadar çok yapılır. Girdideki girişlerin tümü farklı değilse, yinelemelerin bazıları işe yaramayacak (ancak zararsız), çünkü dizi zaten boşaltılmış olacak.

MATL çevrimiçi olarak deneyin .

Pip , 4 program

Program 1 - yerleşik

Pasaj; Listeyi varsayar x.

SNx

( SNSayısal Sırala)

Program 2 - filtre izinleri

Pasaj; Listeyi varsayar y. Yaklaşık 7 maddeden daha uzun girişler için çok yavaş.

Y$<=_FIPMyPOy

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

Program 3 - eval

Pasaj; Listeyi varsayar 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

Anonim işlev; argüman (gibi liste ile çağrı ({...} [1 2])veya 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

Çevrimiçi deneyin!

Bu (örn.) PowerShell'in bir REPL eşdeğerinde çalışan bir snippet'idir. TIO bağlantısı kullanımı gösterir. sortİçin bir diğer adıdır Sort-Objectcmdlet'indeki.

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

Çevrimiçi deneyin!

PowerShell komutları büyük / küçük harf duyarsızdır, bu nedenle sortbiri ve SORTdiğeri için kullanabiliriz . Bu bir girdi dizisini alır, yerinde sıralar ve sonra onu çıkarır.

Ruby, 2 program

İlk - basit:

->t{t.sort}

İkincisi - zor kısım:

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

J

Birinci program: 3 bayt

/:~

/:~ 3,1,2,1çıktılarda olduğu gibi1 1 2 3

Çevrimiçi deneyin!

NOT J'de, negatif sayılar önce _ değil - böylelikle 4, _10,56, _333 vb. Komutları deneyebilirsiniz.

Program iki: 5 bayt

|.\:~

PHP 7, 2 program

Her iki program daha fazla golf oynayabilir.

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

Kabarcık sıralama. Yerleşik gotodöngüler gerektiren bir döngü oluşturmak için kullanır() .

Program 2, 155 bayt, karakter #%'(),-67ACEFINORTUYZ^_{|}~

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

IF(...){}kullanımından kaçınır ;. Ana kod, $önceki programda zaten kullanıldığından XOR ile kodlanmıştır . Kod:

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