From 2ca8bb44278450e115c769db5cef2c81bdd09948 Mon Sep 17 00:00:00 2001
From: "M.V. Hutz" <git@maximhutz.me>
Date: Thu, 2 Apr 2026 15:43:24 +0200
Subject: [PATCH] feat: stuff

---
 .../main.go                                   |  2 +-
 .../main.go                                   | 55 ++++++++++++++-----
 pkg/questions/course_schedule/main.go         |  2 +-
 .../main.go                                   | 23 ++++++++
 pkg/questions/maximum_sliding_window/main.go  | 11 ++++
 .../minimum_window_substring/main.go          |  2 +-
 pkg/tools/heap/main.go                        | 35 ++++++++++++
 7 files changed, 113 insertions(+), 17 deletions(-)
 create mode 100644 pkg/questions/maximum-number-of-non-overlapping-palindrome-substrings/main.go
 create mode 100644 pkg/questions/maximum_sliding_window/main.go
 create mode 100644 pkg/tools/heap/main.go

diff --git a/pkg/questions/construct_binary_tree_from_preorder_and_inorder_traversal/main.go b/pkg/questions/construct_binary_tree_from_preorder_and_inorder_traversal/main.go
index 455a460..ee81890 100644
--- a/pkg/questions/construct_binary_tree_from_preorder_and_inorder_traversal/main.go
+++ b/pkg/questions/construct_binary_tree_from_preorder_and_inorder_traversal/main.go
@@ -43,7 +43,7 @@ func buildTreeInfo(info []NodeInfo) *TreeNode {
 	}
 }
 
-func buildTree(preorder []int, inorder []int) *TreeNode {
+func BuildTree(preorder []int, inorder []int) *TreeNode {
 	info_map := map[int]*NodeInfo{}
 	for o, v := range preorder {
 		info_map[v] = &NodeInfo{
diff --git a/pkg/questions/count_paths_that_can_form_a_palindrome_in_a_tree/main.go b/pkg/questions/count_paths_that_can_form_a_palindrome_in_a_tree/main.go
index 906ee96..d55fa2e 100644
--- a/pkg/questions/count_paths_that_can_form_a_palindrome_in_a_tree/main.go
+++ b/pkg/questions/count_paths_that_can_form_a_palindrome_in_a_tree/main.go
@@ -1,26 +1,53 @@
 package count_paths_that_can_form_a_palindrome_in_a_tree
 
-func isPalindromable(s string) bool {
-	set := map[rune]int{}
+type Node struct {
+	Mask     uint64
+	Children []*Node
+}
 
-	for _, b := range s {
-		set[b]++
+func toTree(parents []int, s string) *Node {
+	nodes := []*Node{}
+	for i := range s {
+		nodes = append(nodes, &Node{1 << (s[i] - 'a'), []*Node{}})
 	}
 
-	singletons := 0
-	for _, v := range set {
-		switch v {
-		case 1:
-			singletons++
-		case 2:
-		default:
-			return false
+	for child, parent := range parents {
+		if parent >= 0 {
+			nodes[parent].Children = append(nodes[parent].Children, nodes[child])
 		}
 	}
 
-	return singletons < 2
+	return nodes[0]
+}
+
+func doDFS(node *Node, path uint64, masks map[uint64]int64) {
+	if node == nil {
+		return
+	}
+
+	path ^= node.Mask
+
+	masks[path]++
+	for _, child := range node.Children {
+		doDFS(child, path, masks)
+	}
 }
 
 func CountPalindromePaths(parent []int, s string) int64 {
-	return 0
+	tree := toTree(parent, s)
+
+	masks := map[uint64]int64{}
+	doDFS(tree, 0, masks)
+
+	valid := int64(0)
+
+	for mask, count := range masks {
+		valid += count * (count + 1) / 2
+
+		for bit := range 26 {
+			valid += count * masks[mask^(1<<bit)]
+		}
+	}
+
+	return valid
 }
diff --git a/pkg/questions/course_schedule/main.go b/pkg/questions/course_schedule/main.go
index 2989ffc..c93dcd9 100644
--- a/pkg/questions/course_schedule/main.go
+++ b/pkg/questions/course_schedule/main.go
@@ -26,7 +26,7 @@ func visit(prereqs map[int][]int, temporary map[int]bool, permanent map[int]bool
 	return true
 }
 
-func canFinish(numCourses int, prerequisites [][]int) bool {
+func CanFinish(numCourses int, prerequisites [][]int) bool {
 	prereqs := map[int][]int{}
 	for _, p := range prerequisites {
 		class, prerequisite := p[0], p[1]
diff --git a/pkg/questions/maximum-number-of-non-overlapping-palindrome-substrings/main.go b/pkg/questions/maximum-number-of-non-overlapping-palindrome-substrings/main.go
new file mode 100644
index 0000000..bd92a00
--- /dev/null
+++ b/pkg/questions/maximum-number-of-non-overlapping-palindrome-substrings/main.go
@@ -0,0 +1,23 @@
+package maximumnumberofnonoverlappingpalindromesubstrings
+
+import (
+	"maps"
+	"slices"
+)
+
+func FindPalindromes(letters string) [][2]int {
+	L := map[[2]int]bool{}
+
+	for length := range letters {
+		for start := range len(letters) - length {
+			end := start + length
+			if length < 2 {
+				L[[2]int{start, end}] = true
+			} else {
+				L[[2]int{start, end}] = L[[2]int{start + 1, end - 1}] && letters[start] == letters[end]
+			}
+		}
+	}
+
+	return slices.Collect(maps.Keys(L))
+}
diff --git a/pkg/questions/maximum_sliding_window/main.go b/pkg/questions/maximum_sliding_window/main.go
new file mode 100644
index 0000000..16568a1
--- /dev/null
+++ b/pkg/questions/maximum_sliding_window/main.go
@@ -0,0 +1,11 @@
+package maximum_sliding_window
+
+import (
+	"git.maximhutz.com/practice/pkg/tools/heap"
+)
+
+func MaxSlidingWindow(nums []int, k int) []int {
+	h := heap.NewBy(heap.More, nums[:k]...)
+	result := []int{h.Data[0]}
+	return result
+}
diff --git a/pkg/questions/minimum_window_substring/main.go b/pkg/questions/minimum_window_substring/main.go
index a1f33c0..51ee8c8 100644
--- a/pkg/questions/minimum_window_substring/main.go
+++ b/pkg/questions/minimum_window_substring/main.go
@@ -74,7 +74,7 @@ func (s *Substring) CullRight(t Substring) {
 	}
 }
 
-func minWindow(s string, t string) string {
+func MinWindow(s string, t string) string {
 	ss, tt := NewSubstring(s), NewSubstring(t)
 	best_answer := ""
 
diff --git a/pkg/tools/heap/main.go b/pkg/tools/heap/main.go
new file mode 100644
index 0000000..ba1cf96
--- /dev/null
+++ b/pkg/tools/heap/main.go
@@ -0,0 +1,35 @@
+package heap
+
+import (
+	"cmp"
+	"container/heap"
+)
+
+type Heap[T any] struct {
+	Data     []T
+	lessFunc func(a, b T) bool
+}
+
+func More[T cmp.Ordered](x, y T) bool {
+	return !cmp.Less(x, y) && x != y
+}
+
+func NewBy[T any](lessFunc func(a, b T) bool, items ...T) *Heap[T] {
+	h := &Heap[T]{items, lessFunc}
+	heap.Init(h)
+	return h
+}
+
+func New[T cmp.Ordered](items ...T) *Heap[T] {
+	return NewBy[T](func(a, b T) bool { return a < b }, items...)
+}
+
+func (h Heap[T]) Len() int           { return len(h.Data) }
+func (h Heap[T]) Less(i, j int) bool { return h.lessFunc(h.Data[i], h.Data[j]) }
+func (h Heap[T]) Swap(i, j int)      { h.Data[i], h.Data[j] = h.Data[j], h.Data[i] }
+
+func (h *Heap[T]) Push(x any) { h.Data = append(h.Data, x.(T)) }
+func (h *Heap[T]) Pop() any {
+	defer func() { h.Data = h.Data[:len(h.Data)-1] }()
+	return h.Data[len(h.Data)-1]
+}