Experiment 1: Finding Minimum and Maximum Values

This experiment demonstrates how to find the minimum and maximum values in an array using pointers.

#include <stdio.h>
#define SIZE 6

void read_data(int arr[], int size);
void display_data(int arr[], int size);
void find_extremes(int arr[], int size, int* min_ptr, int* max_ptr);

int main() {
    int numbers[SIZE];
    int minimum, maximum;

    printf("Enter %d integers:\n", SIZE);
    read_data(numbers, SIZE);

    printf("The entered numbers are:\n");
    display_data(numbers, SIZE);

    printf("Processing data...\n");
    find_extremes(numbers, SIZE, &minimum, &maximum);

    printf("Results:\n");
    printf("Minimum = %d, Maximum = %d\n", minimum, maximum);

    return 0;
}

void read_data(int arr[], int size) {
    int index;
    for (index = 0; index < size; ++index)
        scanf("%d", &arr[index]);
}

void display_data(int arr[], int size) {
    int index;
    for (index = 0; index < size; ++index)
        printf("%d ", arr[index]);
    printf("\n");
}

void find_extremes(int arr[], int size, int* min_ptr, int* max_ptr) {
    int index;
    *min_ptr = *max_ptr = arr[0];

    for (index = 0; index < size; ++index) {
        if (arr[index] < *min_ptr)
            *min_ptr = arr[index];
        else if (arr[index] > *max_ptr)
            *max_ptr = arr[index];
    }
}
</stdio.h>

Experiment 2: Returning Pointer to Maximum Element

This experiment shows how to return a pointer to the maximum element in an array.

#include <stdio.h>
#define SIZE 6

void read_data(int arr[], int size);
void display_data(int arr[], int size);
int* locate_max(int arr[], int size);

int main() {
    int numbers[SIZE];
    int* max_ptr;

    printf("Enter %d integers:\n", SIZE);
    read_data(numbers, SIZE);

    printf("The entered numbers are:\n");
    display_data(numbers, SIZE);

    printf("Processing data...\n");
    max_ptr = locate_max(numbers, SIZE);

    printf("Results:\n");
    printf("Maximum = %d\n", *max_ptr);

    return 0;
}

void read_data(int arr[], int size) {
    int index;
    for (index = 0; index < size; ++index)
        scanf("%d", &arr[index]);
}

void display_data(int arr[], int size) {
    int index;
    for (index = 0; index < size; ++index)
        printf("%d ", arr[index]);
    printf("\n");
}

int* locate_max(int arr[], int size) {
    int max_index = 0;
    int index;

    for (index = 0; index < size; ++index)
        if (arr[index] > arr[max_index])
            max_index = index;
    
    return &arr[max_index];
}
</stdio.h>

Experiment 3: String Operations with Character Arrays

This experiment demonstrates string operations using character arrays.

#include <stdio.h>
#include <string.h>
#define BUFFER_SIZE 100

int main() {
    char text1[BUFFER_SIZE] = "Learning makes me happy";
    char text2[BUFFER_SIZE] = "Learning makes me sleepy";
    char temporary[BUFFER_SIZE];

    printf("sizeof(text1) vs. strlen(text1): \n");
    printf("sizeof(text1) = %d\n", sizeof(text1));
    printf("strlen(text1) = %d\n", strlen(text1));
 
    printf("\nBefore swap: \n");
    printf("text1: %s\n", text1);
    printf("text2: %s\n", text2);
 
    printf("\nSwapping...\n");
    strcpy(temporary, text1);
    strcpy(text1, text2);
    strcpy(text2, temporary);
 
    printf("\nAfter swap: \n");
    printf("text1: %s\n", text1);
    printf("text2: %s\n", text2);
 
    return 0;
}
</string.h></stdio.h>

Experiment 4: String Operations with String Pointers

This experiment demonstrates string operations using string pointers.

#include <stdio.h>
#include <string.h>
#define BUFFER_SIZE 100

int main() {
    char *text1 = "Learning makes me happy";
    char *text2 = "Learning makes me sleepy";
    char *temporary;

    printf("sizeof(text1) vs. strlen(text1): \n");
    printf("sizeof(text1) = %d\n", sizeof(text1));
    printf("strlen(text1) = %d\n", strlen(text1));

    printf("\nBefore swap: \n");
    printf("text1: %s\n", text1);
    printf("text2: %s\n", text2);

    printf("\nSwapping...\n");
    temporary = text1;
    text1 = text2;
    text2 = temporary;

    printf("\nAfter swap: \n");
    printf("text1: %s\n", text1);
    printf("text2: %s\n", text2);

    return 0;
}
</string.h></stdio.h>

Experiment 5: Multi-dimensional Arrays and Pointer Arithmetic

This experiment demonstrates accessing multi-dimentional arrays using different pointer types.

#include <stdio.h>

int main() {
    int matrix[2][4] = {{1, 9, 8, 4}, {2, 0, 4, 9}};
    int i, j;
    int *element_ptr;     // Pointer to individual elements
    int (*row_ptr)[4];    // Pointer to rows (arrays of 4 integers)

    printf("Output 1: Direct array access\n");
    for (i = 0; i < 2; ++i) {
        for (j = 0; j < 4; ++j)
            printf("%d ", matrix[i][j]);
        printf("\n");
    }

    printf("\nOutput 2: Using element pointer\n");
    for (element_ptr = &matrix[0][0], i = 0; element_ptr < &matrix[0][0] + 8; ++element_ptr, ++i) {
        printf("%d ", *element_ptr);

        if ((i + 1) % 4 == 0)
            printf("\n");
    }
                         
    printf("\nOutput 3: Using row pointer\n");
    for (row_ptr = matrix; row_ptr < matrix + 2; ++row_ptr) {
        for (j = 0; j < 4; ++j)
            printf("%d ", *(*row_ptr + j));
        printf("\n");
    }

    return 0;
}
</stdio.h>

Experiment 6: String Replacement Function

This experiment shows how to replace characters in a string.

#include <stdio.h>
#define BUFFER_SIZE 100

void replace_characters(char *text, char old_char, char new_char);

int main() {
    char sentence[BUFFER_SIZE] = "Programming is challenging or not, it is a question.";

    printf("Original text: \n");
    printf("%s\n", sentence);

    replace_characters(sentence, 'i', '*');

    printf("Modified text: \n");
    printf("%s\n", sentence);

    return 0;
}

void replace_characters(char *text, char old_char, char new_char) {
    while(*text) {
        if(*text == old_char)
            *text = new_char;
        text++;
    }
}
</stdio.h>

Experiment 7: String Truncation Function

This experiment demonstrates truncating a string at a specified character.

#include <stdio.h>
#define BUFFER_SIZE 100

char* truncate_string(char *text, char delimiter);

int main() {
    char input[BUFFER_SIZE];
    char delimiter;

    while(printf("Enter a string: "), gets(input) != NULL) {
        printf("Enter a character: ");
        delimiter = getchar();

        printf("Truncating...\n");
        truncate_string(input, delimiter);

        printf("Truncated string: %s\n\n", input);
        getchar();
    }

    return 0;
}

char* truncate_string(char *text, char delimiter) {
    int index;
    for(index = 0; text[index] != '\0'; index++) {
        if(text[index] == delimiter) {
            text[index] = '\0';
            break;
        }
    }
    return text;
}
</stdio.h>

Experiment 8: ID Validation

This experiment validates ID numbers based on their format.

#include <stdio.h>
#include <string.h>
#define NUM_IDS 5

int validate_id(char *id);

int main() {
    char *ids[NUM_IDS] = {"31010120000721656X",
                        "3301061996X0203301",
                        "53010220051126571",
                        "510104199211197977",
                        "53010220051126133Y"};
    int index;

    for (index = 0; index < NUM_IDS; ++index)
        if (validate_id(ids[index]))
            printf("%s\tValid\n", ids[index]);
        else
            printf("%s\tInvalid\n", ids[index]);

    return 0;
}

int validate_id(char *id) {
    int index, last_char;
    if(strlen(id) == 18) {
        for(index = 0; index < 18; ++index)
            ;
        last_char = id[index-1];
        if((index == 18 && (last_char == 'X' || (last_char >= '0' && last_char <= '9'))))
            return 1;
        else
            return 0;
    } else {
        return 0;
    }
}
</string.h></stdio.h>

Experiment 9: String Encoding and Decoding

This experiment demonstrates encoding and decoding strings using a Caesar cipher.

#include <stdio.h>
#define BUFFER_SIZE 100

void encode_text(char *text, int shift);
void decode_text(char *text, int shift);

int main() {
    char message[BUFFER_SIZE];
    int shift_value;

    printf("Enter text: ");
    gets(message);

    printf("Enter shift value: ");
    scanf("%d", &shift_value);

    printf("Encoded text: ");
    encode_text(message, shift_value);
    printf("%s\n", message);

    printf("Decoded text: ");
    decode_text(message, shift_value);
    printf("%s\n", message);

    return 0;
}

void encode_text(char *text, int shift) {
    int index;
    
    for(index = 0; text[index] != '\0'; index++) {
        if(text[index] >= 'A' && text[index] <= 'Z') {
            if(text[index] + shift <= 'Z')
                text[index] += shift;
            else
                text[index] = text[index] + shift%26 - 26;
        }
        else if(text[index] >= 'a' && text[index] <= 'z') {
            if(text[index] + shift <= 'z')
                text[index] += shift;
            else
                text[index] = text[index] + shift%26 - 26;
        }
    }
}

void decode_text(char *text, int shift) {
    int index;
    for(index = 0; text[index] != '\0'; index++) {
        if(text[index] >= 'A' && text[index] <= 'Z') {
            if(text[index] - shift >= 'A')
                text[index] -= shift;
            else
                text[index] = text[index] - shift%26 + 26;
        }
        else if(text[index] >= 'a' && text[index] <= 'z') {
            if(text[index] - shift >= 'a')
                text[index] -= shift;
            else
                text[index] = text[index] - shift%26 + 26;
        }
    }
}
</stdio.h>

Experiment 10: Command-line Argument Sorting

This experiment sorts command-line arguments alphabetically.

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

void sort_arguments(int arg_count, char *arguments[]);

int main(int argc, char *argv[]) {
    int index;
    sort_arguments(argc, argv);
    
    for(index = 1; index < argc; ++index)
        printf("hello, %s\n", argv[index]);

    return 0;
}

void sort_arguments(int arg_count, char *arguments[]) {
    int i, j;
    char *temp;
    for(j = 1; j < arg_count - 1; j++) {
        for(i = 1; i < arg_count - j - 1; i++) {
            if(strcmp(arguments[i], arguments[i+1]) > 0) {
                temp = arguments[i];
                arguments[i] = arguments[i+1];
                arguments[i+1] = temp;
            }
        }
    }
}
</string.h></stdio.h>