Comment convertir les 3 derniers chiffres d'un nombre en 0

Question

Comment convertir les 3 derniers chiffres d'un nombre en 0

exemple 3444678 à 3444000

Je peux faire comme

(int)(3444678/1000) * 1000= 3444000

Mais la division et la multiplication peuvent coûter cher...

Toute autre solution ????

Answer 1

Vous pouvez essayer

n - (n % 1000)

mais l'opérateur modulus pourrait être aussi coûteux qu'une division. Quoi qu'il en soit, cela ressemble fort à une micro-optimisation. S'agit-il vraiment de votre goulot d'étranglement ?

Answer 2

Un tour de passe-passe, donc :

n >>= 3;
n -= n % (5 * 5 * 5);
n <<= 3;

Est-il plus rapide ? C'est peu probable.

Mais voici un fait amusant : gcc n'utilise pas la division/module pour cela :

n -= n % 1000;

Il multiplie par un nombre farfelu (274877907) et fait d'autres choses qui sont vraisemblablement plus rapides.

La morale de cette histoire : plus l'objectif de votre code est évident pour le compilateur, plus il est probable que le compilateur l'optimisera d'une manière à laquelle vous n'auriez jamais pensé. Si le code est plus facile à comprendre pour les humains, c'est un autre avantage.

Answer 3

Juste en passant (vous avez déjà reçu de bons commentaires ici).

La manipulation des bits ne fonctionne jamais avec les nombres décimaux. Le problème est que les valeurs des bits ne correspondent pas du tout aux nombres décimaux. Avec le BCD, cela fonctionne très bien, mais personne ne l'utilise jamais (peut-être que BigDecimal l'utilise ??? J'en doute cependant).

Quoi qu'il en soit, la seule astuce en base 10 que vous pouvez utiliser est la multiplication par des facteurs de 10, mais elle n'est jamais utile à moins que vous ne codiez en assembleur sur une unité centrale des années 1970 ; mais juste parce qu'elle pollue mes banques de mémoire, je la publie pour votre amusement :

int mult10(int val) {
    int tmp_2val = val << 1; // double val
    int tmp_8val = val << 3; // 8x val
    return( tmp_2val + tmp_8val ); // 2x + 8x = 10x
}

Mais le coprocesseur mathématique peut le faire beaucoup plus rapidement, il suffit de ne JAMAIS OPTIMISER ! Le fait que vous preniez en compte la vitesse d'exécution est un problème, et votre "optimisation" est généralement plus susceptible de ralentir le système que de l'accélérer.

Je crois que vous pouvez utiliser une méthode similaire pour diviser par 10, mais je ne vais pas essayer de comprendre - il est tard - Si je me souviens bien, cela a quelque chose à voir avec l'examen des bits décalés et l'ajout de valeurs en fonction de leur valeur.

Answer 4

Si vous travaillez sur l'octal, vous pouvez simplement :

x &= ~0777;

Si vous travaillez sur l'hexagone, vous pouvez simplement :

x &= ~0xfff;

Mais pour les décimales, vous devriez probablement procéder comme le suggère Jesse Beder :

x -= (x % 1000);

La plupart des systèmes disposent d'une division rapide des entiers ; si vous travaillez sur un système qui n'en dispose pas, vous pouvez utiliser la fonction double tentative algorithme de conversion rapide en bcd. Consultez la section consacrée à la division par dix.

En fonction de ce que vous essayez de faire, il peut être plus facile de tronquer le nombre lors de sa conversion en format imprimable (chaîne de caractères), comme l'a suggéré Avitus.

Answer 5

int takeAway(int num)
{
    for (int i = 1; i =< 3; i++)
    {
        num = num/10;
    }

    return num;
}

int addZeroes(int num)
{
    for (int i = 1; i =< 3; i++)
    {
        num = num*10;
    }

    return num;
}

Il suffit ensuite d'appeler takeAway puis addZeroes. Rien de plus simple !

J'ai été tenté d'ajouter un int temp = num et l'utiliser, mais j'ai pensé que ce serait trop, même pour ce code.