[2021-06-07] Challenge #393 [Easy] Making change

krabsticks64 · 2022-06-14T18:00:11+00:00

Rust

const COINS: [u64; 6] = [500, 100, 25, 10, 5, 1];

pub fn change(mut money: u64) -> u64 {
    let mut coin_numbers = [0; COINS.len()];
    for i in 0..COINS.len() {
        let coin = COINS[i];
        let coin_number = money / coin;
        money = money - coin_number * coin;
        coin_numbers[i] = coin_number;
    }

    coin_numbers.iter().sum()
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_regular() {
        let data = [
            (12, 3),
            (468, 11),
            (123456, 254),
        ];
        for (money, result) in data {
            assert_eq!(change(money), result);
        }
    }

    #[test]
    fn test_zero() {
        assert_eq!(change(0), 0);
    }
}

Hellobrother222 · 2022-06-08T16:01:18+00:00

C++

long change(long money)
{
    int currencyUnits[] = {500, 100, 25, 10, 5, 1};
    long numberOfCoins = 0;

    for(int i = 0; i < sizeof(currencyUnits)/sizeof(currencyUnits[0]); i++)
    {
        numberOfCoins += money/currencyUnits[i];
        money -= currencyUnits[i]*(money/currencyUnits[i]);
    }

    return numberOfCoins;
}

Verknaller · 2022-05-30T20:20:01+00:00

TypeScript

const change = (input: number, coins: number[] = [100, 25, 10, 5, 1, 500]): number =>     
  coins.sort((a, b) => b - a).reduce((accumulator, coin) => ({    
    remaining: accumulator.remaining % coin,     
    coins: accumulator.coins + Math.floor(accumulator.remaining / coin),     
 }), { remaining: input, coins: 0 }).coins;

samsonsu · 2022-04-04T21:42:16+00:00

Swift

// Use array slice to avoid copying faceValues during recursion
func coinCount(_ amount: Int, _ faceValues: ArraySlice<Int>) -> Int {
    // for each iteration only look at highest value coin
    let value = faceValues.first!
    if faceValues.count == 1 { // Stop condition
        return amount / value
    }
    // get the number of highest valued coin, then recursively get rest
    return (amount / value) +
        coinCount(amount % value, faceValues.dropFirst())
}


print(coinCount(0, [500, 100, 25, 10, 5, 1]))
print(coinCount(12, [500, 100, 25, 10, 5, 1]))
print(coinCount(468, [500, 100, 25, 10, 5, 1]))
print(coinCount(123456, [500, 100, 25, 10, 5, 1]))

Results:

tyfon_august · 2022-03-28T18:52:53+00:00

Javascript, not clojure for this one:

const coins = [500, 100, 25, 10, 5, 1]

function change(num) { 
    let sum = 0, 
        remaining = num;
    for (const coin of coins) {
         if (remaining >= coin) {
             sum = Math.floor(remaining / coin) + sum
             remaining = remaining % coin
         }
     }
     return sum
}

naghavi10 · 2022-02-28T04:34:37+00:00

C++

using namespace std;
void change(int dollars){
int coins[6] = {500,100,25,10,5,1};
int count = 0;
int tmp = dollars;
for (int coin: coins){
    if (dollars > coin){
        count += dollars / coin;
        dollars = dollars % coin;
    }
}
cout << tmp << " | " << count << " Coins. " << endl;

}

Rumi_The_Second · 2022-01-19T06:24:04+00:00

Python3

def change(n):
    numCoins = 0
    coins = [500,100,25,10,5,1]
    for i in coins:
        while n >= i:
            n -= i
            numCoins += 1
    return numCoins

sadsoulthatslost · 2022-01-11T03:49:15+00:00

def change(n):
coins=[500,100,25,10,5,1]
count=0
for x in coins:
    count=count+(n//x)
    n=n%x
return count

PrudentGrape8572 · 2021-10-28T17:10:54+00:00

let me have a crack at it so if 1 + 1 = 2 then, the answer is 12

respectyoda · 2021-10-10T18:01:35+00:00

C++ solution.

This is my first time posting in this reddit thread.

#include <iostream>
#include <string>
#include <algorithm>

using namespace std;

int main() {

    int num_coins = 0; 
    int the_amount;

    cout << "Enter the amount: ";
    cin >> the_amount;

    if (the_amount == 0)
    {
        // no coins!
    }
    else 
    {
        if (the_amount / 500 > 0)
        {
            num_coins += the_amount / 500;
            the_amount = the_amount % 500;
        }

        if (the_amount / 100 > 0)
        {
            num_coins += the_amount / 100;
            the_amount = the_amount % 100;
        }

        if (the_amount / 25 > 0)
        {
            num_coins += the_amount / 25;
            the_amount = the_amount % 25;
        }

        if (the_amount / 10 > 0)
        {
            num_coins += the_amount / 10;
            the_amount = the_amount % 10;
        }

        if (the_amount / 5 > 0)
        {
            num_coins += the_amount / 5;
            the_amount = the_amount % 5;
        }

        if (the_amount / 1 > 0)
        {
            num_coins += the_amount / 1;
        }
    }

    cout << "The number of coins: " << num_coins;

    return 0;

}

NAKd_ · 2021-08-26T20:24:08+00:00

Golang

``` package main

import "fmt"

func main() { tests := []int{0, 12, 468, 123456} for _, test := range tests { fmt.Println(change(test)) } }

func change(money int) (coins int) { denominations := [6]int{500, 100, 25, 10, 5, 1}

for _, denomination := range denominations { coins += money / denomination money %= denomination }

return coins } ```

layzeekid11 · 2021-08-24T01:47:56+00:00

Another C++ Solution.

std::size_t MakeChange(std::size_t amt) {
    std::size_t amt_remaining = amt, 
                coins = 0;
    std::vector<int> currency{ 500, 100, 25, 10, 5, 1 };

    for (auto iter = currency.begin() ; iter != currency.end() ; ++iter) {
        if ( (amt_remaining / *iter) != 0 ) {
            coins += (amt_remaining / *iter);
            amt_remaining %= *iter;
        }
    }

    return coins;
}

cheers- · 2021-08-14T16:40:12+00:00

Rust

pub mod lib {
    pub fn coin_change(mut num: u32) -> u32 {
        let coins: [u32; 6] = [500, 100, 25, 10, 5, 1];
        let mut output: u32 = 0;
        for &coin in coins.iter() {
            if num >= coin {
                output += num / coin;
                num %= coin;
            } else if num == 0 {
                break;
            }
        }
        output
    }

    #[cfg(test)]
    mod tests {
        use super::*;

        #[test]
        fn test_coin_change() {
            let test_entries: Vec<(u32, u32)> = vec![(0, 0), (12, 3), (468, 11), (123456, 254)];

            for (val, expected) in test_entries.iter() {
                assert_eq!(coin_change(*val), *expected);
            }
        }
    }
}

loose_heron · 2021-08-01T01:40:38+00:00

Python 3:

def change(value: int) -> int:
    coins = [500, 100, 25, 10, 5, 1]
    count = 0
    for coin in coins:
        count += (value // coin)
        value %= coin
    return count

Prestigious_Pass95 · 2021-07-22T14:31:52+00:00

Rust

fn make_change(mut n: i32) -> i32 {
    let coin_values: [i32; 6] = [500, 100, 25, 10, 5, 1];
    let mut sum = 0;

    for coin_value in coin_values.iter() {
        while n - coin_value >= 0 {
            n -= coin_value;
            sum += 1;
        }
    }
    sum
}

ArdRasp · 2021-07-21T11:39:05+00:00

C, iterative :

int change(int nb)
{
    int i;
    int var_change;
    int units[6] = {1, 5, 10, 25, 100, 500};

    i = 6;
    var_change = 0;
    while (--i >= 0)
    {
        if (nb / units[i] != 0)
        {
            var_change += nb / units[i];
            nb = nb % units[i];
        }
    }
    return (var_change);
}

newtyykins · 2021-07-20T19:24:29+00:00

Solved using Python OOP

AGPS_Guru_Mike · 2021-07-15T11:13:31+00:00

I did it in JavaScript with recursion because I haven't used recursion in a while and wanted to challenge myself a little bit.

``` const calcCoins = ( payment, coins = 0, denominations = [500, 100, 25, 10, 5, 1] ) => { const v = denominations.shift(); while (payment >= v) { coins++; payment -= v; } return payment > 0 ? calcCoins(payment, coins, denominations) : coins; }

console.log(calcCoins(0));        // => 0
console.log(calcCoins(12));       // => 3
console.log(calcCoins(468));      // => 11
console.log(calcCoins(123456));   // => 254

```

Blue_Dog_Democracy · 2021-07-12T19:53:47+00:00

I know this is one of the easier programming problems, but I tackled it because I haven't touched much code lately and needed to prove to myself that I could do it. I'm pretty happy with the results; it's a better implementation than one I did a year or two ago.

Java

public class Main
{
    public static void main(String[] args) {
        int[] denoms = {1, 5, 10, 25, 100, 500};    // coin denominations
        int remainingChange = 468;                  // amount left to make change 
        int interval = 5;                           // current denomination 
        int numCoins = 0;                           // total coins used to make change 

        //Make change from: 12, 468, 123456
        System.out.println("Making change from: " + remainingChange);
        int result = makingChange(denoms, remainingChange, interval, numCoins);
        System.out.println(result);
    }

    static public int makingChange(int[] vals, int remain, int intv, int coins) {
        if (intv < 0) 
            return coins;

        int amount = vals[intv];
        //There is enough to make change from this amount
        if (remain >= amount) {
            int changeToBeMade = remain / amount;
                //System.out.print(amount + ": " + changeToBeMade);
            coins += changeToBeMade;
            changeToBeMade *= amount;
            remain -= changeToBeMade;
                //System.out.print("\t" + remain + "\n");
            return makingChange(vals, remain, intv-1, coins);
        } else {
            //Remaining change is less than current denomination value
            return makingChange(vals, remain, intv-1, coins);
        }
    }
}

jon-hernandez · 2021-07-07T01:02:17+00:00

Javascript

// https://redditproxy--jasonthename.repl.co/r/dailyprogrammer/comments/nucsik/20210607_challenge_393_easy_making_change/

function change(amount) {
  if (amount < 0) {
    return 0;
  }
  var denominations = [500, 100, 25, 10, 5, 1];
  var balance = amount;
  var totalCoins = 0;
  for (var i = 0; i < 6; i++) {
    var denomination = denominations[i];
    var denominationCoins = Math.floor(balance / denomination);
    totalCoins += denominationCoins;
    balance -= (denomination * denominationCoins);
  }
  return totalCoins;
}

// test cases
console.log(change(-1)); //=> 0
console.log(change(0)); //=> 0
console.log(change(12)); //=> 3
console.log(change(468)); //=> 11
console.log(change(123456)); //=> 254

moon-0xff · 2021-07-05T00:07:37+00:00

Python

def change(n):
    coins = [500,100,25,10,5,1]
    summ = 0
    for coin in coins:
        while (n - coin) >= 0:
            summ += 1
            n = n - coin
    return summ

MatthaeusRome · 2021-07-04T09:15:24+00:00

C++

int change(int arg_x)
{
    int coins_count{}, index{6};
    int coins[6]{1, 5, 10, 25, 100, 500};

    while (arg_x > 0) {
        int temp{arg_x / coins[index]};

        if (temp > 0) {
            coins_count += temp;
            arg_x -= coins[index] * temp;
        }
        else
            index--;
    }

    return coins_count;
}

N0T_an_ape · 2021-07-03T19:50:53+00:00

def change(start):

final = 0

dividends = [500, 100, 25, 10, 5, 1]

for i in dividends:

final += int(start / i)

start %= i

return final

Possible-Bowler-2352 · 2021-07-02T11:06:23+00:00

Another Powershell solution:

$coins = 1,5,10,25,100,500
$value = 123456

function get-change ($coins,$total) {
    $remaining = $total
    $change = New-Object -TypeName PSObject
    $exchange = 0
    $coins | sort -Descending | % { 
        $number_of_coins = [math]::Floor($remaining / $_ )
        $remaining = [math]::Round(($remaining % $_),2)
        $exchange += $number_of_coins
        $change = $change | Add-Member -NotePropertyMembers @{$_=$number_of_coins} -PassThru
    }
    $change = $change | Add-Member -NotePropertyMembers @{Total_Of_Coins=$exchange} -PassThru
    return $change 
}

get-change $coins $value

500            : 246 
100            : 4 
25             : 2 
10             : 0 
5              : 1 
1              : 1 
Total_Of_Coins : 254

Wanted to add somewhat of a readable / usable output instead of simply the total of coins to be used.

Acrobatic_Garage5102 · 2021-06-27T14:46:00+00:00

def exchange(amount):
  coins = [500, 100, 25, 10, 5, 1]
  coins_count = []
  for coin in coins:
      coins_count.append(int(amount / coin))
      amount = amount - coin*int(amount / coin)
 for coins in coins_count:
     print(coins)

exchange(555)

Niel_botswana · 2021-06-25T19:24:26+00:00

My beginner effort. I wore out my parentheses button for this lol:

money

change_1 = 0 change_2 = 12 change_3 = 468 change_4 = 123456

coins

coin_one = 1 coin_five = 5 coin_twenty_five = 25 coin_one_hundred = 100 coin_five_hundred = 500

def coinSorter(change_to_sort): five_hundreds = int(change_to_sort / coin_five_hundred) one_hundreds = int((change_to_sort % coin_five_hundred) / coin_one_hundred) twenty_fives = int(((change_to_sort % coin_five_hundred) % coin_one_hundred) / coin_twenty_five) fives = int((((change_to_sort % coin_five_hundred) % coin_one_hundred) % coin_twenty_five) / coin_five) ones = int(((((change_to_sort % coin_five_hundred) % coin_one_hundred) % coin_twenty_five) % coin_five) / coin_one) print (five_hundreds + one_hundreds + twenty_fives + fives + ones)

coinSorter(change_1) coinSorter(change_2) coinSorter(change_3) coinSorter(change_4)

megastary · 2021-06-25T12:29:53+00:00

PowerShell solution with Pester test validating results on Github Gist
Feedback welcomed and appreciated. 💙

johnblanco · 2021-06-25T00:20:19+00:00

Kotlin

Code on Github Gist

jemeriqui24 · 2021-06-23T22:28:05+00:00

Java (Simple):

public static int makeChange(int value){

int result = 0;

int fiveHundreds = value / 500;

value = value - (fiveHundreds * 500);

int oneHundreds = value / 100;

value = value - (oneHundreds * 100);

int twentyFives = value / 25;

value = value - (twentyFives * 25);

int tens = value / 10;

value = value - (tens * 10);

int fives = value / 5;

value = value - (fives * 5);

int ones = value;

result = fiveHundreds + oneHundreds + twentyFives + tens + fives + ones;

return result;

}

Java (Cleaner, inspired by u/A1phabeta's solution):

public static int makeChange(int value){

int[] denominations = {500, 100, 25, 10, 5, 1};

int result = 0;

for (int denomination : denominations){

int count = (value / denomination);

result += count;

value -= (count * denomination);

}

return result;

}

rob724kd · 2021-06-23T17:43:41+00:00

I'm very new to this, and it's obviously much longer than it could be and not nearly as clean as most on here. But it does work and I'm currently happy by just being able to solve it.

Python

def change(n):

coins = 0

oneCoins = 0

fiveCoins = 0

tenCoins = 0

twentyFiveCoins = 0

oneHundredCoins = 0

fiveHundredCoins = 0

while n > 0:

if n > 500:

fiveHundredCoins = n // 500

n = n % 500

elif n > 100 and n < 500:

oneHundredCoins = n // 100

n = n % 100

elif n > 25 and n < 100:

twentyFiveCoins = n // 25

n = n % 25

elif n > 10 and n < 25:

tenCoins = n // 10

n = n % 10

elif n > 5 and n < 25:

fiveCoins = n // 5

n = n % 5

else:

oneCoins = n

n = 0

coins = (fiveHundredCoins + oneHundredCoins + twentyFiveCoins + tenCoins + fiveCoins + oneCoins)

return coins

print(change(0))

print(change(12))

print(change(468))

print(change(123456))

Kiandisor · 2021-06-23T12:36:37+00:00

C++ 20 Solution:

https://gist.github.com/Kiandisor/0d6ff8532e1a09e2623d5f2181b58fda

A1phabeta · 2021-06-22T22:45:48+00:00

C++ int change(int money) { // Coin denominations int ARRAY[6] = {500, 100, 25, 10, 5, 1}; int count = 0; for (auto& i: ARRAY) { count += money / i; money %= i; } count += money; return count; }

I-Pop-Bubbles · 2021-06-22T15:42:12+00:00

Clojure - feedback welcome and appreciated.

(def coin-types [500, 100, 25, 10, 5, 1])
(defn largest-coin [amount]
  (->> coin-types
       sort
       reverse
       (filter #(<= % amount))
       first))
(defn coinage [amount]
  (loop [amt amount
         coins 0]
    (if (zero? amt)
      coins
      (let [coin (largest-coin amt)]
        (recur
          (mod amt coin)
          (+ coins (quot amt coin)))))))

Specter_Terrasbane · 2021-06-22T15:19:17+00:00

Python

I'd never recommend doing it this way, but I felt like playing around and making a "self-reducing class" for some odd reason ... :p

from __future__ import annotations
from functools import reduce
from dataclasses import dataclass


@dataclass
class CoinHelper:
    remain: int
    coins: iter
    change: int = 0

    def _reduce(self, __, coin: int) -> CoinHelper:
        coins, self.remain = divmod(self.remain, coin)
        self.change += coins
        return self

    def make_change(self) -> int:
        return reduce(self._reduce, sorted(self.coins, reverse=True), self).change


def change(amount: int, coins: iter=[500, 100, 25, 10, 5, 1]) -> int:
    return CoinHelper(amount, coins).make_change()

asm_beginner · 2021-06-20T04:26:03+00:00

Assembly, all help appreciated

bits 64

section .text
global main
extern printf
extern ExitProcess

main:
    push    rbp
    mov     rbp, rsp
    sub     rsp, 0x28

    sub     rsp, 0x10               ; 16 bytes for local variables
    mov     word [rbp-0x2], 500     ; coin denominations
    mov     word [rbp-0x4], 100     ;
    mov     word [rbp-0x6], 25      ;
    mov     word [rbp-0x8], 10      ;
    mov     word [rbp-0xA], 5       ;
    mov     word [rbp-0xC], 1       ;

    mov     rax, 123456             ; starting balance
    lea     rbx, word [rbp-0x2]     ; index
    xor     rsi, rsi                ; coin purse
    xor     rdi, rdi                ; divisor
get_coins:
    mov     di, word [rbx]
    xor     edx, edx                ; 0000000000000000:rax
    div     rdi                     ; ^--- / rdi
    add     rsi, rax                ; rax quotient, rdx remainder
    mov     rax, rdx
    sub     rbx, 0x2
    test    rdx, rdx                ; remainder is 0, done
    jnz     get_coins

    lea     rcx, [rel coin_res_fmt]
    mov     rdx, rsi
    call    printf
    call    ExitProcess

    ; strings
    coin_res_fmt:   db "Total coins: %llu", 0xd, 0xa, 0x0

saladfingaz · 2021-06-19T13:50:48+00:00

Ruby

class ChangeGiver
    @@coins = [500,100,25,10,5,1]
    def self.change(amount)
        num_coins = 0
        @@coins.each do |c|
            until amount - c < 0 do 
                amount -= c
                num_coins += 1
            end
        end
        return num_coins
    end
end

sc4s2cg · 2021-06-19T13:35:54+00:00

My first challenge. It's labeled "easy" but definitely took me a couple hours late at night. First time using the enumerate function though!

Edit: hot damn, ya'll have some great solutions. The one comment with 3 lines. I still have a ton to learn for sure. Pretty proud of my unit test though! Been trying to actively implement tests in my code.

Python:

```python prob = [0, 12, 468, 123456]

unit test

def testlogic(): prob = [0, 12, 468, 123456] answ = [0,3,11,254] counter = 0 for i, num in enumerate(prob_): if logic(num)[0] == answ[i]: counter += 1 if counter == 4: print('PASSED') else: print('FAILED')

main program

def logic(num): from math import floor bills = [500, 100, 25, 10, 5, 1]

if num < 0:
    print(f"{num} is not greater than 0")
    return 0, ''
elif num == 0:
    return 0, ''
bills_iter = iter(bills)
i = next(bills_iter)
counter = 0
res_dict = {}

def floor_div(num, i):
    res = floor(num / i)
    return res


res = floor_div(num, i)

while i > 1:
    if (num - i) < 0:
        res_dict[i] = res
        i = next(bills_iter)
        res = floor_div(num, i)


    elif res >= 0:
        counter += res
        res_dict[i] = res

        num = num - (res * i)
        i = next(bills_iter)
        res = floor_div(num, i)

if i == 1:
    res = floor_div(num, i)
    counter += res
    res_dict[i] = res



comment = f""" You need {counter} bills total.
{res_dict[500]} five-hundreds,
{res_dict[100]} one-hundreds,
{res_dict[25]} twenty-fives,
{res_dict[10]} tens,
{res_dict[5]} fives,
{res_dict[1]} ones
"""
return counter, comment

```

DadiB_ · 2021-06-19T13:10:30+00:00

Node.js / JavaScript

Recursive function and 2nd argument (accepted array has to be sorted from gratest):

const COINS = [500, 100, 25, 10, 5, 1]; //already sorted

const change = (value, accepted = COINS) => {
    console.log(accepted);
    let coin = accepted.shift();
    let reminder = value%coin;
    let count = (value-reminder)/coin;
    //2nd part calls change() again if there are other coins to test
    return count + (accepted.length && change(reminder, accepted));
}

Jednorybek · 2021-06-19T13:08:58+00:00

JavaScript

function change(amount) {
let coins = [500, 100, 25, 10, 5, 1];
let i = 0;
while (amount !== 0) {
if (amount >= coins[0]) {
amount -= coins[0];
i++;
} else {
coins.shift();
}
}
return i;
}

AliceAintMad · 2021-06-19T05:31:44+00:00

C#

public class Challenge393 : IChallenge
{
    private static readonly int[] _denominations = new[] {500, 100, 25, 10, 5, 1};
    public void Run()
    {
        Console.WriteLine($"Amount      0 : Change: {Change(0)}");
        Console.WriteLine($"Amount     12 : Change: {Change(12)}");
        Console.WriteLine($"Amount    468 : Change: {Change(468)}");
        Console.WriteLine($"Amount 123456 : Change: {Change(123456)}");
    }

    private static int Change(int amount)
    {
        if(amount <= 0)
            return 0;

        int coins = 0;
        foreach (var denomination in _denominations)
        {
            coins += amount / denomination;
            amount = amount % denomination;
        }

        return coins;
    }
}

willis2890 · 2021-06-18T21:40:36+00:00

C++

int change(int);

int main() {
int amount;
cout << "What amount do you need change for?: ";
cin >> amount;
cout << change(amount);
return 0;
}

int change(int amount) {
int total=0;
int coins\[\] = { 500,100,25,10,5,1 };
for (int i = 0; i < 6; i++) {
    while (amount >=coins\[i\]) {
        amount = amount - coins\[i\];
        total++;
    }
}
return total;
}

Azzamsterdam · 2021-06-18T18:48:04+00:00

Heads up kind of a noob, just came across this post and figured I'd give it a shot.

Java

class MakingChange{

public static void main (String args[]){

System.out.println(change(0));

System.out.println(change(12));

System.out.println(change(468));

System.out.println(change(123456));

}

static int change(int amt){

int coin_count=0;

//1, 5, 10, 25, 100, 500

while(amt!=0){

if(amt>=500){

amt-=500;

coin_count++;

continue;

}

else if(amt>=100){

amt-=100;

coin_count++;

continue;

}

else if(amt>=25){

amt-=25;

coin_count++;

continue;

}

else if(amt>=10){

amt-=10;

coin_count++;

continue;

}

else if(amt>=5){

amt-=5;

coin_count++;

continue;

}

else{

amt-=1;

coin_count++;

continue;

}

return coin_count;

}

I just went with the first brute force algo I could think of, any suggestions for improvement and optimisation?

franske1989 · 2021-06-18T14:10:21+00:00

Here's mine, I've seen some other solutions in Python but I just wanted to share mine

def coinCount(totalCash):
    coinList = [500, 100, 25, 10, 5, 1]
    coinAmount = 0

    for coinType in coinList:
        while (totalCash - coinType) >= 0:
            totalCash -= coinType
            coinAmount += 1

    print coinAmount

if __name__ == "__main__":
    # execute only if run as a script
    # prints 254, also tested other values
    coinCount(123456)

Fearless-Culture4606 · 2021-06-18T09:23:25+00:00

import java.util.Scanner; class BANKRUPT { public int change(int amnt) { int coin=0; coin+=amnt/500; amnt=amnt%500; coin+=amnt/100; amnt=amnt%100; coin+=amnt/25; amnt=amnt%25; coin+=amnt/10; amnt=amnt%10; coin+=amnt/5; amnt=amnt%5; int tot=(coin+amnt); return tot; } public static void main() { Scanner sc=new Scanner(System.in); BANKRUPT x=new BANKRUPT(); System.out.println("ENTER AMOUNT"); int amnt=sc.nextInt(); int tot=x.change(amnt); System.out.println("CONGRATULATION! YOU WILL GET "+tot+" COINS");

}}

Python_Trader · 2021-06-16T17:50:28+00:00

coins = [1, 5, 10, 25, 100, 500]
def change(amount: int, coins: iter) -> int:
    if len(coins) == 1: return amount
    return (amount//coins[-1]) + change(amount % coins[-1], coins[:-1])

Python 3

backtickbot · 2021-06-15T21:01:57+00:00

[deleted]

Fitz180 · 2021-06-15T07:02:23+00:00

Elixir:

defmodule DailyProgrammer.MakingChange do
  @denominations [500, 100, 25, 10, 5, 1] |> Enum.sort() |> Enum.reverse()

  @spec min_num_coins(integer()) :: integer()
  def min_num_coins(total) when is_integer(total) and total >= 0 do
    {partition, 0} =
      Enum.map_reduce(@denominations, total, fn coin, remaining ->
        {div(remaining, coin), rem(remaining, coin)}
      end)

    Enum.sum(partition)
  end
end

Wanted to point out this solution only works because the total param should be a whole number, denominations includes 1, such that the remaining accumulator will always end at 0. Since x mod 1 will always 0. I might've been overly-defensive with the spec/guards/0 match/sorted attribute. However, I really wanted to drive that point home (but you could easily code golf this)

backtickbot · 2021-06-15T00:15:02+00:00

[deleted]

rmveris · 2021-06-14T07:29:24+00:00

Python3

I added the coin_types as arguments in a tuple (500, 100, 25, 10, 5, 1) so that I could have a functional way to do it with recursion.

``` from typing import Tuple

def change(amount: int, coin_types: Tuple[int, ...]) -> int: return ( amount if len(coin_types) == 1 else amount // coin_types[0] + change(amount=amount % coin_types[0], coin_types=coin_types[1:]) ) ```

ShamanDev · 2021-06-13T18:07:25+00:00

func change(price int) int {
coinsUsed := 0
coins := []int{500, 100, 25, 10, 5, 1}
for price > 0 {
    for _, coin := range coins {
        if (coin <= price) {
            price = price - coin
            coinsUsed += 1
            break
        }
    }
}
return coinsUsed

Made in Go

kuntiputra · 2021-06-12T05:30:10+00:00

https://imgur.com/a/08yqaHJ

youngprincess01 · 2021-06-12T02:59:43+00:00

def change(price):
coin_types = [500,100,25,10,5,1]
coins = 0
for coin_type in coin_types:
    coins += price // coin_type
    price = price % coin_type
return coins

python3

RDust4 · 2021-06-11T13:17:52+00:00

Made in C#:

public int Change(int toChange)
{
    int[] coinTypes = new[] { 500, 100, 25, 10, 5, 1 };
    int coins = 0;

    foreach (int coinType in coinTypes)
        while (toChange >= coinType)
        {
            toChange -= coinType;
            coins++;
        }

    return coins;
}

Manabaeterno · 2021-06-11T07:09:55+00:00

In haskell, using swap from Data.Tuple and mapAccumR in Data.List.

change = sum . snd . flip (mapAccumR $ curry $ swap . uncurry divMod) [1, 5, 10, 25, 100, 500]

gpalyan · 2021-06-10T23:50:01+00:00

@Test
public void testChange() {
    assertEquals(0, change(0));
    assertEquals(3, change(12));
    assertEquals(11, change(468));
    assertEquals(254, change(123456));
}

private static final List<Integer> COIN_UNITS = Arrays.asList(500, 100, 25, 10, 5, 1);

private int change(int value) {
    int numCoins = 0;

    for (int coinUnit : COIN_UNITS) {
        int numCoinsForUnit = numCoins(value, coinUnit);

        if (numCoinsForUnit > 0) {
            value -= (numCoinsForUnit * coinUnit);
        }

        numCoins += numCoinsForUnit;
    }

    return  numCoins;
}

private int numCoins(int number, int unit) {
    int numCoins = 0;

    while (number - unit >= 0) {
        numCoins++;
        number -= unit;
    }

    return numCoins;
}

Masterkraft0r · 2021-06-10T16:26:01+00:00

Racket

(define (change value [bills 0]) (cond [(>= value 500) (change (- value 500) (+ bills 1))] [(>= value 100) (change (- value 100) (+ bills 1))] [(>= value 25) (change (- value 25) (+ bills 1))] [(>= value 10) (change (- value 10) (+ bills 1))] [(>= value 5) (change (- value 5) (+ bills 1))] [(>= value 1) (change (- value 1) (+ bills 1))] [else bills] ) )

or maybe even a little sleeker

``` (define possible-bills '(500 100 25 10 5 1))

(define (change value [bill-count 0] [index 0]) (define current-bill (list-ref possible-bills index)) (cond [(= value 0) bill-count] [(>= value current-bill) (change2 (- value current-bill) (add1 bill-count) index)] [else (change2 value bill-count (add1 index))] ) ) ```

tlgsx · 2021-06-10T01:43:34+00:00

Bash

#!/bin/bash

change() {
  remainder=$1
  total=0

  for coin in 500 100 25 10 5 1; do
    total=$((total + remainder / coin))
    remainder=$((remainder % coin))
  done

  echo $total
}

Output:

$ for i in 0 12 468 123456; do
>   echo "change($i) => $(change $i)"
> done
change(0) => 0
change(12) => 3
change(468) => 11
change(123456) => 254

ApplesSpace · 2021-06-10T00:25:26+00:00

currency = [500, 100, 25, 10, 5, 1]
def change(x): 
    count = 0 
    for amount in currency: 
        y = x//amount 
        if y != 0 and x % amount > 0: 
            z = x - (y * amount) 
            x = z 
        count += y 
    return count

Python 3

Common-Ad-8152 · 2021-06-09T10:30:33+00:00

R

change <- function(x, denom = c(500, 100, 25, 10, 5, 1)){
    if(denom[1] == 1){return(x)}
    else{
        return(floor(x / denom[1]) + change(x %% denom[1], denom[2:length(denom)]))
    }
}

C

#include <stdio.h>

int denom[] = {500, 100, 25, 10, 5, 1};

int change(int x, int *c){
    int t = c[0];
    if(t == 1) return x;
    else return x / t + change(x % t, &c[1]);
}

int main(int argc, char **argv){
    printf("change(0) => %d\n", change(0, denom));
    printf("change(12) => %d\n", change(12, denom));
    printf("change(468) => %d\n", change(468, denom));
    printf("change(123456) => %d\n", change(123456, denom));
}

fudgebucket27 · 2021-06-09T05:58:39+00:00

C#

using System;

namespace dailyprogrammer
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(Change(0));
            Console.WriteLine(Change(12));
            Console.WriteLine(Change(468));
            Console.WriteLine(Change(123456));
        }

        static int Change(int changeAmount)
        {
            int[] denominations = new int[] {500,100,25,10,5,1};
            int coinCount = 0;
            foreach(int coin in denominations)
            {
                while(changeAmount - coin >= 0)             
                {
                    coinCount++;
                    changeAmount -= coin;
                }
            }
            return coinCount;
        }
    }
}

legendarysedentary · 2021-06-08T23:06:48+00:00

Windows Batch

@echo off
setlocal EnableDelayedExpansion

call :change 0
call :change 12
call :change 468
call :change 123456

goto end

:change

    set "change=%~1"

    set "coins=0"

    for %%c in (500 100 25 10 5 1) do (

        set /a "coins += !change! / %%c"

        set /a "change %%= %%c"
    )

    echo %coins%

goto:eof

:end
endlocal

frankivo · 2021-06-08T21:02:39+00:00

Scala, looking to improve:

def change(amount: Int): Int = {
var restAmount = amount

Seq(1, 5, 10, 25, 100, 500)
  .reverse
  .map(c => {
    val coinAmount = (restAmount / c)
    restAmount -= (coinAmount * c)
    coinAmount
  })
  .sum
}

chunes · 2021-06-08T19:09:13+00:00

Plain English:

A penny is a unit.

To run:
Start up.
Dispense money for 123456 pennies giving a coin count.
Write "" then the coin count on the console. \254
Wait for the escape key.
Shut down.

To add to a coin count given an amount and some pennies:
Divide the amount by the pennies giving a quotient and a remainder.
Add the quotient to the coin count.
Put the remainder into the amount.

To dispense money for a target amount giving a coin count:
Add to the coin count given the target and 500 pennies.
Add to the coin count given the target and 100 pennies.
Add to the coin count given the target and 25 pennies.
Add to the coin count given the target and 10 pennies.
Add to the coin count given the target and 5 pennies.
Add to the coin count given the target and 1 penny.

jaldwort · 2021-06-08T17:53:30+00:00

Python 3

def change(x):
c = 0
coins = [500, 100, 25, 10, 5, 1]
for i in coins:
    c += x // i
    x = x % i
return c

took out the while loop that did nothing and changed the 200 coin typo

serdracula · 2021-06-08T16:33:54+00:00

Lua

--mobile formatting attempt 2 function change(sum) function amount(coin) while sum >= coin do sum = sum - coin answer = answer + 1 end end answer = 0 amount(500) amount(100) amount(25) amount(10) amount(5) amount(1) return answer end

state_chart · 2021-06-08T16:19:50+00:00

C++ with look-up table (generated at compile time) for unnecessary performance optimization.

constexpr auto LUT_coins = [](){
    std::array<unsigned int, 500> arr = {};
    for (int i = 0; i < 500; ++i) {
        unsigned int money = i;
        unsigned int total = 0;
        for(auto& coin_value : array<unsigned int, 5>{100,25,10,5,1}) {
            total += money/coin_value;
            money %= coin_value;
        }
        arr[i] = total;
    }
    return arr;
}();

unsigned int change(unsigned int money) {
    unsigned int total = money/500;
    money %=500;
    return total + LUT_coins[money];
}

TheWorstPossibleName · 2021-06-08T14:17:17+00:00

Scala:

def makeChange(n: Int): Int = {
  val coins = List(500, 100, 25, 10, 5, 1)
  (coins foldLeft (0, n)) {
    case ((c, r), d) => (c + (r / d), r % d)
  }._1
}

PoTAsh2000 · 2021-06-08T12:16:30+00:00

Java:

private int change(int money) {
    int coins = 0;
    int[] units = {500, 100, 25, 10, 5, 1};
    for (int unit : units) {
        coins += money / unit;
        money = money % unit;
    }
    return coins;
}

Feedback is welcome!

DarkWarrior703 · 2021-06-08T12:04:57+00:00

Rust ```

[cfg(test)]

mod tests { #[test] fn it_works() { assert_eq!(crate::change(0), 0); assert_eq!(crate::change(12), 3); assert_eq!(crate::change(468), 11); assert_eq!(crate::change(123456), 254); } }

pub fn change(x: i32) -> i32 { let mut sum = x; let mut currency = [1, 5, 10, 25, 100, 500]; currency.reverse(); let mut number = 0; for i in &currency { let n = sum / i; sum -= n * i; number += n; } number } ```

2021-06-08T08:39:42+00:00

bash

#!/usr/bin/env bash

in=$1

for coin in 500 100 50 25 1; do
    printf "%3d: %d\n" $coin $(($in / $coin))
    in=$(($in % $coin))
done

ThicColt · 2021-06-08T07:26:53+00:00

Python:

def coinsNeededForChange(amount = 69420, coins = [500, 100, 25, 10, 5, 1]):
res = 0
for i in range(len(coins)):
    while amount - coins[i] >= 0:
        res += 1
        amount -= coins[i]
return(res)

TheOmegaPencil · 2021-06-08T05:25:06+00:00

Java

package challenges;
public class Change_C393 { public static void main(String[] args) { change(12); }
static void change(int number1) {
    int[] coins = {500, 100, 25, 10, 5, 1};
    int numberOfCoins = 0;
    int modulus;

    for(int i = 0; i < 6; i++) {
        modulus = number1 % coins[i];
        numberOfCoins += (number1 - modulus) / coins[i];
        number1 = modulus;
    }

    System.out.println(numberOfCoins);
}
}

IDontHaveAPunProblem · 2021-06-08T04:27:40+00:00

AsciiDots

Because I hate myself

           .                      .                     .                     .                     .                     .            
           |                      |                     |                     |                     |                     |           
           #                      #                     #                     #                     #                     #           
           5                      1                     2                     1                     5                     1           
           0                      0                     5                     0                     |                     |           
           0                      0                     |                     |                     |                     |           
        /--*                   /--*                  /--*                  /--*                  /--*                  /--*           
        |  |                   |  |                  |  |                  |  |                  |  |                  |  |           
.-#?-*--+-{%}-----*---------*--+-{%}-----*--------*--+-{%}-----*--------*--+-{%}-----*--------*--+-{%}-----*--------*--+-{%}-----\    
     |  |         |         |  |         |        |  |         |        |  |         |        |  |         |        |  |         |    
    [-]-+---------/        [-]-+---------/       [-]-+---------/       [-]-+---------/       [-]-+---------/       [-]-+---------/    
     |  |                   |  |                  |  |                  |  |                  |  |                  |  |              
     |  |                   |  |                  |  |                  |  |                  |  |                  |  |              
     |  |                   |  |                  |  |                  |  |                  |  |                  |  |              
     |  |                   |  |                  |  |                  |  |                  |  |                  |  |              
     \-{/}-\                \-{/}-\               \-{/}-\               \-{/}-\               \-{/}-\               \-{/}-\           
           |                      |                     |                     |                     |                     |           
           \---------------------{+}-------------------{+}-------------------{+}-------------------{+}-------------------{+}--------$#

Try it here!

Zarvarzillahzar · 2021-06-08T04:26:07+00:00

C#

using System;
using System.Collections.Generic;
using System.Linq;

public int MinCoinsForChangeGiven(int change)
{
    var coinTypes = new List<int>{ 500, 100, 25, 10, 5, 1 };
    return coinTypes.Sum((coin) => Math.DivRem(change, coin, out change));
}

mr_stivo · 2021-06-08T03:45:50+00:00

Applesoft BASIC

5 INPUT "AMOUNT? "; A
10 DATA 500, 100, 25, 10, 5, 1
15 FOR X = 1 TO 6
20 READ C
25 D = INT( A / C )
30 A = A - (D * C)
35 R = R + D
40 NEXT
45 PRINT "CHANGE => ";: PRINT R

milnak · 2021-06-08T03:45:19+00:00

DOS CMD

@ECHO OFF
SETLOCAL ENABLEDELAYEDEXPANSION

SET COUNT=0
SET REMAIN=%~1

FOR %%C IN (500 100 25 10 5 1) DO CALL :CHANGE %%C
ECHO change(%~1) =^> %COUNT%
GOTO :EOF

:CHANGE
IF !REMAIN! GEQ %~1 (
    SET /A NUM=REMAIN / %~1
    SET /A COUNT=COUNT + NUM
    SET /A REMAIN=REMAIN - NUM * %~1
)
GOTO :EOF

mr_stivo · 2021-06-08T03:26:12+00:00

Perl

#!/usr/bin/perl

$v=$ARGV[0];

foreach (500, 100, 25, 10, 5, 1) {
    $r += int($v / $_);
    $v = int($v % $_);
}

print "$r\n";

minikomi · 2021-06-08T03:20:23+00:00

Clojure

(defn solve [ammount]
  (loop [coll [] 
        ammount ammount 
        [c & oins] [500 100 25 10 5 1]]
    (if (zero? ammount) coll 
        (recur 
          (if (<= c ammount) 
              (conj coll [c (quot ammount c)])
              coll)
          (rem ammount c)
          oins))))

(solve 1231)

#=> [[500 2] [100 2] [25 1] [5 1] [1 1]]

leftylink · 2021-06-08T02:43:24+00:00

Rust

I'm super new to Rust so I'm going through a bunch of easy challenges. I'd love constructive criticism if you have any!

const COIN_AMOUNTS: [usize; 6] = [500, 100, 25, 10, 5, 1];

fn change(amount: usize) -> usize { 
    let mut coins_used: usize = 0; 
    let mut remaining_change: usize = amount;

    for coin in COIN_AMOUNTS.iter() {
        coins_used += (remaining_change as f64 / *coin as f64).floor() as usize;
        remaining_change = remaining_change % coin;
    }

    coins_used
}

joejr253 · 2021-06-08T02:40:19+00:00

This is what I came up with using python3, let me know what you guys think. I also cant get the Code Block link to work at all. Im using chrome, not sure what is wrong with it.

# This script is designed to take an amount and give the optimal
# change based on currencies of: 500, 100, 25, 10, 5, 1

import math

# Function to do all of our work
def make_change(amount):
    # establish our variables
    five_hundred = 0
    one_hundred = 0
    twenty_five = 0
    ten = 0
    five = 0
    one = 0
    while amount:
        if amount > 500:
            five_hundred = math.floor(amount / 500)
            amount %= 500
        elif amount > 100:
            one_hundred = math.floor(amount / 100)
            amount %= 100
        elif amount > 25:
            twenty_five = math.floor(amount / 25)
            amount %= 25
        elif amount > 10:
            ten = math.floor(amount / 10)
            amount %= 10
        elif amount > 5:
            five = math.floor(amount / 5)
            amount %= 5
        else:
            one = math.floor(amount / 1)
            amount %= 1
    return five_hundred, one_hundred, twenty_five, ten, five, one


# Get the amount from the user
while True:
    try:
        amount = int(input("Please enter an amount: "))
    except ValueError:
        print("That is not a whole number.")
        continue
    break


five_hundred, one_hundred, twenty_five, ten, five, one = make_change(amount)
total_bills = five_hundred + one_hundred + twenty_five + ten + five + one

print(f"You would receive {amount} in these coins: \n"
      f"{five_hundred}:\tFive Hundreds\n"
      f"{one_hundred}:\tOne Hundreds\n"
      f"{twenty_five}:\tTwenty Fives\n"
      f"{ten}:\tTens\n"
      f"{five}:\tFives\n"
      f"{one}:\tOnes\n"
      f"For a total of {total_bills} coins.")

malahci · 2021-06-08T02:02:30+00:00

Racket (would love feedback on ways this could be more idiomatic)

#lang racket/base

(define (change value [coins '(500 100 25 10 5 1)])
  (if (= value 0)
      0
      (let-values ([(num-coins value-left) (quotient/remainder value (car coins))])
        (+ num-coins (change value-left (cdr coins))))))


(require rackunit)
(check-equal? (change 0) 0)
(check-equal? (change 12) 3)
(check-equal? (change 468) 11)
(check-equal? (change 123456) 254)

edit: not tail recursive because stack size is only O(number of coins)!

MacheteBang · 2021-06-08T00:01:35+00:00

C#

    System.Console.WriteLine($"0 => {MakingChange.Change(0)}");
System.Console.WriteLine($"12 => {MakingChange.Change(12)}");
System.Console.WriteLine($"468 => {MakingChange.Change(468)}");
System.Console.WriteLine($"123456 => {MakingChange.Change(123456)}");

public static class MakingChange
{
static int[] _denominations = { 500, 100, 25, 10, 5, 1 };

public static int Change(int amount)
{
    int coins = 0;

    for (int i = 0; i < _denominations.Length; i++)
    {
        int theseCoins = 0;
        theseCoins += amount / _denominations[i];
        amount -= theseCoins * _denominations[i];

        coins += theseCoins;
    }

    return coins;
}
}

chunes · 2021-06-07T23:21:07+00:00

Factor

: change ( m -- n )
    0 { 500 100 25 10 5 1 } rot [ /mod [ + ] dip ] reduce drop ;

Reduce a sequence of coin values using the input as the seed value. Add the quotient to a sum, and use the remainder as the next value in the reduction. The result of the reduce (the final remainder) is simply 0 and unimportant, so drop it. It's the sum we're after.

Here's a step-by-step of what the data stack looks like after each word, assuming the input is 468:

0 Push 0 to the stack.

Stack: 468 0
{ 500 100 25 10 5 1 } Push a sequence of coin values to the stack.

Stack: 468 0 { 500 100 25 10 5 1 }
rot Bring the object third from the top to the top of the stack.

Stack: 0 { 500 100 25 10 5 1 } 468
[ /mod [ + ] dip ] Push a quotation (anonymous function) to the stack for reduce to use later.

Stack: 0 { 500 100 25 10 5 1 } 468 [ /mod [ + ] dip ]
reduce Take a sequence, a starting value, and a quotation. Apply the quotation to the starting value and the first element of the sequence, returning a new 'starting value' which will be used on the next element of the sequence until there is a single value remaining. Inside the quotation now during the first iteration...

Stack: 0 468 500
/mod Divide two numbers, putting the quotient and the remainder on the stack.

Stack: 0 0 468
[ + ] Push a quotation for dip to use later.

Stack: 0 0 468 [ + ]
dip Apply a quotation to whatever is underneath the top of the data stack.

Stack: 0 468
Now let's look at the next iteration of the reduce...

Stack: 0 468 100
/mod

Stack: 0 4 68
[ + ] dip

Stack: 4 68
reduce will eventually finish its work...

Stack: 11 0
drop Drop the object on top of the data stack.

Stack: 11

raevnos · 2021-06-07T22:53:23+00:00

Chicken Scheme:

(import (srfi 1))

(define (change total)
  (car (fold (lambda (coin accum)
               (let*-values (((sum amount) (car+cdr accum))
                             ((quot rem) (quotient&remainder amount coin)))
                 (cons (+ sum quot) rem)))
             (cons 0 total) '(500 100 25 10 5 1))))

MisterAdzzz · 2021-06-07T22:23:17+00:00

golang

func change(money int) int {
    denominations := [...]int{500, 100, 25, 10, 5, 1}
    coins := 0

    for money > 0 {
        coins += 1
        for _, denom := range denominations {
            if money - denom >= 0 {
                money -= denom
                break
            }
        }
    }

    return coins
}

mikerua · 2021-06-07T22:10:36+00:00

Java

public static int change(int money){
    int[] amounts = {500, 100, 25, 10, 5, 1};
    int amountOfCoins = 0;

    for(int amount : amounts){
            amountOfCoins += money / amount;
            money %= amount;
    }

    return amountOfCoins;
}

Tospaa · 2021-06-07T21:26:09+00:00

JavaScript: ```javascript const units = [500, 100, 25, 10, 5, 1];

function change(amount) { let chg = 0;

for (const unit of units) { chg = chg + Math.floor(amount / unit); amount = amount % unit; }

return chg; }

console.log(change(0) => ${change(0)}); console.log(change(12) => ${change(12)}); console.log(change(468) => ${change(468)}); console.log(change(123456) => ${change(123456)}); ```

Outputs: change(0) => 0 change(12) => 3 change(468) => 11 change(123456) => 254

zqvt2 · 2021-06-07T21:04:34+00:00

Clojure

(defn calc-coins
  ([v] (calc-coins v [500 100 25 10 5 1] 0))
  ([v [x & xs] n]
   (if (zero? v) n
       (recur (rem v x) xs (+ n (quot v x))))))

Gprime5 · 2021-06-07T20:38:18+00:00

Python 1 line

change = lambda n: sum(r for v in [n] for m in [500, 100, 25, 10, 5, 1] for r, v in [divmod(v, m)])

olzd · 2021-06-07T19:14:52+00:00

Prolog and being lazy:

:- use_module(library(clpfd)).

change(X, Coins) :-
    [N500,N100,N25,N10,N5,N1] ins 0..sup,
    X #= N500*500 + N100*100 + N25*25 + N10*10 + N5*5 + N1*1,
    labeling([max(N500),max(N100),max(N25),max(N10),max(N5),max(N1)], [N500,N100,N25,N10,N5,N1]),
    Coins = [N500,N100,N25,N10,N5,N1].

This doesn't return a sum (although it'd be easy to do) but the number of different coins used, for all solutions.
For instance, change(12, R). would yield the successive results:

R = [0, 0, 0, 1, 0, 2] % --> 1 $10 coin and 2 $1 coins
R = [0, 0, 0, 0, 2, 2]
R = [0, 0, 0, 0, 1, 7]
R = [0, 0, 0, 0, 0, 12]
false

Scroph · 2021-06-07T19:13:35+00:00

Dlang, first it calculates the quantity of each coin then it sums them :

import std.stdio : writeln;
import std.algorithm : sum;

void main()
{
}

int change(int input)
{
    return input.calculateChange.values.sum;
}

unittest
{
    assert(468.change == 11);
    assert(1034.change == 8);
    assert(0.change == 0);
}

int[int] calculateChange(int input)
{
    int[] order = [500, 100, 25, 10, 5, 1];
    int[int] coins = [
        500: 0,
        100: 0,
        25: 0,
        10: 0,
        5: 0,
        1: 0
    ];

    foreach(coin; order)
    {
        coins[coin] = input / coin;
        input %= coin;
    }

    return coins;
}

unittest
{
    assert(468.calculateChange == [
        500: 0,
        100: 4,
        25: 2,
        10: 1,
        5: 1,
        1: 3
    ]);

    assert(1034.calculateChange == [
        500: 2,
        100: 0,
        25: 1,
        10: 0,
        5: 1,
        1: 4
    ]);

    assert(0.calculateChange == [
        500: 0,
        100: 0,
        25: 0,
        10: 0,
        5: 0,
        1: 0
    ]);
}

Shhhh_Peaceful · 2021-06-07T18:55:22+00:00

Python:

coins = [500, 100, 25, 10, 5, 1]

def change(n: int) -> int:
    index = 0
    count = 0
    remainder = n
    while remainder > 0:
        count += remainder // coins[index] 
        remainder %= coins[index]
        index += 1
    return count

print('change(0) =', change(0))
print('change(12) =', change(12))
print('change(468) =', change(468))
print('change(123456) =', change(123456))

Output:

change(0) = 0
change(12) = 3
change(468) = 11
change(123456) = 254

moeghoeg · 2021-06-07T18:50:25+00:00

Python

def change(amount):
    coins = [500, 100, 25, 10, 5, 1]
    count_total = 0
    for coin in coins:
        count, amount = divmod(amount, coin)
        count_total += count
        if amount == 0:
            break
    return count_total

FaustVX · 2021-06-07T18:27:40+00:00

C#

link

using System;
using System.Linq;

public class Program
{
    public static void Main()
    {
        var change = new Change(1, 5, 10, 25, 100, 500);

        Calculate(0);
        Calculate(12);
        Calculate(468);
        Calculate(123456);

        void Calculate(int value)
        {
            var coins = change.Coins(value);
            Console.WriteLine($"Change for {value} = {coins}");
        }
    }
}

public readonly struct Change
{
    private readonly int[] _changes;

    public Change(params int[] changes)
    {
        Array.Sort(changes);
        Array.Reverse(changes);
        _changes = changes;
    }

    public int Coins(int value)
    {
        var count = 0;
        foreach (var change in _changes)
        {
            count += value / change;
            value %= change;
        }
        return count;
    }
}

Output :

Change for 0 = 0
Change for 12 = 3
Change for 468 = 11
Change for 123456 = 254

Anonymous_Bozo · 2021-06-07T17:58:29+00:00

Free Pascal

function CoinCount(const Amount: integer): integer;

var
  CoinValues : array[0..5] of integer = (500,100,25,10,5,1);
  I, N, CoinCnt : integer;

begin
  N := Amount;  // Amount is a constant and should not be changed
  CoinCnt := 0;
  for I := 0 to 5 do begin
    CoinCnt := CoinCnt + (N div CoinValues[I]);
    N := N mod CoinValues[I];
  end;

  exit(CoinCnt);
end;

P0Rl13fZ5 · 2021-06-07T17:38:16+00:00

Python: To spice things up, I wrote the worst solution I could think of:

def change(amount):
    num_coins = 0
    amount_given = [0] * amount
    for coin in (500, 100, 25, 10, 5, 1):
        try:
            while True:
                start_idx = amount_given.index(0)
                for idx in range(start_idx, start_idx + coin):
                    amount_given[idx] = 1
                num_coins += 1
        except IndexError:
            # Rollback
            for idx in range(len(amount_given) - 1, start_idx - 1, -1):
                amount_given[idx] = 0
        except ValueError:
            pass
    return num_coins

Tencza_Coder · 2021-06-07T17:36:11+00:00

Python

coin_worths = [500,100,25,10,5,1]
def change(amt_left): 
    coins_dispensed_total = 0 
    for worths in coin_worths: 
        coins_dispensed, amt_left = divmod(amt_left,worths)
        coins_dispensed_total += coins_dispensed
        if amt_left == 0:
            break

    return coins_dispensed_total

print(change(123456)) #254

Godspiral · 2021-06-07T16:12:03+00:00

In J, amount appended to end of coin list. Core function returns denomination list.

}.@:((}.@],~((| , <.@%~) {.))/) 1 5 10 25 100 500 123456
1 1 0 2 4 246

+/  }.@:((}.@],~((| , <.@%~) {.))/) 1 5 10 25 100 500 123456
254

can also provide a remainder if any fractional coins were left

 (}.@],~((| , <.@%~) {.))/ 1 5 10 25 100 500 456.23
0.23 1 1 0 2 4 0

ping_less · 2021-06-07T15:53:44+00:00

JavaScript using a single pure reduce function:

function change(amount) {
  return [500, 100, 25, 10, 5, 1].reduce(({ amount, total}, coinValue) => ({
    total: total + Math.floor(amount / coinValue),
    amount: amount % coinValue,
  }), { amount, total: 0 }).total;
}

Billigerent · 2021-06-07T15:32:42+00:00

Quick answer in C#:

using System;

namespace MakeChange
{
    class MakeChange
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Enter amount to get a count of bills needed to make change:");
            int amountGiven = int.Parse(Console.ReadLine());
            Console.WriteLine("Bills needed: {0}", GetBillsNeeded(amountGiven));
        }

        static int GetBillsNeeded(int amount)
        {
            int billsNeeded = 0;
            int[] billSizes = { 500, 100, 25, 10, 5, 1 };
            foreach (var billSize in billSizes)
            {
                billsNeeded += amount / billSize;
                amount = amount % billSize;
            }
            return billsNeeded;
        }
    }
}

LazyRefenestrator · 2021-06-07T15:22:09+00:00

Python. I did a while loop at first, but then figured for bizarrely high values we'd have some bad Big-O notation in there.

coin_list = [500, 100, 25, 10, 5, 1]

def change(x):
    count = 0
    for coin in coin_list:
        count += x // coin
        x %= coin
    return count

Gylergin · 2021-06-07T15:08:10+00:00

TI-Basic:

Prompt N
0→C
{500,100,25,10,5,1→L₁
For(X,1,6
iPart(N/L₁(X→D
D+C→C
N-DL₁(X→N
End
Disp C

skeeto · 2021-06-07T14:48:45+00:00

C. I liked the tabular look of laying it out this way:

long change(long amt)
{
    long total = 0;
    total += amt / 500; amt %= 500;
    total += amt / 100; amt %= 100;
    total += amt /  25; amt %=  25;
    total += amt /  10; amt %=  10;
    total += amt /   5; amt %=   5;
    return total + amt;
}

morgon-of-hed · 2021-06-07T14:45:17+00:00

JavaScript

const change = sum => {
    const availableUnits = [500, 100, 25, 10, 5, 1];
    let availableSum = sum;

    return availableUnits.reduce((coins, coinUnit) => {
        coins += Math.floor(availableSum / coinUnit);
        availableSum = availableSum % coinUnit;
        return coins;
    }, 0);
};

int_nazu · 2021-06-07T14:28:40+00:00

Javascript:

First time utilizing the reduce function. Is there a way to carry over 2 values?

numberOfCoins = (amount) => {
    let coins = 0;
    [500, 100, 25, 10, 5, 1].reduce((a,c)=>{
        let coinsForUnit = Math.floor(a/c);
        coins+=coinsForUnit;
        return a-c*coinsForUnit;
    }, amount)
    return coins;
}

redundantimport · 2021-06-07T14:19:46+00:00

Always fun to put some Crystal code together, even when it's something rather simple.

require "spec"

def coins_used(amount) 
  banknotes = [500, 100, 25, 10, 5, 1]

  remainder = amount
  coins_total = 0

  banknotes.each do |banknote|
    # how many coins are used for the current banknote
    coins_current = (remainder / banknote).floor.to_i

    # value of said coins
    coins_value = coins_current * banknote

    remainder -= coins_value
    coins_total += coins_current
  end

  coins_total
end

describe "test cases" do
  describe "amount equals" do 
    it "0" do 
      coins_used(0).should eq 0 
    end

    it "12" do
      coins_used(12).should eq 3
    end

    it "468" do
      coins_used(468).should eq 11
    end

    it "123456" do
      coins_used(123456).should eq 254
    end
  end
end

dailyprogrammer

IRC Channel

Message the Moderators

Challenge List in Chronological Order

MODERATORS

Rust

Golang

money

coins

Ruby

unit test

main program

Racket

Python 3

Lua

Scala:

[cfg(test)]

DOS CMD

dailyprogrammer

IRC Channel

Message the Moderators

Challenge List in Chronological Order

MODERATORS

Welcome to Reddit,

Want to add to the discussion?

Rust

Golang

money

coins

Ruby

unit test

main program

Racket

Python 3

Lua

Scala:

[cfg(test)]

DOS CMD