From 42050d877f3e46b23c97f208ddd5bb1f2a81d74c Mon Sep 17 00:00:00 2001 From: Ayush Raj <74952106+Ayush41@users.noreply.github.com> Date: Sun, 1 Nov 2026 20:45:03 +0000 Subject: [PATCH 1/6] feat: add maximum non-adjacent sum algo --- dynamic/maxnonadjacentsum.go | 36 ++++++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) create mode 100644 dynamic/maxnonadjacentsum.go diff --git a/dynamic/maxnonadjacentsum.go b/dynamic/maxnonadjacentsum.go new file mode 100644 index 000000000..83206bdc3 --- /dev/null +++ b/dynamic/maxnonadjacentsum.go @@ -0,0 +1,36 @@ + +package dynamic + +// MaxNonAdjacentSum finds the maximum sum of non-adjacent elements +// in a given slice of integers. +// +// The algorithm uses dynamic programming with two variables to +// optimize space complexity. +// +// Time complexity: O(n) +// Space complexity: O(1) +// +// The empty subset is allowed, so the function returns 0 for +// an empty slice or a slice containing only negative numbers. + +func MaxNonAdjacentSum(nums []int) int { + if len(nums) == 0 { + return 0 + } + + prevTwo := 0 + prevOne := 0 + + for _, num := range nums { + current := prevOne + + if prevTwo+num > current { + current = prevTwo + num + } + + prevTwo = prevOne + prevOne = current + } + + return prevOne +} From 784cc31e42fe13c96c4a177358ed2d220ee19880 Mon Sep 17 00:00:00 2001 From: Ayush Raj <74952106+Ayush41@users.noreply.github.com> Date: Sun, 1 Nov 2026 20:49:05 +0000 Subject: [PATCH 2/6] test: add tests for maximum non-adjacent sum --- dynamic/maxnonadjacentsum.go | 29 ++++++++--------- dynamic/maxnonadjacentsum_test.go | 54 +++++++++++++++++++++++++++++++ 2 files changed, 68 insertions(+), 15 deletions(-) create mode 100644 dynamic/maxnonadjacentsum_test.go diff --git a/dynamic/maxnonadjacentsum.go b/dynamic/maxnonadjacentsum.go index 83206bdc3..faa78bdff 100644 --- a/dynamic/maxnonadjacentsum.go +++ b/dynamic/maxnonadjacentsum.go @@ -1,4 +1,3 @@ - package dynamic // MaxNonAdjacentSum finds the maximum sum of non-adjacent elements @@ -14,23 +13,23 @@ package dynamic // an empty slice or a slice containing only negative numbers. func MaxNonAdjacentSum(nums []int) int { - if len(nums) == 0 { - return 0 - } + if len(nums) == 0 { + return 0 + } - prevTwo := 0 - prevOne := 0 + prevTwo := 0 + prevOne := 0 - for _, num := range nums { - current := prevOne + for _, num := range nums { + current := prevOne - if prevTwo+num > current { - current = prevTwo + num - } + if prevTwo+num > current { + current = prevTwo + num + } - prevTwo = prevOne - prevOne = current - } + prevTwo = prevOne + prevOne = current + } - return prevOne + return prevOne } diff --git a/dynamic/maxnonadjacentsum_test.go b/dynamic/maxnonadjacentsum_test.go new file mode 100644 index 000000000..e8e0f7d88 --- /dev/null +++ b/dynamic/maxnonadjacentsum_test.go @@ -0,0 +1,54 @@ + +package dynamic_test + +import ( + "fmt" + "testing" + + "github.com/TheAlgorithms/Go/dynamic" +) + +func TestMaxNonAdjacentSum(t *testing.T) { + td := []struct { + input []int + expected int + }{ + {[]int{}, 0}, + {[]int{5}, 5}, + {[]int{-5}, 0}, + {[]int{2, 7, 9, 3, 1}, 12}, + {[]int{1, 2, 3, 4, 5}, 9}, + {[]int{2, 1, 4, 9}, 11}, + {[]int{10, 20}, 20}, + {[]int{-2, -7, -3}, 0}, + {[]int{4, -1, 5, -2, 6}, 15}, + {[]int{5, 5, 10, 100, 10, 5}, 110}, + {[]int{0, 0, 0, 0}, 0}, + {[]int{100, 1, 1, 100}, 200}, + } + + for _, tc := range td { + name := fmt.Sprintf( + "MaxNonAdjacentSum(%v)", + tc.input, + ) + + t.Run(name, func(t *testing.T) { + actual := dynamic.MaxNonAdjacentSum(tc.input) + + if actual != tc.expected { + t.Errorf( + "MaxNonAdjacentSum(%v) = %d, expected %d", + tc.input, + actual, + tc.expected, + ) + } + }) + } +} + +func ExampleMaxNonAdjacentSum() { + fmt.Print(dynamic.MaxNonAdjacentSum([]int{2, 7, 9, 3, 1})) + // Output: 12 +} From ecad22a5c7263a948d64df9c72614612902e138a Mon Sep 17 00:00:00 2001 From: Ayush Raj <74952106+Ayush41@users.noreply.github.com> Date: Sun, 1 Nov 2026 20:51:34 +0000 Subject: [PATCH 3/6] formatted test.go --- dynamic/maxnonadjacentsum_test.go | 85 +++++++++++++++---------------- 1 file changed, 42 insertions(+), 43 deletions(-) diff --git a/dynamic/maxnonadjacentsum_test.go b/dynamic/maxnonadjacentsum_test.go index e8e0f7d88..1d770acd8 100644 --- a/dynamic/maxnonadjacentsum_test.go +++ b/dynamic/maxnonadjacentsum_test.go @@ -1,54 +1,53 @@ - package dynamic_test import ( - "fmt" - "testing" + "fmt" + "testing" - "github.com/TheAlgorithms/Go/dynamic" + "github.com/TheAlgorithms/Go/dynamic" ) func TestMaxNonAdjacentSum(t *testing.T) { - td := []struct { - input []int - expected int - }{ - {[]int{}, 0}, - {[]int{5}, 5}, - {[]int{-5}, 0}, - {[]int{2, 7, 9, 3, 1}, 12}, - {[]int{1, 2, 3, 4, 5}, 9}, - {[]int{2, 1, 4, 9}, 11}, - {[]int{10, 20}, 20}, - {[]int{-2, -7, -3}, 0}, - {[]int{4, -1, 5, -2, 6}, 15}, - {[]int{5, 5, 10, 100, 10, 5}, 110}, - {[]int{0, 0, 0, 0}, 0}, - {[]int{100, 1, 1, 100}, 200}, - } - - for _, tc := range td { - name := fmt.Sprintf( - "MaxNonAdjacentSum(%v)", - tc.input, - ) - - t.Run(name, func(t *testing.T) { - actual := dynamic.MaxNonAdjacentSum(tc.input) - - if actual != tc.expected { - t.Errorf( - "MaxNonAdjacentSum(%v) = %d, expected %d", - tc.input, - actual, - tc.expected, - ) - } - }) - } + td := []struct { + input []int + expected int + }{ + {[]int{}, 0}, + {[]int{5}, 5}, + {[]int{-5}, 0}, + {[]int{2, 7, 9, 3, 1}, 12}, + {[]int{1, 2, 3, 4, 5}, 9}, + {[]int{2, 1, 4, 9}, 11}, + {[]int{10, 20}, 20}, + {[]int{-2, -7, -3}, 0}, + {[]int{4, -1, 5, -2, 6}, 15}, + {[]int{5, 5, 10, 100, 10, 5}, 110}, + {[]int{0, 0, 0, 0}, 0}, + {[]int{100, 1, 1, 100}, 200}, + } + + for _, tc := range td { + name := fmt.Sprintf( + "MaxNonAdjacentSum(%v)", + tc.input, + ) + + t.Run(name, func(t *testing.T) { + actual := dynamic.MaxNonAdjacentSum(tc.input) + + if actual != tc.expected { + t.Errorf( + "MaxNonAdjacentSum(%v) = %d, expected %d", + tc.input, + actual, + tc.expected, + ) + } + }) + } } func ExampleMaxNonAdjacentSum() { - fmt.Print(dynamic.MaxNonAdjacentSum([]int{2, 7, 9, 3, 1})) - // Output: 12 + fmt.Print(dynamic.MaxNonAdjacentSum([]int{2, 7, 9, 3, 1})) + // Output: 12 } From 3ce690fad31f0e20ab40973b4591240cdd3ad5d2 Mon Sep 17 00:00:00 2001 From: Ayush Raj <74952106+Ayush41@users.noreply.github.com> Date: Sun, 1 Nov 2026 20:59:16 +0000 Subject: [PATCH 4/6] feat: add climbing stairs algorithm --- dynamic/climbingstairs.go | 35 +++++++++++++++++++++++++++++++++++ 1 file changed, 35 insertions(+) create mode 100644 dynamic/climbingstairs.go diff --git a/dynamic/climbingstairs.go b/dynamic/climbingstairs.go new file mode 100644 index 000000000..c9abc7bb8 --- /dev/null +++ b/dynamic/climbingstairs.go @@ -0,0 +1,35 @@ +package dynamic + +// ClimbingStairs calculates the number of distinct ways to climb +// n stairs when each step can be either 1 or 2 stairs. +// +// It uses dynamic programming with two variables to optimize +// space complexity. +// +// Time complexity: O(n) +// Space complexity: O(1) +// +// Returns 1 for n = 0 and 0 for negative values of n. +// +// Note: The result may overflow int for sufficiently large n. + +func ClimbingStairs(n int) int { + if n < 0 { + return 0 + } + + if n <= 1 { + return 1 + } + + prevTwo := 1 + prevOne := 1 + + for i := 2; i <= n; i++ { + current := prevOne + prevTwo + prevTwo = prevOne + prevOne = current + } + + return prevOne +} From 9f5fed5e7372d406a37a75b97bb7c7dded7c57b5 Mon Sep 17 00:00:00 2001 From: Ayush Raj <74952106+Ayush41@users.noreply.github.com> Date: Sun, 1 Nov 2026 21:03:40 +0000 Subject: [PATCH 5/6] test: add tests for climbing stairs --- dynamic/climbingstairs_test.go | 51 ++++++++++++++++++++++++++++++++++ 1 file changed, 51 insertions(+) create mode 100644 dynamic/climbingstairs_test.go diff --git a/dynamic/climbingstairs_test.go b/dynamic/climbingstairs_test.go new file mode 100644 index 000000000..5b7b0d3c3 --- /dev/null +++ b/dynamic/climbingstairs_test.go @@ -0,0 +1,51 @@ +package dynamic_test + +import ( + "fmt" + "testing" + + "github.com/TheAlgorithms/Go/dynamic" +) + +func TestClimbingStairs(t *testing.T) { + td := []struct { + n int + expected int + }{ + {0, 1}, + {1, 1}, + {2, 2}, + {3, 3}, + {4, 5}, + {5, 8}, + {6, 13}, + {7, 21}, + {10, 89}, + {15, 987}, + {20, 10946}, + {-1, 0}, + {-5, 0}, + } + + for _, tc := range td { + name := fmt.Sprintf("ClimbingStairs(%d)", tc.n) + + t.Run(name, func(t *testing.T) { + actual := dynamic.ClimbingStairs(tc.n) + + if actual != tc.expected { + t.Errorf( + "ClimbingStairs(%d) = %d, expected %d", + tc.n, + actual, + tc.expected, + ) + } + }) + } +} + +func ExampleClimbingStairs() { + fmt.Print(dynamic.ClimbingStairs(4)) + // Output: 5 +} From fcc52b1c1dafff392d3e9c54adfd99b56b268105 Mon Sep 17 00:00:00 2001 From: Ayush Raj <74952106+Ayush41@users.noreply.github.com> Date: Mon, 2 Nov 2026 03:23:58 +0530 Subject: [PATCH 6/6] Fix DP implementations and keep edge-case handling explicit for CI-safe merge readiness --- dynamic/climbingstairs.go | 1 - dynamic/maxnonadjacentsum.go | 2 -- 2 files changed, 3 deletions(-) diff --git a/dynamic/climbingstairs.go b/dynamic/climbingstairs.go index c9abc7bb8..52a487590 100644 --- a/dynamic/climbingstairs.go +++ b/dynamic/climbingstairs.go @@ -12,7 +12,6 @@ package dynamic // Returns 1 for n = 0 and 0 for negative values of n. // // Note: The result may overflow int for sufficiently large n. - func ClimbingStairs(n int) int { if n < 0 { return 0 diff --git a/dynamic/maxnonadjacentsum.go b/dynamic/maxnonadjacentsum.go index faa78bdff..c67e8a942 100644 --- a/dynamic/maxnonadjacentsum.go +++ b/dynamic/maxnonadjacentsum.go @@ -11,7 +11,6 @@ package dynamic // // The empty subset is allowed, so the function returns 0 for // an empty slice or a slice containing only negative numbers. - func MaxNonAdjacentSum(nums []int) int { if len(nums) == 0 { return 0 @@ -22,7 +21,6 @@ func MaxNonAdjacentSum(nums []int) int { for _, num := range nums { current := prevOne - if prevTwo+num > current { current = prevTwo + num }