O problema é o seguinte:

Dado um array inteiro nums e um inteiro val, remova todas as ocorrências de val em nums no local. A ordem dos elementos pode ser alterada. Em seguida, retorne o número de elementos em nums que não são iguais a val.

Considere o número de elementos em nums que não são iguais a val be k, para ser aceito, você precisa fazer o seguinte:

• Altere o array nums de forma que os primeiros k elementos de nums contenham os elementos que não são iguais a val. Os elementos restantes de nums não são importantes, assim como o tamanho de nums.
• Retornar k.

Juiz Personalizado:

O juiz testará sua solução com o seguinte código:

int[] nums = [...]; // Input array
int val = ...; // Value to remove
int[] expectedNums = [...]; // The expected answer with correct length.
                            // It is sorted with no values equaling val.

int k = removeElement(nums, val); // Calls your implementation

assert k == expectedNums.length;
sort(nums, 0, k); // Sort the first k elements of nums
for (int i = 0; i 



Se todas as afirmações forem aprovadas, sua solução será aceita.

Exemplo 1:


Input: nums = [3,2,2,3], val = 3
Output: 2, nums = [2,2,_,_]
Explanation: Your function should return k = 2, with the first two elements of nums being 2.
It does not matter what you leave beyond the returned k (hence they are underscores).




Exemplo 2:


Input: nums = [0,1,2,2,3,0,4,2], val = 2
Output: 5, nums = [0,1,4,0,3,_,_,_]
Explanation: Your function should return k = 5, with the first five elements of nums containing 0, 0, 1, 3, and 4.
Note that the five elements can be returned in any order.
It does not matter what you leave beyond the returned k (hence they are underscores).




Aqui está como resolvi isso:

Para resolver esse problema, usei duas estratégias principais:


Substituição no local: Em vez de criar um novo array para armazenar os elementos que não são iguais a val, use o mesmo array nums para substituir os elementos que precisam ser removidos.

Técnica de dois ponteiros: Um ponteiro (i) itera através de cada elemento na matriz e outro ponteiro (k) rastreia a posição onde o próximo elemento não-val deve ser colocado.

• Primeiro, inicialize um ponteiro k e defina-o como 0. Isso rastreará a posição onde o próximo elemento não-val deve ser colocado.

class Solution:
def removeElement(self, nums: List[int], val: int) -> int:       
    k = 0

• Iterar através da matriz nums.
• Verifique se o elemento atual nums[i] é diferente de val para acompanhar k.
• Se for, mova o elemento nums[i] para a k-ésima posição e aumente k em 1 para atualizar a posição do próximo elemento não-val.

for i in range(len(nums)):
    if nums[i] != val:
        nums[k] = nums[i]
        k  = 1

• Retorna k, que é o número de elementos diferente de val.

return k

Aqui está a solução completa:

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        k = 0
        for i in range(len(nums)):
            if nums[i] != val:
                nums[k] = nums[i]
                k  = 1
        return k