Este es el tipo de desafío que los bytes

32

Necesito dejar de pensar en nombres punny

Su tarea es crear tantos fragmentos (programas que tengan entradas y salidas incorporadas), funciones o programas completos como sea posible que clasifiquen la versión de su matriz de enteros en orden ascendente, pero para cada programa, solo se le permite para usar los caracteres en ASCII (o la página de códigos de su idioma, si se especifica directamente como no ASCII) que no se han utilizado en los programas anteriores.

Este es un ejemplo de respuesta (programas separados separados por nuevas líneas):

Derp
ASdFGHJKLAAA
qwEEERtyRty

En este (lengua ficticia), mi primera respuesta es Derp, que agotado D, e, ry p. En el segundo programa, no se me permite usar esos caracteres nuevamente, pero puedo reutilizar tantos caracteres como quiera. Lo mismo con el tercer programa, y ​​así sucesivamente.

Cada programa debe tomar una matriz de enteros, por lo que algo como esto (ver ejemplos de entrada / salida para estilos de entrada / salida válidos):

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

Y debe mostrar los elementos de la matriz como una matriz, en orden ascendente:

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

Su puntaje será la cantidad total de envíos. Si hay un empate, ¡el bytecount más bajo (la menor cantidad de bytes en su código) gana!

Reglas para programas:

  • Todos los envíos deben ejecutarse correctamente en una versión de idioma (así Python 2 != Python 3).
  • Sus envíos pueden ser fragmentos, funciones o programas completos. Incluso puede mezclarlos y combinarlos; sin embargo, debe decir cuál es cuál y proporcionar enlaces a envíos que funcionen.
  • Proporcione enlaces en línea a todas las soluciones, si es posible.
  • Todos los envíos deben tomar una matriz (o una cadena delimitada con cualquier carácter) como entrada y generar la matriz ordenada (en la forma de matriz de su idioma o como una {any character}cadena delimitada).
  • No está permitido usar ningún carácter fuera de ASCII (o la página de códigos de su idioma).

Por ejemplo, estas son entradas / salidas válidas:

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

Especificaciones para la entrada:

  • Se garantiza que la matriz contiene solo enteros. Sin embargo, puede haber números negativos, y los números pueden repetirse indefinidamente.
clismique
fuente
13
¡Cuantos más juegos de palabras, mejor!
55
¿Te das cuenta de que cualquiera que pueda molestarse en resolver esto en Brainfuck obtiene una solución Lenguage con un puntaje de 128? Alternativamente, una sola solución de Glypho podría obtener 42 puntos.
Martin Ender
1
@ Qwerp-Derp Quizás un poco tedioso, pero ciertamente factible. De hecho, espero que la E / S sea la parte más molesta (si no permite leer la entrada como una lista de códigos de caracteres).
Martin Ender
1
@WheatWizard Estaba contando solo 128 caracteres disponibles ya que el desafío especifica ASCII.
Martin Ender
2
Tengo 3 problemas con la restricción de idioma. (1) Restringir clases arbitrarias de idiomas porque serían buenos en un desafío no es divertido. (2) la mayoría de los lenguajes de programación "normales" como JavaScript (que ya tiene una respuesta) no cumplen con los requisitos, lo cual, ciertamente, no es el intención de la restricción, y una vez más, no es divertido. (3) No creo que sea realmente un requisito observable. La "función específica" no es muy observable, podría argumentar a través de varias capas de abstracción que los caracteres Glypho tienen funciones específicas que operan en un conjunto de variables ocultas.
Wheat Wizard

Respuestas:

15

Jelly , 10 programas, 65 bytes

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

Hay una superposición inevitable con la respuesta de @ Lynn's Jelly . Los créditos para la idea de bogosort van a ella.

Pruébalo en línea! o verificar la unicidad .

Cómo trabajan ellos

Ṣ               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.
Dennis
fuente
15

Jelly, 8 programas

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

El último programa es realmente molesto ...

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.

Si puedo quitar la œṡde <;0œṡ0⁸ṁjµ/, también hay esta extraña uno: ²SNr²ZFœ&. La ayuda es apreciada.

Lynn
fuente
1
Roots → polynomial, polynomial → rootses genio!
Luis Mendo
1
Parece que el orden de salida se invierte . Por suerte Ues gratis
Luis Mendo
Ugh, enteros negativos ... Veré qué puedo hacer al respecto
Lynn
Creo que necesitamos un poco más, pero no sé cómo podríamos mejorarlo.
Matthew Roh
@ETHproductions Corregido, ahora.
Lynn
14

05AB1E , puntuación = 6

05AB1E utiliza la codificación CP-1252 .

Gracias a Kevin Cruijssen por el programa 4.
Gracias a Riley. por la inspiración para el programa 6.

Programa 1

{               # sort          

Pruébalo en línea!

Programa 2

`[Ž.^]¯

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

Pruébalo en línea!

Programa 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

Pruébalo en línea!

Programa 4

ϧ

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

Pruébalo en línea!

Programa 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

Pruébalo en línea!

Programa 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

Pruébalo en línea!

Emigna
fuente
œßSe puede usar para un puntaje adicional. Pruébalo aquí.
Kevin Cruijssen
@KevinCruijssen: ¡Gracias! Estaba buscando una œsolución, pero ni siquiera sabía sobre ß:)
Emigna
Seré completamente honesto, lo obtuve de aquí . ;)
Kevin Cruijssen
1
@Riley A menos que esté haciendo algo mal, da un resultado incorrecto
Kevin Cruijssen
1
¿Hay alguna manera de obtener la cola y el pop? €Ý逤funcionaría si ¤apareciera el valor en su lugar si solo lo obtuviera.
Riley
11

Brachylog , puntaje =  4  5

Programa 1 - Clasificación aleatoria

ṣ.↔: 1≥₎∧ | ↰

Barajamos y verificamos que el reverso de la lista no aumenta. Si no, reintentamos recursivamente.

Programa 2 - Tipo de permutación

p≤₁

Salida de la primera permutación que no es decreciente.

Programa 3 - Incorporado

o

Orden.

Programa 4 - Incorporado

≜ᵒ

Ordenar por etiquetado. Como los enteros en la lista ya están fijos, esto hace lo mismo queo .

Programa 5 - Impresión mínima

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

Aquí hay una explicación para esta monstruosidad de la naturaleza:

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
Fatalizar
fuente
3
Tachado 4 sigue siendo regular 4 :(
NoOneIsHere
2
@NoOneIsHere ¡Hice trampa y extendí la línea para evitar eso!
Fatalize
Recurrencia de cola + bogosort. Parece una receta f-RecursionError: maximum call stack size exceeded
Esolanging Fruit
@ Challenger5 La recursión de cola se implementa lo suficientemente bien en Prolog para que esto no suceda.
Fatalize
7

JavaScript, puntaje 1 2

Duplicó el puntaje gracias a @ETHproductions que me recordó los escapes de cadena

Fragmento 1 (21 bytes, caracteres \ ,-.=>289`Facehilnorstux)

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

Fragmento 2 (9117 bytes, caracteres (+)[!])

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

Puede probar ambas versiones en la consola de su navegador. La primera versión es solo una función, la segunda versión es un fragmento que necesita los paréntesis y el argumento agregado.

Ejemplos

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

¿Cómo?

El primer fragmento llama al método de clasificación en la matriz que le pasa. De manera predeterminada, el método de clasificación ordena lexicográfico, lo cual es malo para los enteros (especialmente números negativos de varios dígitos). Como tal, tenemos que pasarle una devolución de llamada en forma de una función de flecha que toma dos elementos y resta el último del primero. Dependiendo del valor resultante, los dos elementos se reorganizan: si es menor que 0, aaparecerá antes b, si es mayor que 0, aaparecerá despuésb y si es 0, ambos elementos terminarán uno al lado del otro.

El segundo fragmento no es más que una versión codificada del primer fragmento y aprovecha el hecho de que en JavaScript, object.function()es igual object["function"](). También utiliza matrices vacías, !operadores y conversión de números para generar todo tipo de cadenas, en las que se pueden encontrar los caracteres necesarios para el nombre de la función. Luego, los corchetes se usan una vez más para obtener el carácter en un cierto índice en la cadena, y todos esos caracteres se concatenan, lo que da como resultado el siguiente código JavaScript:

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

[]["fill"]igual [].fill, de quién ["constructor"]es el Functionobjeto. Luego lo llamamos con una cadena (que se evaluará cuando se llama a la función), que es la primera función, pero observe que el argumento ha sido reemplazado por this. Para establecer el valor de thisal argumento, necesitamos llamar a una función en esta función, a saber ["call"]. En JavaScript convencional, escribirías esto como:

function _() {
    return this.sort((a,b)=>a-b);
}
_.call(argument);
Luke
fuente
Apuesto a que es posible obtener una solución sin paréntesis, utilizando backticks en su lugar. Function`return a=>a.sort\x28\x28a,b\x29=>a-b\x29` por ejemplo, pero sin usar los caracteres que ya usó
ETHproductions
No es que importe, pero probablemente podría guardar una cantidad significativa de bytes en el segundo fragmento introduciendo 'y haciendo, por ejemplo, en '('lugar de lo que JSF genere ese carácter. (también, use fy tcomo vars en lugar de ay b, bliteralmente cuesta alrededor de 3000 caracteres)
ETHproductions
7

V , puntaje 3 , 4

¡Este fue un desafío muy divertido! Afortunadamente, vim tiene una función de "clasificación" incorporada, de lo contrario, esto sería básicamente imposible. Desafortunadamente, dado que V / vim se basa en cadenas, necesita un argumento para ordenar por valores numéricos. Entonces estoy llamando

  • Ordenar por valor numérico n,

  • Ordenar por valor hexadecimal x, y

  • Ordenar por valor de coma flotante f

Pequeña nota al margen: cuando escribo algo como <esc>o <C-r>, esto es en realidad un solo byte. Representa caracteres no imprimibles, y dado que V desafortunadamente depende en gran medida de caracteres no imprimibles, este método hace que todo sea más fácil. Los enlaces TIO tienen la -vbandera, lo que hace que el intérprete de V los lea como si fueran los caracteres que representan.

Programa 1, 2 bytes

ún

Pruébalo en línea!

Esto llama a la función de clasificación específica V.

Programa 2, 10 bytes

Qsor x
vi

Esto solo llama 'ordenar' directamente. Lo único interesante de esto es que lo hacemos desde el exmodo, que es un modo extraño que emula el editor de texto 'ex', el tatarabuelo de V. vies un acceso directo para visual, el comando utilizado para salir del modo ex. Esto requiere una nueva línea final.

Pruébalo en línea!

Programa 3, 14 bytes

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

Pruébalo en línea!

Muy bien, aquí es donde las explicaciones comienzan a ponerse un poco raras. Si podemos construir el texto sor x, podemos eliminarlo e insertarlo en el comando actual con <C-r><register-name>. Entonces lo ingresaremos en mayúscula.

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

Programa 4, 19 bytes

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

Pruébalo en línea!

Y aquí es donde las explicaciones comienzan a ponerse muy raras. Similar a la última vez, crearemos el comando en modo normal para que podamos usar diferentes teclas.

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
DJMcMayhem
fuente
6

CJam, puntaje 4

Programa 1: incorporado

$

Programa 2: Evaluado incorporado

36c~

36 es el valor ASCII de $.

Programa 3: ordenación de permutación

e!0=

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

Programa 4: valores mínimos

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

Explicación de esta monstruosidad sobrenatural:

[             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
Gato de negocios
fuente
No estoy seguro de lo útil que es, pero puede usarlo en (+lugar de 1m<si lo desea.
Martin Ender
@MartinEnder Ya estoy usando <ese fragmento, así que probablemente sea mejor seguir1m<
Business Cat
Aunque no estoy seguro de que pueda hacer más de todos modos sin usar bloques ...
Business Cat
5

Japt , puntuación = 4

Programa 1

n

Pruébalo en línea!

Programa 2

ñ

Pruébalo en línea!

Programa 3

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

Pruébalo en línea!

Programa 4

Ov85d +110d

Pruébalo en línea!

Tom
fuente
1
Buena esa. Creo que puede guardar la U en el tercer programa haciendo s)$.sort(..., aunque no estoy seguro de si eso es útil.
ETHproductions
@ETHproductions Gracias. No estoy realmente seguro si puedo hacer mucho más de todos modos; no puede evaluar más Japt o JS porque Oy $se han utilizado. ¡Estoy abierto a sugerencias si puede pensar en otras formas de ordenar! :)
Tom
4

Octava, 2 puntos

Es difícil competir con esolangs, pero aquí va:

Estoy impresionado si alguien supera esto. uniquepuede usarse para ordenar valores, pero eliminará los duplicados. Para insertar los duplicados, necesitarías paréntesis, y se usan mucho en el ordenamiento de burbujas. También necesitarías @, que también se usa.

Numero 1:

Este es bastante simple: crear una función anónima, asignada a la variable ans.

@sort

Llamar de esta manera: ans([-5, 3, 0, -2, 100]). No funciona en tio, pero funciona en octave-online .


Número 2:

Esto es simplemente una implementación de ordenamiento de burbujas, sin usar los caracteres @sort. No podemos hacer que esto sea una función o, y no podemos usarlo inputdebido a t. Por lo tanto, estamos atrapados con 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,'("");']);se evalúa como:, a=input("");que podemos usar para ingresar nuestro vector de entrada. El resto es la clasificación de burbujas sin usar foro mod. Tenga en cuenta que esto debe guardarse en un script y llamarse desde la GUI / CLI. No puede copiarlo y pegarlo debido a input("")(usará el resto del código como entrada, por lo tanto fallará miserablemente).

Stewie Griffin
fuente
4

Haskell (lambdabot), 3 funciones

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

Estoy usando el entorno lambdabot para evitar muchas importdeclaraciones. Incluso sortnecesita import Data.List. lambdabot importa un montón de módulos por defecto. Además de lo que falta imports, es el código estándar de Haskell de acuerdo con nuestras reglas.

Pruébalo en línea! .

Función 1

sort

La función de biblioteca de Data.List. No hay mucho que decir aquí.

Función 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

La función vimplementa una ordenación por inserción.

Utilizo guardias de patrones para evitar los ()parámetros. Comparar vv v|vvv:vvvv<-v=...a vv(vvv:vvvv)=....

La primera línea, función vves una función auxiliar para crear la lista vacía. Con él no tengo que usar []para escribir listas vacías literales. Más legible:

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

(==:)es insert, que inserta un elemento en una lista ordenada, de modo que la lista resultante todavía está ordenada. Más legible:

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

(=:)es reducir Más legible:

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

Y finalmente, lo vque reduce la lista de entrada mirando con []:

sort list = [] `reduce` list

Función 3

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

sortFunción de 1 hace que la mayoría de las funciones de la lista-para caminar ( fold, scan, until) no están disponibles. Necesidades de recursión =que se usan en la Función 2. La única opción que queda es usar el combinador de punto fijo fix. He empezado con

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

que es un tipo de selección. Al convertirlo en punto libre (no puedo usar lambdas \f x ->..., debido a lo -que usan los gurads de patrón en la Función 2) da:

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

returnEstá prohibido hacer listas singleton de un valor con (lo mismo para pure), así que tengo que construir mi propia función: \x -> map (\y -> x+0*y) [1]o sin puntos flip map[1].(.(0*)).(+). Sustitución de returnrendimientos

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

MATL , 3 programas

Programa 1

S

Esto solo usa la función incorporada, con entrada y visualización implícitas.

Pruébelo en MATL en línea .

Programa 2

`GGnZrd0<a}3M

Esto sigue generando permutaciones aleatorias de las entradas hasta que todas las diferencias consecutivas del resultado no sean negativas (esto es bogosort , como lo señala @cz ). El tiempo de ejecución no es determinista y su promedio aumenta muy rápido con el tamaño de entrada (es decir, 𝒪 ( n! ) Para un tamaño- n matriz con todas las entradas diferentes).

Pruébalo en MATL Online .

Programa 3

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

Este es un bucle que calcula el mínimo de la matriz, elimina todos los elementos iguales a ese valor y procesa con el resto. Esto se hace tantas veces como el tamaño de entrada. Si no todas las entradas en la entrada son diferentes, algunas de las iteraciones serán inútiles (pero inofensivas), porque la matriz ya se habrá vaciado.

Pruébelo en MATL en línea .

Luis Mendo
fuente
1
¡Buen pensamiento lateral!
Greg Martin
¿Es eso un tipo bogo?
c ..
@cz googles bogo-sort ¡De hecho! TIL
Luis Mendo
1

Pip , 4 programas

Programa 1 - incorporado

Retazo; asume la lista en x.

SNx

( SNpara Ordenar numérico)

Programa 2 - permutaciones de filtro

Retazo; asume la lista en y. Muy lento para entradas de más de 7 elementos.

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

Programa 3 - eval

Retazo; asume la lista en 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

Programa 4 - MergeSort

Función anónima; llamar con la lista como argumento (como ({...} [1 2])o 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}

Sin golf:

{
 ; 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
}
DLosc
fuente
1

PowerShell , 2

|sort

Pruébalo en línea!

Este es un fragmento que se ejecuta en (por ejemplo) el equivalente de PowerShell de un REPL. El enlace TIO muestra el uso. El sortes un alias para el Sort-Objectcmdlet.


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

Pruébalo en línea!

Los comandos de PowerShell no distinguen entre mayúsculas y minúsculas, por lo que podemos usarlos sortpara uno y SORTpara el otro. Esto toma una matriz de entrada, la ordena in situ y luego la genera.

AdmBorkBork
fuente
1

Ruby, 2 programas

Primero, lo sencillo:

->t{t.sort}

Segundo, la parte difícil:

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

J

Programa uno: 3 bytes

/:~

como en /:~ 3,1,2,1salidas1 1 2 3

Pruébalo en línea!

NOTA en J, los números negativos están precedidos por _ no, por lo que puede probar 4, _10,56, _333, etc.

Programa dos: 5 bytes

|.\:~
Richard Donovan
fuente
Arregle su respuesta para que el código se muestre correctamente. ¡Buena respuesta! Asimismo, la Try it onlinecosa se vincula a una página web en TIO, para enlazar una página en una respuesta que puede hacer esto: [displayed text](link).
clismique
¡Gracias! ¡Acabo de empezar, así que aprende lentamente! Creo que se ve mejor ahora. Tu ayuda muy apreciada. Richard
Richard Donovan
Los programas que escribe no pueden compartir ningún carácter; tal cual, :y ~ocurren en ambos.
Lynn
0

PHP 7, 2 programas

Ambos programas se pueden jugar más al golf.

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

Ordenamiento de burbuja. Se utiliza gotopara crear un bucle según lo requieran los bucles integrados ().

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

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

IF(...){}evita el uso de ;. El código principal está codificado con XOR, porque $ya se usó en el programa anterior. El código:

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