@lincyaw/skills 1.0.0-rc.2 → 1.0.0-rc.21

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (38) hide show
  1. package/README.md +1 -1
  2. package/package.json +2 -3
  3. package/skills/index.json +9 -18
  4. package/skills/presmium-animate/SKILL.md +4 -2
  5. package/skills/presmium-animate/gallery/algorithms/lecture.json +171 -115
  6. package/skills/presmium-animate/gallery/anime/scenes/kmeans-seeded.ts +2 -1
  7. package/skills/presmium-animate/gallery/craft/lecture.json +109 -57
  8. package/skills/presmium-animate/gallery/data/lecture.json +711 -175
  9. package/skills/presmium-animate/gallery/emphasis/lecture.json +321 -79
  10. package/skills/presmium-animate/gallery/films/lecture.json +36 -10
  11. package/skills/presmium-animate/gallery/lengths/lecture.json +23 -88
  12. package/skills/presmium-animate/gallery/math-ml/lecture.json +238 -159
  13. package/skills/presmium-animate/gallery/paths-3d/lecture.json +74 -64
  14. package/skills/presmium-animate/gallery/product/lecture.json +27 -3
  15. package/skills/presmium-animate/gallery/story/lecture.json +23 -90
  16. package/skills/presmium-animate/gallery/structure/lecture.json +104 -65
  17. package/skills/presmium-animate/gallery/text/lecture.json +115 -63
  18. package/skills/presmium-animate/gallery/timeline/lecture.json +106 -187
  19. package/skills/presmium-animate/gallery/timeline/scenes/bubble.ts +1 -1
  20. package/skills/presmium-animate/gallery/transitions/lecture.json +103 -52
  21. package/skills/presmium-animate/references/lengths.md +1 -1
  22. package/skills/presmium-animate/references/libraries.md +12 -6
  23. package/skills/presmium-animate/references/procedural.md +1 -0
  24. package/skills/presmium-animate/references/story.md +21 -7
  25. package/skills/presmium-animate/references/team.md +176 -0
  26. package/skills/presmium-author/SKILL.md +53 -19
  27. package/skills/presmium-author/references/assistance.md +3 -1
  28. package/skills/{presmium-present → presmium-author}/references/classroom.md +2 -2
  29. package/skills/presmium-author/references/document.md +1 -1
  30. package/skills/{presmium-present → presmium-author}/references/lecture.md +3 -1
  31. package/skills/presmium-author/references/publishing.md +161 -13
  32. package/skills/presmium-author/references/writing.md +170 -7
  33. package/src/cli.ts +4 -4
  34. package/src/install.ts +42 -5
  35. package/src/messages.ts +5 -5
  36. package/src/resources.ts +5 -4
  37. package/skills/presmium-present/SKILL.md +0 -35
  38. package/skills/presmium-present/references/delivery.md +0 -122
@@ -51,6 +51,7 @@
51
51
  "title": "搜索与遍历",
52
52
  "level": 1,
53
53
  "children": [
54
+ "search--about",
54
55
  "search--intro"
55
56
  ],
56
57
  "stepOrder": [
@@ -524,7 +525,8 @@
524
525
  "level": 2,
525
526
  "children": [
526
527
  "dc-terminal-run--notes",
527
- "dc-terminal-run--shot"
528
+ "dc-terminal-run--shot",
529
+ "dc-terminal-run--closing"
528
530
  ],
529
531
  "stepOrder": [
530
532
  "dc-terminal-run--step-0",
@@ -552,7 +554,7 @@
552
554
  "children": [
553
555
  {
554
556
  "type": "text",
555
- "text": "指针移动、逐个比较与图上的遍历,每一步对应一次判断。"
557
+ "text": "搜索类算法的每一步是一次判断:指针跳到哪里,比较的结果如何,下一个访问哪个节点。本组的动画让画面的每一次变化对应一次这样的判断。"
556
558
  }
557
559
  ]
558
560
  }
@@ -577,7 +579,7 @@
577
579
  "children": [
578
580
  {
579
581
  "type": "text",
580
- "text": "节点出现,从根 A 开始访问。"
582
+ "text": "DrawSVG 把一条路径从起点逐渐画到终点,适合表现搜索沿边扩展。本例的树有七个节点,广度优先搜索从根 A 开始访问。"
581
583
  }
582
584
  ]
583
585
  }
@@ -593,7 +595,7 @@
593
595
  "children": [
594
596
  {
595
597
  "type": "text",
596
- "text": "第一层的两条边从 A 画向 B 和 C,它们被访问。"
598
+ "text": "第一层的两条边从 A 画向 B 和 C,边画到哪个节点,哪个节点就被访问。"
597
599
  }
598
600
  ]
599
601
  }
@@ -609,7 +611,7 @@
609
611
  "children": [
610
612
  {
611
613
  "type": "text",
612
- "text": "第二层的四条边画出,D、E、F、G 依次被访问。"
614
+ "text": "第二层的四条边随后画出,D、E、F、G 依次被访问。"
613
615
  }
614
616
  ]
615
617
  }
@@ -625,7 +627,7 @@
625
627
  "children": [
626
628
  {
627
629
  "type": "text",
628
- "text": "从 A 经 C 到 F 的路径描成一条粗线。"
630
+ "text": "最后,从 A 经 C 到 F 的路径描成一条粗线,标出从根到 F 的路线。"
629
631
  }
630
632
  ]
631
633
  }
@@ -650,7 +652,7 @@
650
652
  "children": [
651
653
  {
652
654
  "type": "text",
653
- "text": "图里有七个节点,搜索从 A 开始。"
655
+ "text": "在一般的图上,广度优先搜索经过的边分为两种:第一次找到某个节点的树边,以及连向已访问节点的其他边。本例的图有七个节点,搜索从 A 开始,树边沿父节点到子节点的方向亮起。"
654
656
  }
655
657
  ]
656
658
  }
@@ -666,7 +668,7 @@
666
668
  "children": [
667
669
  {
668
670
  "type": "text",
669
- "text": "第一层:A 的邻居 B 和 C 被访问,两条树边亮起。"
671
+ "text": "第一层访问 A 的邻居 B 和 C,两条树边亮起。"
670
672
  }
671
673
  ]
672
674
  }
@@ -682,7 +684,7 @@
682
684
  "children": [
683
685
  {
684
686
  "type": "text",
685
- "text": "第二层:D、E、F 被访问。C 到 E 的边不是树边,E 已经由 B 找到。"
687
+ "text": "第二层访问 D、E、F。C 到 E 的边不亮:E 已经由 B 找到,这条边不是树边。"
686
688
  }
687
689
  ]
688
690
  }
@@ -698,7 +700,7 @@
698
700
  "children": [
699
701
  {
700
702
  "type": "text",
701
- "text": "最后一层只剩 G,搜索结束。"
703
+ "text": "最后一层只剩 G,G 被访问后搜索结束。"
702
704
  }
703
705
  ]
704
706
  }
@@ -723,7 +725,7 @@
723
725
  "children": [
724
726
  {
725
727
  "type": "text",
726
- "text": "指针指向中点 16,16 小于 23,左半边变淡。"
728
+ "text": "GSAP 的关键帧让一个指针在一条时间轴上依次停在几个位置,适合表现二分查找。本例在十个有序数中查找 23:指针先指向中点 16,16 小于 23,左半边不可能含有 23,因此变淡。"
727
729
  }
728
730
  ]
729
731
  }
@@ -739,7 +741,7 @@
739
741
  "children": [
740
742
  {
741
743
  "type": "text",
742
- "text": "指针跳到剩下部分的中点 56,56 大于 23,右边变淡。"
744
+ "text": "指针跳到剩余部分的中点 56,56 大于 23,右边变淡。"
743
745
  }
744
746
  ]
745
747
  }
@@ -755,7 +757,7 @@
755
757
  "children": [
756
758
  {
757
759
  "type": "text",
758
- "text": "指针跳到 23,找到了,这一格弹一下。"
760
+ "text": "第三次比较时指针落在 23 上,查找成功,这一格弹动一下。"
759
761
  }
760
762
  ]
761
763
  }
@@ -780,7 +782,7 @@
780
782
  "children": [
781
783
  {
782
784
  "type": "text",
783
- "text": "线性查找:指针一格一格向右,比较到第八次才找到 61。"
785
+ "text": "steps 缓动让指针一格一格地跳,而不是平滑地滑过,每一跳对应一次比较。在这个有序数组中查找 61,线性查找从左向右逐格比较,第八次才找到。"
784
786
  }
785
787
  ]
786
788
  }
@@ -796,7 +798,7 @@
796
798
  "children": [
797
799
  {
798
800
  "type": "text",
799
- "text": "二分查找:先看中间的 34,比 61 小,丢掉左半边;再看 61,找到了,只比较了两次。"
801
+ "text": "二分查找先比较中间的 34,34 小于 61,丢掉左半边;第二次比较就落在 61 上。同一个目标,线性查找比较了八次,二分查找只比较了两次。"
800
802
  }
801
803
  ]
802
804
  }
@@ -812,7 +814,7 @@
812
814
  "children": [
813
815
  {
814
816
  "type": "text",
815
- "text": "元素交换位置、逐趟推进,排好的部分逐渐固定。"
817
+ "text": "排序算法由一次次比较与交换组成,每一趟结束后有一部分元素固定在最终位置。本组的动画让交换的路径可见,并标出已经排好的部分。"
816
818
  }
817
819
  ]
818
820
  }
@@ -837,7 +839,7 @@
837
839
  "children": [
838
840
  {
839
841
  "type": "text",
840
- "text": "下标 1 和 4 的两个格子被选中。"
842
+ "text": "关键帧数组给出几个中间点,元素就沿弧线移动,两个元素交换时不会互相穿过。本例先选中数组中下标 1 和 4 的两个格子。"
841
843
  }
842
844
  ]
843
845
  }
@@ -853,7 +855,7 @@
853
855
  "children": [
854
856
  {
855
857
  "type": "text",
856
- "text": "它们交换位置:一个从上方绕过去,一个从下方。"
858
+ "text": "两个格子交换位置,一个从上方绕过,一个从下方绕过。"
857
859
  }
858
860
  ]
859
861
  }
@@ -869,7 +871,7 @@
869
871
  "children": [
870
872
  {
871
873
  "type": "text",
872
- "text": "落地时压扁一下再弹回,颜色恢复。"
874
+ "text": "格子落地时压扁一下再弹回,颜色恢复,表示交换完成。"
873
875
  }
874
876
  ]
875
877
  }
@@ -894,7 +896,7 @@
894
896
  "children": [
895
897
  {
896
898
  "type": "text",
897
- "text": "第一遍:相邻两根依次比较,大的往右换,9 到了最右边。"
899
+ "text": "对同一个属性串接多段补间,可以把冒泡排序的一连串交换排进一条时间线。冒泡排序依次比较相邻两根柱子,前者较大就交换。第一遍结束时,最大的 9 到了最右边。"
898
900
  }
899
901
  ]
900
902
  }
@@ -910,7 +912,7 @@
910
912
  "children": [
911
913
  {
912
914
  "type": "text",
913
- "text": "第二遍:8 到了倒数第二位。"
915
+ "text": "第二遍把 8 送到倒数第二位。"
914
916
  }
915
917
  ]
916
918
  }
@@ -926,7 +928,7 @@
926
928
  "children": [
927
929
  {
928
930
  "type": "text",
929
- "text": "第三遍:6 就位,这时整个数组其实已经有序。"
931
+ "text": "第三遍 6 就位,此时整个数组已经有序。"
930
932
  }
931
933
  ]
932
934
  }
@@ -967,7 +969,7 @@
967
969
  "children": [
968
970
  {
969
971
  "type": "text",
970
- "text": "第一趟:相邻两个比较,前面大就交换,9 被一路换到最右边。"
972
+ "text": "列表重排的动画让较大的数从上方越过较小的数,适合逐趟演示冒泡排序。本例对六个数排序,每一步是一趟。第一趟依次比较相邻的两个数,前面较大就交换,9 被一路换到最右边。"
971
973
  }
972
974
  ]
973
975
  }
@@ -983,7 +985,7 @@
983
985
  "children": [
984
986
  {
985
987
  "type": "text",
986
- "text": "第二趟:8 归位到倒数第二格。"
988
+ "text": "第二趟把 8 归位到倒数第二格。"
987
989
  }
988
990
  ]
989
991
  }
@@ -999,7 +1001,7 @@
999
1001
  "children": [
1000
1002
  {
1001
1003
  "type": "text",
1002
- "text": "第三趟:2 和 1、5 和 3 交换后,整列有序。"
1004
+ "text": "第三趟交换 2 和 1、5 和 3 之后,整列有序。"
1003
1005
  }
1004
1006
  ]
1005
1007
  }
@@ -1015,7 +1017,7 @@
1015
1017
  "children": [
1016
1018
  {
1017
1019
  "type": "text",
1018
- "text": "排好了:从左到右依次亮起。"
1020
+ "text": "排序完成,各格从左到右依次亮起。"
1019
1021
  }
1020
1022
  ]
1021
1023
  }
@@ -1040,7 +1042,7 @@
1040
1042
  "children": [
1041
1043
  {
1042
1044
  "type": "text",
1043
- "text": "比较前两个数,5 比 3 大,它们被标亮。"
1045
+ "text": "这个效果把冒泡排序的一次比较与交换放大成一个镜头,适合在演示完整排序之前先讲清单步操作。前两个数 5 和 3 被标亮:5 大于 3,两者需要交换。"
1044
1046
  }
1045
1047
  ]
1046
1048
  }
@@ -1056,7 +1058,7 @@
1056
1058
  "children": [
1057
1059
  {
1058
1060
  "type": "text",
1059
- "text": "两个数沿着弧线交换位置,一个从上面过,一个从下面过。"
1061
+ "text": "两个数沿弧线交换位置,一个从上方经过,一个从下方经过。"
1060
1062
  }
1061
1063
  ]
1062
1064
  }
@@ -1072,7 +1074,7 @@
1072
1074
  "children": [
1073
1075
  {
1074
1076
  "type": "text",
1075
- "text": "交换完成,这一对变成绿色,5 向右冒了一格。"
1077
+ "text": "交换完成后这一对变成绿色,5 向右移动了一格。"
1076
1078
  }
1077
1079
  ]
1078
1080
  }
@@ -1097,7 +1099,7 @@
1097
1099
  "children": [
1098
1100
  {
1099
1101
  "type": "text",
1100
- "text": "第一趟:从左到右扫描,最小的 1 换到最前面,变成绿色。"
1102
+ "text": "嵌套时间轴把每一趟排序写成一条子时间轴,再按顺序放进主时间轴,适合结构固定的多趟算法。本例对五根柱子做选择排序:每一趟扫描未排序部分,找出最小值,换到这部分的最前面。第一趟找到最小的 1,换到最前面后变成绿色。"
1101
1103
  }
1102
1104
  ]
1103
1105
  }
@@ -1113,7 +1115,7 @@
1113
1115
  "children": [
1114
1116
  {
1115
1117
  "type": "text",
1116
- "text": "第二趟:在剩下的柱子中找到 3,它已经在位置上。"
1118
+ "text": "第二趟在剩下的柱子中找到 3,它已经在正确的位置上,不需要交换。"
1117
1119
  }
1118
1120
  ]
1119
1121
  }
@@ -1129,7 +1131,7 @@
1129
1131
  "children": [
1130
1132
  {
1131
1133
  "type": "text",
1132
- "text": "第三趟:找到 5,与 8 交换。"
1134
+ "text": "第三趟找到 5,与 8 交换。"
1133
1135
  }
1134
1136
  ]
1135
1137
  }
@@ -1145,7 +1147,7 @@
1145
1147
  "children": [
1146
1148
  {
1147
1149
  "type": "text",
1148
- "text": "第四趟:找到 6,排序完成。"
1150
+ "text": "第四趟找到 6,排序完成。"
1149
1151
  }
1150
1152
  ]
1151
1153
  }
@@ -1161,7 +1163,7 @@
1161
1163
  "children": [
1162
1164
  {
1163
1165
  "type": "text",
1164
- "text": "树逐层生长、栈与盘子的移动、位的变化与合并。"
1166
+ "text": "数据结构的动画表现元素怎样加入、移动与合并:树逐层生长,汉诺塔的圆盘在柱子间移动,二进制位翻转并进位,词元两两合并。"
1165
1167
  }
1166
1168
  ]
1167
1169
  }
@@ -1186,7 +1188,7 @@
1186
1188
  "children": [
1187
1189
  {
1188
1190
  "type": "text",
1189
- "text": "根节点 8 弹出来。"
1191
+ "text": "节点带着回弹弹出,可以强调新元素的出现;先画边再弹出节点,观众能先看到节点挂在哪里。本例的二叉搜索树从根节点 8 开始。"
1190
1192
  }
1191
1193
  ]
1192
1194
  }
@@ -1202,7 +1204,7 @@
1202
1204
  "children": [
1203
1205
  {
1204
1206
  "type": "text",
1205
- "text": "第二层:先画出两条边,4 和 12 依次弹出。"
1207
+ "text": "第二层先画出两条边,4 和 12 随后依次弹出。"
1206
1208
  }
1207
1209
  ]
1208
1210
  }
@@ -1218,7 +1220,7 @@
1218
1220
  "children": [
1219
1221
  {
1220
1222
  "type": "text",
1221
- "text": "第三层的四个叶子依次弹出。"
1223
+ "text": "第三层的四个叶子依次弹出,树长成三层。"
1222
1224
  }
1223
1225
  ]
1224
1226
  }
@@ -1243,7 +1245,7 @@
1243
1245
  "children": [
1244
1246
  {
1245
1247
  "type": "text",
1246
- "text": "架子转到正面,三个圆盘叠在 A 柱上。"
1248
+ "text": "Three.js 把关键帧写成数据:每个圆盘的移动是一条关键帧轨道,AnimationClip 收拢这些轨道,AnimationMixer 负责播放。本例是三个圆盘的汉诺塔,七次移动写成关键帧轨道,正在移动的圆盘显示为橙色。开始时架子转到正面,三个圆盘叠在 A 柱上。"
1247
1249
  }
1248
1250
  ]
1249
1251
  }
@@ -1259,7 +1261,7 @@
1259
1261
  "children": [
1260
1262
  {
1261
1263
  "type": "text",
1262
- "text": "前三步把上面两个圆盘挪到 B 柱,给最大的圆盘让路。"
1264
+ "text": "前三步把上面两个圆盘挪到 B 柱,为最大的圆盘让路。"
1263
1265
  }
1264
1266
  ]
1265
1267
  }
@@ -1275,7 +1277,7 @@
1275
1277
  "children": [
1276
1278
  {
1277
1279
  "type": "text",
1278
- "text": "最大的圆盘从 A 移到 C。"
1280
+ "text": "第四步把最大的圆盘从 A 移到 C。"
1279
1281
  }
1280
1282
  ]
1281
1283
  }
@@ -1291,7 +1293,7 @@
1291
1293
  "children": [
1292
1294
  {
1293
1295
  "type": "text",
1294
- "text": "最后三步把两个小圆盘从 B 移到 C 上,完成。"
1296
+ "text": "最后三步把两个小圆盘从 B 移到 C 上,七次移动完成。"
1295
1297
  }
1296
1298
  ]
1297
1299
  }
@@ -1316,7 +1318,7 @@
1316
1318
  "children": [
1317
1319
  {
1318
1320
  "type": "text",
1319
- "text": "四个位,从高到低是 8、4、2、1。"
1321
+ "text": "二进制位只有 0 和 1 两个值,动画让每一位直接翻转并变色,不做中间过渡。这个四位计数器的位权从高到低是 8、4、2、1。"
1320
1322
  }
1321
1323
  ]
1322
1324
  }
@@ -1332,7 +1334,7 @@
1332
1334
  "children": [
1333
1335
  {
1334
1336
  "type": "text",
1335
- "text": "从 0 数到 15,最低位每次都翻转,进位从右向左传。"
1337
+ "text": "计数器从 0 数到 15。最低位每次都翻转,进位从右向左传递。"
1336
1338
  }
1337
1339
  ]
1338
1340
  }
@@ -1357,7 +1359,7 @@
1357
1359
  "children": [
1358
1360
  {
1359
1361
  "type": "text",
1360
- "text": "四个字依次出现,每个字是一个词元。"
1362
+ "text": "合并的动画让被合并的元素收拢消失,保留的元素换成新内容,适合讲分词时相邻词元的合并。本例中四个字依次出现,每个字是一个词元。"
1361
1363
  }
1362
1364
  ]
1363
1365
  }
@@ -1373,7 +1375,7 @@
1373
1375
  "children": [
1374
1376
  {
1375
1377
  "type": "text",
1376
- "text": "「机」与「器」、「学」与「习」两两合并:右边的词元收拢消失,左边的换成新词。"
1378
+ "text": "「机」与「器」、「学」与「习」两两合并:右边的词元收拢消失,左边的词元换成合并后的词。"
1377
1379
  }
1378
1380
  ]
1379
1381
  }
@@ -1389,7 +1391,7 @@
1389
1391
  "children": [
1390
1392
  {
1391
1393
  "type": "text",
1392
- "text": "两个词再合并成一个词元「机器学习」。"
1394
+ "text": "「机器」与「学习」再合并成一个词元「机器学习」。"
1393
1395
  }
1394
1396
  ]
1395
1397
  }
@@ -1405,7 +1407,7 @@
1405
1407
  "children": [
1406
1408
  {
1407
1409
  "type": "text",
1408
- "text": "讲一个判断流程时用:问题树一层层长出来,再沿一个具体情况从根走到答案;没走的分支随之变暗,答案填色并轻轻放大。"
1410
+ "text": "讲一个判断流程时使用。问题树逐层长出,随后沿一个具体情况从根走到答案;没有走到的分支变暗,答案节点填色并轻轻放大。"
1409
1411
  }
1410
1412
  ]
1411
1413
  },
@@ -1415,7 +1417,7 @@
1415
1417
  "children": [
1416
1418
  {
1417
1419
  "type": "text",
1418
- "text": "root 1.2 s:根问题弹出;grow 3 s:每层占等长一段,连线先从父节点画出,分支标签在拐角淡入,子节点在连线到达时弹出(原因先于结果);trace 3 s:强调色的线一段段走下选中的分支,到达的节点描边变色,没走的分支在线经过后暗到三分之一;answer 2.3 s:答案节点填色、放大 8% 再回落,停住。"
1420
+ "text": "四个状态:root 1.2 s,根问题弹出;grow 3 s,每层占等长的一段,连线先从父节点画出,分支标签在拐角淡入,子节点在连线到达时弹出,原因先于结果;trace 3 s,强调色的线逐段走下选中的分支,到达的节点描边变色,没走的分支在线经过后暗到三分之一;answer 2.3 s,答案节点填色、放大 8% 再回落,然后停住。"
1419
1421
  }
1420
1422
  ]
1421
1423
  },
@@ -1425,7 +1427,7 @@
1425
1427
  "children": [
1426
1428
  {
1427
1429
  "type": "text",
1428
- "text": "参数:tree(节点 label、到它的分支名 edge、children)、path(每层选第几个孩子,从 0 起)、orientation(vertical 自上而下,horizontal 自左向右)。D3 的 tree 布局决定位置;节点宽度按字符列数计算。"
1430
+ "text": "参数:tree(节点的 label、通向它的分支名 edge、children)、path(每层选第几个孩子,从 0 起)、orientation(vertical 自上而下,horizontal 自左向右)。节点位置由 D3 的 tree 布局决定,节点宽度按字符列数计算。"
1429
1431
  }
1430
1432
  ]
1431
1433
  }
@@ -1450,7 +1452,7 @@
1450
1452
  "children": [
1451
1453
  {
1452
1454
  "type": "text",
1453
- "text": "消息往返与哈希的雪崩效应。"
1455
+ "text": "协议与哈希的动画表现看不见的过程:消息在两端之间往返的顺序,以及输入改动一个字母后摘要的变化。"
1454
1456
  }
1455
1457
  ]
1456
1458
  }
@@ -1475,7 +1477,7 @@
1475
1477
  "children": [
1476
1478
  {
1477
1479
  "type": "text",
1478
- "text": "请求发到服务器,在那里停一下,变成响应回来,这一来一回就是 RTT。"
1480
+ "text": "关键帧的 times 参数指定每个关键帧在总时长中的位置,可以让数据包在服务器端停留一段时间再返回。本例中请求发到服务器,停留片刻后变成响应返回,这一来一回的时间就是往返时延(RTT)。"
1479
1481
  }
1480
1482
  ]
1481
1483
  }
@@ -1491,7 +1493,7 @@
1491
1493
  "children": [
1492
1494
  {
1493
1495
  "type": "text",
1494
- "text": "建立连接要三次握手:SYN 过去,SYN-ACK 回来,ACK 再过去。"
1496
+ "text": "建立 TCP 连接需要三次握手:客户端发出 SYN,服务器回复 SYN-ACK,客户端再发出 ACK。"
1495
1497
  }
1496
1498
  ]
1497
1499
  }
@@ -1516,7 +1518,7 @@
1516
1518
  "children": [
1517
1519
  {
1518
1520
  "type": "text",
1519
- "text": "hello 的 SHA-256 摘要从左到右从乱码中显现出来。"
1521
+ "text": "乱码揭示让字符先随机跳动,再从左到右依次定格为真实内容,适合展示哈希值这类看不出规律的输出。本例中 hello 的 SHA-256 摘要从乱码中逐位显现。"
1520
1522
  }
1521
1523
  ]
1522
1524
  }
@@ -1532,7 +1534,7 @@
1532
1534
  "children": [
1533
1535
  {
1534
1536
  "type": "text",
1535
- "text": "把最后一个字母 o 改成 p,只差一个字母。"
1537
+ "text": "把最后一个字母 o 改成 p,新的输入与原来只差一个字母。"
1536
1538
  }
1537
1539
  ]
1538
1540
  }
@@ -1548,7 +1550,7 @@
1548
1550
  "children": [
1549
1551
  {
1550
1552
  "type": "text",
1551
- "text": "新的摘要每一位都可能变,看不出和原来的任何关系,这是雪崩效应。"
1553
+ "text": "新摘要的每一位都可能改变,与原摘要看不出任何关系。输入的微小改动让输出整体改变,这一性质称为雪崩效应。"
1552
1554
  }
1553
1555
  ]
1554
1556
  }
@@ -1564,7 +1566,7 @@
1564
1566
  "children": [
1565
1567
  {
1566
1568
  "type": "text",
1567
- "text": "代码的输入、逐段导览、修改对比、写法变形与终端运行。"
1569
+ "text": "讲代码时常用五种镜头:逐字输入、逐段导览、修改对比、同一逻辑的写法变形,以及在终端中运行。"
1568
1570
  }
1569
1571
  ]
1570
1572
  }
@@ -1580,7 +1582,7 @@
1580
1582
  "children": [
1581
1583
  {
1582
1584
  "type": "text",
1583
- "text": "现场写一段代码时用:代码带着颜色逐字出现,光标始终在最前面;缩进一次出现,中文注释一个字一个字地来。"
1585
+ "text": "现场写一段代码时使用。代码带着语法颜色逐字出现,光标始终在最前面;缩进一次出现,中文注释逐字出现。"
1584
1586
  }
1585
1587
  ]
1586
1588
  },
@@ -1590,7 +1592,7 @@
1590
1592
  "children": [
1591
1593
  {
1592
1594
  "type": "text",
1593
- "text": "0–0.45 s 编辑器升起;0.5 s 起约每秒 14 个字符(观众能跟读的速度),节奏由固定种子决定:词内连打、换行与注释前稍停;每行开始时行号出现;打完后光标以 530 ms 闪烁,静止约 2 秒。代码比状态长时整体压缩。"
1595
+ "text": "0–0.45 s 编辑器升起;从 0.5 s 起约每秒输入 14 个字符,这是观众能跟读的速度。节奏由固定种子决定:词内连打,换行与注释前稍作停顿;每行开始时行号出现。输入完成后光标以 530 ms 的周期闪烁,画面静止约 2 秒。代码输入所需的时间长于状态时长时,节奏整体压缩。"
1594
1596
  }
1595
1597
  ]
1596
1598
  },
@@ -1625,7 +1627,7 @@
1625
1627
  "children": [
1626
1628
  {
1627
1629
  "type": "text",
1628
- "text": "带读一个比窗口长的文件时用:每一步滚到一段代码,高亮带跟着滑过去,其余行变暗,旁边浮出一句短注。"
1630
+ "text": "带读一个比窗口长的文件时使用。每一步滚动到一段代码,高亮带随之滑过去,其余行变暗,旁边浮出一句短注。"
1629
1631
  }
1630
1632
  ]
1631
1633
  },
@@ -1635,7 +1637,7 @@
1635
1637
  "children": [
1636
1638
  {
1637
1639
  "type": "text",
1638
- "text": "overview 1.5 s:编辑器升起,显示文件开头。每个 focus:0–0.85 s 滚动使这一段居中,高亮带随之从上一段滑到这一段(第一次则在滚动落定后从左扫入);0.85 s 起其余行暗到三分之一;1.15 s 起短注在高亮带右侧浮现,上一条短注先在 0.2 s 内离开。"
1640
+ "text": "overview 1.5 s:编辑器升起,显示文件开头。每个 focus 状态:0–0.85 s 滚动使这一段居中,高亮带同时从上一段滑到这一段(第一次则在滚动落定后从左侧扫入);从 0.85 s 起其余行暗到三分之一;从 1.15 s 起短注在高亮带右侧浮现,上一条短注先在 0.2 s 内离开。"
1639
1641
  }
1640
1642
  ]
1641
1643
  },
@@ -1645,7 +1647,7 @@
1645
1647
  "children": [
1646
1648
  {
1647
1649
  "type": "text",
1648
- "text": "参数:code、lang、file、focus(每项 from、to 为行号,note 为不超过九个字的短注;状态数 = focus 数 + 1)。聚焦行由高亮扫入,其余行变暗。"
1650
+ "text": "参数:code、lang、file、focus(每项的 from、to 为行号,note 为不超过九个字的短注;状态数等于 focus 项数加 1)。"
1649
1651
  }
1650
1652
  ]
1651
1653
  }
@@ -1670,7 +1672,7 @@
1670
1672
  "children": [
1671
1673
  {
1672
1674
  "type": "text",
1673
- "text": "讲一次修改时用:先看旧代码,要删的行先变红,新行再一行行撑开(下面的行被推下去,看得出插在哪里),最后删去的行收起、颜色褪去,标题栏弹出“−1 +3”,停在干净的新代码上。"
1675
+ "text": "讲一次修改时使用。先显示旧代码;要删除的行先变红,新行再逐行撑开,下面的行被推下去,看得出新行插在哪里;最后删除的行收起,颜色褪去,标题栏弹出改动计数(如“−1 +3”),画面停在修改后的代码上。"
1674
1676
  }
1675
1677
  ]
1676
1678
  },
@@ -1680,7 +1682,7 @@
1680
1682
  "children": [
1681
1683
  {
1682
1684
  "type": "text",
1683
- "text": "0–1 s 编辑器升起;1–2.2 s 删除行依次标红,先出“−”号再横扫底色(原因先于结果);2.2–3.7 s 新行从零高度展开,底色先到、文字晚 60 ms;3.7–6 s 删除行收起,底色褪去,改动计数弹出,静止 1.6 s。"
1685
+ "text": "0–1 s 编辑器升起;1–2.2 s 删除行依次标红,先出现“−”号,再横扫底色,原因先于结果;2.2–3.7 s 新行从零高度展开,底色先到,文字晚 60 ms;3.7–6 s 删除行收起,底色褪去,改动计数弹出,随后静止 1.6 s。"
1684
1686
  }
1685
1687
  ]
1686
1688
  },
@@ -1690,7 +1692,7 @@
1690
1692
  "children": [
1691
1693
  {
1692
1694
  "type": "text",
1693
- "text": "参数:before、after(前后两版代码,按行做最长公共子序列对比)、lang(python、js、shell)、file(标题栏文件名)。"
1695
+ "text": "参数:before、after(修改前后的两版代码,按行做最长公共子序列对比)、lang(python、js、shell)、file(标题栏中的文件名)。"
1694
1696
  }
1695
1697
  ]
1696
1698
  }
@@ -1715,7 +1717,7 @@
1715
1717
  "children": [
1716
1718
  {
1717
1719
  "type": "text",
1718
- "text": "讲重构、讲同一件事的几种写法时用:留下的词滑到新位置,要走的先沉下去,新来的最后浮上来;标题栏的版本名随落位切换。"
1720
+ "text": "讲重构,或讲同一件事的几种写法时使用。保留的词滑到新位置,要去掉的词先沉下去,新加的词最后浮上来;标题栏的版本名随词落位而切换。"
1719
1721
  }
1720
1722
  ]
1721
1723
  },
@@ -1725,7 +1727,7 @@
1725
1727
  "children": [
1726
1728
  {
1727
1729
  "type": "text",
1728
- "text": "每个后续状态:0–0.25 s 离开的词下沉淡出;0.15–0.8 s 留下的词同时滑到新的列和行(换行的词途中略抬起,看得见它走过去);0.75 s 起新词以 30 ms 间隔浮现;其余时间静止。默认:for 循环 → 列表推导式 → 生成器表达式,x * x 从循环末尾飞到推导式开头。"
1730
+ "text": "每个后续状态:0–0.25 s 离开的词下沉并淡出;0.15–0.8 s 保留的词同时滑到新的行列,换行的词途中略微抬起,看得出它的移动路线;从 0.75 s 起新词以 30 ms 的间隔浮现;其余时间静止。默认示例从 for 循环变为列表推导式,再变为生成器表达式,x * x 从循环末尾飞到推导式开头。"
1729
1731
  }
1730
1732
  ]
1731
1733
  },
@@ -1760,7 +1762,7 @@
1760
1762
  "children": [
1761
1763
  {
1762
1764
  "type": "text",
1763
- "text": "演示一条命令的运行过程时用:命令按人手的节奏敲出,回车后输出一行行打印,最后一行结果以成功色落定,新的提示符闪烁。"
1765
+ "text": "演示一条命令的运行过程时使用。命令按人手打字的节奏敲出,回车后输出逐行打印,最后一行结果以成功色落定,新的提示符随后闪烁。"
1764
1766
  }
1765
1767
  ]
1766
1768
  },
@@ -1770,7 +1772,7 @@
1770
1772
  "children": [
1771
1773
  {
1772
1774
  "type": "text",
1773
- "text": "type 2.6 s:终端升起,0.5 s 起约每秒 14 个字符敲入命令,打完光标闪烁一拍;run 2.4 s:回车,0.3 s 后每 0.32 s 打印一行;done 2 s:结果行以成功色出现并轻微回弹(全片唯一的回弹,表示“完成”),随后新提示符出现。标题栏右侧标“示意输出”。"
1775
+ "text": "type 2.6 s:终端升起,从 0.5 s 起约每秒输入 14 个字符,输入完成后光标闪烁一拍;run 2.4 s:回车,0.3 s 后每 0.32 s 打印一行;done 2 s:结果行以成功色出现并轻微回弹(全片唯一的回弹,表示完成),随后出现新的提示符。标题栏右侧标注“示意输出”。"
1774
1776
  }
1775
1777
  ]
1776
1778
  },
@@ -1780,7 +1782,7 @@
1780
1782
  "children": [
1781
1783
  {
1782
1784
  "type": "text",
1783
- "text": "参数:command、output(每行一项;以 ✓ 开头为成功色,✗ 或“错误”开头为危险色)、prompt、title、tag。"
1785
+ "text": "参数:command、output(每行一项;以 ✓ 开头显示为成功色,以 ✗ 或“错误”开头显示为危险色)、prompt、title、tag。"
1784
1786
  }
1785
1787
  ]
1786
1788
  }
@@ -1794,6 +1796,44 @@
1794
1796
  "scene": "dc/terminal-run",
1795
1797
  "alt": "终端运行:输入 python train.py --epochs 3,打印三轮训练的损失与准确率(示意输出),最后显示模型已保存。"
1796
1798
  }
1799
+ },
1800
+ "search--about": {
1801
+ "id": "search--about",
1802
+ "type": "text",
1803
+ "only": [
1804
+ "web"
1805
+ ],
1806
+ "content": [
1807
+ {
1808
+ "id": "search--about--p",
1809
+ "type": "paragraph",
1810
+ "children": [
1811
+ {
1812
+ "type": "text",
1813
+ "text": "本篇收录讲解算法与代码时可用的动画效果,按讲解对象分为五组:搜索与遍历、排序与交换、数据结构、协议与哈希、代码。这些效果遵循同一条规则:画面的每一次变化对应算法的一次操作,例如一次比较、一次交换或一次访问,观众因此能从画面数出算法走了几步。每页给出一个效果的用途、实现手法和逐步的画面。"
1814
+ }
1815
+ ]
1816
+ }
1817
+ ]
1818
+ },
1819
+ "dc-terminal-run--closing": {
1820
+ "id": "dc-terminal-run--closing",
1821
+ "type": "text",
1822
+ "only": [
1823
+ "web"
1824
+ ],
1825
+ "content": [
1826
+ {
1827
+ "id": "dc-terminal-run--closing--p",
1828
+ "type": "paragraph",
1829
+ "children": [
1830
+ {
1831
+ "type": "text",
1832
+ "text": "本篇各页的效果按同一条规则选取:画面的每一次变化对应一次操作,可以是一次比较、一次交换、一次访问,也可以是一行输入或一行输出。选用效果时,先数清要讲的操作有几步,再让动画的状态与之一一对应。"
1833
+ }
1834
+ ]
1835
+ }
1836
+ ]
1797
1837
  }
1798
1838
  },
1799
1839
  "steps": {
@@ -1804,6 +1844,10 @@
1804
1844
  {
1805
1845
  "blockId": "search--intro",
1806
1846
  "visible": true
1847
+ },
1848
+ {
1849
+ "blockId": "search--about",
1850
+ "visible": false
1807
1851
  }
1808
1852
  ],
1809
1853
  "narrationIds": []
@@ -3440,6 +3484,10 @@
3440
3484
  "blockId": "dc-terminal-run--shot",
3441
3485
  "visible": true,
3442
3486
  "state": "type"
3487
+ },
3488
+ {
3489
+ "blockId": "dc-terminal-run--closing",
3490
+ "visible": false
3443
3491
  }
3444
3492
  ],
3445
3493
  "narrationIds": []
@@ -3456,6 +3504,10 @@
3456
3504
  "blockId": "dc-terminal-run--shot",
3457
3505
  "visible": true,
3458
3506
  "state": "run"
3507
+ },
3508
+ {
3509
+ "blockId": "dc-terminal-run--closing",
3510
+ "visible": false
3459
3511
  }
3460
3512
  ],
3461
3513
  "narrationIds": []
@@ -3472,6 +3524,10 @@
3472
3524
  "blockId": "dc-terminal-run--shot",
3473
3525
  "visible": true,
3474
3526
  "state": "done"
3527
+ },
3528
+ {
3529
+ "blockId": "dc-terminal-run--closing",
3530
+ "visible": false
3475
3531
  }
3476
3532
  ],
3477
3533
  "narrationIds": []
@@ -3483,7 +3539,7 @@
3483
3539
  "content": [
3484
3540
  {
3485
3541
  "type": "text",
3486
- "text": "节点出现,从根 A 开始访问。"
3542
+ "text": "广度优先搜索从根 A 出发,一层一层往外找。"
3487
3543
  }
3488
3544
  ]
3489
3545
  },
@@ -3492,7 +3548,7 @@
3492
3548
  "content": [
3493
3549
  {
3494
3550
  "type": "text",
3495
- "text": "第一层的两条边从 A 画向 B 和 C,它们被访问。"
3551
+ "text": "第一层只有 B 和 C。边画到哪里,哪个节点就算访问过。"
3496
3552
  }
3497
3553
  ]
3498
3554
  },
@@ -3501,7 +3557,7 @@
3501
3557
  "content": [
3502
3558
  {
3503
3559
  "type": "text",
3504
- "text": "第二层的四条边画出,D、E、F、G 依次被访问。"
3560
+ "text": "第二层的 D、E、F、G,要等第一层访问完才轮到。"
3505
3561
  }
3506
3562
  ]
3507
3563
  },
@@ -3510,7 +3566,7 @@
3510
3566
  "content": [
3511
3567
  {
3512
3568
  "type": "text",
3513
- "text": "从 A 经 C 到 F 的路径描成一条粗线。"
3569
+ "text": "从根走到 F,只需沿 A、C、F 这一条路。"
3514
3570
  }
3515
3571
  ]
3516
3572
  },
@@ -3519,7 +3575,7 @@
3519
3575
  "content": [
3520
3576
  {
3521
3577
  "type": "text",
3522
- "text": "图里有七个节点,搜索从 A 开始。"
3578
+ "text": "这张图有七个节点,搜索从 A 开始,每一步展开一层。"
3523
3579
  }
3524
3580
  ]
3525
3581
  },
@@ -3528,7 +3584,7 @@
3528
3584
  "content": [
3529
3585
  {
3530
3586
  "type": "text",
3531
- "text": "第一层:A 的邻居 B 和 C 被访问,两条树边亮起。"
3587
+ "text": "第一层是 A 的邻居 B 和 C,两条树边先亮起来。"
3532
3588
  }
3533
3589
  ]
3534
3590
  },
@@ -3537,7 +3593,7 @@
3537
3593
  "content": [
3538
3594
  {
3539
3595
  "type": "text",
3540
- "text": "第二层:D、E、F 被访问。C 到 E 的边不是树边,E 已经由 B 找到。"
3596
+ "text": "第二层找到 D、E、F。C 到 E 这条边没有亮,因为 E 已经由 B 先找到了。"
3541
3597
  }
3542
3598
  ]
3543
3599
  },
@@ -3546,7 +3602,7 @@
3546
3602
  "content": [
3547
3603
  {
3548
3604
  "type": "text",
3549
- "text": "最后一层只剩 G,搜索结束。"
3605
+ "text": "最后一层只剩 G,访问完它,搜索就结束了。"
3550
3606
  }
3551
3607
  ]
3552
3608
  },
@@ -3555,7 +3611,7 @@
3555
3611
  "content": [
3556
3612
  {
3557
3613
  "type": "text",
3558
- "text": "指针指向中点 16,16 小于 23,左半边变淡。"
3614
+ "text": "在十个有序数里找 23。中点是 16,比 23 小,所以左半边都可以丢掉。"
3559
3615
  }
3560
3616
  ]
3561
3617
  },
@@ -3564,7 +3620,7 @@
3564
3620
  "content": [
3565
3621
  {
3566
3622
  "type": "text",
3567
- "text": "指针跳到剩下部分的中点 56,56 大于 23,右边变淡。"
3623
+ "text": "剩下部分的中点是 56,比 23 大,这回丢掉右边。"
3568
3624
  }
3569
3625
  ]
3570
3626
  },
@@ -3573,7 +3629,7 @@
3573
3629
  "content": [
3574
3630
  {
3575
3631
  "type": "text",
3576
- "text": "指针跳到 23,找到了,这一格弹一下。"
3632
+ "text": "第三次比较就落在 23 上。十个数,只比较了三次。"
3577
3633
  }
3578
3634
  ]
3579
3635
  },
@@ -3582,7 +3638,7 @@
3582
3638
  "content": [
3583
3639
  {
3584
3640
  "type": "text",
3585
- "text": "线性查找:指针一格一格向右,比较到第八次才找到 61。"
3641
+ "text": "先用线性查找找 61。指针每跳一格就比较一次,一共比较了八次。"
3586
3642
  }
3587
3643
  ]
3588
3644
  },
@@ -3591,7 +3647,7 @@
3591
3647
  "content": [
3592
3648
  {
3593
3649
  "type": "text",
3594
- "text": "二分查找:先看中间的 34,比 61 小,丢掉左半边;再看 61,找到了,只比较了两次。"
3650
+ "text": "换成二分查找。中间是 34,比 61 小,丢掉左半边;下一次就找到了,只比较两次。"
3595
3651
  }
3596
3652
  ]
3597
3653
  },
@@ -3600,7 +3656,7 @@
3600
3656
  "content": [
3601
3657
  {
3602
3658
  "type": "text",
3603
- "text": "下标 1 和 4 的两个格子被选中。"
3659
+ "text": "选中下标 1 和 4 的两个格子,准备交换。"
3604
3660
  }
3605
3661
  ]
3606
3662
  },
@@ -3609,7 +3665,7 @@
3609
3665
  "content": [
3610
3666
  {
3611
3667
  "type": "text",
3612
- "text": "它们交换位置:一个从上方绕过去,一个从下方。"
3668
+ "text": "一个从上面绕,一个从下面绕。路线分开,才看得清谁去了哪里。"
3613
3669
  }
3614
3670
  ]
3615
3671
  },
@@ -3618,7 +3674,7 @@
3618
3674
  "content": [
3619
3675
  {
3620
3676
  "type": "text",
3621
- "text": "落地时压扁一下再弹回,颜色恢复。"
3677
+ "text": "落地时压一下再弹回,颜色恢复,交换就完成了。"
3622
3678
  }
3623
3679
  ]
3624
3680
  },
@@ -3627,7 +3683,7 @@
3627
3683
  "content": [
3628
3684
  {
3629
3685
  "type": "text",
3630
- "text": "第一遍:相邻两根依次比较,大的往右换,9 到了最右边。"
3686
+ "text": "冒泡排序每次比较相邻两根柱子,前面的大就交换。第一遍下来,最大的 9 到了最右边。"
3631
3687
  }
3632
3688
  ]
3633
3689
  },
@@ -3636,7 +3692,7 @@
3636
3692
  "content": [
3637
3693
  {
3638
3694
  "type": "text",
3639
- "text": "第二遍:8 到了倒数第二位。"
3695
+ "text": "第二遍不用再管 9,8 到了倒数第二位。"
3640
3696
  }
3641
3697
  ]
3642
3698
  },
@@ -3645,7 +3701,7 @@
3645
3701
  "content": [
3646
3702
  {
3647
3703
  "type": "text",
3648
- "text": "第三遍:6 就位,这时整个数组其实已经有序。"
3704
+ "text": "第三遍,6 就位。其实这时整个数组已经排好了。"
3649
3705
  }
3650
3706
  ]
3651
3707
  },
@@ -3663,7 +3719,7 @@
3663
3719
  "content": [
3664
3720
  {
3665
3721
  "type": "text",
3666
- "text": "第一趟:相邻两个比较,前面大就交换,9 被一路换到最右边。"
3722
+ "text": "六个数做冒泡排序,每一步是一整趟。第一趟,9 被一路换到最右边。"
3667
3723
  }
3668
3724
  ]
3669
3725
  },
@@ -3672,7 +3728,7 @@
3672
3728
  "content": [
3673
3729
  {
3674
3730
  "type": "text",
3675
- "text": "第二趟:8 归位到倒数第二格。"
3731
+ "text": "第二趟不用再比到最后一格,8 归位到倒数第二格。"
3676
3732
  }
3677
3733
  ]
3678
3734
  },
@@ -3681,7 +3737,7 @@
3681
3737
  "content": [
3682
3738
  {
3683
3739
  "type": "text",
3684
- "text": "第三趟:2 和 1、5 和 3 交换后,整列有序。"
3740
+ "text": "第三趟只交换了两对:2 和 1,5 和 3。之后整列就有序了。"
3685
3741
  }
3686
3742
  ]
3687
3743
  },
@@ -3690,7 +3746,7 @@
3690
3746
  "content": [
3691
3747
  {
3692
3748
  "type": "text",
3693
- "text": "排好了:从左到右依次亮起。"
3749
+ "text": "排序完成,六个数从左到右依次亮起。"
3694
3750
  }
3695
3751
  ]
3696
3752
  },
@@ -3699,7 +3755,7 @@
3699
3755
  "content": [
3700
3756
  {
3701
3757
  "type": "text",
3702
- "text": "比较前两个数,5 比 3 大,它们被标亮。"
3758
+ "text": "先只看一次比较:5 比 3 大,所以两个数要交换。"
3703
3759
  }
3704
3760
  ]
3705
3761
  },
@@ -3708,7 +3764,7 @@
3708
3764
  "content": [
3709
3765
  {
3710
3766
  "type": "text",
3711
- "text": "两个数沿着弧线交换位置,一个从上面过,一个从下面过。"
3767
+ "text": "它们沿弧线交换位置,一个从上面过,一个从下面过。"
3712
3768
  }
3713
3769
  ]
3714
3770
  },
@@ -3717,7 +3773,7 @@
3717
3773
  "content": [
3718
3774
  {
3719
3775
  "type": "text",
3720
- "text": "交换完成,这一对变成绿色,5 向右冒了一格。"
3776
+ "text": "交换完,这一对变绿,5 向右冒了一格。大的数就是这样一格一格冒到末尾的。"
3721
3777
  }
3722
3778
  ]
3723
3779
  },
@@ -3726,7 +3782,7 @@
3726
3782
  "content": [
3727
3783
  {
3728
3784
  "type": "text",
3729
- "text": "第一趟:从左到右扫描,最小的 1 换到最前面,变成绿色。"
3785
+ "text": "选择排序每一趟扫一遍,找出最小的,放到最前面。第一趟找到 1。"
3730
3786
  }
3731
3787
  ]
3732
3788
  },
@@ -3735,7 +3791,7 @@
3735
3791
  "content": [
3736
3792
  {
3737
3793
  "type": "text",
3738
- "text": "第二趟:在剩下的柱子中找到 3,它已经在位置上。"
3794
+ "text": "第二趟找到 3,它本来就在该在的位置,不用换。"
3739
3795
  }
3740
3796
  ]
3741
3797
  },
@@ -3744,7 +3800,7 @@
3744
3800
  "content": [
3745
3801
  {
3746
3802
  "type": "text",
3747
- "text": "第三趟:找到 5,与 8 交换。"
3803
+ "text": "第三趟在剩下三根里找到 5,和排在前面的 8 交换。"
3748
3804
  }
3749
3805
  ]
3750
3806
  },
@@ -3753,7 +3809,7 @@
3753
3809
  "content": [
3754
3810
  {
3755
3811
  "type": "text",
3756
- "text": "第四趟:找到 6,排序完成。"
3812
+ "text": "第四趟找到 6,排序就完成了。"
3757
3813
  }
3758
3814
  ]
3759
3815
  },
@@ -3762,7 +3818,7 @@
3762
3818
  "content": [
3763
3819
  {
3764
3820
  "type": "text",
3765
- "text": "根节点 8 弹出来。"
3821
+ "text": "二叉搜索树从根节点 8 开始,一层一层往下长。"
3766
3822
  }
3767
3823
  ]
3768
3824
  },
@@ -3771,7 +3827,7 @@
3771
3827
  "content": [
3772
3828
  {
3773
3829
  "type": "text",
3774
- "text": "第二层:先画出两条边,4 和 12 依次弹出。"
3830
+ "text": "第二层先画边,再弹出节点:比 8 小的 4 在左,比 8 大的 12 在右。"
3775
3831
  }
3776
3832
  ]
3777
3833
  },
@@ -3780,7 +3836,7 @@
3780
3836
  "content": [
3781
3837
  {
3782
3838
  "type": "text",
3783
- "text": "第三层的四个叶子依次弹出。"
3839
+ "text": "第三层的四个叶子依次弹出,三层的树就完整了。"
3784
3840
  }
3785
3841
  ]
3786
3842
  },
@@ -3789,7 +3845,7 @@
3789
3845
  "content": [
3790
3846
  {
3791
3847
  "type": "text",
3792
- "text": "架子转到正面,三个圆盘叠在 A 柱上。"
3848
+ "text": "三个圆盘的汉诺塔,一共要移动七次。开始时三个圆盘都在 A 柱上。"
3793
3849
  }
3794
3850
  ]
3795
3851
  },
@@ -3798,7 +3854,7 @@
3798
3854
  "content": [
3799
3855
  {
3800
3856
  "type": "text",
3801
- "text": "前三步把上面两个圆盘挪到 B 柱,给最大的圆盘让路。"
3857
+ "text": "前三步先把上面两个挪到 B 柱,给最大的让路。"
3802
3858
  }
3803
3859
  ]
3804
3860
  },
@@ -3807,7 +3863,7 @@
3807
3863
  "content": [
3808
3864
  {
3809
3865
  "type": "text",
3810
- "text": "最大的圆盘从 A 移到 C。"
3866
+ "text": "第四步,最大的圆盘从 A 直接移到 C,这是七步的正中间。"
3811
3867
  }
3812
3868
  ]
3813
3869
  },
@@ -3816,7 +3872,7 @@
3816
3872
  "content": [
3817
3873
  {
3818
3874
  "type": "text",
3819
- "text": "最后三步把两个小圆盘从 B 移到 C 上,完成。"
3875
+ "text": "最后三步把两个小圆盘从 B 移到 C 上,七步完成。"
3820
3876
  }
3821
3877
  ]
3822
3878
  },
@@ -3825,7 +3881,7 @@
3825
3881
  "content": [
3826
3882
  {
3827
3883
  "type": "text",
3828
- "text": "四个位,从高到低是 8、4、2、1。"
3884
+ "text": "四个位,从高到低分别代表 8、4、2、1。"
3829
3885
  }
3830
3886
  ]
3831
3887
  },
@@ -3834,7 +3890,7 @@
3834
3890
  "content": [
3835
3891
  {
3836
3892
  "type": "text",
3837
- "text": "从 0 数到 15,最低位每次都翻转,进位从右向左传。"
3893
+ "text": "从 0 数到 15。最低位每次都翻,满二就向左进一位。"
3838
3894
  }
3839
3895
  ]
3840
3896
  },
@@ -3843,7 +3899,7 @@
3843
3899
  "content": [
3844
3900
  {
3845
3901
  "type": "text",
3846
- "text": "四个字依次出现,每个字是一个词元。"
3902
+ "text": "四个字依次出现,开始时每个字都是一个词元。"
3847
3903
  }
3848
3904
  ]
3849
3905
  },
@@ -3852,7 +3908,7 @@
3852
3908
  "content": [
3853
3909
  {
3854
3910
  "type": "text",
3855
- "text": "「机」与「器」、「学」与「习」两两合并:右边的词元收拢消失,左边的换成新词。"
3911
+ "text": "机和器、学和习两两合并。右边的收拢消失,左边的换成新词。"
3856
3912
  }
3857
3913
  ]
3858
3914
  },
@@ -3861,7 +3917,7 @@
3861
3917
  "content": [
3862
3918
  {
3863
3919
  "type": "text",
3864
- "text": "两个词再合并成一个词元「机器学习」。"
3920
+ "text": "最后两个词再合成一个词元:机器学习。"
3865
3921
  }
3866
3922
  ]
3867
3923
  },
@@ -3870,7 +3926,7 @@
3870
3926
  "content": [
3871
3927
  {
3872
3928
  "type": "text",
3873
- "text": "请求发到服务器,在那里停一下,变成响应回来,这一来一回就是 RTT。"
3929
+ "text": "请求发到服务器,在那里停一下,变成响应回来。这一来一回的时间叫往返时延。"
3874
3930
  }
3875
3931
  ]
3876
3932
  },
@@ -3888,7 +3944,7 @@
3888
3944
  "content": [
3889
3945
  {
3890
3946
  "type": "text",
3891
- "text": "hello 的 SHA-256 摘要从左到右从乱码中显现出来。"
3947
+ "text": "hello 的 SHA-256 摘要,从左到右一位一位显现出来。"
3892
3948
  }
3893
3949
  ]
3894
3950
  },
@@ -3897,7 +3953,7 @@
3897
3953
  "content": [
3898
3954
  {
3899
3955
  "type": "text",
3900
- "text": "把最后一个字母 o 改成 p,只差一个字母。"
3956
+ "text": "现在把最后一个字母 o 改成 p,输入只差这一个字母。"
3901
3957
  }
3902
3958
  ]
3903
3959
  },
@@ -3906,7 +3962,7 @@
3906
3962
  "content": [
3907
3963
  {
3908
3964
  "type": "text",
3909
- "text": "新的摘要每一位都可能变,看不出和原来的任何关系,这是雪崩效应。"
3965
+ "text": "可新的摘要每一位都可能变,看不出和原来有任何关系。这叫雪崩效应。"
3910
3966
  }
3911
3967
  ]
3912
3968
  }