Sua tarefa é classificar uma matriz que contenha as cadeias "quarto", "moeda de dez centavos", "níquel" e "centavo" várias vezes em nenhuma ordem específica e classificá-las para que elas estejam nessa ordem: quarter dime nickel penny(em outras palavras, maior ou menor valor monetário).

Regras

1. Seu programa deve usar uma matriz como entrada, contendo os nomes das moedas dos EUA e classificá-las do maior para o menor em valor monetário.
   • Para quem não é dos EUA ou não usa troco, os valores das moedas dos EUA, do maior para o menor, são:
     • Trimestre: 25 centavos
     • Moeda de dez centavos: 10 centavos
     • Níquel: 5 centavos
     • Centavo: 1 centavo
2. Você pode classificar essa matriz da maneira que desejar, desde que a saída seja ordenada pelos valores monetários mostrados acima.
3. A entrada pode ser recebida de qualquer forma, seja argumentos de linha de comando ou STDIN.
4. Uma matriz de entrada seria composta por minúsculas, algo como isto:
   • quarter dime nickel nickel quarter dime penny penny
5. O formato real de entrada e saída é com você.

Casos de teste

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

Este é o código-golfe , portanto, aplicam-se regras e brechas padrão.

Japonês , 5 3 bytes

ñg9

Teste online!

Explicação

Também adicionei uma função de classificação ao meu idioma nas últimas semanas :-) ñpega uma matriz e uma função e classifica a matriz como se cada item tivesse sido mapeado por essa função.

A gfunção em uma string recebe um número ne retorna o nth char na string, quebrando se nfor negativo ou após o final da string. As seqüências de caracteres podem ser alinhadas da seguinte maneira:

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

O nono caractere (indexado 0) de cada sequência foi destacado em negrito. Eles estão na ordem correta, então tudo o que precisamos fazer é ñg9. (Embora agora que eu olhe para trás, ñg5funcione também ...)

V , 7 bytes

ú/¨qu©¿

Experimente online!

Isto usa o spiffy novo tipo de comando I adicionados ao V cerca de uma semana atrás ( ú). Momento doce!

A maneira como isso funciona é classificando todas as linhas por classificação padrão (valores ASCII), mas ignorando a primeira correspondência de um determinado regex. Nesse caso, o regex é (qu)?, embora tenha algumas coisas brutas não-ASCII para evitar o uso de barras invertidas. Se você ignorar as duas primeiras letras de "quarto", começa com 'a' e todas as moedas já estão em ordem alfabética.

Versão não concorrente, 4 bytes

ú!/.

Esse recurso já foi implementado, mas eu ainda não o havia testado extensivamente, portanto havia um bug que só percebi por causa desse desafio. Não há link TIO porque o TIO está um pouco atrasado.

Isso funciona classificando inversamente todas as linhas, mas ignorando o primeiro caractere em cada linha.

Python, 36 bytes

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

Função sem nome que classifica a lista no local pela função de chave fornecida.

As fatias de cada nome de moeda são então, arter, dime, ickel, e penny- que estão em ordem alfabética (ou, mais importante, ordinal).

Bash + coreutils, 18

tr q b|sort|tr b q

• Transliterar q para b
• Ordenar
• Transliterar b voltar para q

Experimente online .

Python 3 , 42 41 38 bytes

Uma função lambda sem nome que recebe a entrada como uma lista de seqüências de caracteres, classifica no lugar.

(Superado por Jonathan Allan)

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

Experimente online!

Outras soluções com as quais eu brinquei:

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 bytes

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

Experimente online!

Explicação

Roubou descaradamente o algoritmo na resposta da ETHproductions (basicamente). Multiplico cada string por 3 e, em seguida, classifico com base no nono caractere da string resultante.

Gelatina , 4 bytes

6ịµÞ

Experimente online! (o rodapé,ÇYjunta-se à lista resultante com alimentações de linha para uma impressão mais bonita.)

Quão?

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

O enésimo índice de uma lista no Jelly é o enésimo item, começando à esquerda, contando de 1 e retornando ao início quando necessário. (O 0º está à direita, o -1º à esquerda e assim por diante).

Portanto, o sexto caractere de ['d','i','m','e']é 'i'que seis é congruente a dois módulos quatro.

O sexto caractere das quatro moedas em ordem é quart er, d ime, nicke l, penny. Estes estão em ordem alfabética (ou mais importante, ordinal).

Outra maneira de conseguir a mesma coisa seria a de ordenar por as cordas giradas com ṙ5µÞ, onde ṙgira para a direita, fazendo com que as cordas erquart, imed, lnicke, e penny.

Python , 32 bytes

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

Experimente online! Classifica a lista no lugar.

A idéia é usar uma função de chave de classificação sem a lambda. Um bom candidato foi x.strip, que pega a string xe remove as bordas esquerda e direita de todos os caracteres da entrada. Por exemplo,"abcdef".strip("faces") == "bcd" ,.

O método "npr".stripleva:

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

que são classificadas lexicograficamente. Encontrei a corda nprpor força bruta. npue npttambém trabalho, e não há mais curto.

Bash (+ coreutils) 11 bytes

Golfe

sort -rk1.2

Como funciona

Classificação reversa, com a "chave de classificação" do segundo caractere do primeiro campo (palavra) até o final da linha, ou seja:

uarter
ime
ickel
enny

Teste

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

quarter
dime
nickel
penny

Experimente Online!

CJam , 8 bytes

q~{5=}$p

Experimente online!

Explicação

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@

Experimente aqui!

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

Retina, 10

• 6 10 bytes salvos graças a @ETHproductions

q
b
O`
b
q

• Substituto q porb
• Ordenar
• Substituir de bvolta aq

Experimente online .

V , 8 7 bytes

1 byte salvo graças a @DJMcMayhem

Úçq/:m0

[Experimente online!]

Veja a resposta de @ DJMcMayhem em V ( 1 0 bytes menor que o meu)

Experimente online!

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

Aqui está uma solução mais antiga com 1 byte maior, mas eu realmente gosto disso.

V , 8 bytes

Ú/q
dGHP

[Experimente online!]

Experimente online!

Explicação

Ú        " sorts the lines

Agora o buffer estará neste formato:

dimes
nickels
pennies
quarters

A única coisa que resta a fazer agora é mover os quartos para o topo.

/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

Japonês , 3 bytes

ñé5

Experimente online!

Algumas outras soluções de 3 bytes:

üÅw

Experimente online!

ü é

Experimente on-line!

T-SQL, 41 36 34 bytes

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

Explicação

Suponha que a entrada seja pré-carregada em uma variável de tabela denominada @, com uma única coluna denominadaa , em que cada valor é uma moeda a ser classificada.

A select * from @peça é a placa da caldeira 'obtém todos os valores para retornar'. A verdadeira magia acontece na order bycláusula.

Usando a mesma estratégia como Johnathan Allan , eu ordenar por os últimos cinco caracteres (SQL retornará a seqüência inteira se é demasiado curta): arter, dime, ickel, penny.

JavaScript (ES6), 35 33 bytes

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

Casos de teste

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

Anterior, 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-

Experimente online!

O processamento e a classificação de strings não são o tipo de coisa que você normalmente gostaria de tentar no Befunge, mas esta solução está aproveitando a observação de John Kasunich de que não precisamos realmente classificar nada. Contamos apenas o número de ocorrências de cada moeda (que pode ser facilmente determinada a partir do primeiro caractere) e, em seguida, produzimos muitos dos nomes de cada moeda na ordem apropriada.

Ainda não é nada competitivo com outros idiomas em termos de tamanho, mas essa abordagem é pelo menos melhor do que teria sido se tentássemos lidar com o desafio como um exercício de classificação de cadeias.

Pitão, 3 bytes

@D5

Demonstração

Baseado em ETHproductions resposta está em Japt.

Explicação:

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

APL (Dyalog APL) , 11 bytes

Retorna e retorna a lista de strings.

{⍵[⍋↑5⌽¨⍵]}

Experimente online!

{ função anônima:

 ⍵[... ] o argumento indexado por

 ⍋ os índices ascendentes de

 ↑ a matriz cujas linhas são acolchoadas

 5⌽ girado em cinco etapas

 ¨⍵ itens do argumento

}

Braquilog , 3 bytes

↺₉ᵒ

Experimente online!

Abordagem roubada da resposta japonesa da ETHproductions.

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

Casca , 3 bytes

Öṙ9

Experimente online!

Portado da minha resposta Brachylog, que rasga a resposta Japt da ETHproductions, mas não é uma tradução exata, pois usa rotação em vez de simples acesso ao enésimo elemento. Lá, eu fiz isso porque ∋não permite que você indexe além do final da entrada (o que provavelmente é bastante útil em muitas circunstâncias devido à natureza declarativa da linguagem). Em Husk, ! faz deixar você índice após o fim da entrada, com o mesmo em torno de embrulho modular que Japt ñg9usos, mas é a partir de 1 de modo que este programa, em particular, iria acabar por ser um byte mais: Ö!10.

Ö      Sort by
 ṙ     rotation by
  9    9.

Lote, 82 bytes

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

Leva a entrada como argumentos da linha de comando e gera STDOUT. Funciona concatenando as listas resultantes da filtragem da lista original em cada moeda.

Ruby, 34 bytes

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

entrada e saída como uma matriz de strings

Ruby, 31 bytes

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

Ruby, 30 bytes

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

Números mágicos encontrados por tentativa e erro. Um pouco desajeitado, mas mais curto do que usar .reverse.

Perl 6 ,  40 36  34 bytes

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

Tente

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

Tente

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

Tente

Expandido:

*\            # 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¢>}$

Explained

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

Try it online!

java 8, 128 112 bytes

This is a lambda expression for 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(" ");}

Explantion: For each of the 4 coins in order, go through the input and append the coin's name to the result every time there is a match for that coin's unique character. Split the result into an array and return it.

Ruby, 27 bytes

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