This is a famous interview question asked in Google, Paytm and many other company interviews.

Below is the problem statement.

Imagine you have a special keyboard with the following keys: Key 1: Prints 'A' on screen Key 2: (Ctrl-A): Select screen Key 3: (Ctrl-C): Copy selection to buffer Key 4: (Ctrl-V): Print buffer on screen appending it after what has already been printed. If you can only press the keyboard for N times (with the above four keys), write a program to produce maximum numbers of A's. That is to say, the input parameter is N (No. of keys that you can press), the output is M (No. of As that you can produce).

**Examples:**

Input: N = 3 Output: 3 We can at most get 3 A's on screen by pressing following key sequence. A, A, A Input: N = 7 Output: 9 We can at most get 9 A's on screen by pressing following key sequence. A, A, A, Ctrl A, Ctrl C, Ctrl V, Ctrl V Input: N = 11 Output: 27 We can at most get 27 A's on screen by pressing following key sequence. A, A, A, Ctrl A, Ctrl C, Ctrl V, Ctrl V, Ctrl A, Ctrl C, Ctrl V, Ctrl V

Below are few important points to note.

a) For N < 7, the output is N itself.

b) Ctrl V can be used multiple times to print current buffer (See last two examples above). The idea is to compute the optimal string length for N keystrokes by using a simple insight. The sequence of N keystrokes which produces an optimal string length will end with a suffix of Ctrl-A, a Ctrl-C, followed by only Ctrl-V’s . (For N > 6)

The task is to find out the break=point after which we get the above suffix of keystrokes. Definition of a breakpoint is that instance after which we need to only press Ctrl-A, Ctrl-C once and the only Ctrl-V’s afterwards to generate the optimal length. If we loop from N-3 to 1 and choose each of these values for the break-point, and compute that optimal string they would produce. Once the loop ends, we will have the maximum of the optimal lengths for various breakpoints, thereby giving us the optimal length for N keystrokes.

Below is implementation based on above idea.

## C++

`/* A recursive C++ program to print maximum number of A's using ` `following four keys */` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// A recursive function that returns the optimal length string ` `// for N keystrokes ` `int` `findoptimal(` `int` `N) ` `{ ` ` ` `// The optimal string length is N when N is smaller than 7 ` ` ` `if` `(N <= 6) ` ` ` `return` `N; ` ` ` ` ` `// Initialize result ` ` ` `int` `max = 0; ` ` ` ` ` `// TRY ALL POSSIBLE BREAK-POINTS ` ` ` `// For any keystroke N, we need to loop from N-3 keystrokes ` ` ` `// back to 1 keystroke to find a breakpoint 'b' after which we ` ` ` `// will have Ctrl-A, Ctrl-C and then only Ctrl-V all the way. ` ` ` `int` `b; ` ` ` `for` `(b = N - 3; b >= 1; b--) { ` ` ` ` ` `// If the breakpoint is s at b'th keystroke then ` ` ` `// the optimal string would have length ` ` ` `// (n-b-1)*screen[b-1]; ` ` ` `int` `curr = (N - b - 1) * findoptimal(b); ` ` ` `if` `(curr > max) ` ` ` `max = curr; ` ` ` `} ` ` ` `return` `max; ` `} ` ` ` `// Driver program ` `int` `main() ` `{ ` ` ` `int` `N; ` ` ` ` ` `// for the rest of the array we will rely on the previous ` ` ` `// entries to compute new ones ` ` ` `for` `(N = 1; N <= 20; N++) ` ` ` `cout << ` `"Maximum Number of A's with "` `<< N << ` ` ` `" keystrokes is "` `<< findoptimal(N) << endl; ` `} ` ` ` `// This code is contributed by shubhamsingh10 ` |

*chevron_right*

*filter_none*

## C

`/* A recursive C program to print maximum number of A's using ` ` ` `following four keys */` `#include <stdio.h> ` ` ` `// A recursive function that returns the optimal length string ` `// for N keystrokes ` `int` `findoptimal(` `int` `N) ` `{ ` ` ` `// The optimal string length is N when N is smaller than 7 ` ` ` `if` `(N <= 6) ` ` ` `return` `N; ` ` ` ` ` `// Initialize result ` ` ` `int` `max = 0; ` ` ` ` ` `// TRY ALL POSSIBLE BREAK-POINTS ` ` ` `// For any keystroke N, we need to loop from N-3 keystrokes ` ` ` `// back to 1 keystroke to find a breakpoint 'b' after which we ` ` ` `// will have Ctrl-A, Ctrl-C and then only Ctrl-V all the way. ` ` ` `int` `b; ` ` ` `for` `(b = N - 3; b >= 1; b--) { ` ` ` `// If the breakpoint is s at b'th keystroke then ` ` ` `// the optimal string would have length ` ` ` `// (n-b-1)*screen[b-1]; ` ` ` `int` `curr = (N - b - 1) * findoptimal(b); ` ` ` `if` `(curr > max) ` ` ` `max = curr; ` ` ` `} ` ` ` `return` `max; ` `} ` ` ` `// Driver program ` `int` `main() ` `{ ` ` ` `int` `N; ` ` ` ` ` `// for the rest of the array we will rely on the previous ` ` ` `// entries to compute new ones ` ` ` `for` `(N = 1; N <= 20; N++) ` ` ` `printf` `(` `"Maximum Number of A's with %d keystrokes is %d\n"` `, ` ` ` `N, findoptimal(N)); ` `} ` |

*chevron_right*

*filter_none*

## Java

`/* A recursive Java program to print ` ` ` `maximum number of A's using ` ` ` `following four keys */` `import` `java.io.*; ` ` ` `class` `GFG { ` ` ` ` ` `// A recursive function that returns ` ` ` `// the optimal length string for N keystrokes ` ` ` `static` `int` `findoptimal(` `int` `N) ` ` ` `{ ` ` ` `// The optimal string length is N ` ` ` `// when N is smaller than 7 ` ` ` `if` `(N <= ` `6` `) ` ` ` `return` `N; ` ` ` ` ` `// Initialize result ` ` ` `int` `max = ` `0` `; ` ` ` ` ` `// TRY ALL POSSIBLE BREAK-POINTS ` ` ` `// For any keystroke N, we need to ` ` ` `// loop from N-3 keystrokes back to ` ` ` `// 1 keystroke to find a breakpoint ` ` ` `// 'b' after which we will have Ctrl-A, ` ` ` `// Ctrl-C and then only Ctrl-V all the way. ` ` ` `int` `b; ` ` ` `for` `(b = N - ` `3` `; b >= ` `1` `; b--) { ` ` ` `// If the breakpoint is s at b'th ` ` ` `// keystroke then the optimal string ` ` ` `// would have length ` ` ` `// (n-b-1)*screen[b-1]; ` ` ` `int` `curr = (N - b - ` `1` `) * findoptimal(b); ` ` ` `if` `(curr > max) ` ` ` `max = curr; ` ` ` `} ` ` ` `return` `max; ` ` ` `} ` ` ` ` ` `// Driver program ` ` ` `public` `static` `void` `main(String[] args) ` ` ` `{ ` ` ` `int` `N; ` ` ` ` ` `// for the rest of the array we ` ` ` `// will rely on the previous ` ` ` `// entries to compute new ones ` ` ` `for` `(N = ` `1` `; N <= ` `20` `; N++) ` ` ` `System.out.println(` `"Maximum Number of A's with keystrokes is "` `+ N + findoptimal(N)); ` ` ` `} ` `} ` ` ` `// This code is contributed by vt_m. ` |

*chevron_right*

*filter_none*

## Python3

`# A recursive Python3 program to print maximum ` `# number of A's using following four keys ` ` ` `# A recursive function that returns ` `# the optimal length string for N keystrokes ` ` ` `def` `findoptimal(N): ` ` ` ` ` `# The optimal string length is ` ` ` `# N when N is smaller than ` ` ` `if` `N<` `=` `6` `: ` ` ` `return` `N ` ` ` ` ` `# Initialize result ` ` ` `maxi ` `=` `0` ` ` ` ` `# TRY ALL POSSIBLE BREAK-POINTS ` ` ` `# For any keystroke N, we need ` ` ` `# to loop from N-3 keystrokes ` ` ` `# back to 1 keystroke to find ` ` ` `# a breakpoint 'b' after which we ` ` ` `# will have Ctrl-A, Ctrl-C and then ` ` ` `# only Ctrl-V all the way. ` ` ` `for` `b ` `in` `range` `(N` `-` `3` `, ` `0` `, ` `-` `1` `): ` ` ` `curr ` `=` `(N` `-` `b` `-` `1` `)` `*` `findoptimal(b) ` ` ` `if` `curr>maxi: ` ` ` `maxi ` `=` `curr ` ` ` ` ` `return` `maxi ` `# Driver program ` `if` `__name__` `=` `=` `'__main__'` `: ` ` ` ` ` `# for the rest of the array we will ` `# rely on the previous ` `# entries to compute new ones ` ` ` `for` `n ` `in` `range` `(` `1` `, ` `21` `): ` ` ` `print` `(` `'Maximum Number of As with '` `, n, ` `'keystrokes is '` `, findoptimal(n)) ` ` ` `# this code is contibuted by sahilshelangia ` |

*chevron_right*

*filter_none*

## C#

`/* A recursive C# program ` `to print maximum number ` `of A's using following ` `four keys */` `using` `System; ` ` ` `class` `GFG { ` ` ` `// A recursive function that ` ` ` `// returns the optimal length ` ` ` `// string for N keystrokes ` ` ` `static` `int` `findoptimal(` `int` `N) ` ` ` `{ ` ` ` `// The optimal string length ` ` ` `// is N when N is smaller than 7 ` ` ` `if` `(N <= 6) ` ` ` `return` `N; ` ` ` ` ` `// Initialize result ` ` ` `int` `max = 0; ` ` ` ` ` `// TRY ALL POSSIBLE BREAK-POINTS ` ` ` `// For any keystroke N, we need ` ` ` `// to loop from N-3 keystrokes ` ` ` `// back to 1 keystroke to find ` ` ` `// a breakpoint 'b' after which ` ` ` `// we will have Ctrl-A, Ctrl-C ` ` ` `// and then only Ctrl-V all the way. ` ` ` `int` `b; ` ` ` `for` `(b = N - 3; b >= 1; b--) { ` ` ` `// If the breakpoint is s ` ` ` `// at b'th keystroke then ` ` ` `// the optimal string would ` ` ` `// have length (n-b-1)*screen[b-1]; ` ` ` `int` `curr = (N - b - 1) * findoptimal(b); ` ` ` `if` `(curr > max) ` ` ` `max = curr; ` ` ` `} ` ` ` `return` `max; ` ` ` `} ` ` ` ` ` `// Driver code ` ` ` `static` `void` `Main() ` ` ` `{ ` ` ` `int` `N; ` ` ` ` ` `// for the rest of the array ` ` ` `// we will rely on the ` ` ` `// previous entries to compute ` ` ` `// new ones ` ` ` `for` `(N = 1; N <= 20; N++) ` ` ` `Console.WriteLine(` `"Maximum Number of A's with "` `+ N + ` `" keystrokes is "` `+ findoptimal(N)); ` ` ` `} ` `} ` ` ` `// This code is contributed by Sam007 ` |

*chevron_right*

*filter_none*

## PHP

`<?php ` `/* A recursive PHP program to print maximum number of A's using ` `following four keys */` ` ` `// A recursive function that returns the optimal ` `// length string for N keystrokes ` `function` `findoptimal(` `$N` `) ` `{ ` ` ` `// The optimal string length is ` ` ` `// N when N is smaller than 7 ` ` ` `if` `(` `$N` `<= 6) ` ` ` `return` `$N` `; ` ` ` ` ` `// Initialize result ` ` ` `$max` `= 0; ` ` ` ` ` `// TRY ALL POSSIBLE BREAK-POINTS ` ` ` `// For any keystroke N, we need to loop from N-3 keystrokes ` ` ` `// back to 1 keystroke to find a breakpoint 'b' after which we ` ` ` `// will have Ctrl-A, Ctrl-C and then only Ctrl-V all the way. ` ` ` `$b` `; ` ` ` `for` `(` `$b` `= ` `$N` `- 3; ` `$b` `>= 1; ` `$b` `-= 1) ` ` ` `{ ` ` ` `// If the breakpoint is s at b'th keystroke then ` ` ` `// the optimal string would have length ` ` ` `// (n-b-1)*screen[b-1]; ` ` ` `$curr` `= (` `$N` `- ` `$b` `- 1) * findoptimal(` `$b` `); ` ` ` `if` `(` `$curr` `> ` `$max` `) ` ` ` `$max` `= ` `$curr` `; ` ` ` `} ` ` ` `return` `$max` `; ` `} ` ` ` `// Driver code ` `$N` `; ` ` ` `// for the rest of the array we will rely on the previous ` `// entries to compute new ones ` `for` `(` `$N` `= 1; ` `$N` `<= 20; ` `$N` `+= 1) ` ` ` `echo` `(` `"Maximum Number of A's with"` ` ` `.` `$N` `.` `"keystrokes is "` `.findoptimal(` `$N` `).` `"\n"` `); ` ` ` `// This code is contributed by aman neekhara ` `?> ` |

*chevron_right*

*filter_none*

**Output:**

Maximum Number of A's with 1 keystrokes is 1 Maximum Number of A's with 2 keystrokes is 2 Maximum Number of A's with 3 keystrokes is 3 Maximum Number of A's with 4 keystrokes is 4 Maximum Number of A's with 5 keystrokes is 5 Maximum Number of A's with 6 keystrokes is 6 Maximum Number of A's with 7 keystrokes is 9 Maximum Number of A's with 8 keystrokes is 12 Maximum Number of A's with 9 keystrokes is 16 Maximum Number of A's with 10 keystrokes is 20 Maximum Number of A's with 11 keystrokes is 27 Maximum Number of A's with 12 keystrokes is 36 Maximum Number of A's with 13 keystrokes is 48 Maximum Number of A's with 14 keystrokes is 64 Maximum Number of A's with 15 keystrokes is 81 Maximum Number of A's with 16 keystrokes is 108 Maximum Number of A's with 17 keystrokes is 144 Maximum Number of A's with 18 keystrokes is 192 Maximum Number of A's with 19 keystrokes is 256 Maximum Number of A's with 20 keystrokes is 324

The above function computes the same subproblems again and again. Recomputations of same subproblems can be avoided by storing the solutions to subproblems and solving problems in bottom up manner.

Below is Dynamic Programming based C implementation where an auxiliary array screen[N] is used to store result of subproblems.

## C++

`/* A Dynamic Programming based C program to find maximum number of A's ` `that can be printed using four keys */` `#include <iostream> ` `using` `namespace` `std; ` ` ` ` ` `// this function returns the optimal length string for N keystrokes ` `int` `findoptimal(` `int` `N) ` `{ ` ` ` `// The optimal string length is N when N is smaller than 7 ` ` ` `if` `(N <= 6) ` ` ` `return` `N; ` ` ` ` ` `// An array to store result of subproblems ` ` ` `int` `screen[N]; ` ` ` ` ` `int` `b; ` `// To pick a breakpoint ` ` ` ` ` `// Initializing the optimal lengths array for uptil 6 input ` ` ` `// strokes. ` ` ` `int` `n; ` ` ` `for` `(n = 1; n <= 6; n++) ` ` ` `screen[n - 1] = n; ` ` ` ` ` `// Solve all subproblems in bottom manner ` ` ` `for` `(n = 7; n <= N; n++) { ` ` ` `// Initialize length of optimal string for n keystrokes ` ` ` `screen[n - 1] = 0; ` ` ` ` ` `// For any keystroke n, we need to loop from n-3 keystrokes ` ` ` `// back to 1 keystroke to find a breakpoint 'b' after which we ` ` ` `// will have ctrl-a, ctrl-c and then only ctrl-v all the way. ` ` ` `for` `(b = n - 3; b >= 1; b--) { ` ` ` `// if the breakpoint is at b'th keystroke then ` ` ` `// the optimal string would have length ` ` ` `// (n-b-1)*screen[b-1]; ` ` ` `int` `curr = (n - b - 1) * screen[b - 1]; ` ` ` `if` `(curr > screen[n - 1]) ` ` ` `screen[n - 1] = curr; ` ` ` `} ` ` ` `} ` ` ` ` ` `return` `screen[N - 1]; ` `} ` ` ` `// Driver program ` `int` `main() ` `{ ` ` ` `int` `N; ` ` ` ` ` `// for the rest of the array we will rely on the previous ` ` ` `// entries to compute new ones ` ` ` `for` `(N = 1; N <= 20; N++) ` ` ` `cout << ` `"Maximum Number of A's with "` `<<N<<` `" keystrokes is "` ` ` `<< findoptimal(N) << endl; ` `} ` ` ` `//This is contributed by shubhamsingh10 ` |

*chevron_right*

*filter_none*

## C

`/* A Dynamic Programming based C program to find maximum number of A's ` ` ` `that can be printed using four keys */` `#include <stdio.h> ` ` ` `// this function returns the optimal length string for N keystrokes ` `int` `findoptimal(` `int` `N) ` `{ ` ` ` `// The optimal string length is N when N is smaller than 7 ` ` ` `if` `(N <= 6) ` ` ` `return` `N; ` ` ` ` ` `// An array to store result of subproblems ` ` ` `int` `screen[N]; ` ` ` ` ` `int` `b; ` `// To pick a breakpoint ` ` ` ` ` `// Initializing the optimal lengths array for uptil 6 input ` ` ` `// strokes. ` ` ` `int` `n; ` ` ` `for` `(n = 1; n <= 6; n++) ` ` ` `screen[n - 1] = n; ` ` ` ` ` `// Solve all subproblems in bottom manner ` ` ` `for` `(n = 7; n <= N; n++) { ` ` ` `// Initialize length of optimal string for n keystrokes ` ` ` `screen[n - 1] = 0; ` ` ` ` ` `// For any keystroke n, we need to loop from n-3 keystrokes ` ` ` `// back to 1 keystroke to find a breakpoint 'b' after which we ` ` ` `// will have ctrl-a, ctrl-c and then only ctrl-v all the way. ` ` ` `for` `(b = n - 3; b >= 1; b--) { ` ` ` `// if the breakpoint is at b'th keystroke then ` ` ` `// the optimal string would have length ` ` ` `// (n-b-1)*screen[b-1]; ` ` ` `int` `curr = (n - b - 1) * screen[b - 1]; ` ` ` `if` `(curr > screen[n - 1]) ` ` ` `screen[n - 1] = curr; ` ` ` `} ` ` ` `} ` ` ` ` ` `return` `screen[N - 1]; ` `} ` ` ` `// Driver program ` `int` `main() ` `{ ` ` ` `int` `N; ` ` ` ` ` `// for the rest of the array we will rely on the previous ` ` ` `// entries to compute new ones ` ` ` `for` `(N = 1; N <= 20; N++) ` ` ` `printf` `(` `"Maximum Number of A's with %d keystrokes is %d\n"` `, ` ` ` `N, findoptimal(N)); ` `} ` |

*chevron_right*

*filter_none*

## Java

`/* A Dynamic Programming based C ` ` ` `program to find maximum number ` ` ` `of A's that can be printed using ` ` ` `four keys */` `import` `java.io.*; ` ` ` `class` `GFG { ` ` ` ` ` `// this function returns the optimal ` ` ` `// length string for N keystrokes ` ` ` `static` `int` `findoptimal(` `int` `N) ` ` ` `{ ` ` ` `// The optimal string length is N ` ` ` `// when N is smaller than 7 ` ` ` `if` `(N <= ` `6` `) ` ` ` `return` `N; ` ` ` ` ` `// An array to store result ` ` ` `// of subproblems ` ` ` `int` `screen[] = ` `new` `int` `[N]; ` ` ` ` ` `int` `b; ` `// To pick a breakpoint ` ` ` ` ` `// Initializing the optimal lengths ` ` ` `// array for uptil 6 input strokes ` ` ` `int` `n; ` ` ` `for` `(n = ` `1` `; n <= ` `6` `; n++) ` ` ` `screen[n - ` `1` `] = n; ` ` ` ` ` `// Solve all subproblems in bottom manner ` ` ` `for` `(n = ` `7` `; n <= N; n++) { ` ` ` `// Initialize length of optimal ` ` ` `// string for n keystrokes ` ` ` `screen[n - ` `1` `] = ` `0` `; ` ` ` ` ` `// For any keystroke n, we need ` ` ` `// to loop from n-3 keystrokes ` ` ` `// back to 1 keystroke to find ` ` ` `// a breakpoint 'b' after which we ` ` ` `// will have ctrl-a, ctrl-c and ` ` ` `// then only ctrl-v all the way. ` ` ` `for` `(b = n - ` `3` `; b >= ` `1` `; b--) { ` ` ` `// if the breakpoint is ` ` ` `// at b'th keystroke then ` ` ` `// the optimal string would ` ` ` `// have length ` ` ` `// (n-b-1)*screen[b-1]; ` ` ` `int` `curr = (n - b - ` `1` `) * screen[b - ` `1` `]; ` ` ` `if` `(curr > screen[n - ` `1` `]) ` ` ` `screen[n - ` `1` `] = curr; ` ` ` `} ` ` ` `} ` ` ` ` ` `return` `screen[N - ` `1` `]; ` ` ` `} ` ` ` ` ` `// Driver program ` ` ` `public` `static` `void` `main(String[] args) ` ` ` `{ ` ` ` `int` `N; ` ` ` ` ` `// for the rest of the array we will rely on the previous ` ` ` `// entries to compute new ones ` ` ` `for` `(N = ` `1` `; N <= ` `20` `; N++) ` ` ` `System.out.println(` `"Maximum Number of A's with keystrokes is "` `+ N + findoptimal(N)); ` ` ` `} ` `} ` ` ` `// This article is contributed by vt_m. ` |

*chevron_right*

*filter_none*

## Python3

`# A Dynamic Programming based Python program ` `# to find maximum number of A's ` `# that can be printed using four keys ` ` ` `# this function returns the optimal ` `# length string for N keystrokes ` `def` `findoptimal(N): ` ` ` ` ` `# The optimal string length is ` ` ` `# N when N is smaller than 7 ` ` ` `if` `(N <` `=` `6` `): ` ` ` `return` `N ` ` ` ` ` `# An array to store result of ` ` ` `# subproblems ` ` ` `screen ` `=` `[` `0` `]` `*` `N ` ` ` ` ` `# Initializing the optimal lengths ` ` ` `# array for uptil 6 input ` ` ` `# strokes. ` ` ` ` ` `for` `n ` `in` `range` `(` `1` `, ` `7` `): ` ` ` `screen[n` `-` `1` `] ` `=` `n ` ` ` ` ` `# Solve all subproblems in bottom manner ` ` ` `for` `n ` `in` `range` `(` `7` `, N ` `+` `1` `): ` ` ` ` ` `# Initialize length of optimal ` ` ` `# string for n keystrokes ` ` ` `screen[n` `-` `1` `] ` `=` `0` ` ` ` ` `# For any keystroke n, we need to ` ` ` `# loop from n-3 keystrokes ` ` ` `# back to 1 keystroke to find a breakpoint ` ` ` `# 'b' after which we ` ` ` `# will have ctrl-a, ctrl-c and then only ` ` ` `# ctrl-v all the way. ` ` ` `for` `b ` `in` `range` `(n` `-` `3` `, ` `0` `, ` `-` `1` `): ` ` ` ` ` `# if the breakpoint is at b'th keystroke then ` ` ` `# the optimal string would have length ` ` ` `# (n-b-1)*screen[b-1]; ` ` ` `curr ` `=` `(n` `-` `b` `-` `1` `)` `*` `screen[b` `-` `1` `] ` ` ` `if` `(curr > screen[n` `-` `1` `]): ` ` ` `screen[n` `-` `1` `] ` `=` `curr ` ` ` ` ` `return` `screen[N` `-` `1` `] ` ` ` `# Driver program ` `if` `__name__ ` `=` `=` `"__main__"` `: ` ` ` ` ` `# for the rest of the array we ` ` ` `# will rely on the previous ` ` ` `# entries to compute new ones ` ` ` `for` `N ` `in` `range` `(` `1` `, ` `21` `): ` ` ` `print` `(` `"Maximum Number of A's with "` `, N, ` `" keystrokes is "` `, ` ` ` `findoptimal(N)) ` ` ` `# this code is contributed by ` `# ChitraNayal ` |

*chevron_right*

*filter_none*

## C#

`/* A Dynamic Programming based C# ` `program to find maximum number ` `of A's that can be printed using ` `four keys */` `using` `System; ` `public` `class` `GFG { ` ` ` ` ` `// this function returns the optimal ` ` ` `// length string for N keystrokes ` ` ` `static` `int` `findoptimal(` `int` `N) ` ` ` `{ ` ` ` `// The optimal string length is N ` ` ` `// when N is smaller than 7 ` ` ` `if` `(N <= 6) ` ` ` `return` `N; ` ` ` ` ` `// An array to store result ` ` ` `// of subproblems ` ` ` `int` `[] screen = ` `new` `int` `[N]; ` ` ` ` ` `int` `b; ` `// To pick a breakpoint ` ` ` ` ` `// Initializing the optimal lengths ` ` ` `// array for uptil 6 input strokes ` ` ` `int` `n; ` ` ` `for` `(n = 1; n <= 6; n++) ` ` ` `screen[n - 1] = n; ` ` ` ` ` `// Solve all subproblems in bottom manner ` ` ` `for` `(n = 7; n <= N; n++) { ` ` ` `// Initialize length of optimal ` ` ` `// string for n keystrokes ` ` ` `screen[n - 1] = 0; ` ` ` ` ` `// For any keystroke n, we need ` ` ` `// to loop from n-3 keystrokes ` ` ` `// back to 1 keystroke to find ` ` ` `// a breakpoint 'b' after which we ` ` ` `// will have ctrl-a, ctrl-c and ` ` ` `// then only ctrl-v all the way. ` ` ` `for` `(b = n - 3; b >= 1; b--) { ` ` ` `// if the breakpoint is ` ` ` `// at b'th keystroke then ` ` ` `// the optimal string would ` ` ` `// have length ` ` ` `// (n-b-1)*screen[b-1]; ` ` ` `int` `curr = (n - b - 1) * screen[b - 1]; ` ` ` `if` `(curr > screen[n - 1]) ` ` ` `screen[n - 1] = curr; ` ` ` `} ` ` ` `} ` ` ` ` ` `return` `screen[N - 1]; ` ` ` `} ` ` ` ` ` `// Driver program ` ` ` `public` `static` `void` `Main(String[] args) ` ` ` `{ ` ` ` `int` `N; ` ` ` ` ` `// for the rest of the array we will rely on the previous ` ` ` `// entries to compute new ones ` ` ` `for` `(N = 1; N <= 20; N++) ` ` ` `Console.WriteLine(` `"Maximum Number of A's with {0} keystrokes is {1}\n"` `, ` ` ` `N, findoptimal(N)); ` ` ` `} ` `} ` ` ` `// This code is contributed by PrinciRaj1992 ` |

*chevron_right*

*filter_none*

Output:

Maximum Number of A's with 1 keystrokes is 1 Maximum Number of A's with 2 keystrokes is 2 Maximum Number of A's with 3 keystrokes is 3 Maximum Number of A's with 4 keystrokes is 4 Maximum Number of A's with 5 keystrokes is 5 Maximum Number of A's with 6 keystrokes is 6 Maximum Number of A's with 7 keystrokes is 9 Maximum Number of A's with 8 keystrokes is 12 Maximum Number of A's with 9 keystrokes is 16 Maximum Number of A's with 10 keystrokes is 20 Maximum Number of A's with 11 keystrokes is 27 Maximum Number of A's with 12 keystrokes is 36 Maximum Number of A's with 13 keystrokes is 48 Maximum Number of A's with 14 keystrokes is 64 Maximum Number of A's with 15 keystrokes is 81 Maximum Number of A's with 16 keystrokes is 108 Maximum Number of A's with 17 keystrokes is 144 Maximum Number of A's with 18 keystrokes is 192 Maximum Number of A's with 19 keystrokes is 256 Maximum Number of A's with 20 keystrokes is 324

Thanks to **Gaurav Saxena** for providing the above approach to solve this problem.

As the number of A’s become large, the effect of pressing Ctrl-V more than 3 times starts to become insubstantial as compared to just pressing Ctrl-A, Ctrl-C and Ctrl-V again. So, the above code can be made more efficient by checking the effect of pressing Ctrl-V for 1, 2, and 3 times only.

## C++

`// A Dynamic Programming based C++ program to find maximum ` `// number of A's that can be printed using four keys ` ` ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// This function returns the optimal length string for N keystrokes ` `int` `findoptimal(` `int` `N) ` `{ ` ` ` `// The optimal string length is N when N is smaller than 7 ` ` ` `if` `(N <= 6) ` ` ` `return` `N; ` ` ` ` ` `// An array to store result of subproblems ` ` ` `int` `screen[N]; ` ` ` ` ` `int` `b; ` `// To pick a breakpoint ` ` ` ` ` `// Initializing the optimal lengths array for uptil 6 input ` ` ` `// strokes. ` ` ` `int` `n; ` ` ` `for` `(n = 1; n <= 6; n++) ` ` ` `screen[n - 1] = n; ` ` ` ` ` `// Solve all subproblems in bottom-up manner ` ` ` `for` `(n = 7; n <= N; n++) { ` ` ` ` ` `// for any keystroke n, we will need to choose between:- ` ` ` `// 1. pressing Ctrl-V once after copying the ` ` ` `// A's obtained by n-3 keystrokes. ` ` ` ` ` `// 2. pressing Ctrl-V twice after copying the A's ` ` ` `// obtained by n-4 keystrokes. ` ` ` ` ` `// 3. pressing Ctrl-V thrice after copying the A's ` ` ` `// obtained by n-5 keystrokes. ` ` ` `screen[n - 1] = max(2 * screen[n - 4], ` ` ` `max(3 * screen[n - 5], ` `4 * screen[n - 6])); ` ` ` `} ` ` ` ` ` `return` `screen[N - 1]; ` `} ` ` ` `// Driver program ` `int` `main() ` `{ ` ` ` `int` `N; ` ` ` ` ` `// for the rest of the array we will rely on the previous ` ` ` `// entries to compute new ones ` ` ` `for` `(N = 1; N <= 20; N++) ` ` ` `printf` `(` `"Maximum Number of A's with %d keystrokes is %d\n"` `, ` ` ` `N, findoptimal(N)); ` `} ` |

*chevron_right*

*filter_none*

## Java

`// A Dynamic Programming based Java program ` `// to find maximum number of A's that ` `// can be printed using four keys ` `class` `GFG ` `{ ` ` ` `// This function returns the optimal length ` `// string for N keystrokes ` `static` `int` `findoptimal(` `int` `N) ` `{ ` ` ` `// The optimal string length is N ` ` ` `// when N is smaller than 7 ` ` ` `if` `(N <= ` `6` `) ` ` ` `return` `N; ` ` ` ` ` `// An array to store result of subproblems ` ` ` `int` `[]screen = ` `new` `int` `[N]; ` ` ` ` ` `int` `b; ` `// To pick a breakpoint ` ` ` ` ` `// Initializing the optimal lengths array ` ` ` `// for uptil 6 input strokes. ` ` ` `int` `n; ` ` ` `for` `(n = ` `1` `; n <= ` `6` `; n++) ` ` ` `screen[n - ` `1` `] = n; ` ` ` ` ` `// Solve all subproblems in bottom-up manner ` ` ` `for` `(n = ` `7` `; n <= N; n++) ` ` ` `{ ` ` ` ` ` `// for any keystroke n, we will need to choose between:- ` ` ` `// 1. pressing Ctrl-V once after copying the ` ` ` `// A's obtained by n-3 keystrokes. ` ` ` ` ` `// 2. pressing Ctrl-V twice after copying the A's ` ` ` `// obtained by n-4 keystrokes. ` ` ` ` ` `// 3. pressing Ctrl-V thrice after copying the A's ` ` ` `// obtained by n-5 keystrokes. ` ` ` `screen[n - ` `1` `] = Math.max(` `2` `* screen[n - ` `4` `], ` ` ` `Math.max(` `3` `* screen[n - ` `5` `], ` ` ` `4` `* screen[n - ` `6` `])); ` ` ` `} ` ` ` `return` `screen[N - ` `1` `]; ` `} ` ` ` `// Driver Code ` `public` `static` `void` `main(String[] args) ` `{ ` ` ` `int` `N; ` ` ` ` ` `// for the rest of the array we will rely ` ` ` `// on the previous entries to compute new ones ` ` ` `for` `(N = ` `1` `; N <= ` `20` `; N++) ` ` ` `System.out.printf(` `"Maximum Number of A's with"` `+ ` ` ` `" %d keystrokes is %d\n"` `, ` ` ` `N, findoptimal(N)); ` ` ` `} ` `} ` ` ` `// This code is contributed by Princi Singh ` |

*chevron_right*

*filter_none*

## Python3

`# A Dynamic Programming based Python3 program ` `# to find maximum number of A's ` `# that can be printed using four keys ` ` ` `# this function returns the optimal ` `# length string for N keystrokes ` `def` `findoptimal(N): ` ` ` ` ` `# The optimal string length is ` ` ` `# N when N is smaller than 7 ` ` ` `if` `(N <` `=` `6` `): ` ` ` `return` `N ` ` ` ` ` `# An array to store result of ` ` ` `# subproblems ` ` ` `screen ` `=` `[` `0` `] ` `*` `N ` ` ` ` ` `# Initializing the optimal lengths ` ` ` `# array for uptil 6 input ` ` ` `# strokes. ` ` ` ` ` `for` `n ` `in` `range` `(` `1` `, ` `7` `): ` ` ` `screen[n ` `-` `1` `] ` `=` `n ` ` ` ` ` `# Solve all subproblems in bottom manner ` ` ` `for` `n ` `in` `range` `(` `7` `, N ` `+` `1` `): ` ` ` ` ` `# for any keystroke n, we will need to choose between:- ` ` ` `# 1. pressing Ctrl-V once after copying the ` ` ` `# A's obtained by n-3 keystrokes. ` ` ` ` ` `# 2. pressing Ctrl-V twice after copying the A's ` ` ` `# obtained by n-4 keystrokes. ` ` ` ` ` `# 3. pressing Ctrl-V thrice after copying the A's ` ` ` `# obtained by n-5 keystrokes. ` ` ` `screen[n ` `-` `1` `] ` `=` `max` `(` `2` `*` `screen[n ` `-` `4` `], ` ` ` `max` `(` `3` `*` `screen[n ` `-` `5` `], ` ` ` `4` `*` `screen[n ` `-` `6` `])); ` ` ` ` ` `return` `screen[N ` `-` `1` `] ` ` ` `# Driver Code ` `if` `__name__ ` `=` `=` `"__main__"` `: ` ` ` ` ` `# for the rest of the array we ` ` ` `# will rely on the previous ` ` ` `# entries to compute new ones ` ` ` `for` `N ` `in` `range` `(` `1` `, ` `21` `): ` ` ` `print` `(` `"Maximum Number of A's with "` `, N, ` ` ` `" keystrokes is "` `, findoptimal(N)) ` ` ` `# This code is contributed by ashutosh450 ` |

*chevron_right*

*filter_none*

## C#

`// A Dynamic Programming based C# program ` `// to find maximum number of A's that ` `// can be printed using four keys ` `using` `System; ` ` ` `class` `GFG ` `{ ` ` ` `// This function returns the optimal length ` `// string for N keystrokes ` `static` `int` `findoptimal(` `int` `N) ` `{ ` ` ` `// The optimal string length is N ` ` ` `// when N is smaller than 7 ` ` ` `if` `(N <= 6) ` ` ` `return` `N; ` ` ` ` ` `// An array to store result of subproblems ` ` ` `int` `[]screen = ` `new` `int` `[N]; ` ` ` ` ` `// Initializing the optimal lengths array ` ` ` `// for uptil 6 input strokes. ` ` ` `int` `n; ` ` ` `for` `(n = 1; n <= 6; n++) ` ` ` `screen[n - 1] = n; ` ` ` ` ` `// Solve all subproblems in bottom-up manner ` ` ` `for` `(n = 7; n <= N; n++) ` ` ` `{ ` ` ` ` ` `// for any keystroke n, we will need to choose between:- ` ` ` `// 1. pressing Ctrl-V once after copying the ` ` ` `// A's obtained by n-3 keystrokes. ` ` ` ` ` `// 2. pressing Ctrl-V twice after copying the A's ` ` ` `// obtained by n-4 keystrokes. ` ` ` ` ` `// 3. pressing Ctrl-V thrice after copying the A's ` ` ` `// obtained by n-5 keystrokes. ` ` ` `screen[n - 1] = Math.Max(2 * screen[n - 4], ` ` ` `Math.Max(3 * screen[n - 5], ` ` ` `4 * screen[n - 6])); ` ` ` `} ` ` ` `return` `screen[N - 1]; ` `} ` ` ` `// Driver Code ` `public` `static` `void` `Main(String[] args) ` `{ ` ` ` `int` `N; ` ` ` ` ` `// for the rest of the array we will rely ` ` ` `// on the previous entries to compute new ones ` ` ` `for` `(N = 1; N <= 20; N++) ` ` ` `Console.Write(` `"Maximum Number of A's with"` `+ ` ` ` `" {0} keystrokes is {1}\n"` `, ` ` ` `N, findoptimal(N)); ` ` ` `} ` `} ` ` ` `// This code is contributed by PrinciRaj1992 ` |

*chevron_right*

*filter_none*

**Output:**

Maximum Number of A's with 1 keystrokes is 1 Maximum Number of A's with 2 keystrokes is 2 Maximum Number of A's with 3 keystrokes is 3 Maximum Number of A's with 4 keystrokes is 4 Maximum Number of A's with 5 keystrokes is 5 Maximum Number of A's with 6 keystrokes is 6 Maximum Number of A's with 7 keystrokes is 9 Maximum Number of A's with 8 keystrokes is 12 Maximum Number of A's with 9 keystrokes is 16 Maximum Number of A's with 10 keystrokes is 20 Maximum Number of A's with 11 keystrokes is 27 Maximum Number of A's with 12 keystrokes is 36 Maximum Number of A's with 13 keystrokes is 48 Maximum Number of A's with 14 keystrokes is 64 Maximum Number of A's with 15 keystrokes is 81 Maximum Number of A's with 16 keystrokes is 108 Maximum Number of A's with 17 keystrokes is 144 Maximum Number of A's with 18 keystrokes is 192 Maximum Number of A's with 19 keystrokes is 256 Maximum Number of A's with 20 keystrokes is 324

Thanks to Sahil for providing the above approach to solve this problem.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.

## Recommended Posts:

- Print all paths from top left to bottom right in a matrix with four moves allowed
- Find four elements that sum to a given value | Set 1 (n^3 solution)
- How to check if given four points form a square
- Find four elements that sum to a given value | Set 2
- Find four elements a, b, c and d in an array such that a+b = c+d
- Minimum sum subsequence such that at least one of every four consecutive elements is picked
- Total number of possible Binary Search Trees and Binary Trees with n keys
- Construct all possible BSTs for keys 1 to N
- Convert a BST to a Binary Tree such that sum of all greater keys is added to every key
- Print even and odd numbers in a given range using recursion
- Given a sequence of words, print all anagrams together using STL
- Efficient program to print all prime factors of a given number
- Print all non-increasing sequences of sum equal to a given number x
- Print Maximum Length Chain of Pairs
- Print all paths of the Binary Tree with maximum element in each path greater than or equal to K
- Print the Maximum Subarray Sum
- Print all root-to-leaf paths with maximum count of even nodes
- Maximum size subset with given sum using Backtracking
- Maximum sum subarray having sum less than or equal to given sum using Set
- Query to find the maximum and minimum weight between two nodes in the given tree using LCA.