Tôi cần phải ngừng suy nghĩ về tên trừng phạt

Nhiệm vụ của bạn là tạo ra nhiều đoạn mã (chương trình có sẵn đầu vào và đầu ra), các hàm hoặc chương trình đầy đủ có thể sắp xếp bất kỳ phiên bản nào của mảng số nguyên của ngôn ngữ của bạn theo thứ tự tăng dần, nhưng đối với mỗi chương trình, bạn chỉ được phép để sử dụng các ký tự trong ASCII (hoặc trang mã ngôn ngữ của bạn, nếu nó được chỉ định trực tiếp là không phải ASCII) chưa được sử dụng trong các chương trình trước đó.

Đây là một câu trả lời mẫu (các chương trình riêng biệt được phân tách bằng dòng mới):

Derp
ASdFGHJKLAAA
qwEEERtyRty

Trong này (ngôn ngữ hư cấu), câu trả lời đầu tiên của tôi là Derp, mà sử dụng hết D, e, rvà p. Trong chương trình thứ hai, tôi không được phép sử dụng lại nhân vật đó, nhưng tôi có thể sử dụng lại bao nhiêu nhân vật tôi muốn. Tương tự với chương trình thứ ba, v.v.

Mỗi chương trình phải lấy một mảng các số nguyên, vì vậy một cái gì đó như thế này (xem ví dụ đầu vào / đầu ra cho các kiểu đầu vào / đầu ra hợp lệ):

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

Và nó phải xuất các mục trong mảng dưới dạng một mảng, theo thứ tự tăng dần:

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

Điểm của bạn sẽ là tổng số bài dự thi. Nếu có một ràng buộc, số byte thấp nhất (số lượng byte ít nhất trong mã của bạn) sẽ thắng!

Quy tắc cho các chương trình:

• Tất cả các bài nộp phải chạy chính xác trong một phiên bản ngôn ngữ (vì vậy Python 2 != Python 3).
• Nội dung gửi của bạn có thể là đoạn trích, chức năng hoặc chương trình đầy đủ. Thậm chí, bạn còn được phép trộn và kết hợp chúng - tuy nhiên, bạn phải nói đó là cái gì và cung cấp liên kết đến bài nộp.
• Vui lòng cung cấp các liên kết trực tuyến cho tất cả các giải pháp, nếu có thể.
• Tất cả các bài nộp phải lấy một mảng (hoặc một chuỗi được phân tách bằng bất kỳ ký tự nào) làm đầu vào và xuất ra mảng được sắp xếp (ở dạng mảng trong ngôn ngữ của bạn hoặc dưới dạng một {any character}chuỗi được phân cách.
• Bạn không được phép sử dụng bất kỳ ký tự nào ngoài ASCII (hoặc trang mã ngôn ngữ của bạn).

Ví dụ: đây là những đầu vào / đầu ra hợp lệ:

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

Thông số kỹ thuật cho đầu vào:

• Bạn được đảm bảo rằng mảng chỉ chứa số nguyên. Tuy nhiên, có thể có số âm và số có thể lặp lại vô thời hạn.

Jelly , 10 chương trình, 65 byte

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

Có một số trùng lặp không thể tránh khỏi với câu trả lời @ Lynn's Jelly . Tín dụng cho ý tưởng bogosort đi đến cô ấy.

Hãy thử trực tuyến! hoặc xác minh tính duy nhất .

Chúng hoạt động như thế nào

Ṣ               Main link. Argument: A (array)

Ṣ               Sort A.

¹Þ              Main link. Argument: A (array)

¹Þ              Sort A, using the identity function as the key.

Ụị              Main link. Argument: A (array)

Ụ               Grade up; yield all indices of A, sorted by their corr. values.
 ị              Index into A.

Œ!Ṃ             Main link. Argument: A (array)

Œ!              Yield all permutations of A.
  Ṃ             Minimum; yield the lexicographically smallest permutation.

7778Ọv          Main link. Argument: A (array)

7778Ọ           Unordinal; yield chr(7778) = 'Ṣ'.
     v          Evaluate with argument A.

Ẋ>2\S$¿         Main link. Argument: A (array)

      ¿         While the condition it truthy, execute the body.
 >2\S$            Condition:
     $              Combine the two links to the left into a monadic chain.
 >2\                  Perform pairwise greater-than comparison.
    S                 Sum; add the results.
                    This returns 0 iff A contains an unsorted pair of integers.
Ẋ                 Body: Shuffle A.

ĠFḣṪ¥@€         Main link. Argument: A (array)

Ġ               Group the indices of A by their sorted values.
 F              Flatten the result.
      €         Apply the link to the left to each index in the previous result, 
                calling it with the index as left argument and A as the right one.
    ¥@            Combine the two links to the left into a dyadic chain and swap
                  its arguments, so A is left one and the index i is the right one.
  ḣ               Head; take the first i elements of A.
   Ṫ              Tail; yield the last of the first i, i.e., the i-th element of A.

~Ṁ~rṀxLœ&       Main link. Argument: A (array)

~               Take the bitwise NOT of all integers in A.
 Ṁ              Take the maximum.
  ~             Take the bitwise NOT of the maximum, yielding the minimum of A.
    Ṁ           Yield the maximum of A.
   r            Range; yield [min(A), ... max(A)].
      L         Yield the length of A.
     x          Repeat each integer in the range len(A) times.
       œ&       Take the multiset-intersection of the result and A.

C»/ð+ÆNPÆfÆC_ḷ  Main link. Argument: A (array)

C               Complement; map (x -> 1-x) over A.
 »/             Reduce by dyadic maximum, yielding 1-min(A).
   ð            Begin a new, dyadic chain. Arguments: 1-min(A), A
    +           Add 1-min(A) to all elements of A, making them strictly positive.
     ÆN         For each element n of the result, yield the n-th prime number.
       P        Take the product.
        Æf      Factorize the product into prime numbers, with repetition.
          ÆC    Prime count; count the number of primes less than or equal to p,
                for each prime p in the resulting factorization.
             ḷ  Yield the left argument, 1-min(A).
            _   Subtract 1-min(A) from each prime count in the result to the left.

<þḅ1‘WiþJḄ³ṫZḢ  Main link. Argument: A (array)

<þ              Construct the less-than matrix of all pairs of elements in A.
  ḅ1            Convert each row from base 1 to integer (sum each).
    ‘           Increment. The integer at index i now counts how many elements
                of A are less than or equal to the i-th.
     W          Wrap the resulting 1D array into an array.
        J       Yield the indices of A, i.e., [1, ..., len(A)].
      iþ        Construct the index table; for each array T in the singleton array
                to the left and index j to the right, find the index of j in T.
                This yields an array of singleton arrays.
         Ḅ      Unbinary; convert each singleton from base 2 to integer, mapping
                ([x]-> x) over the array.
          ³     Yield A.
           ṫ    Tail; for each integer i in the result of `Ḅ`, create a copy of A
                without its first i-1 elements.
            Z   Zip/transpose. The first column becomes the first row.
             Ḣ  Head; yield the first row.

Jelly, 8 chương trình

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

Chương trình cuối cùng thật sự rất khó chịu

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.

Nếu tôi có thể loại bỏ œṡtừ <;0œṡ0⁸ṁjµ/, thì cũng có cái lạ này : ²SNr²ZFœ&. Giúp đỡ được đánh giá cao.

05AB1E , điểm = 6

05AB1E sử dụng mã hóa CP-1252 .

Cảm ơn Kevin Cruijssen cho chương trình 4.
Cảm ơn Riley đã truyền cảm hứng cho chương trình 6.

Chương trình 1

{               # sort          

Hãy thử trực tuyến!

Chương trình 2

`[Ž.^]¯

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

Hãy thử trực tuyến!

Chương trình 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

Hãy thử trực tuyến!

Chương trình 4

ϧ

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

Hãy thử trực tuyến!

Chương trình 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

Hãy thử trực tuyến!

Chương trình 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

Hãy thử trực tuyến!

Brachylog , điểm =  4  5

Chương trình 1 - Sắp xếp ngẫu nhiên

ṣ.↔: 1≥₎∧ |

Chúng tôi xáo trộn và kiểm tra xem mặt trái của danh sách là không tăng. Nếu không chúng ta thử lại đệ quy.

Chương trình 2 - Sắp xếp hoán vị

p≤₁

Xuất ra hoán vị đầu tiên không giảm.

Chương trình 3 - Tích hợp

o

Gọi món.

Chương trình 4 - Tích hợp sẵn

≜ᵒ

Đặt hàng bằng cách dán nhãn. Vì các số nguyên trong danh sách đã được cố định, điều này không giống như o.

Chương trình 5 - In tối thiểu

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

Đây là một lời giải thích cho sự quái dị này của Tự nhiên:

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, điểm số 1 2

Nhân đôi số điểm nhờ @ETHproductions, người đã nhắc nhở tôi về việc thoát chuỗi

Đoạn 1 (21 byte, ký tự \ ,-.=>289`Facehilnorstux)

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

Đoạn 2 (9117 byte, ký tự (+)[!])

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

Bạn có thể kiểm tra cả hai phiên bản trong bảng điều khiển của trình duyệt. Phiên bản đầu tiên chỉ là một chức năng, phiên bản thứ hai là một đoạn trích cần thêm dấu ngoặc đơn và đối số được thêm vào.

Ví dụ

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

Làm sao?

Đoạn mã đầu tiên gọi phương thức sắp xếp trên mảng bạn truyền vào nó. Theo mặc định, phương pháp sắp xếp sắp xếp từ điển, rất tệ cho các số nguyên (đặc biệt là các số âm nhiều chữ số). Như vậy, chúng ta phải truyền cho nó một hàm gọi lại dưới dạng hàm mũi tên có hai phần tử và trừ phần tử sau từ phần tử trước. Tùy thuộc vào giá trị kết quả, hai phần tử được sắp xếp lại: nếu nó nhỏ hơn 0, asẽ xuất hiện trước b, nếu nó lớn hơn 0, asẽ xuất hiện saub và nếu là 0, cả hai phần tử sẽ nằm cạnh nhau.

Đoạn mã thứ hai không có gì khác hơn là một phiên bản được mã hóa của đoạn mã đầu tiên và nó lợi dụng thực tế là trong JavaScript, object.function()bằng object["function"](). Nó cũng sử dụng các mảng trống, !toán tử và truyền số để tạo ra tất cả các loại chuỗi, trong đó có thể tìm thấy các ký tự cần thiết cho tên hàm. Sau đó, dấu ngoặc được sử dụng một lần nữa để lấy ký tự ở một chỉ mục nhất định trong chuỗi và tất cả các ký tự đó được nối với nhau, dẫn đến mã JavaScript sau:

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

[]["fill"]bằng [].fill, mà ["constructor"]là Functionđối tượng. Sau đó, chúng ta gọi đó bằng một chuỗi (sẽ được đánh giá khi hàm được gọi), đây là hàm đầu tiên, nhưng lưu ý rằng đối số đã được thay thế bởi this. Để đặt giá trị của thisđối số, chúng ta cần gọi một hàm trên hàm này, cụ thể là ["call"]. Trong JavaScript thông thường, bạn sẽ viết như sau:

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

V , điểm 3 , 4

Đây là một thử thách thực sự thú vị! Rất may, vim có chức năng "sắp xếp" dựng sẵn, nếu không thì điều này về cơ bản là không thể. Thật không may, vì V / vim là chuỗi dựa trên nên nó cần một đối số để sắp xếp theo các giá trị số. Vì vậy, tôi đang gọi

• Sắp xếp theo giá trị số n,

• Sắp xếp theo giá trị thập lục phân xvà

• Sắp xếp theo giá trị dấu phẩy động f

Lưu ý nhỏ: Khi tôi viết một cái gì đó như <esc>hoặc <C-r>, đây thực sự là một byte đơn. Nó đại diện cho các ký tự không thể in được và vì V không may phụ thuộc rất nhiều vào các ký tự không thể in được, nên phương thức này giúp mọi thứ dễ dàng hơn. Các liên kết TIO có -vcờ, làm cho trình thông dịch V đọc chúng như thể chúng là các ký tự mà chúng đại diện.

Chương trình 1, 2 byte

ún

Hãy thử trực tuyến!

Điều này đòi hỏi các cụ V loại .

Chương trình 2, 10 byte

Qsor x
vi

Điều này chỉ cần gọi 'sắp xếp' trực tiếp. Điều thú vị duy nhất về điều này là chúng tôi thực hiện nó từ exchế độ, đó là một chế độ kỳ lạ mô phỏng trình soạn thảo văn bản 'ex', ông cố của V. vilà một phím tắt cho visual, lệnh được sử dụng để rời khỏi chế độ ex. Điều này đòi hỏi một dòng mới.

Hãy thử trực tuyến!

Chương trình 3, 14 byte

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

Hãy thử trực tuyến!

Được rồi, đây là nơi giải thích bắt đầu có một chút kỳ lạ. Nếu chúng ta có thể xây dựng văn bản sor x, chúng ta có thể xóa nó và chèn nó vào lệnh hiện tại với <C-r><register-name>. Vì vậy, chúng tôi sẽ nhập chữ hoa.

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

Chương trình 4, 19 byte

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

Hãy thử trực tuyến!

Và đây là nơi những lời giải thích bắt đầu trở nên rất kỳ lạ. Tương tự như lần trước, chúng tôi sẽ xây dựng lệnh ở chế độ bình thường để chúng tôi có thể sử dụng các phím khác nhau.

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, điểm 4

Chương trình 1: Tích hợp sẵn

$

Chương trình 2: Được tích hợp sẵn

36c~

36 là giá trị ASCII của $.

Chương trình 3: Sắp xếp hoán vị

e!0=

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

Chương trình 4: Giá trị tối thiểu

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

Giải thích về sự quái dị kinh khủng này:

[             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 , điểm = 4

Chương trình 1

n

Hãy thử trực tuyến!

Chương trình 2

ñ

Hãy thử trực tuyến!

Chương trình 3

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

Hãy thử trực tuyến!

Chương trình 4

Ov85d +110d

Hãy thử trực tuyến!

Octave, 2 điểm

Thật khó để cạnh tranh với esolang, nhưng ở đây đi:

Tôi rất ấn tượng nếu ai đó đánh bại điều này. uniquecó thể được sử dụng để sắp xếp các giá trị, nhưng nó sẽ loại bỏ các bản sao. Để chèn các bản sao, bạn sẽ cần dấu ngoặc đơn và chúng được sử dụng nhiều trong sắp xếp bong bóng. Bạn cũng cần@ , được sử dụng quá.

Số 1:

Điều này khá đơn giản: Tạo một hàm ẩn danh, được gán cho biến ans.

@sort

Gọi nó theo cách này : ans([-5, 3, 0, -2, 100]). Nó không hoạt động trên tio, nhưng nó hoạt động trên quãng tám trực tuyến .

Số 2:

Đây chỉ đơn giản là một triển khai sắp xếp bong bóng, mà không sử dụng các ký tự @sort. Chúng ta không thể biến nó thành một chức năng, vì o, và chúng ta không thể sử dụng inputvì t. Do đó, chúng tôi bị mắc kẹt với 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,'("");']);ước tính để : a=input("");, mà chúng ta có thể sử dụng để nhập vectơ đầu vào của mình. Phần còn lại là phân loại bong bóng mà không sử dụng forhoặc mod. Lưu ý rằng điều này phải được lưu trong một tập lệnh và được gọi từ GUI / CLI. Bạn không thể sao chép-dán nó, bởi vì input("")(nó sẽ sử dụng phần còn lại của mã làm đầu vào, do đó thất bại thảm hại).

Haskell (lambdabot), 3 chức năng

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

Tôi đang sử dụng môi trường lambdabot để tránh nhiều importtuyên bố. Ngay cả sortnhu cầu import Data.List. lambdabot nhập một loạt các mô-đun theo mặc định. Ngoài việc mất tíchimports , đó là mã Haskell tiêu chuẩn theo quy tắc của chúng tôi.

Hãy thử trực tuyến! .

Chức năng 1

sort

Các chức năng thư viện từ Data.List. Không có gì nhiều để nói ở đây.

Chức năng 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

Hàm vthực hiện một kiểu sắp xếp.

Tôi sử dụng mô hình bảo vệ để tránh ()các tham số. So sánh vv v|vvv:vvvv<-v=...với vv(vvv:vvvv)=....

Dòng đầu tiên, hàm vvlà hàm trợ giúp để tạo danh sách trống. Với nó, tôi không phải sử dụng []để viết danh sách trống. Dễ đọc hơn:

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

(==:)được chèn, chèn một phần tử vào danh sách được sắp xếp, để danh sách kết quả vẫn được sắp xếp. Dễ đọc hơn:

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

(=:)là giảm. Dễ đọc hơn:

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

Và cuối cùng vlàm giảm danh sách đầu vào nhìn chằm chằm vào []:

sort list = [] `reduce` list

Chức năng 3

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

sorttừ Function 1 làm cho hầu hết các chức năng danh sách-đi bộ ( fold, scan, until) không có. Nhu cầu đệ quy =được sử dụng trong Hàm 2. Tùy chọn duy nhất còn lại là sử dụng bộ kết hợp fixpoint fix. Tôi đã bắt đầu với

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

đó là một sự lựa chọn Biến nó thành không có điểm (Tôi không thể sử dụng lambdas \f x ->..., vì -cái được sử dụng bởi các gurads mẫu trong Hàm 2) mang lại:

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

Việc lập danh sách đơn lẻ ra khỏi một giá trị returnbị cấm (tương tự pure), vì vậy tôi phải xây dựng chức năng của riêng mình: \x -> map (\y -> x+0*y) [1]hoặc không có điểm flip map[1].(.(0*)).(+). Thay thế returnsản lượng

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

MATL , 3 chương trình

Chương trình 1

S

Điều này chỉ sử dụng chức năng dựng sẵn, với đầu vào và hiển thị ẩn.

Hãy thử nó tại MATL trực tuyến .

Chương trình 2

`GGnZrd0<a}3M

Điều này tiếp tục tạo ra các hoán vị ngẫu nhiên của các đầu vào cho đến khi tất cả các khác biệt liên tiếp của kết quả là không âm (đây là bogosort , như đã lưu ý bởi @cz ). Thời gian chạy là không xác định và trung bình của nó tăng rất nhanh với kích thước đầu vào (cụ thể là, ( n! ) Cho một kích thước- n mảng với tất cả các mục khác nhau).

Dùng thử tại MATL Online .

Chương trình 3

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

Đây là một vòng lặp tính toán tối thiểu của mảng, loại bỏ tất cả các phần tử bằng với giá trị đó và các thủ tục với phần còn lại. Điều này được thực hiện nhiều lần như kích thước đầu vào. Nếu không phải tất cả các mục trong đầu vào là khác nhau, một số lần lặp sẽ vô dụng (nhưng vô hại), vì mảng sẽ bị xóa.

Hãy thử nó tại MATL trực tuyến .

Pip , 4 chương trình

Chương trình 1 - dựng sẵn

Đoạn trích; giả định danh sách trong x.

SNx

( SNđối với Số sắp xếp)

Chương trình 2 - hoán vị bộ lọc

Đoạn trích; giả định danh sách trong y. Rất chậm cho đầu vào dài hơn khoảng 7 mục.

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

Chương trình 3 - eval

Đoạn trích; giả định danh sách trong 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

Chương trình 4 - Hợp nhất

Chức năng ẩn danh; gọi với danh sách là đối số (như ({...} [1 2])hoặc 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}

Ung dung:

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

Hãy thử trực tuyến!

Đây là đoạn mã chạy trong (ví dụ) tương đương với REPL của PowerShell. Liên kết TIO cho thấy việc sử dụng. Đây sortlà một bí danh cho Sort-Objectlệnh ghép ngắn.

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

Hãy thử trực tuyến!

Các lệnh PowerShell không phân biệt chữ hoa chữ thường, vì vậy chúng ta có thể sử dụng sortcho cái này và SORTcái kia. Điều này có một mảng đầu vào, sắp xếp nó tại chỗ, và sau đó đầu ra nó.

Ruby, 2 chương trình

Đầu tiên - đơn giản:

->t{t.sort}

Thứ hai - phần khó khăn:

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

J

Chương trình một: 3 byte

/:~

như trong /:~ 3,1,2,1đầu ra1 1 2 3

Hãy thử trực tuyến!

LƯU Ý trong J, các số âm được đặt trước _ không - vì vậy bạn có thể thử 4, _10,56, _333, v.v.

Chương trình hai: 5 byte

|.\:~

Chương trình PHP 7, 2

Cả hai chương trình có thể được chơi golf nhiều hơn.

Chương trình 1, 254 byte, ký tự ! "$&+.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;

Sắp xếp bong bóng. Sử dụng gotođể tạo một vòng lặp như các vòng lặp tích hợp yêu cầu ().

Chương trình 2, 155 byte, ký tự #%'(),-67ACEFINORTUYZ^_{|}~

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

IF(...){}tránh sử dụng ;. Mã chính được mã hóa bằng XOR, vì $đã được sử dụng trong chương trình trước. Mật mã:

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