Nombre maximum de caractères à l'aide des touches A, Ctrl + A, Ctrl + C et Ctrl + V

Ceci est une question d'entretien de Google. Je ne suis pas capable de le résoudre moi-même. Quelqu'un peut-il faire la lumière?

Écrivez un programme pour imprimer la séquence de frappes de telle sorte qu'il génère le nombre maximum de caractères «A». Vous êtes autorisé à utiliser 4 touches: A, Ctrl+ A, Ctrl+ Cet Ctrl+ V. Seules N frappes sont autorisées. Tous les Ctrlcaractères + sont considérés comme une touche, donc Ctrl+ Aest une touche.

Par exemple, la séquence A, Ctrl+ A, Ctrl+ C, Ctrl+ Vgénère deux A dans 4 frappes.

• Ctrl + A est Sélectionner tout
• Ctrl + C est Copier
• Ctrl + V est Coller

J'ai fait des mathématiques. Pour tout N, en utilisant x nombres de A, un Ctrl+ A, un Ctrl+ Cet y Ctrl+ V, nous pouvons générer max ((N-1) / 2) ² nombre de A. Pour certains N> M, il vaut mieux utiliser autant de Ctrl+ A, Ctrl+ Cet Ctrl+V séquences comme il double le nombre d'A.

La séquence Ctrl+ A, Ctrl+ V, Ctrl+ Cn'écrasera pas la sélection existante. Il ajoutera la sélection copiée à celle sélectionnée.

Il existe une solution de programmation dynamique. Nous commençons par savoir que 0 clé peut nous faire 0 A. Ensuite, nous parcourons ijusqu'à n, en faisant deux choses: en appuyant une fois sur A et en appuyant sur sélectionner tout + copier suivi de jtemps de collage (en fait j-i-1ci-dessous; notez l'astuce ici: le contenu est toujours dans le presse-papiers, nous pouvons donc le coller plusieurs fois sans copie à chaque fois). Nous n'avons qu'à considérer jusqu'à 4 pâtes consécutives, car sélectionner, copier, coller x 5 équivaut à sélectionner, copier, coller, sélectionner, copier, coller et ce dernier est meilleur car il nous en laisse plus dans le presse-papiers. Une fois que nous avons atteint n, nous avons le résultat souhaité.

La complexité peut sembler être O (N), mais comme les nombres croissent à une vitesse exponentielle, il est en fait O (N ² ) en raison de la complexité de multiplier les grands nombres. Vous trouverez ci-dessous une implémentation Python. Il faut environ 0,5 seconde pour calculer N = 50 000.

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]

Dans le code, jreprésente le nombre total de touches pressées après notre nouvelle séquence de touches. Nous avons déjà des itouches à ce stade, et 2 nouvelles touches permettent de sélectionner tout et de copier. Par conséquent, nous atteignons des j-i-2temps de pâte . Puisque le collage ajoute à la séquence existante de dp[i] A's, nous devons ajouter la 1création j-i-1. Cela explique le j-i-1dans la 2ème-dernière ligne.

Voici quelques résultats ( n=> nombre de A):

• 7 => 9
• 8 => 12
• 9 => 16
• 10 => 20
• 100 => 1391569403904
• 1 000 => 3268160001953743683783272702066311903448533894049486008426303248121757146615064636953144900245 174442911064952028008546304
• 50 000 => un très grand nombre!

Je suis d'accord avec @SB pour dire que vous devriez toujours énoncer vos hypothèses: la mienne est que vous n'avez pas besoin de coller deux fois pour doubler le nombre de caractères. Cela obtient la réponse pour 7, donc à moins que ma solution ne soit fausse, l'hypothèse doit être correcte.

En cas de quelqu'un se demande pourquoi je ne suis pas la vérification des séquences de la forme Ctrl+ A, Ctrl+ C, A, Ctrl+ V: Le résultat final sera toujours le même que celui A, Ctrl+ A, Ctrl+ C, Ctrl+ Vque je ne considère.

En utilisant la solution de marcog, j'ai trouvé un modèle qui commence à n=16 . Pour illustrer cela, voici les frappes n=24jusqu'à n=29, j'ai remplacé ^ A par S (sélection), ^ C par C (copie) et ^ V par P (coller) pour plus de lisibilité:

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

Après un premier 4 As, le modèle idéal est de sélectionner, copier, coller, coller, coller et répéter. Cela multipliera le nombre de As par 4 toutes les 5 frappes. Si ce modèle de 5 touches ne peut pas consommer les touches restantes à lui seul, un certain nombre de 4 modèles de touches (SCPP) consomme les dernières frappes, remplaçant SCPPP (ou supprimant l'une des pâtes) si nécessaire. Les 4 modèles de touches multiplient le total par 3 toutes les 4 frappes.

En utilisant ce modèle, voici du code Python qui obtient les mêmes résultats que la solution de marcog, mais est O (1) edit : C'est en fait O (log n) en raison de l'exponentiation, merci à IVlad pour l'avoir signalé.

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)

Calcul de e3: Il y a toujours entre 0 et 4 motifs SCPP à la fin de la liste des touches, car n % 5 == 4il y en a 4, n % 5 == 1il y en a 3, n % 5 == 2il y en a 2, n % 5 == 3il y en a 1 et n % 5 == 4il y en a 0. Cela peut être simplifié à (4 - n) % 5.

Calcul de e4: Le nombre total de motifs augmente de 1 chaque fois n % 5 == 0, car il s'avère que ce nombre augmente à exactement n / 5. En utilisant la division du sol, nous pouvons obtenir le nombre total de motifs, le nombre total pour e4est le nombre total de motifs moins e3. Pour ceux qui ne connaissent pas Python, //est la notation à l'épreuve du temps pour la division par étage.

Voici comment je l'aborderais:

• présumer CtrlA = tout sélectionner
• présumer CtrlC = copie de la sélection
• assume CtrlV= coller la sélection copiée

étant donné du texte, il faut 4 frappes pour le dupliquer:

• CtrlA pour tout sélectionner
• CtrlC pour le copier
• CtrlV coller (cela collera sur la sélection - ÉNONCER VOS HYPOTHÈSES)
• CtrlV coller à nouveau ce qui le double.

À partir de là, vous pouvez envisager de faire 4 ou 5 A, puis de parcourir ce qui précède. Notez que faire ctrl + a, c, v, vaugmentera votre texte de façon exponentielle au fur et à mesure que vous parcourez. Si les coups restants <4, continuez simplement à faire unCtrlV

La clé des interviews @ endroits comme Google est d'exposer vos hypothèses et de communiquer votre réflexion. ils veulent savoir comment vous résolvez les problèmes.

Il est résoluble en O (1): Comme pour les nombres de Fibonacci, il existe une formule pour calculer le nombre de A imprimés (et la séquence de frappes):

1) Nous pouvons simplifier la description du problème:

• N'ayant que [A], [Ca] + [Cc], [Cv] et un tampon copier-coller vide

équivaut à

• n'ayant que [Ca] + [Cc], [Cv] et "A" dans le tampon copier-coller.

2) Nous pouvons décrire la séquence de frappes comme une chaîne de N caractères parmi {'*', 'V', 'v'}, où 'v' signifie [Cv] et '*' signifie [Ca] et 'V »signifie [Cc]. Exemple: "vvvv * Vvvvv * Vvvv"

La longueur de cette chaîne est toujours égale à N.

Le produit des longueurs des mots Vv dans cette chaîne est égal au nombre de As produits.

3) Étant donné une longueur fixe N pour cette chaîne et un nombre fixe K de mots, le résultat sera maximal si tous les mots ont des longueurs presque égales. Leur différence par paire n'est pas supérieure à ± 1.

Maintenant, quel est le nombre optimal K, si N est donné?

4) Supposons que nous voulions augmenter le nombre de mots en ajoutant un seul mot de longueur L, puis nous devons réduire L + 1 fois tout mot précédent par un «v». Exemple: "… * Vvvv * Vvvv * Vvvv * Vvvv" -> "… * Vvv * Vvv * Vvv * Vvv * Vvv"

Maintenant, quelle est la longueur de mot optimale L?

(5 * 5 * 5 * 5 * 5) <(4 * 4 * 4 * 4 * 4) * 4, (4 * 4 * 4 * 4)> (3 * 3 * 3 * 3) * 3

=> Optimal est L = 4.

5) Supposons que nous ayons un N suffisamment grand pour générer une chaîne avec plusieurs mots de longueur 4, mais il reste quelques frappes; comment les utiliser?

• S'il en reste 5 ou plus: ajoutez un autre mot de longueur 4.

• S'il reste 0: Terminé.

• S'il en reste 4: nous pourrions soit

  a) ajoutez un mot de longueur 3: 4 * 4 * 4 * 4 * 3 = 768.

  b) ou augmentez de 4 mots jusqu'à 5: 5 * 5 * 5 * 5 = 625. => Ajouter un mot, c'est mieux.

• S'il en reste 3: nous pourrions soit

  a) ou ajoutez un mot de longueur 3 en ajustant le mot précédent de 4 à 3: 4 * 4 * 4 * 2 = 128 <4 * 4 * 3 * 3 = 144.

  b) augmenter de 3 mots jusqu'à 5: 5 * 5 * 5 = 125. => Ajouter un mot, c'est mieux.

• S'il en reste 2: nous pourrions soit

  a) ou ajoutez un mot de longueur 3 en ajustant les deux mots précédents de 4 à 3: 4 * 4 * 1 = 16 <3 * 3 * 3 = 27.

  b) augmenter de 2 mots jusqu'à 5: 5 * 5 = 25. => Ajouter un mot, c'est mieux.

• S'il en reste 1: nous pourrions soit

  a) ou ajoutez un mot de longueur 3 en ajustant les trois mots précédents de 4 à 3: 4 * 4 * 4 * 0 = 0 <3 * 3 * 3 * 3 = 81.

  b) augmentez d'un mot à la longueur 5: 4 * 4 * 5 = 80. => Ajouter un mot, c'est mieux.

6) Maintenant, que se passe-t-il si nous n'avons pas un "N suffisamment grand" pour utiliser les règles de 5)? Nous devons nous en tenir au plan b), si possible! Les chaînes pour petit N sont:

1: "v", 2: "vv", 3: "vvv", 4: "vvvv"

5: "vvvvv" → 5 (plan b)

6: "vvvvvv" → 6 (plan b)

7: "vvv * Vvv" → 9 (plan a)

8: "vvvv * Vvv" → 12 (plan a)

9: "vvvv * Vvvv" → 16

10: "vvvv * Vvvvv" → 20 (plan b)

11: "vvv * Vvv * Vvv" → 29 (plan a)

12: "vvvv * Vvv * Vvv" → 36 (plan a)

13: "vvvv * Vvvv * Vvv" → 48 (plan a)

14: "vvvv * Vvvv * Vvvv" → 64

15: "vvv * Vvv * Vvv * Vvv" → 81 (plan a)

…

7) Maintenant, quel est le nombre optimal K de mots dans une chaîne de longueur N?

Si N <7 alors K = 1 sinon si 6 <N <11 alors K = 2; sinon: K = ceil ((N + 1) / 5)

Écrit en C / C ++ / Java: int K = (N<7)?(1) : (N<11)?(2) : ((N+5)/5);

Et si N> 10, alors le nombre de mots de longueur 3 sera: K * 5-1-N. Avec cela, nous pouvons calculer le nombre de As imprimés:

Si N> 10, le nombre de As sera: 4 ^ {N + 1-4K} · 3 ^ {5K-N-1}

Utiliser CtrlA+ CtrlC+ CtrlVn'est un avantage qu'après 4 'A'.

Donc je ferais quelque chose comme ça (en pseudo-BASIC-code, puisque vous n'avez spécifié aucun langage approprié):

// 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

Éditer

1. Revenons à l'utilisation d'un single CtrlVdans la boucle principale.
2. Ajout de quelques commentaires pour expliquer ce que j'essaie de faire ici.
3. Correction d'un problème avec le bloc "quatre premiers A".

Il faut 3 frappes pour doubler votre nombre d'As. Cela n'a de sens de commencer à doubler que lorsque vous avez déjà imprimé 3 As ou plus. Vous voulez que votre dernière frappe autorisée soit a CtrlVpour vous assurer que vous doublez le plus grand nombre possible, donc afin de l'aligner, nous remplirons toutes les frappes supplémentaires après les trois premiers As au début avec plus de 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");
}

Éditer:

C'est terrible, j'ai complètement pris de l'avance sur moi-même et je n'ai pas envisagé plusieurs pâtes pour chaque copie.

Modifier 2:

Je pense que coller 3 fois est optimal, lorsque vous avez suffisamment de frappes pour le faire. En 5 touches, vous multipliez votre nombre de As par 4. C'est mieux que de multiplier par 3 en utilisant 4 touches et mieux que de multiplier par 5 en utilisant 6 touches. J'ai comparé cela en donnant à chaque méthode le même nombre de frappes, suffisamment pour qu'elles terminent chacune un cycle en même temps (60), laissant le multiplicateur 3 faire 15 cycles, le multiplicateur 4 faire 12 cycles et le 5 multiplicateur fait 10 cycles. 3 ^ 15 = 14 348 907, 4 ^ 12 = 16 777 216 et 5 ^ 10 = 9 765 625. S'il ne reste que 4 frappes, il vaut mieux faire un multiplicateur à 3 que de coller 4 fois de plus, ce qui fait essentiellement du multiplicateur 4 précédent un multiplicateur à 8. S'il ne reste que 3 touches, un multiplicateur à 2 est préférable.

Supposons que vous ayez x caractères dans le presse-papiers et x caractères dans la zone de texte; appelons-le "état x".

Appuyez sur "Coller" plusieurs fois (je le désigne par m-1commodité), puis sur "Tout sélectionner" et "Copier"; après cette séquence, nous arrivons à "l'état m * x". Ici, nous avons gaspillé un total de m + 1 frappes. Donc, la croissance asymptotique est (au moins) quelque chose comme f^n, où f =m^(1/(m+1)) . Je crois que c'est la croissance asymptotique maximale possible, même si je ne peux pas (encore) le prouver.

Essayer différentes valeurs de m montre que le maximum pour f est obtenu pour m=4 .

Utilisons l'algorithme suivant:

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

(pas sûr que ce soit le meilleur).

Le nombre de fois pour appuyer sur A au début est de 3: si vous appuyez 4 fois, vous manquez l'occasion de doubler le nombre de A en 3 frappes supplémentaires.

Le nombre de fois pour appuyer sur Coller à la fin n'est pas supérieur à 5: s'il vous reste 6 frappes ou plus, vous pouvez utiliser Coller, Coller, Coller, Sélectionner tout, Copier, Coller à la place.

Donc, nous obtenons l'algorithme suivant:

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

(pas sûr que ce soit le meilleur). Le nombre de caractères après exécution est quelque chose comme

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

Exemples de valeurs: 1,2,3,4,5,6,9,12,15,18,24,36,48,60,72,96,144,192,240,288, ...

Ce qui suit utilise la deuxième modification du PO selon laquelle le collage ne remplace pas le texte existant.

Remarquez quelques choses:

• ^ A et ^ C peuvent être considérés comme une action unique qui nécessite deux frappes, car il n'est jamais logique de les faire individuellement. En fait, nous pouvons remplacer toutes les instances de ^ A ^ C par ^ K ^ V, où ^ K est une clé opération "couper" à (abrégons-la X). Nous verrons que traiter ^ K est beaucoup plus agréable que le ^ A ^ C à deux coûts.
• Supposons qu'un «A» commence dans le presse-papiers. Alors ^ V (abrégons-le Y) est strictement supérieur à A et nous pouvons écarter ce dernier de toute considération. (Dans le problème réel, si le presse-papiers commence vide, dans ce qui suit, nous remplacerons simplement Y par A au lieu de ^ V jusqu'au premier X.)

Chaque séquence de touches raisonnable peut donc être interprétée comme un groupe de Y séparés par des X, par exemple YYYXYXYYXY. Notons V (s) le nombre de 'A' produits par la séquence s. Alors V (nXm) = V (n) * V (m), car X remplace essentiellement tout Y de m par V (n) 'A.

Le problème du copier-coller est donc isomorphe au problème suivant: "en utilisant m + 1 nombres qui totalisent Nm, maximisez leur produit." Par exemple, lorsque N = 6, la réponse est m = 1 et les nombres (2,3). 6 = 2 * 3 = V (YYXYYY) = V (AA ^ A ^ C ^ V ^ V) (ou V (YYYXYY) = V (AAA ^ A ^ C ^ V).)

Nous pouvons faire quelques observations:

Pour une valeur fixe de m, les nombres à choisir sont ceil( (N-m)/(m+1) )et floor( (N-m)/(m+1) )(quelle que soit la combinaison qui fait que la somme fonctionne; plus précisément, vous aurez besoin (N-m) % (m+1) ceilset le reste floors). C'est parce que, pour a < b,(a+1)*(b-1) >= a*b .

Malheureusement, je ne vois pas de moyen facile de déterminer la valeur de m. Si c'était mon entretien, je proposerais deux solutions à ce stade:

Option 1. Boucle sur tout le possible m. Une n log nsolution O ( ).

Code 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;
}

Option 2. Permettre md'atteindre des valeurs non entières et trouver sa valeur optimale en prenant la dérivée de [(N-m)/(m+1)]^mpar rapport à met en résolvant sa racine. Il n'y a pas de solution analytique, mais la racine peut être trouvée en utilisant par exemple la méthode de Newton. Ensuite, utilisez le sol et le plafond de cette racine pour la valeur de m, et choisissez celui qui est le meilleur.

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];
}

Voici mon approche et ma solution avec le code ci-dessous.

Approche:

Il existe trois opérations distinctes qui peuvent être effectuées.

1. Keystroke A - Sort un caractère 'A'
2. Keystroke (Ctrl-A) + (Ctrl-C) - Ne produit rien essentiellement. Ces deux frappes peuvent être combinées en une seule opération car chacune de ces frappes n'a aucun sens individuellement. En outre, cette frappe définit la sortie pour la prochaine opération de collage.
3. Séquence de touches (Ctrl-V) - La sortie de cette frappe dépend vraiment de l'opération précédente (deuxième) et nous aurions donc besoin d'en tenir compte dans notre code.

Compte tenu des trois opérations distinctes et de leurs sorties respectives, nous devons parcourir toutes les permutations de ces opérations.

Supposition:

Maintenant, une version de ce problème indique que la séquence de frappes, Ctrl + A -> Ctrl + C -> Ctrl + V, écrase la sélection en surbrillance. Pour prendre en compte cette hypothèse, une seule ligne de code doit être ajoutée à la solution ci-dessous où la variable imprimée dans le cas 2 est définie sur 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;    
            }

Pour cette solution

Le code ci-dessous imprimera quelques séquences et la dernière séquence est la bonne réponse pour tout N. donné, par exemple pour N = 11, ce sera la séquence correcte

Avec l'hypothèse

A, A, A, A, A, C, S, V, V, V, V,: 20:

Sans l'hypothèse

A, A, A, C, S, V, V, C, S, V, V,: 27:

J'ai décidé de retenir l'hypothèse de cette solution.

Légende des touches:

«A» - A

'C' - Ctrl + A

'S' - Ctrl + C

'V' - Ctrl + V

Code:

#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;
}    

En utilisant les astuces mentionnées dans les réponses ci-dessus, mathématiquement, la solution peut être expliquée dans une équation comme suit:

4 + 4 ^ [(N-4) / 5] + ((N-4)% 5) * 4 ^ [(N-4) / 5]. où [] est le plus grand facteur entier

Il y a un compromis entre l'impression manuelle des mA, puis l'utilisation de Ctrl+ A, Ctrl+ Cet Nm-2 Ctrl+ V. La meilleure solution est au milieu. Si le nombre maximal de frappes = 10, la meilleure solution consiste à taper 5 A ou 4 A.

essayez d'utiliser ceci Regardez ce http://www.geeksforgeeks.org/how-to-print-maximum-number-of-a-using-given-four-keys/ et optimisez peut-être un peu la recherche des résultats vers le milieu point.

Voici ma solution avec la programmation dynamique, sans boucle imbriquée, et qui imprime également les caractères réels que vous auriez besoin de taper:

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]))

Ceci est la sortie ('a' signifie 'CTRL + A', etc.)

 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 

Si N coups de touche sont autorisés, alors le résultat est N-3.

A -> N-3

CTRL+ A-> Sélection de ces N caractères: +1

CTRL+ C-> Copie de ces N caractères: +1

Ctrl+ V-> Collage des N caractères. : +1 ie, (Puisque nous avons sélectionné les caractères entiers en utilisant CTRL+ A) En remplaçant ces caractères N-3 existants par les caractères N-3 copiés (qui remplacent les mêmes caractères) et le résultat est N-3.