best video h aapka pure yt me..

But, can you solve the question without converting to String?

wow its good ty

Great video, simpler explanation!! I am struggling to understand this approach, Right after watching 4mins of your video, I totally understood this concept , Thanks a lot!

You can just return --> s.toLowerCase();

checking the array again with a new for loop is not optimal ig, try including that in the above loop itself!

how beautifully you explained it!!

Thanks

Wow!! What a code appreciable 🙏❤️

Is there sny second chance of writting the exam if we fail to get in first attempt

thankyou so much for these videos bro!

thanks

your count array should be of the size of maximum element+1

Greatly explained. Kudos, Bro.

why you did 2+2 when there was only single person on index 1

which ide u r using? or which code editor?

Good one

clear and straightforward explaination

waste of time

don't get how you are using masking...

U have to solve it using b.s

thanks

why merge function is given in void return type? As the output of the program should return an array, right? It means the return type should be int[], right? Please clarify!

😊😊😊

Thankyou ❤

What is the name of this method of solving the problem?

Why do you initially keep P1 on the 3rd position of nums [1] ?

Great thanks for come back...u patiently and clearly explain...

sir literally past week with help of your solutions and explanations I have done 14-15 ques of DSA your way of teaching is soo good ❤🙌

Thnaku so much for making these video please make it daily basic it give me a pattern how i solve these problem

Can we use startsWith method bro

Solved

Solved No leading and trailing space So we can split using single spce

Solved

Solved

bhai pls i want solution of lc contest too

Why 2 more while loop bro?

Super clean explanation

//The trick here is that : //Bitwise-AND of any two numbers will always produce a number less than or equal to the smaller number. /** 12 ---- 1100 11 ---- 1011 10 ---- 1010 9 ---- 1001 8 ---- 1000 7 ---- 0111 6 ---- 0110 5 ---- 0101 Desired Range: [5,12] Starting from 12, the loop will first do 12 & 11 = 8 Next iteration, the loop will do 8 & 7 = 0 why did we skip anding of 10,9? Because even if we did so, the result would eventually be anded with 8 whose value would be lesser than equal to 8. */ while(right>left){ right=right & right - 1; } return left & right;

class Solution { public int singleNumber(int[] nums) { int ones = 0, twos = 0; for (int num : nums) { // 'ones' keeps track of bits that have appeared 1 time (modulo 3) ones = (ones ^ num) & ~twos; // 'twos' keeps track of bits that have appeared 2 times (modulo 3) twos = (twos ^ num) & ~ones; } // The answer is in 'ones', since it represents the bits that appeared exactly once. return ones; } }

your solution is in O(n)2 complexity, please reduce TC for ur code.

please mntion topic name like linklist aray trees

//constant space public int rob(int[] nums) { int prevOfPrev = 0; int prev = nums[0];//phla ghar int cur = 0; for (int i = 2; i <= nums.length; i++) { int skipped = prev; int robbed = nums[i - 1] + prevOfPrev; cur = Math.max(robbed, skipped); prevOfPrev = prev; prev = cur; } return cur; } Here is the best solution

public int findPeakElement(int[] nums) { int left=0; int right=nums.length-1; while(left<right){ int mid=left+(right-left)/2; if(nums[mid]<nums[mid+1]){ left=mid+1; }else{ right=mid; } } return left; } why not using below code, explain while(left<=right)

Not a good solution Suppose we have a linked list 1 -> 2 -> 3 -> 4 -> 5 and n = 2. The goal is to remove the 2nd node from the end, which is 4. After removal, the modified list will be 1 -> 2 -> 3 -> 5. Diagram: Let's visually represent the process with a diagram: Initial Linked List: 1 -> 2 -> 3 -> 4 -> 5 We want to remove the 2nd node from the end, which means we need to find the node n positions from the end. In this case, n = 2. Using the two-pointer approach, we initialize two pointers, fast and slow, both pointing to the head of the linked list. We also create a dummy node (dummy) and set its next pointer to the head. dummy -> 1 -> 2 -> 3 -> 4 -> 5 fast slow Move fast n+1 steps ahead. In this case, move it 3 steps ahead (n + 1 = 3). dummy -> 1 -> 2 -> 3 -> 4 -> 5 fast slow Move both fast and slow pointers one step at a time until fast reaches the end. dummy -> 1 -> 2 -> 3 -> 4 -> 5 fast slow The n-th node from the end (in this case, 4) has been successfully removed. Finally, we return dummy.next as the new head of the modified linked list, which is 1 -> 2 -> 3 -> 5. below is the solution public ListNode removeNthFromEnd(ListNode head, int n) { ListNode dummy = new ListNode(0); dummy.next = head; ListNode fast = dummy; ListNode slow = dummy; // Move the fast pointer n+1 steps ahead for (int i = 0; i <= n; i++) { fast = fast.next; } // Move both pointers until the fast pointer reaches the end while (fast != null) { fast = fast.next; slow = slow.next; } //now slow is just before the element to be removed //so remove slow's next pointer and return head // Remove the nth node from the end slow.next = slow.next.next; return dummy.next; }

int colFlips = 0; for (int i = 0; i < cols; i++) { int[] column = new int[rows]; for (int j = 0; j < rows; j++) { column[j] = grid[j][i]; } colFlips += findMinFlips(column); } This part is confusing me

thank you shared the most understandable solution for this very tough question, if only you could explain a little bit more abt lambda epression used here would be great

Good ex[planatin

How do you pickup questions from leetcode? Can you guide me

bhai apna linkedIn account dena