├── .vscode
    └── settings.json
├── Apple clone
    ├── Apple vision image.png
    ├── images
    │   ├── Vision00001.png
    │   ├── Vision00002.png
    │   ├── Vision00003.png
    │   ├── Vision00004.png
    │   ├── Vision00005.png
    │   ├── Vision00006.png
    │   ├── Vision00007.png
    │   ├── Vision00008.png
    │   ├── Vision00009.png
    │   ├── Vision00010.png
    │   ├── Vision00011.png
    │   ├── Vision00012.png
    │   ├── Vision00013.png
    │   ├── Vision00014.png
    │   ├── Vision00015.png
    │   ├── Vision00016.png
    │   ├── Vision00017.png
    │   ├── Vision00018.png
    │   ├── Vision00019.png
    │   ├── Vision00020.png
    │   ├── Vision00021.png
    │   ├── Vision00022.png
    │   ├── Vision00023.png
    │   ├── Vision00024.png
    │   └── Vision00025.png
    ├── index.html
    ├── script.js
    └── style.css
├── C++
    ├── 4Sum.cpp
    ├── BinaryTree.cpp
    ├── DijkstraAlgorithm.cpp
    ├── MergeSort.c
    ├── QUEUE
    │   └── bfs_traversal.cpp
    ├── QuestionsOfArrays
    │   ├── 2Darray.cpp
    │   ├── Boolean_matrix.cpp
    │   ├── InsertionSort.cpp
    │   ├── ProgramThatReturnsMaximumNumberOfPointsThatLieOnTheSameStraightLine.cpp
    │   ├── Second_largest_array.cpp
    │   ├── SortArray.cpp
    │   ├── bubbleSort.cpp
    │   ├── charSort.cpp
    │   ├── countSort.cpp
    │   ├── diagonalSum.cpp
    │   ├── insertion.cpp
    │   ├── mergesort.cpp
    │   ├── rankTransformOfArray.cpp
    │   ├── selectionSort.cpp
    │   ├── spiralMatrix.cpp
    │   └── trappingRainwater.cpp
    ├── STACK
    │   ├── Check_Balance_Bracket.cpp
    │   ├── Reverse_String.cpp
    │   ├── STACK_USING_ARRAY.cpp
    │   ├── STACK_using_DYN_array.cpp
    │   ├── STACK_using_Linked_list.cpp
    │   ├── StackOfArray.cpp
    │   ├── TWO_Stack_IN_Array.cpp
    │   ├── stack.cpp
    │   └── stackusinglinkedlist222.c
    ├── Selection_Sort.cpp
    ├── Selection_Sort.exe
    ├── binary_search.cpp
    ├── bubble_sort.cpp
    ├── depth_first_search.cpp
    └── fibonacci_memoization.cpp
├── CONTRIBUTING.md
├── CountingSort.py
├── DSA
    └── LL
    │   ├── MERGE.c
    │   └── MERGELL.c
├── README.md
├── ReactProject
    └── YoutubeClone
    │   ├── .gitignore
    │   ├── package-lock.json
    │   ├── package.json
    │   ├── public
    │       ├── favicon.ico
    │       └── index.html
    │   └── src
    │       ├── App.js
    │       ├── components
    │           ├── ChannelCard.jsx
    │           ├── ChannelDetail.jsx
    │           ├── Feed.jsx
    │           ├── Loader.jsx
    │           ├── Navbar.jsx
    │           ├── SearchBar.jsx
    │           ├── SearchFeed.jsx
    │           ├── Sidebar.jsx
    │           ├── VideoCard.jsx
    │           ├── VideoDetail.jsx
    │           ├── Videos.jsx
    │           └── index.js
    │       ├── index.css
    │       ├── index.js
    │       └── utils
    │           ├── constants.js
    │           └── fetchFromAPI.js
├── WebAnimations
    ├── .DS_Store
    ├── .gitignore
    ├── README.md
    ├── index.html
    ├── package-lock.json
    ├── package.json
    ├── postcss.config.js
    ├── public
    │   └── vite.svg
    ├── src
    │   ├── App.jsx
    │   ├── BasicAnimation.jsx
    │   ├── FadeAnimtion.jsx
    │   ├── MoreAnimation.jsx
    │   ├── ScrollAnim2.jsx
    │   ├── ScrollAnimation.jsx
    │   ├── SvgAnimation.jsx
    │   ├── TextAnimation.jsx
    │   ├── TimeLine.jsx
    │   ├── assets
    │   │   └── react.svg
    │   ├── index.css
    │   └── main.jsx
    ├── tailwind.config.js
    ├── vite.config.js
    └── yarn.lock
├── WebProjects
    ├── Food App
    │   └── src
    │   │   ├── app.jsx
    │   │   ├── components
    │   │       └── ui
    │   │       │   ├── button.js
    │   │       │   └── card.js
    │   │   └── pay.jsx
    ├── Personal_Finance_Manger
    │   └── Webpage 5
    │   │   ├── index.html
    │   │   ├── script.js
    │   │   └── styles.css
    ├── Web Calculator
    │   ├── icon
    │   │   └── calculator-icon.png
    │   ├── index.html
    │   ├── script.js
    │   └── style.css
    └── drumsticks
    │   ├── images
    │       ├── crash.png
    │       ├── drumstick.jpg
    │       ├── kick.png
    │       ├── music.jpg
    │       ├── snare.png
    │       ├── tom1.png
    │       ├── tom2.png
    │       ├── tom3.png
    │       └── tom4.png
    │   ├── index.html
    │   ├── main.js
    │   ├── sounds
    │       ├── crash.mp3
    │       ├── kick-bass.mp3
    │       ├── snare.mp3
    │       ├── tom-1.mp3
    │       ├── tom-2.mp3
    │       ├── tom-3.mp3
    │       └── tom-4.mp3
    │   └── styles.css
├── c++
    ├── Binary Search  in C++
    ├── BubbleSort.cpp
    └── Preorder Traversal on Binary Tree.cpp
├── cpp
    ├── .cph
    │   └── .c++ algorithms.cpp_d5d7ec2e6847003f61b365350767f2e0.prob
    ├── BST1.cpp
    ├── BT.cpp
    ├── Bubblesort.cpp
    ├── Container_with_Most_Water.cpp
    ├── InsertionSort.cpp
    ├── Kruskal.cpp
    ├── MatchingParenthesis.cpp
    ├── MergeLists.cpp
    ├── Merge_sort.cpp
    ├── Prims algorithm
    ├── QueueImplementation.cpp
    ├── QueueList.cpp
    ├── Reverse-Alternate-K-Nodes.cpp
    ├── StackImplementation.cpp
    ├── StackUsingQueue.cpp
    ├── c++ algorithms.cpp
    ├── dijkestra.cpp
    ├── floydwarshallalgorithm.cpp
    ├── kadane_algorithm.cpp
    ├── merge_sort.cpp
    ├── pattern
    │   ├── HollowDiamond.cpp
    │   ├── Inverted-Left-Half-Pyramid-Pattern.c
    │   ├── Inverted-Right-Half-Pyramid-Pattern.c
    │   ├── Inverted-full-pyrm.c
    │   ├── NumberPattern.cpp
    │   ├── NumberPattern.exe
    │   ├── Rhombus-pattern.c
    │   ├── diamond.c
    │   ├── full-pyrm.c
    │   ├── left-hal-pyrm.c
    │   ├── right-hal-pyrm.c
    │   ├── second-largest.c
    │   └── tempCodeRunnerFile.c
    └── segmentTree.cpp
├── image.jpg
├── javascript
    ├── BallGame.js
    ├── State_Using_Array.js
    ├── merge.js
    ├── snake_game
    │   ├── index.html
    │   ├── script.js
    │   └── styles.css
    ├── sort.js
    └── todo-app
    │   ├── index.html
    │   ├── script.js
    │   └── style.css
├── pattern
    ├── Inverted-Left-Half-Pyramid-Pattern.c
    ├── Inverted-Right-Half-Pyramid-Pattern.c
    ├── Inverted-full-pyrm.c
    ├── Rhombus-pattern.c
    ├── diamond.c
    ├── full-pyrm.c
    ├── left-hal-pyrm.c
    ├── right-hal-pyrm.c
    ├── second-largest.c
    └── tempCodeRunnerFile.c
├── python
    ├── Air_Quality_prediction
    │   ├── Air_Quality.csv
    │   ├── Air_Quality_Prediction.py
    │   └── output.png
    ├── Car_price_prediction.ipynb
    ├── Quick_sort.py
    ├── bubsort.py
    ├── heapsort.py
    ├── secondLargest.py
    └── study.py
├── to_do_list.html
└── webdevproject
    ├── contributing.md
    └── drag_drop_site
        ├── img1.jpg
        ├── img2.jpg
        ├── img3.jpg
        ├── index.html
        ├── script.js
        └── style.css


/.vscode/settings.json:
--------------------------------------------------------------------------------
1 | {
2 |     "files.associations": {
3 |         "vector": "cpp"
4 |     }
5 | }


--------------------------------------------------------------------------------
/Apple clone/Apple vision image.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/Apple clone/Apple vision image.png


--------------------------------------------------------------------------------
/Apple clone/images/Vision00001.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/Apple clone/images/Vision00001.png


--------------------------------------------------------------------------------
/Apple clone/images/Vision00002.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/Apple clone/images/Vision00002.png


--------------------------------------------------------------------------------
/Apple clone/images/Vision00003.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/Apple clone/images/Vision00003.png


--------------------------------------------------------------------------------
/Apple clone/images/Vision00004.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/Apple clone/images/Vision00004.png


--------------------------------------------------------------------------------
/Apple clone/images/Vision00005.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/Apple clone/images/Vision00005.png


--------------------------------------------------------------------------------
/Apple clone/images/Vision00006.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/Apple clone/images/Vision00006.png


--------------------------------------------------------------------------------
/Apple clone/images/Vision00007.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/Apple clone/images/Vision00007.png


--------------------------------------------------------------------------------
/Apple clone/images/Vision00008.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/Apple clone/images/Vision00008.png


--------------------------------------------------------------------------------
/Apple clone/images/Vision00009.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/Apple clone/images/Vision00009.png


--------------------------------------------------------------------------------
/Apple clone/images/Vision00010.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/Apple clone/images/Vision00010.png


--------------------------------------------------------------------------------
/Apple clone/images/Vision00011.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/Apple clone/images/Vision00011.png


--------------------------------------------------------------------------------
/Apple clone/images/Vision00012.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/Apple clone/images/Vision00012.png


--------------------------------------------------------------------------------
/Apple clone/images/Vision00013.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/Apple clone/images/Vision00013.png


--------------------------------------------------------------------------------
/Apple clone/images/Vision00014.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/Apple clone/images/Vision00014.png


--------------------------------------------------------------------------------
/Apple clone/images/Vision00015.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/Apple clone/images/Vision00015.png


--------------------------------------------------------------------------------
/Apple clone/images/Vision00016.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/Apple clone/images/Vision00016.png


--------------------------------------------------------------------------------
/Apple clone/images/Vision00017.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/Apple clone/images/Vision00017.png


--------------------------------------------------------------------------------
/Apple clone/images/Vision00018.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/Apple clone/images/Vision00018.png


--------------------------------------------------------------------------------
/Apple clone/images/Vision00019.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/Apple clone/images/Vision00019.png


--------------------------------------------------------------------------------
/Apple clone/images/Vision00020.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/Apple clone/images/Vision00020.png


--------------------------------------------------------------------------------
/Apple clone/images/Vision00021.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/Apple clone/images/Vision00021.png


--------------------------------------------------------------------------------
/Apple clone/images/Vision00022.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/Apple clone/images/Vision00022.png


--------------------------------------------------------------------------------
/Apple clone/images/Vision00023.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/Apple clone/images/Vision00023.png


--------------------------------------------------------------------------------
/Apple clone/images/Vision00024.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/Apple clone/images/Vision00024.png


--------------------------------------------------------------------------------
/Apple clone/images/Vision00025.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/Apple clone/images/Vision00025.png


--------------------------------------------------------------------------------
/C++/4Sum.cpp:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 | public:
 3 |     vector<vector<int>> fourSum(vector<int>& nums, int target) {
 4 |         int n = nums.size();
 5 |         sort(nums.begin(), nums.end());
 6 |         set<vector<int>> set;
 7 |         vector<vector<int>> output;
 8 |         for(int i=0; i<n-3; i++){
 9 |             for(int j=i+1; j<n-2; j++){
10 |                 long long newTarget = (long long)target - (long long)nums[i] - (long long)nums[j];
11 |                 int low = j+1, high = n-1;
12 |                 while(low < high){
13 |                     if(nums[low] + nums[high] < newTarget){
14 |                         low++;
15 |                     }
16 |                     else if(nums[low] + nums[high] > newTarget){
17 |                         high--;
18 |                     }
19 |                     else{
20 |                         set.insert({nums[i], nums[j], nums[low], nums[high]});
21 |                         low++; high--;
22 |                     }
23 |                 }
24 |             }
25 |         }
26 |         for(auto it : set){
27 |             output.push_back(it);
28 |         }
29 |         return output;
30 |     }
31 | };
32 | 
33 | 
34 | 
35 | 
36 | 
37 | 
38 | /*
39 | 
40 |     Time Complexity : O(N^3), Here Three nested loop creates the time complexity. Where N is the size of the
41 |     array(nums).
42 | 
43 |     Space Complexity : O(1), Constant space. Extra space is only allocated for the Vector(output), however the
44 |     output does not count towards the space complexity.
45 | 
46 |     Solved using Array(Three Nested Loop) + Sorting. Optimized Approach.
47 | */
48 | 


--------------------------------------------------------------------------------
/C++/BinaryTree.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | 
 3 | struct Node {
 4 |     int data;
 5 |     Node* left;
 6 |     Node* right;
 7 | 
 8 |     Node(int value) {
 9 |         data = value;
10 |         left = right = nullptr;
11 |     }
12 | };
13 | 
14 | class BinaryTree {
15 | public:
16 |     Node* root;
17 | 
18 |     BinaryTree() {
19 |         root = nullptr;
20 |     }
21 | 
22 |     // Insert a new node
23 |     void insert(int value) {
24 |         root = insertRec(root, value);
25 |     }
26 | 
27 |     // In-order traversal of the tree
28 |     void inOrderTraversal() {
29 |         inOrderRec(root);
30 |         std::cout << std::endl;
31 |     }
32 | 
33 |     // Delete the tree
34 |     void deleteTree() {
35 |         deleteRec(root);
36 |         root = nullptr;
37 |     }
38 | 
39 | private:
40 |     // Helper function to insert a node
41 |     Node* insertRec(Node* node, int value) {
42 |         if (node == nullptr) {
43 |             return new Node(value);
44 |         }
45 |         if (value < node->data) {
46 |             node->left = insertRec(node->left, value);
47 |         } else {
48 |             node->right = insertRec(node->right, value);
49 |         }
50 |         return node;
51 |     }
52 | 
53 |     // Helper function for in-order traversal
54 |     void inOrderRec(Node* node) {
55 |         if (node != nullptr) {
56 |             inOrderRec(node->left);
57 |             std::cout << node->data << " ";
58 |             inOrderRec(node->right);
59 |         }
60 |     }
61 | 
62 |     // Helper function to delete the tree
63 |     void deleteRec(Node* node) {
64 |         if (node != nullptr) {
65 |             deleteRec(node->left);
66 |             deleteRec(node->right);
67 |             delete node;
68 |         }
69 |     }
70 | };
71 | 
72 | int main() {
73 |     BinaryTree tree;
74 |     tree.insert(10);
75 |     tree.insert(5);
76 |     tree.insert(15);
77 |     tree.insert(3);
78 |     tree.insert(7);
79 | 
80 |     std::cout << "In-order Traversal: ";
81 |     tree.inOrderTraversal();
82 | 
83 |     tree.deleteTree();
84 |     std::cout << "Tree deleted." << std::endl;
85 | 
86 |     return 0;
87 | }
88 | 


--------------------------------------------------------------------------------
/C++/DijkstraAlgorithm.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <vector>
 3 | #include <queue>
 4 | #include <climits>
 5 | 
 6 | class Graph {
 7 | private:
 8 |     int vertices;
 9 |     std::vector<std::vector<std::pair<int, int>>> adj;
10 | 
11 | public:
12 |     Graph(int v) : vertices(v) {
13 |         adj.resize(v);
14 |     }
15 | 
16 |     void addEdge(int u, int v, int weight) {
17 |         adj[u].emplace_back(v, weight);
18 |         adj[v].emplace_back(u, weight);
19 |     }
20 | 
21 |     void dijkstra(int source) {
22 |         std::vector<int> dist(vertices, INT_MAX);
23 |         dist[source] = 0;
24 | 
25 |         using pii = std::pair<int, int>;
26 |         std::priority_queue<pii, std::vector<pii>, std::greater<pii>> pq;
27 |         pq.push({0, source});
28 | 
29 |         while (!pq.empty()) {
30 |             int u = pq.top().second;
31 |             pq.pop();
32 | 
33 |             for (const auto& neighbor : adj[u]) {
34 |                 int v = neighbor.first;
35 |                 int weight = neighbor.second;
36 | 
37 |                 if (dist[u] + weight < dist[v]) {
38 |                     dist[v] = dist[u] + weight;
39 |                     pq.push({dist[v], v});
40 |                 }
41 |             }
42 |         }
43 | 
44 |         printShortestPaths(dist);
45 |     }
46 | 
47 |     void printShortestPaths(const std::vector<int>& dist) {
48 |         std::cout << "Vertex Distance from Source\n";
49 |         for (int i = 0; i < vertices; i++) {
50 |             std::cout << i << "\t\t" << dist[i] << "\n";
51 |         }
52 |     }
53 | };
54 | 
55 | int main() {
56 |     Graph g(6);
57 |     g.addEdge(0, 1, 4);
58 |     g.addEdge(0, 2, 1);
59 |     g.addEdge(2, 1, 2);
60 |     g.addEdge(1, 3, 1);
61 |     g.addEdge(2, 3, 5);
62 |     g.addEdge(3, 4, 3);
63 |     g.addEdge(4, 5, 2);
64 | 
65 |     g.dijkstra(0);
66 | 
67 |     return 0;
68 | }
69 | 


--------------------------------------------------------------------------------
/C++/MergeSort.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>  
 2 |   
 3 | /* Function to merge the subarrays of a[] */  
 4 | void merge(int a[], int beg, int mid, int end)    
 5 | {    
 6 |     int i, j, k;  
 7 |     int n1 = mid - beg + 1;    
 8 |     int n2 = end - mid;    
 9 |       
10 |     int LeftArray[n1], RightArray[n2]; //temporary arrays  
11 |       
12 |     /* copy data to temp arrays */  
13 |     for (int i = 0; i < n1; i++)    
14 |     LeftArray[i] = a[beg + i];    
15 |     for (int j = 0; j < n2; j++)    
16 |     RightArray[j] = a[mid + 1 + j];    
17 |       
18 |     i = 0; /* initial index of first sub-array */  
19 |     j = 0; /* initial index of second sub-array */   
20 |     k = beg;  /* initial index of merged sub-array */  
21 |       
22 |     while (i < n1 && j < n2)    
23 |     {    
24 |         if(LeftArray[i] <= RightArray[j])    
25 |         {    
26 |             a[k] = LeftArray[i];    
27 |             i++;    
28 |         }    
29 |         else    
30 |         {    
31 |             a[k] = RightArray[j];    
32 |             j++;    
33 |         }    
34 |         k++;    
35 |     }    
36 |     while (i<n1)    
37 |     {    
38 |         a[k] = LeftArray[i];    
39 |         i++;    
40 |         k++;    
41 |     }    
42 |       
43 |     while (j<n2)    
44 |     {    
45 |         a[k] = RightArray[j];    
46 |         j++;    
47 |         k++;    
48 |     }    
49 | }    
50 |   
51 | void mergeSort(int a[], int beg, int end)  
52 | {  
53 |     if (beg < end)   
54 |     {  
55 |         int mid = (beg + end) / 2;  
56 |         mergeSort(a, beg, mid);  
57 |         mergeSort(a, mid + 1, end);  
58 |         merge(a, beg, mid, end);  
59 |     }  
60 | }  
61 |   
62 | /* Function to print the array */  
63 | void printArray(int a[], int n)  
64 | {  
65 |     int i;  
66 |     for (i = 0; i < n; i++)  
67 |         printf("%d ", a[i]);  
68 |     printf("\n");  
69 | }  
70 |   
71 | int main()  
72 | {  
73 |     int a[] = { 12, 31, 25, 8, 32, 17, 40, 42 };  
74 |     int n = sizeof(a) / sizeof(a[0]);  
75 |     printf("Before sorting array elements are - \n");  
76 |     printArray(a, n);  
77 |     mergeSort(a, 0, n - 1);  
78 |     printf("After sorting array elements are - \n");  
79 |     printArray(a, n);  
80 |     return 0;  
81 | }  


--------------------------------------------------------------------------------
/C++/QUEUE/bfs_traversal.cpp:
--------------------------------------------------------------------------------
 1 | // BFS algorithm in C++
 2 | 
 3 | #include <iostream>
 4 | #include <list>
 5 | 
 6 | using namespace std;
 7 | 
 8 | class Graph {
 9 |   int numVertices;
10 |   list<int>* adjLists;
11 |   bool* visited;
12 | 
13 |    public:
14 |   Graph(int vertices);
15 |   void addEdge(int src, int dest);
16 |   void BFS(int startVertex);
17 | };
18 | 
19 | Graph::Graph(int vertices) {
20 |   numVertices = vertices;
21 |   adjLists = new list<int>[vertices];
22 | }
23 | 
24 | // Add edges to the graph
25 | void Graph::addEdge(int src, int dest) {
26 |   adjLists[src].push_back(dest);
27 |   adjLists[dest].push_back(src);
28 | }
29 | 
30 | // BFS algorithm
31 | void Graph::BFS(int startVertex) {
32 |   visited = new bool[numVertices];
33 |   for (int i = 0; i < numVertices; i++)
34 |     visited[i] = false;
35 | 
36 |   list<int> queue;
37 | 
38 |   visited[startVertex] = true;
39 |   queue.push_back(startVertex);
40 | 
41 |   list<int>::iterator i;
42 | 
43 |   while (!queue.empty()) {
44 |     int currVertex = queue.front();
45 |     cout << "Visited " << currVertex << " ";
46 |     queue.pop_front();
47 | 
48 |     for (i = adjLists[currVertex].begin(); i != adjLists[currVertex].end(); ++i) {
49 |       int adjVertex = *i;
50 |       if (!visited[adjVertex]) {
51 |         visited[adjVertex] = true;
52 |         queue.push_back(adjVertex);
53 |       }
54 |     }
55 |   }
56 | }
57 | 
58 | int main() {
59 |   Graph g(4);
60 |   g.addEdge(0, 1);
61 |   g.addEdge(0, 2);
62 |   g.addEdge(1, 2);
63 |   g.addEdge(2, 0);
64 |   g.addEdge(2, 3);
65 |   g.addEdge(3, 3);
66 | 
67 |   g.BFS(2);
68 | 
69 |   return 0;
70 | }


--------------------------------------------------------------------------------
/C++/QuestionsOfArrays/2Darray.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | int main(){
 4 |     int n,m;
 5 |     cout<<"Enter number of rows and columns\n";
 6 |     cin>>n;
 7 |     cin>>m;
 8 |     int arr[n][m];
 9 |     for(int i=0;i<n;i++){
10 |         for(int j=0; j<m; j++){
11 |             cin>>arr[i][j];
12 |         }
13 |     }
14 |     for(int i=0; i<n; i++){
15 |         for(int j=0; j<m; j++){
16 |             cout<<arr[i][j]<<" ";
17 |         }
18 |         cout<<endl;
19 |     }
20 |     
21 | 
22 | }


--------------------------------------------------------------------------------
/C++/QuestionsOfArrays/Boolean_matrix.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | 
 3 | using namespace std;
 4 | 
 5 | void setZeroes(vector < vector < int >> & matrix) {
 6 | int rows = matrix.size(), cols = matrix[0].size();
 7 | for (int i = 0; i < rows; i++) {
 8 | 	for (int j = 0; j < cols; j++) {
 9 | 	if (matrix[i][j] == 1) {
10 | 
11 | 		int ind = i - 1;
12 | 		while (ind >= 0) {
13 | 		if (matrix[ind][j] != 1) {
14 | 			matrix[ind][j] = -1;
15 | 		}
16 | 		ind--;
17 | 		}
18 | 		ind = i + 1;
19 | 		while (ind < rows) {
20 | 		if (matrix[ind][j] != 1) {
21 | 			matrix[ind][j] = -1;
22 | 		}
23 | 		ind++;
24 | 		}
25 | 		ind = j - 1;
26 | 		while (ind >= 0) {
27 | 		if (matrix[i][ind] != 1) {
28 | 			matrix[i][ind] = -1;
29 | 
30 | 		}
31 | 		ind--;
32 | 		}
33 | 		ind = j + 1;
34 | 		while (ind < cols) {
35 | 		if (matrix[i][ind] != 1) {
36 | 			matrix[i][ind] = -1;
37 | 
38 | 		}
39 | 		ind++;
40 | 		}
41 | 	}
42 | 	}
43 | }
44 | for (int i = 0; i < rows; i++) {
45 | 	for (int j = 0; j < cols; j++) {
46 | 	if (matrix[i][j] < 0) {
47 | 		matrix[i][j] = 1;
48 | 	}
49 | 	}
50 | }
51 | 
52 | }
53 | 
54 | int main() {
55 | vector < vector < int >> arr;
56 | arr = {{1, 0, 2, 1}, {3, 4, 5, 2}, {0, 3, 0, 5}};
57 | setZeroes(arr);
58 | cout << "The Final Matrix is " << endl;
59 | for (int i = 0; i < arr.size(); i++) {
60 | 	for (int j = 0; j < arr[0].size(); j++) {
61 | 	cout << arr[i][j] << " ";
62 | 	}
63 | 	cout << "\n";
64 | }
65 | }
66 | 


--------------------------------------------------------------------------------
/C++/QuestionsOfArrays/InsertionSort.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | void InsertionSort(int arr[],int n){
 4 |     for(int i=0;i<=n-1;i++){
 5 |         int j=i;
 6 |         while(j>0 && arr[j-1]>arr[j]){
 7 |             swap(arr[j-1],arr[j]);
 8 |             j--;
 9 |         }
10 |     }
11 | }
12 | int main(){
13 |     int n;
14 |     cout<<"Enter size of the array"<<endl;
15 |     cin>>n;
16 |     cout<<"Enter Unsorted Array"<<endl;
17 |     int arr[n];
18 |     for(int i=0;i<n;i++){
19 |         cin>>arr[i];
20 |     }
21 |     InsertionSort(arr,n);
22 |     cout<<"Sorted Array :"<<endl;
23 |     for(int i=0;i<=n-1;i++){
24 |         cout<<arr[i]<<" ";
25 |     }
26 | }


--------------------------------------------------------------------------------
/C++/QuestionsOfArrays/Second_largest_array.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <climits>
 3 | 
 4 | using namespace std ;
 5 | 
 6 | int main(){
 7 | 
 8 | int number;
 9 | 
10 | cout << "Enter The Number of Elements : " ;
11 | 
12 | cin >> number;
13 | 
14 | int arr[number];
15 | 
16 | cout << "Enter The elements :";
17 | 
18 | for(int i = 0 ; i < number ; i++){
19 | 
20 |     cin >> arr[i];
21 | }
22 | 
23 | int largest = INT_MIN;
24 | int secondLargest = INT_MIN;
25 | 
26 | for(int i = 0 ; i < number ; i++){
27 | 
28 | if( arr[i] > largest ){
29 | 
30 | secondLargest = largest;
31 | largest = arr[i];
32 | }
33 | 
34 | else if( arr[i] > secondLargest && arr[i] != largest){
35 | 
36 | secondLargest = arr[i];
37 | }
38 | }
39 | 
40 | if( secondLargest == INT_NUM){
41 | 
42 | cout << "There i s no Second (2nd) Largesr Number :" << endl;
43 | }
44 | 
45 | else {
46 | 
47 | cout << "The Second Largest Number is : " << secondLargest << endl;
48 |   
49 | }
50 | 
51 | return 0 ;
52 | }
53 | 


--------------------------------------------------------------------------------
/C++/QuestionsOfArrays/SortArray.cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | #include <algorithm>
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | int main()
 7 | {
 8 |     // Initializing an array
 9 |     int arr[] = { 5, 4, 1, 2, 3 };
10 | 
11 |     // Calculate the size of the array
12 |     int n = sizeof(arr) / sizeof(arr[0]);
13 | 
14 |     // Print the array before sorting the elements
15 |     cout << "Array Before Sorting: ";
16 |     for (int i = 0; i < n; i++) {
17 |         cout << arr[i] << " ";
18 |     }
19 |     cout << endl;
20 | 
21 |     // Sort the array
22 |     sort(arr, arr + n);
23 | 
24 |     // Print the array after sorting the elements
25 |     cout << "Array After Sorting: ";
26 |     for (int i = 0; i < n; i++) {
27 |         cout << arr[i] << " ";
28 |     }
29 | 
30 |     return 0;
31 | }
32 | 


--------------------------------------------------------------------------------
/C++/QuestionsOfArrays/bubbleSort.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | void printArray(int arr[], int n){
 4 |     for(int i=0; i<n; i++){
 5 |         cout<<arr[i]<<" ";
 6 |     }
 7 | }
 8 | void Bubble(int *arr, int n){
 9 |     for(int i = 0; i<n-1; i++){
10 |         for(int j=0; j<n-i-1; j++){
11 |             if(arr[j]>arr[j+1]){
12 |                 swap(arr[j], arr[j+1]);
13 |             }
14 |         }
15 |     }
16 |     printArray(arr,n);
17 | }
18 | int main(){
19 |     int arr[5] = {7,6,5,4,3};
20 |     int n = sizeof(arr)/sizeof(int);
21 |     Bubble(arr, n);
22 | }


--------------------------------------------------------------------------------
/C++/QuestionsOfArrays/charSort.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | void printArray(char arr[], int n){
 4 |     for(int i=0; i<n; i++){
 5 |         cout<<arr[i]<<" ";
 6 |     }
 7 | }
 8 | void charSort(char arr[], int n){
 9 |   for(int i = 1; i<n; i++){
10 |         int curr  = arr[i];
11 |         int prev = i-1;
12 |         while(prev>=0 && arr[prev]<curr){
13 |             swap(arr[prev], arr[prev+1]);
14 |             prev--;
15 |         }
16 |         arr[prev+1] = curr;
17 |     }
18 |     printArray(arr,n);
19 | }
20 | int main(){
21 | char arr[] = {'a', 'q','e','z','o','y','b','n','k','g','f'};
22 | int n= sizeof(arr)/sizeof(arr[0]);
23 | charSort(arr,n);
24 | }


--------------------------------------------------------------------------------
/C++/QuestionsOfArrays/countSort.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | void printArray(int arr[], int n) {
 5 |     for (int i = 0; i < n; i++) {
 6 |         cout << arr[i] << " ";
 7 |     }
 8 |     cout << endl;
 9 | }
10 | 
11 | void countSort(int *arr, int n) {
12 |     int max = arr[0];
13 |     for (int i = 1; i < n; i++) {
14 |         if (arr[i] > max) {
15 |             max = arr[i];
16 |         }
17 |     }
18 |     
19 |     int countArray[max + 1] = {0};
20 |     
21 |     for (int i = 0; i < n; i++) {
22 |         countArray[arr[i]]++;
23 |     }
24 |     
25 |     for (int i = 1; i <= max; i++) {
26 |         countArray[i] += countArray[i - 1];
27 |     }
28 |     
29 |     int outputArray[n];
30 |     for (int i = n - 1; i >= 0; i--) {
31 |         outputArray[countArray[arr[i]] - 1] = arr[i];
32 |         countArray[arr[i]]--;
33 |     }
34 |     
35 |     for (int i = 0; i < n; i++) {
36 |         arr[i] = outputArray[i];
37 |     }
38 | }
39 | 
40 | int main() {
41 |     int arr[10] = {10,3,5,2,8,5,9,3,0,1};
42 |     int n = 10;
43 |     countSort(arr, n);
44 |     printArray(arr, n);
45 |     return 0;
46 | }
47 | 


--------------------------------------------------------------------------------
/C++/QuestionsOfArrays/diagonalSum.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | int diagonalSum(int mat[][4], int n){
 4 |     int sum = 0;
 5 |     for(int i=0; i<n; i++){
 6 |         for(int j=0; j<n; j++){
 7 |             if(i==j){
 8 |                 sum += mat[i][j];
 9 |             }
10 |             else if(j=n-i-1){
11 |                 sum += mat[i][j];
12 |             }
13 |         }
14 |     }
15 |     cout<<"Sum of diagonal is "<<sum<<endl;
16 |     return sum;
17 | }
18 | int main(){
19 | int mat[4][4] = {
20 |     {1,2,3,4},
21 |     {5,6,7,8},
22 |     {9,10,11,12},
23 |     {13,14,15,16}
24 | };
25 | 
26 | diagonalSum(mat,4);
27 | cout<<"hello world!";
28 | return 0;
29 | }


--------------------------------------------------------------------------------
/C++/QuestionsOfArrays/insertion.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | void printArray(int arr[], int n){
 4 | for(int i = 0; i<n; i++){
 5 |     cout<<arr[i]<<" ";
 6 | }
 7 | }
 8 | void insertionSort(int arr[], int n){
 9 |     for(int i = 1; i<n; i++){
10 |         int curr  = arr[i];
11 |         int prev = i-1;
12 |         while(prev>=0 && arr[prev]>curr){
13 |             swap(arr[prev], arr[prev+1]);
14 |             prev--;
15 |         }
16 |         arr[prev+1] = curr;
17 |     }
18 |     printArray(arr,n);
19 |     
20 | }
21 | int main(){
22 | int n;
23 | cout<<"Enter number of elements"<<endl;
24 | cin>>n;
25 | int arr[n];
26 | cout<<"enter array elements"<<endl;
27 | for(int i = 0; i<n; i++){
28 |     cin>>arr[i];
29 | }
30 | insertionSort(arr,n);
31 | 
32 | }


--------------------------------------------------------------------------------
/C++/QuestionsOfArrays/mergesort.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | void merge(int *arr,int l,int mid,int r){
 4 |     int ans[r-l+1];
 5 |     int i = l, j = mid+1;
 6 |     int k = 0;
 7 |     while(i<=mid && j<=r){
 8 |         if(arr[i] < arr[j]){
 9 |             ans[k++] = arr[i++];
10 |         }else{
11 |             ans[k++] = arr[j++];
12 |         }
13 |     }
14 |     while(i<=mid){
15 |         ans[k++] = arr[i++];
16 |     }
17 |     while(j<=r){
18 |         ans[k++] = arr[i++];
19 |     }
20 |     for(int i = 0;i<k;i++){
21 |         arr[i+l] = ans[i];
22 |     }
23 | }
24 | void mergeSort(int *arr,int l,int r){
25 |     if(l>=r){
26 |         return;
27 |     }
28 |     int mid = l+(r-l)/2;
29 |     mergeSort(arr,l,mid);
30 |     mergeSort(arr,mid+1,r);
31 |     merge(arr,l,mid,r);
32 | }
33 | int main(){
34 |     int arr[] = {0,6,0,3,2};
35 |     int n= 5;
36 |     mergeSort(arr,0,n-1);
37 |     for(int i = 0;i<n;i++){
38 |         cout<<arr[i]<<" ";
39 |     }
40 |     cout<<endl;
41 |     return 0;
42 | }
43 | 


--------------------------------------------------------------------------------
/C++/QuestionsOfArrays/rankTransformOfArray.cpp:
--------------------------------------------------------------------------------
 1 | // Given an array of integers arr, replace each element with its rank.
 2 | 
 3 | // The rank represents how large the element is. The rank has the following rules:
 4 | 
 5 | // Rank is an integer starting from 1. The larger the element, the larger the rank. If two elements are equal, their rank must be the same. Rank should be as small as possible.
 6 | 
 7 | // Input: arr = [40,10,20,30] Output: [4,1,2,3]
 8 | 
 9 | 
10 | #include <iostream>
11 | #include <vector>
12 | #include <algorithm>
13 | #include <unordered_map>
14 | 
15 | using namespace std;
16 | 
17 | vector<int> arrayRankTransform(vector<int>& arr) {
18 |     // Create a sorted copy of the array
19 |     vector<int> sortedArr = arr;
20 |     sort(sortedArr.begin(), sortedArr.end());
21 | 
22 |     //  Create a map to store ranks
23 |     unordered_map<int, int> rankMap;
24 |     int rank = 1;
25 | 
26 |     //  Assign ranks to unique elements
27 |     for (int num : sortedArr) {
28 |         if (rankMap.find(num) == rankMap.end()) {
29 |             rankMap[num] = rank++;
30 |         }
31 |     }
32 | 
33 |     //  Replace each element in the original array with its rank
34 |     for (int& num : arr) {
35 |         num = rankMap[num];
36 |     }
37 | 
38 |     return arr;
39 | }
40 | 
41 | int main() {
42 |     vector<int> arr = {40, 10, 20, 30};
43 |     vector<int> rankedArr = arrayRankTransform(arr);
44 | 
45 |     // Output the ranked array
46 |     for (int rank : rankedArr) {
47 |         cout << rank << " ";
48 |     }
49 |     cout << endl;
50 | 
51 |     return 0;
52 | }


--------------------------------------------------------------------------------
/C++/QuestionsOfArrays/selectionSort.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | void print(int *arr, int n){
 4 |     for(int i=0; i<n; i++){
 5 |         cout<<arr[i]<<" ";
 6 |     }
 7 | }
 8 | void Selection(int *arr, int n){
 9 |     for(int i=0; i<n-1; i++){
10 |         int minIdx = i;
11 |         for(int j = i+1; j<n; j++){
12 |             if(arr[j]<arr[minIdx]){
13 |                 minIdx = j;
14 |             }
15 |         }
16 |         swap(arr[i], arr[minIdx]);
17 |     }
18 |     print(arr,n);
19 | }
20 | int main(){
21 | int arr[7] = {9,8,5,6,4,8,3};
22 | int n = sizeof(arr)/sizeof(int);
23 | Selection(arr, n);
24 | }


--------------------------------------------------------------------------------
/C++/QuestionsOfArrays/spiralMatrix.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | void spiralMatrix(int mat[][4], int n, int m){
 4 |     int srow = 0, scol = 0;
 5 |     int erow = n-1, ecol = m-1;
 6 |     while(srow<=erow && scol<=ecol){
 7 | //top
 8 | for(int j=scol; j<=ecol; j++){
 9 |     cout<<mat[srow][j]<<" ";
10 | }
11 | //right
12 | for(int j=srow+1; j<=erow; j++){
13 |     cout<<mat[j][ecol]<<" ";
14 | }
15 | //bottom
16 | for(int j=ecol-1; j>=scol; j--){
17 |     if(srow==erow){
18 |         break;
19 |     }
20 |     cout<<mat[erow][j]<<" ";
21 | }
22 | //left
23 | for(int j=erow-1; j>= srow+1; j--){
24 |     if(scol==ecol){
25 |         break;
26 |     }
27 |     cout<<mat[j][scol]<<" ";
28 | }
29 | srow++;
30 | scol++;
31 | erow--;
32 | ecol--;
33 |     }
34 | 
35 | }
36 | int main(){
37 | int matrix[4][4] = {
38 |     {1,2,3,4},
39 |     {5,6,7,8},
40 |     {9,10,11,12},
41 |     {13,14,15,16}
42 | };
43 | spiralMatrix(matrix, 4, 4);
44 | return 0;
45 | }


--------------------------------------------------------------------------------
/C++/QuestionsOfArrays/trappingRainwater.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<algorithm>
 3 | using namespace std;
 4 | 
 5 | int trap(int *heights, int n) {
 6 |     if (n <= 2) return 0;  
 7 | 
 8 |     int left = 0, right = n - 1;
 9 |     int leftMax = heights[left], rightMax = heights[right];
10 |     int waterTrapped = 0;
11 | 
12 |     while (left <= right) {
13 |         if (leftMax < rightMax) {
14 |             leftMax = max(leftMax, heights[left]);   
15 |             waterTrapped += leftMax - heights[left]; r
16 |             left++;
17 |         } else {
18 |             rightMax = max(rightMax, heights[right]); 
19 |             waterTrapped += rightMax - heights[right];
20 |             right--;
21 |         }
22 |     }
23 | 
24 |     return waterTrapped;
25 | }
26 | 
27 | int main() {
28 |     int heights[] = {4, 2, 0, 6, 3, 2, 5};
29 |     int n = sizeof(heights) / sizeof(int);
30 | 
31 |     int result = trap(heights, n);
32 |     cout << "Water trapped: " << result << endl;
33 | 
34 |     return 0;
35 | }
36 | 


--------------------------------------------------------------------------------
/C++/STACK/Check_Balance_Bracket.cpp:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <stdbool.h>
 3 | #include <stdlib.h>
 4 | 
 5 | #define MAX 100
 6 | 
 7 | typedef struct {
 8 |     char arr[MAX];
 9 |     int top;
10 | } Stack;
11 | 
12 | 
13 | void init(Stack *s) {
14 |     s->top = -1;
15 | }
16 | 
17 | bool isEmpty(Stack *s) {
18 |     return s->top == -1;
19 | }
20 | 
21 | 
22 | void push(Stack *s, char c) {
23 |     s->arr[++(s->top)] = c;
24 | }
25 | 
26 | char pop(Stack *s) {
27 |     return s->arr[(s->top)--];
28 | }
29 | 
30 | char peek(Stack *s) {
31 |     return s->arr[s->top];
32 | }
33 | 
34 | bool ispar(const char *s) {
35 |     Stack stk;
36 |     init(&stk);
37 | 
38 |     for (int i = 0; s[i] != '\0'; i++) {
39 |         char ch = s[i];
40 | 
41 |         if (isEmpty(&stk)) {
42 |             push(&stk, ch);
43 |         } else if ((peek(&stk) == '(' && ch == ')') ||
44 |                    (peek(&stk) == '{' && ch == '}') ||
45 |                    (peek(&stk) == '[' && ch == ']')) {
46 | 
47 |             pop(&stk);
48 |         } else {
49 |             push(&stk, ch);
50 |         }
51 |     }
52 | 
53 |     return isEmpty(&stk);
54 | }
55 | 
56 | int main() {
57 |     const char *s = "{()}[]";
58 | 
59 |     if (ispar(s)) {
60 |         printf("true\n");
61 |     } else {
62 |         printf("false\n");
63 |     }
64 | 
65 |     return 0;
66 | }


--------------------------------------------------------------------------------
/C++/STACK/Reverse_String.cpp:
--------------------------------------------------------------------------------
 1 | #include <limits.h>
 2 | #include <stdio.h>
 3 | #include <stdlib.h>
 4 | #include <string.h>
 5 | 
 6 | struct Stack {
 7 | 	int top;
 8 | 	unsigned capacity;
 9 | 	char* array;
10 | };
11 | 
12 | struct Stack* createStack(unsigned capacity) {
13 | 	struct Stack* stack = (struct Stack*)malloc(sizeof(struct Stack));
14 | 	stack->capacity = capacity;
15 | 	stack->top = -1;
16 | 	stack->array = (char*)malloc(stack->capacity * sizeof(char));
17 | 	return stack;
18 | }
19 | 
20 | int isFull(struct Stack* stack) {
21 | 	return stack->top == stack->capacity - 1;
22 | }
23 | 
24 | int isEmpty(struct Stack* stack) {
25 | 	return stack->top == -1;
26 | }
27 | 
28 | void push(struct Stack* stack, char item) {
29 | 	if (isFull(stack))
30 | 		return;
31 | 	stack->array[++stack->top] = item;
32 | }
33 | 
34 | char pop(struct Stack* stack) {
35 | 	if (isEmpty(stack))
36 | 		return INT_MIN;
37 | 	return stack->array[stack->top--];
38 | }
39 | 
40 | void reverse(char str[]) {
41 | 	int n = strlen(str);
42 | 	struct Stack* stack = createStack(n);
43 | 	for (int i = 0; i < n; i++)
44 | 		push(stack, str[i]);
45 | 	for (int i = 0; i < n; i++)
46 | 		str[i] = pop(stack);
47 | }
48 | 
49 | int main() {
50 | 	char str[] = "Reading A Book";
51 | 	reverse(str);
52 | 	printf("Reversed string is %s", str);
53 | 	return 0;
54 | }
55 | 


--------------------------------------------------------------------------------
/C++/STACK/STACK_USING_ARRAY.cpp:
--------------------------------------------------------------------------------
  1 | #include<stdio.h>
  2 | #include<iostream>
  3 | using namespace std;
  4 | class arr_stack
  5 | {  
  6 |     private :
  7 |            int capacity , top ,*ptr;
  8 | 
  9 |     public :
 10 |            arr_stack();
 11 |            void createstack(int );
 12 |            void push(int);
 13 |            int peek();
 14 |            bool isfull();
 15 |            bool isempty();
 16 |            void pop();
 17 |            void display();
 18 |            ~arr_stack();
 19 | };
 20 | arr_stack::arr_stack()
 21 | {
 22 |     ptr = NULL;
 23 | }
 24 | void arr_stack::createstack(int cap)
 25 | {
 26 |     capacity = cap;
 27 |     top = -1;
 28 |     if (ptr!=NULL)
 29 |       delete [] ptr;
 30 |     ptr = new int[capacity];
 31 | }
 32 | bool arr_stack::isfull()
 33 | {
 34 |     return (top==capacity-1);     
 35 | }
 36 | bool arr_stack::isempty()
 37 | {
 38 |     return (top==-1);
 39 | }
 40 | void arr_stack::push(int data)
 41 | {
 42 |     if(top==capacity)
 43 |       cout<<"OVERFLOW";
 44 |     else 
 45 |     {
 46 |         top++;
 47 |         ptr[top]=data;
 48 |     }
 49 | }
 50 | int arr_stack::peek()
 51 | {
 52 |     if(ptr==NULL)
 53 |      cout<<"UNDERFLOW";
 54 |     return ptr[top];
 55 | }
 56 | void arr_stack::pop()
 57 | {
 58 |     if(ptr==NULL)
 59 |      cout<<"UNDERFLOW";
 60 |     else 
 61 |     {
 62 |         top--;
 63 |     }
 64 | }
 65 | void arr_stack::display()
 66 | {
 67 |     for (int i=0;i<=top;i++)
 68 |        cout<<ptr[i];
 69 | }
 70 | arr_stack::~arr_stack()
 71 | {
 72 |     if(ptr!=NULL)
 73 |       delete ptr;
 74 | }
 75 | int main()
 76 | {
 77 |     arr_stack a;
 78 |       int choice;
 79 |     while(1)
 80 |     {
 81 |     cout<<"--*MENU*---"<<endl;
 82 |     cout<<"1.Create array"<<endl;
 83 |     cout<<"2.PUSH"<<endl;
 84 |     cout<<"3.POP"<<endl;
 85 |     cout<<"4.PEEK"<<endl;
 86 |     cout<<"5.Display"<<endl;
 87 |     cout<<"6.EXIT"<<endl;
 88 |     cout<<"Enter choice"<<endl;
 89 |     cin>>choice;
 90 |     switch(choice)
 91 |     {
 92 |         case 1 :
 93 |              int cap;
 94 |              cout<<"Enter capacity : ";
 95 |              cin>>cap;
 96 |              a.createstack(cap);
 97 |              break;
 98 |         case 2 :
 99 |              int data;
100 |              cout<<"Enter data : ";
101 |              cin>>data;
102 |              a.push(data);
103 |              break;
104 |         case 3 :
105 |              a.pop();
106 |              break;
107 |         case 4 :
108 |              int save;
109 |              save=a.peek();
110 |              cout<<save;
111 |              break;
112 |         case 5 :
113 |              a.display();
114 |              break;
115 |         case 6 :
116 |              exit(0);
117 |         default :
118 |              cout<<"WRONG CHOICE"<<endl;
119 |     }
120 |   }
121 | }
122 | 


--------------------------------------------------------------------------------
/C++/STACK/STACK_using_Linked_list.cpp:
--------------------------------------------------------------------------------
  1 | #include<stdio.h>
  2 | #include<iostream>
  3 | #include<stdlib.h>
  4 | using namespace std;
  5 | struct node
  6 | {  
  7 |    int item;
  8 |    node *next;
  9 | };
 10 | class ll_stack
 11 | {
 12 |    private :
 13 |          node *top;
 14 |    
 15 |    public :
 16 |            ll_stack();
 17 |            void push(int);
 18 |            node* peek();
 19 |            bool isfull();
 20 |            bool isempty();
 21 |            void pop();
 22 |            void display();
 23 |            void reverse ();
 24 |           ~ll_stack();
 25 | };
 26 | ll_stack::ll_stack()
 27 | {
 28 |     top = NULL;
 29 | }
 30 | void ll_stack::push(int data)
 31 | {
 32 |     node *n =new node;
 33 |     n->item = data;
 34 |         n->next = top;
 35 |         top = n;
 36 | }
 37 | void ll_stack::pop()
 38 | {
 39 |     node *t;
 40 |     if (top == NULL)
 41 |       cout<<"LIST EMPTY";
 42 |     else 
 43 |      {
 44 |          t = top;
 45 |          top =t->next;
 46 |          delete t;
 47 |      }
 48 | }
 49 | node* ll_stack::peek()
 50 | {
 51 |      return top;
 52 | }
 53 | void ll_stack:: display()
 54 | {
 55 |    reverse();
 56 |    while (top)
 57 |     {
 58 |      cout<<top->item<<"  ";
 59 |      top = top->next;
 60 |     }
 61 | 
 62 | }
 63 | void ll_stack::reverse()
 64 | {
 65 |    ll_stack s1;
 66 |    while(top)
 67 |    {
 68 |       int save = reinterpret_cast<int>(peek());
 69 |       s1.push(save);
 70 |       pop();
 71 |    }
 72 | }
 73 | ll_stack:: ~ll_stack()
 74 | {
 75 |     node *t;
 76 |     t = top;
 77 |     while (t->next!=NULL)
 78 |       pop();
 79 | }
 80 | int main()
 81 | {
 82 |     ll_stack s;
 83 |       int choice;
 84 |     while(1)
 85 |     {
 86 |     cout<<"--*MENU*---"<<endl;
 87 |     cout<<"1.PUSH"<<endl;
 88 |     cout<<"2.POP"<<endl;
 89 |     cout<<"3.PEEK"<<endl;
 90 |     cout<<"4.Display"<<endl;
 91 |     cout<<"5.EXIT"<<endl;
 92 |     cout<<"Enter choice"<<endl;
 93 |     cin>>choice;
 94 |     switch(choice)
 95 |     {
 96 |         case 1 :
 97 |              int data;
 98 |              cout<<"Enter data : ";
 99 |              cin>>data;
100 |              s.push(data);
101 |              break;
102 |         case 2 :
103 |              s.pop();
104 |              break;
105 |         case 3 :
106 |              node *save;
107 |              save=s.peek();
108 |              cout<<save;
109 |              break;
110 |         case 4 :
111 |              s.display();
112 |              break;
113 |         case 5 :
114 |              exit(0);
115 |         default :
116 |              cout<<"WRONG CHOICE"<<endl;
117 |     }
118 |   }
119 | }


--------------------------------------------------------------------------------
/C++/STACK/StackOfArray.cpp:
--------------------------------------------------------------------------------
 1 | #include <array>
 2 | #include <iostream>
 3 | #include <stack>
 4 | using namespace std;
 5 | 
 6 | int main()
 7 | {
 8 |     // Define the type of array
 9 |     typedef array<int, 3> ArrayType;
10 | 
11 |     // Initialize two arrays
12 |     ArrayType array1 = { 1, 2, 3 };
13 |     ArrayType array2 = { 4, 5, 6 };
14 | 
15 |     // Create a stack of arrays
16 |     stack<ArrayType> myStack;
17 |     myStack.push(array1);
18 |     myStack.push(array2);
19 | 
20 |     // Print the stack of arrays
21 |     while (!myStack.empty()) {
22 |         ArrayType& topArray = myStack.top();
23 |         for (int i : topArray) {
24 |             cout << i << " ";
25 |         }
26 |         cout << endl;
27 |         myStack.pop();
28 |     }
29 | 
30 |     return 0;
31 | }
32 | 


--------------------------------------------------------------------------------
/C++/STACK/TWO_Stack_IN_Array.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h> 
 2 | using namespace std; 
 3 | 
 4 | class twoStacks { 
 5 | 	int* arr; 
 6 | 	int size; 
 7 | 	int top1, top2; 
 8 | 
 9 | public: 
10 | 	twoStacks(int n) { 
11 | 		size = n; 
12 | 		arr = new int[n]; 
13 | 		top1 = n / 2 + 1; 
14 | 		top2 = n / 2; 
15 | 	} 
16 | 
17 | 	void push1(int x) { 
18 | 		if (top1 > 0) { 
19 | 			top1--; 
20 | 			arr[top1] = x; 
21 | 		} else { 
22 | 			cout << "Stack Overflow By element : " << x << endl; 
23 | 			return; 
24 | 		} 
25 | 	} 
26 | 
27 | 	void push2(int x) { 
28 | 		if (top2 < size - 1) { 
29 | 			top2++; 
30 | 			arr[top2] = x; 
31 | 		} else { 
32 | 			cout << "Stack Overflow By element : " << x << endl; 
33 | 			return; 
34 | 		} 
35 | 	} 
36 | 
37 | 	int pop1() { 
38 | 		if (top1 <= size / 2) { 
39 | 			int x = arr[top1]; 
40 | 			top1++; 
41 | 			return x; 
42 | 		} else { 
43 | 			cout << "Stack UnderFlow"; 
44 | 			exit(1); 
45 | 		} 
46 | 	} 
47 | 
48 | 	int pop2() { 
49 | 		if (top2 >= size / 2 + 1) { 
50 | 			int x = arr[top2]; 
51 | 			top2--; 
52 | 			return x; 
53 | 		} else { 
54 | 			cout << "Stack UnderFlow" << endl; 
55 | 			exit(1); 
56 | 		} 
57 | 	} 
58 | }; 
59 | 
60 | int main() { 
61 | 	twoStacks ts(5); 
62 | 	ts.push1(5); 
63 | 	ts.push2(10); 
64 | 	ts.push2(15); 
65 | 	ts.push1(11); 
66 | 	ts.push2(7); 
67 | 	cout << "Popped element from stack1 is : " << ts.pop1() << endl; 
68 | 	ts.push2(40); 
69 | 	cout << "Popped element from stack2 is : " << ts.pop2() << endl; 
70 | 	return 0; 
71 | }
72 | 


--------------------------------------------------------------------------------
/C++/STACK/stack.cpp:
--------------------------------------------------------------------------------
  1 | #include<iostream>
  2 | 
  3 | using namespace std;
  4 | 
  5 | 
  6 | int stac[100];int n=100;int top=-1;
  7 | void display();
  8 | void push(int);
  9 | void pop();
 10 | bool isemt();
 11 | bool isfull();
 12 | 
 13 | 
 14 | int main()
 15 | {
 16 | int ch,s;
 17 | char c;
 18 | 
 19 | x1:
 20 | cout<<"\nEnter a choice for stack:\n1. add an element\n2. delete an element\n3.display the content";
 21 | cin>>ch;
 22 | 
 23 | switch(ch)
 24 | {
 25 | case 1:
 26 |  cout<<"\nEnter the element:";
 27 |  cin>>s;
 28 |  if(isfull())
 29 |  {
 30 |   cout<<"\nStack is full,cannot enter";
 31 |  }
 32 |  else 
 33 |  push(s);
 34 |  cout<<"\noperation successful";
 35 |  break;
 36 | case 2:
 37 |  if(isemt())
 38 |  { 
 39 |   cout<<"\nStack already empty";
 40 |  }
 41 |  else
 42 |  pop();
 43 |  cout<<"operation successful";
 44 |  break;
 45 | case 3:
 46 |  display();
 47 |  default:
 48 |   cout<<"\nwrong choice";
 49 | }
 50 |  cout<<"\nDo you want to continue(y/n):";
 51 |  cin>>c;
 52 | if(c=='Y'||c=='y')
 53 | goto x1;
 54 | 
 55 | 
 56 | return 0;
 57 | }
 58 | 
 59 | void display()
 60 | {
 61 | 
 62 |  if(top<=-1)
 63 |   cout<<"No element ";
 64 |  else 
 65 |  { int k=top;
 66 |   cout<<"\nstack :";
 67 |   while(k>=0)
 68 |   {
 69 |    cout<<stac[k]<<" ";
 70 |    k--;
 71 |   }
 72 |   
 73 |  }
 74 | }
 75 | 
 76 | 
 77 | 
 78 | void push(int m)
 79 | {
 80 |  if(top>=100) 
 81 |   cout<<"\nstack overflow";
 82 |  else
 83 |  {
 84 |   stac[++top]=m; 
 85 |  }
 86 | }
 87 | 
 88 | void pop()
 89 | {
 90 |  if(top<=-1)
 91 |  cout<<"Stack Underflow";
 92 |  else
 93 |  {stac[top]=0;
 94 |  top--;
 95 |  }
 96 | }
 97 | 
 98 | 
 99 | bool isemt()
100 | {
101 |   if(top==-1)
102 |   return true;
103 |   else 
104 |   return false;
105 | }
106 | 
107 | bool isfull()
108 | {
109 | 
110 |   if(top==n)
111 |   return true;
112 |   else 
113 |   return false;
114 | }
115 | 


--------------------------------------------------------------------------------
/C++/STACK/stackusinglinkedlist222.c:
--------------------------------------------------------------------------------
  1 | #include <stdio.h>
  2 | #include <stdlib.h>
  3 | 
  4 | // Define the structure for a stack node
  5 | struct Node {
  6 |     int data;
  7 |     struct Node* next;
  8 | };
  9 | 
 10 | // Function 1: Push (insert element into the stack)
 11 | void push(struct Node** top, int data) {
 12 |     struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
 13 |     if (newNode == NULL) {
 14 |         printf("Stack Overflow (Not enough memory)\n");
 15 |         return;
 16 |     }
 17 |     newNode->data = data;
 18 |     newNode->next = *top;
 19 |     *top = newNode;
 20 |     printf("Pushed %d to stack\n", data);
 21 | }
 22 | 
 23 | // Function 2: Pop (remove the top element from the stack)
 24 | int pop(struct Node** top) {
 25 |     if (*top == NULL) {
 26 |         printf("Stack Underflow (Stack is empty)\n");
 27 |         return -1;
 28 |     }
 29 |     struct Node* temp = *top;
 30 |     int poppedData = temp->data;
 31 |     *top = (*top)->next;
 32 |     free(temp);
 33 |     return poppedData;
 34 | }
 35 | 
 36 | // Function 3: Peek (return the top element without removing it)
 37 | int peek(struct Node* top) {
 38 |     if (top == NULL) {
 39 |         printf("Stack is empty\n");
 40 |         return -1;
 41 |     }
 42 |     return top->data;
 43 | }
 44 | 
 45 | // Function 4: Check if stack is empty
 46 | int isEmpty(struct Node* top) {
 47 |     return top == NULL;
 48 | }
 49 | 
 50 | // Function 5: Check if stack is full (based on available memory)
 51 | int isFull() {
 52 |     struct Node* temp = (struct Node*)malloc(sizeof(struct Node));
 53 |     if (temp == NULL) {
 54 |         return 1; // Stack is full if no memory is available
 55 |     }
 56 |     free(temp);
 57 |     return 0; // Stack is not full
 58 | }
 59 | 
 60 | // Function 6: Display all elements in the stack
 61 | void display(struct Node* top) {
 62 |     if (top == NULL) {
 63 |         printf("Stack is empty\n");
 64 |         return;
 65 |     }
 66 |     printf("Stack elements: ");
 67 |     struct Node* temp = top;
 68 |     while (temp != NULL) {
 69 |         printf("%d ", temp->data);
 70 |         temp = temp->next;
 71 |     }
 72 |     printf("\n");
 73 | }
 74 | 
 75 | // Function 7: Size of the stack
 76 | int size(struct Node* top) {
 77 |     int count = 0;
 78 |     struct Node* temp = top;
 79 |     while (temp != NULL) {
 80 |         count++;
 81 |         temp = temp->next;
 82 |     }
 83 |     return count;
 84 | }
 85 | 
 86 | // Main function to test the stack implementation
 87 | int main() {
 88 |     struct Node* stack = NULL; // Stack is initially empty
 89 | 
 90 |     push(&stack, 10);
 91 |     push(&stack, 20);
 92 |     push(&stack, 30);
 93 | 
 94 |     display(stack); // Show current stack elements
 95 | 
 96 |     printf("Top element is: %d\n", peek(stack));
 97 |     printf("Popped element: %d\n", pop(&stack));
 98 |     display(stack); // Show stack after popping one element
 99 | 
100 |     printf("Stack is %s\n", isEmpty(stack) ? "empty" : "not empty");
101 | 
102 |     printf("Current size of stack: %d\n", size(stack));
103 | 
104 |     printf("Stack is %sfull\n", isFull() ? "" : "not ");
105 | 
106 |     return 0;
107 | }
108 | 


--------------------------------------------------------------------------------
/C++/Selection_Sort.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | // Function to swap two elements
 5 | void swap(int& a, int& b) {
 6 |     int temp = a;
 7 |     a = b;
 8 |     b = temp;
 9 | }
10 | 
11 | // Function to perform selection sort
12 | void selectionSort(int arr[], int n) {
13 |     for (int i = 0; i < n - 1; i++) {
14 |         // Find the minimum element in the unsorted portion of the array
15 |         int minIndex = i;
16 |         for (int j = i + 1; j < n; j++) {
17 |             if (arr[j] < arr[minIndex]) {
18 |                 minIndex = j;
19 |             }
20 |         }
21 |         // Swap the found minimum element with the first unsorted element
22 |         swap(arr[minIndex], arr[i]);
23 |     }
24 | }
25 | 
26 | // Utility function to print the array
27 | void printArray(int arr[], int size) {
28 |     for (int i = 0; i < size; i++) {
29 |         cout << arr[i] << " ";
30 |     }
31 |     cout << endl;
32 | }
33 | 
34 | // Main function to test selection sort
35 | int main() {
36 |     int arr[] = {64, 25, 12, 22, 11};
37 |     int n = sizeof(arr) / sizeof(arr[0]);
38 | 
39 |     cout << "Unsorted array: ";
40 |     printArray(arr, n);
41 | 
42 |     // Perform selection sort
43 |     selectionSort(arr, n);
44 | 
45 |     cout << "Sorted array: ";
46 |     printArray(arr, n);
47 | 
48 |     return 0;
49 | }
50 | 


--------------------------------------------------------------------------------
/C++/Selection_Sort.exe:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/C++/Selection_Sort.exe


--------------------------------------------------------------------------------
/C++/binary_search.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <vector>
 3 | #include <algorithm>
 4 | 
 5 | int binarySearch(const std::vector<int>& arr, int target) {
 6 |     int left = 0;
 7 |     int right = arr.size() - 1;
 8 | 
 9 |     while (left <= right) {
10 |         int mid = left + (right - left) / 2;
11 | 
12 |         // Check if target is at mid
13 |         if (arr[mid] == target) {
14 |             return mid; // Target found at index mid
15 |         }
16 |         
17 |         // If target is greater, ignore left half
18 |         if (arr[mid] < target) {
19 |             left = mid + 1;
20 |         }
21 |         // If target is smaller, ignore right half
22 |         else {
23 |             right = mid - 1;
24 |         }
25 |     }
26 | 
27 |     return -1; // Target not found
28 | }
29 | 
30 | int main() {
31 |     int n, target;
32 |     std::cout << "Enter the number of elements in the array: ";
33 |     std::cin >> n;
34 | 
35 |     std::vector<int> arr(n);
36 |     std::cout << "Enter " << n << " sorted elements:\n";
37 |     for (int i = 0; i < n; ++i) {
38 |         std::cin >> arr[i];
39 |     }
40 | 
41 |     std::cout << "Enter the target value to search: ";
42 |     std::cin >> target;
43 | 
44 |     int result = binarySearch(arr, target);
45 |     
46 |     if (result != -1) {
47 |         std::cout << "Target found at index " << result << ".\n";
48 |     } else {
49 |         std::cout << "Target not found in the array.\n";
50 |     }
51 | 
52 |     return 0;
53 | }
54 | 


--------------------------------------------------------------------------------
/C++/bubble_sort.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <vector>
 3 | 
 4 | void bubbleSort(std::vector<int>& arr) {
 5 |     int n = arr.size();
 6 |     bool swapped;
 7 | 
 8 |     // Traverse through all array elements
 9 |     for (int i = 0; i < n - 1; ++i) {
10 |         swapped = false;
11 | 
12 |         // Last i elements are already sorted
13 |         for (int j = 0; j < n - i - 1; ++j) {
14 |             if (arr[j] > arr[j + 1]) {
15 |                 // Swap if the element found is greater than the next element
16 |                 std::swap(arr[j], arr[j + 1]);
17 |                 swapped = true;
18 |             }
19 |         }
20 | 
21 |         // If no two elements were swapped, the array is already sorted
22 |         if (!swapped) break;
23 |     }
24 | }
25 | 
26 | int main() {
27 |     int n;
28 |     std::cout << "Enter the number of elements in the array: ";
29 |     std::cin >> n;
30 | 
31 |     std::vector<int> arr(n);
32 |     std::cout << "Enter " << n << " elements:\n";
33 |     for (int i = 0; i < n; ++i) {
34 |         std::cin >> arr[i];
35 |     }
36 | 
37 |     bubbleSort(arr);
38 | 
39 |     std::cout << "Sorted array: ";
40 |     for (int i = 0; i < n; ++i) {
41 |         std::cout << arr[i] << " ";
42 |     }
43 |     std::cout << std::endl;
44 | 
45 |     return 0;
46 | }
47 | 


--------------------------------------------------------------------------------
/C++/depth_first_search.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <vector>
 3 | 
 4 | void dfs(int node, const std::vector<std::vector<int>>& adjList, std::vector<bool>& visited) {
 5 |     // Mark the current node as visited
 6 |     visited[node] = true;
 7 |     std::cout << node << " ";
 8 | 
 9 |     // Recursively visit all the adjacent nodes
10 |     for (int neighbor : adjList[node]) {
11 |         if (!visited[neighbor]) {
12 |             dfs(neighbor, adjList, visited);
13 |         }
14 |     }
15 | }
16 | 
17 | int main() {
18 |     int vertices, edges;
19 |     std::cout << "Enter the number of vertices and edges: ";
20 |     std::cin >> vertices >> edges;
21 | 
22 |     std::vector<std::vector<int>> adjList(vertices);
23 |     std::cout << "Enter the edges (format: start end):\n";
24 |     for (int i = 0; i < edges; ++i) {
25 |         int start, end;
26 |         std::cin >> start >> end;
27 |         adjList[start].push_back(end);
28 |         adjList[end].push_back(start); // Assuming an undirected graph
29 |     }
30 | 
31 |     std::vector<bool> visited(vertices, false);
32 |     int startNode;
33 |     std::cout << "Enter the starting node for DFS traversal: ";
34 |     std::cin >> startNode;
35 | 
36 |     std::cout << "DFS Traversal starting from node " << startNode << ": ";
37 |     dfs(startNode, adjList, visited);
38 |     std::cout << std::endl;
39 | 
40 |     return 0;
41 | }
42 | 


--------------------------------------------------------------------------------
/C++/fibonacci_memoization.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <vector>
 3 | 
 4 | int fibonacci(int n, std::vector<int>& memo) {
 5 |     // Base cases
 6 |     if (n <= 1) {
 7 |         return n;
 8 |     }
 9 |     
10 |     // Check if value is already computed
11 |     if (memo[n] != -1) {
12 |         return memo[n];
13 |     }
14 | 
15 |     // Calculate and store the result
16 |     memo[n] = fibonacci(n - 1, memo) + fibonacci(n - 2, memo);
17 |     return memo[n];
18 | }
19 | 
20 | int main() {
21 |     int n;
22 |     std::cout << "Enter the position of Fibonacci number to find: ";
23 |     std::cin >> n;
24 | 
25 |     // Initialize memoization array with -1 (indicating uncomputed values)
26 |     std::vector<int> memo(n + 1, -1);
27 | 
28 |     // Calculate Fibonacci number
29 |     int result = fibonacci(n, memo);
30 | 
31 |     std::cout << "Fibonacci(" << n << ") = " << result << std::endl;
32 |     return 0;
33 | }
34 | 


--------------------------------------------------------------------------------
/CONTRIBUTING.md:
--------------------------------------------------------------------------------
 1 | # Contributing to [Hacktoberfest2024]
 2 | 
 3 | First off, thanks for taking the time to contribute! 🎉
 4 | 
 5 | The following is a set of guidelines for contributing to our project. These are mostly guidelines, not rules. Use your best judgment, and feel free to propose changes to this document in a pull request.
 6 | 
 7 | ## Table of Contents
 8 | 
 9 | 1. Code of Conduct
10 | 2. How Can I Contribute?
11 |     - Reporting Bugs
12 |     - Suggesting Enhancements
13 |     - Submitting Pull Requests
14 | 3. Style Guides
15 |     - Git Commit Messages
16 |     - React Code Style
17 |     - C++ Code Style
18 | 4. Additional Resources
19 | 
20 | ## Code of Conduct
21 | 
22 | This project and everyone participating in it is governed by the Code of Conduct. By participating, you are expected to uphold this code. Please report unacceptable behavior to [email@example.com].
23 | 
24 | ## How Can I Contribute?
25 | 
26 | ### Reporting Bugs
27 | 
28 | If you find a bug, please report it by opening an issue. Include as much detail as possible to help us understand and reproduce the issue.
29 | 
30 | ### Suggesting Enhancements
31 | 
32 | We welcome suggestions for new features or improvements. Please open an issue to discuss your ideas before implementing them.
33 | 
34 | ### Submitting Pull Requests
35 | 
36 | 1. Fork the repository.
37 | 2. Create a new branch (`git checkout -b feature/YourFeature`).
38 | 3. Make your changes.
39 | 4. Commit your changes (`git commit -m 'Add some feature'`).
40 | 5. Push to the branch (`git push origin feature/YourFeature`).
41 | 6. Open a pull request.
42 | 
43 | ## Style Guides
44 | 
45 | ### Git Commit Messages
46 | 
47 | - Use the present tense ("Add feature" not "Added feature").
48 | - Use the imperative mood ("Move cursor to..." not "Moves cursor to...").
49 | - Limit the first line to 72 characters or less.
50 | - Reference issues and pull requests liberally after the first line.
51 | 
52 | ### React Code Style
53 | 
54 | - Follow the Airbnb JavaScript Style Guide.
55 | - Use functional components and hooks where possible.
56 | - Ensure your code passes ESLint checks.
57 | 
58 | ### C++ Code Style
59 | 
60 | - Follow the Google C++ Style Guide.
61 | - Use modern C++ features (e.g., `auto`, `nullptr`, range-based for loops).
62 | - Ensure your code passes `clang-tidy` checks.
63 | 
64 | ## Additional Resources
65 | 
66 | - React Documentation
67 | - C++ Documentation
68 | - GitHub Guides
69 | 
70 | We look forward to your contributions! 🚀
71 | 


--------------------------------------------------------------------------------
/CountingSort.py:
--------------------------------------------------------------------------------
 1 | def counting_sort(arr, low, high):
 2 |     hist = [0] * (high - low + 1)
 3 | 
 4 |     for num in arr:
 5 |         hist[num - low] += 1
 6 | 
 7 |     index = 0
 8 |     for i in range(len(hist)):
 9 |         for j in range(hist[i]):
10 |             arr[index] = i + low
11 |             index += 1
12 | 
13 | if __name__ == "__main__":
14 |     arr = [1, 1, 5, 2, 2, 3, 0, 0, -1, 2]
15 | 
16 |     print("Unsorted array:", arr)
17 | 
18 |     counting_sort(arr, -1, 5)
19 | 
20 |     print("Sorted array:", arr)
21 | 


--------------------------------------------------------------------------------
/DSA/LL/MERGE.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <stdlib.h>
 3 | struct Node
 4 | {
 5 |     int data;
 6 |     struct Node *next;
 7 | }*first=NULL,*second=NULL,*third=NULL;
 8 | void Display(struct Node *p)
 9 | {
10 |     while(p!=NULL)
11 |     {
12 |         printf("%d ",p->data);
13 |         p=p->next;
14 |     }
15 | }
16 | void create(int A[],int n)
17 | {
18 |     int i;
19 |     struct Node *t,*last;
20 |     first=(struct Node *)malloc(sizeof(struct Node));
21 |     first->data=A[0];
22 |     first->next=NULL;
23 |     last=first;
24 | 
25 |     for(i=1;i<n;i++)
26 |     {
27 |         t=(struct Node*)malloc(sizeof(struct Node));
28 |         t->data=A[i];
29 |         t->next=NULL;
30 |         last->next=t;
31 |         last=t;
32 |     }
33 | } 
34 | void create2(int A[],int n)
35 | {
36 |     int i;
37 |     struct Node *t,*last;
38 |     second=(struct Node *)malloc(sizeof(struct Node));
39 |     second->data=A[0];
40 |     second->next=NULL;
41 |     last=second;
42 | 
43 |     for(i=1;i<n;i++)
44 |     {
45 |         t=(struct Node*)malloc(sizeof(struct Node));
46 |         t->data=A[i];
47 |         t->next=NULL;
48 |         last->next=t;
49 |         last=t;
50 |     }
51 | }
52 | void Merge(struct Node *p,struct Node *q)
53 | {
54 |     struct Node *last;
55 |     if(p->data < q->data)
56 |     {
57 |         third=last=p;
58 |         p=p->next;
59 |         third->next=NULL;
60 |     }
61 |     else
62 |     {
63 |         third=last=q;
64 |         q=q->next;
65 |         third->next=NULL;
66 |     }
67 |     while(p && q)
68 |     {
69 |         if(p->data < q->data)
70 |         {
71 |             last->next=p;
72 |             last=p;
73 |             p=p->next;
74 |             last->next=NULL;
75 |         }
76 |         else
77 |         {
78 |             last->next=q;
79 |             last=q;
80 |             q=q->next;
81 |             last->next=NULL;
82 |         }
83 |     }
84 |     if(p)
85 |         last->next=p;
86 |     if(q)
87 |         last->next=q;
88 | }
89 | int main()
90 | {
91 |     int A[]={10,20,40,50,60};
92 |     int B[]={15,18,25,30,55};
93 |     create(A,5);
94 |     create2(B,5);
95 |     Merge(first,second);
96 |     Display(third);
97 |     return 0;
98 | }
99 | 


--------------------------------------------------------------------------------
/DSA/LL/MERGELL.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <stdlib.h>
 3 | struct Node
 4 | {
 5 |     int data;
 6 |     struct Node *next;
 7 | }*first=NULL,*second=NULL,*third=NULL;
 8 | void Display(struct Node *p)
 9 | {
10 |     while(p!=NULL)
11 |     {
12 |         printf("%d ",p->data);
13 |         p=p->next;
14 |     }
15 | }
16 | void create(int A[],int n)
17 | {
18 |     int i;
19 |     struct Node *t,*last;
20 |     first=(struct Node *)malloc(sizeof(struct Node));
21 |     first->data=A[0];
22 |     first->next=NULL;
23 |     last=first;
24 | 
25 |     for(i=1;i<n;i++)
26 |     {
27 |         t=(struct Node*)malloc(sizeof(struct Node));
28 |         t->data=A[i];
29 |         t->next=NULL;
30 |         last->next=t;
31 |         last=t;
32 |     }
33 | } 
34 | void create2(int A[],int n)
35 | {
36 |     int i;
37 |     struct Node *t,*last;
38 |     second=(struct Node *)malloc(sizeof(struct Node));
39 |     second->data=A[0];
40 |     second->next=NULL;
41 |     last=second;
42 | 
43 |     for(i=1;i<n;i++)
44 |     {
45 |         t=(struct Node*)malloc(sizeof(struct Node));
46 |         t->data=A[i];
47 |         t->next=NULL;
48 |         last->next=t;
49 |         last=t;
50 |     }
51 | }
52 | void Merge(struct Node *p,struct Node *q)
53 | {
54 |     struct Node *last;
55 |     if(p->data < q->data)
56 |     {
57 |         third=last=p;
58 |         p=p->next;
59 |         third->next=NULL;
60 |     }
61 |     else
62 |     {
63 |         third=last=q;
64 |         q=q->next;
65 |         third->next=NULL;
66 |     }
67 |     while(p && q)
68 |     {
69 |         if(p->data < q->data)
70 |         {
71 |             last->next=p;
72 |             last=p;
73 |             p=p->next;
74 |             last->next=NULL;
75 |         }
76 |         else
77 |         {
78 |             last->next=q;
79 |             last=q;
80 |             q=q->next;
81 |             last->next=NULL;
82 |         }
83 |     }
84 |     if(p)
85 |         last->next=p;
86 |     if(q)
87 |         last->next=q;
88 | }
89 | int main()
90 | {
91 |     int A[]={10,20,40,50,60};
92 |     int B[]={15,18,25,30,55};
93 |     create(A,5);
94 |     create2(B,5);
95 |     Merge(first,second);
96 |     Display(third);
97 |     return 0;
98 | }
99 | 


--------------------------------------------------------------------------------
/ReactProject/YoutubeClone/.gitignore:
--------------------------------------------------------------------------------
 1 | # See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
 2 | 
 3 | # dependencies
 4 | /node_modules
 5 | /.pnp
 6 | .pnp.js
 7 | 
 8 | # testing
 9 | /coverage
10 | 
11 | # production
12 | .env
13 | /build
14 | 
15 | # misc
16 | .DS_Store
17 | .env.local
18 | .env.development.local
19 | .env.test.local
20 | .env.production.local
21 | 
22 | npm-debug.log*
23 | yarn-debug.log*
24 | yarn-error.log*
25 | 


--------------------------------------------------------------------------------
/ReactProject/YoutubeClone/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "yt-clone",
 3 |   "version": "1.0.0",
 4 |   "private": true,
 5 |   "dependencies": {
 6 |     "@emotion/react": "^11.10.0",
 7 |     "@emotion/styled": "^11.10.0",
 8 |     "@mui/icons-material": "^5.8.4",
 9 |     "@mui/material": "^5.9.3",
10 |     "axios": "^0.27.2",
11 |     "react": "^18.2.0",
12 |     "react-dom": "^18.2.0",
13 |     "react-player": "^2.10.1",
14 |     "react-router-dom": "^6.3.0",
15 |     "react-scripts": "^5.0.1"
16 |   },
17 |   "scripts": {
18 |     "start": "react-scripts start",
19 |     "build": "react-scripts build",
20 |     "test": "react-scripts test",
21 |     "eject": "react-scripts eject"
22 |   },
23 |   "eslintConfig": {
24 |     "extends": [
25 |       "react-app",
26 |       "react-app/jest"
27 |     ]
28 |   },
29 |   "browserslist": {
30 |     "production": [
31 |       ">0.2%",
32 |       "not dead",
33 |       "not op_mini all"
34 |     ],
35 |     "development": [
36 |       "last 1 chrome version",
37 |       "last 1 firefox version",
38 |       "last 1 safari version"
39 |     ]
40 |   }
41 | }
42 | 


--------------------------------------------------------------------------------
/ReactProject/YoutubeClone/public/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/ReactProject/YoutubeClone/public/favicon.ico


--------------------------------------------------------------------------------
/ReactProject/YoutubeClone/public/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 |   <head>
 4 |     <meta charset="utf-8" />
 5 |     <link rel="icon" href="%PUBLIC_URL%/favicon.ico" />
 6 |     <meta name="viewport" content="width=device-width, initial-scale=1" />
 7 |     <meta name="theme-color" content="#000000" />
 8 |     <meta name="description" content="Web site created using create-react-app" />
 9 |     <link rel="apple-touch-icon" href="%PUBLIC_URL%/logo192.png" />
10 |     <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Roboto:300,400,500,700&display=swap" />
11 |     <link rel="stylesheet" href="https://fonts.googleapis.com/icon?family=Material+Icons" />
12 |     <link rel="manifest" href="%PUBLIC_URL%/manifest.json" />
13 |     <title>MyTube</title>
14 |   </head>
15 |   <body>
16 |     <noscript>You need to enable JavaScript to run this app.</noscript>
17 |     <div id="root"></div>
18 |   </body>
19 | </html>
20 | 


--------------------------------------------------------------------------------
/ReactProject/YoutubeClone/src/App.js:
--------------------------------------------------------------------------------
 1 | import { BrowserRouter, Routes, Route } from "react-router-dom";
 2 | import { Box } from '@mui/material';
 3 | 
 4 | import { ChannelDetail, VideoDetail, SearchFeed, Navbar, Feed } from './components';
 5 | 
 6 | const App = () => (
 7 |   <BrowserRouter>
 8 |     <Box sx={{ backgroundColor: '#000' }}>
 9 |       <Navbar />
10 |       <Routes>
11 |         <Route exact path='/' element={<Feed />} />
12 |         <Route path='/video/:id' element={<VideoDetail />} />
13 |         <Route path='/channel/:id' element={<ChannelDetail />} />
14 |         <Route path='/search/:searchTerm' element={<SearchFeed />} />
15 |       </Routes>
16 |     </Box>
17 |   </BrowserRouter>
18 | );
19 | 
20 | export default App;
21 | 


--------------------------------------------------------------------------------
/ReactProject/YoutubeClone/src/components/ChannelCard.jsx:
--------------------------------------------------------------------------------
 1 | import React from 'react';
 2 | import { Box, CardContent, CardMedia, Typography } from '@mui/material';
 3 | import CheckCircleIcon from '@mui/icons-material/CheckCircle';
 4 | import { Link } from 'react-router-dom';
 5 | import { demoProfilePicture } from '../utils/constants';
 6 | 
 7 | const ChannelCard = ({ channelDetail, marginTop }) => (
 8 |   <Box
 9 |     sx={{
10 |       boxShadow: 'none',
11 |       borderRadius: '20px',
12 |       display: 'flex',
13 |       justifyContent: 'center',
14 |       alignItems: 'center',
15 |       width: { xs: '356px', md: '320px' },
16 |       height: '326px',
17 |       margin: 'auto',
18 |       marginTop,
19 |     }}
20 |   >
21 |     <Link to={`/channel/${channelDetail?.id?.channelId}`}>
22 |       <CardContent sx={{ display: 'flex', flexDirection: 'column', justifyContent: 'center', textAlign: 'center', color: '#fff' }}>
23 |         <CardMedia
24 |           image={channelDetail?.snippet?.thumbnails?.high?.url || demoProfilePicture}
25 |           alt={channelDetail?.snippet?.title}
26 |           sx={{ borderRadius: '50%', height: '180px', width: '180px', mb: 2, border: '1px solid #e3e3e3' }}
27 |         />
28 |         <Typography variant="h6">
29 |           {channelDetail?.snippet?.title}{' '}
30 |           <CheckCircleIcon sx={{ fontSize: '14px', color: 'gray', ml: '5px' }} />
31 |         </Typography>
32 |         {channelDetail?.statistics?.subscriberCount && (
33 |           <Typography sx={{ fontSize: '15px', fontWeight: 500, color: 'gray' }}>
34 |             {parseInt(channelDetail?.statistics?.subscriberCount).toLocaleString('en-US')} Subscribers
35 |           </Typography>
36 |         )}
37 |       </CardContent>
38 |     </Link>
39 |   </Box>
40 | );
41 | 
42 | export default ChannelCard;
43 | 


--------------------------------------------------------------------------------
/ReactProject/YoutubeClone/src/components/ChannelDetail.jsx:
--------------------------------------------------------------------------------
 1 | import React, { useState, useEffect } from "react";
 2 | import { useParams } from "react-router-dom";
 3 | import { Box } from "@mui/material";
 4 | 
 5 | import { Videos, ChannelCard } from "./";
 6 | import { fetchFromAPI } from "../utils/fetchFromAPI";
 7 | 
 8 | const ChannelDetail = () => {
 9 |   const [channelDetail, setChannelDetail] = useState();
10 |   const [videos, setVideos] = useState(null);
11 | 
12 |   const { id } = useParams();
13 | 
14 |   useEffect(() => {
15 |     const fetchResults = async () => {
16 |       const data = await fetchFromAPI(`channels?part=snippet&id=${id}`);
17 | 
18 |       setChannelDetail(data?.items[0]);
19 | 
20 |       const videosData = await fetchFromAPI(`search?channelId=${id}&part=snippet%2Cid&order=date`);
21 | 
22 |       setVideos(videosData?.items);
23 |     };
24 | 
25 |     fetchResults();
26 |   }, [id]);
27 | 
28 |   return (
29 |     <Box minHeight="95vh">
30 |       <Box>
31 |         <div style={{
32 |           height:'300px',
33 |           background: 'linear-gradient(90deg, rgba(0,238,247,1) 0%, rgba(206,3,184,1) 100%, rgba(0,212,255,1) 100%)',
34 |           zIndex: 10,
35 |         }} />
36 |         <ChannelCard channelDetail={channelDetail} marginTop="-93px" />
37 |       </Box>
38 |       <Box p={2} display="flex">
39 |       <Box sx={{ mr: { sm: '100px' } }}/>
40 |         <Videos videos={videos} />
41 |       </Box>
42 |     </Box>
43 |   );
44 | };
45 | 
46 | export default ChannelDetail;
47 | 


--------------------------------------------------------------------------------
/ReactProject/YoutubeClone/src/components/Feed.jsx:
--------------------------------------------------------------------------------
 1 | import React, { useEffect, useState } from "react";
 2 | import { Box, Stack, Typography } from "@mui/material";
 3 | 
 4 | import { fetchFromAPI } from "../utils/fetchFromAPI";
 5 | import { Videos, Sidebar } from "./";
 6 | 
 7 | const Feed = () => {
 8 |   const [selectedCategory, setSelectedCategory] = useState("New");
 9 |   const [videos, setVideos] = useState(null);
10 | 
11 |   useEffect(() => {
12 |     setVideos(null);
13 | 
14 |     fetchFromAPI(`search?part=snippet&q=${selectedCategory}`)
15 |       .then((data) => setVideos(data.items))
16 |     }, [selectedCategory]);
17 | 
18 |   return (
19 |     <Stack sx={{ flexDirection: { sx: "column", md: "row" } }}>
20 |       <Box sx={{ height: { sx: "auto", md: "92vh" }, borderRight: "1px solid #3d3d3d", px: { sx: 0, md: 2 } }}>
21 |         <Sidebar selectedCategory={selectedCategory} setSelectedCategory={setSelectedCategory} />
22 |         
23 |         <Typography className="copyright" variant="body2" sx={{ mt: 1.5, color: "#fff", }}>
24 |           Copyright © 2022 Manav Shah
25 |         </Typography>
26 |       </Box>
27 | 
28 |       <Box p={2} sx={{ overflowY: "auto", height: "90vh", flex: 2 }}>
29 |         <Typography variant="h4" fontWeight="bold" mb={2} sx={{ color: "white" }}>
30 |           {selectedCategory} <span style={{ color: "#FC1503" }}>videos</span>
31 |         </Typography>
32 | 
33 |         <Videos videos={videos} />
34 |       </Box>
35 |     </Stack>
36 |   );
37 | };
38 | 
39 | export default Feed;
40 | 


--------------------------------------------------------------------------------
/ReactProject/YoutubeClone/src/components/Loader.jsx:
--------------------------------------------------------------------------------
 1 | import React from 'react';
 2 | import { Box, CircularProgress, Stack } from '@mui/material';
 3 | 
 4 | const Loader = () =>  (
 5 |   <Box minHeight="95vh">
 6 |     <Stack direction='row' justifyContent='center' alignItems='center' height='80vh' >
 7 |       <CircularProgress />
 8 |     </Stack>
 9 |   </Box>
10 | );
11 | 
12 | export default Loader;
13 | 


--------------------------------------------------------------------------------
/ReactProject/YoutubeClone/src/components/Navbar.jsx:
--------------------------------------------------------------------------------
 1 | import { Stack } from "@mui/material";
 2 | import { Link } from "react-router-dom";
 3 | 
 4 | import { logo } from "../utils/constants";
 5 | import { SearchBar } from "./";
 6 | 
 7 | const Navbar = () => (
 8 |   <Stack direction="row" alignItems="center" p={2} sx={{ position:  "sticky", background: '#000', top: 0, justifyContent: "space-between" }}>
 9 |     <Link to="/" style={{ display: "flex", alignItems: "center" }}>
10 |       <img src={logo} alt="logo" height={45} />
11 |     </Link>
12 |     <SearchBar />
13 |   </Stack>
14 | );
15 | 
16 | export default Navbar;
17 | 


--------------------------------------------------------------------------------
/ReactProject/YoutubeClone/src/components/SearchBar.jsx:
--------------------------------------------------------------------------------
 1 | import React, { useState } from 'react';
 2 | import { useNavigate } from "react-router-dom";
 3 | import { Paper, IconButton } from '@mui/material';
 4 | import SearchIcon from '@mui/icons-material/Search';
 5 | 
 6 | const SearchBar = () => {
 7 |   const [searchTerm, setSearchTerm] = useState('');
 8 |   const navigate = useNavigate();
 9 | 
10 |   const onhandleSubmit = (e) => {
11 |     e.preventDefault();
12 | 
13 |     if (searchTerm) {
14 |       navigate(`/search/${searchTerm}`);
15 | 
16 |       setSearchTerm('');
17 |     }
18 |   };
19 | 
20 |   return (
21 |     <Paper
22 |       component='form'
23 |       onSubmit={onhandleSubmit}
24 |       sx={{
25 |         borderRadius: 20,
26 |         border: '1px solid #e3e3e3',
27 |         pl: 2,
28 |         boxShadow: 'none',
29 |         mr: { sm: 5 },
30 |       }}
31 |     >
32 |       <input
33 |         className='search-bar'
34 |         placeholder='Search...'
35 |         value={searchTerm}
36 |         onChange={(e) => setSearchTerm(e.target.value)}
37 |       />
38 |       <IconButton type='submit' sx={{ p: '10px', color: 'red' }} aria-label='search'>
39 |         <SearchIcon />
40 |       </IconButton>
41 |     </Paper>
42 |   );
43 | };
44 | 
45 | export default SearchBar;
46 | 


--------------------------------------------------------------------------------
/ReactProject/YoutubeClone/src/components/SearchFeed.jsx:
--------------------------------------------------------------------------------
 1 | import { useState, useEffect } from "react";
 2 | import { Typography, Box } from "@mui/material";
 3 | import { useParams } from "react-router-dom";
 4 | 
 5 | import { fetchFromAPI } from "../utils/fetchFromAPI";
 6 | import { Videos } from "./";
 7 | 
 8 | const SearchFeed = () => {
 9 |   const [videos, setVideos] = useState(null);
10 |   const { searchTerm } = useParams();
11 | 
12 |   useEffect(() => {
13 |     fetchFromAPI(`search?part=snippet&q=${searchTerm}`)
14 |       .then((data) => setVideos(data.items))
15 |   }, [searchTerm]);
16 | 
17 |   return (
18 |     <Box p={2} minHeight="95vh">
19 |       <Typography variant="h4" fontWeight={900}  color="white" mb={3} ml={{ sm: "100px"}}>
20 |         Search Results for <span style={{ color: "#FC1503" }}>{searchTerm}</span> videos
21 |       </Typography>
22 |       <Box display="flex">
23 |         <Box sx={{ mr: { sm: '100px' } }}/>
24 |         {<Videos videos={videos} />}
25 |       </Box>
26 |     </Box>
27 |   );
28 | };
29 | 
30 | export default SearchFeed;
31 | 


--------------------------------------------------------------------------------
/ReactProject/YoutubeClone/src/components/Sidebar.jsx:
--------------------------------------------------------------------------------
 1 | import React from "react";
 2 | import { Stack } from "@mui/material";
 3 | 
 4 | import { categories } from "../utils/constants";
 5 | 
 6 | const Categories = ({ selectedCategory, setSelectedCategory }) => (
 7 |   <Stack
 8 |     direction="row"
 9 |     sx={{
10 |       overflowY: "auto",
11 |       height: { sx: "auto", md: "95%" },
12 |       flexDirection: { md: "column" },
13 |     }}
14 |   >
15 |     {categories.map((category) => (
16 |       <button
17 |         className="category-btn"
18 |         onClick={() => setSelectedCategory(category.name)}
19 |         style={{
20 |           background: category.name === selectedCategory && "#FC1503",
21 |           color: "white",
22 |         }}
23 |         key={category.name}
24 |       >
25 |         <span style={{ color: category.name === selectedCategory ? "white" : "red", marginRight: "15px" }}>
26 |           {category.icon}
27 |         </span>
28 |         <span style={{ opacity: category.name === selectedCategory ? "1" : "0.8" }}>
29 |           {category.name}
30 |         </span>
31 |       </button>
32 |     ))}
33 |   </Stack>
34 | );
35 | 
36 | export default Categories;
37 | 


--------------------------------------------------------------------------------
/ReactProject/YoutubeClone/src/components/VideoCard.jsx:
--------------------------------------------------------------------------------
 1 | import React from 'react'
 2 | import { Link } from "react-router-dom"; 
 3 | import { Typography, Card, CardContent, CardMedia } from "@mui/material";
 4 | import CheckCircleIcon from "@mui/icons-material/CheckCircle";
 5 | 
 6 | import { demoThumbnailUrl, demoVideoUrl, demoVideoTitle, demoChannelUrl, demoChannelTitle } from "../utils/constants";
 7 | 
 8 | const VideoCard = ({ video: { id: { videoId }, snippet } }) => (
 9 |   <Card sx={{ width: { xs: '100%', sm: '358px', md: "320px", }, boxShadow: "none", borderRadius: 0 }}>
10 |     <Link to={videoId ? `/video/${videoId}` : `/video/cV2gBU6hKfY` }>
11 |       <CardMedia image={snippet?.thumbnails?.high?.url || demoThumbnailUrl} alt={snippet?.title} 
12 |         sx={{ width: { xs: '100%', sm: '358px'}, height: 180 }} 
13 |       />
14 |     </Link>
15 |     <CardContent sx={{ backgroundColor: "#1E1E1E", height: '106px' }}>
16 |       <Link to={videoId ? `/video/${videoId}` : demoVideoUrl } >
17 |         <Typography variant="subtitle1" fontWeight="bold" color="#FFF">
18 |           {snippet?.title.slice(0, 60) || demoVideoTitle.slice(0, 60)}
19 |         </Typography>
20 |       </Link>
21 |       <Link to={snippet?.channelId ? `/channel/${snippet?.channelId}` : demoChannelUrl} >
22 |         <Typography variant="subtitle2" color="gray">
23 |           {snippet?.channelTitle || demoChannelTitle}
24 |           <CheckCircleIcon sx={{ fontSize: "12px", color: "gray", ml: "5px" }} />
25 |         </Typography>
26 |       </Link>
27 |     </CardContent>
28 |   </Card>
29 | );
30 | 
31 | export default VideoCard


--------------------------------------------------------------------------------
/ReactProject/YoutubeClone/src/components/VideoDetail.jsx:
--------------------------------------------------------------------------------
 1 | import React, { useEffect, useState } from "react";
 2 | import { Link, useParams } from "react-router-dom";
 3 | import ReactPlayer from "react-player";
 4 | import { Typography, Box, Stack } from "@mui/material";
 5 | import CheckCircleIcon from "@mui/icons-material/CheckCircle";
 6 | 
 7 | import { Videos, Loader } from "./";
 8 | import { fetchFromAPI } from "../utils/fetchFromAPI";
 9 | 
10 | const VideoDetail = () => {
11 |   const [videoDetail, setVideoDetail] = useState(null);
12 |   const [videos, setVideos] = useState(null);
13 |   const { id } = useParams();
14 | 
15 |   useEffect(() => {
16 |     fetchFromAPI(`videos?part=snippet,statistics&id=${id}`)
17 |       .then((data) => setVideoDetail(data.items[0]))
18 | 
19 |     fetchFromAPI(`search?part=snippet&relatedToVideoId=${id}&type=video`)
20 |       .then((data) => setVideos(data.items))
21 |   }, [id]);
22 | 
23 |   if(!videoDetail?.snippet) return <Loader />;
24 | 
25 |   const { snippet: { title, channelId, channelTitle }, statistics: { viewCount, likeCount } } = videoDetail;
26 | 
27 |   return (
28 |     <Box minHeight="95vh">
29 |       <Stack direction={{ xs: "column", md: "row" }}>
30 |         <Box flex={1}>
31 |           <Box sx={{ width: "100%", position: "sticky", top: "86px" }}>
32 |             <ReactPlayer url={`https://www.youtube.com/watch?v=${id}`} className="react-player" controls />
33 |             <Typography color="#fff" variant="h5" fontWeight="bold" p={2}>
34 |               {title}
35 |             </Typography>
36 |             <Stack direction="row" justifyContent="space-between" sx={{ color: "#fff" }} py={1} px={2} >
37 |               <Link to={`/channel/${channelId}`}>
38 |                 <Typography variant={{ sm: "subtitle1", md: 'h6' }}  color="#fff" >
39 |                   {channelTitle}
40 |                   <CheckCircleIcon sx={{ fontSize: "12px", color: "gray", ml: "5px" }} />
41 |                 </Typography>
42 |               </Link>
43 |               <Stack direction="row" gap="20px" alignItems="center">
44 |                 <Typography variant="body1" sx={{ opacity: 0.7 }}>
45 |                   {parseInt(viewCount).toLocaleString()} views
46 |                 </Typography>
47 |                 <Typography variant="body1" sx={{ opacity: 0.7 }}>
48 |                   {parseInt(likeCount).toLocaleString()} likes
49 |                 </Typography>
50 |               </Stack>
51 |             </Stack>
52 |           </Box>
53 |         </Box>
54 |         <Box px={2} py={{ md: 1, xs: 5 }} justifyContent="center" alignItems="center" >
55 |           <Videos videos={videos} direction="column" />
56 |         </Box>
57 |       </Stack>
58 |     </Box>
59 |   );
60 | };
61 | 
62 | export default VideoDetail;
63 | 


--------------------------------------------------------------------------------
/ReactProject/YoutubeClone/src/components/Videos.jsx:
--------------------------------------------------------------------------------
 1 | import React from "react";
 2 | import { Stack, Box } from "@mui/material";
 3 | 
 4 | import { ChannelCard, Loader, VideoCard } from "./";
 5 | 
 6 | const Videos = ({ videos, direction }) => {
 7 |   if(!videos?.length) return <Loader />;
 8 |   
 9 |   return (
10 |     <Stack direction={direction || "row"} flexWrap="wrap" justifyContent="start" alignItems="start" gap={2}>
11 |       {videos.map((item, idx) => (
12 |         <Box key={idx}>
13 |           {item.id.videoId && <VideoCard video={item} /> }
14 |           {item.id.channelId && <ChannelCard channelDetail={item} />}
15 |         </Box>
16 |       ))}
17 |     </Stack>
18 |   );
19 | }
20 | 
21 | export default Videos;
22 | 


--------------------------------------------------------------------------------
/ReactProject/YoutubeClone/src/components/index.js:
--------------------------------------------------------------------------------
 1 | export { default as ChannelCard } from './ChannelCard';
 2 | export { default as VideoCard } from './VideoCard';
 3 | export { default as ChannelDetail } from './ChannelDetail';
 4 | export { default as Feed } from './Feed';
 5 | export { default as Loader } from './Loader';
 6 | export { default as Navbar } from './Navbar';
 7 | export { default as SearchBar } from './SearchBar';
 8 | export { default as VideoDetail } from './VideoDetail';
 9 | export { default as SearchFeed } from './SearchFeed';
10 | export { default as Videos } from './Videos';
11 | export { default as Sidebar } from './Sidebar';
12 | 


--------------------------------------------------------------------------------
/ReactProject/YoutubeClone/src/index.css:
--------------------------------------------------------------------------------
 1 | html,
 2 | body {
 3 |   margin: 0;
 4 |   padding: 0;
 5 |   box-sizing: border-box;
 6 | }
 7 | 
 8 | a {
 9 |   text-decoration: none;
10 |   color: black;
11 | }
12 | 
13 | ::-webkit-scrollbar {
14 |   width: 0px;
15 |   height: 5px;
16 | }
17 | 
18 | ::-webkit-scrollbar-thumb {
19 |   background-color: rgb(114, 113, 113);
20 |   border-radius: 10px;
21 |   height: 200px;
22 | }
23 | 
24 | ::-webkit-scrollbar-track {
25 |   background-color: transparent;
26 | }
27 | 
28 | .category-btn:hover {
29 |   background-color: #FC1503 !important;
30 |   color: white !important;
31 | }
32 | 
33 | .category-btn:hover span{
34 |   color: white !important;
35 | }
36 | 
37 | .react-player {
38 |   height: 77vh !important;
39 |   width: 100% !important;
40 | }
41 | 
42 | .search-bar{
43 |   border:none;
44 |   outline:none;
45 |   width:350px;
46 | }
47 | 
48 | .category-btn{
49 |   font-weight: bold !important;
50 |   text-transform: capitalize;
51 |   display: flex;
52 |   align-items: center;
53 |   justify-content: start;
54 |   cursor:pointer;
55 |   background: transparent;
56 |   outline: none;
57 |   border: none;
58 | 
59 |   padding: 7px 15px;
60 |   margin: 10px 0px;
61 |   border-radius: 20px;
62 |   transition: all 0.3s ease;
63 | }
64 | 
65 | @media screen and (max-width: 900px) {
66 |   .category-btn{
67 |     margin: 10px;
68 |   }
69 | }
70 | 
71 | @media screen and (max-width:800px){
72 |   .copyright{
73 |     display:none !important;
74 |   }
75 | }
76 | 
77 | @media screen and (max-width: 600px) {
78 |   .scroll-horizontal {
79 |     overflow: auto !important;
80 |   }
81 | 
82 |   .react-player {
83 |     height: 45vh !important;
84 |   }
85 |   .search-bar{
86 |     width:200px;
87 |   }
88 | }


--------------------------------------------------------------------------------
/ReactProject/YoutubeClone/src/index.js:
--------------------------------------------------------------------------------
 1 | import React from 'react';
 2 | import ReactDOM from 'react-dom/client';
 3 | 
 4 | import App from './App';
 5 | import './index.css';
 6 | 
 7 | const root = ReactDOM.createRoot(document.getElementById('root'));
 8 | 
 9 | root.render(<App />);
10 | 


--------------------------------------------------------------------------------
/ReactProject/YoutubeClone/src/utils/constants.js:
--------------------------------------------------------------------------------
 1 | import MusicNoteIcon from '@mui/icons-material/MusicNote';
 2 | import HomeIcon from '@mui/icons-material/Home';
 3 | import CodeIcon from '@mui/icons-material/Code';
 4 | import OndemandVideoIcon from '@mui/icons-material/OndemandVideo';
 5 | import SportsEsportsIcon from '@mui/icons-material/SportsEsports';
 6 | import LiveTvIcon from '@mui/icons-material/LiveTv';
 7 | import SchoolIcon from '@mui/icons-material/School';
 8 | import FaceRetouchingNaturalIcon from '@mui/icons-material/FaceRetouchingNatural';
 9 | import CheckroomIcon from '@mui/icons-material/Checkroom';
10 | import GraphicEqIcon from '@mui/icons-material/GraphicEq';
11 | import TheaterComedyIcon from '@mui/icons-material/TheaterComedy';
12 | import FitnessCenterIcon from '@mui/icons-material/FitnessCenter';
13 | import DeveloperModeIcon from '@mui/icons-material/DeveloperMode';
14 | import FaceIcon from '@mui/icons-material/Face';
15 | import CurrencyExchangeIcon from '@mui/icons-material/CurrencyExchange';
16 | export const logo = 'https://i.ibb.co/s9Qys2j/logo.png';
17 | 
18 | export const categories = [
19 |   { name: 'New', icon: <HomeIcon />, },
20 |   { name: 'MrBeast', icon: <FaceIcon />, },
21 |   { name: 'Raj Shamani', icon: <CurrencyExchangeIcon />, },
22 |   { name: 'BB ki Vines', icon: <CodeIcon />, },
23 |   { name: 'NextJS', icon: <CodeIcon />, },
24 |   { name: 'Music', icon: <MusicNoteIcon /> },
25 |   { name: 'Education', icon: <SchoolIcon />, },
26 |   { name: 'Podcast', icon: <GraphicEqIcon />, },
27 |   { name: 'Movie', icon: <OndemandVideoIcon />, },
28 |   { name: 'Gaming', icon: <SportsEsportsIcon />, },
29 |   { name: 'Live', icon: <LiveTvIcon />, },
30 |   { name: 'Sport', icon: <FitnessCenterIcon />, },
31 |   { name: 'Fashion', icon: <CheckroomIcon />, },
32 |   { name: 'Beauty', icon: <FaceRetouchingNaturalIcon />, },
33 |   { name: 'Comedy', icon: <TheaterComedyIcon />, },
34 |   { name: 'Gym', icon: <FitnessCenterIcon />, },
35 |   { name: 'Crypto', icon: <DeveloperModeIcon />, },
36 | ];
37 | 
38 | export const demoThumbnailUrl = 'https://i.ibb.co/G2L2Gwp/API-Course.png';
39 | export const demoChannelUrl = '/channel/UCmXmlB4-HJytD7wek0Uo97A';
40 | export const demoVideoUrl = '/video/GDa8kZLNhJ4';
41 | export const demoChannelTitle = 'JavaScript Mastery';
42 | export const demoVideoTitle = 'Build and Deploy 5 JavaScript & React API Projects in 10 Hours - Full Course | RapidAPI';
43 | export const demoProfilePicture = 'http://dergipark.org.tr/assets/app/images/buddy_sample.png'


--------------------------------------------------------------------------------
/ReactProject/YoutubeClone/src/utils/fetchFromAPI.js:
--------------------------------------------------------------------------------
 1 | import axios from 'axios';
 2 | 
 3 | export const BASE_URL = 'https://youtube-v31.p.rapidapi.com';
 4 | 
 5 | const options = {
 6 |   params: {
 7 |     maxResults: 50,
 8 |   },
 9 |   headers: {
10 |     'X-RapidAPI-Key': process.env.REACT_APP_RAPID_API_KEY,
11 |     'X-RapidAPI-Host': 'youtube-v31.p.rapidapi.com',
12 |   },
13 | };
14 | 
15 | export const fetchFromAPI = async (url) => {
16 |   const { data } = await axios.get(`${BASE_URL}/${url}`, options);
17 | 
18 |   return data;
19 | };
20 | 


--------------------------------------------------------------------------------
/WebAnimations/.DS_Store:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/WebAnimations/.DS_Store


--------------------------------------------------------------------------------
/WebAnimations/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules


--------------------------------------------------------------------------------
/WebAnimations/README.md:
--------------------------------------------------------------------------------
 1 | # GSAP Animations Repository
 2 | 
 3 | Welcome to my GSAP (GreenSock Animation Platform) repository! This repository contains all the code snippets, projects, and experiments I have created while learning and exploring GSAP.
 4 | 
 5 | ## Table of Contents
 6 | 
 7 | - [Introduction](#introduction)
 8 | - [Installation](#installation)
 9 | - [Usage](#usage)
10 | - [Projects](#projects)
11 | - [Resources](#resources)
12 | - [Contributing](#contributing)
13 | - [License](#license)
14 | 
15 | ## Introduction
16 | 
17 | This repository is dedicated to showcasing my journey with GSAP, a powerful JavaScript library for creating animations. Here, you'll find various examples and projects that demonstrate different features and techniques of GSAP.
18 | 
19 | ## Installation
20 | 
21 | To run the examples and projects in this repository, you will need to have GSAP installed. You can include GSAP in your project using a CDN or by installing it via npm.
22 | 
23 | ### Using CDN
24 | 
25 | ```html
26 | <script src="https://cdnjs.cloudflare.com/ajax/libs/gsap/3.9.1/gsap.min.js"></script>
27 | ```
28 | ### using npm 
29 | ```
30 | npm i gsap
31 | ```
32 | 


--------------------------------------------------------------------------------
/WebAnimations/index.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html lang="en">
 3 |   <head>
 4 |     <meta charset="UTF-8" />
 5 |     <link rel="icon" type="image/svg+xml" href="/vite.svg" />
 6 |     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
 7 |     <title>Vite + React</title>
 8 |   </head>
 9 |   <body>
10 |     <div id="root"></div>
11 |     <script type="module" src="/src/main.jsx"></script>
12 |   </body>
13 | </html>
14 | 


--------------------------------------------------------------------------------
/WebAnimations/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "my-gsap-proect",
 3 |   "private": true,
 4 |   "version": "0.0.0",
 5 |   "type": "module",
 6 |   "scripts": {
 7 |     "dev": "vite",
 8 |     "build": "vite build",
 9 |     "lint": "eslint . --ext js,jsx --report-unused-disable-directives --max-warnings 0",
10 |     "preview": "vite preview"
11 |   },
12 |   "dependencies": {
13 |     "@gsap/react": "^2.1.1",
14 |     "gsap": "^3.12.5",
15 |     "react": "^18.3.1",
16 |     "react-dom": "^18.3.1",
17 |     "react-router-dom": "^6.24.0"
18 |   },
19 |   "devDependencies": {
20 |     "@types/react": "^18.3.3",
21 |     "@types/react-dom": "^18.3.0",
22 |     "@vitejs/plugin-react": "^4.3.1",
23 |     "autoprefixer": "^10.4.19",
24 |     "eslint": "^8.57.0",
25 |     "eslint-plugin-react": "^7.34.2",
26 |     "eslint-plugin-react-hooks": "^4.6.2",
27 |     "eslint-plugin-react-refresh": "^0.4.7",
28 |     "postcss": "^8.4.39",
29 |     "tailwindcss": "^3.4.4",
30 |     "vite": "^5.3.1"
31 |   }
32 | }
33 | 


--------------------------------------------------------------------------------
/WebAnimations/postcss.config.js:
--------------------------------------------------------------------------------
1 | export default {
2 |   plugins: {
3 |     tailwindcss: {},
4 |     autoprefixer: {},
5 |   },
6 | }
7 | 


--------------------------------------------------------------------------------
/WebAnimations/public/vite.svg:
--------------------------------------------------------------------------------
1 | <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="31.88" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 257"><defs><linearGradient id="IconifyId1813088fe1fbc01fb466" x1="-.828%" x2="57.636%" y1="7.652%" y2="78.411%"><stop offset="0%" stop-color="#41D1FF"></stop><stop offset="100%" stop-color="#BD34FE"></stop></linearGradient><linearGradient id="IconifyId1813088fe1fbc01fb467" x1="43.376%" x2="50.316%" y1="2.242%" y2="89.03%"><stop offset="0%" stop-color="#FFEA83"></stop><stop offset="8.333%" stop-color="#FFDD35"></stop><stop offset="100%" stop-color="#FFA800"></stop></linearGradient></defs><path fill="url(#IconifyId1813088fe1fbc01fb466)" d="M255.153 37.938L134.897 252.976c-2.483 4.44-8.862 4.466-11.382.048L.875 37.958c-2.746-4.814 1.371-10.646 6.827-9.67l120.385 21.517a6.537 6.537 0 0 0 2.322-.004l117.867-21.483c5.438-.991 9.574 4.796 6.877 9.62Z"></path><path fill="url(#IconifyId1813088fe1fbc01fb467)" d="M185.432.063L96.44 17.501a3.268 3.268 0 0 0-2.634 3.014l-5.474 92.456a3.268 3.268 0 0 0 3.997 3.378l24.777-5.718c2.318-.535 4.413 1.507 3.936 3.838l-7.361 36.047c-.495 2.426 1.782 4.5 4.151 3.78l15.304-4.649c2.372-.72 4.652 1.36 4.15 3.788l-11.698 56.621c-.732 3.542 3.979 5.473 5.943 2.437l1.313-2.028l72.516-144.72c1.215-2.423-.88-5.186-3.54-4.672l-25.505 4.922c-2.396.462-4.435-1.77-3.759-4.114l16.646-57.705c.677-2.35-1.37-4.583-3.769-4.113Z"></path></svg>


--------------------------------------------------------------------------------
/WebAnimations/src/App.jsx:
--------------------------------------------------------------------------------
  1 | import { createBrowserRouter , Link } from "react-router-dom";
  2 | import BasicAnimation from './BasicAnimation';
  3 | import TextAnimation from './TextAnimation';
  4 | import MoreAnimation from "./MoreAnimation";
  5 | import TimeLine from "./TimeLine";
  6 | import FadeAnimtion from "./FadeAnimtion";
  7 | import ScrollAnimation from "./ScrollAnimation";
  8 | import ScrollAnim2 from "./ScrollAnim2";
  9 | import SvgAnimation from "./SvgAnimation";
 10 | 
 11 | 
 12 | function App() {
 13 | 
 14 |   return (
 15 |     <>
 16 |       <div className="App">
 17 | 
 18 | 
 19 |         <h1 className='text-center  mt-2 text-8xl uppercase'>gsap learning</h1>
 20 | 
 21 |         <div className="topicList">
 22 | 
 23 |           <h1 className="uppercase text-xl text-center font-serif">topic</h1>
 24 | 
 25 |           <ul className="list-decimal p-2 cursor-pointer">
 26 |             <li>
 27 |               <Link to='/topic-1'>
 28 |                 <h2 className='my-4'>Basic animations of gsap</h2>
 29 |               </Link>
 30 |             </li>
 31 |             <li>
 32 |               <Link to='/topic-2'>
 33 |                 <h2 className='my-4'>text animation</h2>
 34 |               </Link>
 35 |             </li>
 36 |             <li>
 37 |               <Link to='/topic-3'>
 38 |                 <h2 className='my-4'>Box animation</h2>
 39 |               </Link>
 40 |             </li>
 41 |             <li>
 42 |               <Link to='/topic-4'>
 43 |                 <h2 className='my-4'>TimeLine in gsap</h2>
 44 |               </Link>
 45 |             </li>
 46 |             <li>
 47 |               <Link to='/topic-5'>
 48 |                 <h2 className='my-4'>text fade in gsap</h2>
 49 |               </Link>
 50 |             </li>
 51 |             <li>
 52 |               <Link to='/topic-6'>
 53 |                 <h2 className='my-4'> scroll trigger in gsap</h2>
 54 |               </Link>
 55 |             </li>
 56 |             <li>
 57 |               <Link to='/topic-7'>
 58 |                 <h2 className='my-4'>scroll animation 2</h2>
 59 |               </Link>
 60 |             </li>
 61 | 
 62 |             <li>
 63 |               <Link to='/topic-8'>
 64 |                 <h2 className='my-4'>svg animation </h2>
 65 |               </Link>
 66 |             </li>
 67 |           </ul>
 68 |          
 69 | 
 70 |           
 71 |           
 72 |           
 73 |           
 74 |           
 75 |           
 76 | 
 77 | 
 78 |           
 79 |         </div>
 80 |               
 81 | 
 82 | 
 83 |       </div>
 84 | 
 85 | 
 86 |     </>
 87 |   )
 88 | }
 89 | 
 90 | 
 91 | const router = createBrowserRouter([
 92 |   {
 93 |     path:'/',
 94 |     element:<App/>
 95 |   },
 96 |   {
 97 |     path:'/topic-1',
 98 |     element:<BasicAnimation/>
 99 |   },
100 |   {
101 |     path: '/topic-2',
102 |     element: <TextAnimation/>
103 |   },{
104 |     path:'/topic-3',
105 |     element:<MoreAnimation/>
106 |   },{
107 |     path:"/topic-4",
108 |     element:<TimeLine/>
109 |   },{
110 |     path:"/topic-5",
111 |     element:<FadeAnimtion/>
112 |   },{
113 |     path:'/topic-6',
114 |     element:<ScrollAnimation/>
115 |   },{
116 |     path:'/topic-7',
117 |     element:<ScrollAnim2/>
118 |   },{
119 |     path:'/topic-8',
120 |     element:<SvgAnimation/>
121 |   }
122 | ])
123 | 
124 | export default router
125 | 


--------------------------------------------------------------------------------
/WebAnimations/src/BasicAnimation.jsx:
--------------------------------------------------------------------------------
 1 | import React  ,{useRef} from 'react'
 2 | import { gsap } from 'gsap/gsap-core';
 3 | import { useGSAP } from '@gsap/react';
 4 | 
 5 | 
 6 | gsap.registerPlugin(useGSAP);
 7 | const BasicAnimation = () => {
 8 | 
 9 |     const boxRef = useRef(null);
10 |     const circleRef = useRef(null);
11 |     const circle1Ref = useRef(null);
12 |     const circle2Ref = useRef(null);
13 | 
14 | 
15 |     //gsap animation starts
16 | 
17 |     useGSAP(()=>{
18 |         //start applying the gsap animations
19 |         
20 |         gsap.to(boxRef.current,{
21 |             x:1000,
22 |             duration:1,
23 |             delay:1
24 |         })
25 | 
26 |         gsap.to(circleRef.current, {
27 |             x: 1000,
28 |             duration: 1,
29 |             delay: 1
30 |         })
31 | 
32 |         gsap.to(circle1Ref.current,{
33 |             x: 1000,
34 |             y:200,
35 |             duration:2,
36 |             delay:2,
37 |             backgroundColor:"blue",
38 |             borderColor:"white",
39 |             borderWidth:2,
40 |             repeat:-1,
41 |             yoyo:true //to get the property like yoyo
42 |         })
43 | 
44 |         gsap.to(circle2Ref.current, {
45 |             x: 1000,
46 |             y: 200,
47 |             duration: 2,
48 |             delay: 2,
49 |             backgroundColor: "green",
50 |             borderColor: "white",
51 |             borderWidth: 2,
52 |             repeat: -1,
53 |             yoyo: true //to get the property like yoyo
54 |         })
55 | 
56 | 
57 |         
58 |     })
59 |   return (
60 |     <>
61 | 
62 |     <h1 className='text-center my-10 text-3xl uppercase'> basic animation of gsap</h1>
63 |           <div className="h-60 w-60 bg-red-700 my-6" ref={boxRef}  ></div>
64 | 
65 |           <div className="h-60 w-60 bg-red-700 rounded-full" ref={circleRef} ></div>
66 | 
67 |           <div className="h-60 w-60 my-6 bg-red-200 rounded-full" ref={circle1Ref} ></div>
68 | 
69 |           <div className="h-60 w-60 bg-red-300 rounded-full" ref={circle2Ref} ></div>
70 |     </>
71 |   )
72 | }
73 | 
74 | export default BasicAnimation


--------------------------------------------------------------------------------
/WebAnimations/src/FadeAnimtion.jsx:
--------------------------------------------------------------------------------
 1 | import React , {useRef} from 'react'
 2 | import { gsap } from 'gsap/gsap-core';
 3 | import {useGSAP} from '@gsap/react'
 4 | 
 5 | 
 6 | gsap.registerPlugin(useGSAP);
 7 | 
 8 | const FadeAnimtion = () => {
 9 | 
10 |     const h2=useRef(null);
11 | 
12 |     const h4=useRef(null);
13 | 
14 |     useGSAP(()=>{
15 |         const tl = gsap.timeline();
16 | 
17 |         tl.from(h2.current,{
18 |             opacity:0,
19 |             duration:1,
20 |             ease:"power2.out",
21 |             delay:0.5,
22 |             y:-30
23 |         })
24 | 
25 |         tl.from("h4",{
26 |             opacity: 0,
27 |             duration: 1,
28 |             ease: "power2.out",
29 |             delay: 0.5,
30 |             y: -30,
31 |             stagger:1,
32 |         })
33 | 
34 |         tl.from("p",{
35 |             opacity: 0,
36 |             duration: 1,
37 |             ease: "power2.out",
38 |             delay: 0.5,
39 |             y: -60,
40 |         })
41 | 
42 |         tl.to("p",{
43 |             scaleX:1.5
44 |         })
45 |     })
46 | 
47 |   return (
48 |     <>
49 | 
50 |     <div className="flex items-center justify-between p-6 text-lg">
51 | 
52 |         <h2 ref={h2} className='capitalize'>logo</h2>
53 | 
54 |         <div className="flex gap-7 text-lg capitalize">
55 |             <h4 ref={h4}>home</h4>
56 |             <h4 ref={h4}>courses</h4>
57 |             <h4 ref={h4}>about</h4>
58 |             <h4 ref={h4}>contact us</h4>
59 |         </div>
60 |     </div>
61 | 
62 | 
63 |           <p className='absolute top-1/2 left-1/2 transform -translate-x-1/2 -translate-y-1/2 text-3xl uppercase'>
64 |               hola coder's
65 |           </p>
66 | 
67 |     
68 |     </>
69 |   )
70 | }
71 | 
72 | export default FadeAnimtion


--------------------------------------------------------------------------------
/WebAnimations/src/MoreAnimation.jsx:
--------------------------------------------------------------------------------
 1 | import React , {useRef} from 'react'
 2 | import { gsap } from 'gsap/gsap-core';
 3 | import { useGSAP } from '@gsap/react';
 4 | 
 5 | const MoreAnimation = () => {
 6 | 
 7 |     const box1 = useRef(null);
 8 |     const box2 = useRef(null);
 9 |     const box3 = useRef(null);
10 | 
11 |     gsap.registerPlugin(useGSAP);
12 | 
13 |     useGSAP(()=>{
14 | 
15 |         //animation 1
16 |         gsap.to(box1.current,{
17 |             duration:2,
18 |             delay:1,
19 |             rotation:"+=360", 
20 |             x:1200 , 
21 |             backgroundColor:"green",
22 |             repeat:-1,//it tells about how many time you wanto repeat this animation
23 |             yoyo:true, //to shows a property like yoyo
24 |             scale:2
25 |         });
26 | 
27 | 
28 |         gsap.from(box2.current,{
29 |             duration:3,
30 |             rotation:"-=360",
31 |             y:100 , 
32 |             x:1200 , 
33 |             backgroundColor:"yellow",
34 |             scale:0.5,
35 |             repeat:-1,
36 |             yoyo:true
37 |         })
38 | 
39 | 
40 |         gsap.to(box3.current, {
41 |             duration: 2,
42 |             rotation: "-=360",
43 |             y: 100,
44 |             x: 1200,
45 |             backgroundColor: "orange",
46 |             scale:3,
47 |             repeat: -1,
48 |             yoyo: true
49 |         })
50 | 
51 |     })
52 | 
53 |   return (
54 |     <>
55 | 
56 |           <h1 className='text-center my-10 text-3xl uppercase'> box animation of gsap</h1>
57 |           <div className="box1 h-[100px] w-[100px] bg-blue-500 my-5" ref={box1}></div>
58 |           <div className="box2 h-[100px] w-[100px] bg-blue-600 my-5" ref={box2} ></div>
59 |           <div className="box3 h-[100px] w-[100px] bg-blue-700 my-5" ref={box3} ></div>
60 |     
61 |     </>
62 |   )
63 | }
64 | 
65 | export default MoreAnimation


--------------------------------------------------------------------------------
/WebAnimations/src/ScrollAnim2.jsx:
--------------------------------------------------------------------------------
 1 | import React from 'react'
 2 | import { gsap } from 'gsap/gsap-core'
 3 | import {useGSAP}  from '@gsap/react'
 4 | import { ScrollTrigger } from 'gsap/ScrollTrigger'
 5 | 
 6 | 
 7 | 
 8 | gsap.registerPlugin(useGSAP,ScrollTrigger);
 9 | 
10 | 
11 | 
12 | const ScrollAnim2 = () => {
13 | 
14 |     useGSAP(()=>{
15 |         gsap.from("#page1 .firstText",{
16 |             opacity:0,
17 |             duration:2,
18 |             scale:3,
19 |             delay:0.5
20 | 
21 |         })
22 | 
23 |         gsap.from("#page2 .secondText", {
24 |             opacity: 0,
25 |             duration: 1,
26 |             scale: 3,
27 |             scrollTrigger:{
28 |                 trigger:'#page2 .secondText',
29 |                 markers:true,
30 |                 scrub:2, //used to sync our animation with the scroll,
31 |             }
32 | 
33 |         })
34 | 
35 | 
36 | 
37 |         gsap.to('#page3 .thirdText',{
38 |             duration:3,
39 |             transform:"translateX(-100%)",
40 |             scrollTrigger:{
41 |                 trigger:"#page3", //if you have used pin then you need to trigger the parent of the element at which you have applied animation
42 |                 scroller:"body",
43 |                 markers:true,
44 |                 start:'top 0%',
45 |                 end:'top -100%',
46 |                 scrub:2,
47 |                 pin:true //pin is used to pin a specific part until the animation is over
48 | 
49 | 
50 |             }
51 | 
52 |         })
53 |     })
54 |   return (
55 |     <>
56 | 
57 |           <div id="page1" className="min-h-screen w-full bg-slate-500 flex justify-center items-center">
58 |               <h1 className='firstText text-4xl'>Hola developer's </h1>
59 |           </div>
60 | 
61 |           <div id='page2' className="min-h-screen w-full bg-slate-600 flex justify-center items-center">
62 |               <h1 className='secondText text-4xl'>hope you are doing well !!</h1>
63 |           </div>
64 | 
65 |           <div id='page3' className="page1 min-h-screen w-full bg-slate-700">
66 |               <h1 className='thirdText text-[20vw] w-full text-nowrap  font-semibold'>how's you buddy</h1>
67 |           </div>
68 | 
69 |           <div id='page4' className="page1 min-h-screen w-full bg-slate-800 flex justify-center items-center">
70 |               <h1 className='fourthText  text-nowrap overflow-x-hidden font-semibold'>the end</h1>
71 |           </div>
72 |     
73 |     </>
74 |   )
75 | }
76 | 
77 | export default ScrollAnim2


--------------------------------------------------------------------------------
/WebAnimations/src/ScrollAnimation.jsx:
--------------------------------------------------------------------------------
 1 | import React from 'react'
 2 | import { gsap } from 'gsap/gsap-core'
 3 | import {useGSAP} from '@gsap/react'
 4 | import { ScrollTrigger } from 'gsap/ScrollTrigger'
 5 | 
 6 | 
 7 | //always register the plugin before using it
 8 | gsap.registerPlugin(useGSAP,ScrollTrigger);
 9 | 
10 | const ScrollAnimation = () => {
11 | 
12 |     // the scroll trigger is a property in gsap where we want to trigger an animation  only when we reach at the animation other if we simply appply animation to both box as shown below then both the animation occur at the same time and when scroll to the page2 then we cant see the animation of box2.
13 | 
14 |     
15 | 
16 |     useGSAP(()=>{
17 |         gsap.to("#page1 #box1",{
18 |             duration:2,
19 |             rotate:"+=360",
20 | 
21 |             
22 |         })
23 | 
24 |         gsap.to("#page2 #box2", {
25 |             duration: 2,
26 |             rotate: "+=360",
27 |             scrollTrigger:{
28 |                 trigger:'#page2 #box2', //write that which you want to target at the time of scroll
29 |                 scroller:'body',
30 |                 markers:true,
31 |                 start:"top 70%"
32 |             }
33 | 
34 | 
35 |         })
36 |     })
37 |   return (
38 |    <>
39 | 
40 |    <h1 className='text-white text-center uppercase text-4xl'>scroll trigger in gsap</h1>
41 | 
42 |               <div id="page1" className="min-h-screen w-full bg-gray-500 flex justify-center items-center">
43 |                   <div id='box1' className="box h-[200px] w-[200px] bg-red-300"></div>
44 |               </div>
45 | 
46 |               <div id='page2' className="min-h-screen w-full bg-gray-600 flex justify-center items-center">
47 |                   <div id='box2' className="box h-[200px] w-[200px] bg-red-400"></div>
48 |               </div>
49 | 
50 |               <div id='page3' className="page1 min-h-screen w-full bg-gray-700 flex justify-center items-center">
51 |                   <div id='box3' className="box h-[200px] w-[200px] bg-red-500"></div>
52 |               </div>
53 | 
54 | 
55 |    
56 |    </>
57 |   )
58 | }
59 | 
60 | export default ScrollAnimation


--------------------------------------------------------------------------------
/WebAnimations/src/SvgAnimation.jsx:
--------------------------------------------------------------------------------
 1 | import React from 'react'
 2 | import { gsap } from 'gsap/gsap-core';
 3 | import {useGSAP} from '@gsap/react'
 4 | 
 5 | 
 6 | gsap.registerPlugin(useGSAP);
 7 | 
 8 | const SvgAnimation = () => {
 9 | 
10 |     var path = "M 10 100 Q 500 100 990 100";
11 |     var finalPath = "M 10 100 Q 500 100 990 100"; 
12 | 
13 |     const mouseEnter = (debs)=>{
14 |         path = `M 10 100 Q 500 ${debs.clientY} 990 100`
15 | 
16 |        gsap.to('svg path',{
17 |         attr:{d:path},
18 |         scrub:1
19 |        })
20 |         console.log(debs)
21 |         // console.log("mouse entered")
22 |     }
23 | 
24 | 
25 |     const mouseLeave = ()=>{
26 |         console.log("mouse leaved")
27 | 
28 |         gsap.to('svg path', {
29 |             attr: { d: finalPath }
30 |         })
31 |     }
32 | 
33 |   return (
34 |     <>
35 |     <div className="box1 border-2 border-white" >
36 |               <svg width="1090" height="260" className='bg-teal-200  border-2 border-pink-200' xmlns="http://www.w3.org/2000/svg"
37 |                   onMouseEnter={mouseEnter} onMouseLeave={mouseLeave}>
38 |                   <path className='border-2 border-green-300' d="M 10 100 Q 500 100 990 100" stroke="black" fill="transparent" />
39 |               </svg>
40 |             <svg width="1090" height="1000" className='bg-slate-600'>
41 |                 <path d='M10 10 Q 100 100 100'/>
42 | 
43 |             </svg>
44 | 
45 |     </div>
46 |     </>
47 |   )
48 | }
49 | 
50 | export default SvgAnimation
51 | 
52 | 
53 | 
54 | /* 
55 | svg basic to advanced guide ->
56 | 
57 | svg is basically a container which consist a content and the svg contain path.
58 | 
59 | path-> 
60 | 
61 | it's an elemet of the svg which is used to create line ,curve and arc.
62 | 1. path create complex shapes  by combinng mutliple straight line or curve.
63 | 2. the shape  of the svg image  is based on only one parameter of the path element that is d.The d attribute contains a series of commands and parameters used by those commands.
64 | 
65 | 
66 | 
67 | path of the svg image: 
68 | ---> here the M denote the move to point like from where we have to start (starting  point).
69 | ---> now there are two type of curve in path that are quadratic curve and cubic curve.
70 | ---> the quadratic curve is denoted by Q and cubic curve is denoted by C.
71 | 
72 | ---> this is how a quadraric curved is formed.
73 |        l hhbgggQ x1 y1, x y
74 | */


--------------------------------------------------------------------------------
/WebAnimations/src/TextAnimation.jsx:
--------------------------------------------------------------------------------
 1 | import React from 'react'
 2 | import { gsap } from 'gsap/gsap-core';
 3 | import { useGSAP } from '@gsap/react';
 4 | 
 5 | const TextAnimation = () => {
 6 |   
 7 |     gsap.registerPlugin(useGSAP);
 8 | 
 9 |     useGSAP(()=>{
10 |         gsap.to('h1',{
11 |             duration: 2,
12 |             delay:0.5,
13 |             y:50,
14 |             x:400,
15 |             opacity:0.3
16 |         })
17 | 
18 |         //from is nothing but just vice versa of the to mean whatever is happen in to the totaly oppsite happen in from
19 | 
20 |         gsap.from(".text",{
21 |             delay:1,
22 |             duration:3,
23 |             opacity:0,
24 |             y:-100,
25 |             stagger:2, //use when you have to apply the animation one after other on the element
26 |             
27 | 
28 |         })
29 |     })
30 |   return (
31 |     <>
32 | 
33 |       <h4 className='text-center my-10 text-3xl uppercase'> text animation of gsap</h4>
34 |           <h1 className='text-lg font-semibold' >this is the tutorial of GSAP</h1>
35 |         <h1 className='text-lg font-semibold' >gsap is ananimation library</h1>
36 |         <h1 className='text-lg font-semibold'>we can create multiple animation using that</h1>
37 | 
38 |         <h2 className='my-16 text-2xl capitalize'>for property of the gsap</h2>
39 | 
40 |         <h3 className='text my-2 text-lg font-bold capitalize'>Lorem ipsum dolor sit amet consectetur adipisicing elit. Odit dolorem rerum repudiandae?</h3>
41 |       <h3 className='text my-2 text-lg font-bold capitalize'>Lorem ipsum dolor sit, amet consectetur adipisicing elit. Doloremque nobis aut quos consectetur voluptas.</h3>
42 |       <h3 className='text my-2 text-lg font-bold capitalize'>Lorem ipsum dolor sit amet consectetur adipisicing elit. Aliquam maxime quidem adipisci deserunt nobis itaque aspernatur!</h3>
43 | 
44 |     </>
45 |   )
46 | }
47 | 
48 | export default TextAnimation


--------------------------------------------------------------------------------
/WebAnimations/src/TimeLine.jsx:
--------------------------------------------------------------------------------
 1 | import React, { useRef } from 'react'
 2 | import { gsap } from 'gsap/gsap-core';
 3 | import { useGSAP } from '@gsap/react';
 4 | 
 5 | const TimeLine = () => {
 6 | 
 7 |     const box1 = useRef(null);
 8 |     const box2 = useRef(null);
 9 |     const box3 = useRef(null);
10 |     const box4 = useRef(null);
11 |     const box5 = useRef(null);
12 |     const box6 = useRef(null);
13 | 
14 |     gsap.registerPlugin(useGSAP);
15 | 
16 |     useGSAP(()=>{
17 | 
18 |         // timeline is used when you want your animation to run after the previous animation is finish or executed
19 |         const tl = gsap.timeline();
20 | 
21 |         tl.to(box1.current, {
22 |             duration:2,
23 |             x: 800,
24 |             ease: "power2.out",
25 |             delay:0.5,
26 |             backgroundColor:"cadetBlue"
27 |         })
28 | 
29 |         tl.to(box2.current, {
30 |             duration:2,
31 |             x: 800,
32 |             ease: "power2.out",
33 |             delay: 0.5,
34 |             backgroundColor:"CornflowerBlue"
35 |         })
36 | 
37 |         tl.to(box3.current, {
38 |             duration: 2,
39 |             x: 800,
40 |             ease: "power2.out",
41 |             delay: 0.5,
42 |             backgroundColor:"CornflowerBlue"
43 |         })
44 | 
45 |         tl.from(box4.current, {
46 |             duration: 2,
47 |             x: 800,
48 |             ease: "power2.out",
49 |             delay: 0.5,
50 |             backgroundColor: "CornflowerBlue"
51 |         })
52 | 
53 |         tl.from(box5.current, {
54 |             duration: 2,
55 |             x: 800,
56 |             ease: "power2.out",
57 |             delay: 0.5,
58 |             backgroundColor: "CornflowerBlue"
59 |         })
60 | 
61 |         tl.from(box6.current, {
62 |             duration: 2,
63 |             x: 800,
64 |             ease: "power2.out",
65 |             delay: 0.5,
66 |             backgroundColor: "CornflowerBlue"
67 |         })
68 | 
69 |     })
70 | 
71 |   return (
72 |     <>
73 | 
74 |           <h1 className='text-center my-10 text-3xl uppercase'> time line in gsap</h1>
75 | 
76 |           <div className="box1 h-[100px] w-[100px] bg-pink-100 my-5" ref={box1}></div>
77 |           <div className="box2 h-[100px] w-[100px] bg-pink-200 my-5" ref={box2} ></div>
78 |           <div className="box3 h-[100px] w-[100px] bg-pink-300 my-5" ref={box3} ></div>
79 | 
80 |           <div className="box1 h-[100px] w-[100px] bg-pink-400 my-5" ref={box4}></div>
81 |           <div className="box2 h-[100px] w-[100px] bg-pink-500 my-5" ref={box5} ></div>
82 |           <div className="box3 h-[100px] w-[100px] bg-pink-600 my-5" ref={box6} ></div>
83 |     
84 |     </>
85 |   )
86 | }
87 | 
88 | export default TimeLine


--------------------------------------------------------------------------------
/WebAnimations/src/index.css:
--------------------------------------------------------------------------------
 1 | @tailwind base;
 2 | @tailwind components;
 3 | @tailwind utilities;
 4 | 
 5 | 
 6 | html,body{
 7 |     background-color: black; 
 8 |     color: white;
 9 |     overflow-x: hidden;
10 | }
11 | 
12 | 
13 | .topicList{
14 |     position: absolute;
15 |     top: 50%;
16 |     left: 50%;
17 |     transform: translate(-50%, -50%);
18 |     padding: 20px;
19 |     height: 300px;
20 |     text-transform: uppercase;
21 |     overflow-y: scroll;
22 |     background:rgb(128, 128, 128);
23 |     border-radius: 12px;
24 | }
25 | 
26 | 
27 | 
28 | 
29 | 
30 | 
31 | 


--------------------------------------------------------------------------------
/WebAnimations/src/main.jsx:
--------------------------------------------------------------------------------
 1 | import React from 'react'
 2 | import ReactDOM from 'react-dom/client'
 3 | import './index.css'
 4 | import { RouterProvider } from 'react-router-dom'
 5 | import router from './App'
 6 | 
 7 | ReactDOM.createRoot(document.getElementById('root')).render(
 8 |   <React.StrictMode>
 9 |     <RouterProvider router={router}/> 
10 |   </React.StrictMode>,
11 | )
12 | 


--------------------------------------------------------------------------------
/WebAnimations/tailwind.config.js:
--------------------------------------------------------------------------------
 1 | /** @type {import('tailwindcss').Config} */
 2 | export default {
 3 |   content: [
 4 |     "./index.html",
 5 |     "./src/**/*.{js,ts,jsx,tsx}",
 6 |   ],
 7 |   theme: {
 8 |     extend: {},
 9 |   },
10 |   plugins: [],
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/WebAnimations/vite.config.js:
--------------------------------------------------------------------------------
1 | import { defineConfig } from 'vite'
2 | import react from '@vitejs/plugin-react'
3 | 
4 | // https://vitejs.dev/config/
5 | export default defineConfig({
6 |   plugins: [react()],
7 | })
8 | 


--------------------------------------------------------------------------------
/WebProjects/Food App/src/components/ui/button.js:
--------------------------------------------------------------------------------
 1 | const Button = ({ children, onClick, className, variant = "primary" }) => {
 2 |     const baseClasses = `py-2 px-4 rounded-md font-semibold focus:outline-none transition duration-300`;
 3 |     const variantClasses = variant === "primary"
 4 |       ? "bg-blue-600 text-white hover:bg-blue-700"
 5 |       : "bg-gray-300 text-gray-900 hover:bg-gray-400";
 6 |   
 7 |     return (
 8 |       <button className={`${baseClasses} ${variantClasses} ${className}`} onClick={onClick}>
 9 |         {children}
10 |       </button>
11 |     );
12 |   };
13 |   
14 |   export { Button };
15 |   


--------------------------------------------------------------------------------
/WebProjects/Food App/src/components/ui/card.js:
--------------------------------------------------------------------------------
 1 | const Card = ({ children, className }) => {
 2 |     return (
 3 |       <div className={`p-4 border rounded-lg shadow-md ${className}`}>
 4 |         {children}
 5 |       </div>
 6 |     );
 7 |   };
 8 |   
 9 |   const CardHeader = ({ children }) => {
10 |     return <div className="mb-2">{children}</div>;
11 |   };
12 |   
13 |   const CardContent = ({ children }) => {
14 |     return <div>{children}</div>;
15 |   };
16 |   
17 |   const CardFooter = ({ children }) => {
18 |     return <div className="mt-4">{children}</div>;
19 |   };
20 |   
21 |   const CardTitle = ({ children }) => {
22 |     return <h3 className="text-lg font-bold">{children}</h3>;
23 |   };
24 |   
25 |   export { Card, CardHeader, CardContent, CardFooter, CardTitle };
26 |   


--------------------------------------------------------------------------------
/WebProjects/Personal_Finance_Manger/Webpage 5/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 | <head>
 4 |     <meta charset="UTF-8">
 5 |     <meta name="viewport" content="width=device-width, initial-scale=1.0">
 6 |     <title>Personal Finance Manager</title>
 7 |     <link rel="stylesheet" href="styles.css">
 8 | </head>
 9 | <body>
10 |     <div class="container">
11 |         <h1>Personal Finance Manager</h1>
12 |         <div class="form-group">
13 |             <input type="text" id="expense-name" placeholder="Expense Name">
14 |             <input type="number" id="expense-amount" placeholder="Amount">
15 |             <button onclick="addExpense()">Add Expense</button>
16 |         </div>
17 |         <div class="expenses">
18 |             <h2>Expenses</h2>
19 |             <ul id="expense-list"></ul>
20 |         </div>
21 |     </div>
22 |     <script src="script.js"></script>
23 | </body>
24 | </html>


--------------------------------------------------------------------------------
/WebProjects/Personal_Finance_Manger/Webpage 5/script.js:
--------------------------------------------------------------------------------
 1 | let expenses = [];
 2 | 
 3 | function addExpense() {
 4 |     const name = document.getElementById('expense-name').value;
 5 |     const amount = document.getElementById('expense-amount').value;
 6 | 
 7 |     if (name && amount) {
 8 |         expenses.push({ name, amount: parseFloat(amount) });
 9 |         document.getElementById('expense-name').value = '';
10 |         document.getElementById('expense-amount').value = '';
11 |         renderExpenses();
12 |     } else {
13 |         alert('Please enter both name and amount');
14 |     }
15 | }
16 | 
17 | function renderExpenses() {
18 |     const expenseList = document.getElementById('expense-list');
19 |     expenseList.innerHTML = '';
20 | 
21 |     expenses.forEach(expense => {
22 |         const li = document.createElement('li');
23 |         li.innerHTML = `${expense.name} - $${expense.amount.toFixed(2)}`;
24 |         expenseList.appendChild(li);
25 |     });
26 | }


--------------------------------------------------------------------------------
/WebProjects/Personal_Finance_Manger/Webpage 5/styles.css:
--------------------------------------------------------------------------------
 1 | body {
 2 |     font-family: Arial, sans-serif;
 3 |     background-color: #f4f4f4;
 4 |     margin: 0;
 5 |     padding: 0;
 6 |     display: flex;
 7 |     justify-content: center;
 8 |     align-items: center;
 9 |     height: 100vh;
10 | }
11 | 
12 | .container {
13 |     background-color: #fff;
14 |     padding: 20px;
15 |     box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
16 |     border-radius: 8px;
17 |     width: 300px;
18 |     text-align: center;
19 | }
20 | 
21 | h1 {
22 |     margin-bottom: 20px;
23 | }
24 | 
25 | .form-group {
26 |     margin-bottom: 20px;
27 | }
28 | 
29 | input[type="text"], input[type="number"] {
30 |     width: calc(100% - 22px);
31 |     padding: 10px;
32 |     margin-bottom: 10px;
33 |     border: 1px solid #ddd;
34 |     border-radius: 4px;
35 | }
36 | 
37 | button {
38 |     padding: 10px 20px;
39 |     background-color: #28a745;
40 |     border: none;
41 |     color: white;
42 |     border-radius: 4px;
43 |     cursor: pointer;
44 | }
45 | 
46 | button:hover {
47 |     background-color: #218838;
48 | }
49 | 
50 | .expenses {
51 |     text-align: left;
52 | }
53 | 
54 | .expenses h2 {
55 |     margin-top: 0;
56 | }
57 | 
58 | ul {
59 |     list-style-type: none;
60 |     padding: 0;
61 | }
62 | 
63 | li {
64 |     background-color: #f9f9f9;
65 |     margin-bottom: 10px;
66 |     padding: 10px;
67 |     border: 1px solid #ddd;
68 |     border-radius: 4px;
69 |     display: flex;
70 |     justify-content: space-between;
71 | }


--------------------------------------------------------------------------------
/WebProjects/Web Calculator/icon/calculator-icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/WebProjects/Web Calculator/icon/calculator-icon.png


--------------------------------------------------------------------------------
/WebProjects/Web Calculator/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 | 
 4 | <head>
 5 |     <meta charset="UTF-8">
 6 |     <meta name="viewport" content="width=device-width, initial-scale=1.0">
 7 |     <meta name="description"
 8 |         content="Online calculater to calculate Addition,Substaction,Multiplication,Division and more....">
 9 |     <title>Online Calculator</title>
10 |     <link rel="stylesheet" href="style.css">
11 |     <link rel="icon" href="icon/calculator-icon.png">
12 | 
13 | </head>
14 | 
15 | <body>
16 |     <div class="calculator">
17 |         <div class="heading center">
18 |             <h1>Free online calculator</h1>
19 |         </div>
20 |         <div>
21 |             <div class="center">
22 |                 <textarea class="display" id="display" cols="30" rows="10" disabled></textarea>
23 |             </div>
24 |             <div class="hr-line"></div>
25 |             <div class="center">
26 |                 <input type="text" id="result" class="result" disabled>
27 |             </div>
28 |             <div class="center">
29 |                 <table>
30 |                     <tr>
31 |                         <td><button class="button square-button" style="background-color:#ff4901;">C</button></td>
32 |                         <td><button class="button square-button">/</button></td>
33 |                         <td><button class="button square-button">*</button></td>
34 |                         <td><button class="button square-button">-</button></td>
35 |                     </tr>
36 |                     <tr>
37 |                         <td><button class="button square-button">7</button></td>
38 |                         <td><button class="button square-button">8</button></td>
39 |                         <td><button class="button square-button">9</button></td>
40 |                         <td rowspan="2"><button class="button rectangle-vertical-button">+</button></td>
41 |                     </tr>
42 |                     <tr>
43 |                         <td><button class="button square-button">4</button></td>
44 |                         <td><button class="button square-button">5</button></td>
45 |                         <td><button class="button square-button">6</button></td>
46 |                     </tr>
47 |                     <tr>
48 |                         <td><button class="button square-button">1</button></td>
49 |                         <td><button class="button square-button">2</button></td>
50 |                         <td><button class="button square-button">3</button></td>
51 |                         <td rowspan="2"><button class="button rectangle-vertical-button">=</button></td>
52 |                     </tr>
53 |                     <tr>
54 |                         <td colspan="2"><button class="button rectangle-horizontal-button">0</button></td>
55 |                         <td><button class="button square-button">.</button></td>
56 |                     </tr>
57 |                 </table>
58 |             </div>
59 |         </div>
60 |         <script src="script.js"></script>
61 |     </div>
62 | </body>
63 | 
64 | </html>


--------------------------------------------------------------------------------
/WebProjects/Web Calculator/script.js:
--------------------------------------------------------------------------------
 1 | let display = '';
 2 | let input = document.querySelectorAll('.button');
 3 | Array.from(input).forEach((button) => {
 4 |     button.addEventListener('click', (f) => {
 5 |     
 6 | 
 7 | 
 8 |         if (f.target.innerHTML == '+' || f.target.innerHTML == '-' || f.target.innerHTML == '*' || f.target.innerHTML == '/') {
 9 |             display += '\n';
10 |         }
11 | 
12 |         if (f.target.innerHTML == '=') {
13 |             display = eval(display);
14 |             document.querySelector('textarea').value = display;
15 |         }
16 | 
17 |         else if (f.target.innerHTML == 'C') {
18 |             display = '';
19 |             document.querySelector('textarea').value = display;
20 | 
21 |         }
22 | 
23 |         else {
24 |             console.log(f.target);
25 |             display += f.target.innerHTML;
26 |             document.querySelector('textarea').value = display;
27 |         }
28 | 
29 |         let text = document.getElementById('display');
30 |         text.scrollTop = text.scrollHeight;
31 | 
32 |         let result = '';
33 |         if (display == '') { }
34 |         else {
35 |             result += '=';
36 |             result += eval(display);
37 |         }
38 |         document.querySelector('input').value = result;
39 | 
40 |     })
41 | });


--------------------------------------------------------------------------------
/WebProjects/Web Calculator/style.css:
--------------------------------------------------------------------------------
  1 | * {
  2 |     padding: 0px;
  3 |     margin: 0px;
  4 | }
  5 | 
  6 | body {
  7 |     background-color: #000000;
  8 | }
  9 | 
 10 | .calculator {
 11 |     height: 100vw;
 12 |     margin: auto;
 13 | }
 14 | 
 15 | .heading {
 16 |     font-family: 'Trebuchet MS', 'Lucida Sans Unicode', 'Lucida Grande', 'Lucida Sans', Arial, sans-serif;
 17 |     color: #ffffff;
 18 |     text-align: center;
 19 |     font-size: 150%;
 20 | }
 21 | 
 22 | .center {
 23 |     display: flex;
 24 |     justify-content: center;
 25 |     align-items: center;
 26 |     width: 50vh;
 27 |     margin: auto;
 28 | }
 29 | 
 30 | @media screen and (max-height:843px) {
 31 |     .center {
 32 |         width: 100vh;
 33 |     }
 34 | 
 35 | }
 36 | 
 37 | @media screen and (max-height:600px) {
 38 |     .center {
 39 |         width: 230vh;
 40 |     }
 41 | }
 42 | 
 43 | #display {
 44 |     font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
 45 |     color: #ffffff;
 46 |     height: 110px;
 47 |     width: 410px;
 48 |     font-size: 40px;
 49 |     padding: 5px;
 50 |     text-align: right;
 51 |     scroll-behavior: smooth;
 52 |     overflow: initial;
 53 |     resize: none;
 54 |     border-style: none;
 55 |     border-top-left-radius: 1.5rem;
 56 |     border-top-right-radius: 1.5rem;
 57 | }
 58 | 
 59 | #display::-webkit-scrollbar {
 60 |     display: none;
 61 | }
 62 | 
 63 | .hr-line {
 64 |     width: 410px;
 65 |     height: 1px;
 66 | }
 67 | 
 68 | #result {
 69 |     font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
 70 |     color: #ffffff;
 71 |     height: 60px;
 72 |     width: 410px;
 73 |     font-size: 40px;
 74 |     padding: 5px;
 75 |     text-align: right;
 76 |     margin-bottom: 20px;
 77 |     border-style: none;
 78 |     border-end-end-radius: 1.5rem;
 79 |     border-end-start-radius: 1.5rem;
 80 | 
 81 | }
 82 | 
 83 | .square-button {
 84 |     height: 100px;
 85 |     width: 100px;
 86 | }
 87 | 
 88 | .rectangle-vertical-button {
 89 |     height: 200px;
 90 |     width: 100px;
 91 | }
 92 | 
 93 | .rectangle-horizontal-button {
 94 |     height: 100px;
 95 |     width: 200px;
 96 | }
 97 | 
 98 | .button {
 99 |     background-color: #1a1919;
100 |     color: #ffffff;
101 |     margin: 3px;
102 |     font-size: 30px;
103 |     border-radius: 1.5rem;
104 |     box-shadow: 3px 3px #292929;
105 |     border-style: none;
106 |     transition: 150ms;
107 |     cursor: pointer;
108 | }
109 | 
110 | .button:active {
111 |     box-shadow: none;
112 |     transform: scale(0.98);
113 |     transition: 150ms;
114 | }


--------------------------------------------------------------------------------
/WebProjects/drumsticks/images/crash.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/WebProjects/drumsticks/images/crash.png


--------------------------------------------------------------------------------
/WebProjects/drumsticks/images/drumstick.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/WebProjects/drumsticks/images/drumstick.jpg


--------------------------------------------------------------------------------
/WebProjects/drumsticks/images/kick.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/WebProjects/drumsticks/images/kick.png


--------------------------------------------------------------------------------
/WebProjects/drumsticks/images/music.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/WebProjects/drumsticks/images/music.jpg


--------------------------------------------------------------------------------
/WebProjects/drumsticks/images/snare.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/WebProjects/drumsticks/images/snare.png


--------------------------------------------------------------------------------
/WebProjects/drumsticks/images/tom1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/WebProjects/drumsticks/images/tom1.png


--------------------------------------------------------------------------------
/WebProjects/drumsticks/images/tom2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/WebProjects/drumsticks/images/tom2.png


--------------------------------------------------------------------------------
/WebProjects/drumsticks/images/tom3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/WebProjects/drumsticks/images/tom3.png


--------------------------------------------------------------------------------
/WebProjects/drumsticks/images/tom4.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/WebProjects/drumsticks/images/tom4.png


--------------------------------------------------------------------------------
/WebProjects/drumsticks/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 | 
 4 | <head>
 5 |     <meta charset="UTF-8">
 6 |     <meta name="viewport" content="width=device-width, initial-scale=1.0">
 7 |     <title>Minimal Drum Kit</title>
 8 |     <link rel="stylesheet" href="styles.css">
 9 |     <link href="https://fonts.googleapis.com/css2?family=Poppins:wght@300;600&display=swap" rel="stylesheet">
10 | </head>
11 | 
12 | <body>
13 |     <div class="drum-container">
14 |         <h1>Drum Kit</h1>
15 |         <div class="circle-container">
16 |             <button class="drum-button W" id="W">W</button>
17 |             <button class="drum-button A" id="A">A</button>
18 |             <button class="drum-button S" id="S">S</button>
19 |             <button class="drum-button D" id="D">D</button>
20 |             <button class="drum-button J" id="J">J</button>
21 |             <button class="drum-button K" id="K">K</button>
22 |             <button class="drum-button L" id="L">L</button>
23 |         </div>
24 |     </div>
25 | 
26 |     <footer>
27 |         <p>Click or press the key to play the sound</p>
28 |     </footer>
29 | 
30 |     <script src="main.js"></script>
31 | </body>
32 | 
33 | </html>


--------------------------------------------------------------------------------
/WebProjects/drumsticks/main.js:
--------------------------------------------------------------------------------
 1 | let buttons = document.querySelectorAll(".drum-button");
 2 | 
 3 | for (let i = 0; i < buttons.length; i++) {
 4 |     let text = buttons[i].innerText;
 5 |     buttons[i].addEventListener("click", function () {
 6 |         makeSound(text);
 7 |         applyAnimation(text);
 8 |     });
 9 | }
10 | 
11 | document.addEventListener("keypress", function (event) {
12 |     let key = event.key.toUpperCase();
13 |     makeSound(key);
14 |     applyAnimation(key);
15 | });
16 | 
17 | function makeSound(text) {
18 |     switch (text) {
19 |         case 'A':
20 |             var audio = new Audio("sounds/crash.mp3");
21 |             audio.play();
22 |             break;
23 |         case 'W':
24 |             var audio = new Audio("sounds/snare.mp3");
25 |             audio.play();
26 |             break;
27 |         case 'S':
28 |             var audio = new Audio("sounds/tom-1.mp3");
29 |             audio.play();
30 |             break;
31 |         case 'D':
32 |             var audio = new Audio("sounds/tom-2.mp3");
33 |             audio.play();
34 |             break;
35 |         case 'J':
36 |             var audio = new Audio("sounds/tom-3.mp3");
37 |             audio.play();
38 |             break;
39 |         case 'K':
40 |             var audio = new Audio("sounds/tom-4.mp3");
41 |             audio.play();
42 |             break;
43 |         case 'L':
44 |             var audio = new Audio("sounds/kick-bass.mp3");
45 |             audio.play();
46 |             break;
47 |         default:
48 |             console.log("No audio file for this button");
49 |     }
50 | }
51 | 
52 | function applyAnimation(currentKey) {
53 |     let activeButton = document.querySelector("." + currentKey);
54 |     if (activeButton) {
55 |         activeButton.classList.add("pressed");
56 |         setTimeout(() => {
57 |             activeButton.classList.remove("pressed");
58 |         }, 100); // Removes the class after 100ms to simulate hover effect
59 |     } else {
60 |         console.log("No element found with class: " + currentKey);
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/WebProjects/drumsticks/sounds/crash.mp3:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/WebProjects/drumsticks/sounds/crash.mp3


--------------------------------------------------------------------------------
/WebProjects/drumsticks/sounds/kick-bass.mp3:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/WebProjects/drumsticks/sounds/kick-bass.mp3


--------------------------------------------------------------------------------
/WebProjects/drumsticks/sounds/snare.mp3:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/WebProjects/drumsticks/sounds/snare.mp3


--------------------------------------------------------------------------------
/WebProjects/drumsticks/sounds/tom-1.mp3:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/WebProjects/drumsticks/sounds/tom-1.mp3


--------------------------------------------------------------------------------
/WebProjects/drumsticks/sounds/tom-2.mp3:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/WebProjects/drumsticks/sounds/tom-2.mp3


--------------------------------------------------------------------------------
/WebProjects/drumsticks/sounds/tom-3.mp3:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/WebProjects/drumsticks/sounds/tom-3.mp3


--------------------------------------------------------------------------------
/WebProjects/drumsticks/sounds/tom-4.mp3:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/WebProjects/drumsticks/sounds/tom-4.mp3


--------------------------------------------------------------------------------
/WebProjects/drumsticks/styles.css:
--------------------------------------------------------------------------------
  1 | * {
  2 |     margin: 0;
  3 |     padding: 0;
  4 |     box-sizing: border-box;
  5 | }
  6 | 
  7 | body {
  8 |     background-color: #2c3e50;
  9 |     color: #ecf0f1;
 10 |     font-family: 'Poppins', sans-serif;
 11 |     display: flex;
 12 |     flex-direction: column;
 13 |     align-items: center;
 14 |     justify-content: center;
 15 |     min-height: 100vh;
 16 | }
 17 | 
 18 | h1 {
 19 |     font-size: 3rem;
 20 |     margin-bottom: 20px;
 21 | }
 22 | 
 23 | .drum-container {
 24 |     display: flex;
 25 |     flex-direction: column;
 26 |     align-items: center;
 27 | }
 28 | 
 29 | .circle-container {
 30 |     display: grid;
 31 |     grid-template-columns: repeat(3, 1fr);
 32 |     grid-template-rows: repeat(3, 1fr);
 33 |     gap: 20px;
 34 |     width: 320px;
 35 |     height: 320px;
 36 |     position: relative;
 37 |     justify-items: center;
 38 |     align-items: center;
 39 | }
 40 | 
 41 | .drum-button {
 42 |     width: 100px;
 43 |     height: 100px;
 44 |     border-radius: 20%;
 45 |     border: none;
 46 |     cursor: pointer;
 47 |     font-size: 2rem;
 48 |     font-weight: 600;
 49 |     color: white;
 50 |     box-shadow: 0 4px 15px rgba(0, 0, 0, 0.3);
 51 |     transition: all 0.3s ease;
 52 | }
 53 | 
 54 | .drum-button:hover, .drum-button.pressed {
 55 |     transform: scale(1.1);
 56 |     box-shadow: 0 6px 20px rgba(0, 0, 0, 0.4);
 57 |     background: linear-gradient(145deg, #cdd2d1, #bcdcd5);
 58 |     color: #000;
 59 | }
 60 | 
 61 | .W {
 62 |     background: linear-gradient(145deg, #bc1a9c, #a01692);
 63 | }
 64 | 
 65 | .A {
 66 |     background: linear-gradient(145deg, #bc681a, #a06216);
 67 | }
 68 | 
 69 | .S {
 70 |     background: linear-gradient(145deg, #7b1abc, #6d16a0);
 71 | }
 72 | 
 73 | .D {
 74 |     background: linear-gradient(145deg, #896e10, #7b7212);
 75 | }
 76 | 
 77 | .J {
 78 |     background: linear-gradient(145deg, #1a9cbc, #1689a0);
 79 | }
 80 | 
 81 | .K {
 82 |     background: linear-gradient(145deg, #1dbc1a, #49a016);
 83 | }
 84 | 
 85 | .L {
 86 |     background: linear-gradient(145deg, #333c9b, #2b2d8d);
 87 | }
 88 | 
 89 | .drum-button:active {
 90 |     transform: scale(0.95);
 91 |     background: linear-gradient(145deg, #16a085, #1abc9c);
 92 | }
 93 | 
 94 | footer {
 95 |     margin-top: 30px;
 96 |     font-size: 1.2rem;
 97 |     color: #bdc3c7;
 98 | }
 99 | 
100 | @media (max-width: 768px) {
101 |     .circle-container {
102 |         width: 240px;
103 |         height: 240px;
104 |     }
105 | 
106 |     .drum-button {
107 |         width: 80px;
108 |         height: 80px;
109 |         font-size: 1.5rem;
110 |     }
111 | 
112 |     h1 {
113 |         font-size: 2.5rem;
114 |     }
115 | }
116 | 


--------------------------------------------------------------------------------
/c++/Binary Search  in C++:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <vector>
 3 | using namespace std;
 4 | 
 5 | int binarySearch(const vector<int>& arr, int target) {
 6 |     int left = 0, right = arr.size() - 1;
 7 |     while (left <= right) {
 8 |         int mid = left + (right - left) / 2;
 9 |         if (arr[mid] == target) return mid;
10 |         if (arr[mid] < target) left = mid + 1;
11 |         else right = mid - 1;
12 |     }
13 |     return -1; // Target not found
14 | }
15 | 
16 | int main() {
17 |     vector<int> arr = {1, 2, 3, 4, 5};
18 |     int target = 3;
19 |     int result = binarySearch(arr, target);
20 |     cout << "Element found at index: " << result << endl;
21 |     return 0;
22 | }
23 | 


--------------------------------------------------------------------------------
/c++/BubbleSort.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <vector>
 3 | using namespace std;
 4 | 
 5 | void bubbleSort(vector<int>& arr) {
 6 |     int n = arr.size();
 7 |     for (int i = 0; i < n - 1; i++) {
 8 |         for (int j = 0; j < n - i - 1; j++) {
 9 |             if (arr[j] > arr[j + 1]) {
10 |                 swap(arr[j], arr[j + 1]);
11 |             }
12 |         }
13 |     }
14 | }
15 | 
16 | int main() {
17 |     int n;
18 |     cin >> n;
19 |     vector<int> arr(n);
20 |     
21 |     for (int i = 0; i < n; i++) {
22 |         cin >> arr[i];
23 |     }
24 |     
25 |     bubbleSort(arr);
26 |     
27 |     for (int i = 0; i < arr.size(); i++) {
28 |         cout << arr[i] << " ";
29 |     }
30 |     
31 |     return 0;
32 | }
33 | 


--------------------------------------------------------------------------------
/c++/Preorder Traversal on Binary Tree.cpp:
--------------------------------------------------------------------------------
 1 | // In this program we will perform Preorder traversal on a binary tree
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | class Node{
 7 | public:
 8 |   int val;
 9 |   Node* left;
10 |   Node* right;
11 | 
12 |   Node (int data){
13 |     val = data;
14 |     left = NULL;
15 |     right = NULL;
16 |   }
17 | };
18 | 
19 | Node* BuildTree(Node* &root){
20 | 
21 |   int data;
22 |   cout<<"Enter data:- ";
23 |   cin>> data;
24 | 
25 |   root = new Node (data);
26 | 
27 |   if (data == -1) return NULL;
28 | 
29 |   cout<<"Enter data in left of "<<data<<endl;
30 |   root->left = BuildTree(root->left);
31 | 
32 |   cout<<"Enter data in right of "<<data<<endl;
33 |   root->right = BuildTree(root->right);
34 | 
35 |   return root;
36 | 
37 | }
38 | 
39 | void Preorder(Node* &root){
40 |   
41 |   if (root == NULL) return;
42 |   
43 |   cout<<root->val<<" ";
44 |   
45 |   Preorder(root->left);
46 |   Preorder(root->right);
47 |   
48 | }
49 | 
50 | int main() {
51 |   Node* root = NULL;
52 |   BuildTree(root);
53 |   cout<<"Preorder Traversal:-";
54 |   Preorder(root);
55 | }
56 | 


--------------------------------------------------------------------------------
/cpp/.cph/.c++ algorithms.cpp_d5d7ec2e6847003f61b365350767f2e0.prob:
--------------------------------------------------------------------------------
1 | {"name":"Local: c++ algorithms","url":"/Users/rajasurya/Hacktoberfest2024/cpp/c++ algorithms.cpp","tests":[{"id":1727759729854,"input":"","output":""}],"interactive":false,"memoryLimit":1024,"timeLimit":3000,"srcPath":"/Users/rajasurya/Hacktoberfest2024/cpp/c++ algorithms.cpp","group":"local","local":true}


--------------------------------------------------------------------------------
/cpp/BST1.cpp:
--------------------------------------------------------------------------------
 1 | // C++ program to demonstrate insertion
 2 | // in a BST recursively.
 3 | #include <iostream>
 4 | using namespace std;
 5 |  
 6 | class BST {
 7 |     int data;
 8 |     BST *left, *right;
 9 |  
10 | public:
11 |  
12 |     // Parameterized constructor.
13 |     BST(int);
14 |  
15 |     // Insert function.
16 |     BST* Insert(BST*, int);
17 |  
18 |     // Inorder traversal.
19 |     void Inorder(BST*);
20 | }; 
21 | // Parameterized Constructor definition.
22 | BST ::BST(int value)
23 | {
24 |     data = value;
25 |     left = right = NULL;
26 | }
27 |  
28 | // Insert function definition.
29 | BST* BST ::Insert(BST* root, int value)
30 | {
31 |     if (!root) {
32 |         return new BST(value);
33 |     }
34 |  
35 |     // Insert data.
36 |     if (value > root->data) {
37 |         root->right = Insert(root->right, value);
38 |     }
39 |     else if (value < root->data){
40 |         root->left = Insert(root->left, value);
41 |     }
42 |     return root;
43 | }
44 | void BST ::Inorder(BST* root)
45 | {
46 |     if (!root) {
47 |         return;
48 |     }
49 |     Inorder(root->left);
50 |     cout << root->data << endl;
51 |     Inorder(root->right);
52 | }
53 |  
54 | // Driver code
55 | int main()
56 | {
57 |     BST b, *root = NULL;
58 |     root = b.Insert(root, 50);
59 |     b.Insert(root, 30);
60 |     b.Insert(root, 20);
61 |     b.Insert(root, 40);
62 |     b.Insert(root, 70);
63 |     b.Insert(root, 60);
64 |     b.Insert(root, 80);
65 |  
66 |     b.Inorder(root);
67 |     return 0;
68 | }


--------------------------------------------------------------------------------
/cpp/BT.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | class Node
 5 | {
 6 | public:
 7 |     int info;
 8 |     Node *left;
 9 |     Node *right;
10 |     Node(int ele)
11 |     {
12 |         info = ele;
13 |         left = NULL;
14 |         right = NULL;
15 |     }
16 | };
17 | 
18 | class Tree
19 | {
20 | 
21 | public:
22 |     Node *root;
23 |     Tree()
24 |     {
25 |         root = createBT();
26 |     }
27 |     Node *createBT()
28 |     {
29 |         int ele;
30 |         cout<<">";
31 |         cin>>ele;
32 |         if(ele==-1){
33 |             return NULL;
34 |         }
35 |         Node *temp=new Node(ele);
36 |         cout<<"Left of "<<ele<<": ";
37 |         temp->left=createBT();
38 |         cout<<"Right of "<<ele<<": ";
39 |         temp->right=createBT();
40 |     }
41 | 
42 |     void Inorder(Node *root)
43 |     {
44 |         if (root)
45 |         {
46 |             Inorder(root->left);
47 |             cout << root->info << endl;
48 |             Inorder(root->right);
49 |         }
50 |     }
51 | };
52 | 
53 | int main()
54 | {
55 |     Tree t;
56 |     t.Inorder(t.root);
57 | }


--------------------------------------------------------------------------------
/cpp/Bubblesort.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | void bubbleSort(vector<int>& arr) {
 5 |     int n = arr.size();
 6 |     bool swapped;
 7 |   
 8 |     for (int i = 0; i < n - 1; i++) {
 9 |         swapped = false;
10 |         for (int j = 0; j < n - i - 1; j++) {
11 |             if (arr[j] > arr[j + 1]) {
12 |                 swap(arr[j], arr[j + 1]);
13 |                 swapped = true;
14 |             }
15 |         }
16 |       
17 |         if (!swapped)
18 |             break;
19 |     }
20 | }
21 | 
22 | void printVector(const vector<int>& arr) {
23 |     for (int num : arr)
24 |         cout << " " << num;
25 | }
26 | 
27 | int main() {
28 |     vector<int> arr = { 64, 34, 25, 12, 22, 11, 90 };
29 |     bubbleSort(arr);
30 |     cout << "Sorted array: \n";
31 |     printVector(arr);
32 |     return 0;
33 | }
34 | 


--------------------------------------------------------------------------------
/cpp/Container_with_Most_Water.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <vector>
 3 | #include <algorithm>
 4 | 
 5 | using namespace std;
 6 | 
 7 | class Solution {
 8 | public:
 9 |     int maxArea(vector<int>& height) {
10 |         int left = 0;
11 |         int right = height.size() - 1;
12 |         int maxArea = 0;
13 | 
14 |         while (left < right) {
15 |             int currentArea = min(height[left], height[right]) * (right - left);
16 |             maxArea = max(maxArea, currentArea);
17 | 
18 |             if (height[left] < height[right]) {
19 |                 left++;
20 |             } else {
21 |                 right--;
22 |             }
23 |         }
24 | 
25 |         return maxArea;
26 |     }
27 | };
28 | 
29 | int main() {
30 |     Solution solution;
31 | 
32 |     // Example input: heights of the container walls
33 |     vector<int> height = {1, 8, 6, 2, 5, 4, 8, 3, 7};
34 | 
35 |     // Calling the maxArea function
36 |     int result = solution.maxArea(height);
37 | 
38 |     // Printing the result
39 |     cout << "The maximum area is: " << result << endl;
40 | 
41 |     return 0;
42 | }
43 | 


--------------------------------------------------------------------------------
/cpp/InsertionSort.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     int n, arr[n], temp;
 6 |     cout << "Enter size: ";
 7 |     cin >> n;
 8 |     cout << "\nEnter Elements: ";
 9 |     for (int i; i < n; i++)
10 |     {
11 |         cin >> arr[i];
12 |     }
13 |     cout << "\nAfter sorting: \n";
14 |     for (int i = 1; i < n; i++)
15 |     {
16 |         int j = i - 1;
17 |         temp = arr[i];
18 |         for (; j >= 0 && arr[j] > temp; j--)
19 |         {
20 |             arr[j+1]=arr[j];
21 |         }
22 |         arr[j+1]=temp;
23 |     }
24 |     for(int i=0;i<n;i++){
25 |         cout<<arr[i]<<" ";
26 |     }
27 | }


--------------------------------------------------------------------------------
/cpp/Kruskal.cpp:
--------------------------------------------------------------------------------
  1 | // C++ program for the above approach 
  2 | 
  3 | #include <bits/stdc++.h> 
  4 | using namespace std; 
  5 | 
  6 | // DSU data structure 
  7 | // path compression + rank by union 
  8 | class DSU { 
  9 | 	int* parent; 
 10 | 	int* rank; 
 11 | 
 12 | public: 
 13 | 	DSU(int n) 
 14 | 	{ 
 15 | 		parent = new int[n]; 
 16 | 		rank = new int[n]; 
 17 | 
 18 | 		for (int i = 0; i < n; i++) { 
 19 | 			parent[i] = -1; 
 20 | 			rank[i] = 1; 
 21 | 		} 
 22 | 	} 
 23 | 
 24 | 	// Find function 
 25 | 	int find(int i) 
 26 | 	{ 
 27 | 		if (parent[i] == -1) 
 28 | 			return i; 
 29 | 
 30 | 		return parent[i] = find(parent[i]); 
 31 | 	} 
 32 | 
 33 | 	// Union function 
 34 | 	void unite(int x, int y) 
 35 | 	{ 
 36 | 		int s1 = find(x); 
 37 | 		int s2 = find(y); 
 38 | 
 39 | 		if (s1 != s2) { 
 40 | 			if (rank[s1] < rank[s2]) { 
 41 | 				parent[s1] = s2; 
 42 | 			} 
 43 | 			else if (rank[s1] > rank[s2]) { 
 44 | 				parent[s2] = s1; 
 45 | 			} 
 46 | 			else { 
 47 | 				parent[s2] = s1; 
 48 | 				rank[s1] += 1; 
 49 | 			} 
 50 | 		} 
 51 | 	} 
 52 | }; 
 53 | 
 54 | class Graph { 
 55 | 	vector<vector<int> > edgelist; 
 56 | 	int V; 
 57 | 
 58 | public: 
 59 | 	Graph(int V) { this->V = V; } 
 60 | 
 61 | 	// Function to add edge in a graph 
 62 | 	void addEdge(int x, int y, int w) 
 63 | 	{ 
 64 | 		edgelist.push_back({ w, x, y }); 
 65 | 	} 
 66 | 
 67 | 	void kruskals_mst() 
 68 | 	{ 
 69 | 		// Sort all edges 
 70 | 		sort(edgelist.begin(), edgelist.end()); 
 71 | 
 72 | 		// Initialize the DSU 
 73 | 		DSU s(V); 
 74 | 		int ans = 0; 
 75 | 		cout << "Following are the edges in the "
 76 | 				"constructed MST"
 77 | 			<< endl; 
 78 | 		for (auto edge : edgelist) { 
 79 | 			int w = edge[0]; 
 80 | 			int x = edge[1]; 
 81 | 			int y = edge[2]; 
 82 | 
 83 | 			// Take this edge in MST if it does 
 84 | 			// not forms a cycle 
 85 | 			if (s.find(x) != s.find(y)) { 
 86 | 				s.unite(x, y); 
 87 | 				ans += w; 
 88 | 				cout << x << " -- " << y << " == " << w 
 89 | 					<< endl; 
 90 | 			} 
 91 | 		} 
 92 | 		cout << "Minimum Cost Spanning Tree: " << ans; 
 93 | 	} 
 94 | }; 
 95 | 
 96 | // Driver code 
 97 | int main() 
 98 | { 
 99 | 	Graph g(4); 
100 | 	g.addEdge(0, 1, 10); 
101 | 	g.addEdge(1, 3, 15); 
102 | 	g.addEdge(2, 3, 4); 
103 | 	g.addEdge(2, 0, 6); 
104 | 	g.addEdge(0, 3, 5); 
105 | 
106 | 	// Function call 
107 | 	g.kruskals_mst(); 
108 | 
109 | 	return 0; 
110 | }
111 | //  output
112 | //  Following are the edges in the constructed MST
113 | //  2 -- 3 == 4
114 | //  0 -- 3 == 5
115 | //  0 -- 1 == 10
116 | //  Minimum Cost Spanning Tree: 19
117 | 


--------------------------------------------------------------------------------
/cpp/MatchingParenthesis.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #define MAX 100
 3 | using namespace std;
 4 | class stack
 5 | {
 6 |     int top;
 7 |     int arr[MAX];
 8 | 
 9 | public:
10 |     stack()
11 |     {
12 |         top= -1;
13 |     }
14 |     void push(int ele);
15 |     int pop();
16 |     void disp();
17 |     bool IsEmpty();
18 |     void parenthesischeck();
19 | };
20 | 
21 | bool stack::IsEmpty()
22 | {
23 |     if (top==-1)
24 |     {
25 |         return true;
26 |     }
27 |     return false;
28 | }
29 | 
30 | void stack::push(int ele){
31 |     if(top==MAX-1){
32 |         return;
33 |     }
34 |     arr[++top]=ele;
35 | }
36 | 
37 | int stack::pop(){
38 |     if(IsEmpty()){
39 |         cout<<"Empty stack";
40 |         return -999;
41 |     }
42 |     return arr[top--];
43 | }
44 | 
45 | void stack::disp(){
46 |     if(IsEmpty()){
47 |         cout<<"Empty stack";
48 |         return;
49 |     }
50 |     for(int i=top;i!=-1;i--){
51 |         cout<<arr[i]<<"  ";
52 |     }
53 | }
54 | 
55 | void stack::parenthesischeck(){
56 |     cout<<"Enter Expression: ";
57 | }
58 | 
59 | int main(){
60 |     
61 |     return 0;
62 | }


--------------------------------------------------------------------------------
/cpp/Merge_sort.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * C++ Program to Implement Merge Sort with Dynamic Memory Allocation
  3 |  */
  4 | 
  5 | #include <iostream>
  6 | 
  7 | using namespace std;
  8 | 
  9 | // A function to merge the two halves into sorted data.
 10 | void Merge(int *a, int low, int high, int mid)
 11 | {
 12 |     // We have low to mid and mid+1 to high already sorted.
 13 |     int i, j, k;
 14 |     int *temp = new int[high - low + 1]; // dynamically allocate temp array
 15 |     i = low;
 16 |     k = 0;
 17 |     j = mid + 1;
 18 | 
 19 |     // Merge the two parts into temp[].
 20 |     while (i <= mid && j <= high)
 21 |     {
 22 |         if (a[i] < a[j])
 23 |         {
 24 |             temp[k] = a[i];
 25 |             k++;
 26 |             i++;
 27 |         }
 28 |         else
 29 |         {
 30 |             temp[k] = a[j];
 31 |             k++;
 32 |             j++;
 33 |         }
 34 |     }
 35 | 
 36 |     // Insert all the remaining values from i to mid into temp[].
 37 |     while (i <= mid)
 38 |     {
 39 |         temp[k] = a[i];
 40 |         k++;
 41 |         i++;
 42 |     }
 43 | 
 44 |     // Insert all the remaining values from j to high into temp[].
 45 |     while (j <= high)
 46 |     {
 47 |         temp[k] = a[j];
 48 |         k++;
 49 |         j++;
 50 |     }
 51 | 
 52 |     // Assign sorted data stored in temp[] to a[].
 53 |     for (i = low; i <= high; i++)
 54 |     {
 55 |         a[i] = temp[i - low];
 56 |     }
 57 | 
 58 |     delete[] temp; // deallocate the dynamically allocated temp array
 59 | }
 60 | 
 61 | // A function to split the array into two parts.
 62 | void MergeSort(int *a, int low, int high)
 63 | {
 64 |     int mid;
 65 |     if (low < high)
 66 |     {
 67 |         mid = (low + high) / 2;
 68 |         // Split the data into two halves.
 69 |         MergeSort(a, low, mid);
 70 |         MergeSort(a, mid + 1, high);
 71 | 
 72 |         // Merge them to get sorted output.
 73 |         Merge(a, low, high, mid);
 74 |     }
 75 | }
 76 | 
 77 | int main()
 78 | {
 79 |     int n, i;
 80 |     cout << "\nEnter the number of data elements to be sorted: ";
 81 |     cin >> n;
 82 | 
 83 |     // Dynamically allocate memory for the array
 84 |     int *arr = new int[n];
 85 | 
 86 |     for (i = 0; i < n; i++)
 87 |     {
 88 |         cout << "Enter element " << i + 1 << ": ";
 89 |         cin >> arr[i];
 90 |     }
 91 | 
 92 |     MergeSort(arr, 0, n - 1);
 93 | 
 94 |     // Printing the sorted data.
 95 |     cout << "\nSorted Data ";
 96 |     for (i = 0; i < n; i++)
 97 |         cout << " -> " << arr[i];
 98 | 
 99 |     // Deallocate the dynamically allocated memory for the array
100 |     delete[] arr;
101 | 
102 |     return 0;
103 | }
104 | 


--------------------------------------------------------------------------------
/cpp/Prims algorithm:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <vector>
 3 | #include <queue>
 4 | #include <climits>
 5 | using namespace std;
 6 | // Function to perform Prim's Algorithm
 7 | void primMST(const vector<vector<int>>& graph, int n) {
 8 |     vector<int> parent(n); 
 9 |     vector<int> key(n, INT_MAX); 
10 |     vector<bool> inMST(n, false); 
11 |     priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
12 |     pq.push({0, 0});
13 |     key[0] = 0; 
14 |     parent[0] = -1; 
15 | 
16 |     while (!pq.empty()) {
17 |         int u = pq.top().second; 
18 |         pq.pop();
19 |         inMST[u] = true; 
20 |         for (int v = 0; v < n; v++) {
21 |             if (graph[u][v] != 0 && !inMST[v] && graph[u][v] < key[v]) {
22 |                 key[v] = graph[u][v]; 
23 |                 pq.push({key[v], v}); 
24 |                 parent[v] = u;
25 |             }
26 |         }
27 |     }
28 |     cout << "Edge \tWeight\n";
29 |     for (int i = 1; i < n; i++) {
30 |         cout << parent[i] << " - " << i << "\t" << graph[i][parent[i]] << "\n";
31 |     }
32 | }
33 | 
34 | int main() {
35 |     int n; 
36 |     cout << "Enter the number of vertices: ";
37 |     cin >> n;
38 | 
39 |     vector<vector<int>> graph(n, vector<int>(n));
40 | 
41 |     cout << "Enter the adjacency matrix of the graph (0 for no edge):\n";
42 |     for (int i = 0; i < n; i++) {
43 |         for (int j = 0; j < n; j++) {
44 |             cin >> graph[i][j];
45 |         }
46 |     }
47 | 
48 |     // Run Prim's Algorithm
49 |     primMST(graph, n);
50 | 
51 |     return 0;
52 | }
53 | 


--------------------------------------------------------------------------------
/cpp/QueueImplementation.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #define MAX 100
 3 | using namespace std;
 4 | class queue
 5 | {
 6 |     int r, f;
 7 |     int arr[MAX];
 8 | 
 9 | public:
10 |     queue()
11 |     {
12 |         r = f = -1;
13 |     }
14 |     void enq(int ele);
15 |     int deq();
16 |     void disp();
17 |     bool IsEmpty();
18 | };
19 | 
20 | bool queue::IsEmpty()
21 | {
22 |     if (r == f)
23 |     {
24 |         return true;
25 |     }
26 |     return false;
27 | }
28 | 
29 | void queue::enq(int ele){
30 |     if(r==MAX-1){
31 |         return;
32 |     }
33 |     arr[++r]=ele;
34 | }
35 | 
36 | int queue::deq(){
37 |     if(IsEmpty()){
38 |         cout<<"Empty Queue";
39 |         return -999;
40 |     }
41 |     return arr[++f];
42 | }
43 | 
44 | void queue::disp(){
45 |     if(IsEmpty()){
46 |         cout<<"Empty Queue";
47 |         return;
48 |     }
49 |     for(int i=f+1;i<=r;i++){
50 |         cout<<arr[i]<<"  ";
51 |     }
52 | }
53 | 
54 | int main(){
55 |     queue q;
56 |     int res,ele;
57 |     cout<<"MENU\n1.Enqueue\n2.Dequeue\n3.Display\n\n";
58 |     while(true){
59 |         cout<<"\nEnter your choice: ";
60 |         cin>>res;
61 |         if(res==1){
62 |             cout<<"\nEnter element to enque: ";
63 |             cin>>ele;
64 |             q.enq(ele);
65 |         }  
66 |         else if(res==2){
67 |             cout<<"\nElement dequeued: "<<q.deq();
68 |         }
69 |         else if(res==3){
70 |             q.disp();
71 |         }
72 |         else{
73 |             break;
74 |         }
75 |     }
76 |     return 0;
77 | }


--------------------------------------------------------------------------------
/cpp/QueueList.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream> 
 2 | #include<cmath>
 3 | #include<cstring> 
 4 | #include<vector> 
 5 | using namespace std; 
 6 | 
 7 | class Node{
 8 |     public:
 9 |     Node* next;
10 |     int data;
11 |     Node(int info){
12 |         data=info;
13 |         next=NULL;
14 |     }
15 | };
16 | 
17 | class Que{
18 |     Node *front=NULL;
19 |     Node *rear=NULL;
20 |     public:
21 |     void Enque(int x){
22 |         Node* newNode=new Node(x);
23 |         if(rear == NULL){
24 |             rear=newNode;
25 |             front=newNode;
26 |             return;
27 |         }
28 |         rear->next=newNode;
29 |         rear=newNode;
30 |         return;
31 |     }
32 |     int Deque(){
33 |         if(rear == NULL){
34 |             cout<<"Queue is Empty"<<endl;
35 |             return -9999;
36 |         }
37 |         Node* t=front;
38 |         int ans=front->data;
39 |         front=front->next;
40 |         delete t;
41 |         return ans;
42 |     }
43 |     void display(){
44 |         Node* temp=front;
45 |         while(temp != NULL){
46 |             cout<<temp->data<<" ";
47 |             temp=temp->next;
48 |         }
49 |         cout<<endl;
50 |     }
51 | };
52 | 
53 | int main(){
54 |     Que q1; 
55 |     for(int i=0;i<5;i++){
56 |         q1.Enque(5*i);
57 |     }
58 |     q1.display();
59 |     q1.Deque();
60 |     q1.Deque();
61 |     q1.Deque();
62 |     q1.Deque();
63 |     q1.display();
64 |     q1.Enque(77);
65 |     q1.display();
66 |     return 0;
67 | }


--------------------------------------------------------------------------------
/cpp/Reverse-Alternate-K-Nodes.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | class Node{
 5 |     public:
 6 |     int info;
 7 |     Node *next;
 8 |     Node(int ele){
 9 |         info=ele;
10 |         next=NULL;
11 |     }
12 | };
13 | 
14 | Node* insert_list(Node* head,int ele){
15 |     Node *temp=new Node(ele);
16 |     if(head==NULL){
17 |         return temp;
18 |     }
19 |     Node *t=head;
20 |     while(t->next!=NULL){
21 |         t=t->next;
22 |     }
23 |     t->next=temp;
24 |     return head;
25 | }
26 | 
27 | Node *display(Node *head){
28 |     if(head==NULL){
29 |         cout<<"Empty List";
30 |         return head;
31 |     }
32 |     Node *t=head;
33 |     for(;t;t=t->next){
34 |         cout<<t->info<<"->";
35 |     }
36 | }
37 | 
38 | Node *reversekalternate(Node *head,int k){
39 |     int count=0;
40 |     if(head==NULL){
41 |         return head;
42 |     }
43 |     Node *cur=head,*prev=NULL,*nextptr=NULL;
44 |     while(cur && count<k){
45 |         nextptr=cur->next;
46 |         cur->next=prev;
47 |         prev=cur;
48 |         cur=nextptr;
49 |         count++;
50 |     }
51 |     if(nextptr != NULL){
52 |         head->next=reversekalternate(nextptr,k);
53 |     }
54 |     return prev;
55 | }
56 | 
57 | int main(){
58 |     Node *head=NULL,*alt=NULL,*temp=NULL;
59 |     int ele,res;
60 |     head=insert_list(head,1);
61 |     head=insert_list(head,2);
62 |     head=insert_list(head,3);
63 |     head=insert_list(head,4);
64 |     head=insert_list(head,5);
65 |     head=insert_list(head,6);
66 |     head=insert_list(head,7);
67 |     head=insert_list(head,8);
68 |     cout<<endl;
69 |     display(head);
70 |     cout<<endl;
71 |     head=reversekalternate(head,3);
72 |     display(head);
73 |     // cout<<"MENU\n1.Insert\n2.Display\n3.Alternate-K-Nodes\n\n";
74 |     // while(true){
75 |     //     cout<<"\nEnter your choice: ";
76 |     //     cin>>res;
77 |     //     if(res==1){
78 |     //         cout<<"Enter element: ";
79 |     //         cin>>ele;
80 |     //         head=insert_list(head,ele);
81 |     //     }  
82 |     //     else if(res==2){
83 |     //         display(head);
84 |     //     }
85 |     //     else if(res==3){
86 |     //         // s.disp();
87 |     //     }
88 |     //     else{
89 |     //         break;
90 |     //     }
91 |     // }
92 | }


--------------------------------------------------------------------------------
/cpp/StackImplementation.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #define MAX 100
 3 | using namespace std;
 4 | class stack
 5 | {
 6 |     int top;
 7 |     int arr[MAX];
 8 | 
 9 | public:
10 |     stack()
11 |     {
12 |         top= -1;
13 |     }
14 |     void push(int ele);
15 |     int pop();
16 |     void disp();
17 |     bool IsEmpty();
18 | };
19 | 
20 | bool stack::IsEmpty()
21 | {
22 |     if (top==-1)
23 |     {
24 |         return true;
25 |     }
26 |     return false;
27 | }
28 | 
29 | void stack::push(int ele){
30 |     if(top==MAX-1){
31 |         return;
32 |     }
33 |     arr[++top]=ele;
34 | }
35 | 
36 | int stack::pop(){
37 |     if(IsEmpty()){
38 |         cout<<"Empty stack";
39 |         return -999;
40 |     }
41 |     return arr[top--];
42 | }
43 | 
44 | void stack::disp(){
45 |     if(IsEmpty()){
46 |         cout<<"Empty stack";
47 |         return;
48 |     }
49 |     for(int i=top;i!=-1;i--){
50 |         cout<<arr[i]<<"  ";
51 |     }
52 | }
53 | 
54 | int main(){
55 |     stack s;
56 |     int res,ele;
57 |     cout<<"MENU\n1Push\n2.Pop\n3.Display\n\n";
58 |     while(true){
59 |         cout<<"\nEnter your choice: ";
60 |         cin>>res;
61 |         if(res==1){
62 |             cout<<"\nEnter element to push: ";
63 |             cin>>ele;
64 |             s.push(ele);
65 |         }  
66 |         else if(res==2){
67 |             cout<<"\nElement popped: "<<s.pop();
68 |         }
69 |         else if(res==3){
70 |             s.disp();
71 |         }
72 |         else{
73 |             break;
74 |         }
75 |     }
76 |     return 0;
77 | }


--------------------------------------------------------------------------------
/cpp/StackUsingQueue.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #define MAX 100
 3 | using namespace std;
 4 | 
 5 | class que{
 6 | public:
 7 |     int f;
 8 |     int r;
 9 |     int arr[MAX];
10 |     que(){
11 |     f=-1;
12 |     r=-1;
13 |     }
14 |     void enq(int);
15 |     int deq();
16 |     void display();
17 |     bool IsEmpty();
18 | };
19 | 
20 | void que::enq(int ele){
21 |     if (r==MAX-1){
22 |         cout<<"Queue is full...";
23 |     }
24 |     arr[++r]=ele;
25 | }
26 | 
27 | int que::deq(){
28 |     if (f==r){
29 |         cout<<"Queue if empty...";
30 |         return -999;
31 |     }
32 |     return arr[++f];
33 | }
34 | 
35 | bool que::IsEmpty(){
36 |     if (f==r){
37 |         return true;
38 |     }
39 |     return false;
40 | }
41 | 
42 | class stk{
43 |     que q1,q2;
44 |     public:
45 |     void push(int ele);
46 |     int pop();
47 |     void disp();
48 | };
49 | 
50 | void stk::push(int ele){
51 |     q1.enq(ele);
52 | }
53 | 
54 | int stk::pop(){
55 |     while(q1.f!=(q1.r-1)){
56 |         q2.enq(q1.deq());
57 |     }
58 |     int ele=q1.deq();
59 |     while(q2.f!=(q2.r)){
60 |         q1.enq(q2.deq());
61 |     }
62 |     return ele;
63 | }
64 | 
65 | void stk::disp(){
66 |     for(int i=q1.f+1;i<=q1.r;i++){
67 |         cout<<q1.arr[i]<<"  ";
68 |     }
69 | }
70 | 
71 | int main(){
72 |     stk s;
73 |     s.push(1);
74 |     s.push(2);
75 |     s.push(3);
76 |     s.push(4);
77 |     s.push(5);
78 |     cout<<s.pop()<<endl;
79 |     cout<<s.pop()<<endl;
80 |     s.disp();
81 |     return 0;
82 | }


--------------------------------------------------------------------------------
/cpp/dijkestra.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | // Number of vertices in the graph
 5 | #define V 9
 6 | 
 7 | // A utility function to print the constructed distance
 8 | // array
 9 | void printSolution(vector<int>& dist)
10 | {
11 |     cout << "Vertex Distance from Source\n";
12 |     for (int i = 0; i < V; i++)
13 |         cout << "\t" << i << " \t\t\t\t " << dist[i] << endl;
14 | }
15 | 
16 | // Function that implements Dijkstra's single source shortest path algorithm
17 | void dijkstra(vector<vector<pair<int, int>>> &graph, int src)
18 | {
19 |     // Priority queue to store (distance, vertex) pairs
20 |     priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
21 | 
22 |     // Vector to store the shortest distance from source to each vertex
23 |     vector<int> dist(V, INT_MAX);
24 | 
25 |     // Insert the source node and initialize its distance as 0
26 |     pq.push({0, src});
27 |     dist[src] = 0;
28 | 
29 |     // While there are vertices left to process
30 |     while (!pq.empty()) {
31 |         // Extract the vertex with minimum distance value
32 |         int u = pq.top().second;
33 |         pq.pop();
34 | 
35 |         // Traverse through all adjacent vertices of u
36 |         for (auto& adj : graph[u]) {
37 |             int v = adj.first;
38 |             int weight = adj.second;
39 | 
40 |             // If there is a shorter path to v through u
41 |             if (dist[u] + weight < dist[v]) {
42 |                 dist[v] = dist[u] + weight;
43 |                 pq.push({dist[v], v});
44 |             }
45 |         }
46 |     }
47 | 
48 |     // Print the constructed distance array
49 |     printSolution(dist);
50 | }
51 | 
52 | // Driver program to test the above function
53 | int main()
54 | {
55 |     // Create a graph with adjacency list representation
56 |     vector<vector<pair<int, int>>> graph(V);
57 | 
58 |     // Add edges with (vertex, weight) pairs
59 |     graph[0].push_back({1, 4});
60 |     graph[0].push_back({7, 8});
61 |     graph[1].push_back({0, 4});
62 |     graph[1].push_back({2, 8});
63 |     graph[1].push_back({7, 11});
64 |     graph[2].push_back({1, 8});
65 |     graph[2].push_back({3, 7});
66 |     graph[2].push_back({5, 4});
67 |     graph[2].push_back({8, 2});
68 |     graph[3].push_back({2, 7});
69 |     graph[3].push_back({4, 9});
70 |     graph[3].push_back({5, 14});
71 |     graph[4].push_back({3, 9});
72 |     graph[4].push_back({5, 10});
73 |     graph[5].push_back({2, 4});
74 |     graph[5].push_back({3, 14});
75 |     graph[5].push_back({4, 10});
76 |     graph[5].push_back({6, 2});
77 |     graph[6].push_back({5, 2});
78 |     graph[6].push_back({7, 1});
79 |     graph[6].push_back({8, 6});
80 |     graph[7].push_back({0, 8});
81 |     graph[7].push_back({1, 11});
82 |     graph[7].push_back({6, 1});
83 |     graph[7].push_back({8, 7});
84 |     graph[8].push_back({2, 2});
85 |     graph[8].push_back({6, 6});
86 |     graph[8].push_back({7, 7});
87 | 
88 |     // Call Dijkstra's algorithm
89 |     dijkstra(graph, 0);
90 | 
91 |     return 0;
92 | }
93 | 


--------------------------------------------------------------------------------
/cpp/kadane_algorithm.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <vector>
 3 | #include <climits>
 4 | using namespace std;
 5 | 
 6 | /**
 7 |  * @brief Function to find the maximum sum of a contiguous subarray using Kadane's Algorithm.
 8 |  * @param arr The input vector of integers.
 9 |  * @return The maximum contiguous subarray sum.
10 |  */
11 | int kadane(const vector<int>& arr) {
12 |     int max_so_far = INT_MIN; // Stores the maximum sum found so far
13 |     int max_ending_here = 0;   // Stores the current subarray sum
14 | 
15 |     for (int i = 0; i < arr.size(); i++) {
16 |         max_ending_here += arr[i]; // Add the current element to the current subarray sum
17 | 
18 |         // Update max_so_far if max_ending_here is greater
19 |         if (max_ending_here > max_so_far) {
20 |             max_so_far = max_ending_here;
21 |         }
22 | 
23 |         // Reset max_ending_here to 0 if it becomes negative
24 |         if (max_ending_here < 0) {
25 |             max_ending_here = 0;
26 |         }
27 |     }
28 |     return max_so_far;
29 | }
30 | 
31 | /**
32 |  * @brief Main function to test the Kadane's algorithm implementation.
33 |  * @return 0 on successful execution.
34 |  */
35 | int main() {
36 |     vector<int> arr = {-2, 1, -3, 4, -1, 2, 1, -5, 4};
37 |     cout << "Maximum contiguous sum is " << kadane(arr) << endl;
38 |     return 0;
39 | }
40 | 


--------------------------------------------------------------------------------
/cpp/merge_sort.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <cstdlib>
  3 |  
  4 | using namespace std;
  5 |  
  6 | struct Node
  7 | {
  8 |     int data;
  9 |     struct Node *next;
 10 | }*first=NULL,*second=NULL,*third=NULL;
 11 |  
 12 | void create(int A[], int n)
 13 | {
 14 |     struct Node *t, *last;
 15 |     first = (struct Node *)malloc(sizeof(struct Node));
 16 |     first->data = A[0];
 17 |     first->next = NULL;
 18 |     last = first;
 19 |     
 20 |     for(int i=1;i<n;i++)
 21 |     {
 22 |         t = (struct Node *)malloc(sizeof(struct Node));
 23 |         t->data = A[i];
 24 |         t->next = NULL;
 25 |         last->next = t;
 26 |         last = t;
 27 |     }
 28 | }
 29 |  
 30 | void create2(int A[], int n)
 31 | {
 32 |     struct Node *t, *last;
 33 |     second = (struct Node *)malloc(sizeof(struct Node));
 34 |     second->data = A[0];
 35 |     second->next = NULL;
 36 |     last = second;
 37 |     
 38 |     for(int i=1;i<n;i++)
 39 |     {
 40 |         t = (struct Node *)malloc(sizeof(struct Node));
 41 |         t->data = A[i];
 42 |         t->next = NULL;
 43 |         last->next = t;
 44 |         last = t;
 45 |     }
 46 | }
 47 |  
 48 | void display(struct Node *p)
 49 | {
 50 |     if(p != NULL)
 51 |     {
 52 |         cout << p->data << " ";
 53 |         display(p->next);
 54 |     }
 55 | }
 56 |  
 57 | int counting(struct Node *p)
 58 | {
 59 |     int total {0};
 60 |     while(p != 0)
 61 |     {
 62 |         total++;
 63 |         p = p->next;
 64 |     }
 65 |     return total;
 66 | }
 67 |  
 68 | void concatenate(struct Node *p, struct Node *q)
 69 | {
 70 |     third = p;
 71 |     
 72 |     while(p->next != NULL)
 73 |     {
 74 |         p = p->next;
 75 |     }
 76 |     p->next = q;
 77 | }
 78 |  
 79 | void merge(struct Node *p, struct Node *q)
 80 | {
 81 |     struct Node *last;
 82 |     
 83 |     if(p->data < q->data)
 84 |     {
 85 |         third = last = p;
 86 |         p = p->next;
 87 |         third->next = NULL;
 88 |     }
 89 |     else
 90 |     {
 91 |         third = last = q;
 92 |         q = q->next;
 93 |         third->next = NULL;
 94 |     }
 95 |     while(p && q)
 96 |     {
 97 |         if(p->data < q->data)
 98 |         {
 99 |             last->next = p;
100 |             last = p;
101 |             p = p->next;
102 |             last->next = NULL;
103 |         }
104 |         else
105 |         {
106 |             last->next = q;
107 |             last = q;
108 |             q = q->next;
109 |             last->next = NULL;
110 |         }
111 |     }
112 |     if(p)last->next=p;
113 |     if(q)last->next=q;
114 | }
115 |  
116 | int main()
117 | {
118 |     int A[] = {2,4,6,8,10,12};
119 | 
120 | int B[] = {10,20,30,40,50,60};
121 | 
122 | int sizeA, sizeB;
123 | 
124 | sizeA = sizeof(A)/sizeof(A[0]);
125 | 
126 | sizeB = sizeof(B)/sizeof(B[0]);
127 | 
128 | create(A,sizeA);
129 | 
130 | create2(B,sizeB);
131 | 
132 | display(first);
133 | 
134 | cout << endl;
135 | 
136 | display(second);
137 | 
138 | cout << endl;
139 | 
140 | // concatenate(first,second);
141 | 
142 | // display(third);
143 | 
144 | // cout << endl;
145 | 
146 | merge(first,second);
147 | 
148 | display(third);
149 | 
150 | return 0;
151 | }
152 | 


--------------------------------------------------------------------------------
/cpp/pattern/HollowDiamond.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | int main() {
 5 |   cout<<"Enter a number for the Hollow Diamond Pattern : ";
 6 |     int n;
 7 |     cin >> n;
 8 | 
 9 |     // Upper half of the pattern
10 |     for (int i = 1; i <= n; i++) {
11 |         for (int j = n - i; j >= 0; j--) {
12 |             cout << "*";
13 |         }
14 | 
15 |         for (int k = 2 * (i - 1); k > 0; k--) {
16 |             cout << " ";
17 |         }
18 | 
19 |         for (int l = n - i; l >= 0; l--) {
20 |             cout << "*";
21 |         }
22 |         cout << endl;
23 |     }
24 | 
25 |     // Lower half of the pattern
26 |     for (int i = 0; i < n; i++) {
27 |         for (int j = 0; j <= i; j++) {
28 |             cout << "*";
29 |         }
30 | 
31 |         for (int k = 2 * (n - i - 1); k > 0; k--) {
32 |             cout << " ";
33 |         }
34 | 
35 |         for (int m = 0; m <= i; m++) {
36 |             cout << "*";
37 |         }
38 |         cout << endl;
39 |     }
40 | 
41 |     return 0;
42 | }
43 | 


--------------------------------------------------------------------------------
/cpp/pattern/Inverted-Left-Half-Pyramid-Pattern.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | 
 3 | int main(int argc, char const *argv[])
 4 | {
 5 | 
 6 |     int rows = 5;
 7 |     for (int i = 0; i < rows; i++)
 8 |     {
 9 | 
10 |         for (int j = 0; j < 2 * i; j++)
11 |         {
12 |             printf(" ");
13 |         }
14 |         for (int k = 0; k < rows - i; k++)
15 |         {
16 |             printf("* ");
17 |         }
18 |         printf("\n");
19 |     }
20 |     return 0;
21 | }
22 | 


--------------------------------------------------------------------------------
/cpp/pattern/Inverted-Right-Half-Pyramid-Pattern.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | 
 3 | int main(int argc, char const *argv[])
 4 | {
 5 | 
 6 |     int rows=5;
 7 |     for (int i = 0; i < rows; i++)
 8 |     {
 9 |         for (int j = 0; j < rows-i ; j++)
10 |         {
11 |             printf("*");
12 |         }
13 |         printf("\n");
14 |     }
15 |     return 0;
16 | }
17 | 


--------------------------------------------------------------------------------
/cpp/pattern/Inverted-full-pyrm.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | 
 3 | int main(int argc, char const *argv[])
 4 | {
 5 | 
 6 |     int rows = 5;
 7 |     for (int i = 0; i < rows; i++)
 8 |     {
 9 | 
10 |         for (int j = 0; j < rows + i; j++)
11 |         {
12 |             printf(" ");
13 |         }
14 |         for (int k = 0; k < rows - i; k++)
15 |         {
16 |             printf("* ");
17 |         }
18 |         printf("\n");
19 |     }
20 |     return 0;
21 | }
22 | 
23 | 
24 | //extra 
25 | // int main()
26 | // {
27 | //     int rows = 5;
28 | 
29 |     
30 | //     for (int i = 0; i < rows; i++) {
31 | 
32 | 
33 | //         for (int j = 0; j < 2 * i; j++) {
34 | //             printf(" ");
35 | //         }
36 | 
37 | //         for (int k = 0; k < 2 * (rows - i) - 1; k++) {
38 | //             printf("* ");
39 | //         }
40 | //         printf("\n");
41 | //     }
42 | // }


--------------------------------------------------------------------------------
/cpp/pattern/NumberPattern.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | void patternNumbers(int n)
 5 | {
 6 |     for (int i = 0; i < 2 * n - 1; i++)
 7 |     {
 8 |         for (int j = 0; j < 2 * n - 1; j++)
 9 |         {
10 | 
11 |             int top = i;
12 |             int bottom = j;
13 |             int right = (2 * n - 2) - j;
14 |             int left = (2 * n - 2) - i;
15 | 
16 |             cout << (n - min(min(top, bottom), min(left, right))) << " ";
17 |         }
18 | 
19 |         cout << endl;
20 |     }
21 | }
22 | 
23 | int main()
24 | {
25 |     // Here, we can modify the value of N.
26 |     int N = 5;
27 | 
28 |     patternNumbers(N);
29 | 
30 |     return 1;
31 | }
32 | 
33 | 
34 | 
35 | 
36 | // OUTPUT
37 | 
38 | // 5 5 5 5 5 5 5 5 5 
39 | // 5 4 4 4 4 4 4 4 5 
40 | // 5 4 3 3 3 3 3 4 5 
41 | // 5 4 3 2 2 2 3 4 5 
42 | // 5 4 3 2 1 2 3 4 5 
43 | // 5 4 3 2 2 2 3 4 5 
44 | // 5 4 3 3 3 3 3 4 5 
45 | // 5 4 4 4 4 4 4 4 5 
46 | // 5 5 5 5 5 5 5 5 5


--------------------------------------------------------------------------------
/cpp/pattern/NumberPattern.exe:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/cpp/pattern/NumberPattern.exe


--------------------------------------------------------------------------------
/cpp/pattern/Rhombus-pattern.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | 
 3 | int main(int argc, char const *argv[])
 4 | {
 5 | 
 6 |     int rows = 5;
 7 |     for (int i = 0; i < rows; i++)
 8 |     {
 9 | 
10 |         for (int j = 0; j < rows - i; j++)
11 |         {
12 |             printf(" ");
13 |         }
14 |         for (int k = 0; k < rows; k++)
15 |         {
16 |             printf("* ");
17 |         }
18 |         printf("\n");
19 |     }
20 |     return 0;
21 | }
22 | 


--------------------------------------------------------------------------------
/cpp/pattern/diamond.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | 
 3 | int main(int argc, char const *argv[])
 4 | {
 5 |     // static approach
 6 |     // int rows = 5;
 7 | 
 8 |     // for (int i = 0; i < rows; i++)
 9 |     // {
10 |         
11 |     //     for (int l = 0; l < rows - i; l++)
12 |     //     {
13 |     //         if (l == 0)
14 |     //         {
15 |     //             printf("    ");
16 |     //         }
17 |     //         printf(" ");
18 |     //     }
19 |     //     for (int m = 0; m <= i; m++)
20 |     //     {
21 |     //         printf("* ");
22 |     //     }
23 |     //     printf("\n");
24 |     // }
25 |     // for (int i = 0; i < rows; i++)
26 |     // {
27 |     //     for (int j = 0; j < rows + i; j++)
28 |     //     {
29 |     //         printf(" ");
30 |     //     }
31 |     //     for (int k = 0; k < rows - i; k++)
32 |     //     {
33 |     //         printf("* ");
34 |     //     }
35 |     //     printf("\n");
36 |     // }
37 |     // return 0;
38 | 
39 |     // dynamic one 
40 |      int n = 5;
41 | 
42 |     
43 |     for (int i = 0; i < 2 * n - 1; i++) {
44 |         // the row number
45 |         int comp;
46 |         if (i < n) {
47 |             comp = 2 * (n - i) - 1;
48 |         }
49 |         else {
50 |             comp = 2 * (i - n + 1) + 1;
51 |         }
52 | 
53 |         // space
54 |         for (int j = 0; j < comp; j++) {
55 |             printf(" ");
56 |         }
57 | 
58 |         for (int k = 0; k < 2 * n - comp; k++) {
59 |             printf("* ");
60 |         }
61 |         printf("\n");
62 |     }
63 |     return 0;
64 | }
65 | 


--------------------------------------------------------------------------------
/cpp/pattern/full-pyrm.c:
--------------------------------------------------------------------------------
 1 | // #include <stdio.h>
 2 | 
 3 | // int main()
 4 | // {
 5 | //     int rows = 5;
 6 | //     for (int i = 0; i < rows; i++)
 7 | //     {
 8 | 
 9 | //         for (int j = 0; j < (rows - i); j++)
10 | //         {
11 | //             printf(" ");
12 | //         }
13 | 
14 | //         for (int k = 0; k <= i; k++)
15 | //         {
16 | //             printf("* ");
17 | //         }
18 | //         for (int j = 0; j < (rows - i) ; j++)
19 | //         {
20 | //             printf(" ");
21 | //         }
22 | //         printf("\n");
23 | //     }
24 | //     return 0;
25 | // }
26 | 
27 | 
28 | #include <stdio.h>
29 | 
30 | int main()
31 | {
32 |     int rows = 5;
33 |     for (int i = 0; i < rows; i++)
34 |     {
35 | 
36 |         for (int j = 0; j < (rows - i); j++)
37 |         {
38 |             printf(" ");
39 |         }
40 | 
41 |         for (int k = 0; k <= i; k++)
42 |         {
43 |             printf("* ");
44 |         }
45 |         printf("\n");
46 |     }
47 |     return 0;
48 | }


--------------------------------------------------------------------------------
/cpp/pattern/left-hal-pyrm.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | 
 3 | int main()
 4 | {
 5 |     int rows = 5;
 6 |     for (int i = 0; i < rows; i++)
 7 |     {
 8 | 
 9 |         for (int j = 0; j < 2 * (rows - i) - 1; j++)
10 |         {
11 |             printf(" ");
12 |         }
13 | 
14 |         for (int k = 0; k <= i; k++)
15 |         {
16 |             printf("* ");
17 |         }
18 |         for (int j = 0; j < 2 * (rows - i) - 1; j++)
19 |         {
20 |             printf(" ");
21 |         }
22 |         printf("\n");
23 |     }
24 |     return 0;
25 | }


--------------------------------------------------------------------------------
/cpp/pattern/right-hal-pyrm.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | 
 3 | int main()
 4 | {
 5 | 
 6 |     for (int i = 5; i < 0; i--){
 7 |              printf(" ");
 8 |         for (int j = i; j < i; j--)
 9 |         {
10 |         printf("%d", j+1);
11 |         }
12 |    
13 |     }
14 | }


--------------------------------------------------------------------------------
/cpp/pattern/second-largest.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | 
 3 | void bubbleSort(int arr[], int n) {
 4 |     for (int i = 0; i < n-1; i++) {
 5 |         for (int j = 0; j < n-i-1; j++) {
 6 |             if (arr[j] > arr[j+1]) {
 7 |                 int temp = arr[j];
 8 |                 arr[j] = arr[j+1];
 9 |                 arr[j+1] = temp;
10 |             }
11 |         }
12 |     }
13 | }
14 | 
15 | int secondLargest(int arr[], int n) {
16 |     if (n < 2) return -1;  // size is not enough
17 |     // final result
18 |     for (int i = n-2; i >= 0; i--) {
19 |         if (arr[i] != arr[n-1]) {
20 |             return arr[i];
21 |         }
22 |     }
23 |     return -1; 
24 | }
25 | 
26 | int main() {
27 |     int arr[] = {12, 35, 10000, 1, 34, 10000};
28 |     int n = sizeof(arr) / sizeof(arr[0]);
29 |     bubbleSort(arr, n);
30 |     int result = secondLargest(arr, n);
31 |     
32 |     if (result == -1) {
33 |         printf("There is no second largest element\n");
34 |     } else {
35 |         printf("The second largest element is %d\n", result);
36 |     }
37 |     
38 |     return 0;
39 | }
40 | 
41 | 
42 | 
43 | 
44 | 
45 | // #include <stdio.h>
46 | // #include <limits.h>
47 | 
48 | // int findSecondLargest(int arr[], int size) {
49 | //     if (size < 2) {
50 | //         printf("Array should have at least two elements.\n");
51 | //         return INT_MIN; 
52 | //     }
53 | 
54 | //     int firstLargest, secondLargest;
55 | //     firstLargest = secondLargest = INT_MIN;
56 | 
57 | //     for (int i = 0; i < size; i++) {
58 | //         if (arr[i] > firstLargest) {
59 | //             secondLargest = firstLargest;
60 | //             firstLargest = arr[i];
61 | //         } else if (arr[i] > secondLargest && arr[i] != firstLargest) {
62 | //             secondLargest = arr[i];
63 | //         }
64 | //     }
65 | 
66 | //     if (secondLargest == INT_MIN) {
67 | //         printf("There is no second largest element.\n");
68 | //         return INT_MIN;
69 | //     }
70 | 
71 | //     return secondLargest;
72 | // }
73 | 
74 | // int main() {
75 | //     int arr[] = {12, 35, 1, 10, 34, 100};
76 | //     int size = sizeof(arr) / sizeof(arr[0]);
77 | 
78 | //     int secondLargest = findSecondLargest(arr, size);
79 | 
80 | //     if (secondLargest != INT_MIN) {
81 | //         printf("The second largest element is %d\n", secondLargest);
82 | //     }
83 | 
84 | //     return 0;
85 | // }
86 | 


--------------------------------------------------------------------------------
/cpp/pattern/tempCodeRunnerFile.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | 
 3 | int main(int argc, char const *argv[])
 4 | {
 5 | 
 6 |     int rows = 5;
 7 |     for (int i = 0; i < rows; i++)
 8 |     {
 9 | 
10 |         for (int j = 0; j < rows + i; j++)
11 |         {
12 |             printf(" ");
13 |         }
14 |         for (int k = 0; k < rows - i; k++)
15 |         {
16 |             printf("* ");
17 |         }
18 |         printf("\n");
19 |     }
20 |     return 0;
21 | }
22 | 


--------------------------------------------------------------------------------
/cpp/segmentTree.cpp:
--------------------------------------------------------------------------------
  1 | // C++ code for segment tree with sum
  2 | // range and update query
  3 | 
  4 | #include <bits/stdc++.h>
  5 | using namespace std;
  6 | vector<int> A, ST;
  7 | 
  8 | void build(int node, int L, int R)
  9 | {
 10 | 
 11 | 	// Leaf node where L == R
 12 | 	if (L == R) {
 13 | 		ST[node] = A[L];
 14 | 	}
 15 | 	else {
 16 | 
 17 | 		// Find the middle element to
 18 | 		// split the array into two halves
 19 | 		int mid = (L + R) / 2;
 20 | 
 21 | 		// Recursively travel the
 22 | 		// left half
 23 | 		build(2 * node, L, mid);
 24 | 
 25 | 		// Recursively travel the
 26 | 		// right half
 27 | 		build(2 * node + 1, mid + 1, R);
 28 | 
 29 | 		// Storing the sum of both the
 30 | 		// children into the parent
 31 | 		ST[node] = ST[2 * node] + ST[2 * node + 1];
 32 | 	}
 33 | }
 34 | 
 35 | void update(int node, int L, int R, int idx, int val)
 36 | {
 37 | 
 38 | 	// Find the lead node and
 39 | 	// update its value
 40 | 	if (L == R) {
 41 | 		A[idx] += val;
 42 | 		ST[node] += val;
 43 | 	}
 44 | 	else {
 45 | 
 46 | 		// Find the mid
 47 | 		int mid = (L + R) / 2;
 48 | 
 49 | 		// If node value idx is at the
 50 | 		// left part then update
 51 | 		// the left part
 52 | 		if (L <= idx and idx <= mid)
 53 | 			update(2 * node, L, mid, idx, val);
 54 | 		else
 55 | 			update(2 * node + 1, mid + 1, R, idx, val);
 56 | 
 57 | 		// Store the information in parents
 58 | 		ST[node] = ST[2 * node] + ST[2 * node + 1];
 59 | 	}
 60 | }
 61 | 
 62 | int query(int node, int tl, int tr, int l, int r)
 63 | {
 64 | 
 65 | 	// If it lies out of range then
 66 | 	// return 0
 67 | 	if (r < tl or tr < l)
 68 | 		return 0;
 69 | 
 70 | 	// If the node contains the range then
 71 | 	// return the node value
 72 | 	if (l <= tl and tr <= r)
 73 | 		return ST[node];
 74 | 	int tm = (tl + tr) / 2;
 75 | 
 76 | 	// Recursively traverse left and right
 77 | 	// and find the node
 78 | 	return query(2 * node, tl, tm, l, r)
 79 | 		+ query(2 * node + 1, tm + 1, tr, l, r);
 80 | }
 81 | 
 82 | // Driver code
 83 | int main()
 84 | {
 85 | 	int n = 6;
 86 | 	A = { 0, 1, 3, 5, -2, 3 };
 87 | 
 88 | 	// Create a segment tree of size 4*n
 89 | 	ST.resize(4 * n);
 90 | 
 91 | 	// Build a segment tree
 92 | 	build(1, 0, n - 1);
 93 | 	cout << "Sum of values in range 0-4 are: "
 94 | 		<< query(1, 0, n - 1, 0, 4) << "\n";
 95 | 
 96 | 	// Update the value at idx = 1 by
 97 | 	// 100 thus becoming 101
 98 | 	update(1, 0, n - 1, 1, 100);
 99 | 	cout << "Value at index 1 increased by 100\n";
100 | 	cout << "sum of value in range 1-3 are: "
101 | 		<< query(1, 0, n - 1, 1, 3) << "\n";
102 | 
103 | 	return 0;
104 | }
105 | 


--------------------------------------------------------------------------------
/image.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/image.jpg


--------------------------------------------------------------------------------
/javascript/State_Using_Array.js:
--------------------------------------------------------------------------------
 1 | class Stack {
 2 |     constructor(capacity) {
 3 |         if (capacity <= 0) {
 4 |             throw new Error("Capacity must be greater than zero.");
 5 |         }
 6 |         this.capacity = capacity;
 7 |         this.stack = [];
 8 |         this.top = -1;
 9 |     }
10 | 
11 |     push(value) {
12 |         if (this.isFull()) {
13 |             console.error(`Error: Stack is full. Cannot push ${value}.`);
14 |             return;
15 |         }
16 |         this.stack[++this.top] = value;
17 |     }
18 | 
19 |     pop() {
20 |         if (this.isEmpty()) {
21 |             console.error("Error: Stack is empty. Cannot pop.");
22 |             return;
23 |         }
24 |         this.top--;
25 |     }
26 | 
27 |     peek() {
28 |         if (this.isEmpty()) {
29 |             console.warn("Warning: Stack is empty. Returning -1 as a placeholder.");
30 |             return -1; // Placeholder for error condition
31 |         }
32 |         return this.stack[this.top];
33 |     }
34 | 
35 |     isFull() {
36 |         return this.top === this.capacity - 1;
37 |     }
38 | 
39 |     isEmpty() {
40 |         return this.top === -1;
41 |     }
42 | 
43 |     getCapacity() {
44 |         return this.capacity;
45 |     }
46 | 
47 |     getSize() {
48 |         return this.top + 1;
49 |     }
50 | }
51 | 
52 | try {
53 |     const stack = new Stack(5);
54 | 
55 |     stack.push(10);
56 |     stack.push(20);
57 |     stack.push(30);
58 | 
59 |     console.log("Top element is:", stack.peek());
60 | 
61 |     stack.pop();
62 |     console.log("Top element after pop is:", stack.peek());
63 | 
64 |     stack.pop();
65 |     stack.pop();
66 |     stack.pop(); // This will trigger an error message
67 | 
68 | } catch (error) {
69 |     console.error("Exception:", error.message);
70 | }
71 | 


--------------------------------------------------------------------------------
/javascript/merge.js:
--------------------------------------------------------------------------------
 1 | // Function to perform merge sort
 2 | function mergeSort(arr) {
 3 |     if (arr.length <= 1) {
 4 |         return arr;
 5 |     }
 6 | 
 7 |     // Find the middle point
 8 |     const mid = Math.floor(arr.length / 2);
 9 | 
10 |     // Divide the array into two halves
11 |     const leftHalf = arr.slice(0, mid);
12 |     const rightHalf = arr.slice(mid);
13 | 
14 |     // Recursively sort the two halves and merge them
15 |     return merge(mergeSort(leftHalf), mergeSort(rightHalf));
16 | }
17 | 
18 | // Function to merge two sorted arrays
19 | function merge(left, right) {
20 |     let sortedArray = [];
21 |     let i = 0, j = 0;
22 | 
23 |     // Merge elements from both arrays in sorted order
24 |     while (i < left.length && j < right.length) {
25 |         if (left[i] < right[j]) {
26 |             sortedArray.push(left[i]);
27 |             i++;
28 |         } else {
29 |             sortedArray.push(right[j]);
30 |             j++;
31 |         }
32 |     }
33 | 
34 |     // Concatenate remaining elements (if any) from both arrays
35 |     return sortedArray.concat(left.slice(i)).concat(right.slice(j));
36 | }
37 | 
38 | // Example usage
39 | const array = [12, 11, 13, 5, 6, 7];
40 | console.log("Original Array:", array);
41 | 
42 | const sortedArray = mergeSort(array);
43 | console.log("Sorted Array:", sortedArray);
44 | 


--------------------------------------------------------------------------------
/javascript/snake_game/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 | <head>
 4 |     <meta charset="UTF-8">
 5 |     <meta name="viewport" content="width=device-width, initial-scale=1.0">
 6 |     <title>Snake Game </title>
 7 |     <link rel="stylesheet" href="styles.css">
 8 | </head>
 9 | <body style="background-color: black;">
10 |     <div id="game-arena" >
11 | 
12 |     </div>
13 |     <script src="script.js"></script>
14 | </body>
15 | </html>


--------------------------------------------------------------------------------
/javascript/snake_game/styles.css:
--------------------------------------------------------------------------------
 1 | body {
 2 |     display: flex;
 3 |     flex-direction: column;
 4 |     align-items: center;
 5 |     justify-content: center;
 6 |     height: 100vh;
 7 |     background-color: antiquewhite;
 8 |     text-align: center;
 9 | }
10 | 
11 | #game-arena {
12 |     width: 600px;
13 |     height: 600px;
14 |     background-color: #333;
15 |     position: relative;
16 |     border: 5px solid #666;
17 |     margin-bottom: 20px;
18 |     box-shadow: 0 0 20px rgba(0, 0, 0, 0.5);
19 | }
20 | 
21 | #score-board {
22 |     font-size: x-large;
23 |     font-weight: bold;
24 |     color: black;
25 |     margin: 10px 0;
26 | }
27 | 
28 | .start-button {
29 |     background-color: orangered;
30 |     color: white;
31 |     padding: 15px 30px;
32 |     text-align: center;
33 |     text-decoration: none;
34 |     font-size: 18px;
35 |     margin: 4px 0;
36 |     cursor: pointer;
37 |     border: none;
38 |     border-radius: 6px;
39 | }
40 | 
41 | .food {
42 |     width: 20px;
43 |     height: 20px;
44 |     background-color: red;
45 |     position: absolute;
46 |     border-radius: 50%;
47 |     animation: blink 1s infinite;
48 | }
49 | 
50 | @keyframes blink {
51 |     50% {
52 |         opacity: 0.5;
53 |     }
54 | }
55 | 
56 | .snake {
57 |     width: 20px;
58 |     height: 20px;
59 |     background-color: chartreuse;
60 |     position: absolute;
61 |     border-radius: 5px;
62 | }


--------------------------------------------------------------------------------
/javascript/sort.js:
--------------------------------------------------------------------------------
 1 | function bubbleSort(arr) {
 2 |     let n = arr.length;
 3 |     for (let i = 0; i < n - 1; i++) {
 4 |       for (let j = 0; j < n - i - 1; j++) {
 5 |         if (arr[j] > arr[j + 1]) {
 6 |           // Swap
 7 |           let temp = arr[j];
 8 |           arr[j] = arr[j + 1];
 9 |           arr[j + 1] = temp;
10 |         }
11 |       }
12 |     }
13 |     return arr;
14 |   }
15 |   console.log(bubbleSort([64, 34, 25, 12, 22, 11, 90]));
16 |   


--------------------------------------------------------------------------------
/javascript/todo-app/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 |   <head>
 4 |     <meta charset="UTF-8" />
 5 |     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
 6 |     <title>To-Do App</title>
 7 |     <link rel="stylesheet" href="style.css" />
 8 |     <link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Poppins:wght@400;500;600&display=swap" />
 9 |   </head>
10 |   <body>
11 |     <div class="container" role="main">
12 |         <h1>
13 |             To Do App
14 |             <button id="toggleDarkMode" aria-label="Toggle dark mode">🌙</button>
15 |           </h1>
16 |       <div class="submit">
17 |         <input type="text" id="input" placeholder="Add a new task" aria-label="New task input" />
18 |         <button type="button" id="addbtn" onclick="addTodo()">Add</button>
19 |         <button type="button" id="clearbtn" onclick="clearTodo()">Clear</button>
20 |       </div>
21 |       <div id="message" class="message" aria-live="polite"></div>
22 |       <div class="mainList" role="list"></div>
23 |     </div>
24 |     <script src="script.js" defer></script>
25 |   </body>
26 | </html>
27 | 


--------------------------------------------------------------------------------
/javascript/todo-app/script.js:
--------------------------------------------------------------------------------
 1 | let todos = [];
 2 | const inputField = document.getElementById("input");
 3 | const messageDiv = document.getElementById("message");
 4 | const mainList = document.querySelector(".mainList");
 5 | const toggleDarkModeBtn = document.getElementById("toggleDarkMode");
 6 | 
 7 | function addTodo() {
 8 |     const todoText = inputField.value.trim();
 9 |     
10 |     if (!todoText) {
11 |         return showMessage("Please enter a task!", "red");
12 |     }
13 | 
14 |     todos.push({ title: todoText, completed: false });
15 |     inputField.value = "";
16 |     showMessage(`Todo #${todos.length} Added!`, "green");
17 |     render();
18 | }
19 | 
20 | function showMessage(message, color) {
21 |     messageDiv.textContent = message;
22 |     messageDiv.style.color = color;
23 |     
24 |     setTimeout(() => messageDiv.textContent = "", 500);
25 | }
26 | 
27 | inputField.addEventListener("keypress", (event) => {
28 |     if (event.key === "Enter") addTodo();
29 | });
30 | 
31 | function deleteTodo(index) {
32 |     todos.splice(index, 1);
33 |     render();
34 | }
35 | 
36 | function clearTodo() {
37 |     todos = [];
38 |     render();
39 |     showMessage("Todo List Cleared!", "red");
40 | }
41 | 
42 | function toggleComplete(index) {
43 |     todos[index].completed = !todos[index].completed;
44 |     render();
45 | }
46 | 
47 | function render() {
48 |     mainList.innerHTML = "";
49 | 
50 |     todos.forEach((todo, index) => {
51 |         const todoItem = document.createElement("div");
52 |         todoItem.className = "todo-item";
53 | 
54 |         const checkbox = document.createElement("input");
55 |         checkbox.type = "checkbox";
56 |         checkbox.className = "checkbox";
57 |         checkbox.checked = todo.completed;
58 |         checkbox.addEventListener("change", () => toggleComplete(index));
59 | 
60 |         const todoSpan = document.createElement("span");
61 |         todoSpan.className = `todo-span ${todo.completed ? "completed" : ""}`;
62 |         todoSpan.textContent = todo.title;
63 | 
64 |         const deleteBtn = document.createElement("button");
65 |         deleteBtn.className = "delete-btn";
66 |         deleteBtn.textContent = "❌";
67 |         deleteBtn.onclick = () => deleteTodo(index);
68 | 
69 |         todoItem.appendChild(checkbox);
70 |         todoItem.appendChild(todoSpan);
71 |         todoItem.appendChild(deleteBtn);
72 |         mainList.appendChild(todoItem);
73 |     });
74 | }
75 | 
76 | toggleDarkModeBtn.addEventListener("click", () => {
77 |     document.body.classList.toggle("dark-mode");
78 |     const isDarkMode = document.body.classList.contains("dark-mode");
79 |     toggleDarkModeBtn.textContent = isDarkMode ? "🌞" : "🌙";
80 | });
81 | 
82 | render();
83 | 


--------------------------------------------------------------------------------
/pattern/Inverted-Left-Half-Pyramid-Pattern.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | 
 3 | int main(int argc, char const *argv[])
 4 | {
 5 | 
 6 |     int rows = 5;
 7 |     for (int i = 0; i < rows; i++)
 8 |     {
 9 | 
10 |         for (int j = 0; j < 2 * i; j++)
11 |         {
12 |             printf(" ");
13 |         }
14 |         for (int k = 0; k < rows - i; k++)
15 |         {
16 |             printf("* ");
17 |         }
18 |         printf("\n");
19 |     }
20 |     return 0;
21 | }
22 | 


--------------------------------------------------------------------------------
/pattern/Inverted-Right-Half-Pyramid-Pattern.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | 
 3 | int main(int argc, char const *argv[])
 4 | {
 5 | 
 6 |     int rows=5;
 7 |     for (int i = 0; i < rows; i++)
 8 |     {
 9 |         for (int j = 0; j < rows-i ; j++)
10 |         {
11 |             printf("*");
12 |         }
13 |         printf("\n");
14 |     }
15 |     return 0;
16 | }
17 | 


--------------------------------------------------------------------------------
/pattern/Inverted-full-pyrm.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | 
 3 | int main(int argc, char const *argv[])
 4 | {
 5 | 
 6 |     int rows = 5;
 7 |     for (int i = 0; i < rows; i++)
 8 |     {
 9 | 
10 |         for (int j = 0; j < rows + i; j++)
11 |         {
12 |             printf(" ");
13 |         }
14 |         for (int k = 0; k < rows - i; k++)
15 |         {
16 |             printf("* ");
17 |         }
18 |         printf("\n");
19 |     }
20 |     return 0;
21 | }
22 | 
23 | 
24 | //extra 
25 | // int main()
26 | // {
27 | //     int rows = 5;
28 | 
29 |     
30 | //     for (int i = 0; i < rows; i++) {
31 | 
32 | 
33 | //         for (int j = 0; j < 2 * i; j++) {
34 | //             printf(" ");
35 | //         }
36 | 
37 | //         for (int k = 0; k < 2 * (rows - i) - 1; k++) {
38 | //             printf("* ");
39 | //         }
40 | //         printf("\n");
41 | //     }
42 | // }


--------------------------------------------------------------------------------
/pattern/Rhombus-pattern.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | 
 3 | int main(int argc, char const *argv[])
 4 | {
 5 | 
 6 |     int rows = 5;
 7 |     for (int i = 0; i < rows; i++)
 8 |     {
 9 | 
10 |         for (int j = 0; j < rows - i; j++)
11 |         {
12 |             printf(" ");
13 |         }
14 |         for (int k = 0; k < rows; k++)
15 |         {
16 |             printf("* ");
17 |         }
18 |         printf("\n");
19 |     }
20 |     return 0;
21 | }
22 | 


--------------------------------------------------------------------------------
/pattern/diamond.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | 
 3 | int main(int argc, char const *argv[])
 4 | {
 5 |     // static approach
 6 |     // int rows = 5;
 7 | 
 8 |     // for (int i = 0; i < rows; i++)
 9 |     // {
10 |         
11 |     //     for (int l = 0; l < rows - i; l++)
12 |     //     {
13 |     //         if (l == 0)
14 |     //         {
15 |     //             printf("    ");
16 |     //         }
17 |     //         printf(" ");
18 |     //     }
19 |     //     for (int m = 0; m <= i; m++)
20 |     //     {
21 |     //         printf("* ");
22 |     //     }
23 |     //     printf("\n");
24 |     // }
25 |     // for (int i = 0; i < rows; i++)
26 |     // {
27 |     //     for (int j = 0; j < rows + i; j++)
28 |     //     {
29 |     //         printf(" ");
30 |     //     }
31 |     //     for (int k = 0; k < rows - i; k++)
32 |     //     {
33 |     //         printf("* ");
34 |     //     }
35 |     //     printf("\n");
36 |     // }
37 |     // return 0;
38 | 
39 |     // dynamic one 
40 |      int n = 5;
41 | 
42 |     
43 |     for (int i = 0; i < 2 * n - 1; i++) {
44 |         // the row number
45 |         int comp;
46 |         if (i < n) {
47 |             comp = 2 * (n - i) - 1;
48 |         }
49 |         else {
50 |             comp = 2 * (i - n + 1) + 1;
51 |         }
52 | 
53 |         // space
54 |         for (int j = 0; j < comp; j++) {
55 |             printf(" ");
56 |         }
57 | 
58 |         for (int k = 0; k < 2 * n - comp; k++) {
59 |             printf("* ");
60 |         }
61 |         printf("\n");
62 |     }
63 |     return 0;
64 | }
65 | 


--------------------------------------------------------------------------------
/pattern/full-pyrm.c:
--------------------------------------------------------------------------------
 1 | // #include <stdio.h>
 2 | 
 3 | // int main()
 4 | // {
 5 | //     int rows = 5;
 6 | //     for (int i = 0; i < rows; i++)
 7 | //     {
 8 | 
 9 | //         for (int j = 0; j < (rows - i); j++)
10 | //         {
11 | //             printf(" ");
12 | //         }
13 | 
14 | //         for (int k = 0; k <= i; k++)
15 | //         {
16 | //             printf("* ");
17 | //         }
18 | //         for (int j = 0; j < (rows - i) ; j++)
19 | //         {
20 | //             printf(" ");
21 | //         }
22 | //         printf("\n");
23 | //     }
24 | //     return 0;
25 | // }
26 | 
27 | 
28 | #include <stdio.h>
29 | 
30 | int main()
31 | {
32 |     int rows = 5;
33 |     for (int i = 0; i < rows; i++)
34 |     {
35 | 
36 |         for (int j = 0; j < (rows - i); j++)
37 |         {
38 |             printf(" ");
39 |         }
40 | 
41 |         for (int k = 0; k <= i; k++)
42 |         {
43 |             printf("* ");
44 |         }
45 |         printf("\n");
46 |     }
47 |     return 0;
48 | }


--------------------------------------------------------------------------------
/pattern/left-hal-pyrm.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | 
 3 | int main()
 4 | {
 5 |     int rows = 5;
 6 |     for (int i = 0; i < rows; i++)
 7 |     {
 8 | 
 9 |         for (int j = 0; j < 2 * (rows - i) - 1; j++)
10 |         {
11 |             printf(" ");
12 |         }
13 | 
14 |         for (int k = 0; k <= i; k++)
15 |         {
16 |             printf("* ");
17 |         }
18 |         for (int j = 0; j < 2 * (rows - i) - 1; j++)
19 |         {
20 |             printf(" ");
21 |         }
22 |         printf("\n");
23 |     }
24 |     return 0;
25 | }


--------------------------------------------------------------------------------
/pattern/right-hal-pyrm.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | 
 3 | int main()
 4 | {
 5 | 
 6 |     for (int i = 5; i < 0; i--){
 7 |              printf(" ");
 8 |         for (int j = i; j < i; j--)
 9 |         {
10 |         printf("%d", j+1);
11 |         }
12 |    
13 |     }
14 | }


--------------------------------------------------------------------------------
/pattern/second-largest.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | 
 3 | void bubbleSort(int arr[], int n) {
 4 |     for (int i = 0; i < n-1; i++) {
 5 |         for (int j = 0; j < n-i-1; j++) {
 6 |             if (arr[j] > arr[j+1]) {
 7 |                 int temp = arr[j];
 8 |                 arr[j] = arr[j+1];
 9 |                 arr[j+1] = temp;
10 |             }
11 |         }
12 |     }
13 | }
14 | 
15 | int secondLargest(int arr[], int n) {
16 |     if (n < 2) return -1;  // size is not enough
17 |     // final result
18 |     for (int i = n-2; i >= 0; i--) {
19 |         if (arr[i] != arr[n-1]) {
20 |             return arr[i];
21 |         }
22 |     }
23 |     return -1; 
24 | }
25 | 
26 | int main() {
27 |     int arr[] = {12, 35, 10000, 1, 34, 10000};
28 |     int n = sizeof(arr) / sizeof(arr[0]);
29 |     bubbleSort(arr, n);
30 |     int result = secondLargest(arr, n);
31 |     
32 |     if (result == -1) {
33 |         printf("There is no second largest element\n");
34 |     } else {
35 |         printf("The second largest element is %d\n", result);
36 |     }
37 |     
38 |     return 0;
39 | }
40 | 
41 | 
42 | 
43 | 
44 | 
45 | // #include <stdio.h>
46 | // #include <limits.h>
47 | 
48 | // int findSecondLargest(int arr[], int size) {
49 | //     if (size < 2) {
50 | //         printf("Array should have at least two elements.\n");
51 | //         return INT_MIN; 
52 | //     }
53 | 
54 | //     int firstLargest, secondLargest;
55 | //     firstLargest = secondLargest = INT_MIN;
56 | 
57 | //     for (int i = 0; i < size; i++) {
58 | //         if (arr[i] > firstLargest) {
59 | //             secondLargest = firstLargest;
60 | //             firstLargest = arr[i];
61 | //         } else if (arr[i] > secondLargest && arr[i] != firstLargest) {
62 | //             secondLargest = arr[i];
63 | //         }
64 | //     }
65 | 
66 | //     if (secondLargest == INT_MIN) {
67 | //         printf("There is no second largest element.\n");
68 | //         return INT_MIN;
69 | //     }
70 | 
71 | //     return secondLargest;
72 | // }
73 | 
74 | // int main() {
75 | //     int arr[] = {12, 35, 1, 10, 34, 100};
76 | //     int size = sizeof(arr) / sizeof(arr[0]);
77 | 
78 | //     int secondLargest = findSecondLargest(arr, size);
79 | 
80 | //     if (secondLargest != INT_MIN) {
81 | //         printf("The second largest element is %d\n", secondLargest);
82 | //     }
83 | 
84 | //     return 0;
85 | // }
86 | 


--------------------------------------------------------------------------------
/pattern/tempCodeRunnerFile.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | 
 3 | int main(int argc, char const *argv[])
 4 | {
 5 | 
 6 |     int rows = 5;
 7 |     for (int i = 0; i < rows; i++)
 8 |     {
 9 | 
10 |         for (int j = 0; j < rows + i; j++)
11 |         {
12 |             printf(" ");
13 |         }
14 |         for (int k = 0; k < rows - i; k++)
15 |         {
16 |             printf("* ");
17 |         }
18 |         printf("\n");
19 |     }
20 |     return 0;
21 | }
22 | 


--------------------------------------------------------------------------------
/python/Air_Quality_prediction/Air_Quality_Prediction.py:
--------------------------------------------------------------------------------
 1 | #import the required libraries:-
 2 | 
 3 | import pandas as pd
 4 | from sklearn.ensemble import RandomForestRegressor
 5 | # RandomForestRegressor is useful because it combines all the other models(linear regressions, logistic regressions, etc..) together to make the prediction more accurate.
 6 | 
 7 | # NOTE: Data cannot be in strings(text, non-numericals), it has to be in numbers(ex- 0,1,2...)
 8 | 
 9 | #function:-
10 | def predict(array_lat_long_min_max :list[int | float] = [0,0,0,0]) -> None:
11 |     
12 |     """
13 |     This function takes 4 parameters because there are 4 features in training model and makes the prediction.
14 | 
15 |     array = [`latitude`,`longitude`,`pollutant_min`,`pollutant_max`]
16 |     
17 |     Array can be in Integer type or Float type
18 |     """
19 | 
20 |     result = rfr.predict([array_lat_long_min_max]).item()
21 |     print("Average air quality index(pollutant):",result)
22 | 
23 | 
24 | # loading the dataset using pandas module:-
25 | path_of_dataset = "Air_Quality.csv" # path of the csv file
26 | data = pd.read_csv(path_of_dataset, skipinitialspace=True)
27 | 
28 | 
29 | data = data.dropna() # drop the NaN rows from the dataset because they are not required
30 | 
31 | 
32 | # prints the first 5 rows of the dataset:-
33 | # print(data.head())
34 | 
35 | 
36 | # initializing the class RandomForestRegressor:-
37 | rfr = RandomForestRegressor()
38 | 
39 | 
40 | # creating models:-
41 | features = ['latitude', 'longitude', 'pollutant_min', 'pollutant_max']
42 | train_value = data[features].values # .values is important for not getting any warnings
43 | # the above train value is for the input given by the user for predictions 
44 | target_value = data['pollutant_avg']
45 | # the above target value is for the output which will be predicted
46 | 
47 | 
48 | # check for the data in train_value and target_value:-
49 | # print(train_value)
50 | # print(target_value)
51 | 
52 | 
53 | # fitting the data:-
54 | rfr.fit(train_value, target_value)
55 | 
56 | 
57 | try:
58 |     # user input:-
59 |     array = list(map(float, input("Enter latitude longitude min_pollutant max_pollutant: ").split(" ")))
60 | 
61 | 
62 |     # finding the accuracy:-
63 |     accuracy = rfr.score(train_value,target_value)*100
64 |     print(f"The accuracy score of this model is {accuracy:0.2f}")
65 | 
66 | 
67 |     # prediction:-
68 |     predict(array)
69 | 
70 | 
71 | except (Exception, ValueError): # multiple error handling
72 |     print("Please give numerical values in latitude longitude min_pollutant max_pollutant!")


--------------------------------------------------------------------------------
/python/Air_Quality_prediction/output.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/python/Air_Quality_prediction/output.png


--------------------------------------------------------------------------------
/python/Quick_sort.py:
--------------------------------------------------------------------------------
 1 | # Function to swap two elements
 2 | def swap(arr, i, j):
 3 |     arr[i], arr[j] = arr[j], arr[i]
 4 | 
 5 | # Partition function to rearrange the array
 6 | def partition(arr, low, high):
 7 |     pivot = arr[high]  # Pivot element (typically the last element)
 8 |     i = low - 1        # Index of the smaller element
 9 | 
10 |     for j in range(low, high):
11 |         # If current element is smaller than or equal to pivot
12 |         if arr[j] <= pivot:
13 |             i += 1
14 |             swap(arr, i, j)  # Swap smaller element with element at i
15 | 
16 |     swap(arr, i + 1, high)  # Place the pivot in its correct position
17 |     return i + 1            # Return the partition index
18 | 
19 | # Quick Sort function
20 | def quick_sort(arr, low, high):
21 |     if low < high:
22 |         # pi is the partition index
23 |         pi = partition(arr, low, high)
24 | 
25 |         # Recursively sort elements before and after partition
26 |         quick_sort(arr, low, pi - 1)
27 |         quick_sort(arr, pi + 1, high)
28 | 
29 | # Utility function to print an array
30 | def print_array(arr):
31 |     for i in arr:
32 |         print(i, end=" ")
33 |     print()
34 | 
35 | # Main function to test the quick sort
36 | if __name__ == "__main__":
37 |     arr = [10, 7, 8, 9, 1, 5]
38 |     n = len(arr)
39 | 
40 |     print("Unsorted array:")
41 |     print_array(arr)
42 | 
43 |     # Perform Quick Sort
44 |     quick_sort(arr, 0, n - 1)
45 | 
46 |     print("Sorted array:")
47 |     print_array(arr)
48 | 


--------------------------------------------------------------------------------
/python/bubsort.py:
--------------------------------------------------------------------------------
 1 | def bubble_sort(arr):
 2 | 
 3 |     # Outer loop to iterate through the list n times
 4 |     for n in range(len(arr) - 1, 0, -1):
 5 | 
 6 |         # Inner loop to compare adjacent elements
 7 |         for i in range(n):
 8 |             if arr[i] > arr[i + 1]:
 9 | 
10 |                 # Swap elements if they are in the wrong order
11 |                 swapped = True
12 |                 arr[i], arr[i + 1] = arr[i + 1], arr[i]
13 | 
14 | 
15 | # Sample list to be sorted
16 | arr = [39, 12, 18, 85, 72, 10, 2, 18]
17 | print("Unsorted list is:")
18 | print(arr)
19 | 
20 | bubble_sort(arr)
21 | 
22 | print("Sorted list is:")
23 | print(arr)
24 | 


--------------------------------------------------------------------------------
/python/heapsort.py:
--------------------------------------------------------------------------------
 1 | def heapify(arr, n, i):
 2 |     largest = i  # Initialize largest as root
 3 |     left = 2 * i + 1  # Left child
 4 |     right = 2 * i + 2  # Right child
 5 | 
 6 |     # Check if left child exists and is greater than root
 7 |     if left < n and arr[i] < arr[left]:
 8 |         largest = left
 9 | 
10 |     # Check if right child exists and is greater than largest so far
11 |     if right < n and arr[largest] < arr[right]:
12 |         largest = right
13 | 
14 |     # Swap and continue heapifying if root is not the largest
15 |     if largest != i:
16 |         arr[i], arr[largest] = arr[largest], arr[i]
17 |         heapify(arr, n, largest)
18 | 
19 | def heap_sort(arr):
20 |     n = len(arr)
21 | 
22 |     # Build a max heap
23 |     for i in range(n // 2 - 1, -1, -1):
24 |         heapify(arr, n, i)
25 | 
26 |     # Extract elements one by one
27 |     for i in range(n - 1, 0, -1):
28 |         arr[i], arr[0] = arr[0], arr[i]  # Swap
29 |         heapify(arr, i, 0)
30 | 
31 | # Get user input
32 | user_input = input("Enter numbers separated by spaces: ")
33 | arr = list(map(int, user_input.split()))
34 | 
35 | # Sort the array
36 | heap_sort(arr)
37 | 
38 | # Display the sorted array
39 | print("Sorted array is:", arr)
40 | 


--------------------------------------------------------------------------------
/python/secondLargest.py:
--------------------------------------------------------------------------------
 1 | #User function Template for python3
 2 | class Solution:
 3 |     def getSecondLargest(self, arr):
 4 |         # Code Here
 5 |         largest = -1
 6 |         sLargest = -1
 7 |         for i in arr:
 8 |             if i > largest:
 9 |                 sLargest = largest
10 |                 largest = i
11 |             if i < largest and i > sLargest:
12 |                 sLargest = i
13 |         return sLargest        
14 | 
15 | 
16 | #{ 
17 |  # Driver Code Starts
18 | # Initial Template for Python 3
19 | 
20 | if __name__ == "__main__":
21 |     t = int(input())
22 |     for _ in range(t):
23 |         arr = list(map(int, input().split()))
24 |         ob = Solution()
25 |         ans = ob.getSecondLargest(arr)
26 |         print(ans)
27 | 
28 | # } Driver Code Ends


--------------------------------------------------------------------------------
/python/study.py:
--------------------------------------------------------------------------------
 1 | import pandas as pd
 2 | import time
 3 | import os
 4 | from faker import Faker
 5 | import matplotlib.pyplot as plt
 6 | fake = Faker()
 7 | data = []
 8 | for _ in range(100000):  # Generate 100,000 records
 9 |     data.append({
10 |         'name': fake.name(),
11 |         'address': fake.address(),
12 |         'email': fake.email(),
13 |         'date_joined': fake.date(),
14 |         'salary': fake.random_number(digits=5)
15 |     })
16 | df = pd.DataFrame(data)
17 | def write_csv(df, filename):
18 |     start = time.time()
19 |     df.to_csv(filename, index=False)
20 |     return time.time() - start
21 | 
22 | def write_parquet(df, filename):
23 |     start = time.time()
24 |     df.to_parquet(filename)
25 |     return time.time() - start
26 | def read_csv(filename):
27 |     start = time.time()
28 |     df = pd.read_csv(filename)
29 |     return time.time() - start
30 | 
31 | def read_parquet(filename):
32 |     start = time.time()
33 |     df = pd.read_parquet(filename)
34 |     return time.time() - start
35 | csv_file = 'data.csv'
36 | parquet_file = 'data.parquet'
37 | write_times = {
38 |     'CSV': write_csv(df, csv_file),
39 |     'Parquet': write_parquet(df, parquet_file)
40 | }
41 | read_times = {
42 |     'CSV': read_csv(csv_file),
43 |     'Parquet': read_parquet(parquet_file)
44 | }
45 | labels = ['CSV', 'Parquet']
46 | write_times_values = [write_times['CSV'], write_times['Parquet']]
47 | read_times_values = [read_times['CSV'], read_times['Parquet']]
48 | # Plotting
49 | x = range(len(labels))
50 | width = 0.35  # Width of bars
51 | 
52 | fig, ax = plt.subplots()
53 | ax.bar(x, write_times_values, width, label='Write Time (seconds)', color='b')
54 | ax.bar([p + width for p in x], read_times_values, width, label='Read Time (seconds)', color='g')
55 | 
56 | # Adding labels and title
57 | ax.set_xlabel('File Formats')
58 | ax.set_ylabel('Time (seconds)')
59 | ax.set_title('Comparison of Read/Write Times for CSV and Parquet')
60 | ax.set_xticks([p + width / 2 for p in x])
61 | ax.set_xticklabels(labels)
62 | ax.legend()
63 | 
64 | # Show the plot
65 | plt.tight_layout()
66 | plt.show()
67 | 


--------------------------------------------------------------------------------
/to_do_list.html:
--------------------------------------------------------------------------------
 1 | //index.html
 2 | 
 3 | <!DOCTYPE html>
 4 | <html lang="en">
 5 | 
 6 | <head>
 7 |     <meta charset="UTF-8">
 8 |     <meta name="viewport" content=
 9 |         "width=device-width, initial-scale=1.0">
10 | 
11 |     <link rel="stylesheet" href=
12 | "https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/css/bootstrap.min.css"
13 |         integrity=
14 | "sha384-ggOyR0iXCbMQv3Xipma34MD+dH/1fQ784/j6cY/iJTQUOhcWr7x9JvoRxT2MZw1T"
15 |         crossorigin="anonymous">
16 | 
17 |     <script src="app.js"></script>
18 | 
19 |     <title>To Do List</title>
20 | </head>
21 | 
22 | <body>
23 |     <header class="bg-success text-white p-5">
24 |         <div class="container">
25 |             <div class="row">
26 |                 <div class="col-lg-12 col-md-12 col-sm-12">
27 |                     <font face="Comic sans MS"
28 |                         size="11" color="black">
29 |                         <strong>ToDo List</strong>
30 |                     </font>
31 |                     
32 |                 </div>
33 |             </div>
34 |         </div>
35 |     </header>
36 | 
37 |     <div class="container mt-3">
38 |         <h2>Add Items</h2>
39 | 
40 |         <label id="lblsuccess" class="text-success"
41 |                 style="display: none;">
42 |         </label>
43 |         
44 |         <form id="addForm">
45 |             <div class="row">
46 |                 <div class="col-lg-7 col-md-7 col-sm-7">
47 | 
48 |                     <input type="text" onkeyup=
49 |                         "toggleButton(this, 'submit')"
50 |                         class="form-control" id="item">
51 |                 </div>
52 | 
53 |                 <div class="col-lg-5 col-md-5 col-sm-5">
54 |                 <input type="submit" class="btn btn-dark"
55 |                         id="submit" value="Submit" disabled>
56 |                 </div>
57 |             </div>
58 |         </form>
59 | 
60 |         <h3 class="mt-4">Tasks</h3>
61 | 
62 |         <form id="addForm">
63 |             <ul class="list-group" id="items"></ul>
64 |         </form>
65 |     </div>
66 | </body>
67 | 
68 | </html>
69 | 


--------------------------------------------------------------------------------
/webdevproject/contributing.md:
--------------------------------------------------------------------------------
1 | # contributor : v-aibha-v-jain
2 | 
3 | 
4 | ### Features
5 | 
6 | - We have seen a lot of site which has this property of drag and drop but we don't get this much on mobile phones since drag and drop properties differ on cell phone devices
7 | - Here is a solution a free mode drag and drop site which even works on mobile phones
8 | - There is a frame by which the images don't leave the space (board)


--------------------------------------------------------------------------------
/webdevproject/drag_drop_site/img1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/webdevproject/drag_drop_site/img1.jpg


--------------------------------------------------------------------------------
/webdevproject/drag_drop_site/img2.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/webdevproject/drag_drop_site/img2.jpg


--------------------------------------------------------------------------------
/webdevproject/drag_drop_site/img3.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pravocodes/Hacktoberfest2024/9e7b8c28192c47e2de646b55a27bf0fdcd4fa7ec/webdevproject/drag_drop_site/img3.jpg


--------------------------------------------------------------------------------
/webdevproject/drag_drop_site/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 | <head>
 4 | <title>Drag and Drop</title>
 5 | <link rel="stylesheet" href="style.css">
 6 | </head>
 7 | <body>
 8 |       <div id="text" ondrop="drop(event)" ondragover="allowDrop(event)" droppable="true"></div>
 9 |       <br>
10 |       <div id="images">
11 |         <div class="drag1" id="drag1" draggable="true" ondragstart="drag(event)" droppable="false"></div>
12 |         <div class="drag5" id="drag5" draggable="true" ondragstart="drag(event)" droppable="false"></div>
13 |         <div class="drag6" id="drag6" draggable="true" ondragstart="drag(event)" droppable="false"></div>
14 |       </div>
15 |       
16 |       <script src="script.js"></script>
17 | </body>
18 | </html>
19 | 


--------------------------------------------------------------------------------
/webdevproject/drag_drop_site/style.css:
--------------------------------------------------------------------------------
 1 | body {
 2 |   background: #6b6b69;
 3 |   color: white;
 4 | }
 5 | 
 6 | .info {
 7 |   position: relative;
 8 |   font-family: Arial;
 9 |   margin: 10px;
10 |   text-align: center;
11 |   border-radius: 5px;
12 |   font-size: 15px;
13 | }
14 | 
15 | #title {
16 |   font-size: 20px;
17 | }
18 | 
19 | #rest2 {
20 |   font-size: 13px;
21 | }
22 | 
23 | #text {
24 |   width: 150px;
25 |   height: 100px;
26 |   background-color: rgba(0, 0, 0, 0.233);
27 |   display: flex;
28 |   position: relative;
29 | }
30 | 
31 | #images {
32 |   width: 100%;
33 | }
34 | 
35 | img {
36 |   height: 200px;
37 |   width: 200px;
38 | }
39 | 
40 | #drag1,
41 | #drag5,
42 | #drag6,
43 | #drag7,
44 | #drag8,
45 | #drag9,
46 | #drag10,
47 | #drag11,
48 | #drag12 {
49 |   height: 50px;
50 |   width: 50px;
51 |   display: inline-block;
52 | }
53 | 
54 | #drag1{
55 |   background-image: url("./img1.jpg");
56 |   background-repeat: no-repeat;
57 |   background-size: cover;
58 | }
59 | 
60 | #drag5{
61 |   background-image: url("./img2.jpg");
62 |   background-repeat: no-repeat;
63 |   background-size: cover;
64 | }
65 | 
66 | #drag6{
67 |   background-image: url("./img3.jpg");
68 |   background-repeat: no-repeat;
69 |   background-size: cover;
70 |   height: 75px;
71 | }


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