Duck Number In C++

In this guide, we will explore the concept of Duck Number in C++ along with various approaches such as time complexity and space complexity analysis.

Duck Number

A Duck Number is a unique type of positive integer that contains at least one zero in its decimal form, with the condition that the zero cannot appear at the beginning of the number. Hence, integers like 3210, 8050896, and 70709, which have zeros in non-initial positions, are classified as Duck Numbers. Conversely, numbers like 035 or 0012, which have only leading zeros, are not categorized as Duck Numbers because these zeros do not contribute significantly to their value when represented in standard numeric form. An intriguing example is 01203, which starts with a zero but also has another zero in a non-leading position, thus meeting the criteria to be considered a Duck Number.

Duck Numbers stand out from other numeric categories due to their unique characteristic of having non-leading zeros. These numbers are commonly utilized in coding challenges to identify numerical patterns and are also relevant in the field of number theory.

Method-String manipulation

Strings provide direct character-by-character inspection, negating the need for intricate mathematical computations, making this method effective and simple to use. This method is a reliable way to confirm Duck Numbers since it makes zero identification easier and ensures that leading zeros are handled accurately.

• ✅ Take Input as an Integer: Receiving an integer 'number', which stands for the number that has to be verified, is the first step in taking input as an integer. It ensures that the input is converted after being processed in a numerical format.
• ✅ Convert Integer to String: Utilize C++'s to string function to convert an integer to a string. This conversion is more convenient than doing repeated arithmetic operations since it makes it simple to examine each digit of the number one after the other.
• ✅ Initialize Necessary variables : Determine the length of the string s and add a boolean variable called containsZero, which should be set to false at first. This will initialize the necessary variables. The purpose of this variable is to track the presence of any non-leading zeroes in the integer.
• ✅ Iterate Through the Digits (Ignoring the First One): The second character (index 1), which stands for the first non-leading numeral, is where you start your loop through the characters in the string s. In this step, the initial character (index 0) is disregarded because a leading zero has no role in defining a Duck Number.
• ✅ Verify the Presence of Zero: If any digit is discovered to be "0" throughout the iteration, set containsZero to true and exit the loop since no more checks are required.
• ✅ Make Sure the First Digit Is Not Zero: After the loop has ended, make sure that the first letter of s is not '0'. By doing this, the number is prevented from beginning with an extra leading zero, which would make it ineligible to be a Duck Number.
• ✅ Final Validation and Return Result: If both conditions-(i) at least one non-leading zero exists (containsZero == true) and (ii) the number does not start with zero (numberStr[0] != '0')-are satisfied, return true, indicating that the number is a Duck Number. Otherwise, return false, meaning the number does not meet the criteria.

Example:

Let's consider an example to demonstrate the concept of a Duck Number in C++.

#include <iostream>
#include <string>
using namespace std;
// Function to check if a given number is a Duck Number
bool checkDuckNumber(int number) 
{
    // Convert the integer number to a string for easy manipulation
    string numberStr = to_string(number);
    // Get the length of the string representation of the number
    int length = numberStr.length();
    // Boolean flag to track if a non-leading zero exists
    bool containsZero = false;
    // Iterate through the number string starting from the second character
    for (int i = 1; i < length; i++) 
    {
        if (numberStr[i] == '0')
        {
            containsZero = true;
            break; // No need to check further, as we found a non-leading zero
        }
    }
    // The number is a Duck Number if it contains a non-leading zero and does not start with '0'
    return (containsZero && numberStr[0] != '0');
}
int main() 
{
    int userInput;
    // Prompt the user to enter a number
    cout << "Enter a number to check if it is a Duck Number: ";
    cin >> userInput;
    // Check and display the result
    if (checkDuckNumber(userInput))
    {
        cout << userInput << " is a Duck Number." << endl;
    } 
    else
    {
        cout << userInput << " is not a Duck Number." << endl;
    }
    return 0;
}

Output:

Enter a number to check if it is a Duck Number: 1023
1023 is a Duck Number.

Complexity Analysis:

• ✅ Time Complexity: O(n)
• ✅ Auxiliary Space: O(n)

Explanation:

The software changes the numerical input into a text format and loops through each digit to identify the existence of a zero that is not in the leading position, which helps ascertain if a specific number qualifies as a Duck Number. The checkDuckNumber function ensures that the number doesn't commence with '0' and confirms that there is at least one zero following the initial numeral. Users are prompted to input a number, and the application displays whether the entered number is classified as a Duck Number according to the function's outcome.