Is there any method/algorithm to reduce time complexity of below code?

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        l=0
        for i in range(len(nums)):
            if nums[i]==val:
                nums[i]=1000
                l+=1
        nums.sort()
        return len(nums)-l

problem:
Given an integer array nums and an integer val, remove all occurrences of val in nums in-place. The order of the elements may be changed. Then return the number of elements in nums which are not equal to val.

Consider the number of elements in nums which are not equal to val be k, to get accepted, you need to do the following things:

Change the array nums such that the first k elements of nums contain the elements which are not equal to val. The remaining elements of nums are not important as well as the size of nums.
Return k.

CONSTRAINTS:
0 \<= nums.length \<= 100
0 \<= nums\[i\] \<= 50
0 \<= val \<= 100

I tried to solve this using constraints,setting val=1000 and then sorting list and returning the number k.Is there any way to reduce time complexity of above code?

This can be solved in linear time by keeping track of an index at which a value that is different from val should be written, and only incrementing that index when a value different from val occurs:

def removeElement(nums, val):
    write_index = 0
    for v in nums:
        if v != val:
            nums[write_index] = v
            write_index += 1
    return write_index

so that:

nums = [1, 2, 1, 0, 4]
print(removeElement(nums, 1))
print(nums)

outputs:

3
[2, 0, 4, 0, 4]

Note that as the question states, only the first 3 items of the output are important, so the 0 and 4 at the end of the output list can be ignored.

@blhsing has you covered with an elegant in-place solution. A bit more brutish would be slice-assignment, yet more concise, still linear, in-place, and according to spec (size of nums doesn't matter):

def removeElement(nums, val):
    nums[:] = filter(val.__ne__, nums)
    return len(nums)

You could use use some other utils to work around the dunder while still staying in the functional paradigm:

from functools import partial
from operator import ne

def removeElement(nums, val):
    nums[:] = filter(partial(ne, val), nums)
    return len(nums)

Alternatively, in order to avoid the explicit use of a dunder method, this works with any iterable on the right hand side, so you can use a comprehension or generator expression there:

def removeElement(nums, val):
    nums[:] = (n for n in nums if n != val) 
    return len(nums)

Knowing this pattern is certainly more universally useful and educational than the former code-golfing approach.

You can proceed backward through the list end delete positions as you find matching numbers:

def removeElement(nums,val):
    for i in range(len(nums)-1,-1,-1):
        if nums[i] == val:
            del nums[i]
    return len(nums)

output:

A = [2, 1, 6, 5, 5, 6, 7, 7, 4, 3]

print(removeElement(A,6))
print(A)

8
[2, 1, 5, 5, 7, 7, 4, 3]

Deleting items from a list isn't really an O(1) operation so this would not be a linear time solution. To work around that, you could just swap the items to remove with the ending positions:

def removeElement(nums,val):
    k = len(nums)
    for i in range(k-1,-1,-1):
        if nums[i] == val:
            k -= 1
            nums[i],nums[k] = nums[k],nums[i]
    return k

output:

A = [2, 1, 6, 5, 5, 6, 7, 7, 4, 3]

print(removeElement(A,6))
print(A)
8
[2, 1, 4, 5, 5, 3, 7, 7, 6, 6]

If you wan to return the number of elements in nums which are not equal to val, you don't need to transform the list you are using. The code you have shown is using a list in a local scope that never get's returned. If you need to modify that list in a global scope, you need to return it. Following your code and description, a better way would be...

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

This code will return the number of values that are different from val inside the list. If you want to return the list to use it in outter scope.

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        non_equal_list = [num for num in nums if num != val]
        non_equal_list.sort()
        return len(non_equal_list), non_equal_list