等于其互异真因子之和的正整数称为完数。输入一个正整数，如果它是完数，则输出真因子和式。否则，输出“NO”。

#include <iostream>
#include <vector>
using namespace std;

void perfectNum(int n){
    int sum = 1;
    vector<int> factors;

    for(int i = 2; i<= n/2; i++){
        if(n%i == 0){
            sum += i;
            factors.push_back(i);
        }
    }

    if(sum == n){
        cout<<"真因子和式为：1";
        for(int i = 0; i < factors.size(); i++)
            cout<<" + "<< factors[i];
        cout<<" = "<<n<<endl;
    }
    else
        cout<<"NO"<<endl;

}

int main(){
    int n;
    cin>>n;
    perfectNum(n);
    return 0;
}

#include <iostream>
using namespace std;

int main() {
    int n, sum;
    cin >> n;
    sum = 1;    // 计算真因子和，初始值为1
    for (int i = 2; i <= n / 2; i++) {   // 从2开始枚举真因子
        if (n % i == 0) {
            sum += i;
        }
    }
    if (sum == n) {
        cout << sum << endl;
    } else {
        cout << "NO" << endl;
    }
    return 0;
}

你可以参考下这个问题的回答, 看看是否对你有帮助, 链接: https://ask.csdn.net/questions/7603927
我还给你找了一篇非常好的博客，你可以看看是否有帮助，链接：【初级】数据结构学习——输入一个整型数，判断是否是对称数，如果是，输出yes，否则输出no
除此之外, 这篇博客: 判断一个整数是否为一连串的正整数之和中的 判断一个整数是否为一连串的正整数之和 部分也许能够解决你的问题, 你可以仔细阅读以下内容或跳转源博客中阅读:

判断一个整数是否为一连串的整数之和：如，15=1+2+3+4+5；15=4+5+6；15=7+8
思路：等差数列之和Sn = (a1+an)n/2; an = a1 + n - 1; Sn=(2a1+n-1)*n/2; a1=Sn/2 + (1-n)/2; 判断a1是否为整数即可

判断代码

public class ConsistentSum
{
    public static void main(String[] args)
    {
        Scanner scanner = new Scanner(System.in);
        int input = scanner.nextInt();
        boolean flag = false;

        for (int i = 2; i < input / 2 + 1; i++)
        {
            double init = (double) input / i +  0.5 - (double) i / 2;

            if ((int) init == init && init > 0)  
            {
                flag = true;
                break;
            }
        }
        if (flag)
        {
            System.out.println("yes");
        }
        else
        {
            System.out.println("no");
        }

    }
}

输出该连续正整数

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;

public class ConsistentSumOut
{
    public static void main(String[] args)
    {
        Scanner scanner = new Scanner(System.in);
        int input = scanner.nextInt();
        for (int[] res: consistNums(input))
        {
            System.out.println(Arrays.toString(res));
        }
    }

    /**
     * 根据输入的正整数，输出所有连续的正整数
     * @param input 输入
     * @return 所有连续的正整数数组
     */
    private static int[][] consistNums(int input)
    {
        List<Integer> list = consistCounts(input);
        int[][] res = new int[list.size()][];
        for (int i = 0; i < list.size(); i++)
        {
            res[i] = medianArray(list.get(i), input);
        }
        return res;
    }

    /**
     * 根据输入的正整数，以及它可由多少个连续正整数之和组成，输出该连续的正整数
     * @param nums 给定的正整数可有nums个连续的正整数构成
     * @param input 输入的正整数
     * @return 连续的正整数数组
     */
    private static int[] medianArray(int nums, int input)
    {
        int[] res = new int[nums];
        double first = (double) input / nums + 0.5 - (double) (nums / 2);
        for (int i = 0; i < nums; i++)
        {
            res[i] = (int) first + i;
        }
        return res;
    }

    /**
     * 根据输入的正整数判断有多少个连续的正整数之和可以组成该正整数，如15=1+2+3+4+5；15=7+8；15=4+5+6，则输出为5,2,3
     * @param input 输入值
     * @return 输出连续正整数个数列表
     */
    private static List<Integer> consistCounts(int input)
    {
        List<Integer> res = new ArrayList<>();

        for (int i = 2; i < input / 2 + 1; i++)
        {
            double init = (double) input / i +  0.5 - (double) i / 2;

            if ((int) init == init && init > 0) // init > 0 条件是为了保证正整数之和，否则会存在负数的情况
            {
                res.add(i);
            }
        }
        return res;
    }
}

以下回答由chatgpt基于相关博客总结生成:
问题解答：
```
# 完数计算
def perfect_number(num):
    factors = []
    for i in range(1, num):
        if num % i == 0:
            factors.append(i)
    if sum(factors) == num:
        return factors
    else:
        return "NO"


# 测试
print(perfect_number(6))    # [1, 2, 3]
print(perfect_number(28))   # [1, 2, 4, 7, 14]
print(perfect_number(12))   # NO
```
解释：
定义一个 perfect_number() 函数，传入一个正整数 num。首先定义一个空列表 factors，用来存储真因子。然后从 1 循环到 num-1，判断每个数是否是 num 的因数，如果是，则加入 factors 列表中。如果 factors 列表中所有数的和等于 num，则说明 num 是完数，返回 factors 列表作为真因子和式；否则，返回字符串 "NO"。
测试了几个样例，输出了结果。