C Programming String Exercises

#include <stdio.h>

int main() {
    // Declare a character array (string) with a suitable size
    char str[100]; 

    printf("Enter a string (up to 99 characters):\n");

    // Use fgets to read the entire line, including spaces
    // 100 is the max size, stdin is the input stream
    fgets(str, 100, stdin); 

    printf("You entered: %s", str);

    return 0;
}Code language: C++ (cpp)

Explanation:

• A character array (char str[100];) is declared to hold the string.
• The fgets(str, 100, stdin) function is used for input because it reliably reads a full line of text, including spaces, until it encounters a newline character (\n) or the maximum size (100 in this case) is reached.
• It automatically includes the newline character in the string (if the buffer wasn’t full). The final printf() simply outputs the content of the str array using the %s format specifier.

#include <stdio.h>

int main() {
    char str[] = "Hello World!";
    int length = 0;
    int i = 0;

    // Loop until the null terminator ('\0') is found
    while (str[i] != '\0') {
        length++;
        i++;
    }

    printf("The string is: \"%s\"\n", str);
    printf("The length of the string is: %d\n", length);

    return 0;
}Code language: C++ (cpp)

Explanation:

• An integer variable length is initialized to 0. A while loop iterates through the str array. The loop condition is str[i] != '\0', which means it continues as long as the current character is not the null terminator.
• Inside the loop, the length counter is incremented, and the index i moves to the next character. When the loop terminates, length holds the exact count of characters before the \0, which is the string’s length.

#include <stdio.h>

int main() {
    char source[] = "Copy Me!";
    // Destination must be large enough to hold the source string + '\0'
    char destination[20]; 
    int i = 0;

    // Loop until the null terminator of the source string is reached
    while (source[i] != '\0') {
        destination[i] = source[i];
        i++;
    }

    // Essential: Add the null terminator to the destination string
    destination[i] = '\0'; 

    printf("Source: %s\n", source);
    printf("Destination: %s\n", destination);

    return 0;
}Code language: C++ (cpp)

Explanation:

• The code uses a while loop to traverse the source string. In each iteration, destination[i] = source[i]; copies the character from the source to the destination.
• The loop stops when source[i] is the null terminator.
• After the loop, the index i is pointing to the position right after the last copied character. The line destination[i] = '\0'; manually places the null terminator, ensuring the destination array is treated as a valid C string.

#include <stdio.h>

int main() {
    // str1 must be large enough to hold both strings + '\0'
    char str1[50] = "Hello "; 
    char str2[] = "World!";
    int i, j;

    // 1. Find the end of str1 (where '\0' is located)
    for (i = 0; str1[i] != '\0'; i++);

    // 2. Start copying str2 to str1 from index i
    for (j = 0; str2[j] != '\0'; j++, i++) {
        str1[i] = str2[j];
    }

    // 3. Add the null terminator at the new end of str1
    str1[i] = '\0'; 

    printf("Concatenated string: %s\n", str1);

    return 0;
}Code language: C++ (cpp)

Explanation:

• The first for loop finds the null terminator position in str1 and stores its index in i.
• The second for loop starts iterating through str2 using index j. In the copy statement (str1[i] = str2[j];), the str1 index i is incremented along with j (done in the loop update clause). This ensures characters from str2 are placed sequentially after the original content of str1.
• Finally, a new null terminator is placed at the very end of the resulting string in str1.

#include <stdio.h>
#include <stdbool.h>

int main() {
    char str1[] = "apple";
    char str2[] = "apple";
    bool identical = true;
    int i = 0;

    // Loop as long as characters match AND we haven't hit the end of either string
    while (str1[i] != '\0' && str2[i] != '\0') {
        if (str1[i] != str2[i]) {
            identical = false; // Mismatch found
            break;
        }
        i++;
    }

    // Final check: If one string is longer than the other (one ended, the other didn't)
    if (str1[i] != '\0' || str2[i] != '\0') {
        identical = false;
    }

    if (identical) {
        printf("The strings are identical.\n");
    } else {
        printf("The strings are NOT identical.\n");
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• The program uses a while loop to compare characters at index i. The loop continues only if both strings still have characters to compare. If str1[i] is not equal to str2[i], the identical flag is set to false, and the loop breaks.
• The check after the loop is crucial: if (str1[i] != '\0' || str2[i] != '\0') handles the case where one string is a prefix of the other (e.g., “app” and “apple”). If this condition is true, they have different lengths, so they are not identical.

#include <stdio.h>
// #include <ctype.h> // Can be used for a simpler solution with toupper()

int main() {
    char str[] = "c Programming Is Fun 123";
    int i = 0;

    while (str[i] != '\0') {
        // Check if the character is in the lowercase range
        if (str[i] >= 'a' && str[i] <= 'z') {
            // Conversion logic: 'a' - 'A' is the difference (32 in ASCII)
            str[i] = str[i] - ('a' - 'A'); 
            // Alternatively, using ctype.h: str[i] = toupper(str[i]);
        }
        i++;
    }

    printf("Uppercase string: %s\n", str);

    return 0;
}Code language: C++ (cpp)

Explanation:

• The program iterates through the string. The if condition checks if the ASCII value of the current character falls within the lowercase range (‘a’ to ‘z’). If it does, the character is converted.
• In ASCII, the uppercase letters are sequentially ordered, and the corresponding lowercase letters are 32 positions higher. By subtracting the difference ('a' - 'A') (which is 32), the character’s ASCII value is shifted back to its uppercase equivalent.

#include <stdio.h>
// #include <ctype.h> // Can be used for a simpler solution with tolower()

int main() {
    char str[] = "C PrOgRaMmInG Is AwEsOmE";
    int i = 0;

    while (str[i] != '\0') {
        // Check if the character is in the uppercase range
        if (str[i] >= 'A' && str[i] <= 'Z') {
            // Conversion logic: 'a' - 'A' is the difference (32 in ASCII)
            str[i] = str[i] + ('a' - 'A'); 
            // Alternatively, using ctype.h: str[i] = tolower(str[i]);
        }
        i++;
    }

    printf("Lowercase string: %s\n", str);

    return 0;
}Code language: C++ (cpp)

Explanation:

• Similar to the uppercase conversion, the if condition checks if the current character is within the uppercase ASCII range.
• To convert it to lowercase, the difference ('a' - 'A') (which is 32) is added to the character’s ASCII value. This shifts the value forward by 32 positions, converting it from its uppercase form to its corresponding lowercase form.

#include <stdio.h>

int main() {
    char str[] = "HeLlO wOrLd 123";
    int i = 0;
    int diff = 'a' - 'A'; // The ASCII difference (32)

    while (str[i] != '\0') {
        if (str[i] >= 'a' && str[i] <= 'z') {
            // Convert lowercase to uppercase (subtract diff)
            str[i] = str[i] - diff;
        } else if (str[i] >= 'A' && str[i] <= 'Z') {
            // Convert uppercase to lowercase (add diff)
            str[i] = str[i] + diff;
        }
        // Other characters (digits, spaces) are ignored
        i++;
    }

    printf("Toggled string: %s\n", str);

    return 0;
}Code language: C++ (cpp)

Explanation:

• The code traverses the string and checks two conditions for each character. If the character is lowercase ('a' to 'z'), the difference diff is subtracted to move it to uppercase.
• If the character is uppercase ('A' to 'Z'), the difference diff is added to move it to lowercase. Any character that doesn’t meet either of these criteria (like digits, spaces, or symbols) remains unchanged.

#include <stdio.h>
#include <ctype.h> // For tolower() to simplify the vowel check

int main() {
    char str[] = "Programming In C is fun.";
    int vowels = 0;
    int consonants = 0;
    int i = 0;

    while (str[i] != '\0') {
        char ch = tolower(str[i]); // Convert to lowercase for simplified check

        // Check if the character is an alphabet
        if (ch >= 'a' && ch <= 'z') {
            if (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u') {
                vowels++;
            } else {
                consonants++;
            }
        }
        i++;
    }

    printf("String: %s\n", str);
    printf("Total Vowels: %d\n", vowels);
    printf("Total Consonants: %d\n", consonants);

    return 0;
}Code language: C++ (cpp)

Explanation:

• The code iterates through the string. It first uses tolower() from <ctype.h> to convert the character to lowercase, simplifying the vowel check. The outer if condition ensures that the character is an alphabet.
• The inner if condition explicitly checks if the character matches any of the five lowercase vowels using the logical OR operator (||). If it is an alphabet and not a vowel, the else block increments the consonants count. Non-alphabetic characters (spaces, periods, digits) are correctly ignored.

#include <stdio.h>
#include <ctype.h> // For isspace()

int main() {
    // String starts/ends with spaces and has multiple spaces between words
    char str[] = "This is a test string"; 
    int word_count = 0;
    // 0: outside a word, 1: inside a word
    int is_word = 0; 
    int i = 0;

    while (str[i] != '\0') {
        if (isspace(str[i])) {
            // Character is a space (or other whitespace)
            is_word = 0;
        } else if (is_word == 0) {
            // Character is NOT a space AND we were previously outside a word
            is_word = 1; // Now inside a word
            word_count++; // Increment count (start of a new word)
        }
        i++;
    }

    printf("The string is: \"%s\"\n", str);
    printf("Total number of words: %d\n", word_count);

    return 0;
}Code language: C++ (cpp)

Explanation:

The code uses a state-machine approach with the is_word flag. The isspace() function (from <ctype.h>) reliably checks for any whitespace character (space, tab, newline).

• If a space is found, the is_word flag is reset to 0 (the program is “outside a word”).
• If a non-space character is found and is_word was 0 (meaning the previous character was a space or it’s the start of the string), it means a new word has begun. The is_word flag is set to 1, and word_count is incremented. This logic correctly handles leading/trailing spaces and multiple spaces between words by only counting the transition from a space/non-word state to a non-space/word state.

#include <stdio.h>

int main() {
    char str[100]; 
    char target_char;
    int count = 0;
    int i = 0;

    printf("Enter a string: ");
    fgets(str, 100, stdin);

    printf("Enter the character to count: ");
    // Note: Using ' %c' handles any lingering newline/space from previous input
    scanf(" %c", &target_char); 

    // Loop through the string until the null terminator
    while (str[i] != '\0') {
        if (str[i] == target_char) {
            count++;
        }
        i++;
    }

    printf("The character '%c' appears %d times in the string.\n", target_char, count);

    return 0;
}Code language: C++ (cpp)

Explanation:

The program takes the input string and the target character. The while loop iterates over the string elements. Inside the loop, the if condition checks if the character at the current index str[i] matches the target_char. If they match, the count is incremented. The process continues until the end of the string (\0) is reached, providing the total occurrences.

#include <stdio.h>

int main() {
    char str[] = "programming"; 
    char target = 'g';
    int index = -1; // Initialize to -1 to indicate 'not found'
    int i = 0;

    while (str[i] != '\0') {
        if (str[i] == target) {
            index = i;
            break; // Stop immediately after finding the first occurrence
        }
        i++;
    }

    if (index != -1) {
        printf("First occurrence of '%c' found at index: %d\n", target, index);
    } else {
        printf("Character '%c' not found in the string.\n", target);
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• The index variable is initialized to -1. The while loop iterates through the string. The moment str[i] equals the target character, the current index i is stored in index, and the break statement terminates the loop, ensuring we only record the first match.
• If the loop finishes without a break, index remains -1, triggering the “not found” message.

#include <stdio.h>

int main() {
    char str[] = "programming"; 
    char target = 'g';
    int last_index = -1; // Initialize to -1
    int i = 0;

    while (str[i] != '\0') {
        if (str[i] == target) {
            // Keep updating the index whenever the target is found.
            // The last update before the loop ends will be the last occurrence.
            last_index = i;
        }
        i++;
    }

    if (last_index != -1) {
        printf("Last occurrence of '%c' found at index: %d\n", target, last_index);
    } else {
        printf("Character '%c' not found in the string.\n", target);
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

Unlike Exercise 12, this program does not use break. It iterates through the entire string. Every time the target character is found, the last_index variable is updated to the current index i. Because the loop progresses sequentially, the last value assigned to last_index will necessarily be the index of the character’s final appearance in the string.

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

int main() {
    char str[] = "Programming in C is fun";
    int freq[26] = {0}; // Initialize all 26 counters to zero
    int i = 0;

    while (str[i] != '\0') {
        char ch = tolower(str[i]); // Handle both cases as one

        // Check if the character is a lowercase alphabet
        if (ch >= 'a' && ch <= 'z') {
            // Map 'a' to index 0, 'b' to 1, etc.
            int index = ch - 'a'; 
            freq[index]++;
        }
        i++;
    }

    printf("Character Frequencies (a-z):\n");
    for (i = 0; i < 26; i++) {
        // Only print characters that appeared at least once
        if (freq[i] > 0) {
            // Convert index back to character: i + 'a'
            printf("'%c': %d\n", (char)(i + 'a'), freq[i]);
        }
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• An array freq[26] is used to store counts. The loop traverses the string, converting each character to lowercase using tolower().
• If the character is a letter, the key step is calculating the index by subtracting the ASCII value of 'a' from the character’s value (ch - 'a'). This gives an index from 0 to 25, which is used to increment the counter in the freq array. A final loop iterates through the freq array, displaying the character (by adding 'a' back to the index) and its count.

#include <stdio.h>

int main() {
    char str[] = "eExxammpelle";
    char char_to_remove = 'e';
    int read_index = 0;
    int write_index = 0;

    while (str[read_index] != '\0') {
        if (str[read_index] != char_to_remove) {
            // Character is NOT the one to remove: copy it and advance both indices
            str[write_index] = str[read_index];
            write_index++;
        } 
        // If character IS the one to remove, only read_index advances, effectively skipping it
        read_index++;
    }

    // Place the null terminator at the end of the new (shorter) string
    str[write_index] = '\0'; 

    printf("String after removing '%c': %s\n", char_to_remove, str);

    return 0;
}Code language: C++ (cpp)

Explanation:

• This uses an in-place modification technique with two pointers. read_index always moves forward, reading the original string. write_index only advances when a character is kept.
• When str[read_index] is the character to remove, the if block is skipped, and read_index advances while write_index stays put. This causes the next good character to be written over the removed character’s position. Finally, the string is terminated at the write_index position.

#include <stdio.h>
#include <string.h> // For strlen

int main() {
    char str[] = "aabbccdeeff"; 
    // Array to store frequency for all 256 ASCII characters
    int freq[256] = {0}; 
    int i;

    // PASS 1: Calculate Frequency
    for (i = 0; str[i] != '\0'; i++) {
        freq[(int)str[i]]++;
    }

    // PASS 2: Find the first character with frequency 1
    char first_non_repeat = '\0';
    for (i = 0; str[i] != '\0'; i++) {
        if (freq[(int)str[i]] == 1) {
            first_non_repeat = str[i];
            break;
        }
    }

    if (first_non_repeat != '\0') {
        printf("First non-repeating character: '%c'\n", first_non_repeat);
    } else {
        printf("No non-repeating character found.\n");
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• This solution uses a larger frequency array (freq[256]) to handle any character by using its ASCII value as the index.
• Pass 1 builds the frequency map. Pass 2 is the crucial part: it iterates through the original string in order. The first character encountered that has a frequency count of 1 (meaning it appeared only once) is guaranteed to be the first non-repeating character, so the loop breaks and the result is printed.

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

int main() {
    char str[] = "     This   is     a  test.     ";
    int read_idx = 0;
    int write_idx = 0;
    int i;

    // 1. Skip leading spaces
    while (isspace(str[read_idx])) {
        read_idx++;
    }

    // 2. Normalize spaces (reduce multiple to one)
    while (str[read_idx] != '\0') {
        if (isspace(str[read_idx])) {
            // If it's a space, only write it if the previous character wasn't already a space
            if (write_idx > 0 && !isspace(str[write_idx - 1])) {
                str[write_idx++] = ' ';
            }
        } else {
            // It's a non-space character, just copy it
            str[write_idx++] = str[read_idx];
        }
        read_idx++;
    }

    // 3. Remove trailing space (if one was written before the final '\0')
    if (write_idx > 0 && isspace(str[write_idx - 1])) {
        write_idx--;
    }

    // 4. Terminate the new string
    str[write_idx] = '\0';

    printf("Normalized string: \"%s\"\n", str);

    return 0;
}Code language: C++ (cpp)

Explanation:

• The code first skips over any leading whitespace. Then, it uses the read/write pointer technique.
• The core logic is: only write a space if the current character is a space AND the character just written (str[write_idx - 1]) was not a space. All subsequent spaces are skipped.
• Finally, the trailing space check ensures that if the last non-null character written was a space (because of a trailing space in the original string), the write_idx is moved back one position before the null terminator is placed, effectively trimming the trailing space.

#include <stdio.h>
#include <stdbool.h>
#include <ctype.h> 

int main() {
    char str1[] = "12345";
    char str2[] = "123a45";
    char *str = str1; // Test with str1 first

    bool all_digits = true;
    int i = 0;

    if (str[0] == '\0') {
        all_digits = false; // String is empty
    } else {
        while (str[i] != '\0') {
            if (!isdigit(str[i])) { // Check if character is NOT a digit
                all_digits = false;
                break;
            }
            i++;
        }
    }

    printf("String: \"%s\"\n", str);
    if (all_digits) {
        printf("Result: Contains only digits.\n");
    } else {
        printf("Result: Contains non-digit characters.\n");
    }

    // Optional: Re-test with str2 
    // str = str2; ...
    // [Re-run logic here to test str2]

    return 0;
}Code language: C++ (cpp)

Explanation:

• The program first checks if the string is empty. The while loop iterates through the string. The isdigit() function checks if a character is a decimal digit. The logic uses the negation operator (!) to check if the character is not a digit.
• If a non-digit character is found, the all_digits flag is set to false, and the break statement halts the process immediately, as no further checking is necessary.

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

int main() {
    char source[] = "ProgrammingInC";
    int start_index = 4; // Start from 'r' (index 4)
    int length = 7;      // Extract 7 characters ("ramming")
    char destination[15]; // Destination buffer size
    int i;

    // Ensure indices are valid (omitted full validation for brevity)
    if (start_index >= strlen(source)) {
        printf("Error: Start index out of bounds.\n");
        return 1;
    }

    // Loop runs for 'length' times
    for (i = 0; i < length; i++) {
        // Check if the source string ends before 'length' is complete
        if (source[start_index + i] == '\0') {
            break;
        }
        destination[i] = source[start_index + i];
    }

    // Null-terminate the destination string
    destination[i] = '\0'; 

    printf("Source: %s\n", source);
    printf("Substring: %s\n", destination);

    return 0;
}Code language: C++ (cpp)

Explanation:

• The for loop is designed to run exactly length times, controlled by the counter i. In each iteration, the character from the source string at index start_index + i is copied to the destination string at index i.
• An internal check (if (source[start_index + i] == '\0')) ensures that the copying stops prematurely if the original string ends before the requested length is reached. Finally, destination[i] = '\0'; adds the required null terminator at the end of the newly created substring.

#include <stdio.h>
#include <stdbool.h>

int main() {
    char haystack[] = "This is a search test";
    char needle[] = "search";
    int i, j;
    bool found = false;
    int start_index = -1;

    // Outer loop: iterates through the haystack (potential starting points)
    for (i = 0; haystack[i] != '\0'; i++) {
        // Inner loop: compares needle against haystack starting at index i
        for (j = 0; needle[j] != '\0'; j++) {
            // If a mismatch occurs, break the inner loop
            if (haystack[i + j] == '\0' || haystack[i + j] != needle[j]) {
                break;
            }
        }

        // If the inner loop finished because needle[j] hit '\0', it means a match
        if (needle[j] == '\0') {
            found = true;
            start_index = i;
            break; // Stop searching after the first match
        }
    }

    printf("Haystack: \"%s\"\n", haystack);
    printf("Needle: \"%s\"\n", needle);
    if (found) {
        printf("Substring found at index: %d\n", start_index);
    } else {
        printf("Substring not found.\n");
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• The outer loop (i) controls the potential starting position of the match in the haystack. The inner loop (j) compares characters.
• The key check is haystack[i + j] != needle[j]. If the characters match, j increments, and the comparison continues to the next character of the needle. If the inner loop breaks due to a mismatch, the outer loop continues to the next position in the haystack.
• If the inner loop completes successfully (meaning needle[j] is the null terminator), it implies every character in the needle matched, and the match is confirmed at index i.

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

void swap_char(char *a, char *b) {
    char temp = *a;
    *a = *b;
    *b = temp;
}

int main() {
    char str[] = "programming";
    int len = strlen(str);
    int start = 0;
    int end = len - 1;

    printf("Original string: %s\n", str);

    // Loop until the pointers meet or cross
    while (start < end) {
        // Swap characters at start and end indices
        swap_char(&str[start], &str[end]); 

        // Move pointers inward
        start++;
        end--;
    }

    printf("Reversed string: %s\n", str);

    return 0;
}Code language: C++ (cpp)

Explanation:

• The strlen() function finds the length of the string. start is initialized to 0 and end to the index of the last character.
• The while loop continues as long as start is less than end. Inside the loop, the swap_char function exchanges the characters pointed to by the two indices. By incrementing start and decrementing end simultaneously, the process moves inward from both ends, ensuring that the entire string is reversed in place by the time the pointers meet.

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

int main() {
    char str[] = "madam";
    int len = strlen(str);
    int start = 0;
    int end = len - 1;
    bool is_palindrome = true;

    while (start < end) {
        // Compare characters
        if (str[start] != str[end]) {
            is_palindrome = false;
            break; // Mismatch found, not a palindrome
        }
        // Move pointers inward
        start++;
        end--;
    }

    printf("String: %s\n", str);
    if (is_palindrome) {
        printf("Result: It is a palindrome.\n");
    } else {
        printf("Result: It is NOT a palindrome.\n");
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• The two-pointer technique is used to check symmetry.
• The loop compares characters from the outside-in. If str[start] does not equal str[end], the is_palindrome flag is set to false, and the loop is immediately terminated via break.
• If the loop completes, it means all corresponding characters from the start and end matched perfectly, confirming the string is a palindrome.

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

// Function to swap characters (from Ex 21)
void swap_char(char *a, char *b) {
    char temp = *a;
    *a = *b;
    *b = temp;
}

// Function to reverse a segment of the string (in place)
void reverse_segment(char *str, int start, int end) {
    while (start < end) {
        swap_char(&str[start], &str[end]);
        start++;
        end--;
    }
}

int main() {
    char str[] = "C programming is fun";
    int len = strlen(str);
    int word_start = 0;
    int i;

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

    // STEP 1: Reverse the entire string ("nuf si gnimmargorp C")
    reverse_segment(str, 0, len - 1);

    // STEP 2: Reverse each word individually
    for (i = 0; i <= len; i++) {
        if (str[i] == ' ' || str[i] == '\0') {
            // Found end of a word (or end of string)
            reverse_segment(str, word_start, i - 1);
            // Set the start of the next word to the position after the space
            word_start = i + 1; 
        }
    }

    printf("Reversed words: %s\n", str);

    return 0;
}Code language: C++ (cpp)

Explanation:

• First, the entire string is reversed, which places the words in the correct final order but leaves the characters in each word backwards.
• The second for loop iterates through the reversed string, looking for spaces or the null terminator (\0) to identify word boundaries.
• When a boundary is found, the reverse_segment function is called to reverse the characters only within that identified word’s boundaries, thus correcting the word’s internal character order.

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

int main() {
    char str[] = "programmingisgreat";
    // Flag array for all 256 possible ASCII chars
    int seen[256] = {0}; 
    int read_index = 0;
    int write_index = 0;

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

    while (str[read_index] != '\0') {
        unsigned char current_char = str[read_index]; // Use unsigned char for index safety

        // Check if the character has NOT been seen yet
        if (seen[current_char] == 0) {
            // 1. Mark as seen
            seen[current_char] = 1;

            // 2. Copy the character (keep it)
            str[write_index] = str[read_index];
            write_index++;
        }

        // Always move to the next character in the original string
        read_index++;
    }

    // Null-terminate the new string
    str[write_index] = '\0'; 

    printf("No duplicates: %s\n", str);

    return 0;
}Code language: C++ (cpp)

Explanation:

• The seen array acts as a simple hash set (or frequency map, where we only care about 0 or 1).
• The read/write pointer technique ensures in-place modification. For every character, its ASCII value is used to index into the seen array.
• If the value is 0 (unseen), the character is copied to the write_index position, and its corresponding seen entry is set to 1.
• If the value is 1 (seen), the character is skipped, and only read_index advances, effectively removing the duplicate.

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

int main() {
    char str1[] = "listen";
    char str2[] = "silent";
    int freq[26] = {0}; // Frequency map for a-z
    int i;
    bool is_anagram = true;

    // Pass 1: Increment counts for str1
    for (i = 0; str1[i] != '\0'; i++) {
        if (isalpha(str1[i])) {
            freq[tolower(str1[i]) - 'a']++;
        }
    }

    // Pass 2: Decrement counts for str2
    for (i = 0; str2[i] != '\0'; i++) {
        if (isalpha(str2[i])) {
            freq[tolower(str2[i]) - 'a']--;
        }
    }

    // Pass 3: Check frequency array
    for (i = 0; i < 26; i++) {
        if (freq[i] != 0) {
            is_anagram = false;
            break;
        }
    }

    printf("String 1: %s\n", str1);
    printf("String 2: %s\n", str2);
    if (is_anagram) {
        printf("Result: They are anagrams.\n");
    } else {
        printf("Result: They are NOT anagrams.\n");
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• The core of this solution lies in using the freq[26] array. By first incrementing counts for characters in the first string and then decrementing them for characters in the second string, we achieve a balance check.
• If the strings are true anagrams, every character introduced by str1 must be perfectly canceled out by a character in str2. Therefore, a final check for all zeros in the freq array confirms the anagram status.
• The use of isalpha() and tolower() ensures case and non-alphabetic characters are handled correctly.

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

void swap_char(char *a, char *b) {
    char temp = *a;
    *a = *b;
    *b = temp;
}

int main() {
    char str[] = "Jessa";
    int len = strlen(str);
    int i, j;

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

    // Implement Bubble Sort
    for (i = 0; i < len - 1; i++) {
        for (j = 0; j < len - i - 1; j++) {
            // Compare adjacent characters (using ASCII values)
            if (str[j] > str[j + 1]) {
                swap_char(&str[j], &str[j + 1]);
            }
        }
    }

    printf("Sorted: %s\n", str);

    return 0;
}Code language: C++ (cpp)

Explanation:

The solution uses the Bubble Sort algorithm

• The outer loop controls the number of passes, and the inner loop handles the actual comparisons and swaps. In the inner loop, if (str[j] > str[j + 1]) compares the ASCII values of two adjacent characters.
• If the character at the lower index (j) is greater than the character at the higher index (j + 1), they are swapped, moving the larger character toward the end of the string. This repeated process eventually places all characters in ascending ASCII (alphabetical) order.

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

int main() {
    char str[] = "successfully";
    int freq[256] = {0}; 
    int i;
    int max_freq = -1;
    int max_index = 0; // ASCII value of the most frequent character

    // Pass 1: Calculate Frequency
    for (i = 0; str[i] != '\0'; i++) {
        freq[(int)str[i]]++;
    }

    // Pass 2: Find the maximum frequency and its index
    for (i = 0; i < 256; i++) {
        if (freq[i] > max_freq) {
            max_freq = freq[i];
            max_index = i;
        }
    }

    printf("String: %s\n", str);
    printf("Highest frequency character: '%c' (Count: %d)\n", (char)max_index, max_freq);

    return 0;
}Code language: C++ (cpp)

Explanation:

• The solution uses a freq[256] array to count all characters.
• The second loop iterates through this freq array from index 0 to 255. It keeps track of max_freq (the highest count found so far) and max_index (the corresponding ASCII value).
• Whenever a higher frequency is found, both variables are updated. After checking all 256 possible characters, max_index holds the ASCII value of the character with the greatest number of occurrences, which is then cast back to a char for printing.

#include <stdio.h>
#include <stdbool.h>

int string_to_int(const char *str) {
    int result = 0;
    int sign = 1;
    int i = 0;

    // 1. Handle optional sign
    if (str[i] == '-') {
        sign = -1;
        i++;
    } else if (str[i] == '+') {
        i++;
    }

    // 2. Process digits
    while (str[i] != '\0') {
        // Check if it's a valid digit
        if (str[i] >= '0' && str[i] <= '9') {
            // Convert character digit to integer value
            int digit_value = str[i] - '0';

            // Update result: (previous result * 10) + new digit
            result = (result * 10) + digit_value;
        } else {
            // Stop on first non-digit character (after sign)
            break;
        }
        i++;
    }

    return result * sign;
}

int main() {
    char str1[] = "123";
    char str2[] = "-456";
    printf("123 -> %d\n", string_to_int(str1));
    printf("-456 -> %d\n", string_to_int(str2));

    return 0;
}Code language: C++ (cpp)

Explanation:

The code first checks for a leading sign (+ or -) and stores it in the sign variable, advancing the index i. The while loop iterates through the digits. The core logic is result = (result * 10) + digit_value. For the string “123”:

• ‘1’: (0 * 10) + 1 = 1
• ‘2’: (1 * 10) + 2 = 12
• ‘3’: (12 * 10) + 3 = 123 The character conversion str[i] - '0' uses the sequential nature of ASCII values (e.g., '5' – '0' equals the integer 5). Finally, the result is multiplied by the stored sign.

#include <stdio.h>
#include <string.h>
#include <stdbool.h>
#include <stdlib.h> // For abs()

// Function to reverse a segment of the string (from Ex 21/23)
void reverse_segment(char *str, int start, int end) {
    char temp;
    while (start < end) {
        temp = str[start];
        str[start] = str[end];
        str[end] = temp;
        start++;
        end--;
    }
}

// Converts integer n into string s (assumes s is large enough)
void int_to_string(int n, char s[]) {
    int i = 0;
    bool is_negative = false;

    if (n < 0) {
        is_negative = true;
        n = -n; // Work with positive version
    }

    // Handle case for n=0
    if (n == 0) {
        s[i++] = '0';
    } else {
        // Extract digits using modulo and division (reversed order)
        while (n > 0) {
            // '0' is added to integer digit to get its ASCII character
            s[i++] = (n % 10) + '0'; 
            n /= 10;
        }
    }

    // Add the sign if necessary
    if (is_negative) {
        s[i++] = '-';
    }

    s[i] = '\0'; // Null terminate the reversed string

    // Reverse the string to get the correct order
    reverse_segment(s, 0, i - 1); 
}

int main() {
    char buffer[20];
    int num1 = 12345;
    int num2 = -987;
    int_to_string(num1, buffer);
    printf("12345 -> \"%s\"\n", buffer); // Output: "12345"
    int_to_string(-num2, buffer);
    printf("-987 -> \"%s\"\n", buffer);  // Output: "-987"

    return 0;
}Code language: C++ (cpp)

Explanation:

• The function first handles the sign and converts the number to its positive magnitude.
• It then enters a while loop: n % 10 extracts the last digit (e.g., 123 % 10 = 3), and adding '0' converts this integer to its character representation. n / 10 discards the last digit.
• This process populates the string backwards. After all digits and the sign are placed, the entire string (from index 0 to i-1) is reversed using the auxiliary function to get the correct final order.

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

int main() {
    char url[] = "https://www.google.com/search/c_programming";
    char *protocol_end = strstr(url, "://");
    char *domain_start = NULL;
    char *path_start = NULL;
    int i;

    printf("URL: %s\n", url);

    // 1. EXTRACT PROTOCOL
    if (protocol_end != NULL) {
        int proto_len = protocol_end - url;
        printf("Protocol: ");
        for (i = 0; i < proto_len; i++) {
            printf("%c", url[i]);
        }
        printf("\n");

        domain_start = protocol_end + 3; // Move past "://"
    } else {
        // Handle case where no protocol is present
        domain_start = url; 
    }

    // 2. EXTRACT DOMAIN
    path_start = strchr(domain_start, '/'); // Find first '/' after protocol

    if (path_start != NULL) {
        int domain_len = path_start - domain_start;
        printf("Domain: ");
        for (i = 0; i < domain_len; i++) {
            printf("%c", domain_start[i]);
        }
        printf("\n");

        // 3. EXTRACT PATH
        printf("Path: %s\n", path_start);
    } else {
        // Case where URL ends after domain (e.g., "http://google.com")
        printf("Domain: %s\n", domain_start);
        printf("Path: /\n"); // Path defaults to root
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

The solution uses pointer arithmetic combined with string searching functions.

• Protocol: strstr(url, "://") finds the position of the delimiter. The length of the protocol is calculated by subtracting the start pointer of the URL from the position of the delimiter (protocol_end - url).
• Domain: The domain starts immediately after the delimiter (protocol_end + 3). strchr(domain_start, '/') finds the first forward slash after the protocol, which marks the end of the domain.
• Path: If a slash is found, the path starts at that position (path_start). Since the path goes until the end of the string, it can be printed directly using the %s format specifier. The domain itself is printed by iterating from domain_start up to the character before path_start.