Su tarea es ordenar una matriz que contenga las cadenas "quarter", "dime", "nickel" y "penny" varias veces en un orden no específico y ordenarlas para que estén en este orden: quarter dime nickel penny(en otras palabras, mayor a menor valor monetario).

Reglas

1. Su programa debe tomar una matriz como entrada que contenga los nombres de las monedas estadounidenses y ordenarlas de mayor a menor por valor monetario.
   • Para aquellos que no son de los EE. UU. O no usan el cambio, los valores de las monedas de EE. UU., De mayor a menor, son:
     • Trimestre: 25 centavos
     • Dime: 10 centavos
     • Níquel: 5 centavos
     • Penique: 1 centavo
2. Puede ordenar esta matriz de la forma que desee, siempre que la salida esté ordenada por los valores monetarios que se muestran arriba.
3. La entrada se puede tomar de cualquier manera, ya sea argumentos de línea de comandos o STDIN.
4. Una matriz de entrada sería todas cadenas minúsculas, algo como esto:
   • quarter dime nickel nickel quarter dime penny penny
5. El formato real de entrada y salida depende de usted.

Casos de prueba

"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 es el código de golf , por lo que se aplican reglas y lagunas estándar.

Japt , 5 3 bytes

ñg9

¡Pruébelo en línea!

Explicación

Yo también he agregado una función de clasificación a mi idioma en las últimas semanas :-) ñtoma una matriz y una función y clasifica la matriz como si cada elemento hubiera sido mapeado a través de esa función.

La gfunción en una cadena toma un número ny devuelve el nth char en la cadena, ajustando si nes negativo o más allá del final de la cadena. Las cadenas se pueden alinear de la siguiente manera:

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

El noveno carácter (indexado a 0) de cada cadena se ha resaltado en negrita. Estos están en el orden correcto, por lo que todo lo que tenemos que hacer es ñg9. (Aunque ahora que lo recuerdo, ñg5funcionaría también ...)

V , 7 bytes

ú/¨qu©¿

Pruébalo en línea!

Esto usa el nuevo comando de clasificación que agregué a V hace una semana ( ú). Dulce momento!

La forma en que esto funciona es ordenando cada línea de manera predeterminada (valores ASCII) pero ignorando la primera coincidencia de una expresión regular determinada. En este caso, la expresión regular es (qu)?, aunque tiene algunas cosas groseras que no son ASCII para evitar el uso de barras invertidas. Si ignora las dos primeras letras de "cuarto", comienza con 'a', y luego todas las monedas ya están en orden alfabético.

Versión no competitiva, 4 bytes

ú!/.

Esta característica ya se implementó, pero aún no la había probado exhaustivamente, por lo que tenía un error que solo me di cuenta debido a este desafío. No hay un enlace TIO porque TIO está ligeramente detrás.

Esto funciona mediante la ordenación inversa de cada línea pero ignorando el primer carácter de cada línea.

Python, 36 bytes

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

Función sin nombre que ordena la lista en el lugar por la función clave dada.

Las rebanadas de cada nombre de la moneda son entonces, arter, dime, ickel, y penny- los cuales están en orden alfabético (o más importante, ordinal).

Bash + coreutils, 18

tr q b|sort|tr b q

• Transliterar q a b
• Ordenar
• Transliterar b de nuevo a q

Pruébalo en línea .

Python 3 , 42 41 38 bytes

Una función lambda sin nombre que toma la entrada como una lista de cadenas, se ordena en su lugar.

(Afligido por Jonathan Allan)

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

Pruébalo en línea!

Otras soluciones con las que me metí:

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

Pruébalo en línea!

Explicación

Desvergonzadamente robó el algoritmo en la respuesta de ETHproductions (básicamente). Multiplico cada cadena por 3, luego ordeno según el noveno carácter de la cadena resultante.

Jalea , 4 bytes

6ịµÞ

Pruébalo en línea! (el pie de página, seÇYune a la lista resultante con avances de línea para una impresión más bonita).

¿Cómo?

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

El enésimo índice de una lista en Jelly es el enésimo elemento que comienza en la izquierda, cuenta desde 1 y regresa al inicio cuando es necesario. (El 0 está a la derecha, el -1 a la izquierda de eso y así sucesivamente).

Entonces el sexto personaje de ['d','i','m','e'] es 'i'ya que seis es congruente con dos módulo cuatro.

El sexto carácter de las cuatro monedas en orden son cuartos er, d imi, nicke l, penny. Estos están en orden alfabético (o más importante, ordinal).

Otra forma de conseguir lo mismo sería ordenar por las cadenas de girar con ṙ5µÞ, donde ṙgira a la derecha, por lo que las cuerdas erquart, imed, lnicke, y penny.

Python , 32 bytes

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

Pruébalo en línea! Ordena la lista en su lugar.

La idea es usar una función de clasificación de teclas sin a lambda. Un buen candidato fue x.strip, que toma la cadena xy elimina los bordes izquierdo y derecho de todos los caracteres en la entrada. Por ejemplo, "abcdef".strip("faces") == "bcd".

El método "npr".striptoma:

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

que están clasificadas lexicográficamente. Encontré la cuerda nprpor la fuerza bruta. npuy npttambién trabajo, y no hay ninguno más corto.

Bash (+ coreutils) 11 bytes

Golfed

sort -rk1.2

Cómo funciona

Clasificación inversa, con la "clave de clasificación" desde el segundo carácter del primer campo (palabra) hasta el final de la línea, es decir:

uarter
ime
ickel
enny

Prueba

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

quarter
dime
nickel
penny

¡Pruébelo en línea!

CJam , 8 bytes

q~{5=}$p

Pruébalo en línea!

Explicación

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@

Pruébalo aquí!

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

Retina, 10

• 6 10 bytes guardados gracias a @ETHproductions

q
b
O`
b
q

• Sustituir qab
• Ordenar
• Sustituir de bnuevo aq

Pruébalo en línea .

V , 8 7 bytes

1 byte guardado gracias a @DJMcMayhem

Úçq/:m0

[¡Pruébalo en línea!]

Ver la respuesta de @ DJMcMayhem en V ( 1 0 bytes más corto que el mío)

Pruébalo en línea!

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

Aquí hay una solución anterior de 1 byte más grande, pero realmente me gusta.

V , 8 bytes

Ú/q
dGHP

[¡Pruébalo en línea!]

Pruébalo en línea!

Explicación

Ú        " sorts the lines

Ahora el búfer estará en este formato:

dimes
nickels
pennies
quarters

Lo único que queda por hacer ahora es mover los cuartos hacia arriba.

/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

Pruébalo en línea!

Un par de otras soluciones de 3 bytes:

üÅw

Pruébalo en línea!

ü é

Pruébalo onlin!

T-SQL, 41 36 34 bytes

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

Explicación

Suponga que la entrada está precargada en una variable de tabla denominada @, con una sola columna denominada a, donde cada valor es una moneda para clasificar.

La select * from @parte es placa de caldera 'obtener todos los valores para devolver'. La verdadera magia ocurre en la order bycláusula.

Utilizando la misma estrategia que Johnathan Allan , me ordenar por los últimos cinco caracteres (SQL volveré toda la cadena si es demasiado corto): arter, dime, ickel, penny.

JavaScript (ES6), 35 33 bytes

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

Casos de prueba

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-

Pruébalo en línea!

El procesamiento y la clasificación de cadenas no son el tipo de cosas que normalmente querría intentar en Befunge, pero esta solución está aprovechando la observación de John Kasunich de que en realidad no necesitamos clasificar nada. Solo contamos el número de ocurrencias de cada moneda (que se puede determinar fácilmente desde el primer carácter), y luego mostramos muchos de los nombres de cada moneda en el orden apropiado.

Todavía no es del todo competitivo con otros idiomas en términos de tamaño, pero este enfoque es al menos mejor de lo que hubiera sido si hubiéramos tratado de manejar el desafío como un ejercicio de clasificación de cadenas.

Pyth, 3 bytes

@D5

Demostración

Sobre la base de ETHproductions respuesta 's en Japt.

Explicación:

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

APL (Dyalog APL) , 11 bytes

Toma y devuelve la lista de cadenas.

{⍵[⍋↑5⌽¨⍵]}

Pruébalo en línea!

{ función anónima:

 ⍵[... ] el argumento indexado por

 ⍋ los índices ascendentes de

 ↑ la matriz cuyas filas están acolchadas

 5⌽ cinco pasos rotados

 ¨⍵ elementos del argumento

}

Brachylog , 3 bytes

↺₉ᵒ

Pruébalo en línea!

Enfoque robado de la respuesta Japt de ETHproductions.

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

Casco , 3 bytes

Öṙ9

Pruébalo en línea!

Portado de mi respuesta Brachylog, que arranca la respuesta Japt de ETHproductions pero no es una traducción exacta ya que usa la rotación en lugar del simple acceso al elemento n-ésimo. Allí, lo hice porque ∋no te permite indexar más allá del final de la entrada (lo que probablemente sea bastante útil en muchas circunstancias debido a la naturaleza declarativa del lenguaje). En la cáscara, ! hace que deje índice más allá del final de la entrada, con la misma envoltura alrededor modular que Japt ñg9usos, pero es del 1 por lo que este programa en particular, podría llegar a ser un byte más largo: Ö!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

Toma entradas como argumentos de línea de comandos y salidas a STDOUT. Funciona mediante la concatenación de las listas resultantes del filtrado de la lista original en cada moneda.

Ruby, 34 bytes

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

entrada y salida como un conjunto de cadenas

Ruby, 31 bytes

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

Rubí, 30 bytes.

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

Números mágicos encontrados por ensayo y error. Un poco torpe, pero más corto que usar .reverse.

Perl 6 ,  40 36  34 bytes

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

Intentalo

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

Intentalo

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

Intentalo

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¢>}$

Explicado

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

Pruébalo en línea!

java 8, 128 112 bytes

Esta es una expresión lambda para 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(" ");}

Explantación: para cada una de las 4 monedas en orden, revise la entrada y agregue el nombre de la moneda al resultado cada vez que haya una coincidencia para el personaje único de esa moneda. Divide el resultado en una matriz y devuélvelo.

Rubí, 27 bytes

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