How can I add together the numbers in a file? - c

Question

I have a large text file. In this file there are some numbers I want to add together.
What I've tried:
int sum = 0, i = 0;
file = fopen(filename, "r");
while ((i = fgetc(file)) != EOF) {
if (isdigit(i)) {
sum++;
}
}
printf("Sum of numbers is: %i", sum);
fclose(file);
But that isdigit(i) is just a counter of how many digits this file contains, not what the sum of the numbers is.
The input is: "This text 15 is very 19 nice."
The result should be: Sum of numbers is: 34

Answer 1

Consider the decimal placement
The missing part in the question's code is accumulating the digits (as opposed to counting the digits with sum++;) AND multiplying by ten the previous accumulated number before adding the next digit.
The answer is in:
number = number * 10 + i - '0';
The - '0' part is converting ASCII digit to a number.
Everything else in the below code is checks to make sure there are no obvious overflows and correctly supporting minus sign also adjacent to the numbers, as well as ignoring digits after the decimal point(s). I'm sure it is not perfect, but the idea here is to provide a working example of how it could be done, rather than a well tested code and using a library call to do it for you.
By popular demand (comments were deleted now) I've added a simple-but-working overflow check:
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <error.h>
#include <limits.h>
int main(int argc, char* argv[]) {
int sum = 0, state = 0, i = 0, dir = 1;
unsigned int number = 0, check;
if (argc < 2) {
fprintf(stderr, "Missing filename\n");
return EXIT_FAILURE;
}
char* filename = argv[1];
FILE* file = fopen(filename, "r");
if (!file) {
perror(filename);
return EXIT_FAILURE;
}
while (i != EOF) {
i = fgetc(file);
if (isdigit(i)) {
if (dir) {
state = 1;
check = number;
number = number * 10 + i - '0';
if (check > number || number > INT_MAX) {
fprintf(stderr, "Single number overflow error\n");
fclose(file);
return EXIT_FAILURE;
}
}
} else {
if (state && dir) {
check = number;
if (dir < 0 && sum < 0)
check -= sum;
else if (dir > 0 && sum > 0)
check += sum;
if (check > INT_MAX) {
fprintf(stderr, "Sum overflow error\n");
fclose(file);
return EXIT_FAILURE;
}
sum += number * dir;
number = 0;
}
state = 0;
dir = i == '-' ? -1 : i == '.' ? 0 : 1;
}
}
printf("Sum of numbers is: %i\n", sum);
fclose(file);
return EXIT_SUCCESS;
}
Test run:
$ cat opString.txt
This text 15 is very 19 nice.
$ ./test2 opString.txt
Sum of numbers is: 34
$
And just in case you are on 64bit linux system, and need much higher performance (you mentioned large file) the below code will map the entire file (even file larger than memory, the kernel will handle it nicely) and will not make a library call on every char. In my tests, isdigit() and strtol() slows it down significantly.
#include <stdlib.h>
#include <stdio.h>
#include <error.h>
#include <limits.h>
#include <sys/mman.h>
int addToSum(unsigned int* number, int* sum, int dir, FILE* file) {
unsigned int check;
check = *number;
if (dir < 0 && *sum < 0)
check -= *sum;
else if (dir > 0 && *sum > 0)
check += *sum;
if (check > INT_MAX) {
fprintf(stderr, "Sum overflow error\n");
fclose(file);
exit(EXIT_FAILURE);
}
*sum += *number * dir;
*number = 0;
}
int main(int argc, char* argv[]) {
int sum = 0, state = 0, i = 0, dir = 1;
unsigned int number = 0, check;
if (argc < 2) {
fprintf(stderr, "Missing filename\n");
return EXIT_FAILURE;
}
char* filename = argv[1];
FILE* file = fopen(filename, "r");
if (!file) {
perror(filename);
return EXIT_FAILURE;
}
if (fseek(file, 0L, SEEK_END) < 0) {
perror("fseek failed");
fclose(file);
return EXIT_FAILURE;
}
long fsize = ftell(file);
char* fmap = mmap(NULL, fsize, PROT_READ, MAP_SHARED, fileno(file), 0);
if (fmap == MAP_FAILED) {
perror("map failed");
fclose(file);
return EXIT_FAILURE;
}
long pos = 0;
while (pos < fsize) {
i = fmap[pos++];
if (i >= '0' && i <= '9') {
if (dir) {
state = 1;
check = number;
number = number * 10 + i - '0';
if (check > number || number > INT_MAX) {
fprintf(stderr, "Single number overflow error\n");
fclose(file);
return EXIT_FAILURE;
}
}
} else {
if (state && dir) addToSum(&number, &sum, dir, file);
state = 0;
dir = i == '-' ? -1 : i == '.' ? 0 : 1;
}
}
if (state && dir) addToSum(&number, &sum, dir, file);
printf("Sum of numbers is: %i\n", sum);
fclose(file);
return EXIT_SUCCESS;
}

Answer 2

Input file name: file.txt
This text 15 is very 19 nice.
Output:
Sum of numbers is: 34
Code:
#include <stdio.h>
#include <ctype.h>
int main()
{
int sum = 0, num, i = 0;
int state = 0;
FILE* f;
if ((f = fopen("file.txt", "r")) == NULL)
return -1;
while ((i = fgetc(f)) != EOF) {
switch(state) {
case 0: // processing text
if (isdigit(i)) {
num = i - '0';
state = 1;
}
break;
case 1: // processing number
if (isdigit(i)) {
num *= 10;
num += i - '0';
}
else {
sum += num;
num = 0;
state = 0;
}
break;
}
}
if (state == 1) {
sum += num;
}
printf("Sum of numbers is: %i\n", sum);
fclose(f);
return 0;
}

Answer 3

But that isdigit(i) is just a counter of how many digits this text contents but not whats the sum of the numbers is.
Keep in mind, the function isdigit() reads one character per call. So if it reads the character 9 for example, the value sum should grow by i - '0' (or 57 - 48, or 9). And if there were two characters in sequence, such as 92, reading one character at a time, the value sum would likewise be incremented by 9+2 -> 11, not 92. Given this is what you want, here is how to do it:
The values you have determined are digits are actually ASCII values, so in viewing this table you can see all of the digits will have values from '0' to '9' (or in ASCII, 48 to 57). So in your code you can simply change one line to sum up the value count:
int sum = 0;
file = fopen(filename, "r");
while ((i = fgetc(file)) != EOF) {
if (isdigit(i))
sum += (i - '0');//subtract 48 from every 'i' verified as digit
//Sum will therefore add up values
//between (48-48) to (57-48)
//(or between 0 to 9)
}
printf(f,"Sum of numbers is: %i", sum);
fclose(file);
However, If you want to sum up numeric values represented by a sequence of digits within a buffer, then the code is different. It would require keeping a flag as the buffer content is read.
In pseudo code:
char accumlator[10] = {0}; max possible sequential digits (change as needed)
int found = 0;//flag
int sum = 0;
while ((i = fgetc(file)) != EOF)
{
if (isdigit(i))
{
accumulator[found] = i;
found++;
}
else
{
if(found != 0)
{
sum += atoi(accumulator);
found = 0;
accumulator[0] = 0;
}
}
}
}

Answer 4

The function fgetc only reads a single character that is a potential digit. It does not read a whole number that consist of several digits at once. If you want to read whole numbers, you must change the logic of your program. You can do one of the following:
Use fgetc as you do now and make your program assemble the individual digits into a number, by using the ASCII Code of the digits and converting that to a number using arithmetic. The numerical value of an individual ASCII character digit can be obtained using the expression ascii_code - '0'.
Use fgets instead to read a whole line at once and then use strtol to convert any digits you find into numbers.
Use fscanf() to parse the file and extract the number in one step (not recommended unless you know exactly what you are doing).

Answer 5

Your program only counts the number of digits in the file. Here is a simple solution using getc() to compute the number of all integral numbers in the file without the need for a state machine:
#include <stdio.h>
int count_numbers(const char *filename) {
FILE *fp;
unsigned long long total = 0, current = 0;
int c;
if ((fp = fopen(filename, "r")) == NULL) {
printf("Cannot open input file %s\n", filename);
return -1;
}
while ((c = getc(fp)) != EOF) {
if (c >= '0' && c <= '9') {
current = current * 10 + (c - '0');
} else {
total += current;
current = 0;
}
}
total += current; /* add the last number if at the very end of the file */
printf("Sum of numbers is: %llu\n", total);
fclose(fp);
return 0;
}
Notes:
this program does not handle negative numbers, it ignores negative signs.
it does not handle floating point numbers: processing 1.1 will produce a sum of 2.
very long numbers will produce the result modulo ULLONG_MAX+1 but at least the behavior is defined.

Answer 6

If you want to add all the number strings up in this then you'll have to search for the digits and then convert them from a string to an integer using strtol. Here's how to do that:
#include <ctype.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#define OVERFLOW_STR "Number cannot be represented in an int!\n"
int main(int argc, char **argv)
{
FILE *file;
char n[12];
char *p = n;
int i = 0, sum = 0, tmp, old_errno;
if(argc != 2)
{
fprintf(stderr, "Usage: %s file\n", argv[0]);
return EXIT_FAILURE;
}
file = fopen(argv[1], "r");
if(!file)
{
perror("Error opening file");
return EXIT_FAILURE;
}
while(i != EOF)
{
while( (i = fgetc(file)) != EOF &&
i != '-' &&
i != '+' &&
!isdigit(i) )
{
/* empty loop */ ;
}
if(i != EOF)
{
do {
if( p == n + sizeof(n) - 1 ||
((*n != '-' || *n != '+') &&
p == n + sizeof(n) - 2) )
{
fprintf(stderr, "Error: " OVERFLOW_STR);
return EXIT_FAILURE;
}
*p++ = i;
} while( (i = fgetc(file)) != EOF && isdigit(i) );
}
else
break;
*p = 0;
old_errno = errno;
errno = 0;
tmp = strtol(n, NULL, 10);
if( tmp == 0 && errno != 0 )
{
perror("Error converting string");
break;
}
errno = old_errno;
sum += tmp;
p = n;
}
printf("Sum of numbers is: %d\n", sum);
fclose(file);
return 0;
}
This is largely error-checked. There may be corner cases that I have left out.
Input (contained in a file whose name is passed as a command-line parameter):
This text 15 is very 19 nice.
Output:
Sum of numbers is: 34