《编程的乐趣:用Python解算法谜题》解题代码

  • 更新时间:
  • 7075人关注
  • 点击下载

给大家带来的是《编程的乐趣:用Python解算法谜题》解题代码,介绍了关于编程乐趣、Python、算法谜题、Python方面的内容,本书是由人民邮电出版社出版,已被272人关注,由热心网友储奇文 提供,目前本书在Python类综合评分为:7.1分

资源详情相关推荐
《《编程的乐趣:用Python解算法谜题》解题代码》封面
  • 出版社:人民邮电出版社
  • 作者:斯里尼·德瓦达斯(SriniDevada
  • 大小:67.43 KB
  • 类别:Python
  • 热度:870
  • 《Python少儿趣味编程》示例代码和练习解答
  • 自学Python编程基础学习笔记
  • Python神经网络编程
  • 面向ArcGIS的Python脚本编程
  • Python网络编程
  • 编辑推荐

    很少有初学编程的人愿意为了编程而编程,本书创新地通过求解有趣的谜题来教授读者编程,为枯燥的编程学习过程注入了很强的趣味性,谜题是来自真实世界的应用,饶有趣味、易于描述。
    学习编程是从解谜题开始的,在经历一两次失败的解谜尝试后,读者会豁然开朗——可能是一种搜索策略、一个数据结构或一个数学公式,谜题的算法就跃然而出了,剩下的事情就是用Python语法和语义将算法“翻译”成可实现的代码。
    读者只需掌握初级的编程概念,就可以阅读本书。本书包含了21 个谜题,其中很多谜题都家喻户晓并广为流传,如多皇后、汉诺塔、在几秒钟内解决数独问题、六度分隔等。每个谜题后面都配有不同难度的编程习题,读者可以先自行完成编码,再对照本书给出的答案进行探索和提升。

    内容简介

    这是一本介绍通过解决复杂谜题来学习编程的书,书中的代码用Python语言编写。与以往的编程书不同,本书将对代码功能的理解与编程语言语法和语义的理解分离开来,从解每个谜题开始,先给出解谜题的算法,随后用Python语法和语义实现对应的算法,并适当做出解释。本书包含了21个谜题,其中很多谜题都广为流传,如多皇后、汉诺塔、在几秒钟内解决数独问题、验证六度分隔猜想等,每个谜题后面都配有不同难度的编程习题,帮读者加深对相关算法的理解。
    本书在算法谜题的趣味性和计算机编程的实用性之间搭建了一座桥梁,内容饶有趣味,讲述易于理解,适合已掌握初级编程概念并对算法感兴趣的学习者阅读和参考。

    作者简介

    斯里尼·德瓦达斯(Srini Devadas) 麻省理工学院(MIT)计算机科学和人工智能实验室(CSAIL)电子工程和计算机科学教授,自1988年起在麻省理工学院任教。他目前的研究兴趣主要集中在计算机体系结构、计算机安全和应用密码学领域。他因其研究成就获得了2014年IEEE计算机学会技术成就奖、2015年ACM/IEEE理查德·牛顿技术影响力奖和2017年IEEE华莱士·麦克道尔奖。他在MIT教授编程基础、算法导论和算法设计与分析等课程。
    戴 旭 高级项目管理师,从事金融信息化和电子政务工作多年,现为杭州城市大脑研发团队成员,译有《Python快速入门》《Android平板电脑开发秘籍》《编写高性能的.NET代码》等。
    李亚舟 现任职于知乎,负责数据库平台,关注存储、分布式系统、容器等技术,译有《Haskell趣学指南》。
    许亚运 曾任职于高德、饿了么,有多年互联网行业后端开发经验,爱好Python,喜欢探索新技术。

    目录

    谜题1 保持一致 1
    1.1 寻找想法相同的连续人员 2
    1.2 字符串、列表和元组 3
    1.3 从算法到代码 4
    1.4 代码优化 7
    1.5 列表创建与修改 7
    1.6 作用域 8
    1.7 算法优化 9
    1.8 单遍算法 9
    1.9 应用 10
    1.10 习题 11
    谜题2 参加派对的最佳时间 13
    2.1 反复检查时间 14
    2.2 聪明地检查时间 16
    2.3 有序的表示 20
    2.4 习题 20
    谜题3 拥有(需要一点校准的)读心术 22
    3.1 编程完成助手的工作 24
    3.2 编程完成魔术师的任务 28
    3.3 独自掌握技巧 29
    3.4 信息编码 31
    3.5 4张牌的魔术戏法 31
    3.6 习题 32
    谜题4 让皇后保持分离 34
    4.1 系统地搜索 36
    4.2 用二维列表(数组)表示棋盘 38
    4.3 用一维列表(数组)表示棋盘 41
    4.4 迭代枚举 45
    4.5 习题 46
    谜题5 请打碎水晶 47
    5.1 两颗球的高效搜索 48
    5.2 d颗球的高效搜索 49
    5.3 对两颗球减少抛球次数 53
    5.4 习题 54
    谜题6 寻找假币 55
    6.1 分治 55
    6.2 递归分治 57
    6.3 三进制表示 60
    6.4 称量谜题一个流行的变体 61
    6.5 习题 61
    谜题7 跳到平方根 62
    7.1 迭代查找 62
    7.2 折半查找 65
    7.3 二分搜索 67
    7.4 三分搜索 69
    7.5 习题 69
    谜题8 猜猜谁不来吃晚餐 71
    8.1 第 一次尝试 72
    8.2 始终寻找最大选择 73
    8.3 生成所有组合 74
    8.4 移除不友好的组合 76
    8.5 选择最大组合 76
    8.6 优化内存使用 77
    8.7 应用 78
    8.8 习题 79
    谜题9 美国达人秀 81
    9.1 每次生成并测试一个组合 83
    9.2 确定缺少一门绝活的组合 84
    9.3 应用 85
    9.4 习题 86
    谜题10 多皇后 88
    10.1 递归求取最大公约数 88
    10.2 递归获取斐波那契数列 89
    10.3 递归求解N皇后问题 91
    10.4 递归的应用 94
    10.5 习题 96
    谜题11 请满铺庭院 98
    11.1 归并排序 99
    11.2 归并排序的执行与分析 101
    11.3 基线条件即2 × 2庭院 102
    11.4 递归步骤 103
    11.5 列表推导式的基础知识 107
    11.6 美观打印 107
    11.7 另一个满铺谜题 109
    11.8 习题 109
    谜题12 汉诺塔 111
    12.1 汉诺塔的递归解决方案 112
    12.2 相邻汉诺塔的递归解决方案 114
    12.3 与格雷码的关系 117
    12.4 习题 118
    谜题13 没条理的工匠 121
    13.1 分治时的围绕基准点分拣 122
    13.2 与排序算法的关系 123
    13.3 原地划分 126
    13.4 排序也疯狂 129
    13.5 习题 129
    谜题14 再也不玩数独了 131
    14.1 递归式数独求解 132
    14.2 递归搜索过程中的推理 136
    14.3 数独谜题的难度 140
    14.4 习题 141
    谜题15 统计零钱的组合方式 143
    15.1 钞票的递归选取 143
    15.2 消除重复 145
    15.3 用最少的钞票支付 147
    15.4 习题 148
    谜题16 贪心是好事 150
    16.1 贪心算法 151
    16.2 最短历时规则 151
    16.3 最早开始时间规则 151
    16.4 最少冲突规则 152
    16.5 最早结束时间规则 152
    16.6 贪心算法何时有效 157
    16.7 习题 158
    谜题17 字母也疯狂 160
    17.1 每次找到一组变位词 160
    17.2 通过排序对变位词进行分组 162
    17.3 通过散列操作对变位词进行分组 164
    17.4 字典 165
    17.5 用字典对变位词进行分组 167
    17.6 散列表 169
    17.7 习题 171
    谜题18 充分利用记忆 173
    18.1 递归解决方案 173
    18.2 回溯硬币的选择过程 175
    18.3 memoization技术 178
    18.4 避免使用异常 179
    18.5 动态规划 180
    18.6 习题 180
    谜题19 要记得周末 184
    19.1 找到分区 185
    19.2 二分图的判别 187
    19.3 图的表示 189
    19.4 图的着色 192
    19.5 习题 193
    谜题20 六度分隔 195
    20.1 广度优先搜索 197
    20.2 集合 198
    20.3 在广度优先搜索中使用集合 199
    20.4 历史 202
    20.5 习题 203
    谜题21 问题有价 205
    21.1 用字典构造二叉查找树 207
    21.2 字典形式下的二叉查找树操作 209
    21.3 面向对象风格的二叉查找树 212
    21.4 回到谜题:算法 216
    21.5 解决谜题的代码 218
    21.6 多种数据结构的对比 222
    21.7 习题 222

    展开阅读
    精选笔记1:对python数据切割归并算法的实例讲解

    11小时41分钟前回答

    当一个 .txt 文件的数据过于庞大,此时想要对数据进行排序就需要先将数据进行切割,然后通过归并排序,最终实现对整体数据的排序。要实现这个过程我们需要进行以下几步:获取总数据行数;根据行数按照自己的需要对数据进行切割;对每组数据进行排序 最后对所有数据进行归并排序。

    下面我们就来实现这整个过程:

    一:获取总数据的行

    def get_file_lines(file_path):
     # 目标文件的路径
     file_path = str(file_path)
     with open(file_path, 'rb') as file:
      # 定义行数
      i = 0
      while True:
       # 一次读取一行数据
       line = file.readline()
       if not line :
        break
       else:
        # 每读一行,行数加一
        i += 1
       #设置进度条,每当i读取1000000行时打印一次i
       # 每当读取1000000的整数倍行时,打印行数(进度条)
       if i % 1000000 == 0:
        print(i)
      # 打印总行数
      print(i)
      return i
    

    二:对数据进行切割

    # 定义均等切割函数,num是待切割的文件的行数的值,n为切割份数,file_path是待切割的文件,file_dir是切割好的文件写入的目录
    def evg_split(num, n, file_path, file_dir):
     last_list = []
     # 如果样本刚好可以整除为n份
     if num % n == 0:
      for i in range(n):
       # 则直接将样本分为n分没份对应num/n个
       last_list.append(num / n)
     # 如果不能整除
     if num % n != 0:
      # 如果不能整除,则先将num整除n-1并取n-1份,余下的单独做一份
      evg = (num - num % n) // (n - 1)
      for i in range(n):
       last_list.append(evg)
      last_list.append(num % (n - 1))
     print(last_list)
     # return last_list
     # 对应于切割后的每一份数据
     with open(file_path, 'rb') as path:
      for i in range(n):
       # 创建临时文件
       tmp_file = file_dir + str(i) + '.txt'
       # 打开临时文件,将内容一条一条的写入
       file = open(tmp_file, 'wb')
       for j in range(int(last_list[i])):
        line = path.readline()
        file.write(line)
        print(line)
       print('------------')
       file.close()
    

    三:对每组数据进行排序的内容由读者根据自身数据需要进行排序,下面直接介绍归并排序

    四:归并排序

    def merge( mylist1, mylist2, file1):
     while len(mylist1) > 0 and len(mylist2) > 0:
      if mylist1[0]<mylist2[0]:
       with open(file1,'a') as file:
        file.write(str(mylist1[0]))
        del mylist1[0]
      elif mylist1[0] > mylist2[0]:
       with open(file1,'a') as file:
        file.write(str(mylist2[0]))
        del mylist2[0]
      else:
       with open(file1,'a') as file:
        file.write(str(mylist1[0]))
        file.write(str(mylist2[0]))
        del mylist1[0]
        del mylist2[0]
     with open(file1, 'a') as file:
      for i in mylist1:
       file.write(str(i))
      for i in mylist2:
       file.write(str(i))
    

    总结:对于一个大型数据文件,我们可以将其切割成若干个小型的数据文件,然后分别的这些小型的数据文件进行排序,最后使用归并排序将这些数据文件写入到一个总体文件中,从而实现了对这个大型数据文件的排序。

    以上这篇对python数据切割归并算法的实例讲解就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持码农之家。

    展开阅读

    Python相关资源

    • 《Python编程金典》读书笔记

      大小:103.17 MBPython编程

      立即下载
    • Python编程(第四版) 上册

      Python编程(第四版) 上册

      当掌握Python的基础知识后,你要如何使用Python? Python编程(第四版) 为这门语言的主要应用领域提供了深度教程,譬如系统管理、GUI和Web,并探索了其在数据库、网络、前端脚本、文本处理等方

      大小:234.3 MBPython编程

      立即下载
    • Python网络编程基础

      Python网络编程基础

      大小:26 MBPython基础

      立即下载
    • Python计算机视觉编程

      Python计算机视觉编程

      大小:4.8 MBPython编程

      立即下载
    • Python编程基础

      Python编程基础

      本书以任务为导向的编写模式,全面介绍了Python编程基础及其相关知识的应用,以及如何利用Python的知识解决部分实际问题

      大小:6 MBPython入门

      立即下载
    • Python渗透测试编程技术:方法与实践

      Python渗透测试编程技术:方法与实践

      《Python渗透测试编程技术:方法与实践》由资深的网络安全教师撰写,内容围绕如何使用目前备受瞩目的Python语言进行网络安全编程展开。《Python渗透测试编程技术:方法与实践》从Python的基础讲起,系统讲述了网络安全的作用、方法论,Python在网络安全管理上的应用,以及Python在实现这些应用时相关的网络原理和技术。

      大小:167.2 MBPython编程

      立即下载

    学习笔记

    23小时30分钟前回答

    Python基于递归算法实现的汉诺塔与Fibonacci数列

    这篇文章主要介绍了Python基于递归算法实现的汉诺塔与Fibonacci数列,结合实例形式分析了汉诺塔与Fibonacci数列的递归实现技巧,需要的朋友可以参考下 本文实例讲述了Python基于递归算法实现的汉诺塔与Fibonacci数列。分享给大家供大家参考,具体如下: 这里我们通过2个例子,学习python中递归的使用。 1. 找出Fibonacci数列中,下标为 n 的数(下标从0计数) Fibonacci数列的形式是这样的:0,1,1,2,3,5,8,13…… ① 使用while循环 ,python2代码如下: def fib(n): a,b=0,1 count=0 while countn: a,b=b,a+b count=count+1 print a 运行结果如下: fib(0) 0 fib(1) 1 fib(2) 1 fib(3) 2 fib(4) 3 fib(5) 5 ② 使用递归(递归必须要有边界条件) ,python2代码如下:……

    14小时11分钟前回答

    基于Python递归函数实现二分查找算法

    一、初始递归 递归函数:在一个函数里在调用这个函数本身。 递归的最大深度:998 正如你们刚刚看到的,递归函数如果不受到外力的阻止会一直执行下去。但是我们之前已经说过关于函数调用的问题,每一次函数调用都会产生一个属于它自己的名称空间,如果一直调用下去,就会造成名称空间占用太多内存的问题,于是python为了杜绝此类现象,强制的将递归层数控制在了997(只要997!你买不了吃亏,买不了上当...). 拿什么来证明这个998理论呢?这里我们可以做一个实验: def foo(n): print(n) n += 1 foo(n)foo(1) 由此我们可以看出,未报错之前能看到的最大数字就是998.当然了,997是python为了我们程序的内存优化……