Principle of Computing (Python)学习笔记(2) Cookie Clicker
这个Principle of Computing 是Rice U在coursera上的Python课系列的第二门课。这个课的每个mini-project都是有一些小小的挑战的。
2.2 demo: area under curve
3 使用map
第二个mini project是实现游戏cookie clicker。这个游戏本身很无聊。
这次的Project完全没有算法难度，估计这次的Project的用意是让人体会将实际问题建模为类和翻译为代码。
1 数学知识准备
1.1 求和相关的数学公式(略)
log运算 https://class.coursera.org/principlescomputing-001/wiki/view?page=log_and_exp
数学表达式 https://class.coursera.org/principlescomputing-001/wiki/view?page=math_expressions
1.2 Log 和Plotting
通过Log和plotting来判断多项式的维度。
log(y)=log(axn)
log(y)=log(a)+nlog(x)
If the data points (xi,yi) lie on y=axn, then they must satisfy the equation
log(yi)=log(a)+nlog(xi)
where log(a) and n are constants. This observation suggests a strategy for determining whether the data points lie close to a polynomial function. Plot the data points (log(xi),log(yi)) and check whether these data points lie near a straight line. If they do, the original data points (xi,yi) lie near a polynomial function. Moreover, the degree of this polynomial is simply the slope of this line.
Many plotting packages support this kind of analysis by offering a log/log plotting option. Under this option, the axes are labelled with the various values of the x and y. However, these labels and the plotted data are positioned at the locationslog(x) and log(y). For example, plots with axes labeled 1,10,100,1000,... are usually log/log plots.
2 Higher-Order Functions
2.1 把函数作为另外一个函数的参数
def double(val):
return 2 * val
def square(val):
return val ** 2
def twice(func, val):
return func(func(val));
print twice(double,3)
print twice(square,3)
2.2 demo: area under curve
def area(func, low, high, stepsize):
total = 0;
loc = low;
while loc<high:
total += func(loc) * stepsize;
loc +=stepsize;
return total
def g(x):
return x;
def h(x):
return x **2;
print area(g, 0, 10, 0.01)
print area(h, 0, 10, 0.01)
3 使用map
把函数作为map的参数
list1 = [1,3,6,8,9]
list2 = [x*2 for x in list1]
print list2
def double(val):
return 2 * val
list3 = map(double, list1)
print list3
4 使用filter
把函数作为filter的参数
def even(val):
if val % 2 == 0:
return True
else:
return False
list4 = filter(even, list3)
print list4
4 mini-project
Note that simulate_clicker is a higher-order function: it takes a strategy function as an argument!
5 我的代码：
"""
Cookie Clicker Simulator 最后提交测试的时候，有一个case中的一个数字有些小问题，得到98分，还没有找到问题原因。
"""
import simpleplot
import math
# Used to increase the timeout, if necessary
import codeskulptor
codeskulptor.set_timeout(20)
import poc_clicker_provided as provided
# Constants
SIM_TIME = 10000000000.0
class ClickerState:
"""
Simple class to keep track of the game state.
"""
def __init__(self):
self._total_game_cookies = 0.0
self._current_cookies= 0.0
self._current_time = 0.0
self._current_cps = 1.0
self._history_list = [(0.0, None, 0.0, 0.0)]
def __str__(self):
"""
Return human readable state
"""
# res = ""
# for each_item in self.history_list:
# res += str(each_item) + "\n"
# return res
return "\nmy total cookies: "+str(self._total_game_cookies) + "\ncurrent cookies: " + str(self._current_cookies) + "\ncurrent time: " + str(self._current_time) + "\ncurrent CPS: " +str(self._current_cps)
def get_cookies(self):
"""
Return current number of cookies
(not total number of cookies)
Should return a float
"""
return self._current_cookies
def get_cps(self):
"""
Get current CPS
Should return a float
"""
return self._current_cps
def get_time(self):
"""
Get current time
Should return a float
"""
return self._current_time
def get_history(self):
"""
Return history list
History list should be a list of tuples of the form:
(time, item, cost of item, total cookies)
For example: (0.0, None, 0.0, 0.0)
"""
return self._history_list
def time_until(self, cookies):
"""
Return time until you have the given number of cookies
(could be 0 if you already have enough cookies)
Should return a float with no fractional part
"""
if cookies <= self.get_cookies():
return 0.0
else:
return float(math.ceil((cookies-self.get_cookies())/self.get_cps()))
def wait(self, time):
"""
Wait for given amount of time and update state
Should do nothing if time <= 0
"""
if time<=0:
return
# 如何真正模拟How to simulate waiting for the given amout of time?
self._current_time += time
self._current_cookies += time * self._current_cps
self._total_game_cookies += time * self._current_cps;
def buy_item(self, item_name, cost, additional_cps):
"""
Buy an item and update state
Should do nothing if you cannot afford the item
"""
if self._current_cookies < cost:
return
self._history_list.append((self._current_time, item_name, cost, self._total_game_cookies))
self._current_cookies -= cost;
self._current_cps += additional_cps
# print str(item_name) + "--" + str(self._current_time) + "--" + str(self._current_cookies) + "--" + str(self._current_cps) + "--" + str(self._total_game_cookies)
def simulate_clicker(build_info, duration, strategy):
"""
Function to run a Cookie Clicker game for the given
duration with the given strategy. Returns a ClickerState
object corresponding to game.
"""
# Replace with your code
build_info_clone = build_info.clone()
new_clikcer_state = ClickerState()
while new_clikcer_state.get_time()<duration:
# print "A-1"
if new_clikcer_state.get_time()>duration: #本句可省略？
break
suggested_item = strategy(new_clikcer_state.get_cookies(), new_clikcer_state.get_cps(),duration - new_clikcer_state.get_time(), build_info_clone)
# print "A-2"
if suggested_item == None:
new_clikcer_state.wait(duration - new_clikcer_state.get_time())
# print "A-3"
else:
cookies_needed = build_info_clone.get_cost(suggested_item)
cps_added = build_info_clone.get_cps(suggested_item)
time_needed = new_clikcer_state.time_until(cookies_needed)
# print "A-4"
if time_needed + new_clikcer_state.get_time() > duration:
new_clikcer_state.wait(duration - new_clikcer_state.get_time())
# print "A-5"
else:
new_clikcer_state.wait(time_needed)
new_clikcer_state.buy_item(suggested_item, cookies_needed, cps_added)
build_info_clone.update_item(suggested_item)
# print "A-6"
# print "A-7"
if new_clikcer_state.get_time()==duration:
suggested_item = strategy(new_clikcer_state.get_cookies(), new_clikcer_state.get_cps(),duration - new_clikcer_state.get_time(), build_info_clone)
if suggested_item != None:
cookies_needed = build_info_clone.get_cost(suggested_item)
cps_added = build_info_clone.get_cps(suggested_item)
if cookies_needed<=new_clikcer_state.get_cookies():
new_clikcer_state.buy_item(suggested_item, cookies_needed, cps_added)
build_info_clone.update_item(suggested_item)
return new_clikcer_state
#return ClickerState()
def strategy_cursor(cookies, cps, time_left, build_info):
"""
Always pick Cursor!
Note that this simplistic strategy does not properly check whether
it can actually buy a Cursor in the time left. Your strategy
functions must do this and return None rather than an item you
can't buy in the time left.
"""
return "Cursor"
def strategy_none(cookies, cps, time_left, build_info):
"""
Always return None
This is a pointless strategy that you can use to help debug
your simulate_clicker function.
"""
return None
def strategy_cheap(cookies, cps, time_left, build_info):
"""cheap Strategy"""
pricelist = {}
funding = cookies + cps * time_left
for item in build_info.build_items():
if build_info.get_cost(item) <= funding:
pricelist[build_info.get_cost(item)] = item
if len(pricelist) > 0:
return pricelist[min(pricelist)]
else:
return None
def strategy_expensive(cookies, cps, time_left, build_info):
"""Expensive Strategy"""
pricelist = {}
funding = cookies + cps * time_left
for item in build_info.build_items():
if build_info.get_cost(item) <= funding:
pricelist[build_info.get_cost(item)] = item
if len(pricelist) > 0:
return pricelist[max(pricelist)]
else:
return None
def strategy_best(cookies, cps, time_left, build_info):
"""Best Strategy"""
pricelist = {}
funding = cookies + cps * time_left
for item in build_info.build_items():
if build_info.get_cost(item) <= funding:
pricelist[build_info.get_cps(item)/build_info.get_cost(item)] = item
if len(pricelist) > 0:
return pricelist[max(pricelist)]
elif len(pricelist) == 0:
return None
def run_strategy(strategy_name, time, strategy):
"""
Run a simulation with one strategy
"""
state = simulate_clicker(provided.BuildInfo({"Cursor":[15.0,50.0]},1.15), time, strategy)
# state = simulate_clicker(provided.BuildInfo(), time, strategy)
print strategy_name, ":", state
# Plot total cookies over time
# Uncomment out the lines below to see a plot of total cookies vs. time
# Be sure to allow popups, if you do want to see it
# history = state.get_history()
# history = [(item[0], item[3]) for item in history]
# simpleplot.plot_lines(strategy_name, 1000, 400, 'Time', 'Total Cookies', [history], True)
def run():
"""
Run the simulator.
"""
run_strategy("Cursor", SIM_TIME, strategy_cursor)
# run_strategy("Cursor", 16, strategy_cursor)
# Add calls to run_strategy to run additional strategies
#run_strategy("Cheap", SIM_TIME, strategy_cheap)
#run_strategy("Expensive", SIM_TIME, strategy_expensive)
#run_strategy("Best", SIM_TIME, strategy_best)
run()