编程计算2×3阶矩阵a和3×2阶矩阵b之积c。

### 回答1：
可以使用Python语言来编程计算矩阵乘积c。

代码如下：

import numpy as np

# 定义2x3矩阵a和3x2矩阵b
a = np.array([[1, 2, 3], [4, 5, 6]])
b = np.array([[1, 2], [3, 4], [5, 6]])

# 计算矩阵乘积c
c = np.dot(a, b)

# 输出结果
print(c)

输出结果为：

[[22 28]
 [49 64]]

其中，np.dot()函数用于计算矩阵乘积。

### 回答2：
要编程计算矩阵的乘积，需要使用循环和数组的知识。

假设矩阵 a 是一个 2×3 阶矩阵，矩阵 b 是一个 3×2 阶矩阵，那么它们的乘积 c 就是一个 2×2 阶矩阵。

首先，我们可以创建一个二维数组来存储矩阵 a、b 和 c。

int[][] a = {{1, 2, 3}, {4, 5, 6}};   // 2x3 matrix
int[][] b = {{1, 2}, {3, 4}, {5, 6}}; // 3x2 matrix
int[][] c = new int[2][2];            // 2x2 matrix

接下来，我们需要使用两个嵌套的循环来计算矩阵乘积。第一个循环用来遍历矩阵 a 的行，第二个循环用来遍历矩阵 b 的列。

for (int i = 0; i < 2; i++) { // rows of a
    for (int j = 0; j < 2; j++) { // columns of b
        // Compute dot product of a row and b column
        int sum = 0;
        for (int k = 0; k < 3; k++) { // columns of a, rows of b
            sum += a[i][k] * b[k][j];
        }
        c[i][j] = sum;
    }
}

在每次循环中，我们使用另一个循环来计算 a 的一行和 b 的一列的点积，并将结果存储在矩阵 c 中。

最后，我们可以输出矩阵 c 的值，以验证计算结果是否正确。

for (int i = 0; i < 2; i++) { // rows of c
    for (int j = 0; j < 2; j++) { // columns of c
        System.out.print(c[i][j] + " ");
    }
    System.out.println();
}

整个程序的代码如下：

int[][] a = {{1, 2, 3}, {4, 5, 6}};   // 2x3 matrix
int[][] b = {{1, 2}, {3, 4}, {5, 6}}; // 3x2 matrix
int[][] c = new int[2][2];            // 2x2 matrix

for (int i = 0; i < 2; i++) { // rows of a
    for (int j = 0; j < 2; j++) { // columns of b
        // Compute dot product of a row and b column
        int sum = 0;
        for (int k = 0; k < 3; k++) { // columns of a, rows of b
            sum += a[i][k] * b[k][j];
        }
        c[i][j] = sum;
    }
}

for (int i = 0; i < 2; i++) { // rows of c
    for (int j = 0; j < 2; j++) { // columns of c
        System.out.print(c[i][j] + " ");
    }
    System.out.println();
}

运行程序后，输出的结果为：

22 28 
49 64 

这说明我们计算的矩阵乘积是正确的。

### 回答3：
在编程语言中实现矩阵乘法需要运用到二维数组以及循环等基本语法。下面以Python语言为例，简单介绍如何计算2×3阶矩阵a和3×2阶矩阵b之积c。

首先，需要定义矩阵a和矩阵b的值，这里以随机数生成为例，如下：

import random
 
# 生成2×3阶矩阵a
a = [[random.randint(0, 10) for j in range(3)] for i in range(2)]
print("矩阵a：", a)

# 生成3×2阶矩阵b
b = [[random.randint(0, 10) for j in range(2)] for i in range(3)]
print("矩阵b：", b)

其中，range(2)表示生成长度为2的数列，而range(3)则表示生成长度为3的数列。矩阵a的行数为2，列数为3，矩阵b的行数为3，列数为2。

接下来，需要定义积矩阵c，并进行矩阵乘法运算。矩阵乘法的规则为：积矩阵的行数等于左矩阵的行数，列数等于右矩阵的列数，而且左矩阵的列数必须等于右矩阵的行数。

# 定义3×3阶的积矩阵c
c = [[0]*2 for i in range(3)]
print("积矩阵c：", c)

# 计算矩阵a和矩阵b的积
for i in range(2): # 遍历a的行
    for j in range(2): # 遍历b的列
        for k in range(3): # 遍历a的列或b的行
            c[i][j] += a[i][k] * b[k][j]
print("矩阵a和矩阵b的积c：", c)

这里定义了一个3×2阶的积矩阵c，初始值全部为0。接着，通过三重循环计算每个元素的值，其中i代表矩阵a的行数（也就是积矩阵c的行数），j代表矩阵b的列数（也就是积矩阵c的列数），k代表矩阵a的列数或者矩阵b的行数。

最后输出计算得到的积矩阵c。

总结：通过二维数组和循环等基本语法，可以在编程语言中实现矩阵乘法运算。矩阵乘法的规则是积矩阵的行数等于左矩阵的行数，列数等于右矩阵的列数，而且左矩阵的列数必须等于右矩阵的行数。