Előző - #17 Kockadobás | Tartalomjegyzék | Következő - #19 Jelszógenerátor

18. GYAKORLAT: VEGYÉL 8-AT, KAPSZ 1-ET INGYEN

   getCostOfCoffee(7, 2,50)  →  17,50
getCostOfCoffee(8, 2,50)  →  20
getCostOfCoffee(9, 2,50)  →  20

Tegyük fel, hogy egy kávézó minden alkalommal kilyukasztja az ügyfél kártyáját, amikor kávét vásárol. A kártya nyolc lyukasztása után a vásárló a kártyával ingyenesen hozzájuthat a 9. csésze kávéhoz ^. Ebben a gyakorlatban ezt lefordítja egy egyszerű számításba, hogy megtudja, mennyibe kerül egy adott kávémennyiség, figyelembe véve ezt a 8-kap-1-mentes rendszert.

Gyakorlat leírása

Írjon egy nevű függvényt ,getCostOfCoffee() amelynek paraméterei: numberOfCoffeesPricePerCoffee . Ezen információk birtokában a függvény a kávérendelés teljes költségét adja vissza. Ez azonban nem egyszerű költség és mennyiség szorzása, mert a kávézónak van olyan ajánlata, ahol minden nyolc megvásárolt kávé után kap egy ingyenes kávét.

Például nyolc kávé vásárlása 2,50 dollárért egyenként 20 dollárba (vagy 8 × 2,5-be) kerül. De kilenc kávé vásárlása is 20 dollárba kerül, mivel az első nyolctól a kilencedik kávé ingyenes. Tíz kávé vásárlása a következőképpen számol: 20 dollár az első nyolc kávéért, egy ingyenes kilencedik kávé, és 2,50 dollár a tizedik kávéért, összesen 22,50 dollárért.

Ezek a Python- assertutasítások leállítják a programot, ha feltételük False. Másolja őket a megoldási program aljára. Az Ön megoldása akkor helyes, ha a következő assertállítások feltételei mind igazak :

assert getCostOfCoffee(7; 2,50) == 17,50

állítsa getCostOfCoffee(8, 2,50) == 20

állítsa getCostOfCoffee(9, 2,50) == 20

assert getCostOfCoffee(10; 2,50) == 22,50

 

az i tartományban (1, 4):

    állítsa getCostOfCoffee(0, i) == 0

    assert getCostOfCoffee(8, i) == 8 * i

    assert getCostOfCoffee(9, i) == 8 * i

    assert getCostOfCoffee(18, i) == 16 * i

    assert getCostOfCoffee(19, i) == 17 * i

    assert getCostOfCoffee(30, i) == 27 * i

Próbáljon megoldást írni a leírásban szereplő információk alapján. Ha továbbra is problémái vannak ennek a gyakorlatnak a megoldásával, további tippekért olvassa el a Megoldástervezés és a Különleges esetek és Gotchák című részt.

Előfeltétel fogalmak: whilehurkok, kiterjesztett hozzárendelési operátor

Megoldás tervezése

Erre a gyakorlatra két megoldásom van. Az egyszerűbb a számolási megközelítés ehhez a gyakorlathoz. Először változókat hozunk létre annak nyomon követésére, hogy mennyi volt a teljes ár eddig (ez kezdődik 0), és hány csésze, amíg kapunk egy ingyenes csésze kávét (ez 8- tól kezdődik ). Ezután van egy whilehurok, amely addig folytatja a hurkolást, amíg van még számolnivaló csésze kávé. A hurkon belül csökkentjük az numberOfCoffees argumentumot, és ellenőrizzük, hogy ez egy ingyenes csésze kávé-e. Ha igen, akkor a következő ingyenes csészére visszaállítjuk a csészék számát 8-ra. Ha nem ingyenes kávéról van szó, növeljük a teljes árat, és a következő ingyenes csészére csökkentjük a csészék számát.

A ciklus befejezése után a függvény a teljes árat követő változót adja vissza.

Különleges esetek és Gotchák

Több helyen is előfordulhat egy-egy hiba. Ezek a hibák egyszerű mulasztásokból erednek, amelyek kissé hibás számításokhoz vezetnek.

Először is vegye figyelembe, hogy nyolc csésze kávét kell vásárolnia, hogy a kilencedik csészét ingyen megkapja; a nyolcadik poharat nem kapod ingyen. Az ingyenes csésze kávé nem számít bele az ingyenes csésze megvásárlásához vásárolt nyolc csészébe. Nyolc csésze és kilenc csésze ára ugyanaz: szándékosan lemondhat egy csésze ingyenes kávéról.

Most próbáljon meg egy megoldást írni az előző szakaszok információi alapján. Ha továbbra is problémái vannak a gyakorlat megoldásával, olvassa el a Megoldássablon részt további tippekért.

Megoldás sablon

Próbáljon először megoldást írni a semmiből. De ha nehézségei vannak, akkor a következő részprogramot használhatja kiindulási helynek. Másolja ki a következő kódot a https://invpy.com/buy8get1free-template.py webhelyről , és illessze be a kódszerkesztőbe. Cserélje ki az aláhúzást kódra, hogy működő programot készítsen:

def getCostOfCoffee(Kávék száma, PricePerCoffee):

    # Kövesse nyomon a teljes árat:

    teljes ár = ____

    # Kövesse nyomon, hány kávénk van, amíg nem kapunk egy ingyeneset:

    cupsUntilFreeCoffee = 8

 

    # Csúsztasson addig, amíg a megvásárolható kávék száma el nem éri a 0-t:

    miközben numberOfCoffees ____ 0:

        # Csökkentse a megvásárolható kávék számát:

        ____ -= 1

 

        # Ha ez a csésze kávé ingyenes, állítsa vissza a számot, amíg vásárolni szeretne

        # egy ingyenes csésze vissza 8-ra:

        if cupsUntilFreeCoffee == ____:

            ____ = 8

        # Ellenkező esetben fizessen egy csésze kávéért:

        más:

            # Növelje a teljes árat:

            teljes ár += ____

            # Csökkentse a megmaradt kávék mennyiségét, amíg nem kapunk egy ingyenes kávét:

            cupsUntilFreeCoffee -= ____

 

    # A teljes ár visszaküldése:

    Visszatérés ____

A gyakorlat teljes megoldását az A függelék és a https://invpy.com/buy8get1free.py tartalmazza . A program minden lépését megtekintheti, amint az egy hibakereső alatt fut a https://invpy.com/buy8get1free-debug/ oldalon .

Egy másik megoldás tervezés

The counting solution design, while simple, gets slower the larger the number of purchased coffees becomes. If you called getCostOfCoffee(1000000000, 2.50) it could take a couple of minutes before the function returns an answer. There’s a more direct way to calculate the total price for these large coffee orders.

First, you can calculate the number of free coffees by integer dividing numberOfCoffees by 9. For every nine coffees, one is a free coffee. Any remainder coffees don’t matter for counting the number of free coffees, which is why you use the // integer division operator instead of the / regular division operator. Store this division result in a variable named numberOfFreeCoffees.

To calculate the number of paid coffees, subtract numberOfFreeCoffees from numberOfCoffees and store this difference in a variable named numberOfPaidCoffees. (This makes sense; coffees are either paid for or free, so the number of paid and free coffees must add up to numberOfCoffees). The final value to return is the numberOfPaidCoffees times the pricePerCoffee.

The benefit of this solution design is that it does three calculations (a division, a subtraction, and a multiplication) no matter how big or small numberOfCoffees. Calling getCostOfCoffee(1000000000, 2.50) with this implementation finishes in milliseconds rather than minutes.

Another Solution Template

Try to first write a solution from scratch. But if you have difficulty, you can use the following partial program as a starting place. Copy the following code from https://invpy.com/buy8get1free2-template.py and paste it into your code editor. Replace the underscores with code to make a working program:

def getCostOfCoffee(numberOfCoffees, pricePerCoffee):

    # Calculate the number of free coffees we get in this order:

    numberOfFreeCoffees = ____ // 9

 

    # Calculate the number of coffees we will have to pay for in this order:

    numberOfPaidCoffees = numberOfCoffees - ____

 

    # Calculate and return the price:

    return ____ * ____

The complete solution for this exercise is given in Appendix A and https://invpy.com/buy8get1free2.py. You can view each step of this program as it runs under a debugger at https://invpy.com/buy8get1free2-debug/.

Prev - #17 Dice Roll | Table of Contents | Next - #19 Password Generator