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.
Honestly I find one-liners a bit overrated. A lot of people on here get into this nasty habit of cramping their code just to force a one-liner - which I find just silly.
I agree and disagree. One-liners that don't obfuscate the code are succinct. You just have to make sure that property holds true, and that creating a one-liner doesn't decrease performance.
I suppose practice. Practice list comprehensions enough and it can get easy. This is a list comprehension that adds 1 to a list everytime the sum in that range is equal to d. Then len is used to count all the 1s in that list. I learned list comprehensions through learning haskell.
By "sliding window", I mean one loop without nesting another loop within it. When you advance to the next item, you add one item and subtract another item.
Why does this work? In the case you have the list of squares [1,1, 3, 3, 2], m = 2 and d = 3, there are two positive cases of [2,1] and [1,2]. However, your code gives returns 0.
The only way this makes sense is the assumption the pieces must be consecutive to sum, but I didn't see that mentioned in the problem.
Birthday Chocolate
You are viewing a single comment's thread. Return to all comments →
Pyhton people see this!!
I did the same think with multiple lines, but it's always refreshing to see oneliner solutions.
Honestly I find one-liners a bit overrated. A lot of people on here get into this nasty habit of cramping their code just to force a one-liner - which I find just silly.
I agree and disagree. One-liners that don't obfuscate the code are succinct. You just have to make sure that property holds true, and that creating a one-liner doesn't decrease performance.
One liners make a slipery slope when writting production code, but in games like this, it is just a nice excescise.
Seeking out a one-liner at the expense of efficiency (as we see here) seems a strange way to prioritise things, but oh well
how do you people get this logic ?is it pure practice or do you refer some books for the logic ?
I suppose practice. Practice list comprehensions enough and it can get easy. This is a list comprehension that adds 1 to a list everytime the sum in that range is equal to d. Then len is used to count all the 1s in that list. I learned list comprehensions through learning haskell.
That is how I solved it using Haskell! https://www.hackerrank.com/challenges/the-birthday-bar/submissions/code/99568589 Though I would to love to know if there is a function (like scanl) that would generalise this ...
Beat this:
There is nothing to beat in your code bro :D
You could use a generator expression instead of a list comprehension.
But if you want a more efficient solution for larger inputs, use a sliding window (see the following link). https://www.hackerrank.com/challenges/the-birthday-bar/submissions/code/43358272
By "sliding window" don't you mean a loop whithin a loop, so that it counts a surden amount ahead for each item in the lst.
By "sliding window", I mean one loop without nesting another loop within it. When you advance to the next item, you add one item and subtract another item.
Yo, thanks for that description. I hadn't thought of that. Made the solution so much cleaner.
can u explain ur code pls!!!!!
There's nothing to explain; it's all obvious.
return sum(sum(s[element:element+m) == d for element in range(len(s))])
from where does the n came?
n here is len(squares).
This is adding from idx to idx + m. It's more efficient to keep a running sum and subtract the beginning of the window and add the next value:
I don't understand how this works given that n is not defined.
its lenght of given array. n=len(s)
Python people saw this, and now python people jealous. :p
Thanks for the approach! BTW we could have used segment trees as well, right?
Did similarly, but shorter
That's just a copy of https://www.hackerrank.com/challenges/the-birthday-bar/forum/comments/289156
Truly didn't see that, looks super similar :P
I cannot see the results in the link. Could you please share your code here?
Thank you
@victorz
In Python True == 1 and False == 0, so this also works:
Ruby version:
+1
Ruby <3
how did u write tp?
In fact your solution is dumb, you solved it in O(n^2) instead of O(n)
Why does this work? In the case you have the list of squares [1,1, 3, 3, 2], m = 2 and d = 3, there are two positive cases of [2,1] and [1,2]. However, your code gives returns 0.
The only way this makes sense is the assumption the pieces must be consecutive to sum, but I didn't see that mentioned in the problem.