Count occurences of each digit in integer interval (or int array) - c++

Question

using loops, how to find occurences of each digit in integer interval [n, m]?
for example:
INPUT n,m = [19, 23] = 19, 20, 21, 22, 23
OUTPUT should be:
0 occurences: 1 times
1 occurences: 2 times
2 occurences: 5 times
3 occurences: 1 times etc.
#include <iostream>
using namespace std;
int main()
{
int i, j, z, count, n, m;
cin >>n >>m;
for(int i=0; i<10; i++) // LOOP FOR DIGITS
{
cout << i <<"occurences: ";
count=0;
for(int j=n; j<m; j++) // LOOP INTEGER INTERVAL
{
while (z!=0)
{
z = j % 10; // LAST DIGIT OF FIRST NUMBER IN INTERVAL
if (z == i) count++;
z /= 10;
}
}
cout << count <<" times"<< endl;
}
}
my code returns 0 times for each digit, where is the error?

Answer 1

You don't need to loop over the range 10 times.
int n, m;
cin >> n >> m;
counts = int[10];
for(int i = 0; i < 10; ++i) {
counts[i] = 0;
}
for(int j = n; j <= m; j++) {
int z = j;
do {
int digit = z % 10; // LAST DIGIT OF FIRST NUMBER IN INTERVAL
counts[digit]++;
z /= 10;
} while (z != 0);
}
for(int i = 0; i < 10; ++i) {
cout << i << " occurrences " << counts[i] << " times";
}

Answer 2

You can use std::stringstream to get each digit in a number like so:
constexpr int n = 19;
constexpr int m = 23;
std::array<int, 10> digit_count = {0};
for (int i = n; i <= m; i++)
{
std::stringstream s;
s << i;
unsigned char digit;
while (s >> digit) digit_count[digit - '0']++;
}

Answer 3

Some issues that I see:
z = j % 10;
You need to intialize z outside your while loop to j Also you want to get the mod but not set z to it. try putting the result into a temp variable as opposed to into z.
Your for loop is not inclusive of the last number. for(int j=n; j<m; j++) should be j<=m.
z = j;
while (z!=0)
{
int mod = z % 10; // LAST DIGIT OF FIRST NUMBER IN INTERVAL
if (mod == i) count++;
z /= 10;
}
}
This final code gives the correct result:
#include <iostream>
using namespace std;
int main()
{
int i, j, z, count, n, m;
cin >>n >>m;
for(int i=0; i<10; i++) // LOOP FOR DIGITS
{
cout << i <<" occurences: ";
count=0;
for(int j=n; j<=m; j++) // LOOP INTEGER INTERVAL
{
z = j;
while (z!=0)
{
int mod = z % 10; // LAST DIGIT OF FIRST NUMBER IN INTERVAL
if (mod == i) count++;
z /= 10;
}
}
cout << count <<" times"<< endl;
}
}
19 23
0 occurences: 1 times
1 occurences: 2 times
2 occurences: 5 times
3 occurences: 1 times
4 occurences: 0 times
5 occurences: 0 times
6 occurences: 0 times
7 occurences: 0 times
8 occurences: 0 times
9 occurences: 1 times

Answer 4

Basically, the modulo operation is used to retrieve the least significant digit of any number. Dividing this number with the radix will remove the least significant digit, making the next digit the new least significant digit.
int main(int argc, char *argv[])
{
int radix = 10;
int x, y;
printf("Lower bound: ");
scanf("%d, &x);
printf("Upper bound: ");
scanf("%d, &y);
int digits[radix];
count_digit_occurence(x, y, radix, digits);
int i;
for (i = 0; i < radix; ++i)
{
int occ = digits[i];
printf("%d occurred %d times\n", i, occ);
}
}
void count_digit_occurence(int x, int y, int radix, int digits[radix])
{
int i, n;
for (i = x; i <= y; ++i)
{
n = i;
while (n > 0)
{
++(digits[n % radix]);
n /= radix;
}
}
}

Answer 5

All the answers so far provide algorithms with complexity O(m-n) at best, i.e. linear in the distance from n to m. Here, I provide a method that has logarithmic complexity. The basic idea is to consider the last digit of each number first, then the second last etc.
In order to simplify the code, I change the problem slightly and consider the range [n, m-1], i.e. excluding m.
There are m-n numbers in this range; if this is is a multiple of 10, then each last digit occurs exactly (m-n)/10 times. Otherwise, we must account for the edges. The following routine adds to count unit times the number of occurrences of the last digits in all numbers in the range from n to m-1 inclusive.
void count_last_digits(int n, int m, std::array<int,10> count&, int unit=1)
{
// 1 increment n until it has the same last digit as m
for(int dn=n%10, dm=m%10; n<m && dn!=dm; dn=++n%10)
count[dn] += unit;
// 2 add unit*(m-n)/10 to all counts
if(int cnt = unit*(m-n)/10) // avoid to add nothing
for(int d=0; d!=10; ++d)
count[d] += cnt;
}
Once, we counted the last digits, we count the second last digits etc. First, we need a helper function that just counts the digits of a single number
void count_digits(int x, std::array<int,10> &count, int unit=1)
{
for(; x; x/=10)
count[x%10] += unit;
}
To proceed with the second last digits, we first trim (using this helper function) the interval such that both n and m are multiples of 10, then divide them both by 10, multiply the unit of counting by 10, and recurse
std::array<int,10> count_all_digits(int n, int m)
{
std::array<int,10> count={0};
for(int unit=1; n<m; n/=10,m/=10,unit*=10) {
// count last digits
count_last_digits(n, m, count, unit);
// increment n to the next multiple of 10, but not above m
if(int inc = std::min(10-(n%10), m-n)) {
count_digits(n/10, count, unit*inc);
n += inc;
}
// decrement m to the previous multiple of 10, but not below n
if(int dec = std::min(m%10, m-n)) {
count_digits(m/10, count, unit*dec);
m -= dec; // not really necessary
}
}
return count;
}
The functions count_last_digits() and count_digits() have complexity O(1) and O(ln(x)), respectively. Both are called O(ln(m)) times, so the latter dominates the overall complexity, which is O(ln(m)^2).
Note that these functions assume 0 < n <= m, i.e. n<=0 is not allowed.