如何在 C# 中將兩個不同大小的 arrays 相乘

Question

我正在嘗試做作業，但我正在嘗試的方法不起作用。

任務是基本上將 2 個不同大小的 arrays 相乘（並將所有三個放在一個消息框中，所以如果你也能幫助我，那就太好了）

問題是我得到了“溢出”數量的值，應該只有 10，但我得到了 28

我目前擁有的代碼是

double[] array1 = new Double[10] { 0, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
double[] array2 = new Double[5] { 0, 1, 2, 3, 4 };
double[] array3 = new double[10];
int hold = 1;
int counter = 0;
foreach (int c in array1)
{
    foreach(int k in array2)
    {
        if (counter <= k)
        {
            array3[c] = (array1[c] * array2[c]);//edit3: array2 was wirtten with  c when copied th outcome different but still not rigth with k
        }
        else
        {
            array3[c] = (array1[c] * hold);
        }
    }

    foreach (int j in array3)
    {
        Console.WriteLine(array3[c]);
    }
}

出來的樣子

0
0
0
0
0
0
0
0
0
0
6
6
6
6
6
6
6
6
6
6
12
12
12
12
12
12
12
12
12
12
20
20
20
20
20
20
20
20
20
20

它應該看起來像

0
2
6
12
20
6
7
8
9
10

我已經准備好檢查stackoverflow，所以請不要將我鏈接到另一個問題，或者如果你確實發表評論說我需要看什么。

編輯：array3 有 j 只給出十個 0

編輯2：調試器告訴我我已經知道我正在制作太多值，問題是如何解決這個問題，並且只制作 10 個值

Answer 1

您的代碼中有很多錯誤。 你只需要一個循環：

double[] array1 = new Double[10] { 0, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
double[] array2 = new Double[5] { 0, 1, 2, 3, 4 };
double[] array3 = new double[10];
int hold = 1;
int counter = 0;
for (int i = 0; i < array1.Length; i++)
{
        if (i < array2.Length)
        {
            array3[i] = array1[i] * array2[i];
        }
        else
        {
            array3[i] = (array1[i] * hold);
        }
}

foreach (int j in array3)
    {
        Console.WriteLine(j);
    }

Answer 2

由於您必須編寫一些可以將具有（可能）不同長度的兩個 arrays 相乘的東西，因此您可以從最短的數組中確定最長的數組開始，然后迭代最短的數組並將剩余的數組連接到結果數組（因為在您的示例中保持 1），您可以通過以下方式執行此操作：

static IEnumerable<double> Multiply( double[] left, double[] right ) {
  if ( left == null ) {
    throw new ArgumentNullException( nameof(left));
  }
  if ( right == null ){
    throw new ArgumentNullException( nameof(right));
  }

  var largest = left.Length > right.Length ? left : right;
  var smallest = left.Length > right.Length ? right : left;
  return smallest.Select( ( value, idx ) => value * largest[idx] )
    .Concat( largest.Skip( largest.Length - smallest.Length ) );
}

這會給你一個IEnumerable<double>結果作為 function 的一部分，然后你可以這樣使用它：

public static void Main( string[] args ) {
  var array1 = new double[10] { 0, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
  var array2 = new double[5] { 0, 1, 2, 3, 4 };

  var multiplication = Multiply( array1, array2 );
  foreach ( var item in multiplication ) {
    Console.WriteLine( item );
  }

  Console.ReadLine();
}

現在，在查看您的原始代碼時，讓我們檢查您的版本中存在問題的一些部分

double[] array3 = new double[10];

將array3聲明為固定大小會使您的代碼很容易受到攻擊，即如果array2或array1的長度發生變化，結果大小也會發生變化？ 在我的示例中，in 更具動態性，因為它取決於兩者中最大的數組。

int counter = 0;
// ...
if (counter <= k)

您將計數器定義為 null，但它在共享代碼中永遠不會增加，因為您的代碼應該在到達array2[c]時崩潰，其中c的值大於array2中的最大索引，這有點解釋了為什么只到20

foreach (int c in array1)
{
    foreach(int k in array2)

foreach將在每次迭代時將變量c和k分別設置為array1和array2的下一個值，但是在您的代碼中，您更多地將其用作索引器，因此您應該使用它。 此外，您正在迭代一個double[]並將變量定義為int ，這可能會產生非常混亂的結果，因此您會更容易使用

for (var c = 0; c < array1.Length; c++) 
{
  for (var k = 0; k < array2.Length; k++)
  {

現在您可以將它們用作索引。

最后一個是你在第一個foreach循環中使用foreach循環array3 （從而重復你的迭代），同時使用c作為你的數組的索引，而它應該是j變量。

現在，如果您解決所有這些問題，您會得到類似於 Melchia 的答案，但這也是一個脆弱的答案，例如，如果您切換array1和array2 ，您的代碼將不再提供預期的 output