Given two numbers **A** and **B**, the task is to find the count of pairs **(X, Y)** in range **[A, B]**, such that **(X * Y) + (X + Y)** is equal to the number formed by concatenation of **X** and **Y****Examples:**

Input:A = 1, B = 9Output:9Explanation:

The pairs (1, 9), (2, 9), (3, 9), (4, 9), (5, 9), (6, 9), (7, 9), (8, 9) and (9, 9) are the required pairs.Input:A = 4, B = 10Output:7Explanation:The pairs (4, 9), (5, 9), (6, 9), (7, 9), (8, 9), (9, 9) and (10, 9) satisfy the required condition.

**Approach :**

We can observe that any number of the form [9, 99, 999, 9999, ….] satisfies the condition with all other values.

Illustration:

If Y = 9, the required condition is satisfied for all values of X.

{1*9 + (1 + 9) = 19, 2*9 + (2 + 9) = 29, ……….. 11*9 + (11 + 9) = 119 …..

Similarly, for Y = 99, 1*99 + 1 + 99 = 199, 2*99 + 2 + 99 = 299, ………

Hence, follow the steps below to solve the problems:

- Count the number of possible values of Y of the form {9, 99, 999, 9999, ….} in range [A, B] and store in
**countY** - Count the number of possible values of X in the range [A, B] as
**countX**

countX = (B - A + 1)

- The required count will be the product of possible count of X and Y, i.e.

answer = countX * countY

Below is the implementation of the above approach:

## C++

`// C++ program to count` `// all the possible pairs` `// with X*Y + (X + Y) equal to` `// number formed by` `// concatenating X and Y` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function for counting pairs` `int` `countPairs(` `int` `A, ` `int` `B)` `{` ` ` `int` `countY = 0,` ` ` `countX = (B - A) + 1,` ` ` `next_val = 9;` ` ` `// Count possible values` ` ` `// of Y` ` ` `while` `(next_val <= B) {` ` ` `if` `(next_val >= A) {` ` ` `countY += 1;` ` ` `}` ` ` `next_val = next_val * 10 + 9;` ` ` `}` ` ` `return` `(countX * countY);` `}` `// Driver Code` `int` `main()` `{` ` ` `int` `A = 1;` ` ` `int` `B = 16;` ` ` `cout << countPairs(A, B);` ` ` `return` `0;` `}` |

## Java

`// Java program to count` `// all the possible pairs` `// with X*Y + (X + Y) equal to` `// number formed by` `// concatenating X and Y` `import` `java.util.*;` `class` `GFG{` `// Function for counting pairs` `static` `int` `countPairs(` `int` `A, ` `int` `B)` `{` ` ` `int` `countY = ` `0` `,` ` ` `countX = (B - A) + ` `1` `,` ` ` `next_val = ` `9` `;` ` ` `// Count possible values` ` ` `// of Y` ` ` `while` `(next_val <= B)` ` ` `{` ` ` `if` `(next_val >= A)` ` ` `{` ` ` `countY += ` `1` `;` ` ` `}` ` ` `next_val = next_val * ` `10` `+ ` `9` `;` ` ` `}` ` ` `return` `(countX * countY);` `}` `// Driver Code` `public` `static` `void` `main(String args[])` `{` ` ` `int` `A = ` `1` `;` ` ` `int` `B = ` `16` `;` ` ` `System.out.print(countPairs(A, B));` `}` `}` `// This code is contributed by Code_Mech` |

## Python3

`# Python3 program to count` `# all the possible pairs` `# with X*Y + (X + Y) equal to` `# number formed by` `# concatenating X and Y` `# Function for counting pairs` `def` `countPairs(A, B):` ` ` `countY ` `=` `0` ` ` `countX ` `=` `(B ` `-` `A) ` `+` `1` ` ` `next_val ` `=` `9` ` ` `# Count possible values` ` ` `# of Y` ` ` `while` `(next_val <` `=` `B):` ` ` `if` `(next_val >` `=` `A):` ` ` `countY ` `+` `=` `1` ` ` `next_val ` `=` `next_val ` `*` `10` `+` `9` ` ` `return` `(countX ` `*` `countY)` `# Driver Code` `if` `__name__ ` `=` `=` `'__main__'` `:` ` ` ` ` `A ` `=` `1` ` ` `B ` `=` `16` ` ` ` ` `print` `(countPairs(A, B))` `# This code is contributed by mohit kumar 29` |

## C#

`// C# program to count` `// all the possible pairs` `// with X*Y + (X + Y) equal to` `// number formed by` `// concatenating X and Y` `using` `System;` `class` `GFG{` `// Function for counting pairs` `static` `int` `countPairs(` `int` `A, ` `int` `B)` `{` ` ` `int` `countY = 0,` ` ` `countX = (B - A) + 1,` ` ` `next_val = 9;` ` ` `// Count possible values` ` ` `// of Y` ` ` `while` `(next_val <= B)` ` ` `{` ` ` `if` `(next_val >= A)` ` ` `{` ` ` `countY += 1;` ` ` `}` ` ` `next_val = next_val * 10 + 9;` ` ` `}` ` ` `return` `(countX * countY);` `}` `// Driver Code` `public` `static` `void` `Main()` `{` ` ` `int` `A = 1;` ` ` `int` `B = 16;` ` ` `Console.Write(countPairs(A, B));` `}` `}` `// This code is contributed by Akanksha_Rai` |

## Javascript

`<script>` `// javascript program to count` `// all the possible pairs` `// with X*Y + (X + Y) equal to` `// number formed by` `// concatenating X and Y` ` ` `// Function for counting pairs` ` ` `function` `countPairs(A , B)` ` ` `{` ` ` `var` `countY = 0, countX = (B - A) + 1, next_val = 9;` ` ` `// Count possible values` ` ` `// of Y` ` ` `while` `(next_val <= B)` ` ` `{` ` ` `if` `(next_val >= A)` ` ` `{` ` ` `countY += 1;` ` ` `}` ` ` `next_val = next_val * 10 + 9;` ` ` `}` ` ` `return` `(countX * countY);` ` ` `}` ` ` `// Driver Code` ` ` `var` `A = 1;` ` ` `var` `B = 16;` ` ` `document.write(countPairs(A, B));` `// This code is contributed by todaysgaurav` `</script>` |

**Output:**

16

**Time Complexity: **O(log_{10}(B))**Space Complexity: **O(1)

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the **Essential Maths for CP Course** at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**