Je sais, le titre te fait craquer

Étant donné la quantité d'argent produite, le moins de pièces constitue ce montant

Exemples

0.1
1 dime

0.01
1 penny

0.28
1 quarter 3 penny

0.56
2 quarter 1 nickel 1 penny

1.43
5 quarter 1 dime 1 nickel 3 penny

Spec

• 100 cents dans un dollar.
• Les valeurs de chaque type de pièce sont:
  • penny 1 cent
  • nickel 5 cents
  • dime 10 centimes
  • quarter 25 cents

Les éléments intégrés qui banalisent cette tâche ne sont pas autorisés.

E / S

L'entrée est une décimale représentant la valeur en dollars du total

• Pas besoin de pluraliser
• Commande: quarter->penny
• La sortie doit être <#_of_coins> <coin type>
• Séparateurs: ,ou ,ou

Le seul espace de fin autorisé est un saut de ligne / espace unique.

S'il n'y a aucun type de pièce, ce type de pièce ne doit pas être affiché . Par exemple 0.25-> 1 quarter pas 1 quarter 0 dime 0 nickel 0 penny

CJam, 60

q~e2i[25A5]{md}/]" quarterx dimex nickelx penny"'x/.+{0#},S*

Ce script semble avoir beaucoup de place à amélioration, mais il est plus court que tout jusqu'à présent. Cela utilise la commande intégrée "md" qui retourne à la fois le résultat entier d'une division et le reste. Il fait ce qui suit:

• lit l'entrée (si c'était une fonction, je suppose que vous pouvez supprimer q ~ pour deux caractères de moins)
• multiplie l'entrée par 100 et la convertit en un entier
• effectue "md" en utilisant [25 10 5] ce qui entraîne les restes sur la pile
• combine les numéros et les noms des pièces
• supprime le numéro et le nom de la pièce si le premier est 0
• ajoute des zéros de pré-numérotation

Essayez-le ici

versions antérieures:

q~e2i[25A5]{md}/]_:!:!" quarter x dime x nickel x penny"'x/.*.+e_0-
q~e2i[25A5]{md}/]_:!:!\" quarter x dime x nickel x penny"'x/.+.*

JavaScript ES6, 107 octets

n=>((n*=100)/25|0)+` quarter ${(n%=25)/10|0} dime ${n%10/5|0} nickel ${n%5|0} penny`.replace(/ ?0 \S+/g,"")

Mathématiques simples.

Python 2, 120 octets

n=int(round(input()*100))
a=25
for b in"quarter","dime","nickel","penny":
 if n>=a:print"%d "%(n/a)+b,
 n%=a;a=40/a+5^12

Juste pour être sûr, changé en quelque chose qui fonctionne définitivement pour corriger le commentaire de @ Ogaday, pour le moment du moins. Je ne sais pas si j'en ai aussi besoin int(), mais j'ai du mal à me convaincre que non.

print`n/a`+" "+b,

est un octet supplémentaire désactivé, mais affiche un extra Lpour les entrées de grande taille (bien que ce code ne fonctionne pas de toute façon pour les entrées extrêmement grandes, en raison de la précision du flottant).

dc, 104

Ajout de nouvelles lignes pour la "lisibilité" :

[dn[ quarter ]n]sq
[dn[ dime ]n]sd
[dn[ nickel ]n]sn
[d1/n[ penny ]n]sp
?A0*
25~rd0<qst
A~rd0<dst
5~rd0<nst
d0<p

Rétine , 97

Merci (comme toujours) à @randomra - enregistré 1 octet.

Suppose que l'entrée se fait sous la forme xxx.yyouxxx.y .

\..$
$&0
\.

.+
$0$*:
(:{25})+
$#1 quarter 
(:{10})+
$#1 dime 
(:{5})+
$#1 nickel 
(:)+
$#1 penny

Essayez-le en ligne.

Vitsy, 110 100 97 bytes

Ouais, attendez, je suis encore en train de méthodiser ça.

aa**Dv52^1m([N' retrauq 'Z]v52^MDva1m([N' emid 'Z]vDvaM51m([N' lekcin 'Z]v5MD([N'ynnep 'Z]
/D1M-D

Explication en mode verbeux à venir:

push a;
push a;
multiply top two;
multiply top two;
duplicate top item;
save top as temporary variable;
push 5;
push 2;
push second to top to the power of top;
push 1;
goto top method;
if (int) top is 0;
begin recursive area;
output top as number;
push " quarter ";
output stack as chars;
end recursive area;
save top as temporary variable;
push 5;
push 2;
push second to top to the power of top;
modulo top two;
duplicate top item;
save top as temporary variable;
push a;
push 1;
goto top method;
if (int) top is 0;
begin recursive area;
output top as number;
push " dime ";
output stack as chars;
end recursive area;
save top as temporary variable;
duplicate top item;
save top as temporary variable;
push a;
modulo top two;
push 5;
push 1;
goto top method;
if (int) top is 0;
begin recursive area;
output top as number;
push " nickel ";
output stack as chars;
end recursive area;
save top as temporary variable;
push 5;
modulo top two;
duplicate top item;
if (int) top is 0;
begin recursive area;
output top as number;
push " penny";
output stack as chars;
end recursive area;
:
divide top two;
duplicate top item;
push 1;
modulo top two;
subtract top two;
duplicate top item;

Essayez-le en ligne!

Java 8 lambda, 165 octets

Attend l'entrée ycomme double ou flottante.

y->{int c,d=(int)(y*100);return(((c=d/25)>0)?c+" quarter ":"")+(((c=(d=d%25)/10)>0)?c+" dime ":"")+(((c=(d=d%10)/5)>0)?c+" nickel ":"")+(((d=d%5)>0)?d+" penny":"");}

Tellement ternaire. ; -;

JavaScript ES6, 202 200 octets

J'espère que cela peut être joué au golf ...

r=>eval('i=[.25,.1,.05,.01];v=[0,0,0,0];for(k=0;k<4;k++)for(;r>=i[k];v[k]++,r-=i[k],r=((r*100+.01)|0)/100);v.map((x,i)=>x?x+" "+"quarter0dime0nickel0penny".split(0)[i]:"").join` `.replace(/ +/g," ")')

Code non golfé:

function m(r){
    i=[.25,.1,.05,.01]
    v=[0,0,0,0]
    for(k=0;k<4;k++)for(;r>=i[k];v[k]++,r-=i[k],r=((r*100+.01)|0)/100);
    return v.map((x,i)=>x?x+" "+"quarter0dime0nickel0penny".split(0)[i]:"").join(" ").replace(/ +/g," ");
}

LabVIEW, 62 primitives LabVIEW

J'ai créé 2 tableaux pour les noms et les valeurs et parcourez-les par le haut (tableau d'index avec i) en utilisant un opérateur modulo (la chose R IQ). Les pièces restantes sont passées dans le registre à décalage.

Si la valeur est supérieure à 0, je convertis le nombre en chaîne et concatène la chaîne transmise, le nombre et le nom de la pièce et la remets dans le registre à décalage.

Ijus a réalisé que mon gif ne montre pas le faux étui mais il n'y a rien à voir de toute façon, il passe juste à travers la chaîne qui est entrée.

Japt, 77 octets

` {U*=L /25|0} quÂòr {U%=25 /A|0} ÜX {U%A/5|0} Íõel {U%5|0} p¿ny` r" 0 %S+" x

Heureusement, les quatre noms de pièces sont compressables. Le ¿devrait être l'octet littéral 0x81. Testez-le en ligne!

C, 147 144 142 140 140 octets

a[]={25,10,5,1},m,i=0;f(float n){for(m=n*100;i<4;m%=a[i++])m/a[i]&&printf("%d %s ",m/a[i],(char*[]){"quarter","dime","nickel","penny"}[i]);}

Non golfé avec des tests:

#include <stdio.h>

a[]={25,10,5,1},m,i=0;

f(float n)
{
    for(m=n*100;i<4;m%=a[i++])
        if(m/a[i])
            printf("%d %s ",m/a[i],(char*[]){"quarter","dime","nickel","penny"}[i]);
}

int main()
{
    float test[] = {.1, .01, .28, .56, 1.43};
    for(int j = 0; j < 5; i = 0)
    {
        f(test[j++]);
        printf("\n");
    }
}

MATL , 82 106 107

'%i quarter %i dime %i nickel %i penny'i[.25 .1 .05]"@2#\w]100*Yo5$YD'0 \S+ ?'[]YX

Essayez-le sur MATL Online!

JavaScript, 156 145 144 octets

Aucune correspondance avec la réponse de la formule d'ETHproduction, mais de toute façon ...

function c(t){n=['quarter','dime','nickel','penny'];v=[.25,.1,.05,.01];s='';for(i in v){c=t/v[i]|0;if(c>0)s+=c+' '+n[i]+' ';t-=c*v[i];}return s}

C'est l'une de mes premières rondes de golf, donc toutes les améliorations sont très appréciées! J'ai déjà volé le "xor trunc" d'ETH - désolé, c'était trop intelligent :-)

Plus lisible:

function c(t)
{
  n = ['quarter', 'dime', 'nickel', 'penny'];
  v = [.25, .1, .05, .01];
  s = '';
  for(i in v)
  {
    c = t/v[i]|0;
    if(c>0) s += c+' '+n[i]+' ';
    t -= c*v[i];
  }
  return s
}

Remarque: Lors du test réalisé que je JavaScript (? Au moins sur ma machine) Divise 1.13 / 0.01à 1.12999..., faire mes (et probablement tous les autres soumissions de JS) fonctionne pas correctement ... 100%

Perl 5 - 128 124 octets

Je suppose que cela peut être réécrit pour être beaucoup plus court mais je ne peux vraiment pas le voir.

$s=<>*100;@v=($s/25,$s%2.5,$s%25%10/5,$s%250%5);map{$l=int($_);print$l.$".qw(quarter dime nickel penny)[$i].$"if$l>0;$i++}@v

EDIT: Juste une astuce mathématique pour enregistrer 4 caractères.

Perl 6 , 96 octets

$/=get;put map {$_=Int($//$^a);$/%=$a;"$_ $^b" if $_},<.25 quarter .1 dime .05 nickel .01 penny>

$/ = get; # set $/ to the input

# print the following list with spaces between
# and a newline at the end
put map {
  # the parameters to this block are $a, and $b
  # which are declared as placeholder parameters $^a, and $^b

  $_ = Int( $/ / $^a ); # set $_ to the count of the current coin

  $/ %= $a;             # set $/ to the modulus of itself and the current coin

  "$_ $^b" if $_        # return a string if $_, otherwise return Empty
},
<
  .25 quarter
  .1  dime
  .05 nickel
  .01 penny
>

Usage:

for amount in  0.1  0.01  0.28  0.56  1.43; do
  echo $amount | perl6 -e'…';
done

1 dime
1 penny
1 quarter 3 penny
2 quarter 1 nickel 1 penny
5 quarter 1 dime 1 nickel 3 penny

Python 2, 167 161 octets

Mise à jour 1: l'idée de Stole Sp3000 d'utiliser input () et de faire de mon code un script au lieu d'une fonction.

a=input()*100;k={25:0,10:0,5:0,1:0}
for i in k:k[i]=a//i;a%=i
print' '.join(['%d %s'%(k[x],{25:'quarter',10:'dime',5:'nickel',1:'penny'}[x]) for x in k if k[x]])

C, 162 octets

Malheureusement, ne fonctionne pas sans #include.

#include <stdlib.h>
i,a[]={25,10,5,1};main(c,v)char**v;{for(c=atof(v[1])/.01;c;c%=a[i++])c/a[i]?printf("%d %s ",c/a[i],"quarter\0dime\0   nickel\0 penny"+8*i):0;}

Non golfé

#include <stdlib.h>

i,a[]={25,10,5,1}; /* loop index, coin values */

main(c,v) char**v;
{
    /* Get dollar amount from command line, convert to pennies */
    for (c=atof(v[1])/.01;c;c%=a[i++]) /* loop while still change... */
    {
        c/a[i] /* if there are coins at this index... */
            ? printf("%d %s ", c/a[i], "quarter\0dime\0   nickel\0 penny"+8*i) /* print out how many */
            : 0;
    }
}

Lua 5.3, 141 139 132 131 131 octets

En quelque sorte basé sur la réponse Python de Sp3000, mais avec ma propre formule magique.

n=.5+100*io.read'n'a=25
for s in("quarter dime nickle penny "):gmatch".- "do
_=n<a or io.write(s,~~(n//a)," ")n=n%a
a=35%a|#s%2
end

Modifier - amélioré la aformule. Auparavant, c'étaita=a*3%13~#s%4 .

Edit 2 - auparavant, j'utilisais math.ceilpour arrondir et convertir en entier. Maintenant je réutilise //pour arrondir et ajouter~~ pour convertir en entier.

Edit 3 - rasé un personnage en changeant le motif de "%w+ "à ".- ".

K (oK) , 95 78 octets

Solution:

{" "/,/`quarter`dime`nickel`penny{("";$y,x)y>0}'(-c,1)!'{y!x}\x,c:25 10 5}100*

Essayez-le en ligne!

Exemple:

{" "/,/`quarter`dime`nickel`penny{("";$y,x)y>0}'(-c,1)!'{y!x}\x,c:25 10 5}100*0.92
"3 quarter 1 dime 1 nickel 2 penny"
{" "/,/`quarter`dime`nickel`penny{("";$y,x)y>0}'(-c,1)!'{y!x}\x,c:25 10 5}100*0.95
"3 quarter 2 dime"

Explication:

Modulez l'entrée par chaque pièce, puis divisez les pièces par le résultat.

Alimentez chaque résultat avec le nom de la pièce dans une fonction, en retournant la valeur de chaîne des deux si le nombre de pièces n'est pas nul.

Aplatissez tout et joignez-vous aux espaces.

Kotlin , 147 octets

{listOf("quarter" to 25,"dime" to 10,"nickel" to 5,"penny" to 1).fold((it*100).toInt()){d,(n,a)->val z=d/a
if(z>0){print("$z $n ")
d-(z*a)}else d}}

Embellie

{
    listOf(
            "quarter" to 25,
            "dime" to 10,
            "nickel" to 5,
            "penny" to 1).fold((it * 100).toInt()) { d, (n, a) ->
        val z = d / a
        if (z > 0) {
            print("$z $n ")
            d - (z * a)
        } else d
    }
}

Tester

import java.io.ByteArrayOutputStream
import java.io.PrintStream

var f:(Double)->Unit =
{listOf("quarter" to 25,"dime" to 10,"nickel" to 5,"penny" to 1).fold((it*100).toInt()){d,(n,a)->val z=d/a
if(z>0){print("$z $n ")
d-(z*a)}else d}}

val TEST = listOf(
        0.1 to "1 dime",
        0.01 to "1 penny",
        0.28 to "1 quarter 3 penny",
        0.56 to "2 quarter 1 nickel 1 penny",
        1.43 to "5 quarter 1 dime 1 nickel 3 penny"
)

fun main(args: Array<String>) {
    val temp = ByteArrayOutputStream()
    System.setOut(PrintStream(temp))
    for ((input, output) in TEST) {
        temp.reset()
        f(input)
        println()
        val text = temp.toString().trim()
        if (text != output) {
            throw AssertionError("$input '$output' != '$text'")
        }
    }
}

TIO

TryItOnline