ฉันต้องหยุดคิดถึงชื่อที่อ่อนแอ

งานของคุณคือสร้างสนิปเพตจำนวนมาก (โปรแกรมที่มีอินพุทและเอาท์พุทในตัว), ฟังก์ชั่นหรือโปรแกรมเต็มรูปแบบให้มากที่สุดเท่าที่จะเป็นไปได้ เพื่อใช้อักขระใน ASCII (หรือหน้ารหัสภาษาของคุณหากระบุโดยตรงว่าไม่ใช่ ASCII) ซึ่งไม่ได้ใช้ในโปรแกรมก่อนหน้า

นี่คือตัวอย่างคำตอบ (แยกโปรแกรมโดยคั่นด้วยบรรทัดใหม่):

Derp
ASdFGHJKLAAA
qwEEERtyRty

ในการนี้ (ภาษาสมมุติ) คำตอบแรกของฉันคือDerpซึ่งใช้ขึ้นD, e, และr pในโปรแกรมที่สองฉันไม่ได้รับอนุญาตให้ใช้อักขระเหล่านั้นอีกครั้ง แต่ฉันสามารถนำอักขระที่ฉันต้องการกลับมาใช้ได้อีกครั้ง เช่นเดียวกันกับโปรแกรมที่สามเป็นต้น

แต่ละโปรแกรมจะต้องใช้อาร์เรย์ของจำนวนเต็มดังนั้นสิ่งนี้ (ดูตัวอย่างอินพุต / เอาต์พุตสำหรับรูปแบบอินพุต / เอาต์พุตที่ถูกต้อง):

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

และมันจะต้องเอาท์พุทไอเท็มในอาเรย์เป็นลำดับตามลำดับจากน้อยไปมาก:

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

คะแนนของคุณจะเป็นจำนวนรวมของการส่ง หากมีการเสมอจำนวน bytecount ต่ำสุด (จำนวนไบต์น้อยที่สุดในรหัสของคุณ) ชนะ!

กฎสำหรับโปรแกรม:

• การส่งทั้งหมดจะต้องทำงานอย่างถูกต้องในหนึ่งภาษา (ดังนั้นPython 2 != Python 3)
• การส่งของคุณอาจเป็นตัวอย่างฟังก์ชั่นหรือโปรแกรมเต็มรูปแบบ คุณยังได้รับอนุญาตให้มิกซ์และจับคู่พวกเขา - อย่างไรก็ตามคุณต้องพูดว่าอันไหนและให้ลิงค์ไปยังการส่งผลงาน
• โปรดระบุลิงก์ออนไลน์ไปยังโซลูชันทั้งหมดถ้าเป็นไปได้
• การส่งทั้งหมดจะต้องใช้อาเรย์ (หรือสตริงที่คั่นด้วยอักขระใด ๆ ) เป็นอินพุทและส่งออกอาเรย์ที่จัดเรียง (ในรูปแบบอาเรย์ของภาษาของคุณหรือเป็น{any character}-delimited สตริง
• คุณไม่ได้รับอนุญาตให้ใช้อักขระใด ๆ นอก ASCII (หรือหน้ารหัสภาษาของคุณ)

ตัวอย่างเช่นนี่เป็นอินพุต / เอาต์พุตที่ถูกต้อง:

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

ข้อมูลจำเพาะสำหรับอินพุต:

• คุณรับประกันได้ว่าอาร์เรย์มีจำนวนเต็มเท่านั้น อย่างไรก็ตามอาจมีตัวเลขติดลบและตัวเลขอาจซ้ำไปเรื่อย ๆ

เยลลี่ , 10 โปรแกรม, 65 ไบต์

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

มีบางอย่างที่หลีกเลี่ยงไม่ได้ทับซ้อนกับ@ ลินน์คำตอบของวุ้น เครดิตสำหรับไอเดียโบกี้ไปที่เธอ

ลองออนไลน์! หรือตรวจสอบเอกลักษณ์

พวกเขาทำงานอย่างไร

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

เยลลี่ 8 โปรแกรม

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

โปรแกรมสุดท้ายน่ารำคาญจริงๆ ...

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.

ถ้าฉันสามารถลบœṡจากนอกจากนี้ยังมีคนนี้แปลก:<;0œṡ0⁸ṁjµ/ ²SNr²ZFœ&ความช่วยเหลือชื่นชม

05AB1Eคะแนน = 6

05AB1Eใช้การเข้ารหัสCP-1252

ขอบคุณKevin Cruijssenสำหรับโปรแกรม 4
ขอบคุณRileyสำหรับแรงบันดาลใจในการเขียนโปรแกรม 6

โปรแกรม 1

{               # sort          

ลองออนไลน์!

โปรแกรม 2

`[Ž.^]¯

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

ลองออนไลน์!

โปรแกรม 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

ลองออนไลน์!

โปรแกรม 4

ϧ

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

ลองออนไลน์!

โปรแกรม 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

ลองออนไลน์!

โปรแกรม 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

ลองออนไลน์!

Brachylogคะแนน =  4  5

โปรแกรม 1 - การเรียงแบบสุ่ม

ṣ.↔: 1≥₎∧ | ↰

เราสลับและตรวจสอบว่าการย้อนกลับของรายการไม่เพิ่มขึ้น ถ้าไม่ใช่เราลองใหม่ซ้ำ

โปรแกรม 2 - เรียงลำดับการเรียงสับเปลี่ยน

p≤₁

เอาท์พุทการเปลี่ยนแปลงครั้งแรกที่ไม่ลดลง

โปรแกรม 3 - ในตัว

โอ

ใบสั่ง.

โปรแกรม 4 - ในตัว

≜ᵒ

สั่งซื้อโดยการติดฉลาก เนื่องจากจำนวนเต็มในรายการได้รับการแก้ไขแล้วจึงทำเช่นนี้oนี้

โปรแกรม 5 - การพิมพ์ขั้นต่ำ

กรัม ~ KKT ~ ~ LG KK {⌋M & ~ cṪ↺Th [M] hẉTb↺c} ⁱ⁾

นี่คือคำอธิบายสำหรับความมหัศจรรย์ของธรรมชาติ:

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, คะแนน1 2

เพิ่มคะแนนเป็นสองเท่าด้วย @ETHproductions ที่ทำให้ฉันนึกถึงการหลบหนีของสตริง

ตัวอย่าง 1 (21 ไบต์อักขระ\ ,-.=>289`Facehilnorstux)

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

ตัวอย่าง 2 (9117 ไบต์ตัวอักษร(+)[!])

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

คุณสามารถทดสอบทั้งสองเวอร์ชันได้ในคอนโซลของเบราว์เซอร์ รุ่นแรกเป็นเพียงฟังก์ชั่นรุ่นที่สองเป็นตัวอย่างที่ต้องการวงเล็บและการเพิ่มอาร์กิวเมนต์

ตัวอย่าง

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

อย่างไร?

ตัวอย่างแรกเรียกใช้วิธีการเรียงลำดับในอาร์เรย์ที่คุณส่งผ่าน โดยค่าเริ่มต้นวิธีการเรียงลำดับเรียงตามพจนานุกรมซึ่งไม่ดีสำหรับจำนวนเต็ม (โดยเฉพาะอย่างยิ่งตัวเลขลบหลายหลัก) ดังนั้นเราจะต้องผ่านการเรียกกลับในรูปแบบของฟังก์ชั่นลูกศรที่ใช้สององค์ประกอบและลบหลังจากอดีต องค์ประกอบทั้งสองจะถูกจัดเรียงใหม่: หากมีขนาดเล็กกว่า 0 aจะปรากฏก่อนหน้าbนี้หากมีขนาดใหญ่กว่า 0 aจะปรากฏขึ้นหลังจากbนั้นและถ้าเป็น 0 องค์ประกอบทั้งสองจะสิ้นสุดติดกัน

ข้อมูลที่สองคืออะไรมากกว่ารุ่นเข้ารหัสของข้อมูลเป็นครั้งแรกและจะใช้ประโยชน์จากความจริงที่ว่าใน JavaScript, เท่ากับobject.function() object["function"]()นอกจากนี้ยังใช้อาร์เรย์ที่ว่างเปล่า!ตัวดำเนินการและการส่งหมายเลขเพื่อสร้างสตริงทุกชนิดซึ่งสามารถค้นหาอักขระที่จำเป็นสำหรับชื่อฟังก์ชันได้ จากนั้นวงเล็บจะถูกใช้อีกครั้งเพื่อรับอักขระที่ดัชนีที่แน่นอนในสตริงและอักขระทั้งหมดจะถูกต่อกันเป็นผลลัพธ์ในโค้ด JavaScript ต่อไปนี้:

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

[]["fill"]เท่ากับ[].fillซึ่ง["constructor"]เป็นFunctionวัตถุ แล้วเราเรียกว่ามีสตริง (ซึ่งก็คือการได้รับการประเมินเมื่อฟังก์ชั่นที่เรียกว่า) ซึ่งเป็นฟังก์ชั่นแรก thisแต่แจ้งให้ทราบว่าการโต้แย้งได้ถูกแทนที่ด้วย ในการตั้งค่าของอาร์กิวเมนต์ที่เราจำเป็นต้องเรียกฟังก์ชั่นในการทำงานนี้คือthis ["call"]ในจาวาสคริปต์ทั่วไปคุณจะเขียนสิ่งนี้เป็น:

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

V , คะแนน3 , 4

นี่เป็นความท้าทายที่สนุกจริงๆ! โชคดีที่เสียงเรียกเข้ามีฟังก์ชัน builtin "sort" มิฉะนั้นจะเป็นไปไม่ได้ น่าเสียดายที่มันเป็นเพราะ V / vim เป็นแบบสตริงจึงจำเป็นต้องมีอาร์กิวเมนต์เพื่อจัดเรียงตามค่าตัวเลข ดังนั้นฉันจึงโทร

• เรียงลำดับตามค่าตัวเลขn,

• เรียงตามค่าเลขฐานสิบหกxและ

• เรียงตามค่าทศนิยม f

ข้อสังเกตเล็ก ๆ น้อย ๆ : เมื่อฉันเขียนบางสิ่งเช่น<esc>หรือ<C-r>นี่เป็นไบต์เดียวจริงๆ มันเป็นตัวแทนของตัวอักษรที่ไม่สามารถพิมพ์ได้และเนื่องจาก V นั้นอาศัยตัวอักษรที่ไม่สามารถพิมพ์ได้อย่างน่าเสียดายวิธีนี้ทำให้ทุกอย่างง่ายขึ้น ลิงก์ TIO มีการ-vตั้งค่าสถานะซึ่งทำให้ล่าม V อ่านสิ่งเหล่านี้ราวกับว่าพวกเขาเป็นตัวละครที่พวกเขาเป็นตัวแทน

โปรแกรม 1, 2 ไบต์

ún

ลองออนไลน์!

สิ่งนี้เรียกฟังก์ชันการเรียงลำดับเฉพาะ V

โปรแกรม 2, 10 ไบต์

Qsor x
vi

เพียงแค่เรียก 'เรียงลำดับ' โดยตรง สิ่งที่น่าสนใจเพียงอย่างเดียวเกี่ยวกับเรื่องนี้คือเราทำจากexโหมดซึ่งเป็นโหมดแปลก ๆ ที่เลียนแบบตัวแก้ไขข้อความ 'อดีต' ซึ่งเป็นปู่ทวดของวี viเป็นทางลัดสำหรับvisualคำสั่งที่ใช้เพื่อออกจากโหมด ex สิ่งนี้ต้องการการขึ้นบรรทัดใหม่

ลองออนไลน์!

โปรแกรม 3, 14 ไบต์

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

ลองออนไลน์!

เอาล่ะนี่คือที่คำอธิบายเริ่มต้นที่จะได้รับเพียงเล็กน้อยแปลก ถ้าเราสามารถสร้างขึ้นข้อความเราสามารถลบและใส่ลงในคำสั่งปัจจุบันด้วยsor x <C-r><register-name>ดังนั้นเราจะใส่มันเป็นตัวพิมพ์ใหญ่

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

โปรแกรม 4, 19 ไบต์

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

ลองออนไลน์!

และนี่คือที่ที่คำอธิบายเริ่มแปลกมาก คล้ายกับครั้งที่แล้วเราจะสร้างคำสั่งในโหมดปกติเพื่อให้เราสามารถใช้ปุ่มที่แตกต่างกัน

YP                          " Create a copy of this line up one line. This is mostly so that we have a line to work with without messing with the numbers.
  C                         " Delete this line and enter insert mode
   <C-v>58                  " Insert ASCII '58' (which is ':')
          fbe a             " Insert 'fbe a'
               <C-c>        " Pretty much equivalent to <esc>
                    g?_     " ROT13 this line. Now the line is ':sor n'
                       dd   " Delete this whole line
                         @1 " And run it as if typed

CJam คะแนน 4

โปรแกรม 1: ในตัว

$

โปรแกรมที่ 2: Eval'ed ในตัว

36c~

36 เป็นค่า ASCII $ของ

โปรแกรม 3: เรียงลำดับการเรียงสับเปลี่ยน

e!0=

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

โปรแกรม 4: ค่าต่ำสุด

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

คำอธิบายของสิ่งประหลาดที่น่าพิศวง:

[             e# Begin working in an array
{             e# Do this block while the TOS is truthy (doesn't pop)
 __           e#  Duplicate TOS twice (the array)
 )\;          e#  Take the last element of the array
 \            e#  Swap top two elements, bringing the other array copy to the top
 {            e#  Reduce the array using this block
  _@_@<{\}&;  e#   The minimum of two values (e was already used, so can't use e<)
 }*           e#  (result is the minimum value from the array)
 ^            e#  Bitwise XOR of last element with minimum element;
              e#   if the numbers are the same, result is 0, otherwise non-zero
 {            e#  If non-zero (i.e. last element wasn't the minimum element)
  1m<         e#   Rotate the array 1 to the left
 }{           e#  Else
  )\          e#   Remove the last element and bring the array back to TOS
 }?           e#  (end if)
}h            e# (end do-while)
;             e# Remove the empty array left behind
]             e# End the array

Japt, score = 4

Program 1

n

Try it online!

Program 2

ñ

Try it online!

Program 3

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

Try it online!

Program 4

Ov85d +110d

Try it online!

Octave, 2 points

It's hard to compete with esolangs, but here goes:

I'm impressed if someone beats this. unique can be used to sort values, but it will strip out the duplicates. In order to insert the duplicates you would need parentheses, and they are heavily used in the bubble-sort. You'd also need @, which is used too.

Number 1:

This one is quite simple: Create an anonymous function, assigned to the variable ans.

@sort

Call it this way: ans([-5, 3, 0, -2, 100]). It doesn't work on tio, but it works on octave-online.

Number 2:

This is simply an implementation of bubble sort, without using the characters @sort. We can't make this a function, because of o, and we can't use input because of the t. We're therefore stuck with 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,'("");']); evaluates to: a=input("");, that we can use to enter our input vector. The rest is bubble-sorting without using for or mod. Note that this must be saved in a script and called from the GUI/CLI. You can't copy-paste it, because of input("") (it will use the rest of the code as input, thus fail miserably).

Haskell (lambdabot), 3 functions

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

I'm using the lambdabot environment to avoid lots of import statements. Even sort needs import Data.List. lambdabot imports a bunch of modules by default. Besides the missing imports, it's standard Haskell code according to our rules.

Try it online!.

Function 1

sort

The library function from Data.List. Nothing much to say here.

Function 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

Function v implements an insert-sort.

I use pattern guards to avoid () for parameters. Compare vv v|vvv:vvvv<-v=... to vv(vvv:vvvv)=....

บรรทัดแรกฟังก์ชั่นvvเป็นฟังก์ชั่นผู้ช่วยในการสร้างรายการที่ว่างเปล่า ด้วยฉันไม่ต้องใช้[]เพื่อเขียนรายการเปล่าตามตัวอักษร อ่านเพิ่มเติมได้:

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

(==:)is insert ซึ่งจะแทรกองค์ประกอบลงในรายการเรียงลำดับเพื่อให้รายการผลลัพธ์ยังคงเรียงลำดับ อ่านเพิ่มเติมได้:

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

(=:)คือการลด อ่านเพิ่มเติมได้:

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

และในที่สุดก็vลดรายการอินพุตที่จ้องมองด้วย[]:

sort list = [] `reduce` list

ฟังก์ชั่น 3

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

sortจากฟังก์ชั่น 1 ทำให้มากที่สุดของฟังก์ชั่นรายการเดิน ( fold, scan, until) พร้อมใช้งาน ความต้องการ recursion =ซึ่งจะใช้ในฟังก์ชั่น 2 ตัวเลือกเดียวที่เหลือคือการใช้ fixCombinator ฉันเริ่มต้นด้วย

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

ซึ่งเป็นการเลือกเรียงลำดับ เปลี่ยนเป็นแบบไม่มีจุด (ฉันไม่สามารถใช้ lambdas \f x ->...ได้เพราะ-รูปแบบที่ใช้โดย gurads รูปแบบใน Function 2) ให้:

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

การทำรายการเดี่ยวจากค่ากับreturnเป็นสิ่งต้องห้าม (เดียวกันpure) ดังนั้นฉันจะต้องสร้างฟังก์ชั่นของตัวเอง: หรือจุดฟรี\x -> map (\y -> x+0*y) [1] flip map[1].(.(0*)).(+)แทนที่returnอัตราผลตอบแทน

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

MATL, 3 programs

Program 1

S

This just uses the builtin function, with implicit input and display.

Try it at MATL online.

Program 2

`GGnZrd0<a}3M

This keeps generating random permutations of the inputs until all consecutive differences of the result are non-negative (this is bogosort, as noted by @c.z.). Running time is non-deterministic and its average increases very fast with input size (namely, 𝒪(n!) for a size-n array with all entries different).

Try it at MATL Online.

Program 3

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

This is a loop that computes the minimum of the array, removes all elements equal to that value, and proceds with the rest. This is done as many times as the input size. If not all entries in the input are different, some of the iterations will be useless (but harmless), because the array will have already been emptied.

Try it at MATL online.

Pip, 4 programs

Program 1 - builtin

Snippet; assumes list in x.

SNx

(SN for Sort Numeric)

Program 2 - filter permutations

Snippet; assumes list in y. Very slow for inputs longer than about 7 items.

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

Snippet; assumes list in z.

V J C[83 78 122]

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

Program 4 - MergeSort

Anonymous function; call with list as argument (like ({...} [1 2]) or 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

Try it online!

This is a snippet that runs in (e.g.) PowerShell's equivalent of a REPL. The TIO link shows usage. The sort is an alias for the Sort-Object cmdlet.

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

Try it online!

PowerShell commands are case-insensitive, so we can use sort for one and SORT for the other. This takes an input array, sorts it in-place, and then outputs it.

Ruby, 2 programs

First - the straightforward:

->t{t.sort}

Second - the tricky part:

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

J

Program one: 3 bytes

/:~

as in /:~ 3,1,2,1 outputs 1 1 2 3

Try it online!

NOTE in J, negative numbers are preceded by _ not - so you can try 4,_10,56,_333 etc.

Program two: 5 bytes

|.\:~

PHP 7, 2 programs

Both programs can be golfed more.

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

Bubble sort. Uses goto to create a loop as built-in loops require ().

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

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

IF(...){} avoids usage of ;. The main code is encoded with XOR, because $ has been already used in the previous program. The code:

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