Delete N Nodes After M Nodes of a Linked List

ListNode* deleteNAfterM(ListNode* head, int m, int n) {
    ListNode* curr = head;
    while (curr) {
        // Skip m - 1 nodes (curr counts as 1).
        for (int i = 1; i < m && curr; ++i) curr = curr->next;
        if (!curr) break;
        // Delete next n nodes.
        ListNode* del = curr->next;
        for (int i = 0; i < n && del; ++i) {
            ListNode* nxt = del->next;
            delete del;
            del = nxt;
        }
        curr->next = del;
        curr = del;
    }
    return head;
}

func deleteNAfterM(head *ListNode, m, n int) *ListNode {
    curr := head
    for curr != nil {
        // Skip m - 1 nodes (curr counts as 1).
        for i := 1; i < m && curr != nil; i++ {
            curr = curr.Next
        }
        if curr == nil {
            break
        }
        // Delete next n nodes.
        del := curr.Next
        for i := 0; i < n && del != nil; i++ {
            del = del.Next
        }
        curr.Next = del
        curr = del
    }
    return head
}

from typing import Optional

class Solution:
    def deleteNAfterM(self, head: Optional['ListNode'], m: int, n: int) -> Optional['ListNode']:
        curr = head
        while curr:
            # Skip m - 1 nodes (curr counts as 1).
            for _ in range(m - 1):
                if not curr:
                    break
                curr = curr.next
            if not curr:
                break
            # Delete next n nodes.
            delete = curr.next
            for _ in range(n):
                if not delete:
                    break
                delete = delete.next
            curr.next = delete
            curr = delete
        return head

function deleteNAfterM(head, m, n) {
    let curr = head;
    while (curr) {
        // Skip m - 1 nodes (curr counts as 1).
        for (let i = 1; i < m && curr; i++) curr = curr.next;
        if (!curr) break;
        // Delete next n nodes.
        let del = curr.next;
        for (let i = 0; i < n && del; i++) del = del.next;
        curr.next = del;
        curr = del;
    }
    return head;
}

class Solution {
    public ListNode deleteNAfterM(ListNode head, int m, int n) {
        ListNode curr = head;
        while (curr != null) {
            // Skip m - 1 nodes (curr counts as 1).
            for (int i = 1; i < m && curr != null; i++) curr = curr.next;
            if (curr == null) break;
            // Delete next n nodes.
            ListNode del = curr.next;
            for (int i = 0; i < n && del != null; i++) del = del.next;
            curr.next = del;
            curr = del;
        }
        return head;
    }
}

function deleteNAfterM(head: ListNode | null, m: number, n: number): ListNode | null {
    let curr = head;
    while (curr) {
        // Skip m - 1 nodes (curr counts as 1).
        for (let i = 1; i < m && curr; i++) curr = curr.next;
        if (!curr) break;
        // Delete next n nodes.
        let del: ListNode | null = curr.next;
        for (let i = 0; i < n && del; i++) del = del.next;
        curr.next = del;
        curr = del;
    }
    return head;
}