First Non Repeating Character Using Hash in DSA Javascript - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create an empty object to store character counts.

DSA Javascript

const charCount = [1];

Drag options to blanks, or click blank then click option'

A[]

B{}

Cnull

D''

Attempts:

3 left

💡 Hint

Common Mistakes

Using [] creates an array, not an object.

Using null or empty string does not create a usable object.

We use an empty object {} to store counts of characters as keys.

2fill in blank

medium

Complete the code to loop through each character in the string 's'.

DSA Javascript

for (const [1] of s) {
  // count characters
}

Drag options to blanks, or click blank then click option'

Aelement

Bindex

Ci

Dchar

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'index' or 'i' works but is less clear here.

Using 'element' is vague; 'char' is clearer.

We use 'char' as the variable name to represent each character in the string.

3fill in blank

hard

Fix the error in updating the count of each character in the object.

DSA Javascript

charCount[char] = (charCount[char] [1] 0) + 1;

Drag options to blanks, or click blank then click option'

A||

B+

C-

D&&

Attempts:

3 left

💡 Hint

Common Mistakes

Using '+' alone causes NaN if charCount[char] is undefined.

Using '-' or '&&' does not provide a default value.

We use '||' to default to 0 if charCount[char] is undefined, then add 1.

4fill in blank

hard

Fill both blanks to check if a character count is exactly 1 and return its index.

DSA Javascript

for (let i = 0; i < s.length; i++) {
  if (charCount[s[i]] [1] 1) {
    return [2];
  }
}

Drag options to blanks, or click blank then click option'

A===

B!==

Ci

Ds[i]

Attempts:

3 left

💡 Hint

Common Mistakes

Using '!==' checks for not equal, which is wrong here.

Returning the character instead of index does not match problem requirements.

We check if count equals 1 using '===' and return the index 'i'.

5fill in blank

hard

Fill all three blanks to complete the function that returns the first non-repeating character's index or -1 if none.

DSA Javascript

function firstUniqChar(s) {
  const charCount = [1];
  for (const char of s) {
    charCount[char] = (charCount[char] [2] 0) + 1;
  }
  for (let i = 0; i < s.length; i++) {
    if (charCount[s[i]] === 1) {
      return [3];
    }
  }
  return -1;
}

Drag options to blanks, or click blank then click option'

A{}

B||

Ci

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using [] instead of {} for charCount.

Using '+' instead of '||' causing NaN errors.

Returning the character instead of index.

We create an empty object {}, use '||' to default counts, and return index i.

Practice

1. What is the main purpose of using a hash (object) in finding the first non repeating character in a string?

easy

A. To reverse the string

B. To sort the characters alphabetically

C. To remove duplicate characters from the string

D. To count the frequency of each character in the string

Solution

1. Step 1: Understand the role of hash in frequency counting

   A hash (object) stores each character as a key and counts how many times it appears in the string.

2. Step 2: Use frequency to find first non repeating character

   By checking the hash, we find the first character with count 1, which is the first non repeating character.

3. Final Answer:

   To count the frequency of each character in the string -> Option D

4. Quick Check:

   Hash counts characters = Frequency count [OK]

Hint: Use hash to count characters, then find first with count 1 [OK]

Common Mistakes:

• Trying to sort characters instead of counting
• Ignoring character frequency
• Using hash to reverse string

2. Which of the following is the correct syntax to initialize an empty hash (object) in JavaScript for counting characters?

easy

A. let hash = [];

B. let hash = {};

C. let hash = ();

D. let hash = '';

Solution

1. Step 1: Identify JavaScript object syntax

   In JavaScript, curly braces {} create an empty object, which is used as a hash for key-value pairs.

2. Step 2: Confirm correct initialization

   Using let hash = {}; correctly initializes an empty object for counting characters.

3. Final Answer:

   let hash = {}; -> Option B

4. Quick Check:

   Empty object = {} [OK]

Hint: Use {} to create empty object for hash in JavaScript [OK]

Common Mistakes:

• Using [] which creates an array, not an object
• Using () which is invalid syntax
• Using empty string '' which is not an object

3. What will be the output of the following code?

function firstNonRepeatingChar(str) {
  const hash = {};
  for (const ch of str) {
    hash[ch] = (hash[ch] || 0) + 1;
  }
  for (const ch of str) {
    if (hash[ch] === 1) return ch;
  }
  return '_';
}

console.log(firstNonRepeatingChar('swiss'));

medium

A. 'w'

B. 's'

C. 'i'

D. '_'

Solution

1. Step 1: Count character frequencies in 'swiss'

   Characters: s(3), w(1), i(1). Hash = {s:3, w:1, i:1}

2. Step 2: Find first character with count 1 in original order

   Order: s, w, i, s, s. First with count 1 is 'w'.

3. Final Answer:

   'w' -> Option A

4. Quick Check:

   First unique char in 'swiss' = 'w' [OK]

Hint: Check counts, then scan string for first count 1 char [OK]

Common Mistakes:

• Returning 's' which repeats
• Returning 'i' which is second unique
• Returning '_' which means no unique char

4. Identify the error in the following code snippet that tries to find the first non repeating character:

function firstNonRepeatingChar(str) {
  const hash = {};
  for (let i = 0; i <= str.length; i++) {
    const ch = str[i];
    hash[ch] = (hash[ch] || 0) + 1;
  }
  for (let i = 0; i < str.length; i++) {
    if (hash[str[i]] === 1) return str[i];
  }
  return '_';
}

medium

A. The hash is not initialized correctly

B. The second loop should use <= instead of <

C. The first loop uses <= instead of < causing undefined access

D. The return '_' is unreachable code

Solution

1. Step 1: Check loop conditions for index errors

   The first loop uses i <= str.length, which accesses str[str.length] (undefined), causing an error.

2. Step 2: Correct loop condition to i < str.length

   Changing to i < str.length prevents out-of-bounds access and correctly counts characters.

3. Final Answer:

   The first loop uses <= instead of < causing undefined access -> Option C

4. Quick Check:

   Loop index must be less than length [OK]

Hint: Use < not <= for string index loops to avoid undefined [OK]

Common Mistakes:

• Using <= causes out-of-range errors
• Ignoring loop boundary conditions
• Misunderstanding hash initialization

5. Given the string 'aabbccddeeffg', which modification to the code below will correctly return the first non repeating character?

function firstNonRepeatingChar(str) {
  const hash = {};
  for (const ch of str) {
    hash[ch] = (hash[ch] || 0) + 1;
  }
  for (const ch of str) {
    if (hash[ch] === 1) return ch;
  }
  return '_';
}

Options:
A) Change return '_' to return null
B) Add a check to ignore spaces in the string
C) Modify the function to return '_' if no unique character exists
D) Change the hash to store boolean instead of counts

hard

A. Change return '_' to return null

B. Add a check to ignore spaces in the string

C. Modify the function to return '_' if no unique character exists

D. Change the hash to store boolean instead of counts

Solution

1. Step 1: Analyze the string and current function behavior

   String 'aabbccddeeffg' has all characters repeated except 'g' which appears once.

2. Step 2: Confirm function returns '_' if no unique char

   The function already returns '_' if no unique character is found, which is correct behavior.

3. Step 3: Understand why changing return '_' to return null is better

   Changing return '_' to return null clearly indicates no unique character found, which is a better practice than returning a character that might be confused as valid.

4. Final Answer:

   Change return '_' to return null -> Option A

5. Quick Check:

   Return null when no unique char found is clearer [OK]

Hint: Return null to indicate no unique character found [OK]

Common Mistakes:

• Returning '_' which can be confused as a valid character
• Ignoring spaces when not needed
• Using boolean instead of counts loses frequency info