Count zeroes with Recursion keep crashing - c

Question

My code is supposed to count the number of zeroes using recursion.
However my program keeps crashing.
Expected output:
Input: 10500
Result: 3
Code:
void rCountZeros2(int num, int *result) {
if (num > 0) {
if ((num % 10) == 0) {
rCountZeros2((num / 10) + 1, *result);
}
rCountZeros2(num / 10, *result);
} else if (num == 0) {
*result = 1;
}
*result = num;
}
How do I make it work?

Answer 1

Here's the solution with and without using pointers
Hope this helps
#include <stdio.h> // For C++ #include<iostream>
// Without using pointer
int count_zeros_recursive2(int num) {
if (num % 10 == 0) {
if (num > 19 || num < -19) {
return 1 + count_zeros_recursive2(num / 10);
}
return 1;
}
if (num > 19 || num < -19) {
return count_zeros_recursive2(num / 10);
}
return 0;
}
// Using pointer
void count_zeros_recursive(int num, int *result) {
if (num % 10 == 0)
*result = *result + 1;
if (num > 19 || num < -19)
count_zeros_recursive(num / 10, result);
}
int count_zeros(int num) {
int result = 0;
count_zeros_recursive(num, &result);
//result = count_zeros_recursive2(num);
return result;
}
int main() {
int n;
while (1) {
scanf("%d", &n); // For C++ std::cin >> n;
printf("%d\n", count_zeros(n));// For C++ std::cout << n << "\n";
}
return 0;
}
eg Input: 1010
Output: 2
Input: 0
Output: 1
Input: 10204012410
Output: 4
Input: -101
Output: 1

Answer 2

I prefer returning the result instead of passing the pointer to the result.
Stop condition is when the number is a single digit, then if 0 you have 1 zero, otherwise none.
If the number is not a single digit, calculate the number of zeros in the number without the lowest digit (num/10) and add 1 to the returned value if the lowest digit was 0.
#include <stdio.h>
int count_zeros_recursive(int num)
{
int res = 0;
int num_without_lowest_digit = num/10;
if(num_without_lowest_digit == 0)
{
res = (num == 0);
}
else
{
res = count_zeros_recursive(num_without_lowest_digit);
if (num % 10 == 0)
{
res++;
}
}
return res;
}
int main(void) {
int nums[] = { 202, 7, 100, 10500, 10234, 10000};
int i;
for (i=0; i < sizeof(nums)/sizeof(nums[0]); ++i)
{
printf("Number %d has %d zeros\n", nums[i], count_zeros_recursive(nums[i]));
}
return 0;
}
Tested here
Number 202 has 1 zeros
Number 7 has 0 zeros
Number 100 has 2 zeros
Number 10500 has 3 zeros
Number 10234 has 1 zeros
Number 10000 has 4 zeros

Answer 3

Let's say you really want to use a pointer for some reason. Here's a full solution:
#include <stdio.h>
void rCountZeros2(int num, int *result)
{
if(num>0)
{
if( (num % 10) == 0)
{
*result = *result + 1;
}
rCountZeros2(num/10, result);
}
}
int main() {
int i = 0;
int n;
n = scanf("%d", &n);
int *result = &i;
rCountZeros2(n, result);
printf("%d\n", *result);
}
So what will happen is that you're effectively just updating the value at the location which result is pointing to, which means that you're really just storing the count in the variable i.

Answer 4

There is no need to pass a pointer if you can use a functional approach. Just return the value.
long recursiveZeroesCount(long num) {
if(num == 0) return 1;
if(num < 10) return 0;
if(num % 10 == 0) return 1 + recursiveZeroesCount(num / 10);
else return recursiveZeroesCount(num / 10);
}

Answer 5

Your program has undefined behavior because you pass the value of the *result instead of the pointer to the result variable to recursive calls. Furthermore, your algorithm is flawed as you cannot use this API recursively because the recursive calls update the result as well as the current call, a very impractical situation.
Here is a corrected version without recursion:
void rCountZeros2(int num, int *result) {
int count = 0;
for (;;) {
if (num % 10 == 0)
count++;
num /= 10;
if (num == 0)
break;
}
*result = count;
}
And here is a recursive implementation with a simpler API:
int rCountZeros2(int num) {
if (num % 10 == 0) {
if (num == 0)
return 1;
else
return 1 + rCountZeros2(num / 10);
} else {
if (num < 10)
return 0;
else
return rCountZeros2(num / 10);
}
}
The above function can be simplified as a single statement:
int rCountZeros2(int num) {
return !(num % 10) + ((num < 10) ? 0 : rCountZeros2(num / 10));
}