#2810

Easy

LeetCode Problem Workspace

Faulty Keyboard

Simulate typing on a faulty keyboard where pressing 'i' reverses the string, requiring careful string manipulation tracking.

string simulation

Problem Statement

You are using a laptop with a faulty keyboard that reverses the current text whenever you type the character 'i'. All other characters append normally.

Given a string s representing the keys you type, simulate the effect of this faulty keyboard and return the final string displayed on the screen.

Examples

Example 1

Input: s = "string"

Output: "rtsng"

After typing first character, the text on the screen is "s". After the second character, the text is "st". After the third character, the text is "str". Since the fourth character is an 'i', the text gets reversed and becomes "rts". After the fifth character, the text is "rtsn". After the sixth character, the text is "rtsng". Therefore, we return "rtsng".

Example 2

Input: s = "poiinter"

Output: "ponter"

After the first character, the text on the screen is "p". After the second character, the text is "po". Since the third character you type is an 'i', the text gets reversed and becomes "op". Since the fourth character you type is an 'i', the text gets reversed and becomes "po". After the fifth character, the text is "pon". After the sixth character, the text is "pont". After the seventh character, the text is "ponte". After the eighth character, the text is "ponter". Therefore, we return "ponter".

Constraints

1 <= s.length <= 100
s consists of lowercase English letters.
s[0] != 'i'

Solution Approach

Step-by-step Simulation

Initialize an empty string and iterate through each character in s. Append non-'i' characters to the string and reverse the string whenever you encounter 'i'.

Efficient String Handling

Use a mutable structure like a list to build the string in-place and reverse it efficiently. Avoid repeated string concatenation to reduce overhead.

Return Final Result

After processing all characters, join the mutable structure into a final string and return it. This ensures the simulated reversals are correctly reflected in the output.

Complexity Analysis

Metric	Value
Time	Depends on the final approach
Space	Depends on the final approach

Time complexity is O(n) because each character is processed once and reversals on a mutable list are O(n). Space complexity is O(n) to store the intermediate string during simulation.

What Interviewers Usually Probe

Checks if you understand how to simulate character effects on strings efficiently.
Wants to see proper handling of the reversal trigger 'i' and non-destructive string operations.
Assesses your ability to maintain order and correctness during iterative string manipulations.

Common Pitfalls or Variants

Common pitfalls

Attempting to reverse strings using concatenation in a loop, which can increase time complexity.
Forgetting to reverse the string each time an 'i' appears, leading to incorrect final output.
Not handling edge cases like consecutive 'i' characters or the first character being 'i'.

Follow-up variants

Change the reversal trigger character from 'i' to another letter or symbol.
Instead of reversing the whole string, reverse only the last k characters each time.
Apply similar simulation on an array of numbers where a specific value triggers a reversal.

FAQ

What is the main strategy to solve Faulty Keyboard?

Traverse the string and build the result, reversing it whenever the character 'i' appears to simulate the faulty behavior.

Can this approach handle consecutive 'i' characters?

Yes, each 'i' triggers a reversal independently, so consecutive 'i's will reverse the string multiple times correctly.

Is using string concatenation safe in this problem?

Using repeated string concatenation is less efficient; using a list or mutable structure is preferred for in-place reversals.

What is the time complexity for Faulty Keyboard?

Time complexity is O(n) where n is the length of the string, as each character is processed once and list reversals are linear.

Which LeetCode pattern does this problem exemplify?

This problem is a String plus Simulation pattern where character-specific triggers change the state of the accumulated string.

terminal

Solution

Solution 1: Simulation

We directly simulate the keyboard input process, using a character array $t$ to record the text on the screen, initially $t$ is empty.

1

2

3

4

5

6

7

8

9

class Solution:
    def finalString(self, s: str) -> str:
        t = []
        for c in s:
            if c == "i":
                t = t[::-1]
            else:
                t.append(c)
        return "".join(t)

Continue Practicing

#2744 find maximum number of string pairs #2696 minimum string length after removing substrings #3168 minimum number of chairs in a waiting room