Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Remove all negatives from the given Array

  • Difficulty Level : Basic
  • Last Updated : 28 Feb, 2022

Given an array arr[] of size N, the task is to remove all negative elements from this array.

Examples:

Input: arr[] = {3, -4}
Output: {3}
Explanation: The only negative element of the array is -4.

Input: arr[] = {1, -3, 2}
Output: {1, 2}

 

Approach 1: The given problem can be solved using the following steps :

  1. Create a vector newArr to store only positive elements.
  2. Now traverse the array arr, and push positive element in newArr.
  3. Return newArr as the answer.

Below is the implementation of the above approach:

C++




// C++ code for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to remove the negative elements
void removeNegative(vector<int>& arr)
{
    vector<int> newArr;
 
    for (auto x : arr) {
        if (x >= 0) {
            newArr.push_back(x);
        }
    }
 
    for (auto x : newArr) {
        cout << x << ' ';
    }
}
 
// Driver Code
int main()
{
    vector<int> arr = { 1, -3, 2 };
    removeNegative(arr);
    return 0;
}
Java



// Java code for the above approach
import java.util.ArrayList;
 
class GFG {
 
  // Function to remove the negative elements
  static void removeNegative(int[] arr) {
    ArrayList<Integer> newArr = new ArrayList<Integer>();
 
    for (int x : arr) {
      if (x >= 0) {
        newArr.add(x);
      }
    }
 
    for (int x : newArr) {
      System.out.print(x + " ");
    }
  }
 
  // Driver Code
  public static void main(String args[]) {
    int[] arr = { 1, -3, 2 };
    removeNegative(arr);
  }
}
 
// This code is contributed by saurabh_jaiswal.
Python3



# Python code for the above approach
 
# Function to remove the negative elements
def removeNegative(arr):
    newArr = []
 
    for x in range(0, len(arr)):
        if (arr[x] >= 0):
            newArr.append(arr[x])
 
    for x in range(0, len(newArr)):
        print(newArr[x], end=' ')
 
# Driver Code
arr = [1, -3, 2]
removeNegative(arr)
 
# This code is contributed by Taranpreet
C#



// C# code for the above approach
using System;
using System.Collections;
 
class GFG {
 
  // Function to remove the negative elements
  static void removeNegative(int[] arr) {
    ArrayList newArr = new ArrayList();
 
    foreach (int x in arr) {
      if (x >= 0) {
        newArr.Add(x);
      }
    }
 
    foreach (int x in newArr) {
      Console.Write(x + " ");
    }
  }
 
  // Driver Code
  public static void Main() {
    int[] arr = { 1, -3, 2 };
    removeNegative(arr);
  }
}
 
// This code is contributed by Samim Hossain Mondal.
Javascript



<script>
        // JavaScript code for the above approach
 
        // Function to remove the negative elements
        function removeNegative(arr)
        {
            let newArr = [];
 
            for (let x of arr) {
                if (x >= 0) {
                    newArr.push(x);
                }
            }
 
            for (let x of newArr) {
                document.write(x + " ")
            }
        }
 
        // Driver Code
        let arr = [1, -3, 2];
        removeNegative(arr);
 
    // This code is contributed by Potta Lokesh
    </script>
 
 
Output
1 2 
 
Time Complexity: O(N)
Auxiliary Space: O(N)
 
Approach 2(For Java): Java’s lambda function removeIf() can be used as well to remove negative elements.
 
Java



// Java code for above approach
import java.util.*;
 
public class Solution {
 
    // Function to remove the
    // negative elements from the array
    public static ArrayList<Integer>
    remNeg(ArrayList<Integer> arr)
    {
        arr.removeIf(n -> n < 0);
        return arr;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        ArrayList<Integer> arr
            = new ArrayList<Integer>(
                Arrays.asList(1, -3, 2));
 
        arr = remNeg(arr);
        for (int i = 0; i < arr.size(); i++) {
            System.out.print(arr.get(i) + " ");
        }
    }
}
C#



// C# code for above approach
using System;
using System.Collections.Generic;
 
public class Solution {
 
  static bool isEven(int i)
  {
    return i < 0;
  }
 
  // Function to remove the
  // negative elements from the array
  static List<int>
    remNeg(List<int> arr)
  {
    arr.RemoveAll(isEven);
    return arr;
  }
 
  // Driver Code
  public static void Main(String[] args)
  {
    List<int> arr
      = new List<int>(new int[]{1, -3, 2});
 
    arr = remNeg(arr);
    for (int i = 0; i < arr.Count; i++) {
      Console.Write(arr[i] + " ");
    }
  }
}
 
// This code is contributed by shikhasingrajput
Javascript



<script>
// javascript code for above approach
 
    // Function to remove the
    // negative elements from the array
     function remNeg( arr) {
     for (var i = 0; i < arr.length; i++) {
            if(arr[i] < 0){
                arr.splice(i,1);
            }
        }
         
        return arr;
    }
 
    // Driver Code
        var arr = [1, -3, 2];
 
        arr = remNeg(arr);
        for (i = 0; i < arr.length; i++) {
            document.write(arr[i] + " ");
        }
 
// This code is contributed by Rajput-Ji
</script>
 
 
Output
1 2 
 
Time Complexity: O(N)
Auxiliary Space: O(1)
 

My Personal Notes
arrow_drop_up
Next

Find maximum average subarray of k length
Recommended Articles
Page :
Find subarray with given sum with negatives allowed in constant space
18, Sep 19
Index Mapping (or Trivial Hashing) with negatives allowed
27, Oct 17
Maximize the difference between two subsets of a set with negatives
16, Dec 18
Remove all the prime numbers from the given array
23, Dec 19
Remove all the fibonacci numbers from the given array
08, Apr 20
Minimum number of coins needed to remove all the elements of the array based on given rules
10, Sep 21
Minimum replacements in given Array to remove all strictly peak elements
04, Mar 22
Remove all occurrences of a word from a given string using Z-algorithm
29, Jan 21
Remove all occurrences of any element for maximum array sum
20, Apr 19
Remove all 1s from the adjacent left of 0s in a Binary Array
04, Apr 20
For all Array elements find Product of Sum of all smaller and Sum of all greater elements
06, Apr 22
Remove an element to maximize the GCD of the given array
08, Jul 19
Remove an element to minimize the LCM of the given array
13, Nov 19
Count of possible rotations of given Array to remove largest element from first half
16, Mar 22
Find the last player to be able to remove a string from an array which is not already removed from other array
03, Feb 21
Remove array elements to reduce frequency of each array element to at most K
25, Dec 20
Subsequence pair from given Array having all unique and all same elements respectively
30, Apr 20
Two player game in which a player can remove all occurrences of a number
21, May 20
Different Ways to Remove all the Digits from String in Java
05, Sep 20
C++ Program To Recursively Remove All Adjacent Duplicates
10, Nov 21
Java Program To Recursively Remove All Adjacent Duplicates
10, Oct 21
Python Program To Recursively Remove All Adjacent Duplicates
10, Oct 21
Recursively remove all adjacent duplicates
10, Oct 13
Print all Strings from array A[] having all strings from array B[] as subsequence
16, Jul 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
smiti139
@smiti139
Vote for difficulty
Current difficulty :
Basic





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!