Stai scrivendo un programma per un registratore di cassa automatico. L'utente deve cambiare con il minor numero di monete utilizzate. Scrivi un programma che richiede un importo (ad esempio $ 1,53) e fornisce un cambio nelle denominazioni statunitensi - in questo caso: 1 x una banconota da un dollaro, 1 x cinquanta centesimi e 3 x un centesimo. Il programma più breve sarà il vincitore. Punti bonus per il supporto di altre valute (ad esempio denominazioni del Regno Unito) e valute insolite (1, 2, 3 centesimi?)

Hai queste denominazioni statunitensi: 1 centesimo, 5 centesimi, 10 centesimi, 25 centesimi, 50 centesimi, 1 dollaro (banconota o moneta), 2 dollari, 5 dollari, 10 dollari.

Hai queste denominazioni nel Regno Unito: 1 pence, 2 pence, 5 pence, 10 pence, 20 pence, 50 pence, £ 1, £ 2, £ 5 (nota o moneta), £ 10.

Windows PowerShell, 108 111 117

Primo tentativo, finora non golfato:

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

Note di attuazione:

1. Accetta la quantità da restituire tramite la pipeline
2. Accetta l'elenco delle denominazioni di valuta tramite la riga di comando
3. La quantità può essere fornita con un segno di valuta; che sarà messo a nudo (in realtà, qualsiasi cosa non numerica).
4. Non è necessario ordinare l'elenco delle denominazioni.
5. Il programma produrrà la variazione maggiore inferiore alla quantità richiesta ottenibile con le denominazioni indicate, ovvero 1,5 per 1,53 se manca la moneta da 1 centesimo.

Se 3 e 4 non hanno bisogno di essere soddisfatta (cioè io controllare il formato di input ;-)), allora i seguenti suffissi programma (71):

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

Mathematica: 110 caratteri

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

uso

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

O

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 caratteri in più) dà

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

Per altre denominazioni, basta cambiare la tabella razionali {10, ...., 5 / 100,1 / 100}

D: 225 personaggi

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");}

Più leggibilmente:

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");
}

Gestisce solo la valuta degli Stati Uniti. Prende il valore come valore in virgola mobile sulla riga di comando (deve avere lo 0 iniziale per valori inferiori a 1 dollaro). Non accetta $ come parte del valore. Emette il numero di ciascun tipo di banconota / moneta su una riga separata. Ad esempio, un input di 1,53 comporta:

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

Mathematica, 51 byte

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

ingresso

[1.53]

produzione

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

Mathematica, 82 byte - CON BONUS--

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

Ingresso

[37.6, {15, 7, 2.5, 1, 0.88, 0.2, 0.01}]

produzione

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

Javascript, 84 83 byte

(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")

Utilizza un algoritmo avido.

APL (Dyalog) , 19 byte

Richiede l'importo desiderato e quindi le denominazioni espresse nell'unità più piccola (centesimi / centesimi).

⎕CY'dfns'
⎕ stamps⎕

Provalo online!

⎕CY'dfns' C o p y l' dfnsarea di lavoro

⎕ stamps⎕ chiedere input e usare come argomenti per la stampsfunzione