diff --git a/December 01/dec1.cpp b/December 01/dec1.cpp
new file mode 100644
index 0000000..7c21f85
--- /dev/null
+++ b/December 01/dec1.cpp	
@@ -0,0 +1,38 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+int main()
+{
+    cout<<"no of players:";
+    int n;
+    cin>>n;
+    
+    vector<int>runs;
+    
+    for(int i=0; i<n; i++)
+    {
+        int score;
+        cin>>score;
+        runs.push_back(score);
+    }
+    
+    int team_score;
+    
+    for(int i=0; i<n; i++)
+    {
+        team_score+=runs[i];
+    }
+    
+    cout<<team_score<<endl;
+    
+    int max_runs=*max_element(runs.begin(), runs.end());
+    for(int i=0; i<max_runs; i++)
+    {
+        if(runs[i]==max_runs)
+        {
+            cout<<i<<" ";
+        }
+    }
+    
+    return 0;
+}
diff --git a/December 02 /dec2.cpp b/December 02 /dec2.cpp
new file mode 100644
index 0000000..a89c602
--- /dev/null
+++ b/December 02 /dec2.cpp	
@@ -0,0 +1,53 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+vector<int> choice(vector<int> arr)
+{
+    vector<int> ans;
+    
+    unordered_map<int, int>mpp;
+
+    for (int i = 0; i < arr.size(); i++)
+    {
+        mpp[arr[i]]++;
+    }
+    
+    
+    for(int i=0; i<arr.size(); i++)
+    {
+        if(mpp[arr[i]]!=0)
+        {
+            ans.push_back(mpp[arr[i]]);
+        }
+        mpp[arr[i]]=0;
+        
+    }
+
+    return ans;
+}
+
+int main()
+{
+    int n;
+    cout << "Enter the size: ";
+    cin >> n;
+
+    vector<int> arr;
+
+    for (int i = 0; i < n; i++)
+    {
+        int a;
+        cin >> a;
+        arr.push_back(a);
+    }
+
+    vector<int> result = choice(arr);
+
+    cout << "Frequency of elements are: ";
+    for (int i = 0; i < result.size(); i++)
+    {
+        cout << result[i] << " ";
+    }
+
+    return 0;
+}
diff --git a/December 02/.gitignore b/December 02/.gitignore
deleted file mode 100644
index 8e0ca25..0000000
--- a/December 02/.gitignore	
+++ /dev/null
@@ -1,231 +0,0 @@
-# gitignore file for "A December of Algorithms 2023"
-# visit https://github.com/SVCE-ACM/A-December-of-Algorithms
-# Written individually to adjust for the needs of the problem
-
-# Byte-compiled / optimized / DLL files
-__pycache__/
-*.py[cod]
-*$py.class
-
-# C extensions
-*.so
-
-# node.js
-/node_modules
-package-lock.json
-
-# Distribution / packaging
-.Python
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-lib/
-lib64/
-parts/
-sdist/
-var/
-wheels/
-pip-wheel-metadata/
-share/python-wheels/
-*.egg-info/
-.installed.cfg
-*.egg
-MANIFEST
-
-# PyInstaller
-#  Usually these files are written by a python script from a template
-#  before PyInstaller builds the exe, so as to inject date/other infos into it.
-*.manifest
-*.spec
-
-# Installer logs
-pip-log.txt
-pip-delete-this-directory.txt
-
-# Unit test / coverage reports
-htmlcov/
-.tox/
-.nox/
-.coverage
-.coverage.*
-.cache
-nosetests.xml
-coverage.xml
-*.cover
-*.py,cover
-.hypothesis/
-.pytest_cache/
-
-# Translations
-*.mo
-*.pot
-
-# Django stuff:
-*.log
-local_settings.py
-db.sqlite3
-db.sqlite3-journal
-
-# Flask stuff:
-instance/
-.webassets-cache
-
-# Scrapy stuff:
-.scrapy
-
-# Sphinx documentation
-docs/_build/
-
-# PyBuilder
-target/
-
-# Jupyter Notebook
-.ipynb_checkpoints
-
-# IPython
-profile_default/
-ipython_config.py
-
-# pyenv
-.python-version
-
-# pipenv
-Pipfile.lock
-__pypackages__/
-
-# Celery stuff
-celerybeat-schedule
-celerybeat.pid
-
-# SageMath parsed files
-*.sage.py
-
-# Environments
-.env
-.venv
-env/
-venv/
-ENV/
-env.bak/
-venv.bak/
-
-# Spyder project settings
-.spyderproject
-.spyproject
-
-# Rope project settings
-.ropeproject
-
-# mkdocs documentation
-/site
-
-# mypy
-.mypy_cache/
-.dmypy.json
-dmypy.json
-
-# Pyre type checker
-.pyre/
-
-# Compiled class file
-*.class
-
-# Log file
-*.log
-
-# BlueJ files
-*.ctxt
-
-# Mobile Tools for Java (J2ME)
-.mtj.tmp/
-
-# Package Files #
-*.jar
-*.war
-*.nar
-*.ear
-*.zip
-*.tar.gz
-*.rar
-
-# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
-hs_err_pid*
-
-# Files and directories created by pub
-.dart_tool/
-.packages
-build/
-# If you're building an application, you may want to check-in your pubspec.lock
-pubspec.lock
-
-# Directory created by dartdoc
-# If you don't generate documentation locally you can remove this line.
-doc/api/
-
-# Avoid committing generated Javascript files:
-*.dart.js
-*.info.json      # Produced by the --dump-info flag.
-*.js             # When generated by dart2js. Don't specify *.js if your
-                 # project includes source files written in JavaScript.
-*.js_
-*.js.deps
-*.js.map
-
-# Prerequisites
-*.d
-
-# Compiled Object files
-*.slo
-*.lo
-*.o
-*.obj
-
-# Precompiled Headers
-*.gch
-*.pch
-
-# Compiled Dynamic libraries
-*.so
-*.dylib
-*.dll
-
-# Fortran module files
-*.mod
-*.smod
-
-# Compiled Static libraries
-*.lai
-*.la
-*.a
-*.lib
-
-# Executables
-*.exe
-*.out
-*.app
-
-# Executables
-*.exe
-*.out
-*.app
-*.i*86
-*.x86_64
-*.hex
-
-# Debug files
-*.dSYM/
-*.su
-*.idb
-*.pdb
-
-# Kernel Module Compile Results
-*.mod*
-*.cmd
-.tmp_versions/
-modules.order
-Module.symvers
-Mkfile.old
-dkms.conf
diff --git a/December 03/dec3.cpp b/December 03/dec3.cpp
new file mode 100644
index 0000000..b4d08dd
--- /dev/null
+++ b/December 03/dec3.cpp	
@@ -0,0 +1,31 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+int main()
+{
+    int n;
+    cout << "Enter the size: ";
+    cin >> n;
+
+    vector<int> arr;
+
+    for (int i = 0; i < n; i++)
+    {
+        int a;
+        cin >> a;
+        arr.push_back(a);
+    }
+    
+    int count=1;
+
+    for(int i=1; i<n; i++)
+    {
+        if(arr[i]>arr[i-1])
+        {
+            count++;
+        }
+    }
+    
+    
+    cout<<count;
+}
diff --git a/December 04/dec4.cpp b/December 04/dec4.cpp
new file mode 100644
index 0000000..ff11845
--- /dev/null
+++ b/December 04/dec4.cpp	
@@ -0,0 +1,54 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+void find(string str)
+{
+    unordered_map<int, string>mpp;
+    int count=0;
+    
+    for(int i=0; i<str.size(); i++)
+    {
+        for(int j=i+1; j<=str.size(); j++)
+        {
+            string sub=str.substr(i,j-1);
+            string revsub=sub;
+            reverse(revsub.begin(), revsub.end());
+            if(sub.size()>1 && sub==revsub)
+            {
+                mpp[sub.size()]=sub;
+                count++;
+            }
+        }
+    }
+    int mini=INT_MAX;
+    
+    if(count==0)
+    {
+        cout<<"Error";
+    }
+    
+    for(auto x: mpp)
+    {
+        if(x.first<mini)
+        {
+            mini=x.first;
+        }
+    }
+    
+    string res=mpp[mini];
+    cout<<res;
+    
+    
+}
+
+int main()
+{
+    cout<<"enter sentence:";
+    string str;
+    cin>>str;
+    
+    find(str);
+    
+    return 0;
+    
+}
diff --git a/December 05/dec5.cpp b/December 05/dec5.cpp
new file mode 100644
index 0000000..ad3bf79
--- /dev/null
+++ b/December 05/dec5.cpp	
@@ -0,0 +1,41 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+int find(vector<int>&nums)
+{
+    int sum=0, res=0;
+    for(int i=0; i<nums.size(); i++)
+    {
+        sum+=nums[i];
+    }
+    int avg=sum/nums.size();
+    
+    for(int i=0; i<nums.size(); i++)
+    {
+        if(nums[i]>=avg)
+        {
+            res+=nums[i];
+        }
+    }
+
+    return res;
+}
+
+int main()
+{
+    int n;
+    cout<<"enter size:";
+    cin>>n;
+    vector<int> nums;
+    for(int i=0; i<n; i++)
+    {
+        int a;
+        cin>>a;
+        nums.push_back(a);
+    }
+    
+    cout<<find(nums);
+    
+    return 0;
+    
+}
diff --git a/December 06/dec6.cpp b/December 06/dec6.cpp
new file mode 100644
index 0000000..82ea9a9
--- /dev/null
+++ b/December 06/dec6.cpp	
@@ -0,0 +1,57 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+vector<string> fin;
+int maxlen = 0;
+
+void helper(int tempSize,string prev, vector<string> arr, vector<string> temp) {
+
+    if(tempSize>maxlen){
+        fin=temp;
+        maxlen=tempSize;
+    }
+    for(size_t i=0; i < arr.size(); i++) {
+        if(tempSize == 0){
+            string tempStore=arr[i];
+            temp.push_back(tempStore);
+            arr[i]="-1";
+            helper(tempSize+1,tempStore,arr,temp);
+            arr[i]=tempStore;
+            temp.pop_back();
+            
+        }
+        else if(arr[i] != "-1") {
+            int count = 0;
+            for (int j = 0; j < prev.length(); j++) {
+                if(prev[j] != arr[i][j])
+                    count++;
+            }
+            if(count <= 1) {
+                string tempStore=arr[i];
+                arr[i] = "-1";
+                temp.push_back(tempStore);
+                helper(tempSize+1,tempStore,arr,temp);
+                arr[i]=tempStore;
+                temp.pop_back();
+            }
+            
+        }
+    }
+}
+
+int main() {
+    int n;
+    n=7;
+    vector<string> arr(n);
+    arr={"cat", "cot", "dot", "dog", "cog", "coat", "doll"};
+    helper(0,"",arr, {});
+    if(fin.size() == 1)
+        cout<<"No valid chain";
+    else{
+        for(string t:fin)
+            cout<<t<<" ";
+            cout<<endl;
+    }
+    return 0;
+}
diff --git a/December 07/dec7.cpp b/December 07/dec7.cpp
new file mode 100644
index 0000000..61a8983
--- /dev/null
+++ b/December 07/dec7.cpp	
@@ -0,0 +1,32 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+void find(int width, int height, int radius)
+{
+    float diagonal=sqrt(width*width + height*height);
+    float diameter=radius*2;
+    
+    if(diagonal>diameter)
+    {
+        cout<<"false";
+    }
+    else
+    {
+        cout<<"true";
+    }
+    
+}
+
+int main()
+{
+    cout<<"enter width,height,radius:";
+    int width,height,radius;
+    cin>>width;
+    cin>>height;
+    cin>>radius;
+    
+    find(width, height, radius);
+    
+    return 0;
+    
+}
diff --git a/December 08/dec8.cpp b/December 08/dec8.cpp
new file mode 100644
index 0000000..efc7b39
--- /dev/null
+++ b/December 08/dec8.cpp	
@@ -0,0 +1,43 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+
+int main() 
+{
+    int n;
+    cin>>n;
+    
+    vector<vector<int>> matrix(n, vector<int>(n,0));
+    int r=0, c=(n/2), cur_num=1;
+    
+    while(cur_num <= n*n) 
+    {
+        matrix[r][c] = cur_num;
+        cur_num++;
+        c=(c+1)%n;
+        r=r-1;
+        
+        if(r<0) r=n-1;
+        
+        if(matrix[r][c] != 0) 
+        {
+            c-=1;
+            if(c<0) c=n-1;
+            r=(r+2)%n;
+        }
+    }
+    
+    int maxDigits = to_string(n*n).length();
+    
+    for (vector<int> arr : matrix) 
+    {
+        for (int num : arr) 
+        {            
+            
+            cout << setw(maxDigits) << num << " ";
+        }
+        cout << endl;
+    }
+    
+    return 0;
+}
diff --git a/December 09/dec9.cpp b/December 09/dec9.cpp
new file mode 100644
index 0000000..00d1908
--- /dev/null
+++ b/December 09/dec9.cpp	
@@ -0,0 +1,23 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+int main() 
+{
+    int words = 0;
+    string str;
+    cout<<"enter String:";
+    cin>>str;
+    
+    for(int i=0; i<str.size(); i++) 
+    {
+        if(isupper(str[i]))
+        {
+            words++;
+        }
+            
+    }
+    
+    cout<<words;
+    
+    return 0;
+}
diff --git a/December 10/dec10.cpp b/December 10/dec10.cpp
new file mode 100644
index 0000000..c5219c6
--- /dev/null
+++ b/December 10/dec10.cpp	
@@ -0,0 +1,38 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+int main() {
+    set<string> tables{"emp"};
+    unordered_map<string, vector<string>> table_column_map{{"emp",{"empname"}}};
+    unordered_map<string, vector<string>> column_values{{"empname",{"Shivnash Kumar", "Ragul Gupta"}}};
+    string query, tableName, columnName;
+    int length, startIndex;
+    getline(cin, query);
+    
+    transform(query.begin(),query.end(),query.begin(),::tolower);
+    regex pattern(R"(select\s+substring\((\w+),(\d+),(\d+)\)\s+from\s+(\w+);)");
+
+    
+    smatch matches;
+    if (regex_match(query, matches, pattern)) {
+        // Extract the matched components
+        columnName = matches[1].str();
+        startIndex = stoi(matches[2].str())-1;  
+        length = stoi(matches[3].str());     
+        tableName = matches[4].str();
+    } 
+    else {
+        cout << "Invalid query format." << endl;
+    }
+    if(tables.find(tableName) == tables.end()) cout<<"Invalid Table Name";
+    auto it = table_column_map.find(tableName);
+    if (it == table_column_map.end() || find(it->second.begin(), it->second.end(), columnName) == it->second.end()) {
+        cout << "Column is not present in the table." << endl;
+    }
+    it = column_values.find(columnName);
+    for(string str: it->second) {
+        cout<<str.substr(startIndex, length)<<endl;
+    }
+    return 0;
+}
diff --git a/December 11/dec11.cpp b/December 11/dec11.cpp
new file mode 100644
index 0000000..0aa0ad8
--- /dev/null
+++ b/December 11/dec11.cpp	
@@ -0,0 +1,35 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+int main()
+{
+    int n;
+    cout<<"enter the no of input:";
+    cin>>n;
+    int sum=0;
+    for(int i=0;  i<n; i++)
+    {
+        int a;
+        cin>>a;
+        sum+=a;
+    }
+   
+    int binaryNum[32];
+    int i = 0;
+   
+    while (sum > 0)
+    {
+        binaryNum[i] = sum % 2;
+        sum = sum / 2;
+        i++;
+    }
+
+   
+    for (int j = i - 1; j >= 0; j--)
+    {
+        cout << binaryNum[j];
+    }
+   
+   
+    return 0;
+}
diff --git a/December 12/dec12.cpp b/December 12/dec12.cpp
new file mode 100644
index 0000000..e31b40a
--- /dev/null
+++ b/December 12/dec12.cpp	
@@ -0,0 +1,47 @@
+#include <iostream>
+#include <vector>
+#include <algorithm>
+
+using namespace std;
+
+bool binarySearch(vector<string> box, string target) {
+    int low = 0;
+    int high = box.size() - 1;
+
+    while (low <= high) {
+        int mid = low + (high - low) / 2;
+
+        if (box[mid] == target) {
+            return true;  // Gold found in this box
+        } else if (box[mid] < target) {
+            low = mid + 1;
+        } else {
+            high = mid - 1;
+        }
+    }
+
+    return false; 
+}
+
+string findGoldBox(vector<vector<string>> boxes) {
+    for (auto box = boxes.begin(); box != boxes.end(); box++) {
+        sort(box->begin(), box->end()); 
+        if (binarySearch(*box, "Gold")) 
+            return {"Box"+to_string(box-boxes.begin()+1)+" contains the Gold"};
+    }
+
+    return "Gold not found in any box";  // This should not happen if the input is valid
+}
+
+int main() {
+
+    vector<vector<string>> boxes = {
+        {"Emerald", "Ruby", "Bronze", "Silver"},
+        {"Gold", "Diamond", "Ruby", "Copper"},
+        {"Ruby", "Platinum", "Bronze", "Silver"}
+    };
+
+    cout << findGoldBox(boxes) << endl;
+
+    return 0;
+}
diff --git a/December 13/dec13.cpp b/December 13/dec13.cpp
new file mode 100644
index 0000000..acc4b85
--- /dev/null
+++ b/December 13/dec13.cpp	
@@ -0,0 +1,37 @@
+#include <iostream>
+using namespace std;
+int main() 
+{
+    string encrypted;
+    cout<<" encrypted string:";
+    cin >> encrypted;
+    
+    string decrypted= "";
+    for (char ch: encrypted) 
+    {
+        if ( isalpha(ch) ) 
+        {
+            if ( ch <= 'C' )
+                decrypted += '2';
+            else if ( ch <= 'F' )
+                decrypted += '3';
+            else if ( ch <= 'I' )
+                decrypted += '4';
+            else if ( ch <= 'L' )
+                decrypted += '5';
+            else if ( ch <= 'O' )
+                decrypted += '6';
+            else if ( ch <= 'S' )
+                decrypted += '7';
+            else if ( ch <= 'V' )
+                decrypted += '8';
+            else
+                decrypted += '9';
+        }
+        else
+            decrypted+= ch;
+    }
+    cout<<decrypted;
+    
+    return 0;
+}
diff --git a/December 14/dec14.cpp b/December 14/dec14.cpp
new file mode 100644
index 0000000..ad280fd
--- /dev/null
+++ b/December 14/dec14.cpp	
@@ -0,0 +1,153 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+struct Node
+{
+    int data;
+    Node* left;
+    Node* right;
+};
+
+Node* newNode(int val)
+{
+    Node* temp = new Node;
+    temp->data = val;
+    temp->left = NULL;
+    temp->right = NULL;
+    
+    return temp;
+}
+
+Node* buildTree(string str)
+{   
+
+    if(str.length() == 0 || str[0] == 'N')
+            return NULL;
+
+    vector<string> ip;
+    
+    istringstream iss(str);
+    for(string str; iss >> str; )
+        ip.push_back(str);
+        
+    Node* root = newNode(stoi(ip[0]));
+        
+    queue<Node*> queue;
+    queue.push(root);
+        
+    int i = 1;
+    while(!queue.empty() && i < ip.size()) {
+            
+
+        Node* currNode = queue.front();
+        queue.pop();
+            
+        string currVal = ip[i];
+            
+        if(currVal != "N") {
+                
+            currNode->left = newNode(stoi(currVal));
+                
+            queue.push(currNode->left);
+        }
+            
+        i++;
+        if(i >= ip.size())
+            break;
+        currVal = ip[i];
+            
+        if(currVal != "N") {
+                
+            currNode->right = newNode(stoi(currVal));
+                
+            queue.push(currNode->right);
+        }
+        i++;
+    }
+    
+    return root;
+}
+
+class Solution
+{
+private:
+
+public:
+    vector<int> nodes;
+    
+    void KDistanceNodesDown(Node* root, int k) {
+        if (root == NULL)
+            return;
+        if(k == 0) {
+            nodes.push_back(root->data);
+            return;
+        }
+        KDistanceNodesDown(root->left, k-1);
+        KDistanceNodesDown(root->right, k-1);
+        
+    }
+    
+    int helper(Node* root, int target, int k) {
+        if(root == NULL)
+            return -1;
+        if(root->data == target)
+        {
+            KDistanceNodesDown(root, k);
+            return 0;
+        }
+        int dl = helper(root->left, target, k);
+        if (dl != -1){
+            if (dl + 1 == k)
+                nodes.push_back(root->data);
+            else
+                KDistanceNodesDown(root->right, k-dl-2);
+            return 1 + dl;
+        }
+        int dr = helper(root->right, target, k);
+        if (dr != -1){
+            if (dr + 1 == k)
+                nodes.push_back(root->data);
+            else
+                KDistanceNodesDown(root->left, k-dr-2);
+            return 1 + dr;
+        }
+        return -1;
+    }
+    
+    vector <int> KDistanceNodes(Node* root, int target , int k)
+    {
+        nodes.clear();
+        helper(root, target, k);
+        sort(nodes.begin(), nodes.end());
+        return nodes;
+    }
+        
+};
+
+int main()
+{
+    
+    int t;
+    cin>>t;
+    getchar();
+    
+    Solution x = Solution();
+    
+    while(t--)
+    {
+        string s;
+        getline(cin,s);
+        Node* head = buildTree(s);
+        
+        int target, k;
+        cin>> target >> k;
+        getchar();
+        
+        vector <int> res = x.KDistanceNodes(head, target, k);
+        
+        for( int i=0; i<res.size(); i++ )
+            cout<< res[i] << " ";
+        cout<<endl;
+    }
+    return 0;
+}
diff --git a/December 15/dec15.cpp b/December 15/dec15.cpp
new file mode 100644
index 0000000..d0c8ac2
--- /dev/null
+++ b/December 15/dec15.cpp	
@@ -0,0 +1,45 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+int main() 
+{
+    string inputString;
+    cout<<" enter the word:";
+    cin>>inputString;
+    
+    int n = inputString.length();
+    
+    vector<string>subsequences;
+
+    for (int i = 0; i < (1 << n); i++) 
+    {
+       string subsequence;
+       
+       for (int j = 0; j < n; j++) 
+       {
+            if ((i & (1 << j)) > 0) 
+            {
+                subsequence += inputString[j];
+            }
+        }
+        
+        subsequences.push_back(subsequence);
+    }
+    
+    // for (int i=0; i<subsequences.size(); i++ )
+    // {
+    //     cout << subsequences[i] << " ";
+    // }
+    
+    set<string>st(subsequences.begin(), subsequences.end());
+    
+    //  for (const auto& element : st) {
+    //     std::cout << element << " ";
+    // }
+    
+    int l=st.size();
+    
+    cout<<l;
+    
+    return 0;
+}
diff --git a/December 16/dec16.cpp b/December 16/dec16.cpp
new file mode 100644
index 0000000..2290416
--- /dev/null
+++ b/December 16/dec16.cpp	
@@ -0,0 +1,101 @@
+#include<bits/stdc++.h>
+
+using namespace std;
+
+bool check(int x, int y, int m, int n) {
+    if(x >= 0 && y >= 0 && x < m && y < n) {
+        return true;
+    }
+    return false;
+}
+
+
+int calculate_time (vector<vector<int>>& grid) {
+    int time = 0;
+ 
+    queue<pair<int,int>> q;
+    int m = grid.size(), n = grid[0].size();
+   
+    for (int i = 0; i < m; i++)
+    {
+        for (int j = 0; j < n; j++)
+        {
+            if (grid[i][j] == 1)
+            {
+                q.push({i,j});
+            }
+        }
+    }
+
+  
+    int cur_queue_size = q.size(), next_queue_size = 0;
+
+    while (q.size() != 0)
+    {
+        
+        for (int i = 0; i < cur_queue_size; i++)
+        {
+            pair<int,int> coord = q.front();
+            q.pop();
+            int x = coord.first, y = coord.second;
+            //Checking up, down, left and right
+            if (check(x, y, m, n) && check(x-1, y, m, n) && grid[x-1][y] == 0)
+            {
+                q.push({x-1,y});
+                next_queue_size++;
+                grid[x-1][y] = 1;
+            }
+            if (check(x, y, m, n) && check(x+1, y, m, n) && grid[x+1][y] == 0)
+            {
+                q.push({x+1,y});
+                next_queue_size++;
+                grid[x+1][y] = 1;
+            }
+            if (check(x, y, m, n) && check(x, y-1, m, n) && grid[x][y-1] == 0)
+            {
+                q.push({x,y-1});
+                next_queue_size++;
+                grid[x][y-1] = 1;
+            }
+            if (check(x, y, m, n) && check(x, y+1, m, n) && grid[x][y+1] == 0)
+            {
+                q.push({x,y+1});
+                next_queue_size++;
+                grid[x][y+1] = 1;
+            }
+        }
+      
+        if (next_queue_size == 0)
+            break;
+        cur_queue_size = next_queue_size;
+        next_queue_size = 0;
+        time++;
+
+    }
+    
+    for (int i = 0; i < m; i++)
+    {
+        for (int j = 0; j < n; j++)
+        {
+            if (grid[i][j] == 0)
+            {
+                return -1;
+            }
+        }
+    }
+    return time;
+}
+
+int main()
+{
+    //The second test is incorrect. The time in minutes required to infect the entire city is 2 minutes and not 4.
+    vector<vector<int>> grid {
+                                {0, 1, 0, 0},
+                                {1, 1, 1, 1},
+                                {0, 1, -1, 0},
+                                {0, 0, 0, 0}
+                             };
+    // Calling the function to calculate the time taken to infect the city
+    cout << calculate_time(grid) << endl;
+    return 0;
+}
diff --git a/December 17/dec17.cpp b/December 17/dec17.cpp
new file mode 100644
index 0000000..7077c3e
--- /dev/null
+++ b/December 17/dec17.cpp	
@@ -0,0 +1,140 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+struct Node
+{
+    int data;
+    Node* next;
+    
+    Node(int val)
+    {
+        data = val;
+        next = NULL;
+    }
+};
+
+void loopHere(Node* head, Node* tail, int position)
+{
+    if(position==0) return;
+    
+    Node* walk = head;
+    for(int i=1; i<position; i++)
+        walk = walk->next;
+    tail->next = walk;
+}
+
+bool isLoop(Node* head)
+{
+    if(!head) return false;
+    
+    Node* fast = head->next;
+    Node* slow = head;
+    
+    while( fast != slow)
+    {
+        if( !fast || !fast->next ) return false;
+        fast=fast->next->next;
+        slow=slow->next;
+    }
+    
+    return true;
+}
+
+int length(Node* head)
+{
+    int ret = 0;
+    while(head)
+    {
+        ret++;
+        head = head->next;
+    }
+    return ret;
+}
+
+bool notOriginal(Node *head, unordered_map<Node *, int>&myMap){
+    
+    while(head){
+        if(myMap.find(head)==myMap.end()) return true;
+        if(myMap[head] != (head->data)) return true;
+        
+        head=head->next;
+    }
+}
+
+
+
+class Solution
+{
+    public:
+    //Function to remove a loop in the linked list.
+    void removeLoop(Node* head)
+    {
+
+        
+        Node *fast, *slow;
+        fast = slow = head;
+        while (fast != NULL && fast->next != NULL) {
+            fast = fast->next->next;
+            slow = slow-> next;
+            if(slow == fast) 
+                break;
+        }
+        if(slow != fast) {
+            //cout<<"No Loop detected!" << endl;
+            return;
+        }
+        slow = head;
+        if (slow == fast)
+            while (fast->next != slow)
+                fast = fast->next;
+        else {
+            while (slow->next != fast->next) {
+                slow = slow->next;
+                fast = fast->next;
+            }
+        }
+        fast->next = NULL;
+        return;
+    }
+};
+
+
+int main()
+{
+    int t;
+    cin>>t;
+    while(t--)
+    {
+        unordered_map<Node *, int>myMap;
+        
+        int n, num;
+        cin>>n;
+        
+        Node *head, *tail;
+        cin>> num;
+        head = tail = new Node(num);
+        
+        myMap[head]=num;
+        
+        for(int i=0 ; i<n-1 ; i++)
+        {
+            cin>> num;
+            tail->next = new Node(num);
+            tail = tail->next;
+            myMap[tail]=num;
+        }
+        
+        int pos;
+        cin>> pos;
+        loopHere(head,tail,pos);
+        
+        Solution ob;
+        ob.removeLoop(head);
+        
+        if( isLoop(head) || length(head)!=n || notOriginal(head, myMap))
+            cout<<"0\n";
+        else
+            cout<<"1\n";
+    }
+	return 0;
+}
diff --git a/December 18/dec18.cpp b/December 18/dec18.cpp
new file mode 100644
index 0000000..02b482f
--- /dev/null
+++ b/December 18/dec18.cpp	
@@ -0,0 +1,60 @@
+#include<bits/stdc++.h>
+
+using namespace std;
+
+void dfs(int src, int par, vector<int> edges[], vector<int>& arr) {
+    for (auto ch : edges[src]) {
+        if (ch == par) continue;
+        dfs(ch, src, edges, arr);
+        arr[src] += arr[ch];
+    }
+}
+
+int nCr(int n, int r) {
+    if (r > n) return 0;
+    
+    if (r == 0 || n == r) return 1;
+    
+    double res = 0;
+    for (int i = 0; i < r; i++) {
+  
+        res += log(n-i) - log(i+1);
+    }
+    return (int)round(exp(res));
+}
+
+int main()
+{
+    int t;
+    cin >> t;
+    while(t--) {
+        int n, x;
+        cin >> n >> x;
+        vector <int> arr(n+1);
+        for (int i = 1; i <= n; i++)
+        {
+            cin >> arr[i];
+        }
+        vector <int> edges [n+1];
+        for (int i = 0; i < n - 1; i++)
+        {
+            int u, v;
+            cin >> u >> v;
+            edges[u].push_back(v);
+            edges[v].push_back(u);
+        }
+        dfs(1,-1, edges, arr);
+        if (arr[1]%x != 0) {
+            for (int i = 1; i <= n; i++) 
+            cout << 0 << " "; 
+            cout << endl;
+            return 0;
+        }
+       
+        int ct = 0;
+        for (int i = 2; i <= n; i++) if (arr[i]%x == 0) ct++;
+
+        for (int i = 1; i <= n; i++) cout << nCr(ct, i-1) << " "; cout << endl;
+    }
+    return 0;
+}
diff --git a/December 19/dec19.cpp b/December 19/dec19.cpp
new file mode 100644
index 0000000..6a2e83e
--- /dev/null
+++ b/December 19/dec19.cpp	
@@ -0,0 +1,42 @@
+#include <iostream>
+#include <vector>
+#include <string>
+using namespace std;
+
+int sum_subsequence(vector<string>& sequence, int start, int end) {
+    int sum = 0;
+    for (int i = start; i <= end; i++) {
+        if (isdigit(sequence[i][0])) {
+            sum += stoi(sequence[i]);
+        }
+    }
+    return sum;
+}
+
+int symbolic_sum(vector<string>& sequence) {
+    int result = 0;
+    int n = sequence.size();
+    for (int i = 0; i < n; i++) {
+        if (sequence[i][0] == 'X') {
+            int multiplier = 1;
+            if (sequence[i].size() > 1) {
+                multiplier = stoi(sequence[i].substr(1));
+            }
+            int subsum = sum_subsequence(sequence, i, n - 1);
+            result += multiplier * subsum;
+        }
+    }
+    return result;
+}
+
+int main() {
+    vector<string> sequence1 = {"X3", "3", "X2", "2", "X1", "1", "4"};
+    int result1 = symbolic_sum(sequence1);
+    cout << result1 << endl;
+    
+    vector<string> sequence2 = {"X2", "1", "X3", "2", "3", "X2", "4", "X1", "5"};
+    int result2 = symbolic_sum(sequence2);
+    cout << result2 << endl;
+
+    return 0;
+}
diff --git a/December 20/dec20.cpp b/December 20/dec20.cpp
new file mode 100644
index 0000000..99481d8
--- /dev/null
+++ b/December 20/dec20.cpp	
@@ -0,0 +1,100 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+string min_dist(map<string,int>& distances, set<string>& spt_set) {
+    int n = distances.size();
+    string u;
+    int min = INT_MAX;
+    for (auto it: distances)
+    {
+        if (it.second < min && spt_set.find(it.first) == spt_set.end())        
+        {
+            u = it.first;
+            min = it.second;
+        }
+    }
+    return u;
+}
+
+void dijkstra(map<string, map<string, int>>& graph, map<string,int>& distances, map<string,string>& prev_node, set<string>& spt_set) {
+    int n = graph.size();
+    for (int i = 0; i < n-1; i++)
+    {
+        string u = min_dist(distances, spt_set);
+        spt_set.insert(u);
+        for (auto it:graph[u])
+        {
+            if (spt_set.find(it.first) == spt_set.end() && (distances[u] + it.second < distances[it.first]))
+            {
+                distances[it.first] = distances[u] + it.second;
+                prev_node[it.first] = u;
+            }
+        }
+    }
+}
+
+void print_path(map<string, string>& prev_node, string end_cave) {
+    if (end_cave == "")
+    {
+        return;
+    }
+    string prev_cave = prev_node[end_cave];
+    print_path(prev_node, prev_cave);
+    cout << end_cave <<" ";
+}
+
+int main() {
+//--------------------Input-----------------------------------
+    map<string, map<string, int>> graph = {
+        {{"Cave_A"},
+            {
+                {{"Cave_B"},{3}},
+                {{"Cave_C"}, {7}}
+            }
+        },
+        {{"Cave_B"},
+            {
+                {{"Cave_D"},{7}},
+                {{"Cave_E"}, {1}}
+            }
+        },
+        {{"Cave_C"},
+            {
+                {{"Cave_D"},{3}},
+            }
+        },
+        {{"Cave_D"},
+            {
+                {{"Cave_E"},{5}},
+            }
+        },
+        {{"Cave_E"},
+            {}
+        }
+    };
+    string start_cave = "Cave_A";
+    string end_cave = "Cave_E";
+    int n = graph.size();
+//------------------------------------------------------------    
+    set<string> spt_set;
+    map<string,int> distances {
+        {{"Cave_A"},{INT_MAX}},
+        {{"Cave_B"},{INT_MAX}},
+        {{"Cave_C"},{INT_MAX}},
+        {{"Cave_D"},{INT_MAX}},
+        {{"Cave_E"},{INT_MAX}}
+    };
+    map<string,string> prev_node {
+        {{"Cave_A"},{}},
+        {{"Cave_B"},{}},
+        {{"Cave_C"},{}},
+        {{"Cave_D"},{}},
+        {{"Cave_E"},{}}
+    };
+    distances[start_cave] = 0;
+    dijkstra(graph, distances, prev_node, spt_set);
+//------------------------------------------------------------
+    print_path(prev_node, end_cave);
+    cout << endl;
+    return 0;
+}
diff --git a/December 21/dec21.cpp b/December 21/dec21.cpp
new file mode 100644
index 0000000..a77b692
--- /dev/null
+++ b/December 21/dec21.cpp	
@@ -0,0 +1,39 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+string decryptMessage(string& code, int shift) 
+{
+    string decryptedMessage = "";
+
+    for (char ch : code) 
+    {
+        if (isalpha(ch)) 
+        {
+            char base = islower(ch) ? 'a' : 'A';
+            
+            // decryptedMessage += static_cast<char>((ch - base - shift + 26) % 26 + base);
+            decryptedMessage += 'A' + ((ch - base - shift + 26) % 26);
+        } 
+        
+        else 
+        {
+            decryptedMessage += ch;
+        }
+    }
+
+    return decryptedMessage;
+}
+int main() 
+{
+    string code;
+    cout << "Enter code: ";
+    cin >> code;
+
+    cout << "The Bomb location is: ";
+    for (int shift = 0; shift < 26; shift++) 
+    {
+        string decryptedMessage = decryptMessage(code, shift);
+        cout << decryptedMessage << " - Shift " << shift <<endl;
+    }
+    return 0;
+}
diff --git a/December 22/dec22.cpp b/December 22/dec22.cpp
new file mode 100644
index 0000000..78ddd53
--- /dev/null
+++ b/December 22/dec22.cpp	
@@ -0,0 +1,94 @@
+#include<bits/stdc++.h>
+
+using namespace std;
+
+
+bool check(int x, int y, int m, int n) {
+    if(x >= 0 && y >= 0 && x < m && y < n) {
+        return true;
+    }
+    return false;
+}
+
+
+int calculate_time (vector<vector<int>>& grid) {
+    int time = 0;
+    
+    queue<pair<int,int>> q;
+    int m = grid.size(), n = grid[0].size();
+    
+    for (int i = 0; i < m; i++)
+    {
+        for (int j = 0; j < n; j++)
+        {
+            if (grid[i][j] == 2)
+            {
+                q.push({i,j});
+            }
+        }
+    }
+
+    int cur_queue_size = q.size(), next_queue_size = 0;
+
+    while (q.size() != 0)
+    {
+        
+        for (int i = 0; i < cur_queue_size; i++)
+        {
+            pair<int,int> coord = q.front();
+            q.pop();
+            int x = coord.first, y = coord.second;
+            //Checking up, down, left and right
+            if (check(x, y, m, n) && check(x-1, y, m, n) && grid[x-1][y] == 1)
+            {
+                q.push({x-1,y});
+                next_queue_size++;
+                grid[x-1][y] = 2;
+            }
+            if (check(x, y, m, n) && check(x+1, y, m, n) && grid[x+1][y] == 1)
+            {
+                q.push({x+1,y});
+                next_queue_size++;
+                grid[x+1][y] = 2;
+            }
+            if (check(x, y, m, n) && check(x, y-1, m, n) && grid[x][y-1] == 1)
+            {
+                q.push({x,y-1});
+                next_queue_size++;
+                grid[x][y-1] = 2;
+            }
+            if (check(x, y, m, n) && check(x, y+1, m, n) && grid[x][y+1] == 1)
+            {
+                q.push({x,y+1});
+                next_queue_size++;
+                grid[x][y+1] = 2;
+            }
+        }
+       
+        if (next_queue_size == 0)
+            break;
+        cur_queue_size = next_queue_size;
+        next_queue_size = 0;
+        time++;
+
+    }
+    
+    for (int i = 0; i < m; i++)
+    {
+        for (int j = 0; j < n; j++)
+        {
+            if (grid[i][j] == 1)
+            {
+                return -1;
+            }
+        }
+    }
+    return time;
+}
+
+int main()
+{
+    vector<vector<int>> grid {{2,2,0,1}};
+    cout << calculate_time(grid) << endl;
+    return 0;
+}
diff --git a/December 23/dec23.cpp b/December 23/dec23.cpp
new file mode 100644
index 0000000..851945c
--- /dev/null
+++ b/December 23/dec23.cpp	
@@ -0,0 +1,32 @@
+#include <iostream>
+using namespace std;
+
+int main ()
+{
+    int n, upper_sum = 0, lower_sum = 0;
+    cin >> n;
+    bool s = false;
+    for (int i = 0; i < n; i++)
+    {
+        int x, y; 
+        cin >> x >> y;
+        if ((n == 1) && 
+            ((x % 2 != 0) || 
+            (y % 2 != 0)))
+        {
+            cout << -1;
+            return 0;
+        }
+        if (y % 2 + x % 2 == 1)
+            s = true;
+        upper_sum += x;
+        lower_sum += y;
+    }
+    if (upper_sum % 2 == 0 && lower_sum % 2 == 0) 
+        cout << "0" << endl;
+    else if (upper_sum % 2 == 1 && lower_sum % 2 == 1 && s) 
+        cout << "1" << endl;
+    else 
+        cout << "-1" << endl;
+    return 0;
+}
diff --git a/December 24/dec24.cpp b/December 24/dec24.cpp
new file mode 100644
index 0000000..f5a50cc
--- /dev/null
+++ b/December 24/dec24.cpp	
@@ -0,0 +1,70 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+int inversions = 0;
+void merge(int, int, int, vector<int>&);
+void merge_sort(int left, int right, vector<int>& arr) {
+    if(left >= right)
+        return ;
+    int mid = (left+right)/2;
+    merge_sort(left, mid, arr);
+    merge_sort(mid+1, right, arr);
+    merge(left, mid, right, arr);
+}
+
+void merge(int left, int mid, int right, vector<int>& arr) {
+    int i = left, j = mid+1, n = right-left+1;
+    // cout<<left<<" "<<mid<<" "<<right<<" "<<inversions<<endl;
+    vector<int> merged;
+    while (i <= mid && j <=right)
+    {
+        if (arr[i] < arr[j]) {
+            merged.push_back(arr[i]);
+            i++;
+        }
+        else {
+            merged.push_back(arr[j]);
+            inversions += (mid-i+1);
+            j++;
+        }
+    }
+    while (i <= mid) {
+        merged.push_back(arr[i]);
+        i++;
+    }
+    while (j <= right) {
+        merged.push_back(arr[j]);
+        j++;
+    }
+    for (int p = 0; p < n; ++p) {
+        arr[left + p] = merged[p];
+    }
+}
+
+void bruteforce(vector<int>& arr, int n) {
+    int count = 0;
+    for (int i = 0; i < n; i++)
+    {
+        for (int j = i + 1; j < n; j++)
+        {
+            if (arr[j] < arr[i])
+            {
+                count++;    
+            }
+            
+        }
+    }
+    cout << count << endl;
+}
+int main() {
+    int n;
+    cin >> n;
+    vector<int> arr(n);
+    for (int i = 0; i < n; i++)
+    {
+        cin >> arr[i];     
+    }
+    // bruteforce(arr, n);
+    merge_sort(0, n-1, arr);
+    cout << inversions << endl;
+}
diff --git a/December 25/dec25.cpp b/December 25/dec25.cpp
new file mode 100644
index 0000000..03b72e2
--- /dev/null
+++ b/December 25/dec25.cpp	
@@ -0,0 +1,53 @@
+
+#include<bits/stdc++.h>
+
+using namespace std;
+
+vector<int> minimumTime(int n, map<int, vector<int>>& graph)
+{
+    vector<int> ans(n+1, 0);
+    vector<int> indegree(n+1, 0);
+    queue<int> q;
+    for(int i = 1; i <= n; i++) {
+        for(int j = 0; j < graph[i].size(); j++) {
+            indegree[graph[i][j]]++;
+        }
+    }
+    for(int i = 1; i <= n; i++) {
+        if(indegree[i] == 0) {
+            q.push(i);
+            ans[i] = 1;
+        }
+    }
+    while(!q.empty()) {
+        int u = q.front();
+        q.pop();
+        for(int i:graph[u]) {
+            indegree[i]--;
+            if(indegree[i] == 0) {
+                q.push(i);
+                ans[i] = ans[u] + 1;
+            }
+        }
+    }
+    ans.erase(ans.begin()+0);
+    return ans;
+}
+
+int main()
+{
+    vector<int> tasks = {1, 2, 3, 4, 5};
+    vector<vector<int>> dependencies = {{}, {1}, {2}, {3}, {4,1}};
+    map<int, vector<int>> g;
+    for (int i = 0; i < dependencies.size(); i++)
+    {
+        if(dependencies[i].size() == 0) g[tasks[i]] = {};
+        for(int j = 0; j < dependencies[i].size(); j++)
+            g[dependencies[i][j]].push_back(tasks[i]);
+    }
+    int n = tasks.size();
+    vector<int> ans = minimumTime(n, g);
+
+    cout<<*max_element(ans.begin(), ans.end());
+    return 0;
+}
diff --git a/December 26/dec26.cpp b/December 26/dec26.cpp
new file mode 100644
index 0000000..77facaa
--- /dev/null
+++ b/December 26/dec26.cpp	
@@ -0,0 +1,87 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+struct Node
+{
+    int data;
+    Node* next;
+    
+    Node(int val)
+    {
+        data = val;
+        next = NULL;
+    }
+};
+
+void loopHere(Node* head, Node* tail, int position)
+{
+    if(position==0) return;
+    
+    Node* walk = head;
+    for(int i=1; i<position; i++)
+        walk = walk->next;
+    tail->next = walk;
+}
+
+class Solution
+{
+    public:
+    void detectLoop(Node* head)
+    {
+        
+        Node *fast, *slow;
+        fast = slow = head;
+        while (fast != NULL && fast->next != NULL) {
+            fast = fast->next->next;
+            slow = slow-> next;
+            if(slow == fast) 
+                break;
+        }
+        if(slow != fast) {
+            cout<<"No Loop detected!" << endl;
+            return;
+        }
+        slow = head;
+        if (slow == fast)
+            while (fast->next != slow)
+                fast = fast->next;
+        else {
+            while (slow->next != fast->next) {
+                slow = slow->next;
+                fast = fast->next;
+            }
+        }
+        fast->next = NULL;
+        return;
+    }
+};
+
+int main()
+{
+    int t;
+    cin>>t;
+    while(t--)
+    {
+        int n, num;
+        cin>>n;
+        
+        Node *head, *tail;
+        cin>> num;
+        head = tail = new Node(num);
+        
+        for(int i=0 ; i<n-1 ; i++)
+        {
+            cin>> num;
+            tail->next = new Node(num);
+            tail = tail->next;
+        }
+        
+        int pos;
+        cin>> pos;
+        loopHere(head,tail,pos);
+        
+        Solution ob;
+        ob.detectLoop(head);
+    }
+	return 0;
+}
diff --git a/December 27/dec27.cpp b/December 27/dec27.cpp
new file mode 100644
index 0000000..dec01c8
--- /dev/null
+++ b/December 27/dec27.cpp	
@@ -0,0 +1,40 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+int find_start(int n, vector<int>& petrol, vector<int>& distance)
+{
+    int start = 0; 
+    int end = 1; 
+    int curr_petrol = petrol[start] - distance[start]; 
+    while (end != start || curr_petrol < 0) 
+    { 
+        while (curr_petrol < 0 && start != end) 
+        { 
+            curr_petrol -= petrol[start] - distance[start]; 
+            start = (start + 1) % n; 
+            if (start == 0) 
+               return -1; 
+        } 
+ 
+        curr_petrol += petrol[end] - distance[end]; 
+        end = (end + 1) % n; 
+    } 
+    return start;
+}
+
+
+int main() {
+    int N = 4;
+    vector<int> Petrol {4, 6, 7, 4};
+    vector<int> Distance {6, 5, 3, 5};
+    int out = find_start(N, Petrol, Distance);
+    if(out != -1) out++;
+    cout << out << endl;
+    N = 5;
+    Petrol = {2, 3, 7, 4, 5};
+    Distance = {6, 5, 3, 5, 3};
+    out = find_start(N, Petrol, Distance);
+    if(out != -1) out++;
+    cout << out << endl;
+    return 0;
+}
diff --git a/December 28/dec28.cpp b/December 28/dec28.cpp
new file mode 100644
index 0000000..484e561
--- /dev/null
+++ b/December 28/dec28.cpp	
@@ -0,0 +1,63 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+class i {
+    
+    public:
+    int k,r,m,n;
+    i(int k, int r, int m, int n) {
+        this->k=k;
+        this->r=r;
+        this->m=m;
+        this->n=n;
+    }
+};
+
+class c {
+    
+    public:
+    int k, r;
+    c(int k, int r) {
+        this->k=k;
+        this->r=r;
+    }
+};
+
+int main() {
+    int x = 3;
+    int z = 3;
+    i items[] = {
+        i(10,100,5,110),
+        i(9,200,2,200),
+        i(20,200,30,300)
+    };
+    c clients[] = {
+        c(5,100),
+        c(9,500),
+        c(20,400)
+    };
+    sort(items, items+x, [&](i& i1, i& i2) {
+        return i1.m < i2.m;
+    });
+    sort(clients, clients+z, [&](c& c1, c& c2) {
+        return c1.k > c2.k;
+    });
+    vector<bool> sold(x,false);
+    int count = 0;
+    for(c client: clients) {
+
+        for (int i = 0; i < x; i++)
+        {
+            if(!sold[i] && items[i].m >= client.k && items[i].n <= client.r) {
+                sold[i] = true;
+                count++;
+                break;
+            }
+        }
+        
+    }
+    cout << count << endl;
+
+    return 0;
+}
diff --git a/December 29/dec29.cpp b/December 29/dec29.cpp
new file mode 100644
index 0000000..f2a58a6
--- /dev/null
+++ b/December 29/dec29.cpp	
@@ -0,0 +1,33 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+int main() {
+    int cur_x = 0, cur_y = 0, time = 0;
+    vector<char> walk = {'w', 'e', 'w', 'e', 'w', 'e', 'w', 'e', 'w', 'n'};
+    for (int i = 0; i < walk.size(); i++)
+    {
+        if (walk[i] == 'n')
+        {
+            cur_y++;
+            time++;
+        }
+        else if (walk[i] == 's')
+        {
+            cur_y--;
+            time++;
+        }
+        else if (walk[i] == 'e')
+        {
+            cur_x++;
+            time++;
+        }
+        else
+        {
+            cur_x--;
+            time++;
+        }
+    }
+    if(!cur_x && !cur_y && time == 10) cout<<"TRUE";
+    else cout<<"FALSE";
+    return 0;
+}
diff --git a/December 30/dec30.cpp b/December 30/dec30.cpp
new file mode 100644
index 0000000..ee36cb8
--- /dev/null
+++ b/December 30/dec30.cpp	
@@ -0,0 +1,122 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+vector<int> shortestPath(int n, vector<int> tree[], int start, int end) {
+    vector<int> distance(n+1, -1);
+    vector<int> parent(n+1, -1);
+
+    queue<int> q;
+    q.push(start);
+    distance[start] = 0;
+
+    while (!q.empty()) {
+        int current = q.front();
+        q.pop();
+
+        for (int neighbor : tree[current]) {
+            if (distance[neighbor] == -1) {
+                distance[neighbor] = distance[current] + 1;
+                parent[neighbor] = current;
+                q.push(neighbor);
+            }
+        }
+    }
+
+    vector<int> path;
+    int current = end;
+
+    while (current != start) {
+        path.push_back(current);
+        current = parent[current];
+    }
+
+    path.push_back(start);
+    reverse(path.begin(), path.end());
+
+    return path;
+}
+
+int inversions = 0;
+void merge(int left, int mid, int right, vector<int>& arr) {
+    int i = left, j = mid+1, n = right-left+1;
+    vector<int> merged;
+    while (i <= mid && j <=right)
+    {
+        if (arr[i] <= arr[j]) {
+            merged.push_back(arr[i]);
+            i++;
+        }
+        else {
+            merged.push_back(arr[j]);
+            inversions += (mid-i+1);
+            j++;
+        }
+    }
+    while (i <= mid) {
+        merged.push_back(arr[i]);
+        i++;
+    }
+    while (j <= right) {
+        merged.push_back(arr[j]);
+        j++;
+    }
+    for (int p = 0; p < n; ++p) {
+        arr[left + p] = merged[p];
+    }
+}
+
+void merge_sort(int left, int right, vector<int>& arr) {
+    if(left >= right)
+        return ;
+    int mid = (left+right)/2;
+    merge_sort(left, mid, arr);
+    merge_sort(mid+1, right, arr);
+    merge(left, mid, right, arr);
+}
+
+int main() {
+    int n; 
+    int q; 
+    cin >> n;
+    cin >> q;
+
+    unordered_set<int> nodes;
+    vector<int> color(n+1); // Colors of each vertices
+    for (int i = 1; i <= n; i++)
+    {
+        cin >> color[i];
+        nodes.insert(i);
+    }
+
+    vector<int> tree[n+1];
+    for (int i = 1; i < n; ++i) {
+        int x, y;
+        cin >> x >> y;
+        tree[x].push_back(y);
+        tree[y].push_back(x);
+    }
+
+    while(q > 0)
+    {
+        int x, y; // Starting and ending nodes of the path
+        cin >> x >> y;
+
+        vector<int> path = shortestPath(n, tree, x, y);
+        vector<int> query_path;
+        for (int node : path) {
+            query_path.push_back(color[node]);
+        }
+        vector<int> query_path_reverse(query_path.begin(), query_path.end());
+        reverse(query_path_reverse.begin(), query_path_reverse.end());
+        inversions = 0;
+        merge_sort(0, path.size() - 1, query_path);
+        int f = inversions;
+        inversions = 0;
+        merge_sort(0, path.size() - 1, query_path_reverse);
+        f += inversions;
+        cout << f << endl;
+        q--;
+    }
+
+    return 0;
+}
diff --git a/December 31/dec31.cpp b/December 31/dec31.cpp
new file mode 100644
index 0000000..bee7d8f
--- /dev/null
+++ b/December 31/dec31.cpp	
@@ -0,0 +1,70 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+bool isSafe(vector<vector<int>>& board, int row, int col)
+{
+    int i, j;
+    int N = board.size();
+    for (i = 0; i < col; i++)
+        if (board[row][i])
+            return false;
+    for (i = row, j = col; i >= 0 && j >= 0; i--, j--)
+        if (board[i][j])
+            return false;
+    for (i = row, j = col; j >= 0 && i < N; i++, j--)
+        if (board[i][j])
+            return false;
+ 
+    return true;
+}
+
+bool n_queen(int n, vector<vector<int>>& board, int col, vector<vector<pair<int, int>>>& ans) {
+    if(col >= n) {
+        vector<pair<int,int>> temp;
+        for(int i = 0; i < n; i++) {
+            for(int j = 0; j < n; j++) {
+                if(board[i][j] == 1) {
+                    temp.push_back({i+1,j+1});
+                }
+            } 
+        }
+        ans.push_back(temp);
+        return true;
+    }
+    bool res = false;
+    for (int i = 0; i < n; i++) {
+        if (isSafe(board, i, col)) {
+            board[i][col] = 1;
+            res = n_queen(n, board, col + 1, ans) || res;
+            board[i][col] = 0; 
+        }
+    }
+    return res;
+}
+
+void driver(int n, vector<vector<int>>& board, vector<vector<pair<int, int>>>& ans) {
+    
+    if(!n_queen(n, board, 0, ans)) {
+        cout << "No Solution found!" << endl;
+        return;
+    }
+    else {
+        sort(ans.begin(), ans.end());
+        for(vector<pair<int,int>> sol: ans) {
+            for(pair<int,int> coord: sol) {
+                cout<<"("<<coord.first<<","<<coord.second<<") ";
+            }
+            cout<<endl;
+        }
+        return;
+    }
+}
+
+
+int main() {
+    int n = 8;
+    vector<vector<int>> board(n, vector<int>(n, 0));
+    vector<vector<pair<int, int>>> ans;
+    driver(n, board, ans);
+    return 0;
+}