examples

/*
 * =============================================================================
 * ONE-DIMENSIONAL ARRAYS - EXAMPLES FILE
 * =============================================================================
 * 
 * This file demonstrates one-dimensional arrays in C.
 * Topics: declaration, initialization, access, operations, and more.
 * 
 * Compilation: gcc examples.c -o examples
 * Execution: ./examples
 * =============================================================================
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/*
 * =============================================================================
 * EXAMPLE 1: Array Declaration and Initialization
 * =============================================================================
 */
void example1_declaration_init(void) {
    printf("\n=== Example 1: Array Declaration and Initialization ===\n");
    
    // Method 1: Declare then initialize
    int arr1[5];
    arr1[0] = 10;
    arr1[1] = 20;
    arr1[2] = 30;
    arr1[3] = 40;
    arr1[4] = 50;
    
    // Method 2: Initialize at declaration
    int arr2[5] = {10, 20, 30, 40, 50};
    
    // Method 3: Partial initialization (rest are 0)
    int arr3[5] = {10, 20};  // {10, 20, 0, 0, 0}
    
    // Method 4: All zeros
    int arr4[5] = {0};  // {0, 0, 0, 0, 0}
    
    // Method 5: Size from initializer
    int arr5[] = {10, 20, 30};  // Size is 3
    
    printf("arr1: ");
    for (int i = 0; i < 5; i++) printf("%d ", arr1[i]);
    
    printf("\narr2: ");
    for (int i = 0; i < 5; i++) printf("%d ", arr2[i]);
    
    printf("\narr3 (partial): ");
    for (int i = 0; i < 5; i++) printf("%d ", arr3[i]);
    
    printf("\narr4 (all zeros): ");
    for (int i = 0; i < 5; i++) printf("%d ", arr4[i]);
    
    printf("\narr5 (auto size): ");
    int size5 = sizeof(arr5) / sizeof(arr5[0]);
    for (int i = 0; i < size5; i++) printf("%d ", arr5[i]);
    printf("(size: %d)\n", size5);
}

/*
 * =============================================================================
 * EXAMPLE 2: Accessing Array Elements
 * =============================================================================
 */
void example2_access(void) {
    printf("\n=== Example 2: Accessing Array Elements ===\n");
    
    int numbers[5] = {100, 200, 300, 400, 500};
    
    printf("Array contents:\n");
    for (int i = 0; i < 5; i++) {
        printf("  numbers[%d] = %d\n", i, numbers[i]);
    }
    
    // Modifying elements
    printf("\nModifying elements:\n");
    numbers[0] = 111;
    numbers[2] = 333;
    numbers[4] = 555;
    
    printf("After modification:\n");
    for (int i = 0; i < 5; i++) {
        printf("  numbers[%d] = %d\n", i, numbers[i]);
    }
    
    // Using expressions as index
    int index = 2;
    printf("\nUsing variable as index:\n");
    printf("  numbers[index] where index=%d: %d\n", index, numbers[index]);
    printf("  numbers[index+1]: %d\n", numbers[index + 1]);
}

/*
 * =============================================================================
 * EXAMPLE 3: Array Memory Layout
 * =============================================================================
 */
void example3_memory(void) {
    printf("\n=== Example 3: Array Memory Layout ===\n");
    
    int arr[5] = {10, 20, 30, 40, 50};
    
    printf("Memory layout of int arr[5]:\n\n");
    printf("Index    Address         Value\n");
    printf("─────────────────────────────────\n");
    
    for (int i = 0; i < 5; i++) {
        printf("  [%d]    %p    %d\n", i, (void*)&arr[i], arr[i]);
    }
    
    printf("\nSize information:\n");
    printf("  sizeof(arr) = %zu bytes (total)\n", sizeof(arr));
    printf("  sizeof(arr[0]) = %zu bytes (per element)\n", sizeof(arr[0]));
    printf("  Number of elements = %zu\n", sizeof(arr) / sizeof(arr[0]));
    
    printf("\nAddress arithmetic:\n");
    printf("  Base address: %p\n", (void*)arr);
    printf("  &arr[0]: %p (same as base)\n", (void*)&arr[0]);
    printf("  &arr[1]: %p (+4 bytes)\n", (void*)&arr[1]);
    printf("  &arr[2]: %p (+8 bytes)\n", (void*)&arr[2]);
}

/*
 * =============================================================================
 * EXAMPLE 4: Array Input from User
 * =============================================================================
 */
void example4_input(void) {
    printf("\n=== Example 4: Array Input ===\n");
    
    int arr[5];
    
    // Simulating user input with predefined values
    printf("Simulating input of 5 numbers: 15, 25, 35, 45, 55\n");
    int inputs[] = {15, 25, 35, 45, 55};
    
    for (int i = 0; i < 5; i++) {
        arr[i] = inputs[i];
        printf("  Entered arr[%d] = %d\n", i, arr[i]);
    }
    
    printf("\nArray contents: ");
    for (int i = 0; i < 5; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

/*
 * =============================================================================
 * EXAMPLE 5: Finding Sum and Average
 * =============================================================================
 */
void example5_sum_average(void) {
    printf("\n=== Example 5: Sum and Average ===\n");
    
    int numbers[] = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100};
    int size = sizeof(numbers) / sizeof(numbers[0]);
    
    // Calculate sum
    int sum = 0;
    for (int i = 0; i < size; i++) {
        sum += numbers[i];
    }
    
    // Calculate average
    double average = (double)sum / size;
    
    printf("Array: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", numbers[i]);
    }
    printf("\n");
    
    printf("Sum: %d\n", sum);
    printf("Average: %.2f\n", average);
}

/*
 * =============================================================================
 * EXAMPLE 6: Finding Maximum and Minimum
 * =============================================================================
 */
void example6_max_min(void) {
    printf("\n=== Example 6: Maximum and Minimum ===\n");
    
    int arr[] = {45, 12, 89, 33, 76, 21, 98, 54};
    int size = sizeof(arr) / sizeof(arr[0]);
    
    int max = arr[0];
    int min = arr[0];
    int maxIndex = 0;
    int minIndex = 0;
    
    for (int i = 1; i < size; i++) {
        if (arr[i] > max) {
            max = arr[i];
            maxIndex = i;
        }
        if (arr[i] < min) {
            min = arr[i];
            minIndex = i;
        }
    }
    
    printf("Array: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    
    printf("Maximum: %d (at index %d)\n", max, maxIndex);
    printf("Minimum: %d (at index %d)\n", min, minIndex);
}

/*
 * =============================================================================
 * EXAMPLE 7: Linear Search
 * =============================================================================
 */
void example7_search(void) {
    printf("\n=== Example 7: Linear Search ===\n");
    
    int arr[] = {23, 45, 12, 67, 34, 89, 11, 56};
    int size = sizeof(arr) / sizeof(arr[0]);
    
    printf("Array: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    
    // Search for different values
    int targets[] = {67, 100, 11};
    
    for (int t = 0; t < 3; t++) {
        int target = targets[t];
        int found = -1;
        
        for (int i = 0; i < size; i++) {
            if (arr[i] == target) {
                found = i;
                break;
            }
        }
        
        if (found != -1) {
            printf("Searching for %d: Found at index %d\n", target, found);
        } else {
            printf("Searching for %d: Not found\n", target);
        }
    }
}

/*
 * =============================================================================
 * EXAMPLE 8: Reversing an Array
 * =============================================================================
 */
void example8_reverse(void) {
    printf("\n=== Example 8: Reversing an Array ===\n");
    
    int arr[] = {1, 2, 3, 4, 5, 6, 7};
    int size = sizeof(arr) / sizeof(arr[0]);
    
    printf("Original: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    
    // Reverse in place
    for (int i = 0; i < size / 2; i++) {
        int temp = arr[i];
        arr[i] = arr[size - 1 - i];
        arr[size - 1 - i] = temp;
    }
    
    printf("Reversed: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

/*
 * =============================================================================
 * EXAMPLE 9: Copying Arrays
 * =============================================================================
 */
void example9_copy(void) {
    printf("\n=== Example 9: Copying Arrays ===\n");
    
    int source[] = {10, 20, 30, 40, 50};
    int size = sizeof(source) / sizeof(source[0]);
    int dest[5];
    
    // Method 1: Element by element
    for (int i = 0; i < size; i++) {
        dest[i] = source[i];
    }
    
    printf("Source: ");
    for (int i = 0; i < size; i++) printf("%d ", source[i]);
    printf("\n");
    
    printf("Dest (after copy): ");
    for (int i = 0; i < size; i++) printf("%d ", dest[i]);
    printf("\n");
    
    // Method 2: Using memcpy
    int dest2[5];
    memcpy(dest2, source, sizeof(source));
    
    printf("Dest2 (memcpy): ");
    for (int i = 0; i < size; i++) printf("%d ", dest2[i]);
    printf("\n");
}

/*
 * =============================================================================
 * EXAMPLE 10: Counting Occurrences
 * =============================================================================
 */
void example10_count(void) {
    printf("\n=== Example 10: Counting Occurrences ===\n");
    
    int arr[] = {1, 3, 2, 1, 4, 1, 3, 2, 1, 5};
    int size = sizeof(arr) / sizeof(arr[0]);
    
    printf("Array: ");
    for (int i = 0; i < size; i++) printf("%d ", arr[i]);
    printf("\n\n");
    
    // Count occurrences of each number (1-5)
    for (int num = 1; num <= 5; num++) {
        int count = 0;
        for (int i = 0; i < size; i++) {
            if (arr[i] == num) count++;
        }
        printf("Number %d appears %d time(s)\n", num, count);
    }
}

/*
 * =============================================================================
 * EXAMPLE 11: Array with Different Data Types
 * =============================================================================
 */
void example11_types(void) {
    printf("\n=== Example 11: Arrays of Different Types ===\n");
    
    // Integer array
    int integers[] = {1, 2, 3, 4, 5};
    printf("int array: ");
    for (int i = 0; i < 5; i++) printf("%d ", integers[i]);
    printf("\n");
    
    // Float array
    float floats[] = {1.1f, 2.2f, 3.3f, 4.4f, 5.5f};
    printf("float array: ");
    for (int i = 0; i < 5; i++) printf("%.1f ", floats[i]);
    printf("\n");
    
    // Double array
    double doubles[] = {1.11, 2.22, 3.33, 4.44, 5.55};
    printf("double array: ");
    for (int i = 0; i < 5; i++) printf("%.2f ", doubles[i]);
    printf("\n");
    
    // Char array
    char chars[] = {'H', 'e', 'l', 'l', 'o'};
    printf("char array: ");
    for (int i = 0; i < 5; i++) printf("%c", chars[i]);
    printf("\n");
    
    // Size comparison
    printf("\nMemory sizes:\n");
    printf("  int[5]: %zu bytes\n", sizeof(integers));
    printf("  float[5]: %zu bytes\n", sizeof(floats));
    printf("  double[5]: %zu bytes\n", sizeof(doubles));
    printf("  char[5]: %zu bytes\n", sizeof(chars));
}

/*
 * =============================================================================
 * EXAMPLE 12: Shifting Array Elements
 * =============================================================================
 */
void example12_shift(void) {
    printf("\n=== Example 12: Shifting Elements ===\n");
    
    int arr[] = {1, 2, 3, 4, 5};
    int size = 5;
    
    printf("Original: ");
    for (int i = 0; i < size; i++) printf("%d ", arr[i]);
    printf("\n");
    
    // Left shift by 1
    int first = arr[0];
    for (int i = 0; i < size - 1; i++) {
        arr[i] = arr[i + 1];
    }
    arr[size - 1] = first;
    
    printf("Left shift: ");
    for (int i = 0; i < size; i++) printf("%d ", arr[i]);
    printf("\n");
    
    // Reset and right shift
    int arr2[] = {1, 2, 3, 4, 5};
    int last = arr2[size - 1];
    for (int i = size - 1; i > 0; i--) {
        arr2[i] = arr2[i - 1];
    }
    arr2[0] = last;
    
    printf("Right shift: ");
    for (int i = 0; i < size; i++) printf("%d ", arr2[i]);
    printf("\n");
}

/*
 * =============================================================================
 * EXAMPLE 13: Removing Duplicates
 * =============================================================================
 */
void example13_remove_duplicates(void) {
    printf("\n=== Example 13: Removing Duplicates ===\n");
    
    int arr[] = {1, 2, 2, 3, 4, 4, 4, 5, 5};
    int size = 9;
    
    printf("Original: ");
    for (int i = 0; i < size; i++) printf("%d ", arr[i]);
    printf("\n");
    
    int uniqueArr[9];
    int uniqueSize = 0;
    
    for (int i = 0; i < size; i++) {
        int isDuplicate = 0;
        for (int j = 0; j < uniqueSize; j++) {
            if (arr[i] == uniqueArr[j]) {
                isDuplicate = 1;
                break;
            }
        }
        if (!isDuplicate) {
            uniqueArr[uniqueSize++] = arr[i];
        }
    }
    
    printf("Unique: ");
    for (int i = 0; i < uniqueSize; i++) printf("%d ", uniqueArr[i]);
    printf("(%d elements)\n", uniqueSize);
}

/*
 * =============================================================================
 * EXAMPLE 14: Merging Two Arrays
 * =============================================================================
 */
void example14_merge(void) {
    printf("\n=== Example 14: Merging Arrays ===\n");
    
    int arr1[] = {1, 3, 5, 7};
    int arr2[] = {2, 4, 6, 8, 10};
    int size1 = 4, size2 = 5;
    int merged[9];
    
    // Simple concatenation
    for (int i = 0; i < size1; i++) {
        merged[i] = arr1[i];
    }
    for (int i = 0; i < size2; i++) {
        merged[size1 + i] = arr2[i];
    }
    
    printf("Array 1: ");
    for (int i = 0; i < size1; i++) printf("%d ", arr1[i]);
    printf("\n");
    
    printf("Array 2: ");
    for (int i = 0; i < size2; i++) printf("%d ", arr2[i]);
    printf("\n");
    
    printf("Merged: ");
    for (int i = 0; i < size1 + size2; i++) printf("%d ", merged[i]);
    printf("\n");
}

/*
 * =============================================================================
 * MAIN FUNCTION
 * =============================================================================
 */
int main(void) {
    printf("╔════════════════════════════════════════════════════════════╗\n");
    printf("║      ONE-DIMENSIONAL ARRAYS - DEMONSTRATION PROGRAM        ║\n");
    printf("╚════════════════════════════════════════════════════════════╝\n");
    
    example1_declaration_init();
    example2_access();
    example3_memory();
    example4_input();
    example5_sum_average();
    example6_max_min();
    example7_search();
    example8_reverse();
    example9_copy();
    example10_count();
    example11_types();
    example12_shift();
    example13_remove_duplicates();
    example14_merge();
    
    printf("\n╔════════════════════════════════════════════════════════════╗\n");
    printf("║                    EXAMPLES COMPLETED                       ║\n");
    printf("╚════════════════════════════════════════════════════════════╝\n");
    
    return 0;
}