Python Programming

Sunday, November 3, 2013

Stopwatch: The Game

Mini-project description - "Stopwatch: The Game"

Our mini-project for this week will focus on combining text drawing in the canvas with timers to build a simple digital stopwatch that keeps track of the time in tenths of a second. The stopwatch should contain "Start", "Stop" and "Reset" buttons. To help guide you through this project, we suggest that you download the provided program template for this mini-project and build your stopwatch program as follows:

Mini-project development process

Construct a timer with an associated interval of 0.1 seconds whose event handler increments a global integer. (Remember thatcreate_timer takes the interval specified in milliseconds.) This integer will keep track of the time in tenths of seconds. Test your timer by printing this global integer to the console. Use the CodeSkulptor reset button in the blue menu bar to terminate your program and stop the timer and its print statements. Important: Do not use floating point numbers to keep track of tenths of a second! While it's certainly possible to get it working, the imprecision of floating point can make your life miserable. Use an integer instead, i.e., 12 represents 1.2 seconds.
Write the event handler function for the canvas that draws the current time (simply as an integer, you should not worry about formatting it yet) in the middle of the canvas. Remember that you will need to convert the current time into a string using str before drawing it.
Add "Start" and "Stop" buttons whose event handlers start and stop the timer. Next, add a "Reset" button that stops the timer and reset the current time to zero. The stopwatch should be stopped when the frame opens.
Next, write a helper function format(t) that returns a string of the form A:BC.D where A, C and D are digits in the range 0-9 and Bis in the range 0-5. Test this function independent of your project. Note that the string returned by your helper function format should always correctly include leading zeros. For example
- format(0) = 0:00.0
- format(11) = 0:01.1
- format(321) = 0:32.1
- format(613) = 1:01.3
Hint: Use integer division and remainder (modular arithmetic) to extract various digits for the formatted time from the global integer timer.
Insert a call to the format function into your draw handler to complete the stopwatch. (Note that the stopwatch need only work correctly up to 10 minutes, beyond that its behavior is your choice.)
Finally, to turn your stopwatch into a test of reflexes, add to two numerical counters that keep track of the number of times that you have stopped the watch and how many times you manage to stop the watch on a whole second (1.0, 2.0, 3.0, etc.). These counters should be drawn in the upper right-hand part of the stopwatch canvas in the form "x/y" where x is the number of successful stops and y is number of total stops. My best effort at this simple game is around a 25% success rate.
Add code to ensure that hitting the "Stop" button when the timer is already stopped does not change your score. We suggest that you add a global Boolean variable that is True when the stopwatch is running and False when the stopwatch is stopped. You can then use this value to determine whether to update the score when the "Stop" button is pressed.
Modify "Reset" so as to set these numbers back to zero when clicked.

Steps 1-3 and 5-7 above are relatively straightforward. However, step 4 requires some adept use of integer division and modular arithmetic. So, we again emphasize that you build and debug the helper function format(t) separately.

Code:

# Mini-Project 4: The Digital Stop Watch Game!

import simplegui

# Define global variables
mins, sec, count, x, y, z1, z2 = 0, 0, 0, 0, 0, 0, 0

# counting tenths of seconds into formatted string A:BC.D
def format(t):
global count, sec, mins
t = count
if (t == 10):
sec += 1
count = 0
if (sec == 60):
mins += 1
sec = 0

# Event handlers for buttons; "Start", "Stop", "Reset" and "Exit"

def start_timer():
global z1, z2
if z1-z2 == 0:
z1 += 1
timer.start()

def stop_timer():
global x, y, z1, z2
if z1-z2 == 1:
z2 += 1
timer.stop()
y += 1
if count == 0 :
x += 1

def reset_timer():
global count, sec, mins, x, y, z1,z2
timer.stop()
mins, sec, count, x, y,z1,z2 = 0, 0, 0, 0, 0, 0, 0

def exit_timer():
frame.stop()

# Event handler for timer with 0.1 sec interval
def timer_handler():
global count
count += 1

def draw_handler(canvas):
global count, sec, min, x, y
format(count)
canvas.draw_text(str(x)+"/"+str(y), (135,30), 30, "Red")
if (sec < 10):
canvas.draw_text(str(mins)+":"+ "0"+str(sec)+"."+str(count),(60,100),30,"White")
else:
canvas.draw_text(str(mins)+":"+str(sec)+"."+str(count),(60,100),30,"White")


# create frame
frame = simplegui.create_frame("Digital Stopwatch Game! ",200,200)

# register event handlers
timer = simplegui.create_timer(100,timer_handler)
frame.add_button("Start",start_timer,100)
frame.add_button("Stop ",stop_timer,100)
frame.add_button("Reset",reset_timer,100)
frame.add_button("Exit ",exit_timer,100)
frame.set_draw_handler(draw_handler)

# start frame
frame.start()

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

Result :

Key handling problem

Write a Python program that initializes a global variable to 5. The keydown event handler updates this global variable by doubling it, while the keyup event handler updates it by decrementing it by 3.

What is the value of the global variable after 12 separate key presses, i.e., pressing and releasing one key at a time, and repeating this 12 times in total?

To test your code, the global variable's value should be 35 after 4 key presses.

CODE :

import simplegui
var, i = 5, 0
current_key=''

# event handlers
def keydown(key):
    global var,i, current_key
    current_key=chr(key)
    var*=2
def keyup(key):
    global var,i, current_key
    current_key= ''
    var-=3
    i+=1

def count():
    return str(i)

def result ():
    return str(var)

def draw(canvas):
    canvas.draw_text('Count' , (30, 80), 25, 'White')
    canvas.draw_text('Result' , (110,80), 25, 'White')
    canvas.draw_text( count() , (50, 110), 30, 'Green')
    canvas.draw_text( result(), (110, 110), 30, 'Green')

# create frame
frame = simplegui.create_frame("Key Handling", 200, 200)

# register event handlers
frame.set_keydown_handler(keydown)
frame.set_keyup_handler(keyup)
frame.set_draw_handler(draw)

# start frame
frame.start()

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

Output:

Do the Point and Rectangle ever Overlap?

Problem :
Convert the following specification into code. Do the point and rectangle ever overlap?

A point starts at [10, 20]. It repeatedly changes position by [3, 0.7] — e.g., under button or timer control. Meanwhile, a rectangle stays in place. Its corners are at [50, 50] (upper left), [180, 50] (upper right), [180, 140] (lower right), and [50, 140] (lower left).

To check for overlap, i.e., collision, just run your code and check visually. You do not need to implement a point-rectangle collision test. However, we encourage you to think about how you would implement such a test.

Yes

CODE :

import simplegui

# initialize state
width = 200
height = 200
position = [10, 20]
radius = 2
velocity = [3,0.7]

# event handlers
def keydown(key):
    if key == simplegui.KEY_MAP['down']:
        position[1] = position[1] - velocity[1]
        position[0] = position[0] - velocity[0]

    elif key == simplegui.KEY_MAP['up']:
        position[1] = position[1] + velocity[1]
        position[0] = position[0] + velocity[0]


def draw(canvas):
    canvas.draw_circle(position, radius, 2, "red", "red")
    canvas.draw_line((50, 50), (50, 140), 2, "White")
    canvas.draw_line((50, 140), (180, 140), 2, "White")
    canvas.draw_line((180, 50), (50, 50), 2, "White")
    canvas.draw_line((180, 140), (180, 50), 2, "White")

# create frame
frame = simplegui.create_frame("Key Handling", width, height)

# register event handlers
frame.set_keydown_handler(keydown)
frame.set_draw_handler(draw)

# start frame
frame.start()

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

Output :

Saturday, November 2, 2013

Play with Strings !

STRINGS

LOVE IT !! Besides numbers, Python can also manipulate strings, which can be expressed in several ways.

#! python works with strings
# Used 1 to 24 in printing to see the results in console.

# Strings can be concatenated (glued together) with the + operator, and repeated with *:

word = 'Help' + 'A'
print 1,word

print 2,'<' + word*5 + '>'

# Two string literals next to each other are automatically concatenated;
# the first line above could also have been written "word = 'Help' 'A'";
# this only works with two literals, not with arbitrary string expressions:

st='str' 'ing' # <- This is ok
print 3, st
st='str'.strip() + 'ing' # <- This is ok
print 4, st

# Strings can be subscripted (indexed); like in C, the first character of a string
# has subscript (index) 0. There is no separate character type; a character is
# simply a string of size one. Like in Icon, substrings can be specified with
# the slice notation: two indices separated by a colon.

print 5, word[4]

print 6, word[0:2]

print 7, word[2:4]

# Slice indices have useful defaults; an omitted first index defaults to zero,
# an omitted second index defaults to the size of the string being sliced.

print 8, word[:2] # The first two characters
print 9, word[2:] # All but the first two characters

# Python strings cannot be changed. Assigning to an indexed position in the string results in an error:
# However, creating a new string with the combined content is easy and efficient:

print 10, 'x' + word[1:]

print 11, 'Splat' + word[4]

# Here's a useful invariant of slice operations: s[:i] + s[i:] equals s.

print 12, word[:2] + word[2:]

print 13, word[:3] + word[3:]

# Degenerate slice indices are handled gracefully: an index that is too large is replaced
# by the string size, an upper bound smaller than the lower bound returns an empty string.

print 14, word[1:100]

print 15, word[10:]

print 16, word[2:1]

# Indices may be negative numbers, to start counting from the right. For example:

print 17, word[-1] # The last character

print 18, word[-2] # The last-but-one character

print 19, word[-2:] # The last two characters

print 20, word[:-2] # All but the last two characters

# But note that -0 is really the same as 0, so it does not count from the right!

print 21, word[-0] # (since -0 equals 0)

# Out-of-range negative slice indices are truncated, but don't try this for single-element (non-slice) indices:

print 22, word[-100:]

# print word[-10] # error

#The best way to remember how slices work is to think of the indices as pointing between characters,
#with the left edge of the first character numbered 0. Then the right edge of the last character
#of a string of n characters has index n, for example:

# +---+---+---+---+---+
# | H | e | l | p | A |
# +---+---+---+---+---+
# 0 1 2 3 4 5
#-5 -4 -3 -2 -1

s = 'supercalifragilisticexpialidocious'
print 23, s
print 24, 'length of above string is : ', len(s)

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

Output :

1 HelpA
2 <HelpAHelpAHelpAHelpAHelpA>
3 string
4 string
5 A
6 He
7 lp
8 He
9 lpA
10 xelpA
11 SplatA
12 HelpA
13 HelpA
14 elpA
15 
16 
17 A
18 p
19 pA
20 Hel
21 H
22 HelpA
23 supercalifragilisticexpialidocious
24 length of above string is :  34

Thursday, October 31, 2013

The Collatz conjecture or the 3n + 1 conjecture

Given any initial natural number, consider the sequence of numbers generated by repeatedly following the rule:

divide by two if the number is even or
multiply by 3 and add 1 if the number is odd.

The Collatz conjecture states that this sequence always terminates at 1. For example, the sequence generated by 23 is:

23, 70, 35, 106, 53, 160, 80, 40, 20, 10, 5, 16, 8, 4, 2, 1

Write a Python program that takes a global variable n and print out the sequence of numbers generated by this rule. Run this program for n = 217. What is the largest number in the sequence generated by this starting value?

To test your code, starting at n = 23 generates a sequence with a maximum value of 160.

Note: The Collatz conjecture is a conjecture in mathematics named after Lothar Collatz, who first proposed it in 1937. The conjecture is also known as the 3n + 1 conjecture. For more detail : http://en.wikipedia.org/wiki/Collatz_conjecture

n=int(raw_input("Enter the beginning number: "))
i=0
print n
while n > 1:
if n%2 == 0: # if n is even
n = n/2
print n
else:
n = 3*n+1
print n
i += 1;

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

Sunday, October 27, 2013

My First Automobile in Python

#Turn the following description into a CodeSkulptor program, and run it.

#Create a 300-by-300 canvas.
#Draw two circles with radius 20 and white lines of width 10. One is centered at (90,200) and one at (210,200).
#Draw a red line of width 40 from (50,180) to (250,180).
#Draw two red lines of width 5 from (55,170) to (90,120) and from (90,120) to (130,120).
#Draw a red line of width 140 from (180,108) to (180,160).
#The resulting picture is a simple diagram of what?

import simplegui

# define draw handler
def draw(canvas):
#Draw two circles with radius 20 and white lines of width 10. One is centered at (90,200) and one at (210,200).
canvas.draw_circle([90, 200], 20, 10, "White")
canvas.draw_circle([210, 200], 20, 10, "White")

#Draw a red line of width 40 from (50,180) to (250,180).
canvas.draw_line((50, 180), (250, 180), 10, "Red")

#Draw two red lines of width 5 from (55,170) to (90,120) and from (90,120) to (130,120).
canvas.draw_line((55, 170), (90, 120), 5, "Red")
canvas.draw_line((90, 120), (130, 120), 5, "Red")

#Draw a red line of width 140 from (180,108) to (180,160).
canvas.draw_line((180, 108), (180, 160), 140, "Red")

# create frame
frame = simplegui.create_frame("My First Automobile", 300, 300)

# register draw handler
frame.set_draw_handler(draw)

# start frame
frame.start()

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

Output :

Calculate the Occurance of a Character in a given String!

# Calculate the number of 1 and L in the string given

s="1lll1l1l1l1ll1l111ll1l1ll1l1ll1ll111ll1ll1ll1l1ll1ll1ll1ll1lll1l1l1l1l1l1l1l1l1l1l1l1ll1lll1l111ll1l1l1l1l1l1"

print "Length of String given is : ", len(s)
x,y=0,0
for n in range (0,len(s)):

if s[n]=='l':
x=x+1
else:
y=y+1
print "Number of times L appeared in the given string is : ", x
print "Number of times 1 appear in the given string is : ", y

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

==============
Console Output :

Length of String given is :  109
Number of times L appeared in the given string is :  61
Number of times 1 appear in the given string is :  48

#Another way to do this is by a simple command :
import simplegui
string="1lll1l1l1l1ll1l111ll1l1ll1l1ll1ll111ll1ll1ll1l1ll1ll1ll1ll1lll1l1l1l1l1l1l1l1l1l1l1l1ll1lll1l111ll1l1l1l1l1l1"
x= string.count("l")
y= string.count("1")

print "Length of String given is : ", len(string)
print "Number of times L appeared in the given string is : ", x

print "Number of times 1 appear in the given string is : ", y

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

==============
Console Output Remains the same :

Length of String given is :  109
Number of times L appeared in the given string is :  61
Number of times 1 appear in the given string is :  48

Friday, October 25, 2013

Comparison of Two Number by taking input from User!

# Compare two number by taking input from User

# Program explains How to take input from user and usage of 'if'operator

x = int(raw_input("Enter First number: "))

y = int(raw_input("Enter Second number: "))

if x > y:
print 'First number is greater then second'

elif x < y :
print 'Second number is greater then first'

else:
print 'Both the Numbers are equal'

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

Fibonacci series

# Fibonacci series:
# the sum of two elements defines the next
b, c = 0, 1
while c < 200:
       print c,
       b, c = c, b+c

Console Output :

1 1 2 3 5 8 13 21 34 55 89 144

Mini-Project 2 : “Guess the number” Game

Mini-project description — “Guess the number” game

One of the simplest two-player games is “Guess the number”. The first player thinks of a secret number in some known range while the second player attempts to guess the number. After each guess, the first player answers either “Higher”, “Lower” or “Correct!” depending on whether the secret number is higher, lower or equal to the guess. In this project, you will build a simple interactive program in Python where the computer will take the role of the first player while you play as the second player.

You will interact with your program using an input field and several buttons. For this project, we will ignore the canvas and print the computer's responses in the console. Building an initial version of your project that prints information in the console is a development strategy that you should use in later projects as well. Focusing on getting the logic of the program correct before trying to make it display the information in some “nice” way on the canvas usually saves lots of time since debugging logic errors in graphical output can be tricky.

suggested development strategy for the basic version of “Guess the number” is:

Decide on a set of global variables that contain the state of the game. For example, one obvious choice is the secret number that has been generated by the program. You will need other global variables, especially to accommodate later extensions to the basic game.
Figure out how to generate a random secret number in a given range, low to high. When discussing ranges, we will follow the standard Python convention of including the low end of the range and excluding the high end of the range, which can be expressed mathematically as [low, high). So, [0, 3) means all of the numbers starting at 0 up to, but not including 3. In other words 0, 1, and 2. We suggest using the range [0, 100) in your first implementation. Hint: look at the functions in the random module to figure out how to easily select such a random number. We suggest testing this in a separate CodeSkulptor tab before adding code to your project.
Figure out how to create an input text box using the simplegui module. You will use this input to get the guess from the user. For all variants of the game, this input field should always be active (in other words, a game should always be in progress). Again, test in a separate CodeSkulptor tab before adding code to your project. Again, we suggest testing separate CodeSkulptor tab before adding code to your project.
Write the event handler input_guess(guess) that takes the input guess, compares it to the secret number and prints out the appropriate response. Remember that guess is a string so you will need to convert it into a number before testing it against the secret number. Hint: We have showed you how to convert strings to numbers in the lectures.
Test your code by playing multiple games of “Guess the number” with a fixed range. At this point, you will need to re-run your program between each game (using the CodeSkulptor “Run” button).
Fill in your new_game() function so the generation of the secret number is now done inside this function. That is, calling new_game() should compute a random secret number and assign it to a global variable. You can now call the function new_game() in the body of your code right before you start your frame.

From this minimal working version of “Guess the number”, the rest of this project consists of adding extra functionality to your project. There are two improvements that you will need to make to get full credit:

Using function(s) in the simplegui module, add buttons to restart the game so that you don't need to repeatedly click “Run” in CodeSkulptor to play multiple games. You should add two buttons: “Range: 0 - 100” and “Range: 0 - 1000” that allow the player to choose different ranges for the secret number. Using either of these buttons should restart the game and print out an appropriate message. They should work at any time during the game. In our implementation, the event handler for each button set the desired range for the secret number (as a global variable) and then called new_game to reset the secret number in the desired range.

As you play “Guess the number”, you might notice that a good strategy is to maintain an interval that consists of the highest guess that is “Lower” than the secret number and the lowest guess that is “Higher” than the secret number. A good choice for the next guess is the number that is the average of these two numbers. The answer for this new guess then allows you to figure a new interval that contains the secret number and that is half as large. For example, if the secret number is in the range [0, 100), it is a good idea to guess 50. If the answer is "Higher", the secret number must be in the range [51, 100). It is then a good idea to guess 75 and so on. This technique of successively narrowing the range corresponds to a well-known computer algorithm known as binary search.
Your final addition to “Guess the number” will be to restrict the player to a limited number of guesses. After each guess, your program should include in its output the number of remaining guesses. Once the player has used up those guesses, they lose, the game prints out an appropriate message, and a new game immediately starts.

Since the strategy above for playing “Guess the number” approximately halves the range of possible secret numbers after each guess, any secret number in the range [low, high) can always be found in at most n guesses where n is the smallest integer such that 2 ** n >= high - low + 1. For the range [0, 100), n is seven. For the range [0, 1000), n is ten. In our implementation, the function new_game() set the number of allowed guess to seven when the range is [0, 100) or to ten when the range is [0, 1000). For more of a challenge, you may compute n fromlow and high using the functions math.log and math.ceil in the math module.

When your program starts, the game should immediately begin in range [0, 100). When the game ends (because the player either wins or runs out of guesses), a new game with the same range as the last one should immediately begin by calling new_game(). Whenever the player clicks one of the range buttons, the current game should stop and a new game with the selected range should begin.

Grading rubric — 11 pts total (scaled to 100 pts)

Your peers will assess your mini-project according to the rubric given below. To guide you in determining whether your project satisfies each item in the rubric, please consult the video that demonstrates our implementation of “Guess the number”. Small deviations from the textual output of our implementation are fine. You should avoid potentially confusing deviations (such as printing “Too high” or “Too low” instead of “Lower” and “Higher”). Whether moderate deviations satisfy an item of the grading rubric is at your peers' discretion during their assessment.

Here is a break down of the scoring:

1 pt — The game starts immediately when the “Run” button in CodeSkulptor is pressed.
1 pt — A game is always in progress. Finishing one game immediately starts another in the same range.
1 pt — The game reads guess from the input field and correctly prints it out.
3 pts — The game correctly plays “Guess the number” with the range [0, 100) and prints understandable output messages to the console. Play three complete games: 1 pt for each correct game.
2 pts — The game includes two buttons that allow the user to select the range [0, 100) or the range [0, 1000) for the secret number. These buttons correctly change the range and print an appropriate message. (1 pt per button.)
2 pts — The game restricts the player to a finite number of guesses and correctly terminates the game when these guesses are exhausted. Award 1 pt if the number of remaining guesses is printed, but the game does not terminate correctly.
1 pt — The game varies the number of allowed guesses based on the range of the secret number — seven guesses for range [0, 100), ten guesses for range [0, 1000).

To help aid you in gauging what a full credit project might look like, the video lecture on the “Guess the number” project includes a demonstration of our implementation of this project. You do not need to validate that the input number is in the correct range. (For this game, that responsibility should fall on the player.)

=================================================================================

Code :

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

# Mini Project "Guess the number"

import random

import math

import simplegui

# initialize global variables used in your code

limit = 100

secret_number = random.randrange(0, 100)

max_guess =math.ceil(math.log(limit+1,2))

# define event handlers for control panel

def range100():

global secret_number, max_guess, limit

secret_number = random.randrange(0, 100)

max_guess = math.ceil(math.log(limit+1,2))

print "Let's try a new secret number, ranging from 0 to 100!"

print "You have", int(max_guess),"guesses remaining.\n"

# button that changes range to range [0,100) and restarts

def range1000():

global secret_number, max_guess, limit

secret_number = random.randrange(0, 1000)

limit=1000

max_guess = math.ceil(math.log(limit+1,2))

print "Let's try a new secret number, ranging from 0 to 1000!"

print "You have", int(max_guess),"guesses remaining.\n"

# button that changes range to range [0,1000) and restarts

def get_input(guess):

# main game logic goes here

global max_guess, limit,secret_number

max_guess -= 1

if int(max_guess) > 0 :

if int(guess) == secret_number and limit==100:

print guess, "is correct. You won congratulation! \n "

max_guess = math.ceil(math.log(limit+1,2))

secret_number = random.randint(0,limit)

range100()

elif int(guess) == secret_number and limit==1000:

print guess, "is correct. You won congratulation! \n"

max_guess = math.ceil(math.log(limit+1,2))

secret_number = random.randint(0,limit)

range1000()

elif int(guess) > secret_number:

print "Guess is " + guess + ". Try Lower."

print "You have", int(max_guess),"guesses remaining."

else:

print "Guess is " + guess +". Try Higher."

print "You have", int(max_guess),"guesses remaining."

else:

if int(guess) == secret_number :

if limit==100:

print guess, "is correct. You won congratulation! \n "

max_guess = math.ceil(math.log(limit+1,2))

secret_number = random.randint(0,limit)

range100()

else:

print guess, "is correct. You won congratulation! \n"

max_guess = math.ceil(math.log(limit+1,2))

secret_number = random.randint(0,limit)

range1000()

else:

if limit==1000:

print "You Lose. The Secret Number was ", secret_number, " \n"

max_guess = math.ceil(math.log(limit+1,2))

secret_number = random.randint(0,limit)

range1000()

else :

print "You Lose. The Secret Number was ", secret_number," \n"

max_guess = math.ceil(math.log(limit+1,2))

secret_number = random.randint(0,limit)

range100()

# create frame

frame = simplegui.create_frame("Guess The Number", 200, 200)

# register event handlers for control elements

game_100 = frame.add_button("Range: 0 - 100", range100)

game_1000 = frame.add_button("Range: 0 - 1000", range1000)

inpt = frame.add_input("Enter guess", get_input, 100)

# start frame

frame.start()