Rosetta Code

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

Page Discussion

Find minimum number of coins that make a given value (view source)

Revision as of 11:43, 15 April 2024

11,590 bytes added ,  1 month ago
Added Easylang
(Find minimum number of coins that make a given value en BASIC256)
(Added Easylang)
 
(20 intermediate revisions by 15 users not shown)
Line 17:
one coin of 1
<br><br>
 
=={{header|11l}}==
{{trans|Python_%3A%3A_Procedural}}
 
<syntaxhighlight lang="11l">V denominations = [1, 2, 5, 10, 20, 50, 100, 200]
V total = 988
print(‘Available denominations: ’denominations‘. Total is to be: ’total‘.’)
V (coins, remaining) = (sorted(denominations, reverse' 1B), total)
L(n) 0 .< coins.len
(V coinsused, remaining) = divmod(remaining, coins[n])
I coinsused > 0
print(‘ ’coinsused‘ * ’coins[n])</syntaxhighlight>
 
{{out}}
<pre>
Available denominations: [1, 2, 5, 10, 20, 50, 100, 200]. Total is to be: 988.
4 * 200
1 * 100
1 * 50
1 * 20
1 * 10
1 * 5
1 * 2
1 * 1
</pre>
 
=={{header|Action!}}==
<langsyntaxhighlight Actionlang="action!">PROC Main()
DEFINE LEN="8"
BYTE ARRAY coins=[200 100 50 20 10 5 2 1],count(LEN)
Line 46 ⟶ 71:
FI
OD
RETURN</langsyntaxhighlight>
{{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]
Line 59 ⟶ 84:
1 x 2
1 x 1
</pre>
 
=={{header|ALGOL 68}}==
{{Trans|Wren}}
<syntaxhighlight lang="algol68">
BEGIN # find the minimum number of coins needed to make a given value #
# translated from the Wren sample #
 
[]INT denoms = ( 200, 100, 50, 20, 10, 5, 2, 1 );
INT coins := 0;
INT amount = 988;
INT remaining := amount;
print( ( "The minimum number of coins needed to make a value of " ) );
print( ( whole( amount, 0 ), " is as follows:", newline ) );
FOR d pos FROM LWB denoms TO UPB denoms
WHILE INT denom = denoms[ d pos ];
INT n = remaining OVER denom;
IF n > 0 THEN
coins +:= n;
print( (" ", whole( denom, -3 ), " x ", whole( n, 0 ), newline ) );
remaining MODAB denom
FI;
remaining > 0
DO SKIP OD;
print( ( newline, "A total of ", whole( coins, 0 ), " coins in all.", newline ) )
END
</syntaxhighlight>
{{out}}
<pre>
The minimum number of coins needed to make a value of 988 is as follows:
200 x 4
100 x 1
50 x 1
20 x 1
10 x 1
5 x 1
2 x 1
1 x 1
 
A total of 11 coins in all.
</pre>
 
=={{header|APL}}==
{{works with|Dyalog APL}}
<langsyntaxhighlight APLlang="apl">coins←{
{⍺,≢⍵}⌸⍺[⍒⍺]{
coin←⊃(⍵≥⍺)/⍺
Line 69 ⟶ 134:
coin,⍺∇⍵-coin
}⍵
}</langsyntaxhighlight>
{{out}}
<pre> (1 2 5 10 20 50 100 200) coins 988
Line 82 ⟶ 147:
 
=={{header|AppleScript}}==
<langsyntaxhighlight lang="applescript">----------------- MINIMUM NUMBER OF COINS ----------------
 
-- change :: [Int] -> Int -> [(Int, Int)]
Line 165 ⟶ 230:
set my text item delimiters to dlm
s
end unlines</langsyntaxhighlight>
{{Out}}
<pre>Summing to 1024:
Line 181 ⟶ 246:
1 * 2
1 * 1</pre>
 
=={{header|Arturo}}==
 
<syntaxhighlight lang="arturo">coins: [200 100 50 20 10 5 2 1]
target: 988
 
print ["Minimum number of coins to make a value of " (to :string target)++":"]
 
cnt: 0
remaining: new target
 
loop coins 'coin [
n: remaining / coin
if not? zero? n [
cnt: cnt + n
print [" coins of" coin "->" n]
remaining: remaining - n * coin
if zero? remaining -> break
]
]
 
print ["\nTotal: " cnt]</syntaxhighlight>
 
{{out}}
 
<pre>Minimum number of coins to make a value of 988:
coins of 200 -> 4
coins of 100 -> 1
coins of 50 -> 1
coins of 20 -> 1
coins of 10 -> 1
coins of 5 -> 1
coins of 2 -> 1
coins of 1 -> 1
 
Total: 11</pre>
 
=={{header|AutoHotkey}}==
<syntaxhighlight lang="autohotkey">coins := [1, 2, 5, 10, 20, 50, 100, 200]
val := 988
 
result := ""
while val
{
coin := coins.pop()
if (val//coin)
result .= val//coin " * " coin "`n", val -= val//coin * coin
}
MsgBox, 262144, , % result
return</syntaxhighlight>
{{out}}
<pre>4 * 200
1 * 100
1 * 50
1 * 20
1 * 10
1 * 5
1 * 2
1 * 1</pre>
 
=={{header|AWK}}==
<syntaxhighlight lang="awk">
<lang AWK>
# syntax: GAWK -f FIND_MINIMUM_NUMBER_OF_COINS_THAT_MAKE_A_GIVEN_VALUE.AWK
BEGIN {
Line 205 ⟶ 330:
printf("%9d coins needed to disperse %s\n\n",total,arg1)
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 241 ⟶ 366:
 
=={{header|BASIC256}}==
<langsyntaxhighlight BASIC256lang="basic256">amount = 988
sumCoins = 0
dim coins = {1, 2, 5, 10, 20, 50, 100, 200}
Line 255 ⟶ 380:
end if
next n
end</langsyntaxhighlight>
{{out}}
<pre>
Line 261 ⟶ 386:
</pre>
 
 
=={{header|C}}==
<syntaxhighlight lang="c">
#include <stdio.h>
 
#define TOTAL 988
#define Q_VALUES 8
 
int main() {
const int kValues[Q_VALUES] = { 200, 100, 50, 20, 10, 5, 2, 1 };
int t, q, iv;
 
for( t=TOTAL, iv=0; iv<Q_VALUES; t%=kValues[iv], ++iv ) {
q = t/kValues[iv];
printf( "%4d coin%c of %4d\n", q, q!=1?'s':' ', kValues[iv] );
}
 
return 0;
}
</syntaxhighlight>
{{out}}
<pre>
4 coins of 200
1 coin of 100
1 coin of 50
1 coin of 20
1 coin of 10
1 coin of 5
1 coin of 2
1 coin of 1
</pre>
 
 
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
 
 
<syntaxhighlight lang="Delphi">
const Coins: array [0..7] of integer = (1,2,5,10,20,50,100,200);
 
procedure MinimumCoins(Memo: TMemo; Value: integer);
var I,C: integer;
begin
Memo.Lines.Add('Providing Change for: '+IntToStr(Value));
for I:=High(Coins) downto 0 do
begin
C:=Value div Coins[I];
Value:=Value mod Coins[I];
Memo.Lines.Add(IntToStr(C)+' coins of '+IntToStr(Coins[I]));
end;
Memo.Lines.Add('');
end;
 
 
procedure TestMinimumCoins(Memo: TMemo);
begin
MinimumCoins(Memo,988);
MinimumCoins(Memo,1307);
MinimumCoins(Memo,37511);
MinimumCoins(Memo,0);
end;
 
 
</syntaxhighlight>
{{out}}
<pre>
Providing Change for: 988
4 coins of 200
1 coins of 100
1 coins of 50
1 coins of 20
1 coins of 10
1 coins of 5
1 coins of 2
1 coins of 1
 
Providing Change for: 1307
6 coins of 200
1 coins of 100
0 coins of 50
0 coins of 20
0 coins of 10
1 coins of 5
1 coins of 2
0 coins of 1
 
Providing Change for: 37511
187 coins of 200
1 coins of 100
0 coins of 50
0 coins of 20
1 coins of 10
0 coins of 5
0 coins of 2
1 coins of 1
 
Providing Change for: 0
0 coins of 200
0 coins of 100
0 coins of 50
0 coins of 20
0 coins of 10
0 coins of 5
0 coins of 2
0 coins of 1
</pre>
 
 
 
=={{header|EasyLang}}==
<syntaxhighlight>
sum = 988
coins[] = [ 200 100 50 20 10 5 2 1 ]
#
for coin in coins[]
n = sum div coin
if n > 0
print "coins of " & coin & ": " & n
sum -= n * coin
.
.
</syntaxhighlight>
{{out}}
<pre>
coins of 200: 4
coins of 100: 1
coins of 50: 1
coins of 20: 1
coins of 10: 1
coins of 5: 1
coins of 2: 1
coins of 1: 1
</pre>
 
=={{header|F_Sharp|F#}}==
<langsyntaxhighlight lang="fsharp">
//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)
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 282 ⟶ 541:
=={{header|Factor}}==
{{works with|Factor|0.99 2021-06-02}}
<langsyntaxhighlight lang="factor">USING: assocs kernel math math.order prettyprint sorting ;
 
: make-change ( value coins -- assoc )
[ >=< ] sort [ /mod swap ] zip-with nip ;
 
988 { 1 2 5 10 20 50 100 200 } make-change .</langsyntaxhighlight>
{{out}}
<pre>
Line 304 ⟶ 563:
 
=={{header|FreeBASIC}}==
<langsyntaxhighlight lang="freebasic">#define floor(x) ((x*2.0-0.5) Shr 1)
 
Dim As Integer amount = 988
Line 321 ⟶ 580:
End If
Next n
Sleep</langsyntaxhighlight>
{{out}}
<pre>Make a value of 988 using the coins 1, 2, 5, 10, 20, 50, 100 and 200:
Line 333 ⟶ 592:
1 * 1</pre>
 
 
=={{header|FutureBasic}}==
Task solution wrapped into a general purpose function with test examples shown.
<syntaxhighlight lang="futurebasic">
void local fn MinimumCoinsForValue( value as NSUInteger, coins as CFArrayRef )
NSUInteger i, count, tmp
CFStringRef coinStr = fn ArrayComponentsJoinedByString( coins, @", " )
printf @"The minimum number of coins valued %@ needed to total %lu is:", coinStr, value
count = len(coins)
for i = count to 1 step -1
tmp = (NSUInteger)fn floor( value / fn NumberIntegerValue( coins[i-1] ) )
if ( tmp > 0 )
printf @"%lu * %@", tmp, coins[i-1]
value = value mod fn NumberIntegerValue( coins[i-1] )
end if
next
end fn
 
fn MinimumCoinsForValue( 988, @[@1, @2, @5, @10, @20, @50, @100, @200] )
print : print
fn MinimumCoinsForValue( 1024, @[@1, @2, @5, @10, @20, @50, @100, @200] )
print : print
print "Currency in this example represents U.S. denominations:"
print " 1 cent, 5 cents, 10 cents, 25 cents, 50 cents, $1, $5, $10, $20, $50"
fn MinimumCoinsForValue( 65273, @[@1, @5, @10, @25, @50, @100, @500, @1000, @2000, @5000] )
 
HandleEvents
</syntaxhighlight>
{{output}}
<pre>
The minimum number of coins valued 1, 2, 5, 10, 20, 50, 100, 200 needed to total 988 is:
4 * 200
1 * 100
1 * 50
1 * 20
1 * 10
1 * 5
1 * 2
1 * 1
 
 
The minimum number of coins valued 1, 2, 5, 10, 20, 50, 100, 200 needed to total 1024 is:
5 * 200
1 * 20
2 * 2
 
 
Currency in this example represents U.S. denominations:
1 cent, 5 cents, 10 cents, 25 cents, 50 cents, $1, $5, $10, $20, $50
The minimum number of coins valued 1, 5, 10, 25, 50, 100, 500, 1000, 2000, 5000 needed to total 65273 is:
13 * 5000
2 * 100
1 * 50
2 * 10
3 * 1
</pre>
 
=={{header|Go}}==
{{trans|Wren}}
<langsyntaxhighlight lang="go">package main
 
import "fmt"
Line 358 ⟶ 675:
}
fmt.Println("\nA total of", coins, "coins in all.")
}</langsyntaxhighlight>
 
{{out}}
Line 376 ⟶ 693:
 
=={{header|Haskell}}==
<langsyntaxhighlight lang="haskell">import Data.List (mapAccumL)
import Data.Tuple (swap)
 
Line 391 ⟶ 708:
main =
mapM_ print $
change [200, 100, 50, 20, 10, 5, 2, 1] 988</langsyntaxhighlight>
{{Out}}
<pre>(4,200)
Line 404 ⟶ 721:
Or as a hand-written recursion, defining a slightly more parsimonious listing, and allowing for denomination lists which are ill-sorted or incomplete.
 
<langsyntaxhighlight lang="haskell">import Data.List (sortOn)
import Data.Ord (Down (Down))
 
Line 446 ⟶ 763:
)
)
(change [200, 100, 50, 20, 10, 5, 2, 1] n)</langsyntaxhighlight>
{{Out}}
<pre>Summing to 1024:
Line 462 ⟶ 779:
1 * 2
1 * 1</pre>
 
=={{header|J}}==
<syntaxhighlight lang="j">coins=. [ (,: {."1@}:) [: (#: {:)/\. 0 ,. ,
 
1 2 5 10 20 50 100 200 coins 988</syntaxhighlight>
{{out}}
<pre>1 2 5 10 20 50 100 200
1 1 1 1 1 1 1 4</pre>
 
=={{header|JavaScript}}==
{{Works with|JavaScript|ES6}}
<langsyntaxhighlight lang="javascript">(() => {
"use strict";
 
Line 529 ⟶ 854:
// MAIN ---
return main();
})();</langsyntaxhighlight>
{{Out}}
<pre>Summing to 1024:
Line 549 ⟶ 874:
{{works with|jq}}
'''Works with gojq, the Go implementation of jq'''
<syntaxhighlight lang="jq">
<lang jq>
# If $details then provide {details, coins}, otherwise just the number of coins.
def minimum_number($details):
Line 577 ⟶ 902:
| minimum_number(false), # illustrate minimal output
task # illustrate detailed output
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 598 ⟶ 923:
=== Long version ===
Using a linear optimizer for this is serious overkill, but why not?
<langsyntaxhighlight lang="julia">using JuMP, GLPK
 
model = Model(GLPK.Optimizer)
Line 626 ⟶ 951:
println("Value of ", string(val), " is ", value(val))
end
</langsyntaxhighlight>{{out}}
<pre>
Optimized total coins: 11.0
Line 650 ⟶ 975:
(1, (2, 1))
(0, (1, 1))
</pre>
 
=={{header|Lua}}==
{{Trans|Wren}}
<syntaxhighlight lang="lua">
do -- find the minimum number of coins needed to make a given value
-- translated from the Wren sample
 
local denoms = { 200, 100, 50, 20, 10, 5, 2, 1 }
local amount = 988;
local coins, remaining = 0, amount
print( "The minimum number of coins needed to make a value of "..amount.." is as follows:" )
for _, denom in pairs( denoms ) do
local n = math.floor( remaining / denom )
if n > 0 then
coins = coins + n
print( string.format( "%6d", denom ).." x "..n )
remaining = remaining % denom
end
if remaining == 0 then break end
end
print( "A total of "..coins.." coins in all." )
end
</syntaxhighlight>
{{out}}
<pre>
The minimum number of coins needed to make a value of 988 is as follows:
200 x 4
100 x 1
50 x 1
20 x 1
10 x 1
5 x 1
2 x 1
1 x 1
A total of 11 coins in all.
</pre>
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<langsyntaxhighlight Mathematicalang="mathematica">coins = {1, 2, 5, 10, 20, 50, 100, 200};
out = v /. ConvexOptimization[Total[v], coins . v == 988, v \[Element] Vectors[8, NonNegativeIntegers]];
MapThread[Row[{#1, " x ", #2}] &, {out, coins}] // Column</langsyntaxhighlight>
{{out}}
<pre>1 x 1
Line 667 ⟶ 1,028:
 
=={{header|MiniZinc}}==
<syntaxhighlight lang="minizinc">
<lang MiniZinc>
%Find minimum number of coins that make a given value. Nigel Galloway, August 11th., 2021
int: N=988;
Line 674 ⟶ 1,035:
solve minimize sum(n in 1..8)(take[n]);
output(["Take "++show(take[n])++" of "++show(coinValue[n])++"\n" | n in 1..8])
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 691 ⟶ 1,052:
 
=={{header|Nim}}==
<langsyntaxhighlight Nimlang="nim">import strformat
 
const
Line 708 ⟶ 1,069:
if remaining == 0: break
 
echo "\nTotal: ", count</langsyntaxhighlight>
 
{{out}}
Line 724 ⟶ 1,085:
 
=={{header|Perl}}==
<langsyntaxhighlight lang="perl">use strict;
use warnings;
 
Line 739 ⟶ 1,100:
for (0 .. $#amounts) {
printf "%1d * %3d\n", $amounts[$_], $denominations[$_]
}</langsyntaxhighlight>
{{out}}
<pre>4 * 200
Line 751 ⟶ 1,112:
 
=={{header|Phix}}==
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<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>
Line 770 ⟶ 1,131:
<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>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
Line 787 ⟶ 1,148:
=={{header|Python}}==
===Python :: Procedural===
<langsyntaxhighlight lang="python">def makechange(denominations = [1,2,5,10,20,50,100,200], total = 988):
print(f"Available denominations: {denominations}. Total is to be: {total}.")
coins, remaining = sorted(denominations, reverse=True), total
Line 796 ⟶ 1,157:
 
makechange()
</langsyntaxhighlight>{{out}}
<pre>
Available denominations: [1, 2, 5, 10, 20, 50, 100, 200]. Total is to be: 988.
Line 810 ⟶ 1,171:
 
===Python :: Functional===
<langsyntaxhighlight lang="python">'''Minimum number of coins to make a given value'''
 
 
Line 850 ⟶ 1,211:
# MAIN ---
if __name__ == '__main__':
main()</langsyntaxhighlight>
{{Out}}
<pre>Summing to 1024:
Line 866 ⟶ 1,227:
1 * 2
1 * 1</pre>
 
=={{header|Quackery}}==
 
<syntaxhighlight lang="Quackery"> [ ' [ 200 100 50 20 10 5 2 1 ] ] is coins ( --> [ )
 
[ [] swap
coins witheach
[ /mod dip join ]
drop
witheach
[ dup 0 > iff
[ echo say " * "
coins i^ peek echo
cr ]
else drop ] ] is task ( n --> )
 
' [ 988 345 1024 ]
witheach
[ say "To make "
dup echo say ":" cr
task cr ]</syntaxhighlight>
 
{{out}}
 
<pre>To make 988:
4 * 200
1 * 100
1 * 50
1 * 20
1 * 10
1 * 5
1 * 2
1 * 1
 
To make 345:
1 * 200
1 * 100
2 * 20
1 * 5
 
To make 1024:
5 * 200
1 * 20
2 * 2
</pre>
 
=={{header|Raku}}==
Since unit denominations are possible, don't bother to check to see if an exact pay-out isn't possible.
 
<syntaxhighlight lang="raku" perl6line>my @denominations = 200, 100, 50, 20, 10, 5, 2, 1;
 
sub change (Int $n is copy where * >= 0) { gather for @denominations { take $n div $_; $n %= $_ } }
Line 877 ⟶ 1,283:
say "\n$amount:";
printf "%d × %d\n", |$_ for $amount.&change Z @denominations;
}</langsyntaxhighlight>
{{out}}
<pre>988:
Line 918 ⟶ 1,324:
0 × 2
0 × 1</pre>
 
=={{header|Red}}==
<syntaxhighlight lang="rebol">Red[]
 
value: 988
foreach denomination [200 100 50 20 10 5 2 1][
quantity: to-integer value / denomination
unless 0 = quantity [print [quantity "*" denomination]]
value: value % denomination
]</syntaxhighlight>
{{out}}
<pre>
4 * 200
1 * 100
1 * 50
1 * 20
1 * 10
1 * 5
1 * 2
1 * 1
</pre>
 
=={{header|REXX}}==
Line 923 ⟶ 1,350:
 
The total number of coins paid out is also shown.
<langsyntaxhighlight lang="rexx">/*REXX pgm finds & displays the minimum number of coins which total to a specified value*/
parse arg $ coins /*obtain optional arguments from the CL*/
if $='' | $="," then $= 988 /*Not specified? Then use the default.*/
Line 950 ⟶ 1,377:
say 'number of coins dispensed: ' koins
if $>0 then say 'exact payout not possible.' /*There a residue? Payout not possible*/
exit 0 /*stick a fork in it, we're all done. */</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the default inputs:}}
<pre>
Line 971 ⟶ 1,398:
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
load "stdlib.ring"
 
Line 992 ⟶ 1,419:
 
see "done..." + nl
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,008 ⟶ 1,435:
</pre>
 
 
=={{header|RPL}}==
{{works with|HP|48G}}
« { 200 100 50 20 10 5 2 1 } { }
→ coinset result
« 1 coinset SIZE '''FOR''' j
coinset j GET
MOD LASTARG / IP
'result' SWAP STO+
'''NEXT'''
DROP result DUP ∑LIST "coins" →TAG
» » '<span style="color:blue">COINS</span>' STO
 
988 <span style="color:blue">COINS</span>
{{out}}
<pre>
2: { 4 1 1 1 1 1 1 1 }
1: coins: 11
</pre>
 
=={{header|Rust}}==
<langsyntaxhighlight lang="rust">
fn main() {
let denoms = vec![200, 100, 50, 20, 10, 5, 2, 1];
Line 1,030 ⟶ 1,476:
println!("\nA total of {} coins in all.", coins);
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
The minimum number of coins needed to make a value of 988 is as follows:
200 x 4
100 x 1
50 x 1
20 x 1
10 x 1
5 x 1
2 x 1
1 x 1
 
A total of 11 coins in all.
</pre>
 
=={{header|V (Vlang)}}==
<syntaxhighlight lang="Rust">
fn main() {
denoms := [200, 100, 50, 20, 10, 5, 2, 1]
amount := 988
mut coins := 0
mut remaining := 988
mut n := 0
println("The minimum number of coins needed to make a value of ${amount} is as follows:")
for denom in denoms {
n = remaining / denom
if n > 0 {
coins += n
print(" ${denom} x ${n}" + "\n")
remaining %= denom
if remaining == 0 {break}
}
}
println("\nA total of ${coins} coins in all.")
}
</syntaxhighlight>
 
{{out}}
<pre>
Line 1,049 ⟶ 1,532:
{{libheader|Wren-fmt}}
As there is, apparently, an unlimited supply of coins of each denomination, it follows that any amount can be made up.
<langsyntaxhighlight ecmascriptlang="wren">import "./fmt" for Fmt
 
var denoms = [200, 100, 50, 20, 10, 5, 2, 1]
Line 1,065 ⟶ 1,548:
}
}
System.print("\nA total of %(coins) coins in all.")</langsyntaxhighlight>
 
{{out}}
Line 1,084 ⟶ 1,567:
=={{header|XPL0}}==
{{trans|Wren}}
<langsyntaxhighlight XPL0lang="xpl0">int Denom, Denoms, Coins, Amount, Remaining, I, N;
[Denoms:= [200, 100, 50, 20, 10, 5, 2, 1];
Coins:= 0;
Line 1,106 ⟶ 1,589:
A total of "); IntOut(0, Coins); Text(0, " coins in all.
");
]</langsyntaxhighlight>
 
{{out}}
Line 1,121 ⟶ 1,604:
 
A total of 11 coins in all.
</pre>
 
=={{header|Yabasic}}==
{{trans|FreeBASIC}}
<syntaxhighlight lang="yabasic">amount = 988
sumCoins = 0
dim coins(7)
coins(0) = 1
coins(1) = 2
coins(2) = 5
coins(3) = 10
coins(4) = 20
coins(5) = 50
coins(6) = 100
coins(7) = 200
 
print "Make a value of ", amount, " using the coins 1, 2, 5, 10, 20, 50, 100 and 200:"
 
for n = arraysize(coins(),1) to 0 step -1
tmp = floor(amount/coins(n))
if tmp >= 0 then
print tmp, " * ", coins(n)
sumCoins = sumCoins + tmp
amount = mod(amount, coins(n))
end if
next n
end</syntaxhighlight>
{{out}}
<pre>
Igual que la entrada de FreeBASIC.
</pre>
Chkas
1,995

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/314900...363695"