Відео

This is pure cringe.

This is not Java

Nice effort is applied in this video

Thanks 👍🏻

Thanks 👍🏻

I don't know what's this but lets go bro keep going 💪🏻

Ahh yes I do this all the time in the real world 💀

If you didnt use that cheap lazy ass AI voice over, you might not have needed 200 videos for 70 subs.

Piece of advice? Drop the lazy bullshit AI scripting and voice. Do your own shit. Be different. Not one of the million lazy shit ass yt pages ruining the platform.

Great Solution, Easy to understand and Optimal.

Right here there is no sense in double pointer technique. You can count the volume of the list first time, then get the middle in the second cycle - and it would be the same complexity. It would be the same amount of triggering of next pointers, the only advantage is in not adding the counter...

Smart!

why not just use a single while statement? As such: Node node = startNode; while (node.left != null) node = node.left

You should just subtract from tn instead of calculating the sum. You can also vectorize this operation.

god damn !

❤❤❤

You can also do (n & -n) == n

I wish spoken languages were like this. I've never wrote a lick of Java in my life but could understand this just fine 😂

que

as a computer engineering student, how the fuck did i never think of this

Neat, efficient code. But I'd probably slap you if I found that code uncommented in prod

holy shit

Nice

❤❤❤❤❤❤

'For we live by faith, not by sight.'

Wait.. How is this any different than simply being an anagram?

1235 Maximum Profit in Job Scheduling. To solve the problem of finding the maximum profit in job scheduling without overlapping time ranges, we can use dynamic programming. The idea is to sort the jobs by their end times and then iterate through the sorted jobs, at each step calculating the maximum profit that can be obtained by either taking the current job or not. This code defines a Job class to store the start time, end time, and profit of a job. The jobScheduling method first creates an array of Job objects and sorts them by their end times. It then uses dynamic programming to calculate the maximum profit at each step, storing the results in the dp array. The findLastNonConflictingJob method is a binary search helper function that finds the last job that does not conflict with the current job being considered. The time complexity of this solution is O(n log n) due to the sorting step and the binary search for each job. The space complexity is O(n) for the dp array and the jobs array. Here's a Java implementation of the solution: java import java.util.Arrays; class Solution { public int jobScheduling(int[] startTime, int[] endTime, int[] profit) { int n = startTime.length; Job[] jobs = new Job[n]; for (int i = 0; i < n; i++) { jobs[i] = new Job(startTime[i], endTime[i], profit[i]); } // Sort the jobs by their end time Arrays.sort(jobs, (a, b) -> a.end - b.end); // dp[i] will store the maximum profit by considering jobs[0...i] int[] dp = new int[n]; dp[0] = jobs[0].profit; for (int i = 1; i < n; i++) { // Profit including the current job int profitIncluding = jobs[i].profit; int lastIndex = findLastNonConflictingJob(jobs, i); if (lastIndex != -1) { profitIncluding += dp[lastIndex]; } // Maximum profit by excluding or including the current job dp[i] = Math.max(dp[i - 1], profitIncluding); } // The last element of dp will have the maximum profit return dp[n - 1]; } // Helper method to find the last job which doesn't conflict with the current job private int findLastNonConflictingJob(Job[] jobs, int index) { int low = 0, high = index - 1; while (low <= high) { int mid = (low + high) / 2; if (jobs[mid].end <= jobs[index].start) { if (jobs[mid + 1].end <= jobs[index].start) { low = mid + 1; } else { return mid; } } else { high = mid - 1; } } return -1; } // Job class to store the start time, end time, and profit of a job class Job { int start, end, profit; public Job(int start, int end, int profit) { this.start = start; this.end = end; this.profit = profit; } } }

🌸 'PromoSM'