本文是关于 Advent Of Code 2022 的。
编程圣诞日历，圣诞节前每天一个编程问题。

有兴趣的朋友可以在官网答题，用自己喜欢的编程方式去收集星星⭐️。在官网答题需要登陆并下载为你单独生成的谜题输入，每个人的都不一样。

问题

第十一天终于有点难度了，第一第二部分都是模拟猴子的行为，但是要在第二部分注意怎么解决数值越来越大的问题。

第一部分

当你终于开始逆流而上时，你发现你的背包比你记得的要轻得多。就在这时，你背包中的一件物品从头顶飞过。猴子在和你丢失的东西玩Keep Away!

为了找回你的东西，你需要能够预测猴子会把你的东西扔到哪里。经过仔细观察，你发现猴子的操作是基于 你对每件物品的担心程度 。

你做了一些笔记（你的谜题输入），记录了每只猴子目前拥有的物品，你对这些物品的担心程度，以及猴子如何根据你的担心程度做出决定。比如说。

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

Monkey 0:
  Starting items: 79, 98
  Operation: new = old * 19
  Test: divisible by 23
    If true: throw to monkey 2
    If false: throw to monkey 3

Monkey 1:
  Starting items: 54, 65, 75, 74
  Operation: new = old + 6
  Test: divisible by 19
    If true: throw to monkey 2
    If false: throw to monkey 0

Monkey 2:
  Starting items: 79, 60, 97
  Operation: new = old * old
  Test: divisible by 13
    If true: throw to monkey 1
    If false: throw to monkey 3

Monkey 3:
  Starting items: 74
  Operation: new = old + 3
  Test: divisible by 17
    If true: throw to monkey 0
    If false: throw to monkey 1

每只猴子都有几个属性。

• Starting items列出了你对猴子目前持有的每件物品的 担心程度 ，按照它们将被检查的顺序。
• Operation显示了当猴子检查物品时，你的担心程度如何变化。(像 new = old * 5 这样的操作意味着在猴子检查完物品后，你的担心程度是检查前担心程度的五倍。)
• Test显示了猴子如何使用你的担心程度来决定下一个物品的位置。
  • If true显示了如果Test是真的话，物品会发生什么。
  • If false显示了如果Test 是假的，物品会发生什么。

在每只猴子检查完一件物品后，但在测试你的担心程度之前，你对猴子的检查没有损坏物品的欣慰会使你的担心程度 除以3 ，并向下舍入到最近的整数。

猴子们轮流检查和投掷物品。在 一轮 中，它按照所列的顺序，一次检查并抛出它手中的所有物品。猴子 0 先来，然后是猴子 1 ，以此类推，直到每只猴子都转了一圈。

当一只猴子把物品扔给另一只猴子时，该物品就会被放在接受物品的猴子列表的 末端 。一只猴子如果开始时没有物品，那么在轮到它的时候，它可能已经检查并抛出了许多物品。如果一只猴子在它的回合开始时没有持有任何物品，它的回合就结束了。

在上面的例子中，第一轮的进行情况如下：

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

猴子 0:
  猴子检查物品时，担心程度为 79。
    担心程度乘以 19 到 1501。
    猴子对物品感到厌烦。担心的程度除以3到 500。
    目前的担心程度不能被 23 整除。
    担心等级为 500 的物品被扔给猴子 3。
  猴子检查物品时，担心程度为 98。
    担心程度乘以 19 到 1862。
    猴子对物品感到厌烦。担心的程度除以3到 620。
    目前的担心程度不能被 23 整除。
    担心等级为 620 的物品被扔给猴子 3。
猴子 1:
  猴子检查物品时，担心程度为 54。
    担心程度增加 6 至 60。
    猴子对物品感到厌烦。担心的程度除以3到 20。
    目前的担心程度不能被 19 整除。
    担心等级为 20 的物品被扔给猴子 0。
  猴子检查物品时，担心程度为 65。
    担心程度增加 6 至 71。
    猴子对物品感到厌烦。担心的程度除以3到 23。
    目前的担心程度不能被 19 整除。
    担心等级为 23 的物品被扔给猴子 0。
  猴子检查物品时，担心程度为 75。
    担心程度增加 6 至 81。
    猴子对物品感到厌烦。担心的程度除以3到 27。
    目前的担心程度不能被 19 整除。
    担心等级为 27 的物品被扔给猴子 0。
  猴子检查物品时，担心程度为 74。
    担心程度增加 6 至 80。
    猴子对物品感到厌烦。担心的程度除以3到 26。
    目前的担心程度不能被 19 整除。
    担心等级为 26 的物品被扔给猴子 0。
猴子 2:
  猴子检查物品时，担心程度为 79。
    担心程度乘以自己到 6241。
    猴子对物品感到厌烦。担心的程度除以3到 2080。
    目前的担心程度能够被 13 整除。
    担心等级为 2080 的物品被扔给猴子 1。
  猴子检查物品时，担心程度为 60。
    担心程度乘以自己到 3600。
    猴子对物品感到厌烦。担心的程度除以3到 1200。
    目前的担心程度不能被 13 整除。
    担心等级为 1200 的物品被扔给猴子 3。
  猴子检查物品时，担心程度为 97。
    担心程度乘以自己到 9409。
    猴子对物品感到厌烦。担心的程度除以3到 3136。
    目前的担心程度不能被 13 整除。
    担心等级为 3136 的物品被扔给猴子 3。
猴子 3:
  猴子检查物品时，担心程度为 74。
    担心程度增加 3 至 77。
    猴子对物品感到厌烦。担心的程度除以3到 25。
    目前的担心程度不能被 17 整除。
    担心等级为 25 的物品被扔给猴子 1。
  猴子检查物品时，担心程度为 500。
    担心程度增加 3 至 503。
    猴子对物品感到厌烦。担心的程度除以3到 167。
    目前的担心程度不能被 17 整除。
    担心等级为 167 的物品被扔给猴子 1。
  猴子检查物品时，担心程度为 620。
    担心程度增加 3 至 623。
    猴子对物品感到厌烦。担心的程度除以3到 207。
    目前的担心程度不能被 17 整除。
    担心等级为 207 的物品被扔给猴子 1。
  猴子检查物品时，担心程度为 1200。
    担心程度增加 3 至 1203。
    猴子对物品感到厌烦。担心的程度除以3到 401。
    目前的担心程度不能被 17 整除。
    担心等级为 401 的物品被扔给猴子 1。
  猴子检查物品时，担心程度为 3136。
    担心程度增加 3 至 3139。
    猴子对物品感到厌烦。担心的程度除以3到 1046。
    目前的担心程度不能被 17 整除。
    担心等级为 1046 的物品被扔给猴子 1。

第一轮结束后，猴子们持有的物品都有这些担心程度：

1
2
3
4

Monkey 0: 20, 23, 27, 26
Monkey 1: 2080, 25, 167, 207, 401, 1046
Monkey 2:
Monkey 3:

猴子2和3在这一轮结束时并没有拿着任何物品；它们都在这一轮中检查了物品，并在这一轮结束前把它们都扔了。

这个过程又持续了几轮。

同时追赶所有的猴子是不可能的；如果你想拿回你的东西，你必须集中精力对付 两只最活跃的猴子 。在20个回合中计算每只猴子检查物品的 总次数 。

1
2
3
4

Monkey 0 inspected items 101 times.
Monkey 1 inspected items 95 times.
Monkey 2 inspected items 7 times.
Monkey 3 inspected items 105 times.

在这个例子中，两只最活跃的猴子检查了101和105次物品。在这种情况下， 猴子的业务水平 可以通过相乘这些来找到 10605 。

通过计算猴子在20个回合内检查了多少件物品来计算出要追赶的猴子。 在20轮抡东西之后，猴子的业务水平是多少？

第二部分

你担心你可能永远无法拿回你的物品。事实上，你非常担心，以至于你因为猴子的检查没有损坏物品 不再使你的担心程度被除以3 。

不幸的是，这种松了一口气的感觉让你的担心程度没有达到 可笑的程度 。你需要 找到另一种方法来保持你的担心程度可控 。

按照这个速度，你可能要忍受这些猴子 很长一段时间 —— 可能是 10000个回合 !

有了这些新规则，你仍然可以在10000轮之后弄清猴子的事情。使用上述同样的例子：

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

== 第 1 轮之后 ==
Monkey 0 inspected items 2 times.
Monkey 1 inspected items 4 times.
Monkey 2 inspected items 3 times.
Monkey 3 inspected items 6 times.

== 第 20 轮之后 ==
Monkey 0 inspected items 99 times.
Monkey 1 inspected items 97 times.
Monkey 2 inspected items 8 times.
Monkey 3 inspected items 103 times.

== 第 1000 轮之后 ==
Monkey 0 inspected items 5204 times.
Monkey 1 inspected items 4792 times.
Monkey 2 inspected items 199 times.
Monkey 3 inspected items 5192 times.

== 第 2000 轮之后 ==
Monkey 0 inspected items 10419 times.
Monkey 1 inspected items 9577 times.
Monkey 2 inspected items 392 times.
Monkey 3 inspected items 10391 times.

== 第 3000 轮之后 ==
Monkey 0 inspected items 15638 times.
Monkey 1 inspected items 14358 times.
Monkey 2 inspected items 587 times.
Monkey 3 inspected items 15593 times.

== 第 4000 轮之后 ==
Monkey 0 inspected items 20858 times.
Monkey 1 inspected items 19138 times.
Monkey 2 inspected items 780 times.
Monkey 3 inspected items 20797 times.

== 第 5000 轮之后 ==
Monkey 0 inspected items 26075 times.
Monkey 1 inspected items 23921 times.
Monkey 2 inspected items 974 times.
Monkey 3 inspected items 26000 times.

== 第 6000 轮之后 ==
Monkey 0 inspected items 31294 times.
Monkey 1 inspected items 28702 times.
Monkey 2 inspected items 1165 times.
Monkey 3 inspected items 31204 times.

== 第 7000 轮之后 ==
Monkey 0 inspected items 36508 times.
Monkey 1 inspected items 33488 times.
Monkey 2 inspected items 1360 times.
Monkey 3 inspected items 36400 times.

== 第 8000 轮之后 ==
Monkey 0 inspected items 41728 times.
Monkey 1 inspected items 38268 times.
Monkey 2 inspected items 1553 times.
Monkey 3 inspected items 41606 times.

== 第 9000 轮之后 ==
Monkey 0 inspected items 46945 times.
Monkey 1 inspected items 43051 times.
Monkey 2 inspected items 1746 times.
Monkey 3 inspected items 46807 times.

== 第 10000 轮之后 ==
Monkey 0 inspected items 52166 times.
Monkey 1 inspected items 47830 times.
Monkey 2 inspected items 1938 times.
Monkey 3 inspected items 52013 times.

10000轮之后，两只最活跃的猴子检查了52166和52013次物品。把这些乘起来，这种情况下的 猴子业务水平 现在是 2713310158 。

在每件物品被检查后，担心程度不再被三除以；你需要找到另一种方法来保持你的担心程度可控。再从你的谜题输入中的初始状态开始， 10000轮后的猴子业务水平是多少？

本文是关于 Advent Of Code 2022 的。
编程圣诞日历，圣诞节前每天一个编程问题。

有兴趣的朋友可以在官网答题，用自己喜欢的编程方式去收集星星⭐️。在官网答题需要登陆并下载为你单独生成的谜题输入，每个人的都不一样。

问题

使用指令驱动CRT，但需要注意周期的情况。

第一部分

你避开绳索，跳进河里，游到岸边。

精灵们嚷嚷着要在上游与他们会合，但河水太大，无法准确分辨他们在说什么。他们过完桥，就从视野中消失了。

像这样的情况一定是精灵们优先考虑让你的手持设备上的通讯系统工作的原因。你把它从背包里拿出来，但屏幕上的一个大裂缝里慢慢流出的水告诉你，它可能不会有什么直接用途。

或许 ，你能为该设备的视频系统设计一个替代品 它似乎是某种阴极射线管屏幕和简单的CPU，它们都由一个精确的 时钟电路 驱动。时钟电路以恒定的速率跳动；每一次跳动被称为一个 周期 。

首先要弄清楚由CPU发送的信号。CPU有一个单一的寄存器，X，它的起始值为1。它只支持两条指令。

• addx V需要 两个周期 来完成。 在两个周期后 ，X寄存器增加了V的值。(V可以是负数)。
• noop需要 一个周期 来完成。它没有其他作用。

CPU在程序中使用这些指令（你的谜题输入），以某种方式告诉屏幕要画什么。

考虑一下下面这个小程序：

1
2
3

noop
addx 3
addx -5

这个程序的执行过程如下。

• 在第一个周期的开始，noop指令开始执行。在第一个周期中，X是1。在第一个周期后，noop指令结束执行，不做任何事情。
• 在第二个周期的开始，addx 3指令开始执行。在第二个循环中，X仍然是1。
• 在第三个周期中，X仍然是1。 在第三个周期后，addx 3指令结束执行，将X设置为4。
• 在第四个周期的开始，addx -5指令开始执行。在第四个周期中，X仍然是4。
• 在第五个周期中，X仍然是4。在第五个周期后，addx -5指令结束执行，将X设置为1。

也许你可以通过观察整个执行过程中X寄存器的值来了解一些情况。现在，考虑 在第20个周期和之后的每40个周期 （即在第20、60、100、140、180和220个周期）的 信号强度 （周期数乘以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
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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

addx 15
addx -11
addx 6
addx -3
addx 5
addx -1
addx -8
addx 13
addx 4
noop
addx -1
addx 5
addx -1
addx 5
addx -1
addx 5
addx -1
addx 5
addx -1
addx -35
addx 1
addx 24
addx -19
addx 1
addx 16
addx -11
noop
noop
addx 21
addx -15
noop
noop
addx -3
addx 9
addx 1
addx -3
addx 8
addx 1
addx 5
noop
noop
noop
noop
noop
addx -36
noop
addx 1
addx 7
noop
noop
noop
addx 2
addx 6
noop
noop
noop
noop
noop
addx 1
noop
noop
addx 7
addx 1
noop
addx -13
addx 13
addx 7
noop
addx 1
addx -33
noop
noop
noop
addx 2
noop
noop
noop
addx 8
noop
addx -1
addx 2
addx 1
noop
addx 17
addx -9
addx 1
addx 1
addx -3
addx 11
noop
noop
addx 1
noop
addx 1
noop
noop
addx -13
addx -19
addx 1
addx 3
addx 26
addx -30
addx 12
addx -1
addx 3
addx 1
noop
noop
noop
addx -9
addx 18
addx 1
addx 2
noop
noop
addx 9
noop
noop
noop
addx -1
addx 2
addx -37
addx 1
addx 3
noop
addx 15
addx -21
addx 22
addx -6
addx 1
noop
addx 2
addx 1
noop
addx -10
noop
noop
addx 20
addx 1
addx 2
addx 2
addx -6
addx -11
noop
noop
noop

这个输入的信号强度可以确定如下：

• 在第20个周期中，寄存器X的值是21，所以信号强度是20*21= 420 。(第20个周期发生在第二个addx -1的中间，所以寄存器X的值是起始值1，加上所有其他的addx值到这一点：1 + 15 - 11 + 6 - 3 + 5 - 1 - 8 + 13 + 4 = 21。)
• 在第60个周期，寄存器X的值为19，所以信号强度为60*19= 1140 。
• 在第100个周期，寄存器X的值是18，所以信号强度是100*18= 1800 。
• 在第140个周期，寄存器X的值为21，所以信号强度为140*21 = 2940 。
• 在第180个周期，寄存器X的值为16，所以信号强度为180*16 = 2880 。
• 在第220个周期，寄存器X的值是18，所以信号强度是220*18= 3960 。

这些信号强度的总和是 13140 。

找出第20、60、100、140、180和220个周期内的信号强度。 这六个信号强度之和是多少？

第二部分

似乎X寄存器控制了一个图形的水平位置。具体来说，图像的宽度为3像素，X寄存器设置该精灵的 中间的水平位置 。(在这个系统中，不存在 垂直位置 这种东西：如果精灵的水平位置将其像素放在CRT当前绘制的位置，那么这些像素将被绘制出来）。

你数数CRT上的像素：40个宽，6个高。这个CRT屏幕从左到右画出最上面的一行像素，然后是下面的一行，以此类推。每行的最左边的像素在0位置，每行的最右边的像素在39位置。

与CPU一样，CRT与时钟电路紧密相连：CRT在每个周期内 绘制一个像素 。将屏幕上的每个像素表示为一个 # ，这里是每行的第一个和最后一个像素被绘制的周期。

1
2
3
4
5
6

Cycle   1 -> ######################################## <- Cycle  40
Cycle  41 -> ######################################## <- Cycle  80
Cycle  81 -> ######################################## <- Cycle 120
Cycle 121 -> ######################################## <- Cycle 160
Cycle 161 -> ######################################## <- Cycle 200
Cycle 201 -> ######################################## <- Cycle 240

因此，通过仔细计时CPU指令和CRT绘制操作，你应该能够在每个像素被绘制的瞬间确定图像是否可见。如果图像的位置使其三个像素中的一个是当前正在绘制的像素，那么屏幕上就会产生一个 亮的 像素（#）；否则，屏幕上就会留下该像素的 暗 的像素（.）。

上面这个较大的例子中的前几个像素的绘制方法如下：

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

图像位置: ###.....................................

开始周期    1: 开始执行  addx 15
经过周期  1: CRT绘制像素于位置 0
当前CRT: #

经过周期  2: CRT绘制像素于位置 1
当前CRT: ##
结束周期   2: 完成执行 addx 15 (寄存器X的值为 16)
图像位置: ...............###......................

开始周期  3: 开始执行  addx -11
经过周期  3: CRT绘制像素于位置 2
当前CRT: ##.

经过周期  4: CRT绘制像素于位置 3
当前CRT: ##..
结束周期   4: 完成执行 addx -11 (寄存器X的值为 5)
图像位置: ....###.................................

开始周期    5: 开始执行  addx 6
经过周期  5: CRT绘制像素于位置 4
当前CRT: ##..#

经过周期  6: CRT绘制像素于位置 5
当前CRT: ##..##
结束周期   6: 完成执行 addx 6 (寄存器X的值为 11)
图像位置: ..........###...........................

开始周期    7: 开始执行  addx -3
经过周期  7: CRT绘制像素于位置 6
当前CRT: ##..##.

经过周期  8: CRT绘制像素于位置 7
当前CRT: ##..##..
结束周期   8: 完成执行 addx -3 (寄存器X的值为 8)
图像位置: .......###..............................

开始周期    9: 开始执行  addx 5
经过周期  9: CRT绘制像素于位置 8
当前CRT: ##..##..#

经过周期 10: CRT绘制像素于位置 9
当前CRT: ##..##..##
结束周期  10: 完成执行 addx 5 (寄存器X的值为 13)
图像位置: ............###.........................

开始周期   11: 开始执行  addx -1
经过周期 11: CRT绘制像素于位置 10
当前CRT: ##..##..##.

经过周期 12: CRT绘制像素于位置 11
当前CRT: ##..##..##..
结束周期  12: 完成执行 addx -1 (寄存器X的值为 12)
图像位置: ...........###..........................

开始周期   13: 开始执行  addx -8
经过周期 13: CRT绘制像素于位置 12
当前CRT: ##..##..##..#

经过周期 14: CRT绘制像素于位置 13
当前CRT: ##..##..##..##
结束周期  14: 完成执行 addx -8 (寄存器X的值为 4)
图像位置: ...###..................................

开始周期   15: 开始执行  addx 13
经过周期 15: CRT绘制像素于位置 14
当前CRT: ##..##..##..##.

经过周期 16: CRT绘制像素于位置 15
当前CRT: ##..##..##..##..
结束周期  16: 完成执行 addx 13 (寄存器X的值为 17)
图像位置: ................###.....................

开始周期   17: 开始执行  addx 4
经过周期 17: CRT绘制像素于位置 16
当前CRT: ##..##..##..##..#

经过周期 18: CRT绘制像素于位置 17
当前CRT: ##..##..##..##..##
结束周期  18: 完成执行 addx 4 (寄存器X的值为 21)
图像位置: ....................###.................

开始周期   19: 开始执行  noop
经过周期 19: CRT绘制像素于位置 18
当前CRT: ##..##..##..##..##.
结束周期  19: 完成执行 noop

开始周期   20: 开始执行  addx -1
经过周期 20: CRT绘制像素于位置 19
当前CRT: ##..##..##..##..##..

经过周期 21: CRT绘制像素于位置 20
当前CRT: ##..##..##..##..##..#
结束周期  21: 完成执行 addx -1 ( 20)
图像位置: ...................###..................

让程序运行到完成，使CRT产生以下图像：

1
2
3
4
5
6

##..##..##..##..##..##..##..##..##..##..
###...###...###...###...###...###...###.
####....####....####....####....####....
#####.....#####.....#####.....#####.....
######......######......######......####
#######.......#######.......#######.....

渲染你的程序所给的图像。 你的CRT上出现哪八个大写字母？

本文是关于 Advent Of Code 2022 的。
编程圣诞日历，圣诞节前每天一个编程问题。

有兴趣的朋友可以在官网答题，用自己喜欢的编程方式去收集星星⭐️。在官网答题需要登陆并下载为你单独生成的谜题输入，每个人的都不一样。

问题

在头移动的时候移动绳子的绳段。

第一部分

当你在桥上行走时，这座绳索桥吱吱作响。你不确定它有多老，或者它是否能支撑你的体重。

不过，它似乎可以支撑精灵们的体重。这座桥横跨一个峡谷，这个峡谷是由远在你下面的大河开凿出来的。

你小心翼翼地走着；当你这样做时，绳索就会伸展和扭曲。你决定通过建立绳索物理模型来分散自己的注意力；也许你甚至可以想出 不 走上去的地方。

考虑到一根绳子的两端都有一个结；这些结标志着绳子的 头 和 尾 。如果头部离尾部足够远，尾部就会被拉向头部。

由于涉及普朗克长度的模糊推理，你应该能够在一个二维网格上建立结的位置模型。然后，通过对头部进行一系列 假设的运动 （你的谜题输入），你可以确定尾部将如何移动。

由于前面提到的普朗克长度，绳子必须相当短；事实上，头部（H）和尾部（T）必须 一直接触 （对角线相邻，甚至重叠都算作接触）：

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

....
.TH.
....

....
.H..
..T.
....

...
.H. (H 覆盖 T)
...

如果头离尾巴直接上、下、左、右两步，尾巴也必须朝这个方向移动一步，以便保持足够的距离：

1
2
3
4
5
6
7
8
9
10

.....    .....    .....
.TH.. -> .T.H. -> ..TH.
.....    .....    .....

...    ...    ...
.T.    .T.    ...
.H. -> ... -> .T.
...    .H.    .H.
...    ...    ...

否则，如果头和尾没有接触，而且不在同一行或同一列，尾巴总是斜着走一步来跟上：

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

.....    .....    .....
.....    ..H..    ..H..
..H.. -> ..... -> ..T..
.T...    .T...    .....
.....    .....    .....

.....    .....    .....
.....    .....    .....
..H.. -> ...H. -> ..TH.
.T...    .T...    .....
.....    .....    .....

你只需要计算出在头部做一系列动作时，尾巴的去向。假设头部和尾部都从同一位置开始，重叠在一起。

比如说：

1
2
3
4
5
6
7
8

R 4
U 4
L 3
D 1
R 4
D 1
L 5
R 2

这一系列的动作使头部 向右 四步，然后 向上 四步，然后 向左 三步，然后 向下 一步，如此反复。每一步之后，如果这一步意味着头部不再与尾部相邻，你就需要更新尾部的位置。从视觉上看，这些运动发生如下（s标志着作为参考点的起始位置）。

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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168

== 初始态 ==

......
......
......
......
H.....  (H 覆盖 T, s)

== R 4 ==

......
......
......
......
TH....  (T 覆盖 s)

......
......
......
......
sTH...

......
......
......
......
s.TH..

......
......
......
......
s..TH.

== U 4 ==

......
......
......
....H.
s..T..

......
......
....H.
....T.
s.....

......
....H.
....T.
......
s.....

....H.
....T.
......
......
s.....

== L 3 ==

...H..
....T.
......
......
s.....

..HT..
......
......
......
s.....

.HT...
......
......
......
s.....

== D 1 ==

..T...
.H....
......
......
s.....

== R 4 ==

..T...
..H...
......
......
s.....

..T...
...H..
......
......
s.....

......
...TH.
......
......
s.....

......
....TH
......
......
s.....

== D 1 ==

......
....T.
.....H
......
s.....

== L 5 ==

......
....T.
....H.
......
s.....

......
....T.
...H..
......
s.....

......
......
..HT..
......
s.....

......
......
.HT...
......
s.....

......
......
HT....
......
s.....

== R 2 ==

......
......
.H....  (H 覆盖 T)
......
s.....

......
......
.TH...
......
s.....

模拟绳索后，你可以计算出 尾巴至少访问过一次的所有位置 。在这个图中，s再次标记了起始位置（尾巴也访问了这个位置），#标记了尾巴访问的其他位置：

1
2
3
4
5

..##..
...##.
.####.
....#.
s###..

因此，有 13 个位置的尾巴至少去过一次。

模拟你完整的运动。 绳子的尾巴至少去过多少个位置？

第二部分

绳索断裂了! 突然间，河水变得比你记忆中的要近得多。桥还在那里，但一些断裂的绳索现在正向你呼啸而来，你在空中坠落！这时，你必须抓住绳索。

绳索的移动速度太快，你无法抓住；你只有几秒钟的时间来选择如何拱起你的身体以避免被击中。幸运的是，你的模拟可以扩展到支持更长的绳索。

你现在必须模拟由 十个 结组成的绳子，而不是两个结。一个结仍然是绳子的头，并根据一系列的动作来移动。再往下的每一个绳结都按照之前的规则跟随前面的绳结。

使用与上例相同的运动系列，但标有 H, 1, 2, …, 9 的绳结，现在的运动情况如下。

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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168

== 初始态 ==

......
......
......
......
H.....  (H 覆盖 1, 2, 3, 4, 5, 6, 7, 8, 9, s)

== R 4 ==

......
......
......
......
1H....  (1 覆盖 2, 3, 4, 5, 6, 7, 8, 9, s)

......
......
......
......
21H...  (2 覆盖 3, 4, 5, 6, 7, 8, 9, s)

......
......
......
......
321H..  (3 覆盖 4, 5, 6, 7, 8, 9, s)

......
......
......
......
4321H.  (4 覆盖 5, 6, 7, 8, 9, s)

== U 4 ==

......
......
......
....H.
4321..  (4 覆盖 5, 6, 7, 8, 9, s)

......
......
....H.
.4321.
5.....  (5 覆盖 6, 7, 8, 9, s)

......
....H.
....1.
.432..
5.....  (5 覆盖 6, 7, 8, 9, s)

....H.
....1.
..432.
.5....
6.....  (6 覆盖 7, 8, 9, s)

== L 3 ==

...H..
....1.
..432.
.5....
6.....  (6 覆盖 7, 8, 9, s)

..H1..
...2..
..43..
.5....
6.....  (6 覆盖 7, 8, 9, s)

.H1...
...2..
..43..
.5....
6.....  (6 覆盖 7, 8, 9, s)

== D 1 ==

..1...
.H.2..
..43..
.5....
6.....  (6 覆盖 7, 8, 9, s)

== R 4 ==

..1...
..H2..
..43..
.5....
6.....  (6 覆盖 7, 8, 9, s)

..1...
...H..  (H 覆盖 2)
..43..
.5....
6.....  (6 覆盖 7, 8, 9, s)

......
...1H.  (1 覆盖 2)
..43..
.5....
6.....  (6 覆盖 7, 8, 9, s)

......
...21H
..43..
.5....
6.....  (6 覆盖 7, 8, 9, s)

== D 1 ==

......
...21.
..43.H
.5....
6.....  (6 覆盖 7, 8, 9, s)

== L 5 ==

......
...21.
..43H.
.5....
6.....  (6 覆盖 7, 8, 9, s)

......
...21.
..4H..  (H 覆盖 3)
.5....
6.....  (6 覆盖 7, 8, 9, s)

......
...2..
..H1..  (H 覆盖 4; 1 覆盖 3)
.5....
6.....  (6 覆盖 7, 8, 9, s)

......
...2..
.H13..  (1 覆盖 4)
.5....
6.....  (6 覆盖 7, 8, 9, s)

......
......
H123..  (2 覆盖 4)
.5....
6.....  (6 覆盖 7, 8, 9, s)

== R 2 ==

......
......
.H23..  (H 覆盖 1; 2 覆盖 4)
.5....
6.....  (6 覆盖 7, 8, 9, s)

......
......
.1H3..  (H 覆盖 2, 4)
.5....
6.....  (6 覆盖 7, 8, 9, s)

现在，你需要跟踪新的尾巴9访问的位置。在这个例子中，尾巴从不移动，所以它只访问 1 的位置。然而， 要小心 比以前可能有更多的运动类型，所以你可能想把你模拟的绳子和上面的绳子进行视觉上的比较。

这里有一个更大的例子。

1
2
3
4
5
6
7
8

R 5
U 8
L 8
D 3
R 17
D 10
L 25
U 20

这些运动发生如下（个别步骤没有显示）：

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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216

== 初始态 ==

..........................
..........................
..........................
..........................
..........................
..........................
..........................
..........................
..........................
..........................
..........................
..........................
..........................
..........................
..........................
...........H..............  (H 覆盖 1, 2, 3, 4, 5, 6, 7, 8, 9, s)
..........................
..........................
..........................
..........................
..........................

== R 5 ==

..........................
..........................
..........................
..........................
..........................
..........................
..........................
..........................
..........................
..........................
..........................
..........................
..........................
..........................
..........................
...........54321H.........  (5 覆盖 6, 7, 8, 9, s)
..........................
..........................
..........................
..........................
..........................

== U 8 ==

..........................
..........................
..........................
..........................
..........................
..........................
..........................
................H.........
................1.........
................2.........
................3.........
...............54.........
..............6...........
.............7............
............8.............
...........9..............  (9 覆盖 s)
..........................
..........................
..........................
..........................
..........................

== L 8 ==

..........................
..........................
..........................
..........................
..........................
..........................
..........................
........H1234.............
............5.............
............6.............
............7.............
............8.............
............9.............
..........................
..........................
...........s..............
..........................
..........................
..........................
..........................
..........................

== D 3 ==

..........................
..........................
..........................
..........................
..........................
..........................
..........................
..........................
.........2345.............
........1...6.............
........H...7.............
............8.............
............9.............
..........................
..........................
...........s..............
..........................
..........................
..........................
..........................
..........................

== R 17 ==

..........................
..........................
..........................
..........................
..........................
..........................
..........................
..........................
..........................
..........................
................987654321H
..........................
..........................
..........................
..........................
...........s..............
..........................
..........................
..........................
..........................
..........................

== D 10 ==

..........................
..........................
..........................
..........................
..........................
..........................
..........................
..........................
..........................
..........................
..........................
..........................
..........................
..........................
..........................
...........s.........98765
.........................4
.........................3
.........................2
.........................1
.........................H

== L 25 ==

..........................
..........................
..........................
..........................
..........................
..........................
..........................
..........................
..........................
..........................
..........................
..........................
..........................
..........................
..........................
...........s..............
..........................
..........................
..........................
..........................
H123456789................

== U 20 ==

H.........................
1.........................
2.........................
3.........................
4.........................
5.........................
6.........................
7.........................
8.........................
9.........................
..........................
..........................
..........................
..........................
..........................
...........s..............
..........................
..........................
..........................
..........................
..........................

现在，尾巴（9）访问了 36 个位置（包括s）至少一次。

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

..........................
..........................
..........................
..........................
..........................
..........................
..........................
..........................
..........................
#.........................
#.............###.........
#............#...#........
.#..........#.....#.......
..#..........#.....#......
...#........#.......#.....
....#......s.........#....
.....#..............#.....
......#............#......
.......#..........#.......
........#........#........
.........########.........

在一根有10个结的大绳上模拟你的一系列动作。 绳子的尾巴至少到过多少个位置？

本文是关于 Advent Of Code 2022 的。
编程圣诞日历，圣诞节前每天一个编程问题。

有兴趣的朋友可以在官网答题，用自己喜欢的编程方式去收集星星⭐️。在官网答题需要登陆并下载为你单独生成的谜题输入，每个人的都不一样。

问题

找到一个 Grid 里面一个点的能见度。

第一部分

探险队遇到了一片奇特的高大树木，它们都被小心翼翼地种植在一个网格中。精灵们解释说，以前的探险队种植这些树木是为了重新造林。现在，他们很好奇这里是否是建造树屋的好地方。

首先，确定这里是否有足够的树木覆盖，以保持树屋的 隐蔽性 。要做到这一点，你需要计算从网格外直接沿某一行或某一列观察时 可见的树 的数量。

精灵们已经发射了一架四轴飞行器来生成一张有每棵树高度的地图（你的谜题输入）。比如说：

1
2
3
4
5

30373
25512
65332
33549
35390

每棵树都用一个数字表示，其值是它的高度，其中0是最短的，9是最高的。

如果一棵树和网格边缘之间的所有其他树都比它 短 ，那么该树就是 可见的 。只考虑同一行或同一列的树；也就是说，只从任何给定的树上、下、左或右看。

网格边缘的所有树木都是 可见的 ，因为它们已经在边缘了，所以没有树木阻挡视线。在这个例子中，只剩下 内部的九棵树 需要考虑。

• 左上角的 5 从左边和上面是 可见 的（从右边和下面不可见，因为其他高度为 5 的树挡住了）。
• 中上层的5从顶部和右侧都是 可见 的。
• 右上角的 1 从任何方向都不可见；要使其可见，需要在其与边缘之间只有高度为 0 的树。
• 左中的5是 可见 的，但只能从右边看。
• 中间的3从任何方向都是不可见的；如果它是可见的，在它和一条边之间最多只有高度为2的树。
• 右侧中间的3从右边是 可见 的。
• 在底排，中间的5是 可见 的，但3和4不是。

边缘有16棵树是可见的，内部还有5棵树是可见的，在这种安排下，总共有 21 棵树是可见的。

考虑一下你的地图； 从网格外可以看到多少棵树？

第二部分

精灵们对现有的树木覆盖量感到满意，他们只需要知道建造树屋的最佳地点：他们希望能够看到很多*树。

要测量从某棵树上看到的距离，从那棵树往上、往下、往左、往右看；如果你走到一个边缘或在第一棵与考虑中的树相同高度或更高的树上，就停下来。(如果一棵树正处于边缘，至少有一个观察距离是零。）

精灵们并不关心比上述规则找到的树更高的远处的树；提议的树屋有很大的屋檐以保持干燥，所以无论如何他们都无法看到比树屋更高的地方。

在上面的例子中，考虑第二行中的5：

1
2
3
4
5

30373
25512
65332
33549
35390

• 向上看，它的视线没有被阻挡；它可以看到 1 树（高度为3）。
• 向左看，它的视线立即被挡住了；它只能看到 1 棵树（高度为5，就在它旁边）。
• 向右看，它的视线没有被挡住；它可以看到 2 棵树。
• 向下看，它的视线最终被挡住了；它可以看到 2 棵树（一棵高度为3，然后是挡住它视线的高度为5的树）。

一棵树的 风景得分 是通过 乘以 它在四个方向上的观察距离而得到的。对于这棵树，这是 4 （通过乘以1*1*2*2找到）。

然而，你可以做得更好：考虑第四行中间高度为5的树：

1
2
3
4
5

30373
25512
65332
33549
35390

• 向上看，它的视线被 2 棵树挡住（被另一棵5高度的树挡住）。
• 向左看，它的视线没有被挡住；它可以看到 2 棵树。
• 向下看，它的视线也没有被阻挡；它可以看到 1 棵树。
• 向右看，它的视线被 2 棵树挡住了（被一棵高度为9的大树）。

这棵树的风景得分是 8 （2*2*1*2）；这是建造树屋的理想地点。

考虑一下你地图上的每棵树。 任何一棵树的最高景观得分是多少？

本文是关于 Advent Of Code 2022 的。
编程圣诞日历，圣诞节前每天一个编程问题。

有兴趣的朋友可以在官网答题，用自己喜欢的编程方式去收集星星⭐️。在官网答题需要登陆并下载为你单独生成的谜题输入，每个人的都不一样。

问题

把一个终端的输入输出变成一个树状结构。

第一部分

随着考察的进行，你可以听到鸟儿的鸣叫和雨滴打在树叶上的声音。偶尔，你甚至能听到远处更响亮的声音；这里的动物到底有多大？

精灵们给你的设备不仅在通信系统上有问题。你试着运行一个系统更新：

1

$ system-update --please --pretty-please-with-sugar-on-top

也许你可以删除一些文件来为更新腾出空间？

你在文件系统中浏览以评估情况，并保存终端输出结果（你的谜题输入）。比如说：

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

$ cd /
$ ls
dir a
14848514 b.txt
8504156 c.dat
dir d
$ cd a
$ ls
dir e
29116 f
2557 g
62596 h.lst
$ cd e
$ ls
584 i
$ cd ..
$ cd ..
$ cd d
$ ls
4060174 j
8033020 d.log
5626152 d.ext
7214296 k

文件系统由文件（普通数据）和目录（可以包含其他目录或文件）组成的树状结构。最外层的目录被称为/。
你可以在文件系统中导航，进入或离开目录，并列出你当前所在目录的内容。

在终端输出中，以$开头的行是你执行的 命令 ，非常像一些现代计算机。

• cd意味着 改变目录 。这将改变哪个目录是当前目录，但具体结果取决于参数。

  • cd x移动 一级 ：它在当前目录中寻找名为x的目录并使其成为当前目录。
  • cd ..移出 一级 ：它寻找包含当前目录的目录，然后使该目录成为当前目录。
  • cd /将当前目录切换到最外层的目录，/。

• ls意味着 列表 。它打印出当前目录所有文件和目录。

  • 123 abc表示当前目录包含一个名为abc的文件，大小为123。
  • dir xyz表示当前目录包含一个名为xyz的目录。

考虑到上面例子中的命令和输出，你可以确定文件系统在视觉上看起来像这样：

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

- / (dir)
  - a (dir)
    - e (dir)
      - i (file, size=584)
    - f (file, size=29116)
    - g (file, size=2557)
    - h.lst (file, size=62596)
  - b.txt (file, size=14848514)
  - c.dat (file, size=8504156)
  - d (dir)
    - j (file, size=4060174)
    - d.log (file, size=8033020)
    - d.ext (file, size=5626152)
    - k (file, size=7214296)

这里，有四个目录。/（最外层的目录），a和d（在/中），以及e（在a中）。这些目录还包含不同大小的文件。

由于磁盘已满，你的第一步可能应该是找到适合删除的目录。要做到这一点，你需要确定每个目录的 总大小
。一个目录的总大小是它直接或间接包含的文件大小之和。(目录本身不算是有任何内在的大小)。

上述目录的总大小可以通过以下方式找到。

• 目录e的总大小是 584 ，因为它包含一个大小为584的文件i，没有其他目录。
• 目录a的总大小为 94853 ，因为它包含文件f（大小为29116），g（大小为2557），和h.lst（大小为62596），加上文件i
  间接地（a包含e，e包含i）。
• 目录d的总大小为 24933642 。
• 作为最外层的目录，/包含每个文件。它的总大小是 48381165 ，是每个文件的大小之和。

首先，找到所有总大小为 最多100000 的目录，然后计算它们的总大小之和。在上面的例子中，这些目录是a和e；它们的总大小之和是 95437 （94853 + 584）。(在这个例子中，这个过程可以不止一次地计算文件！)

找到所有总大小最多为100000的目录。 这些目录的总大小之和是多少？

第二部分

现在，你准备选择一个目录来删除。

文件系统可用的总磁盘空间是 70000000 。为了运行更新，你需要至少有 30000000 的未使用空间。你需要找到一个可以删除的目录，它将 释放出足够的空间 来运行更新。

在上面的例子中，最外层目录的总大小（也就是已使用空间的总量）是48381165；这意味着 未使用 空间的大小目前必须是21618835，这还没有达到更新所要求的30000000。因此，更新仍然需要在运行前删除一个总大小至少为8381165的目录。

为了达到这个目的，你有以下选择。

• 删除目录e，这将增加584的未使用空间。
• 删除目录a，这将增加94853的未使用空间。
• 删除目录d，这将增加24933642的未使用空间。
• 删除目录/，这将增加48381165的未使用空间。

目录e和a都太小了；删除它们将不能释放足够的空间。然而，目录d和/都足够大！在这两者之间，选择 小的 。在这两个目录中，选择 小的 一个。d，增加未使用空间 24933642 。

找到最小的目录，如果删除它，将在文件系统上释放足够的空间来运行更新。 该目录的总大小是多少？

本文是关于 Advent Of Code 2022 的。
编程圣诞日历，圣诞节前每天一个编程问题。

有兴趣的朋友可以在官网答题，用自己喜欢的编程方式去收集星星⭐️。在官网答题需要登陆并下载为你单独生成的谜题输入，每个人的都不一样。

问题

给出一个字符串，让你找出第一个 n 个字符都不相同的位置。

第一部分

准备工作终于完成了；你和精灵们步行离开营地，开始向 星 果树林进发。

当你穿过茂密的树丛时，其中一个精灵给了你一个手持 设备 。他说，它有很多花哨的功能，但现在最重要的是设置 通信系统 。

然而，因为他听说你有与处理基于信号的系统的经验，他说服了其他精灵，把他们那个出故障的设备给你也无妨–你修好它肯定不会有问题。

仿佛是受到了喜剧时机的启发，该设备发出了一些五颜六色的火花。

为了能够与精灵族沟通，该设备需要 锁定他们的信号 。该信号是一系列看似随机的字符，设备一次接收一个。

为了修复通信系统，你需要在设备上添加一个子程序，检测数据流中的 开始包标记 。在精灵族使用的协议中，一个数据包的开始是由 *
四个不同的字符序列* 来表示的。

设备将向你的子程序发送一个 数据流缓冲区（你的谜题输入）；你的子程序需要识别最近收到的四个字符全部不同的第一个位置。具体来说，它需要报告从缓冲区开始到第一个这样的四个字符标记结束的字符数。

例如，假设你收到以下数据流缓冲区：

1

mjqjpqmgbljsphdztnvjfqwrcgsmlb

在收到前三个字符（mjq
）后，还没有收到足够的字符来寻找标记。第一次可能出现的标记是在收到第四个字符后，使最近的四个字符为mjqj。因为j
是重复的，这不是一个标记。

标记的第一次出现是在 第七个 字符到达之后。一旦它出现，最后收到的四个字符是jpqm，这都是不同的。在这种情况下，你的子程序应该报告值
7 ，因为在处理了7个字符后，第一个包开始标记就完成了。

这里还有几个例子：

• bvwbjplbgvbhsrlpgdmjqwftvncz: 第一个标记于 5
• nppdvjthqldpwncqszvftbrmjlhg: 第一个标记于 6
• nznrnfrfntjfmvfwmzdfjlvtqnbhcprsg: 第一个标记于 10
• zcfzfwzzqfrljwzlrfnpqdbhtmscgvjw: 第一个标记于 11

在检测到第一个数据包开始标记之前，需要处理多少个字符？

第二部分

你的设备的通信系统正确地检测到了数据包，但仍然没有工作。看起来它还需要寻找 消息 。

一个 消息开始标记 就像一个数据包开始标记，只是它由 14个不同的字符 组成，而不是4个。

下面是上述所有例子中信息开始标记的第一个位置：

• mjqjpqmgbljsphdztnvjfqwrcgsmlb: 第一个标记于 19
• bvwbjplbgvbhsrlpgdmjqwftvncz: 第一个标记于 23
• nppdvjthqldpwncqszvftbrmjlhg: 第一个标记于 23
• nznrnfrfntjfmvfwmzdfjlvtqnbhcprsg: 第一个标记于 29
• zcfzfwzzqfrljwzlrfnpqdbhtmscgvjw: 第一个标记于 26

在检测到第一个数据包开始标记之前，需要处理多少个字符？

本文是关于 Advent Of Code 2022 的。
编程圣诞日历，圣诞节前每天一个编程问题。

有兴趣的朋友可以在官网答题，用自己喜欢的编程方式去收集星星⭐️。在官网答题需要登陆并下载为你单独生成的谜题输入，每个人的都不一样。

问题

移动箱子部分不是很复杂，只要按照指示操作就好，这题比较有趣的地方在于写出解析初始状态的解析器。

第一部分

一旦最后的物资从船上卸下，探险队就可以出发了。补给品被存放在一堆有标记的 箱 中，但由于需要的补给品被埋在许多其他箱子下面，所以箱子需要重新排列。

船上有一个 巨大的货物起重机 ，能够在堆栈之间移动板条箱。为了确保没有一个板条箱被压碎或倒下，起重机操作员将通过一系列精心策划的步骤重新安排它们。在板条箱被重新排列后，所需的板条箱将在每个堆栈的顶部。

精灵们不想在这个微妙的过程中打断起重机操作员，但他们忘了问她 哪个 板条箱最后会在哪里，而且他们想尽快准备好卸货，以便他们能够登船。

然而，他们确实有一张开始堆放的板条箱的图纸 和 重新排列的程序（你的谜题输入）。比如说：

1
2
3
4
5
6
7
8
9

    [D]    
[N] [C]    
[Z] [M] [P]
 1   2   3

move 1 from 2 to 1
move 3 from 1 to 3
move 2 from 2 to 1
move 1 from 1 to 2

在这个例子中，有三个堆栈的板条箱。堆栈1包含两个箱子：箱子Z在底部，箱子N
在顶部。堆栈2包含三个箱子；从下到上，它们是箱子M，C，和D。最后，堆栈3包含一个板条箱，P。

然后，给出了重新排列的程序。在程序的每一步中，一定数量的板条箱被从一个堆栈移到另一个堆栈。在上述重排程序的第一步中，一个板条箱从堆栈2移到堆栈1，形成了这种配置。

1
2
3
4

[D]        
[N] [C]    
[Z] [M] [P]
 1   2   3

在第二步中，三个板条箱被从堆栈1移到堆栈3。板条箱是 一个个移动 的，所以第一个被移动的板条箱（D）最后会在第二和第三个板条箱下面。

1
2
3
4
5

       [Z]
       [N]
   [C] [D]
   [M] [P]
1   2   3

然后，两个板条箱都从堆栈2移到堆栈1。同样，因为箱子是 一个个移动 的，所以箱子C最后会在箱子M下面。

1
2
3
4
5

        [Z]
        [N]
[M]     [D]
[C]     [P]
 1   2   3

最后，一个板条箱从堆栈1移到堆栈2。

1
2
3
4
5

        [Z]
        [N]
        [D]
[C] [M] [P]
 1   2   3

精灵们只需要知道 哪个板条箱最终会在每个堆栈的顶部 ；在这个例子中，顶部的板条箱是堆栈1中的C，堆栈2中的M
，以及堆栈3中的Z，所以你应该把这些结合起来，给精灵们一个信息 CMZ 。

在重新排列程序完成后，每个堆栈顶部的板条箱最终是什么？

第二部分

当你看着起重机操作员熟练地重新排列板条箱时，你注意到这个过程并没有按照你的预测进行。

一些泥巴覆盖在起重机侧面的字迹上，你赶紧把它擦掉。这台起重机不是 箱子移动机9000 - 它是 箱子移动机9001 。

箱子移动机9001值得注意的是许多新的和令人兴奋的功能：空调、皮革座椅、一个额外的杯架，以及 能够同时拿起和移动多个箱子 。

再次考虑上面的例子，板条箱开始时的配置是一样的。

1
2
3
4

    [D]    
[N] [C]    
[Z] [M] [P]
 1   2   3