【华为OD机试真题】30、检查是否存在满足条件的数字组合 | 机试真题+思路参考+代码解析（C语言、C++、Java、Py、JS）

---

🍂个人博客首页：鲨鱼狼臧
 
🍂专栏介绍： 2023华为OD机试真题，使用C、C++、JS、Java、Python五种语言进行解答，专栏每篇文章都包括真题，思路参考，代码分析，订阅有问题后续可与博主解答问题，欢迎大家订阅学习

---

一、题目

---

🎃题目描述

给定一个正整数数组，检查数组中是否存在满足规则的数字组合
规则：A = B + 2C

---

🎃输入输出

输入
第一行输出数组的元素个数。
接下来一行输出所有数组元素，用空格隔开
 
输出
如果存在满足要求的数，在同一行里依次输出规则里A/B/C的取值，用空格隔开。
如果不存在，输出0。

---

🎃样例1

输入
4
2 7 3 0

输出
7 3 2

说明：
7 = 3 + 2 * 2

---

二、代码与思路参考

---

🎈C语言思路

---

1、读取数组的元素个数和数组元素

2、使用三层嵌套循环遍历数组中的所有可能的组合

3、在循环中，选择一个元素作为A，另外两个元素作为B和C，分别计算B + 2C的值

4、如果计算得到的值与A相等，表示找到了满足规则的组合，输出A、B和C的值，并设置一个标记变量found为1

5、如果在所有的组合中找不到满足规则的组合，标记变量found保持为0

6、根据found的值判断是否找到了满足规则的组合，输出结果

---

🎉C代码

#include <stdio.h>

int main() {
    int n;
    scanf("%d", &n);

    int arr[n];
    for (int i = 0; i < n; i++) {
        scanf("%d", &arr[i]);
    }

    int found = 0;  // 标记是否找到满足规则的组合

    for (int i = 0; i < n; i++) {
        int A = arr[i];
        for (int j = 0; j < n; j++) {
            if (j == i) {
                continue;  // 排除同一个元素
            }

            int B = arr[j];
            for (int k = 0; k < n; k++) {
                if (k == i || k == j) {
                    continue;  // 排除已经使用过的元素
                }

                int C = arr[k];
                if (A == B + 2 * C) {
                    printf("%d %d %d\n", A, B, C);
                    found = 1;
                    break;
                }
            }

            if (found) {
                break;
            }
        }

        if (found) {
            break;
        }
    }

    if (!found) {
        printf("0\n");
    }

    return 0;
}

---

🎈C++语言思路

---

1、读取输入的数组元素个数 n

2、读取输入的数组元素，并存储在数组 arr 中

3、初始化 found 变量为 false，用于标记是否找到满足规则的组合

4、开始遍历数组元素，依次将其作为 A 的值：

a. 将当前元素值 arr[i] 赋给 A。

b. 在嵌套的循环中遍历数组元素，将其作为 B 的值：

• 如果当前元素的索引 j 等于 i，跳过本次循环（排除同一个元素）
• 将当前元素值 arr[j] 赋给 B
• 在嵌套的循环中遍历数组元素，将其作为 C 的值：
  • 如果当前元素的索引 k 等于 i 或 j，跳过本次循环（排除已经使用过的元素）
  • 将当前元素值 arr[k] 赋给 C
  • 检查是否满足规则 A = B + 2C：
    • 如果满足，输出满足规则的 A、B、C 的值，并将 found 设置为 true

c. 如果 found 为 true，说明已经找到满足规则的组合，跳出外层循环

5、如果 found 为 false，说明没有找到满足规则的组合，输出 0

6、程序结束

---

🎉C++代码

#include <iostream>
#include <vector>

int main() {
    int n;
    std::cin >> n;  // 输入数组的元素个数
    std::vector<int> arr(n);

    // 输入数组元素
    for (int i = 0; i < n; ++i) {
        std::cin >> arr[i];
    }

    bool found = false;  // 标记是否找到满足规则的组合

    // 遍历数组元素，依次将其作为A的值
    for (int i = 0; i < n; ++i) {
        int A = arr[i];

        // 遍历数组元素，将其作为B的值
        for (int j = 0; j < n; ++j) {
            if (j == i) {
                continue;  // 排除同一个元素
            }

            int B = arr[j];

            // 遍历数组元素，将其作为C的值
            for (int k = 0; k < n; ++k) {
                if (k == i || k == j) {
                    continue;  // 排除已经使用过的元素
                }

                int C = arr[k];

                // 检查是否满足规则 A = B + 2C
                if (A == B + 2 * C) {
                    std::cout << A << " " << B << " " << C << std::endl;  // 输出满足规则的A、B、C的值
                    found = true;
                    break;
                }
            }

            if (found) {
                break;
            }
        }

        if (found) {
            break;
        }
    }

    if (!found) {
        std::cout << 0 << std::endl;  // 如果没有找到满足规则的组合，输出0
    }

    return 0;
}

---

🎈Java语言思路

---

1、首先，我们需要在给定的数组中找到满足规则 A = B + 2C 的组合

2、使用嵌套的循环遍历数组元素，依次将每个元素作为 A 的值

3、对于选定的 A 值，再次使用嵌套的循环遍历数组元素，将每个元素作为 B 的值

4、对于选定的 A 和 B 值，再次使用嵌套的循环遍历数组元素，将每个元素作为 C 的值

5、在内层循环中，检查是否满足规则 A = B + 2C。如果满足规则，则输出满足规则的 A、B、C 的值，并将 found 标记设为 true。

6、在完成一轮的内层循环后，检查 found 标记是否为 true。如果是，表示已找到满足规则的组合，可以结束外层循环。

7、如果遍历完整个数组后，仍然没有找到满足规则的组合，则输出 0

---

🎉Java代码

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 输入数组的元素个数
        int n = scanner.nextInt();
        int[] arr = new int[n];

        // 输入数组元素
        for (int i = 0; i < n; i++) {
            arr[i] = scanner.nextInt();
        }

        boolean found = false; // 标记是否找到满足规则的组合

        // 遍历数组元素，依次将其作为A的值
        for (int i = 0; i < n; i++) {
            int A = arr[i];

            // 遍历数组元素，将其作为B的值
            for (int j = 0; j < n; j++) {
                if (j == i) {
                    continue; // 排除同一个元素
                }

                int B = arr[j];

                // 遍历数组元素，将其作为C的值
                for (int k = 0; k < n; k++) {
                    if (k == i || k == j) {
                        continue; // 排除已经使用过的元素
                    }

                    int C = arr[k];

                    // 检查是否满足规则 A = B + 2C
                    if (A == B + 2 * C) {
                        System.out.println(A + " " + B + " " + C); // 输出满足规则的A、B、C的值
                        found = true;
                        break;
                    }
                }

                if (found) {
                    break;
                }
            }

            if (found) {
                break;
            }
        }

        if (!found) {
            System.out.println(0); // 如果没有找到满足规则的组合，输出0
        }
    }
}

---

🎈Python语言思路

---

1、读取输入的数组长度n和数组元素

2、设置一个标记变量found，初始值为False，用于标记是否找到满足规则的组合

3、使用三层嵌套的循环遍历数组元素，找到满足规则的A、B、C的值

 外层循环遍历数组元素，将当前元素作为A的值
 中层循环遍历数组元素，将当前元素作为B的值
 内层循环遍历数组元素，将当前元素作为C的值

4、在内层循环中，检查是否满足规则 A = B + 2C

 如果满足规则，将标记变量found设为True，输出A、B、C的值，并跳出循环

5、在中层循环中，如果found为True，表示已找到满足规则的组合，跳出循环

6、在外层循环中，如果found为True，表示已找到满足规则的组合，跳出循环

7、如果found为False，表示没有找到满足规则的组合，输出0

---

🎉Python代码

n = int(input())  # 输入数组的元素个数
arr = list(map(int, input().split()))  # 输入数组元素，以空格分隔

found = False  # 标记是否找到满足规则的组合

# 遍历数组元素，依次将其作为A的值
for i in range(n):
    A = arr[i]

    # 遍历数组元素，将其作为B的值
    for j in range(n):
        if j == i:
            continue  # 排除同一个元素

        B = arr[j]

        # 遍历数组元素，将其作为C的值
        for k in range(n):
            if k == i or k == j:
                continue  # 排除已经使用过的元素

            C = arr[k]

            # 检查是否满足规则 A = B + 2C
            if A == B + 2 * C:
                print(A, B, C)  # 输出满足规则的A、B、C的值
                found = True
                break

        if found:
            break

    if found:
        break

if not found:
    print(0)  # 如果没有找到满足规则的组合，输出0

---

🎈JS语言思路

---

1. 使用readline模块创建一个readline接口对象rl，用于读取用户的输入。
2. 定义变量n和数组arr，分别用于存储输入的数组的元素个数和数组元素。
3. 通过rl.on(‘line’, callback)监听用户输入的每一行，并根据输入的行数和数组元素进行相应的处理。
4. 在回调函数中，通过判断n的值来确定是输入数组的元素个数还是输入数组元素。
5. 当n为0时，将用户输入的值转换为整数，并赋值给n，表示数组的元素个数。
6. 当n不为0时，将用户输入的值通过空格分割成数组，并将每个元素转换为数字，赋值给arr。
7. 调用findCombination函数，用于查找满足规则的组合。
8. 在findCombination函数中，定义一个变量found，用于标记是否找到满足规则的组合。
9. 使用嵌套的三重循环遍历数组元素，依次将其作为A、B、C的值。
10. 检查是否满足规则 A = B + 2C，如果满足则输出A、B、C的值，并将found标记设为true。
11. 如果找到满足规则的组合，则跳出循环。
12. 如果未找到满足规则的组合，则输出0。
13. 当用户输入完毕后，关闭readline接口。

---

🎉JS代码

const readline = require('readline');

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

let n = 0;
let arr = [];

rl.on('line', (line) => {
  if (n === 0) {
    n = parseInt(line);  // 输入数组的元素个数
  } else {
    arr = line.split(' ').map(Number);  // 输入数组元素
    findCombination();  // 调用函数查找满足规则的组合
  }
});

function findCombination() {
  let found = false;  // 标记是否找到满足规则的组合

  // 遍历数组元素，依次将其作为A的值
  for (let i = 0; i < n; i++) {
    const A = arr[i];

    // 遍历数组元素，将其作为B的值
    for (let j = 0; j < n; j++) {
      if (j === i) {
        continue;  // 排除同一个元素
      }

      const B = arr[j];

      // 遍历数组元素，将其作为C的值
      for (let k = 0; k < n; k++) {
        if (k === i || k === j) {
          continue;  // 排除已经使用过的元素
        }

        const C = arr[k];

        // 检查是否满足规则 A = B + 2C
        if (A === B + 2 * C) {
          console.log(A, B, C);  // 输出满足规则的A、B、C的值
          found = true;
          break;
        }
      }

      if (found) {
        break;
      }
    }

    if (found) {
      break;
    }
  }

  if (!found) {
    console.log(0);  // 如果没有找到满足规则的组合，输出0
  }
}

---

作者：鲨鱼狼臧