Task 1.1: Finding Minimum and Maximum in an Array Using Pointers

This program reads five integers into an array, then finds the minimum and maximum values using a function that modifies values through pointer parameters.

#include <stdio.h>
#define SIZE 5

void read_array(int arr[], int len);
void print_array(int arr[], int len);
void get_min_max(int arr[], int len, int *min_ptr, int *max_ptr);

int main() {
    int numbers[SIZE];
    int min_val, max_val;

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

    printf("Input data:\n");
    print_array(numbers, SIZE);

    printf("Processing...\n");
    get_min_max(numbers, SIZE, &min_val, &max_val);

    printf("Results:\n");
    printf("min = %d, max = %d\n", min_val, max_val);
    return 0;
}

void read_array(int arr[], int len) {
    for (int i = 0; i < len; ++i)
        scanf("%d", &arr[i]);
}

void print_array(int arr[], int len) {
    for (int i = 0; i < len; ++i)
        printf("%d ", arr[i]);
    printf("\n");
}

void get_min_max(int arr[], int len, int *min_ptr, int *max_ptr) {
    *min_ptr = *max_ptr = arr[0];
    for (int i = 1; i < len; ++i) {
        if (arr[i] < *min_ptr)
            *min_ptr = arr[i];
        else if (arr[i] > *max_ptr)
            *max_ptr = arr[i];
    }
}

Task 1.2: Returning Pointer to Maximum Element

This version returns a pointer to the maximum element instead of its value.

#include <stdio.h>
#define SIZE 5

void read_array(int arr[], int len);
void print_array(int arr[], int len);
int* locate_max(int arr[], int len);

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

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

    printf("Input data:\n");
    print_array(numbers, SIZE);

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

    printf("Maximum value: %d\n", *max_ptr);
    return 0;
}

void read_array(int arr[], int len) {
    for (int i = 0; i < len; ++i)
        scanf("%d", &arr[i]);
}

void print_array(int arr[], int len) {
    for (int i = 0; i < len; ++i)
        printf("%d ", arr[i]);
    printf("\n");
}

int* locate_max(int arr[], int len) {
    int max_idx = 0;
    for (int i = 1; i < len; ++i)
        if (arr[i] > arr[max_idx])
            max_idx = i;
    return &arr[max_idx];
}

Task 2.1: Swapping Strings Stored in Character Arrays

Demonstrates swapping contents of two fixed-size character arrays using strcpy.

#include <stdio.h>
#include <string.h>
#define MAX_LEN 80

int main() {
    char str1[MAX_LEN] = "Learning makes me happy";
    char str2[MAX_LEN] = "Learning makes me sleepy";
    char temp[MAX_LEN];

    printf("sizeof(str1) = %zu\n", sizeof(str1));
    printf("strlen(str1) = %zu\n", strlen(str1));

    printf("\nBefore swap:\n");
    printf("str1: %s\n", str1);
    printf("str2: %s\n", str2);

    strcpy(temp, str1);
    strcpy(str1, str2);
    strcpy(str2, temp);

    printf("\nAfter swap:\n");
    printf("str1: %s\n", str1);
    printf("str2: %s\n", str2);
    return 0;
}

Task 2.2: Swapping Pointers to String Literals

Swaps pointers to string literals—no actual string content is moved in memory.

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

int main() {
    char *s1 = "Learning makes me happy";
    char *s2 = "Learning makes me sleepy";
    char *tmp;

    printf("sizeof(s1) = %zu\n", sizeof(s1));
    printf("strlen(s1) = %zu\n", strlen(s1));

    printf("\nBefore swap:\n");
    printf("s1: %s\n", s1);
    printf("s2: %s\n", s2);

    tmp = s1;
    s1 = s2;
    s2 = tmp;

    printf("\nAfter swap:\n");
    printf("s1: %s\n", s1);
    printf("s2: %s\n", s2);
    return 0;
}

Task 3: Accessing 2D Arrays via Different Pointer Types

Illustrates three ways to traverse a 2D array: direct indexing, element-wise pointer, and row-pointer.

#include <stdio.h>

int main() {
    int matrix[2][4] = {{1, 9, 8, 4}, {2, 0, 4, 9}};
    int *elem_ptr;
    int (*row_ptr)[4];

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

    // Method 2: Element-wise pointer
    printf("\nMethod 2: Element pointer\n");
    for (elem_ptr = &matrix[0][0], int idx = 0; elem_ptr < &matrix[0][0] + 8; ++elem_ptr, ++idx) {
        printf("%d ", *elem_ptr);
        if ((idx + 1) % 4 == 0) printf("\n");
    }

    // Method 3: Row pointer
    printf("\nMethod 3: Row pointer\n");
    for (row_ptr = matrix; row_ptr < matrix + 2; ++row_ptr) {
        for (int j = 0; j < 4; ++j)
            printf("%d ", *(*row_ptr + j));
        printf("\n");
    }
    return 0;
}

Task 4: Character Replacement in a String

Replaces all occurrences of a specified character with another (e.g., 'i' → '*').

#include <stdio.h>
#define MAX_LEN 80

void substitute_char(char *str, char target, char replacement);

int main() {
    char text[MAX_LEN] = "Programming is difficult or not, it is a question.";
    printf("Original: %s\n", text);
    substitute_char(text, 'i', '*');
    printf("Modified: %s\n", text);
    return 0;
}

void substitute_char(char *str, char target, char replacement) {
    while (*str) {
        if (*str == target)
            *str = replacement;
        str++;
    }
}

Task 5: Truncating a String at a Specified Character

Truncates the input string at the first occurrence of a given character by inserting '\0'.

#include <stdio.h>
#define MAX_LEN 80

char* truncate_at(char *str, char delimiter);

int main() {
    char input[MAX_LEN];
    char ch;
    while (printf("Enter string: "), fgets(input, MAX_LEN, stdin) != NULL) {
        input[strcspn(input, "\n")] = '\0'; // Remove newline
        printf("Enter delimiter: ");
        ch = getchar();
        while (getchar() != '\n'); // Clear input buffer
        truncate_at(input, ch);
        printf("Result: %s\n\n", input);
    }
    return 0;
}

char* truncate_at(char *str, char delimiter) {
    while (*str && *str != delimiter)
        str++;
    if (*str == delimiter)
        *str = '\0';
    return str;
}

Task 6: Validating Chinese ID Numbers

Checks if a string is a valid 18-digit Chinese ID: exactly 18 characters, first 17 are digits, last can be digit or 'X'.

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

int validate_id(const char *id);

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

    for (int i = 0; i < COUNT; ++i) {
        if (validate_id(ids[i]))
            printf("%s\tTrue\n", ids[i]);
        else
            printf("%s\tFalse\n", ids[i]);
    }
    return 0;
}

int validate_id(const char *id) {
    if (strlen(id) != 18)
        return 0;
    for (int i = 0; i < 17; ++i)
        if (id[i] < '0' || id[i] > '9')
            return 0;
    if (!(id[17] >= '0' && id[17] <= '9') && id[17] != 'X')
        return 0;
    return 1;
}

Task 7: Caesar Cipher Encoder and Decoder

Implements a Caesar cipher that shifts letters by n positions, with wrap-around. Handles both uppercase and lowercase.

#include <stdio.h>
#define MAX_LEN 80

void encode(char *text, int shift);
void decode(char *text, int shift);

int main() {
    char message[MAX_LEN];
    int n;

    printf("Enter plaintext: ");
    fgets(message, MAX_LEN, stdin);
    message[strcspn(message, "\n")] = '\0';

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

    printf("Original: %s\n", message);
    encode(message, n);
    printf("Encoded:  %s\n", message);
    decode(message, n);
    printf("Decoded:  %s\n", message);
    return 0;
}

void encode(char *text, int shift) {
    while (*text) {
        if (*text >= 'a' && *text <= 'z')
            *text = 'a' + (*text - 'a' + shift) % 26;
        else if (*text >= 'A' && *text <= 'Z')
            *text = 'A' + (*text - 'A' + shift) % 26;
        text++;
    }
}

void decode(char *text, int shift) {
    while (*text) {
        if (*text >= 'a' && *text <= 'z')
            *text = 'a' + (*text - 'a' - shift + 26) % 26;
        else if (*text >= 'A' && *text <= 'Z')
            *text = 'A' + (*text - 'A' - shift + 26) % 26;
        text++;
    }
}