Tech Number In C++

Introduction

A Tech Number is a mathematically explored concept of a property that is generally addressed in programming to tackle a particular problem or challenge. The term itself is not a standard concept in mathematics or computer science, but it is everywhere used in competitive programming and coding exercises to refer to some numbers with a different numerical property. Tech Number is a concept around the idea of picking numbers that fit some conditions if their digits are considered and operations performed over them.

Tech Number is defined as a number that meets the following criteria:

✅ Even Number of Digits: The number of digits in the number should be an even count. It is necessary because we need to split the number in two halves equal and verify these properties.
✅ Splitting into Equal Halves: It is broken into two equal parts. A simple example is a four-digit number like 2025 is split into 20 and 25. If the number had six digits, it would be decomposed into three-digit parts, and so on.
✅ Sum of Halves: So once the number is split into two halves they are added together. In order for the next step, verification, this is the sum of these halves.
✅ Squared Sum Matches the Original Number: We calculate the square of the sum of two halves. A Tech Number is a number that, when squared, gives the same result as the original.

To give an example, let us assume 2025 is a number. It has four digits, which is an even count, allowing it to be split into two halves: 20 and 25. When we add these two halves, we get 20 + 25 = 45. When we square the sum, 45² = 2025, the original number is confirmed as a Tech Number.

Applications and Relevance:

✅ Understanding Mathematical Patterns: Searching and working with specific numerical properties helps programmers understand mathematics better and its practical applications.
✅ Digit Manipulation: Tech Numbers help to build expertise in handling individual digits of a number as well as string slicing, arithmetic operations, and type conversions that we often come across in programming challenges.
✅ Debugging and Testing: As a part of working with Tech Numbers, we get to handle edge cases, testing the robustness of the logic implemented, for example, dealing with input that doesn't fit certain criteria or has an odd number of digits.

Challenges in Implementation:

✅ Performance Optimization: The logic is simple but processing large number or many inputs is difficult in the environments where we compete in competitive programming. However, scaling the algorithm well with input size is an important consideration.
✅ Edge Cases: We need to support special cases like single-digit numbers, negative numbers, or numbers really big, etc. For scenarios like this, implementing can become complicated, and can have some additional checks required in our logic.

Approach-1: Basic Arithmetic Approach

The basic Arithmetic Approach, which is used to figure out a Tech Number, involves doing math on the number using / and % operators to break the number in half without changing it to a string . Instead, we start by figuring out how many digits we will need in the number and how many digits that number needs to have, and then we can split the number up by powers of 10.

It calculates the sum of the two halves, and compares it to the original number squared. If the number matches, the number becomes a Tech Number. For small inputs, it is an efficient method, avoiding string manipulation, and is suitable for arithmetic-focusing programming. However, it can tend to be complicated to handle large numbers or edge cases successfully.

Example:

Let us take an example to illustrate the Tech number using basic arithmetic approach in C++ .

Example


#include <iostream>
#include <cmath>
#include <vector>
using namespace std;
// Function to count the digits in a number
int countDigits(int num) {
    int count = 0;
    while (num > 0) {
        count++;
        num /= 10;
    }
    return count;
}
// Function to calculate the power of 10 (used for splitting the number)
int powerOf10(int exp) {
    int result = 1;
    for (int i = 0; i < exp; i++) {
        result *= 10;
    }
    return result;
}
// Function to validate user input
bool isValidInput(int num) {
    if (num < 0) {
        cout << "Negative numbers cannot be Tech Numbers.\n";
        return false;
    }
    if (countDigits(num) % 2 != 0) {
        cout << "Number must have an even number of digits.\n";
        return false;
    }
    return true;
}
// Function to check if a number is a Tech Number
bool isTechNumber(int num) {
    if (!isValidInput(num)) return false;
    int digits = countDigits(num);
    // Split the number into two halves
    int halfDigits = digits / 2;
    int divisor = powerOf10(halfDigits);
    int firstHalf = num / divisor;  // Extract the first half
    int secondHalf = num % divisor; // Extract the second half
    // Calculate the sum of the two halves
    int sum = firstHalf + secondHalf;
    // Check if the square of the sum equals the original number
    return (sum * sum == num);
}
// Function to get a list of Tech Numbers in a given range
vector<int> findTechNumbersInRange(int start, int end) {
    vector<int> techNumbers;
    for (int i = start; i <= end; i++) {
        if (isTechNumber(i)) {
            techNumbers.push_back(i);
        }
    }
    return techNumbers;
}
// Function to test predefined examples
void testPredefinedExamples() {
    cout << "\nTesting predefined examples:\n";
    vector<int> examples = {2025, 3025, 9801, 1234, 1001, 123321, 4096};
    for (int num : examples) {
        cout << num << " -> ";
        if (isTechNumber(num)) {
            cout << "Tech Number\n";
        } else {
            cout << "Not a Tech Number\n";
        }
    }
}
// Function to test user-defined range
void testUserDefinedRange() {
    int start, end;
    cout << "\nEnter a range to find Tech Numbers (start and end): ";
    cin >> start >> end;
    if (start > end) {
        cout << "Invalid range. Start must be less than or equal to end.\n";
        return;
    }
    vector<int> techNumbers = findTechNumbersInRange(start, end);
    cout << "\nTech Numbers in the range " << start << " to " << end << ":\n";
    if (techNumbers.empty()) {
        cout << "No Tech Numbers found in the given range.\n";
    } else {
        for (int num : techNumbers) {
            cout << num << " ";
        }
        cout << endl;
    }
}
// Function to check a single number input by the user
void checkSingleNumber() {
    int num;
    cout << "\nEnter a number to check if it's a Tech Number: ";
    cin >> num;
    if (isTechNumber(num)) {
        cout << num << " is a Tech Number.\n";
    } else {
        cout << num << " is NOT a Tech Number.\n";
    }
}
// Main function
int main() {
    cout << "Welcome to the Tech Number Checker Program!\n";
    // Test predefined examples
    testPredefinedExamples();
    // Check a single number
    checkSingleNumber();
    // Test for a range of numbers
    testUserDefinedRange();
    cout << "\nThank you for using the Tech Number Checker Program. Goodbye!\n";
    return 0;
}

Output:

Output


Welcome to the Tech Number Checker Program!
Testing predefined examples:
2025 -> Tech Number
3025 -> Tech Number
9801 -> Tech Number
1234 -> Not a Tech Number
1001 -> Not a Tech Number
123321 -> Not a Tech Number
4096 -> Not a Tech Number
Enter a number to check if it's a Tech Number: 3025
3025 is a Tech Number.
Enter a range to find Tech Numbers (start and end): 2000 5000
Tech Numbers in the range 2000 to 5000:
2025 3025 
Thank you for using the Tech Number Checker Program. Goodbye!

Explanation:

countDigits:

✅ This function loops the number for digits within number.
✅ Example: For 2025, the digit count is 4.
✅ We know that the number has an even number of digits, but we somehow need to find out.

powerOf10:

✅ It splits numbers by the powers of 10.
✅ Example: In general, powerOf10(n) gives n power of 10, which can divide 2025 into 2n (first half) and (2n+1) (second half) for 4 digits.

isValidInput:

✅ Ensures the input is valid for a Tech Number: It must be a non-negative number. The number has to be of even digits. Only appropriate inputs like positive numbers, except odd-digit numbers, are allowed elsewhere. It will throw appropriate error messages.

isTechNumber:

✅ Core logic to identify a Tech Number.

Validates the input.

✅ Divide (by the slash /) and modulus (by the per cent sign) splits the number into two halves. It sums the two halves and see if it square is equal to the original number.
✅ Example: For 2025, 20 + 25 = 45, and we have (45)^2 = 2025, so it's a Tech Number.

findTechNumbersInRange:

✅ A user-defined range is iterated through and is found to have all the Tech Numbers in it.
✅ Example: It identifies 2025, 3025, and 9801 in the range 2000-10000.

testPredefinedExamples:

✅ It shows the correctness of the program by using hardcoded examples.

testUserDefinedRange:

✅ Users can input a range to get Tech Numbers as well as handle invalid ranges gracefully.

Complexity Analysis:

Time Complexity

countDigits(int num)

✅ This function does until the number is able to be 0. First, the number is divided by each division-reducing number, and the number of iterations is proportional to the number of digits d in the number.
✅ Obviously, the time complexity of countDigits is O(log10(n)) since d = O(log10(n)) for n is the input number.

powerOf10(int exp)

✅ In this function, we have used a loop to multiply 10 by itself exp times. Depending on the value of exp, exp determines how many times we iterate, typically d/2, where d is the number of digits for the number. Thus, the powerOf10 is O(d) (or O(log10(n))) time.

isTechNumber(int num)

✅ The countDigits function finds the number of digits in this function time complexity of O(log10(n)). After that, it computes the power of 10 for splitting the number (powerOf10) with a time complexity of array d. All other operations (squaring, dividing, adding) are O(1) operations.
✅ Thus, the isTechNumber's function overall time complexity is O(log10(n)) + O(d), which reduces to O(d) = O(log10(n)).

findTechNumbersInRange(int end, int start)

✅ This function takes a range from start to end and does its loop over that range calling isTechNumber for each number.
✅ The isTechNumber function has a time complexity of O(log10(n)) for each number in the range.
✅ As a result, the time complexity is O( k log_10 (n) ), where n is the average of the value in the range.

testPredefinedExamples

✅ This function will iterate through a list of given fixed numbers and checks if it is a Tech Number using isTechNumber.
✅ The time complexity is O(m log10 n) m is the number of test cases and n is the average number of test cases in the list. M and n are a constant list size.

Space Complexity

countDigits(int num):

✅ This function takes up a constant amount of space, and it only holds the number and a counter variable. The space complexity is O(1).

powerOf10(int exp):

✅ The function uses a loop to compute powers of 10 and save the result, but stores whatever the result was. It's O(1) with respect to space complexity as well.

isTechNumber(int num):

✅ The function needs only fixed number variables (at least for storing the two halves of the number, their sum, and squaring them ..., therefore, it can be written O(1) space.

findTechNumbersInRange(int start, int end):

✅ This function checks for Tech Numbers, and stores the identified Tech Numbers into a vector. Here, space complexity is a number of Tech Numbers in the range. In the worst case, the space complexity is O(k), where k is the size of the range.

Other Functions:

✅ The testPredefinedExamples and checkSingleNumber function are just a couple of functions that have O(1) space complexity, storing a few variables.

Approach-2: Recursive Approach

The Recursive Approach for checking if a number is a Tech Number takes the essence of recursion and divide-and-base. The idea is to repeatedly break the number into two halves and see the sum of the two halves, whether or not the square of their sum equals the original number. The method works by repeatedly calling a function that splits the number into smaller parts until we reach a base case of a single-digit number.

The number is divided in half at each recursive step, and the sum of those things divided in half is computed. The process repeats until the number comes to one that we can compare directly to the original number. The recursive approach greatly simplifies the code as well as affords a nice way to solve the problem. It uses recursion (which is useful for demonstration purposes) but may not be as efficient for large numbers.

Example:

Let us take an example to illustrate the Tech number using recursive approach in C++.

Example


#include <iostream>
#include <cmath>
using namespace std;
// Function to count the number of digits in a number
int countDigits(int num) {
    int count = 0;
    while (num > 0) {
        count++;
        num /= 10;
    }
    return count;
}
// Recursive function to check if a number is a Tech Number
bool isTechNumberHelper(int num, int totalDigits, int digitCount) {
    // Base case: if we reach a single digit, return false since we need two halves
    if (digitCount == 1) {
        return false;
    }
    // Get the power of 10 for the second half (half the total number of digits)
    int powerOf10 = pow(10, totalDigits / 2);
    // Split the number into two halves
    int firstHalf = num / powerOf10;
    int secondHalf = num % powerOf10;
    // Calculate the sum of the halves
    int sum = firstHalf + secondHalf;

    // Check if the square of the sum equals the original number
    if (sum * sum == num) {
        return true;
    }
    // Recursive case: if not a Tech Number, recursively try with fewer digits
    return isTechNumberHelper(num / 10, totalDigits, digitCount - 1);
}
// Wrapper function to handle the recursion and start checking Tech Number
bool isTechNumber(int num) {
    // Base case: handle negative or single-digit numbers
    if (num < 10) {
        return false;
    }
    // Count the digits
    int digitCount = countDigits(num);
    // Check if the number has an even number of digits
    if (digitCount % 2 != 0) {
        return false;
    }
    // Call the recursive helper function
    return isTechNumberHelper(num, digitCount, digitCount);
}
// Function to find Tech Numbers in a range
void findTechNumbersInRange(int start, int end) {
    cout << "Tech Numbers between " << start << " and " << end << " are: " << endl;
    for (int i = start; i <= end; i++) {
        if (isTechNumber(i)) {
            cout << i << " ";
        }
    }
    cout << endl;
}
// Test predefined examples for Tech Numbers
void testPredefinedExamples() {
    int numbers[] = {2025, 3025, 1234, 9, 9999, 12321};
    cout << "Testing predefined numbers:" << endl;
    for (int i = 0; i < 6; i++) {
        if (isTechNumber(numbers[i])) {
            cout << numbers[i] << " is a Tech Number." << endl;
        } else {
            cout << numbers[i] << " is not a Tech Number." << endl;
        }
    }
}
// Function to test a single number entered by the user
void checkSingleNumber() {
    int num;
    cout << "Enter a number to check if it's a Tech Number: ";
    cin >> num;
    if (isTechNumber(num)) {
        cout << num << " is a Tech Number." << endl;
    } else {
        cout << num << " is not a Tech Number." << endl;
    }
}
int main() {
    int choice;
    do {
        cout << "\nTech Number Check Program\n";
        cout << "1. Check if a single number is a Tech Number\n";
        cout << "2. Find Tech Numbers in a range\n";
        cout << "3. Test predefined examples\n";
        cout << "4. Exit\n";
        cout << "Enter your choice: ";
        cin >> choice;
        switch (choice) {
            case 1:
                checkSingleNumber();
                break;
            case 2:
                int start, end;
                cout << "Enter the range (start end): ";
                cin >> start >> end;
                findTechNumbersInRange(start, end);
                break;
            case 3:
                testPredefinedExamples();
                break;
            case 4:
                cout << "Exiting program.\n";
                break;
            default:
                cout << "Invalid choice, please try again.\n";
        }
    } while (choice != 4);

    return 0;
}

Output:

Output


Tech Number Check Program
1. Check if a single number is a Tech Number
2. Find Tech Numbers in a range
3. Test predefined examples
4. Exit
Enter your choice: 1
Enter a number to check if it's a Tech Number: 2025
2025 is a Tech Number.
Tech Number Check Program
1. Check if a single number is a Tech Number
2. Find Tech Numbers in a range
3. Test predefined examples
4. Exit
Enter your choice: 2
Enter the range (start end): 2000
5000
Tech Numbers between 2000 and 5000 are: 
2025 3025 
Tech Number Check Program
1. Check if a single number is a Tech Number
2. Find Tech Numbers in a range
3. Test predefined examples
4. Exit
Enter your choice: 4
Exiting program.

Explanation:

The code starts with a function for counting digits in a number so that a number can be divided into two halves and continues from there. The isTechNumberHelper function implements the recursive approach to check if the number is a Tech Number. This function splits the number into two halves; both halves are calculated using mathematical operations such as dividing and calculating modulo.

After that, it calculates the sum of these two halves, and if the square of that equals the given number, it's a lucky number. If the condition is met, the function will return true, and the number is a Tech Number. The function will return false if not because it will recursively call itself, splitting the number into fewer digits and counting down one at a time until the base case is a single digit, where it returns false.

The main function isTechNumber is a wrapper that checks if a number has an even length of digits and, if so, calls a recursive helper function. It is immediately considered not a Tech Number if the number consists of an odd number of digits.

After that, users can use a user-friendly interface to check if a single number is a Tech Number, find all Tech Numbers in a given range, and test predefined examples. It is a tool that accepts input types of both single numbers and ranges and checks accordingly. A set of predefined examples tests various numbers that display whether any given one is a Tech Number. It is a looped program, so the user can keep making checks until he decides to exit.

The approach takes a recursive approach to the problem, breaking it down one step at a time but cutting the size of the problem at each level. Although, the overhead of multiple recursive calls may make it less efficient for large numbers.

Complexity Analysis:

Time Complexity:

✅ In this case, the recursive approach has an already known time complexity that majorly depends on the number of digits in the input number. Let the number have d digits.
✅ The countChars function runs in O(d), where d is the number of digits in the number. As mentioned, it takes a sequence of digits and iterates it once to find the total number of numbers in each number.
✅ Recursively, the isTechNumberHelper function splits the number into two halves. As the number is divided by two recursively, it's no longer written in base 10. It means that its recursion depth is proportional to the number of digits, O(d).
✅ At each recursive level, the function performs constant-time operations: We can calculate the sum of two halves and check if the square of the sum equals the original number in O(1) time.
✅ The overall time complexity is O(d) due to the fact that the recursion depth is directly proportional to the number of digits, and each recursive step will take constant work time.

Space Complexity:

The space complexity is influenced by two main factors:

✅ It is of a depth d because the number we are working on has d digits. It gives a space complexity of O(d) of recursion.
✅ However, other auxiliary space will be constant because no data structures , such as arrays or lists, are involved.

Introduction

Applications and Relevance:

Challenges in Implementation:

Approach-1: Basic Arithmetic Approach

Example:

Explanation:

Complexity Analysis:

Approach-2: Recursive Approach

Example:

Explanation:

Complexity Analysis:

Input Required