Merge Nodes in Between Zeros - Leetcode 2181 - Python

[@coderunner743]

thanks, sir because of you I got placed in Zoho.

[@NeetCodeIO]

Congratulations so happy to hear that :)

[@arunmurugan7093]

I just want to say that ever since I started following your youtube channel and videos, I have been having an easier time coming up with solutions to a problem. Everytime before I watch your videos, I try to think of solution(s) and then I come here to see if I was on the right track and I have been doing great! It's great to see myself improve and it has all been because of your videos and my practice! Thank you for these videos and keep it up!

[@AJK-a2j00k4]

2nd approach is on different level!

[@galkk3]

my in-place solution: prev = head cur = head.next while cur: temp = 0 prev = prev.next while cur.val != 0: temp += cur.val cur = cur.next cur = cur.next prev.val = temp prev.next = cur return head.next

[@yang5843]

Thanks for uploading I was curious about the in place solution

[@shwethaks7994]

@NeetCodeIO can you make a video on giving tips regarding job search and some websites where we can apply. I think this would be very helpful to many people like me in the middle of a job hunt.

[@nirmalgurjar8181]

5:13, we can initialize cur = head.next in the start to avoid first 0 and only update return list when we get node.val == 0 instead checking node.next.val == 0, to reduce complexity and typo and potential bug in the code.

[@user-nt4se7vc8v]

Thanks, sir Could you please tell me the toll you use to take notes?

[@beinghappy9223]

class Solution: def mergeNodes(self, head: Optional[ListNode]) -> Optional[ListNode]: temp = head ans = ListNode(0) dummy = ans curr_sum = 0 while temp: if temp.val == 0: if curr_sum >0: dummy.next = ListNode(curr_sum) dummy = dummy.next curr_sum = 0 else: curr_sum += temp.val temp = temp.next return ans.next

[@kaunasmiit246]

I am recursively calling for each 0

[@zongyu100]

It seems like your in-place solution is still a bit complicated, could have just keep adding node values to the 0s and delete the last 0, since when you reaching right before the last 0, you could delete the last 0 by "if not cur.next.next: cur.next = cur.next.next"

[@nickleo4308]

crazy🥵

[@tuandino6990]

I did it without any knowledges regarding linked list, and after reading my code I dont know why it works

[@chien-yuyeh9386]

🥳

[@mohammedsuhail.s192]

# Definition for singly-linked list. class ListNode: def __init__(self, val=0, next=None): self.val = val self.next = next class Solution: def mergeNodes(self, head: Optional[ListNode]) -> Optional[ListNode]: li=[] li1=[] while head: li.append(head.val) head=head.next i=0 head=None while i

[@mohanedomer9081]

second comment

[@TheSambitDutta]

Very confusing explanation!! Like if you agree...

[@maestr3218]

/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNode(int val) { this.val = val; } * ListNode(int val, ListNode next) { this.val = val; this.next = next; } * } */ class Solution { public ListNode mergeNodes(ListNode head) { ListNode ansNode = new ListNode(0); ListNode dummy = ansNode; if(head == null) return null; ListNode flag = head; while(flag != null) { boolean present = false; int sum = 0; ListNode temp = flag; while(temp.val != 0) { present = true; sum += temp.val; temp = temp.next; } if(present = true) { ListNode node = new ListNode(sum); dummy.next = node; dummy = node; } flag = temp.next; } return ansNode.next.; } } can somone help ?? why my ans list is 0->4->11 for the first testcase even when im returning ansnode.next

[@yang5843]

My new list solution is simpler, skip the first 0, add a new node when we hit a 0 class Solution { public ListNode mergeNodes(ListNode head) { ListNode rc = new ListNode(); head = head.next; ListNode copy = rc; int cur = 0; while ( head!=null ) { if ( head.val == 0 ) { rc.next = new ListNode(cur); rc = rc.next; cur = 0; } cur += head.val; head = head.next; } return copy.next; } }

[@krityaan]

Using additional memory (creating a new node) could be viewed as inefficient during an interview. If you can't modify the original linked list, then this is preferred, but the challenge is to optimise time and space complexities