From 992ce909015ebd7d8078fb2a64e122d3f29417b8 Mon Sep 17 00:00:00 2001
From: Khevna Khona <khkhona@microsoft.com>
Date: Sat, 31 Jan 2026 14:50:15 -0500
Subject: [PATCH 1/2] Completed Subsets problem

---
 Subsets.kt | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 Subsets.kt

diff --git a/Subsets.kt b/Subsets.kt
new file mode 100644
index 00000000..2a5385f6
--- /dev/null
+++ b/Subsets.kt
@@ -0,0 +1,29 @@
+// In this problem, we need to find all possible subsets of a given set of integers. We are using backtracking to explore all combinations. We maintain a path that represents the current subset being constructed. 
+//At each step, we have the choice to either include or exclude the current element. When we reach the end of the array, we add the current path to our result list.
+// Time complexity: O(n * 2^n) where n is the number of elements and 2^n is the no. of substes
+ // Space complexity : O(n)
+class Solution {
+    val result = mutableListOf<List<Int>>()
+    fun subsets(nums: IntArray): List<List<Int>> {
+        val path = mutableListOf<Int>()
+        helper(nums, 0, path)
+        return result
+    }
+    fun helper(nums: IntArray, i: Int,path: MutableList<Int>) {
+        //base
+        if(i == nums.size) {
+            result.add(path.toList())
+            return
+        }
+
+        //no choose
+        helper(nums, i + 1, path)
+        //choose
+        //action
+        path.add(nums[i])
+        //recurse
+        helper(nums, i+ 1, path)
+        //backtrack
+        path.removeAt(path.size - 1)
+    }
+}
\ No newline at end of file

From 7334e7e7f40eb70c81bd8b674611999a32be00e7 Mon Sep 17 00:00:00 2001
From: Khevna Khona <khkhona@microsoft.com>
Date: Sat, 31 Jan 2026 15:13:08 -0500
Subject: [PATCH 2/2] completed partitioning

---
 PalindromePartitioning.kt | 44 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 PalindromePartitioning.kt

diff --git a/PalindromePartitioning.kt b/PalindromePartitioning.kt
new file mode 100644
index 00000000..83af97d1
--- /dev/null
+++ b/PalindromePartitioning.kt
@@ -0,0 +1,44 @@
+// In this problem, we are using for loop based backtracking to find all possible palindrome partitioning of a given string. We maintain a path that represents the current partition being constructed. 
+// At each step, we explore if the substring from the current pivot to the current index is a palindrome or not. If it is we add it to path and recursively call the helper with updated pivot. 
+// When we reach the end of the string, we add the current path to our result list.
+// Time complexity: O(n * 2^n) where n is the length of the string and 2^n is the no. of possible partitions
+// Space complexity : O(n)
+
+class Solution {
+    val result = mutableListOf<List<String>>()
+    fun partition(s: String): List<List<String>> {
+        val path = mutableListOf<String>()
+        helper(s, 0, path)
+        return result
+    }
+
+    fun helper(s:String, pivot: Int, path: MutableList<String>) {
+        //base
+        if(pivot == s.length) {
+            result.add(path.toList())
+            return
+        }
+
+        for(i in pivot until s.length) {
+            val subStr = s.substring(pivot, i+1)
+            if(isPalindrome(subStr)) {
+                path.add(subStr)
+
+                helper(s, i + 1, path)
+
+                path.removeAt(path.lastIndex)
+            }
+        }
+    }
+
+    fun isPalindrome(s: String) : Boolean {
+        var left = 0 
+        var right = s.length - 1
+        while(left < right) {
+            if(s[left] != s[right]) return false
+            left++ 
+            right--
+        }
+        return true
+    } 
+}
\ No newline at end of file