package main

// ListNode ...
/* type ListNode struct {
	Val  int
	Next *ListNode
} */

/* func list2str(head *ListNode) string {
	curr := head
	str := make([]rune, 0)
	for curr != nil {
		str = append(str, rune(curr.Val+'0'))
		curr = curr.Next
	}
	return string(str)
} */

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func partition(head *ListNode, x int) *ListNode {
	if head == nil || head.Next == nil {
		return head
	}
	dummy := ListNode{0, head}
	fast, slow := &dummy, &dummy
	// slow -> body -> fast -> target -> tail
	// => slow -> target -> body -> fast -> tail
	// => slow -> body -> fast -> tail
	// or fast/slow -> tail
	for fast != nil {
		if fast.Next != nil && fast.Next.Val < x {
			if fast == slow {
				fast = fast.Next
			} else {
				tail := fast.Next.Next
				fast.Next.Next = slow.Next
				slow.Next = fast.Next
				fast.Next = tail
			}
			slow = slow.Next
		} else {
			fast = fast.Next
		}
	}
	return dummy.Next
}

/* func main() {
	l15 := ListNode{5, nil}
	l14 := ListNode{0, &l15}
	l13 := ListNode{6, &l14}
	l12 := ListNode{3, &l13}
	l1 := &ListNode{7, &l12}
	fmt.Println(list2str(partition(l1, 6)))
	fmt.Println(list2str(partition(nil, 9)))
	l23 := ListNode{3, nil}
	l22 := ListNode{2, &l23}
	l2 := &ListNode{1, &l22}
	fmt.Println(list2str(partition(l2, 9)))
}
*/