Wednesday, October 9, 2024
Google search engine
HomeData Modelling & AICount of digits in N and M that are same and are...

Count of digits in N and M that are same and are present on the same indices

Given two number N and M, the task is to find the count of digits in N and M that are the same and are present on the same indices.

Examples:

Input: N = 123, M = 321
Output: 1
Explanation: Digit 2 satisfies the condition

Input: N = 123, M = 111
Output: 1

 

Approach: The problem can be solved using two-pointer approach.

  • Convert N and M for ease of traversal
  • Create two pointers where one pointer points to the first digit of N and the other to the first digit of M respectively initially.
  • Now traverse both the numbers left to right and check if the digits on both pointers are same or not.
  • If yes, increase the count.
  • Increase the pointer by 1 on each iteration.
  • Return the final count at the end.

Below is the implementation of the above approach:

C++




// C++ implementation of the above approach
 
#include <bits/stdc++.h>
using namespace std;
int countDigits(int N, int M)
{
 
    // Convert N and M to string
    // for ease of traversal
    string a = to_string(N), b = to_string(M);
 
    int same_dig_cnt = 0;
 
    // Find the count of digits
    // that are same and occur on same indices
    // in both N and M.
    // Store the count in variable same_dig_cnt
    for (int i = 0; i < a.length() && b.length(); i++)
        if (a[i] == b[i])
            same_dig_cnt++;
 
    return same_dig_cnt;
}
 
// Driver code
int main()
{
 
    int N = 123, M = 321;
 
    cout << countDigits(N, M);
    return 0;
}


Java




// Java implementation of the above approach
import java.io.*;
public class GFG {
 
  static int countDigits(int N, int M) {
 
    // Convert N and M to string
    // for ease of traversal
    String a = Integer.toString(N), b = Integer.toString(M);
 
    int same_dig_cnt = 0;
 
    // Find the count of digits
    // that are same and occur on same indices
    // in both N and M.
    // Store the count in variable same_dig_cnt
    for (int i = 0; i < a.length() && i < b.length(); i++)
      if (a.charAt(i) == b.charAt(i))
        same_dig_cnt++;
 
    return same_dig_cnt;
  }
 
  // Driver code
  public static void main(String args[])
  {
    int N = 123, M = 321;
    System.out.println(countDigits(N, M));
  }
}
 
// This code is contributed by gfgking


Python3




# Python code for the above approach
def countDigits(N, M):
 
    # Convert N and M to string
    # for ease of traversal
    a = str(N)
    b = str(M)
 
    same_dig_cnt = 0;
 
    # Find the count of digits
    # that are same and occur on same indices
    # in both N and M.
    # Store the count in variable same_dig_cnt
    i = 0
    while(i < len(a) and len(b)):
        if (a[i] == b[i]):
            same_dig_cnt += 1
        i += 1
 
    return same_dig_cnt;
 
# Driver code
N = 123
M = 321;
 
print(countDigits(N, M));
 
# This code is contributed by Saurabh Jaiswal


C#




// C# implementation of the above approach
using System;
using System.Collections;
class GFG
{
 
  static int countDigits(int N, int M)
  {
 
    // Convert N and M to string
    // for ease of traversal
    string a = N.ToString(), b = M.ToString();
 
    int same_dig_cnt = 0;
 
    // Find the count of digits
    // that are same and occur on same indices
    // in both N and M.
    // Store the count in variable same_dig_cnt
    for (int i = 0; i < a.Length && i < b.Length; i++)
      if (a[i] == b[i])
        same_dig_cnt++;
 
    return same_dig_cnt;
  }
 
  // Driver code
  public static void Main()
  {
 
    int N = 123, M = 321;
 
    Console.Write(countDigits(N, M));
  }
}
 
// This code is contributed by Samim Hossain Mondal.


Javascript




<script>
       // JavaScript code for the above approach
       function countDigits(N, M) {
 
           // Convert N and M to string
           // for ease of traversal
           let a = (N).toString(), b = (M).toString();
 
           let same_dig_cnt = 0;
 
           // Find the count of digits
           // that are same and occur on same indices
           // in both N and M.
           // Store the count in variable same_dig_cnt
           for (let i = 0; i < a.length && b.length; i++)
               if (a[i] == b[i])
                   same_dig_cnt++;
 
           return same_dig_cnt;
       }
 
       // Driver code
       let N = 123, M = 321;
 
       document.write(countDigits(N, M));
 
      // This code is contributed by Potta Lokesh
   </script>


Output

1

Time Complexity: O(D), where D is the min count of digits in N or M
Auxiliary Space: O(D), where D is the max count of digits in N or M

Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!

Commit to GfG’s Three-90 Challenge! Purchase a course, complete 90% in 90 days, and save 90% cost click here to explore.

Last Updated :
12 Dec, 2022
Like Article
Save Article


Previous

<!–

8 Min Read | Java

–>


Next


<!–

8 Min Read | Java

–>

Share your thoughts in the comments

RELATED ARTICLES

Most Popular

Recent Comments