按键A，Ctrl + A，Ctrl + C和Ctrl + V的最大字符数

这是来自谷歌的面试问题。 我无法自己解决。 有人可以点亮吗？

编写一个程序来打印按键序列，以便生成最大数量的字符“A”。 您只能使用4个键： A ， Ctrl + A ， Ctrl + C和Ctrl + V。 只允许N个击键。 所有Ctrl +字符被认为是一个按键，所以Ctrl + A是一个按键。

例如，序列A ， Ctrl + A ， Ctrl + C ， Ctrl + V在4个按键中生成两个A。

• Ctrl + A是全选
• Ctrl + C是复制
• Ctrl + V是粘贴

我做了一些math。 对于任何N，使用A的x个数，一个Ctrl + A ，一个Ctrl + C和y Ctrl + V ，我们可以生成A的最大（（N-1）/ 2） ²个数。 对于某些N> M，最好使用更多的Ctrl + A ， Ctrl + C和Ctrl + V序列，因为它将A的数量加倍。

顺序Ctrl + A ， Ctrl + V ， Ctrl + C不会覆盖现有select。 它会将复制的选项追加到选定的选项上。

Answer 1

通过使用marcog的解决scheme，我发现了一个从n=16开始的模式。 为了说明这里是n=24到n=29的击键，我用S（select）replace^ A，用C（copy）replace^ C，用P（paste）replace^ V以提高可读性：

 24: A,A,A,A,S,C,P,P,P,S,C,P,P,P,S,C,P,P,P,S,C,P,P,P 4 * 4 * 4 * 4 * 4 = 1024 25: A,A,A,A,S,C,P,P,P,S,C,P,P,S,C,P,P,S,C,P,P,S,C,P,P 4 * 4 * 3 * 3 * 3 * 3 = 1296 26: A,A,A,A,S,C,P,P,P,S,C,P,P,P,S,C,P,P,S,C,P,P,S,C,P,P 4 * 4 * 4 * 3 * 3 * 3 = 1728 27: A,A,A,A,S,C,P,P,P,S,C,P,P,P,S,C,P,P,P,S,C,P,P,S,C,P,P 4 * 4 * 4 * 4 * 3 * 3 = 2304 28: A,A,A,A,S,C,P,P,P,S,C,P,P,P,S,C,P,P,P,S,C,P,P,P,S,C,P,P 4 * 4 * 4 * 4 * 4 * 3 = 3072 29: A,A,A,A,S,C,P,P,P,S,C,P,P,P,S,C,P,P,P,S,C,P,P,P,S,C,P,P,P 4 * 4 * 4 * 4 * 4 * 4 = 4096 

最初的4个字符后，理想的模式是select，复制，粘贴，粘贴，粘贴和重复。 这将每5个按键乘以4的数量。 如果这5个击键模式不能自己消耗其余的击键，则一些数量的4个击键模式（SCPP）消耗最终的击键，根据需要replaceSCPPP（或移除其中一个贴）。 4个按键模式每4个按键将总数乘以3。

在这里使用这个模式是一些Python代码，得到与marcog的解决scheme相同的结果，但是O（1） 编辑 ：这实际上是O（log n）由于幂指数，感谢IVlad指出了。

 def max_chars(n): if n <= 15: return (0, 1, 2, 3, 4, 5, 6, 9, 12, 16, 20, 27, 36, 48, 64, 81)[n] e3 = (4 - n) % 5 e4 = n // 5 - e3 return 4 * (4 ** e4) * (3 ** e3) 

计算e3：按键列表末尾总是有0到4个SCPP模式，对于n % 5 == 4有4个， n % 5 == 1有3个， n % 5 == 2有2个， n % 5 == 3有1， n % 5 == 4有0个。这可以简化为(4 - n) % 5 。

计算e4：每当n % 5 == 0时，模式的总数增加1，因为这个数字增加到n / 5 。 使用floor division我们可以得到模式的总数， e4的总数是模式的总数减去e3 。 对于那些不熟悉Python的人来说， //是地板划分的未来certificate符号。

Answer 2

有一个dynamic的编程解决scheme。 我们开始知道0键可以使我们0 A的。 然后我们迭代到n ，做两件事：按A一次，然后按全选+复制粘贴j次（实际上是下面的ji-1 ;注意这里的技巧：内容仍然在剪贴板中，所以我们可以多次粘贴而不需要每次都复制）。 我们只需要考虑最多4个连续的粘贴，因为select，复制，粘贴x 5相当于select，复制，粘贴，select，复制，粘贴，后者更好，因为它在剪贴板中留下了更多。 一旦我们达到了n ，我们有理想的结果。

复杂性似乎是O（N），但由于数字以指数速度增长，实际上是O（N ² ），因为乘以大数的复杂性。 下面是一个Python实现。 计算N = 50,000时大约需要0.5秒。

 def max_chars(n): dp = [0] * (n+1) for i in xrange(n): dp[i+1] = max(dp[i+1], dp[i]+1) # press a for j in xrange(i+3, min(i+7, n+1)): dp[j] = max(dp[j], dp[i]*(ji-1)) # press select all, copy, paste x (ji-1) return dp[n] 

在代码中， j表示按下新按键序列后按下的按键总数。 在这个阶段，我们已经有了i按键，并且有2个新的按键可以select全部和复制。 所以我们打粘贴ji-2次。 由于粘贴增加了现有的dp[i] A的序列，所以我们需要加1使之成为ji-1 。 这就解释了倒数第二线的ji-1 。

下面是一些结果（ n => A的数字）：

• 7 => 9
• 8 => 12
• 9 => 16
• 10 => 20
• 100 => 1391569403904
• 1,000 => 3268160001953743683783272702066311903448533894049486008426303248121757146615064636953144900245 174442911064952028008546304
• 50,000 => 一个非常大的数字！

我同意@SB，你应该总是说出你的假设：我的意思是你不需要粘贴两次来增加字符的数量。 这得到7的答案，所以除非我的解决scheme是错误的假设必须是正确的。

如果有人想知道为什么我不检查Ctrl + A ， Ctrl + C ， A ， Ctrl + Vforms的序列：最终结果将始终与A ， Ctrl + A ， Ctrl + C ， Ctrl + V我也考虑过

Answer 3

以下是我的方法：

• 假设Ctrl A =全选
• 假定Ctrl C =复制select
• 假定Ctrl V =粘贴复制的select

给一些文本，它需要4个按键来复制它：

• Ctrl A将其全部选中
• 按Ctrl C来复制它
• Ctrl V粘贴（这将粘贴在select – 状态您的假设）
• Ctrl V再次粘贴，将其加倍。

从那里，你可以考虑做4或5个，然后循环上述。 请注意，按ctrl + a, c, v, v会循环显示您的文本指数增长。 如果剩余的笔画<4，只要继续Ctrl V

像谷歌这样的访谈的关键是陈述你的假设，并传达你的想法。 他们想知道你是如何解决问题的。

Answer 4

使用Ctrl A + Ctrl C + Ctrl V仅在4'A之后才有优势。

所以我会做这样的事情（在伪BASIC代码，因为你没有指定任何适当的语言）：

 // We should not use the clipboard for the first four A's: FOR I IN 1 TO MIN(N, 4) PRINT 'CLICK A' NEXT LET N1 = N - 4 // Generates the maximum number of pastes allowed: FOR I IN 1 TO (N1 DIV 3) DO PRINT 'CTRL-A' PRINT 'CTRL-C' PRINT 'CTRL-V' LET N1 = N1 - 3 NEXT // If we still have same keystrokes left, let's use them with simple CTRL-Vs FOR I IN N1 TO N PRINT 'CTRL-V' NEXT 

编辑

1. 回到主循环中使用单个Ctrl V。
2. 添加了一些意见，以解释我想在这里做什么。
3. 修正了“前四A”块的问题。

Answer 5

在O（1）中是可以解决的：与Fibonacci数字一样，有一个公式可以计算打印的As的数量（以及按键的顺序）：

---

1）我们可以简化问题描述：

• 只有[A]，[Ca] + [Cc]，[Cv]和一个空的复制粘贴缓冲区

等于

• 复制粘贴缓冲区中只有[Ca] + [Cc]，[Cv]和“A”。

---

2）我们可以将击键的顺序描述为{'*'，'V'，'v'}之外的N个string，其中'v'表示[Cv]，'*'表示[Ca]和'V '的意思是[抄送]。 例如：“vvvv * Vvvvv * Vvvv”

该string的长度仍然等于N.

该string中的Vv字的长度的乘积等于产生的As的数量。

---

3）给定该string的固定长度N和固定数量K的单词，如果所有单词具有几乎相等的长度，则结果将是最大的。 它们的成对差异不超过±1。

现在，如果给定N，那么最佳数K是多less？

---

4）假设我们想要通过附加一个长度为L的单个单词来增加单词的数量，那么我们必须将任意一个单词的L + 1乘以一个“v”。 例如：“… * Vvvv * Vvvv * Vvvv * Vvvv” – >“… * Vvv * Vvv * Vvv * Vvv * Vvv”

现在，最佳的字长L是多less？

（5 * 5 * 5 * 5 * 5）<（4 * 4 * 4 * 4 * 4）* 4，（4 * 4 * 4 * 4）（3 * 3 * 3 * 3）* 3

=>最佳是L = 4。

---

5）假设我们有足够大的N生成一个长度为4的字的string，只剩下几个击键。 我们应该如何使用它们？

• 如果剩下5个或更多：添加长度为4的另一个单词。

• 如果剩下0个：完成。

• 如果还有4个，我们也可以

  a）附加长度为3：4 * 4 * 4 * 4 * 3 = 768的单词。

  b）或增加4个单词至5：5 * 5 * 5 * 5 = 625。 =>添加一个单词比较好。

• 如果剩下3个，我们也可以

  a）或者通过调整从长度4到3：4 * 4 * 4 * 2 = 128 <4 * 4 * 3 * 3 = 144的前缀词来附加长度为3的一个单词。

  b）增加3个单词至5：5 * 5 * 5 = 125。 =>添加一个单词比较好。

• 如果剩下两个：我们可以

  a）或者通过调整从长度4到3：4 * 4 * 1 = 16 <3 * 3 * 3 = 27的前两个单词来附加长度为3的一个单词。

  b）增加2个单词到5：5 * 5 = 25。 =>添加一个单词比较好。

• 如果还有一个：我们也可以

  a）或者通过调整从长度4到3的前三个单词来追加一个长度为3的单词：4 * 4 * 4 * 0 = 0 <3 * 3 * 3 * 3 = 81。

  b）增加一个单词长度5：4 * 4 * 5 = 80。 =>添加一个单词比较好。

---

6）现在，如果我们没有“足够大的N”来使用5）中的规则呢？ 如果可能，我们必须坚持计划b）！ 小N的string是：

1：“v”，2：“vv”，3：“vvv”，4：“vvvv”

5：“vvvvv”→5 （schemeb）

6：“vvvvvv”→6 （计划b）

7：“vvv * vvv”→9（计划a）

8：“vvvv * vvv”→12（计划a）

9：“vvvv * vvvv”→16

10：“vvvv * vvvvv”→20 （计划b）

11：“vvv * vvv * vvv”→29（a计划）

12：“vvvv * vvv * vvv”→36（计划a）

13：“vvvv * vvvv * vvv”→48（计划a）

14：“vvvv * vvvv * vvvv”→64

15：“vvv * Vvv * Vvv * Vvv”→81（计划a）

…

---

7）现在，一串长度为N的词的最佳数目K是多less？

如果N <7，那么K = 1否则如果6 <N <11则K = 2; 否则： K = ceil（（N + 1）/ 5）

写在C / C ++ / Java中： int K = (N<7)?(1) : (N<11)?(2) : ((N+5)/5);

如果N> 10，那么长度为3的字的数量将是：K * 5-1-N。 用这个，我们可以计算打印的数量为：

如果N> 10，则As的数量将是： 4 ^ {N + 1-4K}·3 ^ {5K-N-1}

Answer 6

需要3次按键才能使你的数量增加一倍。 当你有3个或更多已经打印时，开始加倍是有意义的。 你希望你最后一次允许的击键是一个Ctrl V ，以确保你可以把最大的数字加倍，所以为了alignment它，我们将在前三个As之后填入任何额外的击键。

 for (i = 3 + n%3; i>0 && n>0; n--, i--) { print("a"); } for (; n>0; n = n-3) { print("ctrl-a"); print("ctrl-c"); print("ctrl-v"); } 

编辑：

这太可怕了，我完全超越了自己，并没有考虑每个副本多个贴。

编辑2：

我相信粘贴3次是最佳的，当你有足够的击键来做到这一点。 在5个按键中，您将As的数字乘以4.这比使用4个按键乘以3要好，并且比使用6个按键的乘以5更好。 我通过给每种方法相同数量的按键来比较这一点，足以让他们每个人同时完成一个周期（60），让3乘法器做15个周期，4乘法器做12个周期，乘数做10个周期。 3 ^ 15 = 14,348,907,4 ^ 12 = 16,777,216和5 ^ 10 = 9,765,625。 如果只剩下4个击键，那么做一个3乘法器比再粘贴4次要好，基本上使前面的4乘法器成为一个8乘法器。 如果只剩下3个击键，则2乘法器是最好的。

Answer 7

假设剪贴板中有x个字符，文本区域中有x个字符; 我们称之为“状态x”。

我们按几次“粘贴”（为了方便，我用m-1表示），然后是“全部select”和“复制”。 在这个序列之后，我们得到“状态m * x”。 在这里，我们浪费了总共m + 1个按键。 所以渐近增长（至less）是f^n ，其中f = m^(1/(m+1)) 。 我相信这是最大可能的渐近增长，尽pipe我不能certificate它（但）。

尝试m的各种值表明，对于m=4获得f的最大值。

我们来使用下面的algorithm：

 Press A a few times Press Select-all Press Copy Repeat a few times: Press Paste Press Paste Press Paste Press Select-all Press Copy While any keystrokes left: Press Paste 

（不知道这是最佳的）。

按A开始的次数是3次：如果你按下4次，你错过了将A的次数加倍3次的机会。

最后按Paste键的次数不超过5次：如果还剩6个或更多击键，可以使用粘贴，粘贴，粘贴，全选，复制，粘贴。

所以，我们得到以下algorithm：

 If (less than 6 keystrokes - special case) While (any keystrokes left) A Else First 5 keystrokes: A, A, A, Select-all, Copy While (more than 5 keystrokes left) Paste, Paste, Paste, Select-all, Copy While (any keystrokes left) Paste 

（不知道这是最佳的）。 执行这个之后的字符数就是类似的

3 * pow(4, floor((n - 6) / 5)) * (2 + (n - 1) % 5) 。

样本值：1,2,3,4,5,6,9,12,15,18,24,36,48,60,72,96,144,192,240,288，…

Answer 8

接下来使用OP的第二个粘贴不会replace现有文本的编辑。

注意几件事情：

• ^ A和^ C可以被认为是一个单一的行动，需要两个按键，因为它们单独做它们是没有意义的。 实际上，我们可以用^ K ^ V来代替^ A ^ C的所有实例，其中^ K是一个一键 “剪切”操作（让我们简写为X）。 我们将看到，处理^ K要比双成本^ A ^ C好得多。
• 我们假设“A”从剪贴板开始。 那么^ V（我们把它缩写为Y）严格优于A，我们可以从所有的考虑中放弃后者。 （在实际的问题中，如果剪贴板开始是空的，那么在下面的代码中，我们将用A代替Y，直到第一个X.

因此，每个合理的按键序列可以被解释为由X分隔的一组Y，例如YYYXYXYYXY。 由V（s）表示由序列s产生的“A”的数量。 那么V（nXm）= V（n）* V（m），因为X本质上用V（n）'A代替m中的每个Y.

复制粘贴问题因此同构于以下问题：“使用总和为Nm的m + 1个数字，使其产品最大化”。 例如，当N = 6时，答案是m = 1，数字（2,3）。 6 = 2 * 3 = V（YYXYYY）= V（AA ^ A ^ C ^ V ^ V）（或V（YYYXYY）= V（AAA ^ A ^ C ^ V）

我们可以做一些观察：

对于一个固定的m值，要select的数字是ceil( (Nm)/(m+1) )和floor( (Nm)/(m+1) )将需要(Nm) % (m+1) ceils和其余的ceils s）。 这是因为对于a < b ， (a+1)*(b-1) >= a*b 。

不幸的是我没有看到一个简单的方法来findm的价值。 如果这是我的采访，我会提出两个解决scheme：

选项1.循环所有可能的m 。 O（ n log n ）解决scheme。

C ++代码：

 long long ipow(int a, int b) { long long val=1; long long mul=a; while(b>0) { if(b%2) val *= mul; mul *= mul; b/=2; } return val; } long long trym(int N, int m) { int floor = (Nm)/(m+1); int ceil = 1+floor; int numceils = (Nm)%(m+1); return ipow(floor, m+1-numceils) * ipow(ceil, numceils); } long long maxAs(int N) { long long maxval=0; for(int m=0; m<N; m++) { maxval = std::max(maxval, trym(N,m)); } return maxval; } 

选项2.允许m获得非整数值，并通过取[(Nm)/(m+1)]^m对m并求解它的根来find它的最优值。 没有分析解决scheme，但是可以使用牛顿的方法find根。 然后使用该根的地板和天花板作为m的值，并select哪个最好。

Answer 9

 public int dp(int n) { int arr[] = new int[n]; for (int i = 0; i < n; i++) arr[i] = i + 1; for (int i = 2; i < n - 3; i++) { int numchars = arr[i] * 2; int j = i + 3; arr[j] = Math.max(arr[j], numchars); while (j < n - 1) { numchars = numchars + arr[i]; arr[++j] = Math.max(arr[j], numchars); } } return arr[n - 1]; } 

Answer 10

下面是我的方法和解决scheme，下面的代码。

做法：

有三种不同的操作可以执行。

1. 按键A – 输出一个字符“A”
2. 按键（Ctrl-A）+（Ctrl-C） – 本质上不输出。 这两个击键可以合并成一个操作，因为每个击键都是没有意义的。 另外，这个按键为下一个粘贴操作设置输出。
3. 按键（Ctrl-V） – 这个击键的输出真的取决于以前的（第二）操作，因此我们需要在我们的代码中说明这一点。

现在给出三个不同的操作和它们各自的输出，我们必须经历所有这些操作的排列。

---

假设：

现在，这个问题的一些版本指出，按键的顺序是Ctrl + A – > Ctrl + C – > Ctrl + V，会覆盖突出显示的select。 为了考虑这个假设，只有一行代码需要被添加到下面的解决scheme中，情况2中的打印variables被设置为0

  case 2: //Ctrl-A and then Ctrl-C if((count+2) < maxKeys) { pOutput = printed; //comment the below statement to NOT factor //in the assumption described above printed = 0; } 

为此解决scheme

下面的代码将打印几个序列，最后一个序列是任何给定N的正确答案。例如对于N = 11，这将是正确的序列

有了这个假设

A，A，A，A，A，C，S，V，V，V，V，20：

没有这个假设

A，A，A，C，S，V，V，C，S，V，V，27：

我决定保留这个解决scheme的假设。

---

击键传奇：

'A' – A

'C' – Ctrl + A

'S' – Ctrl + C

'V' – Ctrl + V

---

码：

 #include <stdio.h> #include <string.h> #include <stdlib.h> void maxAprinted(int count, int maxKeys, int op, int printed, int pOutput, int *maxPrinted, char *seqArray) { if(count > maxKeys) return; if(count == maxKeys) { if((*maxPrinted) < printed) { //new sequence found which is an improvement over last sequence (*maxPrinted) = printed; printf("\n"); int i; for(i=0; i<maxKeys; i++) printf(" %c,",seqArray[i]); } return; } switch(op) { case 1: //A keystroke printed++; seqArray[count] = 'A'; count++; break; case 2: //Ctrl-A and then Ctrl-C if((count+2) < maxKeys) { pOutput = printed; //comment the below statement to NOT factor //in the assumption described above printed = 0; } seqArray[count] = 'C'; count++; seqArray[count] = 'S'; count++; break; case 3: //Ctrl-V printed = printed + pOutput; seqArray[count] = 'V'; count++; break; } maxAprinted(count, maxKeys, 1, printed, pOutput, maxPrinted, seqArray); maxAprinted(count, maxKeys, 2, printed, pOutput, maxPrinted, seqArray); maxAprinted(count, maxKeys, 3, printed, pOutput, maxPrinted, seqArray); } int main() { const int keyStrokes = 11; //this array stores the sequence of keystrokes char *sequence; sequence = (char*)malloc(sizeof(char)*(keyStrokes + 1)); //stores the max count for As printed for a sqeuence //updated in the recursive call. int printedAs = 0; maxAprinted(0, keyStrokes, 1, 0, 0, &printedAs, sequence); printf(" :%d:", printedAs); return 0; } 

Answer 11

使用上面答案中提到的技巧，在math上，解可以用一个等式来解释，

4 + 4 ^ [（N-4）/ 5] +（（N-4）％5）* 4 ^ [（N-4）/ 5]。 其中[]是最大的整数因子

Answer 12

在手动打印mA之间进行折衷，然后使用Ctrl + A ， Ctrl + C和Nm-2 Ctrl + V。 最好的解决办法是在中间。 如果最大键击= 10，最好的解决办法是input5 A或4 A.

尝试使用这个看看这个http://www.geeksforgeeks.org/how-to-print-maximum-number-of-a-using-given-four-keys/ ，也许优化一下，find围绕中期的结果点。

Answer 13

这里是我的dynamic编程解决scheme，没有嵌套循环，而且还打印出您需要键入的实际字符：

 N = 52 count = [0] * N res = [[]] * N clipboard = [0] * N def maybe_update(i, new_count, new_res, new_clipboard): if new_count > count[i] or ( new_count == count[i] and new_clipboard > clipboard[i]): count[i] = new_count res[i] = new_res clipboard[i] = new_clipboard for i in range(1, N): # First option: type 'A'. # Using list concatenation for 'res' to avoid O(n^2) string concatenation. maybe_update(i, count[i - 1] + 1, res[i - 1] + ['A'], clipboard[i - 1]) # Second option: type 'CTRL+V'. maybe_update(i, count[i - 1] + clipboard[i - 1], res[i - 1] + ['v'], clipboard[i - 1]) # Third option: type 'CTRL+A, CTRL+C, CTRL+V'. # Assumption: CTRL+V always appends. if i >= 3: maybe_update(i, 2 * count[i - 3], res[i - 3] + ['acv'], count[i - 3]) for i in range(N): print '%2d %7d %6d %-52s' % (i, count[i], clipboard[i], ''.join(res[i])) 

这是输出（'a'表示'CTRL + A'等）

  0 0 0 1 1 0 A 2 2 0 AA 3 3 0 AAA 4 4 0 AAAA 5 5 0 AAAAA 6 6 3 AAAacv 7 9 3 AAAacvv 8 12 3 AAAacvvv 9 15 3 AAAacvvvv 10 18 9 AAAacvvacv 11 27 9 AAAacvvacvv 12 36 9 AAAacvvacvvv 13 45 9 AAAacvvacvvvv 14 54 27 AAAacvvacvvacv 15 81 27 AAAacvvacvvacvv 16 108 27 AAAacvvacvvacvvv 17 135 27 AAAacvvacvvacvvvv 18 162 81 AAAacvvacvvacvvacv 19 243 81 AAAacvvacvvacvvacvv 20 324 81 AAAacvvacvvacvvacvvv 21 405 81 AAAacvvacvvacvvacvvvv 22 486 243 AAAacvvacvvacvvacvvacv 23 729 243 AAAacvvacvvacvvacvvacvv 24 972 243 AAAacvvacvvacvvacvvacvvv 25 1215 243 AAAacvvacvvacvvacvvacvvvv 26 1458 729 AAAacvvacvvacvvacvvacvvacv 27 2187 729 AAAacvvacvvacvvacvvacvvacvv 28 2916 729 AAAacvvacvvacvvacvvacvvacvvv 29 3645 729 AAAacvvacvvacvvacvvacvvacvvvv 30 4374 2187 AAAacvvacvvacvvacvvacvvacvvacv 31 6561 2187 AAAacvvacvvacvvacvvacvvacvvacvv 32 8748 2187 AAAacvvacvvacvvacvvacvvacvvacvvv 33 10935 2187 AAAacvvacvvacvvacvvacvvacvvacvvvv 34 13122 6561 AAAacvvacvvacvvacvvacvvacvvacvvacv 35 19683 6561 AAAacvvacvvacvvacvvacvvacvvacvvacvv 36 26244 6561 AAAacvvacvvacvvacvvacvvacvvacvvacvvv 37 32805 6561 AAAacvvacvvacvvacvvacvvacvvacvvacvvvv 38 39366 19683 AAAacvvacvvacvvacvvacvvacvvacvvacvvacv 39 59049 19683 AAAacvvacvvacvvacvvacvvacvvacvvacvvacvv 40 78732 19683 AAAacvvacvvacvvacvvacvvacvvacvvacvvacvvv 41 98415 19683 AAAacvvacvvacvvacvvacvvacvvacvvacvvacvvvv 42 118098 59049 AAAacvvacvvacvvacvvacvvacvvacvvacvvacvvacv 43 177147 59049 AAAacvvacvvacvvacvvacvvacvvacvvacvvacvvacvv 44 236196 59049 AAAacvvacvvacvvacvvacvvacvvacvvacvvacvvacvvv 45 295245 59049 AAAacvvacvvacvvacvvacvvacvvacvvacvvacvvacvvvv 46 354294 177147 AAAacvvacvvacvvacvvacvvacvvacvvacvvacvvacvvacv 47 531441 177147 AAAacvvacvvacvvacvvacvvacvvacvvacvvacvvacvvacvv 48 708588 177147 AAAacvvacvvacvvacvvacvvacvvacvvacvvacvvacvvacvvv 49 885735 177147 AAAacvvacvvacvvacvvacvvacvvacvvacvvacvvacvvacvvvv 50 1062882 531441 AAAacvvacvvacvvacvvacvvacvvacvvacvvacvvacvvacvvacv 51 1594323 531441 AAAacvvacvvacvvacvvacvvacvvacvvacvvacvvacvvacvvacvv 

Answer 14

如果允许N个键击，则结果是N-3。

A's – > N-3

CTRL + A – >select这N个字符：+1

CTRL + C – >复制N个字符：+1

Ctrl + V – >粘贴N个字符。 ：+1 ie，（因为我们用CTRL + Aselect了整个字符）用复制的N-3个字符replace这些现有的N-3个字符（覆盖相同的字符），结果是N-3。