← Static tasks

26. Remove Duplicates from Sorted Array

leetcode easy

#array#csharp#easy#leetcode#sort

Task

Учитывая целочисленный массив чисел, отсортированный в неубывающем порядке, удалите дубликаты на месте так, чтобы каждый уникальный элемент появлялся только один раз. Относительный порядок элементов должен оставаться неизменным. Затем верните количество уникальных элементов в числах.

Считайте, что количество уникальных элементов чисел равно k. Чтобы вас приняли, вам нужно сделать следующее:

Измените массив nums так, чтобы первые k элементов nums содержали уникальные элементы в том порядке, в котором они присутствовали в nums изначально. Остальные элементы nums не важны, как и размер nums.
Вернуть К.

C# solution

matched/original
public class Solution {
    public int RemoveDuplicates(int[] nums) {
        if (nums == null || nums.Length == 0)
            return 0;
        
        int i = 0;
        
        for (int j = 0; j < nums.Length; j++)
        {
            nums[i++] = nums[j];
            
            while (j < nums.Length - 1 && nums[j] == nums[j + 1])
                j++;
        }
        
        return i;
    }
}

C++ solution

auto-draft, review before submit
#include <bits/stdc++.h>
using namespace std;

// Auto-generated C++ draft from the C# solution. Review containers, LINQ and helper types before submit.
class Solution {
public:
    public int RemoveDuplicates(vector<int>& nums) {
        if (nums == null || nums.size() == 0)
            return 0;
        
        int i = 0;
        
        for (int j = 0; j < nums.size(); j++)
        {
            nums[i++] = nums[j];
            
            while (j < nums.size() - 1 && nums[j] == nums[j + 1])
                j++;
        }
        
        return i;
    }
}

Java solution

matched/original
class Solution {
    public int removeDuplicates(int[] nums) {
        int n = nums.length;
        if(n<=1){return n;}
        
        int left = 0; //everything to the left of left(inclusive) is good
        int right = 1;//the current element we are processing
        
        while(right<=n-1){
            if(nums[right] == nums[left]){
                right++;
            }
            else{
                nums[left+1] = nums[right];
                left++;
                right++;
            }
        }
        
        return left+1;
    }
}

JavaScript solution

matched/original
/**
 * @param {number[]} nums
 * @return {number}
 */
var removeDuplicates = function (nums) {
    let k = 0;
    for (const x of nums) {
        if (k === 0 || x !== nums[k - 1]) {
            nums[k++] = x;
        }
    }
    return k;
};

Python solution

matched/original
from typing import List 
 
class Solution: 
    def removeDuplicates(self, nums: List[int]) -> int: 
        i = 0  
        while i < len(nums) - 1:   
            if nums[i] == nums[i + 1]: 
                print(nums[i + 1])   
                nums.pop(i + 1)   
            else: 
                i += 1   
 
        return len(nums)

Go solution

matched/original
func removeDuplicates(nums []int) int {
    if len(nums) <= 1 {
        return len(nums)
    }
    i, j := 0, 1
    for j < len(nums) {
        if nums[i] == nums[j] {
            j++
        } else {
            nums[i+1] = nums[j]
            i++
            j++
        }
    }
    return i+1
}

Explanation

Данный код представляет собой класс `Solution`, в котором содержится метод `RemoveDuplicates`, предназначенный для удаления повторяющихся элементов в упорядоченном массиве `nums`. Вот пояснение к данному методу:

1. Метод `RemoveDuplicates` принимает входной массив `nums` и возвращает целое число, представляющее количество уникальных элементов в массиве после удаления повторяющихся. Если входной массив `nums` равен `null` или его длина равна 0, метод возвращает 0, так как в этом случае массив уже не содержит уникальных элементов и нечего удалять.

2. В методе создается переменная `i`, которая будет использоваться для отслеживания уникальных элементов и их позиций в массиве после удаления повторяющихся элементов.

3. Затем происходит итерация по всем элементам массива с использованием индекса `j`. В каждой итерации элемент с индексом `j` копируется в соответствующую позицию `i`, затем индекс `i` увеличивается. Здесь элементы копируются в массив без пропуска повторяющихся элементов.

4. В теле цикла while проверяется, если текущий элемент `nums[j]` равен следующему элементу `nums[j + 1]` и если `j` не указывает на последний элемент массива, то индекс `j` увеличивается. Это позволяет пропустить все повторяющиеся элементы и перейти к следующему уникальному элементу.

5. В конце метод возвращает значение `i` после завершения всех итераций, представляющее количество уникальных элементов, которые остались в массиве после удаления повторяющихся. Таким образом, код эффективно удаляет дубликаты из упорядоченного массива, сохраняя порядок оставшихся уникальных элементов.