如何编写函数识别矩阵奇数位置并提取对应元素？

嘿，这个问题我来给你拆解清楚！首先得明确咱们说的「奇数位置」——你举的例子是(1,1)、(1,3)，也就是行号和列号都从1开始计数的奇数位置，对应编程里常用的0索引体系的话，就是行索引和列索引都是偶数的位置（因为1=0+1，3=2+1）。

咱们可以写两种函数：一种判断单个坐标是否为奇数位置，另一种遍历矩阵标记所有奇数位置。

1. 判断单个位置是否为奇数位置 #

这个函数支持两种索引体系（从1开始或从0开始），返回布尔值告诉你是否符合条件：

def is_odd_position(row, col, start_index=1):
    # 默认按行/列从1开始计数，判断是否为奇数
    if start_index == 1:
        return row % 2 == 1 and col % 2 == 1
    # 如果是编程常用的0索引，判断是否为偶数索引
    else:
        return row % 2 == 0 and col % 2 == 0

比如调用is_odd_position(1,1)会返回True，调用is_odd_position(0,0, start_index=0)也会返回True，完全匹配咱们的需求。

2. 遍历矩阵标记所有奇数位置 #

如果需要找出整个矩阵里所有的奇数位置坐标，可以用这个函数：

def find_all_odd_positions(matrix):
    positions = []
    # i是0索引，对应实际行号i+1；j同理对应实际列号j+1
    for i in range(len(matrix)):
        for j in range(len(matrix[i])):
            if (i+1) % 2 == 1 and (j+1) % 2 == 1:
                # 这里存储从1开始的坐标，换成(i,j)就是0索引坐标
                positions.append((i+1, j+1))
    return positions

拿5×8矩阵测试的话，会返回[(1,1), (1,3), (1,5), (1,7), (3,1), ..., (5,7)]这样的坐标列表。

接下来直接实现提取逻辑，这里用Python举例，思路在JavaScript、Java等语言里完全通用：

1. 先构造一个5×8的示例矩阵 #

方便咱们测试效果：

# 构造5×8矩阵，元素格式为「行号*10 + 列号」（行、列从1开始）
matrix = [[i*10 + j for j in range(1, 9)] for i in range(1, 6)]

这个矩阵的第一行是[11,12,13,14,15,16,17,18]，第二行是[21,22,...28]，以此类推。

2. 编写提取函数 #

这个函数支持两种返回形式：一维列表（所有元素按顺序排列），或者保留原矩阵的行结构（只保留奇数行的奇数列）：

def extract_odd_position_elements(matrix, keep_structure=False):
    if keep_structure:
        # 保持原矩阵的行结构，只留奇数行的奇数列
        result = []
        for i in range(len(matrix)):
            if (i+1) % 2 == 1:  # 只处理奇数行
                row = matrix[i]
                odd_cols = [row[j] for j in range(len(row)) if (j+1) % 2 == 1]
                result.append(odd_cols)
        return result
    else:
        # 返回一维列表，所有奇数位置元素按顺序排列
        return [
            matrix[i][j]
            for i in range(len(matrix))
            for j in range(len(matrix[i]))
            if (i+1) % 2 == 1 and (j+1) % 2 == 1
        ]

3. 测试函数效果 #

调用函数看看结果：

# 提取为一维列表
flat_result = extract_odd_position_elements(matrix)
print(flat_result)
# 输出: [11, 13, 15, 17, 31, 33, 35, 37, 51, 53, 55, 57]

# 保持行结构提取
structured_result = extract_odd_position_elements(matrix, keep_structure=True)
print(structured_result)
# 输出: [[11,13,15,17], [31,33,35,37], [51,53,55,57]]

如果用JavaScript实现，思路完全一致，给个快速示例：

// 构造5×8矩阵
const matrix = Array.from({length:5}, (_,i) => 
  Array.from({length:8}, (_,j) => (i+1)*10 + (j+1))
);

function extractOddPositionElements(matrix, keepStructure = false) {
  if (keepStructure) {
    return matrix.filter((_, i) => (i+1) % 2 === 1)
                 .map(row => row.filter((_, j) => (j+1) % 2 === 1));
  } else {
    return matrix.flatMap((row, i) => 
      row.filter((_, j) => (i+1) % 2 === 1 && (j+1) % 2 === 1)
    );
  }
}

console.log(extractOddPositionElements(matrix));
// 输出一维结果：[11,13,15,17,31,33,35,37,51,53,55,57]

核心逻辑其实很简单：先明确「奇数位置」的定义，然后遍历矩阵的每个元素，判断其行号和列号是否都为奇数（从1开始计数），最后收集符合条件的元素即可。

内容的提问来源于stack exchange，提问作者Joe-izy