|
|
|
|
|
|
|
class Point:
def __init__(self, x=0, y=0):
self.x = x
self.y = y
def __str__(self):
return '(' + str(self.x) + ', ' + str(self.y) + ')'
def __add__(self, other):
return Point(self.x + other.x, self.y + other.y)
def __sub__(self, other):
return Point(self.x - other.x, self.y - other.y)
def __mul__(self, other):
return self.x * other.x + self.y * other.y
def __rmul__(self, other):
return Point(other * self.x, other * self.y)
def reverse(self):
self.x, self.y = self.y, self.x
def frontAndBack(front):
from copy import copy
back = copy(front)
back.reverse()
print str(front) + str(back)
class Time:
def __init__(self, hours=0, minutes=0, seconds=0):
self.hours = hours
self.minutes = minutes
self.seconds = seconds
def __str__(self):
return str(self.hours) + ":" + str(self.minutes) + ":" + str(self.seconds)
def convertToSeconds(self):
minutes = self.hours * 60 + self.minutes
seconds = self.minutes * 60 + self.seconds
return seconds
def increment(self, secs):
secs = secs + self.seconds
self.hours = self.hours + secs/3600
secs = secs % 3600
self.minutes = self.minutes + secs/60
secs = secs % 60
self.seconds = secs
def makeTime(secs):
time = Time()
time.hours = secs/3600
secs = secs - time.hours * 3600
time.minutes = secs/60
secs = secs - time.minutes * 60
time.seconds = secs
return time
import random
class Karte:
farbListe = ["Treff", "Pik", "Karo", "Herz"]
rangListe = ["nix", "As", "2", "3", "4", "5", "6", "7",
"8", "9", "10", "Bube", "Dame", "König"]
def __init__(self, farbe=0, rang=2):
self.farbe = farbe
self.rang = rang
def __str__(self):
return (self.farbListe[self.farbe] + " " +
self.rangListe[self.rang])
def __cmp__(self, other):
# Prüfung der Farben
if self.farbe > other.farbe: return 1
if self.farbe < other.farbe: return -1
# Farben sind gleich... Prüfung der Ränge
if self.rang > other.rang: return 1
if self.rang < other.rang: return -1
# Ränge sind gleich... unentschieden
return 0
class Paket:
def __init__(self):
self.karten = []
for farbe in range(4):
for rang in range(1, 14):
self.karten.append(Karte(farbe, rang))
def printPaket(self):
for karte in self.karten:
print karte
def __str__(self):
s = ""
for i in range(len(self.karten)):
s = s + " "*i + str(self.karten[i]) + "\n"
return s
def mischen(self):
import random
nKarten = len(self.karten)
for i in range(nKarten):
j = random.randrange(i, nKarten)
self.karten[i], self.karten[j] = self.karten[j], self.karten[i]
def entferneKarte(self, karte):
if karte in self.karten:
self.karten.remove(karte)
return 1
else:
return 0
def popKarte(self):
return self.karten.pop()
def istLeer(self):
return (len(self.karten) == 0)
def geben(self, blattListe, nKarten=999):
nblatt = len(blattListe)
for i in range(nKarten):
if self.istLeer(): break # break wenn keine Karten mehr da
karte = self.popKarte() # nimm die "oberste" Karte
blatt = blattListe[i % nblatt] # wer ist der nächste?
blatt.gibKarteDazu(karte) # gib die Karte zu Blatt
class Blatt(Paket):
def __init__(self, name=""):
self.karten = []
self.name = name
def gibKarteDazu(self,karte) :
self.karten.append(karte)
def __str__(self):
s = "Das Blatt von " + self.name
if self.istLeer():
s = s + " ist leer.\n"
else:
s = s + ":\n"
return s + Paket.__str__(self)
class KartenSpiel:
def __init__(self):
self.paket = Paket()
self.paket.mischen()
class OldMaidBlatt(Blatt):
def entfernePaare(self):
partnerFarbe = {0:1, 1:0, 2:3, 3:2}
anzahl = 0
blattKarten = self.karten[:]
for karte in blattKarten:
partner = Karte(partnerFarbe[karte.farbe], karte.rang)
if partner in self.karten:
self.karten.remove(karte)
self.karten.remove(partner)
print "Im Blatt %s ist das Paar %s, %s" % (self.name,karte,partner)
anzahl = anzahl + 1
return anzahl
class OldMaidSpiel(KartenSpiel):
def entferneAllePaare(self):
anzahl = 0
for blatt in self.blattListe:
anzahl = anzahl + blatt.entfernePaare()
return anzahl
def spielen(self, namen):
# entferne die Treff Dame
self.paket.entferneKarte(Karte(0,12))
# erzeuge fuer jeden Spieler ein Blatt
self.blattListe = []
for name in namen :
self.blattListe.append(OldMaidBlatt(name))
# die Karten geben
self.paket.geben(self.blattListe)
print "---------- Die Karten sind gegeben!"
self.printBlattListe()
# entferne anfangs vorhandene Paare
paare = self.entferneAllePaare()
print "---------- Paare abgelegt - das Spiel beginnt!"
self.printBlattListe()
# Spiel läuft bis alle 25 Paare abgelegt sind
amZug = 0
numBlattListe = len(self.blattListe)
while paare < 25:
paare = paare + self.einSpielerSpielt(amZug)
amZug = (amZug + 1) % numBlattListe
print "---------- Das Spiel ist aus!"
self.printBlattListe()
def einSpielerSpielt(self, i):
if self.blattListe[i].istLeer():
return 0
nachbar = self.findeNachbarn(i)
gezogeneKarte = self.blattListe[nachbar].popKarte()
self.blattListe[i].gibKarteDazu(gezogeneKarte)
print "Blatt", self.blattListe[i].name, "hat", gezogeneKarte, "gezogen."
anzahl = self.blattListe[i].entfernePaare()
self.blattListe[i].mischen()
return anzahl
def findeNachbarn(self, i):
numBlattListe = len(self.blattListe)
for naechste in range(1,numBlattListe):
nachbar = (i - naechste) % numBlattListe ## original i + naechste
if not self.blattListe[nachbar].istLeer():
return nachbar
def printBlattListe(self):
for blatt in self.blattListe:
print blatt
def printList(node) :
while node :
print node,
node = node.next
print
def printBackward(list) :
if list == None : return
head = list
tail = list.next
printBackward(tail)
print head,
def printBackwardNicely(list) :
print "(",
if list != None :
head = list
tail = list.next
printBackward(tail)
print head,
print ")",
def removeSecond(list) :
if list == None : return
first = list
second = list.next
first.next = second.next
second.next = None
return second
class Node :
def __init__(self, cargo=None) :
self.cargo = cargo
self.next = None
def __str__(self) :
return str(self.cargo)
def printBackward(self) :
if self.next != None :
tail = self.next
tail.printBackward()
print self.cargo,
class LinkedList :
def __init__(self) :
self.length = 0
self.head = None
def printBackward(self) :
print "(",
if self.head != None :
self.head.printBackward()
print ")",
def addFirst(self, cargo) :
node = Node(cargo)
node.next = self.head
self.head = node
self.length = self.length + 1
class Stack: # Python list implementation
def __init__(self):
self.items = []
def push(self, item):
self.items.append(item)
def pop(self):
return self.items.pop()
def isEmpty(self):
return(self.items == [])
def evalPostfix(expr) :
import re
expr = re.split("([^0-9])", expr)
stack = Stack()
for token in expr :
if token == '' or token == ' ':
continue
if token == '+' :
sum = stack.pop() + stack.pop()
stack.push(sum)
elif token == '*' :
product = stack.pop() * stack.pop()
stack.push(product)
else :
stack.push(int(token))
return stack.pop()
class Queue :
def __init__(self) :
self.length = 0
self.head = None
def empty(self) :
return (self.length == 0)
def insert(self, cargo) :
node = Node(cargo)
node.next = None
if self.head == None :
# If list is empty our new node is first
self.head = node
else :
# Find the last node in the list
last = self.head
while last.next : last = last.next
# Append our new node
last.next = node
self.length = self.length + 1
def remove(self) :
cargo = self.head.cargo
self.head = self.head.next
self.length = self.length - 1
return cargo
class ImprovedQueue :
def __init__(self) :
self.length = 0
self.head = None
self.last = None
def empty(self) :
return (self.length == 0)
def insert(self, cargo) :
node = Node(cargo)
node.next = None
if self.length == 0 :
# If list is empty our new node is first
self.head = self.last = node
else :
# Find the last node in the list
last = self.last
# Append our new node
last.next = node
self.last = node
self.length = self.length + 1
def remove(self) :
cargo = self.head.cargo
self.head = self.head.next
self.length = self.length - 1
if self.length == 0 : self.last = None
return cargo
class PriorityQueue :
def __init__(self) :
self.items = []
def empty(self) :
return self.items == []
def insert(self, item) :
self.items.append(item)
def remove(self) :
maxi = 0
for i in range(1,len(self.items)) :
if self.items[i] > self.items[maxi] :
maxi = i
item = self.items[maxi]
self.items[maxi:maxi+1] = []
return item
class Golfer :
def __init__(self, name, score) :
self.name = name
self.score= score
def __str__(self) :
return "%-15s: %d" % (self.name, self.score)
def __cmp__(self, other) :
if self.score < other.score : return 1 # less is more
if self.score > other.score : return -1
return 0
class Tree :
def __init__(self, cargo, left=None, right=None) :
self.cargo = cargo
self.left = left
self.right = right
def __str__(self) :
return str(self.cargo)
def getCargo(self): return self.cargo
def getLeft (self): return self.left
def getRight(self): return self.right
def setCargo(self, cargo): self.cargo = cargo
def setLeft (self, left): self.left = left
def setRight(self, right): self.right = right
def total(tree) :
if tree == None : return 0
return total(tree.left) + total(tree.right) + tree.cargo
def printTree(tree) :
if tree == None : return
print tree.cargo,
printTree(tree.left)
printTree(tree.right)
def printTreePostorder(tree) :
if tree == None : return
printTreePostorder(tree.left)
printTreePostorder(tree.right)
print tree.cargo,
def printTreeInorder(tree) :
if tree == None : return
printTreeInorder(tree.left)
print tree.cargo,
printTreeInorder(tree.right)
def printTreeIndented(tree, level=0) :
if tree == None : return
printTreeIndented(tree.right, level+1)
print ' '*level + str(tree.cargo)
printTreeIndented(tree.left, level+1)
def getToken(tokenList, expected) :
if tokenList[0] == expected :
tokenList[0:1] = [] # remove the token
return 1
else :
return 0
def getProduct(tokenList) :
a = getNumber(tokenList)
if getToken(tokenList, '*') :
b = getProduct(tokenList)
return Tree('*', a, b)
else :
return a
def getSum(tokenList) :
a = getProduct(tokenList)
if getToken(tokenList, '+') :
b = getSum(tokenList)
return Tree('+', a, b)
else :
return a
def getNumber(tokenList) :
if getToken(tokenList, '(') :
x = getSum(tokenList) # get subexpression
getToken(tokenList, ')') # eat the closing paran
return x
else :
x = tokenList[0]
if type(x) != type(0) : return None
tokenList[0:1] = [] # remove the token
return Tree(x, None, None) # return a leaf with the number
def animal() :
# start with a singleton
root = Tree("bird")
# loop until the user quits
while 1 :
print
if not yes("Are you thinking of an animal? ") : break
# walk the tree
tree = root
while tree.getLeft() != None :
prompt = tree.getCargo() + "? "
if yes(prompt):
tree = tree.getRight()
else:
tree = tree.getLeft()
# make a guess
guess = tree.getCargo()
prompt = "Is it a " + guess + "? "
if yes(prompt) :
print "I rule!"
continue
# get new information
prompt = "What is the animal\'s name? "
animal = raw_input(prompt)
prompt = "What question would distinguish a %s from a %s? "
question = raw_input(prompt % (animal,guess))
# add new information to the tree
tree.setCargo(question)
prompt = "If the animal were %s the answer would be? "
if yes(prompt % animal) :
tree.setLeft(Tree(guess))
tree.setRight(Tree(animal))
else :
tree.setLeft(Tree(animal))
tree.setRight(Tree(guess))
def yes(ques) :
from string import lower
ans = lower(raw_input(ques))
return (ans[0:1] == 'y')
class Fraction:
def __init__(self, numerator, denominator=1):
g = gcd(numerator, denominator)
self.numerator = numerator / g
self.denominator = denominator / g
def __mul__(self, object):
if type(object) == type(5):
object = Fraction(object)
return Fraction(self.numerator*object.numerator,
self.denominator*object.denominator)
__rmul__ = __mul__
def __add__(self, object):
if type(object) == type(5):
object = Fraction(object)
return Fraction(self.numerator*object.denominator +
self.denominator*object.numerator,
self.denominator * object.denominator)
__radd__ = __add__
def __cmp__(self, object):
if type(object) == type(5):
object = Fraction(object)
diff = (self.numerator*object.denominator -
object.numerator*self.denominator)
return diff
def __repr__(self):
return self.__str__()
def __str__(self):
return "%d/%d" % (self.numerator, self.denominator)
def gcd(m,n):
"return the greatest common divisor of 2 integer arguments"
if m % n == 0:
return n
else:
return gcd(n,m%n)
|
|
|
|
|
|
|