Faulty Keyboard

Faulty Keyboard - Problem

String Simulation Easy

Imagine you're working on an old laptop with a quirky keyboard bug - every time you press the letter 'i', instead of just typing it, the keyboard reverses your entire string that you've written so far!

You're given a string s representing the sequence of characters you want to type. Your task is to simulate this faulty keyboard behavior and determine what the final string will look like on your screen.

The Rules:

When you type any character other than 'i' → it gets appended normally
When you type the character 'i' → the entire current string gets reversed

Goal: Return the final string that appears on your laptop screen after typing all characters in s.

Example: If you type "string", you get: s → st → str → rts (reverse after 'i') → rtsn → rtsng → final result: "rtsng"

Input & Output

example_1.py — Basic Case

$ Input: s = "string"

› Output: "rtsng"

💡 Note: Step by step: '' → 's' → 'st' → 'str' → (reverse on 'i') 'rts' → 'rtsn' → 'rtsng'

example_2.py — Multiple Reversals

$ Input: s = "poiinter"

› Output: "ponter"

💡 Note: '' → 'p' → 'po' → (reverse) 'op' → (reverse) 'po' → 'pon' → 'pont' → 'ponte' → 'ponter'

example_3.py — No 'i' Characters

$ Input: s = "hello"

› Output: "hello"

💡 Note: Since there are no 'i' characters, the string is built normally without any reversals

Constraints

1 ≤ s.length ≤ 100
s consists of only lowercase English letters
The character 'i' will trigger the reversal operation

Visualization

Tap to expand

Asked in

f Meta 15 G Google 12 a Amazon 8 ⊞ Microsoft 6

The optimal approach uses string simulation with character-by-character processing. We iterate through the input string, appending normal characters and reversing the entire result whenever we encounter the character 'i'. This directly mirrors the faulty keyboard behavior with O(n²) time complexity in worst case due to string reversals.

Common Approaches

✓ Sort First

⏱️ Time: N/A Space: N/A

Brute Force String Reversal

⏱️ Time: O(n²) Space: O(n)

This approach simulates the keyboard behavior exactly as described. We iterate through each character in the input string. If it's not 'i', we append it to our result. If it is 'i', we reverse the entire result string built so far. This directly mirrors the problem description but can be inefficient for strings with many 'i' characters.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

typedef struct {
    int idx;
    int sourceLen;
    char target[100];
} Replacement;

int compare(const void* a, const void* b) {
    return ((Replacement*)b)->idx - ((Replacement*)a)->idx;
}

int parseArray(char* str, int* arr) {
    if (strcmp(str, "[]") == 0) return 0;
    
    int count = 0;
    char* token = strtok(str + 1, ",]");
    while (token != NULL) {
        arr[count++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    return count;
}

int parseStringArray(char* str, char arr[][100]) {
    if (strcmp(str, "[]") == 0) return 0;
    
    int count = 0;
    int len = strlen(str);
    int i = 2; // Skip '["'
    
    while (i < len - 2) { // Until '"]
        int j = 0;
        while (i < len && str[i] != '"') {
            arr[count][j++] = str[i++];
        }
        arr[count][j] = '\0';
        count++;
        
        // Skip '","'
        i += 3;
        if (i >= len - 2) break;
    }
    return count;
}

char* solution(char* s, int* indices, char sources[][100], char targets[][100], int k) {
    // Collect valid replacements
    Replacement validReplacements[k];
    int validCount = 0;
    
    for (int i = 0; i < k; i++) {
        int idx = indices[i];
        int sourceLen = strlen(sources[i]);
        if (idx + sourceLen <= strlen(s) && strncmp(s + idx, sources[i], sourceLen) == 0) {
            validReplacements[validCount].idx = idx;
            validReplacements[validCount].sourceLen = sourceLen;
            strcpy(validReplacements[validCount].target, targets[i]);
            validCount++;
        }
    }
    
    // Sort by index in descending order (right to left)
    qsort(validReplacements, validCount, sizeof(Replacement), compare);
    
    // Apply replacements from right to left
    char* result = malloc(10000);
    strcpy(result, s);
    
    for (int i = 0; i < validCount; i++) {
        int idx = validReplacements[i].idx;
        int sourceLen = validReplacements[i].sourceLen;
        int targetLen = strlen(validReplacements[i].target);
        
        // Move the part after replacement
        memmove(result + idx + targetLen, result + idx + sourceLen, strlen(result) - idx - sourceLen + 1);
        // Insert target
        memcpy(result + idx, validReplacements[i].target, targetLen);
    }
    
    return result;
}

int main() {
    char s[1000];
    char indicesStr[1000];
    char sourcesStr[1000];
    char targetsStr[1000];
    
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    fgets(indicesStr, sizeof(indicesStr), stdin);
    indicesStr[strcspn(indicesStr, "\n")] = 0;
    
    fgets(sourcesStr, sizeof(sourcesStr), stdin);
    sourcesStr[strcspn(sourcesStr, "\n")] = 0;
    
    fgets(targetsStr, sizeof(targetsStr), stdin);
    targetsStr[strcspn(targetsStr, "\n")] = 0;
    
    int indices[100];
    char sources[100][100];
    char targets[100][100];
    
    int k = parseArray(indicesStr, indices);
    parseStringArray(sourcesStr, sources);
    parseStringArray(targetsStr, targets);
    
    char* result = solution(s, indices, sources, targets, k);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~8 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen