Ihre Aufgabe ist es, ein Array mit den Zeichenfolgen "quarter", "dime", "nickel" und "penny" beliebig oft in einer bestimmten Reihenfolge zu sortieren und sie so zu sortieren, dass sie in der folgenden Reihenfolge quarter dime nickel pennyvorliegen: größter bis kleinster Geldwert).

Regeln

1. Ihr Programm muss ein Array als Eingabe verwenden, das die Namen der US-Münzen enthält, und diese vom größten bis zum geringsten Geldwert sortieren.
   • Für diejenigen, die nicht aus den USA stammen oder kein Wechselgeld verwenden, sind die Werte der US-Münzen vom höchsten bis zum niedrigsten:
     • Vierteljahr: 25 Cent
     • Cent: 10 Cent
     • Nickel: 5 Cent
     • Penny: 1 Cent
2. Sie können dieses Array nach Belieben sortieren, solange die Ausgabe nach den oben angegebenen Geldwerten geordnet ist.
3. Die Eingabe kann auf jede Art und Weise erfolgen, sei es durch Befehlszeilenargumente oder STDIN.
4. Ein Eingabearray besteht aus Kleinbuchstaben wie folgt:
   • quarter dime nickel nickel quarter dime penny penny
5. Das tatsächliche Format der Ein- und Ausgabe liegt bei Ihnen.

Testfälle

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

Dies ist Codegolf , daher gelten Standardregeln und -lücken.

Japt , 5 3 Bytes

ñg9

Online testen!

Erläuterung

Auch ich habe in den letzten Wochen meiner Sprache eine Sortierfunktion hinzugefügt :-) ñ ein Array und eine Funktion auf und sortiert das Array so, als ob jedes Element über diese Funktion zugeordnet worden wäre.

Die gFunktion für eine Zeichenfolge nimmt eine Zahl auf nund gibt das nth-Zeichen in der Zeichenfolge zurück, das umbrochen wird, wenn nes negativ ist oder hinter dem Ende der Zeichenfolge liegt. Die Zeichenfolgen können also wie folgt ausgerichtet werden:

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

Das 9. Zeichen (0-indiziert) jeder Zeichenfolge wurde fett hervorgehoben. Diese sind in der richtigen Reihenfolge, also müssen wir nur noch tun ñg9. (Obwohl ich jetzt darauf zurückblicke, ñg5würde es auch funktionieren ...)

V , 7 Bytes

ú/¨qu©¿

Probieren Sie es online!

Dabei wird der schicke neue Art Befehl , den ich vor etwa einer Woche V hinzugefügt ( ú). Süßes Timing!

Das funktioniert, indem jede Zeile standardmäßig sortiert wird (ASCII-Werte), aber die erste Übereinstimmung einer bestimmten Regex ignoriert wird. In diesem Fall ist der reguläre Ausdruck (qu)?, obwohl er einige grobe Nicht-ASCII-Elemente enthält, um die Verwendung von Backslashes zu vermeiden. Wenn Sie die ersten beiden Buchstaben von "Quartal" ignorieren, beginnt es mit "a", und dann sind alle Münzen bereits in alphabetischer Reihenfolge.

Nicht konkurrierende Version, 4 Bytes

ú!/.

Dieses Feature wurde bereits implementiert, aber ich hatte es noch nicht ausgiebig getestet, sodass es einen Fehler aufwies, den ich nur aufgrund dieser Herausforderung bemerkte. Es gibt keine TIO-Verbindung, da TIO leicht zurückliegt.

Dies funktioniert durch umgekehrtes Sortieren jeder Zeile, wobei das erste Zeichen in jeder Zeile ignoriert wird.

Python, 36 Bytes

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

Unbenannte Funktion, die die Liste direkt nach der angegebenen Schlüsselfunktion sortiert.

Die Scheiben von jeder Münze Namen werden dann arter, dime, ickel, und penny- die in alphabetischer (oder noch wichtiger, ordinal) um.

Bash + Coreutils, 18

tr q b|sort|tr b q

• Transkribiere q nach b
• Sortieren
• Transliteriere b zurück nach q

Probieren Sie es online aus .

Python 3 , 42 41 38 Bytes

Eine unbenannte Lambda-Funktion, die Eingaben als Liste von Zeichenfolgen annimmt, wird an Ort und Stelle sortiert.

(Ausgolfed von Jonathan Allan)

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

Probieren Sie es online!

Andere Lösungen, mit denen ich herumgespielt habe:

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 Byte

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

Probieren Sie es online!

Erläuterung

Schamlos stahl der Algorithmus in der Antwort von ETHproductions (im Grunde genommen). Ich multipliziere jede Zeichenfolge mit 3 und sortiere dann nach dem 9. Zeichen der resultierenden Zeichenfolge.

Gelee , 4 Bytes

6ịµÞ

Probieren Sie es online! (Die FußzeileÇYverbindet die resultierende Liste mit Zeilenvorschüben, um einen schöneren Ausdruck zu erhalten.)

Wie?

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

Der N-te Index einer Liste in Jelly ist der N-te Eintrag, der links beginnt, von 1 zählt und bei Bedarf zum Anfang zurückkehrt. (Die 0te ist rechts, die -1te links davon und so weiter).

Das sechste Zeichen von ['d','i','m','e']is 'i'since six ist also kongruent zu two modulo four.

Das sechste Zeichen der vier Münzen ist quart er, d ime l, pnicke , enny. Diese sind alphabetisch (oder vor allem ordinal) sortiert.

Eine andere Möglichkeit , das Gleiche zu erreichen würde durch die gedrehten Saiten Art sein mit ṙ5µÞ, wo ṙdreht sich nach rechts, die Saiten zu machen erquart, imed, lnicke, und penny.

Python , 32 Bytes

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

Probieren Sie es online! Sortiert die Liste an Ort und Stelle.

Die Idee ist, eine Sortierschlüsselfunktion ohne ein zu verwenden lambda. Ein guter Kandidat war x.strip, der die Zeichenkette nimmt xund am linken und rechten Rand alle Zeichen in der Eingabe entfernt. Zum Beispiel "abcdef".strip("faces") == "bcd".

Die Methode "npr".stripdauert:

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

die lexikographisch sortiert sind. Ich habe die Saite nprmit roher Gewalt gefunden. npuund nptauch arbeiten, und es gibt keine kürzer.

Bash (+ Coreutils) 11 Bytes

Golf gespielt

sort -rk1.2

Wie es funktioniert

Umgekehrte Sortierung mit dem "Sortierschlüssel" vom zweiten Zeichen des ersten Feldes (Wort) bis zum Zeilenende, dh:

uarter
ime
ickel
enny

Prüfung

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

quarter
dime
nickel
penny

Probieren Sie es online!

CJam , 8 Bytes

q~{5=}$p

Probieren Sie es online!

Erläuterung

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 Bytes

.#5R@

Probieren Sie es hier aus!

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

Retina, 10

• 6 10 Bytes gespart dank @ETHproductions

q
b
O`
b
q

• Ersatz q zub
• Sortieren
• bZurück zu ersetzenq

Probieren Sie es online aus .

V , 8 7 Bytes

1 Byte gespart dank @DJMcMayhem

Úçq/:m0

[Online ausprobieren!]

Siehe die Antwort von @ DJMcMayhem in V ( 1 0 Bytes kürzer als meine)

Probieren Sie es online!

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

Hier ist eine ältere Lösung mit 1 Byte größer, aber ich mag es wirklich.

V , 8 Bytes

Ú/q
dGHP

[Online ausprobieren!]

Probieren Sie es online!

Erläuterung

Ú        " sorts the lines

Der Puffer hat nun folgendes Format:

dimes
nickels
pennies
quarters

Jetzt müssen Sie nur noch die Viertel nach oben verschieben.

/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 Bytes

ñé5

Probieren Sie es online!

Einige andere 3-Byte-Lösungen:

üÅw

Probieren Sie es online!

ü é

Probieren Sie es online!

T-SQL, 41 36 34 Bytes

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

Erläuterung

Angenommen, die Eingabe ist in einer Tabellenvariablen namens @mit einer einzelnen Spalte namens vorgeladena , wobei jeder Wert eine zu sortierende Münze ist.

Das select * from @Teil ist Boiler-Plate, damit alle Werte zurückgegeben werden. Die wahre Magie geschieht in derorder by Klausel statt.

Mit der gleichen Strategie wie Johnathan Allan , ich sortiere nach den letzten fünf Zeichen (SQL wird die gesamte Zeichenkette zurück , wenn es zu kurz ist): arter, dime, ickel, penny.

JavaScript (ES6), 35 33 Bytes

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

Testfälle

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 Bytes

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

Probieren Sie es online!

Das Verarbeiten und Sortieren von Zeichenfolgen ist nicht die Art von Dingen, die Sie normalerweise in Befunge versuchen möchten, aber diese Lösung nutzt die Vorteile von John Kasunich Beobachtung dass wir eigentlich nichts sortieren müssen. Wir zählen nur die Anzahl der Vorkommen jeder Münze (die leicht anhand des ersten Zeichens bestimmt werden kann) und geben dann diese Anzahl der Münznamen in der entsprechenden Reihenfolge aus.

Es ist immer noch nicht konkurrenzfähig mit anderen Sprachen in Bezug auf die Größe, aber dieser Ansatz ist zumindest besser als es gewesen wäre, wenn wir versucht hätten, die Herausforderung als eine Übung zum Sortieren von Zeichenfolgen zu behandeln.

Pyth, 3 Bytes

@D5

Demonstration

Beyogen auf ETHproductions ‚s Antwort in Japt.

Erläuterung:

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

APL (Dyalog APL) , 11 Bytes

Übernimmt eine Liste von Zeichenfolgen und gibt sie zurück.

{⍵[⍋↑5⌽¨⍵]}

Probieren Sie es online!

{ anonyme Funktion:

 ⍵[…]  Das Argument von

 ⍋ die aufsteigenden Indizes von

 ↑ die Matrix, deren Zeilen die gepolsterten sind

 5⌽ Fünf Schritte gedreht

 ¨⍵ Punkte des Arguments

}

Brachylog , 3 Bytes

↺₉ᵒ

Probieren Sie es online!

Ansatz aus der Japt-Antwort von ETHproductions gestohlen.

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

Schale , 3 Bytes

Öṙ9

Probieren Sie es online!

Portiert aus meiner Brachylog-Antwort, die die Japt-Antwort von ETHproductions herausreißt, aber keine exakte Übersetzung ist, da sie Rotation anstelle des einfachen Zugriffs auf das n-te Element verwendet. Dort habe ich es getan, weil Sie ∋nicht über das Ende der Eingabe hinaus indizieren können (was unter vielen Umständen aufgrund des deklarativen Charakters der Sprache sehr hilfreich ist). In Husk, ! tut man Index über das Ende des Eingangs lassen, mit den gleichen modularen umschlingenden dass Japt ñg9Anwendungen, aber es ist von 1 , so das Programm insbesondere wobei ein Byte länger enden würde: Ö!10.

Ö      Sort by
 ṙ     rotation by
  9    9.

Batch, 82 Bytes

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

Übernimmt Eingaben als Befehlszeilenargumente und gibt sie an STDOUT aus. Arbeitet durch Verketten der Listen, die sich aus dem Filtern der ursprünglichen Liste auf jeder Münze ergeben.

Ruby, 34 Bytes

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

Eingabe und Ausgabe als Array von Zeichenfolgen

Ruby, 31 Bytes

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

Ruby, 30 Bytes

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

Durch Versuch und Irrtum gefundene magische Zahlen. Ein bisschen ungeschickt, aber kürzer als mit .reverse.

Perl 6 ,  40 36  34 Bytes

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

Versuch es

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

Versuch es

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

Versuch es

Erweitert:

*\            # 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 Bytes

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

RProgN , 18 Bytes

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

Erklärt

~               # 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.

Probieren Sie es online!

Java 8, 128 112 Bytes

Dies ist ein Lambda-Ausdruck für a 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(" ");}

Erklärung: Gehen Sie für jede der 4 Münzen nacheinander die Eingabe durch und hängen Sie den Namen der Münze jedes Mal an das Ergebnis an, wenn eine Übereinstimmung mit dem eindeutigen Charakter dieser Münze vorliegt. Teilen Sie das Ergebnis in ein Array und geben Sie es zurück.

Ruby, 27 Bytes

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