Question

我目前正在寻找一种强力算法，我找不到一个好的/简单的算法所以我试着自己写一个，但我失败了。我在数学或其他方面都太糟糕了。：/
我不需要特定编程语言中的算法，如果你有一个，我可以把它移植到我需要的语言中。
我基本上都在寻找像这样简单的东西：
（我试图写一个暴力函数）

function BruteForce(chars,minLen,maxLen)
    curCharArray = {}
    for i=1, maxLen do
      curCharArray[i] = 0
    end
    generatedString = ""
    for currentLength = minLen, maxLen, 1 do
        curCharArray[currentLength] = 1
        Pos=currentLength
        while Pos>0 do

            if string.len(generatedString) < 1 then 
                generatedString= string.sub(chars,curCharArray[Pos],curCharArray[Pos])
            else
                generatedString= string.sub(generatedString,1,Pos-1) .. string.sub(chars,curCharArray[Pos],curCharArray[Pos])
            end

                print(generatedString)

            curCharArray[Pos] = curCharArray[Pos]+1
            Pos = currentLength
            while curCharArray[Pos]==string.len(chars)+1 do
                curCharArray[Pos]=1
                Pos = Pos-1
            end
        end
    end
end

BruteForceAttack("abc",2,3)

它是用Lua编写的，你可以在这里在线运行代码：http://www.lua.org/cgi-bin/demo 输出是：

a
ab
ac

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

如您所见，某些输出相同且未考虑最小长度。此外，订单是错误的。我希望输出为：

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

Answer 1

不幸的是，我不了解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);

更新：没有递归的代码段：

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);
}

Answer 2

许多编程语言在某些标准库中具有这种功能。例如，在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)

Answer 3

非常感谢@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)

结果：

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

我希望这段代码对某人有用。

Answer 4

解决问题时，有不同的方法，例如：

Brute-Force：尝试所有可能的状态组合，通过组合枚举来获得解决方案。
分而治征服：当问题状态在某些时候很困难时，你将它分成两个或多个相同的部分，然后合并，然后合并部分解决方案。
动态编程：当问题在2维或更多维度上变异时，您重建相同的问题直到输入大小，在每次构建时，您通过使用您获得的最佳解决方案线性地解决问题低于它。
贪婪：在每个州，如果不是解决方案，请走向最佳邻居状态，这基本上是对成本g(state)函数进行优化（最大化\最小化）。
启发式：在每种状态下，你都有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

如何编写蛮力算法？

4 个答案: