Coût minimum de conversion de 1 en N, qui peut être obtenu en multipliant par X ou en tournant à droite du nombre

Nous pouvons utiliser la technique suivante pour trouver le moyen le moins cher de multiplier X ou de faire pivoter son nombre de 1 à N vers la droite. Pour surveiller le coût minimum initial, créez une variable de coût. En passant de N à 1, vérifiez si N est divisible par X à chaque étape. Si tel est le cas, divisez N par X pour le mettre à jour et continuez le processus. Si N n'est pas divisible par X, bouclez les chiffres de N vers la droite pour augmenter sa valeur. Ajoutez la variable de coût dans ce cas. La valeur finale de la variable de coût sera le montant minimum requis pour transformer 1 en N. L'algorithme détermine efficacement les opérations minimales requises pour effectuer la transformation souhaitée à l'aide d'une rotation ou d'une multiplication numérique.

Méthode à utiliser

• Approche naïve : rotation à droite des nombres

• Méthode efficace : multiplier par X

Facile : faites pivoter les nombres vers la droite

L'approche naïve consiste à commencer par le chiffre 1 et à faire pivoter ses chiffres à plusieurs reprises vers la droite jusqu'à atteindre le chiffre cible N. À chaque tour, le dernier numéro devient le premier numéro. Bien que conceptuellement simple, cette stratégie peut s’avérer inefficace pour des valeurs élevées de N et nécessiter de nombreuses étapes pour atteindre le nombre cible. À mesure que N augmente, le nombre de rotations augmente également rapidement, ce qui en fait une méthode moins efficace pour déterminer le coût minimum de conversion de 1 en N. En raison de son inefficacité, cette méthode n'est pas recommandée pour les grandes valeurs de N, alors que d'autres méthodes, comme la division de N par X, se sont révélées plus efficaces pour trouver le coût de transformation le plus bas.

Algorithme

• Créez la variable "coût" pour suivre les étapes nécessaires pour atteindre N et initialisez-la à 1 pour représenter la valeur actuelle.

• Répétez ces instructions jusqu'à ce que le numéro actuel soit égal à N :

  Faites pivoter les chiffres du numéro actuel vers la droite pour que le dernier chiffre devienne le premier chiffre.

  Enregistrez le nombre de tours requis en incrémentant la variable "coût" de 1.

• Une fois que le nombre actuel est égal à N, la variable "coût" stockera le nombre minimum d'étapes requises pour faire pivoter l'entier d'origine (1) vers N en utilisant une rotation à droite.

Exemple

#include <iostream>
#include <cmath>

int rotateDigits(int num, int numDigits) {
    return (num / 10) + (num % 10) * std::pow(10, numDigits - 1);
}

int main() {
    int N = 123; // Replace this with your desired N value

    int current = 1;
    int cost = 0;
    bool found = false;

    while (current != N) {
        int numDigits = std::to_string(current).length();
        current = rotateDigits(current, numDigits);
        cost++;

        if (cost > N) {
            std::cout << "N cannot be reached from 1 using right rotations." << std::endl;
            found = true;
            break;
        }
    }

    if (!found) {
        std::cout << "Minimum steps to reach N: " << cost << std::endl;
    }
    return 0;
}

Sortie

N cannot be reached from 1 using right rotations.

Méthode efficace : multiplier par X

La meilleure façon de minimiser le coût de multiplication de 1 par N est de diviser périodiquement N par X jusqu'à ce que le résultat soit 1. Pour y parvenir, initialisez une variable de coût pour surveiller le coût minimum. Nous déterminons si N est divisible par X en commençant par la valeur de N. Si N et X sont divisibles, le coût augmente et une opération de division est effectuée. Répétez ce processus jusqu'à ce que N soit égal à 1. Cette méthode est plus efficace que la "rotation du nombre à droite" car elle nécessite moins d'étapes pour obtenir le résultat 1. En raison de sa nature plus rapide et plus efficace, il s’agit de la méthode privilégiée pour déterminer le coût de commutation le plus bas.

Algorithme

• Pour suivre le coût minimum, initialisez la variable "coût" à 0.

• Partez d'un nombre cible N donné, en utilisant un multiplicateur fixe X.

• Tant que N est supérieur à 1, répétez les étapes 4 à 6.

• En supposant que N% X == 0, déterminez si N est divisible par X.

• Si N est divisible (N = N/X), divisez N par X et ajoutez 1 à la variable "coût".

• S'il n'est pas divisible, bouclez les N nombres vers la droite (en déplaçant le dernier chiffre vers le premier) et augmentez le "coût" de 1.

• Répétez les étapes 3 à 6 jusqu'à ce que N devienne 1.

• Le dernier "coût" représente le minimum requis pour multiplier par X ou décaler le nombre vers la droite pour changer 1 en N.

Exemple

#include <iostream>
#include <cmath>

int main() {
    int X = 3;
    int N = 100;
    int cost = 0;

    while (N > 1) {
        if (N % X == 0) {
            N /= X;
            cost++;
        } else {
            int lastDigit = N % 10;
            N = (N / 10) + (lastDigit * std::pow(10, std::floor(std::log10(N))));
            cost++;
        }
    }

    std::cout << "Final cost: " << cost << std::endl;

    return 0;
}

Sortie

Final cost: 2

Conclusion

En résumé, lorsqu'il s'agit de déterminer le coût le plus bas de conversion de 1 en N en multipliant par X ou en faisant pivoter le nombre vers la droite, la méthode efficace de multiplication par L'approche plus rationalisée fournie par des méthodes efficaces nécessite moins d'étapes pour atteindre le nombre requis de N. D’un autre côté, les méthodes naïves peuvent s’avérer inefficaces et chronophages, notamment pour des valeurs de N plus élevées. Nous pouvons réduire les processus requis et utiliser des méthodes efficaces pour déterminer le moyen le plus économique de convertir 1 en N. Cette stratégie résout le problème de la détermination du coût minimum de ce processus de conversion et s'avère être un algorithme plus utile et plus efficace.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!