From c8ad286ed717462f59ab04d6af78cabce28c1285 Mon Sep 17 00:00:00 2001
From: kalyan <kalyan.ng22@gmail.com>
Date: Mon, 13 Oct 2025 14:59:37 -0500
Subject: [PATCH] Competitive-Coding-2 solutions

---
 Problem1.java | 22 ++++++++++++++++++++++
 Problem2.java | 35 +++++++++++++++++++++++++++++++++++
 2 files changed, 57 insertions(+)

diff --git a/Problem1.java b/Problem1.java
index e69de29b..8a9c8f14 100644
--- a/Problem1.java
+++ b/Problem1.java
@@ -0,0 +1,22 @@
+//Two Sum problem
+// Time Complexity : O(n).
+// Space Complexity : O(n)
+// Did this code successfully run on Leetcode : Yes
+// Approach : As we have to check if the target can be achieved with addition of two numbers in the Array, I have calculated the difference by subtracting
+// target and nums[i]. Then we check in the HashMap if the differnce is present, if not we add to the HashMap.
+
+
+class Solution {
+    public int[] twoSum(int[] nums, int target) {
+        HashMap<Integer, Integer> map = new HashMap<>();
+        for(int i=0; i<nums.length; i++){
+            int diff = target - nums[i];
+            if(map.containsKey(diff)){
+                return new int[]{map.get(diff), i};//return if already present in hashmap
+            } else{
+                map.put(nums[i], i);// add to hashmap
+            }
+        }
+        return null;
+    }
+}
\ No newline at end of file
diff --git a/Problem2.java b/Problem2.java
index e69de29b..938c4147 100644
--- a/Problem2.java
+++ b/Problem2.java
@@ -0,0 +1,35 @@
+//0/1 knapsack problem
+
+// Time Complexity : O(n*W).
+// Space Complexity : O(n*W)
+// Did this code successfully run on Leetcode : Yes
+// Approach : I was asked to solve this problem in the mock interview. I did a exhaustive approach with binary trees and was getting 2^n time complexity.
+// Then I did a 2d matrix approach and was able to define a formula for picking and not picking the value. If we pick the value, we need to consider the
+// maximum of previous row value vs the value that satisfies the remaining weight criteria. And the last value of the matrix will be the solution. It can also
+// be implemented in 1D array as only previous array values are considered in formula calculation.
+
+
+public class Main
+{
+    public static int Knapsack(int[] val, int[] wt, int W){
+        int[][] dp = new int[wt.length+1][W+1];
+        for(int i=1;i<=wt.length;i++){ //loop over given weight array
+            for(int j=0;j<=W;j++){ //loop over weights to reach maximum
+
+                if(wt[i-1] <= j) { //condition for elements less than weight
+                    dp[i][j] = Math.max(dp[i-1][j], val[i - 1] + dp[i - 1][j - wt[i - 1]]); //picking the value
+                }else{
+                    dp[i][j] = dp[i-1][j];//not picking
+                }
+            }
+        }
+        return dp[wt.length][W];
+    }
+
+    public static void main(String args[]){
+        int[] val = {60,100,120};
+        int[] wt = {10,20,30};
+        int W = 50;
+        System.out.println(Knapsack(val, wt, W));
+    }
+}