diff --git a/2160. Minimum Sum of Four Digit Number After Splitting Digits b/2160. Minimum Sum of Four Digit Number After Splitting Digits
new file mode 100644
index 0000000..6876265
--- /dev/null
+++ b/2160. Minimum Sum of Four Digit Number After Splitting Digits	
@@ -0,0 +1,61 @@
+/*
+Get all digits of num.
+Sort them.
+To get the minimum sum. We need to choose 1st and 2nd digits as tens digits and 3rd and 4th as ones digits.
+As when the tens digits will be minimum, then only we will get minimum sum.
+For example:
+5643=>3,4,5,6
+30+40+5+6=86(min)
+
+Other possibilities:
+30+50+4+6=90
+30+60+4+5=101
+40+50+4+6=100 and so on.
+
+Method 1:
+Time complexity: O(nlogn)
+Use array to store the digits of num.
+*/
+
+class Solution {
+    public int minimumSum(int num) {
+        int[] res=new int[4];
+        int i=0;
+        while(num>0){
+            res[i]=num%10;
+            num/=10;
+            i++;
+        }
+        Arrays.sort(res)
+        return res[0]*10+res[2]+res[1]*10+res[3];
+    }
+}
+
+
+
+
+
+//method 2
+/*
+Method 2:
+Use priorityqueue to store the digits of num.
+Time complexity: O(n)
+*/
+
+
+class Solution {
+    public int minimumSum(int num) {
+        PriorityQueue<Integer>pq=new PriorityQueue<>();
+		//complexity to insert: O(1)
+        while(num>0){
+            pq.offer(num%10);
+            num/=10;
+        }
+		//complexity to remove: O(n)
+        int a=10*pq.remove();
+        int b=10*pq.remove();
+        int c=pq.remove();
+        int d=pq.remove();
+        return a+b+c+d;
+    }
+}
diff --git a/BFS.cpp b/BFS.cpp
new file mode 100644
index 0000000..f0e309b
--- /dev/null
+++ b/BFS.cpp
@@ -0,0 +1,88 @@
+// Program to print BFS traversal from a given
+// source vertex. BFS(int s) traverses vertices
+// reachable from s.
+#include<bits/stdc++.h>
+using namespace std;
+
+// This class represents a directed graph using
+// adjacency list representation
+class Graph
+{
+	int V; // No. of vertices
+
+	// Pointer to an array containing adjacency
+	// lists
+	vector<list<int>> adj;
+public:
+	Graph(int V); // Constructor
+
+	// function to add an edge to graph
+	void addEdge(int v, int w);
+
+	// prints BFS traversal from a given source s
+	void BFS(int s);
+};
+
+Graph::Graph(int V)
+{
+	this->V = V;
+	adj.resize(V);
+}
+
+void Graph::addEdge(int v, int w)
+{
+	adj[v].push_back(w); // Add w to v’s list.
+}
+
+void Graph::BFS(int s)
+{
+	// Mark all the vertices as not visited
+	vector<bool> visited;
+	visited.resize(V,false);
+
+	// Create a queue for BFS
+	list<int> queue;
+
+	// Mark the current node as visited and enqueue it
+	visited[s] = true;
+	queue.push_back(s);
+
+	while(!queue.empty())
+	{
+		// Dequeue a vertex from queue and print it
+		s = queue.front();
+		cout << s << " ";
+		queue.pop_front();
+
+		// Get all adjacent vertices of the dequeued
+		// vertex s. If a adjacent has not been visited,
+		// then mark it visited and enqueue it
+		for (auto adjecent: adj[s])
+		{
+			if (!visited[adjecent])
+			{
+				visited[adjecent] = true;
+				queue.push_back(adjecent);
+			}
+		}
+	}
+}
+
+// Driver program to test methods of graph class
+int main()
+{
+	// Create a graph given in the above diagram
+	Graph g(4);
+	g.addEdge(0, 1);
+	g.addEdge(0, 2);
+	g.addEdge(1, 2);
+	g.addEdge(2, 0);
+	g.addEdge(2, 3);
+	g.addEdge(3, 3);
+
+	cout << "Following is Breadth First Traversal "
+		<< "(starting from vertex 2) \n";
+	g.BFS(2);
+
+	return 0;
+}
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 0000000..30b9f91
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,53 @@
+# Contributing to Programming_HacktoberFest-2023
+
+Welcome to Programming_Hactober23 ! We appreciate your interest in contributing. Before you get started, please read and follow these guidelines.
+
+## Prerequisites
+
+Prior to beginning your contributions, please ensure the following:
+
+- Possess a GitHub Account.
+- Complete your contributor registration on the [Hacktoberfest 2023 website.](https://hacktoberfest.com/)
+
+<br/>
+
+## How to Contribute
+
+1. **Look for the issue you wish to solve** on the project's issue tracker.
+
+2. **Comment on the issue**: Please comment on the issue, indicating your interest in working on it. You can use a comment like: "Please assign me this issue."
+
+
+   **Note**:
+
+   - If the assigned contributor takes longer than expected to work on the issue, the maintainer may reassign the issue to the next person in the comment queue.
+
+<br/>
+
+## Commit your changes:
+
+- Make your changes or additions to the code, documentation, or any other improvements.
+
+- Test your changes thoroughly.
+
+## Contribution Guidelines
+
+- Please ensure your code and contributions align with the project's purpose and goals.
+
+- Follow the coding style and guidelines of the project.
+
+- Keep your commits and pull requests concise and clearly describe the changes you've made.
+
+- Do not submit spammy, trivial, or duplicate pull requests. Quality contributions are highly encouraged.
+
+<br/>
+
+## Questions and Support
+
+- If you have questions or need support related to your contributions or the project, feel free to tag and ask your doubts to the repository maintainer.
+
+- Thank you for contributing to Programming_HacktoberFest-2023! Your contributions are greatly appreciated.
+
+<br/>
+
+<b> Happy contributing! 🚀 </b>
diff --git a/FindUniqueElement.cpp b/FindUniqueElement.cpp
new file mode 100644
index 0000000..e8ae77e
--- /dev/null
+++ b/FindUniqueElement.cpp
@@ -0,0 +1,29 @@
+#include <iostream>
+#include <vector>
+#include <set>
+
+int main() {
+    int n;
+    std::cout << "Enter the number of elements: ";
+    std::cin >> n;
+
+    std::vector<int> arr(n);
+
+    std::cout << "Enter " << n << " elements: ";
+    for (int i = 0; i < n; ++i) {
+        std::cin >> arr[i];
+    }
+
+    std::set<int> uniqueElements;
+    for (int i : arr) {
+        uniqueElements.insert(i);
+    }
+
+    std::cout << "Unique elements in the array: ";
+    for (int element : uniqueElements) {
+        std::cout << element << " ";
+    }
+    std::cout << std::endl;
+
+    return 0;
+}
diff --git a/Gr8stIntInArr.cpp b/Gr8stIntInArr.cpp
new file mode 100644
index 0000000..8c0b0d8
--- /dev/null
+++ b/Gr8stIntInArr.cpp
@@ -0,0 +1,48 @@
+#include <iostream>
+using namespace std;
+
+int findLargestElement(int arr[], int size) {
+    if (size <= 0) {
+        // Ha the case of an empty array or invalid size
+        return -1;
+    }
+
+    int largest = arr[0];  // Assuming the first element is the largest
+
+    for (int i = 1; i < size; i++) {
+        if (arr[i] > largest) {
+            largest = arr[i]; // Updating largest if current element is greater
+        }
+    }
+
+    return largest;
+}
+
+int main() {
+    int size;
+
+    cout << "Enter the size of the array: ";
+    cin >> size;
+
+    if (size <= 0) {
+        cout << "Invalid array size." <<endl;
+        return 1;
+    }
+
+    int arr[size];
+
+    cout << "Enter the elements of the array, separated by spaces:" <<endl;
+    for (int i = 0; i < size; i++) {
+        cin >> arr[i];
+    }
+
+    int largest = findLargestElement(arr, size);
+
+    if (largest != -1) {
+        cout << "The largest element in the array is: " << largest <<endl;
+    } else {
+        cout << "The array is empty or has an invalid size." <<endl;
+    }
+
+    return 0;
+}
diff --git a/KadansAlgorithm.cpp b/KadansAlgorithm.cpp
new file mode 100644
index 0000000..60b1f70
--- /dev/null
+++ b/KadansAlgorithm.cpp
@@ -0,0 +1,24 @@
+#include <iostream>
+#include <vector>
+
+int kadanesAlgorithm(const std::vector<int>& arr) {
+    int maxEndingHere = arr[0];
+    int maxSoFar = arr[0];
+
+    for (int i = 1; i < arr.size(); ++i) {
+        maxEndingHere = std::max(arr[i], maxEndingHere + arr[i]);
+        maxSoFar = std::max(maxSoFar, maxEndingHere);
+    }
+
+    return maxSoFar;
+}
+
+int main() {
+    std::vector<int> arr = {1, -3, 2, 1, -1};
+
+    int maxSubarraySum = kadanesAlgorithm(arr);
+
+    std::cout << "Maximum subarray sum: " << maxSubarraySum << std::endl;
+
+    return 0;
+}
diff --git a/MaxSubarray.cpp b/MaxSubarray.cpp
new file mode 100644
index 0000000..0280476
--- /dev/null
+++ b/MaxSubarray.cpp
@@ -0,0 +1,27 @@
+#include <iostream>
+using namespace std;
+
+// function for kadane's algorithm
+static int kadane(int Array[], int n) {
+  int max_sum = 0;
+  int current_sum = 0;
+
+  for(int i=0; i<n; i++) {
+    current_sum = current_sum + Array[i];
+    
+    if (current_sum < 0)
+      current_sum = 0;
+    
+    if(max_sum < current_sum)
+      max_sum = current_sum;
+  }
+  return max_sum;
+}
+
+// test the code
+int main() {
+  int MyArray[] = {-3, 1, -8, 12, 0, -3, 5, -9, 4};
+  int n = sizeof(MyArray) / sizeof(MyArray[0]);
+  cout<<"Maximum SubArray is: "<<kadane(MyArray, n);
+  return 0;
+}
\ No newline at end of file
diff --git a/NGE.java b/NGE.java
new file mode 100644
index 0000000..cb09b85
--- /dev/null
+++ b/NGE.java
@@ -0,0 +1,22 @@
+//leetcode --> 496. Next Greater Element I
+import java.util.*;
+class Hactober {
+    public static int[] nextGreaterElement(int[] nums1, int[] nums2) {
+        HashMap<Integer,Integer> map = new HashMap<>();
+        Stack<Integer> s = new Stack<>();
+        for(int i:nums2){
+            while(!s.isEmpty()&&s.peek()<i)map.put(s.pop(),i);
+            s.push(i);
+        }
+        for(int i=0;i<nums1.length;i++){
+            nums1[i]=map.getOrDefault(nums1[i],-1);
+        }
+        return nums1;
+    }
+   public static void main(String[] args){
+        int[] arr1 = {4,1,2};
+        int[] arr2 = {1,3,4,2};
+        int[] res = nextGreaterElement(arr1,arr2);
+        for(int i : res)System.out.print(i + " ");
+   }
+}
diff --git a/New_Game/TreasureHunt.py b/New_Game/TreasureHunt.py
new file mode 100644
index 0000000..879034d
--- /dev/null
+++ b/New_Game/TreasureHunt.py
@@ -0,0 +1,54 @@
+import random
+
+def treasure_hunt():
+    print("🏝️ Welcome to the Treasure Hunt Adventure!")
+    print("You are trapped on a mysterious island.")
+    print("Find the hidden treasure using clues before your chances run out!\n")
+
+    # grid 5x5
+    grid_size = 5
+    treasure_x = random.randint(1, grid_size)
+    treasure_y = random.randint(1, grid_size)
+
+    chances = 7
+    last_distance = None
+
+    while chances > 0:
+        try:
+            print(f"📍 Chances left: {chances}")
+            x = int(input("Enter X coordinate (1–5): "))
+            y = int(input("Enter Y coordinate (1–5): "))
+
+            if x < 1 or x > 5 or y < 1 or y > 5:
+                print("⚠️ Coordinates must be between 1 and 5!\n")
+                continue
+
+            distance = abs(treasure_x - x) + abs(treasure_y - y)
+
+            if distance == 0:
+                print("\n💎 CONGRATULATIONS! You found the treasure! 🏆")
+                print("You escaped the island with riches beyond imagination!")
+                break
+
+            if last_distance is None:
+                print("🧭 You start your journey... keep going!")
+            else:
+                if distance < last_distance:
+                    print("🔥 You’re getting closer!")
+                elif distance > last_distance:
+                    print("❄️ You’re moving away!")
+                else:
+                    print("😐 You’re at the same distance as before!")
+
+            last_distance = distance
+            chances -= 1
+            print()
+        except ValueError:
+            print("❌ Please enter numbers only!\n")
+
+    else:
+        print("\n💀 You ran out of chances!")
+        print(f"The treasure was hidden at ({treasure_x}, {treasure_y}). Better luck next time!")
+
+# Run the game
+treasure_hunt()
diff --git a/Palindrom_checkerwithJava.java b/Palindrom_checkerwithJava.java
new file mode 100644
index 0000000..46f463e
--- /dev/null
+++ b/Palindrom_checkerwithJava.java
@@ -0,0 +1,35 @@
+import java.util.Scanner;
+
+public class PalindromeChecker {
+
+    public static boolean isPalindrome(String str) {
+        str = str.replaceAll("[^a-zA-Z0-9]", "").toLowerCase(); // Remove non-alphanumeric characters and convert to lowercase
+        int left = 0;
+        int right = str.length() - 1;
+
+        while (left < right) {
+            if (str.charAt(left) != str.charAt(right)) {
+                return false; // Characters at the left and right positions don't match
+            }
+            left++;
+            right--;
+        }
+
+        return true; // All characters matched, it's a palindrome
+    }
+
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+
+        System.out.print("Enter a string: ");
+        String input = scanner.nextLine();
+
+        if (isPalindrome(input)) {
+            System.out.println("The input is a palindrome.");
+        } else {
+            System.out.println("The input is not a palindrome.");
+        }
+
+        scanner.close();
+    }
+}
diff --git a/Palindrome_Num_Checker.cpp b/Palindrome_Num_Checker.cpp
new file mode 100644
index 0000000..56a959a
--- /dev/null
+++ b/Palindrome_Num_Checker.cpp
@@ -0,0 +1,28 @@
+#include<iostream>
+using namespace std;
+
+int main(){
+
+int num, result=0;
+cout<<"Enter a positive integer: ";
+cin>>num;
+
+
+int temporary = num;
+while(num>0){
+    int dig = num%10;
+    result = result*10+dig;
+    num=num/10;
+}
+
+num = temporary;
+
+
+   if(result==num){
+    cout<<"Number is a palindrome.";
+}
+   else
+    cout<<"Not a palindrome.";
+
+return 0;
+}
diff --git a/Python/F1_RACE_PREDICTION.py b/Python/F1_RACE_PREDICTION.py
new file mode 100644
index 0000000..974910f
--- /dev/null
+++ b/Python/F1_RACE_PREDICTION.py
@@ -0,0 +1,129 @@
+# -*- coding: utf-8 -*-
+"""Untitled19.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1n8tDlXoN3D4JWiWUl-WPjG2wfc9qMR1C
+
+NEW MODEL
+"""
+
+import pandas as pd
+import numpy as np
+from sklearn.model_selection import train_test_split
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.metrics import accuracy_score, confusion_matrix
+
+# Load datasets (update paths if needed)
+drivers = pd.read_csv("/content/drivers.csv")
+constructor = pd.read_csv("/content/constructors.csv")
+driver_standings = pd.read_csv("/content/driver_standings.csv")
+constructor_standings = pd.read_csv("/content/constructor_standings.csv")
+results = pd.read_csv("/content/results.csv")
+constructor_results = pd.read_csv("/content/constructor_results.csv")
+
+# Merge driver info into results
+data = results.merge(drivers, on="driverId", how="left")
+# Merge constructor info
+data = data.merge(constructor, on="constructorId", how="left")
+# Using average points per race for realistic values
+driver_points_avg = results.groupby('driverId')['points'].mean().to_dict()
+constructor_points_avg = results.groupby('constructorId')['points'].mean().to_dict()
+
+data['driver_points'] = data['driverId'].map(driver_points_avg)
+data['constructor_points'] = data['constructorId'].map(constructor_points_avg)
+
+data.head()
+
+# Target = 1 if driver won the race, else 0
+data['target'] = (data['positionOrder'] == 1).astype(int)
+
+features = ['grid', 'driver_points', 'constructor_points']
+X = data[features]
+y = data['target']
+
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+model = RandomForestClassifier(n_estimators=100, random_state=42)
+model.fit(X_train, y_train)
+
+y_pred = model.predict(X_test)
+print("Accuracy:", accuracy_score(y_test, y_pred))
+print("Confusion Matrix:\n", confusion_matrix(y_test, y_pred))
+
+# Example future race: use actual driver IDs
+future_race = pd.DataFrame({
+    'driverId': [1, 2, 3, 4, 5],
+    'grid': [1, 2, 3, 4, 5]       # starting positions
+})
+
+# Maping driver names
+driver_names = drivers.set_index('driverId')['surname'].to_dict()
+future_race['driver_name'] = future_race['driverId'].map(driver_names)
+
+# Maping latest constructor for each driver from results
+latest_race_per_driver = results.groupby('driverId').apply(lambda x: x.sort_values('raceId', ascending=False).iloc[0])
+driver_constructor_map = latest_race_per_driver.set_index('driverId')['constructorId'].to_dict()
+future_race['constructorId'] = future_race['driverId'].map(driver_constructor_map)
+
+# Mapingg constructor names
+constructor_names = constructor.set_index('constructorId')['name'].to_dict()
+future_race['constructor_name'] = future_race['constructorId'].map(constructor_names)
+
+# Maping average points per race for drivers and constructors
+driver_points_avg = results.groupby('driverId')['points'].mean().to_dict()
+constructor_points_avg = results.groupby('constructorId')['points'].mean().to_dict()
+future_race['driver_points'] = future_race['driverId'].map(driver_points_avg)
+future_race['constructor_points'] = future_race['constructorId'].map(constructor_points_avg)
+
+future_race
+
+features = ['grid', 'driver_points', 'constructor_points']
+X_future = future_race[features]
+
+# Predict probability of winning
+future_race['win_probability'] = model.predict_proba(X_future)[:,1]
+future_race
+
+# Sorting by win probability descending
+future_race_sorted = future_race.sort_values('win_probability', ascending=False)
+
+# final table
+future_race_sorted[['driver_name', 'constructor_name', 'grid', 'driver_points', 'constructor_points', 'win_probability']]
+
+# Select top 3 drivers by win probability
+top3 = future_race_sorted.head(3)
+
+# Display a clean leaderboard
+for i, row in top3.iterrows():
+    print(f"Position {i+1}: {row['driver_name']} ({row['constructor_name']})")
+    print(f"  Grid: {row['grid']}, Avg Driver Points: {row['driver_points']:.1f}, "
+          f"Avg Constructor Points: {row['constructor_points']:.1f}, "
+          f"Win Probability: {row['win_probability']:.2%}\n")
+
+# Sorting by win_probability descending
+future_race_sorted = future_race.sort_values('win_probability', ascending=False)
+
+# top drivers
+future_race_sorted[['driver_name', 'constructor_name', 'grid', 'driver_points', 'constructor_points', 'win_probability']]
+
+import matplotlib.pyplot as plt
+
+# Sort by win probability descending
+future_race_sorted = future_race.sort_values('win_probability', ascending=False)
+
+#  Bar chart of win probabilities
+plt.figure(figsize=(12,6))
+bars = plt.bar(future_race_sorted['driver_name'], future_race_sorted['win_probability'], color='royalblue')
+
+# Add probability values on top of bars
+for bar in bars:
+    height = bar.get_height()
+    plt.text(bar.get_x() + bar.get_width()/2.0, height + 0.01, f"{height:.2%}", ha='center', va='bottom')
+
+plt.ylabel('Win Probability')
+plt.xlabel('Driver')
+plt.title('Predicted Win Probabilities for Future Race')
+plt.ylim(0, 1)  # set y-axis between 0 and 1
+plt.show()
\ No newline at end of file
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..dfee3ea
--- /dev/null
+++ b/README.md
@@ -0,0 +1,3 @@
+# Programming_Hactoberfest23
+New Contribution Repository
+https://github.com/Nikhil-2002/hacktoberfest2025-contributions
diff --git a/Take input in String form and convert to array format for operation #98 b/Take input in String form and convert to array format for operation #98
new file mode 100644
index 0000000..361bbdc
--- /dev/null
+++ b/Take input in String form and convert to array format for operation #98	
@@ -0,0 +1,38 @@
+/*
+Steps:
+1. Directly take a string as input.
+2. Keep a list and a temporary string str.
+3. Traverse in the string add the characters in the temporary string until the white space encountered.
+4. If white space encountered, add the temporary string to list after converting to integer.
+5. Make temporary string empty string.
+6. after coming out of the string again check the temporary string and add.
+Note: step 6 is important as in most of the cases white space will not come at the end.
+      so, after coming to end add the temporary string in end.
+7. Now, you have the list of integers, without giving the input number of elements.
+
+*/
+
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+
+public class Solution {
+    public static void main(String[] args) {
+        Scanner sc=new Scanner(System.in);
+        String s=sc.nextLine();
+        String str="";
+        int n=s.length();
+        List<Integer>list=new ArrayList<>();
+        for(int i=0;i<n;i++){
+            if(s.charAt(i)==' '){
+                int num=Integer.parseInt(str);
+                list.add(num);
+                str="";
+            }
+            else str+=s.charAt(i);
+        }
+        list.add(Integer.parseInt(str));
+        System.out.println(list);
+    }
+}
diff --git a/application of algorithm/shortestPath.cpp b/application of algorithm/shortestPath.cpp
new file mode 100644
index 0000000..1dd7da9
--- /dev/null
+++ b/application of algorithm/shortestPath.cpp	
@@ -0,0 +1,64 @@
+#include <iostream>
+#include <vector>
+#include <climits>
+
+const int V = 6; // Number of vertices in the graph
+
+// Function to find the vertex with the minimum distance value from the set of vertices not yet included in the shortest path tree
+int minDistance(const std::vector<int>& dist, const std::vector<bool>& sptSet) {
+    int minDist = INT_MAX, minIndex = -1;
+    for (int v = 0; v < V; ++v) {
+        if (!sptSet[v] && dist[v] < minDist) {
+            minDist = dist[v];
+            minIndex = v;
+        }
+    }
+    return minIndex;
+}
+
+// Function to print the constructed distance array
+void printSolution(const std::vector<int>& dist) {
+    std::cout << "Vertex \t Distance from Source" << std::endl;
+    for (int i = 0; i < V; ++i) {
+        std::cout << i << " \t " << dist[i] << std::endl;
+    }
+}
+
+// Dijkstra's algorithm to find the shortest path from source to all vertices
+void dijkstra(const std::vector<std::vector<int>>& graph, int src) {
+    std::vector<int> dist(V, INT_MAX); // The output array to store the shortest distance from the source vertex
+    std::vector<bool> sptSet(V, false); // Set to keep track of vertices included in the shortest path tree
+
+    dist[src] = 0; // Distance from the source to itself is 0
+
+    for (int count = 0; count < V - 1; ++count) {
+        int u = minDistance(dist, sptSet);
+
+        sptSet[u] = true;
+
+        for (int v = 0; v < V; ++v) {
+            if (!sptSet[v] && graph[u][v] && dist[u] != INT_MAX && dist[u] + graph[u][v] < dist[v]) {
+                dist[v] = dist[u] + graph[u][v];
+            }
+        }
+    }
+
+    printSolution(dist);
+}
+
+int main() {
+    std::vector<std::vector<int>> graph = {
+        {0, 2, 4, 0, 0, 0},
+        {2, 0, 3, 2, 0, 0},
+        {4, 3, 0, 0, 1, 0},
+        {0, 2, 0, 0, 3, 2},
+        {0, 0, 1, 3, 0, 2},
+        {0, 0, 0, 2, 2, 0}
+    };
+
+    int src = 0; // Source vertex
+
+    dijkstra(graph, src);
+
+    return 0;
+}
diff --git a/application of algorithm/shortest_path b/application of algorithm/shortest_path
new file mode 100644
index 0000000..1dd7da9
--- /dev/null
+++ b/application of algorithm/shortest_path	
@@ -0,0 +1,64 @@
+#include <iostream>
+#include <vector>
+#include <climits>
+
+const int V = 6; // Number of vertices in the graph
+
+// Function to find the vertex with the minimum distance value from the set of vertices not yet included in the shortest path tree
+int minDistance(const std::vector<int>& dist, const std::vector<bool>& sptSet) {
+    int minDist = INT_MAX, minIndex = -1;
+    for (int v = 0; v < V; ++v) {
+        if (!sptSet[v] && dist[v] < minDist) {
+            minDist = dist[v];
+            minIndex = v;
+        }
+    }
+    return minIndex;
+}
+
+// Function to print the constructed distance array
+void printSolution(const std::vector<int>& dist) {
+    std::cout << "Vertex \t Distance from Source" << std::endl;
+    for (int i = 0; i < V; ++i) {
+        std::cout << i << " \t " << dist[i] << std::endl;
+    }
+}
+
+// Dijkstra's algorithm to find the shortest path from source to all vertices
+void dijkstra(const std::vector<std::vector<int>>& graph, int src) {
+    std::vector<int> dist(V, INT_MAX); // The output array to store the shortest distance from the source vertex
+    std::vector<bool> sptSet(V, false); // Set to keep track of vertices included in the shortest path tree
+
+    dist[src] = 0; // Distance from the source to itself is 0
+
+    for (int count = 0; count < V - 1; ++count) {
+        int u = minDistance(dist, sptSet);
+
+        sptSet[u] = true;
+
+        for (int v = 0; v < V; ++v) {
+            if (!sptSet[v] && graph[u][v] && dist[u] != INT_MAX && dist[u] + graph[u][v] < dist[v]) {
+                dist[v] = dist[u] + graph[u][v];
+            }
+        }
+    }
+
+    printSolution(dist);
+}
+
+int main() {
+    std::vector<std::vector<int>> graph = {
+        {0, 2, 4, 0, 0, 0},
+        {2, 0, 3, 2, 0, 0},
+        {4, 3, 0, 0, 1, 0},
+        {0, 2, 0, 0, 3, 2},
+        {0, 0, 1, 3, 0, 2},
+        {0, 0, 0, 2, 2, 0}
+    };
+
+    int src = 0; // Source vertex
+
+    dijkstra(graph, src);
+
+    return 0;
+}
diff --git a/count-the-number-of-complete-components b/count-the-number-of-complete-components
new file mode 100644
index 0000000..111c703
--- /dev/null
+++ b/count-the-number-of-complete-components
@@ -0,0 +1,79 @@
+/*
+                                                                      Just 3 main steps|| dfs || connected graph || check adjList
+a) Intuition
+      1. Get the number of connected graphs.
+      2. For each connected graph, each element should be present in other's adjacency list.
+      3. If the 2nd step becomes correct, increment count by 1.
+b) Approach
+      1. Make the adjacency list using map.
+      2. dfs approach to get the list of connected nodes.
+      3. Check whether each node has edges to other in the connected graph.
+      -->take the adjency list and add itself to its adjency list.
+      -->If adjency list == connectedNode list (for each node in the connected graph), count it.
+
+*/
+
+class Solution {
+    List<Integer> dfs(List<Integer>list,Map<Integer,List<Integer>>map,int key,int[] vis){
+        //visted again means traversal completed for a given connected chunk of nodes
+        if(vis[key]==1)return list;
+        //mark node as visted
+        vis[key]=1;
+        //store list in new list
+        List<Integer>li=new ArrayList<>(list);
+        li.add(key);
+        for(int i=0;i<map.get(key).size();i++){
+            //dfs call for each not visited adjacent node
+            int adjNode=map.get(key).get(i);
+            if(vis[adjNode]==0)li=dfs(li,map,adjNode,vis);
+        }
+        return li;
+    }
+    int conn(List<Integer>list,Map<Integer,List<Integer>>adjList){
+        int cnt=0;
+         for(Integer i:list){
+             //if a node can visit to all other node
+             //means adj list just lack itself
+             //if we add it to its own adjacency list, 
+             //adj will be equal to list.
+             List<Integer>adj=new ArrayList<>(adjList.get(i));
+             adj.add(i);
+             Collections.sort(adj);
+             if(list.equals(adj))cnt++;
+         }
+        return cnt==list.size()?1:0;
+    }
+    public int countCompleteComponents(int n, int[][] edges) {
+        //make adjacency list using map
+        Map<Integer,List<Integer>>map=new HashMap<>();
+        for(int i=0;i<edges.length;i++){
+            //undirected graph so, store both nodes in each other 
+            map.putIfAbsent(edges[i][0],new ArrayList<>());
+            map.get(edges[i][0]).add(edges[i][1]);
+            map.putIfAbsent(edges[i][1],new ArrayList<>());
+            map.get(edges[i][1]).add(edges[i][0]);
+        }
+        
+        for(int i=0;i<n;i++){
+            //empty adjacency list for single nodes
+            map.putIfAbsent(i,new ArrayList<>());
+        }
+        int[] vis=new int[map.size()];
+        int sum=0;
+        for(Map.Entry<Integer,List<Integer>>m:map.entrySet()){
+            if(vis[m.getKey()]==0){
+                List<Integer>list=new ArrayList<>();
+                //get the list of connected nodes
+                list=dfs(list,map,m.getKey(),vis);
+                
+                if(list.size()==1)sum++;
+                else{
+                    //sort it to match with the adjacency list of particular nodes.
+                    Collections.sort(list);
+                    sum+=conn(list,map);
+                }
+            }
+        }
+        return sum;
+    }
+}
diff --git a/findDisjoint/ArrayDisjoinOrNot.java b/findDisjoint/ArrayDisjoinOrNot.java
new file mode 100644
index 0000000..754cf8d
--- /dev/null
+++ b/findDisjoint/ArrayDisjoinOrNot.java
@@ -0,0 +1,51 @@
+import java.util.HashSet;
+import java.util.Scanner;
+
+public class DisjointArraysChecker {
+
+    public static boolean areDisjoint(int[] arr1, int[] arr2) {
+        HashSet<Integer> set = new HashSet<>();
+
+        for (int num : arr1) {
+            set.add(num);
+        }
+
+        for (int num : arr2) {
+            if (set.contains(num)) {
+                return false; // Common element found, arrays are not disjoint
+            }
+        }
+
+        return true; // No common elements found, arrays are disjoint
+    }
+
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+
+        System.out.print("Enter the size of the first array: ");
+        int size1 = scanner.nextInt();
+        int[] array1 = new int[size1];
+
+        System.out.println("Enter elements of the first array:");
+        for (int i = 0; i < size1; i++) {
+            array1[i] = scanner.nextInt();
+        }
+
+        System.out.print("Enter the size of the second array: ");
+        int size2 = scanner.nextInt();
+        int[] array2 = new int[size2];
+
+        System.out.println("Enter elements of the second array:");
+        for (int i = 0; i < size2; i++) {
+            array2[i] = scanner.nextInt();
+        }
+
+        scanner.close();
+
+        if (areDisjoint(array1, array2)) {
+            System.out.println("The arrays are disjoint.");
+        } else {
+            System.out.println("The arrays are not disjoint.");
+        }
+    }
+}
diff --git a/maximum-product-of-two-elements-in-an-array b/maximum-product-of-two-elements-in-an-array
new file mode 100644
index 0000000..67c1427
--- /dev/null
+++ b/maximum-product-of-two-elements-in-an-array
@@ -0,0 +1,56 @@
+/*
+                                                      Approach 1
+                                                  Time Complexity: O(nlogn)
+*/
+
+class Solution {
+    public int maxProduct(int[] nums) {
+		Arrays.sort(nums); //O(nlogn) time complexity sorting quick sort 
+        return (nums[nums.length-1]-1)*(nums[nums.length-2]-1);
+    }
+}
+
+/* 
+                                                        Approach 2
+                                                    Time Complexity: O(n)
+*/
+class Solution {
+    public int maxProduct(int[] nums) {
+       int[] arr=new int[2];
+        arr[0]=nums[0];//take array of size 2 store maximum two elements as we traverse through the array.
+        arr[1]=nums[1];
+		//Once traversing the array has O(n) time complexity
+        for(int i=2;i<nums.length;i++){
+		//if both stored elements are smaller than the nums[i], replace the smaller one with nums[i]
+            if(nums[i]>arr[0] && nums[i]>arr[1]){
+                if(arr[0]<arr[1]){
+                    arr[0]=nums[i];
+                }
+                else arr[1]=nums[i];
+            }
+			//else if  only one element is smaller then replace that with nums[i]
+            else if(nums[i]>arr[0]){
+                arr[0]=nums[i];
+            }
+            else if(nums[i]>arr[1]){
+                arr[1]=nums[i];
+            }
+        }
+        return (arr[0]-1)*(arr[1]-1);
+    }
+}
+
+/*
+                                                    Approach 3
+                                              Time complexity: O(n) using PriorityQueue
+*/
+class Solution {
+    public int maxProduct(int[] nums) {
+        PriorityQueue<Integer>pq=new PriorityQueue<>();
+        for(int num:nums){
+            pq.offer(num);
+            if(pq.size()>2)pq.poll();
+        }
+        return (pq.poll()-1)*(pq.poll()-1);
+    }
+}
diff --git a/mergesort.cpp b/mergesort.cpp
new file mode 100644
index 0000000..ab42bd6
--- /dev/null
+++ b/mergesort.cpp
@@ -0,0 +1,97 @@
+#include <stdio.h>
+//#include <stdlib.h>
+ 
+// Merges two subarrays of arr[].
+// First subarray is arr[l..m]
+// Second subarray is arr[m+1..r]
+void merge(int arr[], int l, int m, int r)
+{
+    int i, j, k;
+    int n1 = m - l + 1;
+    int n2 = r - m;
+ 
+    // Create temp arrays
+    int L[n1], R[n2];
+ 
+    // Copy data to temp arrays L[] and R[]
+    for (i = 0; i < n1; i++)
+        L[i] = arr[l + i];
+    for (j = 0; j < n2; j++)
+        R[j] = arr[m + 1 + j];
+ 
+    // Merge the temp arrays back into arr[l..r
+    i = 0;
+    j = 0;
+    k = l;
+    while (i < n1 && j < n2) {
+        if (L[i] <= R[j]) {
+            arr[k] = L[i];
+            i++;
+        }
+        else {
+            arr[k] = R[j];
+            j++;
+        }
+        k++;
+    }
+ 
+    // Copy the remaining elements of L[],
+    // if there are any
+    while (i < n1) {
+        arr[k] = L[i];
+        i++;
+        k++;
+    }
+ 
+    // Copy the remaining elements of R[],
+    // if there are any
+    while (j < n2) {
+        arr[k] = R[j];
+        j++;
+        k++;
+    }
+}
+ 
+// l is for left index and r is right index of the
+// sub-array of arr to be sorted
+void mergeSort(int arr[], int l, int r)//mergeSort(arr, 0, arr_size - 1);
+{
+    if (l < r) {//arr[0]=2, l=0; r=arr_size-1=6-1=5
+        int m = l + ( r - l) / 2;//m=0+(5-0)/2
+ 
+        // Sort first and second halves
+        mergeSort(arr, l, m);
+        mergeSort(arr, m + 1, r);
+ 
+        merge(arr, l, m, r);
+    }
+}
+ 
+// Function to print an array
+void printArray(int A[], int size)
+{
+    int i;
+    for (i = 0; i < size; i++)
+        printf("%d ", A[i]);
+    printf("\n");
+}
+ 
+// Driver code
+int main()
+{
+   int n,i, j;
+	printf("Enter no of elements in the array:");
+	scanf("%d",&n);
+	int arr[n];
+	printf("Enter array to be sorted:\n");
+	for(i=0;i<n;i++)                   
+	{
+		scanf("%d",&arr[i]);
+	}
+ 
+    mergeSort(arr, 0, n - 1);
+ 
+    printf("\nSorted array is \n");
+    printArray(arr, n);
+    return 0;
+}
diff --git a/palindrome.cpp b/palindrome.cpp
index 068f20a..6bc0a39 100644
--- a/palindrome.cpp
+++ b/palindrome.cpp
@@ -21,13 +21,24 @@ string isPalindrome(string S)
 	}
 }
 
+//Function to check if string is Palindrome without using extra space
+string isPalind(string &s){
+    	int l=0, r = s.size()-1;
+	while(l<r){
+		if (s[l++] != s[r--]) return "false";
+	}
+	return "true";
+
+}
+
 // Driver Code
 int main()
 {
-	string S;
+    string S;
     cout<<"Enter the string: ";
     cin>>S;
-	cout << isPalindrome(S);
-
-	return 0;
+    cout << isPalindrome(S);
+    cout<<isPalind(S);
+	
+    return 0;
 }
diff --git a/patterns/.DS_Store b/patterns/.DS_Store
new file mode 100644
index 0000000..95f99d6
Binary files /dev/null and b/patterns/.DS_Store differ
diff --git a/patterns/starPatterns/Pattern0.java b/patterns/starPatterns/Pattern0.java
new file mode 100644
index 0000000..681b560
--- /dev/null
+++ b/patterns/starPatterns/Pattern0.java
@@ -0,0 +1,27 @@
+ package basics.patterns.starPatterns;
+import java.util.*;
+public class Pattern0 {
+
+	public static void main(String[] args) {
+		
+	Scanner sc = new Scanner(System.in);
+		int n = sc.nextInt();
+		int row=1;
+		//rows
+		
+		while(row<=n) {
+			//work
+			System.out.print("x");
+			
+			//prepation
+			System.out.println();
+			row++;
+		}
+		
+		
+		
+		
+
+	}
+
+}
diff --git a/patterns/starPatterns/Pattern1.java b/patterns/starPatterns/Pattern1.java
new file mode 100644
index 0000000..43fcf5c
--- /dev/null
+++ b/patterns/starPatterns/Pattern1.java
@@ -0,0 +1,35 @@
+package basics.patterns.starPatterns;
+
+import java.util.Scanner;
+
+/*
+
+x x x x x 
+x x x x x 
+x x x x x 
+x x x x x 
+x x x x x 
+
+*/
+
+public class Pattern1 {
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		int n = sc.nextInt();
+		int row=1;
+		
+		while(row<=n) {
+			//work
+			for(int col = 1;col<=n;col++) {
+				System.out.print("x ");
+			}
+			//prepartion
+			
+			System.out.println();
+			row++;
+		}
+
+	}
+
+}
diff --git a/patterns/starPatterns/Pattern10.java b/patterns/starPatterns/Pattern10.java
new file mode 100644
index 0000000..59ff1e5
--- /dev/null
+++ b/patterns/starPatterns/Pattern10.java
@@ -0,0 +1,38 @@
+package basics.patterns.starPatterns;
+
+import java.util.Scanner;
+
+public class Pattern10 {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int n = sc.nextInt();
+        int nst = n+4;
+        int nsp = 0;
+
+        //rows
+        int row=1;
+        while(row<=n){
+
+
+            // space work
+            int csp= 1;
+            while(csp<=nsp){
+                System.out.print(" ");
+                csp++;
+            }
+
+            //star work
+            int cst= 1;
+            while(cst<=nst){
+                System.out.print("x");
+                cst++;
+            }
+
+            //preparation
+            System.out.println();
+            nsp++;
+            nst-=2;
+            row++;
+        }
+    }
+}
diff --git a/patterns/starPatterns/Pattern11.java b/patterns/starPatterns/Pattern11.java
new file mode 100644
index 0000000..c8e39d2
--- /dev/null
+++ b/patterns/starPatterns/Pattern11.java
@@ -0,0 +1,50 @@
+package basics.patterns.starPatterns;
+
+import java.util.Scanner;
+
+/*
+        x
+      x   x
+    x   x   x
+  x   x   x   x
+x   x   x   x   x
+
+ */
+public class Pattern11 {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int n = sc.nextInt();
+        int nst = 1;
+        int nsp = n-1;
+
+        //rows
+        int row=1;
+        while(row<=n){
+
+            //space work
+            int csp=1;
+            while(csp<=nsp){
+                System.out.print("  ");
+                csp++;
+            }
+
+            //star work
+            int cst =1;
+            while(cst<=nst){
+                //checking the even position
+                if(cst%2==0){
+                    System.out.print("  ");
+                }else{
+                    System.out.print("x ");
+                }
+                cst++;
+            }
+
+            //preparation
+            System.out.println();
+            nsp--;
+            nst+=2;
+            row++;
+        }
+    }
+}
diff --git a/patterns/starPatterns/Pattern12.java b/patterns/starPatterns/Pattern12.java
new file mode 100644
index 0000000..cf564b9
--- /dev/null
+++ b/patterns/starPatterns/Pattern12.java
@@ -0,0 +1,52 @@
+package basics.patterns.starPatterns;
+
+import java.util.Scanner;
+
+/*
+
+        x
+      x ! x
+    x ! x ! x
+  x ! x ! x ! x
+x ! x ! x ! x ! x
+
+ */
+
+public class Pattern12 {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int n = sc.nextInt();
+        int nst = 1;
+        int nsp = n-1;
+
+        //rows
+        int row=1;
+        while(row<=n){
+
+            //space work
+            int csp=1;
+            while(csp<=nsp){
+                System.out.print("  ");
+                csp++;
+            }
+
+            //star work
+            int cst =1;
+            while(cst<=nst){
+                //checking the even position
+                if(cst%2==0){
+                    System.out.print("! ");
+                }else{
+                    System.out.print("x ");
+                }
+                cst++;
+            }
+
+            //preparation
+            System.out.println();
+            nsp--;
+            nst+=2;
+            row++;
+        }
+    }
+}
diff --git a/patterns/starPatterns/Pattern13.java b/patterns/starPatterns/Pattern13.java
new file mode 100644
index 0000000..61c997b
--- /dev/null
+++ b/patterns/starPatterns/Pattern13.java
@@ -0,0 +1,46 @@
+package basics.patterns.starPatterns;
+
+import java.util.Scanner;
+/*
+
+x
+x x
+x x x
+x x x x
+x x x x x
+x x x x
+x x x
+x x
+x
+
+ */
+
+public class Pattern13 {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int n = sc.nextInt();
+        int nst= 1;// no of stars
+        int nr = 2*n-1;
+
+        //rows
+        int row =  1;
+        while(row<=nr){
+
+            //work done
+            int cst = 1;
+            while(cst<=nst){
+                System.out.print("x ");
+                cst++;
+            }
+
+            //preparation
+            System.out.println();
+            if(row<=nr/2){
+                nst++;
+            }else{
+                nst--;
+            }
+            row++;
+        }
+    }
+}
diff --git a/patterns/starPatterns/Pattern14.java b/patterns/starPatterns/Pattern14.java
new file mode 100644
index 0000000..7d21b42
--- /dev/null
+++ b/patterns/starPatterns/Pattern14.java
@@ -0,0 +1,57 @@
+package basics.patterns.starPatterns;
+
+import java.util.Scanner;
+
+/*
+
+            x
+          x x
+        x x x
+      x x x x
+    x x x x x
+      x x x x
+        x x x
+          x x
+            x
+ */
+
+public class Pattern14 {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int n = sc.nextInt();
+        int nr = 2*n-1;
+        int nst = 1;
+        int nsp= n-1;
+
+        //rows
+        int row = 1;
+        while(row<=nr){
+
+            //space work
+            int csp=1;
+            while(csp<=nsp){
+                System.out.print("  ");
+                csp++;
+            }
+            // star work
+
+            int cst = 1;
+            while(cst<=nst){
+                System.out.print("*");
+                cst++;
+            }
+
+            //prepartion
+            System.out.println();
+            if(row<=nr/2){
+                nst++;
+                nsp--;
+            }else{
+                nst--;
+                nsp++;
+            }
+            row++;
+
+        }
+    }
+}
diff --git a/patterns/starPatterns/Pattern15.java b/patterns/starPatterns/Pattern15.java
new file mode 100644
index 0000000..9027d75
--- /dev/null
+++ b/patterns/starPatterns/Pattern15.java
@@ -0,0 +1,50 @@
+package basics.patterns.starPatterns;
+
+import java.util.Scanner;
+/*
+x x x x x
+    x x x x
+        x x x
+            x x
+                x
+            x x
+        x x x
+    x x x x
+x x x x x
+
+ */
+public class Pattern15 {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int n = sc.nextInt();
+        int nr = 2*n-1;
+        int nst = n;
+        int nsp= 0;
+
+        //rows
+        for(int row=1;row<=nr;row++){
+
+            //space work
+            for(int csp =1; csp<=nsp;csp++)
+            {
+                System.out.print("  ");
+            }
+
+            //star work
+            for(int cst =1;cst<=nst;cst++)
+            {
+                System.out.print("x ");
+            }
+
+            //prearation
+            System.out.println();
+            if(row<=nr/2){
+                nst--;
+                nsp+=2;
+            }else{
+                nst++;
+                nsp-=2;
+            }
+        }
+    }
+}
diff --git a/patterns/starPatterns/Pattern16.java b/patterns/starPatterns/Pattern16.java
new file mode 100644
index 0000000..fec9ef6
--- /dev/null
+++ b/patterns/starPatterns/Pattern16.java
@@ -0,0 +1,52 @@
+package basics.patterns.starPatterns;
+
+import java.util.Scanner;
+/*
+
+        x x x x x
+      x x x x
+    x x x
+  x x
+x
+  x x 
+    x x x
+      x x x x
+        x x x x x
+
+
+ */
+public class Pattern16 {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int n = sc.nextInt();
+        int nr = 2*n-1;
+        int nst = n;
+        int nsp= n-1;
+
+        //rows
+        for(int row=1;row<=nr;row++){
+
+            //space work
+            for(int csp =1; csp<=nsp;csp++)
+            {
+                System.out.print("  ");
+            }
+
+            //star work
+            for(int cst =1;cst<=nst;cst++)
+            {
+                System.out.print("x ");
+            }
+
+            //prearation
+            System.out.println();
+            if(row<=nr/2){
+                nst--;
+                nsp--;
+            }else{
+                nst++;
+                nsp++;
+            }
+        }
+    }
+}
diff --git a/patterns/starPatterns/Pattern17.java b/patterns/starPatterns/Pattern17.java
new file mode 100644
index 0000000..bd7220f
--- /dev/null
+++ b/patterns/starPatterns/Pattern17.java
@@ -0,0 +1,52 @@
+package basics.patterns.starPatterns;
+
+import java.util.Scanner;
+/*
+
+x x x   x x x
+x x       x x
+x           x
+
+x           x
+x x       x x
+x x x   x x x
+
+
+ */
+public class Pattern17 {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int n = sc.nextInt();//7
+        int nst = n/2; //   7/2 = 3
+        int nsp=1;
+
+        //rows
+        for(int row=1;row<=n;row++){
+
+            //star work
+            for(int cst = 1;cst<=nst;cst++){
+                System.out.print("x ");
+            }
+            //space work
+            for(int csp=1;csp<=nsp;csp++){
+                System.out.print("  ");
+            }
+
+            //star work
+            for(int cst = 1;cst<=nst;cst++){
+                System.out.print("x ");
+            }
+
+            //preparation
+            System.out.println();
+            if(row<=n/2){
+                nst--;
+                nsp+=2;
+            }else{
+                nst++;
+                nsp-=2;
+            }
+
+        }
+    }
+}
diff --git a/patterns/starPatterns/Pattern18.java b/patterns/starPatterns/Pattern18.java
new file mode 100644
index 0000000..f30b5be
--- /dev/null
+++ b/patterns/starPatterns/Pattern18.java
@@ -0,0 +1,47 @@
+package basics.patterns.starPatterns;
+
+import java.util.Scanner;
+
+/*
+      x
+    x x x
+  x x x x x
+x x x x x x x
+  x x x x x
+    x x x
+      x
+
+ */
+
+public class Pattern18 {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int n = sc.nextInt();//7
+
+        int nst = 1;
+        int nsp = n/2;
+
+        //row
+        for(int row=1;row<=n;row++){
+
+            //space
+            for(int csp=1;csp<=nsp;csp++){
+                System.out.print("  ");
+            }
+            //star
+            for(int cst = 1; cst <= nst ;cst++){
+                System.out.print("x ");
+            }
+
+            //preparation
+            System.out.println();
+            if(row<=n/2){
+                nsp--;
+                nst+=2;
+            }else{
+                nsp++;
+                nst-=2;
+            }
+        }
+    }
+}
diff --git a/patterns/starPatterns/Pattern19.java b/patterns/starPatterns/Pattern19.java
new file mode 100644
index 0000000..5217aac
--- /dev/null
+++ b/patterns/starPatterns/Pattern19.java
@@ -0,0 +1,63 @@
+package basics.patterns.starPatterns;
+
+import java.util.Scanner;
+
+/*
+
+x x x x x x x
+x x x   x x x
+x x       x x
+x           x
+x x       x x
+x x x   x x x
+x x x x x x x
+    
+
+ */
+
+public class Pattern19 {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int n = sc.nextInt();//7
+
+        int nst = n/2+1;
+        int nsp = -1;
+
+        //row
+        for(int row=1;row<=n;row++){
+
+            //star
+            if(row==1 | row==n){
+
+                for(int cst = 1; cst <= n ;cst++){
+                    System.out.print("x ");
+                }
+            }else{
+
+                //star
+                for(int cst = 1; cst <= nst ;cst++){
+                    System.out.print("x ");
+                }
+                //space
+                for(int csp=1;csp<=nsp;csp++) {
+                    System.out.print("  ");
+                }
+
+                //star
+                for(int cst = 1; cst <= nst ;cst++){
+                    System.out.print("x ");
+                }
+            }
+
+            //preparation
+            System.out.println();
+            if(row<=n/2){
+                nsp+=2;
+                nst--;
+            }else{
+                nsp-=2;
+                nst++;
+            }
+        }
+    }
+}
diff --git a/patterns/starPatterns/Pattern2.java b/patterns/starPatterns/Pattern2.java
new file mode 100644
index 0000000..f5da95d
--- /dev/null
+++ b/patterns/starPatterns/Pattern2.java
@@ -0,0 +1,33 @@
+package basics.patterns.starPatterns;
+
+import java.util.Scanner;
+
+public class Pattern2 {
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		int n = sc.nextInt();
+		int nst = 1; // no of star present in first row
+		int row=1;
+		
+		
+		// no of row
+		while(row<=n) {
+			
+			//work done
+
+			int cst = 1; //  counter of stars that need to bee print in a row
+			while(cst<=nst) {
+				System.out.print("x ");
+				cst++;
+			}
+			
+			//pre
+			System.out.println();
+			nst++;
+			row++;
+			
+			
+		}
+	}
+}
diff --git a/patterns/starPatterns/Pattern20.java b/patterns/starPatterns/Pattern20.java
new file mode 100644
index 0000000..7a7f6f9
--- /dev/null
+++ b/patterns/starPatterns/Pattern20.java
@@ -0,0 +1,13 @@
+package basics.patterns.starPatterns;
+
+import java.util.Scanner;
+
+public class Pattern20 {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int n = sc.nextInt();//7
+
+
+
+    }
+}
diff --git a/patterns/starPatterns/Pattern21.java b/patterns/starPatterns/Pattern21.java
new file mode 100644
index 0000000..2a97095
--- /dev/null
+++ b/patterns/starPatterns/Pattern21.java
@@ -0,0 +1,69 @@
+package basics.patterns.starPatterns;
+
+import java.util.Scanner;
+
+/*
+
+x               x
+x x           x x
+x x x       x x x
+x x x x   x x x x
+x x x x x x x x x
+
+
+ */
+
+public class Pattern21 {
+
+    public static void main(String[] args) {
+
+
+        Scanner sc = new Scanner(System.in);
+        int n = sc.nextInt();
+        int nst = 1;
+        int nsp = 2 * n - 3;
+
+        //rows
+        int row = 1;
+        while (row <= n) {
+
+            /*     work done     */
+
+            //star
+            int cst = 1;
+            while (cst <= nst) {
+                System.out.print("x ");
+                cst++;
+            }
+
+            //space
+            int csp = 1;
+            while (csp <= nsp) {
+                System.out.print("  ");
+                csp++;
+            }
+
+            //star
+
+            int cstt=1;
+            if(row==n){
+                cstt=2;
+            }
+            while (cstt<= nst) {
+                System.out.print("x ");
+                cstt++;
+            }
+
+
+            /* preparation   */
+            System.out.println();
+            nst++;
+            nsp -= 2;
+            row++;
+
+
+        }
+
+    }
+
+}
diff --git a/patterns/starPatterns/Pattern22.java b/patterns/starPatterns/Pattern22.java
new file mode 100644
index 0000000..1785f87
--- /dev/null
+++ b/patterns/starPatterns/Pattern22.java
@@ -0,0 +1,71 @@
+package basics.patterns.starPatterns;
+
+import java.util.Scanner;
+
+/*
+
+x x x x x x x x x
+x x x x   x x x x
+x x x       x x x
+x x           x x
+x               x
+
+*/
+
+public class Pattern22 {
+
+public static void main(String[] args) {
+
+
+    Scanner sc = new Scanner(System.in);
+    int n = sc.nextInt();
+    int nst = n;
+    int nsp = -1;
+
+    //rows
+    int row = 1;
+    while (row <= n) {
+
+        /*     work done     */
+
+        //star
+              int cst=1;
+               if(row==1) {
+                   cst = 2;
+               }
+            while (cst <= nst) {
+                System.out.print("x ");
+                cst++;
+            }
+
+
+
+        //space
+        int csp = 1;
+        while (csp <= nsp) {
+            System.out.print("  ");
+            csp++;
+        }
+
+        //star
+
+        int cstt=1;
+
+        while (cstt<= nst) {
+            System.out.print("x ");
+            cstt++;
+        }
+
+
+        /* preparation   */
+        System.out.println();
+        nst--;
+        nsp += 2;
+        row++;
+
+
+    }
+
+}
+
+}
diff --git a/patterns/starPatterns/Pattern3.java b/patterns/starPatterns/Pattern3.java
new file mode 100644
index 0000000..2eaad17
--- /dev/null
+++ b/patterns/starPatterns/Pattern3.java
@@ -0,0 +1,38 @@
+/**
+ * 
+ */
+package basics.patterns.starPatterns;
+
+import java.util.Scanner;
+
+public class Pattern3 {
+
+	
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		int n = sc.nextInt();
+		int nst = n; // no of star present in first row
+		int row = 1;
+
+
+		// no of row
+		while (row <= n) {
+
+			//work done
+
+			int cst = 1; //  counter of stars that need to bee print in a row
+			while (cst <= nst) {
+				System.out.print("x");
+				cst++;
+			}
+
+			//pre
+			System.out.println();
+			//System.out.print("\t");
+			nst--;
+			row++;
+		}
+
+	}
+
+}
diff --git a/patterns/starPatterns/Pattern4.java b/patterns/starPatterns/Pattern4.java
new file mode 100644
index 0000000..659dfa3
--- /dev/null
+++ b/patterns/starPatterns/Pattern4.java
@@ -0,0 +1,53 @@
+package basics.patterns.starPatterns;
+
+import java.util.Scanner;
+
+/*
+      *
+     **
+    ***
+   ****
+  *****
+ ******
+*******
+
+ */
+
+public class Pattern4 {
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		int n = sc.nextInt();
+		int nsp = n-1;
+		int nst = 1;
+		
+		// row
+		int row=1;
+		while(row<= n ) {
+			
+			// space work
+			
+			int csp = 1;
+			while(csp<= nsp) {
+				System.out.print(" ");
+				csp++;
+			}
+			
+			// star work
+			
+			int cst = 1;
+			
+			while(cst <= nst) {
+				System.out.print("*");
+				cst++;
+			}
+			
+			//preparation
+			System.out.println();
+			nsp--;
+			nst++;
+			row++;
+		}
+	}
+
+}
diff --git a/patterns/starPatterns/Pattern5.java b/patterns/starPatterns/Pattern5.java
new file mode 100644
index 0000000..486a380
--- /dev/null
+++ b/patterns/starPatterns/Pattern5.java
@@ -0,0 +1,42 @@
+package basics.patterns.starPatterns;
+
+import java.util.Scanner;
+
+public class Pattern5 {
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		int n = sc.nextInt();
+		int nsp=0;
+		int nst = n;
+		
+		
+		//rows
+		int row=1;
+		while( row <= n) {
+			
+			//star work
+			int cst = 1;
+			while(cst <= nst) {
+				System.out.print("x");
+				cst++;
+			}
+			
+			//space work
+
+			int csp = 1;
+			while(csp <= nsp) {
+				System.out.print(" ");
+				csp++;
+			}
+			
+			//pre
+			System.out.println();
+			nsp++;
+			nst--;
+			row++;
+		}
+
+	}
+
+}
diff --git a/patterns/starPatterns/Pattern6.java b/patterns/starPatterns/Pattern6.java
new file mode 100644
index 0000000..2f48cc9
--- /dev/null
+++ b/patterns/starPatterns/Pattern6.java
@@ -0,0 +1,40 @@
+package basics.patterns.starPatterns;
+
+import java.util.Scanner;
+
+public class Pattern6 {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int n = sc.nextInt();
+        int nst = n;
+        int nsp = 0;
+
+        //rows
+        int rows =1;
+        while( rows <=n){
+
+            //spaces work
+            if(nsp>=2){
+                int csp = 1;
+                 while(csp<=nsp){
+                     System.out.print(" ");
+                     csp++;
+                 }
+            }
+
+            //star work
+            int cst = 1;
+            while (cst <=nst){
+                System.out.print("x");
+                cst++;
+            }
+
+            System.out.println();
+            nst--;
+            nsp+=2;
+            rows++;
+
+
+        }
+    }
+}
diff --git a/patterns/starPatterns/Pattern7.java b/patterns/starPatterns/Pattern7.java
new file mode 100644
index 0000000..3a5fdf6
--- /dev/null
+++ b/patterns/starPatterns/Pattern7.java
@@ -0,0 +1,39 @@
+package basics.patterns.starPatterns;
+
+import java.util.Scanner;
+
+public class Pattern7 {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int n = sc.nextInt();
+
+        int nst =n;
+        //rows
+
+        for(int row=1;row<=n;row++){
+            //work done
+            if(row==1 || row==n){
+                for(int cst =1; cst<=nst;cst++ ){
+                    System.out.print("x ");
+                }
+            }
+            else{
+                for(int cst =1;cst<=n;cst++){
+                    if(cst==1 || cst==n){
+                        System.out.print("x ");
+                    }else{
+                        System.out.print("  ");
+                    }
+
+
+                }
+
+            }
+
+
+
+            System.out.println();
+
+        }
+    }
+}
diff --git a/patterns/starPatterns/Pattern8.java b/patterns/starPatterns/Pattern8.java
new file mode 100644
index 0000000..8e84da2
--- /dev/null
+++ b/patterns/starPatterns/Pattern8.java
@@ -0,0 +1,14 @@
+package basics.patterns.starPatterns;
+
+import java.util.Scanner;
+
+public class Pattern8 {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int n = sc.nextInt();
+
+
+
+
+    }
+}
diff --git a/patterns/starPatterns/Pattern9.java b/patterns/starPatterns/Pattern9.java
new file mode 100644
index 0000000..305c6e6
--- /dev/null
+++ b/patterns/starPatterns/Pattern9.java
@@ -0,0 +1,46 @@
+package basics.patterns.starPatterns;
+
+import java.util.Scanner;
+
+/*
+    x
+   xxx
+  xxxxx
+ xxxxxxx
+xxxxxxxxx
+
+ */
+
+public class Pattern9 {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int n = sc.nextInt();
+        int nst = 1;
+        int nsp = n-1;
+
+        //rows
+        int row=1;
+        while(row<=n){
+            // space work
+            int csp= 1;
+            while(csp<=nsp){
+                System.out.print(" ");
+                csp++;
+            }
+
+            //star work
+
+            int cst= 1;
+            while(cst<=nst){
+                System.out.print("x");
+                cst++;
+            }
+
+            //preparation
+            System.out.println();
+            nsp--;
+            nst+=2;
+            row++;
+        }
+    }
+}