我的天

明明想好了，要早点回宿舍动感单车，但是还是不知不觉的拖到了9点多。明明想好了回到宿舍就不再开电脑做VBA相关的东西，结果还是忍不住，我满脑子都是那个玩意。所以周四的晚上，我又只是匆匆忙忙我完成了一个30分钟的动感单车课程。理论上周三对我来说是动感单车的大课，但实际上我只上了一节15分钟的Y5强度，虽然强度很够意思，但持续时间太长短。周四晚上，本来我打算好好干一场，结果又被时间所限。

周四晚上11点多我才开始研究把字符串分组连接的数组。思路很简单，就是建立一个字典，如果键是相同的，就把键值通过顿号连接起来。这只需要一个循环就能做到，但我在那里磨叽了好久，最大的原因是我没有踏踏实实地手动进行前几轮的试验，而是大概凭感觉写好就丢给程序，于是一次又一次地被程序报错。有些时候是下标超限。有些时候是出来的结果完全不是我想要的。最终我整出来了，但就好像只是运气，碰对了。最让我觉得自己很无语的是，明明我在里面设置了if，如果这个键跟上一个键的内容是一样的，那么就把这个数值通过顿号连接到上一个键的键值那里，但是我却一直没有写 else，实际上我只需要再写一条，余下的就把这个数值成为这个键的键值。我处理的是非常典型的字典，没有比这更近更简单的了，但是我却在那里兜圈子，我自己也觉得自己很无语。

搞定了这个字典以后，我又试着把之前已经汇总好的表跟这个字典合并起来。思路也是非常简单，因为我只需要在原来的那个表那里加一列。当那个字典里面的键等于这个表某一列的某个数据，那么就把这个键值放在数据所在行最后一列的下一列你。结果我折腾了半天，为什么就是没有结果呢？最后发现我一直被数组的最大值给搞迷糊了。什么是1，什么2。通常来说我喜欢从1开始计数，但实际上记录集直接输出来数组是从0开始的，而且那个行列结构刚好和从单元格获取数据形成数组是一个转置的关系，本来1和2就已经迷糊，然后还得实际上得2变成1。因为我要新增一列，所以应该是加在什么地方呢？大半夜脑子本来就不太好使，再加上这种转置加1就让我更加迷糊。所以我已经不记得系统弹出过多少次下标超限。最后还是那一招，当系统说我超限的时候，我用鼠标看一下参数，果然发现了我进行for循环的那些设置都是乱来的，虽然肯定就是两个循环一次互换的操作，但里面的i，j我乱写，于是我又在那里折腾了好长时间。搞笑的是那个合并的数组的确没有问题了，在用Ctrl+F8运行的时候，我的确看到那个数组的里面已经齐全了我要的东西，但为什么输出到工作表的单元格就是看不到我想要的呢？最终发现又是数组最大行与列的问题。显然我的大脑非常不善于处理这个。因为我需要的那个数据在我单元格输出区域以外的地方，所以工作表里死活看不到。如果我一开始就耐心点的，我就不需要走这些弯路，但是这两个数组方案我都是一开始抱着大概差不多的心态瞎写的。

学习C语言的时候，我没有现在那么好的调试工具，现在的调试工具时的确强大了，尤其是如果我在VSCode里面写python，但就是因为这些东西很强大，它们可以把我的问题描述得很清楚，所以一定程度上我也习惯了大概差不多瞎写，出现什么问题再去改，但是这种习惯如果用在VBE里就会让我经常碰壁、非常绝望。

昨天研究了一个晚上的Excel。其实也没折腾出什么高端的东西出来，都是一些大路的功能。用我以前的方式，也能实现，不过昨天晚上我把它更进一步，让使用者更直观简单。之所以要改进自己，很重要的一个因素是我发现单位的仓号命名会导致筛选一些比较小的仓号的时候如果用输入的方式会误杀。比如说我选1仓的时候，当我输入1，那些什么11，13，16全部都会中招。要避免出现这种低级错误，最简单的方法我觉得是全部用两位数字，甚至直接用上三位。001，002这种东西不会在999之内重叠。但其实，以我们单位的占地，应该达不到三位数字。一个10万吨的立筒仓群里面有18个立筒仓，10个星仓。如果有5个以上的立筒仓群，两位数的命名就会出状况，但显然我们单位没有那么多的地方建这么多组立筒仓。至于浅圆仓，至少是1万吨一个，现在新建的那些甚至达到了2万吨。再怎么牛逼位，我们单位也规划不下100个浅圆仓。因为这就意味着起码有150万吨以上的仓容。加上立筒仓，要达到200万吨几乎不可能。以我们单位的占地，以及所建厂房的仓容，即便到达200万吨也用不上三位数字的编码。

以普通人的思路去考虑，从1-99编码是再正常不过的事，但是从一个不重叠数字的角度考虑，如果用的是CTRL+F的搜索，尚且可以选择单元格匹配，但是如果那是一个列表里面的筛选项，效果就会很尴尬。当然，也有一个不会中招的方式，就是用手动单选。如果你手头上有100个仓，你要单选其中一个。无论如何，这都比不上你直接输入数字快。点到某个单元格的下拉菜单里面去挑选某个东西是一个非常没有效率的做法。昨晚我突然领会到在这种时候，我需要使用切片器。其实切片器跟传统的筛选没什么区别，但是切片器可以直接放在工作表外面，你可以把它拉得很长。在普通的下拉菜单里面，某个视图你可能只有5-10个选项，但是只要你的电脑屏幕足够大，你的切片器就可以很大，极限情况下，一列估计能排下20个。5个选项和20个选项的区别在于下拉的滚动条被大大缩小了。Office 2003没有切片器，我不知道2010有没有，因为我几乎没有用过2010，但我知道2013年以后的Office具备这种功能，除了切片器以外，还有日程表。日程表这个东西我试用了一下，感觉能实现我的某些功能，但是为什么那个东西只能用滑动条而不能手动输入数据控制呢？如果要做到自由的控制，难道我要为那个日程表写个宏？

洗澡的时候我一直在考虑。计算堆存费这个东西最根本的是判断起始时间。决定了开始与结束，中间的那些东西就只是重复得做同样的事情而已。可悲的是，我脑子里只有python，没有Excel VBA。几乎不假思索地，我就已经设定好了有了开始结束以后，中间的循环在python应该怎么写。虽然我完全不知道要怎么让python读取我的Excel文件。python能实现的功能，Excel VBA应该也能实现，顶多是语句比较麻烦而已。做好了前期准备以后，计算那些东西就只是一个秒杀的过程。

当别人在想用什么程序可以解放自己，策划这要为之付多少钱的时候，我想的却是怎么自己写一个程序，解放生产力。

前面还在沾沾自喜我写出来的脚本运行效率战胜了参考答案，但这道题目我是看着参考答案都不知道他们在说什么。如果只是一个词，我的确可以列举出它一次减少一个字母可以出现的所有可能，但怎么知道上一层可能和这一层的哪个配套？？？我花了2天时间去研究、消化答案。一边搞清楚答案为什么这样，另一边考虑有没有其它容易吃透的表达方式。这道题之所以让我非常纠结，根本的原因是我想不透到底我可以用什么手段实现。没有可以实现的逻辑，就不会有可行的编程。

Exercise 4: Here’s another Car Talk Puzzler (http://www.cartalk.com/content/puzzlers): What is the longest English word, that remains a valid English word, as you remove its letters one at a time? Now, letters can be removed from either end, or the middle, but you can’t rearrange any of the letters. Every time you drop a letter, you wind up with another English word. If you do that, you’re eventually going to wind up with one letter and that too is going to be an English word—one that’s found in the dictionary. I want to know what’s the longest word and how many letters does it have? I’m going to give you a little modest example: Sprite. Ok? You start off with sprite, you take a letter off, one from the interior of the word, take the r away, and we’re left with the word spite, then we take the e off the end, we’re left with spit, we take the s off, we’re left with pit, it, and I. Write a program to find all words that can be reduced in this way, and then find the longest one. This exercise is a little more challenging than most, so here are some suggestions: You might want to write a function that takes a word and computes a list of all the words that can be formed by removing one letter. These are the “children” of the word. Recursively, a word is reducible if any of its children are reducible. As a base case, you can consider the empty string reducible. The wordlist I provided, words.txt, doesn’t contain single letter words. So you might want to add “I”, “a”, and the empty string. To improve the performance of your program, you might want to memoize the words that are known to be reducible. Solution: http://thinkpython2.com/code/reducible.py.

最终，我觉得自己总算消化了，顺便画了个思维导图帮助大家理解到底分解到什么程度叫做完成，什么状态叫做分解失败。[”]和[]是两种不同的东西！！！！！！

is_reducible()是最关键的函数，memos用在这里，memos初始设置了known[”] = [”]也很关键，这是个守卫模式，没有守卫is_reducible()根本没法玩。这个脚本里的5个函数，除了一开始的创建字典函数，其余函数都可以单独测试，把一个固定单词放进去脚手架测试，可以帮助理解。cut_letter()，is_reducible()和all_reducible()这三个函数最终返回的都是列表，它们的样式都是类似的。希望我理解过程中的注释能帮助到有需要的人。PS一句：参考答案的打印效果让人很晕，我修改版的打印效果很美丽:)

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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

from time import time
def set_dict(fin):
    d = {}
    for line in fin:
        word = line.strip()
        d[word] = 0
    for word in ['a', 'i', '']:
        d[word] = 0
    return d
def cut_letter(word, d): # 生成子单词，返回列表
    l = []
    for i in range(len(word)):
        new_word = word[:i] + word[i+1:]
        if new_word in d:
            l.append(new_word)
    return l # ['']长度为1，[]长度为0，无子词不能分解时返回[]，'a'返回['']
def is_reducible(word, d): # 判断能否生成无限子单词，返回列表
    if word in known: # 守卫模式下，''空字符串被列入初始字典，不列入永远会被递归到[]，无果
        return known[word]
    # if word == '': # 不用memos的时候，需要加入这句守卫
    #     return ['']
    l = []
    for new_word in cut_letter(word, d):
        if len(is_reducible(new_word, d)) > 0:
            l.append(new_word)
    known[word] = l
    return l
def all_reducible(d): # 收集所有无限子单词的单词，返回列表
    l = []
    for word in d:
        if len(is_reducible(word, d)) > 0: # 有列表，即有无限子单词
            l.append((len(word), word)) # 列表含有N个元组，元组里有2个元素，1为单词的字母数量，2为单词本尊
    new_l = sorted(l, reverse = True) # 每次减少一个字母，单词的字母越多当然就能降解出越多层了
    return new_l
def word_list(word): # 打印单词及子单词
    if len(word) == 0: # 最后一个进入is_reducible()的是['']，对应l[0]为无，打印结束
        return
    print(word)
    l = is_reducible(word, d) # 因为是被鉴定过词汇表里的词，所以必定有无限子单词
    word_list(l[0]) # 子单词有多个时只选第1个
known = {} # memos实际上只在is_reducible()起作用，除了提高效率，还能用作守卫
known[''] = [''] # 因为is_reducible()返回的是列表，所以即便是空字符串，键值也必须是列表！
fin = open('words.txt')
start = time()
d = set_dict(fin) # 普通的字典，键为单词，键值为0
words = all_reducible(d) # 列表，元组，2元素
for i in range(5):
    word_list(words[i][1]) # 列表里第某个元组的第2个元素
end = time()
print(end - start)
# complecting
# completing
# competing
# compting
# comping
# coping
# oping
# ping
# pig
# pi
# i
# twitchiest
# witchiest
# withiest
# withies
# withes
# wites
# wits
# its
# is
# i
# stranglers
# strangers
# stranger
# strange
# strang
# stang
# tang
# tag
# ta
# a
# staunchest
# stanchest
# stanches
# stances
# stanes
# sanes
# anes
# ane
# ae
# a
# restarting
# restating
# estating
# stating
# sating
# sting
# ting
# tin
# in
# i
# 0.6459996700286865
# 无memos 1.5830001831054688， 有memos 0.6459996700286865

循环和递归，对路人甲来说那是差不多的玩意，反正就是在那里转圈圈。但是，虽然已经认识递归好些时间了，但我依然非常害怕这个存在。之所以害怕递归，是因为我很难想象到底递归什么时候才是个头，而我又非常明白，达不到递归的头，就不能把东西返回出来，得到我想要的答案。这个玩意就像一个无底洞。于是每次当我遇到递归，我都会在那里瑟瑟发抖，大概要克服这个，我需要非常大量的递归练习，让理解这个东西变成我的条件反射。

我不知道，在实际编程过程之中，到底会不会真的经常用到递归这种恐怖的东西。在Think Python 2这本书里面，很早就已经在说递归。还记得递归这种东西他们是结合小海龟一起折腾人的。现在回想起来，这或许是个正确的选择。因为小海龟是一个画图的东西，会让你用更直观地去理解递归到底在做什么。我还记得他们要我们理解的那个树杈和雪花。树杈那个图还算是一个比较正经的东西，雪花那个图案，简直是让我头皮发毛。每次说起递归，我就会想起小时候家里那个卷纸筒。黄色的卷纸筒上面，有一个卡通熊猫在拉卷纸的图案，而它拉的那个卷纸筒上面也贴着一个熊猫在拉卷纸。每次看到纸筒上的那个图案，我就会盯着看，然后脑子就会不断想象，熊猫卷纸筒，熊猫卷纸筒……想着想着甚至会觉得好恐怖，到底什么时候才是个头！这跟俄罗斯的套娃不一样。我总觉得，俄罗斯套娃无论套子多精细，总会有个头，但是，拉卷纸的熊猫，对我来说简直是个噩梦。我觉得，拉卷纸的熊猫是递归，而套娃是循环。

昨天我花了大半天的时间查单位的某些账本。查出了一箩筐的问题，我不知道为什么之前他们检查居然没发现。绝大多数都是弱智的问题，不弱智的问题则代表了他们做事的时候根本没用脑子去思考。那些莫名其妙的错误几乎到达了一种人人都有永不落空的境地。这也实在是太强大了吧！归根到底，是因为根本没有人去统一他们。每个人都看着那个规则，每个人都有自己的理解，又或者他们没看规则，只是按照上一个人的方法去做，但是他们对上一个人的做法的理解又各不相同。情况就像一个人不断地传话给下一个人，当人数传到一定程度的时候，原本的故事就会变得乱七八糟。我还记得第一次发现这个现象是在翡翠台的综艺节目超级掌门人上。这是我第一次认真地去揪他们的错误。不只是核对核心数据，也看了格式上到底合不合要求。有时我真的不明白他们，这样干活，他们觉得自己对得住自己的工资吗？他们晚上为什么居然能睡得着觉？换个说法，为什么他们这般吊儿郎当却没有东西惩罚他们？即便不是金钱上的惩罚，但起码也要让他们心里不好过，比如批评一下。但或许批评根本无效，就像你妈妈骂你一样，左耳进右耳出，就只是一阵耳边风。既然不能用惩罚，能不能用奖励的机制呢？在这个单位，爬上去的那些人你也说不上到底牛逼在哪里。没有惩罚，也没有奖励，于是也就可以理解，为什么他们会这样。

不是人人都能自律，对不自律的人必须用铁手腕。

觉得自己虽然见过递归，但几乎不用，不逼着我我都不用，循环用得越来越遛。前两题我和参考答案得出的结论一致，最后一题，我觉得参考答案有问题。下面的都是我的脚本。下面要用到的words.txt在这里。

Exercise 7：This question is based on a Puzzler that was broadcast on the radio program Car Talk: Give me a word with three consecutive double letters. I’ll give you a couple of words that almost qualify, but don’t. For example, the word committee, c-o-m-m-i-t-t-e-e. It would be great except for the ‘i’ that sneaks in there. Or Mississippi: M-i-s-s-i-s-s-i-p-p-i. If you could take out those i’s it would work. But there is a word that has three consecutive pairs of letters and to the best of my knowledge this may be the only word. Of course there are probably 500 more but I can only think of one. What is the word? Write a program to find it. Solution: http://thinkpython2.com/code/cartalk1.py.

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

def double_letter(word):
    num = 0
    i = 0
    if len(word) >= 6:
        while i < len(word)-1:
            if word[i] == word[i+1]: 
                num = num + 1
                i = i + 2
            elif i > 2 and word[i-2] != word[i-3]:
                break
            else:
                i = i + 1
        if num == 3:
            print(word)
fin = open('words.txt')
n = 0
for line in fin:
    word = line.strip()
    double_letter(word)
# bookkeeper
# bookkeepers
# bookkeeping
# bookkeepings

Exercise 8: Here’s another Car Talk Puzzler: “I was driving on the highway the other day and I happened to notice my odometer. Like most odometers, it shows six digits, in whole miles only. So, if my car had 300,000 miles, for example, I’d see 3-0-0-0-0-0. “Now, what I saw that day was very interesting. I noticed that the last 4 digits were palindromic; that is, they read the same forward as backward. For example, 5-4-4-5 is a palindrome, so my odometer could have read 3-1-5-4-4-5. “One mile later, the last 5 numbers were palindromic. For example, it could have read 3-6-5-4-5-6. One mile after that, the middle 4 out of 6 numbers were palindromic. And you ready for this? One mile later, all 6 were palindromic! “The question is, what was on the odometer when I first looked?” Write a Python program that tests all the six-digit numbers and prints any numbers that satisfy these requirements. Solution: http://thinkpython2.com/code/cartalk2.py.

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

def is_palindrome(word):
    if word[::-1] == word:
        return True 
def test_palindrome(number):
    if is_palindrome(str(number)[2:]):
        if is_palindrome(str(number+1)[1:]):
            if is_palindrome(str(number+2)[1:1]):
                if is_palindrome(str(number+3)):
                    return True
for number in range(100000, 999999):
    if test_palindrome(number):
        print(number)
# 198888
# 199999

Exercise 9: Here’s another Car Talk Puzzler you can solve with a search: “Recently I had a visit with my mom and we realized that the two digits that make up my age when reversed resulted in her age. For example, if she’s 73, I’m 37. We wondered how often this has happened over the years but we got sidetracked with other topics and we never came up with an answer. “When I got home I figured out that the digits of our ages have been reversible six times so far. I also figured out that if we’re lucky it would happen again in a few years, and if we’re really lucky it would happen one more time after that. In other words, it would have happened 8 times over all. So the question is, how old am I now?” Write a Python program that searches for solutions to this Puzzler. Hint: you might find the string method zfill useful. Solution: http://thinkpython2.com/code/cartalk3.py.

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
45
46
47
48
49
50
51
52
53
54
55
56
57
58

year = 99
meet = int(input('how many times have we met?(1-8): '))
print('mom born me at', '\t','my age', '\t',"mon's age")
for i in range(10, 80): # 假设你妈生你的最低年龄是10，最高年龄是80
    n = 0
    for age in range(1, year):
        if age < int(str(age).zfill(2)[::-1]) and int(str(age).zfill(2)[::-1]) - age == i:            
            # print(i, '\t\t', age, '\t\t', str(age).zfill(2)[::-1])             
            n = n + 1
            if n == meet:
                print(i, '\t\t', age, '\t\t', str(age).zfill(2)[::-1])
 
# how many times have we met?(1-8): 6
# mom born me at   my age          mon's age
# 18               57              75
# 27               58              85
# 36               59              95
 
# how many times have we met?(1-8): 8
# mom born me at   my age          mon's age
# 18               79              97
 
# mom born me at   my age          mon's age
# 18               2               20
# 18               13              31
# 18               24              42
# 18               35              53
# 18               46              64
# 18               57              75
# 18               68              86
# 18               79              97
# 27               3               30
# 27               14              41
# 27               25              52
# 27               36              63
# 27               47              74
# 27               58              85
# 27               69              96
# 36               4               40
# 36               15              51
# 36               26              62
# 36               37              73
# 36               48              84
# 36               59              95
# 45               5               50
# 45               16              61
# 45               27              72
# 45               38              83
# 45               49              94
# 54               6               60
# 54               17              71
# 54               28              82
# 54               39              93
# 63               7               70
# 63               18              81
# 63               29              92
# 72               8               80
# 72               19              91