Is there a way to verify if a word is constructed using characters from separate arrays?

Question

Is there a way to verify if a word is constructed using characters from separate arrays?

I am currently developing a word game using Vue.

The concept is simple - the player receives a random string of characters and has to input a word that can be formed from those characters. For example, given "ABEOHSTD", the user could enter "BASE" for a score of 4.

One of the challenges I'm facing is verifying the entered words against an external word list stored in a .txt file (which is another issue I need to address separately). Specifically, I'm struggling with confirming whether the words can actually be created using the provided random string of characters.

I'm unsure how to approach ensuring that each letter can only be used as many times as it appears in the original array, or even how to store and calculate the scores. Right now, my main focus is on getting this initial functionality working correctly.

My current approach involves splitting both the entered word and the random string into arrays of individual characters, then looping through them to check if each character in the entered word is included in the random string array.


splitUserCurrentWord = this.userAttemptedWord.split("");
for (var i = 0; i <= splitUserCurrentWord.length; i++) {
    if (this.randomStringForGame.split("").includes(splitUserCurrentWord[i])) {
        return true;
    } else {
        return false;
    }
}

As it stands, I expect the function to return true only if all the letters in the user inputted word are present in the random string array. However, it seems to only consider the first letter of the array, which is problematic because as long as the first letter matches, it registers as correct regardless of subsequent letters.

You can view the current state of the project on jsfiddle: https://jsfiddle.net/sk4f9d8w/

javascript arrays vue.js

Answer 1

Answer №1

Your return statement is causing the loop to exit after the first iteration.

An alternative approach is to utilize Array.every to validate all letters and String.includes to confirm if the letter belongs to the specified string

const randomString = "ABEOHSTD";

console.log(isWordValid(randomString, "BASE"));
console.log(isWordValid(randomString, "BASEU"));

function isWordValid(validLetters, attemptedWord) {
  const attemptedWordSplitted = attemptedWord.split("");
  return attemptedWordSplitted.every(attemptedLetter => validLetters.includes(attemptedLetter));
}

If you do not allow the same letter to be used multiple times, an alternate method involves removing the utilized letter from the list of approved letters

const randomString = "ABEOHSTD";

console.log(isWordValid(randomString, "BASE"));
console.log(isWordValid(randomString, "BAASE"));
console.log(isWordValid(randomString, "BASEU"));

function isWordValid(validLetters, attemptedWord) {
  const validLettersSplitted = validLetters.split("");
  const attemptedWordSplitted = attemptedWord.split("");
  return attemptedWordSplitted.every(attemptedLetter => {
    const letterIndex = validLettersSplitted.indexOf(attemptedLetter);
    if(letterIndex > -1){
      validLettersSplitted.splice(letterIndex, 1);
      return true;
    } else {
      return false
    }
  });
}

Answer 2

Your return statement is causing the loop to exit after the first iteration.

An alternative approach is to utilize Array.every to validate all letters and String.includes to confirm if the letter belongs to the specified string

const randomString = "ABEOHSTD";

console.log(isWordValid(randomString, "BASE"));
console.log(isWordValid(randomString, "BASEU"));

function isWordValid(validLetters, attemptedWord) {
  const attemptedWordSplitted = attemptedWord.split("");
  return attemptedWordSplitted.every(attemptedLetter => validLetters.includes(attemptedLetter));
}

If you do not allow the same letter to be used multiple times, an alternate method involves removing the utilized letter from the list of approved letters

const randomString = "ABEOHSTD";

console.log(isWordValid(randomString, "BASE"));
console.log(isWordValid(randomString, "BAASE"));
console.log(isWordValid(randomString, "BASEU"));

function isWordValid(validLetters, attemptedWord) {
  const validLettersSplitted = validLetters.split("");
  const attemptedWordSplitted = attemptedWord.split("");
  return attemptedWordSplitted.every(attemptedLetter => {
    const letterIndex = validLettersSplitted.indexOf(attemptedLetter);
    if(letterIndex > -1){
      validLettersSplitted.splice(letterIndex, 1);
      return true;
    } else {
      return false
    }
  });
}

Answer 3

Answer №2

You're headed in the right direction! It's important to carefully examine each letter in the user word and compare it to the letters in the random word. If a letter matches, remove it from the random word to prevent it from being used again.

let randomWord = "ABEOHSTD";
let userWordThatFail = "BAASE";
let userWord = "BASE";

// Optional: convert both words to uppercase.

// Splitting the words into individual letters for easier processing
let randomLetters = randomWord.split('');
let userLetters = userWord.split('');

let score = 0;

// Iterating through each letter in the user input
userLetters.forEach((letter) => {
  // Check if the letter exists in the random word.
  let indexOfTheCurrentLetter = randomLetters.indexOf(letter);
  // If the letter exists, remove it and increase the score.
  if(indexOfTheCurrentLetter !== -1) {
    randomLetters.splice(indexOfTheCurrentLetter, 1);
    score++;
  }
});

// If the user input contains letters not present in the random word
if(score < userLetters.length) {
  console.log('fail');
} else {
  console.log('win : ' + score);
}

Answer 4

You're headed in the right direction! It's important to carefully examine each letter in the user word and compare it to the letters in the random word. If a letter matches, remove it from the random word to prevent it from being used again.

let randomWord = "ABEOHSTD";
let userWordThatFail = "BAASE";
let userWord = "BASE";

// Optional: convert both words to uppercase.

// Splitting the words into individual letters for easier processing
let randomLetters = randomWord.split('');
let userLetters = userWord.split('');

let score = 0;

// Iterating through each letter in the user input
userLetters.forEach((letter) => {
  // Check if the letter exists in the random word.
  let indexOfTheCurrentLetter = randomLetters.indexOf(letter);
  // If the letter exists, remove it and increase the score.
  if(indexOfTheCurrentLetter !== -1) {
    randomLetters.splice(indexOfTheCurrentLetter, 1);
    score++;
  }
});

// If the user input contains letters not present in the random word
if(score < userLetters.length) {
  console.log('fail');
} else {
  console.log('win : ' + score);
}

Answer 5

Answer №3

One way to efficiently check for valid characters in a string is by utilizing the Set object in JavaScript.

By creating a reusable function that utilizes the power of Set, we can achieve a linear time-complexity of O(n) where n is the length of the string being tested:

function testFor(validChars) {
  const charSet = new Set(validChars);
  return testString =>
    Array.prototype.every.call(testString, c => charSet.has(c));
}

// Example usage:

const testForABC = testFor("ABC"); //returns a function

console.log(testForABC("AABBCC")); //true
console.log(testForABC("abc")); //false

This approach leverages the constant lookup time of Set, making it a much more efficient solution compared to iterating through characters in a list for each comparison.

Answer 6

One way to efficiently check for valid characters in a string is by utilizing the Set object in JavaScript.

By creating a reusable function that utilizes the power of Set, we can achieve a linear time-complexity of O(n) where n is the length of the string being tested:

function testFor(validChars) {
  const charSet = new Set(validChars);
  return testString =>
    Array.prototype.every.call(testString, c => charSet.has(c));
}

// Example usage:

const testForABC = testFor("ABC"); //returns a function

console.log(testForABC("AABBCC")); //true
console.log(testForABC("abc")); //false

This approach leverages the constant lookup time of Set, making it a much more efficient solution compared to iterating through characters in a list for each comparison.

Is there a way to verify if a word is constructed using characters from separate arrays?

Answer №1

Answer №2

Answer №3

Similar questions

Mastering the Art of Modifying HTML with Node.js

Tips for building a responsive website with JavaScript and media queries:

What is the best method to retrieve an Element using both its ID and value?

Trouble viewing Geojson map on website

Although XPath works in Chrome, it is not compatible with Selenium

How to transform a byte array into a String in Java

How can JavaScript be used to make an AJAX request to a server-side function?

In the world of Knockout JS, forget about using e.stopPropagation() because it won't

Vue's beforeEnter does not function as expected when defined for child routes within routes

A JavaScript popup displaying selectable options and a callback function

Why does mapping only give me the last item when I try to map onto an object?

The Chrome extension does not function properly within Gmail

Having trouble extracting values from this JSON array - need help parsing it

Is it possible for Angular to either remove my object from the scope or combine it with my provider during execution?

Encounter a scope.router.go error when using Vue.js with System.js

Tips for extracting information from a JSON file using $routeParams in AngularJS

When trying to implement a dark/light theme, CSS variables may not function properly on the body tag

In order to effectively manage the output of these loaders, it may be necessary to incorporate an extra loader. This can be achieved by using the

resetting form with submission action

Using Javascript to determine the frequency of a JSON array with ESLINT version 6