Powershell how to process a variable array - arrays

I have the following situation in powershell:
$arrayX = 0..1
$arrayY = 0..10
$array1 = #()
$array2 = #()
for ($i = 0; $i -lt $arrayY.Length; $i++){
$array1 += $arrayX[0] + $arrayY[$i]
$array2 += $arrayX[1] + $arrayY[$i]
}
Both $arrayX and $arrayY can be variable in length. If i extend $arrayX by 1 i'll need to adjust the code to take the third value into account. like this:
$arrayX = 0..2
$arrayY = 0..10
$array1 = #()
$array2 = #()
$array3 = #()
for ($i = 0; $i -lt $arrayY.Length; $i++){
$array1 += $arrayX[0] + $arrayY[$i]
$array2 += $arrayX[1] + $arrayY[$i]
$array3 += $arrayX[2] + $arrayY[$i]
}
What is the best practice in a situation like this to have this work automatic?

First, please consider not using the += operation with arrays: it will hurt performance a lot on larger arrays. Since you know the array size in advance you can allocate all required memory in advance:
$array1 = New-Object object[] $arrayY.Length
(you may want to use more specific type instead of object: int or float/double will work)
Next, instead of assigning each array to a variable, you can instead create array of arrays:
$arrayX = 0..2
$arrayY = 0..10
$resultArrays = New-Object int[][] $arrayX.Length
for ($x = 0; $x -lt $resultArrays.Length; ++$x)
{
$resultArrays[$x] = New-Object int[] $arrayY.Length
}
for ($y = 0; $y -lt $arrayY.Length; ++$y)
{
for ($x = 0; $x -lt $arrayX.Length; ++$x)
{
$resultArrays[$x][$y] = $arrayX[$x] + $arrayY[$y];
}
}
for ($x = 0; $x -lt $resultArrays.Length; ++$x)
{
Write-Output "array $($x): $($resultArrays[$x] -join ' ')"
}

Is this what you are looking for?
$arrayX = 0..2
$arrayY = 0..10
$arrayX | ForEach-Object {
$aX = $_
New-Variable -Name ('array' + $($aX+1)) -Value ($arrayY | ForEach-Object {$_ + $aX}) -Force
}

Related

Powershell combine the elements of two arrays into one another

I'd like to join two arrays by picking the elements from each array one by one. and not have them combined or simply merged
I know how to add a second array to the first one as in:
$array1 = (0,4,8)
$array2 = (1,5,2)
$array1 += $array2
$array1
Which results in the following:
0
4
8
1
5
2
But how can I copy them into one another giving me an output like this:
0
1
4
5
8
2
Note: I don't want to merge them and then sort the list.
The elements need to stay in the same order. How would that be achieved?
Although Esperento57 gives you a perfect working solution, here's my idea that will also allow for arrays that are not of the same length. It uses a System.Collections.ArrayList to add the values from the arrays for better performance if you have large arrays to combine.
$array1 = (0,2,4)
$array2 = (1,3,5,6,7,8)
$len1 = $array1.Length
$len2 = $array2.Length
$maxLength = [Math]::Max($len1, $len2)
$listResult = New-Object System.Collections.ArrayList
for ($i = 0; $i -lt $maxLength; $i++) {
if ($i -lt $len1) { [void] $listResult.Add($array1[$i]) }
if ($i -lt $len2) { [void] $listResult.Add($array2[$i]) }
}
$listResult.ToArray()
try something like this
$array1 = (0,2,4)
$array2 = (1,3,5)
$MaxLen=[Math]::Max($array1.Length, $array2.Length)
$Result=#()
for ($i = 0; $i -lt $MaxLen; $i++)
{
$Result+=$array1[$i]
$Result+=$array2[$i]
}
$Result
here's another way to do it. [grin]
this one takes into account dissimilar sizes in the arrays and interleaves them until one array runs out of items. the remaining items in the larger array are then added without "ghost" items from the the smaller array.
$array1 = #(0,2,4)
$array2 = #(5,7,9,11)
$InterleavedArray = [System.Collections.Generic.List[int]]::new()
$UpperBound = [math]::Max($array1.GetUpperBound(0), $array2.GetUpperBound(0))
foreach ($Index in 0..$UpperBound)
{
if ($Index -le $array1.GetUpperBound(0))
{
$InterleavedArray.Add($array1[$Index])
}
if ($Index -le $array2.GetUpperBound(0))
{
$InterleavedArray.Add($array2[$Index])
}
}
$InterleavedArray
output ...
0
5
2
7
4
9
11
hope that helps,
lee
If you want the elements to stay in the same order, just do $array3 = $array1 + $array2. If you want to sort it though, do $array3 = ($array1 + $array2) | sort.
Here is a slightly modified version of Theos answer.
Looks cleaner and its faster:
$array1 = (0,2,4)
$array2 = (1,3,5,6,7,8)
$len1 = $array1.Length
$len2 = $array2.Length
$maxIndex = [Math]::Max($len1, $len2)-1
$arrayResult = #()
$arrayResult = foreach ($i in 0..$maxIndex) {
if ($i -lt $len1) { $array1[$i] }
if ($i -lt $len2) { $array2[$i] }
}
$arrayResult

How to deal with "distorted" array-output

I'm trying to build a "connect four" in powershell, usable via console commands, without any GUI.
I've written the code to initialize the gamefield via the output of an array. However, after the newline element in the array, after the very first line, the output gets moved a little to the left:
The code i'm using that produces the error:
$initializegamefield = #()
$savedgamefield = #()
for ($i = 0; $i -lt 48; $i++) {
if (($i -eq 7 ) -or ($i -eq 15) -or ($i -eq 23) -or ($i -eq 31) -or ($i -eq 39) -or ($i -eq 47)) {
$initializegamefield += "`n"
Write-Host "$($initializegamefield)"
$savedgamefield += $initializegamefield
$initializegamefield = #()
} else {
$initializegamefield += "A"
}
}
#Write-Host "$($initializegamefield)"
Write-Host "$($savedgamefield)"
Here I've basically initialized the gamefield two times for testing purposes.
The first time it is initialized, it is done via outputting the array $initializegamefield after it has been filled with ONE ROW including the newline element.
Afterwards $initializegamefield is emptied (see if structure).
In addition, before it is emptied, it is saved to $savedgamefield.
Whilst the formatting of the gamefield is okay with the way I do it with $initializegamefield it isn't okay anymore when doing it it with $savedgamefield.
How can I avoid having this distortion of $savedgamefield?
Since your game field is a 6x8 array I'd recommend actually initializing it as an 6x8 array:
$height = 6
$width = 8
$gamefield = New-Object 'Object[,]' $height, $width
for ($i=0; $i -lt $height; $i++) {
for ($j=0; $j -lt $width; $j++) {
$gamefield[$i, $j] = 'A'
}
}
or at least as a "jagged" array (an array of arrays):
$height = 6
$width = 8
$gamefield = #()
for ($i=0; $i -lt $height; $i++) {
$gamefield += ,#(1..$width | ForEach-Object { 'A' })
}

Building a sequential string into an array (quickly)

I've written the following code to build an array with sequential strings.
It works like I expect, but I wish it ran quicker. Is there a more efficient way to produce my desired results in PowerShell?
I'm very new to PowerShell and appreciate your coaching.
$MIN = 1
$MAX = 20000
$ARRAY = #()
$PREFIX = "AA"
$startDTM = (Get-Date) # Start time
FOR ($i=$MIN; $i -le $MAX; $i++)
{
If ($i -gt 0 -and $i -lt 10) {
$ARRAY = $ARRAY + ($PREFIX+"00000"+$i)
}
If ($i -gt 9 -and $i -lt 100) {
$ARRAY = $ARRAY + ($PREFIX+"0000"+$i)
}
If ($i -gt 99 -and $i -lt 1000) {
$ARRAY = $ARRAY + ($PREFIX+"000"+$i)
}
If ($i -gt 999 -and $i -lt 10000) {
$ARRAY = $ARRAY + ($PREFIX+"00"+$i)
}
If ($i -gt 9999 -and $i -lt 100000) {
$ARRAY = $ARRAY + ($PREFIX+"0"+$i)
}
If ($i -gt 99999 -and $i -lt 1000000) {
$ARRAY = $ARRAY + ($PREFIX+$i)
}
}
$endDTM = (Get-Date) #End Time
"Elapsed Time: $(($endDTM-$startDTM).totalseconds) seconds"
$ARRAY.count #How many loaded.
Example of $ARRAY:
AA000001
AA000002
...
AA019999
AA020000
The following one-liner tooked 0.4911672 seconds (your example 12.9638944 seonds). Results are the same. It uses the format string with decimal specifier to ensure there are 6 digits and just store the result in the array:
$MIN = 1
$MAX = 20000
$PREFIX = "AA"
$ARRAY = $MIN .. $MAX | % { "$PREFIX{0:D6}" -f $_ }
You can further improove the performance by using a while loop (thanks 4c74356b41 for mentioning that):
# ....
$array = while ($MIN -le $MAX)
{
"$PREFIX{0:D6}" -f $MIN++
}
This tooked 0.0970327 seconds on my computer.

How to fill an array efficiently in Powershell

I want to fill up a dynamic array with the same integer value as fast as possible using Powershell.
The Measure-Command shows that it takes 7 seconds on my system to fill it up.
My current code (snipped) looks like:
$myArray = #()
$length = 16385
for ($i=1;$i -le $length; $i++) {$myArray += 2}
(Full code can be seen on gist.github.com or on superuser)
Consider that $length can change. But for better understanding I chose a fixed length.
Q: How do I speed up this Powershell code?
You can repeat arrays, just as you can do with strings:
$myArray = ,2 * $length
This means »Take the array with the single element 2 and repeat it $length times, yielding a new array.«.
Note that you cannot really use this to create multidimensional arrays because the following:
$some2darray = ,(,2 * 1000) * 1000
will just create 1000 references to the inner array, making them useless for manipulation. In that case you can use a hybrid strategy. I have used
$some2darray = 1..1000 | ForEach-Object { ,(,2 * 1000) }
in the past, but below performance measurements suggest that
$some2darray = foreach ($i in 1..1000) { ,(,2 * 1000) }
would be a much faster way.
Some performance measurements:
Command Average Time (ms)
------- -----------------
$a = ,2 * $length 0,135902 # my own
[int[]]$a = [System.Linq.Enumerable]::Repeat(2, $length) 7,15362 # JPBlanc
$a = foreach ($i in 1..$length) { 2 } 14,54417
[int[]]$a = -split "2 " * $length 24,867394
$a = for ($i = 0; $i -lt $length; $i++) { 2 } 45,771122 # Ansgar
$a = 1..$length | %{ 2 } 431,70304 # JPBlanc
$a = #(); for ($i = 0; $i -lt $length; $i++) { $a += 2 } 10425,79214 # original code
Taken by running each variant 50 times through Measure-Command, each with the same value for $length, and averaging the results.
Position 3 and 4 are a bit of a surprise, actually. Apparently it's much better to foreach over a range instead of using a normal for loop.
Code to generate above chart:
$length = 16384
$tests = '$a = ,2 * $length',
'[int[]]$a = [System.Linq.Enumerable]::Repeat(2, $length)',
'$a = for ($i = 0; $i -lt $length; $i++) { 2 }',
'$a = foreach ($i in 1..$length) { 2 }',
'$a = 1..$length | %{ 2 }',
'$a = #(); for ($i = 0; $i -lt $length; $i++) { $a += 2 }',
'[int[]]$a = -split "2 " * $length'
$tests | ForEach-Object {
$cmd = $_
$timings = 1..50 | ForEach-Object {
Remove-Variable i,a -ErrorAction Ignore
[GC]::Collect()
Measure-Command { Invoke-Expression $cmd }
}
[pscustomobject]#{
Command = $cmd
'Average Time (ms)' = ($timings | Measure-Object -Average TotalMilliseconds).Average
}
} | Sort-Object Ave* | Format-Table -AutoSize -Wrap
Avoid appending to an array in a loop. It's copying the existing array to a new array with each iteration. Do this instead:
$MyArray = for ($i=1; $i -le $length; $i++) { 2 }
Using PowerShell 3.0 you can use (need .NET Framework 3.5 or upper):
[int[]]$MyArray = ([System.Linq.Enumerable]::Repeat(2, 65000))
Using PowerShell 2.0
$AnArray = 1..65000 | % {2}
It is not clear what you are trying. I tried looking at your code. But, $myArray +=2 means you are just adding 2 as the element. For example, here is the output from my test code:
$myArray = #()
$length = 4
for ($i=1;$i -le $length; $i++) {
Write-Host $myArray
$myArray += 2
}
2
2 2
2 2 2
Why do you need to add 2 as the array element so many times?
If all you want is just fill the same value, try this:
$myArray = 1..$length | % { 2 }
If you need it really fast, then go with ArrayLists and Tuples:
$myArray = New-Object 'Collections.ArrayList'
$myArray = foreach($i in 1..$length) {
[tuple]::create(2)
}
and if you need to sort it later then use this (normally a bit slower):
$myArray = New-Object 'Collections.ArrayList'
foreach($i in 1..$length) {
$myArray.add(
[tuple]::create(2)
)
}
both versions are in the 20ms range for me ;-)

How can I compare two arrays, removing similar items, without iterating through the whole array?

Is it possible to compare two arrays and remove the values that are equal (if they are at the same index), without iterating through both arrays? Here is an example:
$array1 = #(1,2,3,4,5,6,7,23,44)
$array2 = #(1,1,3,4,5,7,6,23,45)
$array3 = $sudo_compare_function $array1 $array2
where $array3 would now contain an array of indexes where $array2 is different from $array1 array:
(1,5,6,8)
If there isn't something like this, is there an easy way to do something similar without iterating through both arrays?
Use the Compare-Object cmdlet to get an array of differing values:
$array1 = #(1,2,3,4,5,6,7,23,44)
$array2 = #(1,1,3,4,5,7,6,23,45)
$array3 = #(Compare-Object $array1 $array2 | select -Expand InputObject
For comparing just the corresponding indexes you'll have to manually make the comparison:
function Compare-Indexes($a1, $a2) {
$minindex = [math]::Min($a1.Length, $a2.Length)
$maxindex = [math]::Max($a1.Length, $a2.Length)
for ($i = 0; $i -le $minindex; $i++) {
if ( $a1[$i] -ne $a2[$i] ) { $i }
}
for ( $i = $minindex + 1; $i -le $maxindex; $i++ ) { $i }
}
$array1 = #(1,2,3,4,5,6,7,23,44)
$array2 = #(1,1,3,4,5,7,6,23,45)
$array3 = Compare-Indexes $array1 $array2

Resources