Votre tâche consiste à trier un tableau contenant les chaînes "quarter", "dime", "nickel" et "penny" un certain nombre de fois sans ordre spécifique et à les trier de manière à ce qu'elles soient dans cet ordre: quarter dime nickel penny(en d'autres termes, valeur monétaire la plus élevée à la moins élevée).

Règles

1. Votre programme doit prendre un tableau en entrée contenant les noms des pièces américaines et les trier du plus grand au moins par valeur monétaire.
   • Pour ceux qui ne sont pas des États-Unis ou n'utilisent pas de monnaie, les valeurs des pièces américaines, du plus grand au moins, sont:
     • Trimestre: 25 cents
     • Dime: 10 cents
     • Nickel: 5 cents
     • Penny: 1 cent
2. Vous pouvez trier ce tableau comme vous le souhaitez, tant que la sortie est ordonnée par les valeurs monétaires indiquées ci-dessus.
3. L'entrée peut être prise de n'importe quelle manière, que ce soit des arguments de ligne de commande ou STDIN.
4. Un tableau d'entrée serait composé de toutes les chaînes en minuscules, quelque chose comme ceci:
   • quarter dime nickel nickel quarter dime penny penny
5. Le format réel de l'entrée et de la sortie dépend de vous.

Cas de test

"penny nickel dime quarter" 
-> "quarter dime nickel penny"

"nickel penny penny quarter quarter quarter dime dime dime dime"
-> "quarter quarter quarter dime dime dime dime nickel penny penny"

"quarter dime nickel nickel quarter dime penny penny"
-> "quarter quarter dime dime nickel nickel penny penny"

Il s'agit de code-golf , donc les règles et lacunes standard s'appliquent.

Japt , 5 3 octets

ñg9

Testez-le en ligne!

Explication

Moi aussi, j'ai ajouté une fonction de tri à ma langue au cours des dernières semaines :-) ñprend un tableau et une fonction et trie le tableau comme si chaque élément avait été mappé via cette fonction.

La gfonction sur une chaîne prend un nombre net retourne le nth caractère dans la chaîne, encapsulant si nest négatif ou passé la fin de la chaîne. Les chaînes peuvent ainsi être alignées comme suit:

quarterquarter...
dimedimedimedi...
nickelnickelni...
pennypennypenn...

Le 9ème caractère (indexé 0) de chaque chaîne a été mis en évidence en gras. Ce sont dans le bon ordre, donc tout ce que nous avons à faire est ñg9. (Bien que maintenant que j'y repense, ñg5cela fonctionnerait aussi ...)

V , 7 octets

ú/¨qu©¿

Essayez-le en ligne!

Cela utilise la nouvelle commande de tri que j'ai ajoutée à V il y a environ une semaine ( ú). Bon timing!

La façon dont cela fonctionne est en triant chaque ligne par tri par défaut (valeurs ASCII) mais en ignorant la première correspondance d'une certaine expression régulière. Dans ce cas, l'expression rationnelle l'est (qu)?, bien qu'elle contienne des éléments bruts non ASCII pour éviter d'utiliser des barres obliques inverses. Si vous ignorez les deux premières lettres de «quart», il commence par «a», puis toutes les pièces sont déjà dans l'ordre alphabétique.

Version non concurrente, 4 octets

ú!/.

Cette fonctionnalité était déjà implémentée, mais je ne l'avais pas encore testée de manière approfondie, donc elle contenait un bogue que je n'ai réalisé qu'à cause de ce défi. Il n'y a pas de lien TIO car TIO est légèrement en retard.

Cela fonctionne en inversant le tri de chaque ligne mais en ignorant le premier caractère de chaque ligne.

Python, 36 octets

lambda a:a.sort(key=lambda x:x[-5:])

Fonction sans nom qui trie la liste sur place en fonction de la fonction clé indiquée.

Les tranches de chaque nom de pièce sont alors, arter, dime, ickelet penny- qui sont dans l' ordre alphabétique (ou plus important encore , ordinale) commande.

Bash + coreutils, 18

tr q b|sort|tr b q

• Translittérer q en b
• Trier
• Translittérer b en q

Essayez-le en ligne .

Python 3 , 42 41 38 octets

Une fonction lambda sans nom qui prend l'entrée comme une liste de chaînes, trie en place.

(Outgolfé par Jonathan Allan)

lambda x:x.sort(key=lambda s:(s*2)[5])

Essayez-le en ligne!

Autres solutions avec lesquelles je me suis amusé:

lambda x:x.sort(key=lambda s:s*(s<'q'))
lambda x:x.sort(key=lambda s:(s+'pi')[5])
lambda x:x.sort(key=lambda s:ord(s[3])%16)

PowerShell , 21 octets

$args|sort{($_*3)[9]}

Essayez-le en ligne!

Explication

Sans vergogne a volé l'algorithme dans la réponse d'ETHproductions (essentiellement). Je multiplie chaque chaîne par 3, puis je trie en fonction du 9e caractère de la chaîne résultante.

Gelée , 4 octets

6ịµÞ

Essayez-le en ligne! (le pied de page,,ÇYrejoint la liste résultante avec des sauts de ligne pour une impression plus jolie.)

Comment?

6ịµÞ - Main link: list of strings
  µ  - monadic chain separation
   Þ - sort the list of strings by the monadic function:
6ị   - the sixth index - Jelly indexing is modular and 1-based

Le Nème index d'une liste dans Jelly est le Nème élément commençant à gauche, en comptant à partir de 1, et rebouclant au début si nécessaire. (Le 0ème est à droite, le -1ème à gauche et ainsi de suite).

Donc, le sixième caractère de ['d','i','m','e']est 'i'puisque six est congru à deux modulo quatre.

Le sixième caractère des quatre pièces dans l'ordre est quart er, d ime, nicke l, penny. Ceux-ci sont classés par ordre alphabétique (ou, plus important, ordinal).

Une autre façon de réaliser la même chose serait de trier par les chaînes en rotation avec ṙ5µÞ, où ṙtourne vers la droite, ce qui rend les cordes erquart, imed, lnicke, et penny.

Python , 32 octets

lambda s:s.sort(key="npr".strip)

Essayez-le en ligne! Trie la liste en place.

L'idée est d'utiliser une fonction de touche de tri sans lambda. Un bon candidat était x.strip, qui prend la chaîne xet supprime ses bords gauche et droit de tous les caractères de l'entrée. Par exemple "abcdef".strip("faces") == "bcd",.

La méthode "npr".stripprend:

quarter ->  np
dime    ->  npr
nickel  ->  pr
penny   ->  r

qui sont triés lexicographiquement. J'ai trouvé la chaîne nprpar force brute. npuet nptaussi travailler, et il n'y en a pas plus court.

Bash (+ coreutils) 11 octets

Golfé

sort -rk1.2

Comment ça marche

Tri inversé, avec la "clé de tri" du deuxième caractère du premier champ (mot) jusqu'à la fin de la ligne, soit:

uarter
ime
ickel
enny

Tester

>echo penny nickel dime quarter|tr ' ' '\n'|sort -rk1.2

quarter
dime
nickel
penny

Essayez-le en ligne!

CJam , 8 octets

q~{5=}$p

Essayez-le en ligne!

Explication

q~        Get and eval all input (array of coin names)
  {5=}$   Sort the array by the 5th index of each element (array indices loop in CJam)
       p  Print the result

Pyke, 9 7 5 octets

.#5R@

Essayez-le ici!

.#5R@ - sort_by:
  5R@ -  i[5]

Rétine, 10

• 6 10 octets enregistrés grâce à @ETHproductions

q
b
O`
b
q

• Remplacer qparb
• Trier
• Remplacer bretour àq

Essayez-le en ligne .

V , 8 7 octets

1 octet enregistré grâce à @DJMcMayhem

Úçq/:m0

[Essayez-le en ligne!]

Voir la réponse de @ DJMcMayhem en V ( 1 0 octets plus court que le mien)

Essayez-le en ligne!

Ú                    " sort all lines "
 ç                   " globally "
  q/                 "  where there a q is matched, "
    :m0              "  move it to the top of the buffer "

Voici une solution plus ancienne à 1 octet de plus, mais je l'aime vraiment.

V , 8 octets

Ú/q
dGHP

[Essayez-le en ligne!]

Essayez-le en ligne!

Explication

Ú        " sorts the lines

Maintenant, le tampon sera dans ce format:

dimes
nickels
pennies
quarters

Il ne reste plus qu'à déplacer les trimestres vers le haut.

/q      " search for a q "
dG      " delete everything from the first quarter to the end of buffer "
HP      " and paste it at the top of the buffer

Japt , 3 octets

ñé5

Essayez-le en ligne!

Quelques autres solutions à 3 octets:

üÅw

Essayez-le en ligne!

ü é

Essayez-le en ligne!

T-SQL, 41 36 34 octets

select*from @ order by right(a,5)

Explication

Supposons que l'entrée est préchargée dans une variable de table nommée @, avec une seule colonne nommée a, où chaque valeur est une pièce à trier.

La select * from @pièce est une plaque de chaudière «obtenir toutes les valeurs à retourner». La vraie magie opère dans la order byclause.

En utilisant la même stratégie que Johnathan Allan , je sorte par les cinq derniers caractères (SQL renverra la chaîne entière si elle est trop courte): arter, dime, ickel, penny.

JavaScript (ES6), 35 33 octets

a=>a.sort(([,...a],[,...b])=>b>a)

Cas de test

let f =

a=>a.sort(([,...a],[,...b])=>b>a)

console.log(f(['penny','nickel','dime','quarter']).join` `);
console.log(f(['nickel','penny','penny','quarter','quarter','quarter','dime','dime','dime','dime']).join` `);
console.log(f(['quarter','dime','nickel','nickel','quarter','dime','penny','penny']).join` `);

Befunge, 158 octets

~:0`v0v4<~_
9:%8_^>8*`^1p9\+1g
$:!#@_1-0" ynnep">:#,_>
1-0" lekcin">:#,_>$:!#^_
" emid">:#,_>$:!#^_1-0
>:#,_$1>-:!#^_0" retrauq"
*84g9< ^*84g91-*84g94-*84g96-

Essayez-le en ligne!

Le traitement et le tri des chaînes ne sont pas le genre de choses que vous voudriez généralement essayer dans Befunge, mais cette solution tire parti de l' observation de John Kasunich selon laquelle nous n'avons en fait pas besoin de trier quoi que ce soit. Nous comptons simplement le nombre d'occurrences de chaque pièce (qui peut facilement être déterminé à partir du premier caractère), puis nous sortons ce nombre de chaque nom de pièce dans l'ordre approprié.

Ce n'est toujours pas du tout compétitif avec les autres langues en termes de taille, mais cette approche est au moins meilleure qu'elle ne l'aurait été si nous avions essayé de gérer le défi comme un exercice de tri des chaînes.

Pyth, 3 octets

@D5

Manifestation

Sur la base de ETHproductions réponse de l » en Japt.

Explication:

@D5
@D5Q    Variable introduction
 D Q    Sort the input by
@ 5     Its fifth character

APL (Dyalog APL) , 11 octets

Prend et retourne la liste des chaînes.

{⍵[⍋↑5⌽¨⍵]}

Essayez-le en ligne!

{ fonction anonyme:

 ⍵[… ] L'argument indexé par

 ⍋ les indices ascendants de

 ↑ la matrice dont les rangées sont le rembourré

 5⌽ rotation en cinq étapes

 ¨⍵ éléments de l'argument

}

Brachylog , 3 octets

↺₉ᵒ

Essayez-le en ligne!

Approche dérobée à la réponse Japt d'ETHproductions.

       The input
  ᵒ    sorted by
↺      its elements rotated left
 ₉     by 9
       is the output.

Husk , 3 octets

Öṙ9

Essayez-le en ligne!

Porté de ma réponse Brachylog, qui arrache la réponse Japt d'ETHproductions mais n'est pas une traduction exacte car elle utilise la rotation au lieu d'un simple accès au-nième élément. Là, je l'ai fait car ∋ne vous permet pas d'indexer après la fin de l'entrée (ce qui est probablement très utile dans de nombreuses circonstances en raison de la nature déclarative du langage). En Husk, ! ne vous laissez indice après la fin de l'entrée, avec le même emballage modulaire autour de cette Japt ñg9utilisations, mais il est de 1 pour ce programme en particulier finirait par être un octet plus: Ö!10.

Ö      Sort by
 ṙ     rotation by
  9    9.

Lot, 82 octets

@for %%c in (quarter dime nickel penny)do @for %%a in (%*)do @if %%a==%%c echo %%c

Prend les entrées comme arguments de ligne de commande et les sorties vers STDOUT. Fonctionne en concaténant les listes résultant du filtrage de la liste d'origine sur chaque pièce.

Rubis, 34 octets

->m{m.sort_by{|c|c[1..2]}.reverse}

entrée et sortie sous forme de tableau de chaînes

Rubis, 31 octets

->s{s.sort_by{|i|i[1]}.reverse}

Rubis, 30 octets

->m{m.sort_by{|s|s[3].ord^16}}

Des nombres magiques trouvés par essais et erreurs. Un peu maladroit, mais plus court que l'utilisation .reverse.

Perl 6 ,  40 36  34 octets

*.sort: {(<q d n p>Zxx 1..*).Bag{~m/./}}

Essayez-le

*.sort: {%(<q d n p>Z=>1..*){~m/./}}

Essayez-le

*.sort: {%(<q d n p>Z=>^4){~m/./}}

Essayez-le

Étendu:

*\            # WhateverCode lambda ( this is the parameter )

.sort:        # sort using the following code block

{             # bare block lambda with implicit parameter ｢$_｣

  %(          # treat this list as a hash

    <q d n p> # list of first characters
    Z[=>]     # zipped using pair constructor
    ^4        # Range from 0 up-to 4 ( excludes 4 )

  ){          # get the value associated with this key

    ~m/./     # regex which gets the first character ( implicitly from ｢$_｣ )

  }

}

Mathematica, 50 octets

Flatten@{Last@#,Most@#}&@Split@Sort@StringSplit@#&

RProgN , 18 octets

~{3mtt¢\3mtt¢>}$

Expliqué

~               # Zero Space Segment
 {            } # Anonymous Function
  3m            # Repeat the inputted string 3 times
    tt¢         # And take the tenth character of that
       \3mtt¢   # Do the same for the entry underneith
             >  # Compare the ascii value of the two
               $# Sort the input by the anonymous function.

Essayez-le en ligne!

java 8, 128 112 octets

Ceci est une expression lambda pour un java.util.function.Function<String[],String[]>

s->{String r="";for(String k:"q d c p".split(" "))for(String t:s)if(t.contains(k))r+=" "+t;return r.split(" ");}

Explantion: Pour chacune des 4 pièces dans l'ordre, passez par l'entrée et ajoutez le nom de la pièce au résultat chaque fois qu'il y a une correspondance pour le caractère unique de cette pièce. Divisez le résultat en un tableau et retournez-le.

Rubis, 27 octets

->s{s.sort_by{|x|(x*2)[5]}}