• nums.length is even.
• nums[i] != nums[i + 1] for all i % 2 == 0.

Note that an empty array is considered beautiful.

You can delete any number of elements from nums. When you delete an element, all the elements to the right of the deleted element will be shifted one unit to the left to fill the gap created and all the elements to the left of the deleted element will remain unchanged.

Return the minimum number of elements to delete from nums to make it beautiful.

Example 1:

Input: nums = [1,1,2,3,5]
Output: 1
Explanation: You can delete either nums[0] or nums[1] to make nums = [1,2,3,5] which is beautiful. It can be proven you need at least 1 deletion to make nums beautiful.

Example 2:

Input: nums = [1,1,2,2,3,3]
Output: 2
Explanation: You can delete nums[0] and nums[5] to make nums = [1,2,2,3] which is beautiful. It can be proven you need at least 2 deletions to make nums beautiful.

Constraints:

• 1 <= nums.length <= 105
• 0 <= nums[i] <= 105

Solution: Greedy + Two Pointers

If two consecutive numbers are the same, we must remove one. We don’t need to actually remove elements from array, just need to track how many elements have been removed so far.

i is the position in the original array, ans is the number of elements been removed. i – ans is the position in the updated array.

ans += nums[i – ans] == nums[i – ans + 1]

Remove the last element (just increase answer by 1) if the length of the new array is odd.

Time complexity: O(n)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int minDeletion(vector<int>& nums) {
    const int n = nums.size();
    int ans = 0;
    for (int i = 0; i - ans + 1 < n; i += 2)
      ans += nums[i - ans] == nums[i - ans + 1];
    ans += (n - ans) & 1;
    return ans;
  }
};

The post 花花酱 LeetCode 2216. Minimum Deletions to Make Array Beautiful appeared first on Huahua's Tech Road.

Given an array nums and a value val, remove all instances of that value in-place and return the new length.

Do not allocate extra space for another array, you must do this by modifying the input array in-place with O(1) extra memory.

The order of elements can be changed. It doesn’t matter what you leave beyond the new length.

Example 1:

Given nums = [3,2,2,3], val = 3,

Your function should return length = 2, with the first two elements of nums being 2.

It doesn't matter what you leave beyond the returned length.

Example 2:

Given nums = [0,1,2,2,3,0,4,2], val = 2,

Your function should return length = 5, with the first five elements of nums containing 0, 1, 3, 0, and 4. Note that the order of those five elements can be arbitrary. It doesn't matter what values are set beyond the returned length.

Clarification:

Confused why the returned value is an integer but your answer is an array?

Note that the input array is passed in by reference, which means modification to the input array will be known to the caller as well.

Internally you can think of this:

// nums is passed in by reference. (i.e., without making a copy)
int len = removeElement(nums, val);

// any modification to nums in your function would be known by the caller.
// using the length returned by your function, it prints the first len elements.
for (int i = 0; i < len; i++) {
    print(nums[i]);
}

Solution:

Time complexity: O(n)

Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int removeElement(vector<int>& nums, int val) {
    int len = 0;
    for (int num : nums)
      if (num != val) nums[len++] = num;
    return len;
  }
};

class Solution:
  def removeElement(self, nums, val):
    l = 0
    for num in nums:
      if num != val:
        nums[l], l = num, l + 1        
    return l

Related Problems

• 花花酱 LeetCode 26. Remove Duplicates from Sorted Array

The post 花花酱 LeetCode 27. Remove Element appeared first on Huahua's Tech Road.

Given a sorted array nums, remove the duplicates in-place such that each element appear only once and return the new length.

Do not allocate extra space for another array, you must do this by modifying the input array in-place with O(1) extra memory.

Example 1:

Given nums = [1,1,2],

Your function should return length = 2, with the first two elements of nums being 1 and 2 respectively. It doesn't matter what you leave beyond the returned length.

Example 2:

Given nums = [0,0,1,1,1,2,2,3,3,4],

Your function should return length = 5, with the first five elements of nums being modified to 0, 1, 2, 3, and 4 respectively. It doesn't matter what values are set beyond the returned length.

Clarification:

Confused why the returned value is an integer but your answer is an array?

Note that the input array is passed in by reference, which means modification to the input array will be known to the caller as well.

Internally you can think of this:

// nums is passed in by reference. (i.e., without making a copy)
int len = removeDuplicates(nums);

// any modification to nums in your function would be known by the caller.
// using the length returned by your function, it prints the first len elements.
for (int i = 0; i < len; i++) {
    print(nums[i]);
}

Solution:

Time complexity: O(n)

Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int removeDuplicates(vector<int>& nums) {
    const int n = nums.size();
    if (n <= 1) return n;        
    int ans = 0;
    int i = 0;
    while (i < n) {
      nums[ans++] = nums[i];
      int j = i + 1;
      while (j < n && nums[j] == nums[j - 1]) ++j;
      i = j;
    }
    return ans;
  }
};

The post 花花酱 LeetCode 26. Remove Duplicates from Sorted Array appeared first on Huahua's Tech Road.

Problem:

https://leetcode.com/problems/remove-linked-list-elements/description/

Remove all elements from a linked list of integers that have value val.

Example
Given: 1 –> 2 –> 6 –> 3 –> 4 –> 5 –> 6, val = 6
Return: 1 –> 2 –> 3 –> 4 –> 5

Idea:

Use a dummy head

Solution:

Time complexity: O(n)

Space complexity: O(1)

C++

// Author: Huahua
// Running time: 30 ms
class Solution {
public:
  ListNode* removeElements(ListNode* head, int val) {
    ListNode dummy{0};
    dummy.next = head;
    ListNode* curr = &dummy;
    while (curr) {
      ListNode* next = curr->next;
      while (next && next->val == val) next = next->next;
      curr->next = next;
      curr = next;
    }
    return dummy.next;
  }
};

The post 花花酱 LeetCode 203. Remove Linked List Elements appeared first on Huahua's Tech Road.