Esse é o tipo de desafio que bytes

32

Eu preciso parar de pensar em nomes punny

Sua tarefa é criar o maior número possível de trechos (programas com entrada e saída integradas), funções ou programas completos que classifiquem a versão do seu idioma de matrizes inteiras em ordem crescente, mas para cada programa, você só tem permissão para usar os caracteres em ASCII (ou a página de código do seu idioma, se for diretamente especificado como não ASCII), que não foram usados ​​nos programas anteriores.

Este é um exemplo de resposta (programas separados por novas linhas):

Derp
ASdFGHJKLAAA
qwEEERtyRty

Neste (linguagem ficcional), minha primeira resposta é Derp, que utilizou-se D, e, re p. No segundo programa, não tenho permissão para usar esses caracteres novamente, mas posso reutilizar quantos caracteres desejar. O mesmo com o terceiro programa, e assim por diante.

Cada programa deve ter uma matriz de números inteiros, então algo assim (consulte exemplos de entrada / saída para estilos válidos de entrada / saída):

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

E deve gerar os itens na matriz como uma matriz, em ordem crescente:

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

Sua pontuação será o total de envios. Se houver um empate, o menor número de bytes (menor quantidade de bytes no seu código) vence!

Regras para programas:

  • Todos os envios devem ser executados corretamente em uma versão do idioma Python 2 != Python 3.
  • Seus envios podem ser trechos, funções ou programas completos. Você ainda pode misturá-los e combiná-los - no entanto, você deve dizer qual é qual e fornecer links para envios de trabalho.
  • Forneça links on-line para todas as soluções, se possível.
  • Todos os envios devem usar uma matriz (ou uma string delimitada com qualquer caractere) como entrada e produzir a matriz classificada (no formato de matriz do seu idioma ou como uma {any character}string delimitada.
  • Você não tem permissão para usar caracteres fora do ASCII (ou na página de códigos do seu idioma).

Por exemplo, estas são entradas / saídas 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)

Especificações para entrada:

  • Você está garantido que a matriz contém apenas números inteiros. No entanto, pode haver números negativos, e os números podem se repetir indefinidamente.
code-golf code-challenge restricted-source sorting clismique
fonte
13
Quanto mais trocadilhos, melhor!
5
Você percebe que qualquer um que se incomode em resolver isso em Brainfuck recebe uma solução Lenguage com pontuação 128? Como alternativa, uma única solução Glypho poderia ter 42 pontos.
Martin Ender
11
@ Qwerp-Derp Talvez um pouco entediante, mas certamente factível. Na verdade, espero que a E / S seja a parte mais irritante (se você não permitir a leitura de entrada como uma lista de códigos de caracteres).
Martin Ender
11
@WheatWizard Eu estava contando apenas 128 caracteres disponíveis, já que o desafio especifica ASCII.
Martin Ender
2
Tenho 3 problemas com a restrição de idioma. (1) Restringir classes arbitrárias de linguagens porque elas seriam boas em um desafio não é divertido. (2) a maioria das linguagens de programação "normais" como JavaScript (que já tem uma resposta) não atende aos requisitos, o que certamente não é o intenção da restrição e, mais uma vez, não é divertido. (3) Não acho que seja realmente um requisito observável. "Função específica" não é muito observável, eu poderia argumentar através de várias camadas de abstração que os caracteres Glypho realmente têm funções específicas que operam em um conjunto de variáveis ​​ocultas.
Assistente de trigo

Respostas:

15

Geléia , 10 programas, 65 bytes

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

Existe alguma sobreposição inevitável com a resposta do @ Lynn Jelly . Créditos para a idéia do bogosort vão para ela.

Experimente online! ou verifique a exclusividade .

Como eles trabalham

Ṣ               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
fonte
15

Geléia, 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.

O último programa é realmente irritante…

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.

Se eu puder remover a œṡpartir de <;0œṡ0⁸ṁjµ/, há também um presente estranho:²SNr²ZFœ& . A ajuda é apreciada.

Lynn
fonte
11
Roots → polynomial, polynomial → rootsé gênio!
Luis Mendo
11
Parece que a ordem de saída está invertida . Felizmente Ué livre
Luis Mendo
Ugh, inteiros negativos ... Eu vou ver o que posso fazer sobre aqueles
Lynn
Acho que precisamos de um pouco mais, mas não sei como poderíamos melhorá-lo.
Matthew Roh
@ETHproductions Corrigido, agora.
21417 Lynn
14

05AB1E , pontuação = 6

05AB1E usa a codificação CP-1252 .

Agradecimentos a Kevin Cruijssen pelo programa 4.
Agradecemos a Riley pela inspiração no programa 6.

Programa 1

{               # sort

Experimente online!

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

Experimente online!

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

Experimente online!

Programa 4

ϧ

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

Experimente online!

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

Experimente online!

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

Experimente online!

Emigna
fonte
œßPode ser usado para uma pontuação adicional. Experimente aqui.
Kevin Cruijssen 16/03/19
@KevinCruijssen: Obrigado! Eu estava apenas olhando para uma œsolução, mas eu nem sequer saber sobre ß:)
Emigna
Serei completamente honesto, entendi daqui . ;)
Kevin Cruijssen 16/03/19
11
@Riley A menos que eu estou fazendo algo errado, ele dá uma saída incorreta
Kevin Cruijssen
11
Existe uma maneira de obter o rabo e pop? €Ý逤funcionaria se ¤exibisse o valor em vez de apenas obtê-lo.
Riley
11

Brachylog , score =  4  5

Programa 1 - Classificação aleatória

ṣ.↔: 1≥₎∧ | ↰

Nós embaralhamos e verificamos que o reverso da lista não aumenta. Caso contrário, tentamos novamente recursivamente.

Programa 2 - Classificação da permutação

p≤₁

Emita a primeira permutação que não diminui.

Programa 3 - Integrado

o

Ordem.

Programa 4 - Integrado

≜ᵒ

Encomende por etiqueta. Como os números inteiros na lista já estão corrigidos, isso faz o mesmo queo .

Programa 5 - Impressão mínima

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

Aqui está uma explicação para essa monstruosidade da natureza:

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
fonte
3
Riscado
2
@NoOneIsHere eu trapacei e estendi a linha para contornar isso!
Fatalize 16/03/17
Recursão da cauda + bogosort. Parece uma receita f-RecursionError: maximum call stack size exceeded
Esolanging Fruit
@ Challenger5 A recursão da cauda é implementada suficientemente bem no Prolog para que isso não aconteça.
Fatalize
7

JavaScript, pontuação 1 2

Dobrou a pontuação graças a @ETHproductions que me lembrou de escapes de cordas

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

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

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

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

Você pode testar as duas versões no console do seu navegador. A primeira versão é apenas uma função, a segunda versão é um trecho que precisa dos parênteses e argumentos adicionados.

Exemplos

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

Quão?

O primeiro trecho chama o método de classificação na matriz que você passa. Por padrão, o método de classificação classifica lexicográficos, o que é ruim para números inteiros (especialmente números negativos de vários dígitos). Como tal, temos que passar um retorno de chamada na forma de uma função de seta que pega dois elementos e subtrai o último do primeiro. Dependendo do valor resultante, os dois elementos são reorganizados: se for menor que 0, aaparecerá antes b, se for maior que 0, aaparecerá apósb e se for 0, os dois elementos terminarão próximos um do outro.

O segundo trecho nada mais é do que uma versão codificada do primeiro trecho e tira vantagem do fato de que no JavaScript object.function()é igual object["function"](). Ele também usa matrizes vazias, !operadores e conversão de números para gerar todos os tipos de strings, nos quais os caracteres necessários para o nome da função podem ser encontrados. Em seguida, os colchetes são usados ​​mais uma vez para obter o caractere em um determinado índice na sequência e todos esses caracteres são concatenados, resultando no seguinte código JavaScript:

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

[]["fill"]igual a [].fill, cujo ["constructor"]é o Functionobjeto. Em seguida, chamamos isso com uma string (que deve ser avaliada quando a função é chamada), que é a primeira função, mas observe que o argumento foi substituído por this. Para definir o valor de thispara o argumento, precisamos chamar uma função nessa função, a saber ["call"]. No JavaScript convencional, você escreveria isso como:

function _() {
    return this.sort((a,b)=>a-b);
}
_.call(argument);
Luke
fonte
Aposto que é possível obter uma solução sem parênteses, usando backticks. Function`return a=>a.sort\x28\x28a,b\x29=>a-b\x29` por exemplo, mas sem usar os caracteres que você já usou
ETHproductions
Não que isso importe, mas você provavelmente poderia economizar uma quantidade significativa de bytes no segundo trecho introduzindo 'e executando, por exemplo, em '('vez do JSF que gera esse caractere. (também, use fe tcomo vars em vez de ae b, bliteralmente , custa cerca de 3000 caracteres)
ETHproductions
7

V , pontuação 3 , 4

Este foi um desafio muito divertido! Felizmente, o vim possui uma função de "classificação" integrada, caso contrário, isso seria basicamente impossível. Infelizmente, como o V / vim é baseado em string, ele precisa de um argumento para classificar por valores numéricos. Então eu estou ligando

  • Classifique por valor numérico n,

  • Classifique por valor hexadecimal xe

  • Classificar por valor de ponto flutuante f

Pequena observação: quando escrevo algo como <esc>ou <C-r>, esse é realmente um byte. Representa caracteres não imprimíveis e, como infelizmente o V depende muito de caracteres não imprimíveis, esse método facilita tudo. Os links TIO têm o -vsinalizador, o que faz com que o intérprete V os leia como se fossem os caracteres que representam.

Programa 1, 2 bytes

ún

Experimente online!

Isso chama o tipo específico de V função de

Programa 2, 10 bytes

Qsor x
vi

Isso apenas chama 'ordenar' diretamente. A única coisa interessante sobre isso é que fazemos do exmodo mode, que é um modo estranho que emula o editor de texto 'ex', o trisavô de V. vié um atalho para visual, o comando usado para sair do modo ex. Isso requer uma nova linha à direita.

Experimente online!

Programa 3, 14 bytes

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

Experimente online!

Tudo bem, aqui é onde as explicações começam a ficar um pouco estranhas. Se podemos construir o texto sor x, podemos excluí-lo e inseri-lo no comando atual com <C-r><register-name>. Então, entraremos em maiúsculas.

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

Experimente online!

E aqui é onde as explicações começam a ficar muito estranhas. Semelhante à última vez, criaremos o comando no modo normal para que possamos usar chaves diferentes.

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
fonte
6

CJam, pontuação 4

Programa 1: Integrado

$

Programa 2: Avaliação Interna

36c~

36 é o valor ASCII de $.

Programa 3: Classificação de Permutação

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

Explicação dessa monstruosidade 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 negócios
fonte
Não sabe ao certo como é útil, mas você pode usar em (+vez de, 1m<se quiser.
Martin Ender
@MartinEnder Eu já estou usando <nesse trecho por isso é provavelmente melhor ficar com1m<
Cat Negócios
Embora eu não tenho certeza que vou ser capaz de fazer mais qualquer maneira sem o uso de blocos ...
Cat Negócios
5

Japt , pontuação = 4

Programa 1

n

Experimente online!

Programa 2

ñ

Experimente online!

Programa 3

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

Experimente online!

Programa 4

Ov85d +110d

Experimente online!

Tom
fonte
11
Agradável. Eu acho que você pode salvar o U no terceiro programa, fazendo s)$.sort(..., não tenho certeza se isso é útil.
ETHproductions
@ETHproductions Obrigado. Não tenho muita certeza se posso fazer muito mais; não pode eval mais Japt ou JS porque Oe $têm sido utilizados. Estou aberto a sugestões, se você puder pensar em outras maneiras de classificar! :)
Tom
4

Oitava, 2 pontos

É difícil competir com esolangs, mas aqui vai:

Estou impressionado se alguém vencer isso. uniquepode ser usado para classificar valores, mas eliminará as duplicatas. Para inserir as duplicatas, você precisará de parênteses e eles são muito usados ​​na classificação de bolhas. Você também precisaria@ , o que também é usado.

Número 1:

Essa é bem simples: Crie uma função anônima, atribuída à variável ans.

@sort

Chamá-lo desta forma: ans([-5, 3, 0, -2, 100]). Ele não funciona no tio, mas funciona na oitava on-line .

Número 2:

Isso é simplesmente uma implementação de classificação de bolha, sem usar os caracteres @sort. Não podemos fazer disso uma função, por causa de o, e não podemos usar inputpor causa do t. Portanto, estamos presos 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,'("");']);avalia como:, a=input("");que podemos usar para inserir nosso vetor de entrada. O resto é uma classificação de bolhas sem usar forou mod. Observe que isso deve ser salvo em um script e chamado a partir da GUI / CLI. Você não pode copiá-lo e colá-lo devido a input("")(ele usará o restante do código como entrada, portanto falhará miseravelmente).

Stewie Griffin
fonte
4

Haskell (lambdabot), 3 funções

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

Estou usando o ambiente lambdabot para evitar muitas importinstruções. Até sortprecisa import Data.List. O lambdabot importa vários módulos por padrão. Além dos desaparecidosimports , é o código Haskell padrão de acordo com nossas regras.

Experimente online! .

Função 1

sort

A função de biblioteca de Data.List. Não há muito o que dizer aqui.

Função 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

A função vimplementa uma ordenação por inserção.

Eu uso protetores de padrão para evitar ()parâmetros. Compare vv v|vvv:vvvv<-v=...com vv(vvv:vvvv)=....

A primeira linha, function vvé uma função auxiliar para criar a lista vazia. Com ele, não preciso []escrever listas literais vazias. Mais legível:

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

(==:)é insert, que insere um elemento em uma lista classificada, para que a lista resultante ainda seja classificada. Mais legível:

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

(=:)é reduzir. Mais legível:

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

E, finalmente, o vque reduz a lista de entrada com []:

sort list = [] `reduce` list

Função 3

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

sortFunção de uma toma a maioria das funções lista-de passeio ( fold, scan, until) indisponíveis. Necessidades de recursão =usadas na Função 2. A única opção que resta é usar o combinador de ponto de fixação fix. Eu comecei com

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

que é um tipo de seleção. Ativá-lo sem pontos (eu não posso usar lambdas \f x ->..., por causa do -que é usado pelos gurads padrão na Função 2) fornece: 

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

Fazer listas singleton com um valor com returné proibido (o mesmo para pure), então eu tenho que criar minha própria função: \x -> map (\y -> x+0*y) [1]ou sem ponto flip map[1].(.(0*)).(+). Substituindo returnrendimentos

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

MATL , 3 programas

Programa 1

S

Isso apenas usa a função interna, com entrada e exibição implícitas.

Experimente no MATL online .

Programa 2

`GGnZrd0<a}3M

Isso continua gerando permutações aleatórias das entradas até que todas as diferenças consecutivas do resultado sejam não negativas (isso é bogosort , conforme observado por @cz ). O tempo de execução não é determinístico e sua média aumenta muito rapidamente com o tamanho da entrada (ou seja, 𝒪 ( n! ) Para um tamanho- n matriz com todas as entradas diferentes).

Experimente no MATL Online .

Programa 3

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

Este é um loop que calcula o mínimo da matriz, remove todos os elementos iguais a esse valor e procede com o restante. Isso é feito quantas vezes o tamanho da entrada. Se nem todas as entradas na entrada forem diferentes, algumas das iterações serão inúteis (mas inofensivas), porque a matriz já terá sido esvaziada.

Experimente no MATL online .

Luis Mendo
fonte
11
Bom pensamento lateral!
Greg Martin
Isso é bogo-sort?
c ..
@cz googles bogo-sort Na verdade! TIL
Luis Mendo
1

Pip , 4 programas

Programa 1 - incorporado

Snippet; assume a lista em x.

SNx

( SNpara classificação numérica)

Programa 2 - permutações de filtro

Snippet; assume a lista em y. Muito lento para entradas com mais de 7 itens.

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

Snippet; assume a lista em 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

Função anônima; chamada com lista como argumento (como ({...} [1 2])ou 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
}
DLosc
fonte
1

PowerShell , 2

|sort

Experimente online!

Este é um trecho executado (por exemplo) no equivalente do PowerShell a um REPL. O link TIO mostra o uso. O sorté um alias para o Sort-Objectcmdlet.

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

Experimente online!

Os comandos do PowerShell não diferenciam maiúsculas de minúsculas; portanto, podemos usar sortum e SORToutro. Isso pega uma matriz de entrada, classifica-a no local e depois a gera.

AdmBorkBork
fonte
1

Ruby, 2 programas

Primeiro - o direto:

->t{t.sort}

Segundo - a parte complicada:

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

J

Programa um: 3 bytes

/:~

como nas /:~ 3,1,2,1saídas1 1 2 3

Experimente online!

NOTA em J, números negativos são precedidos por _ not - para que você possa experimentar 4, _10,56, _333 etc.

Programa dois: 5 bytes

|.\:~
Richard Donovan
fonte
Corrigi sua resposta para que o código seja exibido corretamente. Boa resposta! Além disso, a Try it onlinecoisa links para uma página web na TIO, para ligar uma página em uma resposta que você pode fazer isso: [displayed text](link).
Clismique 17/03/19
Obrigado! Apenas começando, pegando o jeito devagar! Pense que parece melhor agora. Sua ajuda muito apreciada. Richard
Richard Donovan
Os programas que você escreve não podem compartilhar nenhum caractere; como estão :e ~ocorrem em ambos.
21417 Lynn
0

PHP 7, 2 programas

Ambos os programas podem ser jogados mais.

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;

Tipo de bolha. Usa gotopara criar um loop, conforme os loops internos exigem() .

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 o uso de ;. O código principal é codificado com o XOR, porque $já foi usado no programa anterior. O código:

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