自描述语句

初始化

那么先把句子模板确定下来，然后往里面套总字数和完整的词频分布。这里我对句子结构做了些简化，假设我想要生成的句子是这样的：

这一句话一共有__个字，__个“__”，__个“__”，……。

先确定可能会出现的汉字集合，显然目前能看到的有“这”、“一”、“句”、“话”、“共”、“有”、“个”、“字”。另外预计会出现的就是所有的数词了。因为字数比较少，所以暂时就不用考虑“零”、“百”、“千”等字，只要考虑“一”到“十”即可。

关于把数字用中文表示出来的方法，参见之前的博文 将整数数字转换成中文 ，非常简单的程序，这里不再重复。

如果你的心算笔算能力还不错，下面的过程用一张纸和一支笔就能搞定了。首先列出所有可能出现的汉字，并且所有字的初始计数均为 0。总字数也要记录在案，初始值也是 0。列出来就是这样的表格，其中最后一列“TC”表示总字数。

第一次迭代

接下来对句子模板做第一次扫描，并根据情况更新相应汉字的字数和总字数。处理的方法很简单，每看到一个汉字，就要给它的计数加 1，总字数加 1。任何一个汉字，如果计数从 0 变成 1，即第一次遇到它，就要再给它的计数和总字数加 1，同时对“个”字执行同样的操作。把这个过程叫做“increase”操作，即：

1
2
3
4
5
6
7
8

def increase(character c):
    if c.count == 0:
        c.count += 2
        total.count += 2
        increase('个')
    else:
        c.count += 1
        total.count += 1

比如首先看到“这”字，当前计数为 0，执行 increase 操作给它的个数加 2，总字数加 2，再对“个”字执行 increase 操作。由于“个”字此时的计数也是 0，因此它的计数直接加到 2，总字数加 2，这时注意还要再对“个”字执行一次 increase 操作。但第二次对“个”字执行 increase 操作时，由于其当前计数是 2 不是 0，所以直接给计数和总字数分别加 1 就行了。处理完第一个字“这”之后，计数情况为：2 个“这”，3 个“个”，总字数 5。

然后是“一”字，同样执行 increase 操作，计数增加 2，总字数增加 2，再对“个”字执行 increase，效果是其字数和总字数又分别加 1。完成后的计数情况为：2 个“这”，4 个“个”，2 个“一”，总字数 7。

用类似的办法把后面的“句”、“话”、“一”、“共”、“有”、“个”、和“字”都处理完，最后得到如下的计数情况：

第二次迭代

下一轮就把所有的计数都翻译成中文，并统计它们所带来的计数改变。比如第一个计数是 3，就要对“三”字执行 increase 操作。然后是 10，对“十”字做 increase 操作。……。最后总字数 25，分别对“二”、“十”和“五”操作即可。处理完后得到新的一轮计数：

第三次迭代

对比这两组计数，发现：

• “一”、“这”、“句”等字的计数没有发生变化，并且这些数字对应的汉字已经全部统计过了，所以不必对它们做别的处理。
• “二”、“三”、“十”等字，计数从没有变成了若干个，就要用跟刚才一样的方法，把这些数字翻译成中文并增加相应汉字的计数。
• “个”字和总字数，我本来是想加入 10 和 25，但现在分别是 14 和 44，所以要把刚才加入的 10 和 25 都去掉，换成 14 和 25。比如把 10 换成 14，先对 “十”字做 decrease 操作，然后分别对“十”和“四”字执行 increase 操作。decrease 的过程如下所示，注意，由于每个字的计数都是直接从 0 涨到 2 的，所以也会直接从 2 降到 0。

1
2
3
4
5
6
7
8

def decrease(character c):
    if c.count == 2:
        c.count -= 2
        total.count -= 2
        decrease('个')
    else:
        c.count -= 1
        total.count -= 1

这样处理完后得到的新一轮计数为：

周而复始

之后用同样的方法一轮一轮地迭代，结果如下（包含从初始化开始的每次迭代，第一列 ID 表示迭代次数）：

很高兴地发现，第十次的结果和第十一次的结果是完全一致的，这时候就没有任何操作可做了，实际上算法也就终止了。显然，通过这组数据生成的句子就是符合要求的自我统计的句子：

这一句话一共有五十九个字，四个“一”，十一个“二”，二个“三”，三个“四”，二个“五”，二个“七”，二个“九”，四个“十”，十七个“个”，二个“这”，二个“句”，二个“话”，二个“共”，二个“有”，二个“字”。

算法

总的看来，一轮一轮迭代的处理方法是这样的：

1. 所有汉字的计数和总字数均初始化为 0；
2. 遍历句子模板中的每一个汉字，对其计数做“increase”操作，得到一组新的计数；
3. 比较当前计数数组与前一轮计数数组中的每一项：
   1. 如果二者一致，无操作；
   2. 否则，对前一轮的数值对应的每个汉字执行 decrease 操作（0 除外），对当前数值对应的每个汉字执行 increase 操作（0 除外）；
4. 重复步骤 3，直到相邻两轮计数数组完全一致。

其中 increase 和 decrease 操作均如前所述，不再重复了。

问题

换一个例子看看，把上面的句子模板开头的“这一句话”换成“新的一句话”，即：

新的一句话一共有__个字，__个“__”，__个“__”，……。

按照同样的算法一轮一轮迭代处理，却永远都无法终止。仔细看了看，发现计数数组会在几组值之间不断地反复，却怎么都无法收敛。具体的数据就不列出来了。

想想也是，上面的算法只是保证了，如果收敛，得到的一定是满足条件的解，却完全无法保证收敛。

解决

想到一个比较简单的变通方法就是修改之前的 decrease 操作。本来一个汉字如果是第一次出现，计数就直接从 0 涨到 2，如果要去掉，也直接从 2 回到 0。这样避免了出现“一个 XX”的情况。这其实不是必须的，如果把条件放宽，允许出现“一个 XX”（仍然符合自我统计的要求，只是显得有点儿多余），可以让 decrease 操作把计数从 2 降到 1。写出来大概是这样：

1
2
3

def decrease(character c):
    c.count -= 1
    total.count -= 1

根据这个规则重新迭代计算，结果如下表示，发现到第 9 次迭代后就收敛完毕。

这样得到的自统计句子是：

新的一句话一共有六十六个字，五个“一”，十一个“二”，三个“三”，二个“四”，二个“五”，三个“六”，一个“八”，二个“九”，四个“十”，十九个“个”，二个“新”，二个“的”，二个“句”，二个“话”，二个“共”，二个“有”，二个“字”。

其中比较特殊的就是“一个‘八’”，句子中确实只有这个地方出现了 1 个“八”字，其他字的个数和总字数也都没错，但这个“一个‘八’”没有什么实际的意义。不引入这种“一个 XX”能否找到符合这个模板的解呢？目前我还没有明确的答案。

问题

很快就又遇到了新的麻烦，比如把句子模板开头换成“这句话”，即：

这句话一共有__个字，__个“__”，__个“__”，……。

算一下就会发现，不论是像开始那样直接从 2 减到 0，还是像刚才那样从 2 减到 1，全都会陷入无法终止的迭代。

实际上随便想一个句子模板出来，十有八九会是这样的，能像前两个例子那样收敛出结果的非常少。这可怎么办呢？

解决

想了一个简单粗暴的办法，效果还不错。前面提到 decrease 操作有两个方案，区别在于对于计数 2 做 decrease 的时候，要么直接减到 0，要么减到 1。那么一个直接的想法就是不要那么死板，让这个抉择可以随机的使用，即有一半的概率会直接减到 0，另一半的概率是减到 1。这个不确定性因素实际上是给迭代过程带来了一点儿干扰。如果按照某个确定的方案，迭代过程很容易陷入无穷尽的震荡，这时候如果引入一下随机的干扰，就有可能打破稳定的震荡，使得迭代过程偏离当前的动态平衡点，或许就刚好落在一个收敛的位置上了。

改造后的 decrease 操作大致是这样的：

1
2
3
4
5
6
7
8

def decrease(character c):
    if c.count == 2 and random.choice(0, 1) == 0:
        c.count -= 2
        total.count -= 2
        decrease('个')
    else:
        c.count -= 1
        total.count -= 1

用上面遇到问题的模板来说，以 3 作为随机数种子时可以得到这样的迭代过程，其中第 9 次和第 10 次的结果一致，是一个可行解。

把计数结果带入到模板中，得到一个自统计句子：

这句话一共有五十八个字，三个“一”，十一个“二”，三个“三”，二个“四”，二个“五”，二个“七”，二个“八”，四个“十”，十七个“个”，二个“这”，二个“句”，二个“话”，二个“共”，二个“有”，二个“字”。

思考一下随机干扰对迭代收敛的作用，可以想见，这个随机选择进行的越频繁，迭代过程就越不稳定，遇到收敛点的概率相对也就越大。但如果迭代已经陷入到一个稳定震荡的状态，在整个振荡周期内却始终没有用到这个随机干扰，那还是没有办法跳出死循环。所以实际的程序会通过某种方式（最简单的就是设置最大迭代次数）判断是否陷入死循环并强制终止当前的迭代过程，从头开始重新走一遍。由于早期计数比较小，很容易遇到需要从 2 减到 0 或 1 的情况，大量的随机干扰可能会使得整个迭代过程完全变样，有可能会得到收敛的解。