Where are my pennies?

Question

Given string S representing a dollar amount, make change for that amount of money use the least number of coins to make the change and record the amount of each coin in a list. Here are the coins available to use and their value.

Coin : Value
Dollar Coins : $1.00
Quarters: $0.25
Dimes: $0.10
Nickels: $0.05
Pennies: $0.01

Input

String S that contains the dollar symbol $ and the dollar amount.

Output

List of coin numbers separated by a space character " ". The list must be in this order: Dollar coins, quarters, dimes, nickels, pennies.

Constraints

• $0.00 < S < $10.00
• S is given to two decimal places.
• make change for that amount of money use the least number of coins

Example Input

$4.58

$9.99

Output

4 2 0 1 3

9 3 2 0 4

Win Condition

shortest bytes win.

Answer 1

Hexagony, 35 32 28 27 bytes

]{=?2'?!/@[1[5/P0;:!%'[01[5

Try it online!

There are no no-ops . now, so it must be optimal.

Answer 2

Python 2, 79 72 71 bytes

s=input()
d=int(s[1]+s[3:])
for c in(100,25,10,5,1):print d/c,;d-=d/c*c

Try it online!

Saved 7 bytes thanks, in part, to Chas Brown

Saved a byte thanks to Jo King

Answer 3

05AB1E, 24 17 bytes

¦'.¡25‰10‰5‰r5F?' ?}

¦'.¡`25‰`T‰`5‰`ðý

Try it online!

My first attempt at it. It's very verbose in my opinion and I'll look at further revising this answer. Maybe somebody better than me will figure it out.

Explanation

¦             # Remove '$' from input
'.¡           # Push '.' and split string on that. (dollar),(cents) is result
`25‰          # Push all items onto stack and mod top by 25
`T‰           # Push all items onto stack and mod top by 10
`5‰           # Push all items onto stack and mod top by 5
`r            # Push all items onto stack and reverse stack
ðý            # Loop through stack and print each element with space

-7 bytes thanks to Emigna

Answer 4

Octave, 106 bytes

@(n)[k=(f=@fix)(x=str2num(n(2:5))),m=f(4*(x-k)),t=f(10*(s=x-k-.25*m)),p=f(20*(s-.1*t)),100*(s-.1*t-.05*p)]

Try it online!

16 bytes is used simply to get rid of $ and convert the string to a number. The rest is simply removing the as many coins as possible, one value at a time.

Answer 5

R, 81 bytes

x=as.double(substr(scan(,""),2,6));for(i in 1/c(1,4,10,20,100))x=x-i*print(x%/%i)

Try it online!

26 bytes ensuring the data are a double rather than a string, very nearly a third of the program! That's lame, to say the least.

Answer 6

Stax, 18 17 bytes

ä┐¢6ⁿ≡♠₧ç7╦Δ╛XÄR│

Run and debug it

Answer 7

Ruby, 74 bytes

->s{n=s.delete("$.").to_i;["%s"]*5*" "%[n/100,n/25%4,(m=n/5%5)/2,m%2,n%5]}

Try it online!

Converts input to an integer containing number of pennies, then applies formulas in the [] at the end.

5 bytes standard Ruby boilerplate ->s{}
34 bytes on solving the problem
35 bytes on formatting

Answer 8

Julia, 72 71 bytes

!s=(x=parse(Int,filter(>('.'),s));[100,25,10,5,1].|>u->(t=x÷u;x%=u;t))

Attempt This Online!

• -1 byte: x=x%u -> x*=u - thanks to @MarcMush

Answer 9

Java 8, 138 bytes

s->{long p=new Long(s.replaceAll("\\D","")),c,i=100;for(s="";i>0;s+=c+" ",i=i>25?25:i>10?10:i>5?5:i>1?1:0)for(c=0;p>=i;p-=i)c++;return s;}

Explanation:

Try it online.

s->{              // Method with String as both parameter and return-type
  long p=new Long(s.replaceAll("\\D","")),
                  //  Remove all non-digits, and convert it to a number
       c,         //  Count-integer
       i=100;     //  Amount integer, starting at 100
  for(s="";       //  Set the input to an empty String, because we no longer need it
      i>0         //  Loop as long as `i` is not 0
      ;           //    After every iteration:
       s+=c+" ",  //     Append the count and a space to `s`
       i=i>25?    //     If `i` is 100:
          25      //      Change it to 25
         :i>10?   //     Else-if `i` is 25:
          10      //      Change it to 10
         :i>5?    //     Else-if `i` is 10:
          5       //      Change it to 5
         :i>1?    //     Else-if `i` is 5:
          1       //      Change it to 1
         :        //     Else (`i` is 1)
          0)      //      Change it to 0
    for(c=0;      //   Reset the count `c` to 0
        p>=i;     //   Inner loop as long as `p` is larger than or equal to `i`
        p-=i)     //     After every iteration: subtract `i` from `p`
      c++;        //    Increase the count `c` by 1
  return s;}      //  Return the result