JavaScript字谜比较

我试着比较两个字符串，看看它们是否是字谜

我的问题是，我只是比较每个字符串中的第一个字母。例如，“玛丽”和“军队”将返回真值，但不幸的是，“玛丽”和“武器”也将返回真值

在返回真/假之前，如何比较两个字符串的每个字母

这是一个jsbin演示（单击“控制台”选项卡查看结果）：

功能比较（a、b）{
y=a.split（“”.sort（）；
z=b.split（“”.sort（）；
对于（i=0；i而不是逐个字母进行比较，排序后，您可以
再次将数组连接到字符串，并让浏览器进行比较：

function compare (a, b) {
    var y = a.split("").sort().join(""),
        z = b.split("").sort().join("");
    console.log(z === y
        ? a + " and " + b + " are anagrams!"
        : a + " and " + b + " are not anagrams."
    );
}

排序后，您可以
将数组再次连接到字符串，并让浏览器进行比较，而不是逐个字母进行比较：

function compare (a, b) {
    var y = a.split("").sort().join(""),
        z = b.split("").sort().join("");
    console.log(z === y
        ? a + " and " + b + " are anagrams!"
        : a + " and " + b + " are not anagrams."
    );
}

我修改了你的函数使之工作

它将遍历这两个单词的每个字母，直到一个字母不匹配（然后它知道它们不是字谜）

它只适用于字母数相同的单词，并且是完美的字谜

function compare (a, b) {
  y = a.split("").sort();
  z = b.split("").sort();
  areAnagrams = true;
  for (i=0; i<y.length && areAnagrams; i++) {
    console.log(i);
    if(y.length===z.length) {
      if (y[i]===z[i]){
        // good for now
        console.log('up to now it matches');
      } else {
        // a letter differs
        console.log('a letter differs');
        areAnagrams = false;
      }
    }
    else {
      console.log(a + " has a different amount of letters than " + b);
      areAnagrams = false;
    }

  }
  if (areAnagrams) {
    console.log('They ARE anagrams');
  } else {
    console.log('They are NOT anagrams');
  }
    return areAnagrams;
}

compare("mary", "arms");

功能比较（a、b）{
y=a.split（“”.sort（）；
z=b.split（“”.sort（）；
areAnagrams=真；
对于（i=0；i我修改了你的函数使其工作

它将遍历这两个单词的每个字母，直到一个字母不匹配（然后它知道它们不是字谜）

它只适用于字母数相同的单词，并且是完美的字谜

function compare (a, b) {
  y = a.split("").sort();
  z = b.split("").sort();
  areAnagrams = true;
  for (i=0; i<y.length && areAnagrams; i++) {
    console.log(i);
    if(y.length===z.length) {
      if (y[i]===z[i]){
        // good for now
        console.log('up to now it matches');
      } else {
        // a letter differs
        console.log('a letter differs');
        areAnagrams = false;
      }
    }
    else {
      console.log(a + " has a different amount of letters than " + b);
      areAnagrams = false;
    }

  }
  if (areAnagrams) {
    console.log('They ARE anagrams');
  } else {
    console.log('They are NOT anagrams');
  }
    return areAnagrams;
}

compare("mary", "arms");

功能比较（a、b）{
y=a.split（“”.sort（）；
z=b.split（“”.sort（）；
areAnagrams=真；
对于（i=0；i
函数比较（a，b）{
y=a.split（“”.sort（）；
z=b.split（“”.sort（）；
如果（y.length==z.length）{
对于（i=0；i
函数比较（a，b）{
y=a.split（“”.sort（）；
z=b.split（“”.sort（）；
如果（y.length==z.length）{
for（i=0；i首先，您可以在for循环之前进行长度检查，无需对每个字符进行检查

此外，“break”会中断整个for循环。如果使用“continue”而不是“break”，则会跳过当前步骤。
这就是为什么只比较第一个字母，在第一个字母之后它退出for循环

我希望这对您有所帮助。
首先，您可以在for循环之前进行长度检查，无需对每个字符进行检查

此外，“break”会中断整个for循环。如果使用“continue”而不是“break”，则会跳过当前步骤。
这就是为什么只比较第一个字母，在第一个字母之后它退出for循环

我希望这对您有所帮助。
这考虑了大小写敏感性，删除了空格，并忽略了所有非字母数字字符


功能比较（a、b）{
var c=a.replace（/\W+/g'）.toLowerCase（）.split（“”）.sort（）.join（“”）；
var d=b.replace（/\W+/g'）.toLowerCase（）.split（“”）.sort（）.join（“”）；
返回（c==d）？“字谜”：“非字谜”；
}
这会考虑大小写敏感度，删除空格并忽略所有非字母数字字符


功能比较（a、b）{
var c=a.replace（/\W+/g'）.toLowerCase（）.split（“”）.sort（）.join（“”）；
var d=b.replace（/\W+/g'）.toLowerCase（）.split（“”）.sort（）.join（“”）；
返回（c==d）？“字谜”：“非字谜”；
}
如果单词之间的长度不同，并且如果在单词之间发现不匹配的字符，则使函数返回false

// check if two strings are anagrams
var areAnagrams = function(a, b) {
    // if length is not the same the words can't be anagrams
    if (a.length != b.length) return false;
    // make words comparable
    a = a.split("").sort().join("");
    b = b.split("").sort().join("");
    // check if each character match before proceeding
    for (var i = 0; i < a.length; i++) {
        if ((a.charAt(i)) != (b.charAt(i))) {
            return false;
        }
    }
    // all characters match!
    return true;
};

//检查两个字符串是否为字谜
var areAnagrams=功能（a、b）{
//如果长度不一样，这些词就不能是字谜
如果（a.length！=b.length）返回false；
//使词语具有可比性
a=a.split（“”）.sort（）.join（“”）；
b=b.split（“”）.sort（）.join（“”）；
//继续之前，请检查每个字符是否匹配
对于（变量i=0；i

它在遍历大字典数组时特别有效，因为它先比较每个“正常化”单词的第一个字母，然后再比较第二个字母，依此类推。如果一个字母不匹配，它会跳到下一个单词，节省大量时间

在一个有1140个单词（并非所有的字谜）的字典中，整个检查比使用当前接受答案中的方法快70%。
如果单词之间的长度不同，并且如果发现单词之间的字符不匹配，则使函数返回false

// check if two strings are anagrams
var areAnagrams = function(a, b) {
    // if length is not the same the words can't be anagrams
    if (a.length != b.length) return false;
    // make words comparable
    a = a.split("").sort().join("");
    b = b.split("").sort().join("");
    // check if each character match before proceeding
    for (var i = 0; i < a.length; i++) {
        if ((a.charAt(i)) != (b.charAt(i))) {
            return false;
        }
    }
    // all characters match!
    return true;
};

//检查两个字符串是否为字谜
var areAnagrams=功能（a、b）{
//如果长度不一样，这些词就不能是字谜
如果（a.length！=b.length）返回false；
//使词语具有可比性
a=a.split（“”）.sort（）.join（“”）；
b=b.split（“”）.sort（）.join（“”）；
//继续之前，请检查每个字符是否匹配
对于（变量i=0；i

它在遍历大字典数组时特别有效，因为它先比较每个“正常化”单词的第一个字母，然后再比较第二个字母，依此类推。如果一个字母不匹配，它会跳到下一个单词，节省大量时间

在一个有1140个单词（不是所有的字谜）的字典中，整个检查比使用当前接受答案中的方法快70%。
如果您想编写一个函数，而不使用内置函数，请检查以下解决方案

function isAnagram(str1, str2) {

  if(str1 === str2) {
    return true;
  }

  let srt1Length = str1.length;
  let srt2Length = str2.length;

  if(srt1Length !== srt2Length) {
    return false;
  }

  var counts = {};

  for(let i = 0; i < srt1Length; i++) {
    let index = str1.charCodeAt(i)-97;
    counts[index] = (counts[index] || 0) + 1;
  }

  for(let j = 0; j < srt2Length; j++) {
    let index = str2.charCodeAt(j)-97;
    if (!counts[index]) { 
      return false; 
    }
    counts[index]--;
  }

  return true;
}

函数isAnagram（str1、str2）{
如果（str1==str2）{
返回true；
}
设srt1Length=str1.length；
设srt2Length=str2.length；
if（srt1Length！==srt2Length）{
返回false；
}
变量计数={}；
for（设i=0；ifunction(s, t) {
 if(s === t) return true
 if(s.length !== t.length) return false

 let count = {}

 for(let letter of s)
  count[letter] = (count[letter] || 0) + 1

 for(let letter of t) { 
  if(!count[letter]) return false
  else --count[letter]
 }

 return true;
}

            const stripChar = (str) => 
            {
               return str.replace(/[\W]/g,'').toLowerCase();
            }
            const charMap = str => {
                 let MAP = {};
                 for (let char of stripChar(str)) {
                     !MAP[char] ? (MAP[char] = 1) : MAP[char]++;
                 }
              return MAP;
            };

      const anagram = (str1, str2) => {
 if(Object.keys(charMap(str1)).length!==Object.keys(charMap(str2)).length) return false;
          for(let char in charMap(str1))
          {
            if(charMap(str1)[char]!==charMap(str2)[char]) return false;
          }
          return true;
        };

    console.log(anagram("rail safety","!f%airy tales"));

function validAnagramOrNot(a, b) {
      if (a.length !== b.length)
      return false;
      const lookup = {};
      for (let i = 0; i < a.length; i++) {
          let character = a[i];
          lookup[character] = (lookup[character] || 0) + 1;
      }
      for (let i = 0; i < b.length; i++) {
          let character = b[i];
          if (!lookup[character]) {
            return false;
          } else {
             lookup[character]--;
          }
       }
  return true;
}
 validAnagramOrNot("a", "b"); // false
 validAnagramOrNot("aza", "zaa"); //true

function checkAnagrams(str1, str2){

  var newstr1 = str1.toLowerCase().split('').sort().join();
  var newstr2 = str2.toLowerCase().split('').sort().join();

  if(newstr1 == newstr2){
    console.log("String is Anagrams");
  }
  else{
    console.log("String is Not Anagrams");
  }

}

checkAnagrams("Hello", "lolHe");
checkAnagrams("Indian", "nIndisn");

 //The best code so far that checks, white space, non alphabets 
 //characters 
 //without sorting   
function anagram(stringOne,stringTwo){
var newStringOne = ""
var newStringTwo = ''
for(var i=0; i<stringTwo.length; i++){
 if(stringTwo[i]!= ' ' && isNaN(stringTwo[i]) == true){
    newStringTwo =  newStringTwo+stringTwo[i]
 }
    }

for(var i=0; i<stringOne.length; i++){
    if(newStringTwo.toLowerCase().includes(stringOne[i].toLowerCase())){
    newStringOne=newStringOne+stringOne[i].toLowerCase()
    }
}
console.log(newStringOne.length, newStringTwo.length)
if(newStringOne.length==newStringTwo.length){
    console.log("Anagram is === to   TRUE")
}
else{console.log("Anagram is === to   FALSE")}
}
anagram('ddffTTh@@@#$', '@dfT9t@D@#H$F')

function anagrams(str1,str2){

      //spliting string into array   
      let arr1 = str1.split("");
      let arr2 = str2.split("");

      //verifying array lengths
      if(arr1.length !== arr2.length){
          return false;
      }     

      //creating objects
      let frqcounter1={};
      let frqcounter2 ={};

    //   looping through array elements and keeping count
      for(let val of arr1){
         frqcounter1[val] =(frqcounter1[val] || 0) + 1; 
      }
      for(let val of arr2){
         frqcounter2[val] =(frqcounter2[val] || 0) + 1; 
      }

      console.log(frqcounter1);
      console.log(frqcounter2);

      //loop for every key in first object
      for(let key in frqcounter1){
          //if second object does not contain same frq count
          if(frqcounter2[key] !== frqcounter1[key]){
            return false;
          }
      }
      return true;

    }

    anagrams('anagrams','nagramas');

//using char array for fast lookups
const Anagrams1 = (str1 = '', str2 = '') => {
    if (str1.length !== str2.length) {
        return false;
    }
    
    if (str1 === str2) {
        return true;
    }

    const charCount = [];
    let startIndex = str1.charCodeAt(0);

    for (let i = 0; i < str1.length; i++) {
        const charInt1 = str1.charCodeAt(i);
        const charInt2 = str2.charCodeAt(i); 

        startIndex = Math.min(charInt1, charInt2);
        
        charCount[charInt1] = (charCount[charInt1] || 0) + 1;           
        charCount[charInt2] = (charCount[charInt2] || 0) - 1;           
    }

    while (charCount.length >= startIndex) { 
        if (charCount.pop()) {
            return false;
        }
    }

    return true;
}

console.log(Anagrams1('afc','acf'))//true
console.log(Anagrams1('baaa','bbaa'))//false
console.log(Anagrams1('banana','bananas'))//false
console.log(Anagrams1('',' '))//false
console.log(Anagrams1(9,'hey'))//false

//using {} for fast lookups
function Anagrams(str1 = '', str2 = '') {
  if (str1.length !== str2.length) {
    return false;
  }

  if (str1 === str2) {
    return true;
  }

  const lookup = {};
  let len = str1.length;

  for (let i = 0; i < len; i++) {
    const char1 = str1[i];
    const char2 = str2[i];
    const remainingChars = len - (i + 1);
    
    lookup[char1] = (lookup[char1] || 0) + 1;
    lookup[char2] = (lookup[char2] || 0) - 1;

    if (lookup[char1] > remainingChars || lookup[char2] > remainingChars) {
      return false;
    }
  }

  for (let i = 0; i < str1.length; i++) {
    if (lookup[str1[i]] !== 0 || lookup[str2[i]] !== 0) {
      return false;
    }
  }

  return true;
}

console.log(Anagrams('abc', 'cba'));//true
console.log(Anagrams('abcc', 'cbaa')); //false
console.log(Anagrams('abc', 'cde')); //false
console.log(Anagrams('aaaaaaaabbbbbb','bbbbbbbbbaaaaa'));//false
console.log(Anagrams('banana', 'ananab'));//true

function isAnagram(string1, string2) {
    // first check: if the lenghts are different, not an anagram 
    if (string1.length != string2.length)
        return false
    else {
    // it doesn't matter if the letters are capitalized, 
    // so the toLowerCase method ensures that...
        string1 = string1.toLowerCase()
        string2 = string2.toLowerCase()
        
    // for each letter in the string (I could've used for each :P)
        for (let i = 0; i < string1.length; i++) {
            // check, for each char in string2, if they are NOT somewhere at string1
            if (!string1.includes(string2.charAt(i))) {
                return false
            }
            else {
                // if all the chars are covered 
                // and the condition is the opposite of the previous if
                if (i == (string1.length - 1))
                    return true
            }
        }
    }
}