这是来自谷歌的访谈问题。我自己无法解决这个问题。有人可以解释一下吗？
编写一个程序来打印击键序列，以便生成最大数量的字符'A'。您只能使用4个键： A ， Ctrl + A ， Ctrl + C < / kbd>和 Ctrl + V 。只允许N次击键。所有 Ctrl +字符都被视为一次击键，因此 Ctrl + A 是一次击键。
例如，序列 A ， Ctrl + A ， Ctrl + C ， Ctrl + V 在4次击键中产生两个A。
我做了一些数学。对于任何N，使用x个A，一个 Ctrl + A ，一个 Ctrl + C 和y < kbd> Ctrl + V ，我们可以生成A的最大（（N-1）/ 2） 2 数。对于某些N＆gt; M，最好使用尽可能多的 Ctrl + A ， Ctrl + C 和 Ctrl + V 序列，因为它的数量是A的两倍。
序列 Ctrl + A ， Ctrl + V ， Ctrl + C 不会覆盖现有选择。它会将复制的选择附加到选定的选择。
答案 0 :(得分：42)
有一个动态编程解决方案。我们开始知道0键可以让我们0 A。然后我们迭代i直至n，做两件事：按A一次然后按全选+复制然后粘贴j次（实际上j-i-1以下;注意这里的诀窍：内容仍在剪贴板中，因此我们可以多次粘贴它而不必每次复制）。我们只需要考虑最多4个连续的粘贴，因为选择，复制，粘贴x 5相当于选择，复制，粘贴，选择，复制，粘贴，后者更好，因为它在剪贴板中留下了更多。一旦我们达到n，我们就会得到理想的结果。
复杂度似乎可能是O（N），但由于数字以指数速率增长，因此实际上是O（N 2 ），因为大数字的乘法很复杂。下面是一个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]*(j-i-1)) # press select all, copy, paste x (j-i-1)
return dp[n]
在代码中，j表示在我们新的按键序列之后按下的键的总数。我们在此阶段已经有i个按键，并且有2个新的按键用于select-all和copy。因此，我们正在进行粘贴j-i-2次。由于粘贴会添加dp[i] A的现有序列，因此我们需要添加1使其成为j-i-1。这解释了倒数第二行的j-i-1。
以下是一些结果（n =＆gt; A的数量）：
我同意@SB你应该总是陈述你的假设：我的是你不需要粘贴两次来加倍字符数。这得到7的答案，所以除非我的解决方案是错误的，否则假设必须是正确的。
如果有人想知道为什么我没有检查格式的序列 Ctrl + A ， Ctrl + C ， A ， Ctrl + V ：最终结果将始终与 A 相同， Ctrl + A ， Ctrl + C ， Ctrl + V 我做考虑。
答案 1 :(得分：41)
通过使用marcog的解决方案，我找到了一个从n=16开始的模式。为了说明这一点，n=24最多n=29的键击，我用S（选择）替换^ A，用C（复制）替换^ C，为了可读性，用V（粘贴）替换^ 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 As之后，理想的模式是选择，复制，粘贴，粘贴，粘贴和重复。这将每5次击键将As的数量乘以4。如果这5个击键模式不能消耗其余的击键，则一些4个击键模式（SCPP）消耗最后的击键，根据需要替换SCPPP（或移除其中一个击球）。 4个击键模式每4次击键将总数乘以3。
这里使用这个模式是一些Python代码，它得到与marcog解决方案相同的结果，但是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。使用楼层划分我们可以获得模式的总数，e4的总数是模式总数减去e3。对于那些不熟悉Python的人来说，//是一个面向未来的分区表示法。
答案 2 :(得分：16)
以下是我如何处理它：
给出一些文本，需要4次击键才能复制它：
从那里，你可以考虑做4或5 A，然后循环上面。请注意，执行ctrl + a, c, v, v会在循环播放时以指数方式增加文本。如果剩余的笔划< 4，继续做 Ctrl V
像Google这样的采访@关键的关键是陈述你的假设，并传达你的想法。他们想知道你是如何解决问题的。
答案 3 :(得分：5)
使用 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
修改
答案 4 :(得分：4)
可以在O（1）中求解：与Fibonacci数一样，有一个公式来计算打印的As数（以及击键顺序）：
1）我们可以简化问题描述：
等于
2）我们可以将键击顺序描述为{'*'，'V'，'v'}中的一串N个字符，其中'v'表示[Cv]，'*'表示[Ca] 'V'表示[抄送]。示例：“vvvv * Vvvvv * Vvvv”
该字符串的长度仍然等于N.
该字符串中Vv-words长度的乘积等于生成的As的数量。
3）给定该字符串的固定长度N和固定数量K的单词，如果所有单词的长度几乎相等，则结果将是最大的。他们的成对差异不超过±1。
现在，如果给出N，最佳数字K是多少？
4）假设我们想通过附加一个长度为L的单个字来增加单词数，那么我们必须将前一个单词的L + 1倍减少一个'v'。示例：“... * Vvvv * Vvvv * Vvvv * Vvvv” - ＆gt; “... * * VVV VVV * VVV * VVV * VVV”
现在，最佳字长L是什么？
（5 * 5 * 5 * 5 * 5）＆lt; （4 * 4 * 4 * 4 * 4）* 4，（4 * 4 * 4 * 4）> （3 * 3 * 3 * 3）* 3
=＆GT;最优是L = 4.
5）假设，我们有足够大的N来生成一个长度为4的字符串，但会留下几个键击;我们该如何使用它们？
如果剩下5个或更多：添加另一个长度为4的单词。
如果剩下0：完成。
如果剩下4个：我们可以
a）附加一个长度为3：4 * 4 * 4 * 4 * 3 = 768的单词。
b）或增加4个字，长度为5：5 * 5 * 5 * 5 = 625。 =＆GT;附加一个单词会更好。
如果剩下3个：我们可以
a）或通过调整长度为4到3的普通词来附加长度为3的一个单词：4 * 4 * 4 * 2 = 128＆lt; 4 * 4 * 3 * 3 = 144。
b）增加3个字，长度为5：5 * 5 * 5 = 125。 =＆GT;附加一个单词会更好。
如果剩下2个：我们可以
a）或通过调整长度为4到3的前两个单词来附加长度为3的单词：4 * 4 * 1 = 16＆lt; 3 * 3 * 3 = 27。
b）增加2个字，长度为5：5 * 5 = 25。 =＆GT;附加一个单词会更好。
如果剩下1个：我们可以
a）或通过从长度4到3调整前三个单词来附加长度为3的单词：4 * 4 * 4 * 0 = 0＆lt; 3 * 3 * 3 * 3 = 81。
b）将一个单词增加到5：4 * 4 * 5 = 80。 =＆GT;附加一个单词会更好。
6）现在，如果我们没有“足够大的N”来使用5）中的规则怎么办？如果可能的话，我们必须坚持计划b）！ 小N的字符串是：
1：“v”，2：“vv”，3：“vvv”，4：“vvvv”
5：“vvvvv”→5 （计划b）
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是多少？
如果N <然后，如果6 <1，则K = 1。 N＆lt; 11然后K = 2;否则： K = ceil（（N + 1）/ 5）
用C / C ++ / Java编写：int K = (N<7)?(1) : (N<11)?(2) : ((N+5)/5);
如果N＆gt;如图10所示，则长度为3的字的数量为：K * 5-1-N。有了这个，我们就可以计算打印的数量：
如果N> 10，As的数量将是： 4 ^ {N + 1-4K}·3 ^ {5K-N-1}
答案 5 :(得分：3)
需要3次击键才能使你的As数量增加一倍。只有当你已经打印了3个或更多时才开始加倍才有意义。您希望最后一次允许的击键是 Ctrl V ，以确保您将最大数量加倍，所以为了对齐它我们将填写任何额外的击键在前三个之后在开始时有更多的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个循环，以及5-乘数做10个循环。 3 ^ 15 = 14,348,907,4 ^ 12 = 16,777,216，和5 ^ 10 = 9,765,625。如果只剩下4次击键，那么做3次乘法比粘贴4次更好，基本上使前4次乘数成为8次乘数。如果只剩下3次击键，则最好使用2次乘数。
答案 6 :(得分：2)
假设剪贴板中有x个字符，文本区域中有x个字符;我们称之为“状态x”。
让我们按“粘贴”几次（为方便起见，我用m-1表示），然后按“全选”和“复制”;在这个序列之后，我们得到“状态m * x”。
在这里，我们浪费了总共m + 1次击键。
因此，渐近增长（至少）类似于f^n，其中f = m^(1/(m+1))。
我相信它是最大可能的渐近增长，但我无法证明它（还）。
尝试m的各种值表明，m=4获得了f的最大值。
让我们使用以下算法：
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次，则错过了在3次按键时将A的数量加倍的机会。
最后按下粘贴的次数不超过5次：如果你还有6次或更多次击键，你可以使用粘贴，粘贴，粘贴，全选，复制，粘贴等。
因此，我们得到以下算法：
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，......
答案 7 :(得分：2)
以下内容使用OP的第二次编辑，即粘贴不替换现有文本。
请注意以下几点：
因此，每个合理的击键序列可以被解释为由X分隔的一组Y，例如YYYXYXYYXY。由V（s）表示由序列s产生的'A'的数量。然后V（nXm）= V（n）* V（m），因为X基本上用V（n）'A'替换m中的每个Y.
因此，复制粘贴问题与以下问题同构：“使用总和为N-m的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，要选择的数字为ceil( (N-m)/(m+1) )和floor( (N-m)/(m+1) )（无论如何组合使得总和能够解决;更具体地说，需要(N-m) % (m+1) ceils和其他floor s。这是因为a < b，(a+1)*(b-1) >= a*b。
不幸的是，我没有看到找到m值的简单方法。如果这是我的采访，我会提出两个解决方案：
选项1.循环遍历所有可能的m。 O（n log n）解决方案。
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 = (N-m)/(m+1);
int ceil = 1+floor;
int numceils = (N-m)%(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获得非整数值，并通过取[(N-m)/(m+1)]^m相对于m的导数并求解其根来找到其最佳值。没有分析解决方案，但可以使用例如根找到根。牛顿的方法。然后使用该根的地板和天花板获取m的值，并选择最适合的那个。
答案 8 :(得分：0)
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];
}
答案 9 :(得分：0)
以下是我的方法和解决方案，代码如下。
方法：
可以执行三种不同的操作。
现在给出三个不同的操作及其各自的输出，我们必须完成这些操作的所有排列。
<强>假设：
现在，这个问题的某个版本说明按键序列，Ctrl + A - ＆gt; Ctrl + C - ＆gt;按Ctrl + V，覆盖突出显示的选项。考虑到这个假设，只需要将一行代码添加到下面的解决方案中，其中案例2中的打印变量设置为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;
}
对于此解决方案
下面的代码将打印几个序列，最后一个序列是任何给定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：
我决定保留这个解决方案的假设。
按键图例
＆＃39; A＆＃39; - A
＆＃39; C＆＃39; - Ctrl + A
＆＃39; S＆＃39; - Ctrl + C
＆＃39; V＆＃39; - 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;
}
答案 10 :(得分：0)
使用上面答案中提到的技巧，数学上，解决方案可以用一个等式来解释，
4 + 4 ^ [（N-4）/ 5] +（（N-4）％5）* 4 ^ [（N-4）/ 5]。 其中[]是最大整数因子
答案 11 :(得分：0)
手动打印m-A之间需要权衡，然后使用 Ctrl + A ， Ctrl + < kbd> C 和Nm-2 Ctrl + V 。最好的解决方案是在中间。如果最大击键次数= 10，则最佳解决方案是输入5 A或4 A。
尝试使用此查看此http://www.geeksforgeeks.org/how-to-print-maximum-number-of-a-using-given-four-keys/并可能优化一点寻找中点周围的结果。
答案 12 :(得分：0)
这是我的动态编程解决方案，没有嵌套循环，并且还打印了您需要输入的实际字符：
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
答案 13 :(得分：0)
如果允许N键Strokes，则结果为N-3。
A的 - ＆gt; N-3
CTRL + A - ＆gt;选择那N个字符：+1
CTRL + C - ＆gt;复制这N个字符：+1
Ctrl + V - ＆gt;粘贴N个字符。 ：+1 ie，（因为我们使用 CTRL + A 选择了整个字符）用复制的N-3字符替换这些现有的N-3字符（覆盖相同的字符） ）结果是N-3。