Given an array arr[] of size N and an integer X, the task is to find the number of ordered pairs (i, j) such that i != j and X is the concatenation of the numbers arr[i] and arr[j]
Examples:
Input: N = 4, arr[] = {1, 212, 12, 12}, X = 1212
Output: 3
Explanation: X = 1212 can be obtained by concatenating:
- numbers[0] = 1 with numbers[1] = 212
- numbers[2] = 12 with numbers[3] = 12
- numbers[3] = 12 with numbers[2] = 12
- Therefore, number of possible ordered pairs are 3
Input: N = 3, arr[] = {11, 11, 110}, X = 11011
Output: 2
Approach: The task can be solved using a hashmap Follow the below steps to solve the problem
- Store the lengths of all the numbers in a vector.
- Iterate over the given number array and check if X can be obtained from the number. If so increase the count to check with how many numbers does the current number can form a pair.
- Increase the value of the current number in the map.
- Clear the map and repeat the same steps on the given number array from the back.
Below is the implementation of the above approach:
C++
// C++ program for the above approach #include <bits/stdc++.h> using namespace std;
// Function to find the number of possible // ordered pairs long long countPairs( int n, int x, vector< int > v)
{ int power[10]
= { 1, 10, 100,
1000, 10000, 100000,
1000000, 10000000,
100000000,
1000000000 };
// Stores the count of digits of each number
vector< int > len;
long long count = 0;
for ( int i = 0; i < n; i++)
len.push_back( log10 (v[i]) + 1);
unordered_map< int , int > mp;
mp[v[0]]++;
// Iterating from the start
for ( int i = 1; i < n; i++) {
if (x % power[len[i]] == v[i])
count += mp[x / power[len[i]]];
cout<< "count = " <<count<<endl;
mp[v[i]]++;
}
mp.clear();
mp[v[n - 1]]++;
// Iterating from the end
for ( int i = n - 2; i >= 0; i--) {
if (x % power[len[i]] == v[i])
count += mp[x / power[len[i]]];
cout<< "c = " <<count<<endl;
mp[v[i]]++;
}
return count;
} // Driver Code int main()
{ int N = 4;
int X = 1212;
vector< int > numbers = { 1, 212, 12, 12 };
long long ans = countPairs(N, X, numbers);
cout << ans << endl;
return 0;
} |
Java
// Java program for the above approach import java.util.*;
class GFG {
// Function to find the number of possible
// ordered pairs
static long countPairs( int n, int x, int [] v) {
int power[] = { 1 , 10 , 100 , 1000 , 10000 , 100000 ,
1000000 , 10000000 , 100000000 , 1000000000 };
// Stores the count of digits of each number
Vector<Integer> len = new Vector<Integer>();
long count = 0 ;
for ( int i = 0 ; i < n; i++)
len.add(( int ) (Math.log10(v[i]) + 1 ));
HashMap<Integer, Integer> mp = new HashMap<Integer, Integer>();
if (mp.containsKey(v[ 0 ])) {
mp.put(v[ 0 ], mp.get(v[ 0 ]) + 1 );
} else {
mp.put(v[ 0 ], 1 );
}
// Iterating from the start
for ( int i = 1 ; i < n; i++) {
if (x % power[len.get(i)] == v[i]&&mp.containsKey(x / power[len.get(i)]))
count += mp.get(x / power[len.get(i)]);
System.out.println( "count = " + count);
if (mp.containsKey(v[i])) {
mp.put(v[i], mp.get(v[i]) + 1 );
} else {
mp.put(v[i], 1 );
}
}
mp.clear();
if (mp.containsKey(v[n - 1 ])) {
mp.put(v[n - 1 ], mp.get(v[n - 1 ]) + 1 );
} else {
mp.put(v[n - 1 ], 1 );
}
// Iterating from the end
for ( int i = n - 2 ; i >= 0 ; i--) {
if (x % power[len.get(i)] == v[i]&&mp.containsKey(x / power[len.get(i)]))
count += mp.get(x / power[len.get(i)]);
System.out.println( "c = " + count);
if (mp.containsKey(v[i])) {
mp.put(v[i], mp.get(v[i]) + 1 );
} else {
mp.put(v[i], 1 );
}
}
return count;
}
// Driver Code
public static void main(String[] args) {
int N = 4 ;
int X = 1212 ;
int [] numbers = { 1 , 212 , 12 , 12 };
long ans = countPairs(N, X, numbers);
System.out.print(ans + "\n" );
}
} // This code is contributed by shikhasingrajput |
Python3
# Python 3 program for the above approach from collections import defaultdict
import math
# Function to find the number of possible # ordered pairs def countPairs(n, x, v):
power = [ 1 , 10 , 100 ,
1000 , 10000 , 100000 ,
1000000 , 10000000 ,
100000000 ,
1000000000 ]
# Stores the count of digits of each number
length = []
count = 0
for i in range (n):
length.append( int (math.log10(v[i])) + 1 )
mp = defaultdict( int )
mp[v[ 0 ]] + = 1
# Iterating from the start
for i in range ( 1 , n):
if (x % power[length[i]] = = v[i]):
count + = mp[x / / power[length[i]]]
mp[v[i]] + = 1
mp.clear()
mp[v[n - 1 ]] + = 1
# Iterating from the end
for i in range (n - 2 , - 1 , - 1 ):
if (x % power[length[i]] = = v[i]):
count + = mp[x / / power[length[i]]]
mp[v[i]] + = 1
return count
# Driver Code if __name__ = = "__main__" :
N = 4
X = 1212
numbers = [ 1 , 212 , 12 , 12 ]
ans = countPairs(N, X, numbers)
print (ans)
# This code is contributed by ukasp.
|
C#
// C# program to implement above approach using System;
using System.Collections;
using System.Collections.Generic;
class GFG
{ // Function to find the number of possible
// ordered pairs
static long countPairs( int n, int x, int [] v) {
int [] power = new int []{ 1, 10, 100, 1000, 10000, 100000,
1000000, 10000000, 100000000, 1000000000 };
// Stores the count of digits of each number
List< int > len = new List< int >();
long count = 0;
for ( int i = 0 ; i < n ; i++){
len.Add(( int )(Math.Log10(v[i]) + 1));
}
Dictionary< int , int > mp = new Dictionary< int , int >();
if (mp.ContainsKey(v[0])) {
mp[v[0]]+=1;
} else {
mp.Add(v[0], 1);
}
// Iterating from the start
for ( int i = 1; i < n; i++) {
if (x % power[len[i]] == v[i] && mp.ContainsKey(x / power[len[i]])){
count += mp[x / power[len[i]]];
}
// Console.WriteLine("count = " + count);
if (mp.ContainsKey(v[i])) {
mp[v[i]]+=1;
} else {
mp.Add(v[i], 1);
}
}
mp.Clear();
if (mp.ContainsKey(v[n - 1])) {
mp[v[n - 1]] += 1;
} else {
mp.Add(v[n - 1], 1);
}
// Iterating from the end
for ( int i = n - 2; i >= 0; i--) {
if (x % power[len[i]] == v[i] && mp.ContainsKey(x / power[len[i]])){
count += mp[x / power[len[i]]];
}
// Console.WriteLine("c = " + count);
if (mp.ContainsKey(v[i])) {
mp[v[i]] += 1;
} else {
mp.Add(v[i], 1);
}
}
return count;
}
public static void Main( string [] args){
int N = 4;
int X = 1212;
int [] numbers = new int []{ 1, 212, 12, 12 };
long ans = countPairs(N, X, numbers);
Console.WriteLine(ans);
}
} // This code is contributed by subhamgoyal2014. |
Javascript
<script> // JavaScript code for the above approach
// Function to find the number of possible
// ordered pairs
function countPairs(n, x, v) {
let power = [1, 10, 100,
1000, 10000, 100000,
1000000, 10000000,
100000000,
1000000000];
// Stores the count of digits of each number
let len = [];
let count = 0;
for (let i = 0; i < n; i++)
len.push(Math.floor(Math.log10(v[i])) + 1);
let mp = new Map();
mp.set(v[0], 1);
// Iterating from the start
for (let i = 1; i < n; i++) {
if (x % power[len[i]] == v[i] && mp.has(Math.floor(x / power[len[i]])))
count += mp.get(Math.floor(x / power[len[i]]));
if (mp.has(v[i])) {
mp.set(v[i], mp.get(v[i]) + 1)
}
else {
mp.set(v[i], 1)
}
}
mp = new Map();
mp.set(v[n - 1], 1);
// Iterating from the end
for (let i = n - 2; i >= 0; i--) {
if (x % power[len[i]] == v[i] && mp.has(Math.floor(x / power[len[i]])))
count += mp.get(Math.floor(x / power[len[i]]));
if (mp.has(v[i])) {
mp.set(v[i], mp.get(v[i]) + 1)
}
else {
mp.set(v[i], 1)
}
}
return count;
}
// Driver Code
let N = 4;
let X = 1212;
let numbers = [1, 212, 12, 12];
let ans = countPairs(N, X, numbers);
document.write(ans + '<br>' )
// This code is contributed by Potta Lokesh
</script>
|
Output
3
Time complexity: O(N)
Auxiliary Space: O(N)
Recommended Articles