Question

例如，我试图忽略所有其他字谜而在数组中找到第一个唯一字符串：

let words = ['nap'，'teachers'，'cheaters'，'pan'，'ear'，'era'，'hectares]]

输出=小睡老师的耳朵

或让单词= ['rat'，'tar'，'art'];

输出老鼠

我被困在这里

let set = new Set();
let words = let words = ['nap', 'teachers', 'cheaters', 'pan', 'ear', 'era', 'hectares']


let map = new Map();
for (let word of words) {
    let sorted = word.toLowerCase().split('').sort().join(''); 
    map.set(sorted, word);
    set.add(sorted)
}
let arr = Array.from(set)


for (let inx = 0; inx < words.length; inx++) {
    arr.push('0')
}
console.log(arr);
console.log(words);

function isAnagram(s1, s2){
    return s1.split("").sort().join("") === s2.split("").sort().join("");
  }

let result = [];

  for (let i = 0; i < words.length; i++) {
       if ()
       result.push(words[i])

}
console.log(result);

Answer 1

您可以创建存储所有选项的Map映射，而不是仅存储最后一个字谜选项的string: string中的string: [ string ]。

然后，最后，您可以遍历所有这些条目并返回每个数组的第一个元素：

let set = new Set();
let words = ['nap', 'teachers', 'cheaters', 'pan', 'ear', 'era', 'hectares']


let map = new Map();

for (let word of words) {
    let sorted = word.toLowerCase().split('').sort().join('');
    if (!map.has(sorted)) map.set(sorted, []);
    set.add(sorted);
    
    map.get(sorted).push(word);
}

let arr = Array
  .from(set)
  .map(k => map.get(k)[0])
  

console.log(arr);

Answer 2

您需要检查数组“ words”的当前位置，然后检查其他位置，这意味着您需要在一个循环中有一个循环，因此您的代码应如下所示：

let set = new Set();
let words = ['nap', 'teachers', 'cheaters', 'pan', 'ear', 'era', 'hectares']


let map = new Map();
for (let word of words) {
    let sorted = word.toLowerCase().split('').sort().join(''); 
    map.set(sorted, word);
    set.add(sorted)
}
let arr = Array.from(set)


for (let inx = 0; inx < words.length; inx++) {
    arr.push('0')
}
console.log(arr);
console.log(words);

function isAnagram(s1, s2){
	console.log("checking: " + s1 + " and " + s2);
    return s1.split("").sort().join("") === s2.split("").sort().join("");
  }

let result = [];
let anagram = false;
  for (let i = 0; i < words.length; i++) {
	for(let j=i+1; j<words.length; j++){
			if (isAnagram(words[i], words[j])){
				anagram = true;	
				break;	
				console.log("Is anagram!");
			}
		}
	if(anagram)
    {
		//Before insert we will see if we have an anagram in the result array
		anagram = false;
		for(let z=0; z<result.length; z++)
    	{
			//We will se if it exists in result
			if(isAnagram(words[i],result[z]))
        	{
				anagram = true;
				break;
			}
		}
		if(!anagram)
        {
           	result.push(words[i]);
			anagram = false;
		}

	}
  }
       

console.log(result);

Answer 3

感谢user3297291 我找到了更简单的变体

let words = ['nap', 'teachers', 'cheaters', 'pan', 'ear', 'era', 'hectares']
const set = new Set();
const unique = [];

words.forEach((word) => {

 const sorted = word.split('').sort().join('');

 if (set.has(sorted)) {
   return;
 }
   unique.push(word);
   set.add(sorted);
 });

 print(unique.join(' '));

Answer 4

另一个实现。：）

function aClean(arr) {
     var map = new Map();
     arr.map(item => {
         var key = item.toLowerCase().split("").sort().join("");
         map.has(key) ? null : map.set(key, item)
     });
    return Array.from(map.values());
}

Answer 5

这应该可以完成工作：

let words = ['nap', 'teachers', 'cheaters', 'pan', 'ear', 'era', 'hectares']

let map = new Map(
    words.reverse().map(word => {
        let sorted = word.toLowerCase().split('').sort().join(''); 
        return [sorted, word];
    })
);

console.log(Array.from(map.values())); // output: [ "teachers", "ear", "nap" ]

使用每个单词中的字符作为键。例如：对于[老师，作弊者，公顷]，关键是“ aceehrst”

由于顺序对于查找第一个单词很重要，因此反转单词顺序将有助于保持“老师”作为键“ aceehrst”而不是“公顷”的值。

Answer 6

const checkAnagram = (var1, var2) => {
    let val1 = var1.split("").sort().join("")
    let val2 = var2.split("").sort().join("")

    if (val1 == val2) {
        return true;
    } else {
        return false;
    }
    return false;
}

console.log(checkAnagram("shoes", "ssoeh"))

在数组（JS）中查找第一个唯一的非七字串

6 个答案: