How to add same keys with different values to a hashtable in powershell?

If you want to add multiple values to the same key, you need to test for whether the key is already present and act accordingly:

$keys = 1,2,3,1
$value = 'a value'
$hashtable = @{}

foreach($key in $keys){
  if(-not $hashtable.ContainsKey($key)){
    # First time we see this key, let's make sure the value is a resizable array
    $hashtable[$key] = @()
  }

  # Now we can safely add values regardless of whether the key already exists
  $hashtable[$key] += $value
}

To complement the answer from @Matthias:
You can't have duplicate keys in a hash table. This is by design. Hash tables contain a list of unique keys based on a binary search algorithm where each key is linked to a specific object (value).

There are two workarounds:

1. add an array of values to a specific hash table key:

$Keys = 1,2,2,3
$Values = 'a'..'d'
$HashTable = @{}
$i = 0
foreach($key in $Keys){ [array]$HashTable[$Key] += $Values[$i++] }

Iterating
The disadvantage is that you lose the order of the items (regardless if you use an ordered dictionary simply because some values share a single key).

Foreach ($Key in $Hashtable.Keys) {
    Foreach ($Value in @($Hashtable[$Key])) {
        Write-Host $Key '=' $Value
    }
}

3 = d
2 = b
2 = c
1 = a

Searching
The advantage is that the items are binary indexed and therefor quickly found.

$SearchKey = 2
Foreach ($Value in @($Hashtable[$SearchKey])) {
    Write-Host $SearchKey '=' $Value
}

2 = b
2 = c

2. or you might create a list (array) of hash tables (Key Value Pairs)

$Keys = 1,2,2,3
$Values = 'a'..'d'
$i = 0
$KeyValuePairs = foreach($key in $keys){ @{ $Key = $Values[$i++] } }

Iterating
The advantage is that the items will stay in order.
^{(Note that you have to invoke the GetEnumerator() method twice)}

$KeyValuePairs.GetEnumerator().GetEnumerator() | Foreach-Object {
    Write-Host $_.Key '=' $_.Value
}

1 = a
2 = b
2 = c
3 = d

Searching
The disadvantage is that searching for the items is slower and little more comprehensive.

$SearchKey = 2
$KeyValuePairs.GetEnumerator().GetEnumerator() | 
    Where-Object Key -eq $SearchKey | Foreach-Object {
    Write-Host $_.Key '=' $_.Value
}

2 = b
2 = c

I am doing this in a separate answer as your new redefined objective more specific than the initial question appeared. Instead, each response should be assigned to a the concerned podnumber.

Script:

$podnumbers = @(1,3,1)
$Inputs = 1,2,4,6,3
$c = 0
$podarray = foreach ($pd in $podnumbers) {
    $podinfo = @{}
    for($i=0; $i -lt $pd; $i = $i+1) {
        # $pod = Read-Host -Prompt "Assign the pod numbers for",$esxarray[$buffer]
        [array]$podinfo[$pd] += $Inputs[$c++]
    }
    $podinfo
}
$podarray

Output:

Name                           Value
----                           -----
1                              {1}
3                              {2, 4, 6}
1                              {3}

There's a simpler and faster way to do this: an array of hashtables. For this, I'll be using an 'ArrayList', which is a type of array that is not a fixed size.

ArrayLists keep PowerShell from having to recreate an array every time you want to add a new item, which is great for foreach operations.

I'm going to go ahead and just present a simple example instead of integrating it into your code. Given the age of this question, it's doubtful you still need it, so this is more for everyone else.

EXAMPLE CODE

# Make sure this is initialized outside BEFORE the foreach loop:
$arr = New-Object Collections.ArrayList
#OR
$arr = [Collections.ArrayList]::new()

# Normally the 'Add' method for ArrayList outputs the updated count,
# setting it to the $null variable prevents that.
$null = $arr.Add( @{foo='bar'} )
$null = $arr.Add( @{foo='test'} )

As for iterating over the resulting array, here are a few good ways of doing so:

PER-ITEM ITERATION

$arr.ForEach({$_.GetEnumerator()}).ForEach({
  "Key: " + $ht.Key; "Value: " + $ht.Value })

#OR

foreach ($ht in $arr) {
  "Key: " + $ht.Keys; "Value: " + $ht.Values }

output:

Key: foo
Value: bar
Key: foo
Value: test

PER-KEY ITERATION

foreach ($k in ($arr.Keys | Get-Unique)) {
  "Key: $k"; "Value(s): " + $arr.$k }

output:

Key: foo
Value(s): bar test

I'm deliberately avoiding using ForEach-Object in these examples due to its performance issues in every version of PowerShell (7.2.1 is the current version as of writing). You can read more about that here.