String practice problems

You have the tools now: a string knows its length(), it hands you any character with charAt, and a loop can walk it from end to end. This lesson is one long workout. It takes five classic string problems, the kind that turn up in coding interviews and in everyday programs, and solves each one slowly, with the index walking the string in front of you.

Problem 1: reverse a string#

Given a string such as "java", make a new string with its characters in the opposite order: "avaj".

A string is immutable, so you cannot shuffle "java" in place. Instead, start with an empty string and add characters to it. The trick is the direction you read in. Walk the original from its last index down to its first, adding each character as you go, and the new string comes out reversed.

Press Run and watch i count down: 3, 2, 1, 0. Each round takes one character from the end and adds it to reversed, which grows as "a", then "av", then "ava", then "avaj".

The line that does the work

reversed = reversed + s.charAt(i). Read it right to left. s.charAt(i) is the character at the current index. The + joins it to whatever reversed already holds, and the assignment stores that longer string back in reversed. Because you read s from the end, its last character lands first and its first character lands last.

For long text, a StringBuilder

Adding to a string with + in a loop makes a new string every round, which you saw is fine for a short word and slow for long text. The same loop with the StringBuilder from the strings lesson appends to one builder instead, and the builder can also reverse itself in one call.

Both lines print avaj. Step through the loop and watch the builder in the memory view gain one character per round. The rest of this page builds results with +, because the words are short and the steps are easier to follow, but the habit to carry into real programs is the builder.

Problem 2: count the vowels#

Given a word, count how many of its letters are vowels (a, e, i, o, u). For "Programming" the answer is 3.

This time walk the string forwards. Keep a counter that starts at 0. For each character, ask “is this one of the five vowels?”, and if it is, add one to the counter. Lower-case the whole string first, so that a capital A counts the same as a small a.

After toLowerCase, s holds "programming". As i walks across it, the counter goes up at three places: the o, the a and the i. Every other letter is a consonant and is skipped, so the program prints Vowels: 3.

The line that does the work

The long if condition. c == 'a' || c == 'e' || ...reads as “is c an a, or an e, or one of the others?”. The || (or) joins the five tests: if any one of them is true, the whole condition is true and the character counts. Notice the single quotes. 'a' is a char, the same type charAt hands back, so each test compares a char with a char, and == is the right tool for that.

Problem 3: is it a palindrome?#

A palindrome reads the same forwards and backwards: "racecar", "level", "noon". Given a string, decide true or false.

You could reverse the string and compare, and the puzzle at the end of this problem does exactly that. There is a tighter way, though, called two pointers. One position starts at the front and one at the back. Compare the characters there. If they ever differ, it is not a palindrome. If the front reaches the middle without finding a difference, every pair matched and it is a palindrome.

You do not even need two separate variables. The front character is s.charAt(i), and its mirror at the back is s.charAt(s.length() - 1 - i). As i grows, the mirror index shrinks. i only has to walk to the middle, so the loop runs while i < s.length() / 2.

"racecar" has length 7, so the loop runs while i < 3: for i equal to 0, 1 and 2. Watch the pairs line up: r with the r at index 6, a with the a at index 5, c with the c at index 4. The middle e at index 3 has no partner and needs none. Nothing ever differed, so it prints true.

The line that does the work

s.charAt(s.length() - 1 - i). The last index of any string is s.length() - 1, because counting starts at 0. Subtracting i walks the mirror inward as i walks the front inward from the other side. When i is 0 the mirror is the very last character; when i is 1 it is the second to last. The two march toward each other and meet in the middle.

To see the false case, change s to "hello" and run it again. On the very first round front is h and back is o. They differ, the flag turns false, and the program prints false. Now one that catches people out:

It prints false. The first pair is 'R' and 'r', and to Java those are different characters with different codes, 82 and 114. A person reads Racecar as a palindrome; the program needs to be told to ignore case. The exercise below does that.

1import java.util.Scanner;
2 
3public class Main {
4    public static void main(String[] args) {
5        Scanner in = new Scanner(System.in);
6        String s = in.nextLine();
7        boolean isPalindrome = true;
8 
9        for (int i = 0; i < s.length() / 2; i++) {
10            if (s.charAt(i) != s.charAt(s.length() - 1 - i)) {
11                isPalindrome = false;
12                break;
13            }
14        }
15 
16        System.out.println(isPalindrome);
17    }
18}

Problem 4: count one character#

Given a string and a target character, count how many times the character appears. In "yellow umbrella", the letter l appears 4 times.

This is the vowel counter with a simpler question. Walk the string, and for each character ask the one question “is this my target?”. If it is, add one.

The l shows up twice in yellow (at indexes 2 and 3), then twice more in umbrella (at indexes 12 and 13). Four in all, so the program prints 'l' appears 4 times.

The line that does the work

if (s.charAt(i) == target). Both sides are a char, so == compares them directly. The target has a variable of its own, so the same code counts any character: change target to 'e'and the loop counts the e's instead. Naming the thing you search for is a small habit that makes code easy to reuse.

Key idea

Counting problems share one skeleton: a counter at zero, a walk across the string, and one question asked of each character. Only the question changes.

Problem 5: the first non-repeating character#

Find the first character in a string that appears exactly once. In "swiss" the s repeats, and w is the first letter that stands alone, so the answer is w.

For each character you need to know whether it appears anywhere else in the string. You can find out by counting how many times it shows up across the whole string. If that count is exactly 1, the character is unique, and because you check from the front, the first unique character you meet is the answer.

Counting one character takes a second loop inside the first: the outer loop picks a character, and the inner loop walks the whole string counting how often that character appears. A loop inside a loop is called a nested loop.

Step through it slowly. The outer loop first picks the sat index 0. The inner loop counts the s's across "swiss" and finds 3 (at indexes 0, 3 and 4), so s is not unique and the outer loop moves on. Next it picks the w at index 1, and the inner loop finds only 1. That is the answer: the program stores w and breaks out, then prints First non-repeating: w.

The line that does the work

The pair answer = c; then break;. The moment a count comes back as 1, you have found the first unique character, and there is no reason to keep searching. break leaves the outer loop at once. Without it, the loop would carry on and could overwrite answer with a later unique character. break is what makes it the first one rather than the last.

It prints First non-repeating: ?. No count ever comes back as 1, so answer = c never runs and answer keeps the '?'it started with. That starting value is the program's way of saying “none”, which is why it was chosen to be something that is not a letter.

If every character's count were worked out once and kept in a table, the second loop could look each count up instead of counting again. For the small letters a to z, an array of 26 numbers is that table: counts[0] for a, counts[1] for b, and so on. A letter's place in the array is its distance from 'a', and since a char is a number, c - 'a' works it out: 0 for a, 22 for w.

1import java.util.Scanner;
2 
3public class Main {
4    public static void main(String[] args) {
5        Scanner in = new Scanner(System.in);
6        String s = in.nextLine();
7        int[] counts = new int[26];
8 
9        // TODO 1: walk s and add one to the count of each letter
10 
11        char answer = '?';
12        // TODO 2: walk s again and stop at the first letter whose count is 1
13 
14        System.out.println("First non-repeating: " + answer);
15    }
16}

The patterns you just used#

Five problems, but only a few ideas underneath them. Knowing their names helps you solve the sixth problem, the one you have never seen before.

• Reverse built a new string: it started from "", or an empty StringBuilder, and added one character per round.
• The vowel and character counts kept a counter at zero and added one whenever a test passed.
• The palindrome check used two pointers, walking in from both ends toward the middle.
• The first non-repeating character used a nested search, scanning the whole string again for each character, and then a table of counts to avoid the second scan.

Further reading#

• Strings, the dev.java tutorial, with more on searching and comparing text
• String in the Java SE 25 API documentation, for every method these problems could use