NASA Document Secret
NASA Document Secret
1. Bubble Sort
==================================================
#include <stdio.h>
int main() {
int arr[] = {64, 34, 25, 12, 22, 11, 90};
int n = sizeof(arr) / sizeof(arr[0]);
bubbleSort(arr, n);
printf("Bubble Sorted array: \n");
printArray_bubble(arr, n);
return 0;
}
==================================================
2. Insertion Sort
==================================================
#include <stdio.h>
void insertionSort(int arr[], int n) {
int i, key, j;
for (i = 1; i < n; i++) {
key = arr[i];
j = i - 1;
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j = j - 1;
}
arr[j + 1] = key;
}
}
int main() {
int arr[] = {12, 11, 13, 5, 6};
int n = sizeof(arr) / sizeof(arr[0]);
insertionSort(arr, n);
printf("Insertion Sorted array: \n");
printArray_insertion(arr, n);
return 0;
}
==================================================
3. Selection Sort
==================================================
#include <stdio.h>
int main() {
int arr[] = {64, 25, 12, 22, 11};
int n = sizeof(arr) / sizeof(arr[0]);
selectionSort(arr, n);
printf("Selection Sorted array: \n");
printArray_selection(arr, n);
return 0;
}
==================================================
4. Heap Sort
==================================================
#include <stdio.h>
if (largest != i) {
swap_heap(&arr[i], &arr[largest]);
heapify(arr, n, largest);
}
}
int main() {
int arr[] = {12, 11, 13, 5, 6, 7};
int n = sizeof(arr) / sizeof(arr[0]);
heapSort(arr, n);
printf("Heap Sorted array: \n");
printArray_heap(arr, n);
return 0;
}
==================================================
5. Binary Search (Divide and Conquer)
==================================================
#include <stdio.h>
int binarySearch(int arr[], int left, int right, int x) {
if (right >= left) {
int mid = left + (right - left) / 2;
if (arr[mid] == x)
return mid;
if (arr[mid] > x)
return binarySearch(arr, left, mid - 1, x);
return binarySearch(arr, mid + 1, right, x);
}
return -1;
}
int main() {
int arr[] = {2, 3, 4, 10, 40};
int n = sizeof(arr) / sizeof(arr[0]);
int x = 10;
printf("Binary Search:\nArray: ");
for(int i=0; i<n; i++) printf("%d ", arr[i]);
printf("\nElement to search: %d\n", x);
int result = binarySearch(arr, 0, n - 1, x);
if (result == -1)
printf("Element is not present in array\n");
else
printf("Element is present at index %d\n", result);
return 0;
}
==================================================
6. Min-Max Finding (Divide and Conquer)
==================================================
#include <stdio.h>
void minMax(int arr[], int left, int right, int *min_val, int *max_val){
if(left == right){
*min_val = arr[left];
*max_val = arr[left];
return;
}
if(left == (right-1)){
if(arr[left]>arr[right]){
*min_val = arr[right];
*max_val = arr[left];
}else {
*max_val = arr[right];
*min_val = arr[left];
}
return;
}
minMax(arr,left,mid,min_val,max_val);
minMax(arr,(mid+1),right,&min1,&max1);
int main() {
int arr[] = {22,13,-5,-8,15,60,17,31,47};
int min_result,max_result;
int n = sizeof(arr)/sizeof(arr[0]);
if (n > 0) {
minMax(arr,0, n-1 ,&min_result,&max_result);
printf("Min : %d \n",min_result);
printf("Max : %d \n",max_result);
} else {
printf("Array is empty.\n");
}
return 0;
}
==================================================
7. Merge Sort (Divide and Conquer)
==================================================
#include <stdio.h>
#include <stdlib.h>
i = 0;
j = 0;
k = left;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
arr[k] = L[i];
i++;
} else {
arr[k] = R[j];
j++;
}
k++;
}
int main() {
int arr[] = {12, 11, 13, 5, 6, 7};
int arr_size = sizeof(arr) / sizeof(arr[0]);
printf("Merge Sort:\nGiven array is \n");
printArray_merge(arr, arr_size);
mergeSort(arr, 0, arr_size - 1);
printf("\nSorted array is \n");
printArray_merge(arr, arr_size);
return 0;
}
==================================================
8. Knapsack (Greedy - Image-based)
==================================================
#include <stdio.h>
int main() {
int p_profits[] = {25, 24, 15};
int w_weights[] = {18, 15, 10};
int n_items = sizeof(p_profits) / sizeof(p_profits[0]);
int capacity_m = 20;
==================================================
9. Job Sequencing with Deadlines (Greedy - Image-based)
==================================================
#include <stdio.h>
#include <stdlib.h>
void swap_JobSeq_Image(int *a, int *b) {
int temp = *a;
*a = *b;
*b = temp;
}
void jobSeq_Image(int n_jobs, int profits[], int deadlines[], int original_job_ids_param[], int
result_job_slots[], int max_deadline_m) {
int job_indices_internal[n_jobs];
int temp_profits[n_jobs];
int temp_deadlines[n_jobs];
int i, j, k;
int main() {
int profits_arr[] = {20, 15, 10, 5, 1};
int deadlines_arr[] = {2, 2, 1, 3, 3};
int n = sizeof(profits_arr) / sizeof(profits_arr[0]);
int job_ids[n];
for(int i=0; i<n; i++) job_ids[i] = i+1;
if (n > 0) {
jobSeq_Image(n, profits_arr, deadlines_arr, job_ids, result_jobs, max_d);
} else {
printf("No jobs to schedule.\n");
}
return 0;
}
==================================================
10. Multistage Graph (Dynamic Programming - Image-based)
==================================================
#include <stdio.h>
#include <limits.h>
cost_ms[destination_node] = 0;
path_ms[destination_node] = destination_node;
if (cost_ms[start_node] == INT_MAX) {
printf("No path from start node %d to destination node %d.\n", start_node,
destination_node);
return;
}
int main() {
printf("Multistage Graph (Image Style):\n");
int vertices1 = 6;
int exampleGraph_ms1[6][6] = {
{0, 2, 3, 0, 0, 0},
{0, 0, 0, 2, 3, 0},
{0, 0, 0, 3, 1, 0},
{0, 0, 0, 0, 0, 2},
{0, 0, 0, 0, 0, 3},
{0, 0, 0, 0, 0, 0}
};
==================================================
11. N-Queen (Backtracking - Image-based 4-Queen)
==================================================
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define N_VALUE 4
int board_nq[N_VALUE];
int solution_count_nq = 0;
void printBoard_NQueen_Image() {
solution_count_nq++;
printf("Solution %d:\n", solution_count_nq);
for (int i = 0; i < N_VALUE; i++) {
for (int j = 0; j < N_VALUE; j++) {
if (board_nq[i] == j) {
printf("Q ");
} else {
printf(". ");
}
}
printf("\n");
}
printf("\n");
}
int isSafe_NQueen_Image(int row, int col) {
for (int i = 0; i < row; i++) {
if (board_nq[i] == col) {
return 0;
}
if (abs(board_nq[i] - col) == abs(i - row)) {
return 0;
}
}
return 1;
}
int main() {
printf("N-Queen Problem for N = %d (Image Style - All Solutions):\n", N_VALUE);
solveNQueens_Image(0);
if (solution_count_nq == 0) {
printf("No solutions found for N = %d.\n", N_VALUE);
}
return 0;
}