LLM告诉我一般的方法是使用LFS，这个功能我很快通过LLM学习并运用到当前项目上， 尽管有一些warning，但是实测是能正常上传和下载大文件的。我称之为第一版，将其部署在一台机器上并提供了服务。

之后我面临另一个问题， 项目中用到的是flux-fill的模型，但是随着项目发展，后面越来越多的需要用到flux-dev的模型来进行文生图，按理说只要将flux-dev也加到项目中就好了，但是实际测试中显示，flux-fill模型和flux-dev的使用会互相冲突，一个模型使用时，换用另一个模型需要加载很长时间，因此不得不考虑两个模型拆开来放到两个独立的项目中分开部署到两台不同的机器上。但是这让我感觉很不爽，毕竟他们本来应该是一个项目中的类似的功能。因此考虑许久后结合GPT4o的建议，我又将项目做了重构，不再用LFS上传模型，而是采用使用时下载模型的设计方式，这样在一个项目内就可以根据配置文件选择可以提供何种api，并在初次调用的时候下载模型，不会有无意义的空间占用。这个版本我称之为第二版。

好景不长，第二版刚刚提交之后，项目就遭到了质疑，我的导师认为这样的设计会导致每次部署都要向huggingface那个不可靠的服务器去下载模型，会影响项目的可用性，这点我自己也深受其害，所以也能理解。于是我不得不放弃这个思路，重新回退到第一版，将其重命名为pro分支。回退后flux-dev的接口无法使用了，但是之后flux-dev的需求依然存在，必须想办法把相关的api重新提供出来。这时我又投向了开始时考虑过的另一种解决方法，就是把两个模型作为git的两个分支，使用哪个模型就下载对应的分支，这样还是在同一个项目内，也不用下载多余文件。

按照这一思路，我又从第一版的pro分支上做了改造，之后分出来两个新的分支fill和txt2img，并且合并了第二版的main分支，使其看起来相对简洁，且每个分支都很直观。这个可以称为第三版。

我想这大概是目前能提供的最好的解决方法，为了实现优雅而简洁的开发和部署，投入了非常多的精力。尽管还有一些问题，比如说，我在我的电脑上开发的时候不需要使用模型文件，那么整个项目应该在clone时避免下载lfs文件，这个操作可以通过设置来实现，可是model虽然没有下载，但是当前的.git文件达到了惊人的30GB，这应该是某个环节中有错误的上传操作，但是由于此前的操作过多，很难搞清楚是哪一步的问题，还要想办法将这部分的历史记录清除，这样才能达到最终的状态。

后日谈：

又过一周后，我抽空开始调查.git的压缩方法，因为GPT-4o告诉我这部分并不是必须的，于是我将fill分支的.git/object的文件删除后提交到远程，但是当我重新拉取项目，.git又变成了30GB，GPT的说法是lfs还存在于历史中，之后我又按照它的指示将lfs从历史中排除，重写了历史，历史因此将fill独立成一条全新的分支路线，之前的提交都被复制了一份，在graph里看着非常难受，但这还好说，当我再次拉取项目时，lfs完全没有了（这是自然），于是我再次问了grok和claude-sonnet，它们的意见和GPT-4o难得的出现了冲突，想要下载lfs文件，就必须有庞大的.git，但是本机不需要的话可以删除.git/object，也不影响正常使用，情况大致就是这样。最后我还是找到txt2img分支，强制覆盖了远程仓库，好在只有我在上面工作。之后将本机的项目也删除后重新拉取，删除掉.git/object，一切正常了,真是实践出真知。当前阶段的项目功能都完善了，AI绘画要放一放了，短时间内也不会回来，以后有问题再说吧。

身体方面，年后到现在经历了一段非常离奇的治疗过程，一方面我把治疗疾病作为最主要的目标，但另一方面，在诸多的复杂变量的影响下，我也逐渐丧失了对最关键要素的感知能力，使得病情经历了两次急转直下，但是诸多措施又都不见效果，最后进入了病急乱投医的混乱状态中，同时进行了严格的禁食，直到上周在三医院重新建立了有效的治疗措施，在两天内有了大幅的改观，到现在已经算得上是卓有成效了。值得反思的东西有很多，没有第一时间抓住主要的矛盾，同时走了错误的诊疗路线是最大的问题。

游戏方面，暂时游戏荒，一直在等AOE2 DE的东亚DLC，一方面也确实没什么精力去玩太多。

为了优先治病，暂时放弃了本就比较悬的学习计划。

没有安排过远的活动，只在能力范围内随便走了走，赶上了楼下公园的花期，充分观赏了，之后再考虑到市内去看看。

动画方面，看完了金牌得主，底子很强，值得一看。此外看了老版的全职猎人，开始没觉得有什么特别，看多了还是能感受到作者很多的妖孽的想法，确实是能让人打开思路，有点上头，快看完了。

这一个多月里一直有种念头，就是展开和收回，所谓展开是指将生活中的很多领域重新审视、复习、提取到大脑内存中，收回是指将这个原本乱糟糟的东西整理一下，再存回硬盘中，方便后续调用。通过这样的作法，来确认对这些内容的掌控程度。所幸也没有什么挖的很深的领域，存档过程也还算是跟的上。考虑到精力有限，因此要在很多领域采取守势，减少不必要的观察和念头，将有限的生活过好，积累信心，再考虑向外拓展。

​

按其所说的更新了diffusers，然后运行下载的示例代码flux_fill.py，报错说是

1

ImportError: cannot import name 'FluxFillPipeline' from 'diffusers' (~/miniconda3/envs/flux/lib/python3.10/site-packages/diffusers/__init__.py)

经过查询发现，FluxFillPipeline好像是2024年11月23日加上的，而pypi那里最新的包0.31.0还是10月的，于是就出现了这个问题，想使用最新的FluxFillPipeline就得自己手动安装一下开发版本的卸载diffusers，解决方法如下：

1. 进入所需的conda环境，卸载diffusers

   1	pip uninstall diffusers

2. 克隆diffusers仓库：

   1	git clone https://github.com/huggingface/diffusers.git

3. 进入diffusers目录：

   1	cd diffusers

4. 使用以下命令通过setup.py安装diffusers：

   1	pip install .

这样就可以安装开发中的版本。再回去运行flux_fill.py，一切正常了。这怎么看都是black-forest-labs官方的问题，其教程要过些日子才能正常使用。

国庆后四天的福建之旅算得上是安排紧凑，按照“轻松愉快“的指导思想去安排了全部的活动，整个过程算不上特别惬意，由于天气原因，没有看到什么特别亮眼的景色，身体原因也不敢强行安排太多的活动，强度被限制在一个易于接受的范围内，但是在锻炼心理的层面上称得上卓有成效。

​

上次提到的整备活动正在按预期执行，旅行前更换手机电池使得旅途中少了很多不必要的麻烦和负重。上周末由于眼镜腿断裂而不得不去配的眼镜也将长久以来的问题解决。之后按计划还有很多需要更新。

在工作方面，商品图的模块在节前基本完成，主要的功能基本上都齐全了，后续要做各个模块的升级，考虑到comfyui已经被美工广泛地使用，也许下一阶段会接触一些新的东西。

游戏方面，还是继续推进黑神话，目前到达第五章的后半段，之后应该不会花太久。

动画上面，十月似乎没有太多可看的内容，目前估计会跟进观看《乱马》，而《物语系列 外传季&怪物季》还有最后一集，周末才能看到。

运动方面，由于高强度的旅行和其他的实践活动，没有再安排什么锻炼。

居家生活方面，买了空气炸锅和一袋小米，周末可以用更轻松的方式来做饭吃，目前几次基本上是一个肉菜+小米粥+凉拌蔬菜的模式。小米确实是令人怀念和格外安心的食物，之后考虑来自己做一些面食来吃。此外还购入了一个升降台，用来解决室内办公的问题，目前还不太适应，似乎桌面还是有点低，导致打字的感觉不佳。

国庆假期结束已过去一周了，天气转凉，可能由于这个原因，状态竟然开始趋于好转，似乎去年也有类似的状态，应该是从9月中旬到10月，也许我们的行为真的是在被气温所主导。这周以来每天起的都比之前要早一些，心理状态也更加斩钉截铁，完成手头的任务走向下一个目标的决心十分强烈。遥远的地方那些不怎么好的风景、可去可不去的场所以及麻烦的任务，会耗费很多脑力和体力，但并不是不值得的，陌生的事物确实能带来全新的经验，经验带给人们新的自由度。所以，实践还要不断继续下去。

工作方面，继上次之后基本完成了拖拖拉拉了好久的商品图的功能，方案几经调整，确实非常折磨，节后应该会推出；另一方面由于技术的快速迭代也面临着推出即落后的窘境，后续还得加强这方面的学习。本计划假期搞一下，但现在看来是没时间了。

身体方面，精力还是比较萎靡，夏天以来几乎没有了锻炼的行为，每天的流汗只限于早晨通勤阶段，目前的状况用湿疹的指标来看算得上是岌岌可危，随时会崩。要开始加强锻炼和保证休息。

游戏方面，也基本上在第一时间购入和游玩《黑神话》，但是由于身体和精力状况不佳，导致整体速度较慢，中间还故意中断了两周来使生活节奏恢复，目前刚进入第五章。

由于上述所说，导致我久违地开始审视当前的物质环境，并提出了一系列的整备计划，解决各方面的落后的现状，优化生活条件。目前已经解决了泡脚困难、手机续航差的问题，还留下没法站立办公、眼镜老化等问题需要进一步解决。

假期安排了去厦门的单人旅行，这本来是由于假期难得，但是在计划做好之后产生了巨大的动摇，不止一次考虑把计划推翻或删减。最后还是决定要去，只不过要照顾身体状况，必须限制活动的强度，为此决定带上箱子。把背包的重量始终压缩到一个比较小的范围，即便如此，还是有诸多风险，可能关键是在于要有一个闲适的心情吧，这我太缺了。

动画方面，看完了《败犬女主太多了！》，制作精良，非常好看，为此还买了动画之后的下一卷小说来看。

假期说长也长，说短也短，各人有各人的过法，我得找到适合自己的过法、适合自己的旅游法，总之要以自己为标尺，慢慢来吧。也祝大家都获得幸福。

工作上的东西还在稳步推进，新技术的出现又开始动摇前面工作的基础，导致新功能举棋不定，来回拉扯了一月，做得有点拖沓。

7月19比赛截止，8月7号答辩，ai大赛的项目完成的出乎意料的好，甚至具备了一定的实用价值，而搜索引擎也还ok，还可以继续优化。虽然看起来还是有点过于小儿科，但是折腾的多了，至少flask还是日渐熟练起来。

7月安排了几场出游，寻访了南头古城（7.6）和大梅沙（7.14），完成了一些早该做的旅行。之后参加两个批次的观影会，7.20和7.27，算得上比较充实。之后8月初体检，没什么大问题，8月11找老舍友吃饭，随后一周的博物馆之行因大雨未能成行。各周末基本都有事情做。

这段时间运动严重不足，每天只有晚上散步和中午爬楼的活动，导致一直没什么精神。

七月番还挺好看，没什么太大的话题度，但足以填补我的空缺了。

接下来可能要在周末去逛cpgz，回来要试试打黑神话，再把搜索引擎做完善，多学习下相关领域的知识，准备下内部培训，之后要做的事情还有很多。

我于是开始尝试围绕这篇blog进行学习， 我设想的搭建过程分为以下几个步骤，

• 第一步，找一个开源项目运行起来

• 第二步，然后阅读源代码来学习如何搭建，

• 第三步，搭建自己的图片搜索引擎

这个计划在第一步就遇到巨大困难，blog的对应项目使用到imac的芯片，我没法使用，之后在github上找到的一系列项目各有千秋，但是共同的特点是没法在我的pc上运行，其中的制约因素包括但不限于需要搭建python环境、需要从huggingface下载模型，数据库连接不上去等等，手头的四个项目卡在不同阶段，当一个卡住，我就重新搭建环境尝试另一个，如此往复，进度最佳的一个已经在公司电脑上成功读取文件夹并将图片向量传到数据库，但此项目在本机上无法从huggingface下载任何模型，大概在这样的泥潭中折腾了一个月之后的月一个晚上，我终于意识到，整个计划从第一步开始就不是必要的。

整个引擎只有两个步骤，读取图片上传到数据库、在数据库中查询，我只要完成这两步就好了

向量数据库有很多家，但我直接选了最早接触到的pinecone

我打开gpt，向其询问把图片转换成向量的方式，测试运行，通过。

之后，我登录pinecone的官网，按照教程新建了index，并获取了官方提供的存储及搜索的代码，完成了将向量上传和搜索的环节

最后添加了一个用于获取单张图向量的函数

这样经过非常简单的步骤之后，搜索引擎的核心功能就完成了，花费了一个多小时，只有几十行代码。我可以将本地的图片对应的上传到数据库，然后，拿一张图片进行搜索，获取相似度最高的前n张图片名称，根据这些名称找到本地的对应图片。这个操作在你本地有大量各个类型图片的情况下会非常有趣，假如你只有少量图片。那就没什么意思，很可能没太多有关联的内容。

不难看出这个玩具的核心在于clip模型，它决定了图片到向量的对应关系，这个模型的效果越好，对图片做语义识别的能力就越强，体现出的图片的搜索效果就越智能。

项目地址

工作方面，在5月下旬到6月上半期间都相对比较缓和，主要做功能方面的优化，研究用一些新的开源模型来解决现有的效果不佳的问题。

自己做的项目上取得了一些突破，虽然事后想来没有什么难度，但还是有点意思，详情见之后的文章。

在游戏方面，过去三周主要在打《动物井》，确实是震撼人心的好游戏，但也确实累人，打通真结局后将其永久性搁置。感觉松了一口气。之后可以慢慢打休闲一点的游戏。

动画上面这周追完了《迷宫饭》，京吹等搁置了几周，有待补完，上周看起了《攻壳机动队》，这周又转向《旋风管家》，也确实没闲着。四月番恐怕总共不会超过两部。

运动方面，天气渐热，身体的问题开始加重，感冒的阴云还没有散去，希望能增加一些肌肉来增强体质，应对现在的光吃不消耗的局面。走路的锻炼方式又很难增加什么肌肉，并且逐渐受气温影响难以继续，因此打算开始进行室内的更高强度的锻炼，让gpt给了一份计划， 比较有操作性，可以先试试。

居家生活方面，六一炖了牛肉，感觉不错，端午节收到家里寄来的羊肉，于是又炖了一锅。这周末虽然没有炖肉，却把为炖肉准备的葱拿来做了葱油来拌面吃。

时间过得真快，好些同学研究生毕业，开始四处毕业旅行。一些工作的同学也四处游玩，让人好奇他们是哪来的空闲。我好像已经没有旅行的欲望了，倒是期待能去广州看未来有你的演唱会。

书已经没有在看了。

但愿能各项事务能尽快走上正轨。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

def remove_color_range(image_path:str, color:list, width:int):
    lower_bound = np.array([max(x - width,0) for x in color])  # 需要去除的颜色的下界
    upper_bound = np.array([min(x + width,255) for x in color])  # 需要去除的颜色的上界

    img = Image.open(image_path).convert('RGBA')

    # 将图片转换为NumPy数组
    img_array = np.array(img)

    # 创建一个布尔数组，标记需要去除的像素
    mask = np.all((img_array >= lower_bound) & (img_array <= upper_bound), axis=-1)

    # 将需要去除的像素设置为白色（或其他你想要的颜色）
    img_array[mask] = [0, 0, 0, 0]

    # 将NumPy数组转换回PIL图像
    new_img = Image.fromarray(img_array)

    return new_img

而导师给了我另一种实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

def color_within_tolerance(color, target, tolerance):
    """检查颜色是否在目标颜色的容差范围内"""
    return all(abs(c - t) <= tolerance for c, t in zip(color, target))

def remove_color(input_image_path, output_image_path, target_color, tolerance):
    image = Image.open(input_image_path).convert("RGBA")
    datas = image.getdata()
    
    new_data = []
    for item in datas:
        # 检查当前像素是否在容差范围内
        if color_within_tolerance(item[:3], target_color, tolerance):
            # 将匹配的颜色替换为透明
            new_data.append((255, 255, 255, 0))
        else:
            new_data.append(item)
    
    image.putdata(new_data)
    image.save(output_image_path, "PNG")

导师的代码额外加入了输出，我使用同一张图片进行测试，两者的效果完全一致。

那么两者的效率是否相同呢，我在我的函数中也加上保存图片的环节进行测试得出的时间之比为： 0.496： 3.702，换另一张图测试，时间比为 0.958：10.208，看来我这边确实更快，

原理看上去也比较简单，后者是通过逐个对比像素来确定是否要替换对应点的，而前者是通过np包将图片转成矩阵后使用np.all(函数进行处理，np.all() 是 NumPy 中的一个非常有用的函数,它用于检查数组中所有元素是否都为 True。而当 axis=-1 时,表示沿着最后一个轴(即宽度轴)进行操作，(理解起来可能有点困难，可以看作对矩阵降维，两行三列的数组，降维的方式有两种，一种是横向取与，一种是纵向取与，得到的分别是一行两列和一行三列的bool数组，数组中的值表示这一行或这一列是否都符合条件)，也就是img_array判断矩阵的最小维度是否符合条件，对比的是[229 229 229 255]是否不大于[249 249 249 255]中的每一个对应元素，[229 229 229 255]是否不小于[209 209 209 235]中的每一个对应元素，如均符合，则此像素置为true，np.all最终得到的是一个布尔数组，再经过img_array[mask] = [0, 0, 0, 0]将原图的对应像素置为透明即可。

借助于numpy，其中的筛选和修改似乎都是并行计算，因此效率高得多。

​ 31号带着弟弟逛了下广州中心，我制作了三套返程方案后按计划快去快回，下午三点过去晚上10点多回来，总还是没影响到工作。最大的感想是花费少量时间进行区间旅行完全是可行的。

​ 之后的清明假期（4.4-4.6）只安排了逛cpsp的活动，为此我们提前一天去了广州，次日早上前往琶洲，cpsp的场面之大是之前没有见过的，内容上也要丰富很多，一时上头买了不少的本子，狠狠投资了同人文化。一部分周边也在后来一周寄给友人。

​ 这周看了《你想活出怎样的人生》，本来想看看这次会烂到什么程度，看了感觉还不错，并不是一部糟心的电影，只是一个老头和你讲你理解不了的话罢了，而且也没有令人反感的桥段，不至于如此不推荐，想必大家还是报了过高的期待来看，虽然很多人的感觉上像是用宫崎骏的电影训练了一个ai模型后拍出来的，但是这个终究不是ai，可以肯定作者有用心思。看的时候前半段老是想到《刺杀骑士团长》，此外很多元素都能串到之前的一些电影中，老旧的大宅是《龙猫》、会追踪的箭和哇啦哇啦是《幽灵公主》，通往不同世界的门和狂风吹拂的水边草丛是《哈尔的移动城堡》，父亲的工厂是《起风了》，苍鹭里的大鼻子老头是《千与千寻》，爬塔的时候一度很像《天空之城》。全程都在关注这些要素导致观影的流程也变得非常有趣。

​ 可能是最近的活动太多了，总有种休息不好的的感觉，心情急躁，走路也很不悠闲，不是好的生活方式，需要改正。

​

​ 这几周在工作上比较繁忙，刚刚肝完了换背景方案，写的昏天黑地，又参加准备了晋级考试和答辩。今天刚刚转为常规状态，但是方案还有诸多bug要改，今天领导又急着使用新的方案，预计还有大改。希望能尽快掌握laravel，加快对各种功能调整和bug的响应速度。

​ 这周起天气开始变得炎热，短袖首次登场，并且在可以遇见的未来将一直服役到11月份以后。有必要迈出关键一步去买些像样的衣服。

​ 由于工作繁忙，这周开始早睡，体验不错，也不是完全做不到嘛。

​ 病中的感觉今年体会的够多了，不想继续下去了。

​

在工作方面，年后继续沿着图像处理的方向前进，完成了一些图片叠加和内容审查之类的工作，其中涉及了很多对项目本身的修改工作，还是有些许收获的。但是全部是python的工作，没机会参与php的工作。🤨

第一周疯狂看电影，陆续看完了《坠落的审判》、《俄罗斯方块》、《怪物》、《年会不能停》，回过头想想都不知道这时间是怎么挤出来的。😑

游戏方面，值得一提的是这两个周末在玩的《圣兽之王》demo，这个游戏比之前预想的还是好玩许多，在今天打通了试玩版剧情，并下单了实体版本，春季应该会全力推这个，但是剧情的发展看上去过于平淡了，内容长了之后可能会有问题。此外用剩下的一张任亏券换了《密特罗德生存恐惧》，防止之后忘记。😊

动画上面一月番只看了《芙莉莲》、《迷宫饭》和《我心危第二季》，迷宫饭这两周观感非常好，更多的讲了人物过往的经历，比起前几周有意思多了，整体上还算是比较充实。😊

​

运动方面，跑步的习惯还是没完全搞起来，第二次跑的时候出了些问题，气管至今也没完全恢复。由于作息时间没做调整的缘故，这些日子还是非常困。🥱

居家生活方面，回来深圳第二天就下单了几个收纳的箱子，把药品和厨具收纳一下，这周末则下单了用于收纳衣服的抽屉式的箱子，希望能提升家里整体的观感。👌

家里带来的真空包装的熟肉也吃了大半了，在家的时候感觉状态良好，一方面是由于大量和人社交，另一方面想来与那几天吃得格外好也有关系。🍖

​

两个周末都以居家为主，天气也比较阴冷，不宜外出游玩，上周抽空去了下周边的城中村附近的商场，这周逛了下楼下的公园，又看到了去年相似的山花烂漫的场景。🌸

年后的总结大致就是这样了，还有许多东西百废待兴，希望尽快把事项推进起来。💪

Programmers dream of
Abstraction, recursion, and
Typing really fast.

Introduction

Important submission note: For full credit:

• Submit with Phase 1 complete by Tuesday, September 27, worth 1 pt.
• Submit with all phases complete by Friday, September 30.

Try to attempt the problems in order, as some later problems will depend on earlier problems in their implementation and therefore also when running ok tests.

The entire project can be completed with a partner.

You can get 1 bonus point by submitting the entire project by Thursday, September 29.

In this project, you will write a program that measures typing speed. Additionally, you will implement typing autocorrect, which is a feature that attempts to correct the spelling of a word after a user types it. This project is inspired by typeracer.

When students in the past have tried to implement the functions without thoroughly reading the problem description, they’ve often run into issues. 😱 Read each description thoroughly before starting to code.

Final Product

Our staff solution to the project can be interacted with at cats.cs61a.org. If you’d like, feel free to try it out now. When you finish the project, you’ll have implemented a significant part of this match yourself!

Phase 1: Typing

When students in the past have tried to implement the functions without thoroughly reading the problem description, they’ve often run into issues. 😱 Read each description thoroughly before starting to code.

Problem 1 (1 pt)

Throughout the project, we will be making changes to functions in cats.py.

Implement pick. This function selects which paragraph the user will type. It takes three parameters:

• a list of paragraphs (strings)
• a select function, which returns True for paragraphs that can be selected
• a non-negative index k

The pick function returns the kth paragraph for which select returns True. If no such paragraph exists (because k is too large), then pick returns the empty string.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

def pick(paragraphs, select, k):
    """Return the Kth paragraph from PARAGRAPHS for which SELECT called on the
    paragraph returns True. If there are fewer than K such paragraphs, return
    the empty string.

    Arguments:
        paragraphs: a list of strings
        select: a function that returns True for paragraphs that can be selected
        k: an integer

    >>> ps = ['hi', 'how are you', 'fine']
    >>> s = lambda p: len(p) <= 4
    >>> pick(ps, s, 0)
    'hi'
    >>> pick(ps, s, 1)
    'fine'
    >>> pick(ps, s, 2)
    ''
    """
    # BEGIN PROBLEM 1
    paragraphs = [i for i in paragraphs if select(i)]
    if len(paragraphs)>k:
        return paragraphs[k]
    else:
        return ''
    # END PROBLEM 1

Problem 2 (1 pt)

Implement about, which takes a list of topic words. It returns a function which takes a paragraph and returns a boolean indicating whether that paragraph contains any of the words in topic.

Once we’ve implemented about, we’ll be able to pass the returned function to pick as the select argument, which will be useful as we continue to implement our typing test.

To be able to make this comparison accurately, you will need to ignore case (that is, assume that uppercase and lowercase letters don’t change what word it is) and punctuation in the paragraph. Additionally, only check for exact matches of the words in topic in the paragraph, not substrings. For example, “dogs” is not a match for the word “dog”.

Hint: You may use the string utility functions in utils.py. You can reference the docstrings of the utility functions to see how they are being used.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

def about(topic):
    """Return a select function that returns whether
    a paragraph contains one of the words in TOPIC.

    Arguments:
        topic: a list of words related to a subject

    >>> about_dogs = about(['dog', 'dogs', 'pup', 'puppy'])
    >>> pick(['Cute Dog!', 'That is a cat.', 'Nice pup!'], about_dogs, 0)
    'Cute Dog!'
    >>> pick(['Cute Dog!', 'That is a cat.', 'Nice pup.'], about_dogs, 1)
    'Nice pup.'
    """
    assert all([lower(x) == x for x in topic]), 'topics should be lowercase.'
    # BEGIN PROBLEM 2
    def uu(somewords):
      list=split(somewords)
      for i in list:
        if lower(remove_punctuation(i)) in topic:
          return True
      return False
    return uu
    # END PROBLEM 2

Problem 3 (2 pts)

Implement accuracy, which takes a typed paragraph and a source paragraph. It returns the percentage of words in typed that exactly match the corresponding words in source. Case and punctuation must match as well. “Corresponding” here means that two words must occur at the same indices in typed and source—the first words of both must match, the second words of both must match, and so on.

A word in this context is any sequence of characters separated from other words by whitespace, so treat “dog;” as a single word.

If typed is longer than source, then the extra words in typed that have no corresponding word in source are all incorrect.

If both typed and source are empty, then the accuracy is 100.0. If typed is empty but source is not empty, then the accuracy is zero. If typed is not empty but source is empty, then the accuracy is zero.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

def accuracy(typed, source):
    """Return the accuracy (percentage of words typed correctly) of TYPED
    when compared to the prefix of SOURCE that was typed.

    Arguments:
        typed: a string that may contain typos
        source: a string without errors

    >>> accuracy('Cute Dog!', 'Cute Dog.')
    50.0
    >>> accuracy('A Cute Dog!', 'Cute Dog.')
    0.0
    >>> accuracy('cute Dog.', 'Cute Dog.')
    50.0
    >>> accuracy('Cute Dog. I say!', 'Cute Dog.')
    50.0
    >>> accuracy('Cute', 'Cute Dog.')
    100.0
    >>> accuracy('', 'Cute Dog.')
    0.0
    >>> accuracy('', '')
    100.0
    """
    # BEGIN PROBLEM 3
    typed_words = split(typed)
    source_words = split(source)
    len1 = len(typed_words)
    len2 = len(source_words)
    i=0
    count = 0
    if len1 ==0 and len2 ==0:
        return 100.0
    elif len1 ==0 or len2 ==0:
        return 0.0
    else:
        min_len = min(len1,len2)
        for i in range(min_len):
            if source_words[i] == typed_words[i]:
                count += 1
        return 100.0*count/len1
    # END PROBLEM 3

Problem 4 (1 pt)

Implement wpm, which computes the words per minute, a measure of typing speed, given a string typed and the amount of elapsed time in seconds. Despite its name, words per minute is not based on the number of words typed, but instead the number of groups of 5 characters, so that a typing test is not biased by the length of words. The formula for words per minute is the ratio of the number of characters (including spaces) typed divided by 5 (a typical word length) to the elapsed time in minutes.

For example, the string "I am glad!" contains three words and ten characters (not including the quotation marks). The words per minute calculation uses 2 as the number of words typed (because 10 / 5 = 2). If someone typed this string in 30 seconds (half a minute), their speed would be 4 words per minute.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

def wpm(typed, elapsed):
    """Return the words-per-minute (WPM) of the TYPED string.

    Arguments:
        typed: an entered string
        elapsed: an amount of time in seconds

    >>> wpm('hello friend hello buddy hello', 15)
    24.0
    >>> wpm('0123456789',60)
    2.0
    """
    assert elapsed > 0, 'Elapsed time must be positive'
    # BEGIN PROBLEM 4
    return (len(typed)/5)/(elapsed/60)
    # END PROBLEM 4

Phase 2: Autocorrect

When students in the past have tried to implement the functions without thoroughly reading the problem description, they’ve often run into issues. 😱 Read each description thoroughly before starting to code.

In the web-based GUI, there is an autocorrect button, but right now it doesn’t do anything. Let’s implement automatic correction of typos. Whenever the user presses the space bar, if the last word they typed doesn’t match a word in the dictionary but is close to one, then that similar word will be substituted for what they typed.

Problem 5 (2 pts)

Implement autocorrect, which takes a typed_word, a word_list, a diff_function, and a limit.

If the typed_word is contained inside the word_list, autocorrect returns that word.

Otherwise, autocorrect returns the word from word_list that has the lowest difference from the provided typed_word based on the diff_function. However, if the lowest difference between typed_word and any of the words in word_list is greater than limit, then typed_word is returned instead.

Important: If typed_word is not contained inside word_list, and multiple strings have the same lowest difference from typed_word according to the diff_function, autocorrect should return the string that appears first in word_list.

A diff function takes in three arguments. The first is the typed_word, the second is the source word (in this case, a word from word_list), and the third argument is the limit. The output of the diff function, which is a number, represents the amount of difference between the two strings.

Note: Some diff functions may be asymmetric (meaning flipping the first two parameters may yield a different output), so make sure to pass in the arguments to diff_function in the correct order. We will see an example of an asymmetric diff function in problem 7.

Here is an example of a diff function that computes the minimum of 1 + limit and the difference in length between the two input strings:

1
2
3
4
5
6

>>> def length_diff(w1, w2, limit):
...     return min(limit + 1, abs(len(w2) - len(w1)))
>>> length_diff('mellow', 'cello', 10)
1
>>> length_diff('hippo', 'hippopotamus', 5)
6

Assume that typed_word and all elements of word_list are lowercase and have no punctuation.

Hint: Try using max or min with the optional key argument.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

def autocorrect(typed_word, word_list, diff_function, limit):
    """Returns the element of WORD_LIST that has the smallest difference
    from TYPED_WORD. Instead returns TYPED_WORD if that difference is greater
    than LIMIT.

    Arguments:
        typed_word: a string representing a word that may contain typos
        word_list: a list of strings representing source words
        diff_function: a function quantifying the difference between two words
        limit: a number

    >>> ten_diff = lambda w1, w2, limit: 10 # Always returns 10
    >>> autocorrect("hwllo", ["butter", "hello", "potato"], ten_diff, 20)
    'butter'
    >>> first_diff = lambda w1, w2, limit: (1 if w1[0] != w2[0] else 0) # Checks for matching first char
    >>> autocorrect("tosting", ["testing", "asking", "fasting"], first_diff, 10)
    'testing'
    """
    # BEGIN PROBLEM 5
    theword=typed_word
    min = limit
    if typed_word in word_list:
        return typed_word
    else:
        for word in word_list:
            distence = diff_function(typed_word,word,limit)
            if distence <= min:
                if theword == typed_word or distence < min:
                    min = distence
                    theword = word
        return theword 
    # END PROBLEM 5

Problem 6 (3 pts)

Implement feline_fixes, which is a diff function that takes two strings. It returns the minimum number of characters that must be changed in the typed word in order to transform it into the source word. If the strings are not of equal length, the difference in lengths is added to the total.

Important: You may not use while, for, or list comprehensions in your implementation. Use recursion.

Here are some examples:

1
2
3
4
5
6
7
8
9
10
11

>>> big_limit = 10
>>> feline_fixes("nice", "rice", big_limit)    # Substitute: n -> r
1
>>> feline_fixes("range", "rungs", big_limit)  # Substitute: a -> u, e -> s
2
>>> feline_fixes("pill", "pillage", big_limit) # Don't substitute anything, length difference of 3.
3
>>> feline_fixes("roses", "arose", big_limit)  # Substitute: r -> a, o -> r, s -> o, e -> s, s -> e
5
>>> feline_fixes("rose", "hello", big_limit)   # Substitute: r->h, o->e, s->l, e->l, length difference of 1.
5

Important: If the number of characters that must change is greater than limit, then feline_fixes should return any number larger than limit and should minimize the amount of computation needed to do so.

These two calls to feline_fixes should take about the same amount of time to evaluate:

1 2 3 4 5

>>> limit = 4 >>> feline_fixes("roses", "arose", limit) > limit True >>> feline_fixes("rosesabcdefghijklm", "arosenopqrstuvwxyz", limit) > limit True

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

def feline_fixes(typed, source, limit):
    """A diff function for autocorrect that determines how many letters
    in TYPED need to be substituted to create SOURCE, then adds the difference in
    their lengths and returns the result.

    Arguments:
        typed: a starting word
        source: a string representing a desired goal word
        limit: a number representing an upper bound on the number of chars that must change

    >>> big_limit = 10
    >>> feline_fixes("nice", "rice", big_limit)    # Substitute: n -> r
    1
    >>> feline_fixes("range", "rungs", big_limit)  # Substitute: a -> u, e -> s
    2
    >>> feline_fixes("pill", "pillage", big_limit) # Don't substitute anything, length difference of 3.
    3
    >>> feline_fixes("roses", "arose", big_limit)  # Substitute: r -> a, o -> r, s -> o, e -> s, s -> e
    5
    >>> feline_fixes("rose", "hello", big_limit)   # Substitute: r->h, o->e, s->l, e->l, length difference of 1.
    5
    """
    # BEGIN PROBLEM 6
    if limit<0:
        return 1
    if len(typed) == 0 or len(source) == 0:
        return max(len(source),len(typed))
    else:
        if source[0] != typed[0]:
            return feline_fixes(typed[1:], source[1:], limit-1)+1
        else:
            return feline_fixes(typed[1:], source[1:], limit)
    # END PROBLEM 6

Problem 7 (3 pts)

Implement minimum_mewtations, which is a diff function that returns the minimum number of edit operations needed to transform the start word into the goal word.

There are three kinds of edit operations, with some examples:

1. Add a letter to start.
   • Adding "k" to "itten" gives us "kitten".
2. Remove a letter from start.
   • Removing "s" from "scat" givs us "cat".
3. Substitute a letter in start for another.
   • Substituting "z" with "j" in "zaguar" gives us "jaguar".

Each edit operation contributes 1 to the difference between two words.

1
2
3
4
5
6
7

>>> big_limit = 10
>>> minimum_mewtations("cats", "scat", big_limit)       # cats -> scats -> scat
2
>>> minimum_mewtations("purng", "purring", big_limit)   # purng -> purrng -> purring
2
>>> minimum_mewtations("ckiteus", "kittens", big_limit) # ckiteus -> kiteus -> kitteus -> kittens
3

We have provided a template of an implementation in cats.py.

Hint: This is a recursive function with three recursive calls. One of these recursive calls will be similar to the recursive call in feline_fixes.

You may modify the template however you want or delete it entirely.

Important: If the number of edits required is greater than limit, then minimum_mewtations should return any number larger than limit and should minimize the amount of computation needed to do so.

These two calls to minimum_mewtations should take about the same amount of time to evaluate:

1 2 3 4 5

>>> limit = 2 >>> minimum_mewtations("ckiteus", "kittens", limit) > limit True >>> minimum_mewtations("ckiteusabcdefghijklm", "kittensnopqrstuvwxyz", limit) > limit True

1

python3 ok -q 07✂️

(Optional) Extension: final diff (0pt)

You may optionally design your own diff function called final_diff. Here are some ideas for making even more accurate corrections:

• Take into account which additions and deletions are more likely than others. For example, it’s much more likely that you’ll accidentally leave out a letter if it appears twice in a row.
• Treat two adjacent letters that have swapped positions as one change, not two.
• Try to incorporate common misspellings.

You can also set the limit you’d like your diff function to use by changing the value of the variable FINAL_DIFF_LIMIT in cats.py.

You can check your final_diff‘s success rate by running:

1

python3 score.py

If you don’t know where to start, try copy-pasting your code for feline_fixes and minimum_mewtations into final_diff and scoring them. Looking at the typos they accidentally fixed might give you some ideas!

Phase 3: Multiplayer

When students in the past have tried to implement the functions without thoroughly reading the problem description, they’ve often run into issues. 😱 Read each description thoroughly before starting to code.

Typing is more fun with friends! You’ll now implement multiplayer functionality, so that when you run cats_gui.py on your computer, it connects to the course server at cats.cs61a.org and looks for someone else to race against.

To race against a friend, 5 different programs will be running:

• Your GUI, which is a program that handles all the text coloring and display in your web browser.
• Your cats_gui.py, which is a web server that communicates with your GUI using the code you wrote in cats.py.
• Your opponent’s cats_gui.py.
• Your opponent’s GUI.
• The CS 61A multiplayer server, which matches players together and passes messages around.

When you type, your GUI uploads what you have typed to your cats_gui.py server, which computes how much progress you have made and returns a progress update. It also uploads a progress update to the multiplayer server, so that your opponent’s GUI can display it.

Meanwhile, your GUI display is always trying to keep current by asking for progress updates from cats_gui.py, which in turn requests that info from the multiplayer server.

Each player has an id number that is used by the server to track typing progress.

Problem 8 (2 pts)

Implement report_progress, which is called every time the user finishes typing a word. It takes a list of the words typed, a list of the words in the prompt, the user’s user_id, and a upload function that is used to upload a progress report to the multiplayer server. There will never be more words in typed than in prompt.

Your progress is a ratio of the words in the prompt that you have typed correctly, up to the first incorrect word, divided by the number of prompt words. For example, this example has a progress of 0.25:

1

report_progress(["Hello", "ths", "is"], ["Hello", "this", "is", "wrong"], ...)

Your report_progress function should do two things: upload a message to the multiplayer server and return the progress of the player with user_id.

You can upload a message to the multiplayer server by calling the upload function on a two-element dictionary containing the keys 'id' and 'progress'. You should then return the player’s progress, which is the ratio of words you computed.

Hint: See the dictionary below for an example of a potential input into the upload function. This dictionary represents a player with user_id 1 and progress 0.6.

1	{'id': 1, 'progress': 0.6}

Before writing any code, unlock the tests to verify your understanding of the question:

1

python3 ok -q 08 -u✂️

Once you are done unlocking, begin implementing your solution. You can check your correctness with:

1

python3 ok -q 08✂️

Problem 9 (2 pts)

Implement time_per_word, which takes in a list words and times_per_player, a list of lists for each player with timestamps indicating when each player finished typing every individual word in words. It returns a match with the given information.

A match is a dictionary that stores words and times. The times are stored as a list of lists of how long it took each player to type every word in words. Specifically, times[i][j] indicates how long it took player i to type words[j].

For example, say words = ['Hello', 'world'] and times = [[5, 1], [4, 2]], then [5, 1] corresponds to the list of times for player 0, and [4, 2] corresponds to the list of times for player 1. Thus, player 0 took 5 units of time to write the word 'Hello'.

Important: Be sure to use the match constructor when returning a match. The tests will check that you are using the match dictionary rather than assuming a particular data format.

Read the definitions for the match constructor in cats.py to learn more about how the dictionary is implemented.

Timestamps are cumulative and always increasing, while the values in times are differences between consecutive timestamps for each player.

Here’s an example: If times_per_player = [[1, 3, 5], [2, 5, 6]], the corresponding times attribute of the match would be [[2,2], [3, 1]]. This is because the differences in timestamps are (3-1), (5-3) for the first player and (5-2), (6-5) for the second player. The first value of each list within times_per_player represents the initial starting time for each player.

Before writing any code, unlock the tests to verify your understanding of the question:

1

python3 ok -q 09 -u✂️

Once you are done unlocking, begin implementing your solution. You can check your correctness with:

1

python3 ok -q 09✂️

👩🏽‍💻👨🏿‍💻 Pair programming? We suggest switching roles now, if you haven’t recently. Almost done!

Problem 10 (2 pts)

Implement fastest_words, which returns which words each player typed fastest. This function is called once both players have finished typing. It takes in a match.

Specifically, the fastest_words function returns a list of lists of words, one list for each player, and within each list the words they typed the fastest (against all the other players). In the case of a tie, consider the earliest player in the list (the smallest player index) to be the one who typed it the fastest.

For example consider the following match with the words ‘Just’, ‘have’, and ‘fun’. Player 0 typed ‘fun’ the fastest (3 seconds), Player 1 typed ‘Just’ the fastest (4 seconds), and they tied on the word ‘have’ (both took 1 second) so we consider to Player 0 to be the fastest, because they are the earliest player in the list.

1
2
3
4

>>> player_0 = [5, 1, 3]
>>> player_1 = [4, 1, 6]
>>> fastest_words(match(['Just', 'have', 'fun'], [player_0, player_1]))
[['have', 'fun'], ['Just']]

The match argument is a match dictionary, like the one returned in Problem 9. You can access words in the match with the selector get_word, which takes in a match and the word_index (an integer). With get_word you can access the time it took any player to type any word using time.

Important: Be sure to use the match constructor when returning a match. The tests will check that you are using the match dictionary rather than assuming a particular data format.

Make sure your implementation does not mutate the given player input lists. For the example above, calling fastest_words on [player_0, player_1] should not mutate player_0 or player_1.

Before writing any code, unlock the tests to verify your understanding of the question:

1

python3 ok -q 10 -u✂️

Once you are done unlocking, begin implementing your solution. You can check your correctness with:

1

python3 ok -q 10✂️

Congratulations! Now you can play against other students in the course. Set enable_multiplayer to True near the bottom of cats.py and type swiftly!

1

python3 cats_gui.py

At this point, run the entire autograder to see if there are any tests that don’t pass.

1

python3 ok

Once you are satisfied, submit to Ok to complete the project.

1

python3 ok --submit

If you have a partner, make sure to add them to the submission on okpy.

Check to make sure that you did all the problems by running:

1

python3 ok --score

I know! I’ll use my
Higher-order functions to
Order higher rolls.

Introduction

Important submission note: For full credit:

• Submit with Phase 1 complete by Tuesday, Sept 6, worth 1 pt.
• Submit the complete project by Friday, Sept 9.

Try to attempt the problems in order, as some later problems will depend on earlier problems in their implementation and therefore also when running ok tests.

You may complete the project with a partner.

You can get 1 bonus point by submitting the entire project by Thursday, Sept 8 You can receive extensions on the project deadline and checkpoint deadline, but not on the early deadline, unless you’re a DSP student with an accommodation for assignment extensions.

In this project, you will develop a simulator and multiple strategies for the dice game Hog. You will need to use control statements and higher-order functions together, as described in Sections 1.2 through 1.6 of Composing Programs, the online textbook.

When students in the past have tried to implement the functions without thoroughly reading the problem description, they’ve often run into issues. 😱 Read each description thoroughly before starting to code.

Rules

In Hog, two players alternate turns trying to be the first to end a turn with at least GOAL total points, where GOAL defaults to 100. On each turn, the current player chooses some number of dice to roll, up to 10. That player’s score for the turn is the sum of the dice outcomes. However, a player who rolls too many dice risks:

• Sow Sad. If any of the dice outcomes is a 1, the current player’s score for the turn is 1.

In a normal game of Hog, those are all the rules. To spice up the game, we’ll include some special rules:

• Pig Tail. A player who chooses to roll zero dice scores 2 * abs(tens - ones) + 1 points; where tens, ones are the tens and ones digits of the opponent’s score. The ones digit refers to the rightmost digit and the tens digit refers to the second-rightmost digit.

• Square Swine. After a player gains points for their turn, if the resulting score is a perfect square, then increase their score to the next higher perfect square. A perfect square is any integer n where n = d * d for some integer d.

Phase 1: Rules of the Game

In the first phase, you will develop a simulator for the game of Hog.

Problem 1 (2 pt)

Implement the roll_dice function in hog.py. It takes two arguments: a positive integer called num_rolls giving the number of dice to roll and a dice function. It returns the number of points scored by rolling the dice that number of times in a turn: either the sum of the outcomes or 1 (Sow Sad).

• Sow Sad. If any of the dice outcomes is a 1, the current player’s score for the turn is 1.

Examples

To obtain a single outcome of a dice roll, call dice(). You should call dice() exactly num_rolls times in the body of roll_dice.

Remember to call dice() exactly num_rolls times even if Sow Sad happens in the middle of rolling. By doing so, you will correctly simulate rolling all the dice together (and the user interface will work correctly).

Note: The roll_dice function, and many other functions throughout the project, makes use of default argument values—you can see this in the function heading:

1	def roll_dice(num_rolls, dice=six_sided): ...

The argument dice=six_sided means that when roll_dice is called, the dice argument is optional. If no value for dice is provided, then six_sided is used by default.

For example, calling roll_dice(3, four_sided), or equivalently roll_dice(3, dice=four_sided), simulates rolling 3 four-sided dice, while calling roll_dice(3) simulates rolling 3 six-sided dice.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

def roll_dice(num_rolls, dice=six_sided):
    """Simulate rolling the DICE exactly NUM_ROLLS > 0 times. Return the sum of
    the outcomes unless any of the outcomes is 1. In that case, return 1.

    num_rolls:  The number of dice rolls that will be made.
    dice:       A function that simulates a single dice roll outcome.
    """
    # These assert statements ensure that num_rolls is a positive integer.
    assert type(num_rolls) == int, 'num_rolls must be an integer.'
    assert num_rolls > 0, 'Must roll at least once.'
    # BEGIN PROBLEM 1
    count = 0
    one = 0
    for i in range(num_rolls):
        dice_thistime = dice()
        if dice_thistime == 1:
            one = 1
        count = count + dice_thistime
    res = (1 if one == 1 else count)
    return res
    # END PROBLEM 1

Problem 2 (2 pt)

Implement tail_points, which takes the player’s opponent’s current score opponent_score, and returns the number of points scored by Pig Tail when the player rolls 0 dice.

• Pig Tail. A player who chooses to roll zero dice scores 2 * abs(tens - ones) + 1 points; where tens, ones are the tens and ones digits of the opponent’s score. The ones digit refers to the rightmost digit and the tens digit refers to the second-rightmost digit.

Examples

Don’t assume that scores are below 100. Write your tail_points function so that it works correctly for any non-negative score.

Important: Your implementation should not use str, lists, or contain square brackets [ ]. The test cases will check if those have been used.

1
2
3
4
5
6
7
8
9
10
11

def tail_points(opponent_score):
    """Return the points scored by rolling 0 dice according to Pig Tail.

    opponent_score:   The total score of the other player.

    """
    # BEGIN PROBLEM 2
    ones = opponent_score%10
    tens = opponent_score%100//10
    return 2*abs(tens-ones)+1
    # END PROBLEM 2

You can also test tail_points interactively by running python3 -i hog.py from the terminal and calling tail_points on various inputs.

Problem 3 (2 pt)

Implement the take_turn function, which returns the number of points scored for a turn by rolling the given dice num_rolls times.

Your implementation of take_turn should call both roll_dice and tail_points rather than repeating their implementations.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

def take_turn(num_rolls, opponent_score, dice=six_sided):
    """Return the points scored on a turn rolling NUM_ROLLS dice when the
    opponent has OPPONENT_SCORE points.

    num_rolls:       The number of dice rolls that will be made.
    opponent_score:  The total score of the other player.
    dice:            A function that simulates a single dice roll outcome.
    """
    # Leave these assert statements here; they help check for errors.
    assert type(num_rolls) == int, 'num_rolls must be an integer.'
    assert num_rolls >= 0, 'Cannot roll a negative number of dice in take_turn.'
    assert num_rolls <= 10, 'Cannot roll more than 10 dice.'
    # BEGIN PROBLEM 3
    if num_rolls==0:
        return tail_points(opponent_score)
    else:
        return roll_dice(num_rolls,dice)
    # END PROBLEM 3

Problem 4 (1 pt)

Add functions perfect_square and next_perfect_square so that square_update returns a player’s total score after they roll num_rolls. You do not need to edit the body of square_update.

• Square Swine. After a player gains points for their turn, if the resulting score is a perfect square, then increase their score to the next higher perfect square. A perfect square is any integer n where n = d * d for some integer d.

1
2
3
4
5
6
7

# BEGIN PROBLEM 4
def perfect_square(score):
    return score ** 0.5 % 1 == 0
 
def next_perfect_square(score):
    return int((score ** 0.5 + 1)**2)
# END PROBLEM 4

Problem 5 (5 pt)

Implement the play function, which simulates a full game of Hog. Players take turns rolling dice until one of the players reaches the goal score, and the final scores of both players are returned by the function.

To determine how many dice are rolled each turn, call the current player’s strategy function (Player 0 uses strategy0 and Player 1 uses strategy1). A strategy is a function that, given a player’s score and their opponent’s score, returns the number of dice that the current player will roll in the turn. An example strategy is always_roll_5 which appears above play.

To determine the updated score for a player after they take a turn, call the update function. An update function takes the number of dice to roll, the current player’s score, the opponent’s score, and the dice function used to simulate rolling dice. It returns the updated score of the current player after they take their turn. Two examples of update functions are simple_update andsquare_update.

If a player achieves the goal score by the end of their turn, i.e. after all applicable rules have been applied, the game ends. play will then return the final total scores of both players, with Player 0’s score first and Player 1’s score second.

Some example calls to play are:

• play(always_roll_5, always_roll_5, simple_update) simulates two players that both always roll 5 dice each turn, playing with just the Sow Sad and Pig Tail rules.
• play(always_roll_5, always_roll_5, square_update) simulates two players that both always roll 5 dice each turn, playing with the Square Swine rule in addition to the Sow Sad and Pig Tail rules (i.e. all the rules).

Important: For the user interface to work, a strategy function should be called only once per turn. Only call strategy0 when it is Player 0’s turn and only call strategy1 when it is Player 1’s turn.

Hints:

• If who is the current player, the next player is 1 - who.
• To call play(always_roll_5, always_roll_5, square_update) and print out what happens each turn, run python3 hog_ui.py from the terminal.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

def play(strategy0, strategy1, update,
         score0=0, score1=0, dice=six_sided, goal=GOAL):
    """Simulate a game and return the final scores of both players, with
    Player 0's score first and Player 1's score second.

    E.g., play(always_roll_5, always_roll_5, square_update) simulates a game in
    which both players always choose to roll 5 dice on every turn and the Square
    Swine rule is in effect.

    A strategy function, such as always_roll_5, takes the current player's
    score and their opponent's score and returns the number of dice the current
    player chooses to roll.

    An update function, such as square_update or simple_update, takes the number
    of dice to roll, the current player's score, the opponent's score, and the
    dice function used to simulate rolling dice. It returns the updated score
    of the current player after they take their turn.

    strategy0: The strategy for player0.
    strategy1: The strategy for player1.
    update:    The update function (used for both players).
    score0:    Starting score for Player 0
    score1:    Starting score for Player 1
    dice:      A function of zero arguments that simulates a dice roll.
    goal:      The game ends and someone wins when this score is reached.
    """
    who = 0  # Who is about to take a turn, 0 (first) or 1 (second)
    # BEGIN PROBLEM 5
    while score0 < goal and score1 < goal:
        if who == 0:
            score0 = update(strategy0(score0, score1), score0, score1, dice)
        else:
            score1 = update(strategy1(score1, score0), score1, score0, dice)
        who = 1 - who
    # END PROBLEM 5
    return score0, score1

Phase 2: Strategies

In this phase, you will experiment with ways to improve upon the basic strategy of always rolling five dice. A strategy is a function that takes two arguments: the current player’s score and their opponent’s score. It returns the number of dice the player will roll, which can be from 0 to 10 (inclusive).

Problem 6 (2 pt)

Implement always_roll, a higher-order function that takes a number of dice n and returns a strategy that always rolls n dice. Thus, always_roll(5) would be equivalent to always_roll_5.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

def always_roll(n):
    """Return a player strategy that always rolls N dice.

    A player strategy is a function that takes two total scores as arguments
    (the current player's score, and the opponent's score), and returns a
    number of dice that the current player will roll this turn.

    >>> strategy = always_roll(3)
    >>> strategy(0, 0)
    3
    >>> strategy(99, 99)
    3
    """
    assert n >= 0 and n <= 10
    # BEGIN PROBLEM 6
    return lambda score, opponent_score : n
    # END PROBLEM 6

Problem 7 (2 pt)

A strategy only has a fixed number of possible argument values. In a game to 100, there are 100 possible score values (0-99) and 100 possible opponent_score values (0-99), giving 10,000 possible argument combinations.

Implement is_always_roll, which takes a strategy and returns whether that strategy always rolls the same number of dice for every possible argument combination.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

def is_always_roll(strategy, goal=GOAL):
    """Return whether strategy always chooses the same number of dice to roll.

    >>> is_always_roll(always_roll_5)
    True
    >>> is_always_roll(always_roll(3))
    True
    >>> is_always_roll(catch_up)
    False
    """
    # BEGIN PROBLEM 7
    start = strategy(0,0)
    for m in range(goal):
        for n in range(goal):
            if strategy(m,n)!=start:
                return False
    return True
    # END PROBLEM 7

Problem 8 (2 pt)

Implement make_averaged, which is a higher-order function that takes a function original_function as an argument.

The return value of make_averaged is a function that takes in the same number of arguments as original_function. When we call this returned function on the arguments, it will return the average value of repeatedly calling original_function on the arguments passed in.

Specifically, this function should call original_function a total of total_samples times and return the average of the results of these calls.

Important: To implement this function, you will need to use a new piece of Python syntax. We would like to write a function that accepts an arbitrary number of arguments, and then calls another function using exactly those arguments. Here’s how it works.

Instead of listing formal parameters for a function, you can write *args, which represents all of the arguments that get passed into the function. We can then call another function with these same arguments by passing these *args into this other function. For example:

1 2 3 4 5 6 7 8 9 10 11 12 13 14

>>> def printed(f): ... def print_and_return(*args): ... result = f(*args) ... print('Result:', result) ... return result ... return print_and_return >>> printed_pow = printed(pow) >>> printed_pow(2, 8) Result: 256 256 >>> printed_abs = printed(abs) >>> printed_abs(-10) Result: 10 10

Here, we can pass any number of arguments into print_and_return via the *args syntax. We can also use *args inside our print_and_return function to make another function call with the same arguments.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

def make_averaged(original_function, total_samples=1000):
    """Return a function that returns the average value of ORIGINAL_FUNCTION
    called TOTAL_SAMPLES times.

    To implement this function, you will have to use *args syntax.

    >>> dice = make_test_dice(4, 2, 5, 1)
    >>> averaged_dice = make_averaged(roll_dice, 40)
    >>> averaged_dice(1, dice)  # The avg of 10 4's, 10 2's, 10 5's, and 10 1's
    3.0
    """
    # BEGIN PROBLEM 8
    def new_function(*args):
        count = 0
        for i in range(total_samples):
            count += original_function(*args)
        return count/total_samples
    
    return new_function
    # END PROBLEM 8

Problem 9 (2 pt)

Implement max_scoring_num_rolls, which runs an experiment to determine the number of rolls (from 1 to 10) that gives the maximum average score for a turn. Your implementation should use make_averaged and roll_dice.

If two numbers of rolls are tied for the maximum average score, return the lower number. For example, if both 3 and 6 achieve a maximum average score, return 3.

You might find it useful to read the doctest and the example shown in the doctest for this problem before doing the unlocking test.

Important: In order to pass all of our tests, please make sure that you are testing dice rolls starting from 1 going up to 10, rather than from 10 to 1.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

def max_scoring_num_rolls(dice=six_sided, total_samples=1000):
    """Return the number of dice (1 to 10) that gives the highest average turn score
    by calling roll_dice with the provided DICE a total of TOTAL_SAMPLES times.
    Assume that the dice always return positive outcomes.

    >>> dice = make_test_dice(1, 6)
    >>> max_scoring_num_rolls(dice)
    1
    """
    # BEGIN PROBLEM 9
    max_score = 0
    bestnum=0
    averaged_dice = make_averaged(roll_dice, total_samples)
    the_dice = dice
    for i in range (1,11):
        score = averaged_dice(i, the_dice)
        if score > max_score:
            bestnum = i
            max_score = score
    return bestnum
    # END PROBLEM 9

Problem 10 (2 pt)

A strategy can try to take advantage of the Pig Tail rule by rolling 0 when it is most beneficial to do so. Implement tail_strategy, which returns 0 whenever rolling 0 would give at least threshold points and returns num_rolls otherwise. This strategy should not also take into account the Square Swine rule.

Hint: You can use the tail_points function you defined in Problem 2.

1
2
3
4
5
6
7
8
9

def tail_strategy(score, opponent_score, threshold=12, num_rolls=6):
    """This strategy returns 0 dice if Pig Tail gives at least THRESHOLD
    points, and returns NUM_ROLLS otherwise. Ignore score and Square Swine.
    """
    # BEGIN PROBLEM 10
    if tail_points(opponent_score)>=threshold:
        return 0
    return num_rolls  # Remove this line once implemented.
    # END PROBLEM 10

Problem 11 (2 pt)

A better strategy will take advantage of both Pig Tail and Square Swine in combination. Even a small number of pig tail points can lead to large gains. For example, if a player has 31 points and their opponent has 42, rolling 0 would bring them to 36 which is a perfect square, and so they would end the turn with 49 points: a gain of 49 - 31 = 18!

The square_strategy returns 0 whenever rolling 0 would result in a score that is at least threshold points more than the player’s score at the start of turn.

Hint: You can use the square_update function.

1
2
3
4
5
6
7

def square_strategy(score, opponent_score, threshold=12, num_rolls=6):
    """This strategy returns 0 dice when your score would increase by at least threshold."""
    # BEGIN PROBLEM 11
    if square_update(0, score, opponent_score)-score >= threshold:
        return 0
    return num_rolls  # Remove this line once implemented.
    # END PROBLEM 11

You should find that running python3 hog.py -r now shows a win rate for square_strategy close to 62%.

Optional: Problem 12 (0 pt)

Implement final_strategy, which combines these ideas and any other ideas you have to achieve a high win rate against the baseline strategy. Some suggestions:

• If you know the goal score (by default it is 100), there’s no benefit to scoring more than the goal. Check whether you can win by rolling 0, 1 or 2 dice. If you are in the lead, you might decide to take fewer risks.
• Instead of using a threshold, roll 0 whenever it would give you more points on average than rolling 6.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

def final_strategy(score, opponent_score):
    """Write a brief description of your final strategy.

    *** YOUR DESCRIPTION HERE ***
    """
    # BEGIN PROBLEM 12
    averaged_dice = make_averaged(roll_dice, 100)
    if square_update(0, score, opponent_score)-score >= averaged_dice(6):
        return 0
    elif 100 - score < averaged_dice(1):
        return 1
    elif 100 - score < averaged_dice(2):
        return 2
    elif 100 - score < averaged_dice(3):
        return 3
    elif 100 - score < averaged_dice(4):
        return 4
    elif 100 - score < averaged_dice(5):
        return 5
    else :
        return 6
    # END PROBLEM 12

Due by 11:59pm on Thursday, September 8

Required questions

Several doctests refer to these functions:

1
2
3
4
5
6
7
8
9

from operator import add, mul

square = lambda x: x * x

identity = lambda x: x

triple = lambda x: 3 * x

increment = lambda x: x + 1

Q1: Product

Write a function called product that returns term(1) * ... * term(n).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

def product(n, term):
    """Return the product of the first n terms in a sequence.

    n: a positive integer
    term:  a function that takes one argument to produce the term

    >>> product(3, identity)  # 1 * 2 * 3
    6
    >>> product(5, identity)  # 1 * 2 * 3 * 4 * 5
    120
    >>> product(3, square)    # 1^2 * 2^2 * 3^2
    36
    >>> product(5, square)    # 1^2 * 2^2 * 3^2 * 4^2 * 5^2
    14400
    >>> product(3, increment) # (1+1) * (2+1) * (3+1)
    24
    >>> product(3, triple)    # 1*3 * 2*3 * 3*3
    162
    """
    sum=term(1)
    for i in range(n-1):
        sum*=term((i+2))
    return sum

Q2: Accumulate

Let’s take a look at how product is an instance of a more general function called accumulate, which we would like to implement:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

def accumulate(merger, start, n, term):
    """Return the result of merging the first n terms in a sequence and start.
    The terms to be merged are term(1), term(2), ..., term(n). merger is a
    two-argument commutative function.

    >>> accumulate(add, 0, 5, identity)  # 0 + 1 + 2 + 3 + 4 + 5
    15
    >>> accumulate(add, 11, 5, identity) # 11 + 1 + 2 + 3 + 4 + 5
    26
    >>> accumulate(add, 11, 0, identity) # 11
    11
    >>> accumulate(add, 11, 3, square)   # 11 + 1^2 + 2^2 + 3^2
    25
    >>> accumulate(mul, 2, 3, square)    # 2 * 1^2 * 2^2 * 3^2
    72
    >>> # 2 + (1^2 + 1) + (2^2 + 1) + (3^2 + 1)
    >>> accumulate(lambda x, y: x + y + 1, 2, 3, square)
    19
    >>> # ((2 * 1^2 * 2) * 2^2 * 2) * 3^2 * 2
    >>> accumulate(lambda x, y: 2 * x * y, 2, 3, square)
    576
    >>> accumulate(lambda x, y: (x + y) % 17, 19, 20, square)
    16
    """
    "*** YOUR CODE HERE ***"
    sum = start
    for i in range(n):
        sum = merger(sum,term(i+1))
    return sum

accumulate has the following parameters:

• term and n: the same parameters as in product
• merger: a two-argument function that specifies how the current term is merged with the previously accumulated terms.
• start: value at which to start the accumulation.

For example, the result of accumulate(add, 11, 3, square) is

1

11 + square(1) + square(2) + square(3) = 25

Note: You may assume that merger is commutative. That is, merger(a, b) == merger(b, a) for all a and b. However, you may not assume merger is chosen from a fixed function set and hard-code the solution.

After implementing accumulate, show how summation and product can both be defined as function calls to accumulate.

Important: You should have a single line of code (which should be a return statement) in each of your implementations for summation_using_accumulate and product_using_accumulate, which the syntax check will check for.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

def summation_using_accumulate(n, term):
    """Returns the sum: term(0) + ... + term(n), using accumulate.

    >>> summation_using_accumulate(5, square)
    55
    >>> summation_using_accumulate(5, triple)
    45
    >>> # You aren't expected to understand the code of this test.
    >>> # Check that the bodies of the functions are just return statements.
    >>> # If this errors, make sure you have removed the "***YOUR CODE HERE***".
    >>> import inspect, ast
    >>> [type(x).__name__ for x in ast.parse(inspect.getsource(summation_using_accumulate)).body[0].body]
    ['Expr', 'Return']
    """
    return accumulate(add, term(0), n, term)

def product_using_accumulate(n, term):
    """Returns the product: term(1) * ... * term(n), using accumulate.

    >>> product_using_accumulate(4, square)
    576
    >>> product_using_accumulate(6, triple)
    524880
    >>> # You aren't expected to understand the code of this test.
    >>> # Check that the bodies of the functions are just return statements.
    >>> # If this errors, make sure you have removed the "***YOUR CODE HERE***".
    >>> import inspect, ast
    >>> [type(x).__name__ for x in ast.parse(inspect.getsource(product_using_accumulate)).body[0].body]
    ['Expr', 'Return']
    """
    return accumulate(mul, 1, n, term)

Required questions

Arms-length recursion

Before we get started, a quick comment on recursion with tree data structures. Consider the following function.

1
2
3
4
5
6
7
8
9

def min_depth(t):
    """A simple function to return the distance between t's root and its closest leaf"""
    if is_leaf(t):
        return 0 # Base case---the distance between a node and itself is zero
    h = float('inf') # Python's version of infinity
    for b in branches(t):
        if is_leaf(b): return 1 # !!!
        h = min(h, 1 + min_depth(b))
    return h

The line flagged with !!! is an “arms-length” recursion violation. Although our code works correctly when it is present, by performing this check we are doing work that should be done by the next level of recursion—we already have an if-statement that handles any inputs to min_depth that are leaves, so we should not include this line to eliminate redundancy in our code.

1
2
3
4
5
6
7
8
9

def min_depth(t):
    """A simple function to return the distance between t's root and its closest leaf"""
    if is_leaf(t):
        return 0
    h = float('inf')
    for b in branches(t):
        # Still works fine!
        h = min(h, 1 + min_depth(b))
    return h

Arms-length recursion is not only redundant but often complicates our code and obscures the functionality of recursive functions, making writing recursive functions much more difficult. We always want our recursive case to be handling one and only one recursive level. We may or may not be checking your code periodically for things like this.

Mobiles

Acknowledgements This mobile example is based on a classic problem from MIT Structure and Interpretation of Computer Programs, Section 2.2.2.

We are making a planetarium mobile. A mobile is a type of hanging sculpture. A binary mobile consists of two arms. Each arm is a rod of a certain length, from which hangs either a planet or another mobile. For example, the below diagram shows the left and right arms of Mobile A, and what hangs at the ends of each of those arms.

We will represent a binary mobile using the data abstractions below.

• A mobile must have both a left arm and a right arm.
• An arm has a positive length and must have something hanging at the end, either a mobile or planet.
• A planet has a positive mass, and nothing hanging from it.

Q2: Weights

Below are the implementations of the various data abstractions used in mobiles. The mobile and arm data abstractions have been completed for you.

Your job is to implement the planet data abstraction by completing the planet constructor and the mass selector so that a planet is represented using a two-element list where the first element is the string 'planet' and the second element is its mass.

Implementation of the Mobile Data Abstraction (for your reference, no need to do anything here):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

def mobile(left, right):
    """Construct a mobile from a left arm and a right arm."""
    assert is_arm(left), "left must be a arm"
    assert is_arm(right), "right must be a arm"
    return ['mobile', left, right]

def is_mobile(m):
    """Return whether m is a mobile."""
    return type(m) == list and len(m) == 3 and m[0] == 'mobile'

def left(m):
    """Select the left arm of a mobile."""
    assert is_mobile(m), "must call left on a mobile"
    return m[1]

def right(m):
    """Select the right arm of a mobile."""
    assert is_mobile(m), "must call right on a mobile"
    return m[2]

Implementation of the Arm Data Abstraction (for your reference, no need to do anything here):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

def arm(length, mobile_or_planet):
    """Construct a arm: a length of rod with a mobile or planet at the end."""
    assert is_mobile(mobile_or_planet) or is_planet(mobile_or_planet)
    return ['arm', length, mobile_or_planet]

def is_arm(s):
    """Return whether s is a arm."""
    return type(s) == list and len(s) == 3 and s[0] == 'arm'

def length(s):
    """Select the length of a arm."""
    assert is_arm(s), "must call length on a arm"
    return s[1]

def end(s):
    """Select the mobile or planet hanging at the end of a arm."""
    assert is_arm(s), "must call end on a arm"
    return s[2]

(Your turn!) Fill out the implementation of the Planet Data Abstraction!

1
2
3
4
5
6
7
8
9
10
11
12
13

def planet(mass):
    """Construct a planet of some mass."""
    assert mass > 0
    return ["planet",mass]

def mass(w):
    """Select the mass of a planet."""
    assert is_planet(w), 'must call mass on a planet'
    return w[1]

def is_planet(w):
    """Whether w is a planet."""
    return type(w) == list and len(w) == 2 and w[0] == 'planet'

Total Weight implementation (for your reference and understanding, no need to do anything here):

The total_weight example is provided to demonstrate use of the mobile, arm, and planet abstractions for your reference. You do not need to implement anything here. You may use the total_weight function in questions 3 and 4.

The examples function builds and returns three mobiles. These mobiles are used in the doctest examples for total_weight, a function that takes in either a mobile or a planet and returns its total weight. The total weight of a planet is just its mass. The total weight of a mobile is the sum of the masses of all the planets hanging from the mobile.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

def examples():
    t = mobile(arm(1, planet(2)),
               arm(2, planet(1)))
    u = mobile(arm(5, planet(1)),
               arm(1, mobile(arm(2, planet(3)),
                              arm(3, planet(2)))))
    v = mobile(arm(4, t), arm(2, u))
    return (t, u, v)
def total_weight(m):
    """Return the total weight of m, a planet or mobile.

    >>> t, u, v = examples()
    >>> total_weight(t)
    3
    >>> total_weight(u)
    6
    >>> total_weight(v)
    9
    >>> from construct_check import check
    >>> # checking for abstraction barrier violations by banning indexing
    >>> check(HW_SOURCE_FILE, 'total_weight', ['Index'])
    True
    """
    if is_planet(m):
        return mass(m)
    else:
        assert is_mobile(m), "must get total weight of a mobile or a planet"
        return total_weight(end(left(m))) + total_weight(end(right(m)))

Use Ok to test your code:

1

python3 ok -q total_weight✂️

Q3: Balanced

Implement the balanced function, which returns whether m is a balanced mobile. A mobile is balanced if both of the following conditions are met:

1. The torque applied by its left arm is equal to that applied by its right arm. The torque of the left arm is the length of the left rod multiplied by the total weight hanging from that rod. Likewise for the right. For example, if the left arm has a length of 5, and there is a mobile hanging at the end of the left arm of total weight 10, the torque on the left side of our mobile is 50.
2. Each of the mobiles hanging at the end of its arms is itself balanced.

Planets themselves are balanced, as there is nothing hanging off of them.

Reminder: You may use the total_weight function defined for you in Question 2 (as well as any of the other functions defined in Question 2).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

def balanced(m):
    """Return whether m is balanced.

    >>> t, u, v = examples()
    >>> balanced(t)
    True
    >>> balanced(v)
    True
    >>> w = mobile(arm(3, t), arm(2, u))
    >>> balanced(w)
    False
    >>> balanced(mobile(arm(1, v), arm(1, w)))
    False
    >>> balanced(mobile(arm(1, w), arm(1, v)))
    False
    >>> from construct_check import check
    >>> # checking for abstraction barrier violations by banning indexing
    >>> check(HW_SOURCE_FILE, 'balanced', ['Index'])
    True
    """
    if is_mobile(m):
        if total_weight(end(left(m)))*length(left(m)) != total_weight(end(right(m)))*length(right(m)):
            return False
        if not balanced(end(left(m))) or not balanced(end(right(m))):
            return False
    return True

Use Ok to test your code:

1

python3 ok -q balanced✂️

Q4: Totals

Implement totals_tree, which takes in a mobile or planet and returns a tree whose root is the total weight of the input. For a planet, totals_tree should return a leaf. For a mobile, totals_tree should return a tree whose label is that mobile‘s total weight, and whose branches are totals_trees for the ends of its arms. As a reminder, the description of the tree data abstraction can be found here.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

def totals_tree(m):
    """Return a tree representing the mobile with its total weight at the root.

    >>> t, u, v = examples()
    >>> print_tree(totals_tree(t))
    3
      2
      1
    >>> print_tree(totals_tree(u))
    6
      1
      5
        3
        2
    >>> print_tree(totals_tree(v))
    9
      3
        2
        1
      6
        1
        5
          3
          2
    >>> from construct_check import check
    >>> # checking for abstraction barrier violations by banning indexing
    >>> check(HW_SOURCE_FILE, 'totals_tree', ['Index'])
    True
    """
    if is_planet(m):
        return [total_weight(m)]
    elif is_mobile(m):
        branches = []
        branches.append(totals_tree(end(left(m))))
        branches.append(totals_tree(end(right(m))))
        res = tree(total_weight(m), branches)
        return res

Use Ok to test your code:

1

python3 ok -q totals_tree✂️

More Trees

Q5: Replace Loki at Leaf

Define replace_loki_at_leaf, which takes a tree t and a value lokis_replacement. replace_loki_at_leaf returns a new tree that’s the same as t except that every leaf label equal to "loki" has been replaced with lokis_replacement.

If you want to learn about the Norse mythology referenced in this problem, you can read about it here.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

def replace_loki_at_leaf(t, lokis_replacement):
    """Returns a new tree where every leaf value equal to "loki" has
    been replaced with lokis_replacement.

    >>> yggdrasil = tree('odin',
    ...                  [tree('balder',
    ...                        [tree('loki'),
    ...                         tree('freya')]),
    ...                   tree('frigg',
    ...                        [tree('loki')]),
    ...                   tree('loki',
    ...                        [tree('sif'),
    ...                         tree('loki')]),
    ...                   tree('loki')])
    >>> laerad = copy_tree(yggdrasil) # copy yggdrasil for testing purposes
    >>> print_tree(replace_loki_at_leaf(yggdrasil, 'freya'))
    odin
      balder
        freya
        freya
      frigg
        freya
      loki
        sif
        freya
      freya
    >>> laerad == yggdrasil # Make sure original tree is unmodified
    True
    """
    if is_leaf(t):
        if label(t)=="loki":
            return tree(lokis_replacement)
    return tree(label(t),[replace_loki_at_leaf(x, lokis_replacement) for x in branches(t)])

Use Ok to test your code:

1

python3 ok -q replace_loki_at_leaf✂️

Q6: Has Path

Write a function has_path that takes in a tree t and a string word. It returns True if there is a path that starts from the root where the entries along the path spell out the word, and False otherwise. (This data structure is called a trie, and it has a lot of cool applications, such as autocomplete). You may assume that every node’s label is exactly one character.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

def has_path(t, word):
    """Return whether there is a path in a tree where the entries along the path
    spell out a particular word.

    >>> greetings = tree('h', [tree('i'),
    ...                        tree('e', [tree('l', [tree('l', [tree('o')])]),
    ...                                   tree('y')])])
    >>> print_tree(greetings)
    h
      i
      e
        l
          l
            o
        y
    >>> has_path(greetings, 'h')
    True
    >>> has_path(greetings, 'i')
    False
    >>> has_path(greetings, 'hi')
    True
    >>> has_path(greetings, 'hello')
    True
    >>> has_path(greetings, 'hey')
    True
    >>> has_path(greetings, 'bye')
    False
    >>> has_path(greetings, 'hint')
    False
    """
    assert len(word) > 0, 'no path for empty word.'
    if len(word) == 1:
        if(label(t)==word[0]):
            return True
        return False
    else:
        if(label(t)==word[0]):
            for i in branches(t):
                if has_path(i, word[1:]):
                    return True
            return False
        else:
            return False

Use Ok to test your code:

1

python3 ok -q has_path✂️

Optional Questions

Data Abstraction

Feel free to reference Section 2.2 for more information on data abstraction.

Acknowledgements. This interval arithmetic example is based on a classic problem from Structure and Interpretation of Computer Programs, Section 2.1.4.

Introduction. Alyssa P. Hacker is designing a system to help people solve engineering problems. One feature she wants to provide in her system is the ability to manipulate inexact quantities (such as measurements from physical devices) with known precision, so that when computations are done with such approximate quantities the results will be numbers of known precision. For example, if a measured quantity x lies between two numbers a and b, Alyssa would like her system to use this range in computations involving x.

Alyssa’s idea is to implement interval arithmetic as a set of arithmetic operations for combining “intervals” (objects that represent the range of possible values of an inexact quantity). The result of adding, subracting, multiplying, or dividing two intervals is also an interval, one that represents the range of the result.

Alyssa suggests the existence of an abstraction called an “interval” that has two endpoints: a lower bound and an upper bound. She also presumes that, given the endpoints of an interval, she can create the interval using data abstraction. Using this constructor and the appropriate selectors, she defines the following operations:

1
2
3
4
5
6
7
8
9
10

def str_interval(x):
    """Return a string representation of interval x."""
    return '{0} to {1}'.format(lower_bound(x), upper_bound(x))

def add_interval(x, y):
    """Return an interval that contains the sum of any value in interval x and
    any value in interval y."""
    lower = lower_bound(x) + lower_bound(y)
    upper = upper_bound(x) + upper_bound(y)
    return interval(lower, upper)

Q7: Interval Abstraction

Alyssa’s program is incomplete because she has not specified the implementation of the interval abstraction. She has implemented the constructor for you; fill in the implementation of the selectors.

1
2
3
4
5
6
7
8
9
10
11
12

def interval(a, b):
    """Construct an interval from a to b."""
    assert a <= b, 'Lower bound cannot be greater than upper bound'
    return [a, b]

def lower_bound(x):
    """Return the lower bound of interval x."""
    return x[0]

def upper_bound(x):
    """Return the upper bound of interval x."""
    return x[1]

Use Ok to unlock and test your code:

1
2

python3 ok -q interval -u
python3 ok -q interval✂️

Q8: Interval Arithmetic

After implementing the abstraction, Alyssa decided to implement a few interval arithmetic functions.

This is her current implementation for interval multiplication. Unfortunately there are some data abstraction violations, so your task is to fix this code before someone sets it on fire.

1
2
3
4
5
6
7
8

def mul_interval(x, y):
    """Return the interval that contains the product of any value in x and any
    value in y."""
    p1 = x[0] * y[0]
    p2 = x[0] * y[1]
    p3 = x[1] * y[0]
    p4 = x[1] * y[1]
    return [min(p1, p2, p3, p4), max(p1, p2, p3, p4)]

Use Ok to unlock and test your code:

1
2

python3 ok -q mul_interval -u
python3 ok -q mul_interval✂️

Interval Subtraction

Using a similar approach as mul_interval and add_interval, define a subtraction function for intervals. If you find yourself repeating code, see if you can reuse functions that have already been implemented.

1
2
3
4
5
6

def sub_interval(x, y):
    """Return the interval that contains the difference between any value in x
    and any value in y."""
    lower = lower_bound(x) - upper_bound(y)
    upper = upper_bound(x) - lower_bound(y)
    return interval(lower, upper)

Use Ok to unlock and test your code:

1
2

python3 ok -q sub_interval -u
python3 ok -q sub_interval✂️

Interval Division

Alyssa implements division below by multiplying by the reciprocal of y. A systems programmer looks over Alyssa’s shoulder and comments that it is not clear what it means to divide by an interval that spans zero. Add an assert statement to Alyssa’s code to ensure that no such interval is used as a divisor:

1
2
3
4
5
6
7

def div_interval(x, y):
    """Return the interval that contains the quotient of any value in x divided by
    any value in y. Division is implemented as the multiplication of x by the
    reciprocal of y."""
    assert lower_bound(y)>0 or upper_bound(y)<0
    reciprocal_y = interval(1 / upper_bound(y), 1 / lower_bound(y))
    return mul_interval(x, reciprocal_y)

Use Ok to unlock and test your code:

1
2

python3 ok -q div_interval -u
python3 ok -q div_interval✂️

Q9: Par Diff

After considerable work, Alyssa P. Hacker delivers her finished system. Several years later, after she has forgotten all about it, she gets a frenzied call from an irate user, Lem E. Tweakit. It seems that Lem has noticed that the formula for parallel resistors can be written in two algebraically equivalent ways:

1

par1(r1, r2) = (r1 * r2) / (r1 + r2)

or

1

par2(r1, r2) = 1 / (1/r1 + 1/r2)

He has written the following two programs, each of which computes the parallel_resistors formula differently:

1
2
3
4
5
6
7
8

def par1(r1, r2):
    return div_interval(mul_interval(r1, r2), add_interval(r1, r2))

def par2(r1, r2):
    one = interval(1, 1)
    rep_r1 = div_interval(one, r1)
    rep_r2 = div_interval(one, r2)
    return div_interval(one, add_interval(rep_r1, rep_r2))

Lem points out that Alyssa’s program gives different answers for the two ways of computing. Find two intervals r1 and r2 that demonstrate the difference in behavior between par1 and par2 when passed into each of the two functions.

Demonstrate that Lem is right. Investigate the behavior of the system on a variety of arithmetic expressions. Make some intervals r1 and r2, and show that par1 and par2 can give different results.

1
2
3
4
5
6
7
8
9
10
11
12

def check_par():
    """Return two intervals that give different results for parallel resistors.

    >>> r1, r2 = check_par()
    >>> x = par1(r1, r2)
    >>> y = par2(r1, r2)
    >>> lower_bound(x) != lower_bound(y) or upper_bound(x) != upper_bound(y)
    True
    """
    r1 = interval(7, 123)  # Replace this line!
    r2 = interval(3, 44)  # Replace this line!
    return r1, r2

Due by 11:59pm on Thursday, September 1

Required Questions

Q1: A Plus Abs B

Python’s operator module defines binary functions for Python’s intrinsic arithmetic operators. For example, calling operator.add(2,3) is equivalent to calling the expression 2 + 3; both will return 5.

Note that when the operator module is imported into the namespace, like at the top of hw01.py, you can just call add(2,3) instead of operator.add(2,3).

Fill in the blanks in the following function for adding a to the absolute value of b, without calling abs. You may not modify any of the provided code other than the two blanks.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

def a_plus_abs_b(a, b):
    """Return a+abs(b), but without calling abs.

    >>> a_plus_abs_b(2, 3)
    5
    >>> a_plus_abs_b(2, -3)
    5
    >>> a_plus_abs_b(-1, 4)
    3
    >>> a_plus_abs_b(-1, -4)
    3
    """
    if b < 0:
        f = lambda x,y:x-y
    else:
        f = lambda x,y:x+y
    return f(a, b)

Q2: Two of Three

Write a function that takes three positive numbers as arguments and returns the sum of the squares of the two smallest numbers. Use only a single line for the body of the function.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

def two_of_three(i, j, k):
    """Return m*m + n*n, where m and n are the two smallest members of the
    positive numbers i, j, and k.

    >>> two_of_three(1, 2, 3)
    5
    >>> two_of_three(5, 3, 1)
    10
    >>> two_of_three(10, 2, 8)
    68
    >>> two_of_three(5, 5, 5)
    50
    """
    return i * i + j * j + k * k-max(i, j, k)*max(i, j, k)

Q3: Largest Factor

Write a function that takes an integer n that is greater than 1 and returns the largest integer that is smaller than n and evenly divides n.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

def largest_factor(n):
    """Return the largest factor of n that is smaller than n.

    >>> largest_factor(15) # factors are 1, 3, 5
    5
    >>> largest_factor(80) # factors are 1, 2, 4, 5, 8, 10, 16, 20, 40
    40
    >>> largest_factor(13) # factor is 1 since 13 is prime
    1
    """
    "*** YOUR CODE HERE ***"
    factor = n-1
    while factor>0:
        if n%factor==0:
            return factor
        factor-=1

Q4: Hailstone

Douglas Hofstadter’s Pulitzer-prize-winning book, Gödel, Escher, Bach, poses the following mathematical puzzle.

1. Pick a positive integer n as the start.
2. If n is even, divide it by 2.
3. If n is odd, multiply it by 3 and add 1.
4. Continue this process until n is 1.

The number n will travel up and down but eventually end at 1 (at least for all numbers that have ever been tried – nobody has ever proved that the sequence will terminate). Analogously, a hailstone travels up and down in the atmosphere before eventually landing on earth.

This sequence of values of n is often called a Hailstone sequence. Write a function that takes a single argument with formal parameter name n, prints out the hailstone sequence starting at n, and returns the number of steps in the sequence:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

def hailstone(n):
    """Print the hailstone sequence starting at n and return its
    length.

    >>> a = hailstone(10)
    10
    5
    16
    8
    4
    2
    1
    >>> a
    7
    >>> b = hailstone(1)
    1
    >>> b
    1
    """
    "*** YOUR CODE HERE ***"
    count = 1
    print(n)
    while n>1:
        if n%2==0:
            n//=2
        else:
            n=n*3+1
        print(n)
        count+=1
    return count

Due by 11:59pm on Wednesday, August 31.

Syllabus Quiz

Q1: Syllabus Quiz

Please fill out the Syllabus Quiz, which is based off of our policies found on the course syllabus.

What Would Python Display? (WWPD)

Q2: WWPD: Control

Use Ok to test your knowledge with the following “What Would Python Display?” questions:

1	python3 ok -q control -u✂️

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

>>> def xk(c, d):
...     if c == 4:
...         return 6
...     elif d >= 4:
...         return 6 + 7 + c
...     else:
...         return 25
>>> xk(10, 10)
______
>>> xk(10, 6)
______
>>> xk(4, 6)
______
>>> xk(0, 0)
______
>>> def how_big(x):
...     if x > 10:
...         print('huge')
...     elif x > 5:
...         return 'big'
...     elif x > 0:
...         print('small')
...     else:
...         print("nothing")
>>> how_big(7)
______
>>> how_big(12)
______
>>> how_big(1)
______
>>> how_big(-1)
______

Hint: Make sure your while loop conditions eventually evaluate to a false value, or they’ll never stop! Typing Ctrl-C will stop infinite loops in the interpreter.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

>>> n = 3
>>> while n >= 0:
...     n -= 1
...     print(n)
______
>>> positive = 28
>>> while positive:
...    print("positive?")
...    positive -= 3
______
>>> positive = -9
>>> negative = -12
>>> while negative:
...    if positive:
...        print(negative)
...    positive += 3
...    negative += 3
______

Q3: WWPD: Veritasiness

Use Ok to test your knowledge with the following “What Would Python Display?” questions:

1	python3 ok -q short-circuit -u✂️

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

>>> True and 13
______
>>> False or 0
______
>>> not 10
______
>>> not None
______
>>> True and 1 / 0 and False
______
>>> True or 1 / 0 or False
______
>>> True and 0
______
>>> False or 1
______
>>> 1 and 3 and 6 and 10 and 15
______
>>> -1 and 1 > 0
______
>>> 0 or False or 2 or 1 / 0
______
>>> not 0
______
>>> (1 + 1) and 1
______
>>> 1/0 or True
______
>>> (True or False) and False
______

Q4: Debugging Quiz

The following is a quick quiz on different debugging techniques that will be helpful for you to use in this class. You can refer to the debugging article to answer the questions.

Code Writing Questions

Q5: Falling Factorial

Let’s write a function falling, which is a “falling” factorial that takes two arguments, n and k, and returns the product of k consecutive numbers, starting from n and working downwards. When k is 0, the function should return 1.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

def falling(n, k):
    """Compute the falling factorial of n to depth k.

    >>> falling(6, 3)  # 6 * 5 * 4
    120
    >>> falling(4, 3)  # 4 * 3 * 2
    24
    >>> falling(4, 1)  # 4
    4
    >>> falling(4, 0)
    1
    """
    "*** YOUR CODE HERE ***"
    i = 0
    res = 1
    while i < k:
        res *= (n-i)
        i += 1
    return res

Q6: Sum Digits

Write a function that takes in a nonnegative integer and sums its digits. (Using floor division and modulo might be helpful here!)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

def sum_digits(y):
    """Sum all the digits of y.

    >>> sum_digits(10) # 1 + 0 = 1
    1
    >>> sum_digits(4224) # 4 + 2 + 2 + 4 = 12
    12
    >>> sum_digits(1234567890)
    45
    >>> a = sum_digits(123) # make sure that you are using return rather than print
    >>> a
    6
    """
    "*** YOUR CODE HERE ***"
    count = 0
    while y > 0:
        count += y % 10
        y = y//10
    return count

Extra Practice

These questions are optional and will not affect your score on this assignment. However, they are great practice for future assignments, projects, and exams. Attempting these questions can be valuable in helping cement your knowledge of course concepts.

Q7: WWPD: What If?

Use Ok to test your knowledge with the following “What Would Python Display?” questions:

1	python3 ok -q if-statements -u✂️

Hint: print (unlike return) does not cause the function to exit.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

>>> def ab(c, d):
...     if c > 5:
...         print(c)
...     elif c > 7:
...         print(d)
...     print('foo')
>>> ab(10, 20)
______
>>> def bake(cake, make):
...     if cake == 0:
...         cake = cake + 1
...         print(cake)
...     if cake == 1:
...         print(make)
...     else:
...         return cake
...     return make
>>> bake(0, 29)
______
>>> bake(1, "mashed potatoes")
______

Q8: Double Eights

Write a function that takes in a number and determines if the digits contain two adjacent 8s.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

def double_eights(n):
    """Return true if n has two eights in a row.
    >>> double_eights(8)
    False
    >>> double_eights(88)
    True
    >>> double_eights(2882)
    True
    >>> double_eights(880088)
    True
    >>> double_eights(12345)
    False
    >>> double_eights(80808080)
    False
    """
    "*** YOUR CODE HERE ***"
    count = 0
    while n > 0:
        if n % 10==8:
            count += 1
        n = n//10
    return count==2

Due by 11:59pm on Wednesday, September 7.

Q1: WWPD: Lambda the Free

Use Ok to test your knowledge with the following “What Would Python Display?” questions:

1	python3 ok -q lambda -u✂️

As a reminder, the following two lines of code will not display anything in the Python interpreter when executed:

1 2	>>> x = None >>> x

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

>>> lambda x: x  # A lambda expression with one parameter x
______
>>> a = lambda x: x  # Assigning the lambda function to the name a
>>> a(5)
______
>>> (lambda: 3)()  # Using a lambda expression as an operator in a call exp.
______
>>> b = lambda x: lambda: x  # Lambdas can return other lambdas!
>>> c = b(88)
>>> c
______
>>> c()
______
>>> d = lambda f: f(4)  # They can have functions as arguments as well.
>>> def square(x):
...     return x * x
>>> d(square)
______
>>> z = 3
>>> e = lambda x: lambda y: lambda: x + y + z
>>> e(0)(1)()
______
>>> f = lambda z: x + z
>>> f(3)
______
>>> x = None # remember to review the rules of WWPD given above!
>>> x
______
>>> higher_order_lambda = lambda f: lambda x: f(x)
>>> g = lambda x: x * x
>>> higher_order_lambda(2)(g)  # Which argument belongs to which function call?
______
>>> higher_order_lambda(g)(2)
______
>>> call_thrice = lambda f: lambda x: f(f(f(x)))
>>> call_thrice(lambda y: y + 1)(0)
______
>>> print_lambda = lambda z: print(z)  # When is the return expression of a lambda expression executed?
>>> print_lambda
______
>>> one_thousand = print_lambda(1000)
______
>>> one_thousand # What did the call to print_lambda return?
______

Q2: WWPD: Higher Order Functions

Use Ok to test your knowledge with the following “What Would Python Display?” questions:

1	python3 ok -q hof-wwpd -u✂️

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42