Find Duplicates of array using bit array
Last Updated :
23 Feb, 2023
You have an array of N numbers, where N is at most 32,000. The array may have duplicate entries and you do not know what N is. With only 4 Kilobytes of memory available, how would print all duplicate elements in the array ?.
Examples:
Input : arr[] = {1, 5, 1, 10, 12, 10}
Output : 1 10
1 and 10 appear more than once in given
array.
Input : arr[] = {50, 40, 50}
Output : 50
Asked In: Amazon
We have 4 Kilobytes of memory which means we can address up to 8 * 4 * 210 bits. Note that 32 * 210 bits is greater than 32000. We can create a bit with 32000 bits, where each bit represents one integer. Note: If you need to create a bit with more than 32000 bits, then you can create easily more and more than 32000; Using this bit vector, we can then iterate through the array, flagging each element v by setting bit v to 1. When we come across a duplicate element, we print it. Below is the implementation of the idea.
Implementation:
C++
// C++ program to print all Duplicates in array
#include <bits/stdc++.h>
using namespace std;
// A class to represent an array of bits using
// array of integers
class BitArray
{
int *arr;
public:
BitArray() {}
// Constructor
BitArray(int n)
{
// Divide by 32. To store n bits, we need
// n/32 + 1 integers (Assuming int is stored
// using 32 bits)
arr = new int[(n >> 5) + 1];
}
// Get value of a bit at given position
bool get(int pos)
{
// Divide by 32 to find position of
// integer.
int index = (pos >> 5);
// Now find bit number in arr[index]
int bitNo = (pos & 0x1F);
// Find value of given bit number in
// arr[index]
return (arr[index] & (1 << bitNo)) != 0;
}
// Sets a bit at given position
void set(int pos)
{
// Find index of bit position
int index = (pos >> 5);
// Set bit number in arr[index]
int bitNo = (pos & 0x1F);
arr[index] |= (1 << bitNo);
}
// Main function to print all Duplicates
void checkDuplicates(int arr[], int n)
{
// create a bit with 32000 bits
BitArray ba = BitArray(320000);
// Traverse array elements
for (int i = 0; i < n; i++)
{
// Index in bit array
int num = arr[i];
// If num is already present in bit array
if (ba.get(num))
cout << num << " ";
// Else insert num
else
ba.set(num);
}
}
};
// Driver code
int main()
{
int arr[] = {1, 5, 1, 10, 12, 10};
int n = sizeof(arr) / sizeof(arr[0]);
BitArray obj = BitArray();
obj.checkDuplicates(arr, n);
return 0;
}
// This code is contributed by
// sanjeev2552
// Java program to print all Duplicates in array
import java.util.*;
import java.lang.*;
import java.io.*;
// A class to represent array of bits using
// array of integers
public class BitArray
{
int[] arr;
// Constructor
public BitArray(int n)
{
// Divide by 32. To store n bits, we need
// n/32 + 1 integers (Assuming int is stored
// using 32 bits)
arr = new int[(n>>5) + 1];
}
// Get value of a bit at given position
boolean get(int pos)
{
// Divide by 32 to find position of
// integer.
int index = (pos >> 5);
// Now find bit number in arr[index]
int bitNo = (pos & 0x1F);
// Find value of given bit number in
// arr[index]
return (arr[index] & (1 << bitNo)) != 0;
}
// Sets a bit at given position
void set(int pos)
{
// Find index of bit position
int index = (pos >> 5);
// Set bit number in arr[index]
int bitNo = (pos & 0x1F);
arr[index] |= (1 << bitNo);
}
// Main function to print all Duplicates
static void checkDuplicates(int[] arr)
{
// create a bit with 32000 bits
BitArray ba = new BitArray(320000);
// Traverse array elements
for (int i=0; i<arr.length; i++)
{
// Index in bit array
int num = arr[i] - 1;
// If num is already present in bit array
if (ba.get(num))
System.out.print(num +" ");
// Else insert num
else
ba.set(num);
}
}
// Driver code
public static void main(String[] args) throws
java.lang.Exception
{
int[] arr = {1, 5, 1, 10, 12, 10};
checkDuplicates(arr);
}
}
# Python3 program to print all Duplicates in array
# A class to represent array of bits using
# array of integers
class BitArray:
# Constructor
def __init__(self, n):
# Divide by 32. To store n bits, we need
# n/32 + 1 integers (Assuming int is stored
# using 32 bits)
self.arr = [0] * ((n >> 5) + 1)
# Get value of a bit at given position
def get(self, pos):
# Divide by 32 to find position of
# integer.
self.index = pos >> 5
# Now find bit number in arr[index]
self.bitNo = pos & 0x1F
# Find value of given bit number in
# arr[index]
return (self.arr[self.index] &
(1 << self.bitNo)) != 0
# Sets a bit at given position
def set(self, pos):
# Find index of bit position
self.index = pos >> 5
# Set bit number in arr[index]
self.bitNo = pos & 0x1F
self.arr[self.index] |= (1 << self.bitNo)
# Main function to print all Duplicates
def checkDuplicates(arr):
# create a bit with 32000 bits
ba = BitArray(320000)
# Traverse array elements
for i in range(len(arr)):
# Index in bit array
num = arr[i]
# If num is already present in bit array
if ba.get(num):
print(num, end = " ")
# Else insert num
else:
ba.set(num)
# Driver Code
if __name__ == "__main__":
arr = [1, 5, 1, 10, 12, 10]
checkDuplicates(arr)
# This code is contributed by
# sanjeev2552
// C# program to print all Duplicates in array
// A class to represent array of bits using
// array of integers
using System;
class BitArray
{
int[] arr;
// Constructor
public BitArray(int n)
{
// Divide by 32. To store n bits, we need
// n/32 + 1 integers (Assuming int is stored
// using 32 bits)
arr = new int[(int)(n >> 5) + 1];
}
// Get value of a bit at given position
bool get(int pos)
{
// Divide by 32 to find position of
// integer.
int index = (pos >> 5);
// Now find bit number in arr[index]
int bitNo = (pos & 0x1F);
// Find value of given bit number in
// arr[index]
return (arr[index] & (1 << bitNo)) != 0;
}
// Sets a bit at given position
void set(int pos)
{
// Find index of bit position
int index = (pos >> 5);
// Set bit number in arr[index]
int bitNo = (pos & 0x1F);
arr[index] |= (1 << bitNo);
}
// Main function to print all Duplicates
static void checkDuplicates(int[] arr)
{
// create a bit with 32000 bits
BitArray ba = new BitArray(320000);
// Traverse array elements
for (int i = 0; i < arr.Length; i++)
{
// Index in bit array
int num = arr[i];
// If num is already present in bit array
if (ba.get(num))
Console.Write(num + " ");
// Else insert num
else
ba.set(num);
}
}
// Driver code
public static void Main()
{
int[] arr = {1, 5, 1, 10, 12, 10};
checkDuplicates(arr);
}
}
// This code is contributed by Rajput-Ji
// JavaScript program to print all Duplicates in array
// A class to represent array of bits using
// array of integers
class BitArray {
// Constructor
constructor(n){
// Divide by 32. To store n bits, we need
// n/32 + 1 integers (Assuming int is stored
// using 32 bits)
this.arr = new Array((n >> 5) + 1);
}
// Get value of a bit at given position
get(pos){
// Divide by 32 to find position of
// integer.
let index = (pos >> 5);
// Now find bit number in arr[index]
let bitNo = (pos & 0x1F);
// Find value of given bit number in
// arr[index]
let arrCopy = this.arr
return (arrCopy[index] & (1 << bitNo)) != 0;
}
// Sets a bit at given position
set(pos){
// Find index of bit position
var index = (pos >> 5);
// Set bit number in arr[index]
var bitNo = (pos & 0x1F);
var arr1 = this.arr;
arr1[index] = arr1[index] | (1 << bitNo);
this.arr = arr1;
}
}
// Main function to print all Duplicates
function checkDuplicates(arr){
// create a bit with 32000 bits
var ba = new BitArray(320000);
// Traverse array elements
for (var i = 0; i < arr.length; i++) {
// Index in bit array
var num = arr[i];
// If num is already present in bit array
if (ba.get(num))
console.log(num);
// Else insert num
else
ba.set(num);
}
}
// Driver code
var a = [ 1, 5, 1, 10, 12, 10 ];
checkDuplicates(a);
// This code is contributed by Kirti Agarwal(kirtiagarwal23121999)
Time Complexity: O(N)
Space Complexity: O(1)
Similar Reads
Bitwise multiplication of Binary Array with K Given an array nums[] representing a binary number and integer K, the task is to perform bitwise multiplication by a given integer K (where K is a power of 2). Return a new array representing the product. Examples: Input: nums[] = {1, 0, 1}, K = 8 Output: {1, 0, 1, 0, 0, 0} Explanation: The binary n
6 min read
Inversion count in Array using BIT Inversion Count for an array indicates – how far (or close) the array is from being sorted. If the array is already sorted then the inversion count is 0. If the array is sorted in the reverse order that inversion count is the maximum. Two elements a[i] and a[j] form an inversion if a[i] > a[j] an
15+ min read
Find an element in Bitonic array Given a bitonic sequence of n distinct elements, and an integer x, the task is to write a program to find given element x in the bitonic sequence in O(log n) time. A Bitonic Sequence is a sequence of numbers that is first strictly increasing then after a point decreasing. Examples: Input : arr[] = {
11 min read
Find bitwise OR of all possible sub-arrays Given an array A of size N where, 1\leq N \leq 10^{5} . The task is to find the OR of all possible sub-arrays of A and then the OR of all these results. Examples: Input : 1 4 6 Output : 7 All possible subarrays are {1}, {1, 4}, {4, 6} and {1, 4, 6} ORs of these subarrays are 1, 5, 6 and 7. OR of the
9 min read
Construct the Array using given bitwise AND, OR and XOR Given Bitwise AND, OR, and XOR of N elements of an array denoted by a, b, c. The task is to find the elements of the array. If there exists no such array then print "-1".Examples: Input: N = 3, a = 4, b = 6, c = 6. Output: {4, 4, 6} Explanation: Bitwise AND of array = 4 & 4 & 6 = 4 Bitwise O
9 min read
Find last element in Array formed from bitwise AND of array elements Given an array A[] of size N, the task is to find the last remaining element in a new array B containing all pairwise bitwise AND of elements from A i.e., B consists of N?(N ? 1) / 2 elements, each of the form Ai & Aj for some 1 ? i < j ? N. And we can perform the following operation any numb
6 min read
Check if original Array Sum is Odd or Even using Bitwise AND of Array Given an integer N denoting the size of an array and the bitwise AND (K) of all elements of the array. The task is to determine whether the total sum of the elements is odd or even or cannot be determined. Examples: Input: N = 1, K = 11Output: OddExplanation: As there is only one element in the arra
6 min read
Searching Elements in an Array | Array Operations In this post, we will look into search operation in an Array, i.e., how to search an element in an Array, such as: Searching in an Unsorted Array using Linear SearchSearching in a Sorted Array using Linear SearchSearching in a Sorted Array using Binary SearchSearching in an Sorted Array using Fibona
15+ min read
Queries to calculate Bitwise AND of an array with updates Given an array arr[] consisting of N positive integers and a 2D array Q[][] consisting of queries of the type {i, val}, the task for each query is to replace arr[i] by val and calculate the Bitwise AND of the modified array. Examples: Input: arr[] = {1, 2, 3, 4, 5}, Q[][] = {{0, 2}, {3, 3}, {4, 2}}O
15+ min read
Count all pairs of an array which differ in K bits Given an array of size n and integer k, count all pairs in array which differ in exactly K bits of binary representation of both the numbers.The input arrays have elements with small values and possibly many repetitions. Examples: Input: arr[] = {2, 4, 1, 3, 1} k = 2 Output: 5 Explanation: There are
14 min read