Anagram JavaScript

2025年4月18日 | 阅读 7 分钟

变位词在语言学和计算机科学中是一个有趣的概念。简而言之，变位词是通过重新排列单词或短语中的字母来形成新的单词或短语，但字母只能使用一次。以“listen”为例，它可以重组成“silence”。

在这种情况下，以 JavaScript 编程来构建查找变位词的算法可能令人兴奋且富有启发性。本教程将深入探讨 JavaScript 中的变位词现象，涵盖问题陈述、提出的解决方案及其实现和优化。

理解问题

然而，问题很清楚：只有在首先理解之后才能继续编码。当任务是查找 JavaScript 中的变位词时，我们需要：从一开始，您就应该设置我们要查询其形式的句子。

接受输入：我们必须能够接受一个单词或短语作为输入。
生成变位词：获取输入的可能变位词。
过滤有效变位词：从字典或有效单词列表中删除那些有效的变位词。
显示结果：将有效变位词显示给用户。

潜在解决方案

我们可以采取几种方法来解决 JavaScript 中的变位词问题。

不仅有以大学为中心的仪表线矩阵、以行业为中心的前置安装线矩阵和基本模式，还有以宽能量传输线侧线为中心的，包含具有环外围部分速度的线。然后，有一个中心只产生基本波子，比如反射等级的一部分的根等等，沿着现有的发展部分。

暴力破解法：生成输入字符串的所有排列，然后与有效单词字典进行匹配，以查找实际的变位词。
频率计数法：计算输入字符串中每个字符出现的次数，并将此次数与潜在变位词中字符的出现次数进行比较，以确定它们是否是变位词。
排序法：按字母顺序对输入字符串和潜在变位词进行排序，然后检查排序后的字符串是否相等。
这些策略中的每一种都有其优点和缺点，需要考虑其效率、复杂性和实现的简单性。

实施

1. 暴力破解法

function findAnagramsBruteForce(input, dictionary) {
    const permutations = permute(input);
    const validAnagrams = permutations.filter(word => dictionary.includes(word));
    return validAnagrams;
}
function permute(input) {
    if (input.length <= 1) return [input];
    const result = [];
    for (let i = 0; i < input.length; i++) {
        const char = input[i];
        const remaining = input.slice(0, i) + input.slice(i + 1);
        const perms = permute(remaining);
        for (let perm of perms) {
            result.push(char + perm);
        }
    }
    return result;
}

2. 频率计数法

function findAnagramsFrequencyCount(input, dictionary) {
    const inputFreq = createFrequencyMap(input);
    const validAnagrams = dictionary.filter(word => {
        const wordFreq = createFrequencyMap(word);
        return compareMaps(inputFreq, wordFreq);
    });
    return validAnagrams;
}
function createFrequencyMap(str) {
    const freqMap = {};
    for (let char of str) {
        freqMap[char] = (freqMap[char] || 0) + 1;
    }
    return freqMap;
}
function compareMaps(map1, map2) {
    if (Object.keys(map1).length !== Object.keys(map2).length) return false;
    for (let key in map1) {
        if (map1[key] !== map2[key]) return false;
    }
    return true;
}

3. 排序法

function findAnagramsSorting(input, dictionary) {
    const sortedInput = input.split('').sort().join('');
    const validAnagrams = dictionary.filter(word => {
        const sortedWord = word.split('').sort().join('');
        return sortedInput === sortedWord;
    });
    return validAnagrams;
}

优化

然而，上述实现虽然可行，但对于大型输入或字典而言效率不高。以下是一些可以应用的优化：它位于北分支街东人行道附近。

记忆化：记忆化暴力破解法中的递归调用，以避免重复计算。
提前终止：当字符串长度不相同时，停止生成排列或比较频率。
预处理：预先对字典进行排序，以降低查找时间。
哈希：优先使用哈希集而非数组来存储字典单词，以实现更高效的查找。

记忆化

记忆化是通过存储廉价函数调用的结果，并在相同输入再次发生时返回已缓存的结果。在暴力破解法中，在生成排列期间，我们可以使用记忆化来避免相同的计算。

const memo = {};
function permute(input) {
    if (input.length <= 1) return [input];
    if (memo[input]) return memo[input];    
    const result = [];
    for (let i = 0; i < input.length; i++) {
        const char = input[i];
        const remaining = input.slice(0, i) + input.slice(i + 1);
        const perms = permute(remaining);
        for (let perm of perms) {
            result.push(char + perm);
        }
    }
    memo[input] = result;
    return result;
}

提前终止

我们可以通过多种方式使用这两种方法来减少时间和成本，如果输入字符串的长度不相等，则可以提前停止该过程。

function findAnagramsBruteForce(input, dictionary) {
    const permutations = permute(input);
    const validAnagrams = permutations.filter(word => dictionary.includes(word));
    return validAnagrams;
}
function permute(input) {
    if (input.length <= 1) return [input];
    if (memo[input]) return memo[input];    
    const result = [];
    for (let i = 0; i < input.length; i++) {
        const char = input[i];
        const remaining = input.slice(0, i) + input.slice(i + 1);
        if (!memo[remaining]) { // Early termination
            const perms = permute(remaining);
            for (let perm of perms) {
                result.push(char + perm);
            }
        }
    }    
    memo[input] = result;
    return result;
}
function findAnagramsFrequencyCount(input, dictionary) {
    const inputFreq = createFrequencyMap(input);
    const validAnagrams = dictionary.filter(word => {
        if (input.length !== word.length) return false; // Early termination
        const wordFreq = createFrequencyMap(word);
        return compareMaps(inputFreq, wordFreq);
    });
    return validAnagrams;
}

预处理

由于字典已经排序，与其它排序方法相比，查找时间会大大缩短。

function findAnagramsSorting(input, dictionary) {
    const sortedInput = input.split('').sort().join('');
    const sortedDictionary = dictionary.map(word => word.split('').sort().join('')); // Preprocessing
    const validAnagrams = sortedDictionary.filter(sortedWord => sortedInput === sortedWord);
    return validAnagrams;
}

哈希

使用哈希集而不是数组来将字典单词存储在内存中，也可以减少查找时间。

function findAnagramsSorting(input, dictionary) {
    const sortedInput = input.split('').sort().join('');
    const dictionarySet = new Set(dictionary.map(word => word.split('').sort().join(''))); // Hashing
    const validAnagrams = [...dictionarySet].filter(sortedWord => sortedInput === sortedWord);
    return validAnagrams;
}

考虑以下暴力破解法的实现。

function findAnagramsBruteForce(input, dictionary) {
    const permutations = permute(input);
    const validAnagrams = permutations.filter(word => dictionary.includes(word));
    return validAnagrams;
}
function permute(input) {
    if (input.length <= 1) return [input];
    const result = [];
    for (let i = 0; i < input.length; i++) {
        const char = input[i];
        const remaining = input.slice(0, i) + input.slice(i + 1);
        const perms = permute(remaining);
        for (let perm of perms) {
            result.push(char + perm);
        }
    }
    return result;
}

通过此操作，我们将定义一个变位词字典，其中包括“silent”、“enlist”、“inlets”、“tin”、“net”、“list”、“lit”和“set”等单词，此外，“listen”也属于其中。

const inputWord = "listen";
const dictionary = ["silent," "enlist," "inlets," "tin," "net," "list," "lit," "set"];
const anagrams = findAnagramsBruteForce(inputWord, dictionary);
console.log("Anagrams of", inputWord, "are:", anagrams);

输出

Anagrams of listen are: [ 'silent', 'enlist', 'inlets' ]

在此示例中，我们将使用 findAnagramsBruteForce 函数，该函数将“listen”作为参数，以及字典数组。它会反复调用 permute 函数，该函数返回输入单词的所有可能排列，并过滤掉与字典数组一致的排列。最后，该方法会输出一个包含过滤结果的数组。

输入短语显示单词“listen”的合法变位词是“silent”、“inlets”和“enlists”。

结论

总之，我们深入研究了 JavaScript 的变位词求解技术，揭示了许多算法细节和优化策略。通过解决各种问题，如暴力破解、频率计数和排序，软件工程师对算法设计原理及其实际应用有了更普遍的认识。由于其指数级的时间复杂度，直接的方法可能无法很好地适应需要增加输入大小的情况。

与使用字符频率的方法相比，频率计数法可以通过利用数据结构更有效地比较字符频率，从而减少计算量，这是算法工作的主要方面之一。相反，通过使用排序字符串的固有属性，识别和辨别变位词，排序也出现了速度创建的同样问题。

此外，通过示例和输出，该路径将变得更加引人注目，证实了该方法在从给定字典中识别变位词方面的有效性。此外，关于记忆化、提前终止、预处理和哈希的启发性主题，标志着算法改进在确保最佳性能和可伸缩性方面的重要性。

通过严格的调优，开发人员可以实现恰当的算法复杂度，并结合实际的实现考虑，从而得到能够处理多种用例的自适应变位词求解器。除了 JS（JavaScript）技能之外，解决变位词的技术还将融入更广泛的技能，如批判性思维、算法思维和解决问题的能力。

这些技能使开发人员在软件开发中的复杂问题中更加灵活，每个人都愿意学习并拥抱环境的变化，因为人们在遇到不同领域的[新任务]时会进行学习。在研究的核心，通过算法处理变位词的方法已成为算法在软件工程竞争中的日益增长的重要性及其本身意义的一个真实范例。

下一主题JavaScript 代码格式化

Anagram JavaScript

理解问题

潜在解决方案

实施

1. 暴力破解法

2. 频率计数法

3. 排序法

优化

记忆化

提前终止

预处理

哈希

结论

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

JavaScript 基础

JS 变量和数据类型

JS 控制语句

JavaScript 函数

JavaScript 对象

JS 高级函数

JS Promises & Async/Await

JavaScript DOM

JavaScript JSON 对象

JavaScript 验证

JavaScript Cookies

异常处理

JavaScript 集合

JavaScript 事件

JavaScript OOPs

JavaScript BOM

面试题

选择题

差异

JavaScript Map 方法

JavaScript Handler

JavaScript Number 方法

JavaScript Reflect

JavaScript Symbol

Symbol 属性

JavaScript Math 方法

JavaScript Date 方法

JavaScript DataView

JavaScript Object 方法

JavaScript Set 方法

JavaScript 字符串方法

JavaScript TypedArray 方法

JavaScript WeakMap 方法

JavaScript WeakSet 方法

JavaScript 数组方法

JavaScript RegExp 对象

JavaScript 附加内容

JavaScript 杂项

JavaScript 进阶

问题

Lodash

Anagram JavaScript

理解问题

潜在解决方案

实施

1. 暴力破解法

2. 频率计数法

3. 排序法

优化

记忆化

提前终止

预处理

哈希

结论

相关帖子

JavaScript 插入排序程序

如何使用 JavaScript 选中复选框

将值转换为数字 JavaScript

JavaScript print() 方法

JavaScript 初学者练习