CareerCup

int countDigits(int num) {

int rem = num;
int count = 0;

while(rem > 0){

rem = rem / 10 ;
count ++;
}

return count ;

}


void digitsCountFrom(int from, int to)
{
int *digitsCount = (int *) malloc( to *sizeof(int)) ;
int i,k ;

for(i=from, k=0 ; i<=to; i++, k++)
{
digitsCount[k] = countDigits(i);
printf("digitsCount[%d] : %d\n",i,digitsCount[k] );
}

free(digitsCount);
digitsCount = NULL ;
}


int main(int argc, const char * argv[])
{
digitsCountFrom(1,100) ;

return 0;
}

I guess i was not clear. Counting digit means total number of occurrences of digits 0,,1,2,3,4,5..9 in that range.

This works for 2 digit. Not sure how to make it dynamic for all.

public static void countNumberJumbel(int from, int to){
		if(from > to){
			System.out.println("From value cannot be more than To Value");
		}else{
			for(int i=from; i<to; i++){
				int unit = i%10;
				int tens = i/10;
				numberOfDigit[unit]++;
				numberOfDigit[tens]++;
			}
			
			for(int itr=0; itr< numberOfDigit.length; itr++){
				System.out.println("numberOfDigit["+itr+"] = "+numberOfDigit[itr]);
			}
		}
	}

a very naive implementation goes like to iterate from 0 to N.
Parse each digit and add digits to digit array.

#include <iostream>
#include "stdlib.h"
using namespace std;

void updateDigits (int *digits, int num)
{
	if (num == 0)
	{
		digits[0] += 1;
		return;
	}
	int k = 0;
	while (num > 0)
	{
		k = num%10;
		digits[k] += 1;
		num = num/10;
	}
}

void countDigits (int num)
{
	int j = 0;
	int digits[10] = {0};
	for (j = 0; j <= num; j++)
	{
		updateDigits (digits, j);
	}
	for (j = 0; j <= 9; j++)
	{
		cout << "digits[" << j <<"]" << digits[j] << endl;
	}
}
int main(int argc, char* argv[]) {
	countDigits (299);
	return 0;
}

Output:
digits[0]50
digits[1]160
digits[2]160
digits[3]60
digits[4]60
digits[5]60
digits[6]60
digits[7]60
digits[8]60
digits[9]60

geekyjumps.blogspot.in/2014/01/given-number-n-now-find-number-of.html

The solution is simpler than iterating from 0 to n and counting the digits:
This solution is O(log n) instead of O(n).

void countDigits(int n)
{
	int digits[10], j, multiplier = 1, m=n;
	for (j=0; j< 10; j++)
		digits[j] = 0;

	if (n == 0) // Edge case: n is 0
		digits[0] = 1;

	while (n>0)
	{
		int current = n % 10;
		for (j=0;j<10;j++)
			digits[j] += (n /10) * multiplier + (j < current)*multiplier;
		digits[current] += (m % multiplier)+1;
		if (multiplier > 1)
			digits[0] -= multiplier;
		n /= 10;
		multiplier *= 10;
	}

	for (j=0; j<10; j++)
		printf("digits[%d]=%d\n",j,digits[j]);
}

How will we modify this code if we want to get the number of digits within a range?
Here the range is assumed to be 0-n.

void getcount(int n)
{
     int digits[10];
     int i,pow;
     for(i=0;i<10;i++)
        digits[i]=0;
     digits[0]=1;
     for(i=1;i<=n;i++)
     {
        pow=i;
        while(i>0)
        {
            digits[i%10] += 1;
            i=i/10;
        }
        i=pow;
     }
     for(i=0;i<10;i++)
        printf("count %d is %d\n",i,digits[i]);

}

import java.util.HashMap;
import java.util.Map;

public class CountDigits {

public static void main(String args[]) {
countDigits(1, 200);

}

private static void countDigits(int i, int j) {
HashMap<String, Integer> numCnt = new HashMap<>();
//map<digit,count>
for (int n = i; n <= j; n++) {
String num = String.valueOf(n);
for (int k = 0; k < num.length(); k++) {
if (numCnt.containsKey(String.valueOf(num.charAt(k)))){
numCnt.put(String.valueOf(num.charAt(k)), numCnt.get(String.valueOf(num.charAt(k))) + 1);
} else {
numCnt.put(String.valueOf(num.charAt(k)), 1);
}
}
}
for (Map.Entry<String, Integer> ele : numCnt.entrySet()) {
System.out.println("Number" + ele.getKey() + ",Count:"
+ ele.getValue());
}
}

}