C RUBY-ON-RAILS MYSQL ASP.NET DEVELOPMENT RUBY .NET LINUX SQL-SERVER REGEX WINDOWS ALGORITHM ECLIPSE VISUAL-STUDIO STRING SVN PERFORMANCE APACHE-FLEX UNIT-TESTING SECURITY LINQ UNIX MATH EMAIL OOP LANGUAGE-AGNOSTIC VB6 MSBUILD

# How to find array items that occur at least K times

By : Gene
Date : November 14 2020, 04:48 PM
like below fixes the issue No, you cannot do it in O(n) and O(1) time without any restriction on the input.
This is a generalization of the element distinctness problem (element distinctness is basically this problem with k=2), and it cannot be solved in O(n) time with O(1) memory.
code :

Share :

## Find all the elements in an array which occur odd number of times

By : 曾義格
Date : March 29 2020, 07:55 AM
it should still fix some issue "Better" depends on context. Using the hash map or hash set will be faster and has the advantage of not modifying the original array, but it requires O(N) extra memory. Sorting and counting takes longer and modifies the array, but requires no extra memory.
Which solution you choose depends on whether you can afford the extra memory.

## Printing items in a list that occur a certain number of times?

By : Ramit Aggarwal
Date : March 29 2020, 07:55 AM
should help you out Given a list of items, e.g. , Your approach is O(N^2), but this can be solved in O(N).
code :
``````from collections import Counter
print [key for key, count in Counter(words).items() if count == 3]
``````
``````Counter({'apple': 3, 'cat': 2, 'boat': 1})
``````
``````counter = {}
for word in words:
counter[word] = counter.get(word, 0) + 1
print [key for key, count in counter.items() if count == 3]
``````
``````from collections import OrderedDict
counter = OrderedDict()
words = ['cat', 'apple', 'apple', 'boat', 'cat', 'apple', 'cat']
for word in words:
counter[word] = counter.get(word, 0) + 1
print [key for key, count in counter.items() if count == 3]
``````
``````['cat', 'apple']
``````

## Get items from Ruby Array that occur 2 or more times

By : Carlos
Date : March 29 2020, 07:55 AM
help you fix your problem Let's say I have a Ruby array. , There are probably better ways, but this is one:
code :
``````> [1,2,3,4,4,5,6,6,7,7].group_by{|i| i}.reject{|k,v| v.size == 1}.keys
=> [4, 6, 7]
``````
``````> a = [1,2,3,4,4,5,6,6,7,7]
=> [1, 2, 3, 4, 4, 5, 6, 6, 7, 7]
> a1 = a.group_by{|i| i}
=> {1=>[1], 2=>[2], 3=>[3], 4=>[4, 4], 5=>[5], 6=>[6, 6], 7=>[7, 7]}
> a2 = a1.reject{|k,v| v.size == 1}
=> {4=>[4, 4], 6=>[6, 6], 7=>[7, 7]}
> a2.keys
=> [4, 6, 7]
``````

## Find duplicate element occur more than two times from an array in java

By : Nathan Creswell
Date : March 29 2020, 07:55 AM
wish helps you You want to iterate through your array only one time. If all you want is duplicates, you can do this simply by keeping track of any value you have seen before using an ArrayList:
code :
``````int[] data = {5, 6, 1, 6, 9, 5, 2, 1, 5};

System.out.println(Arrays.toString(data));

ArrayList<Integer> seenBeforeList = new ArrayList<>();
for(int index = 0; index < data.length; index++){
int value = data[index];
if(seenBeforeList.contains(value)){
System.out.println("Duplicate Element : " + value);
System.out.println("Index of that duplicate element : " + index);
} else {
}
}
``````
``````[5, 6, 1, 6, 9, 5, 2, 1, 5]
Duplicate Element : 6
Index of that duplicate element : 3
Duplicate Element : 5
Index of that duplicate element : 5
Duplicate Element : 1
Index of that duplicate element : 7
Duplicate Element : 5
Index of that duplicate element : 8
``````

## How to find all values that occur more than n/k times in an array?

By : Sofio Gagnidze
Date : March 29 2020, 07:55 AM
hope this fix your issue Finding the n/10th largest key (that is, the key that would be at position n/10 if the array was sorted) takes linear time using QuickSelect. If there are less than n/10 copies of this key, then you know that there are not n/10 copies of anything above it in sorted order, because there isn't room for n/10 copies of anything above the key in sorted order. If there are n/10 or more copies, then you have found something that occurs more than n/10 times, and again there can't be anything larger than it that occurs more than n/10 times, because there isn't room for it.
Now you have an array of at most 9n/10 values smaller than the key you have just found left over from QuickSelect. Use another pass of QuickSelect to find the key n/10 from the top of this left over array. As before, you may find a key that occurs n/10 or more times, and whether you do or not you will eliminate at least n/10 entries from the array.