Repeat String - Practice Coding Problems

Repeat String - Problem

JavaScript Easy

In this problem, you'll extend JavaScript's String prototype to add a custom method that repeats a string multiple times.

Goal: Implement a String.prototype.replicate(x) method that returns the string repeated x times. For example, "hello".replicate(3) should return "hellohellohello".

Challenge: You must implement this without using the built-in String.prototype.repeat() method. This exercise will help you understand string manipulation, prototype extension, and algorithm optimization.

Examples:
• "abc".replicate(2) → "abcabc"
• "x".replicate(5) → "xxxxx"
• "hello".replicate(0) → ""

Input & Output

example_1.js — Basic Usage

$ Input: "hello".replicate(3)

› Output: "hellohellohello"

💡 Note: The string 'hello' is repeated 3 times consecutively without any separators.

example_2.js — Single Character

$ Input: "x".replicate(5)

› Output: "xxxxx"

💡 Note: Single character 'x' is repeated 5 times to create a string of length 5.

example_3.js — Edge Case Zero

$ Input: "test".replicate(0)

› Output: ""

💡 Note: When repeat count is 0, the method should return an empty string regardless of the original string.

Constraints

The repeat count x will be a non-negative integer (0 ≤ x ≤ 1000)
The original string length will not exceed 100 characters
Cannot use the built-in String.prototype.repeat() method
Must extend the String prototype to add the replicate method

Visualization

Tap to expand

Understanding the Visualization

Simple Approach

Worker copies 'abc' five times: abc + abc + abc + abc + abc

Smart Approach Setup

Machine starts with 'abc', target is 5 copies (binary: 101)

Binary Logic

101 means: take 1×'abc' + skip 2×'abc' + take 4×'abc'

Efficient Result

Result: 'abc' + 'abcabcabcabc' = 'abcabcabcabcabc'

Key Takeaway

🎯 Key Insight: Binary exponentiation transforms a linear problem into a logarithmic one by leveraging the binary representation of the repeat count, making it exponentially faster for large inputs.

Asked in

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

The optimal solution uses binary exponentiation to efficiently replicate strings. Instead of concatenating the original string x times, we examine the binary representation of x and strategically double our base string. This reduces the time complexity from O(n²) to O(n log m) where n is string length and m is repeat count.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Exponentiation (Optimal)	O(n × log m)	O(n × m)	Use binary representation to efficiently double the string length
Simple Loop (Concatenation)	O(n²)	O(n×m)	Concatenate the string x times using a simple loop

Binary Exponentiation (Optimal) — Algorithm Steps

Handle edge case when x <= 0
Initialize result as empty and base as original string
While x > 0, check if x is odd
If odd, add current base to result
Double the base and halve x (integer division)
Continue until x becomes 0

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set base = 'ab', x = 5 (binary: 101)

x=5 (odd)

Add 'ab' to result, double base to 'abab'

x=2 (even)

Skip addition, double base to 'abababab'

x=1 (odd)

Add 'abababab' to result = 'ababababab'

Code -

solution.c — C

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

char* replicate(const char* str, int x) {
    if (x <= 0 || str == NULL) {
        char* empty = malloc(1);
        empty[0] = '\0';
        return empty;
    }
    
    int len = strlen(str);
    char* result = malloc(len * x + 1);
    result[0] = '\0';
    
    char* base = malloc(len * x + 1);
    strcpy(base, str);
    
    while (x > 0) {
        if (x & 1) {
            strcat(result, base);
        }
        strcat(base, base);
        x >>= 1;
    }
    
    free(base);
    return result;
}

int main() {
    char* result = replicate("hello", 5);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × log m)

Where n is string length and m is repeat count. We perform log m iterations, each doing string operations of length n

⚡ Linearithmic

Space Complexity

O(n × m)

Still need space for final result, but intermediate operations are more efficient

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~12 min Avg. Time

892 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Binary Exponentiation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler