Algorithm 如何编写蛮力算法？

我目前正在寻找一个bruteforce算法，但我找不到一个好的/简单的。
所以我试着自己写一本，但失败了。我只是数学太差了/
我不需要特定编程语言中的算法，如果您有，我可能可以将其移植到我需要的语言中。
我基本上在寻找这样简单的东西：
（我尝试编写一个bruteforce函数）

正如您所看到的，一些输出是相同的，并且没有考虑最小长度。而且，顺序是错误的。 我希望输出为：

aa
ab
ac
ba
bb
bc
ca
cb
cc
aaa
aab
aac
aba
abb
abc
aca
acb
acc
baa
bab
bac
bba
bbb
bbc
bca
bcb
bcc
caa
cab
cac
cba
cbb
cbc
cca
ccb
ccc

---

许多编程语言在某些标准库中都有这样的功能。例如，在Python中，可以执行以下操作：

import itertools 

def print_perms(chars, minlen, maxlen): 
    for n in range(minlen, maxlen+1): 
        for perm in itertools.product(chars, repeat=n): 
            print(''.join(perm)) 

print_perms("abc", 2, 3)

---

不幸的是，我不知道LUA，但我认为这个JavaScript代码片段的想法很清楚：

function generate(current, len, chars) 
{
    if (current.length == len)
        console.log(current);
    if (current.length < len)
        for (var i in chars) {
            generate(current + chars[i], len, chars) 
        }
}

function brute(chars, min, max)
{
    for (var l = min; l <= max; ++l)
        generate("", l, chars);
}

brute(['a', 'b', 'c'], 2, 3);

函数生成（当前、len、chars）
{
if（current.length==len）
console.log（当前）；
如果（当前长度对于（var l=min；l解决问题时，有不同的方法，例如：


蛮力：尝试所有可能的状态组合，通过组合枚举获得解决方案

分而治之：当一个问题状态在某一点上很困难时，你把它分成两个或多个相同的部分，分别解决，然后合并部分解决方案

动态规划：当问题在两个或更多维度上发生变化时，您将重建相同的问题，直到输入大小。在每次构建时，您将使用在其下大小得到的最优解线性地解决问题

贪婪：在每个状态下，如果不是解决方案，则逐步进入最佳近邻状态，这基本上是对成本
g（状态）
函数的优化（最大化\最小化）

启发式：在每个状态下，您都有
h（state）
函数，它的工作原理就像一个8球，告诉您相邻状态与解决方案状态的距离有多近

等等


Eaxmple:搜索问题

-- Brute Force example, search array

local array = { "apple", "orange", "pear", "banana" }

for i = 1, #array do

  if array[i] == "banana" then

    -- item found

  end

end

非常感谢@Dmitry Poroh的好主意。我在lua上实现了代码：

symbols = {'A','B','C'}

lenght = {min = 2, max = 3}

function print_t(t)
    for _,v in pairs(t) do
    io.write(v)
    end
    print()
end

function generate(current, len, chars)
    if #current == len then
    print_t(current)
    return
    end
    if #current < len then
    for c = 1, #chars do
    curr = {}
    for i = 1, #current do
        curr[i] = current[i]
    end
    curr[#curr+1] = chars[c]
    generate(curr, len, chars)
    end
    end
end

function brute(chars, min, max)
    for l = min, max do
    generate({}, l, chars)
    end
end

brute(symbols, lenght.min, lenght.max)

我希望这段代码对某些人有用。
你还没有说你在强制执行什么。@pjs我只是在寻找一种我认为被称为“强制执行”的算法。@Forivin:我想你应该澄清一下，你在强制执行与顺序无关的所有2-3个字母的“abc”组合。@Forivin“强制执行”是一种攻击类型，通常意味着尝试所有可能的方法，通常在考虑密码的情况下，意味着您以“a”、“AA”、“AAA”开头，等等。在你的例子中，你实际上想要的是一个字典创建程序。你可以生成字典，然后将该文本文件输入到类似于John The Ripper密码破解程序的程序中。为什么顺序很重要？通常在暴力中，顺序并不重要。旁白：你应该花一个小时来学习f Lua。基础知识非常简单直观。直到你开始学习元表，它才变得更加棘手。这个问题不是关于Lua的，所以没关系。@Forivin：是的，答案很好。+1.我只是对一个程序员说：学习基础知识只需要一个小时，而且这是一门有趣的语言。你知道吗你会知道的：PI刚刚测试了代码，它确实工作了，但是有可能把这个算法放到一个函数中吗？也许也能摆脱自调用？Forivin还添加了非递归算法。它没有递归模拟那么优雅，但也非常简短和清晰。
function generateNoRecursion(len, chars) 
{
    // Indices that indicate what char to use on corresponding place.
    var indices = [];
    for (var i = 0; i < len; ++i)
        indices.push(0);

    // While all indices in set of chars
    while (indices[0] < chars.length)
    {
        // Print current solution
        var str = "";
        for (var i = 0; i < indices.length; ++i)
            str += chars[indices[i]];
        console.log(str);
        // Go to next solution by incrementing last index and adjusting
        // if it is out of chars set.
        indices[len-1]++;
        for (var i = len-1; i > 0 && indices[i] == chars.length; --i)
        {
            indices[i] = 0;
            indices[i-1]++;
        }
    }
}

function brute(chars, min, max)
{
    for (var l = min; l <= max; ++l)
        generateNoRecursion(l, chars);
}

-- Brute Force example, search array

local array = { "apple", "orange", "pear", "banana" }

for i = 1, #array do

  if array[i] == "banana" then

    -- item found

  end

end

symbols = {'A','B','C'}

lenght = {min = 2, max = 3}

function print_t(t)
    for _,v in pairs(t) do
    io.write(v)
    end
    print()
end

function generate(current, len, chars)
    if #current == len then
    print_t(current)
    return
    end
    if #current < len then
    for c = 1, #chars do
    curr = {}
    for i = 1, #current do
        curr[i] = current[i]
    end
    curr[#curr+1] = chars[c]
    generate(curr, len, chars)
    end
    end
end

function brute(chars, min, max)
    for l = min, max do
    generate({}, l, chars)
    end
end

brute(symbols, lenght.min, lenght.max)

AA
AB
AC
BA
BB
BC
CA
CB
CC
AAA
AAB
AAC
ABA
ABB
ABC
ACA
ACB
ACC
BAA
BAB
BAC
BBA
BBB
BBC
BCA
BCB
BCC
CAA
CAB
CAC
CBA
CBB
CBC
CCA
CCB
CCC