Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Minimize moves to reach a target point from origin by moving horizontally or diagonally in right direction

  • Difficulty Level : Medium
  • Last Updated : 27 Jan, 2022

Given source (X1, Y1) as (0, 0) and a target (X2, Y2) on a 2-D plane. In one step, either of (X1+1, Y1+1) or (X1+1, Y1) can be visited from (X1, Y1). The task is to calculate the minimum moves required to reach the target using given moves. If the target can’t be reached, print “-1”.

Examples: 

Input: X2 = 1, Y2 = 0
Output: 1
Explanation: Take 1 step from (X1, Y1) to (X1+1, Y1), i.e., (0,0) -> (1,0). So number of moves to reach target is 1.

Input: X2 = 47, Y2 = 11
Output:  47

 

Naive Approach: The naive approach to solve this problem is to check all combination of (X+1, Y) and (X+1, Y+1) moves needed to reach the target and print the least among them.

Efficient Approach: Based on given conditions about movement, following points can be observed:

  • If Y2 > X2, then we cannot the target since in every move it must that X increases by 1.
  • If Y2 < X2, then we can either move diagonally Y2 times, and then (X2-Y2) times horizontally, or vice versa.
  • If Y2 = X2, then we can move either X2 times diagonally or Y2 moves diagonally

The task can be solved using the above observations. If Y2 > X2, then the target can never be reached with given moves, else always a minimum of X2 moves are necessary. 

Below is the implementation of the above approach-:

C++




// C++ Implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find minimum moves
int minimum_Moves(int x, int y)
{
    // If y > x, target can never be reached
    if (x < y) {
        return -1;
    }
 
    // In all other case answer will be X
    else {
        return x;
    }
}
 
// Driver Code
int main()
{
    long long int X2 = 47, Y2 = 11;
    cout << minimum_Moves(X2, Y2) << endl;
}

Java




// Java program for the above approach
import java.io.*;
import java.lang.*;
import java.util.*;
 
class GFG {
 
  // Function to find minimum moves
  static long minimum_Moves(long x, long y)
  {
     
    // If y > x, target can never be reached
    if (x < y) {
      return -1;
    }
 
    // In all other case answer will be X
    else {
      return x;
    }
  }
 
  // Driver Code
  public static void main (String[] args)
  {
 
    long  X2 = 47, Y2 = 11;
    System.out.println(minimum_Moves(X2, Y2));
  }
}
 
// This code is contributed by hrithikgarg03188

Python




# Pyhton Implementation of the approach
 
# Function to find minimum moves
def minimum_Moves(x, y):
     
    # If y > x, target can never be reached
    if (x < y):
        return -1
 
    # In all other case answer will be X
    else:
        return x
 
# Driver Code
X2 = 47
Y2 = 11
print(minimum_Moves(X2, Y2))
 
# This code is contributed by samim2000.

C#




// C# Implementation of the approach
using System;
class GFG {
 
    // Function to find minimum moves
    static int minimum_Moves(int x, int y)
    {
       
        // If y > x, target can never be reached
        if (x < y) {
            return -1;
        }
 
        // In all other case answer will be X
        else {
            return x;
        }
    }
 
    // Driver Code
    public static void Main()
    {
        int X2 = 47, Y2 = 11;
        Console.WriteLine(minimum_Moves(X2, Y2));
    }
}
 
// This code is contributed by ukasp.

Javascript




<script>
       // JavaScript code for the above approach
 
       // Function to find minimum moves
       function minimum_Moves(x, y)
       {
        
           // If y > x, target can never be reached
           if (x < y)
           {
               return -1;
           }
 
           // In all other case answer will be X
           else
           {
               return x;
           }
       }
 
       // Driver Code
       let X2 = 47, Y2 = 11;
       document.write(minimum_Moves(X2, Y2) + '<br>');
 
        // This code is contributed by Potta Lokesh
   </script>

 
 

Output
47

 

Time Complexity: O(1)
Auxiliary Space: O(1)

 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!