📹 Product of Array Except Self – Leetcode 238 – Python
0:00 – Read the problem 2:09 – Drawing Explanation 9:47 – Coding Explanation leetcode 238 This question was identified as an …
What is the 135 rule of productivity?
The 1-3-5 rule is a productivity strategy that suggests focusing on one big task, three medium tasks, and five small tasks per day. It helps manage time effectively and ensures the most important tasks are completed first. The rule can be adjusted to suit individual needs, such as meeting schedules or unexpected job tasks, by leaving some task slots empty. Overall, the 1-3-5 rule has significantly improved productivity.
What is the 52 17 rule for productivity?
The 52/17 rule, developed by scientists, suggests that taking a break every hour, between 52 minutes on and 17 minutes off, is crucial for maintaining attention, motivation, creativity, and productivity. This rule suggests that our bodies and brains are designed to work without a break, and downtime is essential for maintaining attention, motivation, creativity, and productivity. Sleep helps solidify memory, while resting while awake plays a different role in processing information.
What is the 70% rule productivity?
The 70 percent rule is a management principle that suggests employees should not work 100% of their capacity, as it allows them to be most productive when they have the reserve strength to meet temporary demands. However, overburdened employees may not have the extra capacity to meet increased demands, leading to burnout, poor performance, absenteeism, and job loss. This can result in reduced productivity, increased employee turnover, loss of corporate knowledge, and increased costs associated with hiring and training new employees.
What is the 50 30 20 rule for productivity?
The 50/30/20 budgetary allocation strategy assigns 50% of income to essential expenditures, 30% to discretionary purchases, and 20% to savings. In order to ascertain the requisite spending limits, it is necessary to multiply the monthly net income by the respective values of 50, 30, and 20. For example, if one’s net income is $3, 000, one would allocate $1, 500 to needs, $900 to wants, and $600 to savings. It is of the utmost importance to accurately track spending for a minimum of two months in order to ensure the efficacy of the budget.
What is the 1 3 5 rule of productivity?
The 1-3-5 Rule is a productivity technique that categorizes tasks into a to-do list, with the objective of accomplishing one significant mission, three medium-sized tasks, and five minor tasks. This structured approach enhances productivity by concentrating on significant, time-sensitive, and straightforward tasks.
What is 333 productivity rule?
The 3-3-3 method is a productivity strategy that involves dedicating three hours of uninterrupted time to a critical project, followed by three urgent tasks that don’t require much focus, and the remaining three hours for maintenance tasks like organizing workspaces, answering emails, or planning for the next day. This approach minimizes distractions and optimizes output, making it an effective way to manage time effectively. However, deep work isn’t sustainable throughout the workday.
What is the 1-3-5 7 rule?
The 1-3-5-7 rule is a mnemonic technique that facilitates long-term memory retention and recall by first presenting information on the first day, then again after two days, and finally after two additional days.
How much productivity is normal?
The mean productivity of the typical office worker is less than three hours per day, with a higher productivity rate of 60 or less across all career fields. The productivity of employees is of great consequence to the success of a company. However, the majority of studies indicate that this only occurs approximately 60% of the time, with homework being a more productive activity. The occurrence of interruptions and ineffective meetings has been identified as a factor contributing to unproductive work.
What is the 80 20 rule in productivity?
The 80-20 rule, also known as the Pareto Principle, is a concept that suggests that 80 of outcomes result from 20 of all causes for any given event. It is commonly used in business to identify the most productive inputs and prioritize them, and can be applied to various fields like wealth distribution, personal finance, spending habits, and relationships. The goal is to efficiently use an entity’s best assets to create maximum value. It is a precept rather than a strict mathematical law.
What is the 85% rule for productivity?
Research in the Harvard Business Review indicates that optimal effort is more effective in reducing burnout and achieving better results in the long run. High-engaged workers are more likely to experience burnout, while those working over 40 hours are more likely to make mistakes and have less flexibility. Studies consistently show that 85% effort leads to better results in various fields. To avoid burnout, employees should pace themselves, take breaks, and be inspired to perform better next week.
📹 14.C Programming – using Literal Suffix when assigning values to a variable (L, f)
In C there is this term called literal suffix which is used to affirm the data type that is being stored. This course will give you a full …
there’s literally no way anyone would ever come up with this algorithm on their own without seeing this exact problem before lol. these are the kinds of leetcode problems that are completely pointless to ask a candidate; you either see them solve some solution they memorized, or they give you n^2, neither really tell you anything about their ability
I tried to understand the problem the way you taught and finally solve it on my own. I was able to produce the exact same code as you did, because the explanation was so detailed. I think moving forward, I need to spend a lot more time studying the logic before coding anything. I have an interview coming up and this insight will definately help me.
I followed through with the explanation, then the day after recollected the steps and coded out the answer… However, this makes me feel uneasy as I don’t know if I ACTUALLY learned anything or just memorized your solution. I spent an hour thinking through the problem and couldn’t find another way to solve it that didn’t take the division approach. Since I couldn’t get to your solution on my own, I question if this means I lack the mental capacity to solve a problem I’ve never seen before during an interview. When you started, did you just do Leetcode problems until you remembered the patterns and were then able to use information that you’ve picked up along the way as tools to solve new problems or is there another approach I should take such as reading Introduction to Algorithms by Cormen, Rivest, and Stein? I’m currently using the Blind 75 problem set on your personal site. Thanks for the great content!
Just started to solve leetcode problems. I told myself that I won’t look at the solution until I solve it because I developed a bad habit to look at the solution too early. Took a pen and a paper. After an hour I was ready to give up. But then somehow I came up with the solution. It seemed impossible at the beginning and so simple at the end.
product = 1 prefix = () for num_val in nums: product = product * num_val prefix.append(product) product = 1 postfix = () for i in range(len(nums) – 1, -1, -1): product = product * nums(i) postfix.insert(0, product) res=() for i in range(len(nums)): left = prefix(i-1) if i – 1 >= 0 else 1 right = postfix(i+1) if i + 1 < len(nums) else 1 res.append(left * right) return res this is the unoptimized code which he was talking about
Given `nums = (a, b, c, d)` Then answer or the resulting list would be `(b*c*d, a*c*d, a*b*d, a*b*c)` The left_pass, after left to right iteration gives `(1, a, a*b, a*b*c)` The right_pass, after right to left iteration gives `(b*c*d, c*d, d, 1)` Product of left_pass(i) and right_pass(i) would give us the above result. So the cumulative product does make sense in this way.
I think it’s a really stupid question because of the limitations they place on the problem. The calculate the product for all nums and use division for each index is such a straightforward and simple solution which you are not allowed to use for some reason. Like I can’t imagine that you would be writing software and you come up with something that is efficient, easy to understand and intuitive and then say forget about that we’re gonna write a more complicated solution.
C++ optimal solution Runtime: 19 ms, faster than 89.54% of C++ online submissions for Product of Array Except Self. Memory Usage: 23.9 MB, less than 80.30% of C++ online submissions for Product of Array Except Self. class Solution { public: \tvector productExceptSelf(vector & nums) \t{ \t\tauto res = nums; \t\tint postfix = 1; \t\tfor (int i = 1; i < nums.size(); ++i) \t\t{ \t\t\tres(i) *= res(i - 1); \t\t} \t\tfor (int i = nums.size() - 1; i > 0; –i) \t\t{ \t\t\tres(i) = postfix; \t\t\tres(i) *= res(i – 1); \t\t\tpostfix *= nums(i); \t\t} \t\tres = postfix; \t\treturn res; \t} };
Done thanks Wants us to map input array to an output array where output(i) is the product of all elements in input array except ith entry Maintain two arrays prefix() and postfix() where prefix(i) is product of elements in input before ith element and postfix(i) is also the product of all elements in input array after i So to find output(i) = prefix(i) x postfix(i) Need two passes on the input array to build prefix and postfix so linear complexity
public class Solution { public int() ProductExceptSelf(int() nums) { //Using pincer approach int() res = new int(nums.Length); int prodsofar = 1;//read as product-so-far for(int i = 0;i=0;i–){ res(i) = res(i)*prodsofar; prodsofar = prodsofar*nums(i); }//for loop to multiply array elements(except nums(i)) from end(so that we cover all elements that missed during first pass) and store them in res. return res; } } //c# solution
There is still a wrinkle with using division because of zeroes. It doesnt change time complexity its just not as elegant as it first appeared to me. If there are multiple zeroes, then each element in ans will be 0. But consider the given test case (-1,1,0,-3,3) Here is 1 solution but I bet someone can improve upon it. The total product for the case of (-1,1,0,-3,3) would be 0. The answer should be (0,0,9,0,0). When iterating over nums to calculate the total product, you can calculate another the total product as if there were no zeroes (by falling back to 1 if the value is 0). Then when dividing the total product by each element to get the answer, check if the element in nums is a zero. If it is, just return the total product instead.
Hi There, I am not sure whether there is bug in your code or not. As I don’t use the python. I was using C#, and but followed your explanation. However In your code you didn’t do.. result(j) = postfix * result(j) ; —> To get the 8 for index 2. When I did the code by the explanation I m doing multiplying the “result(j) = postfix * result(j)” and works perfectly fine. Could help me understand is there any diff C# vs python, that made your code to work ?
Is this code correct? it takes too much time but i want to know if it is still right: class Solution: def __init__(self): self.answer = () def productExceptSelf(self, nums: List(int)) -> List(int): nums.insert(0, 1) nums.append for i in range(1, len(nums) -1): self.answer.append(reduce(lambda x, y: x*y, nums(i+1:))*reduce(lambda x, y: x*y, nums(:i))) return self.answer EDIT: a one liner doesnt seem to work either : /, altho the execution time improved by 20ms class Solution: def productExceptSelf(self, nums: List(int)) -> List(int): nums.insert(0, 1) nums.append return (reduce(lambda x, y: x*y, nums(i+1:))*reduce(lambda x, y: x*y, nums(:i)) for i in range(1, len(nums) -1 )) EDIT 2: i tried another one and it didnt work :c, guess im perusal the solution class Solution: def productExceptSelf(self, nums: List(int)) -> List(int): return (reduce(lambda x,y: x*y, nums(:i)+nums(i+1:)) for i in range(len(nums))) EDIT 3: SPOILERS SOLUTION: well i managed to make a solution by implementing the drawn explanation class Solution: def __init__(self): self.answer = () self.prefix = 1 self.postfix = 1 def productExceptSelf(self, nums: List(int)) -> List(int): self.answer.append(self.prefix) for i in range(0, len(nums) – 1): self.prefix *= nums(i) self.answer.append(self.prefix) for i in range(1, len(nums)): self.postfix *= nums(-i) self.answer(-i-1) *= self.postfix return self.answer
Java solution with 1ms runtime – better than 100% submissions and memory usage less than 97.25% submissions. class Solution { public int() productExceptSelf(int() nums) { int() productArray = new int(nums.length); int product = 1; int zeroCount = 0; for(int i=0; i 1) productArray(i) = 0; else if(zeroCount == 1) if(nums(i) == 0) productArray(i) = product; else productArray(i) = 0; else productArray(i) = product/nums(i); } return productArray; } }
wouldnt it be easier to have a left array and a right array. Left contains the products of all elements left of that element except itself. Same goes for the right. leftArray = (1,1,2,6) rightArray = (24,12,4,1). Then just multiply each corresponding element of leftArray to the rightArray to get outpur array = (24,12,8,6)
Came up with recursion solution in Go, func productExceptSelf(nums ()int) ()int { rec(nums, 1,0) return nums } func rec(nums ()int, current,i int) int { if i == len(nums){ return 1 } right := rec(nums, current*nums(i),i+1) old := nums(i) nums(i) = current*right return right*old } not doing good in time and space though( is it really that bad?
This is what I love about python, you can solve leetcode problems in 10 lines of code class Solution: def productExceptSelf(self, nums: List(int)) -> List(int): N = len(nums) res=*N prod_pre, prod_post = 1,1 for i in range(N): res(i) *= prod_pre res(N-1-i) *= prod_post prod_pre *= nums(i) prod_post *= nums(N-1-i) return res
Ngl whoever designed the question shouldn’t have written ” The product of any prefix or suffix of nums is guaranteed to fit in a 32-bit integer “, this statement made the problem way easier than it is as It is a pretty big hint. You can easily figure that part out just by looking at the constraints(i.e 100000 x 30) will never exceed 32 bit int. At least the follow up question was good.
This is not the best solution and can be optimised from here on, but I did come up with this on my own after seeing the visualisation. I guess my code is easy to understand for beginners as this problem is already cooking XD Code in Java -> class Solution { public int() productExceptSelf(int() nums) { int len = nums.length; int res() = new int(len); int prefix() = new int(len); int postfix() = new int(len); for(int i = 0; i < len; i++){ if(i==0){ prefix(i) = 1 * nums(i); continue; } prefix(i) = prefix(i-1) * nums(i); } for(int i = len - 1; i >= 0; i–){ if(i==len-1){ postfix(i) = 1 * nums(i); continue; } postfix(i) = postfix(i+1) * nums(i); } for(int i = 0; i < len; i++){ if(i==0){ res(i) = postfix(i+1); continue; } if(i==len-1){ res(i) = prefix(len-2); break; } int p1 = prefix(i-1); int p2 = postfix(i+1); res(i) = p1 * p2; } return res; } }
bro this problem has a better and more simple solution step 1 – just calculate the product of the whole array in this example the answer would be 1*2*3*4=24 step 2 – in the second step to calculate result ( i ) just divide the calculated result by nums ( i ) e.g to calculate result ( 0 ) = 24/1 =24 result ( 1 ) =24/2 =12 and so on
This was a particularily hard problem to wrap my head around. I came up with the following solution (similar but different). It was more intuitive for me. Hope this helps someone. You got this!! Intuition/Key Idea: The key observation here is that you can split the problem into two parts: Left Product: The product of all elements to the left of the current element. Right Product: The product of all elements to the right of the current element. By multiplying these two products, you get the desired value for each position in the result array. def productExceptSelf(self, nums: List(int)) -> List(int): n = len(nums) output_array =*n # calculate the left product left = 1 for i in range(n): output_array(i)=left left = left*nums(i) # calculate the right product right=1 for i in range(n-1, -1,-1): output_array(i)*=right right*=nums(i) return output_array
Can’t you just have a z pointer that goes through each element In the array and an i and j pointer that multiplies all elements before z and after z? That’s the solution I came up with and it looks like this: class Solution: def productExceptSelf(self, nums: List(int)) -> List(int): output = () for z in range(len(nums)): product = 1 for i in range(z + 1, len(nums)): product *= nums(i) for j in range(z – 1, -1, -1): product *= nums(j) output.append(product) return output
I got O(n) for this solution on my first try, this is the solution I came up with: def productExceptSelf(self, nums: List(int)) -> List(int): output = () numZeros = 0 prod = 1 for num in nums: if num == 0: numZeros += 1 else: prod *= num for num in nums: if num == 0: output.append if numZeros > 1 else output.append(int(prod)) else: output.append if numZeros > 0 else output.append(int(prod*(num**-1))) return output Is this a valid solution or cheating?
A cheeky solution is to notice that, in the problem constraints, the range of values in each element of the input array is fixed (an integer between -30 to 30, inclusive). So you can create an array of 61 elements to keep track of the number of appearances of the integers between -30 to 30, and then loop over that array (O time because it is an array of fixed size) to compute the product for each element of the returned array.
When calculating the prefix and postfix array values, you can omit the value in the array itself, so that in the final iteration of the loop you can avoid the slightly confusing way of doing prefix(i-1) * postfix(i+1) and instead just do prefix(i) * postfix(i); Also initialize both the first and last values of the preflix and postfix arrays with 1 respectively and then do something like this: for (let i=1; i=0; i–) { postfixArray(i) = postfixArray(i + 1) * nums(i+1); } for (let i=0; i
How did you think of this solution? My approach was to remove the current element and save in a “temporary” variable, multiply the remaining values in the list, then add the “temporary” variable back to the end of the list. LeetCode ended up telling me my implementation took too long so I came here to see a different approach. initial code: class Solution: def productExceptSelf(self, nums: List(int)) -> List(int): answer = () lenN = len(nums) for i in range(lenN): first_number = nums.pop(nums.index(nums)) answer.append(math.prod(nums)) nums.append(first_number) return answer
When I read “The product of any prefix or suffix of nums is guaranteed to fit in a 32-bit integer.” I wrongly thought they guarantee that our desired products will fit into integer, but product of the entire array not necessarily. My misinterpretation led me to solution with memoization. You can notice possible values nums(i) are quite limited. This means we need at most 61 traversals to find answer to any possible nums(i) value. My solution is obviously a little slower. Code below for anyone interested. class Solution { public: vector productExceptSelf(vector & nums) { unordered_map results; vector res(nums.size()); for(int i = 0; i < nums.size(); i++) { if(results.find(nums(i)) != results.end()) continue; results(nums(i)) = accumulate(nums.begin(), nums.begin() + i, 1, multiplies()) * accumulate(nums.begin() + i + 1, nums.end(), 1, multiplies()); if(results.size() == 61) break; } for(int i = 0; i < nums.size(); i++) { res(i) = results(nums(i)); } return res; } };
It is questions like this which makes learning dsa even more exciting. I know a lot of folks might be thinking am I crazy to say that but I see learning dsa as a cool skill which I can flex upon those who haven’t just practiced enough. Yes “practiced enough” coz eventually anybody who has practiced consistently months over months would be at this level of thought. Sounds crazy right?
If division is not allowed, then use right shift (bitwise :D) after multiplication of whole nums array. nums = (1, 2, 3, 4) Output: (24, 12, 8, 6) 1) multiplication_num = multiplication of whole num array # (24, 24, 24, 24, ) 2) multiplication_num >> nums 3) done btw: Python seems to have problems with >> ??