Die meisten Trinkgeldrechner-Apps nehmen einfach einen pauschalen Prozentsatz des Essenspreises ein. Wenn Ihre Mahlzeit beispielsweise 23,45 USD beträgt, können Sie ein Trinkgeld von 15% = 3,52 USD oder ein großzügigeres Trinkgeld von 20% = 4,69 USD hinterlassen.

Praktisch genug für Kreditkartenbenutzer. Aber nicht, wenn Sie lieber Bargeld-Trinkgelder abgeben möchten. In diesem Fall behindern Sie diese seltsamen Cent-Beträge. Ändern wir also die Idee, um sie für Bargeldbenutzer angenehmer zu gestalten.

Ihre Aufgabe

Schreiben Sie in so wenigen Bytes wie möglich ein Programm oder eine Funktion , die als Eingabe verwendet wird:

• Preis der Mahlzeit
• Minimaler Trinkgeldanteil
• Maximaler Trinkgeldanteil

Und geben Sie einen beliebigen Trinkgeldbetrag im Bereich [Preis * Mindestprozentsatz / 100, Preis * Höchstprozentsatz / 100] aus, der die Anzahl der erforderlichen Scheine / Banknoten und Münzen minimiert.

Angenommen, die US-Währungsbezeichnungen lauten 1, 5, 10, 25, 1, 5, 10, 20, 50 und 100 US-Dollar.

Beispiel

Hier ist ein nicht-golfendes Beispielprogramm in Python:

import math
import sys

# Do the math in cents so we can use integer arithmetic
DENOMINATIONS = [10000, 5000, 2000, 1000, 500, 100, 25, 10, 5, 1]

def count_bills_and_coins(amount_cents):
    # Use the Greedy method, which works on this set of denominations.
    result = 0
    for denomination in DENOMINATIONS:
        num_coins, amount_cents = divmod(amount_cents, denomination)
        result += num_coins
    return result

def optimize_tip(meal_price, min_tip_percent, max_tip_percent):
    min_tip_cents = int(math.ceil(meal_price * min_tip_percent))
    max_tip_cents = int(math.floor(meal_price * max_tip_percent))
    best_tip_cents = None
    best_coins = float('inf')
    for tip_cents in range(min_tip_cents, max_tip_cents + 1):
        num_coins = count_bills_and_coins(tip_cents)
        if num_coins < best_coins:
            best_tip_cents = tip_cents
            best_coins = num_coins
    return best_tip_cents / 100.0

# Get inputs from command-line
meal_price = float(sys.argv[1])
min_tip_percent = float(sys.argv[2])
max_tip_percent = float(sys.argv[3])
print('{:.2f}'.format(optimize_tip(meal_price, min_tip_percent, max_tip_percent)))

Einige Beispieleingaben und -ausgaben:

~$ python tipcalc.py 23.45 15 20
4.00
~$ python tipcalc.py 23.45 15 17
3.55
~$ python tipcalc.py 59.99 15 25
10.00
~$ python tipcalc.py 8.00 13 20
1.05

Kohle , 60 Bytes

Ｎθ≔×θＮη≔×θＮζ≔⁰θＦＩ⪪”;‴üφ↷Σ↗SEX&¿h'⊟”³«Ｗ‹θη≧⁺ιθ¿›θζ≧⁻ιθ»﹪%.2fθ

Probieren Sie es online! Nimmt Eingaben als Dezimalstellen. Link ist eine ausführliche Version des Codes. Erläuterung:

Ｎθ

Geben Sie die Rechnung ein.

≔×θＮη≔×θＮζ

Geben Sie die Spitzen-Dezimalbrüche ein und berechnen Sie die minimale und maximale Spitze.

≔⁰θ

Beginnen Sie mit der Nullspitze.

ＦＩ⪪”;‴üφ↷Σ↗SEX&¿h'⊟”³«

Die SEXy-Zeichenfolge wird erweitert und 10050.20.10.5.01.0.250.1.05.01in Gruppen mit drei Zeichen aufgeteilt und in Floating umgewandelt.

Ｗ‹θη≧⁺ιθ

Fügen Sie so viele Stückelungen wie nötig hinzu, um die minimale Spitze zu erreichen.

¿›θζ≧⁻ιθ»

Entfernen Sie eine Stückelung, wenn die maximale Spitze überschritten wurde.

﹪%.2fθ

Formatieren Sie den Tipp für die Anzeige.

JavaScript (ES6), 93 Byte

(x,m,M)=>(g=(t,c=1e4)=>t>x*M?0:t<x*m?[...'1343397439'].some(d=>g(t+(c/=-~d/2)))*r:r=t)(0)/100

Probieren Sie es online!

Wie?

Wir berechnen rekursiv eine Summe von Banknoten- / Münzenwerten, bis sie in den akzeptablen Bereich fällt, wobei immer der höchste Wert zuerst versucht wird.

$\{b_0,\dots,b_n\}$

• $b_0$$b_n$$\{b_0,\dots,b_{k-1},x\}$$x \ge b_k$$0 \le k < n$
• $0 \le k < n$$x \le b_n$$\{b_0,\dots,b_{k-1},b_k-x,b_{k+1},\dots,b_n\}$$\{b_0,\dots,b_{n-1}\}$
• $0 < x < b_n$$\{b_0,\dots,b_{n-1},x\}$

$c_n$

$(d_0,\dots,d_9) = (1,3,4,3,3,9,7,4,3,9)$

 n | c(n)  | d(n) | k = (d(n)+1)/2 | c(n+1) = c(n)/k
---+-------+------+----------------+-----------------
 0 | 10000 |   1  | (1+1)/2 = 1    |      10000
 1 | 10000 |   3  | (3+1)/2 = 2    |       5000
 2 |  5000 |   4  | (4+1)/2 = 2.5  |       2000
 3 |  2000 |   3  | (3+1)/2 = 2    |       1000
 4 |  1000 |   3  | (3+1)/2 = 2    |        500
 5 |   500 |   9  | (9+1)/2 = 5    |        100
 6 |   100 |   7  | (7+1)/2 = 4    |         25
 7 |    25 |   4  | (4+1)/2 = 2.5  |         10
 8 |    10 |   3  | (3+1)/2 = 2    |          5
 9 |     5 |   9  | (9+1)/2 = 5    |          1

Python 3.x: 266 185 Bytes

Eine unkomplizierte Änderung meines Beispielprogramms in der Frage. Beachten Sie, dass die Ausgabe nicht mehr so ​​formatiert ist, dass 2 Dezimalstellen erforderlich sind.

Edit: Danke an Jo King für die Verkleinerung.

import sys
p,m,M,T=*map(float,sys.argv[1:]),0
C=p*M
for t in range(-int(-p*m),int(p*M)+1):
 n,a=0,t
 for d in 1e4,5e3,2e3,1e3,500,100,25,10,5,1:n+=a//d;a%=d
 if n<C:T,C=t,n
print(T/100)

Java 10, 186 185 Bytes

(p,m,M)->{double r=0,t,Q=99,q;for(m*=p+.02;m<M*p;m+=.01){q=0;t=m;for(var c:new double[]{100,50,20,10,5,1,.25,.1,.05,.01})for(;t>=c;t-=c)q++;if(q<Q){Q=q;r=m;}}return"".format("%.2f",r);}

Nimmt die minimalen und maximalen Prozentsätze als /100Dezimalstellen (dh 15%als 0.15).

-1 Byte, um das Problem mit 3.51der möglichen Ausgabe zu beheben und gleichzeitig Rundungsfehler um 1 Byte zu beheben.

Probieren Sie es online aus.

Erläuterung:

(p,m,M)->{                // Method with three double parameters and String return-type
  double r=0,             //  Result-double, starting at 0
         t,               //  Temp-double
         Q=99,            //  Min amount of coins, starting at 99
         q;               //  Temp-double for the amount of coins
  for(m*=p-.02;m<M*p;     //  Loop in the range [`m*p-0.02`, `M*p`]
           m+=.01){       //  in steps of 0.01 (1 cent) per iteration
                          //  (the -0.02 (minus 2 cents) is to fix rounding errors)
    q=0;                  //   Reset `q` to 0
    t=m;                  //   Reset `t` to the current iteration `m`
    for(var c:new double[]{100,50,20,10,5,1,.25,.1,.05,.01})
                          //   Loop over the coins (largest to smallest)
      for(;t>=c;          //    As long as `t` is larger than or equal to the current coin
          t-=c)           //     Remove the coin from the value `t`
          q++;            //     And increase the quantity-counter by 1
      if(q<Q){            //   If the quantity-counter is smaller than the current smallest
        Q=q;              //    Replace the smallest with the current
        r=m;}}            //    And replace the result with the current `m`
  return"".format("%.2f",r)l;}
                          //  Return the result with 2 decimal places

Sauber , 207 156 Bytes

Das Wechseln zu einer Funktion sparte, nicht überraschend, 51 Byte.

import StdEnv
d=[10000,2000,1000,500,100,25,10,5,1]
$n u l=snd(hd(sort[(sum[foldl(rem)m(d%(0,i))/k\\k<-d&i<-[-1..]],toReal m)\\m<-map toInt[n*u..n*l]]))/1E2

Probieren Sie es online!

Python ( 264 222 Bytes)

Etwas mehr Golf.

m=[.01,.05,.1,.25,.5,1,5,10,20,50,100]
def f(a,i,j):
 t,u=9**9,a*j
 def g(s,d,c):
  nonlocal t
  if(a*i<s<u)+(c>t):t=min(c,t);return c,s
  return(t+1,s)if(s>u)+(d>9)else min(g(s+m[d],d,c+1),g(s,d+1,c))
 return g(0,0,0)[1]

Probieren Sie es online!

Perl 6 , 93 92 89 Bytes

{.01*($^a*$^b+|0...$a*$^c).min:{$!=$_;sum '✐ᎈߐϨǴd
'.ords>>.&{($!%=$_)xx$!/$_}}}

Probieren Sie es online!

Anonymer Codeblock, der drei Argumente (Preis, Mindestprozentsatz und Höchstprozentsatz) akzeptiert und den Tipp zurückgibt.

Wolfram Language (Mathematica) , 105 Byte

Dies ergibt alle Lösungen mit minimaler Münzzahl.

MinimalBy[NumberDecompose[#,d=100{100,50,20,10,5,1,.25,.10,.05,.01}]&/@Range[Ceiling[#2#],#3#],Tr].d/100&

Probieren Sie es online!

Kotlin , 215 Bytes

{p:Double,l:Int,h:Int->val d=listOf(10000,5000,2000,1000,500,100,25,10,5,1)
var m=Int.MAX_VALUE
var r=0.0
(Math.ceil(p*l).toInt()..(p*h).toInt()).map{var a=it
var c=0
d.map{c+=a/it
a%=it}
if(c<m){m=c
r=it/100.0}}
r}

Probieren Sie es online!

Jelly ,  33  32 Bytes

“ñṇzi;’b⁴×H¥\ɓ_>Ƈ-Ṫ
PĊ1¦r/ÇƬL$ÞḢ

Ein monadischer Link, der eine Liste akzeptiert, [cost in cents, [minimum ratio, maximum ratio]]die einen Trinkgeldbetrag in Cent ergibt.

Probieren Sie es online!

Wie?

Die erste Zeile ist ein Hilfslink, der den angegebenen Betrag abzüglich der größten Nennwertnote / Münze ergibt:

“ñṇzi;’b⁴×H¥\ɓ_>Ƈ-Ṫ - Link 1, get next lower amount: integer, V
“ñṇzi;’             - base 250 number = 112835839060
       b⁴           - to base 16 = [1,10,4,5,8,10,4,4,5,4]
            \       - cumulative reduce with:       e.g.: 1,10   5,4   10,5   25,8
           ¥        -   last two links as a dyad:
         ×          -     multiply                        10     20    50     200
          H         -     halve                            5     10    25     100
                    - ...yielding: [1,5,10,25,100,500,1000,2000,5000,10000]
             ɓ      - start a new dyadic link with swapped arguments
              _     - subtract (vectorises) ...i.e. [V-1,V-5,V-10,...]
                Ƈ   - filter keep those which satisfy:
                 -  -   literal -1
               >    -   greater than? (i.e. if V-X > -1)
                  Ṫ - tail (tailing an empty list yields 0)

Die Anzahl der Anrufe, die erforderlich sind, um Null zu erreichen, wird verwendet, um den Bereich der Trinkgeldbeträge zu sortieren, und dann wird ganz links ausgegeben:

PĊ1¦r/ÇƬL$ÞḢ - Main Link: [cost, [min, max]]
P            - product = [cost*min, cost*max]
   ¦         - sparse application...
  1          - ...to indices: 1
 Ċ           - ...what: ceiling   -> [ceil(cost*min), cost*max]
     /       - reduce by:
    r        -   inclusive range (implicit floor of arguments)
          Þ  - sort by:
         $   -   last two links as a monad:
       Ƭ     -     repeat collecting results until a fixed point is reached:
      Ç      -       last link (1) as a monad  (e.g. 32 -> [32,7,2,1,0])
        L    -     length (i.e. coins/notes required + 1)
           Ḣ - head