# Solving Leetcode Interviews in Seconds with AI: Furthest Point From Origin


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "2833" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> You are given a string moves of length n consisting only of characters 'L', 'R', and '_'. The string represents your movement on a number line starting from the origin 0. In the ith move, you can choose one of the following directions:  move to the left if moves[i] = 'L' or moves[i] = '_' move to the right if moves[i] = 'R' or moves[i] = '_'  Return the distance from the origin of the furthest point you can get to after n moves.   Example 1:  Input: moves = "L_RL__R" Output: 3 Explanation: The furthest point we can reach from the origin 0 is point -3 through the following sequence of moves "LLRLLLR".  Example 2:  Input: moves = "_R__LL_" Output: 5 Explanation: The furthest point we can reach from the origin 0 is point -5 through the following sequence of moves "LRLLLLL".  Example 3:  Input: moves = "_______" Output: 7 Explanation: The furthest point we can reach from the origin 0 is point 7 through the following sequence of moves "RRRRRRR".    Constraints:  1 <= moves.length == n <= 50 moves consists only of characters 'L', 'R' and '_'.  

	# Explanation
	Here's the breakdown of the solution:

*   **Maximize the distance:** The goal is to maximize the absolute distance from the origin. This means we want to go as far to the left or as far to the right as possible.
*   **Greedy approach:** A greedy strategy will be employed. Count the number of 'R' moves, 'L' moves, and '_' moves. 'R' moves contribute positively to the distance, 'L' moves contribute negatively, and '_' moves can be used either to maximize the positive distance (treat as 'R') or to maximize the negative distance (treat as 'L').
*   **Calculate both extremes:** Calculate the maximum possible distance to the right (by treating all '_' as 'R') and the maximum possible distance to the left (by treating all '_' as 'L'). Return the absolute value of the maximum of these two extremes.

*   **Runtime Complexity:** O(n), where n is the length of the `moves` string. Storage Complexity: O(1).

	
	# Code
	```python
	def furthestPoint(moves: str) -> int:
    """
    Calculates the maximum distance from the origin after a series of moves.

    Args:
        moves: A string representing the moves, consisting of 'L', 'R', and '_'.

    Returns:
        The maximum distance from the origin.
    """

    r_count = 0
    l_count = 0
    underscore_count = 0

    for move in moves:
        if move == 'R':
            r_count += 1
        elif move == 'L':
            l_count += 1
        else:
            underscore_count += 1

    max_right = r_count + underscore_count - l_count
    max_left = r_count - l_count - underscore_count

    return max(abs(max_right), abs(max_left))
	```