We use cookies to ensure you have the best browsing experience on our website. Please read our cookie policy for more information about how we use cookies.
The fastest solution is O(n) and it requires only 26 bit slots for storage. There is no need to find the shortest string which will make the process takes longer time. O(n) is already the fastest solution because you need to read every characters.
row1: abb
row2: a
______I dont think it will pass. Since you even count the letter in the same row. Actually to see if the nubmers of the letter equals the row, is not precise.
He is counting the letters occurrence in each string, the first condition ensure that same letters in the same string will only be counted once.
The second condition is just confirming the answer: if a letter have n counts accross n strings -> number of gem-element increases
r is 0 for first string , first condition
"if (letter[c - 'a'] == r) { letter[c - 'a']++;"
will increase the letter's index only once throught the whole string if a particular character occures even multiple times. and second condition
if (letter[c - 'a'] == rocks) { count++; } means if the particular index is equals to the number of string entered means it's present in every string so increase the counter.
I like this.
People have already explained how duplicates are avoided.
I particularly like the other feature (because I had to think about it to understand it),
if(letter[c-'a']==r){
means if up until now we have found this element in as many rocks as we have examined before this rock, it's still a gem-element, so it remains one after this rock as well.
But I don't like having
if(letter[c-'a']==rocks){count++;}
inside every every rock since it can only be true when r == rocks-1. I'd prefer to keep s[] outside the outer loop, and after all the rocks have been parsed, go through all the elements in the last rock again, counting if they have been found exactly rock times (and incrementing their count, so they aren't double-counted for duplicate elements in the last rock.)
If repeated character is met, this 'if' condition will fail because at first, if condition is passed but after it the letter[c - 'a'] is incremented, but the r's value is still same say '0' for 1st iteration then letter[c - 'a'] will be 1 which leads to failing of this 'if' case for 2nd iteration.
it's a good point about finding the shortest of the strings, but the tests here appear not to deal with that problem, but it is a nice approach in some cases
Gemstones
You are viewing a single comment's thread. Return to all comments →
Instead of checking it against all 26 alphabet, find the shortest of the strings, make a set out of those letters in the shortest string and compare.
Then you need to store all the strings and find the minimal. It's a sacrifice of space.
or use the first string itself
The fastest solution is O(n) and it requires only 26 bit slots for storage. There is no need to find the shortest string which will make the process takes longer time. O(n) is already the fastest solution because you need to read every characters.
C solution:
if (letter[c - 'a'] == r) { letter[c - 'a']++; if (letter[c - 'a'] == rocks) { count++; }
can you explain this concept??
Yeah please.
row1: abb row2: a ______I dont think it will pass. Since you even count the letter in the same row. Actually to see if the nubmers of the letter equals the row, is not precise.
He is counting the letters occurrence in each string, the first condition ensure that same letters in the same string will only be counted once. The second condition is just confirming the answer: if a letter have n counts accross n strings -> number of gem-element increases
r is 0 for first string , first condition "if (letter[c - 'a'] == r) { letter[c - 'a']++;" will increase the letter's index only once throught the whole string if a particular character occures even multiple times. and second condition if (letter[c - 'a'] == rocks) { count++; } means if the particular index is equals to the number of string entered means it's present in every string so increase the counter.
I like this. People have already explained how duplicates are avoided. I particularly like the other feature (because I had to think about it to understand it),
means if up until now we have found this element in as many rocks as we have examined before this rock, it's still a gem-element, so it remains one after this rock as well.
But I don't like having
inside every every rock since it can only be true when r == rocks-1. I'd prefer to keep s[] outside the outer loop, and after all the rocks have been parsed, go through all the elements in the last rock again, counting if they have been found exactly rock times (and incrementing their count, so they aren't double-counted for duplicate elements in the last rock.)
how you are eliminating the condition of repeated character in the string??
Have a close look at it:
"if (letter[c - 'a'] == r) { letter[c - 'a']++; "
If repeated character is met, this 'if' condition will fail because at first, if condition is passed but after it the letter[c - 'a'] is incremented, but the r's value is still same say '0' for 1st iteration then letter[c - 'a'] will be 1 which leads to failing of this 'if' case for 2nd iteration.
can i marry ur brain?
i also want to join...
My mother tongue is not english.
Who can tell me what's meaning of this sentence？
nice!
Nice logic
really nice logic.............
Nice logic. I modified your logic a bit. First deleted all the repeated elements and them made the comparison. C++ code
char c = str[i].at(k); alpha[c - 'a']++;
can be simplify to
alpha[str[i].at(k)-'a']++
can you explain why int alpha[26] = {0}; has to have a size when I change it to vector? vector alpha(26), without the size the program failed to run.
Why is sorting necessary here?
Very clever the count the rocks on the last iteration of the loop, saving one additional iteration!
Nice optimise solution.
by this condition we can find only how many a and b etc
Very Nice Logic !
love it man!!!
i love this letter[26]. i used [123].
it's a good point about finding the shortest of the strings, but the tests here appear not to deal with that problem, but it is a nice approach in some cases
Thank you kind sir, that's how tips should be passed on, inspired by your advice: