This is the solution for the practice question set on the concept of strings in programming languages.

You can find the corresponding list of questions here. Try solving the questions yourself before you go through the solutions.

Reverse Words in a Sentence

Problem: Write a program that reverses the order of words in a given sentence without altering the characters within each word.

Example: Input: `"Hello world from Java"` → Output: `"Java from world Hello"`

CODE : 

import java.io.*;

class Main {

    public static void main(String[] args) {

        // declaring the variables

        String sentence = "Hello world from Java";

        String[] words = sentence.split(" ");

        String[] reversed = new String[words.length];

        // reversing the words

        int index = 0;

        for (int i = words.length - 1; i >= 0; i--) {

            reversed[index] = words[i];

            index++;

        }

        // printing the original sentence

        System.out.println(sentence);

        // printing the reversed sentence

        for (int i = 0; i < reversed.length; i++) {

            System.out.print(reversed[i] + " ");

        }

    }

}

Check for Anagrams

Problem: Write a program to check if two given strings are anagrams (contain the same characters with the same frequency).

Example: `"listen"` and `"silent"` are anagrams.

CODE : 

import java.io.*;

class Main {

    public static void main(String[] args) {

        // declaring the variables

        String str1 = "listen";

        String str2 = "silent";

        int[] count1 = new int[26];

        int[] count2 = new int[26];

        int i;

        if (str1.length() != str2.length()) {

            System.out.println("The strings are not anagrams.");

            return;

        }

        // counting character frequencies

        for (i = 0; i < str1.length(); i++) {

            count1[str1.charAt(i) - 'a']++;

            count2[str2.charAt(i) - 'a']++;

        }

        // comparing frequency arrays

        boolean isAnagram = true;

        for (i = 0; i < 26; i++) {

            if (count1[i] != count2[i]) {

                isAnagram = false;

                break;

            }

        }

        if (isAnagram) {

            System.out.println("The strings are anagrams.");

        } else {

            System.out.println("The strings are not anagrams.");

        }

    }

}

Remove Duplicate Characters

Problem: Write a program to remove all duplicate characters from a given string, keeping only the first occurrence of each character.

Example: Input: `"programming"` → Output: `"progamin"`

CODE : 

import java.io.*;

class Main {

    public static void main(String[] args) {

        // declaring the variables

        String str = "programming";

        char[] chars = str.toCharArray();

        boolean[] seen = new boolean[256];

        String result = "";

        // forming result string without duplicate characters

        for (int i = 0; i < chars.length; i++) {

            if (!seen[chars[i]]) {

                result += chars[i];

                seen[chars[i]] = true;

            }

        }

        // printing the output

        System.out.println(str);

        System.out.println(result);

    }

}

Replace Vowels with Next Character

Problem: Write a program that replaces each vowel in a given string with the next consonant in the alphabet. For example, replace `a` with `b`, `e` with `f`, and so on.

Example: Input: `"hello"` → Output: `"hfllp"`

CODE : 

import java.io.*;

class Main {

    public static void main(String[] args) {

        // declaring the variables

        String str = "hello";

        char[] chars = str.toCharArray();

        // replacing vowels with next character

        for (int i = 0; i < chars.length; i++) {

            if ("aeiouAEIOU".indexOf(chars[i]) != -1) {

                chars[i] = (char) (chars[i] + 1);

            }

        }

        String result = new String(chars);

        // printing the output

        System.out.println(str);

        System.out.println(result);

    }

}

Count Vowels and Consonants

Problem: Write a program to count the number of vowels and consonants in a given string.

Example: Input: `"Hello World"` → Output: `Vowels: 3, Consonants: 7`

CODE : 

import java.io.*;

class Main {

    public static void main(String[] args) {

        // declaring the variables

        String str = "Hello World";

        char[] chars = str.toLowerCase().toCharArray();

        int vowels = 0, consonants = 0;

        // counting the vowels and consonants

        for (int i = 0; i < chars.length; i++) {

            if (chars[i] >= 'a' && chars[i] <= 'z') {

                if ("aeiou".indexOf(chars[i]) != -1) {

                    vowels++;

                } else {

                    consonants++;

                }

            }

        }

        // printing the output

        System.out.println("String : " + str);

        System.out.println("Vowels: " + vowels);

        System.out.println("Consonants: " + consonants);

    }

}

Find the Most Frequent Character

Problem: Write a program to find the character that appears the most frequently in a given string.

Example: Input: `"success"` → Output: `Most frequent character: s`

CODE : 

import java.io.*;

class Main {

    public static void main(String[] args) {

        // declaring the variables

        String str = "success";

        char[] chars = str.toCharArray();

        int[] freq = new int[256];

        // counting frequency of all characters

        for (int i = 0; i < chars.length; i++) {

            freq[chars[i]]++;

        }

        // finding the most frequent character

        char mostFrequent = '\0';

        int maxFrequency = 0;

        for (int i = 0; i < chars.length; i++) {

            if (freq[chars[i]] > maxFrequency) {

                maxFrequency = freq[chars[i]];

                mostFrequent = chars[i];

            }

        }

        // printing the output

        System.out.println("String: " + str);

        System.out.println("Most frequent character: " + mostFrequent);

    }

}

Check for a Pangram

Problem: A pangram is a sentence that contains every letter of the alphabet at least once. Write a program to check if a given string is a pangram.

Example: `"The quick brown fox jumps over the lazy dog"` is a pangram.

CODE : 

import java.io.*;

class Main {

    public static void main(String[] args) {

        // declaring the variables

        String sentence = "The quick brown fox jumps over the lazy dog";

        boolean[] seen = new boolean[26];

        int uniqueCount = 0;

        // there should be 26 unique alphabets

        for (int i = 0; i < sentence.length(); i++) {

            char c = Character.toLowerCase(sentence.charAt(i));

            if (c >= 'a' && c <= 'z') {

                if (!seen[c - 'a']) {

                    seen[c - 'a'] = true;

                    uniqueCount++;

                }

            }

        }

        // printing the output

        System.out.println("String: " + sentence);

        if (uniqueCount == 26) {

            System.out.println("The sentence is a pangram.");

        } else {

            System.out.println("The sentence is not a pangram.");

        }

    }

}

Convert Sentence to Title Case

Problem: Write a function that converts a given sentence to title case (capitalize the first letter of each word and lowercase the remaining letters).

Example: Input: `"hello world from python"` → Output: `"Hello World From Python"`

CODE : 

import java.io.*;

class Main {

    public static void main(String[] args) {

        // declaring the variables

        String sentence = "hello world from python";

        String[] words = sentence.split(" ");

        String result = "";

        // converting sentence to title case

        for (int i = 0; i < words.length; i++) {

            result += Character.toUpperCase(words[i].charAt(0)) + words[i].substring(1).toLowerCase() + " ";

        }

        // printing the output

        System.out.println("Original: " + sentence);

        System.out.println("Updated: " + result.trim());

    }

}

Run-Length Encoding

Problem: Implement run-length encoding, a simple form of data compression, where consecutive duplicates are replaced with the character and count. Write a program that converts a string into its run-length encoding.

Example: Input: `"aaabbc"` → Output: `"a3b2c1"`

CODE : 

import java.io.*;

class Main {

    public static void main(String[] args) {

        // declaring the variables

        String str = "aaabbc";

        String result = "";

        // run-length encoding

        for (int i = 0; i < str.length(); i++) {

            int count = 1;

            while (i + 1 < str.length() && str.charAt(i) == str.charAt(i + 1)) {

                count++;

                i++;

            }

            result += str.charAt(i) + String.valueOf(count);

        }

        // printing the output

        System.out.println("String: " + str);

        System.out.println("Run-Length Encoding: " + result);

    }

}

Character Frequency Sort

Problem: Write a program that takes a string and returns a new string where characters are sorted in descending order by their frequency of occurrence. If two characters have the same frequency, they should appear in lexicographical order.

Example: Input: `"tree"` → Output: `"eert"` or `"eetr"`

CODE : 

import java.io.*;

class Main {

    public static void main(String[] args) {

        // declaring the variables

        String str = "tree";

        char[] chars = str.toCharArray();

        int[] freq = new int[256];

        // counting frequency of characters

        for (int i = 0; i < chars.length; i++) {

            freq[chars[i]]++;

        }

        // sorting by character frequency

        for (int i = 0; i < chars.length; i++) {

            for (int j = i + 1; j < chars.length; j++) {

                if (freq[chars[j]] > freq[chars[i]] ||

                   (freq[chars[j]] == freq[chars[i]] && chars[j] < chars[i])) {

                    char temp = chars[i];

                    chars[i] = chars[j];

                    chars[j] = temp;

                }

            }

        }

        String result = new String(chars);

        // printing the output

        System.out.println("String: " + str);

        System.out.println("Frequency Sorted String: " + result);

    }

}