Self-Descriptive Numbers in Java

A number n is given. Our task is to find out the self-descriptive numbers that are present between 1 to n.

Self-Descriptive Numbers

A self-descriptive number m, is a number that contains b digits in the base b, where the most significant digit is positioned at 0 and the least significant digit positioned at b - 1 (left to right and zero indexing (similar to an array)). Also, every digit d is positioned at n, counting how many times the digit n is there in m. Observe the following examples.

Example 1:

m = 2020

Output: 2020 is a self-descriptive number.

Explanation: Since the number 2020 contains only 4 digits, therefore, base 4 is considered. In the number 2 is positioned at the 0th position, which means 0 occurs two times. 0 is positioned at 1st position, which means 1 is occurring zero times. Again, 2 is positioned at 2nd position, meaning 2 is occurring two times. After that, 0 is placed at the 3rd position, which means 3 occurs zero times. If we see the number, we find that

0 is occurring two times. 2 is occurring two times. Also, 1 and 3 occur zero times. Thus, all the statements written in the above paragraph are correct. Hence, 2020 is a self-descriptive number.

Example 2:

m = 6210001000

Output: 6210001000 is a self-descriptive number.

Explanation: Since the number 2020 contains only 10 digits, therefore, base 10 is considered. In the number 6 is positioned at 0th position, which means 0 occurs six times. 2 is positioned at 1st position, which means 1 is occurring two times. Again, 1 is positioned at 2nd position, meaning 2 is occurring one time. After that 0 is placed at the 3rd position, 4th position, 5th position, 7th position, 8th position, and 9th position, which means numbers 3, 4, 5, 7, 8, and 9 occur zero times. At 6th position, we see the number 1, which means 6 occurs one time. If we see the number, we find that

6 is occurring one time. 2 is occurring one time. 1 is occurring two times. 2 occurs one time, and 0 occurs six times. Also, 3, 4, 5, 7, 8, and 9 occur zero times. Thus, all the statements written in the above paragraph are correct. Hence, 6210001000 is a self-descriptive number.

Implementation: Using Nested Loop

Observe the following program for finding the self-descriptive number.

FileName: SelfDescriptive.java

// Printing self-descriptive number
// lying between 1 to 100000
public class SelfDescriptive 
{

public boolean isSelfDescNum(int n)
{
// changing the integer n to the string str
String str = Integer.toString(n);
for (int k = 0; k < str.length(); k++) 
{

// From the string, one by one, extract each digit
String tempChar = str.charAt(k) + "";

// changing the string (temChar) into an integer
// the variable v keeps the digit located at the index 'k'
int v = Integer.parseInt(tempChar);

// computing the number of times a specific-digit
// is occurring in the number n
int cnt = 0;
for (int p = 0; p < str.length(); p++) 
{
// converting string char to integer
int tmp = Integer.parseInt(str.charAt(p) + "");

// check whether it is the same as the index 'k' or not
// if yes, then increase the count cnt.
if (tmp == k) 
{
cnt = cnt + 1;
}
}

// If it is not the same
// then returning a false value.
if (cnt != v)
{
return false;
}
}
return true;
}
// main method
public static void main(String argvs[])
{
int n = 100000;

// creating an object of the class SelfDescriptive
SelfDescriptive obj = new SelfDescriptive();

System.out.println("In the range 1 to " + n + ", we have the following self-descriptive numbers.");

for (int j = 1; j < n; j++)
{
if (obj.isSelfDescNum(j))
{
System.out.println(j);
}
}
}
}

Output:

In the range 1 to 100000, we have the following self-descriptive numbers.
1210
2020
21200

Explanation: In the outer loop, all of the digits are getting extracted and kept in the variable v in every iteration. Then inside the inner loop, a variable cnt is there to computing the number of times the number j (this j is the j^th index of the outer loop) is occurring in the string. Eventually, the variable cnt is compared with the variable v. If the comparison does not match, a false value is returned.

Complexity Analysis: The time complexity of the program is O(n * len(n) * len(n)). The space complexity of the program is O(1).

If we do some preprocessing to store the frequency of the digits in an array, then we can reduce the complexity of the program. The illustration of the same is given in the following program.

FileName: SelfDescriptive1.java

// Printing self-descriptive number
// lying between 1 to 100000
public class SelfDescriptive1 
{
public boolean isSelfDescNum(int n)
{
String st = String.valueOf(n);
    int j;
    // auxiliary array for storing the 
    // frequency count
    int freqCount[] = new int[10];
    for (j = 0; j < 10; j++)
    {
      freqCount[j] = 0;
    }
    while (n > 0) 
    {
      freqCount[n % 10] = freqCount[n % 10] + 1;
      n = n / 10;
    }
    for (j = 0; j < st.length(); j++)
    {
        // if the frequency count at the index j
        // does not match with the value at the 
        // index j present in the string st, then
        // the given number n is not the self-descriptive 
        // number.
      if (freqCount[j] != (st.charAt(j) - '0'))
      {
        return false;
      }
    }
    return true;
}
// main method
public static void main(String argvs[])
{
int n = 100000;
// creating an object of the class SelfDescriptive1
SelfDescriptive1 obj = new SelfDescriptive1();
System.out.println("In the range 1 to " + n + ", we have the following self-descriptive numbers.");
for (int j = 1; j < n; j++)
{
if (obj.isSelfDescNum(j))
{
System.out.println(j);
}
}
}
}

Output:

In the range 1 to 100000, we have the following self-descriptive numbers.
1210
2020
21200

Complexity Analysis: The time complexity of the program is O(n * len(n)). The space complexity of the program is O(1). One may argue that we are using an auxiliary array. However, the auxiliary array is of the size 10 and is not varying in any scenario. Thus, we can say that the auxiliary array is of a fixed size making the space complexity O(1).

Next TopicHybrid Inheritance in Java

← prev next →