|
Thread Rules 1. This is not a "do my homework for me" thread. If you have specific questions, ask, but don't post an assignment or homework problem and expect an exact solution. 2. No recruiting for your cockamamie projects (you won't replace facebook with 3 dudes you found on the internet and $20) 3. If you can't articulate why a language is bad, don't start slinging shit about it. Just remember that nothing is worse than making CSS IE6 compatible. 4. Use [code] tags to format code blocks. |
honestly, I'm not sure you can get much more optimized than travis's idea with a slight modification:
1. run through the string and dump each index into a bucket with that letter (if it's not a letter, ignore it, and convert everything to lower case just in case. 2. remove all buckets with size != 1. 3. find the remaining lowest index and return its key.
It's O(n). Technically O(nm) where m is the size of your alphabet, but even including all unicode characters, it's not that bad in the grand scale of things.
|
On July 06 2017 06:15 Manit0u wrote:Show nested quote +On July 06 2017 05:28 mahrgell wrote:On July 06 2017 05:16 Blisse wrote:Am I missing something? Thought this was really straightforward? + Show Spoiler + char find_first_nonunique_character(string input_string) { set<char> characters;
for (char& c: input_string) { if (characters.contains(element)) { return element; } else { characters.insert(element); } }
throw IllegalArgumentException("Input only has unique characters"); }
char find_first_unique_character(string input_string) { map<char, int> characters_count;
for (char& c: input_string) { if (characters_count.count(c) == 0) { characters_count.insert(element, 1); } else { characters_count[element] += 1; } } for (char& c: input_string) { if (characters_count.count(c) == 1) { return c; } }
throw IllegalArgumentException("Input has no unique characters"); }
your find unique doesnt work and will always return the first character of the string, given that it surely will have an entry in your map, thus the count(c) will always return 1 on it. And even if you fix that bug in your code, I think it was never argued that this problem is a challenge to solve, but the question is how to solve it efficiently. And that optimization is the way more tricky part with a lot of probably interesting potential ideas. Using maps is certainly something I would avoid in that regard! Actually, it's an algorithms interview question everyone is asked at my company. Making it optimal isn't important. Making it work is semi-important (good attempts count, even if they fail somehow - my initial solution could enter an infinite loop but I've corrected it when it was pointed out and it was fine). 90% of the candidates can't make it past this test  My pretty shitty solution during the interview: letter = string.shift
foreach another_letter in string if letter == another_letter delete all copies of letter from string reset
return letter
Obviously, it was a bit more complicated, since I've decided to do it in C for whatever reason. The only optimization was that with each pass it had to go through smaller char arrays (but still, it was quite a bit of work). My mind simply went blank and I went down to absolute basics of programming, without using any existing libraries or built-in functions for it.
if it makes you feel better I think that's a really creative solution and if you were looking for only letters you could simply remove all non-letter characters as soon as you saw them too
so even though it might sound awful I am pretty sure that solution is O(n) just not the best coefficient
|
So I'm going to do a short data science course in LSE later this summer. My plan is to leverage my maths background and just run head first into data science, hopefully in a year I'll be useful and have a hirable and valuable skillset
|
28079 Posts
On July 06 2017 04:58 NovemberstOrm wrote:poor guy, just came across this lol + Show Spoiler + I don't personally have a job in the industry yet (gonna start applying soon hopefully) so I'm not 100% sure how things work in a real office environment, but this doesn't really feel like the junior devs fault. Or at least, he fucked up but shouldn't have had the ability to fuck up that hard in the first place from what I understand.
I'll watch the video when I have time, but I remember seeing that story on reddit lol.
|
Canada16217 Posts
On July 06 2017 07:13 TheEmulator wrote:I don't personally have a job in the industry yet (gonna start applying soon hopefully) so I'm not 100% sure how things work in a real office environment, but this doesn't really feel like the junior devs fault. Or at least, he fucked up but shouldn't have had the ability to fuck up that hard in the first place from what I understand. I'll watch the video when I have time, but I remember seeing that story on reddit lol. Yeah definitely not his fault, the company had a very poor setup. Not even having proper backups is just stupid.
|
Regarding the first non unique letter, a hash table should get it extremely quickly. Something pretty close to O(1), unless I've really forgotten how they work.
|
you can't do it in O(1) because you have to look at every element of the string (unless there is some absolutely insane trick I am not aware of)
|
On July 06 2017 07:45 travis wrote: you can't do it in O(1) because you have to look at every element of the string (unless there is some absolutely insane trick I am not aware of) Pretty much that.
As you have to go over the entire string anyway, I'm actually quite confident that my solution from the previous page should be close to the optimum. There is no need at all to count how often each letter occurs, all you need is save the first index it occurs and have 2 void values for "has not occured yet" (0 in my code) and "has occured at least 2 times" (INF in my code)
It's idea can also simply be adapted to what ever alphabet one wants to consider eligable.
Iterate once over the string, then iterate once over the alphabet. All operations are direct access, no sorting, finding, middle inserting or anything similar potentially time consuming is required.
|
|
That's exactly what I'm talking about, and the search time should be somewhere between O(1) to O(2) on average. I can't think of a scenario where it's greater then O(2), but I can think of a scenario where it's significantly less.
Hope I'm not horrible wrong rofl.
I'm an idiot, I don't mean O(1), I mean something else.
|
In an interview question, just show the obvious n^2 solution. As Manit0u said most people already fail there.
If they ask you to optimize ask "Does the profiler show this as a bottleneck?" Gj, you know about premature optimization.
Ask what you are optimizing for (speed, memory, readability ...). You can probably write some unreadable code that is super fast. Thanks for not doing that.
Do whatever you want and explain your thoughts. Histograms. Frequency of English alphabet. Whatever.
|
On July 06 2017 08:35 Nesserev wrote:Show nested quote +On July 06 2017 07:45 travis wrote: you can't do it in O(1) because you have to look at every element of the string (unless there is some absolutely insane trick I am not aware of) I think he's talking about an approximately constant lookup in a properly implemented hashmap and using a nicely distributed hash function. That said, something to note: bucket sort and radix sort should be used when the internal structure allows us to pass through all the elements only k times (k being the length of a string, the max amount of digits, etc.). No reason to do it in this case. s = "fqkmjsdfjnqsmq" // k is first unique letter m = {}
for c in s: if c not in m: m[c] = 1 else: m[c] += 1
for c in s: if m[c] == 1: print(c) // prints solution break
Does that mean for a string length of 10 characters, it would require us to pass through each element 10 times each?
How would radix sort work for a single string?
Did a bit of reading on it since I only vaguely heard about radix sort before and I understand how it works for a group of strings or numbers but not for a single one.
Just to confirm, for a list of 10 numbers with max length of a number being 10 digits, it would take 10*10=100 passes right?
|
|
Ah I see, thanks that was pretty insightful and we did not cover radix sort in my classes so I guess that was why.
|
if you have an undirected graph and choose to represent it with an adjacency list
how do we avoid having to traverse two lists whenever an edge is altered?
for example when vertex 3 connects to vertex 7
We need to go to index 3 of our list, find the edge to 7, and alter it Then we need to go to index 7, find the edge to 3, and alter it
how to avoid this redundancy?
edit: would you use pointers? are there any other ways?
|
|
|
On July 06 2017 23:54 travis wrote: edit: would you use pointers? are there any other ways?
Yeah, you can always store a pointer to the mirrored edge in each edge. If you store a list pointer / iterator, you can also do removals without a second traversal.
|
Thoughts? A coworker merges a PR where you completely disagreed with their implementation. One senior/not-really person OK'd the PR but he never leaves comments. How would you handle this?
|
On July 07 2017 08:30 Blisse wrote: Thoughts? A coworker merges a PR where you completely disagreed with their implementation. One senior/not-really person OK'd the PR but he never leaves comments. How would you handle this?
Can you verbalize all the reasons you disagree with their implementation? How much code are we talking about? If it's under a couple hours work, I generally try to rework it in the way that I think that it should be done differently without pushing any code off hours. This has a couple benefits, if you figure out along the way that you've missed some assumptions that are actual trade offs that they already considered, you did so without putting your foot in your mouth first. It also provides the benefit that if it works out as you expected then you would now have a talking point that you can approach, I saw your code but was curious did you consider x or y?
Either way, hopefully you work in an environment where you can freely and openly question why things are done. Seek to understand why they did it their way instead of imposing your own way. If you really think you know better then you should be able to ask them questions that lead them to your own conclusion without making any statements making them defensive. I personally also like to have these meetings 1 on 1 to make people feel less vulnerable and less likely to get defensive.
|
|
|
|