Arrays 获取数组的所有组合

我目前正在尝试创建一个函数，该函数可以获取所有可能的数组值组合

我已经提出了一个非函数版本，但它仅限于3个值，所以我正试图将其变成一个更具

动态性的函数

我尝试过搜索，但是没有找到一个powershell示例，我可以找到一个PHP版本，但是我的PHP非常有限


非函数脚本

$name = 'First','Middle','Last'

$list = @()

foreach ($c1 in $name) {
    foreach ($c2 in $name) {
        foreach ($c3 in $name) {
            if (($c1 -ne $c2) -and ($c2 -ne $c3) -and ($c3 -ne $c1))
            {
                $list += "$c1 $c2 $c3"
            }
        }
    }
} 

这给了我结果

First Middle Last
First Last Middle
Middle First Last
Middle Last First
Last First Middle
Last Middle First

我不确定在递归函数时如何重新排列这些值，这是我到目前为止得到的结果：

<#
.Synopsis
    Short description
.DESCRIPTION
    Long description
.EXAMPLE
    Example of how to use this cmdlet
.EXAMPLE
    Another example of how to use this cmdlet
#>
function Get-Combinations
{
    [CmdletBinding()]
    [OutputType([int])]
    Param
    (
        # Param1 help description
        [Parameter(Mandatory=$true,
                   ValueFromPipelineByPropertyName=$true,
                   Position=0)]
        [string[]]$Array,

        # Param1 help description
        [Parameter(Mandatory=$false,
                   ValueFromPipelineByPropertyName=$false,
                   Position=1)]
        [string]$Temp,

        # Param1 help description
        [Parameter(Mandatory=$false,
                   ValueFromPipelineByPropertyName=$true,
                   Position=2)]
        [string[]]$Return
    )

    Begin
    {
        Write-Verbose "Starting Function Get-Combinations with parameters `n`n$($Array | Out-String)`n$temp`n`n$($Return | Out-String)"

        If ($Temp)
        {
            $Return = $Temp
        }

        $newArray = new-object system.collections.arraylist
    }
    Process
    {
        Write-Verbose ($return | Out-String)

        For($i=0; $i -lt $Array.Length; $i++)
        {
            #Write-Verbose $i

            $Array | ForEach-Object {$newArray.Add($_)}
            $newArray.RemoveAt($i)

            Write-Verbose ($newArray | Out-String)

            if ($newArray.Count -le 1)
            {
                Get-Combinations -Array $newArray -Temp $Temp -Return $Return
            }
            else
            {
                $Return = $Temp
            }
        }
        $newArray
    }
    End
    {
        Write-Verbose "Exiting Function Get-Combinations"
    }
}

$combinations = @("First","First2","Middle","Last")

$Combos = Get-Combinations -Array $combinations

$Combos

2008年8月28日更新

越来越近，但仍然得到奇怪的输出

<#
.Synopsis
    Short description
.DESCRIPTION
    Long description
.EXAMPLE
    Example of how to use this cmdlet
.EXAMPLE
    Another example of how to use this cmdlet
#>
function Get-Combinations
{
    [CmdletBinding()]
    [OutputType([int])]
    Param
    (
        # Param1 help description
        [Parameter(Mandatory=$true,
                    ValueFromPipelineByPropertyName=$true,
                    Position=0)]
        [string[]]$Array,

        # Param1 help description
        [Parameter(Mandatory=$false,
                    ValueFromPipelineByPropertyName=$false,
                    Position=1)]
        [string]$Temp,

        # Param1 help description
        [Parameter(Mandatory=$false,
                    ValueFromPipelineByPropertyName=$true,
                    Position=2)]
        [string[]]$Return
    )

    Begin
    {
        Write-Verbose "Starting Function Get-Combinations with parameters `n`n$($Array | Out-String)`n$temp`n`n$($Return | Out-String)"

        If ($Temp)
        {
            $Return += $Temp
        }

        #$newArray = new-object [System.Collections.ArrayList]
        #$Array | ForEach-Object {$newArray.Add($_) | Out-Null}

        [System.Collections.ArrayList]$newArray = $Array
    }
    Process
    {
        Write-Verbose "return -> $return"

        For($i=0; $i -lt $Array.Length; $i++)
        {
            Write-Verbose "`$i -> $i"

            $element = $newArray[0]
            $newArray.RemoveAt(0)

            Write-Verbose "`$newArray -> $newArray"
            Write-Verbose "Element -> $element"

            if ($newArray.Count -gt 0)
            {
                Get-Combinations -Array $newArray -Temp (($temp + " " +$element).Trim()) -Return $Return
            }
            else
            {
                $Return = $Temp + " " + $element
            }
        }
        $return
    }
    End
    {
        Write-Verbose "Exiting Function Get-Combinations"
    }
}

$combinations = @("First","First2","Middle","Last")

$return = @()

$Combos = Get-Combinations -Array $combinations -Return $return

$Combos

我试着学习一些新的东西来帮助你，但是我被卡住了。也许这会帮助您找到正确的方向，但我对Powershell递归了解不够，无法解决这个问题。我将php转换为powershell，理论上它应该可以工作，但实际上不行

$array = @('Alpha', 'Beta', 'Gamma', 'Sigma')


function depth_picker([system.collections.arraylist]$arr,$temp_string, $collect)
{
if($temp_string -ne ""){$collect += $temp_string}
    for($i = 0; $i -lt $arr.count;$i++)
    {
    [system.collections.arraylist]$arrCopy = $arr
    $elem = $arrCopy[$i]
    $arrCopy.removeRange($i,1)
    if($arrCopy.count -gt 0){
    depth_picker -arr $arrCopy -temp_string "$temp_string $elem" -collect $collect}
    else{$collect += "$temp_string $elem"}
    }
}
$collect = @()
depth_picker -arr $array -temp_string "" -collect $collect
$collect

它似乎有效，并将为您提供第一套可能的解决方案：

Alpha
Alpha Beta
Alpha Beta Gamma
Alpha Beta Gamma Sigma

但由于某些原因，我无法确定它何时返回到以前的函数并执行$I++然后检查（$I-lt$arr.count）$arr.count它始终为0，因此它永远不会进入下一次迭代以继续查找可能性

希望其他人能解决我似乎无法解决的问题，因为我对递归了解不够。但似乎每个深度级别都被称为上一个深度级别$arr变量，并且值都丢失了。
我试图学习一些新知识并帮助您解决问题，但我被卡住了。也许这会帮助您找到正确的方向，但我对Powershell递归了解不够，无法解决这个问题。我将php转换为powershell，理论上它应该可以工作，但实际上不行

$array = @('Alpha', 'Beta', 'Gamma', 'Sigma')


function depth_picker([system.collections.arraylist]$arr,$temp_string, $collect)
{
if($temp_string -ne ""){$collect += $temp_string}
    for($i = 0; $i -lt $arr.count;$i++)
    {
    [system.collections.arraylist]$arrCopy = $arr
    $elem = $arrCopy[$i]
    $arrCopy.removeRange($i,1)
    if($arrCopy.count -gt 0){
    depth_picker -arr $arrCopy -temp_string "$temp_string $elem" -collect $collect}
    else{$collect += "$temp_string $elem"}
    }
}
$collect = @()
depth_picker -arr $array -temp_string "" -collect $collect
$collect

它似乎有效，并将为您提供第一套可能的解决方案：

Alpha
Alpha Beta
Alpha Beta Gamma
Alpha Beta Gamma Sigma

但由于某些原因，我无法确定它何时返回到以前的函数并执行$I++然后检查（$I-lt$arr.count）$arr.count它始终为0，因此它永远不会进入下一次迭代以继续查找可能性

希望其他人能解决我似乎无法解决的问题，因为我对递归了解不够。但似乎每个深度级别都称为前一个深度级别$arr变量，并且值丢失。
以下是我的解决方案：

function Remove ($element, $list)
{
    $newList = @()
    $list | % { if ($_ -ne $element) { $newList += $_} }

    return $newList
}


function Append ($head, $tail)
{
    if ($tail.Count -eq 0)
        { return ,$head }

    $result =  @()

    $tail | %{
        $newList = ,$head
        $_ | %{ $newList += $_ }
        $result += ,$newList
    }

    return $result
}


function Permute ($list)
{
    if ($list.Count -eq 0)
        { return @() }

    $list | %{
        $permutations = Permute (Remove $_ $list)
        return Append $_ $permutations
    }
}

cls

$list = "x", "y", "z", "t", "v"

$permutations = Permute $list


$permutations | %{
    Write-Host ([string]::Join(", ", $_))
}

编辑：在一个函数中相同（排列）。不过，这有点作弊，因为我用lambdas替换了普通函数。您可以用自己处理的堆栈替换递归调用，但这会使代码变得非常复杂

function Permute ($list)
{
    $global:remove = { 
        param ($element, $list) 

        $newList = @() 
        $list | % { if ($_ -ne $element) { $newList += $_} }  

        return $newList 
    }

    $global:append = {
        param ($head, $tail)

        if ($tail.Count -eq 0)
            { return ,$head }

        $result =  @()

        $tail | %{
            $newList = ,$head
            $_ | %{ $newList += $_ }
            $result += ,$newList
        }

        return $result
    }

    if ($list.Count -eq 0)
        { return @() }

    $list | %{
        $permutations = Permute ($remove.Invoke($_, $list))
        return $append.Invoke($_, $permutations)
    }
}

cls

$list = "x", "y", "z", "t"

$permutations = Permute $list

$permutations | %{
    Write-Host ([string]::Join(", ", $_))
}

以下是我的解决方案：

function Remove ($element, $list)
{
    $newList = @()
    $list | % { if ($_ -ne $element) { $newList += $_} }

    return $newList
}


function Append ($head, $tail)
{
    if ($tail.Count -eq 0)
        { return ,$head }

    $result =  @()

    $tail | %{
        $newList = ,$head
        $_ | %{ $newList += $_ }
        $result += ,$newList
    }

    return $result
}


function Permute ($list)
{
    if ($list.Count -eq 0)
        { return @() }

    $list | %{
        $permutations = Permute (Remove $_ $list)
        return Append $_ $permutations
    }
}

cls

$list = "x", "y", "z", "t", "v"

$permutations = Permute $list


$permutations | %{
    Write-Host ([string]::Join(", ", $_))
}

编辑：在一个函数中相同（排列）。不过，这有点作弊，因为我用lambdas替换了普通函数。您可以用自己处理的堆栈替换递归调用，但这会使代码变得非常复杂

function Permute ($list)
{
    $global:remove = { 
        param ($element, $list) 

        $newList = @() 
        $list | % { if ($_ -ne $element) { $newList += $_} }  

        return $newList 
    }

    $global:append = {
        param ($head, $tail)

        if ($tail.Count -eq 0)
            { return ,$head }

        $result =  @()

        $tail | %{
            $newList = ,$head
            $_ | %{ $newList += $_ }
            $result += ,$newList
        }

        return $result
    }

    if ($list.Count -eq 0)
        { return @() }

    $list | %{
        $permutations = Permute ($remove.Invoke($_, $list))
        return $append.Invoke($_, $permutations)
    }
}

cls

$list = "x", "y", "z", "t"

$permutations = Permute $list

$permutations | %{
    Write-Host ([string]::Join(", ", $_))
}

这是我使用递归函数的解决方案。它生成以空格分隔的字符串，但使用$list[$i]拆分每个元素非常简单。拆分（“”）：

这是我使用递归函数的解决方案。它生成以空格分隔的字符串，但使用$list[$i]拆分每个元素非常简单。拆分（“”）：

米奇·巴拉德利发布的解决方案几乎对我有效。以下是一个不复制值的版本：

Function Get-Permutations 
{
    param ($array_in, $current, $depth, $array_out)
    $depth++
    $array_in = $array_in | select -Unique
    for ($i = 0; $i -lt $array_in.Count; $i++)
    {
        $array_out += ($current+" "+$array_in[$i]).Trim()
        if ($depth -lt $array_in.Count)
        {
            $array_out = Get-Permutations $array_in ($current+" "+$array_in[$i]) $depth $array_out
        }
        else {}
    }
    if(!($array_out -contains ($array_in -Join " "))) {}
    for ($i = 0; $i -lt $array_out.Count; $i++)
    {
        $array_out[$i] = (($array_out[$i].Split(" ")) | select -Unique) -Join " "
    }
    $array_out | select -Unique
}

米奇·巴拉德利发布的解决方案几乎对我有效。以下是一个不复制值的版本：

Function Get-Permutations 
{
    param ($array_in, $current, $depth, $array_out)
    $depth++
    $array_in = $array_in | select -Unique
    for ($i = 0; $i -lt $array_in.Count; $i++)
    {
        $array_out += ($current+" "+$array_in[$i]).Trim()
        if ($depth -lt $array_in.Count)
        {
            $array_out = Get-Permutations $array_in ($current+" "+$array_in[$i]) $depth $array_out
        }
        else {}
    }
    if(!($array_out -contains ($array_in -Join " "))) {}
    for ($i = 0; $i -lt $array_out.Count; $i++)
    {
        $array_out[$i] = (($array_out[$i].Split(" ")) | select -Unique) -Join " "
    }
    $array_out | select -Unique
}

是的，我知道你的意思，它在lol中做我的头，但我慢慢地越来越近，所以我至少对我来说是这样。是的，我知道你的意思，它在lol中做我的头，但我慢慢地越来越近，所以我至少对我来说是这样。有一些想法在盒子之外。这是一种非常酷的方法，有没有办法将其浓缩成一个函数？请参阅我的编辑。正如我所说，这有点作弊。但我能想到的所有其他替代方案都会使代码更加复杂。先生，您是位绅士和学者，非常感谢您的编辑。这将给我很多东西来提高我的递归知识。有一些想法是不切实际的。这是一种非常酷的方法，有没有办法将其浓缩成一个函数？请参阅我的编辑。正如我所说，这有点作弊。但我能想到的所有其他替代方案都会使代码更加复杂。先生，您是位绅士和学者，非常感谢您的编辑。这将给我很多东西来提高我的递归知识。所以你想包括1..$arr.count结果吗？例如“First”是有效的，以及“First，First2”和“First，First2，Middle”和“First，First2，Middle，Last”以及它们的所有组合。对吗？那么您想包括1..$arr.count结果？例如“First”是有效的，以及“First，First2”和“First，First2，Middle”和“First，First2，Middle，Last”以及它们的所有组合。对吗？