diff --git a/C++/Combination Sum.cpp b/C++/Combination Sum.cpp
new file mode 100644
index 0000000000..6c9ffc221d
--- /dev/null
+++ b/C++/Combination Sum.cpp	
@@ -0,0 +1,49 @@
+#include<vector>
+#include<stdio.h>
+
+class Solution {
+
+    public:
+    
+        vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
+    
+            vector<vector<int>> res;
+    
+            vector<int> comb;
+    
+            makeCombination(candidates, target, 0, comb, 0, res);
+    
+            return res;        
+    
+        }
+    
+    private:
+    
+        void makeCombination(std::vector<int>& candidates, int target, int idx, vector<int>& comb, int total, vector<vector<int>>& res) {
+    
+            if (total == target) {
+    
+                res.push_back(comb);
+    
+                return;
+    
+            }
+    
+            if (total > target || idx >= candidates.size()) {
+    
+                return;
+    
+            }
+    
+            comb.push_back(candidates[idx]);
+    
+            makeCombination(candidates, target, idx, comb, total + candidates[idx], res);
+    
+            comb.pop_back();
+    
+            makeCombination(candidates, target, idx + 1, comb, total, res);
+    
+        }    
+    
+    };
+    
\ No newline at end of file
diff --git a/C++/Diameter of a Binary Tree.cpp b/C++/Diameter of a Binary Tree.cpp
new file mode 100644
index 0000000000..1fd2b037d2
--- /dev/null
+++ b/C++/Diameter of a Binary Tree.cpp	
@@ -0,0 +1,17 @@
+class Solution {
+    public: 
+    int ans=0;
+    int height(TreeNode* root){
+        if(root==NULL){
+            return 0;
+        }
+        int leftHt= height(root->left);
+        int rightHt= height(root->right);
+        ans=max(leftHt+rightHt,ans);
+        return max(leftHt,rightHt)+1;
+    }
+        int diameterOfBinaryTree(TreeNode* root) { 
+            height(root);
+            return ans;
+        }
+    };
\ No newline at end of file
diff --git a/C++/Lowest Common Ancestor of a Binary Tree.cpp b/C++/Lowest Common Ancestor of a Binary Tree.cpp
new file mode 100644
index 0000000000..f63c8b6a3b
--- /dev/null
+++ b/C++/Lowest Common Ancestor of a Binary Tree.cpp	
@@ -0,0 +1,32 @@
+/*
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+*/
+class Solution {
+    public:
+        TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
+          if(root==NULL){
+            return NULL;
+          }
+          if(root->val==p->val || root->val==q->val){
+            return root;
+          }
+          TreeNode* leftLCA=lowestCommonAncestor(root->left,p,q);
+          TreeNode* rightLCA=lowestCommonAncestor(root->right,p,q);
+          if(leftLCA && rightLCA)
+          {
+            return root;
+          }
+          else if(leftLCA!=NULL){
+            return leftLCA;
+          }
+          else{
+            return rightLCA;
+          }
+        }
+    };
\ No newline at end of file
diff --git a/Java/.project b/Java/.project
index 4fdb69a93e..d92baf7aec 100644
--- a/Java/.project
+++ b/Java/.project
@@ -14,4 +14,19 @@
 	<natures>
 		<nature>org.eclipse.jdt.core.javanature</nature>
 	</natures>
+	<filteredResources>
+		<filter>
+<<<<<<< HEAD
+			<id>1745466012044</id>
+=======
+			<id>1744612223460</id>
+>>>>>>> ccb4566f91334ed4ca8447e7932db4fa2b1a10d1
+			<name></name>
+			<type>30</type>
+			<matcher>
+				<id>org.eclipse.core.resources.regexFilterMatcher</id>
+				<arguments>node_modules|\.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__</arguments>
+			</matcher>
+		</filter>
+	</filteredResources>
 </projectDescription>
diff --git a/Java/Build Array from Permutation.java b/Java/Build Array from Permutation.java
new file mode 100644
index 0000000000..d1c56f7581
--- /dev/null
+++ b/Java/Build Array from Permutation.java	
@@ -0,0 +1,11 @@
+class Solution {
+
+    public int[] buildArray(int[] nums) {
+        int n = nums.length;
+        int[] ans = new int[n];
+        for (int i = 0; i < n; ++i) {
+            ans[i] = nums[nums[i]];
+        }
+        return ans;
+    }
+}
diff --git a/Java/Count Equal and Divisible in an Array.java b/Java/Count Equal and Divisible in an Array.java
new file mode 100644
index 0000000000..22d9f82330
--- /dev/null
+++ b/Java/Count Equal and Divisible in an Array.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int countPairs(int[] nums, int k) {
+        int n=nums.length;
+        int res=0;
+        for(int i=0;i<n-1;++i)
+        {
+            for(int j=i+1;j<n;++j)
+            {
+                if((i*j)%k==0 && nums[i]==nums[j])
+                {
+                    ++res;
+                }
+            }
+        }
+        return res;
+    }
+}
\ No newline at end of file
diff --git a/Java/Count Hidden Sequence.java b/Java/Count Hidden Sequence.java
new file mode 100644
index 0000000000..c398d16df7
--- /dev/null
+++ b/Java/Count Hidden Sequence.java	
@@ -0,0 +1,19 @@
+public  class Solution {
+    public int numberOfArrays(int[] differences, int lower, int upper) {
+        int n = differences.length;
+        int prefix = 0;
+        int min = 0;
+        int max = 0;
+        int diff = upper-lower;
+        
+        for(int i = 0;i<n;i++){
+            prefix = prefix + differences[i];
+            min = Math.min(min,prefix);
+            max = Math.max(max,prefix);
+            if(max-min > diff) return 0;
+        }
+        return (diff) - (max -min) +1;
+    }
+} 
+    
+
diff --git a/Java/Count Largest Group.java b/Java/Count Largest Group.java
new file mode 100644
index 0000000000..30507221a2
--- /dev/null
+++ b/Java/Count Largest Group.java	
@@ -0,0 +1,26 @@
+class Solution {
+    public int countLargestGroup(int n) {
+       Map<Integer, Integer>hashMap=new HashMap<Integer,Integer>();
+        int maxValue=0;
+        for(int i=1;i<=n;i++)
+        {
+            int key=0,num=i;
+            while(num!=0)
+            {
+                key+=num%10;
+                num=num/10;
+            }
+            hashMap.put(key,hashMap.getOrDefault(key,0)+1);
+            maxValue=Math.max(maxValue,hashMap.get(key));
+   }
+     int count=0;
+        for(Map.Entry<Integer,Integer>kvpair: hashMap.entrySet()){
+            if(kvpair.getValue()== maxValue)
+                {
+                ++count;
+                }
+            }
+        return count;
+                
+    }
+}
\ No newline at end of file
diff --git a/Java/Count Number of Subarrays of Length 3 within the condition.java b/Java/Count Number of Subarrays of Length 3 within the condition.java
new file mode 100644
index 0000000000..1fcbe2a495
--- /dev/null
+++ b/Java/Count Number of Subarrays of Length 3 within the condition.java	
@@ -0,0 +1,27 @@
+public class Solution 
+{
+    public int countSubarrays(int[] nums) 
+    {
+        int count = 0;
+        
+        // Step 1: Loop through the array to check subarrays of size 3
+        for (int i = 0; i <= nums.length - 3; i++) 
+        {
+            // Step 2: Extract the three consecutive elements
+            int first = nums[i];
+            int second = nums[i + 1];
+            int third = nums[i + 2];
+            
+            // Step 3: Check if 2 * (first + third) == second
+            if (2 * (first + third) == second) 
+            {
+                count++; // Increment count if condition is satisfied
+            }
+        }
+        
+        // Step 4: Return the final count of subarrays that satisfy the condition
+        return count;
+        //he.ll
+    }
+
+} 
diff --git a/Java/Count Subarray Where max element appear more than k .java b/Java/Count Subarray Where max element appear more than k .java
new file mode 100644
index 0000000000..1557a4e9d1
--- /dev/null
+++ b/Java/Count Subarray Where max element appear more than k .java	
@@ -0,0 +1,19 @@
+class Solution {
+    public long countSubarrays(int[] nums, int k) {
+        int n = nums.length;
+        int maxVal = 0;
+        for (int v : nums) maxVal = Math.max(maxVal, v);
+
+        long res = 0;
+        int count = 0, left = 0;
+        for (int right = 0; right < n; right++) {
+            if (nums[right] == maxVal) count++;
+            while (count >= k) {
+                if (nums[left] == maxVal) count--;
+                left++;
+            }
+            res += left;
+        }
+        return res;
+    }
+}
diff --git a/Java/Count and Say.java b/Java/Count and Say.java
new file mode 100644
index 0000000000..bdebba3d63
--- /dev/null
+++ b/Java/Count and Say.java	
@@ -0,0 +1,75 @@
+class Combinations {
+    long[] fact;
+    long[] invFact;
+    long M;
+
+    public Combinations(int n, long mod) {
+        M = mod;
+        fact = new long[n + 1];
+        invFact = new long[n + 1];
+        fact[0] = 1;
+        invFact[0] = 1;
+        for (int i = 1; i <= n; i++) {
+            fact[i] = (fact[i - 1] * i) % M;
+            invFact[i] = power(fact[i], M - 2);
+        }
+    }
+
+    long power(long base, long exp) {
+        long res = 1;
+        base %= M;
+        while (exp > 0) {
+            if ((exp & 1) == 1) res = (res * base) % M;
+            base = (base * base) % M;
+            exp >>= 1;
+        }
+        return res;
+    }
+
+    long nCr(int n, int r) {
+        if (r < 0 || r > n) return 0;
+        long num = fact[n];
+        long den = (invFact[r] * invFact[n - r]) % M;
+        return (num * den) % M;
+    }
+}
+
+class Solution {
+    private static final int MOD = 1_000_000_007;
+
+    public int idealArrays(int n, int maxValue) {
+        Combinations comb = new Combinations(n, MOD);
+        long[] dp = new long[maxValue + 1];
+        long totalAns = maxValue;
+
+        for (int i = 1; i <= maxValue; i++) {
+            dp[i] = 1;
+        }
+
+        int kLimit = Math.min(n, 16);
+
+        for (int k = 2; k <= kLimit; k++) {
+            long[] next_dp = new long[maxValue + 1];
+            for (int j = 1; j <= maxValue; j++) {
+                if (dp[j] == 0) continue;
+                for (long i = 2L * j; i <= maxValue; i += j) {
+                    next_dp[(int) i] = (next_dp[(int) i] + dp[j]) % MOD;
+                }
+            }
+
+            long count = 0;
+            for (int i = 1; i <= maxValue; i++) {
+                count = (count + next_dp[i]) % MOD;
+            }
+
+            if (count == 0) break;
+
+            long factor = comb.nCr(n - 1, k - 1);
+            totalAns = (totalAns + count * factor % MOD) % MOD;
+
+            dp = next_dp;
+        }
+
+        return (int) totalAns;
+    }
+}
\ No newline at end of file
diff --git a/Java/Count of Good Subarray.java b/Java/Count of Good Subarray.java
new file mode 100644
index 0000000000..da19d185c5
--- /dev/null
+++ b/Java/Count of Good Subarray.java	
@@ -0,0 +1,22 @@
+public class Solution {
+
+    public long countGood(int[] nums, int k) {
+        int n = nums.length;
+        int same = 0, right = -1;
+        HashMap<Integer, Integer> cnt = new HashMap<>();
+        long ans = 0;
+        for (int left = 0; left < n; ++left) {
+            while (same < k && right + 1 < n) {
+                ++right;
+                same += cnt.getOrDefault(nums[right], 0);
+                cnt.put(nums[right], cnt.getOrDefault(nums[right], 0) + 1);
+            }
+            if (same >= k) {
+                ans += n - right;
+            }
+            cnt.put(nums[left], cnt.get(nums[left]) - 1);
+            same -= cnt.get(nums[left]);
+        }
+        return ans;
+    }
+} 
diff --git a/Java/Count of Interested Subarrays.java b/Java/Count of Interested Subarrays.java
new file mode 100644
index 0000000000..5f904d73fd
--- /dev/null
+++ b/Java/Count of Interested Subarrays.java	
@@ -0,0 +1,32 @@
+class Solution 
+{
+    public long countInterestingSubarrays(List<Integer> nums, int modulo, int k) 
+    {
+        // Step 1 : Initialize result, prefix sum, and a map with base case
+        long result = 0;
+        int prefix = 0;
+        Map<Integer, Long> map = new HashMap<>();
+        map.put(0, 1L);
+
+        // Step 2 : Traverse through nums
+        for (int num : nums) 
+        {
+            // Step 3 : Check condition and update prefix
+            if (num % modulo == k) 
+            {
+                prefix++;
+            }
+
+            // Step 4 : Calculate current prefix mod and target
+            int mod = prefix % modulo;
+            int target = (mod - k + modulo) % modulo;
+
+            // Step 5 : Add to result and update map
+            result += map.getOrDefault(target, 0L);
+            map.put(mod, map.getOrDefault(mod, 0L) + 1);
+        }
+
+        // Step 6 : Return final count
+        return result;
+    }
+}
diff --git a/Java/Count of Subarray with Score less than k.java b/Java/Count of Subarray with Score less than k.java
new file mode 100644
index 0000000000..9536523b93
--- /dev/null
+++ b/Java/Count of Subarray with Score less than k.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public long countSubarrays(int[] nums, long k) {
+           int n=nums.length;
+        long res=0,total=0;
+        for(int i=0,j=0;j<n;j++){
+            total+=nums[j];
+            while(i<=j && total*(j-i+1)>=k){
+                total-=nums[i];
+                i++;
+            }
+            res+=j-i+1;
+        }
+        return res;
+    }
+}
\ No newline at end of file
diff --git a/Java/Count of Subarrays in An Array.java b/Java/Count of Subarrays in An Array.java
new file mode 100644
index 0000000000..5032b24ab9
--- /dev/null
+++ b/Java/Count of Subarrays in An Array.java	
@@ -0,0 +1,28 @@
+class Solution {
+    public int countCompleteSubarrays(int[] nums) {
+        int cnt = 0;
+        HashSet<Integer> set = new HashSet<>();
+        for (int i = 0; i < nums.length; i++) {
+            set.add(nums[i]);
+        }
+        HashMap<Integer, Integer> map = new HashMap<>();
+        int i = 0, j = 0;
+        while (j < nums.length) {
+            map.put(nums[j], map.getOrDefault(nums[j], 0) + 1);
+            if (map.size() == set.size()) {
+                cnt += nums.length - j;
+                while (true) {
+                    map.put(nums[i], map.get(nums[i]) - 1);
+                    if (map.get(nums[i]) == 0) {
+                        map.remove(nums[i++]);
+                        break;
+                    }
+                    cnt += nums.length - j;
+                    i++;
+                }
+            }
+            j++;
+        }
+        return cnt;
+    }
+}
\ No newline at end of file
diff --git a/Java/Domino and Tromino Tiling.java b/Java/Domino and Tromino Tiling.java
new file mode 100644
index 0000000000..971539563e
--- /dev/null
+++ b/Java/Domino and Tromino Tiling.java	
@@ -0,0 +1,26 @@
+#include<stdio.h>
+
+public class Solution {
+    public:
+        const int MOD = 1e9 + 7;
+        template <typename T>
+        inline T mod_add(T a, T b, T m) { return (a % m + b % m) % m; }
+        vector<int> dp;
+        int rec(int idx) {
+            if (idx == 0) return 1;
+            if (idx == 1) return 1;
+            if (idx == 2) return 2;
+            if (dp[idx] != -1) return dp[idx];
+            auto ans = (2LL * rec(idx - 1)) % MOD;
+            ans = mod_add<long long>(ans, rec(idx - 3), MOD);
+            
+            return dp[idx] = ans;
+        }
+    
+    
+        int numTilings(int n) {
+            dp.assign(n + 1, -1);
+            return rec(n);
+        }
+    };
+
diff --git a/Java/Find Minimum time to reach the last Room I.java b/Java/Find Minimum time to reach the last Room I.java
new file mode 100644
index 0000000000..b340e8113c
--- /dev/null
+++ b/Java/Find Minimum time to reach the last Room I.java	
@@ -0,0 +1,55 @@
+class Solution {
+
+    private static final int INF = 0x3f3f3f3f;
+
+    public int minTimeToReach(int[][] moveTime) {
+        int n = moveTime.length, m = moveTime[0].length;
+        int[][] d = new int[n][m];
+        boolean[][] v = new boolean[n][m];
+        for (int i = 0; i < n; i++) {
+            Arrays.fill(d[i], INF);
+        }
+
+        int[][] dirs = { { 1, 0 }, { -1, 0 }, { 0, 1 }, { 0, -1 } };
+        d[0][0] = 0;
+        PriorityQueue<State> q = new PriorityQueue<>();
+        q.offer(new State(0, 0, 0));
+
+        while (!q.isEmpty()) {
+            State s = q.poll();
+            if (v[s.x][s.y]) {
+                continue;
+            }
+            v[s.x][s.y] = true;
+            for (int[] dir : dirs) {
+                int nx = s.x + dir[0];
+                int ny = s.y + dir[1];
+                if (nx < 0 || nx >= n || ny < 0 || ny >= m) {
+                    continue;
+                }
+                int dist = Math.max(d[s.x][s.y], moveTime[nx][ny]) + 1;
+                if (d[nx][ny] > dist) {
+                    d[nx][ny] = dist;
+                    q.offer(new State(nx, ny, dist));
+                }
+            }
+        }
+        return d[n - 1][m - 1];
+    }
+
+    static class State implements Comparable<State> {
+
+        int x, y, dis;
+
+        State(int x, int y, int dis) {
+            this.x = x;
+            this.y = y;
+            this.dis = dis;
+        }
+
+        @Override
+        public int compareTo(State other) {
+            return Integer.compare(this.dis, other.dis);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Java/Find Minimum time to reach the last room II.java b/Java/Find Minimum time to reach the last room II.java
new file mode 100644
index 0000000000..d04ab7516d
--- /dev/null
+++ b/Java/Find Minimum time to reach the last room II.java	
@@ -0,0 +1,72 @@
+import java.util.*;
+
+public class Solution {
+
+    public int minTimeToReach(int[][] moveTime) {
+
+        int n = moveTime.length;
+
+        int m = moveTime[0].length;
+
+        int[][] bestTime = new int[n][m];
+
+        for (int[] row : bestTime) {
+
+            Arrays.fill(row, Integer.MAX_VALUE);
+
+        }
+
+        int[][] directions = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
+
+        PriorityQueue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt(a -> a[0]));
+
+        pq.offer(new int[]{0, 0, 0, 0}); // time, i, j, nextMoveTime
+
+        while (!pq.isEmpty()) {
+
+            int[] curr = pq.poll();
+
+            int time = curr[0], i = curr[1], j = curr[2], nextMoveTime = curr[3];
+
+            if (time >= bestTime[i][j]) continue;
+
+            bestTime[i][j] = time;
+
+            if (i == n - 1 && j == m - 1) return time;
+
+            for (int[] d : directions) {
+
+                int x = i + d[0], y = j + d[1];
+
+                if (x >= 0 && x < n && y >= 0 && y < m) {
+
+                    int wait = moveTime[x][y];
+
+                    int futureMove = nextMoveTime == 1 ? 2 : 1;
+
+                    int nextTime = wait > time ? wait + futureMove : time + futureMove;
+
+                    if (i == 0 && j == 0 && wait <= time) {
+
+                        nextTime = wait + futureMove;
+
+                    }
+
+                    if (nextTime < bestTime[x][y]) {
+
+                        pq.offer(new int[]{nextTime, x, y, futureMove});
+
+                    }
+
+                }
+
+            }
+
+        }
+
+        return -1; // Should never reach
+
+    }
+
+}
+    
diff --git a/Java/Find Numbers with Even Numbers of Digits.java b/Java/Find Numbers with Even Numbers of Digits.java
new file mode 100644
index 0000000000..abe01753f6
--- /dev/null
+++ b/Java/Find Numbers with Even Numbers of Digits.java	
@@ -0,0 +1,23 @@
+class Solution {
+    // Helper function to check if the number of digits is even
+    private boolean hasEvenDigits(int num) {
+        int digitCount = 0;
+        while (num != 0) {
+            digitCount++;
+            num /= 10;
+        }
+        return (digitCount & 1) == 0;
+    }
+
+    public int findNumbers(int[] nums) {
+        // Counter to count the number of even digit integers
+        int evenDigitCount = 0;
+
+        for (int num : nums) {
+            if (hasEvenDigits(num))
+                evenDigitCount++;
+        }
+
+        return evenDigitCount;
+    }
+}
diff --git a/Java/Maximum Value of an  Ordered Triplets.java b/Java/Maximum Value of an  Ordered Triplets.java
new file mode 100644
index 0000000000..1453d1b089
--- /dev/null
+++ b/Java/Maximum Value of an  Ordered Triplets.java	
@@ -0,0 +1,30 @@
+ //TC:O(N)
+ //SC:O(N)
+
+class Solution {
+    public long maximumTripletValue(int[]  nums){
+        int n = nums.length;
+        if (n < 3) return 0;
+
+        int[] leftMax = new int[n];
+        leftMax[0] = nums[0];
+        for (int i = 1; i < n; i++) {
+            leftMax[i] = Math.max(leftMax[i - 1], nums[i]);
+        }
+
+        int[] rightMax = new int[n];
+        rightMax[n - 1] = nums[n - 1];
+        for (int i = n - 2; i >= 0; i--) {
+            rightMax[i] = Math.max(rightMax[i + 1], nums[i]);
+        }
+
+        long ans = 0;  
+        for (int i = 1; i < n - 1; i++) {
+            int left = leftMax[i - 1];
+            int right = rightMax[i + 1];
+            ans = Math.max(ans, (long)(left - nums[i]) * right); 
+        }
+
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/Java/Minimum Dominaeo Rotation for Equal row.java b/Java/Minimum Dominaeo Rotation for Equal row.java
new file mode 100644
index 0000000000..eba0c9432a
--- /dev/null
+++ b/Java/Minimum Dominaeo Rotation for Equal row.java	
@@ -0,0 +1,47 @@
+class Solution 
+{
+    public int minDominoRotations(int[] tops, int[] bottoms) 
+    {
+        // Step 1: Try to make all values equal to tops[0]
+        int result = check(tops[0], tops, bottoms);
+
+        // Step 2: If tops[0] failed, try bottoms[0]
+        if (result != -1) return result;
+
+        // Step 3: Return result from checking bottoms[0]
+        return check(bottoms[0], tops, bottoms);
+    }
+
+    // Step 4: Helper function to count rotations to make all values = target
+    private int check(int target, int[] tops, int[] bottoms) 
+    {
+        int rotateTop = 0;    // Rotations needed to bring target to top
+        int rotateBottom = 0; // Rotations needed to bring target to bottom
+
+        // Step 5: Loop through all dominoes
+        for (int i = 0; i < tops.length; i++) 
+        {
+            // Step 6: If target is not on either side, it's impossible
+            if (tops[i] != target && bottoms[i] != target) 
+            {
+                return -1;
+            }
+
+            // Step 7: If top doesn't have the target, it must be rotated
+            if (tops[i] != target)
+            {
+                rotateTop++;
+            } 
+
+            // Step 8: If bottom doesn't have the target, it must be rotated
+            if (bottoms[i] != target)
+            {
+                rotateBottom++;
+            } 
+        }
+
+        // Step 9: Return the minimum of the two rotation counts
+        return Math.min(rotateTop, rotateBottom);
+    }
+}
+    
\ No newline at end of file
diff --git a/Three Consecutive Odds.java b/Three Consecutive Odds.java
new file mode 100644
index 0000000000..f6077e692c
--- /dev/null
+++ b/Three Consecutive Odds.java	
@@ -0,0 +1,14 @@
+class Solution {
+    public boolean threeConsecutiveOdds(int[] arr) {
+        // Loop through the array up to the third-to-last element
+        for (int i = 0; i < arr.length - 2; i++) {
+            // Check if the current element and the next two elements are all odd
+            int product=arr[i]*arr[i+1]*arr[i+2];
+            if(product% 2==1){
+                return true;
+            }
+        }
+
+        return false;
+    }
+}