How to build a function that searches for string occurrences?

Question

I need help Writing a function subLength() that takes 2 parameters, a string and a single character. The function should search the string for the two occurrences of the character and return the length between them including the 2 characters. If there are less than 2 or more than 2 occurrences of the character the function should return 0. How can I solve this problem using loops?

        subLength('Saturday', 'a'); // returns 6
        subLength('summer', 'm'); // returns 2
        subLength('digitize', 'i'); // returns 0
        subLength('cheesecake', 'k'); // returns 0

Answer 1

I just answered this problem in codeAcademy and this is the solution that I came up with, just using if-statements and string.indexOf

const subLength = (strng, char) => {
    let firstIndex = strng.indexOf(char); 
    let secondIndex = strng.indexOf(char, (firstIndex + 1));
    let thirdIndex = strng.indexOf(char, (secondIndex + 1)); 

    if (firstIndex === -1){
      return 0
    } else if (secondIndex === -1){
      return 0
    } else if (thirdIndex === -1 ){
      return (secondIndex - firstIndex + 1)
    } else {
      return 0
    };
};

Answer 2

It is better to try yourself a solution first. It is a very bad practice to just ask a solution for your homework!!! Even if the solution can be JUST a few lines of code i wrote for you with commments a working solution :

const subLength = (str,char) => {
// create an empty array
const strarr = [];
// push string into array
strarr.push(str);
//initiate a count variable
let count = 0;
// WRITE YOUR REGULAR EXPRESSION 
// Using the regular expression constructor - new RegExp("ab{2}", "g") .
const regString = `[${char}]`; 
const regex = new RegExp(regString, "g");
// iterate through the string array to 
for (let i = 0; i < strarr.length; i++) {

   // calculate how many time the character occurs
   count = (strarr[i].match(regex) || []).length;
  
  
 };

 // check with if condition 
 //if count is 2 
 if (count === 2) {
   
  // calculate the index of first ocurrance of the string
  first = str.indexOf(char);
  // calculate the index of second ocurrance of the string
  second = str.lastIndexOf(char);
  
  // calculate the distance between them
  return second - first + 1;

// if count is greater than two return 0
  }
 else if (count > 2)  {
   return count = 0;
 }
 // if count is less than two return 0
 else if (count < 2) {
   return 0;
 }
};



  
 console.log(subLength("iiiiliiile","l"));
 

Answer 3

I too am going through the Codecademy course where this question came up which led me to this post.

Using the RegExp solution provided by @Rajesh (thank you!!) I started to break it down to better understand what was going on and making notes/comments because I am still pretty new and haven't used or been exposed to some of these things.

At the end of it all I thought I'd share what I ended up with in case anyone found it helpful.

function subLength(str, char) {
  // Outputting to the console what we are looking for given the value of the string and character from the test cases at the end of this script.
  console.log(`Showing the subLength for the string: "${str}" between "${char}" and "${char}" including the "${char}" positions.`);
  // create the length variable which will be returned by the function
  let length = 0;
  // ** Search the string for the two occurrences of the character and count them. Then assign the result to the occurrenceCount variable for use in the if else statement.

  // The "Array" class is a global object that is used in the construction off arrays.

  // The Array.from() static method creates a new, shallow-copied Array instance from an array-like or iterable object.

  // The Array.filter() method creates a new array with all elements that pass the test implemented by the provided function. The "c" represents each element of the array/string which is then compared to the char variable. if it is a match it gets added to the Array. We use .toLowerCase on both to ensure case compatibility.

  // Appending the Array with ".length" assigns occurrenceCount the numeric value of the array's length rather than the array of characters.

  const occurrenceCount = Array.from(str).filter((c) => c.toLowerCase() === char.toLowerCase());
  console.log(' The contents of the occurrenceCountArray = ' + occurrenceCount);
  console.log(' The character occurrence count = ' + occurrenceCount.length);
  // if the string has two occurrences : return the length between them including the two characters : else the string has less than 2 or more than 2 characters : return 0.
  if (occurrenceCount.length === 2) {
    // The RegExp object is used for matching text with a pattern. The "(.*)" in between the ${char}'s will match and capture as much as possible aka greedy match. "()" = capture anything matched. (" = start of group. "." = match any character. "*" = Greedy match that matches everything in place of the "*". ")" = end of group.
    const regex = new RegExp(`${char}(.*)${char}`);
    // log to console the pattern being matched
    console.log(`   regex pattern to find = ${regex}`);
    // log to the console the [0] = index 0 pattern that was captured from the string using str.match(regex)[0]
    console.log(`   regex output = ${str.match(regex)[0]}`);

    // Use".length" to count the number of characters in the regex string at index 0 of the regex array and assign that value to the length variable.
    length = str.match(regex)[0].length;

    // Output the results to the console
    console.log(`   The distance from "${char}" to "${char}" (including the "${char}" positions) in the string: ${str} = ${length}\n`);

    // return the length value
    return length;
  } else {
    // Output the results to the console
    console.log(`   The string either has too many or too few occurrences.\n    The subLength = ${length}\n`);
    // return the length value
    return length;
  }
}

// test cases
subLength('Saturday', 'a'); // returns 6
subLength('summer', 'm'); // returns 2
subLength('digitize', 'i'); // returns 0
subLength('cheesecake', 'k'); // returns 0

Answer 4

The answer I am getting is this:

const subLength = (str, char) => {
  let charCount = 0;
  let len = -1;
  
  for (let i=0; i<str.length; i++) {
    if (str[i] == char) {
      charCount++;
      if (charCount > 2) {
        return 0;
      }
      if (len == -1) {
        len = i;
      } else {
        len = i - len + 1
      }
    }
  }
  if (charCount < 2) {
    return 0;
  }

  return len;
};

Answer 5

Here I loop through the characters of the string to find each value that is the char.

• if the length isn't 2, return 0.
• using slice, get only the characters within the two found indexs and get that length adding one to fix the offset

const subLength = (str, char) => {
    let strChars = str.toLowerCase().split(""),
        found = [],
        length = 0;
    
    strChars.forEach((val, index) => {
        if (val === char) {
            found.push(index);
        }
    });

    if (found.length != 2) {
        return length;
    }

   return str.slice(found[0], found[1]).length + 1;
}

console.log(subLength('Saturday', 'a')); // returns 6
console.log(subLength('summer', 'm')); // returns 2
console.log(subLength('digitize', 'i')); // returns 0
console.log(subLength('cheesecake', 'k')); // returns 0

Answer 6

You can try this logic:

• Loop over string and count number of occurance
• if count is 2,
  • Create a regex to capture the string in between.
  • Return its length
• Else return 0

function subLength(str, char) {
  let length = 0;
  const occuranceCount = Array
    .from(str)
    .filter((c) => c.toLowerCase() === char.toLowerCase())
    .length
  if (occuranceCount === 2) {
    const regex = new RegExp(`${char}(.*)${char}`)
    length = str.match(regex)[0].length
  }
  console.log(length)
  return length;
}

subLength('Saturday', 'a'); // returns 6
subLength('summer', 'm'); // returns 2
subLength('digitize', 'i'); // returns 0
subLength('cheesecake', 'k'); // returns 0

Using just for loop:

function subLength(str, char) {
  let count = 0;
  let initPosition;
  let lastPosition;
  for (let i = 0; i < str.length; i++) {
    if (str[i] === char) {
      count++
      if (count > 2) {
        return 0;
      }
      if (initPosition === undefined) {
        initPosition = i
      } else {
        lastPosition = i+1
      }
    }
  }
  return count < 2 ? 0 : lastPosition - initPosition;
}

console.log(subLength('Saturday', 'a')); // returns 6
console.log(subLength('summer', 'm')); // returns 2
console.log(subLength('digitize', 'i')); // returns 0
console.log(subLength('cheesecake', 'k')); // returns 0