# Print direction of moves such that you stay within the [-k, +k] boundary

• Difficulty Level : Easy
• Last Updated : 27 Oct, 2021

Given an array arr[] of N positive integers and an integer K. It is given that you start at position 0 and you can move to left or right by a[i] positions starting from arr. The task is to print direction of moves in such a way that you can complete N steps without exceeding the [-K, +K] boundary by moving right or left. In case you cannot perform steps, print -1. In case of multiple answers, print any one.
Examples:

Input: arr[] = {40, 50, 60, 40}, K = 120
Output:
Right
Right
Left
Right
Explanation :
Since N = 4 (Number of elements in the array),
we need to make 4 moves from arr such that
value does not go out of [-120, 120]
Move 1: Position = 0 + 40 = 40
Move 2: Position = 40 + 50 = 90
Move 3: Position = 90 – 60 = 30
Move 4: Position = 30 + 50 = 80
Input: arr[] = {40, 50, 60, 40}, K = 20
Output: -1

Approach: The following steps can be followed to solve the above problem:

• Initialize position to 0 in the beginning.
• Start traversing all the array elements,
• If a[i] + position does not exceed the left and the right boundary, then the move will be “Right”.
• If position – a[i] does not exceed the left and the right boundary, then the move will be “Left”.
• If at any stage both the condition fail then print -1.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Function to print steps such that``// they do not cross the boundary``void` `printSteps(``int` `a[], ``int` `n, ``int` `k)``{` `    ``// To store the resultant string``    ``string res = ``""``;` `    ``// Initially at zero-th position``    ``int` `position = 0;``    ``int` `steps = 1;` `    ``// Iterate for every i-th move``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// Check for right move condition``        ``if` `(position + a[i] <= k``            ``&& position + a[i] >= (-k)) {``            ``position += a[i];``            ``res += ``"Right\n"``;``        ``}` `        ``// Check for left move condition``        ``else` `if` `(position - a[i] >= -k``                 ``&& position - a[i] <= k) {``            ``position -= a[i];``            ``res += ``"Left\n"``;``        ``}` `        ``// No move is possible``        ``else` `{``            ``cout << -1;``            ``return``;``        ``}``    ``}` `    ``// Print the steps``    ``cout << res;``}` `// Driver code``int` `main()``{``    ``int` `a[] = { 40, 50, 60, 40 };``    ``int` `n = ``sizeof``(a) / ``sizeof``(a);``    ``int` `k = 120;``    ``printSteps(a, n, k);` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``class` `GFG``{``    ` `// Function to print steps such that``// they do not cross the boundary``static` `void` `printSteps(``int` `[]a, ``int` `n, ``int` `k)``{` `    ``// To store the resultant string``    ``String res = ``""``;` `    ``// Initially at zero-th position``    ``int` `position = ``0``;``    ``//int steps = 1;` `    ``// Iterate for every i-th move``    ``for` `(``int` `i = ``0``; i < n; i++)``    ``{` `        ``// Check for right move condition``        ``if` `(position + a[i] <= k``            ``&& position + a[i] >= (-k))``        ``{``            ``position += a[i];``            ``res += ``"Right\n"``;``        ``}` `        ``// Check for left move condition``        ``else` `if` `(position - a[i] >= -k``                ``&& position - a[i] <= k)``        ``{``            ``position -= a[i];``            ``res += ``"Left\n"``;``        ``}` `        ``// No move is possible``        ``else``        ``{``            ``System.out.println(-``1``);``            ``return``;``        ``}``    ``}` `    ``// Print the steps``    ``System.out.println(res);``}` `// Driver code``public` `static` `void` `main (String[] args)``{` `    ``int` `[]a = { ``40``, ``50``, ``60``, ``40` `};``    ``int` `n = a.length;``    ``int` `k = ``120``;``    ``printSteps(a, n, k);``}``}` `// This code is contributed by mits`

## Python3

 `# Python3 implementation of the approach` `# Function to print steps such that``# they do not cross the boundary``def` `printSteps(a, n, k):` `    ``# To store the resultant string``    ``res ``=` `""` `    ``# Initially at zero-th position``    ``position ``=` `0``    ``steps ``=` `1` `    ``# Iterate for every i-th move``    ``for` `i ``in` `range``(n):` `        ``# Check for right move condition``        ``if` `(position ``+` `a[i] <``=` `k ``and``            ``position ``+` `a[i] >``=` `-``k):``            ``position ``+``=` `a[i]``            ``res ``+``=` `"Right\n"` `        ``# Check for left move condition``        ``elif` `(position``-``a[i] >``=` `-``k ``and``              ``position``-``a[i] <``=` `k):``            ``position ``-``=` `a[i]``            ``res ``+``=` `"Left\n"` `        ``# No move is possible``        ``else``:``            ``print``(``-``1``)``            ``return``    ``print``(res)` `# Driver code``a ``=` `[``40``, ``50``, ``60``, ``40``]``n ``=` `len``(a)``k ``=` `120``printSteps(a, n, k)` `# This code is contributed by Shrikant13`

## C#

 `// C# implementation of the approach``using` `System;` `class` `GFG``{``    ` `// Function to print steps such that``// they do not cross the boundary``static` `void` `printSteps(``int` `[]a, ``int` `n, ``int` `k)``{` `    ``// To store the resultant string``    ``String res = ``""``;` `    ``// Initially at zero-th position``    ``int` `position = 0;``    ``//int steps = 1;` `    ``// Iterate for every i-th move``    ``for` `(``int` `i = 0; i < n; i++)``    ``{` `        ``// Check for right move condition``        ``if` `(position + a[i] <= k``            ``&& position + a[i] >= (-k))``        ``{``            ``position += a[i];``            ``res += ``"Right\n"``;``        ``}` `        ``// Check for left move condition``        ``else` `if` `(position - a[i] >= -k``                ``&& position - a[i] <= k)``        ``{``            ``position -= a[i];``            ``res += ``"Left\n"``;``        ``}` `        ``// No move is possible``        ``else``        ``{``            ``Console.WriteLine(-1);``            ``return``;``        ``}``    ``}` `    ``// Print the steps``    ``Console.Write(res);``}` `// Driver code``static` `void` `Main()``{``    ``int` `[]a = { 40, 50, 60, 40 };``    ``int` `n = a.Length;``    ``int` `k = 120;``    ``printSteps(a, n, k);``}``}` `// This code is contributed by mits`

## PHP

 `= (-``\$k``))``            ``{``            ``\$position` `+= ``\$a``[``\$i``];``            ``\$res` `.= ``"Right\n"``;``        ``}` `        ``// Check for left move condition``        ``else` `if` `(``\$position` `- ``\$a``[``\$i``] >= -``\$k` `&&``                 ``\$position` `- ``\$a``[``\$i``] <= ``\$k``)``        ``{``            ``\$position` `-= ``\$a``[``\$i``];``            ``\$res` `.= ``"Left\n"``;``        ``}` `        ``// No move is possible``        ``else``        ``{``            ``echo` `-1;``            ``return``;``        ``}``    ``}` `    ``// Print the steps``    ``echo` `\$res``;``}` `// Driver code``\$a` `= ``array``( 40, 50, 60, 40 );``\$n` `= ``count``(``\$a``);``\$k` `= 120;``printSteps(``\$a``, ``\$n``, ``\$k``);` `// This code is contributed by mits``?>`

## Javascript

 ``
Output:
```Right
Right
Left
Right```

My Personal Notes arrow_drop_up