Ok)

IntStream.range(0, in.nextInt()) - constructs a stream of ints [0..N). Think of it like (for i = 0; i < N; i++)

.mapToObj(i -> in.next()) - for each i from stream we read a word

.collect(Collectors.toList()); - gather to list

So at this points we just read out N words to List<String> strings

IntStream.range(0, in.nextInt()).mapToObj(i -> in.next()) -- same as previous: read count, and read M words

.mapToLong(q -> strings.stream().filter(q::equals).count()) - for each of M word: iterate over N words, filter those who are equal to current word, and count elements.

.forEach(System.out::println) - output that count.

That is called 'functional style'. If you really want to learn this approach - i'd suggest learning haskell. It's the most pure functional language.

Python brofist! Here's my python.

from collections import defaultdict

words = defaultdict(lambda: 0)

for _ in range(int(input().strip())):
    words[input().strip()] += 1
    
for _ in range(int(input().strip())):
    print(words[input().strip()])

Can you explain your code please

Counter makes it even easier

from collections import Counter, defaultdict

counter = defaultdict(int, Counter([raw_input() for _ in range(input())]))

for _ in range(input()):
    print counter[raw_input()]

Here's mine :)

N = int(input())
strArray = []
for _ in range(N):
    strArray.append(input().strip())
Q = int(input())
for _ in range(Q):
    query = input()
    print(strArray.count(query)) #count how many times query occured in strArray

Python with no external libraries.

lst = []
for i in range(int(input())):
    lst.append(input())
for i in range(int(input())):
    query_string = input()
    count = 0
    for i in range(len(lst)):
        if query_string == lst[i]:
            count += 1
    print(count)

Can you elobrate the code.

That is nearly identical to my solution. Python is pretty great.

Here's mine:

from collections import Counter

def matchingStrings(strings, queries):
    occurs = Counter(strings)
    return [occurs[query] for query in queries]

I notice alot of these solutions process 2x. an easy way is to just use Counter and collect values that have keys in the counter.

ex: (Psuedo)

result = [] c = Counter(strings)

for q in queries: c[q] ? result.append(c[q]) : result.append(0)

thanks for posting your code helped a lot

Thanks!! That was very helpful!

is there any simpler code rather than using some other library

instead of using unordered_set, it would be quicker with set because unordered_set takes a constant O(1) while set takes O(log n)

We can also use map with almost similar implementation. Key is required string and value is the number of occurance of that string. If a key is not present in map , it's value is '0' by default.

#include <string>
#include <iostream>
#include <map>
using namespace std;

int main() {
    map<string,int> m;
    int n,q;
    string s;
    cin>>n;
    
    for(int i=0; i<n; i++){
        cin>>s;
        m[s]++;
    }
    
    cin>>q;
    for(int i=0;i<q;i++){
        cin>>s;
        cout<<m[s]<<endl;
    } 
    return 0;
}

I dont understand one thing:

unordered_set sould contain no duplicated elements, so count would return 0 or 1.... How to overcome this issue?

http://www.cplusplus.com/reference/unordered_set/unordered_set/count/

your run time sucks

for(String str : a) can you explain it

Its still O(N^2)

Hi SonJohn. I did the same. It works, so why should I do something more? Is it too slow? Then some tests should fail.. but they dont

Nice 3-liner for HashMap solution, upvoting!

Can you explain this solution please? Thanks

hw about this man..!

seq = [input() for _ in range(int(input()))]
[print(seq.count(input())) for _ in range(int(input()))]

Imagine all strings in test have same hashCodes. String length <= 100. It's very easy to achieve. If author wanted, he could've made such a test. Every hash algorithm is vulnerable to that kind of test. And your O(N+Q) hashtable solution will degrade to O(N*Q).

So when talking about "big O", which is upper bound, "hashtable" solution has same complexity, which is O(N*Q).

Better and stable algorithm would be to use TreeMap with lexicographic comparator. Which would give you O(Q*logN).

By the way, starging from Java8 they combined the "best of two worlds". HashMap class uses binary tree (if keys are "comparable") instead of linked list in case there are a lots of keys with same hashCode. So in java8 it would give you O(Q*logN) if using HashMap solution.

Best you can do with map-based is O((n+q)*logN). Think about HashMap performance when all strings have same hashcodes, your solution is O(n*q) as well. Only in java8 they introduced "treemap inside hashmap" for equi-hash comparable objects.

Here is reference to a 3-liner for hashmap solution in java8, maybe you'll like it https://www.hackerrank.com/challenges/sparse-arrays/forum/comments/304466

why flatMap?

maybe:

return queries.map { s -> strings.count { it==s } }.toTypedArray()

Did something very similar in swift: func matchingStrings(strings: [String], queries: [String]) -> [Int] {

let arrayMatching: [Int] = queries.compactMap({
    let query = $0
    return strings.filter({$0 == query}).count
})

return arrayMatching

}