Comment obtenir les x premiers chiffres (les plus à gauche) d'un nombre décimal ?

Question

Supposons que j'ai n=1234 et je veux obtenir le premier x Les chiffres de n . Supposons que x=2 En mathématiques C, je calcule simplement 1234/100 et je vais obtenir 12 . Mais comment puis-je le faire de manière programmatique ? C'est-à-dire en utilisant les mathématiques. Je l'ai implémenté de la manière la plus horrible qui soit, en convertissant en chaîne de caractères et en mettant une balise 0 à l'adresse x position. Si possible, je veux éviter les fonctions C intégrées car mon objectif est de convertir l'algorithme en langage assembleur par la suite.

Answer 1

Sans utiliser de fonctions de la bibliothèque, la meilleure façon de le faire est la force brute. La valeur maximale d'un nombre entier est de 2147483648, nous ne traiterons donc pas les valeurs supérieures.

int first_two(int value)
{
    assert(value >= 0);  // unspecified for negative numbers
    if (value >= 1000000000)
        return value / 100000000;
    if (value >= 100000000)
        return value / 10000000;
    if (value >= 10000000)
        return value / 1000000;
    if (value >= 1000000)
        return value / 100000;
    if (value >= 100000)
        return value / 10000;
    if (value >= 10000)
        return value / 1000;
    if (value >= 1000)
        return value / 100;
    if (value >= 100)
        return value / 10;
    return value;
}

Answer 2

Vous pouvez le faire par programme en prenant le plancher du logarithme décimal de votre nombre (dans le cas de 1234, c'est floor(3.091315) soit 3), en ajoutant un, et en soustrayant n - le nombre de chiffres décimaux souhaité. Vous obtiendrez ainsi x tel que la division entière de la valeur originale par 10^x vous donne le résultat souhaité :

#include <math.h>
...
int num = 12345;
int n = 3;
int log10 = (log(num)/log(10))+1;
int divisor = pow(10, log10-n);
int res = num / divisor;
printf("%d\n", res);

Voici un démo sur l'idéone .

La conversion de ce qui précède en assemblage serait délicate en raison des fonctions mathématiques impliquées. Vous pouvez le simplifier en définissant un tableau de puissances de dix, en recherchant le premier élément supérieur ou égal au nombre souhaité (ce qui vous donne log10 ci-dessus), puis de saisir le log10-n -ème entrée, vous donnant pow(10, log10-n) :

int pow10[] = {1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000};

int main(void) {
    int num = 12345;
    int n = 3;
    int log10 = 0;
    while (pow10[log10] < num) {
        log10++;
    }
    int divisor = pow10[log10-n];
    int res = num / divisor;
    printf("log10(num)+1=%d, divisor=%d, result=%d\n", log10, divisor, res);
    return 0;
}

Voici la démo modifiée .

Answer 3

Vous pouvez utiliser l'algorithme suivant : divisez la valeur de la n par 10 jusqu'à ce que vous obteniez n < 10^x

ici après le code

int power10(int x) {
    int p = 1;
    while (x) {
        p *= 10;
        x--;
    }
    return p;
}

int main (void) {

    int x = 2;
    int n = 1234;
    int max = power10(x);

    int res = n;   
    while(res>=max)
        res = res/10;

   printf("%d\n",res);
}

Answer 4

int getLeftDigits(double num, double numOfDigits)
{
double divider = pow(10, numOfDigits);

if (num < divider)
    return num;

getLeftDigits(num/10, numOfDigits);
}

Si vous voulez éviter l'utilisation de la fonction pow, vous pouvez l'implémenter vous-même comme indiqué dans l'un des autres commentaires ici.