Absolute difference between the first X and last X Digits of N

0 0 5 minutes read

Given two integers N and X. The task is to print the absolute difference between the first X and last X digits in N. Considering the number of digits is atleast 2*x.

Examples:

Input: N = 21546, X = 2
Output: 25
The first two digit in 21546 is 21.
The last two digit in 21546 is 46.
The absolute difference of 21 and 46 is 25.

Input: N = 351684617, X = 3
Output: 266

Simple Approach:

Store the last x digits of the number in last.
Find the number of digits in the number.
Remove all the digits except the first x.
Store the first x integers of the number in first.

Below is the implementation of the above approach:

C++

// C++ implementation of the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the
// number of digits in the integer
long long digitsCount(long long n)
{
    int len = 0;
    while (n > 0) {
        len++;
        n /= 10;
    }
    return len;
}
 
// Function to find the absolute difference
long long absoluteFirstLast(long long n, int x)
{
    // Store the last x digits in last
    int i = 0, mod = 1;
    while (i < x) {
        mod *= 10;
        i++;
    }
    int last = n % mod;
 
    // Count the no. of digits in N
    long long len = digitsCount(n);
 
    // Remove the digits except the first x
    while (len != x) {
        n /= 10;
        len--;
    }
 
    // Store the first x digits in first
    int first = n;
 
    // Return the absolute difference between
    // the first and last
    return abs(first - last);
}
 
// Driver code
int main()
{
    long long n = 21546, x = 2;
    cout << absoluteFirstLast(n, x);
 
    return 0;
}

Java

// Java implementation of the above approach
import java.util.*;
 
class GFG
{
 
// Function to find the
// number of digits in the integer
static int digitsCount(int n)
{
    int len = 0;
    while (n > 0) 
    {
        len++;
        n /= 10;
    }
    return len;
}
 
// Function to find the absolute difference
static int absoluteFirstLast(int n, int x)
{
    // Store the last x digits in last
    int i = 0, mod = 1;
    while (i < x) 
    {
        mod *= 10;
        i++;
    }
    int last = n % mod;
 
    // Count the no. of digits in N
    int len = digitsCount(n);
 
    // Remove the digits except the first x
    while (len != x)
    {
        n /= 10;
        len--;
    }
 
    // Store the first x digits in first
    int first = n;
 
    // Return the absolute difference between
    // the first and last
    return Math.abs(first - last);
}
 
// Driver code
public static void main(String args[])
{
    int n = 21546, x = 2;
    System.out.println(absoluteFirstLast(n, x));
}
}
 
// This code is contributed by
// Surendra_Gangwar

Python3

# Python3 implementation of the above approach 
 
# Function to find the 
# number of digits in the integer 
def digitsCount(n) :
    length = 0; 
    while (n > 0) : 
        length += 1; 
        n //= 10; 
         
    return length; 
 
 
# Function to find the absolute difference 
def absoluteFirstLast(n, x) :
     
    # Store the last x digits in last 
    i = 0 ;
    mod = 1;
    while (i < x) :
        mod *= 10;
        i += 1; 
     
    last = n % mod;
     
    # Count the no. of digits in N
    length = digitsCount(n); 
     
    # Remove the digits except the first x
    while (length != x) :
        n //= 10;
        length -= 1; 
     
    # Store the first x digits in first 
    first = n; 
     
    # Return the absolute difference between
    # the first and last 
    return abs(first - last); 
 
# Driver code 
if __name__ == "__main__" : 
     
    n = 21546 ;
    x = 2; 
    print(absoluteFirstLast(n, x)); 
     
# This code is contributed by Ryuga

C#

// C# implementation of the approach 
using System;
 
class GFG 
{ 
 
// Function to find the 
// number of digits in the integer 
static int digitsCount(int n) 
{ 
    int len = 0; 
    while (n > 0) 
    { 
        len++; 
        n /= 10; 
    } 
    return len; 
} 
 
// Function to find the absolute difference 
static int absoluteFirstLast(int n, int x) 
{ 
    // Store the last x digits in last 
    int i = 0, mod = 1; 
    while (i < x) 
    { 
        mod *= 10; 
        i++; 
    } 
    int last = n % mod; 
 
    // Count the no. of digits in N 
    int len = digitsCount(n); 
 
    // Remove the digits except the first x 
    while (len != x) 
    { 
        n /= 10; 
        len--; 
    } 
 
    // Store the first x digits in first 
    int first = n; 
 
    // Return the absolute difference between 
    // the first and last 
    return Math.Abs(first - last); 
} 
 
// Driver code 
public static void Main(String []args) 
{ 
    int n = 21546, x = 2; 
    Console.Write(absoluteFirstLast(n, x)); 
} 
} 
 
// This code has been contributed by 29AjayKumar

PHP

<?php
// PHP implementation of the above approach
 
// Function to find the number of 
// digits in the integer
function digitsCount($n)
{
    $len = 0;
    while ($n > 0) 
    {
        $len++;
        $n = (int)($n / 10);
    }
    return $len;
}
 
// Function to find the absolute difference
function absoluteFirstLast($n, $x)
{
    // Store the last x digits in last
    $i = 0;
    $mod = 1;
    while ($i < $x)
    {
        $mod *= 10;
        $i++;
    }
    $last = $n % $mod;
 
    // Count the no. of digits in N
    $len = digitsCount($n);
 
    // Remove the digits except the first x
    while ($len != $x) 
    {
        $n = (int)($n / 10);
        $len--;
    }
 
    // Store the first x digits in first
    $first = $n;
 
    // Return the absolute difference 
    // between the first and last
    return abs($first - $last);
}
 
// Driver code
$n = 21546;
$x = 2;
echo absoluteFirstLast($n, $x);
 
// This code is contributed by mits
?>

Javascript

<script>
 
// Javascript implementation of the above approach
 
// Function to find the
// number of digits in the integer
function digitsCount(n)
{
    let len = 0;
    while (n > 0) 
    {
        len++;
        n = Math.floor(n / 10);
    }
    return len;
}
 
// Function to find the absolute difference
function absoluteFirstLast(n, x)
{
    // Store the last x digits in last
    let i = 0, mod = 1;
    while (i < x) 
    {
        mod *= 10;
        i++;
    }
    let last = n % mod;
 
    // Count the no. of digits in N
    let len = digitsCount(n);
 
    // Remove the digits except the first x
    while (len != x)
    {
        n = Math.floor(n / 10);
        len--;
    }
 
    // Store the first x digits in first
    let first = n;
 
    // Return the absolute difference between
    // the first and last
    return Math.abs(first - last);
}
 
// driver program
     
    let n = 21546, x = 2;
    document.write(absoluteFirstLast(n, x));
   
</script>

Output:

Time Complexity: O(X+k) where X is the given integer and k is the number of digits in n.
Auxiliary Space: O(1), since no extra space has been taken.

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 zambiatek!