find sum of digits after decimal point

Question

I want to find the sum of all the digits entered by a user after the decimal point in c.

Eg. 12.36 must return 9
15.06 must return 6
9.0 must return 0

My approach

#include <stdio.h>
int main()
{
    double num,numfloat;
    int digitf,numint,sumf=0;
    scanf("%lf",&num);
    numint=num;
    numfloat=num-numint;
    while(numfloat!=0)
    {
        digitf=(numfloat*10);
        numfloat=numfloat*10-digitf;
        sumf=sumf+digitf;
    }
    printf("Sum float %d",sumf);
return 0;
}

The sum comes out a lot more than the expected.

Answer 1

Try, (The reason why in this example, I haven't joined the loops is that: I want this to be usable on other situations where they use an alternate method of validating input, see the SECOND EXAMPLE for both loops joined):

#include <stdio.h>
#include <string.h>
#include <ctype.h>

int main() {
        // read from stdin
        char num[512] = { };
        fgets(num, sizeof(num), stdin);

        num[strcspn(num, "\n")] = '\0';

        // verify if number is valid
        int decimal_point_found = 0;

        for (int i = 0; i < strlen(num); i++) {
                // check if digit
                if (!isdigit(num[i])) {
                        // be safe from multiple decimal points
                        if (num[i] == '.' && decimal_point_found == 0) {
                                decimal_point_found = 1;
                                continue;
                        }
                        printf("ERROR: enter a valid number\n");
                        return 1;
                }
        }

        int total = 0;
        // add all the decimal points
        for (int i = 0, decimal_point_found = 0; i < strlen(num); i++) {
                if (decimal_point_found == 1) {
                        total += num[i] - '0'; // - '0' converts char to int
                }
                if (num[i] == '.') {
                        decimal_point_found = 1;
                }
        }

        // show total
        printf("%d\n", total);

}

In the above, I have read char instead of reading float. I have read using fgets() which is safer than scanf().

Handling char makes it so much easier to calculate such things. As we know the number of digits, etc.

With both loops joined:

#include <stdio.h>
#include <string.h>
#include <ctype.h>

int main() {
        char num[512] = { };
        fgets(num, 512, stdin);

        num[strcspn(num, "\n")] = '\0';

        // verify if number is valid
        int decimal_point_found = 0;

        int total = 0;

        for (int i = 0; i < strlen(num); i++) {
                if (!isdigit(num[i])) {
                        if (num[i] == '.' && decimal_point_found == 0) {
                                decimal_point_found = 1;
                                continue;
                        }
                        printf("ERROR: enter a valid number\n");
                        break;
                }
                if (decimal_point_found == 1) {
                        total += num[i] - '0';
                }

        }

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

Answer 2

You mentioned in a comment that the input has to be a number.

This first point to mention is that when coding, we are not manipulating such abstract things as numbers, but imperfection representations of numbers. Think to the famous painting "This is not a pipe". Same here, "This is not a number".

float, double and char* are all or can be all representations of numbers. Depending on the context, one representation can be more suitable than others. Here, using a char* is the best solution, has no internal conversion error occurs.

Now, let us assume that the input format double is imposed by your professor. Why is your code not working? Mainly because internally, the representation of the numbers is generally imperfect. A small error can lead to a large error when converting a float to an integer.

For example, int i = 0.999999 will give i = 0.

The solution is to account for the internal error representation, by introducing a margin, e.g. eps = 1.0e-14, when performing the float-to-integer conversion, or when testing if a number is equal to 0.

A difficulty is that the internal error is multiplied by 10 when the number is multiplied by 10. So the value of epshas to be updated accordingly.

Moreover, we have to take into accout that the mantissa provides a relative accurracy only, not an absolute one.
Therefore, the eps value must be increased when the number is large.

0.123456789 --> 45
19.1 -> 1
12.45e-36  -> 12
12345.973 -> 19
0.83 -> 11

#include <stdio.h>
int main() {
    double num, numfloat;
    int digitf, numint, sumf = 0;
    double eps = 1.0e-14;        // to deal with representation inaccuracy of numbers
    if (scanf("%lf", &num) != 1) return 1;
    printf("number in memory: %.20g\n", num);
    if (num < 0.0) num = -num;
    numint = (int) (num + eps);
    numfloat = num - numint;
    int deal_with_low_number = numint == 0;
    while (numint) {        // the mantissa only proposes a relative accurracy ...
        eps *= 10;
        numint /= 10;
    }
    while (numfloat > eps || deal_with_low_number) {
        numfloat *= 10;
        digitf = (int) (numfloat + eps);
        numfloat -= digitf;
        sumf = sumf + digitf;
        if (digitf != 0) deal_with_low_number = 0;
        if (!deal_with_low_number) eps *= 10;
    }
    printf("Sum float %d\n", sumf);
    return 0;
}

Answer 3

Original code fails as unless the fraction if exactly an integer/power-of-2, the input number, as decimal text, does not convert exactly to the same double. Instead num is the closet double possible. Yet that closest double may have many more digits when manipulated.

Further OP's numfloat=numfloat*10-digitf; injects repeated rounding errors.

Instead code needs to compensate for that rounding in some fashion.

the input has to be a number

Hmm, better to read in as a string, yet we can code a tolerable solution if we know the length of input by using "%n" to record the length of user input.

width below is the number of non-white-space characters in input. If we assume things like 1) sign only when negative, 2) no exponential 3) not infinity nor NAN, 4) no more than 15 significant digits 5) no more than 15 fraction digits --> then width will almost always^*1 gives us what is needed to process num.

#include<stdio.h>
#include<math.h>

int sumFraction(void) {
  int sum = 0;
  double num;
  int start, end;
  if (scanf(" %n%lf%n", &start, &num, &end) != 1) {
    return -1;
  }
  if (num == 0) {
    return 0;
  }
  int width = end - start;
  if (num < 0) {
    num = -num;
    width--;
  }
  int p10 = (int) log10(num);
  width--;  // Decrement for the '.'
  if (width > 15) {
    printf("Too many leading digits\n");
    return -1;
  }
  width -= (p10 + 1);

  // Only care about fractional part
  double ipart;
  num = modf(num, &ipart);
  if (num == 0) {
    return 0;
  }

  // assert(width >= 0);
  num *= pow(10, width);
  long long ival  = llround(num);  // Form an integer

  while (width > 0) {
    width--;
    sum += ival % 10;
    ival /= 10;
  }
  return sum;
}

int main() {
  printf(" %d\n", sumFraction());
  printf(" %d\n", sumFraction());
  printf(" %d\n", sumFraction());
}

---

^*1 IMO, code is not robust as the given limitation of not reading in as a string is not real for the real world. So here is a non-real solution.