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!
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.
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
@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.
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"
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; } }
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
# 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
thanks, sir because of you I got placed in Zoho.
Congratulations so happy to hear that :)
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!
2nd approach is on different level!
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.
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
Thanks, sir
Could you please tell me the toll you use to take notes?
Thanks for uploading
I was curious about the in place solution
@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.
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
why did we not return cur
I am recursively calling for each 0
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"
crazy🥵
I did it without any knowledges regarding linked list, and after reading my code I dont know why it works
second comment
🥳
Very confusing explanation!!
Like if you agree...
/**
* 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
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;
}
}
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
# 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