|
1 | 1 | [ |
2 | 2 | { |
3 | | - "categoryName": "Basics", |
| 3 | + "name": "Basics", |
4 | 4 | "snippets": [ |
5 | 5 | { |
6 | 6 | "title": "Hello, World!", |
|
16 | 16 | ] |
17 | 17 | }, |
18 | 18 | { |
19 | | - "categoryName": "Mathematical Functions", |
| 19 | + "name": "Mathematical Functions", |
20 | 20 | "snippets": [ |
21 | 21 | { |
22 | 22 | "title": "Factorial Function", |
|
28 | 28 | ], |
29 | 29 | "contributors": [], |
30 | 30 | "code": "int factorial(int x) {\n int y = 1;\n\n for (int i = 2; i <= x; i++)\n y *= i;\n\n return y;\n}\n\n// Usage:\nfactorial(4); // Returns: 24\n" |
| 31 | + }, |
| 32 | + { |
| 33 | + "title": "Swap numbers", |
| 34 | + "description": "Swaps two numbers without using third variable", |
| 35 | + "author": "Emosans", |
| 36 | + "tags": [ |
| 37 | + "swap", |
| 38 | + "numbers" |
| 39 | + ], |
| 40 | + "contributors": [], |
| 41 | + "code": "#include<stdio.h>\nvoid swap(int* num1,int* num2){\n *num1 = *num1 + *num2;\n *num2 = *num1 - *num2;\n *num1 = *num1 - *num2;\n}\n\n// Usage:\nint a = 3,b = 4;\nswap(&a,&b); // swaps the values of the a and b variables\n" |
| 42 | + } |
| 43 | + ] |
| 44 | + }, |
| 45 | + { |
| 46 | + "name": "Search", |
| 47 | + "snippets": [ |
| 48 | + { |
| 49 | + "title": "Binary Search ", |
| 50 | + "description": "Searches for an element in a sorted array using the Binary Search algorithm.", |
| 51 | + "author": "0xHouss", |
| 52 | + "tags": [ |
| 53 | + "search", |
| 54 | + "binarysearch", |
| 55 | + "array", |
| 56 | + "algorithm" |
| 57 | + ], |
| 58 | + "contributors": [], |
| 59 | + "code": "int binarySearch(int arr[], int low, int high, int x) {\n while (low <= high) {\n int mid = low + (high - low) / 2;\n\n // Check if x is present at mid\n if (arr[mid] == x) {\n return mid;\n }\n\n // If x is smaller, search the left half\n if (arr[mid] > x) {\n high = mid - 1;\n } else { // If x is larger, search the right half\n low = mid + 1;\n }\n }\n return -1; // Element not found\n}\n\n// Usage:\nint arr[] = {2, 3, 4, 10, 40};\nint n = sizeof(arr) / sizeof(arr[0]);\nint x = 10;\nint result = binarySearch(arr, 0, n - 1, x);\n// result = 3 (index of the element 10)\n\n\n" |
| 60 | + }, |
| 61 | + { |
| 62 | + "title": "Linear Search ", |
| 63 | + "description": "Searches for an element in an array using the Linear Search algorithm.", |
| 64 | + "author": "0xHouss", |
| 65 | + "tags": [ |
| 66 | + "search", |
| 67 | + "linearsearch", |
| 68 | + "array", |
| 69 | + "algorithm" |
| 70 | + ], |
| 71 | + "contributors": [], |
| 72 | + "code": "int linearSearch(int arr[], int n, int x) {\n for (int i = 0; i < n; i++) {\n if (arr[i] == x) {\n return i; // Element found at index i\n }\n }\n return -1; // Element not found\n}\n\n// Usage:\nint arr[] = {10, 20, 30, 40, 50};\nint n = sizeof(arr) / sizeof(arr[0]);\nint x = 30;\nint result = linearSearch(arr, n, x);\n// result = 2 (index of the element 30)\n\n" |
| 73 | + } |
| 74 | + ] |
| 75 | + }, |
| 76 | + { |
| 77 | + "name": "Sorting", |
| 78 | + "snippets": [ |
| 79 | + { |
| 80 | + "title": "Bubble Sort ", |
| 81 | + "description": "Sorts an array of integers using the Bubble Sort algorithm.", |
| 82 | + "author": "0xHouss", |
| 83 | + "tags": [ |
| 84 | + "sorting", |
| 85 | + "bubblesort", |
| 86 | + "array", |
| 87 | + "algorithm" |
| 88 | + ], |
| 89 | + "contributors": [], |
| 90 | + "code": "void bubbleSort(int arr[], int n) {\n for (int i = 0; i < n - 1; i++) {\n for (int j = 0; j < n - i - 1; j++) {\n if (arr[j] > arr[j + 1]) {\n // Swap arr[j] and arr[j + 1]\n int temp = arr[j];\n arr[j] = arr[j + 1];\n arr[j + 1] = temp;\n }\n }\n }\n}\n\n// Usage:\nint arr[] = {64, 34, 25, 12, 22, 11, 90};\nint n = sizeof(arr) / sizeof(arr[0]);\nbubbleSort(arr, n);\n// Now arr[] is sorted: {11, 12, 22, 25, 34, 64, 90}\n" |
| 91 | + }, |
| 92 | + { |
| 93 | + "title": "Insertion Sort ", |
| 94 | + "description": "Sorts an array of integers using the Insertion Sort algorithm.", |
| 95 | + "author": "0xHouss", |
| 96 | + "tags": [ |
| 97 | + "sorting", |
| 98 | + "insertionsort", |
| 99 | + "array", |
| 100 | + "algorithm" |
| 101 | + ], |
| 102 | + "contributors": [], |
| 103 | + "code": "void insertionSort(int arr[], int n) {\n for (int i = 1; i < n; i++) {\n int key = arr[i];\n int j = i - 1;\n\n // Move elements of arr[0..i-1] that are greater than key\n // to one position ahead of their current position\n while (j >= 0 && arr[j] > key) {\n arr[j + 1] = arr[j];\n j--;\n }\n arr[j + 1] = key;\n }\n}\n\n// Usage:\nint arr[] = {12, 11, 13, 5, 6};\nint n = sizeof(arr) / sizeof(arr[0]);\ninsertionSort(arr, n);\n// Now arr[] is sorted: {5, 6, 11, 12, 13}\n\n" |
| 104 | + }, |
| 105 | + { |
| 106 | + "title": "Merge Sort ", |
| 107 | + "description": "Sorts an array of integers using the Merge Sort algorithm.", |
| 108 | + "author": "0xHouss", |
| 109 | + "tags": [ |
| 110 | + "sorting", |
| 111 | + "mergesort", |
| 112 | + "array", |
| 113 | + "algorithm" |
| 114 | + ], |
| 115 | + "contributors": [], |
| 116 | + "code": "#include <stdio.h>\n\nvoid merge(int arr[], int l, int m, int r) {\n int n1 = m - l + 1;\n int n2 = r - m;\n\n // Temporary arrays\n int L[n1], R[n2];\n\n // Copy data to temporary arrays L[] and R[]\n for (int i = 0; i < n1; i++)\n L[i] = arr[l + i];\n for (int j = 0; j < n2; j++)\n R[j] = arr[m + 1 + j];\n\n int i = 0, j = 0, k = l;\n\n // Merge the temporary arrays back into arr[l..r]\n while (i < n1 && j < n2) {\n if (L[i] <= R[j]) {\n arr[k] = L[i];\n i++;\n } else {\n arr[k] = R[j];\n j++;\n }\n k++;\n }\n\n // Copy remaining elements of L[], if any\n while (i < n1) {\n arr[k] = L[i];\n i++;\n k++;\n }\n\n // Copy remaining elements of R[], if any\n while (j < n2) {\n arr[k] = R[j];\n j++;\n k++;\n }\n}\n\nvoid mergeSort(int arr[], int l, int r) {\n if (l < r) {\n int m = l + (r - l) / 2;\n\n // Sort first and second halves\n mergeSort(arr, l, m);\n mergeSort(arr, m + 1, r);\n\n merge(arr, l, m, r);\n }\n}\n\n// Usage:\nint arr[] = {38, 27, 43, 3, 9, 82, 10};\nint n = sizeof(arr) / sizeof(arr[0]);\nmergeSort(arr, 0, n - 1);\n// Now arr[] is sorted: {3, 9, 10, 27, 38, 43, 82}\n\n" |
| 117 | + }, |
| 118 | + { |
| 119 | + "title": "Quick Sort ", |
| 120 | + "description": "Sorts an array of integers using the Quick Sort algorithm.", |
| 121 | + "author": "0xHouss", |
| 122 | + "tags": [ |
| 123 | + "sorting", |
| 124 | + "quicksort", |
| 125 | + "array", |
| 126 | + "algorithm" |
| 127 | + ], |
| 128 | + "contributors": [], |
| 129 | + "code": "int partition(int arr[], int low, int high) {\n int pivot = arr[high]; // Pivot element\n int i = low - 1;\n\n for (int j = low; j < high; j++) {\n if (arr[j] < pivot) {\n i++;\n // Swap arr[i] and arr[j]\n int temp = arr[i];\n arr[i] = arr[j];\n arr[j] = temp;\n }\n }\n\n // Swap arr[i + 1] and arr[high] (pivot)\n int temp = arr[i + 1];\n arr[i + 1] = arr[high];\n arr[high] = temp;\n\n return i + 1;\n}\n\nvoid quickSort(int arr[], int low, int high) {\n if (low < high) {\n int pi = partition(arr, low, high);\n\n // Recursively sort elements before and after partition\n quickSort(arr, low, pi - 1);\n quickSort(arr, pi + 1, high);\n }\n}\n\n// Usage:\nint arr[] = {10, 7, 8, 9, 1, 5};\nint n = sizeof(arr) / sizeof(arr[0]);\nquickSort(arr, 0, n - 1);\n// Now arr[] is sorted: {1, 5, 7, 8, 9, 10}\n\n" |
| 130 | + }, |
| 131 | + { |
| 132 | + "title": "Selection Sort ", |
| 133 | + "description": "Sorts an array of integers using the Selection Sort algorithm.", |
| 134 | + "author": "0xHouss", |
| 135 | + "tags": [ |
| 136 | + "sorting", |
| 137 | + "selectionsort", |
| 138 | + "array", |
| 139 | + "algorithm" |
| 140 | + ], |
| 141 | + "contributors": [], |
| 142 | + "code": "void selectionSort(int arr[], int n) {\n for (int i = 0; i < n - 1; i++) {\n int minIdx = i;\n\n // Find the minimum element in the unsorted part of the array\n for (int j = i + 1; j < n; j++) {\n if (arr[j] < arr[minIdx]) {\n minIdx = j;\n }\n }\n\n // Swap the found minimum element with the first element of the unsorted part\n int temp = arr[minIdx];\n arr[minIdx] = arr[i];\n arr[i] = temp;\n }\n}\n\n// Usage:\nint arr[] = {64, 25, 12, 22, 11};\nint n = sizeof(arr) / sizeof(arr[0]);\nselectionSort(arr, n);\n// Now arr[] is sorted: {11, 12, 22, 25, 64}\n\n" |
31 | 143 | } |
32 | 144 | ] |
33 | 145 | } |
|
0 commit comments