Leetcode with dani

class Solution:
    def canJump(self, nums: List[int]) -> bool:
        maxReach = 0
        for i, jump in enumerate(nums):
            if i > maxReach:
                return False
            maxReach = max(maxReach, i + jump)
            if maxReach >= len(nums) - 1:
                return True
        return False

class Solution:
    def canJump(self, nums: List[int]) -> bool:
        last = len(nums)-1
        for i in range(len(nums)-2,-1,-1):
            if nums[i]+i >= last:
                last = i
        return nums[0] >= last

nums = [1, 2, 3]

Output:

2

Explanation:
Only two moves are needed (each move increments or decrements one element):

• Step 1: [1, 2, 3] => [2, 2, 3]

• Step 2: [2, 2, 3] => [2, 2, 2]

---

Example 2:

Input:

nums = [1, 10, 2, 9]

Output:

16

▎Constraints

•  n = nums.length 

•  1 ≤ n ≤ 10⁵ 

•  -10⁹ ≤ nums[i] ≤ 10⁹ 

▎Explanation

To minimize the number of moves, you want to choose a target value that minimizes the sum of the absolute differences between each element and that target. It can be proven that the best target value is the median of the array.

If the array is sorted, the median minimizes the sum of absolute deviations. Thus, the minimum number of moves is given by:

moves = ∑ᵢ₌₀ⁿ⁻¹ | nums[i] - median |

def minMoves2(nums):
    # Sort the array to find the median.
    nums.sort()
    n = len(nums)
    median = nums[n // 2]  # Get the median value
    
    # Compute the total moves as the sum of absolute differences.
    moves = sum(abs(num - median) for num in nums)
    return moves

# Example usage:
nums1 = [1, 2, 3]
print(minMoves2(nums1))  # Output: 2

nums2 = [1, 10, 2, 9]
print(minMoves2(nums2))  # Output: 16

nums = [1, 2, 3]

3

nums = [1, 1, 1]

0

moves = ∑ᵢ₌₀ⁿ⁻¹ (nums[i] - minVal)

def minMoves(nums):
    # Find the minimum value in the array.
    minVal = min(nums)
    # Compute the total number of moves required.
    moves = sum(num - minVal for num in nums)
    return moves

# Example usage:
nums = [1, 2, 3]
print(minMoves(nums))  # Output: 3

nums = [3, 1, 6, 8]
queries = [1, 5]

Output:

[14, 10]

Explanation:

• For the first query (q = 1):

    • Decrease nums[0] 2 times: from 3 to 1.

    • Decrease nums[2] 5 times: from 6 to 1.

    • Decrease nums[3] 7 times: from 8 to 1.

    • Total operations = 2 + 5 + 7 = 14.

• For the second query (q = 5):

    • Increase nums[0] 2 times: from 3 to 5.

    • Increase nums[1] 4 times: from 1 to 5.

    • Decrease nums[2] 1 time: from 6 to 5.

    • Decrease nums[3] 3 times: from 8 to 5.

    • Total operations = 2 + 4 + 1 + 3 = 10.

---

Example 2:

Input:

nums = [2, 9, 6, 3]
queries = [10]

Output:

[20]

Explanation:

• Increase each element in the array to 10:

    • Operations for each element: 

        • 8 (from 2 to 10),

        • 1 (from 9 to 10),

        • 4 (from 6 to 10),

        • 7 (from 3 to 10).

    • Total operations = 8 + 1 + 4 + 7 = 20.

▎Constraints

• n = nums.length

• m = queries.length

• 1 ≤ n, m ≤ 10⁵

• 1 ≤ nums[i], queries[i] ≤ 10⁹

---

class Solution:
    def middleNode(self, head: Optional[ListNode]) -> Optional[ListNode]:
        p1 = head
        p2 = head
        while p2 and p2.next:
            p1=p1.next
            p2 = p2.next.next
        return p1

class Solution:
    def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
        dummy = ListNode(-1,head)
        p1 = dummy
        p2 = dummy.next
        count = 0
        while p2:
            if count <n:
                p2 = p2.next
                count+=1
            else:
                p1 = p1.next
                p2 = p2.next
        if p1:
            p1.next = p1.next.next
        return dummy.next

class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        dummy = ListNode(0,head)
        p1 = dummy
        p2 = dummy.next
        while p2:
            if p2.val==val:
                p1.next = p2.next
                p2  = p2.next
            else:
                p1 = p1.next
                p2 = p2.next
        return dummy.next