Mini-Project : Blackjack

Mini-project description - Blackjack

Blackjack is a simple, popular card game that is played in many casinos. Cards in Blackjack have the following values: an ace may be valued as either 1 or 11 (player's choice), face cards (kings, queens and jacks) are valued at 10 and the value of the remaining cards corresponds to their number. During a round of Blackjack, the players plays against a dealer with the goal of building a hand (a collection of cards) whose cards have a total value that is higher than the value of the dealer's hand, but not over 21.  (A round of Blackjack is also sometimes referred to as a hand.)

The game logic for our simplified version of Blackjack is as follows. The player and the dealer are each dealt two cards initially with one of the dealer's cards being dealt faced down (his hole card). The player may then ask for the dealer to repeatedly "hit" his hand by dealing him another card. If, at any point, the value of the player's hand exceeds 21, the player is "busted" and loses immediately. At any point prior to busting, the player may "stand" and the dealer will then hit his hand until the value of his hand is 17 or more. (For the dealer, aces count as 11 unless it causes the dealer's hand to bust). If the dealer busts, the player wins. Otherwise, the player and dealer then compare the values of their hands and the hand with the higher value wins.The dealer wins ties in our version.

Mini-project development process

We suggest you develop your Blackjack game in two phases. The first phase will concentrate on implementing the basic logic of Blackjack while the second phase will focus on building a more full-featured version. In phase one, you will use buttons to control the game and print the state of the game to the console using print statements. In the second phase, you will replace the print statements by drawing images and text on the canvas and add some extra game logic.

In phase one, we will provide testing templates for four of the steps. The templates are designed to check whether your class implementations work correctly. You should copy your class definition into the testing template and compare the console output generated by running the template with the provided output. If the output matches, it is likely that your implementation of the class is correct. DO NOT PROCEED TO THE NEXT STEP UNTIL YOUR CODE WORKS WITH THE PROVIDED TESTING TEMPLATE. Debugging code that uses incorrectly implemented classes is extremely difficult. Avoid this problem by using our provided testing templates.

Phase one

1. Download the program template for this mini-project and review the class definition for the Card class. This class is already implemented so your task is to familiarize yourself with the code. Start by pasting the Card class definition into the provided testing template and verifying that our implementation works as expected.
2. Implement the methods __init__, __str__, add_card for the Hand class. We suggest modeling a hand as a list of cards. For help in implementing the __str__ method for hands, refer back to practice exercise number four from last week. Remember to use the string method for cards to convert each card object into a string. Once you have implemented the Hand class, test it using the provided testing template.
3. Implement the methods for the Deck class listed in the mini-project template. We suggest modeling a deck of cards as list of cards. You can generate this list using a pair of nested for loops or a list comprehension. Remember to use the Card initializer to create your cards. Userandom.shuffle() to shuffle this deck of cards. Once you have implemented the Deck class, test your Deck class using the provided testing template. Remember that the deck is randomized after shuffling, so the output of the testing template should match the output in the comments in form but not in exact value.
4. Implement the handler for a "Deal" button that shuffles the deck and deals the two cards to both the dealer and the player. The event handlerdeal for this button should shuffle the deck (stored as a global variable), create new player and dealer hands (stored as global variables), and add two cards to each hand. To transfer a card from the deck to a hand, you should use the deal_card method of the Deck class and theadd_card method of Hand class in combination. The resulting hands should be printed to the console with an appropriate message indicating which hand is which.
5. Implement the get_value method for the Hand class. You should use the provided VALUE dictionary to look up the value of a single card in conjunction with the logic explained in the video lecture for this project to compute the value of a hand. Once you have implemented theget_value method, test it using the provided testing template . 
6. Implement the handler for a "Hit" button. If the value of the hand is less than or equal to 21, clicking this button adds an extra card to player's hand. If the value exceeds 21 after being hit, print "You have busted".
7. Implement the handler for a "Stand" button. If the player has busted, remind the player that they have busted. Otherwise, repeatedly hit the dealer until his hand has value 17 or more (using a while loop). If the dealer busts, let the player know. Otherwise, compare the value of the player's and dealer's hands. If the value of the player's hand is less than or equal to the dealer's hand, the dealer wins. Otherwise the player has won.Remember the dealer wins ties in our version.

In our version of Blackjack, a hand is automatically dealt to the player and dealer when the program starts. In particular, the program template includes a call to the deal() function during initialization. At this point, we would suggest testing your implementation of Blackjack extensively.

Phase two

In the second phase of your implementation, you will add five features. For those involving drawing with global variables, remember to initialize these variables to appropriate values (like creating empty hands for the player and dealer) just before starting the frame.  

1. Implement your own draw method for the Hand class using the draw method of the Card class. We suggest drawing a hand as a horizontal sequence of cards where the parameter pos is the position of the upper left corner of the leftmost card. To simplify your code, you may assume that only the first five cards of a player's hand need to be visible on the canvas.
2. Replace printing in the console by drawing text messages on the canvas. We suggest adding a global outcome string that is drawn in the draw handler using draw_text. These messages should prompt the player to take some require action and have a form similar to "Hit or stand?" and "New deal?". Also, draw the title of the game, "Blackjack", somewhere on the canvas.
3. Add logic using the global variable in_play that keeps track of whether the player's hand is still being played. If the round is still in play, you should draw an image of the back of a card (provided in the template) over the dealer's first (hole) card to hide it. Once the round is over, the dealer's hole card should be displayed.
4. Add a score counter that keeps track of wins and losses for your Blackjack session. In the simplest case (see our demo), the program displays wins minus losses. However, you are welcome to implement a more sophisticated betting/scoring system.
5. Modify the logic for the "Deal" button to create and shuffle a new deck (or restock and shuffle an existing deck) each time the "Deal" button is clicked. This change avoids the situation where the deck becomes empty during play.
6. Finally, modify the deal function such that, if the "Deal" button is clicked during the middle of a round, the program reports that the player lost the round and updates the score appropriately.

Congratulations! You have just built Blackjack. To wrap things up, please review the demo of our version of Blackjack in the Blackjack video lecture to ensure that your version has full functionality.

CODE :

# Mini-project #6 - Blackjack

import simplegui

import random

# load card sprite - 949x392 - source: jfitz.com

CARD_SIZE = (73, 98)

CARD_CENTER = (36.5, 49)

card_images = simplegui.load_image("http://commondatastorage.googleapis.com/codeskulptor-assets/cards.jfitz.png")

CARD_BACK_SIZE = (71, 96)

CARD_BACK_CENTER = (35.5, 48)

card_back = simplegui.load_image("http://commondatastorage.googleapis.com/codeskulptor-assets/card_back.png")

# initialize global variables

in_play = False

message = ""

outcome = ""

score = 0

popped = []

player = []

dealer = []

deck = []

# define globals for cards

SUITS = ('C', 'S', 'H', 'D')

RANKS = ('A', '2', '3', '4', '5', '6', '7', '8', '9', 'T', 'J', 'Q', 'K')

VALUES = {'A':1, '2':2, '3':3, '4':4, '5':5, '6':6, '7':7, '8':8, '9':9, 'T':10, 'J':10, 'Q':10, 'K':10}

# Card class. Hand class calls this draw method for rendering card images onto canvas

class Card:

    def __init__(self, suit, rank):

        if (suit in SUITS) and (rank in RANKS):

            self.suit = suit

            self.rank = rank

        else:

            self.suit = None

            self.rank = None

    def __str__(self):

        return self.suit + self.rank

    def get_suit(self):

        return self.suit

    def get_rank(self):

        return self.rank

    def draw(self, canvas, pos):

        card_loc = (CARD_CENTER[0] + CARD_SIZE[0] * RANKS.index(self.rank), 

                    CARD_CENTER[1] + CARD_SIZE[1] * SUITS.index(self.suit))

        canvas.draw_image(card_images, card_loc, CARD_SIZE, [pos[0] + CARD_CENTER[0], pos[1] + CARD_CENTER[1]], CARD_SIZE)

        

# Hand class used for adding card objects from Deck() and for getting the value of hands

class Hand:

    def __init__(self):

        self.player_hand = []

    def __str__(self):

        s = ''

        for c in self.player_hand:

            s = s + str(c) + ' '

        return s

    def add_card(self, card):

        self.player_hand.append(card)

        return self.player_hand

    def get_value(self):

        value = 0

        for card in self.player_hand:

            rank = card.get_rank()

            value = value + VALUES[rank]

        for card in self.player_hand:

            rank = card.get_rank()    

            if rank == 'A' and value <= 11:

                value += 10

        return value

    

    def draw(self, canvas, p):

        pos = p

        for card in self.player_hand:

            card.draw(canvas, p)

            pos[0] = pos[0] + 90

        if in_play == True:

            canvas.draw_image(card_back, CARD_BACK_CENTER, CARD_BACK_SIZE, [115.5,184], CARD_BACK_SIZE)

        

# Deck class used for re-shuffling between hands and giving card objects to Hand as called

class Deck:

    def __init__(self):

        popped = []

        self.cards = [Card(suit, rank) for suit in SUITS for rank in RANKS]

        self.shuffle()

        

    def __str__(self):

        s = ''

        for c in self.cards:

            s = s + str(c) + ' '

        return s

    def shuffle(self):

        random.shuffle(self.cards)

    def deal_card(self):

        popped = self.cards.pop(0)

        return popped

    

def deal():

    # deal function deals initial hands and adjusts message.

    global in_play, player, dealer, deck, message, score, outcome

    if in_play == True:

        # if player clicks Deal button during a hand, player loses hand in progress

        message = "Here is the new hand"

        score -= 1

        deck = Deck()

        player = Hand()

        dealer = Hand()

        player.add_card(deck.deal_card())

        dealer.add_card(deck.deal_card())

        player.add_card(deck.deal_card())

        dealer.add_card(deck.deal_card())

    if in_play == False:

        # starts a new hand

        deck = Deck()

        player = Hand()

        dealer = Hand()

        player.add_card(deck.deal_card())

        dealer.add_card(deck.deal_card())

        player.add_card(deck.deal_card())

        dealer.add_card(deck.deal_card())

        message = "New Hand. Hit or Stand?"

    in_play = True

    outcome = ""

def hit():

    # deals player a new hand and ends hand if it causes a bust.

    global in_play, score, message

    if in_play == True:

        player.add_card(deck.deal_card())

        message = "Hit or Stand?"

        if player.get_value() > 21:

            in_play = False

            message = "Player busted! You Lose! Play again?"

            score -= 1

            outcome = "Dealer: " + str(dealer.get_value()) + "  Player: " + str(player.get_value())

def stand():

    # hits dealer until >=17 or busts. Determines winner of hand and adjusts score, game state, and messages

    global in_play, score, message, outcome

    if in_play == False:

        message = "The hand is already over. Deal again."

    else:

        while dealer.get_value() < 17:

            dealer.add_card(deck.deal_card())

        if dealer.get_value() > 21:

            message = "Dealer busted. You win! Play again?"

            score += 1

            in_play = False

            

        elif dealer.get_value() > player.get_value():

            message = "Dealer wins! Play again?"

            score -= 1

            in_play = False

        

        elif dealer.get_value() == player.get_value():

            message = "Tie! Dealer wins! Play again?"

            score -= 1

            in_play = False

        

        elif dealer.get_value() < player.get_value():

            message = "You win! Play again?"

            score += 1

            in_play = False

            

        outcome = "Dealer: " + str(dealer.get_value()) + "  Player: " + str(player.get_value())

        

def exit():

    frame.stop()

    

# draw handler

def draw(canvas):

    canvas.draw_text("Blackjack", [270,50], 48, "Yellow")

    canvas.draw_text("Score : " + str(score), [80,520], 36, "Black")

    canvas.draw_text("Dealer :", [80,110], 30, "Black")

    canvas.draw_text("Player :", [80,300], 30, "Black")

    canvas.draw_text(message, [200,480], 26, "Black")

    canvas.draw_text(outcome, [80,560], 28, "White")

    dealer.draw(canvas, [80,135])

    player.draw(canvas, [80,325])

    

# initialization frame

frame = simplegui.create_frame("Blackjack", 700, 600)

frame.set_canvas_background("Green")

# buttons and canvas callback

frame.add_button("Deal", deal, 200)

frame.add_button("Hit", hit, 200)

frame.add_button("Stand", stand, 200)

frame.add_button("Exit", exit, 200)

frame.set_draw_handler(draw)

# deals initial hand

deal()

# get things rolling

frame.start()

# http://www.codeskulptor.org/#user26_ZvPjz7GLuE8FuyP.py

OUTPUT :

Bank Account Code with Multiple Accounts

We will again use the BankAccount class from the previous problem. You should be able to use the same definition for both problems.

Of course, a bank with only one account will go out of business, so we want our BankAccount class to work correctly with many accounts. Naturally, each bank account should have its own balance, with deposits and withdrawals going to the appropriate account. Similarly, the penalty fees for each account should be kept separate.

class BankAccount:
    def __init__(self, initial_balance):
        """Creates an account with the given balance."""
        …
    def deposit(self, amount):
        """Deposits the amount into the account."""
        …
    def withdraw(self, amount):
        """
        Withdraws the amount from the account.  Each withdrawal resulting in a
        negative balance also deducts a penalty fee of 5 dollars from the balance.
        """
        …
    def get_balance(self):
        """Returns the current balance in the account."""
        …
    def get_fees(self):
        """Returns the total fees ever deducted from the account."""
        …

Here's one possible test with multiple accounts. It should print the values 10, 5, 5, and 0.

account1 = BankAccount(10)
account1.withdraw(15)
account2 = BankAccount(15)
account2.deposit(10)
account1.deposit(20)
account2.withdraw(20)
print account1.get_balance(), account1.get_fees(), account2.get_balance(), account2.get_fees()

Copy-and-paste the following much longer test. What four numbers are printed at the end? Enter the four numbers, separated only by spaces.

account1 = BankAccount(20)
account1.deposit(10)
account2 = BankAccount(10)
account2.deposit(10)
account2.withdraw(50)
account1.withdraw(15)
account1.withdraw(10)
account2.deposit(30)
account2.withdraw(15)
account1.deposit(5)
account1.withdraw(10)
account2.withdraw(10)
account2.deposit(25)
account2.withdraw(15)
account1.deposit(10)
account1.withdraw(50)
account2.deposit(25)
account2.deposit(25)
account1.deposit(30)
account2.deposit(10)
account1.withdraw(15)
account2.withdraw(10)
account1.withdraw(10)
account2.deposit(15)
account2.deposit(10)
account2.withdraw(15)
account1.deposit(15)
account1.withdraw(20)
account2.withdraw(10)
account2.deposit(5)
account2.withdraw(10)
account1.deposit(10)
account1.deposit(20)
account2.withdraw(10)
account2.deposit(5)
account1.withdraw(15)
account1.withdraw(20)
account1.deposit(5)
account2.deposit(10)
account2.deposit(15)
account2.deposit(20)
account1.withdraw(15)
account2.deposit(10)
account1.deposit(25)
account1.deposit(15)
account1.deposit(10)
account1.withdraw(10)
account1.deposit(10)
account2.deposit(20)
account2.withdraw(15)
account1.withdraw(20)
account1.deposit(5)
account1.deposit(10)
account2.withdraw(20)
print account1.get_balance(), account1.get_fees(), account2.get_balance(), account2.get_fees()

CODE :

# http://www.codeskulptor.org/#user25_e4TY2qlXm9gkKEk.py
class BankAccount: 
    def __init__(self, initial_balance):
        """Creates an account with the given balance."""
        self.money = initial_balance 
        self.penalty = 0
    
    def deposit(self, amount):
        """Deposits the amount into the account."""
        self.money += amount
        return self.money

    def withdraw(self, amount):
        """
        Withdraws the amount from the account.  Each withdrawal resulting in a
        negative balance also deducts a penalty fee of 5 dollars from the balance.
        """
       
        if self.money - amount < 0:
            self.money -= amount+5
            self.penalty += 5
            
        else:
            self.money -= amount
        return self.money


    def get_balance(self):
        """Returns the current balance in the account."""
        return self.money

    def get_fees(self):
        """Returns the total fees ever deducted from the account."""
        return self.penalty

account1 = BankAccount(10)
account1.withdraw(15)
account2 = BankAccount(15)
account2.deposit(10)
account1.deposit(20)
account2.withdraw(20)
print account1.get_balance(), account1.get_fees(), account2.get_balance(), account2.get_fees()
print"..............."
account1 = BankAccount(20)
account1.deposit(10)
account2 = BankAccount(10)
account2.deposit(10)
account2.withdraw(50)
account1.withdraw(15)
account1.withdraw(10)
account2.deposit(30)
account2.withdraw(15)
account1.deposit(5)
account1.withdraw(10)
account2.withdraw(10)
account2.deposit(25)
account2.withdraw(15)
account1.deposit(10)
account1.withdraw(50)
account2.deposit(25)
account2.deposit(25)
account1.deposit(30)
account2.deposit(10)
account1.withdraw(15)
account2.withdraw(10)
account1.withdraw(10)
account2.deposit(15)
account2.deposit(10)
account2.withdraw(15)
account1.deposit(15)
account1.withdraw(20)
account2.withdraw(10)
account2.deposit(5)
account2.withdraw(10)
account1.deposit(10)
account1.deposit(20)
account2.withdraw(10)
account2.deposit(5)
account1.withdraw(15)
account1.withdraw(20)
account1.deposit(5)
account2.deposit(10)
account2.deposit(15)
account2.deposit(20)
account1.withdraw(15)
account2.deposit(10)
account1.deposit(25)
account1.deposit(15)
account1.deposit(10)
account1.withdraw(10)
account1.deposit(10)
account2.deposit(20)
account2.withdraw(15)
account1.withdraw(20)
account1.deposit(5)
account1.deposit(10)
account2.withdraw(20)
print account1.get_balance(), account1.get_fees(), account2.get_balance(), account2.get_fees()
print"..............."

OUTPUT :

10 5 5 0
...............
-55 45 45 20
...............

Bank Account

First, complete the following class definition:

class BankAccount:
    def __init__(self, initial_balance):
        """Creates an account with the given balance."""
        …
    def deposit(self, amount):
        """Deposits the amount into the account."""
        …
    def withdraw(self, amount):
        """
        Withdraws the amount from the account.  Each withdrawal resulting in a
        negative balance also deducts a penalty fee of 5 dollars from the balance.
        """
        …
    def get_balance(self):
        """Returns the current balance in the account."""
        …
    def get_fees(self):
        """Returns the total fees ever deducted from the account."""
        …

The deposit and withdraw methods each change the account balance. The withdraw method also deducts a fee of 5 dollars from the balance if the withdrawal (before any fees) results in a negative balance. Since we also have the method get_fees, you will need to have a variable to keep track of the fees paid.

Here's one possible test of the class. It should print the values 10 and 5, respectively, since the withdrawal incurs a fee of 5 dollars.

my_account = BankAccount(10)
my_account.withdraw(15)
my_account.deposit(20)
print my_account.get_balance(), my_account.get_fees()

Copy-and-paste the following much longer test. What two numbers are printed at the end? Enter the two numbers, separated only by spaces.

my_account = BankAccount(10)
my_account.withdraw(5)
my_account.deposit(10)
my_account.withdraw(5)
my_account.withdraw(15)
my_account.deposit(20)
my_account.withdraw(5) 
my_account.deposit(10)
my_account.deposit(20)
my_account.withdraw(15)
my_account.deposit(30)
my_account.withdraw(10)
my_account.withdraw(15)
my_account.deposit(10)
my_account.withdraw(50) 
my_account.deposit(30)
my_account.withdraw(15)
my_account.deposit(10)
my_account.withdraw(5) 
my_account.deposit(20)
my_account.withdraw(15)
my_account.deposit(10)
my_account.deposit(30)
my_account.withdraw(25) 
my_account.withdraw(5)
my_account.deposit(10)
my_account.withdraw(15)
my_account.deposit(10)
my_account.withdraw(10) 
my_account.withdraw(15)
my_account.deposit(10)
my_account.deposit(30)
my_account.withdraw(25) 
my_account.withdraw(10)
my_account.deposit(20)
my_account.deposit(10)
my_account.withdraw(5) 
my_account.withdraw(15)
my_account.deposit(10)
my_account.withdraw(5) 
my_account.withdraw(15)
my_account.deposit(10)
my_account.withdraw(5) 
print my_account.get_balance(), my_account.get_fees()

CODE :

# http://www.codeskulptor.org/#user25_wvi8CqCpEVvhzVa.py

class BankAccount: 

    def __init__(self, initial_balance):

        """Creates an account with the given balance."""

        self.money = initial_balance 

        self.penalty = 0

    

    def deposit(self, amount):

        """Deposits the amount into the account."""

        self.money += amount

        return self.money

    def withdraw(self, amount):

        """

        Withdraws the amount from the account.  Each withdrawal resulting in a

        negative balance also deducts a penalty fee of 5 dollars from the balance.

        """

       

        if self.money - amount < 0:

            self.money -= amount+5

            self.penalty += 5

            

        else:

            self.money -= amount

        return self.money

    def get_balance(self):

        """Returns the current balance in the account."""

        return self.money

    def get_fees(self):

        """Returns the total fees ever deducted from the account."""

        return self.penalty

my_account = BankAccount(10)

my_account.withdraw(15)

my_account.deposit(20)

print my_account.get_balance(), my_account.get_fees()

print "....."

my_account = BankAccount(10)

my_account.withdraw(5)

my_account.deposit(10)

my_account.withdraw(5)

my_account.withdraw(15)

my_account.deposit(20)

my_account.withdraw(5) 

my_account.deposit(10)

my_account.deposit(20)

my_account.withdraw(15)

my_account.deposit(30)

my_account.withdraw(10)

my_account.withdraw(15)

my_account.deposit(10)

my_account.withdraw(50) 

my_account.deposit(30)

my_account.withdraw(15)

my_account.deposit(10)

my_account.withdraw(5) 

my_account.deposit(20)

my_account.withdraw(15)

my_account.deposit(10)

my_account.deposit(30)

my_account.withdraw(25) 

my_account.withdraw(5)

my_account.deposit(10)

my_account.withdraw(15)

my_account.deposit(10)

my_account.withdraw(10) 

my_account.withdraw(15)

my_account.deposit(10)

my_account.deposit(30)

my_account.withdraw(25) 

my_account.withdraw(10)

my_account.deposit(20)

my_account.deposit(10)

my_account.withdraw(5) 

my_account.withdraw(15)

my_account.deposit(10)

my_account.withdraw(5) 

my_account.withdraw(15)

my_account.deposit(10)

my_account.withdraw(5) 

print my_account.get_balance(), my_account.get_fees()

print "....."

OUTPUT :

10 5
......
-60 75
......

Enter the first year when the fast wumpuses outnumber the slow wumpuses

We can use loops to simulate natural processes over time. Write a program that calculates the populations of two kinds of “wumpuses” over time. At the beginning of year 1, there are 1000 slow wumpuses and 1 fast wumpus. This one fast wumpus is a new mutation. Not surprisingly, being fast gives it an advantage, as it can better escape from predators. Each year, each wumpus has one offspring. (We'll ignore the more realistic niceties of sexual reproduction, like distinguishing males and females.). There are no further mutations, so slow wumpuses beget slow wumpuses, and fast wumpuses beget fast wumpuses. Also, each year 40% of all slow wumpuses die each year, while only 30% of the fast wumpuses do.

So, at the beginning of year one there are 1000 slow wumpuses. Another 1000 slow wumpuses are born. But, 40% of these 2000 slow wumpuses die, leaving a total of 1200 at the end of year one. Meanwhile, in the same year, we begin with 1 fast wumpus, 1 more is born, and 30% of these die, leaving 1.4. (We'll also allow fractional populations, for simplicity.)

Beginning of Year	Slow Wumpuses	Fast Wumpuses
1	1000	1
2	1200	1.4
3	1440	1.96
…	…	…

Enter the first year in which the fast wumpuses outnumber the slow wumpuses. Remember that the table above shows the populations at the start of the year.

CODE: 
# http://www.codeskulptor.org/#user25_kGSRR7OF76rhSba.py

slow_wumpuses, fast_wumpuses = 1000, 1

years=0

while slow_wumpuses > fast_wumpuses:

    slow_wumpuses *=.6*2

    fast_wumpuses *=.7*2

    years+=1

print "First year when the fast wumpuses outnumber the slow wumpuses : ", years

Output :

First year when the fast wumpuses outnumber the slow wumpuses :  45

Convert English description into code

Convert the following English description into code.

1. Initialize n to be 1000. Initialize numbers to be a list of numbers from 2 to n, but not including n.
2. With results starting as the empty list, repeat the following as long as numbers contains any numbers.
   • Add the first number in numbers to the end of results.
   • Remove every number in numbers that is evenly divisible by (has no remainder when divided by) the number that you had just added toresults.

How long is results?

To test your code, when n is instead 100, the length of results is 25.

CODE :

n = 1000

numbers = range(2, n)

results = []

 while numbers != []:

    results.append(numbers[0])

    numbers = [n for n in numbers if n % numbers[0] != 0]

 print len(results)

# http://www.codeskulptor.org/#user25_2ekzalIuBzMYYnj.py

Output :

168

Mini-project # 5: Memory - Card Game

Mini-project development process

As usual, we suggest that you start from the program template for this mini-project.

1. Model the deck of cards used in Memory as a list consisting of 16 numbers with each number lying in the range [0,8) and appearing twice. We suggest that you create this list by concatenating two list with range [0,8) together. Use the Docs to locate the list concatenation operator.
2. Write a draw handler that iterates through the Memory deck using a for loop and uses draw_text to draw the number associated with each card on the canvas. The result should be a horizontal sequence of evenly-spaced numbers drawn on the canvas.
3. Shuffle the deck using random.shuffle(). Remember to debug your canvas drawing code before shuffling to make debugging easier.
4. Next, modify the draw handler to either draw a blank green rectangle or the card's value. To implement this behavior, we suggest that you create a second list called exposed. In the exposed list, the ith entry should be True if the ith card is face up and its value is visible or False if the ith card is face down and it's value is hidden. We suggest that you initialize exposed to some known values while testing your drawing code with this modification.
5. Now, add functionality to determine which card you have clicked on with your mouse. Add an event handler for mouse clicks that takes the position of the mouse click and prints the index of the card that you have clicked on to the console. To make determining which card you have clicked on easy, we suggest sizing the canvas so that the sequence of cards entirely fills the canvas.
6. Modify the event handler for mouse clicks to flip cards based on the location of the mouse click. If the player clicked on the ith card, you can change the value of exposed[i] from False to True. If the card is already exposed, you should ignore the mouseclick. At this point, the basic infrastructure for Memory is done.
7. You now need to add game logic to the mouse click handler for selecting two cards and determining if they match. We suggest following the game logic in the example code discussed in the Memory video. State 0 corresponds to the start of the game. In state 0, if you click on a card, that card is exposed, and you switch to state 1. State 1 corresponds to a single exposed unpaired card. In state 1, if you click on an unexposed card, that card is exposed and you switch to state 2. State 2 corresponds to the end of a turn. In state 2, if you click on an unexposed card, that card is exposed and you switch to state 1.
8. Note that in state 2, you also have to determine if the previous two cards are paired or unpaired. If they are unpaired, you have to flip them back over so that they are hidden before moving to state 1. We suggest that you use two global variables to store the index of each of the two cards that were clicked in the previous turn.
9. Add a counter that keeps track of the number of turns and uses set_text to update this counter as a label in the control panel. (BTW, Joe's record is 12 turns.)  This counter should be incremented after either the first or second card is flipped during a turn.
10. Finally, implement the new_game() function (if you have not already) so that the "Reset" button reshuffles the cards, resets the turn counter and restarts the game. All cards should start the game hidden.
11. (Optional) You may replace the draw_text for each card by a draw_image that uses one of eight different images.

Once the run button is clicked in CodeSkulptor, the game should start. You should not have to hit the "Reset" button to start. Once the game is over, you should hit the "Reset" button to restart the game. 

While this project may seem daunting at first glance, our full implementation took well under 100 lines with comments and spaces. If you feel a little bit intimidated, focus on developing your project to step six. Our experience is that, at this point, you will begin to see your game come together and the going will get much easier.

CODE :

# http://www.codeskulptor.org/#user24_KgfZC5P5oSvoRU9.py

# mini-project #5 : Card game - Memory

import simplegui

import random

turns=0

# helper function to initialize globals

def new_game():

    global listOfCards,exposed,openedCard,clickCounter,turns

    listOfCards=[i for i in range(8)]+[i for i in range(8)]

    random.shuffle(listOfCards)

    exposed=[False for i in range(16)]

    openedCard=[]

    clickCounter=0

    turns=0

   

# define event handlers

def mouseclick(pos):

    global clickCounter,turns

    if clickCounter==0:

        openedCard.append(pos[0]//50)

        exposed[pos[0]//50]=True

        clickCounter+=1

        turns=1

        

    elif clickCounter==1:

        if not (pos[0]//50 in openedCard):

            openedCard.append(pos[0]//50)

            clickCounter+=1

        exposed[pos[0]//50]=True

       

    else:

        if not (pos[0]//50 in openedCard):

            if listOfCards[openedCard[-1]]!=listOfCards[openedCard[-2]]:

                exposed[openedCard[-1]]=False

                exposed[openedCard[-2]]=False

                openedCard.pop()

                openedCard.pop()

            clickCounter=1

            turns+=1

            exposed[pos[0]//50]=True

            openedCard.append(pos[0]//50)

                        

# cards are logically 50x100 pixels in size    

def draw(canvas):

        label.set_text("Turns = "+str(turns))

        for i in range(16):

            canvas.draw_line([50*(i%15+1),0], [50*(i%15+1),100], 2, "Green")

            if exposed[i]:

                canvas.draw_text(str(listOfCards[i]), [15+50*i,70], 40, "White")

         

# create frame and add a button and labels

frame = simplegui.create_frame("Memory", 800, 100)

frame.add_button("Restart", new_game) 

label=frame.add_label("Turns = 0")

# register event handlers

frame.set_mouseclick_handler(mouseclick)

frame.set_draw_handler(draw)

# get things rolling

new_game()

frame.start()

Output :