Maximum Twin Sum of a Linked List

class Solution {
public:
    int pairSum(ListNode* head) {
        ListNode *slow = head, *fast = head;
        while (fast && fast->next) { slow = slow->next; fast = fast->next->next; }
        ListNode* prev = nullptr;
        while (slow) {
            ListNode* nxt = slow->next;
            slow->next = prev;
            prev = slow;
            slow = nxt;
        }
        int best = 0;
        ListNode *a = head, *b = prev;
        while (b) {
            best = max(best, a->val + b->val);
            a = a->next; b = b->next;
        }
        return best;
    }
};

func pairSum(head *ListNode) int {
    slow, fast := head, head
    for fast != nil && fast.Next != nil {
        slow = slow.Next
        fast = fast.Next.Next
    }
    var prev *ListNode
    for slow != nil {
        nxt := slow.Next
        slow.Next = prev
        prev = slow
        slow = nxt
    }
    best := 0
    a, b := head, prev
    for b != nil {
        if a.Val+b.Val > best {
            best = a.Val + b.Val
        }
        a = a.Next
        b = b.Next
    }
    return best
}

from typing import Optional

class Solution:
    def pairSum(self, head: Optional[ListNode]) -> int:
        slow, fast = head, head
        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
        prev = None
        while slow:
            nxt = slow.next
            slow.next = prev
            prev = slow
            slow = nxt
        best = 0
        a, b = head, prev
        while b:
            best = max(best, a.val + b.val)
            a = a.next
            b = b.next
        return best

function pairSum(head) {
    let slow = head, fast = head;
    while (fast && fast.next) {
        slow = slow.next;
        fast = fast.next.next;
    }
    let prev = null;
    while (slow) {
        const nxt = slow.next;
        slow.next = prev;
        prev = slow;
        slow = nxt;
    }
    let best = 0;
    let a = head, b = prev;
    while (b) {
        best = Math.max(best, a.val + b.val);
        a = a.next;
        b = b.next;
    }
    return best;
}

class Solution {
    public int pairSum(ListNode head) {
        ListNode slow = head, fast = head;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        ListNode prev = null;
        while (slow != null) {
            ListNode nxt = slow.next;
            slow.next = prev;
            prev = slow;
            slow = nxt;
        }
        int best = 0;
        ListNode a = head, b = prev;
        while (b != null) {
            best = Math.max(best, a.val + b.val);
            a = a.next;
            b = b.next;
        }
        return best;
    }
}

function pairSum(head: ListNode | null): number {
    let slow = head, fast = head;
    while (fast && fast.next) {
        slow = slow!.next;
        fast = fast.next.next;
    }
    let prev: ListNode | null = null;
    while (slow) {
        const nxt: ListNode | null = slow.next;
        slow.next = prev;
        prev = slow;
        slow = nxt;
    }
    let best = 0;
    let a: ListNode | null = head, b: ListNode | null = prev;
    while (b) {
        best = Math.max(best, (a as ListNode).val + b.val);
        a = (a as ListNode).next;
        b = b.next;
    }
    return best;
}