Il tuo compito è ordinare un array contenente le stringhe "quarter", "dime", "nickel" e "penny" un numero qualsiasi di volte in nessun ordine specifico e ordinarle in modo che siano in questo ordine: quarter dime nickel penny(in altre parole, dal più grande al minimo valore monetario).

Regole

1. Il tuo programma deve prendere una matrice come input contenente i nomi delle monete statunitensi e ordinarle dal più grande al meno in base al valore monetario.
   • Per coloro che non provengono dagli Stati Uniti o non usano il cambiamento, i valori delle monete statunitensi, dal più grande al meno, sono:
     • Quarto: 25 centesimi
     • Dime: 10 centesimi
     • Nichel: 5 centesimi
     • Penny: 1 centesimo
2. È possibile ordinare questo array nel modo desiderato, purché l'output sia ordinato in base ai valori monetari indicati sopra.
3. L'input può essere preso in qualsiasi modo, che si tratti di argomenti della riga di comando o STDIN.
4. Un array di input sarebbe tutto stringhe minuscole, qualcosa del genere:
   • quarter dime nickel nickel quarter dime penny penny
5. Il formato effettivo di input e output dipende da te.

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

Si tratta di code-golf , quindi si applicano regole standard e scappatoie.

Japt , 5 3 byte

ñg9

Provalo online!

Spiegazione

Anch'io ho aggiunto una funzione di ordinamento alla mia lingua nelle ultime settimane :-) ñaccetta un array e una funzione e ordina l'array come se ogni elemento fosse stato mappato attraverso quella funzione.

La gfunzione su una stringa accetta un numero ne restituisce il ncarattere th nella stringa, avvolgendo se nè negativo o oltre la fine della stringa. Le stringhe possono quindi essere allineate come segue:

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

Il 9 ° carattere (indicizzato 0) di ogni stringa è stato evidenziato in grassetto. Questi sono nell'ordine corretto, quindi tutto ciò che dobbiamo fare è ñg9. (Anche se ora che ci ripenso, ñg5funzionerebbe anche ...)

V , 7 byte

ú/¨qu©¿

Provalo online!

Questo utilizza il nuovo comando di ordinamento che ho aggiunto a V circa una settimana fa ( ú). Tempismo dolce!

Il modo in cui funziona è ordinando ogni riga per ordinamento predefinito (valori ASCII) ma ignorando la prima corrispondenza di una certa regex. In questo caso, il regex è (qu)?, sebbene abbia alcune cose grossolane non ASCII per evitare l'uso di barre rovesciate. Se ignori le prime due lettere di "quarter", inizia con "a", quindi tutte le monete sono già in ordine alfabetico.

Versione non competitiva, 4 byte

ú!/.

Questa funzionalità era già stata implementata, ma non l'avevo ancora testata ampiamente, quindi aveva un bug che avevo realizzato solo a causa di questa sfida. Non esiste alcun collegamento TIO perché TIO è leggermente indietro.

Funziona ordinando al contrario ogni riga ma ignorando il primo carattere su ogni riga.

Python, 36 byte

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

Funzione senza nome che ordina l'elenco sul posto in base alla funzione chiave fornita.

Le fette di ogni nome di moneta sono poi, arter, dime, ickel, e penny- che sono in ordine alfabetico (o più importante, ordinale).

Bash + coreutils, 18

tr q b|sort|tr b q

• Traslitterare da q a b
• Ordinare
• Traslitterare b di nuovo a q

Provalo online .

Python 3 , 42 41 38 byte

Una funzione lambda senza nome che accetta input come un elenco di stringhe, ordinandole al loro posto.

(Superato da Jonathan Allan)

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

Provalo online!

Altre soluzioni con cui ho pasticciato:

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

Provalo online!

Spiegazione

Spudoratamente ha rubato l'algoritmo nella risposta di ETHproductions (in pratica). Moltiplico ogni stringa per 3, quindi ordina in base al nono carattere della stringa risultante.

Gelatina , 4 byte

6ịµÞ

Provalo online! (il piè di pagina,ÇYunisce l'elenco risultante con feed di riga per una stampa più carina.)

Come?

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

L'ennesimo indice di un elenco in Jelly è l'ennesimo elemento che inizia a sinistra, contando da 1 e ritornando all'inizio quando necessario. (Lo 0 è a destra, l'1 a sinistra di quello e così via).

Quindi il sesto carattere di ['d','i','m','e']è 'i'dal momento che sei è congruente con due moduli quattro.

Il sesto personaggio delle quattro monete in ordine sono quart er, d ime, nicke l, penny. Questi sono in ordine alfabetico (o, soprattutto, ordinale).

Un altro modo per ottenere la stessa cosa sarebbe quella di sorta dagli archi ruotato ṙ5µÞ, dove ṙgira a destra, rendendo le corde erquart, imed, lnicke, e penny.

Python , 32 byte

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

Provalo online! Ordina l'elenco in posizione.

L'idea è di utilizzare una funzione chiave di ordinamento senza a lambda. Era un buon candidato x.strip, che prende la stringa xe rimuove i suoi bordi sinistro e destro tutti i caratteri nell'input. Ad esempio "abcdef".strip("faces") == "bcd",.

Il metodo "npr".striprichiede:

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

che sono ordinati lessicograficamente. Ho trovato la corda nprcon la forza bruta. npue nptfunziona anche, e non ce ne sono più brevi.

Bash (+ coreutils) 11 byte

golfed

sort -rk1.2

Come funziona

Ordinamento inverso, con la "chiave di ordinamento" dal secondo carattere del primo campo (parola) fino alla fine della riga, ovvero:

uarter
ime
ickel
enny

Test

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

quarter
dime
nickel
penny

Provalo online!

CJam , 8 byte

q~{5=}$p

Provalo online!

Spiegazione

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 byte

.#5R@

Provalo qui!

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

Retina, 10

• 6 10 byte salvati grazie a @ETHproductions

q
b
O`
b
q

• Sostituire qab
• Ordinare
• Sostituisci di bnuovo aq

Provalo online .

V , 8 7 byte

1 byte salvato grazie a @DJMcMayhem

Úçq/:m0

[Provalo online!]

Vedi la risposta di @ DJMcMayhem in V ( 1 0 byte più breve della mia)

Provalo online!

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

Ecco una soluzione più vecchia a 1 byte più grande, ma mi piace molto.

V , 8 byte

Ú/q
dGHP

[Provalo online!]

Provalo online!

Spiegazione

Ú        " sorts the lines

Ora il buffer sarà in questo formato:

dimes
nickels
pennies
quarters

L'unica cosa che resta da fare ora è spostare i quarti in cima.

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

ñé5

Provalo online!

Un paio di altre soluzioni a 3 byte:

üÅw

Provalo online!

ü é

Provalo onlin!

T-SQL, 41 36 34 byte

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

Spiegazione

Supponiamo che l'input sia precaricato in una variabile di tabella denominata @, con una singola colonna denominata a, in cui ogni valore è una moneta da ordinare.

La select * from @parte è la piastra della caldaia 'ottenere tutti i valori per restituire'. La vera magia accade nella order byclausola.

Utilizzando la stessa strategia di Johnathan Allan , mi ordina per gli ultimi cinque caratteri (SQL ritornerò l'intera stringa se è troppo breve): arter, dime, ickel, penny.

JavaScript (ES6), 35 33 byte

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

Casi 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 byte

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

Provalo online!

L'elaborazione e l'ordinamento delle stringhe non sono il genere di cose che vorresti tipicamente tentare in Befunge, ma questa soluzione sfrutta l' osservazione di John Kasunich secondo cui non è necessario ordinare nulla. Contiamo solo il numero di occorrenze di ogni moneta (che può essere facilmente determinata dal primo carattere), quindi emettiamo quel numero di ciascuna moneta nell'ordine appropriato.

Non è ancora affatto competitivo con altre lingue in termini di dimensioni, ma questo approccio è almeno migliore di quello che sarebbe stato se avessimo provato a gestire la sfida come un esercizio di selezione delle stringhe.

Pyth, 3 byte

@D5

Dimostrazione

Sulla base di ETHproductions risposta s' in Japt.

Spiegazione:

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

APL (Dyalog APL) , 11 byte

Prende e restituisce un elenco di stringhe.

{⍵[⍋↑5⌽¨⍵]}

Provalo online!

{ funzione anonima:

 ⍵[... ] l'argomento indicizzato da

 ⍋ gli indici ascendenti di

 ↑ la matrice le cui file sono imbottite

 5⌽ cinque passi ruotata

 ¨⍵ elementi dell'argomento

}

Brachylog , 3 byte

↺₉ᵒ

Provalo online!

Approccio rubato dalla risposta Japt di ETHproductions.

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

Buccia , 3 byte

Öṙ9

Provalo online!

Portato dalla mia risposta Brachylog, che strappa la risposta Japt di ETHproductions ma non è una traduzione esatta poiché usa la rotazione invece del semplice accesso all'ennesimo elemento. Lì l'ho fatto perché ∋non ti consente di indicizzare oltre la fine dell'input (che è probabilmente abbastanza utile in molte circostanze a causa della natura dichiarativa della lingua). In buccia, ! non si lascia indice oltre la fine dell'input, con lo stesso intorno involucro modulare che Japt ñg9utilizzi, ma è da 1 così questo programma in particolare finirebbe per essere un byte più: Ö!10.

Ö      Sort by
 ṙ     rotation by
  9    9.

Lotto, 82 byte

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

Accetta input come argomenti della riga di comando e output su STDOUT. Funziona concatenando le liste risultanti dal filtraggio della lista originale su ogni moneta.

Rubino, 34 byte

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

input e output come una matrice di stringhe

Rubino, 31 byte

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

Rubino, 30 byte

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

Numeri magici trovati per tentativi ed errori. Un po 'goffo, ma più corto dell'uso .reverse.

Perl 6 ,  40 36  34 byte

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

Provalo

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

Provalo

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

Provalo

Allargato:

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

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

RProgN , 18 byte

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

spiegato

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

Provalo online!

java 8, 128 112 byte

Questa è un'espressione lambda per 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(" ");}

Spiegazione: Per ciascuna delle 4 monete in ordine, esaminare l'ingresso e aggiungere il nome della moneta al risultato ogni volta che c'è una corrispondenza per il carattere unico di quella moneta. Dividi il risultato in un array e restituiscilo.

Rubino, 27 byte

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