examples

/**
 * String Manipulation - Examples
 * 
 * This file demonstrates string manipulation techniques in C.
 * 
 * Compile: gcc examples.c -o examples
 * Run: ./examples
 */

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

/* ============================================================
 * EXAMPLE 1: Case Conversion Functions
 * ============================================================ */

// Convert string to uppercase
void to_uppercase(char *str) {
    while (*str) {
        *str = toupper(*str);
        str++;
    }
}

// Convert string to lowercase
void to_lowercase(char *str) {
    while (*str) {
        *str = tolower(*str);
        str++;
    }
}

// Convert to title case (capitalize first letter of each word)
void to_titlecase(char *str) {
    int capitalize = 1;  // Start with first letter
    
    while (*str) {
        if (isspace(*str)) {
            capitalize = 1;
        } else if (capitalize) {
            *str = toupper(*str);
            capitalize = 0;
        } else {
            *str = tolower(*str);
        }
        str++;
    }
}

// Toggle case of each character
void toggle_case(char *str) {
    while (*str) {
        if (isupper(*str)) {
            *str = tolower(*str);
        } else if (islower(*str)) {
            *str = toupper(*str);
        }
        str++;
    }
}

void example1_case_conversion(void) {
    printf("=== EXAMPLE 1: Case Conversion ===\n\n");
    
    char text1[] = "Hello World";
    char text2[] = "Hello World";
    char text3[] = "hello world";
    char text4[] = "Hello World";
    
    printf("Original: \"%s\"\n\n", text1);
    
    // Uppercase
    to_uppercase(text1);
    printf("to_uppercase: \"%s\"\n", text1);
    
    // Lowercase
    to_lowercase(text2);
    printf("to_lowercase: \"%s\"\n", text2);
    
    // Title case
    to_titlecase(text3);
    printf("to_titlecase: \"%s\"\n", text3);
    
    // Toggle case
    toggle_case(text4);
    printf("toggle_case:  \"%s\"\n", text4);
    
    printf("\n--- ctype.h Character Functions ---\n");
    printf("toupper('a') = '%c'\n", toupper('a'));
    printf("tolower('Z') = '%c'\n", tolower('Z'));
    printf("isupper('A') = %d (true)\n", isupper('A') != 0);
    printf("islower('a') = %d (true)\n", islower('a') != 0);
    printf("isalpha('X') = %d (true)\n", isalpha('X') != 0);
    printf("isdigit('5') = %d (true)\n", isdigit('5') != 0);
}


/* ============================================================
 * EXAMPLE 2: Reversing Strings
 * ============================================================ */

// In-place string reversal using indices
void reverse_string(char *str) {
    int len = strlen(str);
    
    for (int i = 0; i < len / 2; i++) {
        char temp = str[i];
        str[i] = str[len - 1 - i];
        str[len - 1 - i] = temp;
    }
}

// Pointer-based string reversal
void reverse_string_ptr(char *str) {
    char *start = str;
    char *end = str + strlen(str) - 1;
    
    while (start < end) {
        char temp = *start;
        *start = *end;
        *end = temp;
        start++;
        end--;
    }
}

// Reverse words in a string
void reverse_words(char *str) {
    // First, reverse the entire string
    reverse_string(str);
    
    // Then reverse each word
    char *word_start = str;
    char *ptr = str;
    
    while (*ptr) {
        if (*ptr == ' ') {
            // Reverse the word before this space
            *ptr = '\0';
            reverse_string(word_start);
            *ptr = ' ';
            word_start = ptr + 1;
        }
        ptr++;
    }
    // Reverse the last word
    reverse_string(word_start);
}

void example2_reversing(void) {
    printf("\n=== EXAMPLE 2: Reversing Strings ===\n\n");
    
    char text1[] = "Hello";
    char text2[] = "World";
    char text3[] = "Hello World";
    
    printf("--- In-place Reversal (index-based) ---\n");
    printf("Before: \"%s\"\n", text1);
    reverse_string(text1);
    printf("After:  \"%s\"\n\n", text1);
    
    printf("--- Pointer-based Reversal ---\n");
    printf("Before: \"%s\"\n", text2);
    reverse_string_ptr(text2);
    printf("After:  \"%s\"\n\n", text2);
    
    printf("--- Reverse Words ---\n");
    printf("Before: \"%s\"\n", text3);
    reverse_words(text3);
    printf("After:  \"%s\"\n", text3);
}


/* ============================================================
 * EXAMPLE 3: Trimming Whitespace
 * ============================================================ */

// Trim leading whitespace (returns pointer to first non-space)
char* ltrim(char *str) {
    while (isspace(*str)) {
        str++;
    }
    return str;
}

// Trim trailing whitespace (modifies string in place)
void rtrim(char *str) {
    int len = strlen(str);
    while (len > 0 && isspace(str[len - 1])) {
        len--;
    }
    str[len] = '\0';
}

// Trim both ends in place
void trim(char *str) {
    // Trim leading
    char *start = str;
    while (isspace(*start)) {
        start++;
    }
    
    // All whitespace?
    if (*start == '\0') {
        *str = '\0';
        return;
    }
    
    // Trim trailing
    char *end = start + strlen(start) - 1;
    while (end > start && isspace(*end)) {
        end--;
    }
    
    // Move trimmed string and terminate
    size_t len = end - start + 1;
    memmove(str, start, len);
    str[len] = '\0';
}

void example3_trimming(void) {
    printf("\n=== EXAMPLE 3: Trimming Whitespace ===\n\n");
    
    char text1[] = "   Hello World";
    char text2[] = "Hello World   ";
    char text3[] = "   Hello World   ";
    
    printf("--- Left Trim (ltrim) ---\n");
    printf("Before: \"%s\" (length %zu)\n", text1, strlen(text1));
    char *trimmed = ltrim(text1);
    printf("After:  \"%s\" (length %zu)\n\n", trimmed, strlen(trimmed));
    
    printf("--- Right Trim (rtrim) ---\n");
    printf("Before: \"%s\" (length %zu)\n", text2, strlen(text2));
    rtrim(text2);
    printf("After:  \"%s\" (length %zu)\n\n", text2, strlen(text2));
    
    printf("--- Trim Both (trim) ---\n");
    printf("Before: \"%s\" (length %zu)\n", text3, strlen(text3));
    trim(text3);
    printf("After:  \"%s\" (length %zu)\n", text3, strlen(text3));
}


/* ============================================================
 * EXAMPLE 4: Padding Strings
 * ============================================================ */

// Left pad string to total length
void lpad(char *str, size_t total_len, char pad_char) {
    size_t current_len = strlen(str);
    if (current_len >= total_len) return;
    
    size_t pad_count = total_len - current_len;
    
    // Move string right
    memmove(str + pad_count, str, current_len + 1);
    
    // Fill with pad character
    memset(str, pad_char, pad_count);
}

// Right pad string to total length
void rpad(char *str, size_t total_len, char pad_char) {
    size_t current_len = strlen(str);
    if (current_len >= total_len) return;
    
    memset(str + current_len, pad_char, total_len - current_len);
    str[total_len] = '\0';
}

// Center string with padding
void center(char *str, size_t total_len, char pad_char) {
    size_t current_len = strlen(str);
    if (current_len >= total_len) return;
    
    size_t pad_total = total_len - current_len;
    size_t left_pad = pad_total / 2;
    size_t right_pad = pad_total - left_pad;
    
    // Move string right
    memmove(str + left_pad, str, current_len);
    
    // Pad left
    memset(str, pad_char, left_pad);
    
    // Pad right and terminate
    memset(str + left_pad + current_len, pad_char, right_pad);
    str[total_len] = '\0';
}

void example4_padding(void) {
    printf("\n=== EXAMPLE 4: Padding Strings ===\n\n");
    
    char num1[15] = "42";
    char text2[20] = "Hello";
    char text3[20] = "Hi";
    
    printf("--- Left Pad (lpad) ---\n");
    printf("Before: \"%s\"\n", num1);
    lpad(num1, 8, '0');
    printf("lpad(str, 8, '0'): \"%s\"\n\n", num1);
    
    printf("--- Right Pad (rpad) ---\n");
    printf("Before: \"%s\"\n", text2);
    rpad(text2, 10, '.');
    printf("rpad(str, 10, '.'): \"%s\"\n\n", text2);
    
    printf("--- Center ---\n");
    printf("Before: \"%s\"\n", text3);
    center(text3, 10, '-');
    printf("center(str, 10, '-'): \"%s\"\n", text3);
}


/* ============================================================
 * EXAMPLE 5: Character Replacement
 * ============================================================ */

// Replace all occurrences of a character
void replace_char(char *str, char old_char, char new_char) {
    while (*str) {
        if (*str == old_char) {
            *str = new_char;
        }
        str++;
    }
}

// Count occurrences of a character
int count_char(const char *str, char c) {
    int count = 0;
    while (*str) {
        if (*str == c) count++;
        str++;
    }
    return count;
}

// Remove all occurrences of a character
void remove_char(char *str, char c) {
    char *read = str;
    char *write = str;
    
    while (*read) {
        if (*read != c) {
            *write++ = *read;
        }
        read++;
    }
    *write = '\0';
}

void example5_char_replacement(void) {
    printf("\n=== EXAMPLE 5: Character Replacement ===\n\n");
    
    char text1[] = "Hello World";
    char text2[] = "Mississippi";
    char text3[] = "Hello World!";
    
    printf("--- Replace Character ---\n");
    printf("Before: \"%s\"\n", text1);
    replace_char(text1, ' ', '_');
    printf("replace_char(str, ' ', '_'): \"%s\"\n\n", text1);
    
    printf("--- Count Character ---\n");
    printf("String: \"%s\"\n", text2);
    printf("Count of 's': %d\n", count_char(text2, 's'));
    printf("Count of 'i': %d\n\n", count_char(text2, 'i'));
    
    printf("--- Remove Character ---\n");
    printf("Before: \"%s\"\n", text3);
    remove_char(text3, 'l');
    printf("remove_char(str, 'l'): \"%s\"\n", text3);
}


/* ============================================================
 * EXAMPLE 6: Substring Replacement
 * ============================================================ */

// Replace first occurrence of substring
int replace_first(char *str, size_t size, 
                  const char *old_sub, const char *new_sub) {
    char *pos = strstr(str, old_sub);
    if (pos == NULL) return 0;
    
    size_t old_len = strlen(old_sub);
    size_t new_len = strlen(new_sub);
    size_t tail_len = strlen(pos + old_len);
    
    // Check if fits
    if (strlen(str) - old_len + new_len >= size) {
        return 0;
    }
    
    // Move tail
    memmove(pos + new_len, pos + old_len, tail_len + 1);
    
    // Copy new substring
    memcpy(pos, new_sub, new_len);
    
    return 1;
}

// Replace all occurrences of substring
int replace_all(char *str, size_t size, 
                const char *old_sub, const char *new_sub) {
    int count = 0;
    char *pos = str;
    
    while ((pos = strstr(pos, old_sub)) != NULL) {
        if (!replace_first(pos, size - (pos - str), old_sub, new_sub)) {
            break;  // No room
        }
        pos += strlen(new_sub);
        count++;
    }
    
    return count;
}

// Count substring occurrences
int count_substring(const char *str, const char *sub) {
    int count = 0;
    const char *ptr = str;
    
    while ((ptr = strstr(ptr, sub)) != NULL) {
        count++;
        ptr++;
    }
    
    return count;
}

void example6_substring_replacement(void) {
    printf("\n=== EXAMPLE 6: Substring Replacement ===\n\n");
    
    char text1[100] = "Hello World";
    char text2[100] = "the cat sat on the mat";
    char text3[] = "one two one three one";
    
    printf("--- Replace First Substring ---\n");
    printf("Before: \"%s\"\n", text1);
    replace_first(text1, sizeof(text1), "World", "C");
    printf("replace_first(str, \"World\", \"C\"): \"%s\"\n\n", text1);
    
    printf("--- Replace All Substrings ---\n");
    printf("Before: \"%s\"\n", text2);
    int count = replace_all(text2, sizeof(text2), "the", "a");
    printf("replace_all(str, \"the\", \"a\"): \"%s\"\n", text2);
    printf("Replacements made: %d\n\n", count);
    
    printf("--- Count Substring ---\n");
    printf("String: \"%s\"\n", text3);
    printf("Count of \"one\": %d\n", count_substring(text3, "one"));
}


/* ============================================================
 * EXAMPLE 7: Splitting and Joining
 * ============================================================ */

// Split string into array of tokens
int split(char *str, const char *delim, char **tokens, int max_tokens) {
    int count = 0;
    char *token = strtok(str, delim);
    
    while (token != NULL && count < max_tokens) {
        tokens[count++] = token;
        token = strtok(NULL, delim);
    }
    
    return count;
}

// Join array of strings with delimiter
void join(char *result, size_t size, 
          char **strings, int count, const char *delim) {
    if (count == 0) {
        result[0] = '\0';
        return;
    }
    
    result[0] = '\0';
    for (int i = 0; i < count; i++) {
        if (i > 0) {
            strncat(result, delim, size - strlen(result) - 1);
        }
        strncat(result, strings[i], size - strlen(result) - 1);
    }
}

void example7_split_join(void) {
    printf("\n=== EXAMPLE 7: Splitting and Joining ===\n\n");
    
    char text[] = "apple,banana,cherry,date";
    char *tokens[10];
    
    printf("--- Split String ---\n");
    printf("Original: \"%s\"\n", text);
    
    int count = split(text, ",", tokens, 10);
    printf("Split by ',': %d tokens\n", count);
    for (int i = 0; i < count; i++) {
        printf("  tokens[%d] = \"%s\"\n", i, tokens[i]);
    }
    
    printf("\n--- Join Strings ---\n");
    char *words[] = {"Hello", "World", "!"};
    char result[50];
    
    join(result, sizeof(result), words, 3, " ");
    printf("Join [\"Hello\", \"World\", \"!\"] with ' ':\n");
    printf("  Result: \"%s\"\n", result);
    
    join(result, sizeof(result), words, 3, "->");
    printf("Join with \"->\":\n");
    printf("  Result: \"%s\"\n", result);
}


/* ============================================================
 * EXAMPLE 8: Extracting Substrings
 * ============================================================ */

// Extract substring from start position with given length
void substring(char *dest, const char *src, int start, int length) {
    int src_len = strlen(src);
    
    if (start >= src_len) {
        dest[0] = '\0';
        return;
    }
    
    if (start + length > src_len) {
        length = src_len - start;
    }
    
    strncpy(dest, src + start, length);
    dest[length] = '\0';
}

// Extract until a specific character
void extract_until(char *dest, const char *src, char stop_char) {
    while (*src && *src != stop_char) {
        *dest++ = *src++;
    }
    *dest = '\0';
}

// Extract text between two delimiter characters
int extract_between(char *dest, const char *src, 
                    char start_char, char end_char) {
    const char *start = strchr(src, start_char);
    if (start == NULL) return 0;
    
    start++;  // Move past start character
    
    const char *end = strchr(start, end_char);
    if (end == NULL) return 0;
    
    size_t len = end - start;
    strncpy(dest, start, len);
    dest[len] = '\0';
    
    return 1;
}

void example8_extraction(void) {
    printf("\n=== EXAMPLE 8: Extracting Substrings ===\n\n");
    
    char result[50];
    
    printf("--- Substring ---\n");
    const char *text = "Hello World";
    printf("Source: \"%s\"\n", text);
    
    substring(result, text, 0, 5);
    printf("substring(str, 0, 5): \"%s\"\n", result);
    
    substring(result, text, 6, 5);
    printf("substring(str, 6, 5): \"%s\"\n\n", result);
    
    printf("--- Extract Until ---\n");
    const char *email = "user@example.com";
    printf("Email: \"%s\"\n", email);
    extract_until(result, email, '@');
    printf("extract_until(str, '@'): \"%s\"\n\n", result);
    
    printf("--- Extract Between ---\n");
    const char *tagged = "Hello (World) Test";
    printf("Source: \"%s\"\n", tagged);
    extract_between(result, tagged, '(', ')');
    printf("extract_between(str, '(', ')'): \"%s\"\n", result);
}


/* ============================================================
 * EXAMPLE 9: String Validation
 * ============================================================ */

// Check if string is numeric
int is_numeric(const char *str) {
    if (*str == '\0') return 0;
    
    // Allow leading sign
    if (*str == '+' || *str == '-') str++;
    
    if (*str == '\0') return 0;
    
    while (*str) {
        if (!isdigit(*str)) return 0;
        str++;
    }
    
    return 1;
}

// Check if string is alphabetic
int is_alphabetic(const char *str) {
    if (*str == '\0') return 0;
    
    while (*str) {
        if (!isalpha(*str)) return 0;
        str++;
    }
    
    return 1;
}

// Check if string is alphanumeric
int is_alphanumeric(const char *str) {
    if (*str == '\0') return 0;
    
    while (*str) {
        if (!isalnum(*str)) return 0;
        str++;
    }
    
    return 1;
}

// Simple email validation
int is_valid_email_simple(const char *email) {
    const char *at = strchr(email, '@');
    if (at == NULL || at == email) return 0;
    
    const char *dot = strrchr(at, '.');
    if (dot == NULL || dot == at + 1 || dot[1] == '\0') return 0;
    
    return 1;
}

// Check if palindrome (case insensitive)
int is_palindrome(const char *str) {
    int len = strlen(str);
    
    for (int i = 0; i < len / 2; i++) {
        if (tolower(str[i]) != tolower(str[len - 1 - i])) {
            return 0;
        }
    }
    
    return 1;
}

void example9_validation(void) {
    printf("\n=== EXAMPLE 9: String Validation ===\n\n");
    
    printf("--- Numeric Validation ---\n");
    printf("is_numeric(\"123\"):  %s\n", is_numeric("123") ? "true" : "false");
    printf("is_numeric(\"-42\"): %s\n", is_numeric("-42") ? "true" : "false");
    printf("is_numeric(\"12.5\"): %s\n", is_numeric("12.5") ? "true" : "false");
    printf("is_numeric(\"abc\"): %s\n\n", is_numeric("abc") ? "true" : "false");
    
    printf("--- Alphabetic Validation ---\n");
    printf("is_alphabetic(\"Hello\"): %s\n", is_alphabetic("Hello") ? "true" : "false");
    printf("is_alphabetic(\"Hi2\"): %s\n\n", is_alphabetic("Hi2") ? "true" : "false");
    
    printf("--- Alphanumeric Validation ---\n");
    printf("is_alphanumeric(\"Test123\"): %s\n", is_alphanumeric("Test123") ? "true" : "false");
    printf("is_alphanumeric(\"Test 123\"): %s\n\n", is_alphanumeric("Test 123") ? "true" : "false");
    
    printf("--- Email Validation (simple) ---\n");
    printf("is_valid_email(\"user@example.com\"): %s\n", 
           is_valid_email_simple("user@example.com") ? "valid" : "invalid");
    printf("is_valid_email(\"invalid-email\"): %s\n\n", 
           is_valid_email_simple("invalid-email") ? "valid" : "invalid");
    
    printf("--- Palindrome Check ---\n");
    printf("is_palindrome(\"radar\"): %s\n", is_palindrome("radar") ? "true" : "false");
    printf("is_palindrome(\"Level\"): %s\n", is_palindrome("Level") ? "true" : "false");
    printf("is_palindrome(\"hello\"): %s\n", is_palindrome("hello") ? "true" : "false");
}


/* ============================================================
 * EXAMPLE 10: Common String Algorithms
 * ============================================================ */

// Remove duplicate characters (keep first occurrence)
void remove_duplicates(char *str) {
    int seen[256] = {0};  // Track seen characters
    char *write = str;
    
    while (*str) {
        unsigned char c = *str;
        if (!seen[c]) {
            seen[c] = 1;
            *write++ = c;
        }
        str++;
    }
    *write = '\0';
}

// Squeeze multiple spaces into one
void squeeze_spaces(char *str) {
    char *read = str;
    char *write = str;
    int prev_space = 0;
    
    while (*read) {
        if (isspace(*read)) {
            if (!prev_space) {
                *write++ = ' ';
                prev_space = 1;
            }
        } else {
            *write++ = *read;
            prev_space = 0;
        }
        read++;
    }
    *write = '\0';
}

// Find the longest word in a string
void longest_word(const char *str, char *result) {
    const char *word_start = NULL;
    size_t max_len = 0;
    const char *max_start = NULL;
    
    while (1) {
        if (!isspace(*str) && *str != '\0') {
            if (word_start == NULL) {
                word_start = str;
            }
        } else {
            if (word_start != NULL) {
                size_t len = str - word_start;
                if (len > max_len) {
                    max_len = len;
                    max_start = word_start;
                }
                word_start = NULL;
            }
        }
        
        if (*str == '\0') break;
        str++;
    }
    
    if (max_start != NULL) {
        strncpy(result, max_start, max_len);
        result[max_len] = '\0';
    } else {
        result[0] = '\0';
    }
}

// Count words in a string
int count_words(const char *str) {
    int count = 0;
    int in_word = 0;
    
    while (*str) {
        if (isspace(*str)) {
            in_word = 0;
        } else if (!in_word) {
            in_word = 1;
            count++;
        }
        str++;
    }
    
    return count;
}

void example10_algorithms(void) {
    printf("\n=== EXAMPLE 10: Common String Algorithms ===\n\n");
    
    char text1[] = "programming";
    char text2[] = "Hello   World   !";
    char result[50];
    
    printf("--- Remove Duplicates ---\n");
    printf("Before: \"%s\"\n", text1);
    remove_duplicates(text1);
    printf("After:  \"%s\"\n\n", text1);
    
    printf("--- Squeeze Spaces ---\n");
    printf("Before: \"%s\"\n", text2);
    squeeze_spaces(text2);
    printf("After:  \"%s\"\n\n", text2);
    
    printf("--- Longest Word ---\n");
    const char *sentence = "The quick brown fox jumps";
    printf("Sentence: \"%s\"\n", sentence);
    longest_word(sentence, result);
    printf("Longest word: \"%s\"\n\n", result);
    
    printf("--- Count Words ---\n");
    printf("Sentence: \"%s\"\n", sentence);
    printf("Word count: %d\n", count_words(sentence));
}


/* ============================================================
 * EXAMPLE 11: Performance Tips
 * ============================================================ */

void example11_performance(void) {
    printf("\n=== EXAMPLE 11: Performance Considerations ===\n\n");
    
    char str[] = "Hello World";
    
    printf("--- Avoid Repeated strlen() Calls ---\n\n");
    
    printf("BAD (strlen called every iteration):\n");
    printf("  for (int i = 0; i < strlen(str); i++)\n\n");
    
    printf("GOOD (strlen called once):\n");
    printf("  size_t len = strlen(str);\n");
    printf("  for (int i = 0; i < len; i++)\n\n");
    
    printf("BETTER (check null directly):\n");
    printf("  for (int i = 0; str[i] != '\\0'; i++)\n\n");
    
    printf("--- Pointer vs Index Access ---\n\n");
    
    printf("Index-based (offset calculation each time):\n");
    printf("  while (str[i] != '\\0') { ... i++; }\n\n");
    
    printf("Pointer-based (direct access, faster):\n");
    printf("  char *ptr = str;\n");
    printf("  while (*ptr) { ... ptr++; }\n");
    
    // Demo
    printf("\n--- Demonstration ---\n");
    printf("String: \"%s\"\n\n", str);
    
    printf("Index-based iteration:\n  ");
    for (int i = 0; str[i] != '\0'; i++) {
        printf("%c ", str[i]);
    }
    printf("\n\n");
    
    printf("Pointer-based iteration:\n  ");
    char *ptr = str;
    while (*ptr) {
        printf("%c ", *ptr++);
    }
    printf("\n");
}


/* ============================================================
 * EXAMPLE 12: Complete String Utility Demo
 * ============================================================ */

// Comprehensive string statistics
typedef struct {
    int length;
    int words;
    int vowels;
    int consonants;
    int digits;
    int spaces;
    int uppercase;
    int lowercase;
} StringStats;

StringStats analyze_string(const char *str) {
    StringStats stats = {0};
    const char *vowels = "aeiouAEIOU";
    int in_word = 0;
    
    while (*str) {
        stats.length++;
        
        if (isspace(*str)) {
            stats.spaces++;
            in_word = 0;
        } else {
            if (!in_word) {
                stats.words++;
                in_word = 1;
            }
            
            if (isdigit(*str)) {
                stats.digits++;
            } else if (isalpha(*str)) {
                if (strchr(vowels, *str)) {
                    stats.vowels++;
                } else {
                    stats.consonants++;
                }
                
                if (isupper(*str)) {
                    stats.uppercase++;
                } else {
                    stats.lowercase++;
                }
            }
        }
        str++;
    }
    
    return stats;
}

void example12_comprehensive(void) {
    printf("\n=== EXAMPLE 12: Comprehensive String Analysis ===\n\n");
    
    const char *text = "Hello World! C Programming 101.";
    
    printf("Analyzing: \"%s\"\n\n", text);
    
    StringStats stats = analyze_string(text);
    
    printf("Statistics:\n");
    printf("  Length:     %d characters\n", stats.length);
    printf("  Words:      %d\n", stats.words);
    printf("  Vowels:     %d\n", stats.vowels);
    printf("  Consonants: %d\n", stats.consonants);
    printf("  Digits:     %d\n", stats.digits);
    printf("  Spaces:     %d\n", stats.spaces);
    printf("  Uppercase:  %d\n", stats.uppercase);
    printf("  Lowercase:  %d\n", stats.lowercase);
}


/* ============================================================
 * MAIN FUNCTION
 * ============================================================ */

int main(void) {
    printf("╔═══════════════════════════════════════════════════════╗\n");
    printf("║       STRING MANIPULATION IN C - EXAMPLES             ║\n");
    printf("╚═══════════════════════════════════════════════════════╝\n\n");
    
    example1_case_conversion();
    example2_reversing();
    example3_trimming();
    example4_padding();
    example5_char_replacement();
    example6_substring_replacement();
    example7_split_join();
    example8_extraction();
    example9_validation();
    example10_algorithms();
    example11_performance();
    example12_comprehensive();
    
    printf("\n╔═══════════════════════════════════════════════════════╗\n");
    printf("║              ALL EXAMPLES COMPLETED!                  ║\n");
    printf("╚═══════════════════════════════════════════════════════╝\n");
    
    return 0;
}