Find minimum number of coins that make a given value: Difference between revisions

{{trans|Python_%3A%3A_Procedural}}

 

V total = 988

print(‘Available denominations: ’denominations‘. Total is to be: ’total‘.’)

(V coinsused, remaining) = divmod(remaining, coins[n])

I coinsused > 0

 

{{out}}

 

=={{header|Action!}}==

DEFINE LEN="8"

BYTE ARRAY coins=[200 100 50 20 10 5 2 1],count(LEN)

FI

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Find_minimum_number_of_coins_that_make_a_given_value.png Screenshot from Atari 8-bit computer]

=={{header|APL}}==

{{works with|Dyalog APL}}

{⍺,≢⍵}⌸⍺[⍒⍺]{

coin←⊃(⍵≥⍺)/⍺

coin,⍺∇⍵-coin

}⍵

{{out}}

<pre> (1 2 5 10 20 50 100 200) coins 988

 

=={{header|AppleScript}}==

 

-- change :: [Int] -> Int -> [(Int, Int)]

set my text item delimiters to dlm

s

{{Out}}

<pre>Summing to 1024:

 

=={{header|AutoHotkey}}==

val := 988

 

}

MsgBox, 262144, , % result

{{out}}

<pre>4 * 200

 

=={{header|AWK}}==

# syntax: GAWK -f FIND_MINIMUM_NUMBER_OF_COINS_THAT_MAKE_A_GIVEN_VALUE.AWK

BEGIN {

printf("%9d coins needed to disperse %s\n\n",total,arg1)

}

{{out}}

<pre>

 

=={{header|BASIC256}}==

sumCoins = 0

dim coins = {1, 2, 5, 10, 20, 50, 100, 200}

end if

next n

{{out}}

<pre>

 

=={{header|F_Sharp|F#}}==

//Find minimum number of coins that make a given value - Nigel Galloway: August 12th., 20

let fN g=let rec fG n g=function h::t->fG((g/h,h)::n)(g%h) t |_->n in fG [] g [200;100;50;20;10;5;2;1]

fN 988|>List.iter(fun(n,g)->printfn "Take %d of %d" n g)

{{out}}

<pre>

=={{header|Factor}}==

{{works with|Factor|0.99 2021-06-02}}

 

: make-change ( value coins -- assoc )

[ >=< ] sort [ /mod swap ] zip-with nip ;

 

{{out}}

<pre>

 

=={{header|FreeBASIC}}==

 

Dim As Integer amount = 988

End If

Next n

{{out}}

<pre>Make a value of 988 using the coins 1, 2, 5, 10, 20, 50, 100 and 200:

=={{header|Go}}==

{{trans|Wren}}

 

import "fmt"

}

fmt.Println("\nA total of", coins, "coins in all.")

 

{{out}}

 

=={{header|Haskell}}==

import Data.Tuple (swap)

 

main =

mapM_ print $

{{Out}}

<pre>(4,200)

Or as a hand-written recursion, defining a slightly more parsimonious listing, and allowing for denomination lists which are ill-sorted or incomplete.

 

import Data.Ord (Down (Down))

 

)

)

{{Out}}

<pre>Summing to 1024:

=={{header|JavaScript}}==

{{Works with|JavaScript|ES6}}

"use strict";

 

// MAIN ---

return main();

{{Out}}

<pre>Summing to 1024:

{{works with|jq}}

'''Works with gojq, the Go implementation of jq'''

# If $details then provide {details, coins}, otherwise just the number of coins.

def minimum_number($details):

| minimum_number(false), # illustrate minimal output

task # illustrate detailed output

{{out}}

<pre>

=== Long version ===

Using a linear optimizer for this is serious overkill, but why not?

 

model = Model(GLPK.Optimizer)

println("Value of ", string(val), " is ", value(val))

end

<pre>

Optimized total coins: 11.0

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

out = v /. ConvexOptimization[Total[v], coins . v == 988, v \[Element] Vectors[8, NonNegativeIntegers]];

{{out}}

<pre>1 x 1

 

=={{header|MiniZinc}}==

%Find minimum number of coins that make a given value. Nigel Galloway, August 11th., 2021

int: N=988;

solve minimize sum(n in 1..8)(take[n]);

output(["Take "++show(take[n])++" of "++show(coinValue[n])++"\n" | n in 1..8])

{{out}}

<pre>

 

=={{header|Nim}}==

 

const

if remaining == 0: break

 

 

{{out}}

 

=={{header|Perl}}==

use warnings;

 

for (0 .. $#amounts) {

printf "%1d * %3d\n", $amounts[$_], $denominations[$_]

{{out}}

<pre>4 * 200

 

=={{header|Phix}}==

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #7060A8;">requires</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"1.0.1"</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- (lastdelim added to the join() function)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%s coins were used.\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">proper</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">ordinal</span><span style="color: #0000FF;">(</span><span style="color: #000000;">count</span><span style="color: #0000FF;">,</span><span style="color: #004600;">true</span><span style="color: #0000FF;">))})</span>

{{out}}

<pre>

=={{header|Python}}==

===Python :: Procedural===

print(f"Available denominations: {denominations}. Total is to be: {total}.")

coins, remaining = sorted(denominations, reverse=True), total

 

makechange()

<pre>

Available denominations: [1, 2, 5, 10, 20, 50, 100, 200]. Total is to be: 988.

 

===Python :: Functional===

 

 

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>Summing to 1024:

Since unit denominations are possible, don't bother to check to see if an exact pay-out isn't possible.

 

 

sub change (Int $n is copy where * >= 0) { gather for @denominations { take $n div $_; $n %= $_ } }

say "\n$amount:";

printf "%d × %d\n", |$_ for $amount.&change Z @denominations;

{{out}}

<pre>988:

 

=={{header|Red}}==

 

value: 988

unless 0 = quantity [print [quantity "*" denomination]]

value: value % denomination

{{out}}

<pre>

 

The total number of coins paid out is also shown.

parse arg $ coins /*obtain optional arguments from the CL*/

if $='' | $="," then $= 988 /*Not specified? Then use the default.*/

say 'number of coins dispensed: ' koins

if $>0 then say 'exact payout not possible.' /*There a residue? Payout not possible*/

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

 

=={{header|Ring}}==

load "stdlib.ring"

 

 

see "done..." + nl

{{out}}

<pre>

 

=={{header|Rust}}==

fn main() {

let denoms = vec![200, 100, 50, 20, 10, 5, 2, 1];

println!("\nA total of {} coins in all.", coins);

}

{{out}}

<pre>

{{libheader|Wren-fmt}}

As there is, apparently, an unlimited supply of coins of each denomination, it follows that any amount can be made up.

 

var denoms = [200, 100, 50, 20, 10, 5, 2, 1]

}

}

 

{{out}}

=={{header|XPL0}}==

{{trans|Wren}}

[Denoms:= [200, 100, 50, 20, 10, 5, 2, 1];

Coins:= 0;

A total of "); IntOut(0, Coins); Text(0, " coins in all.

");

 

{{out}}

=={{header|Yabasic}}==

{{trans|FreeBASIC}}

sumCoins = 0

dim coins(7)

end if

next n

{{out}}

<pre>