Aquileo | Special two digit numbers in a Binary Search Tree

Given a Binary Search Tree, the task is to count the number of nodes which are having special two-digit numbers.
Note: Special two-digit numbers are those numbers that satisfy the condition that the sum of their digits added to the product of their digits equals the original number.
Prerequisite: Special Two Digit Number | Binary Search Tree |

Examples :

Input:
Output: 2
Explanation: The two special two-digit numbers in the input are 19 and 99. These numbers satisfy the condition of special two-digit numbers. Hence, the output is 2.
Input:
Output: 0
Explanation: There are no special two-digit number in the given input.

Approach:

The idea is to iterate through each node of tree recursively with a variable count, and check each node's data for a special two-digit number. If it is then increment the variable count. In the end, return count.

Below is the implementation of the above approach:

C++

// C++ code to count special two-digit 
// numbers in BST
#include <bits/stdc++.h>
using namespace std;

class Node {
public:
    int data;
    Node* left;
    Node* right;

    Node(int x) {
        data = x;
        left = right = nullptr;
    }
};

// Function to check if a number is a special 
// two-digit number
bool isSpecial(int num) {
    if (num < 10 || num > 99) return false;
    
    int firstDigit = num / 10;
    int secondDigit = num % 10;
    
    // Check if the sum of digits and product of 
    // digits equals the number
    return (firstDigit + secondDigit + 
                      firstDigit * secondDigit == num);
}

// Recursive function to count special two-digit 
// numbers in BST
int countSpecialNumbers(Node* root) {
    if (root == nullptr) return 0;

    // Count special numbers in left and right
    // subtrees recursively
    int leftCount = countSpecialNumbers(root->left);
    int rightCount = countSpecialNumbers(root->right);

    // Check if current node's data is a special
    // two-digit number
    int currentCount = isSpecial(root->data) ? 1 : 0;

    return leftCount + rightCount + currentCount;
}

int main() {
  
    // Binary Search Tree representation:
    //               19
    //             /    \
    //            1      99
    //                 /
    //               57
    //              /
    //            22
    Node* root = new Node(19);
    root->left = new Node(1);
    root->right = new Node(99);
    root->right->left = new Node(57);
    root->right->left->left = new Node(22);

    cout << countSpecialNumbers(root) << endl;

    return 0;
}

// C code to count special two-digit
// numbers in BST
#include <stdio.h>
#include <stdlib.h>

struct Node {
    int data;
    struct Node* left;
    struct Node* right;
};

// Function to check if a number is a special
// two-digit number
int isSpecial(int num) {
    if (num < 10 || num > 99) return 0;

    int firstDigit = num / 10;
    int secondDigit = num % 10;

    // Check if the sum of digits and product of
    // digits equals the number
    return (firstDigit + secondDigit +
                   firstDigit * secondDigit == num);
}

// Recursive function to count special 
// two-digit numbers in BST
int countSpecialNumbers(struct Node* root) {
    if (root == NULL) return 0;

    // Count special numbers in left and right
    // subtrees recursively
    int leftCount = countSpecialNumbers(root->left);
    int rightCount = countSpecialNumbers(root->right);

    // Check if current node's data is a 
    // special two-digit number
    int currentCount = isSpecial(root->data) ? 1 : 0;

    return leftCount + rightCount + currentCount;
}

struct Node* createNode(int data) {
    struct Node* node 
      = (struct Node*)malloc(sizeof(struct Node));
    node->data = data;
    node->left = NULL;
    node->right = NULL;
    return node;
}

int main() {
  
    // Binary Search Tree representation:
    //               19
    //             /    \
    //            1      99
    //                 /
    //               57
    //              /
    //            22

    struct Node* root = createNode(19);
    root->left = createNode(1);
    root->right = createNode(99);
    root->right->left = createNode(57);
    root->right->left->left = createNode(22);
    printf("%d\n", countSpecialNumbers(root));

    return 0;
}

Java

// Java code to count special two-digit 
// numbers in BST
import java.util.*;

class Node {
    int data;
    Node left, right;

    Node(int x) {
        data = x;
        left = right = null;
    }
}

class GfG {

    // Function to check if a number is a 
    // special two-digit number
    static boolean isSpecial(int num) {
        if (num < 10 || num > 99) return false;
        
        int firstDigit = num / 10;
        int secondDigit = num % 10;

        // Check if the sum of digits and product 
        // of digits equals the number
        return (firstDigit + secondDigit + 
                firstDigit * secondDigit == num);
    }

    // Recursive function to count special 
    // two-digit numbers in BST
    static int countSpecialNumbers(Node root) {
        if (root == null) return 0;

        // Count special numbers in left and right 
        // subtrees recursively
        int leftCount = countSpecialNumbers(root.left);
        int rightCount = countSpecialNumbers(root.right);

        // Check if current node's data is a
        // special two-digit number
        int currentCount = isSpecial(root.data) ? 1 : 0;

        return leftCount + rightCount + currentCount;
    }

    public static void main(String[] args) {
      
        // Binary Search Tree representation:
        //               19
        //             /    \
        //            1      99
        //                 /
        //               57
        //              /
        //            22

        Node root = new Node(19);
        root.left = new Node(1);
        root.right = new Node(99);
        root.right.left = new Node(57);
        root.right.left.left = new Node(22);
        System.out.println(countSpecialNumbers(root));
    }
}

Python

# Python code to count special 
# two-digit numbers in BST
class Node:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None

# Function to check if a number is a special
# two-digit number
def is_special(num):
    if num < 10 or num > 99:
        return False
    
    first_digit = num // 10
    second_digit = num % 10
    
    # Check if the sum of digits and product of 
    # digits equals the number
    return first_digit + second_digit \
  	+ first_digit * second_digit == num

# Recursive function to count special 
# two-digit numbers in BST
def count_special_numbers(root):
    if root is None:
        return 0

    # Count special numbers in left and right 
    # subtrees recursively
    left_count = count_special_numbers(root.left)
    right_count = count_special_numbers(root.right)

    # Check if current node's data is a 
    # special two-digit number
    current_count = 1 if is_special(root.data) else 0

    return left_count + right_count + current_count

if __name__ == "__main__":
  
    # Binary Search Tree representation:
    #               19
    #             /    \
    #            1      99
    #                 /
    #               57
    #              /
    #            22
    root = Node(19)
    root.left = Node(1)
    root.right = Node(99)
    root.right.left = Node(57)
    root.right.left.left = Node(22)
    print(count_special_numbers(root))

// C# code to count special two-digit
// numbers in BST
using System;

class Node {
    public int data;
    public Node left, right;

    public Node(int x) {
        data = x;
        left = right = null;
    }
}

class GfG {

    // Function to check if a number is a 
    // special two-digit number
    static bool IsSpecial(int num) {
        if (num < 10 || num > 99) return false;

        int first_digit = num / 10;
        int second_digit = num % 10;

        // Check if the sum of digits and product of 
        // digits equals the number
        return (first_digit + second_digit +
                 first_digit * second_digit == num);
    }

    // Recursive function to count special 
    // two-digit numbers in BST
    static int CountSpecialNumbers(Node root) {
        if (root == null) return 0;

        // Count special numbers in left and 
        // right subtrees recursively
        int left_count = CountSpecialNumbers(root.left);
        int right_count = CountSpecialNumbers(root.right);

        // Check if current node's data is a 
        // special two-digit number
        int current_count = IsSpecial(root.data) ? 1 : 0;

        return left_count + right_count + current_count;
    }

    static void Main(string[] args) {
      
        // Binary Search Tree representation:
        //               19
        //             /    \
        //            1      99
        //                 /
        //               57
        //              /
        //            22

        Node root = new Node(19);
        root.left = new Node(1);
        root.right = new Node(99);
        root.right.left = new Node(57);
        root.right.left.left = new Node(22);
        Console.WriteLine(CountSpecialNumbers(root));
    }
}

JavaScript

// JavaScript code to count special 
// two-digit numbers in BST

class Node {
    constructor(data) {
        this.data = data;
        this.left = null;
        this.right = null;
    }
}

// Function to check if a number is a special 
// two-digit number
function isSpecial(num) {
    if (num < 10 || num > 99) {
        return false;
    }
    
    const firstDigit = Math.floor(num / 10);
    const secondDigit = num % 10;
    
    // Check if the sum of digits and product of 
    // digits equals the number
    return firstDigit + secondDigit + 
                        firstDigit * secondDigit === num;
}

// Recursive function to count special 
// two-digit numbers in BST
function countSpecialNumbers(root) {
    if (root === null) {
        return 0;
    }

    // Count special numbers in left and right 
    // subtrees recursively
    const leftCount = countSpecialNumbers(root.left);
    const rightCount = countSpecialNumbers(root.right);

    // Check if current node's data is a special 
    // two-digit number
    const currentCount = isSpecial(root.data) ? 1 : 0;

    return leftCount + rightCount + currentCount;
}

// Binary Search Tree representation:
//               19
//             /    \
//            1      99
//                 /
//               57
//              /
//            22
const root = new Node(19);
root.left = new Node(1);
root.right = new Node(99);
root.right.left = new Node(57);
root.right.left.left = new Node(22);

console.log(countSpecialNumbers(root));

Output

Time Complexity: O(n), thatn is the number of nodes in Tree.
Auxiliary Space: O(h), where h is the height of the tree and this extra space is used due to the recursion call stack.

Special two digit numbers in a Binary Search Tree

Explore