├── README.md
├── 14.SavethePrisioner.cpp
├── 7.Staircase.cpp
├── 2.Birthday.cpp
├── 25.Bon_Appétit.cpp
├── 5.MiniandMax.cpp
├── 15.SherlockAndSquares.cpp
├── 26.BreakingtheRecords.cpp
├── 27.CatAndMouse.cpp
├── 29.Circular_Array_Rotation.cpp
├── 19. HurdleRace.cpp
├── 4.DiagonalDIff.cpp
├── 13.RepeatedString.cpp
├── 1.Time.cpp
├── 3.CompTrip.cpp
├── 12.PickingNumbers.cpp
├── 11.Sequence.cpp
├── 10.MinimumDist.cpp
├── 9.MigratoryBirds.cpp
├── 6.PlusMinus.cpp
├── 28.CavityMap.cpp
├── 30.ClimbingtheLeaderboard.cpp
├── 8.MatrixLRotation.cpp
└── 24.Between_Two_Sets.cpp


/README.md:
--------------------------------------------------------------------------------
1 | # Long-Hour-Coding
2 | 


--------------------------------------------------------------------------------
/14.SavethePrisioner.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | int saveThePrisoner(int n, int m, int s) {
 4 |     int last_position = (s + m - 1) % n;
 5 |     return last_position == 0 ? n : last_position;
 6 | }
 7 | 
 8 | int main() {
 9 |     int t;
10 |     cin >> t;
11 |     while(t--) {
12 |         int n, m, s;
13 |         cin >> n >> m >> s;
14 |         cout << saveThePrisoner(n, m, s) << endl;
15 |     }
16 |     
17 |     return 0;
18 | }
19 | 


--------------------------------------------------------------------------------
/7.Staircase.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | void Staircase(int n){
 4 |     for (int i = 0 ; i< n;i++){
 5 |         for(int j = 0;j< n-i-1;j++){
 6 |             cout<<" ";
 7 |         }
 8 |         for (int j = 0;j< i;j++){
 9 |             cout<<"# ";
10 |         }
11 |         for(int j = 0;j< n-i-1;j++){
12 |             cout<<" ";
13 |         }
14 |         cout<<endl;
15 |     }
16 | }
17 | int main(){
18 |     int n ;
19 |     cin>>n;
20 |     Staircase(n);
21 |     return 0;
22 | }


--------------------------------------------------------------------------------
/2.Birthday.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | int main() {
 4 |     int n;
 5 |     cin >> n; 
 6 |     vector<int> candles(n);
 7 |     for (int i = 0; i < n; i++) {
 8 |         cin >> candles[i]; 
 9 |     }
10 |     int max_height = *max_element(candles.begin(), candles.end());
11 |     int count = 0;
12 |     for (int height : candles) {
13 |         if (height == max_height) {
14 |             count++;
15 |         }
16 |     }
17 |     cout << count << endl; 
18 |     return 0;
19 | }
20 | 


--------------------------------------------------------------------------------
/25.Bon_Appétit.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int main()
 5 | {
 6 |     int n,k;
 7 |     cin>>n>>k;
 8 |     vector<int> cost(n);
 9 |     int total=0;
10 |     for(int i=0;i<n;i++)
11 |     {
12 |         cin>>cost[i];
13 |         total=total+cost[i];
14 |     }
15 |     int share=(total-cost[k])/2;
16 |     int b;
17 |     cin>>b;
18 |     if(b==share)
19 |     {
20 |         cout<<"Bon Appetit.....";
21 |     }
22 |     else
23 |     {
24 |         cout<<b-share;
25 |     }
26 |     return 0;
27 | }


--------------------------------------------------------------------------------
/5.MiniandMax.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | void miniMaxSum(vector<long long> arr) {
 4 |     sort(arr.begin(), arr.end());
 5 |     long long minSum = accumulate(arr.begin(), arr.end() - 1, 0LL);
 6 |     long long maxSum = accumulate(arr.begin() + 1, arr.end(), 0LL);
 7 |     cout << minSum << " " << maxSum << endl;
 8 | }
 9 | int main() {
10 |     vector<long long> arr(5);
11 |     for (int i = 0; i < 5; ++i) {
12 |         cin >> arr[i];
13 |     }
14 |     miniMaxSum(arr);
15 |     return 0;
16 | }
17 | 


--------------------------------------------------------------------------------
/15.SherlockAndSquares.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream> 
 2 | #include <cmath> 
 3 | using namespace std; 
 4 |  
 5 | int squares(int a, int b) { 
 6 |     //smallest integer x such that x^2 >= a 
 7 |     int start = ceil(sqrt(a)); 
 8 |     //largest integer y such that y^2 <= b 
 9 |     int end = floor(sqrt(b)); 
10 |     return (end - start + 1); 
11 | } 
12 |  
13 | int main() { 
14 |     int T; 
15 |     cin >> T;  
16 |  
17 |     while (T--) { 
18 |         int a, b; 
19 |         cin >> a >> b; 
20 |         cout << squares(a, b) << endl; 
21 |     } 
22 |  
23 |     return 0; 
24 | }


--------------------------------------------------------------------------------
/26.BreakingtheRecords.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     int n;
 6 |     cin>>n;
 7 |     vector<int> score(n);
 8 |     for(int i=0;i<n;i++)
 9 |     {
10 |         cin>>score[i];
11 |     }
12 |     int max=score[0];
13 |     int maxcount=0;
14 |     int min=score[0];
15 |     int mincount=0;
16 |     for(int i:score)
17 |     {
18 |         if(i>max)
19 |         {
20 |             maxcount++;
21 |             max=i;
22 |         }
23 |         if(i<min)
24 |         {
25 |             mincount++;
26 |             min=i;
27 |         }
28 |     }
29 |     cout<<maxcount<<" "<<mincount;
30 |     return 0;
31 | }


--------------------------------------------------------------------------------
/27.CatAndMouse.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     int q;
 6 |     cin>>q;
 7 |     vector<int> a(q);
 8 |     vector<int> b(q);
 9 |     vector<int> m(q);
10 |     for (int i = 0; i < q; i++)
11 |     {
12 |         cin>>a[i]>>b[i]>>m[i];
13 |     }
14 |     int disa,disb;
15 |     for (int i = 0; i < q; i++)
16 |     {
17 |         disa=m[i]-a[i];
18 |         disb=m[i]-b[i];
19 |         if(disa<0){disa=disa*-1;}
20 |         if(disb<0){disb=disb*-1;}
21 |         if(disa<disb){cout<<"Cat A\n";}
22 |         if(disb<disa){cout<<"Cat B\n";}
23 |         if(disa==disb){cout<<"Mouse C\n";}
24 |     }
25 |     return 0;
26 | }


--------------------------------------------------------------------------------
/29.Circular_Array_Rotation.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int main()
 5 | {
 6 |     int n,k,q;
 7 |     cin>>n>>k>>q;
 8 |     vector<int> v(n);
 9 |     for (int i = 0; i < n; i++)
10 |     {
11 |         cin>>v[i];
12 |     }
13 |     vector<int> que(q);
14 |     for (int i = 0; i < q; i++)
15 |     {
16 |         cin>>que[i];
17 |     }
18 |     for(int i=0;i<k;i++)
19 |     {
20 |         int temp=v[v.size()-1];
21 |         for(int j=v.size()-1;j>0;j--)
22 |         {
23 |             v[j]=v[j-1];
24 |         }
25 |         v[0]=temp;
26 |     }
27 |     
28 |     for (int i:que)
29 |     {
30 |         cout<<v[i]<<endl;
31 |     }
32 |     return 0;
33 |     
34 | }
35 | 
36 | 


--------------------------------------------------------------------------------
/19. HurdleRace.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream> 
 2 | using namespace std; 
 3 | int HurdleRace(int height[], int n, int k) 
 4 | { 
 5 |     int max_e = height[0]; 
 6 |     for(int i = 0; i < n; i++){ 
 7 |         if(height[i] > max_e){ 
 8 |             max_e = height[i]; 
 9 |         } 
10 |     } 
11 |     if(k > max_e){ 
12 |         return 0; 
13 |     } 
14 |     int potion = max_e - k; 
15 |     return potion; 
16 | } 
17 |  
18 | int main(){ 
19 |     int n, k; 
20 |     cin >> n >> k;  
21 |     int height[n]; 
22 |     for(int i = 0; i < n; i++){ 
23 |         cin >> height[i]; 
24 |     } 
25 |     int potion = HurdleRace(height, n, k); 
26 |     cout << potion; 
27 |     return 0; 
28 | } 


--------------------------------------------------------------------------------
/4.DiagonalDIff.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | int main() {
 4 |     int n;
 5 |     cin >> n;
 6 |     vector<vector<int>> matrix(n, vector<int>(n));
 7 |     for (int i = 0; i < n; ++i) {
 8 |         for (int j = 0; j < n; ++j) {
 9 |             cin >> matrix[i][j];
10 |         }
11 |     }
12 |     int primaryDiagonalSum = 0, secondaryDiagonalSum = 0;
13 |     for (int i = 0; i < n; ++i) {
14 |         primaryDiagonalSum += matrix[i][i];                
15 |         secondaryDiagonalSum += matrix[i][n - i - 1];       
16 |     }
17 |     int difference = abs(primaryDiagonalSum - secondaryDiagonalSum);
18 |     cout << difference << endl;
19 |     return 0;
20 | }
21 | 


--------------------------------------------------------------------------------
/13.RepeatedString.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | long repeatedString(string s, long n) {
 4 |     long stringLength = s.length();
 5 |     long countInOriginal = 0;
 6 |     for(char c : s) {
 7 |         if(c == 'a') countInOriginal++;
 8 |     }
 9 |     long completeStrings = n / stringLength;
10 |     long remainingChars = n % stringLength;
11 |     long countInRemaining = 0;
12 |     for(long i = 0; i < remainingChars; i++) {
13 |         if(s[i] == 'a') countInRemaining++;
14 |     }
15 |     return (countInOriginal * completeStrings) + countInRemaining;
16 | }
17 | int main() {
18 |     string s;
19 |     long n;
20 |     cin >> s;      
21 |     cin >> n;       
22 |     cout << repeatedString(s, n) << endl;
23 |     return 0;
24 | }


--------------------------------------------------------------------------------
/1.Time.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | string timeConversion(string s) {
 4 |     int hour = stoi(s.substr(0, 2));
 5 |     string minutes = s.substr(3, 2);
 6 |     string seconds = s.substr(6, 2);
 7 |     string period = s.substr(9, 2); 
 8 |     if (period == "AM") {
 9 |         if (hour == 12) {
10 |             hour = 0;
11 |         }
12 |     } else if (period == "PM") {
13 |         if (hour != 12) {
14 |             hour += 12;
15 |         }
16 |     }
17 |     stringstream ss;
18 |     ss << setw(2) << setfill('0') << hour << ":" << minutes << ":" << seconds;
19 |     return ss.str();
20 | }
21 | int main() {
22 |     string s;
23 |     getline(cin, s); 
24 |     cout << timeConversion(s) << endl; 
25 |     return 0;
26 | }
27 | 


--------------------------------------------------------------------------------
/3.CompTrip.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | vector<int> compareTriplets(vector<int> a, vector<int> b) {
 4 |     int alice_points = 0;
 5 |     int bob_points = 0;
 6 |     for (int i = 0; i < 3; i++) {
 7 |         if (a[i] > b[i]) {
 8 |             alice_points++;
 9 |         } else if (a[i] < b[i]) {
10 |             bob_points++;
11 |         }
12 |     }
13 |     return {alice_points, bob_points};
14 | }
15 | int main() {
16 |     vector<int> a(3), b(3);
17 |     for (int i = 0; i < 3; i++) {
18 |         cin >> a[i];
19 |     }
20 |     for (int i = 0; i < 3; i++) {
21 |         cin >> b[i];
22 |     }
23 |     vector<int> result = compareTriplets(a, b);
24 |     cout << result[0] << " " << result[1] << endl;
25 | 
26 |     return 0;
27 | }
28 | 


--------------------------------------------------------------------------------
/12.PickingNumbers.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | int pickingNumbers(const vector<int>& a) {
 4 |     unordered_map<int, int> frequency;
 5 |     for (int num : a) {
 6 |         frequency[num]++;
 7 |     }
 8 |     int max_count = 0;
 9 |     for (const auto& pair : frequency) {
10 |         int num = pair.first;
11 |         int count = pair.second;
12 |         int current_count = count + frequency[num + 1];
13 |         max_count = max(max_count, current_count);
14 |     }
15 |     return max_count;
16 | }
17 | int main() {
18 |     int n;
19 |     cin >> n;
20 |     vector<int> a(n);
21 |     for (int i = 0; i < n; ++i) {
22 |         cin >> a[i];
23 |     }
24 |     int result = pickingNumbers(a);
25 |     cout << result << endl;
26 |     return 0;
27 | }


--------------------------------------------------------------------------------
/11.Sequence.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | vector<int> permutationEquation(const vector<int>& p) {
 4 |     int n = p.size();
 5 |     vector<int> index_map(n + 1);
 6 |     for (int i = 0; i < n; ++i) {
 7 |         index_map[p[i]] = i + 1;
 8 |     }
 9 |     
10 |     vector<int> result;
11 |     for (int x = 1; x <= n; ++x) {
12 |         int y = index_map[index_map[x]];
13 |         result.push_back(y);
14 |     }
15 |     return result;
16 | }
17 | 
18 | int main() {
19 |     int n;
20 |     cin >> n;
21 |     
22 |     vector<int> p(n);
23 |     for (int i = 0; i < n; ++i) {
24 |         cin >> p[i];
25 |     }
26 |     vector<int> result = permutationEquation(p);
27 |     for (int value : result) {
28 |         cout << value << endl;
29 |     }
30 |     return 0;
31 | }


--------------------------------------------------------------------------------
/10.MinimumDist.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | int minimumDistance(const vector<int>& arr) {
 4 |     unordered_map<int, int> lastIndex; 
 5 |     int minDist = numeric_limits<int>::max(); 
 6 |     for (int i = 0; i < arr.size(); i++) {
 7 |         int current = arr[i];
 8 |         if (lastIndex.find(current) != lastIndex.end()) {
 9 |             int distance = i - lastIndex[current]; 
10 |             minDist = min(minDist, distance); 
11 |         }
12 |         lastIndex[current] = i;
13 |     }
14 |     return (minDist == numeric_limits<int>::max()) ? -1 : minDist;
15 | }
16 | int main() {
17 |     int n;
18 |     cin >> n;
19 |     vector<int> arr(n); 
20 |     for (int i = 0; i < n; i++) {
21 |         cin >> arr[i];
22 |     }
23 |     cout << minimumDistance(arr) << endl;
24 |     return 0;
25 | }


--------------------------------------------------------------------------------
/9.MigratoryBirds.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | int migratoryBirds(const vector<int>& arr) {
 4 |     unordered_map<int, int> birdCount;
 5 |     int maxCount = 0;
 6 |     int minType = numeric_limits<int>::max();
 7 |     for (int bird : arr) {
 8 |         birdCount[bird]++;
 9 |         if (birdCount[bird] > maxCount) {
10 |             maxCount = birdCount[bird];
11 |             minType = bird;
12 |         } else if (birdCount[bird] == maxCount) {
13 |             if (bird < minType) {
14 |                 minType = bird;
15 |             }
16 |         }
17 |     }
18 |     return minType;
19 | }
20 | int main() {
21 |     int n;
22 |     cin >> n; 
23 |     vector<int> arr(n);
24 |     for (int i = 0; i < n; i++) {
25 |         cin >> arr[i];
26 |     }
27 |     cout << migratoryBirds(arr) << endl;
28 | 
29 |     return 0;
30 | }


--------------------------------------------------------------------------------
/6.PlusMinus.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | void plusMinus(const vector<int>& arr) {
 4 |     int size = arr.size();
 5 |     int positiveCount = 0, negativeCount = 0, zeroCount = 0;
 6 |     for (int num : arr) {
 7 |         if (num > 0)
 8 |             positiveCount++;
 9 |         else if (num < 0)
10 |             negativeCount++;
11 |         else
12 |             zeroCount++;
13 |     }
14 |     cout << fixed << setprecision(6);
15 |     cout << static_cast<double>(positiveCount) / size << endl;
16 |     cout << static_cast<double>(negativeCount) / size << endl;
17 |     cout << static_cast<double>(zeroCount) / size << endl;
18 | }
19 | int main() {
20 |     int n;
21 |     cin >> n;
22 |     vector<int> arr(n);
23 |     for (int i = 0; i < n; i++) {
24 |         cin >> arr[i];
25 |     }
26 |     plusMinus(arr);
27 |     return 0;
28 | }
29 | 


--------------------------------------------------------------------------------
/28.CavityMap.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | vector<string> cavityMap(vector<string> &grid)
 4 | {
 5 |     int n = grid.size();
 6 |     vector<string> result = grid;
 7 |     for (int i = 1; i < n - 1; ++i)
 8 |     {
 9 |         for (int j = 1; j < n - 1; ++j)
10 |         {
11 |             char current = grid[i][j];
12 |             if (current > grid[i - 1][j] && current > grid[i + 1][j] &&
13 |                 current > grid[i][j - 1] && current > grid[i][j + 1])
14 |             {
15 |                 result[i][j] = 'X'; 
16 |             }
17 |         }
18 |     }
19 |     return result;
20 | }
21 | void print(vector<string> &grid)
22 | {
23 |     for (string s:grid)
24 |     {
25 |         cout<<s<<"\n";
26 |     }
27 |     
28 | }
29 | int main()
30 | {
31 |     int n;
32 |     cin >> n;
33 |     vector<string> grid(n);
34 |     for (int i = 0; i < n; ++i)
35 |     {
36 |         cin >> grid[i];
37 |     }
38 |     vector<string> result = cavityMap(grid);
39 |     for (const string &row : result)
40 |     {
41 |         cout << row << endl;
42 |     }
43 |     return 0;
44 | }


--------------------------------------------------------------------------------
/30.ClimbingtheLeaderboard.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | vector<int> rank_alice(vector<int> &players, vector<int> &score_of_alice) {
 5 |     vector<int> rank_of_alice;
 6 |     vector<int> unique_scores;
 7 | 
 8 |     // Create a unique list of scores in descending order
 9 |     unique_scores.push_back(players[0]);
10 |     for (int i = 1; i < players.size(); i++) {
11 |         if (players[i] != players[i - 1]) {
12 |             unique_scores.push_back(players[i]);
13 |         }
14 |     }
15 | 
16 |     // Determine Alice's rank for each of her scores
17 |     for (int score : score_of_alice) {
18 |         // Find the rank by comparing Alice's score with unique scores
19 |         while (!unique_scores.empty() && score >= unique_scores.back()) {
20 |             unique_scores.pop_back();
21 |         }
22 |         // The rank is the size of the remaining unique scores + 1
23 |         rank_of_alice.push_back(unique_scores.size() + 1);
24 |     }
25 | 
26 |     return rank_of_alice;
27 | }
28 | 
29 | int main() {
30 |     int n;
31 |     cin >> n;
32 |     vector<int> players(n);
33 |     for (int i = 0; i < n; i++) {
34 |         cin >> players[i];
35 |     }
36 |     int m;
37 |     cin >> m;
38 |     vector<int> score_of_alice(m);
39 |     for (int i = 0; i < m; i++) {
40 |         cin >> score_of_alice[i];
41 |     }
42 | 
43 |     vector<int> rank_of_alice = rank_alice(players, score_of_alice);
44 |     for (int rank : rank_of_alice) {
45 |         cout << rank << " ";
46 |     }
47 |     cout << endl;
48 | 
49 |     return 0;
50 | }


--------------------------------------------------------------------------------
/8.MatrixLRotation.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | vector<int> extractLayer(const vector<vector<int>>& matrix, int layer, int M, int N) {
 4 |     vector<int> layerElements;
 5 |     int topRow = layer, leftCol = layer;
 6 |     int bottomRow = M - layer - 1, rightCol = N - layer - 1;
 7 |     for (int j = leftCol; j <= rightCol; j++) {
 8 |         layerElements.push_back(matrix[topRow][j]);
 9 |     }
10 |     for (int i = topRow + 1; i <= bottomRow; i++) {
11 |         layerElements.push_back(matrix[i][rightCol]);
12 |     }
13 |     if (bottomRow > topRow) { 
14 |         for (int j = rightCol - 1; j >= leftCol; j--) {
15 |             layerElements.push_back(matrix[bottomRow][j]);
16 |         }
17 |     }
18 |     if (leftCol < rightCol) { 
19 |         for (int i = bottomRow - 1; i > topRow; i--) {
20 |             layerElements.push_back(matrix[i][leftCol]);
21 |         }
22 |     }
23 |     return layerElements;
24 | }
25 | void insertLayer(vector<vector<int>>& matrix, int layer, const vector<int>& layerElements, int M, int N) {
26 |     int topRow = layer, leftCol = layer;
27 |     int bottomRow = M - layer - 1, rightCol = N - layer - 1;
28 |     int index = 0;
29 |     for (int j = leftCol; j <= rightCol; j++) {
30 |         matrix[topRow][j] = layerElements[index++];
31 |     }
32 |     for (int i = topRow + 1; i <= bottomRow; i++) {
33 |         matrix[i][rightCol] = layerElements[index++];
34 |     }
35 |     if (bottomRow > topRow) { 
36 |         for (int j = rightCol - 1; j >= leftCol; j--) {
37 |             matrix[bottomRow][j] = layerElements[index++];
38 |         }
39 |     }
40 |     if (leftCol < rightCol) { 
41 |         for (int i = bottomRow - 1; i > topRow; i--) {
42 |             matrix[i][leftCol] = layerElements[index++];
43 |         }
44 |     }
45 | }
46 | void rotateMatrix(int M, int N, int R, vector<vector<int>>& matrix) {
47 |     int numLayers = min(M, N) / 2;
48 |     for (int layer = 0; layer < numLayers; layer++) {
49 |         vector<int> layerElements = extractLayer(matrix, layer, M, N);
50 |         int lengthOfLayer = layerElements.size();
51 |         int effectiveRotations = R % lengthOfLayer;
52 |         vector<int> rotatedLayer(lengthOfLayer);
53 |         for (int i = 0; i < lengthOfLayer; i++) {
54 |             rotatedLayer[i] = layerElements[(i + effectiveRotations) % lengthOfLayer];
55 |         }
56 |         insertLayer(matrix, layer, rotatedLayer, M, N);
57 |     }
58 | }
59 | int main() {
60 |     int M, N, R;
61 |     cin >> M >> N >> R;
62 |     vector<vector<int>> matrix(M, vector<int>(N));
63 |     for (int i = 0; i < M; i++) {
64 |         for (int j = 0; j < N; j++) {
65 |             cin >> matrix[i][j];
66 |         }
67 |     }
68 |     rotateMatrix(M, N, R, matrix);
69 |     for (const auto& row : matrix) {
70 |         for (const auto& element : row) {
71 |             cout << element << " ";
72 |         }
73 |         cout << endl;
74 |     }
75 | 
76 |     return 0;
77 | }


--------------------------------------------------------------------------------
/24.Between_Two_Sets.cpp:
--------------------------------------------------------------------------------
  1 | #include <bits/stdc++.h>
  2 | using namespace std;
  3 | 
  4 | // Calculate GCD using Euclidean algorithm
  5 | long long gcd(long long a, long long b) {
  6 |     if (b == 0)
  7 |         return a;
  8 |     return gcd(b, a % b);
  9 | }
 10 | 
 11 | // Calculate LCM using GCD
 12 | long long lcm(long long a, long long b) {
 13 |     if (a == 0 || b == 0)
 14 |         return 0;
 15 |     // First multiply, then divide to minimize overflow chance
 16 |     return (a / gcd(a, b)) * b;
 17 | }
 18 | 
 19 | // Calculate LCM of array elements
 20 | long long lcm_of_array(vector<int>& arr) {
 21 |     if (arr.empty()) 
 22 |         return 0;
 23 |         
 24 |     long long result = arr[0];
 25 |     for (size_t i = 1; i < arr.size(); ++i) {
 26 |         if (arr[i] == 0) 
 27 |             return 0;
 28 |         result = lcm(result, arr[i]);
 29 |         if (result < 0) // Overflow check
 30 |             return -1;
 31 |     }
 32 |     return result;
 33 | }
 34 | 
 35 | // Calculate GCD of array elements
 36 | long long gcd_of_array(vector<int>& arr) {
 37 |     if (arr.empty()) 
 38 |         return 0;
 39 |         
 40 |     long long result = arr[0];
 41 |     for (size_t i = 1; i < arr.size(); ++i) {
 42 |         result = gcd(result, arr[i]);
 43 |     }
 44 |     return result;
 45 | }
 46 | 
 47 | // Count numbers between LCM and GCD
 48 | int count_numbers_between(vector<int>& arr1, vector<int>& arr2) {
 49 |     // Check for empty arrays
 50 |     if (arr1.empty() || arr2.empty())
 51 |         return 0;
 52 |         
 53 |     // Calculate LCM and GCD
 54 |     long long lcm_val = lcm_of_array(arr1);
 55 |     long long gcd_val = gcd_of_array(arr2);
 56 |     
 57 |     // Check for overflow or invalid values
 58 |     if (lcm_val == -1 || lcm_val == 0 || gcd_val == 0)
 59 |         return 0;
 60 |         
 61 |     // If LCM > GCD, no numbers exist between them
 62 |     if (lcm_val > gcd_val)
 63 |         return 0;
 64 |         
 65 |     // Check if gcd_val is divisible by lcm_val
 66 |     if (gcd_val % lcm_val != 0)
 67 |         return 0;
 68 |         
 69 |     // Calculate count of numbers
 70 |     return gcd_val / lcm_val;
 71 | }
 72 | 
 73 | int main() {
 74 |     ios_base::sync_with_stdio(false);
 75 |     cin.tie(NULL);
 76 |     
 77 |     int m, n;
 78 |     cin >> m >> n;
 79 |     
 80 |     // Input validation
 81 |     if (m <= 0 || n <= 0) {
 82 |         cout << 0 << endl;
 83 |         return 0;
 84 |     }
 85 |     
 86 |     vector<int> arr1(m);
 87 |     vector<int> arr2(n);
 88 |     
 89 |     // Read first array
 90 |     for (int i = 0; i < m; i++) {
 91 |         cin >> arr1[i];
 92 |         if (arr1[i] <= 0) {
 93 |             cout << 0 << endl;
 94 |             return 0;
 95 |         }
 96 |     }
 97 |     
 98 |     // Read second array
 99 |     for (int i = 0; i < n; i++) {
100 |         cin >> arr2[i];
101 |         if (arr2[i] <= 0) {
102 |             cout << 0 << endl;
103 |             return 0;
104 |         }
105 |     }
106 |     
107 |     int result = count_numbers_between(arr1, arr2);
108 |     cout << result << endl;
109 |     
110 |     return 0;
111 | }


--------------------------------------------------------------------------------