N = int(input())
for n in range(2,N+1):
    div = 0; 

    for i in range(1,n+1): #약수의 합
        if n % i  == 0:
            div+=i

    if div - n - 1 != 0:
        k = (n-1) / (div - n - 1)
        if int(k) == k:
            print('({},{})'.format(n,int(k)))
    else:
        continue

Python 3.4.2 범위 입력받아 초완전수 튜플 리스트로 출력하기 한줄로 작성하고 싶었으나 실행속도를 올리기위해서 4줄로

약수합찾기의 실행속도를 올릴려면 max sqrt(num) 로 하면 반복회수 반으로 줄일 수 있고, range(2,ran+1)로 약수가 있는 2부터 시작하면 range(0), range(1) 을 안할 수 있으므로 약간 더 줄이고

from functools import reduce
from math import sqrt

def factors_sum_wo_1_self(num): # 1과 자기자신을 제외한 약수의 합 함수
    return sum(reduce(list.__add__, ([i, num // i] for i in range(1, int(sqrt(num))+1) if num % i == 0))[2:])

ran = int(input("Enter range: ")) # 범위입력
print([(n, int((n-1)/factors_sum_wo_1_self(n))) for n in range(2, ran+1) if factors_sum_wo_1_self(n) != 0 and (n-1)%factors_sum_wo_1_self(n) == 0]) # 결과는 튜플 리스트

실행결과

>>> ran = int(input("Enter range: "))
Enter range: 1000
>>> print([(n, int((n-1)/factors_sum_wo_1_self(n)))for n in range(2, ran+1) if factors_sum_wo_1_self(n) != 0 and (n-1)%factors_sum_wo_1_self(n) == 0])
[(6, 1), (21, 2), (28, 1), (301, 6), (325, 3), (496, 1), (697, 12)]

Ruby

fsum = ->n { (1..n).select {|f| n%f == 0 }.sum.to_f }
find_k = ->n { dn=fsum[n]-n-1; k=(n-1)/dn if dn > 0; [n,k.to_i] if k==k.to_i }
k_pnums = -> { puts (1..gets.to_i).map(&find_k).compact.map(&:to_s).join(" ") }

Test

$stdin = StringIO.new("1000\n")
result = "[6, 1] [21, 2] [28, 1] [301, 6] [325, 3] [496, 1] [697, 12]\n"
expect{ k_pnums.call }.to output(result).to_stdout

k(f(n) - n - 1)은 약수의 합에서 1과 자기자신 제외하는거니까 애초부터 제외하고 합을 구하도록했습니다.

#include <stdio.h>

int f(int n) //약수의 합
{
    int i = 0;
    int sum = 0;

    for(i = 2; i < n; i++)
    {
        if(n % i == 0)
        {
            sum += i;
        }
    }
    return sum;
}

void isCompleteNumber(int N)
{
    int calcN = 0;
    int k = 1;
    int i = 0;
    int fn = 0;

    for(i = 2; i <= N; i++)
    {
        fn = f(i);
        for(k = 1; k <= N; k++)
        {
            calcN = 1 + (k * fn);
            if(calcN == i)
            {
                printf("(%d, %d) ", i, k);
            }
        }
    }
}

int main(int argc, char *argv[])
{
    isCompleteNumber(1000);
    return 0;
}

매트랩으로 시도해보았습니다. 초보라서 간결하게는 안되는군요;; 정리하면 k = (n-1)/(1과 자기자신을 제외한 약수의 합)으로 표현되므로 i, k를 구하고 이때 k가 자연수인 경우만 출력하도록 하였습니다.

N = input('Input number :');
for i = 2 : N              % (1, 0)을 피하기 위해 2부터 시작
    tmp = 0;
    for j = 1 : i
        if mod(i,j) == 0
            tmp = tmp + j;  % 약수의 합
        end
    end
    k = (i-1)/(tmp-1-i); % 약수의 합에서 1과 자기자신 제외
    if mod(k,1) == 0
        fprintf('(%d, %d) ', i, k)
    end
end

def fnat(a):
    sum=0
    for i in range(1,a+1):
        if a%i :pass
        else:
            sum=sum+i
    return sum
N=input("number=")
for i in range(2,int(N)+1):
    j=fnat(i)-i-1
    if j>0:
        if (i-1)%j: pass
        else:
            print("(",i,",",int((i-1)/j),")" , end=" ")

#include <stdio.h>

int main(void)
{
    int N,n,j,fn=0;
    double k;

    printf("자연수를 입력하시오\n");
    scanf("%d",&N);
    for(n=2;n<=N;n++)
    {
        for(j=1;j<=n;j++)
        {
            if( n % j == 0)
                fn += j;
        }
    k = (double)(n-1)/(double)(fn-n-1);
    if (k/1.00 == (int)k) 
        printf("(%d,%d)\n",n,(int)k);
    fn = 0;
    }
    return 0;
}

c언어로 작성해봤습니다.

def f(N):
    sum = 0
    for i in range(1,N+1):
        if N%i == 0:
            sum +=i
    return  sum

def A(N):
    for i in range(2,N+1):
        try:
            t = (i - 1) % (f(i) - i - 1)
        except:
            continue
        k = (i - 1) / (f(i) - i - 1)
        if t == 0:
            print('(', i, ', ', k, ')')

A(1000)

n=int(input("input:"))
for nn in range(1,n):
    fn=sum(x for x in range(1,nn+1) if nn%x==0)
    o=((nn,k) for i,k in enumerate(range(1,nn)) if nn==(1+k*(fn-nn-1)))
    for ii in o:print(ii, end="")

// C++

// 양의 약수의 합을 구함..

inline int FuncD( int nValue )
{
    int nSum    = 0;

    int nTemp   = nValue;

    while( nTemp > 0 )
    {
        if( nValue  % nTemp == 0 )
        {
            nSum    += nTemp;
        }

        --nTemp;
    }

    return nSum;
}

// k = ( n - 1 ) / ( f( n ) - n - 1 )

inline int GetK( int nValue )
{
    int nDiv = ( FuncD( nValue ) - nValue - 1 );

    if( nDiv <= 0 )
    {
        return -1;
    }

    nValue  = ( nValue - 1 ) / nDiv;

    return nValue;
}

//n = 1 + k * ( f ( n ) - n - 1 )

inline int GetN( int nValue )
{
    return ( 1 + GetK( nValue ) * ( FuncD( nValue ) - nValue - 1 ) );
}

int main()
{
    int nValue  = 0;

    cin >> nValue;

    for( int x = 0 ; x <= nValue ; ++x )
    {
        if( x == GetN( x ) )
        {
            cout << x << "," << GetK( x ) << "\n";
        }
    }

    return 0;
}

N = int(input())
print(N)

def f(n):
    sum = 0
    for k in range(1,N+1):
        if n%k == 0:
            sum = sum + k
    return sum

for i in range(3,N+1):
    if (f(i)-i-1) != 0:
        if (i-1)%(f(i) - i - 1) == 0:
            k = (i-1)/(f(i) - i - 1)
            print('(%d, %d)' % (i, k), end = ' ')

nombreHyperparfait(1000)

def nombreHyperparfait(n: Int): Unit = {
    (1 to n).foreach(i => {
        val mv = mineralWater(i) - i - 1
        if (mv > 0 && i > 1) {
            val fd = (i - 1) / mv
            val fm = (i - 1) % mv
            if (fd > 0 && fm == 0) print("(" + i + "," + fd + ")")
        }
    })
}

def mineralWater(n: Int): Int = {
    (1 to n).filter(i => n % i == 0).sum
}

static final int INPUT = 1000;

    public static void main(String argv[]) throws Exception {



        for(int i = 2; i<=1000; i++){

            int sum = sumDivisor(i);

            if(sum !=0 && (i -1) % sum == 0){

                    System.out.println("("+i+","+i/sum +")" );

            }

        }

    }


    private static int sumDivisor(int val){


        int rtnVal = 0;
        for(int i = 1; i<= val ; i++){

            if(val%i == 0){

                rtnVal+=i;
            }

        }

        return rtnVal -1 - val;

    }

#파이썬3.5.2

from math import *
from itertools import *

def primedp(p):
    dic = {}
    a = p
    for i in range(2, int(sqrt(p))+1):
        c = 0
        while a%i == 0:
            a = a//i
            c += 1
        dic[i]=c
    if a!= 1:
        dic[a] = 1
    dic = list(dic.items())
    for i in range(len(dic), 0, -1):
        if dic[i-1][1] == 0:
            del dic[i-1]
    dic = dict(dic)
    return dic

def divisors(n):
    case = primedp(n)
    def times(l):
        n=1
        for i in l:
            n *= i
        return n
    r = eval('list(map(times,product('+str([[y**k for k in range(0,case[y]+1)] for y in case.keys()])[1:-1]+')))')
    return r

do = lambda x: sum(divisors(x))

for i in range(2,int(input())+1):
    try:
        k = (i-1)/(do(i)-i-1)
        if int(k)==k:
            print((i,int(k)))
    except ZeroDivisionError:
        pass

입력:
1000

출력:
(6, 1)
(21, 2)
(28, 1)
(301, 6)
(325, 3)
(496, 1)
(697, 12)

자바입니다.

public class Hyper_Perf_Nu {
    public static void calcPerfNu(int n) {
        int tmp = 0;
        String result = "";
        int sum = 0;
        for (int i = 1; i <= n; i++)
            if (n % i == 0) {
                sum += i;
            }

        for (int i = 1; i <= n; i++) {

            if (n == 1 + i * (sum - n - 1)) {
                tmp = i;
                result = "(" + n + "," + tmp + ")";
                System.out.println(result);
            }
        }

    }

    public static void prnPerfNu(int n) {
        for (int i = 1; i <= n; i++) {
            calcPerfNu(i);
        }
    }

    public static void main(String[] args) {
        prnPerfNu(1000);
    }

}

def hyper_perfect_num(n):
    result=[]
    for i in range(1,n+1):
        for j in range(1,i):
            if j*(sum(x for x in range(1,i) if i%x==0)-1)+1==i:
                result+=[(i,j)]
    print(result)

import java.util.Scanner;

public class numer_1 {

    public static void main(String[] args) {
        **int** num = 0;
        **Divisor** divisor = new Divisor();

        System.out.print("Input : ");
        **Scanner** scan = new Scanner(System.in);
        num = scan.nextInt();

        **for**(**int** i = 2; i < num; i++){
            **divisor.calc_divisor(i);**
            **divisor.determind(i);**
        }

    }

}


public class Divisor {

    **int** sum;
    public Divisor(){
        sum = 0;
    }

    public **void calc_divisor**(**int** num){
        **for**(int i = 2; i < num; i++){
            **if**(num % i == 0)
                sum += i;
        }
    }

    public **void determind**(**int** num){
        **int** k;
        **if**(sum == 0)
            **return;**
        **if**((num - 1) % (sum) == 0){
            **k = (num - 1) / (sum);**
            System.out.print("(" + num +"," + k +")");
        }
        sum = 0;
    }
}

package coading02;
import java.lang.*;
import java.util.*;
public class Test01 {
    public static void main(String[] args) {

        Scanner robot = new Scanner(System.in);
        int num;
        System.out.print("입력 : ");
        num = robot.nextInt();

        int tmp = 0;

        for(int i = 1 ; i <= num ; i++){
            for(int j = 1 ; j < i ; j++){
                if(i%j == 0){
                    tmp+=j;
                }
            }
            //System.out.println("tmp = "+tmp);
            for(int k = 1 ; k < i ; k++){
                if(k*(tmp-1) == (i-1)){
                    System.out.println("("+i+","+k+")");
                    break;
                }
            }
            tmp = 0;
        }
        System.out.println("종료");
    }
}

var arr = [];
var input = prompt("input: ")

for(var i=1; i<=input; i++){
  var sum = 0;
  for(var divisor=1; divisor<=i; divisor++){
    if(i%divisor == 0){
      sum += divisor;
    }
  }
  for(var k=1; k<=i; k++){
    if(i == (1+k*(sum-i-1))){
      arr.push({"n":i, "k":k})
    }
  }
}
console.log(arr)

MATLAB으로 짜보았습니다.

clear all
close all
clc

N=input('입력 : ');
for n=1:N

    % reset the value
    f_n__minus__n_1=0; % f(n)-n-1

    % accumulate the prime numbers
    for p=2:floor(n/2)
        if mod(n,p)==0
            f_n__minus__n_1=f_n__minus__n_1+p;
        end
    end

    % If n is a prime number, this number can be zero. As such, it should skip the loop.
    if f_n__minus__n_1==0 
        continue
    end

    % calculate k
    k=(n-1)/f_n__minus__n_1;

    % maybe... we are interested in only natural number k
    if floor(k)~=k
        continue
    end

    % display
    disp(['(' num2str(n) ',' num2str(k) ')']);
end

// Swift 3.0
let inputNumber = 1000

func main() {
    for i in 1...inputNumber {
        let divisor = divisorSumNum(num: Int(i))
        printPerfectNumber(n: Double(i), divisor: divisor)
    }
}

func divisorSumNum(num: Int) -> Double {
    var sum = 0
    let endNum = sqrt(Double(num))

    for i in 1...Int(endNum) {
        if (num % i) == 0{
            var tempNum = 0
            sum += i

            if endNum != Double(i) {
                tempNum = num / i
                sum += tempNum
            }
        }
    }   
    return Double(sum)
}

func printPerfectNumber(n : Double, divisor: Double) {
    if (divisor - n - 1) > 0 {
        let k = (n - 1) / (divisor - n - 1)
        if k == floor(k) {
            print(Int(n), Int(k))
        }
    }
}

main()

다듬고 다듬었지만... 이렇습니다.

// 양의 약수의 합 출력 함수.
int myPrintFn(int num)
{
    int sum = 0;
    for (int i = 1; i < num+1; i++)
    {
        if (num%i == 0)
        {
            sum += i;
        }
    }
    return sum;
}


int main(void)
{
    int scannum = 0;
    printf("입력하는 값 이하의 초완전수를 구합니다. : ");
    scanf("%d", &scannum);

    for (int i = 2; i < scannum+1; i++)         //1은 해당x.
    {
        int result = myPrintFn(i) - i - 1;      //for문 내 반복계산을 피하기위함.
        for (int j = 0; j <= i; j++)
        {
            if ((double)j == (i - 1) / (double)result)
            {
                printf("(%d,%d)", i,j);
            }
        }
    }
    printf("\n");
    return 0;
}

c입니다. 조언부탁드립니다.

_ = [*(((lambda a: (print(i, (i-1)//a) if a and (i-1)%a == 0 else 0))(sum(j for j in range(1, i+1) if i%j == 0)-i-1)) for i in range(2, int(input('>>>'))+1))]

_ =는 없어도 무관. 콘솔 실행 시는 사용 권장.

파이썬 3.6.0 64

n = 1 + k(f(n)-n-1)
n = 1 + ka
n-1 = ka
k = (n-1)/a

으로 정리될 수 있기 때문에 루프를 한번 돌면서 계산식에 맞아 떨어지는 것만 가져옵니다.

def find_k_supernum(max_n):
    supernums = []
    for n in range(1, max_n+1):
        divisors_sum = sum([x for x in range(1,n+1) if n % x == 0])
        a = (n - 1)
        b = (divisors_sum - n - 1)
        if b > 0 and a % b == 0:
            supernums.append('(%d, %d)' % (n,  a/b))
    return ' '.join(supernums)
print(find_k_supernum(1000))

package training;

import java.util.Scanner;

/**
 * 자연수 n이 있다. f(n)=(n의 양의 약수의 합)이라고고 하자. 자연수 n이 어떤 k에 대하여 등식 n = 1 + k(f(n)-n-1)을 만족했을 때, 
 * n을 k-초완전수라고 부른다. n이 완전수라는 것은 n이 1-초완전수라는 것이라는 명제와 동치이다. 예를 들어, 21은 2-초완전수이고 301은 6-초완전수이다. 
 * 자연수 N을 입력받고 N 이하의 k-초완전수와 그때의 k를 순서쌍으로 출력하는 프로그램을 작성하라.
 * <예시> 1. 입력 1000 2. 출력 (6,1) (21,2) (28,1) (301,6) (325,3) (496,1) (697,12)
 */
public class ChoPerfectNum {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sc = new Scanner(System.in);
        System.out.print("Please insert Number? ");
        int iNum = sc.nextInt();

        for(int i=1; i<=iNum; i++) {
            for(int j=1; j<i ; j++){
                if(i==(1+j*(getPerfectNum(i)-i-1))){
                    System.out.println("ChoPerfect Number ========> (" + i + ","+j+")");
                }
            }
        }
    }

    // f(n)=(n의 양의 약수의 합) 처리
    public static int getPerfectNum(int iNum) {
        int iSum = 0;
        for(int i=1;i<iNum+1;i++){
            if(iNum % i == 0){
                iSum = iSum + i;
            }
        }
        return iSum;
    }
}

파이썬 3입니다

print('N이하의 k-초완전수를 출력합니다.')
int_N = input("N을 입력하세요 : ")

string = ''

def divisor_sum(x):
    dsum = 0
    for i in range(1, x+1):
        if x%i == 0:
            dsum += i
    return dsum

for i in range(1, int(int_N) +1):
    for k in range(1, i):
        if i == 1 + k * (divisor_sum(i) - i - 1):
            string += str((i,k)) + ''

print(string)

아래와 같이 평이한 수준에서 풀었습니다. 파이썬 3.6.1입니다.

def f(n):
    s, k, l = 0, 2, n ** 0.5
    while k < l:
        if n % k is 0:
            s += k + (n // k)
        k += 1
    if k * k == n:
        s += k
    return s

def do():
    n = int(input())
    result = []
    if n < 6:
        return result
    for i in range(6, n+1):
        k, j = 1, f(i)
        if j > 0:
            while i > j * k:
                if j * k + 1 == i:
                    result.append((i, k))
                    break
                k += 1
    return result

print(", ".join(str(x) for x in do()))

import sys sys.path.append("C:/") import time import faliquot

def eperfect(N):

start_time = time.time()
List2 = []
temp = 0
for n in range(N):
    n = n + 1
    if (n % 2) == 0 and n > 2:
        x = n / 2
        temp = sum(faliquot.aliquot(x,2))
        if (temp - n - 1) != 0 : 
            k = (n-1) / (temp-n-1) 
        else:
            continue
        if (k % 1) == 0:
            List2.append((n,int(k)))

    elif (n > 3) and not(n % 2 == 0) :
        x = n / 3
        temp = sum(faliquot.aliquot(x,3))
        if (temp - n - 1) != 0 : 
            k = (n-1) / (temp-n-1)
        else:
            continue
        if (k % 1) == 0:
            List2.append((n,int(k)))

end_time = time.time()          
return List2, end_time - start_time

def aliquot(n, t) :

List1 = []
temp = 0
x =int(n)
for i in range(x):

    i = i + 1
    print("i=%s" %i)
    temp = ( t*n )% i
    print("temp=%s" %temp)

    if (temp == 0):                            
        List1.append(i)
        print("i=%s" %i)
List1.append(n*t)
print(List1)            
return List1

def divisor(n):
    l = []; i = 2
    while i*i <= n:
        if n % i == 0:
            l.append(i)
            l.append(int(n/i))
        i += 1
    l = list(set(l))
    return l

def hyperperfect(n):
    l = []
    for i in range(1,n+1):
        if sum(divisor(i)) != 0:
            a = sum(divisor(i))
            if (i-1) % a == 0: l.append([i,int((i-1) / a)])

    return l

hyperperfect(10000)
'''
[[6, 1],
 [21, 2],
 [28, 1],
 [301, 6],
 [325, 3],
 [496, 1],
 [697, 12],
 [1333, 18],
 [1909, 18],
 [2041, 12],
 [2133, 2],
 [3901, 30],
 [8128, 1]]
'''

def MinMul(n):
    result = []
    for i in range(1,n+1):
        if n%i == 0:
            result.append(i)

    return sum(result)


def K(n):
    k = 0
    remk = 0
    if (MinMul(n)-n-1) == 0:
        pass
    else:
        k = ((n-1) / (MinMul(n)-n-1))
        remk = ((n-1) % (MinMul(n)-n-1))

    return (k, remk)




n = int(input("input : "))
for i in range(3,n+1):
    if K(i)[1] == 0 and K(i)[0] != 0:
        print ("(%d,%d)" %(i,int(K(i)[0])))

javascript

var aliquotSum = n => Array.from(Array(n), (v, i) => i + 1)
                           .reduce((a, b) => a + (n % b === 0 ? b : 0), 0);                           

var hyperperfect = n => {
    var factor = aliquotSum(n) - n - 1;
    var k = 0;
    if (factor !== 0 && Number.isInteger(k = (n - 1) / factor)) {
        return [n, k];
    }
};

var findhp = n => Array.from(Array(n - 1), (v, i) => i + 2)
                       .map(hyperperfect)
                       .forEach(v => v && console.log(`(${v[0]}, ${v[1]})`));

findhp(1000);

def k_hyper_perfect_number(N):
    lst = []
    for n in range(3, N+1):
        factorsum = sum([x for x in range(2, n) if n % x == 0])  # 1, n 제외 약수합
        if factorsum > 0:
            k, r = divmod(n-1, factorsum)
            if r == 0:
                lst.append((n, k))

    return lst


print(k_hyper_perfect_number(1000))

def super_num(N):

    list_ans = []
    for n in range(2,N+1):
        list_a = []
        for i in range(1,n+1):
            if n%i == 0:
                list_a.append(i)
        if list_a == [1,n]:
            continue
        fn = sum(list_a)
        k = (n-1) / (fn -n-1)
        if k.is_integer() == True:
            list_ans.append([n,int(k)])
    print(list_ans)

super_num(1000)

# 약수의 합을 구하는 함수
def f(n) :

    result = 0
    for i in range(1, n + 1) :

        if n % i == 0 :
            result += i
        else :
            pass

    return result

# 완전수와 k의 쌍을 튜플로 출력하는 함수
def perfectNum(n) :

    k = 1
    while True :

        if n == 1 + k * (f(n) - n - 1) :
            return n, k

        elif k == n :
            break

        else :
            k += 1

    return None

#최종 프로그램
N = int(input())

for i in range(1, N + 1) :

    if perfectNum(i) == None :
        pass

    else :
        print(perfectNum(i), end = " ")

파이썬 3.6

def main(N):
# f(n) = t
    k,t = 0,0
    factor = []   
    for n in range(1,N+1):
        for i in range(1,n+1):
            if n%i == 0: factor.append(i)
        t = sum(factor)
        if t > n and (t-n-1) != 0: k = (n-1)/(t-n-1)
# k가 자연수인지 확인
            if k%1 == 0: print("(%d,%d)"%(n,int(k)))
        factor = []

if __name__ == "__main__":
    N = int(input("N = "))
    main(N)

*결과값

N = 1000
(6,1)
(21,2)
(28,1)
(301,6)
(325,3)
(496,1)
(697,12)

r로 풀었습니다.

pr<-function(x){
  k<-NULL
  r<-NULL
  f<-function(n){
    a<-n%/%2
    b<-1
    for(i in 2:a){
      if(n%%i==0){
        b<-c(b,i)
      }
    }
    for(j in 1:length(b)){
      b<-union(b, n/b[j])
    }
    sum(b)
  }
  for(l in 6:1000){
    if((f(l)-l-1)>0){
      if(((l-1)%%(f(l)-l-1))==0){
        k<-(l-1)/(f(l)-l-1)
        r<-paste0(r, '(',l, ',',k,')')
      }
    }
  }
  print(r)
}
pr(1000)

# 파이썬


def a_sum(i1):
    r = 0
    for m in range(1, int(i1**0.5+1)):
        if i1 % m == 0:
            r += int(m + i1 / m)
    return r


def k_p_number(i2):
    denominator = a_sum(i2)-i2-1
    if denominator:
        k = (i2-1)/denominator
        if k == int(k):
            return k


def kp_below(i3):
    for m in range(1, i3+1):
        rk = k_p_number(m)
        if rk:
            print(m, int(rk))


kp_below(1000)

import math
def sigma(n):
    result = 0
    if math.sqrt(n).is_integer():
        result += math.sqrt(n)
        for i in range(1, int(math.sqrt(n))):
            if n%i == 0:
                result += i + n/i
    else:
        for i in range(1, int(math.sqrt(n))+1):
            if n%i == 0:
                result += i + n/i
    return result

def supper(n):
    result = list()
    for i in range(2,n+1):
        if sigma(i) == i+1:
            pass
        else:
            m = (i - 1) / (sigma(i) - i - 1)
            if m.is_integer():
                result.append((i, int(m)))
    return result


print(supper(int(input())))

    static int f(int num) {
        int answer = 0;```{.java}
    static int f(int num) {
        int answer = 0;
        for(int i = 1; i<=num/2; i++){
          if(num%i==0){
            answer+=i;
          }
        }
        return answer+num;
    }

    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int t = Integer.parseInt(br.readLine()); 
        // n = 1 + k(f(n)-n-1)
        int k=1;
        for (int n=1; n<=t; n++) {
            int prev = 1+(f(n)-n-1); // 처음 값 저장
            if (prev == n)
                System.out.println(n + " " + 1);
            else {
                while(n > 1+ k*(f(n)-n-1) && 1+ k*(f(n)-n-1) > 0) { // 이 조건 안에서만 루프를 돌아야합니다
                    k++;
                    if(prev == 1+ k*(f(n)-n-1)) // 이전 거랑 똑같으면 계속 루프 돌아버림, 그래서 break;
                        break;
                    if (n == 1+ k*(f(n)-n-1))
                        System.out.println(n + " " + k);
                }
            }
            k = 1; 
        }
    }
}
자바입니다. 코드가 되게 기네요 ㅠㅠ

    for(int i = 1; i<=num/2; i++){
      if(num%i==0){
        answer+=i;
      }
    }
    return answer+num;
}

public static void main(String[] args) throws Exception {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    int t = Integer.parseInt(br.readLine()); 
    // n = 1 + k(f(n)-n-1)
    int k=1;
    for (int n=1; n<=t; n++) {
        int prev = 1+(f(n)-n-1); // 처음 값 저장
        if (prev == n)
            System.out.println(n + " " + 1);
        else {
            while(n > 1+ k*(f(n)-n-1) && 1+ k*(f(n)-n-1) > 0) { // 이 조건 안에서만 루프를 돌아야합니다
                k++;
                if(prev == 1+ k*(f(n)-n-1)) // 이전 거랑 똑같으면 계속 루프 돌아버림, 그래서 break;
                    break;
                if (n == 1+ k*(f(n)-n-1))
                    System.out.println(n + " " + k);
            }
        }
        k = 1; 
    }
}

} 자바입니다. 코드가 되게 기네요 ㅠㅠ ```

def chowanjeonsu(number): # under number

    dic = {}
    # 약수의 합을 구하자
    for x in range(1,number+1):
        lst = []
        for k in range(1,x+1):
            if x % k == 0:
                lst.append(k)
        s = sum(lst)

        for j in range(1,x+1):
            if x == 1 + j*(s - x - 1):
                dic[x] = j

    for key in dic:
        print((key,dic[key]), end = ' ')
    return ' '

파이썬으로 작성했습니다.

n=int(input('자연수 입력:'))
for num in range(1,n+1):
    f=sum( t for t in range(1,num+1) if num%t==0)
    for k in range(1,num):
        if num==1+k*(f-num-1):
            print('(%d,%d)'%(num,k))
            break

Python

N = 1000
for n in range(1, N+1):
    f_n = 0
    k = 0
    for i in range(1, n+1):
        if n % i == 0:
            f_n += i
    if f_n-n-1 != 0 and n - 1 >= f_n-n-1 and (n - 1) % (f_n-n-1) == 0:
        k = (n - 1)//(f_n-n-1)
        if k != 0:
            print(n, k)

k = lambda n: (n-1)/sum(sum({i,n//i}) for i in range(2,int(n**0.5)+1) if not n%i)
n = int(input())
for i in range(n+1):
    try:
        if k(i)%1 == 0: print(f'({i},{int(k(i))})')
    except ZeroDivisionError: pass

package practice;

import java.util.TreeSet;

public class test {
    public static void main(String[] args) {
        for (int n = 2; n < 1001; n++) {
            int a = Check(n);
            if (a > 0)
                System.out.println(n + " " + a);
        }

    }

    private static int Check(int n) {
        int a = getNs(n) - n - 1;
        if (a != 0 && (n - 1) % a == 0)
            return (n - 1) / a;
        return 0;
    }

    private static int getNs(int n) {
        TreeSet<Integer> nn = new TreeSet<>();
        int sum = 0;
        for (int i = 1; i < n / 2 + 1; i++)
            if (n % i == 0) {
                nn.add(i);
                nn.add(n / i);
            }
        for (Integer a : nn)
            sum += a;
        return sum;
    }
}

# 다른 문제를 풀면서 만든 제곱근 함수를 가져왔습니다.

def sqrt(a):
    ip = 0
    deci_len = 2

    while (ip + 1) ** 2 <= a:
        ip = ip + 1

    deci_list = list()
    i = 1
    approx = ip

    while i <= deci_len:
        deci_dyn = 0
        stck = 0.1 ** i
        while (approx + stck) ** 2 <= a:
            deci_dyn = deci_dyn + stck
            approx = approx + stck
        deci_list.append(deci_dyn)
        i = i + 1

    approx_list = ip
    for j in deci_list:
        approx_list = approx_list + j

    return approx_list

N = int(input("put number"))

def sum_f(a):
    summ = 0
    if not a == 1:
        for i in range(1, a):
            if a % i == 0:
                summ = summ + i
    return summ - 1


for i in range(1, N+1):
    R = int(sqrt(i)+4)
    for k in range(1, R):
        if i == 1 + k*sum_f(i):
            print(i, k)

저는 python을 사용하였습니다. 처음엔 다중for문에서 i 는 초완전수를, k는 그 종류를 탐색하도록 알고리즘을 짰습니다. (예를 들어,입력값이 1000일때, 1-초완전수를 1~1000까지 살피고, 2-초완전수를 1~1000까지 살핍니다.) 나아가 k의 범위를 추릴 순 없을까 고민한 결과 k를 sqrt(i)+3 까지만 살피면 됨을 보였습니다. (코드 짜는건 수월했는데 이걸 보이는게 너무 어려웠어요ㅜㅜ) 확실히 돌아가는 속도가 차이가 나더군요 휴~

len_p <- 1000

sum_div <- function(x){
  tar <- 0
  for (i in 1:floor(sqrt(x))){
    if (x %% i == 0){
      tar <- tar + i + (x / i)
    }
  }
  if (floor(sqrt(x)) == sqrt(x)){
    tar <- tar - sqrt(x)
  }
  return(tar)
}

answer <- data.frame(NULL)

for (i in 2:len_p){
  for (j in 1:i){
    if ((1 + j * (sum_div(i) - i - 1)) == i){
      answer <- rbind(answer, c(i, j))
    }
  }
}
names(answer) <- c('n', 'k')

answer

def f(n):
    total = 0
    for i in range(1, n+1):
        if n % i == 0:
            total += i
    return total

def hyper_perfect(n, x):
    if x - n - 1 != 0:
        k = (n - 1)/(x - n - 1)
        if k == int(k):
            return int(k)
    else:
        return False

N = int(input())

for i in range(2, N + 1):
    x = f(i)
    if hyper_perfect(i, x):
        print((i, hyper_perfect(i, x)), end='')

Python 3.7

def sum_ntps(n):  # = f(n)-n-1 = 진(proper)약수면서, 고유(non-trivial)약수의 합
    return sum({divs for i in range(2, int(n ** 0.5) + 1) if n % i == 0 for divs in (i, n // i)})


for n in range(1, int(input()) + 1):
    check = sum_ntps(n)
    if check == 0: continue
    # k 값이 자연수인 경우 결과 쌍 출력
    k = (n - 1) / check
    if k.is_integer(): print(f"({n},{int(k)}) ", end='')

n=int(input());ans=''

for m in range(2,n+1):
    fn=0
    for i in range(1,m+1):
        if m%i==0:
            fn+=i

    if fn-m-1<=0:
        continue
    elif (m-1)%(fn-m-1)==0:
        ans+='({},{}) '.format(m,int((m-1)/(fn-m-1)))

print(ans)

public class 초완전수 {

    public static void main(String[] args) {

        Scanner scan = new Scanner(System.in);
        int N = scan.nextInt();
        ArrayList<Integer> aliquot = new ArrayList<Integer>();

        int F = aliquot.stream().mapToInt(Integer::intValue).sum();
        for(int i=2; i<=N; i++) {
            for(int j=1; j<=i; j++) {
                if(i%j==0) {
                    aliquot.add(j);
                }
            }
            F = aliquot.stream().mapToInt(Integer::intValue).sum();
            try{if((i-1)%(F-i-1)==0) {
                System.out.println(i+","+(i-1)/(F-i-1));
            }
            }catch(ArithmeticException e) {}
            finally{
                aliquot.clear();
            }
        }
    }
}

N=int(input("""N이하의 k-초완전수와 k를 출력합니다.
자연수 N을 입력하십시오: """))

def HPN(n): #문제의 f(n)-n-1을 구하는 함수(n의 약수 집합에서 자기 자신과 1을 제외한 약수들의 합)
    elst=[]
    for i in range(2,int(n**(1/2))+1):
        if n%i==0:
            elst.append(i)
            if n//i!=i:
                elst.append(n//i)
    sum=0
    for num in elst:
        sum+=num
    return sum

for n in range(1,N+1):
    if HPN(n)==0: #소수의 경우  f(n)-n-1이 0인데 k를 구할 때 0으로 나눌 수 없으므로 f(n)-n-1이 0이면 continue
        continue
    k=(n-1)/HPN(n)
    if int(k)*HPN(n)==(n-1): #k값이 자연수여야 int(k)값과 같아  n=1+k(f(n)-n-1)를 만족시킬 수 있음
        print((n,int(k)), end=" ")

num = int(input())
for j in range(2,num+1):
    measure = 0
    k = 0
    for i in range(1,j+1):
        if j % i == 0:
            measure += i
    if (measure-j-1) > 0:
        k = (j-1)/(measure-j-1)
        if int(k) == k:
            print(j,int(k))

꾸역꾸역 작성 했는데.....

def f(x):
    sum=0
    for i in range (1,x+1):
        if x%i==0:
            sum+=i
    return (sum)

n=int(input('n='))

for i in range (1,n+1):
    for k in range (1,n+1):
        if i==((f(i)-i-1)*k)+1:
            print('(',i,',',k,')')

import time
def divisor_sum(n):
    d = []
    for i in range(1, int(n**0.5)+1):
        if n%i == 0:
            d.append(i)
            d.append(n//i)
    s1 = set(d)
    return sum(s1)

def hpn(in1):
    output = []

    for h in in1:
        fn = divisor_sum(h)
        try:
            if (h-1)%(fn-h-1) == 0:
                k = (h-1)//(fn-h-1)
                print('({}, {}'.format(h, k))
        except ZeroDivisionError:
            continue

if __name__ == '__main__':
    t = time.time()
    in1 = [i for i in range(2, 10001)]
    hpn(in1)
    print('time: {}'.format(time.time() - t))

N = int(input())
for n in range(1,N+1):
    yaksu = []
    for j in range(1,n+1):
        if n%j == 0:
            yaksu.append(j)
        else:
            continue
    fn = sum(yaksu) 
    k = 1
    while k <= N:
        if n == (1+k*(fn-n-1)):
            print('%d는%d-초완전수'%(n,k))
            k += 1
        else:
            k += 1

파이썬3입니다.

계산 시간이 좀 많이 걸리는 느낌이데 어떻게 시간을 줄일 수 있을까요?

def f(n) :
    sum([x for x in range(1,n+1) if n % x == 0])
    return sum([x for x in range(1,n+1) if n % x == 0])

n = 1000
nkList = [] # list of n, k set

for x in range(1, n+1) :
    for k in range(1, x+1) :
        if x == 1 + k*(f(x) - x - 1) :
            nkList.append([x,k])

print(nkList)

def sum_per(number):

  total=0

  for i in range(2,number,1):

    if number%i==0:

      total+=i

  return total

def real_perfect_number(number):

  if sum_per(number)!=0:

    check=(number-1)/sum_per(number)

  else:

    check=0.1

  if check==int(check):

    return [number,int(check)]

def main():

  for i in range(1,1001,1):

    if real_perfect_number(i)!=None:

      print(real_perfect_number(i))

main()

def Super(a):
    for i in range(1,a+1):
        b=[]
        for j in range(1,i+1):
            if i%j==0:
                b.append(j)
        try:
            if (i-1)%(sum(b)-i-1)==0:
                print("({},{})".format(i,int((i-1)/(sum(b)-i-1))))
        except Exception:
            pass
        else:
            pass

Super(1000)

def func1(n):
    sum = 0
    for i in range(1, n+1):
        if n % i == 0:
            sum += i    
    # print(sum)
    return sum

def func2(n):
    for i in range(3, n+1):
        # print(i-1, func1(i)-i-1)
        if (func1(i)-i-1) != 0 and (i-1) % (func1(i)-i-1) == 0:
            k = (i-1)/(func1(i)-i-1)
            print(i, int(k))

func2(1000)

n = int(input("")) 
num = 1
while True : 
    dsum = sum([x for x in range(1, num+ 1) if num %  x ==0])
    for k in range(1, n):
        if num == 1+ k*(dsum - num - 1):
            print("(%d,%d)"%(num,k), end=' ')
        else : continue
    if n == num:
        break
    num += 1

#codingdojing_hyperperfactnumber

def sum_CD(n):

    a = []
    for i in range(1, int(n**0.5)+1):
        if n%i == 0:
            a.extend([i, n//i])

    return sum(a)


N = eval(input('N: '))
for n in range(1, N+1):
    M = (sum_CD(n) - n - 1)

    if M:   #분모가 0이 아니면,
        k = (n-1) / M
        if k%1 == 0: #자연수면,
            print((n, int(k)))

n=int(input("자연수 n을 입력하세요: "))
for m in range(n+1):
    k=[k for k in range(1,m+1) if 1+k*(sum([i for i in range(1,m+1) if m%i==0])-m-1)==m]
    for i in k: print(f"({m},{i})", end=' ')

잘 나오기는 하는데 실행 시간이 산으로 가버렸습니다

while True:
    N = int(input("자연수 N을 입력하시오"))
    if N>0 :
        break

def F(n):
    sum = 0
    for i in range(1,n+1):
        if n%i ==0:
            sum +=i
    return sum


for i in range(1,N+1):
    try :
        k = (i-1)/(F(i)-i-1)
        if k == int(k) and k>0:
            print("(",i,",",k,")")
    except ZeroDivisionError:
        continue

약수 의 합 구하는 함수를 따로 정의했어요 k값중에 분모부분이 0이되어서 'ZeroDivisionError' 는 예외처리했고, k값중에서도 자연수들만 필터링했습니다

// Rust

// 약수 : HashSet으로 중간에 나왔던 약수가 나오면 바로 loop 중단

// f_ = f - n - 1 : 1과 자신을 제외한 약수의 합이 0(소수)이면 k가 나올수 없으므로 건너뛰기(Option::None 반환)

// N이하의 수를 검사하며 if let (pattern matching)으로 Option::Some 패턴만 결과 벡터에 추가

// (Rust의 자료형은 훌륭합니다...)

fn hyperfect_number(n: u32) -> Option {

assert!(n>2);

// n의 약수 구하기 => f_ = f(n)-n-1
// let f_ = (2..n).filter(|&i| n % i == 0).sum();
let mut set = HashSet::<u32>::new();
for i in 2..n {
    if n % i == 0 {
        if !set.insert(i) { break; } } }
let f_ = set.iter().sum::<u32>();

// k 구하기 (n-1)/f_ : n이 소수이면 f_==0, k indefinite
if f_ == 0 { return None; }
if (n - 1) % f_ == 0 { return Some((n - 1) / f_); }
else { return None; }

} fn range_hyperfect_number(n: u32) -> Vec<(u32, u32)> {

let mut result = vec![];
for i in 3..=n {    //n 이하의 k-초완전수
    if let Some(k) = hyperfect_number(i) {
        result.push((i, k));}}
result

}

[test]

fn test() {

assert_eq!(hyperfect_number(21), Some(2));
assert_eq!(hyperfect_number(301), Some(6));

}

def f(n):
    return sum([x for x in range(1,n+1) if n%x == 0])

def super(n):

    nk=[]
    for i in range(2,n):
        kl = [k for k in range(i) if i == (1 + k*(f(i)-i-1))]
        if  len(kl) != 0:
            nk.append((i,kl[0]))
    return nk

super(1000)