C'est le genre de défi que les octets

32

Je dois arrêter de penser à des noms chétifs

Votre tâche consiste à créer autant d'extraits de code (programmes dotés d'entrées et de sorties intégrées), de fonctions ou de programmes complets que possible, qui trie la version des tableaux entiers de votre langue dans l'ordre croissant, mais pour chaque programme, vous n'êtes autorisé qu'à pour utiliser les caractères en ASCII (ou la page de codes de votre langue, si elle est directement spécifiée comme non ASCII) qui n'ont pas été utilisés dans les programmes précédents.

Voici un exemple de réponse (programmes séparés séparés par des retours à la ligne):

Derp
ASdFGHJKLAAA
qwEEERtyRty

Dans cette (langue fictive), ma première réponse est Derp, qui épuisé D, e, ret p. Dans le deuxième programme, je ne suis pas autorisé à utiliser à nouveau ces caractères, mais je peux réutiliser autant de caractères que je veux. Même chose avec le troisième programme, etc.

Chaque programme doit prendre un tableau d'entiers, donc quelque chose comme ça (voir des exemples d'entrée / sortie pour les styles d'entrée / sortie valides):

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

Et il doit sortir les éléments du tableau sous forme de tableau, dans l'ordre croissant:

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

Votre score sera le montant total des soumissions. S'il y a égalité, le nombre d'octets le plus bas (le moins d'octets dans votre code) gagne!

Règles pour les programmes:

  • Toutes les soumissions doivent s'exécuter correctement dans une version linguistique (donc Python 2 != Python 3).
  • Vos soumissions peuvent être des extraits, des fonctions ou des programmes complets. Vous êtes même autorisé à les mélanger et à les assortir - cependant, vous devez dire lequel est lequel et fournir des liens vers des soumissions de travail.
  • Veuillez fournir des liens en ligne vers toutes les solutions, si possible.
  • Toutes les soumissions doivent prendre un tableau (ou une chaîne délimitée par n'importe quel caractère) en entrée, et sortir le tableau trié (sous la forme d'un tableau de votre langue ou sous la forme d'une {any character}chaîne délimitée).
  • Vous n'êtes pas autorisé à utiliser des caractères en dehors de l'ASCII (ou de la page de codes de votre langue).

Par exemple, ce sont des entrées / sorties valides:

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

Spécifications pour l'entrée:

  • Vous êtes assuré que le tableau ne contient que des entiers. Cependant, il peut y avoir des nombres négatifs et les nombres peuvent se répéter indéfiniment.
code-golf code-challenge restricted-source sorting clismique
la source
13
Plus il y a de calembours, mieux c'est!
5
Vous vous rendez compte que quiconque peut être dérangé pour résoudre ce problème dans Brainfuck obtient une solution Lenguage avec un score de 128? Alternativement, une seule solution Glypho pourrait marquer 42.
Martin Ender
1
@ Qwerp-Derp Peut-être un peu fastidieux, mais certainement faisable. En fait, je m'attends à ce que les E / S soient la partie la plus ennuyeuse (si vous n'autorisez pas la lecture des entrées comme une liste de codes de caractères).
Martin Ender
1
@WheatWizard Je ne comptais que 128 caractères disponibles depuis le défi spécifie ASCII.
Martin Ender
2
J'ai 3 problèmes avec la restriction de langue. (1) Restreindre des classes de langues arbitraires parce qu'elles seraient bonnes dans un défi n'est pas amusant. (2) la plupart des langages de programmation "normaux" comme JavaScript (qui a déjà une réponse) ne répondent pas aux exigences, ce qui n'est certainement pas le l'intention de la restriction, et encore une fois, pas amusant. (3) Je ne pense pas que ce soit vraiment une exigence observable. La "fonction spécifique" n'est pas très observable, je pourrais affirmer à travers plusieurs couches d'abstraction que les caractères Glypho ont en effet des fonctions spécifiques qui opèrent sur un ensemble de variables cachées.
Wheat Wizard

Réponses:

15

Gelée , 10 programmes, 65 octets

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

Il y a un certain chevauchement inévitable avec la réponse Jelly de @ Lynn . Les crédits pour l'idée du bogosort lui reviennent.

Essayez-le en ligne! ou vérifier l'unicité .

Comment ils travaillent

Ṣ               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
la source
15

Jelly, 8 programmes

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

Le dernier programme est vraiment ennuyeux…

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 je peux retirer le œṡde <;0œṡ0⁸ṁjµ/, il y a aussi ce bizarre un: ²SNr²ZFœ&. L'aide est appréciée.

Lynn
la source
1
Roots → polynomial, polynomial → rootsest un génie!
Luis Mendo
1
Il semble que l'ordre de sortie soit inversé . Heureusement, Uc'est gratuit
Luis Mendo
Pouah, des nombres entiers négatifs… Je vais voir ce que je peux faire à ce sujet
Lynn
Je pense que nous avons besoin d'un peu plus, mais je ne sais pas comment nous pourrions l'améliorer.
Matthew Roh
@ETHproductions Fixed, now.
Lynn
14

05AB1E , score = 6

05AB1E utilise le codage CP-1252 .

Merci à Kevin Cruijssen pour le programme 4.
Merci à Riley pour l'inspiration du programme 6.

Programme 1

{               # sort

Essayez-le en ligne!

Programme 2

`[Ž.^]¯

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

Essayez-le en ligne!

Programme 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

Essayez-le en ligne!

Programme 4

ϧ

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

Essayez-le en ligne!

Programme 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

Essayez-le en ligne!

Programme 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

Essayez-le en ligne!

Emigna
la source
œßPeut être utilisé pour un score supplémentaire. Essayez ici.
Kevin Cruijssen
@KevinCruijssen: Merci! Je cherchais juste une œsolution, mais je ne savais même pas ß:)
Emigna
Je serai complètement honnête, je l'ai eu d' ici . ;)
Kevin Cruijssen
1
@Riley Sauf si je fais quelque chose de mal, cela donne une sortie incorrecte
Kevin Cruijssen
1
Existe-t-il un moyen d'obtenir la queue et le pop? €Ý逤fonctionnerait si ¤sauté la valeur à la place si juste l'obtenir.
Riley
11

Brachylog , score =  4  5

Programme 1 - Tri aléatoire

ṣ.↔: 1≥₎∧ | ↰

Nous mélangeons et vérifions que l'inverse de la liste n'est pas en augmentation. Sinon, nous réessayons récursivement.

Programme 2 - Tri par permutation

p≤₁

Sortez la première permutation qui n'est pas décroissante.

Programme 3 - Intégré

o

Ordre.

Programme 4 - Intégré

≜ᵒ

Commandez par étiquetage. Puisque les entiers de la liste sont déjà fixes, cela fait la même chose que o.

Programme 5 - Impression minimale

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

Voici une explication de cette monstruosité de la nature:

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
Fataliser
la source
3
Barré 4 est toujours régulier 4 :(
NoOneIsHere
2
@NoOneIsHere J'ai triché et étendu la ligne pour contourner cela!
Fatalize
Récursivité de la queue + bogosort. Ressemble à une recette f-RecursionError: maximum call stack size exceeded
Esolanging Fruit
La récursivité @ Challenger5 Tail est suffisamment implémentée dans Prolog pour que cela ne se produise pas.
Fatalize
7

JavaScript, marquez 1 2

Double le score grâce à @ETHproductions qui m'a rappelé les échappements de chaîne

Extrait 1 (21 octets, caractères \ ,-.=>289`Facehilnorstux)

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

Extrait 2 (9117 octets, caractères (+)[!])

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

Vous pouvez tester les deux versions dans la console de votre navigateur. La première version est juste une fonction, la deuxième version est un extrait qui nécessite l'ajout des parenthèses et de l'argument.

Exemples

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

Comment?

Le premier extrait appelle la méthode de tri sur le tableau que vous lui transmettez. Par défaut, la méthode de tri trie lexicographique, ce qui est mauvais pour les entiers (en particulier les nombres négatifs à plusieurs chiffres). En tant que tel, nous devons lui passer un rappel sous la forme d'une fonction de flèche qui prend deux éléments et soustrait ce dernier de l'ancien. En fonction de la valeur résultante, les deux éléments sont réorganisés: s'il est inférieur à 0, aapparaîtra avant b, s'il est supérieur à 0, aapparaîtra après b, et s'il est 0, les deux éléments se retrouveront côte à côte.

Le deuxième extrait n'est rien de plus qu'une version codée du premier extrait et il profite du fait qu'en JavaScript, c'est object.function()égal object["function"](). Il utilise également des tableaux, des !opérateurs et des transtypages vides pour générer toutes sortes de chaînes, dans lesquelles les caractères nécessaires pour le nom de la fonction peuvent être trouvés. Ensuite, les crochets sont utilisés une fois de plus pour obtenir le caractère à un certain index dans la chaîne, et tous ces caractères sont concaténés, ce qui donne le code JavaScript suivant:

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

[]["fill"]est égal [].fill, dont ["constructor"]est l' Functionobjet. Nous appelons ensuite cela avec une chaîne (qui doit être évaluée lorsque la fonction est appelée), qui est la première fonction, mais notons que l'argument a été remplacé par this. Pour définir la valeur de thisl'argument, nous devons appeler une fonction sur cette fonction, à savoir ["call"]. En JavaScript conventionnel, vous écririez ceci comme:

function _() {
    return this.sort((a,b)=>a-b);
}
_.call(argument);
Luke
la source
Je parie qu'il est possible d'obtenir une solution sans parenthèses, en utilisant des backticks à la place. Function`return a=>a.sort\x28\x28a,b\x29=>a-b\x29` par exemple, mais sans utiliser les caractères que vous avez déjà utilisés
ETHproductions
Ce n'est pas important, mais vous pourriez probablement économiser une quantité importante d'octets dans le deuxième extrait en introduisant 'et en faisant par exemple '('au lieu de tout ce que JSF génère ce caractère. (aussi, utilisez fet tcomme vars au lieu de aet b, bcoûte littéralement environ 3000 caractères)
ETHproductions
7

V , score 3 , 4

Ce fut un défi vraiment amusant! Heureusement, vim a une fonction de "tri" intégrée, sinon cela serait fondamentalement impossible. Malheureusement, comme V / vim est basé sur une chaîne, il a besoin d'un argument pour trier par valeurs numériques. Alors j'appelle

  • Trier par valeur numérique n,

  • Trier par valeur hexadécimale xet

  • Trier par valeur à virgule flottante f

Petite note: lorsque j'écris quelque chose comme <esc>ou <C-r>, c'est en fait un octet. Il représente des caractères non imprimables, et puisque V repose malheureusement fortement sur des caractères non imprimables, cette méthode facilite tout. Les liens TIO ont le -vdrapeau, ce qui fait que l'interpréteur V les lit comme s'ils étaient les caractères qu'ils représentent.

Programme 1, 2 octets

ún

Essayez-le en ligne!

Cela appelle la fonction de tri spécifique à V.

Programme 2, 10 octets

Qsor x
vi

Cela appelle simplement «trier» directement. La seule chose intéressante à ce sujet est que nous le faisons à partir du exmode, qui est un mode étrange qui émule l'éditeur de texte «ex», l'arrière-arrière-grand-père de V. viest un raccourci pour visual, la commande utilisée pour quitter le mode ex. Cela nécessite une nouvelle ligne de fin.

Essayez-le en ligne!

Programme 3, 14 octets

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

Essayez-le en ligne!

D'accord, c'est ici que les explications commencent à devenir un peu bizarres. Si nous pouvons construire le texte sor x, nous pouvons le supprimer et l'insérer dans la commande courante avec <C-r><register-name>. Nous allons donc le saisir en majuscules.

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

Programme 4, 19 octets

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

Essayez-le en ligne!

Et c'est là que les explications commencent à devenir très étranges. Semblable à la dernière fois, nous allons construire la commande en mode normal afin que nous puissions utiliser différentes clés.

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
la source
6

CJam, score 4

Programme 1: Intégré

$

Programme 2: Eval'ed Built-in

36c~

36 est la valeur ASCII de $.

Programme 3: Tri par permutation

e!0=

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

Programme 4: valeurs minimales

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

Explication de cette monstruosité surnaturelle:

[             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
Chat d'affaires
la source
Je ne sais pas à quel point c'est utile, mais vous pouvez l'utiliser (+au lieu de 1m<si vous le souhaitez.
Martin Ender
@MartinEnder J'utilise déjà <cet extrait, il est donc préférable de s'en tenir à1m<
Business Cat
Bien que je ne sois pas sûr de pouvoir continuer de toute façon sans utiliser de blocs ...
Business Cat
5

Japt , score = 4

Programme 1

n

Essayez-le en ligne!

Programme 2

ñ

Essayez-le en ligne!

Programme 3

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

Essayez-le en ligne!

Programme 4

Ov85d +110d

Essayez-le en ligne!

À M
la source
1
Joli. Je pense que vous pouvez enregistrer le U dans le troisième programme en faisant s)$.sort(..., je ne sais pas si c'est utile cependant.
ETHproductions
@ETHproductions Merci. Je ne sais pas vraiment si je peux faire beaucoup plus de toute façon; ne peut plus évaluer Japt ou JS car Oet $ont été utilisés. Je suis ouvert aux suggestions si vous pouvez penser à d'autres méthodes de tri! :)
Tom
4

Octave, 2 points

Il est difficile de rivaliser avec les esolangs, mais voici:

Je suis impressionné si quelqu'un bat ça. uniquepeut être utilisé pour trier les valeurs, mais il supprimera les doublons. Afin d'insérer les doublons, vous auriez besoin de parenthèses, et ils sont fortement utilisés dans le tri à bulles. Vous auriez également besoin@ , qui est également utilisé.

Numéro 1:

Celui-ci est assez simple: créez une fonction anonyme, affectée à la variable ans.

@sort

Appelez cette façon: ans([-5, 3, 0, -2, 100]). Cela ne fonctionne pas sur tio, mais cela fonctionne sur octave-online .

Numéro 2:

Il s'agit simplement d'une implémentation de type bulle, sans utiliser les caractères @sort. Nous ne pouvons pas en faire une fonction à cause de o, et nous ne pouvons pas l'utiliser à inputcause de t. Nous sommes donc coincés avec 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,'("");']);évalue à:, a=input("");que nous pouvons utiliser pour entrer notre vecteur d'entrée. Le reste consiste à trier les bulles sans utiliser forou mod. Notez que cela doit être enregistré dans un script et appelé à partir de l'interface graphique / CLI. Vous ne pouvez pas le copier-coller à cause de input("")(il utilisera le reste du code en entrée, échouera donc lamentablement).

Stewie Griffin
la source
4

Haskell (lambdabot), 3 fonctions

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

J'utilise l'environnement lambdabot pour éviter beaucoup de importdéclarations. Même sortbesoin import Data.List. lambdabot importe un tas de modules par défaut. Outre les manquants imports, il s'agit du code Haskell standard selon nos règles.

Essayez-le en ligne! .

Fonction 1

sort

La fonction de bibliothèque de Data.List. Rien à dire ici.

Fonction 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 fonction vimplémente un tri par insertion.

J'utilise des gardes de modèle pour éviter les ()paramètres. Comparez vv v|vvv:vvvv<-v=...avec vv(vvv:vvvv)=....

La première ligne, function vvest une fonction d'aide pour créer la liste vide. Avec lui, je n'ai pas besoin de l'utiliser []pour écrire des listes vides littérales. Plus lisible:

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

(==:)is insert, qui insère un élément dans une liste triée, afin que la liste résultante soit toujours triée. Plus lisible:

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

(=:)est de réduire. Plus lisible:

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

Et enfin, vce qui réduit la liste d'entrée avec []:

sort list = [] `reduce` list

Fonction 3

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

sortFonction de 1 fait la plupart des fonctions de liste marche ( fold, scan, until) indisponible. Besoins de récursivité =utilisés dans la fonction 2. La seule option qui reste est d'utiliser le combinateur de points fixes fix. J'ai commencé avec

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

qui est un tri par sélection. Le transformer en point-free (je ne peux pas utiliser de lambdas \f x ->..., à cause de celui -qui est utilisé par les gurads de motif dans la fonction 2) donne: 

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

Il returnest interdit de créer des listes singleton à partir d'une valeur avec (même chose pour pure), donc je dois créer ma propre fonction: \x -> map (\y -> x+0*y) [1]ou sans point flip map[1].(.(0*)).(+). Remplacement des returnrendements

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

MATL , 3 programmes

Programme 1

S

Cela utilise simplement la fonction intégrée, avec une entrée et un affichage implicites.

Essayez-le sur MATL en ligne .

Programme 2

`GGnZrd0<a}3M

Cela continue de générer des permutations aléatoires des entrées jusqu'à ce que toutes les différences consécutives du résultat ne soient pas négatives (c'est le bogosort , comme indiqué par @cz ). Le temps d'exécution n'est pas déterministe et sa moyenne augmente très rapidement avec la taille d'entrée (à savoir, 𝒪 ( n! ) Pour un tableau de taille n avec toutes les entrées différentes).

Essayez-le sur MATL Online .

Programme 3

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

Il s'agit d'une boucle qui calcule le minimum du tableau, supprime tous les éléments égaux à cette valeur et procède avec le reste. Cela se fait autant de fois que la taille d'entrée. Si toutes les entrées de l'entrée ne sont pas différentes, certaines des itérations seront inutiles (mais inoffensives), car le tableau aura déjà été vidé.

Essayez-le sur MATL en ligne .

Luis Mendo
la source
1
Belle réflexion latérale!
Greg Martin
Est-ce du genre bogo?
c.
@cz googles bogo-sort En effet! TIL
Luis Mendo
1

Pip , 4 programmes

Programme 1 - intégré

Fragment; suppose une liste dans x.

SNx

( SNpour Trier numérique)

Programme 2 - permutations de filtre

Fragment; suppose une liste dans y. Très lent pour les entrées de plus de 7 éléments environ.

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

Programme 3 - Eval

Fragment; suppose une liste dans 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

Programme 4 - MergeSort

Fonction anonyme; appeler avec la liste comme argument (comme ({...} [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
la source
1

PowerShell , 2

|sort

Essayez-le en ligne!

Il s'agit d'un extrait qui s'exécute (par exemple) dans l'équivalent PowerShell d'un REPL. Le lien TIO montre l'utilisation. Le sortest un alias pour l' Sort-Objectapplet de commande.

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

Essayez-le en ligne!

Les commandes PowerShell ne sont pas sensibles à la casse, nous pouvons donc les utiliser sortpour l'une et SORTpour l'autre. Cela prend un tableau d'entrée, le trie sur place, puis le sort.

AdmBorkBork
la source
1

Ruby, 2 programmes

Tout d'abord - le simple:

->t{t.sort}

Deuxièmement - la partie délicate:

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

J

Programme un: 3 octets

/:~

un péché /:~ 3,1,2,1 sorties1 1 2 3

Essayez-le en ligne!

NOTE en J, les nombres négatifs sont précédés de _ non - vous pouvez donc essayer 4, _10,56, _333 etc.

Programme deux: 5 octets

|.\:~
Richard Donovan
la source
J'ai corrigé votre réponse pour que le code s'affiche correctement. Bonne réponse! En outre, la Try it onlinechose des liens vers une page Web sur TIO, pour lier une page dans une réponse que vous pouvez le faire: [displayed text](link).
clismique
Merci! Je commence juste donc à comprendre lentement! Je pense que ça a l'air mieux maintenant. Votre aide très appréciée. Richard
Richard Donovan
Les programmes que vous écrivez peuvent ne partager aucun caractère; tels quels :et ~se produisent dans les deux.
Lynn
0

PHP 7, 2 programmes

Les deux programmes peuvent être joués plus.

Programme 1, 254 octets, caractères ! "$&+.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;

Tri par bulle. Utilise gotopour créer une boucle car les boucles intégrées nécessitent() .

Programme 2, 155 octets, caractères #%'(),-67ACEFINORTUYZ^_{|}~

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

IF(...){}évite l'utilisation de ;. Le code principal est codé avec XOR, car il $a déjà été utilisé dans le programme précédent. Le code:

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