Sie schreiben ein Programm für eine automatische Registrierkasse. Der Benutzer muss mit der geringsten Anzahl verwendeter Münzen wechseln. Schreiben Sie ein Programm, das einen Betrag (z. B. 1,53 US-Dollar) benötigt und die US-Stückelung ändert - in diesem Fall: 1 x 1-Dollar-Note, 1 x 50 Cent und 3 x 1 Cent. Das kürzeste Programm ist der Gewinner. Bonuspunkte für die Unterstützung anderer Währungen (dh britischer Stückelungen) und ungewöhnlicher Währungen (1, 2, 3 Cent?)

Sie haben diese US-Stückelungen: 1 Cent, 5 Cent, 10 Cent, 25 Cent, 50 Cent, 1 Dollar (Banknote oder Münze), 2 Dollar, 5 Dollar, 10 Dollar.

Sie haben diese britischen Stückelungen: 1 Pence, 2 Pence, 5 Pence, 10 Pence, 20 Pence, 50 Pence, £ 1, £ 2, £ 5 (Banknote oder Münze), £ 10.

Windows PowerShell, 108 111 117

Der allererste Versuch, bisher ungeölft:

$i=+("$input"-replace'[^\d.]')
$args|%{0d+$_}|sort -des|%{$a=[math]::floor($i/$_)
if($a){$i-=$a*$_
"$a×$_"}}

Implementierungshinweise:

1. Akzeptiert die Menge, die über die Pipeline zurückgegeben werden soll
2. Akzeptiert die Liste der Währungsbezeichnungen über die Befehlszeile
3. Die Menge kann mit einem Währungszeichen angegeben werden; das wird entfernt (in der Tat alles nicht numerische).
4. Die Liste der Stückelungen muss nicht sortiert werden.
5. Das Programm gibt die größte Änderung aus, die kleiner ist als die angeforderte Menge, die mit den angegebenen Nennwerten erreichbar ist, dh 1,5 für 1,53, wenn die 1-Cent-Münze fehlt.

Wenn 3 und 4 nicht erfüllt sein müssen (dh ich steuere das Eingabeformat ;-)), reicht das folgende Programm aus (71):

$i=+"$input"
$args|%{$a=[math]::floor($i/$_)
if($a){$i-=$a*$_
"$a×$_"}}

Mathematica: 110 Zeichen

Sort[IntegerPartitions[Rationalize@#,Infinity,{10,5,2,1,1/2,1/4,1/10,5/100,1/100}],
    Length@#1<Length@#2&][[1]]&  

Verwendungszweck

%[0.98]  
{1/100, 1/100, 1/100, 1/10, 1/10, 1/4, 1/2}  

Oder

Tally@Sort[IntegerPartitions[Rationalize@#,Infinity,
                             {10,5,2,1,1/2,1/4,1/10,5/100,1/100}],
     Length@#1<Length@#2&][[1]]&  

(6 Zeichen mehr) gibt

{{1/100, 3}, {1/10, 2}, {1/4, 1}, {1/2, 1}}

Für andere Nennwerte ändern Sie einfach die Rationals-Tabelle {10, ...., 5 / 100,1 / 100}.

D: 225 Zeichen

import std.algorithm,std.conv,std.stdio;void main(string[]args){auto m=args[1].findSplit(".");void p(T,S)(T t,T u,S s){foreach(v;[u,10,5,1]){writefln("%s %s%s",t/v,v,s);t-=(t/v)*v;}}p(to!int(m[0]),20,"");p(to!int(m[2]),25,"/100");}

Lesbarer:

import std.algorithm,std.conv,std.stdio;

void main(string[] a)
{
    auto m = a[1].findSplit(".");

    void p(T, S)(T t, T u, S s)
    {
        foreach(v; [u, 10, 5, 1])
        {
            writefln("%s %s%s", t / v, v, s);
            t -= (t / v) * v;
        }
    }

    p(to!int(m[0]), 20, "");
    p(to!int(m[2]), 25, "/100");
}

Behandelt nur US-Währung. Nimmt den Wert als Gleitkommawert in der Befehlszeile (muss für Werte unter 1 Dollar die führende 0 haben). Akzeptiert $ nicht als Teil des Wertes. Gibt die Nummer jedes Geldschein- / Münztyps in einer separaten Zeile aus. ZB ergibt eine Eingabe von 1,53:

0 20
0 10
0 5
1 1
2 25/100
0 10/100
0 5/100
3 1/100

Mathematica, 51 Bytes

#~NumberDecompose~{10,5,2,1,.5,.25,.1,.05,.01}&

Eingang

[1.53]

Ausgabe

{0, 0, 0, 1, 1, 0, 0, 0, 3.}

Mathematica, 82 Bytes - MIT BONUS--

(s=#~NumberDecompose~#2;Row@Flatten@Table[Table[#2[[i]]"+",s[[i]]],{i,Length@s}])&

Eingang

[37,6, {15, 7, 2,5, 1, 0,88, 0,2, 0,01}]

Ausgabe

15 +15 +7 +0,2 +0,2 +0,2 +

Javascript, 84 83 Bytes

(n,v=[10,5,2,1,.5,.25,.1,.05,.01],l=[])=>{for(i in v)l[i]=n/v[i]|0,n%=v[i];return l}

(n,v=[10,5,2,1,.5,.25,.1,.05,.01],l=[])=>eval("for(i in v)l[i]=n/v[i]|0,n%=v[i];l")

Verwendet einen gierigen Algorithmus.

APL (Dyalog) , 19 Bytes

Fordert zur Eingabe des gewünschten Betrags und dann zur Bezeichnung in kleinsten Einheiten (Pennies / Cent) auf.

⎕CY'dfns'
⎕ stamps⎕

Probieren Sie es online aus!

⎕CY'dfns' C o p y der dfnsArbeitsbereich

⎕ stamps⎕ Fragen Sie nach Eingaben und verwenden Sie diese als Argumente für die stampsFunktion