hactoberfest-2024

.vscode/c_cpp_properties.json

@@ -0,0 +1,16 @@
+{
+    "configurations": [
+        {
+            "name": "Win32",
+            "includePath": [
+                "${workspaceFolder}/**"
+            ],
+            "defines": [
+                "_DEBUG",
+                "UNICODE",
+                "_UNICODE"
+            ]
+        }
+    ],
+    "version": 4
+}

.vscode/launch.json

@@ -0,0 +1,38 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "(gdb) Bash on Windows Launch",
+            "type": "cppdbg",
+            "request": "launch",
+            "program": "enter program name, for example ${workspaceFolder}/a.exe",
+            "args": [],
+            "stopAtEntry": false,
+            "cwd": "${fileDirname}",
+            "environment": [],
+            "externalConsole": false,
+            "pipeTransport": {
+                "debuggerPath": "/usr/bin/gdb",
+                "pipeProgram": "${env:windir}\\system32\\bash.exe",
+                "pipeArgs": ["-c"],
+                "pipeCwd": ""
+            },
+            "setupCommands": [
+                {
+                    "description": "Enable pretty-printing for gdb",
+                    "text": "-enable-pretty-printing",
+                    "ignoreFailures": true
+                },
+                {
+                    "description": "Set Disassembly Flavor to Intel",
+                    "text": "-gdb-set disassembly-flavor intel",
+                    "ignoreFailures": true
+                }
+            ]
+        }
+
+    ]
+}

0,1Knapsack Problem.cpp

@@ -0,0 +1,47 @@
+/* A Naive recursive implementation of
+0-1 Knapsack problem */
+#include <bits/stdc++.h>
+using namespace std;
+
+// A utility function that returns
+// maximum of two integers
+int max(int a, int b) { return (a > b) ? a : b; }
+
+// Returns the maximum value that
+// can be put in a knapsack of capacity W
+int knapSack(int W, int wt[], int val[], int n)
+{
+
+	// Base Case
+	if (n == 0 || W == 0)
+		return 0;
+
+	// If weight of the nth item is more
+	// than Knapsack capacity W, then
+	// this item cannot be included
+	// in the optimal solution
+	if (wt[n - 1] > W)
+		return knapSack(W, wt, val, n - 1);
+
+	// Return the maximum of two cases:
+	// (1) nth item included
+	// (2) not included
+	else
+		return max(
+			val[n - 1]
+				+ knapSack(W - wt[n - 1], wt, val, n - 1),
+			knapSack(W, wt, val, n - 1));
+}
+
+// Driver code
+int main()
+{
+	int profit[] = { 60, 100, 120 };
+	int weight[] = { 10, 20, 30 };
+	int W = 50;
+	int n = sizeof(profit) / sizeof(profit[0]);
+	cout << knapSack(W, weight, profit, n);
+	return 0;
+}
+
+// This code is contributed by rathbhupendra

0001.cpp

@@ -0,0 +1,15 @@
+class Solution {
+public:
+    vector<int> twoSum(vector<int>& nums, int target) {
+        unordered_map<int,int>mp;
+        int tmp;
+        for(int i=0;i<nums.size();i++){
+            tmp=target-nums[i];
+            if(mp.find(tmp)!=mp.end()){
+                return {mp[tmp],i};
+            }
+            mp[nums[i]]=i;
+        }
+        return{-1,-1};
+    }
+};

0078.cpp

@@ -0,0 +1,20 @@
+class Solution {
+public:
+    void helper(int idx,int n,vector<int>& nums,vector<int>& tmp,vector<vector<int>>& ans){
+        if(idx==n){
+            ans.push_back(tmp);
+            return;
+        }
+        tmp.push_back(nums[idx]);
+        helper(idx+1,n,nums,tmp,ans);
+        tmp.pop_back();
+        helper(idx+1,n,nums,tmp,ans);
+    }
+    vector<vector<int>> subsets(vector<int>& nums) {
+        vector<vector<int>>ans;
+        vector<int>tmp;
+        int n=nums.size();
+        helper(0,n,nums,tmp,ans);
+        return ans;
+    }
+};

0103.cpp

@@ -0,0 +1,46 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
+        vector<vector<int>>ans;
+        int flag=0;
+        if(root==NULL){
+            return ans;
+        }
+        queue<TreeNode*>q;
+        q.push(root);
+        while(!q.empty()){
+            int count=0;
+            vector<int>tmp;
+            int n=q.size();
+            for(int i=0;i<n;i++){
+                TreeNode* t=q.front();
+                q.pop();
+                tmp.push_back(t->val);
+                if(t->left){
+                    q.push(t->left);
+                }
+                if(t->right){
+                    q.push(t->right);
+                }    
+            }
+
+            if(flag%2!=0){
+                reverse(tmp.begin(),tmp.end());
+            }
+            flag++;
+            ans.push_back(tmp);
+        }
+        return ans;
+    }
+};

0112.cpp

@@ -0,0 +1,40 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    bool dfs(TreeNode* root,int targetSum){
+        if(root==NULL){
+            return false;
+        }
+        if(root->val==targetSum&&root->left==NULL&&root->right==NULL){
+            return true;
+        }
+
+        if(dfs(root->left,targetSum-root->val)){
+            return true;
+        }
+        if(dfs(root->right,targetSum-root->val)){
+            return true;
+        }
+
+        return false;
+    }
+    bool hasPathSum(TreeNode* root, int targetSum) {
+        // if(root==NULL){
+        //     return false;
+        // }
+        // if(root->val==targetSum){
+        //     return true;
+        // }
+        return dfs(root,targetSum);
+    }
+};

0113.cpp

@@ -0,0 +1,32 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    void dfs(TreeNode* root,int targetSum,vector<int>&tmp,vector<vector<int>>&ans){
+        if(root==NULL){
+            return;
+        }
+        tmp.push_back(root->val);
+        if(root->val==targetSum&&root->left==NULL&&root->right==NULL){
+            ans.push_back(tmp);
+        }
+        dfs(root->left,targetSum-root->val,tmp,ans);
+        dfs(root->right,targetSum-root->val,tmp,ans);
+        tmp.pop_back();
+    }
+    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
+        vector<vector<int>>ans;
+        vector<int>tmp;
+        dfs(root,targetSum,tmp,ans);
+        return ans;
+    }
+};

01_Bubble_Sort.cpp

@@ -0,0 +1,45 @@
+#include<iostream>
+using namespace std;
+
+/*
+Best Time Complexity : O(n)
+Average Time Complexity : O(n^2)
+Worst Time Complexity : O(n^2)
+Worst Space Complexity : O(1)
+*/
+
+void printArray(int A[], int n){
+    for (int i = 0; i < n; i++)
+    {
+        cout<<A[i]<<", ";
+    }
+    cout<<endl;
+}
+
+void bubbleSort(int A[], int n){
+    int temp;
+    for (int i = 0; i < n-1; i++) 
+    { 
+        for (int j = 0; j <n-1-i ; j++) 
+        {
+            if(A[j]>A[j+1]){
+                temp = A[j];
+                A[j] = A[j+1];
+                A[j+1] = temp; 
+            }
+        }  
+    } 
+}
+
+
+
+int main(){
+
+    int A[] = {1, 2, 5, 6, 12, 54, 625, 7, 23, 9, 987};
+
+    int n = 11;
+    printArray(A, n);
+    bubbleSort(A, n); 
+    printArray(A, n); 
+    return 0;
+}

01_Linear_Binary_Search.c

@@ -0,0 +1,66 @@
+#include <stdio.h>
+
+int linearSearch(int arr[], int size, int element)
+{
+    /*
+    Best Time Complexity : O(1)
+    Average Time Complexity : O(n)
+    Worst Time Complexity : O(n)
+    Worst Space Complexity : O(1)
+    */
+    for (int i = 0; i < size; i++)
+    {
+        if (arr[i] == element)
+        {
+            return i;
+        }
+    }
+    return -1;
+}
+
+int binarySearch(int arr[], int size, int element)
+{
+    /*
+    Best Time Complexity : O(1)
+    Average Time Complexity : O(logn)
+    Worst Time Complexity : O(logn)
+    Worst Space Complexity : O(1)
+    */
+
+    int low, mid, high;
+    low = 0;
+    high = size - 1;
+    // Keep searching until low <= high
+    while (low <= high)
+    {
+        mid = (low + high) / 2;
+        if (arr[mid] == element)
+        {
+            return mid;
+        }
+        if (arr[mid] < element)
+        {
+            low = mid + 1;
+        }
+        else
+        {
+            high = mid - 1;
+        }
+    }
+    return -1;
+}
+
+int main()
+{
+    // Unsorted array for linear search
+    // int arr[] = {1,3,5,56,4,3,23,5,4,54634,56,34};
+    // int size = sizeof(arr)/sizeof(int);
+
+    // Sorted array for binary search
+    int arr[] = {1, 3, 5, 56, 64, 73, 123, 225, 444};
+    int size = sizeof(arr) / sizeof(int);
+    int element = 444;
+    int searchIndex = binarySearch(arr, size, element);
+    printf("The element %d was found at index %d \n", element, searchIndex);
+    return 0;
+}