Loading…

easyStrings0Sometimes asked

Funny String

Q: How do you solve Funny String using the Build the Reverse and Compare Difference Lists (Baseline) approach?

When to use it: Open with this — it follows the definition literally and is easy to get right, then note the extra O(n) space. Follow the wording of the problem to the letter: form `r = reverse(s)`, compute the adjacent absolute differences of both strings, and check the two lists are identical. **Why it is correct by construction.** The problem defines 'funny' as 'the adjacent difference profiles of `s` and `reverse(s)` agree'. This approach computes exactly those two profiles and compares them, so there is no room for an off-by-one in the *logic* — only in the indexing. **Why absolute value is essential.** `|s[i] − s[i−1]|` discards sign. If you kept the signed difference, the reverse would flip every sign (walking the same neighbours in the opposite direction), and almost nothing would ever be funny. Taking the absolute value is what makes the forward and mirrored gaps comparable. **Why we don't ship it.** It allocates a reversed string and (often) two difference arrays — `O(n)` memory — to answer a yes/no question. The reverse's difference at position `i` is fully determined by the original string, so we can compute it on the fly and drop all the extra storage. Use this version to make the definition concrete, then fold it into the index-mirroring solution. Time complexity: O(n). Space complexity: O(n).

Q: How do you solve Funny String using the Mirror the Index — No Reverse Allocated (Optimal) approach?

When to use it: The polished answer. Phrase it as 'the reverse's gap at i is just s's gap read from the other end'. Walk one index `i` from `1` to `n−1`. At each step compare the forward gap `|s[i] − s[i−1]|` with the *mirrored* gap `|s[n−i] − s[n−i−1]|`. If they ever disagree, return 'Not Funny'; survive the whole range and return 'Funny'. **Where the mirror index comes from.** In the reversed string `r`, character at position `i` is the original character at position `n−1−i`. So the reverse's adjacent gap `|r[i] − r[i−1]|` equals `|s[n−1−i] − s[n−1−(i−1)]| = |s[n−1−i] − s[n−i]|`. Since absolute value ignores order, that's `|s[n−i] − s[n−i−1]|`. The reverse's gap at step `i` is therefore a plain expression in the *original* string — no `r` required. **Why this is the same test as the baseline.** The baseline compared two lists; this compares the same two values pairwise, just sourced directly from `s`. As `i` runs forward, the mirror index `n−i` runs backward, so we're checking `s`'s gap sequence against itself reversed — exactly the palindrome-of-differences condition. **Why absolute value still matters.** Reading the neighbours from the opposite end swaps which one is subtracted first, flipping the sign. The absolute value erases that flip so the forward and mirrored gaps are directly comparable. Drop it and the mirror almost never matches. **Why O(1) space.** The only state is the loop counter and two freshly computed integer gaps per iteration. Nothing scales with `n`, so memory is constant — the entire reason to prefer this over the baseline. **Why early exit is safe.** A single position where the forward and mirrored gaps differ is a witness that the difference sequence is not a palindrome, which is enough to conclude 'Not Funny' without scanning the rest. Time complexity: O(n). Space complexity: O(1).

Arrays & Hashing · 51 of 83 · 6 min

A string is funny if, comparing it with its reverse, the absolute difference between the ASCII values of every pair of adjacent characters is preserved.

Return "Funny" if the condition holds for all i, and "Not Funny" otherwise.

In plain English

Forget the characters themselves; what matters is the gap between each pair of neighbours. Slide a window of size two across the string and record |gap|. Do the same on the reverse. The string is funny when those two gap profiles line up exactly. Because reversing a string reverses its gap profile, 'matches the reverse' is just 'the gap profile is a palindrome'.

Examples

Example 1

Input: s = "acxz"
Output: Funny
Note: Forward gaps: |c−a|=2, |x−c|=21, |z−x|=2 → [2,21,2]. Reverse 'zxca' gaps: |x−z|=2, |c−x|=21, |a−c|=2 → [2,21,2]. They match.

Example 2

Input: s = "bcxz"
Output: Not Funny
Note: Forward gaps: |c−b|=1, |x−c|=21, |z−x|=2 → [1,21,2]. Reverse gaps: [2,21,1]. First positions differ (1 vs 2).

Example 3

Input: s = "a"
Output: Funny
Note: No adjacent pairs exist, so the condition holds vacuously.

Constraints

1 ≤ |s| ≤ 10⁴
s consists of lowercase (or mixed) English letters
Differences are taken over ASCII / code-point values

Clarifying questions4First question: Absolute difference or signed?Explore questions

Q1.Absolute difference or signed?
Absolute. The definition uses |s[i] − s[i−1]|, so direction is discarded.
Q2.Do I need to actually build the reversed string?
No. The reverse's adjacent difference at step i equals |s[n−i] − s[n−i−1]| in the original, so you can mirror the index and stay O(1) space.
Q3.What counts as the value of a character?
Its ASCII / Unicode code point. In Java a char is already an int; in Python use ord().
Q4.What about a single-character or empty string?
There are no adjacent pairs, so the condition is vacuously true → 'Funny'. The loop simply never runs.

Quick interview revision

Understand

30-second explanation

Build the interview-ready mental model before comparing implementations.

Build the list of absolute differences between adjacent characters, |s[i] − s[i−1]|. Do the same for the reversed string. The string is 'funny' when those two difference lists are identical. The clean trick: you don't have to physically reverse the string — the reverse's difference at position i equals the original's difference read from the opposite end. Compare s's differences front-to-back against the same list back-to-front. O(n) time, O(1) space.

Interview contextWhat is testedWhere candidates slipHow to stand outExplore interview context

What's being tested

Whether you translate the wordy definition into a concrete invariant — the adjacent absolute-difference sequence — and whether you realise reversing the string just reverses that sequence, so no extra allocation is needed.

Where candidates slip

Comparing the characters of s and its reverse instead of the differences, or forgetting the absolute value so a negative gap fails to match its positive mirror.

How to stand out

State the insight out loud: 'funny' means the difference sequence is a palindrome. Then skip building reverse(s) entirely by mirroring the index, turning O(n) extra space into O(1).

Choose

Compare the available approaches

Use constraints and trade-offs to select the route you can defend in an interview.

Approaches at a glanceCompare before you dive in

#	Approach	Time	Space	When to mention	Jump
1	Build the Reverse and Compare Difference Lists (Baseline)	`O(n)`	`O(n)`	Open with this — it follows the definition literally and is easy to get right, then note the extra O(n) space.	Read
2	Mirror the Index — No Reverse Allocated (Optimal)Optimal	`O(n)`	`O(1)`	The polished answer. Phrase it as 'the reverse's gap at i is just s's gap read from the other end'.	Read

Interactive decision treeInteractiveChoose the right approachFollow the branches and learn why each constraint changes the solution.First decision previewString sIs the gap sequence a palindrome?YesNoExplore the full tree

Learn & trace

Build each solution step by step

Move from the core idea to a visual trace, implementation, proof, and edge cases.

03.1

Approach 1 of 2

Build the Reverse and Compare Difference Lists (Baseline)

TimeO(n)SpaceO(n)

Open with this — it follows the definition literally and is easy to get right, then note the extra O(n) space.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

The definition mentions reverse(s) explicitly. What's the most direct way to follow it?

2Hint 2Explore hint

Physically reverse the string, then build two arrays of adjacent absolute differences — one for s, one for the reverse.

3Hint 3Explore hint

Compare the two difference arrays element by element; equal everywhere means 'Funny'.

A · Core idea

Follow the wording of the problem to the letter: form r = reverse(s), compute the adjacent absolute differences of both strings, and check the two lists are identical.

Why it is correct by construction. The problem defines 'funny' as 'the adjacent difference profiles of s and reverse(s) agree'. This approach computes exactly those two profiles and compares them, so there is no room for an off-by-one in the logic — only in the indexing.

Why absolute value is essential. |s[i] − s[i−1]| discards sign. If you kept the signed difference, the reverse would flip every sign (walking the same neighbours in the opposite direction), and almost nothing would ever be funny. Taking the absolute value is what makes the forward and mirrored gaps comparable.

Why we don't ship it. It allocates a reversed string and (often) two difference arrays — O(n) memory — to answer a yes/no question. The reverse's difference at position i is fully determined by the original string, so we can compute it on the fly and drop all the extra storage. Use this version to make the definition concrete, then fold it into the index-mirroring solution.

B · Visual dry run

Interactive dry run

Select a frame to connect the decision with its visual state.

s = "acxz"

reverse

r = "zxca"

Statehave both strings

Final resultFunny

C · Code with teaching comments

Reference implementation previewpublic String funnyString(String s) { String r = new StringBuilder(s).reverse().toString(); int n = s.length(); for (int i = 1; i < n; i++) { int ds = Math.abs(s.charAt(i) - s.charAt(i - 1));Explore the full code

solution.javaJava

Build the Reverse and Compare Difference Lists (Baseline) — reference

3 teaching notes

1
public String funnyString(String s) {
2
    // Physically build the reverse — the O(n) allocation we'll later eliminate.
3
    String r = new StringBuilder(s).reverse().toString();
4
    int n = s.length();
5
    for (int i = 1; i < n; i++) {
6
        // char subtraction promotes to int; abs() discards direction.
7
        int ds = Math.abs(s.charAt(i) - s.charAt(i - 1));
8
        int dr = Math.abs(r.charAt(i) - r.charAt(i - 1));
9
        // Any mismatch between forward and reverse gaps disqualifies the string.
10
        if (ds != dr) {
11
            return "Not Funny";
12
        }
13
    }
14
    return "Funny";
15
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.15 lines

D · Why it works and complexityO(n) timeO(n) spaceOpen the invariant and proofExplore the proof

Writing out both difference lists makes the symmetry obvious: the reverse's list is literally s's list read backwards. That observation is the bridge to the O(1)-space version — you never needed the reversed string, only its differences, which you already have.

ComplexityO(n) time, O(n) space — Reversing is O(n), building each difference list is O(n), and comparing them is O(n) → O(n) time. Storing the reversed string and/or two difference arrays costs O(n) extra space.

E · Edge cases and pitfalls3Comparing characters of s and r instead of their adjacent differences.Explore edge cases

Pitfalls

Comparing characters of s and r instead of their adjacent differences.
Dropping the absolute value, so signed gaps never match across the reverse.
Allocating the reversed string when an index mirror would do.

03.2

Approach 2 of 2 · Optimal

Mirror the Index — No Reverse Allocated (Optimal)

TimeO(n)SpaceO(1)

The polished answer. Phrase it as 'the reverse's gap at i is just s's gap read from the other end'.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

You built reverse(s) only to read its adjacent differences. Can you express the reverse's difference at position i purely in terms of s?

2Hint 2Explore hint

3Hint 3Explore hint

Loop i from 1 to n-1, compare |s[i] - s[i-1]| against |s[n-i] - s[n-i-1]|. No reversed string, no difference arrays — just two subtractions per step.

A · Core idea

Walk one index i from 1 to n−1. At each step compare the forward gap |s[i] − s[i−1]| with the mirrored gap |s[n−i] − s[n−i−1]|. If they ever disagree, return 'Not Funny'; survive the whole range and return 'Funny'.

Where the mirror index comes from. In the reversed string r, character at position i is the original character at position n−1−i. So the reverse's adjacent gap |r[i] − r[i−1]| equals |s[n−1−i] − s[n−1−(i−1)]| = |s[n−1−i] − s[n−i]|. Since absolute value ignores order, that's |s[n−i] − s[n−i−1]|. The reverse's gap at step i is therefore a plain expression in the original string — no r required.

Why this is the same test as the baseline. The baseline compared two lists; this compares the same two values pairwise, just sourced directly from s. As i runs forward, the mirror index n−i runs backward, so we're checking s's gap sequence against itself reversed — exactly the palindrome-of-differences condition.

Why absolute value still matters. Reading the neighbours from the opposite end swaps which one is subtracted first, flipping the sign. The absolute value erases that flip so the forward and mirrored gaps are directly comparable. Drop it and the mirror almost never matches.

Why O(1) space. The only state is the loop counter and two freshly computed integer gaps per iteration. Nothing scales with n, so memory is constant — the entire reason to prefer this over the baseline.

Why early exit is safe. A single position where the forward and mirrored gaps differ is a witness that the difference sequence is not a palindrome, which is enough to conclude 'Not Funny' without scanning the rest.

B · Visual dry run

Interactive dry run

Select a frame to connect the decision with its visual state.

s = "bcxz"

Array state

i=1

fwd |c-a|=2 vs mirror |z-x|=2 → match

[0]

i ↓

[1]

[2]

n-i ↓

[3]

Current pointerResolved stateNot processed

Final resultNot Funny

C · Code with teaching comments

solution.javaJava

Mirror the Index — No Reverse Allocated (Optimal) — optimal

4 teaching notes

1
public String funnyString(String s) {
2
    int n = s.length();
3
    // i indexes forward gaps; for each, n-i indexes the mirrored gap from the far end.
4
    for (int i = 1; i < n; i++) {
5
        // Gap between this character and its left neighbour in the original direction.
6
        int forward = Math.abs(s.charAt(i) - s.charAt(i - 1));
7
        // The reverse's gap at step i, rewritten in terms of s — no reversed string
8
        // needed.
9
        int mirror = Math.abs(s.charAt(n - i) - s.charAt(n - i - 1));
10
        // A single disagreement breaks the palindrome-of-differences and ends the scan.
11
        if (forward != mirror) {
12
            return "Not Funny";
13
        }
14
    }
15
    return "Funny";
16
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.16 lines

D · Why it works and complexityO(n) timeO(1) spaceOpen the invariant and proofExplore the proof

Whenever you only need a transformed string's derived values (here, adjacent gaps) rather than the string itself, look for a closed-form index map back into the original. Reverse maps position i to n−1−i; substituting that turns an O(n)-space copy into O(1)-space arithmetic.

ComplexityO(n) time, O(1) space — A single pass with i from 1 to n−1 does O(1) work per step → O(n) time. You hold only a couple of integers, so O(1) extra space — no reversed string, no arrays.

E · Edge cases and pitfalls6s = "a" — n = 1, loop from 1 never runs → 'Funny' (no adjacent pairs to violate).Explore edge cases

Edge cases handled

s = "a"n = 1, loop from 1 never runs → 'Funny' (no adjacent pairs to violate).
s = "aa"One gap |a-a|=0 vs mirror |a-a|=0 → 'Funny'.
s = "ab"fwd |b-a|=1, mirror also |b-a|=1 (mirror reads s[1],s[0]) → 'Funny'; any 2-char string is funny.

Pitfalls

Off-by-one on the mirror: it's s[n-i] and s[n-i-1], not s[n-1-i] alone.
Forgetting abs(), so the sign flip from reading right-to-left breaks the match.
Subtracting characters without code-point semantics (fine in Java; use ord() in Python).

Practice

Try the solution yourself

Edit the optimal implementation, test another input, and observe the result.

Editable code previewpublic String funnyString(String s) { int n = s.length(); for (int i = 1; i < n; i++) { int forward = Math.abs(s.charAt(i) - s.charAt(i - 1)); int mirror = Math.abs(s.charAt(n - i) - s.charAt(n - i - 1));Explore the playground

Try it — Java· run a complete program; method snippets need a driver

Avoid mistakes

Recognize the interview traps

Understand why common attempts fail before reviewing the corrected implementation.

Comparing characters, not differences

'Funny' is about the GAPS between neighbours, not the letters. Comparing s[i] to r[i] tests whether the string is a palindrome — a different, stricter property.

Explore the code comparison

Don't write this

r = s[::-1]
for i in range(len(s)):
    if s[i] != r[i]:
        return "Not Funny"
return "Funny"

Write this instead

for i in range(1, len(s)):
    if abs(ord(s[i]) - ord(s[i-1])) != abs(ord(s[len(s)-i]) - ord(s[len(s)-i-1])):
        return "Not Funny"
return "Funny"

Dropping the absolute value

Reading neighbours from the reversed end flips the sign of every gap. Without abs() the forward gap +2 never equals the reverse gap −2, so almost no string is judged funny.

Explore the code comparison

Don't write this

int ds = s.charAt(i) - s.charAt(i - 1);
int dr = r.charAt(i) - r.charAt(i - 1);
if (ds != dr) return "Not Funny";

Write this instead

int ds = Math.abs(s.charAt(i) - s.charAt(i - 1));
int dr = Math.abs(r.charAt(i) - r.charAt(i - 1));
if (ds != dr) return "Not Funny";

Wrong mirror index

When skipping the explicit reverse, the reverse's gap at step i is |s[n-i] - s[n-i-1]|. Using s[n-1-i] for a single character (instead of the pair) silently compares the wrong neighbours.

Explore the code comparison

Don't write this

mirror = abs(ord(s[n - 1 - i]) - ord(s[i - 1]))

Write this instead

mirror = abs(ord(s[n - i]) - ord(s[n - i - 1]))

Revise

Carry the pattern into the interview

Quick interview revision

Pattern to remember

Adjacent-difference sequence + symmetry check

Code pattern to memorize

n = len(s)
for i in 1 .. n-1:
    if |s[i] - s[i-1]| != |s[n-i] - s[n-i-1]|:
        return "Not Funny"
return "Funny"

Rules to remember

1Compare absolute differences — |s[i] − s[i−1]|, never the signed value.
2You don't need to allocate reverse(s): the reversed difference at step i is |s[n−i] − s[n−i−1]|.
3Index the original characters by their ASCII / code-point value, not the character itself.
4Loop i from 1 to n−1; both the forward and mirrored differences are valid in that range.
5Any single mismatch ends it as 'Not Funny'; survive all positions and it's 'Funny'.

Use this pattern when

You must compare a string's adjacent-difference profile against its reverse
The property is defined on gaps between neighbours, not the characters themselves
You want to avoid building the reversed string and just mirror the index
A symmetry / palindrome-of-differences check is hidden inside the prompt

Choose another pattern when

The property uses the characters directly (not gaps) → compare characters, not differences
Signed direction matters → don't take absolute value
You must transform the string, not just answer yes/no → you may actually need the reverse
Differences are over non-adjacent pairs → it's no longer a simple neighbour scan

Interview takeaway

A string is funny exactly when its sequence of adjacent absolute differences is a palindrome. Reversing the string reverses that difference sequence, so 'equal to its reverse's differences' is the same as 'the difference sequence reads the same both ways'. Mirror the index instead of building the reverse to keep it O(1) space.

Continue

Transfer the pattern to another problem

Use a direct variation or pattern sibling to prove the idea is reusable.

Transferable patternDifference-sequence symmetry. Translate a wordy string property into a concrete invariant — here the sequence of adjacent absolute differences — then notice that reversing the string reverses that sequence, so the test becomes 'is the difference sequence a palindrome?'. Mirroring the index (i ↔ n−i) reads the reverse's values straight off the original, trading O(n) space for O(1).

Practice queueDirect variations and pattern siblings

Direct follow-ups

Valid Palindrome
Same mirror-index idea, but compare characters directly instead of their gaps.
Funny String with signed differences
Coming soon
Drop the absolute value and ask which strings survive — a good 'why abs?' discussion.
Longest Palindromic Substring
Coming soon
Palindrome detection scaled up — expand around centres instead of one full check.
Mars Exploration
Another adjacent-window string scan: count characters that deviate from the expected SOS pattern.

Same pattern

←

Subarray Division (Lily's Chocolate)

Continue · Next problem

Gemstones

easyStrings0Sometimes asked

Funny String

Arrays & Hashing · 51 of 83 · 6 min

A string is funny if, comparing it with its reverse, the absolute difference between the ASCII values of every pair of adjacent characters is preserved.

Return "Funny" if the condition holds for all i, and "Not Funny" otherwise.

In plain English

Examples

Example 1

Input: s = "acxz"
Output: Funny
Note: Forward gaps: |c−a|=2, |x−c|=21, |z−x|=2 → [2,21,2]. Reverse 'zxca' gaps: |x−z|=2, |c−x|=21, |a−c|=2 → [2,21,2]. They match.

Example 2

Input: s = "bcxz"
Output: Not Funny
Note: Forward gaps: |c−b|=1, |x−c|=21, |z−x|=2 → [1,21,2]. Reverse gaps: [2,21,1]. First positions differ (1 vs 2).

Example 3

Input: s = "a"
Output: Funny
Note: No adjacent pairs exist, so the condition holds vacuously.

Constraints

1 ≤ |s| ≤ 10⁴
s consists of lowercase (or mixed) English letters
Differences are taken over ASCII / code-point values

Clarifying questions4First question: Absolute difference or signed?Explore questions

Q1.Absolute difference or signed?
Absolute. The definition uses |s[i] − s[i−1]|, so direction is discarded.
Q2.Do I need to actually build the reversed string?
No. The reverse's adjacent difference at step i equals |s[n−i] − s[n−i−1]| in the original, so you can mirror the index and stay O(1) space.
Q3.What counts as the value of a character?
Its ASCII / Unicode code point. In Java a char is already an int; in Python use ord().
Q4.What about a single-character or empty string?
There are no adjacent pairs, so the condition is vacuously true → 'Funny'. The loop simply never runs.

Quick interview revision

Understand

30-second explanation

Build the interview-ready mental model before comparing implementations.

Interview contextWhat is testedWhere candidates slipHow to stand outExplore interview context

What's being tested

Where candidates slip

Comparing the characters of s and its reverse instead of the differences, or forgetting the absolute value so a negative gap fails to match its positive mirror.

How to stand out

State the insight out loud: 'funny' means the difference sequence is a palindrome. Then skip building reverse(s) entirely by mirroring the index, turning O(n) extra space into O(1).

Choose

Compare the available approaches

Use constraints and trade-offs to select the route you can defend in an interview.

Approaches at a glanceCompare before you dive in

#	Approach	Time	Space	When to mention	Jump
1	Build the Reverse and Compare Difference Lists (Baseline)	`O(n)`	`O(n)`	Open with this — it follows the definition literally and is easy to get right, then note the extra O(n) space.	Read
2	Mirror the Index — No Reverse Allocated (Optimal)Optimal	`O(n)`	`O(1)`	The polished answer. Phrase it as 'the reverse's gap at i is just s's gap read from the other end'.	Read

Learn & trace

Build each solution step by step

Move from the core idea to a visual trace, implementation, proof, and edge cases.

03.1

Approach 1 of 2

Build the Reverse and Compare Difference Lists (Baseline)

TimeO(n)SpaceO(n)

Open with this — it follows the definition literally and is easy to get right, then note the extra O(n) space.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

The definition mentions reverse(s) explicitly. What's the most direct way to follow it?

2Hint 2Explore hint

Physically reverse the string, then build two arrays of adjacent absolute differences — one for s, one for the reverse.

3Hint 3Explore hint

Compare the two difference arrays element by element; equal everywhere means 'Funny'.

A · Core idea

Follow the wording of the problem to the letter: form r = reverse(s), compute the adjacent absolute differences of both strings, and check the two lists are identical.

B · Visual dry run

Interactive dry run

Select a frame to connect the decision with its visual state.

s = "acxz"

reverse

r = "zxca"

Statehave both strings

Final resultFunny

C · Code with teaching comments

solution.javaJava

Build the Reverse and Compare Difference Lists (Baseline) — reference

3 teaching notes

1
public String funnyString(String s) {
2
    // Physically build the reverse — the O(n) allocation we'll later eliminate.
3
    String r = new StringBuilder(s).reverse().toString();
4
    int n = s.length();
5
    for (int i = 1; i < n; i++) {
6
        // char subtraction promotes to int; abs() discards direction.
7
        int ds = Math.abs(s.charAt(i) - s.charAt(i - 1));
8
        int dr = Math.abs(r.charAt(i) - r.charAt(i - 1));
9
        // Any mismatch between forward and reverse gaps disqualifies the string.
10
        if (ds != dr) {
11
            return "Not Funny";
12
        }
13
    }
14
    return "Funny";
15
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.15 lines

D · Why it works and complexityO(n) timeO(n) spaceOpen the invariant and proofExplore the proof

E · Edge cases and pitfalls3Comparing characters of s and r instead of their adjacent differences.Explore edge cases

Pitfalls

Comparing characters of s and r instead of their adjacent differences.
Dropping the absolute value, so signed gaps never match across the reverse.
Allocating the reversed string when an index mirror would do.

03.2

Approach 2 of 2 · Optimal

Mirror the Index — No Reverse Allocated (Optimal)

TimeO(n)SpaceO(1)

The polished answer. Phrase it as 'the reverse's gap at i is just s's gap read from the other end'.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

You built reverse(s) only to read its adjacent differences. Can you express the reverse's difference at position i purely in terms of s?

2Hint 2Explore hint

3Hint 3Explore hint

Loop i from 1 to n-1, compare |s[i] - s[i-1]| against |s[n-i] - s[n-i-1]|. No reversed string, no difference arrays — just two subtractions per step.

A · Core idea

B · Visual dry run

Interactive dry run

Select a frame to connect the decision with its visual state.

s = "bcxz"

Array state

i=1

fwd |c-a|=2 vs mirror |z-x|=2 → match

[0]

i ↓

[1]

[2]

n-i ↓

[3]

Current pointerResolved stateNot processed

Final resultNot Funny

C · Code with teaching comments

solution.javaJava

Mirror the Index — No Reverse Allocated (Optimal) — optimal

4 teaching notes

1
public String funnyString(String s) {
2
    int n = s.length();
3
    // i indexes forward gaps; for each, n-i indexes the mirrored gap from the far end.
4
    for (int i = 1; i < n; i++) {
5
        // Gap between this character and its left neighbour in the original direction.
6
        int forward = Math.abs(s.charAt(i) - s.charAt(i - 1));
7
        // The reverse's gap at step i, rewritten in terms of s — no reversed string
8
        // needed.
9
        int mirror = Math.abs(s.charAt(n - i) - s.charAt(n - i - 1));
10
        // A single disagreement breaks the palindrome-of-differences and ends the scan.
11
        if (forward != mirror) {
12
            return "Not Funny";
13
        }
14
    }
15
    return "Funny";
16
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.16 lines

D · Why it works and complexityO(n) timeO(1) spaceOpen the invariant and proofExplore the proof

E · Edge cases and pitfalls6s = "a" — n = 1, loop from 1 never runs → 'Funny' (no adjacent pairs to violate).Explore edge cases

Edge cases handled

s = "a"n = 1, loop from 1 never runs → 'Funny' (no adjacent pairs to violate).
s = "aa"One gap |a-a|=0 vs mirror |a-a|=0 → 'Funny'.
s = "ab"fwd |b-a|=1, mirror also |b-a|=1 (mirror reads s[1],s[0]) → 'Funny'; any 2-char string is funny.

Pitfalls

Off-by-one on the mirror: it's s[n-i] and s[n-i-1], not s[n-1-i] alone.
Forgetting abs(), so the sign flip from reading right-to-left breaks the match.
Subtracting characters without code-point semantics (fine in Java; use ord() in Python).

Practice

Try the solution yourself

Edit the optimal implementation, test another input, and observe the result.

Try it — Java· run a complete program; method snippets need a driver

Avoid mistakes

Recognize the interview traps

Understand why common attempts fail before reviewing the corrected implementation.

Comparing characters, not differences

'Funny' is about the GAPS between neighbours, not the letters. Comparing s[i] to r[i] tests whether the string is a palindrome — a different, stricter property.

Explore the code comparison

Don't write this

r = s[::-1]
for i in range(len(s)):
    if s[i] != r[i]:
        return "Not Funny"
return "Funny"

Write this instead

for i in range(1, len(s)):
    if abs(ord(s[i]) - ord(s[i-1])) != abs(ord(s[len(s)-i]) - ord(s[len(s)-i-1])):
        return "Not Funny"
return "Funny"

Dropping the absolute value

Reading neighbours from the reversed end flips the sign of every gap. Without abs() the forward gap +2 never equals the reverse gap −2, so almost no string is judged funny.

Explore the code comparison

Don't write this

int ds = s.charAt(i) - s.charAt(i - 1);
int dr = r.charAt(i) - r.charAt(i - 1);
if (ds != dr) return "Not Funny";

Write this instead

int ds = Math.abs(s.charAt(i) - s.charAt(i - 1));
int dr = Math.abs(r.charAt(i) - r.charAt(i - 1));
if (ds != dr) return "Not Funny";

Wrong mirror index

When skipping the explicit reverse, the reverse's gap at step i is |s[n-i] - s[n-i-1]|. Using s[n-1-i] for a single character (instead of the pair) silently compares the wrong neighbours.

Explore the code comparison

Don't write this

mirror = abs(ord(s[n - 1 - i]) - ord(s[i - 1]))

Write this instead

mirror = abs(ord(s[n - i]) - ord(s[n - i - 1]))

Revise

Carry the pattern into the interview

Quick interview revision

Pattern to remember

Adjacent-difference sequence + symmetry check

Code pattern to memorize

n = len(s)
for i in 1 .. n-1:
    if |s[i] - s[i-1]| != |s[n-i] - s[n-i-1]|:
        return "Not Funny"
return "Funny"

Rules to remember

1Compare absolute differences — |s[i] − s[i−1]|, never the signed value.
2You don't need to allocate reverse(s): the reversed difference at step i is |s[n−i] − s[n−i−1]|.
3Index the original characters by their ASCII / code-point value, not the character itself.
4Loop i from 1 to n−1; both the forward and mirrored differences are valid in that range.
5Any single mismatch ends it as 'Not Funny'; survive all positions and it's 'Funny'.

Use this pattern when

You must compare a string's adjacent-difference profile against its reverse
The property is defined on gaps between neighbours, not the characters themselves
You want to avoid building the reversed string and just mirror the index
A symmetry / palindrome-of-differences check is hidden inside the prompt

Choose another pattern when

The property uses the characters directly (not gaps) → compare characters, not differences
Signed direction matters → don't take absolute value
You must transform the string, not just answer yes/no → you may actually need the reverse
Differences are over non-adjacent pairs → it's no longer a simple neighbour scan

Interview takeaway

Continue

Transfer the pattern to another problem

Use a direct variation or pattern sibling to prove the idea is reusable.

Practice queueDirect variations and pattern siblings

Direct follow-ups

Valid Palindrome
Same mirror-index idea, but compare characters directly instead of their gaps.
Funny String with signed differences
Coming soon
Drop the absolute value and ask which strings survive — a good 'why abs?' discussion.
Longest Palindromic Substring
Coming soon
Palindrome detection scaled up — expand around centres instead of one full check.
Mars Exploration
Another adjacent-window string scan: count characters that deviate from the expected SOS pattern.

Same pattern

←

Subarray Division (Lily's Chocolate)

Continue · Next problem

Gemstones