Algorithm 用Powershell编写的笛卡尔积

我一直在尝试在Powershell中完成笛卡尔积算法。使用stackoverflow上的其他公式，我得出以下结论：

clear

Function New-GenericDictionary([type] $keyType, [type]$valueType)
{
    $base = [System.Collections.Generic.Dictionary``2]
    $ct = $base.MakeGenericType(($keyType, $valueType))
    New-Object $ct
}

$sets = New-GenericDictionary int string
$sets[0] = "1"
$sets[1] = "0,1"
$sets[2] = "0,1"

$iterations = 1
$stringCombo = ""
foreach($key in $sets.Keys) {
    $pieces = $sets[$key].Split(",")
    $iterations = $iterations * $pieces.Length
}

for ($i = 0; $i -lt $iterations; $i++) {
    $stringCombo = ""
    foreach($key in $sets.Keys) {
        $pieces = $sets[$key].Split(",")
        $val = $pieces.Length
        $get = $i%$val
        $stringCombo = $stringCombo + " " + $pieces[$get]
    }

    Write-Host $stringCombo.Trim()
}

#output hoped for:
#1 0 0
#1 0 1
#1 1 0
#1 1 1

#output is:
#1 0 0
#1 1 1
#1 0 0
#1 1 1

正如代码段底部的注释所示，输出并没有产生预期的结果。迭代次数计数返回了正确的值，但组合没有正确完成

在此代码段中，$sets[x]是固定的，但在实际脚本中，$sets字典项是作为循环的一部分创建的，每次迭代可以包含1到多个项

有人能再给我一双眼睛看看我错过了什么吗

---

谢谢

我想你不需要通用字典来做这件事。一对简单的阵列可以：

PS> $c1 = 0,1
PS> $c2 = 0,1
PS> foreach ($i in $c1) {
>>    foreach ($j in $c2) {
>>      "$i,$j"
>>    }
>>  }
>>
0,0
0,1
1,0
1,1

---

我认为你不需要通用字典来做这件事。一对简单的阵列可以：

PS> $c1 = 0,1
PS> $c2 = 0,1
PS> foreach ($i in $c1) {
>>    foreach ($j in $c2) {
>>      "$i,$j"
>>    }
>>  }
>>
0,0
0,1
1,0
1,1

---

不漂亮，但对n个列表有好处

# ------------------------------------------------------------------------------
<#

    CartesianProduct-Lists

#>
# ------------------------------------------------------------------------------

function CartesianProduct-Lists
{
    param
    (
        $Lists
    )

    function Make-List
    {
        param
        (
            $Head, $Tail
        )

        if ($Head -is [Object[]])
        {
            # List already so just extend
            $Result = $Head + $Tail
        }
        else
        {
            # Create List
            $Result = @($Head, $Tail)
        }

        ,$Result
    }

    # if Head..Tail 
    if (@($Lists).Count -gt 1)
    {
        $Head = $Lists[0]
        $Next = $Lists[1]

        $Result = @()
        foreach ($HeadItem in $Head)
        {
            foreach ($NextItem in $Next)
            {            
                $Result += ,(Make-List $HeadItem $NextItem)
            }
        }

        if (@($Lists).Count -gt 2)
        {
            $Index = $Lists.Count - 1
            $Tail = $Lists[2..$Index]

            $Result = ,$Result + $Tail

            $Result = CartesianProduct-Lists $Result
        }

        ,$Result
    }
}

# --------------------------------------------------------

$Lists = @(@(1),@(0,1),@(0,1))

$Result = CartesianProduct-Lists $Lists

$Result | % { $_; "" }

#------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
功能笛卡尔产品列表
{
param
(
美元清单
)
功能列表
{
param
(
头，尾
)
if（$Head-is[Object[]））
{
#清单已经列好了，所以只需扩展
$Result=$Head+$Tail
}
其他的
{
#创建列表
$Result=@（$Head，$Tail）
}
，$Result
}
#如果是头尾
如果（@（$Lists）.Count-gt 1）
{
$Head=$Lists[0]
$Next=$Lists[1]
$Result=@（）
foreach（$Head中的HeadItem）
{
foreach（$NextItem，单位为$Next）
{            
$Result+=，（制作列表$HeadItem$NextItem）
}
}
如果（@（$Lists）.Count-gt 2）
{
$Index=$Lists.Count-1
$Tail=$Lists[2..$Index]
$Result=，$Result+$Tail
$Result=CartesianProduct列出$Result
}
，$Result
}
}
# --------------------------------------------------------
$Lists=@（@（1），@（0,1），@（0,1））
$Result=CartesianProduct list$Lists
$Result |%{$|“”}

屈服

一, 0 0

一, 0 一,

一, 1. 0

一, 1.

---

1

不漂亮，但对n个列表有效果

# ------------------------------------------------------------------------------
<#

    CartesianProduct-Lists

#>
# ------------------------------------------------------------------------------

function CartesianProduct-Lists
{
    param
    (
        $Lists
    )

    function Make-List
    {
        param
        (
            $Head, $Tail
        )

        if ($Head -is [Object[]])
        {
            # List already so just extend
            $Result = $Head + $Tail
        }
        else
        {
            # Create List
            $Result = @($Head, $Tail)
        }

        ,$Result
    }

    # if Head..Tail 
    if (@($Lists).Count -gt 1)
    {
        $Head = $Lists[0]
        $Next = $Lists[1]

        $Result = @()
        foreach ($HeadItem in $Head)
        {
            foreach ($NextItem in $Next)
            {            
                $Result += ,(Make-List $HeadItem $NextItem)
            }
        }

        if (@($Lists).Count -gt 2)
        {
            $Index = $Lists.Count - 1
            $Tail = $Lists[2..$Index]

            $Result = ,$Result + $Tail

            $Result = CartesianProduct-Lists $Result
        }

        ,$Result
    }
}

# --------------------------------------------------------

$Lists = @(@(1),@(0,1),@(0,1))

$Result = CartesianProduct-Lists $Lists

$Result | % { $_; "" }

#------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
功能笛卡尔产品列表
{
param
(
美元清单
)
功能列表
{
param
(
头，尾
)
if（$Head-is[Object[]））
{
#清单已经列好了，所以只需扩展
$Result=$Head+$Tail
}
其他的
{
#创建列表
$Result=@（$Head，$Tail）
}
，$Result
}
#如果是头尾
如果（@（$Lists）.Count-gt 1）
{
$Head=$Lists[0]
$Next=$Lists[1]
$Result=@（）
foreach（$Head中的HeadItem）
{
foreach（$NextItem，单位为$Next）
{            
$Result+=，（制作列表$HeadItem$NextItem）
}
}
如果（@（$Lists）.Count-gt 2）
{
$Index=$Lists.Count-1
$Tail=$Lists[2..$Index]
$Result=，$Result+$Tail
$Result=CartesianProduct列出$Result
}
，$Result
}
}
# --------------------------------------------------------
$Lists=@（@（1），@（0,1），@（0,1））
$Result=CartesianProduct list$Lists
$Result |%{$|“”}

屈服

一, 0 0

一, 0 一,

一, 1. 0

一, 1. 1改进版

# ------------------------------------------------------------------------------
<#

    CartesianProduct-Lists

#>
# ------------------------------------------------------------------------------

function CartesianProduct-Lists
{
    param
    (
        $Lists
    )

    function Make-List
    {
        param
        (
            $Head, $Tail
        )

        if ($Tail -is [Object[]])
        {
            # List already so just extend
            $Result = ,$Head + $Tail
        }
        else
        {
            # Create List
            $Result = @($Head, $Tail)
        }

        ,$Result
    }

    switch (,$Lists) {
        $Null 
        { 
            break 
        }

        # 1 List so just return it
        { $_.Count -eq 1 } 
        { 
            $_ 
        }

        # More than one list so recurse
        { $_.Count -gt 1 } 
        {  
            $Head = $_[0]
            $Index = $_.Count - 1
            $Tail = $_[1..$Index]

            $Next = CartesianProduct-Lists $Tail

            $Result = @()

            foreach ($HeadItem in $Head)
            {
                foreach ($NextItem in $Next)
                {            
                    $Result += ,(Make-List $HeadItem $NextItem)
                }
            }

            ,$Result
        }
    }    
}

#------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
功能笛卡尔产品列表
{
param
(
美元清单
)
功能列表
{
param
(
头，尾
)
if（$Tail-is[Object[]））
{
#清单已经列好了，所以只需扩展
$Result=，$Head+$Tail
}
其他的
{
#创建列表
$Result=@（$Head，$Tail）
}
，$Result
}
开关（，$Lists）{
$Null
{ 
打破
}
#1个列表，所以只需返回它
{$\计数-等式1}
{ 
$_ 
}
#不止一个列表如此递归
{$\计数-gt 1}
{  
$Head=$\uU0]
$Index=$\u.Count-1
$Tail=$\[1..$Index]
$Next=CartesianProduct列出$Tail
$Result=@（）
foreach（$Head中的HeadItem）
{
foreach（$NextItem，单位为$Next）
{            
$Result+=，（制作列表$HeadItem$NextItem）
}
}
，$Result
}
}    
}

改进版

# ------------------------------------------------------------------------------
<#

    CartesianProduct-Lists

#>
# ------------------------------------------------------------------------------

function CartesianProduct-Lists
{
    param
    (
        $Lists
    )

    function Make-List
    {
        param
        (
            $Head, $Tail
        )

        if ($Tail -is [Object[]])
        {
            # List already so just extend
            $Result = ,$Head + $Tail
        }
        else
        {
            # Create List
            $Result = @($Head, $Tail)
        }

        ,$Result
    }

    switch (,$Lists) {
        $Null 
        { 
            break 
        }

        # 1 List so just return it
        { $_.Count -eq 1 } 
        { 
            $_ 
        }

        # More than one list so recurse
        { $_.Count -gt 1 } 
        {  
            $Head = $_[0]
            $Index = $_.Count - 1
            $Tail = $_[1..$Index]

            $Next = CartesianProduct-Lists $Tail

            $Result = @()

            foreach ($HeadItem in $Head)
            {
                foreach ($NextItem in $Next)
                {            
                    $Result += ,(Make-List $HeadItem $NextItem)
                }
            }

            ,$Result
        }
    }    
}

#------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
功能笛卡尔产品列表
{
param
(
美元清单
)
功能列表
{
param
(
头，尾
)
if（$Tail-is[Object[]））
{
#清单已经列好了，所以只需扩展
$Result=，$Head+$Tail
}
其他的
{
#创建列表
$Result=@（$Head，$Tail）
}
，$Result
}
开关（，$Lists）{
$Null
{ 
打破
}
#1个列表，所以只需返回它
{$\计数-等式1}
{ 
$_ 
}
#不止一个列表如此递归
{$\计数-gt 1}
{  
$Head=$\uU0]
$Index=$\u.Count-1