How to print maximum number of A’s using given four keys

28 Feb, 2022
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 afterward 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++14
C
Java
Python3
C#
PHP
Javascript
/* A recursive C++ program to print maximum number of A's usingfollowing four keys */#include <bits/stdc++.h>using namespace std; // A recursive function that returns the optimal length string// for N keystrokesint 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 programint main(){    int N;     // for the rest of the array we will reply 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
/* 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 keystrokesint 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 programint main(){    int N;     // for the rest of the array we will reply 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));}
/* 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 reply 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.
# 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 programif __name__=='__main__':      # for the rest of the array we will# reply 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 contributed by sahilshelangia
/* A recursive C# programto print maximum numberof A's using followingfour 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 reply 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
<?php/* A recursive PHP program to print maximum number of A's usingfollowing four keys */ // A recursive function that returns the optimal//  length string for N keystrokesfunction 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 reply on the previous// entries to compute new onesfor ($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?>
<script> // A recursive Javascript program to print// maximum number of A's using// following four keys     // A recursive function that returns the// optimal length string  for N keystrokesfunction findoptimal(N){         // The optimal string length is N    // when N is smaller than 7    if (N <= 6)        return N;     // Initialize result    let 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.    let 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];        let curr = (N - b - 1) * findoptimal(b);                 if (curr > max)            max = curr;    }    return max;} // Driver codelet N; // For the rest of the array we// will reply on the previous// entries to compute new onesfor(N = 1; N <= 20; N++)    document.write("Maximum Number of A's with "+                   N + " keystrokes is " +                   findoptimal(N) + "<br>"); // This code is contributed by avanitrachhadiya2155     </script>
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 a bottom-up manner. 
Below is Dynamic Programming based C implementation where an auxiliary array screen[N] is used to store result of subproblems. 
C++
C
Java
Python3
C#
Javascript
/* A Dynamic Programming based C program to find maximum number of A'sthat can be printed using four keys */#include <iostream>using namespace std;  // this function returns the optimal length string for N keystrokesint 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 until 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 programint main(){    int N;     // for the rest of the array we will reply 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
/* 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 keystrokesint 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 until 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 programint main(){    int N;     // for the rest of the array we will reply 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));}
/* 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 until 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 reply 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.
# 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 keystrokesdef 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 until 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 programif __name__ == "__main__":     # for the rest of the array we    # will reply 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
/* A Dynamic Programming based C#program to find maximum numberof A's that can be printed usingfour 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 until 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 reply 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
<script> // A Dynamic Programming based javascript// 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  function 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    let screen = new Array(N);    for(let i = 0; i < N; i++)    {        screen[i] = 0;    }         // To pick a breakpoint    let b;     // Initializing the optimal lengths    // array for until 6 input strokes    let 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];            let curr = (n - b - 1) * screen[b - 1];                         if (curr > screen[n - 1])                screen[n - 1] = curr;        }    }    return screen[N - 1];} // Driver codelet N;for(N = 1; N <= 20; N++)    document.write("Maximum Number of A's with " +                   N + " keystrokes is " +                   findoptimal(N) + "<br>"); // This code is contributed by rag2127 </script>
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++
Java
Python3
C#
Javascript
// 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 keystrokesint 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 until 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 programint main(){    int N;     // for the rest of the array we will reply 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));}
// A Dynamic Programming based Java program// to find maximum number of A's that// can be printed using four keysclass GFG{ // This function returns the optimal length// string for N keystrokesstatic 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 Codepublic static void main(String[] args){    int N;     // for the rest of the array we will reply    // 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
# 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 keystrokesdef 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 until 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 Codeif __name__ == "__main__":     # for the rest of the array we    # will reply 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
// A Dynamic Programming based C# program// to find maximum number of A's that// can be printed using four keysusing System; class GFG{ // This function returns the optimal length// string for N keystrokesstatic 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 Codepublic static void Main(String[] args){    int N;     // for the rest of the array we will reply    // 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
<script> // A Dynamic Programming based// JavaScript program to find maximum// number of A's that can be printed// using four keys // This function returns the optimal// length string for N keystrokesfunction 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    let screen = [];     let b; // To pick a breakpoint     // Initializing the optimal lengths    // array for until 6 input    // strokes.    let 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 programlet N;// for the rest of the array we will reply on the previous// entries to compute new onesfor (N = 1; N <= 20; N++)    document.write(    "Maximum Number of A's with "+ N +" keystrokes is "    +findoptimal(N)+"<br>"    ); </script>
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 
Sam007
sahilshelangia
ukasp
princiraj1992
aman neekhara
SahilSingh3
princi singh
ashutosh450
SHUBHAMSINGH10
avanitrachhadiya2155
rag2127
rohitsingh07052
surinderdawra388
kk9826225
Amazon
Google
Paytm
Dynamic Programming
Recursion
Paytm
Amazon
Google
Dynamic Programming
Recursion
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Find if there is a path between two vertices in an undirected graph
Count number of binary strings without consecutive 1's
Optimal Substructure Property in Dynamic Programming | DP-2
Unique paths in a Grid with Obstacles
How to solve a Dynamic Programming Problem ?
Write a program to print all permutations of a given string
Given an array A[] and a number x, check for pair in A[] with sum as x (aka Two Sum)
Recursion
Program for Tower of Hanoi
Backtracking | Introduction