위의 파이선코드들을 참조 했습니다.

sum(set(range(1, 5000)) - {x + sum([int(a) for a in str(x)]) for x in range(1, 5000)})

python 2.7.3

Python으로 작성해 보았습니다.

처음에 만든 코드는 아래와 같았습니다.

def d_fn(n):
    y = n
    while n > 0:
        y += n % 10
        n //= 10
    return y

Z = [d_fn(n) for n in range(5000)]
A = [n for n in range(5000) if n not in Z]
print (sum(A))

그 다음에는 문자열을 사용해서 조금 더 짧게 고쳐봤습니다.

def d_fn(n): return (n + sum([int(x) for x in str(n)]))

Z = [d_fn(n) for n in range(5000)]
A = [n for n in range(5000) if n not in Z]
print (sum(A))

여기에 아래와 같이 집합 데이터 구조를 사용해 보니 더 직관적으로 고쳐지는 것 같습니다.

def d_fn(n): return (n + sum([int(x) for x in str(n)]))

S = set(range(5000))
Z = set([d_fn(n) for n in range(5000)])
print (sum(S-Z))

파이썬의 def를 사용하지 않고 set() 의 차집합을 이용해서 작성해보았습니다.

nums = range(1,5001)
selfnums = set(nums) - set([sum([int(ii) for ii in str(num)]) + num for num in nums])

print sum(selfnums)

파이썬 3.2.5 기준입니다.

def d(number):
    total = number
    number = str(number)
    for i in number:
        total += int(i)
    return total

self_number_total = 0
self_number_set = set()

for i in range(1,5000):
    self_number_set.add(d(i))

for i in range(1,5000):
    if not i in self_number_set:
        self_number_total += i

print(self_number_total)

코딩도장 자주 애용할 듯 합니다ㅎㅎ 자바에요

public class SelfNumber {

    public static void main(String[] args) {
        // 1~5000 까지
        // generator 로 돌려서 각 값을 배열에 저장
        // 그중 1~5000과 일치하지 않는 수를 골라낸다
        // int 를 나눌 경우 소수점 이하는 계산에서 무시되므로 int를 사용

        Integer a,b,c,d,result,sum=0;

        boolean[] generated = new boolean[5000];

        for(int generator=1; generator<5000;generator++){
            a = generator/1000;
            b = (generator/100)%10;
            c = (generator/10)%10;
            d = generator%10;

            result = a+b+c+d+generator;

            if((result>=1)&&(result<5000)){
                generated[result] = true;
            }
        }

        for(int i=1; i<5000; i++){
            if(generated[i]==false){
                sum = sum + i;
            }
        }

        System.out.println("Self-Number의 합계는 : " + sum);

    }
}

public static void main(String[] args)
    {
        calculateNumbersHasGenerator();
        int sum = 0;
        for (int i = 0; i < 5001; i++)
            if (!hasGenerator(i))
                sum += i;
        System.out.println("합 : "+sum);
    }

    private static boolean hasGenerator(int num)
    {
        return numbersHasGenerator.contains(num);
    }

    private static ArrayList<Integer> numbersHasGenerator;

    private static void calculateNumbersHasGenerator()
    {
        numbersHasGenerator = new ArrayList<Integer>();
        for (int i = 0; i <= 5000; i++)
        {
            String num = String.valueOf(i);
            int no = 0;
            for (int n = 0; n < num.length(); n++)
                no += Integer.parseInt(num.substring(n, n + 1));
            numbersHasGenerator.add(no + i);
        }
    }

합 : 1227365

자바로 짯습니다. 코딩 퀴즈 재밌군요. 아직 많이 부족한 실력이라, 적극적인 지적 환영합니다.

#include <stdio.h>
int getValueByGenerator(int);

int main(){
    int num[5000];
    int haveGenerator[5000] = {0,};
    int i =0;
    int result = 0;

    // n은 항상 d(n)보다 작으므로
    // i를 Generator로 가지는 값을 구하여 배열에 저장
    for(i=1; i<=5000; i++)
        num[i-1]= getValueByGenerator(i);

    for(i=0; i<5000; i++){
        // 1. num[i]값을 참조하여 Generator를 가졌는지 판단
        // 2. 5000이하인 경우 해당 인덱스 참조하여 Generator를 가졌는지 표시(1 = have, 0 = donthave)
        if(num[i] <= 5000)
            haveGenerator[(num[i] -1)] = 1;
    }

    // Generator를 가지지않은 값들을 모두 합하여 결과도출.
    for(i=0; i<5000; i++){
        if(haveGenerator[i] == 0){
            result += (i+1);
            printf("%d ", i+1);
        }
    }

    printf("\n\nresult : %d\n", result);
    return 0;
}

int getValueByGenerator(int x){
    return (x + x/1000 + (x%1000)/100 + (x%100)/10 + x%10);
}

합 : 1227365

*풀이방법 -> 주석

J를 이리 저리 익혀 보려고 하고 있는데 손에 잘 안 익네요. 그래도 일단 풀긴 풀었습니다. 그다지 깔끔한 것 같지 않은데 J 하시는 분들의 가멸찬 지적 바랍니다...

   +/I.-.(e.(++/"1@(10&#.^:_1)))i.5001
1227365

처음부터 이렇게 만들었다는 소리는 아니고요, 대강 이렇게 구성됩니다.

   digits =: #.^:_1
   digits10 =: 10 & digits
   digits10 4057 2289
4 0 5 7
2 2 8 9

J에 내장되어 있는 #.(base)라는 함수는 오른쪽의 인자들을 2진법(또는 왼쪽 인자가 있으면 그 진법)으로 해석해서 하나의 숫자로 만듭니다. 이를테면 "#. 1 1 0 1"은 13이 되겠죠. ^:_1는 함수의 의미를 뒤집는 역할을 합니다.

   +/ digits10 4057 2289
6 2 13 16
   +/"1 digits10 4057 2289
16 21

J에서 배열의 합을 구할 때는 흔히 +/(sum)을 씁니다만 이 경우 오른쪽 인자가 여럿일 때도 동작해야 하기 때문에 행과 열을 잘 생각해야 합니다. +/(좀 더 정확히는, /)의 기본값은 열 별로 더하는 것이므로 이 동작을 바꾸려면 "1로 rank를 바꿔 줘야 합니다.

   digitsum =: +/"1 @ digits10
   d =: + digitsum
   d 2289
2310

고로 digitsum은 오른쪽 인자를 10진법 자릿수로 나눈(digits10) 것을 행 별로 다 더한(+/"1) 것으로 정의할 수 있습니다. 함수 d(x)는 당연히 x + digitsum(x)로 정의되는데, J의 fork를 사용하면 코드가 좀 더 간단해집니다. 사실 이렇게 안 하면 괜시리 복잡해지기도 하고요.

   i.20
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
   d i.20
0 2 4 6 8 10 12 14 16 18 11 13 15 17 19 21 23 25 27 29

이제 앞에서 정의했던 d를 가지고 self number의 목록을 구합니다. i.(integers)는 0부터 주어진 인자 빼기 1까지를 담은 배열을 만들고(파이썬의 range와 거의 비슷합니다), 앞에서도 살펴 봤지만 배열에 함수를 적용하면 배열 각 원소에 함수가 모두 자동으로 적용됩니다. (+/와 같이 다른 형태로 동작하는 경우도 물론 있습니다.)

   (i.20) e. (d i.20)
1 0 1 0 1 0 1 0 1 0 1 1 1 1 1 1 1 1 1 1
   (e. d) i.20
1 0 1 0 1 0 1 0 1 0 1 1 1 1 1 1 1 1 1 1

e.(member)를 써서 집합 빼기(set difference) 비스무리한 걸 구현할 수 있습니다. (d에 ^:_1을 적용할 수 있으면 참 좋겠지만 d의 역함수는 애초에 함수가 아닙니다...) 앞에서 fork 얘기를 했는데 여기서도 한 번 더 쓰게 되네요.

   -. (e. d) i.20 
0 1 0 1 0 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0
   I. -. (e. d) i.100
1 3 5 7 9 20 31 42 53 64 75 86 97
   +/ I. -. (e. d) i.5001
1227365

-.(not)을 써서 0과 1을 뒤집은 뒤, I.(indices)를 써서 1이 있는 칸의 인덱스만 빼 오면 d의 반환값에 나오지 않았던 모든 숫자들을 구할 수 있습니다. 그 결과를 모두 더하면(이번에는 그냥 +/로) 결과를 얻을 수 있습니다. 맨 위의 코드는 이 코드에서 공백 떼고 d를 안에 넣어서 완성한 것입니다.

import math
def d(x):
    x=str(x)
    s=int(x)
    for i in x:
        s+=int(i)
    return s
s=0
i=1
a=d(i)
while a<5000:
    s+=a
    i+=1;a=d(i)


print((4999*5000/2)-s)

    Sub Main()
        Dim result As Integer = 0
        Dim ht As New Hashtable

        For i As Integer = 1 To 4999
            Dim n As Integer = GetGenerator(i)

            If n < 5000 Then
                ht.Add(i, n)
            End If
        Next

        For i As Integer = 1 To 4999
            If Not ht.ContainsValue(i) Then
                result += i
            End If
        Next

        Console.WriteLine("Result: " & result)

        Console.ReadLine()
    End Sub

    Public Function GetGenerator(n As Integer) As Integer
        Return n + (From str In n.ToString.ToArray Select Integer.Parse(str)).ToArray.Sum
    End Function

1227365

#include <iostream>

using namespace std;

static const int N = 5000;

int d(int n)
{
  int res = n;
  while (n != 0) { res += n % 10; n /= 10; }
  return res;
}

int main()
{
  bool isSelfNo[N + 1];
  for (int i = 0; i <= N; i++) isSelfNo[i] = true;
  int sumOfSelfNo = 0;
  int n = 1;
  while (n <= N)
  {
    if (isSelfNo[n]) sumOfSelfNo += n;
    int _d = d(n);
    if (_d <= N) isSelfNo[_d] = false;
    n++;
  }
  cout << sumOfSelfNo << endl;
}

이렇게 하면 되나염?

모든 자연수는 자신의 generator 보다 클 수 밖에 없으므로(각 자릿수의 합은 항상 0보다 크기 때문에) 1 이상 5000 미만의 self-number 를 알기 위해선 1 이상 5000 미만인 수들을 generator 로 하는 수들을 key 로 하고 아무 값을 value로 하도록 비어있는 dictionary에 모두 저장한뒤 다시 1부터 4999 까지 반복문을 돌려서 dictionary에 해당 숫자를 key 로 갖는 값이 존재하는지 검사해서 없으면 sum 에 누적시키면 1 이상 5000 미만의 self-number 의 합이 된다. (왜냐하면 1 이상 5000 미만인 수들이 가질 수 있는 모든 가능한 generator 들을 이용하여 generate 하였으므로 해당 숫자의 key 를 갖는 값이 없다면 self-number 인 것이다.) 답은 1227365

def generate(num):
    res = 0
    for i in str(num):
       res = res + int(i)
    return res + num

dic = dict()

for i in range(1,5000):
    dic[generate(i)] = 1

res = 0

for i in range(1,5000):
    if not dic.has_key(i):
        res = res + i

print res

(python 2.7 기준)

scala> def d(n: Int): Int = {
     | n + n.toString.map(_.asDigit).sum
     | }
d: (n: Int)Int

scala> (1 to 5000) diff (1 to 5000).map(d) sum
res7: Int = 1227365

generator = @ (n) sum(int2str(n)-'0')+n;
range = 1:5000;
num = range;
for n=range
    num(generator(n)) = 0;
end
sum(num(range))

..

/*****************************************************************************************************************************
 * 어떤 자연수 n이 있을 때, d(n)을 n의 각 자릿수 숫자들과 n 자신을 더한 숫자라고 정의하자.
 *
 * 예를 들어
 * 
 * d(91) = 9 + 1 + 91 = 101
 *
 * 이 때, n을 d(n)의 제네레이터(generator)라고 한다. 위의 예에서 91은 101의 제네레이터이다.
 * 
 * 어떤 숫자들은 하나 이상의 제네레이터를 가지고 있는데, 101의 제네레이터는 91 뿐 아니라 100도 있다. 
 * 그런데 반대로, 제네레이터가 없는 숫자들도 있으며, 
 * 이런 숫자를 인도의 수학자 Kaprekar가 셀프 넘버(self-number)라 이름 붙였다. 
 * 예를 들어 1,3,5,7,9,20,31 은 셀프 넘버 들이다.
 * 
 * 1 이상이고 5000 보다 작은 모든 셀프 넘버들의 합을 구하라.
 *****************************************************************************************************************************/
import java.util.ArrayList;

//1. self-number가 아닌 숫자를 찾아 리스트로 정리한다.
//2. 1 - 4999중 해당 리스트에 포함되지 않는 숫자를 전부 더한다.

public class Generator {
    //5000은 포함 하지 않는다
    private static final int LIMIT = 4999;

    //generator를 가지는 1 - LIMIT 범위 내의 숫자 목록
    private static ArrayList<Integer> notSelfNumberList;

    public static void main(String[] args) {
        initNotSelfNumberList();

        printTotalSelftNumberSum();
    }

    //not self-number list 셋팅
    public static void initNotSelfNumberList() {
        notSelfNumberList = new ArrayList<Integer>();

        //5000보다 작으며 5000에 가장 근접한 self값을 모르며 제한되는 generator를 모르기 때문에 LIMIT까지 진행.
        for (int i = 0; i <= LIMIT ; i++) {
            //해당 숫자를 generator로 가지는 값을 찾아 낸다.
            //찾아낸 수는 generator를 가지고 있으므로 notSelfNumberList에 포함 한다.
            //이때 생성된 수가 최초로 LIMIT값을 넘게 되는 순간 break(해당 숫자는 notSelfNumberList에 포함 안함)

            String strNum = String.valueOf(i);

            //자기 자신도 더해야 하므로 우선 자기 자신을 최초 숫자로 셋팅
            int notSelfNumber = i;
            //각 자리수를 전부 분해하여 더한다.
            for (int idx = 0; idx < strNum.length(); idx++) {
                notSelfNumber += Integer.parseInt(strNum.substring(idx, idx+1));
            }

            //더한 숫자가 한도 범위를 벗어 난다면 for문 중단.
            if (notSelfNumber > LIMIT) break;

            //한도를 넘지 않았다면 not self-number list에 포함
            notSelfNumberList.add(notSelfNumber);
        }
    }

    public static void printTotalSelftNumberSum() {
        int sum = 0;

        //1부터 LIMIT까지 진행
        for (int i = 1; i <= LIMIT; i++) {
            //not self-number list에 포함되어 있다면 통과
            if (notSelfNumberList.contains(i)) continue;

            //아니라면 최종합에 더하기.
            sum += i;
        }

        System.out.println("1 부터 " + LIMIT + "까지 self-number 가 아닌 모든 수의 합 : " + sum);
    }

}

결과는 1227365가 나오네요 ㅎㅎ
우연히 이곳을 알게 되었는데 많이 활성화 되면 좋겠습니다.
더불어 퀴즈도 많아지면 재미있겠네요

ruby

([*1..5000] - (1..5000).map{|i| i.to_s.split("").map(&:to_i).reduce(:+)+i}).reduce(:+)

python 2.4 으로 풀었습니다. 코드가 이쁘지는 않습니다.

우선 d(n) = n + (n 각자리수 합) 이므로 1~5000의 셀프넘버를 구하는데 제네레이터 값이 5000보다 클수는 없다고 보고서 풀었습니다.

전체 코드입니다.

def main():
    l = range(1, 5000)

    for i in range(1, 5000):
        if l.count(d(i)):
            l.remove(d(i))

    print sum(l)

def d(n):
    s = str(n)
    sum = 0
    for i in range(0, len(s)):
        sum = sum + int(s[i])

    return sum + n

if __name__ == '__main__':
    main()

먼저 d(n) 함수를 만들어 놓은뒤 제네레이터 값을 1~5000 까지 넣으면서 나오는 d(n) 의 값들을 1~5000 사이에서 빼는 형식으로 처리한 뒤에 합쳤습니다. 답은 맞게 나온거 같지만 코드가 이쁘지 않은것이 마음에 걸리네요... 추가 조언 주시면 많은 참고 하겠습니다.

자바로 짜봤습니당

import java.util.Hashtable;

public class SelfNumberSum {

    public static void main(String[] args){

        int result = 0;
        int generatorNum=0;
        final int MAX_NUMBER = 5000;

        Hashtable v = new Hashtable();
        SelfNumberSum sum = new SelfNumberSum();

        // 1.generating generator number.
        for(int i=1; i<=MAX_NUMBER; i++){
            generatorNum=sum.getGenerator(i);
            if(generatorNum<MAX_NUMBER){
                v.put(i,generatorNum);
            }
        }

        /// 2.finding SelfNumber
        for(int i=1; i<MAX_NUMBER; i++){
            if(!v.containsValue(i)){
                result += i;
            }           
        }

        System.out.println("self-number sum : " + result);

    }

    private int getGenerator(int generator){

        int substrSum=0;
        String numberStr = Integer.toString(generator);
        int substrLength = numberStr.length();

        for(int i=0; i<substrLength;i++){
            substrSum+=Integer.parseInt(numberStr.substring(i,i+1));
        }
        substrSum += generator;

        return substrSum;
    }



}

coding by python beginner

def d(n):
    sum = n
    for i in str(n): sum += int(i)
    return sum

gen = 1; nonSelfNums = []
while True:
    nonSelfNum = d(gen)
    if nonSelfNum >= 5000: break
    nonSelfNums.append(nonSelfNum)
    gen += 1        

print( sum( set(list(range(1, 5000))) - set(nonSelfNums) ) )

        static void Main(string[] args)
        {
            Hashtable hst = new Hashtable();
            int Sum = 0;

            for (int i = 0; i < 5000; i++)
            {
                int tmp = jene(i);
                if (tmp < 5000)
                {
                    hst.Add(i,tmp);
                } 
            }

            for (int i = 0; i < 5000; i++)
            {
                if (!hst.ContainsValue(i))
                {
                    Sum += i;
                }
            }

            Console.WriteLine(Sum);
        }

        public static int jene(int Ine)
        {
            int result = 0;   

            string Tmp = Ine.ToString();


            int[] TmI = new int[Tmp.Length];


            for (int i = 0; i < Tmp.Length; i++)
            {
                TmI[i] = Convert.ToInt32(Tmp[i].ToString());
            }

            result += Ine;

            for (int i = 0; i < TmI.Length; i++)
            {
                result += TmI[i];
            }

            return result;
        }

#include <iostream>

using namespace std;
void calDNNumbers();
bool isNotSelfNumber(int number);

int dnNumbers[5000] = {0, };

int main() {

    int sum = 0;

    calDNNumbers();

    for(int i=1; i<=5000; i++) {
        if(!isNotSelfNumber(i)) {
            sum+=i;     
                }
    }

    cout << sum;
}

void calDNNumbers() {
    int f[4] = {0};

    for(int i=0; i<5000; i++) {
        f[0]=0, f[1]=0, f[2]=0, f[3]=0;
        f[0] = (i+1)/1000;
        f[1] = ((i+1)%1000)/100;
        f[2] = ((i+1)%100)/10;
        f[3] = (i+1)%10;

        dnNumbers[i] = f[0]+f[1]+f[2]+f[3]+(i+1);       
    }

}

bool isNotSelfNumber(int number) {
    bool isNotSelfNumber = false;
    for(int i=0; i<5000; i++) {
        if(dnNumbers[i]==number) {
            isNotSelfNumber = true;
            break;
        } 
    }
    return isNotSelfNumber;
}

Java8을 활용하여 만들었습니다.

public static void main(String[] args){
    Set<Integer> set = new HashSet<>();
    IntStream.rangeClosed(1, 5000)
             .forEach(x -> set.add(String.valueOf(x).chars().sum() + x));
    int sum = IntStream.rangeClosed(1,5000)
                   .filter(x -> !set.contains(x))
                   .sum();
    System.out.println(sum);
}

파이썬 2.7.6 입니다.

def d(n):
    return n + sum(int(x) for x in str(n))
L = [x for x in range(5001)]
for n in L:
    if n == 0 : continue
    while d(n) <= 5000 :
        L[d(n)] = 0
        n = d(n)
print sum(L)

PHP 로 작성했습니다. 초기배열 인덱스와 값을 맞춰주기위해 0~4999로 설정했구요.. (0은 뭐 껴있어도 상관없으니) 제너레이터의 결과값을 그대로 인덱스를 찾아 제거하는 용도로 사용했습니다.

$array = range(0,4999);

for($i=1; $i<=5000; $i++) {
    unset($array[array_sum(str_split((string)$i))+$i]);
}

echo array_sum($array);

#include <iostream>
#include <string>

using namespace std;

#define MAX 5000

bool list[MAX] = { false };
int Generator(int num) {
    int res = num;

    while (num != 0)
    {
        num /= 10;
        res += num % 10;
    }
    return res;
}


int main()
{
    for (int i = 1; i < MAX; i++) {
        list[Generator(i)] = true;
    }

    for (int i = 1; i < MAX; i++) {
        if (list[i] == 0) cout << i << endl;
    }

    return 0;
}

Scala

(1 to 5000).filter(i => {
    !(1 until 5000).map(i => {
        var f = i
        var s = i
        while (f > 0) {
            s = s + (f % 10)
            f = f / 10
        }
        s
    }
    ).toList.contains(i)
}).foldLeft(0) { (a: Int, b: Int) => a + b }

/**
  * Created by ReolSt on 2017-07-18.
  */
object NexonGenerator
{
  private val A : IndexedSeq[Int] = (1 to 5000) map(x => D(x,s"$x",0,x)) filter(_ <= 5000)
  def D(N : Int, NL : IndexedSeq[Char], i : Int, Result : Int) : Int =  if(i < NL.length - 1) D(N,NL,i+1,Result + NL(i).toInt - 48) else Result + NL(i).toInt - 48
  def main(args: Array[String]): Unit = print(((1 to 5000) filter(x=> A.lastIndexOf(x) == -1)).sum)
}

스칼라로 풀어봤습니다.

# 각 자리 숫자 들의 합
def sum_digit(n):
    if n >= 0 and n < 10:
        return n
    str_n = str(n)
    return sum_digit(int(str_n[:-1])) + int(str_n[-1])

# 각 자리 숫자들의 합 + 그 숫자
def sum_digit_itself(n):
     return n + sum_digit(n)

# 셀프 제너레이터가 있는 숫자들의 리스트
i = 1
sum = []
while sum_digit_itself(i) < 5000:
    new_num = sum_digit_itself(i)
    if new_num not in sum:
        sum.append(new_num)
    i += 1

# 1 부터 5000 까지 셀프 제너레이터가 없는 숫자들의 합
answer = 0
for i in range(1, 5000):
    if i not in sum:
        answer += i

print(answer)

nonself=[]

for i in range(1,5000):
    string = str(i)
    nstr = len(string)
    d_n=i
    for j in range(0,nstr):
        d_n = d_n + int(string[j])
    nonself.append(d_n)

sumself=0
for iself in range(1,5000):
    if iself not in nonself:
        sumself=sumself+iself
print sumself

#include <stdio.h>

int main()
{
    int n = 5000, temp, re, i, j,k;
    re = n * (n + 1) / 2;
    for (i = 1; i<n + 1; i++) {
        for (j = (i - 40>1) ? i - 40 : 1; j<i+1; j++) {
            temp = j;
            k = j;
            while (k >= 1) {
                temp += k % 10;
                k = k / 10;
            };
            if (i == temp)
            {
                re -= i; break;
            }
        }
    }
    printf("%d", re);
    return 0;
}

Swift로 해봤습니다.

import Foundation

func getGeneratedNumber (_ number : Int) -> Int {
    return String(number).reduce(0, {return $0 + Int(String($1))!}) + number
}

var selfNumbers = Set<Int>(1..<5000)
for i in 1..<5000 {
    selfNumbers.remove(getGeneratedNumber(i))
}
print(selfNumbers.reduce(0, +))

// python version. // almost copycat top rank code.

print(sum(range(5000)) - sum(filter(lambda x: x < 5000, set(x + sum(int(a) for a in str(x)) for x in range(5000)))))

def p365_fn(n):
    return n + sum(int(x) for x in str(n))

def p365():
    d_list = set()
    for i in range(1,5000):
        d_list.add(p365_fn(i))

    n_list = set(range(1,5000))
    print(sum(n_list-d_list))


#####################################
if __name__ == "__main__":
    p365()

nums_g=[]
for i in range(1,5000):
    num_g = i + sum(int(t) for t in str(i))
    nums_g.append(num_g)
result = set(range(1,5000)) - set(nums_g)
sum(result) # 1227365

a = [sum(map(int,str(i)))+i for i in range(1, 5000)]
print(sum(i for i in range(1,5000) if i not in a))

num_list = []
for l in range(1, 5000):
    num_list.append(l)

gen_dic = {}

#N 이하의 숫자중 제네레이터 찾기
def gen_maker(N):
    for i in range(1, N):
        if i >= 1000:
            a1 = i // 1000
            a2 = (i-a1*1000) // 100
            a3 = (i-(a1*1000)-(a2*100)) // 10
            a4 = i-(a1*1000)-(a2*100)-(a3*10)
            gen_dic[i] = i + a1 + a2 + a3 + a4
        elif i >= 100:
            a1 = i // 100
            a2 = (i - a1*100) // 10
            a3 = i - a1*100 - a2*10
            gen_dic[i] = i + a1 + a2 + a3
        elif i >= 10:
            a1 = i // 10
            a2 = i - a1*10
            gen_dic[i] = i + a1 + a2
        else:
            gen_dic[i] = i + i


gen_maker(5000)
gen_list = list(gen_dic.values())

#제네레이터와 일반 숫자간에 차이 구하기
self_list = []
def check_gen():
    for m in num_list:
        if m not in gen_list:
            self_list.append(m)
        else:
            pass

check_gen()

#self number간의 합 구하기
Sum_self = 0
for c in self_list:
    Sum_self += c

print(Sum_self)

다른 분들 보니까 제 코드가 쓸데없이 너무 긴거 같네요... 아직 초보의 머리로는 저거 밖에 떠오르지 않습니다

public class MJ365 { public static int generate(int n) { int re=n; while(n!=0) { re=re+n%10; n=(int)(n/10); } return re;

}
public static void main(String args[]) {
    int[] self = new int [5001];
    for(int i=1; i<=4975; i++) {
        self[generate(i)]=self[generate(i)]+1;
    }
    int n=0;
    for(int j=1; j<=5000; j++) {
        if(self[j]==0) {
            n=n+j;
        }
    }
    System.out.println(n);
}

}

import java.util.ArrayList;
import java.util.Collections;

public class 넥슨입사문제중에서 {

    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        for(int s = 0; s<5001; s++) {
            list.add(s);
        }
        for(int i=0; i<5001; i=i+1000) {
            for(int j=0; j<901; j=j+100) {
                for(int k=0; k<91; k=k+10) {
                    for(int l=0; l<10; l++) {
                        int num=0;
                        num=i+j+k+l+(i/1000)+(j/100)+(k/10)+l;
                        if(list.contains(num)) {
                        Collections.replaceAll(list, num, 0);
                    }
                    }
                }
            }
        }
        int sum = 0;
        for(int a = 0; a<list.size(); a++) {
            sum+=list.get(a);
        }
        System.out.println(sum);
    }
}

function solution() {

            var generator = 0;
            var b_sum = 0;
            for ( var list = 1; list < 5000; list++ ) {
                var flag = false; // flag 초기화를 해준다.
                for ( var i = 1; i < list; i++ ) { // 999 일 경우
                    generator = 0;
                    var j = i.toString().split( "" ); // 9 9 9
                    for ( let k = 0; k < j.length; k++ ) {
                        generator += parseInt( j[ k ] ); // 9+9+9
                    }
                    generator += i; // 9+9+9+999 = 1026
                    if ( generator == list ) {
                        flag = true; // generator 와 list 값이 같은 경우 flag에 true 값을 저장 후
                        break; // 반복문을 빠져 나간다.
                    }
                }
                if ( !flag ) { // flag 가 true 인경우만 ( 셀프 넘버 인경우만 )
                    b_sum += parseInt( list ); // b_sum에 합을 더한다.
                }
            }
            console.log( b_sum ); // 1227365
        }

   function SumSelfNunber(){

        var total_sum = 0;
        for(var i = 1; i < 5000; i++){
            var notselfNumber = false;

            for(let c = 1; c < i; c++){
                var sum = parseInt(c /1000) + parseInt((c % 1000) / 100) + parseInt((c % 100) / 10) + parseInt(c % 10) + c; //제네레이터의 sum
                if(sum == i ){ //셀프넘버 체크.
                    notselfNumber = true; 
                    break;
                }
            }
            if(!notselfNumber)
                total_sum += parseInt(i);
        }
       console.log(total_sum);
    }

A= set(range(1,5000))

b=[]

for i in range(1,5000):

    c = (i + sum([int(a) for a in str(i)]))

    b.append(c)

B = set(b)

print(sum(A-B))

a = set(range(1,5000))
generator_set = set()

for i in range(1,5000):               # 1부터 4999까지 자신과 각 자리의 수를 합하여 5000보다 작으면 generator_set에 추가
    n = 0
    for j in range(len(str(i))):
        n += int(str(i)[j])

    if i+n <5000:
        generator_set.add(i+n)    

selfnum_set = a - generator_set           # 1부터 4999까지를 요소를 갖는 세트에서 generator_set와 차집합 연산으로 셀프넘버 세트를 만듬
sum(selfnum_set)                         # 셀프넘버들의 합

generator = lambda a: sum(int(i) for i in str(a))+a
dn_list = [generator(x) for x in range(5000)]
print(sum(set([x for x in range(5000)]) - set(dn_list)))

def is_self_number(num): #파라미터가 self number일때 스스로를 출력하는 함수
  for i in range(num):   #파라미터보다 같거나 큰 숫자는 제네레이터가 될수 없으므로, 그보다 작은 숫자만을 반복해서 checking
    if sum([int(x) for x in str(i)]+[i]) == num: #제너레이터를 str활용해 simplyfing, self number인지 체크
      return 0
  return num

# 정답확인부분
sum([is_self_number(i) for i in range(1,5000)])

result=0 ; real_result=0 
x=[]
for i in range(1,5000):
    i_str=str(i)
    i_list=list(i_str)
    for j in i_list:
        result+=int(j)
    real_result=result+i
    real_result_str=(str(real_result))
    x.append(real_result_str)
    #print(real_result)
    result=0 ; real_result=0 
realreal=[]
for i in x:
    x_int=int(i)
    realreal.append(x_int)
#print(realreal)

a=realreal
bb=range(0,5000)
b=list(bb)
b_minus_a=[]
count=0 #검증수
for i in range(0,len(b)):
    count=0
    for j in range(0,len(a)):
        if b[i]==a[j]:
            count+=1
        else:
            pass
    if count==0:
        b_minus_a.append(b[i])

#print(b_minus_a)
result=0
for i in b_minus_a:
    result+=i
print(result)

파이썬으로 구현해 보았어요..

import unittest

def d(n):
    result = 0
    for c in str(n):
        result += int(c)
    result += n
    return result

def sum_of_selfnumber(n):
    total = set()
    found = set()
    for i in range(1, n):
        total.add(i)
        found.add(d(i))
    return sum(total - found)


class MyTest(unittest.TestCase):
    def test1(self):
        self.assertEqual(101, d(91))
        self.assertEqual(101, d(100))

    def test2(self):
        self.assertEquals(1+3+5+7+9, sum_of_selfnumber(10))
        self.assertEquals(1227365, sum_of_selfnumber(5000))

if __name__ == "__main__":
    unittest.main()

어제 오늘 일이 잘 안되서 빈둥 거리다 보니.. 하나 더 풀어 봤습니다. ㅡ.ㅡ;
어제도 오랫만에 알고리즘 책을 보다가 잠들었는데, 머리가 아픕니다 ㅠ.ㅠ
그래도 재미있네요.

program Sample;

{$APPTYPE CONSOLE}

function GetGeneratorResult(AIndex:integer):integer;
begin
  Result := AIndex;

  while AIndex > 0 do begin
    Result := Result + AIndex mod 10;
    AIndex := AIndex div 10;
  end;
end;

var
  Loop, Index, Sum : integer;
  HasGenerator : array [1..5000] of boolean;

begin
  FillChar(HasGenerator[1], SizeOf(HasGenerator), 0);

  Sum := 0;
  for Loop := Low(HasGenerator) to High(HasGenerator) do begin
    Index := GetGeneratorResult(Loop);

    // 하나라도 제너레이터가 발견되었는 가?
    if Index <= High(HasGenerator) then HasGenerator[Index] := true;

    // 제너레이터의 결과는 현재 Loop보다 항상 크기 때문에.
    // 아직까지 발견되지 않았으면 계속 없다.
    if not HasGenerator[Loop] then Sum := Sum + Loop;
  end;

  WriteLn('셀프 넘버들의 함 = ', Sum);
  WriteLn;

  Write('Press any key...');
  ReadLn;
end.

루비로 풀어 봅니다.

def d(n)
  res = n
  split_n = n.to_s.split ""
  split_n.each { |e| res = res + e.to_i }
  res
end

def sum(arr)
  res = 0
  arr.each {|e| res = res + e}
  res
end

range_arr = (1...5000).to_a

for i in 1...5000
  dn = d(i)
  range_arr.delete dn if dn < 5000
end

puts "result = #{sum(range_arr)}"

아직 파이썬 배운지 얼마 안되서 별로 않좋은 코드를 짠것 같지만...많은 지적 부탁드립니다.

#NexonQuiz.py
#1부터 5000이하의 수중 generator가 없는 수들의 총합은?
import time
a=time.time()
genList=[]
for i in range(1,5000):
    genNumber=i
    for j in range(0,len(str(i))):
        genNumber+=int(str(i)[j])
    if (not genNumber in genList) and genNumber <=5000:
        genList.append(genNumber)

genSum=0
for j in range(1,5000):
    if not j in genList:
        genSum+=j

print('답은 {0} !!'.format(genSum))
print('걸린시간 : {0} 초'.format(time.time()-a))

코드에서 지적할 점이나 조언해주실 점 있으면 정말 감사하겠습니다ㅎ아직 초보라서..
읽어주셔서 감사합니다!ㅎ

#include <iostream>
using namespace std;

bool check[5000];

void setD(int i)
{
    while(true)
    {
        int idx = i;
        int tmp = i;
        while(tmp)
        {
            idx+= tmp%10;
            tmp/=10;
        }
        if(idx < 5000 && check[idx]) check[idx] = false;
        else break;
    }
}
int main()
{
    fill_n(check,5000,true);
    for(int i=1;i<5000;i++) setD(i); //d(n) > n 이므로 5000까지만 체크해도 된다.
    long long sum=0;
    for(int i=1;i<5000;i++)
        if(check[i] == true)
            sum+=i;
    cout<<sum<<endl;
    return 0;
}

C스타일로 짜본 C++코드입니다. 재밌네요...!>

public class Main 
{
    public static final int MAX_COUNT=5000;
  public static void main(String[] args)
  {
    HashMap<Integer, Boolean> selfNumCheckMap = getSelfNumCheckMap(MAX_COUNT);
    int selfNumSumValue = getSelfNumSum(selfNumCheckMap);
    System.out.println("Sum of self number is " + selfNumSumValue);
  } //void main

  public static HashMap<Integer, Boolean> getSelfNumCheckMap(int maxNum)
  {
    HashMap<Intger, Boolean selfNumCheckMap=new HashMap<Intger, Boolean>();
    for(int i=0; i<maxNum; i++)
    {
      selfNumCheckMap.put(generateNum(i), true);
    } //for i
    return selfNumCheckMap;
  } //HashMap getSelfNumCheckMap

  public static int generateNum(int num)
  {
    int generatedNum = num;
    while(num>10)
    {
      generatedNum += num % 10;
      num = (int)num/10;
    } //while
    generatedNum += num;

    return generatedNum;
  } //int generateNum

  public static int getSelfNumSum(Map<Integer, Boolean> selfNumCheckMap)
  {
    int sumValue = 0;
    for(int i=0; i<MAX_COUNT; i++)
    {
      if(null == selfNumCheckMap.get(i))
      {
        sumValue+=i;
      } //if
    } //for i
    return sumValue;
  } //int getSelfNumSum
} //class Main

자바로 짰습니다. 피씨방이라서 돌려보지는 못했어요... 아흑...

def g n
  t = n 
  n.to_s.chars do |c| 
    t += c.to_i
  end
  t
end

not_selfs = []
total = 0

(1..5000).each do |n|
  not_selfs << (g n)
  total += n unless not_selfs.include? n
end

puts "total : #{total}"

재귀함수로 작성해 보았습니다.

#include<stdio.h>
#define _LENGTH 5000

int d(int num, int origin){
    if(num == 0)
        return num;
    else 
        return (origin == 0 ? num : 0) + num % 10 + d(num / 10, 1);
}

int main(){
    int arr[_LENGTH];
    int i, temp, res = 0;
    for(i = 0; i < _LENGTH; i++)
        arr[i] = 0;
    for(i = 0;(temp = d(i, 0)) < _LENGTH; i++)
        arr[temp] = 1;
    for(i = 0; i < _LENGTH; i++)
        res += arr[i] == 0 ? i : 0;
    printf("res : %d\n", res);
    return 0;
}

..

#include <stdio.h>

unsigned int qz_getNumberOfDigits(unsigned int _n)
{
    unsigned int digits = 0;
    unsigned int n = _n;

    while(n != 0)
    {
        digits++;
        n = n / 10;
    }

    return digits;
}

unsigned int qz_computeFnD(unsigned int _n, unsigned int _digits)
{
    unsigned int digits;
    unsigned int retVal;
    unsigned int remainder;
    unsigned int divisor;
    unsigned int i;

    if(_digits == 0)
        digits = qz_getNumberOfDigits(_n);
    else
        digits = _digits;

    retVal = _n;
    remainder = _n;
    divisor = 1;
    for(i = 1; i < digits; i++)
        divisor *= 10;
    while(digits != 0)
    {
        retVal += (remainder / divisor);
        remainder = remainder % divisor;
        divisor /= 10;
        digits--;
    }

    return retVal;
}

unsigned int qz_isSelfNumber(unsigned int _n)
{
    unsigned int retVal;
    unsigned int digits;
    unsigned int i;
    unsigned int min;
    unsigned int max;
    unsigned int fnD_N;

    if(_n <= 31)
    {
        switch(_n)
        {
            case 1: case 3: case 5: case 7:
            case 9: case 20: case 31:
                retVal = 1; /* self number */
                break;
            default :
                retVal = 0;
                break;
        }

        return retVal;
    }

    retVal = 1;
    digits = qz_getNumberOfDigits(_n);
    min = _n - (9 * digits);
    max = _n -1;

    for(i = min; i <= max; i++)
    {
        fnD_N = qz_computeFnD(i, 0);

        if(fnD_N == _n)
        {
            retVal = 0;
            break;
        }

        if(fnD_N + 10 < i)
            i += 4;
    }

    return retVal;
}

unsigned int qz_getSumOfSelfNumbers(unsigned int _from,
        unsigned int _to)
{
    unsigned int sum = 0;
    unsigned int i;
    unsigned int digits;

    sum = ((_from + _to) * ((_to + 1) - _from)) >> 1;
    digits = qz_getNumberOfDigits(_to);

    for(i = _from; i < _to; i++)
    {
        if(qz_isSelfNumber(i) == 0)
            sum -= i;
    }

    return sum;
}

int main(void)
{
    unsigned int from;
    unsigned int to;
    unsigned int result;

    while(1)
    {
        printf("From: \n");
        while(scanf("%u", &from) != 1)
        {
            scanf("%*c");
            continue;
        }
        printf("To: \n");
        while(scanf("%u", &to) != 1)
        {
            scanf("%*c");
            continue;
        }
        result = qz_getSumOfSelfNumbers(from, to);
        printf("Result (%u-%u): %u \n", from, to, result);
    }

    return 0;
}

Javascript로 풀어 봤습니다.

function checkGen(n) {
  var sum = n;
  while(n>0) {
    sum += n - parseInt(n/10)*10;
    n = parseInt(n/10);
  }

  return sum;
}


var isSelfNo = new Array(5000);
var r = 0;
var i = 0;
while(r <= 5000) {
  isSelfNo[r] = 1;
  r = checkGen(++i);
}

var sum = 0;
for(i=0; i<5000; i++) {
  if( !isSelfNo[i] ) sum += i;
}

console.log(sum);

PHP 날코딩 해봤습니다.

<?php

    /********************************************************************************
    [문제] 

    어떤 자연수 n이 있을 때, d(n)을 n의 각 자릿수 숫자들과 n 자신을 더한 숫자라고 정의하자.

    예를 들어


    d(91) = 9 + 1 + 91 = 101

    이 때, n을 d(n)의 제네레이터(generator)라고 한다. 위의 예에서 91은 101의 제네레이터이다.

    어떤 숫자들은 하나 이상의 제네레이터를 가지고 있는데, 101의 제네레이터는 91 뿐 아니라 
    100도 있다. 그런데 반대로, 제네레이터가 없는 숫자들도 있으며, 이런 숫자를 인도의 수학자 
    Kaprekar가 셀프 넘버(self-number)라 이름 붙였다. 예를 들어 1,3,5,7,9,20,31 은 셀프 넘버 
    들이다.

    1 이상이고 5000 보다 작은 모든 셀프 넘버들의 합을 구하라.
    *********************************************************************************/

    $limit = 4999;
    $total = 0;

    for ( $i=1; $i <= $limit; $i++ ) {
        $gen = false;
        for ( $j=1 ; $j < $i; $j++ ) {

            //
            $row = (string)$j;
            $rowsum = 0;
            for ( $k=0; $k < strlen($row); $k++ ) {
                $rowsum += (int)$row[$k];
            }
            $sum = $j + (int)$rowsum;
            if ( $sum == $i ) {
                $gen = true;
                break;
            }
        }
        if ( !$gen ) {
            $total += $i;
            echo $i."<br/>";
        }
    }
    echo "total : ".$total;

    ?>

Haskell 버전 갑니다.

#!/usr/bin/env runhaskell

import Data.List(nub, (\\))

-- generator를 받아서 결과로 변환 합니다.
transform :: Int -> Int
transform x = (sum . splitDigit) x + x

-- 123 -> [1, 2, 3]
splitDigit :: Int -> [Int]
splitDigit x = reverse .              -- [1, 2, 3]
               map (`mod` 10) .       -- [3, 2, 1]
               takeWhile (> 0) .      -- [123, 12, 1]
               iterate (`div` 10) $ x -- [123, 12, 1, 0, 0 ... ]

main = print $ sum $ [1..4999] \\ itsNotSelfNumber    -- [1, 2, 3] \\ [1, 2] == [3]
       -- 5000 미만의 generator 목록
       where itsNotSelfNumber = nub .                 -- 중복된 숫자를 제거
                                takeWhile (< 5000) .  -- [2, 4, 6 .. 4998]
                                map transform $ [1..] -- [2, 4, 6 ... ]

$ ./selfnumber.hs
1227365
$ 

저도 어찌어찌 한참 헤매다 겨우 1227365 나왔네요.

# coding=utf-8
# Python 2.7.3에서 실행 확인 했음

def d(gen):
    a=[0,0,0,0,gen]
    n=0
    while gen>=1:
        a[n]=gen%10
        gen=gen/10
        n+=1
    return a
y=range(1,5000)
for x in range(1,5000):
    z=sum(d(x))
    if z<5000:
        y[z-1]=0
print sum(y)

저도 해봤네요 코드이그나이터로 짰구요.

<?
class Code extends CI_Controller {

    /*
        어떤 자연수 n이 있을 때, d(n)을 n의 각 자릿수 숫자들과 n 자신을 더한 숫자라고 정의하자.

        예를 들어

            d(91) = 9 + 1 + 91 = 101

        이 때, n을 d(n)의 제네레이터(generator)라고 한다. 위의 예에서 91은 101의 제네레이터이다.

        어떤 숫자들은 하나 이상의 제네레이터를 가지고 있는데, 101의 제네레이터는 91 뿐 아니라 100도 있다. 그런데 반대로, 제네레이터가 없는 숫자들도 있으며, 

        이런 숫자를 인도의 수학자 Kaprekar가 셀프 넘버(self-number)라 이름 붙였다. 예를 들어 1,3,5,7,9,20,31 은 셀프 넘버 들이다.

        1 이상이고 5000 보다 작은 모든 셀프 넘버들의 합을 구하라.
     */

     function d($number){
        $data = array();
        //자릿수
        $cnt = strlen($number);
        for($i=1;$i<=$cnt;$i++){
            $data[$number][$i] = substr($number,$i-1,1);
        }
        unset($cnt);

        $tot = $number;
        foreach($data[$number] as $key => $val){
            $tot += $val;
        }
        return $tot;
     }

     function self_sum(){
        $data = array();
        for($i=1;$i<5000;$i++){
            $data[$this->d($i)] = true;
        }

        /*echo "<pre>";
        print_r($data);
        echo "</pre>";*/ 

        for($i=1,$tot='';$i<5000;$i++){
            if(!isset($data[$i]))
             $tot += $i;
        }

        echo $tot;


     }

}

//출력결과 1227365

C#입니다

var arr = Enumerable.Range(0, 5000).Select(x => x.ToString().Select( z => Int32.Parse(z.ToString())).Concat(new [] { x }).Sum()).ToArray<int>();

var result = Enumerable.Range(0, 5000).Select(x => (arr.Where(y => x == y).Select(y => y).Count() == 0) ? x : 0 ).Sum();

Console.WriteLine(result);

MATLAB 도 괜찮은가요?

index=1:4999;
for i=1:4999
    i_4=(i-rem(i,1000))/1000;
    i_3=(i-rem(i,100))/100-i_4*10;
    i_2=(i-rem(i,10))/10-i_3*10-i_4*100;
    i_1=i-i_2*10-i_3*100-i_4*1000;
    compared(i)=i+i_1+i_2+i_3+i_4;
    index(compared(i))=0;
end
sol=sum(index);

sol = 1227365

scala 로 풀어봤습니다.

object SelfNumber {

  def gen(number: Int): Int = {
    (number % 10) + (if (number >= 10) gen(number / 10) else 0)
  }

  def generation(number: Int): Int = {
    number + gen(number)
  }

  def main(args: Array[String]) {
    var haveGenNumber = (1 until 5001).foldLeft(List[Int]())( (b,a) => b :+ generation(a))
    println((1 to 5000).toList.filterNot(haveGenNumber.contains(_)).sum)
  }
}

Ruby입니다

require 'set'

def gen(n)
    n.to_s.scan(/\d/).map(&:to_i).inject(:+) + n
end

range = 1..5000
s = range.to_set

sum = range.inject(0){|sum, num|
    sum += num if s.include?(num)
    s.delete(gen(num))
    sum
}

puts sum

Clojure 코드입니다.

(let [digits         (fn [n] (map #(Character/getNumericValue %) (str n)))
      generate       (fn [n] (apply + n (digits n)))
      generated-set  (set (map generate (range 1 5001)))
      self-numbers   (filter (complement generated-set) (range 1 5001))]
  (reduce + self-numbers))

설명

1. digits: 수 n의 각 자리 수를 구하는 함수

2. generate: 제너레이터 함수

3. generated-set: 1 ~ 5000 의 리스트을 제너레이터로 하여 생성한 값의 집합

4. self-numbers: 1 ~ 5000 의 리스트에서 generated-set 의 값들을 제외한 리스트

5. (reduce + self-numbers): self-numbers의 합계

출력값: 1227365

int GetGenData(int nData)
{   
    int nGen = nData;
    do
    {
        nGen += nData%10;
    }
    while(nData/= 10);
    return nGen;        
}
int _tmain(int argc, _TCHAR* argv[])
{
    char chHasGen[5001];
    memset(chHasGen,0,5001);
    for(int iter = 1 ;iter <= 5000 ; iter ++)
    {
        int nGen = GetGenData(iter);
        if(nGen <= 5000)
        {
            chHasGen[nGen] = 1;
        }
    }
    int nResult = 0;
    for(int iter = 1 ;iter <= 5000 ; iter ++)
        if(chHasGen[iter] == 0)
            nResult += iter;
    printf("%d",nResult);
    return 0;
}

#include <iostream>
using namespace std;

int i, j;
int d(int n, int total)
{
    total += n % 10; //자리수 더해줌.

    //재귀탈출조건
    if(n / 10 == 0)
        return j + total;

    return d(n/10, total);
}
int main(void)
{
    int total = 0;

    for(i = 1 ; i < 5000 ; ++i)
    {
        for(j = 1 ; j <= i ; ++j)
        {
            if( d(j, 0) == i )
                break;
        }

        if(j-1 == i)
            total += i;
    }

    cout << total << endl;
    return 0;
}

자바입니당

package h22_generator_selfnum;
class HelloNexon {
    int d(int n){ //함수 d(제네레이터)
        int dn=n, m;
        for(m=1;n/m!=0;m*=10) dn+=(n/m)%10;
        return dn;
    }
    public static void main(String[] args) {
    HelloNexon h=new HelloNexon();
    int L=5000, i, result=0;
    boolean[] selfnum=new boolean[L+1]; //selfnum[i] : i가 selfnum인지 여부
    for(i=1; i<L; i++) selfnum[i]=true; //selfnum 초기화
    for(i=1; i<L; i++) if(h.d(i)<=L) selfnum[h.d(i)]=false;//제네레이터 가진 숫자 골라내기
    for(i=1; i<L; i++) if(selfnum[i]==true) result+=i; //selfnum 총합
    System.out.println(result);
    }
}

console.info("selfNumber Start \n1이상이고 5000보다 작은 모든 셀프 넘버들의 합을 구하라");

// 1부터 5000보다 작은 숫자들의 배열을 생성한다.
var selfArray = new Array(4998);
var tot = 0;
for(var i = 1; i < 5000; i++){
selfArray[i] = i;
}

//제너레이터는배열에 gen라고 입력한다.
for(var i = 1; i < 5000; i++){
var genNum = parseInt(i%10) + parseInt((i/10)%10) +parseInt((i/100)%10) + parseInt((i/1000)%10) + i; //제너레이터
if(genNum > 5000) break;
selfArray[genNum] = "gen";  //해당 배열에 gen 이라고 입력
}

//self 넘버의 합계를 더한다.

for(var i=1; i<5000; i++){
if(selfArray[i] != "gen") tot += selfArray[i];
}
console.info(tot);

배열로 풀어봤어요..결과는 1227365 나왔습니다.

Ruby.

(1.upto(5000).to_a - 1.upto(5000).map{|i| i + i.to_s.scan(/./).map(&:to_i).reduce(&:+) }).reduce(&:+)

n.seq=1:4999
generate=function(n){
  len=nchar(n)
  sub.n=vector()
  for(i in seq(len)) sub.n[i]=as.integer(substr(n, i, i))  
  return(n+sum(sub.n))
}

generator=sapply(n.seq , generate)
sum(subset(n.seq, !(n.seq %in% generator)))

R로 짜봤습니다 좋은 문제 감사합니다

clojure

(defn d [n]
  (->> n
       str
       (map #(Character/getNumericValue %))
       (reduce +)
       (+ n)))



(let [r (range 1 (inc 5000))]
  (reduce + (clojure.set/difference (set r)
                                    (set (map d r)))))

def d(g):
    sum = g
    while g>0:
        quotient,remain = divmod(g, 10)
        g = quotient
        sum = sum + remain
    return sum

s = set(range(1,5000))

for i in range(1, 5000):
    v = d(i)
    if v >= 5000:
        break
    if v in s:
        s.remove(v)

print(sum(s))

이미 위에 간결한 코드들이 있지만 학습 중이므로 ^^;

gen=[]
self=[]
for i in range(1, 5001):
    j = str(i)
    j=j.zfill(4)
    gen.append(int(j[0])+int(j[1])+int(j[2])+int(j[3])+int(j))

for i in range(1, 5001):
    if gen.count(i)==0:
        self.append(i)

print sum(self)

파이썬입니다.

1부터 5000사이의 self넘버들은 gen(1)~gen(5000)보다 작기 때문에 gen(1)~gen(5000)을 만들고 1~5000중에서 gen에 없는것만 고르기 무식하네요 ㅠㅠㅎ

안드로이드...

ArrayList<Integer> list = new ArrayList<Integer>();
    private void test() {
        for(int i=0; i<5000; ++i) {
            String test = String.valueOf(i);
            int sum = i;


            for(int k=0; k<test.length(); ++k) {
                String cut = test.substring(k, k+1);
                sum += Integer.parseInt(cut);
            }

            if(5000 > sum) {
                list.add(sum);
            }
        }

        int sum = 0;
        for(int i=0; i<5000; ++i) {
            if(!list.contains(i)) {
                sum += i;
            }
        }
        Log.v("", "kdw sum:"+sum);
    }

1부터 5000사이의 숫자들을 제네레이터로 하여 셀프넘버가 아닌 Set을 만들고(5000 미만의)
그 Set에 포함되지 않는 숫자들만 더해서 셀프넘버들의 합을 구했습니다.

개념은 쉬운데 예쁘고, 간결하게 짜는 것은 어렵네요ㅠㅠ

package selfnumber;

import java.util.HashSet;

public class SelfNumber {
    private HashSet<Integer> notSelfNumberSet = new HashSet<Integer>();

    public int getSelfNumberSum(int limitNumber) {
        makeNotSelfNumberSet(limitNumber);

        int sum = 0;

        for (int i = 1; i < 5000; i++) {
            if (notSelfNumberSet.contains(i) == false) {
                sum += i;
            }
        }

        return sum;
    }

    private void makeNotSelfNumberSet(int limitNumber) {
        for (int generator = 1; generator <= limitNumber; generator++) {
            int generatedNumber = generate(generator);
            if (generatedNumber < 5000) {
                notSelfNumberSet.add(generatedNumber);
            }
        }
    }

    private int generate(int generator) {
        int generatedNumber = generator;

        do {
            generatedNumber += generator % 10;
            generator /= 10;
        } while (generator > 0);

        return generatedNumber;
    }

}

public class SelfNumber {

    /**
     * 각 숫자 길이를 len 라고 하면, 각 자릿수를 더한 합의 최대값은 9 * len 이다.
     * d(n) = 각 자릿수의 합 + n 이므로, n의 범위는 d(n) - 9 * len <= n <= d(n)
     * 
     * n이 2자리인데, d(n)이 3자리 일수도 있을까? 99 = 9 + 9 + 99 = 117 이런 경우도 상관없다.
     * 왜냐하면, d(n)의 자릿수의 길이가 항상 n의 자릿수의 길이보다 크기 때문이다.
     *
     */

    public static void main(String[] args) {
        SelfNumber sn = new SelfNumber();

        int selfNumberSum = 0;

        for (int dn = 1; dn < 5000; dn++) {
            if (sn.isSelfNumber(dn)) {
                selfNumberSum += dn;
            }
        }

        System.out.println(selfNumberSum);
    }

    public boolean isSelfNumber(int number) {
        boolean isSelf = true;

        int len = Integer.toString(number).length();

        int nStart = number - 9 * len;
        if (nStart <= 1) {
            nStart = 1;
        }

        for (int i = nStart; i < number; i++) {
            int digitSum = digitSum(i);
            int dn = digitSum + i;
            if (dn == number) {
                return false;
            }

        }

        return isSelf;
    }

    private int digitSum(int num) {
        String str = Integer.toString(num);
        int sum = 0;

        for (int i = 0; i < str.length(); i++) {
            sum += Integer.parseInt(str.substring(i, i + 1));
        }

        return sum;
    }

}

class ABCD:
    generator=list(range(0,5000))
    def d(self, i):
        i=str(i)
        j=0
        j+=int(i)
        for k in i:
            j+=int(k)
        return j


def main():
    abcd=ABCD()
    for i in range(0,5000):
        j=abcd.d(i)
        if j == i :
            continue
        else :
            try:
                abcd.generator.remove(j)
            except:
                pass
    print(abcd.generator)
    sumGnrt=0
    for sum in abcd.generator:
        sumGnrt+=sum
    print("셀프 넘버의 합 :",sumGnrt)

main()

다른사람에 비해서 좀 지저분해보이네요 ㅠㅠ

def d(num2):
    result=num2
    for i in str(num2):
        result = result + int(i)
    return result 

gene=[]
for i in range(1,5001):
    gene.append(i)

for i in range(1,5001):    
    if d(i) in gene:
        gene.remove(d(i))

print sum(gene), gene

잠깐 생각해서 만들어 봤습니다... 파이썬이구요

def d(n):
    a = str(n)
    for x in a : n += int(x)
    return n

print sum(set([x for x in range(1,5001,1)]) - set([d(x) for x in range(1,5001,1)]))

처음 올려봤는데 나름 재밌네요^^

python 2.7.3 으로 작성하였습니다. 먼저 1부터 5000까지 list를 만들고 gernerating 하여 나오는 숫자를 하나씩 제거합니다. 최소 1+5000=5001이므로 5000번의 loop만 돌리면되고, loop 이후 남는 숫자들이 selfNumber가 되므로 마지막에 sum 만 해주면됩니다. 답은 1227365

selfNum = [i for i in range(5001)]

for i in range(1, 5001) :
    sum = i
    temp = list(str(i))
    for j in temp :
        sum += int(j)

    if sum in selfNum :
        selfNum.remove(sum)

answer = 0
for i in selfNum :
    answer += i

print answer

파이썬 3.2.5 기준입니다.

def d(n):
    L1 = list(str(n))
    return sum([int(N) for N in L1]) + n
L = [n for n in range(5001)]
for n in range(5001):
    if n == d(n):
        continue
    if d(n) in L:
        L.remove(d(n))

print(sum(L))

//유니티 C#으로 도전해봤어요. 실력이 워낙 없어서 좀 지저분합니다. ^^ 의지의 한국인 정도로 생각해주세요~

using UnityEngine;
using System.Collections;

public class NexonQuiz {

    // Use this for initialization
    void Start () {
        int[] array = new int[5000];
        for(int i = 1; i < 5000; i++){
            int gene = getGenerator(i);
            if( gene < 5000 )
                array[gene] = gene;
        }

        int sum = 0;
        for(int i = 1; i < 5000; i++){
            if( array[i] == 0 )
                sum += i;
        }

        Debug.Log( sum ); // 정답: 1227365
    }

        //제너레이터 구하기
    private int getGenerator(int integer){
        int chpher = getCipher(integer);
        int[] array = new int[chpher];

        int nTemp = integer;
        for(int i = 0; i < chpher; i++){
            array[i] = nTemp % 10;
            nTemp = nTemp / 10;
        }
        int sum = 0;
        for(int i = 0; i < chpher; i++){
            sum += array[i];
        }

        return sum + integer;
    }

        //자릿수 구하기
    private int getCipher(int integer){
        int count = 0;
        int nCheck = 1;
        while( integer / nCheck > 0 ){
            nCheck *= 10;
            count ++;
        }

        return count;
    }
}

회사에서 빈둥빈둥하다 최근에 배우고 있는 swift로 작성해보았습니다.

var generatorArray:Array<Int> = [];

// 제너레이터 판별하는 함수
func hasGeneratorNumber(number:Int) -> Bool {
    if find(generatorArray, number) {
        return true
    }
    return false
}
// 제너레이터 만드는 함수
func makeGeneratorNumber(number:Int)-> Int {
    var tmpNumber = number
    var result = 0
    // 각 자릿수 숫자들의 합을 구합니다.
    do {
        result += tmpNumber % 10
        tmpNumber /= 10
    } while tmpNumber != 0
    // 자신을 더하여 최종적인 제너레이터를 얻습니다.
    result += number

    return result;
}


var result:Int = 0;
for i in 1..5001 {
    //현재 숫자가 제너레이터가 없다면 셀프 넘버이다.
    if !hasGeneratorNumber(i) {
        result += i;
    }
    // 제너레이터 숫자를 생성합니다.
    let generatorNumber:Int = makeGeneratorNumber(i)
    // 제너레이터 숫자가 존재하지 않는다면 제너레이터 배열에 추가합니다.
    if !hasGeneratorNumber(generatorNumber) {
        generatorArray.append(generatorNumber);
    }
}

println("Result : " + result)

파이썬 공부한지 얼마 안되서 기본 문법을 공부하면서 작성해보았습니다. 다른 분들하신거에 비해 많이 부족하네요. 파이썬 공부 얼마 안하신 분들이 참고하시면 좋을 거 같습니다.

Python 2.6.6

max_range = 5000

def d(n):
    n_total = n 
    for i in str(n):
        n_total += int(i)
    return n_total

def main():
    sel_num_total = 0 
    sel_num_list = []

    for n in range(1,max_range):
        sel_num_list.append(d(n))

    for n in range(1,max_range):
        if not n in sel_num_list:
            sel_num_total += n

    print "Total: "+str(sel_num_total)

if __name__ == "__main__":
    main()

PHP 입니다.

function print5($init=1, $limit=4999) {
    $arr = range($init, $limit);
    foreach ($arr as $n) {
        $arr_gen[$n] = $this->d($n);
    }
    $arr_sum = array_sum(array_unique(array_diff($arr,$arr_gen)));  /* 합(중복제거(셀프넘버만 남기기)) */
    echo $arr_sum;
}
function d($n) {
    $d_val = $n;
    $len = strlen($n);
    for($i=0;$i<$len;$i++) {
        $tmp_n = substr($n,$i,1);
        $d_val += $tmp_n;
    }
    return $d_val;
}

1227365 나오네요

다른 분들 풀이를 보다보니, 파이썬을 공부해봐야겠다는 생각이 꿈틀꿈틀하네요. :)

C++11 입니다.

#include <iostream>
#include <set>
#include <numeric>

class SelfNumbersIn
{
public:
  SelfNumbersIn(const int& range) {
    for (int i = 1; i < range; ++i) numbers_.insert(i);
    for (int i = 1; i < range; ++i) numbers_.erase(d(i));
  }
  int Sum() const {
    return std::accumulate(numbers_.begin(), numbers_.end(), 0);
  }
private:
  int d(int n) {
    int sum = n;
    while(n > 0) {
    sum +=  n % 10;
    n = n / 10;
    }
    return sum;
  }
  std::set<int> numbers_;
};

int main()
{
  std::cout << SelfNumbersIn(5000).Sum() << std::endl;
  return 0;
}

$ g++ generator_c11.cpp -std=c++11 && ./a.out
1227365

  1 #!/usr/bin/env python
  2 #-*- encoding:utf-8 -*-
  3 def check(num):
  4     base = num
  5     while 1:
  6         total = 0
  7         number = str(num)
  8         lenth = len(number)
  9
 10         for i in range(lenth):
 11             total = total + int(number[i])
 12         total = total + num
 13         if total == base:
 14             return 0 #셀프 넘버가 아닌것들은 0으로 리컨
 15         num = num - 1
 16         if num == 0:
 17             return base #self number 인 값을 리턴
 18
 19
 20 result = 0
 21 for i in range(1,5001):
 22     result = result + check(i)
 23 print result

python 2.7.2 기준입니다.

출력 결과 :

My_home$ python self_number.py

1227365

===============================================================

간단한 설명

:- 일단 속도는 빠르지는 않습니다. ( 좋은 코딩이라고 보기는 어려울것 같습니다. )

:- 숫자를 넣었을때 일단 ex) 112 -> 1+1+2 + 112 가 112인지 체크 합니다. 아니라면 , 다음스텝에 1줄여서 111로......이런식으로

:- 값이 매칭이되면 0리턴, 셀프 넘버면 셀프 넘버값 리턴

:- 반복문으로 호출하며 값을 더해줍니다.

:- 끝

c언어로 짜보았습니다.

#include <stdio.h>
#define MAX 5000
int Return_Generator(int number);
typedef enum {false, true} bool;


int main()
{
    // 1차원 배열로 인덱스+1 = N,  배열의 값이 false이면 셀프넘버.  배열의 값이 true이면 제네리이터라고 한다
    int CheckGen[MAX];
    int i;
    int Gen_index=0;
    int sum=0;

    // 배열 초기화
    for(i=1; i < MAX; i++)
    {
        CheckGen[i]=false;
    }


    for(i=1; i < MAX; i++)
    {
        Gen_index=Return_Generator(i);
        if(Gen_index < MAX)  // 5000을 넘는 값은 문제의 범위를 넘어가기 때문에 알 필요가 없다.
        {
            CheckGen[Gen_index-1]=true;
        }
    }

    for (i=0; i < MAX; i++)
    {
        if(CheckGen[i]==false)
        {
         //   printf("%d  ", i+1);
            sum = sum+ (i+1);
        }
    } 
    printf("Sum= %d\n",sum);


}

// d(n)값을 리턴한다.
int Return_Generator(int number)
{
    int Return_Value=0;
    int TargetNumber=0;
    int LastNumber=0;

    TargetNumber=number;

    while(TargetNumber > 0)
    {
        LastNumber = TargetNumber % 10;
        TargetNumber=TargetNumber /10;
        if(TargetNumber == 0)
        {
            return Return_Value += LastNumber + number;
                // 마지막에 최고 자릿수의 넘버와, 자기자신을 더하고 리턴시킨다.
        }else{
            Return_Value += LastNumber;
        }
    }
}

def cal_generator(num):
    result = 0
    tmp = str(num)
    for item in tmp:
        result = result + int(item)
    result = result + num
    return result

sample = range(1,5000)
temp_list = []

for item in sample:
    tmp = cal_generator(item)
    if tmp in range(1,5000):
        temp_list.append(tmp)

temp_list.sort()
result = 0

for item in range(1,5000):
    if item not in temp_list:
        result = result + item

print result

scala로 풀어봤습니다.

scala> (1 until 5000).filterNot( (1 until 5000).map( (m:Int)=>m+m.toString.map(_.asDigit).sum ).toSet ).sum
res4: Int = 1227365

#include <stdio.h>

#define TRUE 1
#define FALSE 0

int IsSelfNumber( int num )
{
    int i, temp, self_sum;

    for( i = 1; i < num; i++ )
    {
        temp = i;
        self_sum = 0;

        while( temp > 0 )
        {
            self_sum += temp % 10;
            temp /= 10;
        }

        if(( self_sum + i ) == num )
        {
            return FALSE;
        }
    }

    printf("%d is Selfnumber \r\n", num );
    return TRUE;
}

void main()
{
    int i, sum;

    sum = 0;

    for( i = 1; i < 5000; i++)
    {
        if( IsSelfNumber(i) == TRUE )
            sum += i;
    }

    printf("sum : %d\r\n", sum );
}

Python 열공할려고 처음으로 만들어봤어요. v3.4.1

def generator(inputnum):
    return inputnum + sum([int(i) for i in str(inputnum)])


targetnums = range(1,5001)
print (sum(set(targetnums) - set(map(generator, targetnums))))

저도.. python3.3.2 입니다.

print(sum(set(range(1,5001))-set(map(lambda n:sum(map(int, str(n)))+n, range(1,5001)))))

근데 짧은게 정답만은 아닌듯;

def d(n):
    nn = str(n)
    sum = n
    for s in nn:
        sum += int(s)
    return sum

def dset(i, j):
    result = set()
    for x in range(i, j):
        result.add(d(x))
    return result

print(sum(set(range(1, 5000)) - dset(1, 5000)))

파이썬 공부하는 중입니다.

public class generator {

    private static int d(int num) {
        int x1 = num % 10;
        int x10 = (num / 10) % 10;
        int x100 = (num / 100) % 10;
        int x1000 = num / 1000;

        return num + x1 + x10 + x100 + x1000;
    }

    public static void main(String[] args) {

        int sum = 0;

        outer: for (int i = 1; i < 5000; i++) {
            for (int j = 1; j < i; j++) {
                if (i == d(j)) {
                    continue outer;
                }
            }
            sum += i;
        }
        System.out.println(sum);
    }
}

자바입니다.

코딩배운지 이제 1년 반 다되가는 고등학생입니다. 이제 c와 c++, 자바를 조금 할 수 있는데.. 여기 와 보니 전 우물안의 개구리였군요 ㅠㅠ 더 열심히 배우도록 하겠습니다!

노란띠 되려고 풀이 같지도 않은 풀이를 작성하네요 양해바랍니다.

코드:

#include <iostream>
#include <vector>

using namespace std;

int getGenerator(int);

void main() {

    vector<int> selfNumbers;
    int normalSum = 0;
    int generatorSum = 0;

    for(int i = 1; i < 5001; i++) {
        normalSum += i;

        int generator = getGenerator(i);
        bool overlap = false;
        for(int j = 0; j < selfNumbers.size(); j++)
        {
            if(selfNumbers[j] == generator)
            {
                overlap = true;
                break;
            }
        }

        if(!overlap && generator <= 5000) {
            selfNumbers.push_back(generator);
            generatorSum += generator;
        }
    }

    cout<<normalSum-generatorSum<<endl;
}

int getGenerator(int n)
{
    int sum = n;

    while(true) {
        sum += n % 10;
        n /= 10;
        if(n == 0)
            break;
    }

    return sum;
}

출력값 :

1227365

이렇게 짜 두었습니다. 방학이라 오랜만에 코딩하니 어렵네요.. 노가다 방식으로 무식하고 무난(?)하게

(1부터 5000까지 자연수 합) - (1부터 5000까지 제너레이터 합) = (1부터 5000까지 셀프넘버 합)

이렇게 구했네요.

이제부터 코드를 효율적으로 짜는 방법을 익혀야죠!! 화이팅!

#include <iostream>
using namespace std;

#define MAX 5000

int tempArr[MAX];

int calcNum(int a)
{
    int sum = a;
    while (a != 0)
    {
        sum += a % 10;
        a /= 10;
    }
    return sum;
}

bool checkSelfNum(int num)
{
    for (int j = 0; j < MAX; j++)
    {
        if (tempArr[j] == num)
        {
            return false; //셀프넘버x
        }
    }
    return true;//셀프넘버  
}

void init()
{
    int tmp = 0;
    for (int i = 0; i < MAX; i++)
    {
        tmp = calcNum(i);
        tempArr[i] = tmp;
    }
}

int main()
{
    init();

    int res = 0;

    for (int i = 0; i < MAX; i++)
    {
        if (checkSelfNum(i))
        {
            //cout << "self Number -> " << i << endl;
            res += i;
        }
    }
    cout << res << endl;
    return 0;
}

c++ 로 했구요 ... 속도가 느리네요.. 50000만 되도..;;ㅠ

def d(n):
    val = n
    for i in str(n):
        val += int(i)
    return val

def gen(x):
    generator = [x for x in range(1,x)]
    for i in range(1,x):
        val = d(i)
        if val in generator:
            generator.remove(val)
    return sum(generator)

print (gen(5000))

// java

> // System.out.println(selfNumberSum(5000));
    public static int selfNumberSum(int n) {
        int[] memo = new int[n];
        for(int i=1; i<n; i++)
            saveDn(memo, i, n);

        int sum = 0;
        for(int i=1; i<n; i++)
            if(memo[i] == 0)
                sum += i;

        return sum;
    }

    private static void saveDn(int[] tab, int i, int n) {
        int dn = i + sumDigits(i);
        if(dn < n)
            tab[dn] = 1;
    }

    private static int sumDigits(int n) {
        return n==0 ? 0 : n%10 + sumDigits(n/10);
    }

result : 1227365

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;


public class GeneratorTest {
    /** 
     * 
     * 어떤 자연수 n이 있을 때, d(n)을 n의 각 자릿수 숫자들과 n 자신을 더한 숫자라고 정의하자.
     * d(91) = 9 + 1 + 91 = 101
     * 이 때, n을 d(n)의 제네레이터(generator)라고 한다. 위의 예에서 91은 101의 제네레이터이다.
     * 제네레이터가 없는 숫자를 인도의 수학자 Kaprekar가 셀프 넘버(self-number)라 이름 붙였다.
     * 예를 들어 1,3,5,7,9,20,31 은 셀프 넘버 들이다.
     * 1 이상이고 5000 보다 작은 모든 셀프 넘버들의 합을 구하라.
     * 
     */
    private final static int MAX_NUM = 4999;


    public static void main(String[] args) {


        Set<Integer> noSelfNum = getNoSelfNum(MAX_NUM); //셀프넘버가 아닌 숫자 셋.        

        int result = getSum(MAX_NUM) ;  // 1부터 4999까지의 합

        Iterator<Integer> noSelfNumIter = noSelfNum.iterator();
        while(noSelfNumIter.hasNext()) {    // 뺍니다.
            result -= noSelfNumIter.next();
        }

        System.out.println("result : " + result);
    }

    public static Set<Integer> getNoSelfNum(int maxNum) {
        Set<Integer> noSelfNum = new HashSet<Integer>();
        int num;
        for(int i = 1; i <= maxNum; i++) {
            //ex)1342 -> 1+3+4+2+1342 = 1352. 
            num =  i; //1342
            num += i % 10; //1342 % 10 = 2
            num += (i/10) % 10; // 134 % 10 = 4
            num += (i/100) % 10;    // 13 % 10 = 3
            num += i/1000;  //1         

            if(num > maxNum) continue;

            noSelfNum.add(num);

        }
        return noSelfNum;
    }

    public static int getSum(int maxNum) {
        if(maxNum%2 == 0) return (1+maxNum) * (maxNum/2);
        return (1+maxNum) * (maxNum/2) + (maxNum/2+1); 
    }
}

def d(n)
  n[0].to_i + n[1].to_i + n[2].to_i + n[3].to_i + n.to_i 
end

sum = 0

(1..5000).each do |i|
  true_check = false
  (1..i).each do |ii|
    true_check = true if d(ii.to_s) == i 
  end
  sum = sum + i unless true_check
end
puts sum

일단 답을 빨리 찾자고 생각하고 코딩한건데.. 다른 분들 보니까 진짜 내공이 장난아니군요.. 많이 배워갑니다!

Delphi

var
  boolArrary: Array of Boolean;
  n,nLength,dn,divNumber,sumSelfNum:Integer;
begin
  SetLength(boolArrary,5000); 
  try
    { TODO -oUser -cConsole Main : Insert code here }
    dn := 0;
    for n := 1 to 5000 do
    begin
      for nLength := 1 to Length(IntToStr(n)) do
      begin
        divNumber := StrToInt(Copy(IntToStr(n),nLength,1)); 
        dn := dn + divNumber;
        if nLength = Length(IntToStr(n)) then
          dn := dn + n; 
      end;
      if dn <= 5000 then
        boolArrary[dn] := True; 
      dn := 0;
    end;
    sumSelfNum := 0;
    for n := 1 to 5000 do     
      if not (boolArrary[n]) then
        sumSelfNum := sumSelfNum + n;
    Writeln('1 ~ 5000 사이의 self number 합');
    Writeln('SumSelfNum = ' + IntToStr(sumSelfNum));
    Readln;
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;

def gen(num):
    result = num
    for x in str(num):
        result = result + int(x)
    return result

gen_result = set()

for x in range (1,5000):
    result = gen(x)
    gen_result.add(result)

self_set = set(range(1,5000))-gen_result
print(sum(self_set))

JAVA로 풀어봤습니다.

public static int generate_number(int x){
    int num=x, sum=x;
    while(true){
        if(num==0) break;
        sum+=num%10;
        num/=10;
    }

    return sum;
}
public static void main(String[] args) {
    int area=5000, 
        sum=0;
    List generated_numbers=new ArrayList<Integer>();

    for(int i=1;i<area;i++)
        generated_numbers.add(generate_number(i));

    for(int i=1;i<area;i++){            
        if(generated_numbers.indexOf(i)==-1)
            sum+=i;
    }       
    System.out.printf("solution is %d.\n",sum);
}

여기 오늘 가입했습니다... 그냥 for문으로 노가다ㅠㅠ.....

/*어떤 자연수 n이 있을 때, d(n)을 n의 각 자릿수 숫자들과 n 자신을 더한 숫자라고 정의하자.
예를 들어
d(91) = 9 + 1 + 91 = 101
이 때, n을 d(n)의 제네레이터(generator)라고 한다. 위의 예에서 91은 101의 제네레이터이다.
어떤 숫자들은 하나 이상의 제네레이터를 가지고 있는데, 101의 제네레이터는 91 뿐 아니라 100도 있다.
그런데 반대로, 제네레이터가 없는 숫자들도 있으며, 
이런 숫자를 인도의 수학자 Kaprekar가 셀프 넘버(self-number)라 이름 붙였다. 
예를 들어 1,3,5,7,9,20,31 은 셀프 넘버 들이다.
1 이상이고 5000 보다 작은 모든 셀프 넘버들의 합을 구하라.*/

#include "stdafx.h"
#include <iostream>

using namespace std;

int gener (int num);

int _tmain(int argc, _TCHAR* argv[])
{
    int self_num[5001]={0}; //제네레이터가 될때마다 1씩증가
    int i;
    int sum=0;//셀프넘버의 합

    for(i=1;i<5000;i++)
    {

        self_num[gener(i)]+=1;
        //제너레이션이 발생하면 그 자리에 맞는 값이 1씩증가 합니다.
        //gener[4988]=0이면 셀프 넘버
    }

    for(i=1;i<5000;i++)
    {
        if(self_num[i]==0)
        {
            cout<<i<<"  "<<self_num[i]<<endl;
            sum+=i;
        }
    }
    cout<<"1~5000까지의 self_number의 합은 "<<sum<<" 입니다.\n";
    return 0;
}

int gener(int num)
{
    int i=1000;
    int val=num;
    int a=0;

    while(i>0)
    {
        a=num/i;//각 자릿수를 구합니다.
        val+=a;//제너레이션
        num-=a*i;//젤앞의 수부터 차례대로 지웁니다.
        if(val>5000)
        {
            val=0;
            break;
            //만약 제너레이션 값이 5000이상이 나왔으면 0을 출력합니다.
        }
        i=i/10;
    }

    return (val);
}

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var sumOfSelfNumbers = 0;
        var generatedNumbers = new List<int>();

        for (var i = 1; i < 5000; i++)
        {
            if (generatedNumbers.Contains(i) == false)
            {
                sumOfSelfNumbers += i;
            }
            generatedNumbers.Add(d(i));
        }

        Console.WriteLine("sumOfSelfNumbers = " + sumOfSelfNumbers);
    }

    static int d(int number)
    {
        var generate = number;
        var digits = number.ToString().ToCharArray();

        foreach (var aDigit in digits)
        {
            generate += Int32.Parse(aDigit.ToString());
        }

        return generate;
    }
}

Java

public static void main(String args[]) {                      

    int[] generator = new int[5000];
    int sumSelfnumber = 0; 

    for (int i = 1; i < 5001; i++) {       // generator가 있는 값
        int temp = i;
    while (temp != 0) {
        item[i - 1] += temp % 10;
        temp = temp / 10;
        if (temp == 0) 
            generator[i - 1] += i;
    }
    }

go: for (int j = 1; j < 5001; j++){        // 1 ~ 5000 중에 generator가 있는 값을 제외하고 모두 더한다
    for (int i = 0; i < 5000; i++)         // (self-number들의 합)     
        if (j == generator[i])               
            continue go;
        total += j;
   }

   System.out.println("1~5000 셀프 넘버들의 합 : " + sumSelfnumber);
}

//C로 짰습니다.

#include <stdio.h>
#include <stdlib.h>

int get_Dn(int input);
int filtering_and_Sum(char* _filter, int size);

int main()
{
    int MaxNum, i, result;
    char* filter; //true, false값을 체크하는 array
    printf("자연수를 입력하시오 : ");
    scanf("%d", &MaxNum);
    filter = (char*)malloc(sizeof(char)*MaxNum);
    for (i = 0; i < MaxNum; i++){
        *(filter + i) = 1;
    }

    result = filtering_and_Sum(filter, MaxNum);
    printf("-----------------------------\n\n");
    printf("The Summation of Self_Number is : %d\n", result);

    free(filter);
    return 0;
}

int get_Dn(int input)
{
    int output;
    int divisor=10;
    output = input;
    for (; 10*input/divisor; input /= divisor){
        output += input % divisor;
    }
    return output;
}


int filtering_and_Sum(char* _filter, int size)
{
    int i;
    int sum = 0;
    for (i = 1; i < size+1; i++){
        if (get_Dn(i) <= size)
            _filter[get_Dn(i)-1] = 0; // Self_Num이 아닌 경우 false값 지정
    }
    printf("self_number from 1 to %d...\n", size);
    for (i = 1; i < size+1; i++){
        if (_filter[i-1]){
            printf("%d\n", i);
            sum += i;
        }
    }
    return sum;
}

// Java

public class SelfNumber {
    private static final int N = 5000;
    private static final int K = 10000;
    private static boolean[] self = new boolean[N];

    public static void main(String[] args) {
        int result = 0;
        for (int i = 0; i < N; i++) {
            result = i + calc(i, K);
            if (result < N) self[result] = true;
        }

        int sum = 0;
        for (int i = 1; i < N; i++) {
            if (self[i] == false) sum += i;
        }

        System.out.println(sum);
    }

    public static int calc(int i, int k) {
        if (k == 10) return (i%k) / (k/10);
        return ((i%k) / (k/10)) + calc(i, k/10);
    }
}

Recursion 사용해봤습니다.

erlang 있나요? OTP 17.3에서 테스트해봤습니다.

sets 안쓴 버전입니다.

-module(generator_sum).
-export([check/1]).

% sum for each digits
s(N) -> N rem 10 + case N < 10 of true -> 0; false -> s(N div 10) end.

check(N) ->
    L = lists:seq(1, N),
    lists:sum([X || X <- L, fun(Y) -> not lists:member(Y, [fun(Y) -> Y + s(Y) end (X) || X <- L]) end(X)]).

sets쓰면...

-module(generator_sum).
-export([check/1]).

% sum for each digits
s(N) -> N rem 10 + case N < 10 of true -> 0; false -> s(N div 10) end.

check(N) ->
    L = lists:seq(1, N),
    lists:sum(sets:to_list(sets:subtract(sets:from_list(L), sets:from_list([fun(Y) -> Y + s(Y) end (X) || X <- L])))).

실행은...

generator_sum:check(5000).

def d(n):
    dd = str(n)
    nn = 0
    for i in dd:
        nn += int(i)
    return n + nn

ll = []

for i in range(1,5050):
    if d(i) >= 5000:
        pass
    else:
        ll.append(d(i))

answer = sum(list(range(5000))) - sum(list(set(ll)))
print(answer)

print( sum(set(range(1,5000)) - {x+sum([int(i) for i in str(x)]) for x in range(1,5000)}) )

scala> def d(n: Int): Int = {
     | n + n.toString.map(_.asDigit).sum
     | }
d: (n: Int)Int

scala> def dlist(n: Int): Stream[Int] = d(n) #:: dlist(n + 1)
dlist: (n: Int)Stream[Int]

scala> (1 to 5000) diff dlist(1).takeWhile(_ <= 5000) sum
res8: Int = 1227365

scala> def d(n: Int): Int = {
     | n + n.toString.map(_.asDigit).sum
     | }
d: (n: Int)Int

scala> def dlist(n: Int): Stream[Int] = d(n) #:: dlist(n + 1)
dlist: (n: Int)Stream[Int]

scala> (1 to 5000) diff dlist(1).takeWhile(_ <= 5000) sum
res8: Int = 1227365

#include <iostream>

using namespace std;


void main() {
    int const num = 5000;
    int sum = num * (num - 1) / 2;
    int check[num] = { 0, };

    for (int j = num; j != 0; j--) {
        int i = j;
        int g = 0;
        g += i;
        g += i % 10;
        while (i >= 10) {
            i /= 10;
            g += i % 10;
        }
        if (g<num && check[g] == 0) {
            sum -= g;
            check[g] = 1;
        }
    }

    cout << sum << endl;
}

public class test {

    public static void main(String[] args) {

        boolean[] list = new boolean[5000];
        int x;
        int namuji; //나머지 
        int mok; //몫
        int sum; //제네레이터에 의해 생성된 수
        int i;
        int sum2 = 5000*2499+2500; //총합을 누적하는 변수


        for(i = 0; i<5000; i++)
        {
            list[i] = false;
        }


        for(i = 1; i<5000; i++)
        {
            mok = i; 
            sum = i;

            //제네레이터에 의한 합 구하기
            while(mok>=1)  
            {  
                namuji = mok % 10;   
                mok = mok / 10;
                sum = sum + namuji;
            }  

            //제네레이터에 의해 생성된 수만 list 배열에서 true로 지정하고 누적 합에서 빼기
            if(sum < 5000)
            {
                list[sum] = true;
            }

            if(list[i] == true)
            {
                sum2 = sum2 - i; 
            }
        }

        System.out.println("셀프 넘버의 합은 "+sum2+"입니다.");
    }
}

답은 1227365 입니다.

set을 안쓰고 풀어보았습니다.

l = [0] + [1]*(5000-1)
for i in range(1, 5000):
    d = sum((int(x) for x in str(i))) + i
    if d < 5000:
        l[d] = 0
print sum(l)

JavaScript

var i = 0
var arr = new Array(5001).join('0').split('').map(parseInt);
while (1) {
    var j = i++;
    var s = j;
    while(j > 0) {
        s += j - parseInt(j / 10) * 10;
        j = parseInt(j / 10);
    }
    if (s >= 5000) break;
    arr[s] = 1;
}

var r = 0;
arr.forEach(function(e, n) {
  r += e ? 0 : n;
});

console.log(r);

#include <iostream>
using namespace std;


bool checkGenerator(int input);// 이숫자가 제네레이터가 있는가
int d(int input); // 제네레이터 값

int main(){

    int result = 0;

    for (int i = 1; i <= 5000; i++)
    {
        if (checkGenerator(i) == false)
        {
            cout << i << endl;
            result += i;
        }
    }

    cout << "result = " << result << endl;
}

int d(int input)
{
    int temp = input;
    int result = 0;
    if (input < 10)
        result += input;
    while (temp >= 10)
    {
        result += temp % 10;
        temp /= 10;
        if (temp < 10)
            result += temp;
    }
//  cout <<"g = "<<input <<" "<< result + input<<" end"<<endl;
    return result + input;
}

bool checkGenerator(int input)
{
    for (int i = 1; i <= input-1; i++)
    {
        if (d(i) == input)
            return true;
    }
    return false;
}

파이썬을 배워봐야겠네요

self_nums = range(1,5001)               #self number의 후보를 리스트로 만듭니다.

for gen in range(1,5001):               #generator는 반드시 generate한 숫자보다 작으니까 있더라도 1-5000중에 있습니다.
    gen_str = str(gen)              #generator의 각 자릿수를 뽑아내기 위해 스트링으로 바꿉니다
    sum_digits = 0                  #자릿수의 합을 초기화합니다.
    for digit in gen_str:               
        sum_digits += int(digit)        #자릿수의 합을 구합니다.
    generated_num = sum_digits + gen        #자릿수의 합과 generator를 더해서 최종 generate된 숫자를 구합니다.
    if generated_num in self_nums:          
        self_nums.remove(generated_num)     #만약에 generate된 숫자가 self number 후보 안에 있다면 그 수를 후보 리스트에서 지웁니다.
                            #이렇게 해서 후보 리스트 안에는 self_number들만 남습니다.
final_sum = 0                       #셀프 넘버 합을 초기화합니다.
for self_num in self_nums:
    final_sum += self_num               #셀프 넘버 합을 구합니다.

print final_sum                     #셀프 넘버 합을 출력합니다.

def generate(num):
  return num + sum([int(d) for d in str(num)])

generated = set([generate(n) for n in range(1, 5000)])
all_num = set(range(1, 5000))

print(sum(all_num - generated))

다른 답을 봐버려서 비슷하게 나오네요.. 다음번엔 다른 답 안보고 도전...

Perl

for(1..4999){my$a=$_;my$b=0;for(split(//,$a)){$b+=$_}$c[$a+$b]++;$d+=$a if $c[$a]<1}print$d;

문제에 나왔듯 한 수가 여러 제너레이터를 가질 수 있기 때문에 총합에서 그냥 빼면 다른 값이 나옵니다.

[1,4999]의 정수는 제너레이터를 2개까지 갖는 것만 보입니다.

파이썬은 접해본지 얼마 안되서 잘 모르니 처음엔 이렇게 1~4999까지 값들을 list에 놓고 d(n) 으로 제거해가면서 했습니다.

lst=range(1,5000)

def d(n):
    tot = 0
    for c in str(n):
        tot += int(c)
    tot += n
    return int(tot)

for i in range(1,5000):
    if d(i) in lst:
        lst.remove(d(i))

print lst
print type(lst)
print sum(lst)

Ruby

puts ((1...5000).to_a - (1...5000).collect { |x| x + x.to_s.split('').map(&:to_i).inject(:+) }).inject(:+)

Scala

def d(n:Int):Int = if(n == 0) 0 else (n % 10) + d(n / 10)
(1 until 5000).diff(for(i <- 1 until 5000) yield i + d(i)).sum

python 3.4

답변들이 많아서 먼저 풀어보고 다른 답변들을 보니, 역시나 간결하고 좋은 코드들이 많이 있네요.

generator = []
for i in range(1,5000):
    strNo = str(i)
    sumNo = 0
    for j in range(len(strNo)):
        sumNo = sumNo + int(strNo[j])
    sumNo = sumNo + i
    generator.append(sumNo)
print(sum(set(range(5000))-set(generator)))

#include <stdio.h>

int check[5000];

int main()
{
    int sum;
    int i,tmp=0;
    for(i=0;i<5000;i++)
    {
        if(i<9)
        {
            tmp = i+i;

        }
        else if( i<99)
        {
            tmp = i+ (i/10)+(i%10);

        }
        else if(i<999)
            tmp = i+ (i/100)+(i/10)+(i%10);
        else if(i<4999)
            tmp = i+ (i/1000)+(i/10)+(i%10);

        if(tmp <= 5000)
            check[tmp] = 1;

    }
    for(i = 0 ; i < 5000; i++)
    {
        if(check[i]==0)
            sum+=i;
    }
    printf("%d", sum);
}

처음 구할 리스트를 정했습니다.

last_list=[]
new_list=[]
sum=0

그다음 자신의 수와 자신의 개개인의 수를구하는 함수를 만들었습니다.

def get_value(value):
    list=[]
    value2=str(value)
    for i in value2:
         list.append(i)
    value4=0
    for t in list:
        value3=int(t)
        value4=value4+value3
    return value4+value

그럼 5000 까지중에 리스트에 없는 것을 하나씩 구했습니다.

for k in range(5000):
     key=get_value(k)
     if key not in last_list:
            last_list.append(key)

그럼 5000 까지 해서 없는 값을 구하고

for key in range(5000):

     if key not in last_list:
            new_list.append(key)

이제 합을 구합니다.

for i in new_list:
    sum=sum+i
print sum

a = set(range(1,5000))
c = set(num+sum(int(a) for a in str(num)) for num in range(1,5000))

print sum(a-c)

어차피 제네레이터를 돌리면 자신의 수보다 최소 1은(100같은경우) 더 크므로 제네레이터를 돌리는 수보다 작은 수들중 셀프 넘버를 찾으면 되므로 제네레이터를 돌리면서 자신이 셀프넘버인지 확인.

나올 수 있는 최대 수는 자리수 = n 이라고 하면 9*n + (10^(n+1))-1 이므로 if문 하나 더 넣는것보다 배열 조~금더 주는게 좋다고 생각했습니다.

조언 부탁드립니다 ㅎㅎ;;

int d(int a)
{
    if(a<10)
        return a;
    return a%10+d(a/10);
}
main()
{
    int i,num[5100]={0,},sum=0;
    for(i=1;i<=5000;i++)
    {
        num[d(i)+i]=1;
        if(!num[i])sum+=i;
    }
    printf("%d",sum);
}

def d(n: Int): Int = {
  n + n.toString.map(_.asDigit).sum
}

val generators = (1 to 5000).map(d)
val numbers = 1 to 5000

val result = numbers.diff(generators).sum

스칼라로 풀어봤어요. scala 2.11.5

파이썬으로 풀어 보았습니다. 1~5000까지 모든 숫자에 대한 연산 결과를 hasGen 리스트에 추가한 후, i번째 숫자가 리스트 hasGen에 없으면 total에 누적하여 더하는 방식으로 구했습니다.

hasGen = []
begin=1
end=5000
total=0
for i in range(begin,(end+1)) :
    a1 = int(i/1000)%10
    a2 = int(i/100)%10
    a3 = int(i/10)%10
    a4 = i%10
    result = sum([a1, a2, a3, a4]) + i
    hasGen.append(result)
    if i not in hasGen:
        total += i
print(total)

vegan님의 코드를 참조하여 조금 더 간단히 고쳐 보았습니다.

hasGen = []
begin=1
end=5000
total=0
for i in range(begin,(end+1)) :
    result = i
    for j in str(i): result += int(j)
    hasGen.append(result)
    if i not in hasGen:
        total += i
print(total)

파이썬을 배운지 얼마 되지 않았는데, 여기 와서 강력한 문법에 놀라고 있습니다. 재미있네요:)

JAVA

public class SelfNumber {
    public static void main(String[] args) {

        int maxNum = 5000;
        boolean[] generator = new boolean[maxNum];

        for (int num=1; num<maxNum; num++){
            String str = num+"";
            int tmp = num;
            for (int idx=0; idx<str.length(); idx++){
                tmp += str.charAt(idx)-'0';
            }
            if (tmp >= maxNum) break;
            generator[tmp] = true; 
        }

        int sumSelfNumber = 0;
        for (int i=0; i<maxNum; i++){
            if (!generator[i]){
                sumSelfNumber+=i;
            }
        }
        System.out.println("self-number 총합:"+sumSelfNumber);
    }
}

self-number 총합:1227365

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

gen = set(range(5000))
for x in list(gen):
    num=x
    for a in str(x):
        num += int(a)
    try:
        gen.remove(int(num))
    except: None        
print(sum(list(gen)))

(apply + ;; 최종 합
       (clojure.set/difference ;; 차집합
        (set (range 5000))         ;; 5000 까지 숫자 집합
        (set (for [i (range 5000)] ;; non-셀프 숫자 집합
               (+ i (apply + (map (comp read-string str) (str i))))))))


1 부터 5000 까지 제너레이터 집합을 구한 뒤, 1~5000 집합에서 차집합으로 셀프넘버를 구했음.
=> 1227365

자신의 수까지 d() 를 구하면서 self-number인지 체크한다.

package coding.lv1;

import static org.junit.Assert.*;

import org.junit.Test;

public class SumOfSelfNumbersTest {

    /*
     * n is a generator of d(n)
     * ex) d(91) = 9+1 + 91 = 101
     * 
     * self-number is the number which doesn't have any generators
     */

    @Test
    public void itShouldCalculateSumOfSelfNumbers() {
        SumOfSelfNumbers selfNumber = new SumOfSelfNumbers();

        assertEquals(101, selfNumber.dOfGenerator(91));
        assertEquals(103, selfNumber.dOfGenerator(92));

        assertTrue(selfNumber.isSelfNumber(1));
        assertTrue(selfNumber.isSelfNumber(3));
        assertTrue(selfNumber.isSelfNumber(20));
        assertTrue(selfNumber.isSelfNumber(31));

        assertEquals(0, selfNumber.sumWithRange(1,1));
        assertEquals(1, selfNumber.sumWithRange(1,2));
        assertEquals(0, selfNumber.sumWithRange(2,3));
        assertEquals(5, selfNumber.sumWithRange(5,6));

        assertEquals(1+3+5+7+9, selfNumber.sumWithRange(1,10));

        int sumWithRange = selfNumber.sumWithRange(1, 5000);
        System.out.println("Sum Of SelfNumbers : " + sumWithRange);
        assertEquals(1227365, sumWithRange);
    }


    public class SumOfSelfNumbers {
        public int dOfGenerator(int generator) {
            int d = generator;
            for (char c : (generator+"").toCharArray())
                d += (c - '0');
            return d;
        }

        public boolean isSelfNumber(int d) {
            for (int i = 1; i < d; i++)
                if( dOfGenerator(i) == d ) return false;
            return true;
        }

        public int sumWithRange(int start, int end) {
            int sum = 0;
            for (int i = start; i < end; i++)
                sum += isSelfNumber(i)?i:0;
            return sum;
        }
    }
}

자바 arraylist 사용 답 : 1227365

코딩도장 재밌네요.ㅎㅎ

import java.awt.List;
import java.util.ArrayList;


public class generator {

    public static void main(String[] args) {
        int sum = 0;
        ArrayList<Integer> num = new ArrayList<Integer>();
        ArrayList<Integer> geneNum = new ArrayList<Integer>();
        for(int i= 1; i < 5001 ;i++){                       //1~5000까지 숫자 저장
             num.add(i);
        }
        for(int i= 1; i < 5001 ;i++){                       //제너레이터 저장
             geneNum.add( generator(i));
        }
        num.removeAll(geneNum);                             //1~5000 중에 제너레이터 삭제
        for(int i= 0; i<num.size();i++){                    //셀프넘버 더하기
            sum+=num.get(i);
        }
        System.out.println(sum);
    }
    private static int generator(int i) {  //제너레이터 
        int one = 0;
        int ten = 0;
        int hud = 0;
        int thou = 0;
        int temp = 0;
        int origin =i;
        if (i >= 1000){
            thou = i/1000;
            i = i%1000;
        }
        if (i >= 100){
            hud = i/100;
            i = i%100;
        }
        if (i >= 10){
            ten = i/10;
            i = i%10;
        } 
        if(i<10){
            one = i;
        }
        return temp = thou + hud + ten + one + origin;
        }
}

저는 c 언어로 작성했는데요. 범위를 정해주면 그 수까지의 셀프 넘버들과 그 수까지의 총 합을 구하게 만들었습니다. 5000 까지의 셀프 넘버들의 총 합은 1227365 입니다.

#include <stdio.h>

int main(void)
{
    int a = 0, b = 0, c = 0, d = 1, e = 0, f = 0, g = 0, h = 0, i = 0, j = 0, k = 0, l = 0, m = 0, n = 0, o = 0, p = 0, q = 0, r = 0, s = 0, t = 0, u = 0, v = 0, w = 0, x = 0;
    int arr1[10000], arr2[10000], arr3[10000], arr[10000];
    printf("몇까지 셀프 넘버를 구할것인가? 그 수까지의 셀프 넘버와 총 합을 알려주겠다.");
    scanf("%d", &a);

    for(c = 0; c <= a;)
    {
        c++;
        n = c;
        t = c;
        f = 0;
        while(1)
        {           
            d = 10;
            c = (int) c/d;
            if(c==0)
                break;
            f++;
        }
        d = 1;
        k = 0;
        while(k <= f)
        {
            k++;
            d = d*10;
        }
        p = n;
        while(1)
        {               
            if(d==1)
            {   e = e+n;
                break;
            }
            h = n/d;
            n = n%d;
            d = (int) d/10;
            e = e+h;
        }       
        g = t+e;
        arr1[t] = g;
        c = p;
        e = 0;
        u = 0;
    }   
    t = 1;
    c = 1;

    for(c = 1; c <= a; c++)
    {       
        for(s = 1; s <= a; s++)
        {           
            if(arr1[c]==s)
            {
                arr2[s] = s;                
                break;
            }
        }
    }
    for(q = 1; q <= a; q++)
    {
        if(q==arr2[a])
            break;
        if(arr2[q]==q)
            continue;
        else
        {
            arr[q] = q;
            continue;
        }       
    }   
    r = 1;
    for(r = 1; r <= a; r++)
    {       
        if(arr[r]==r)
        {
            x++;
            i = i + r;
            printf("self-number %d: %d\n", x, r);
        }
    }

    printf("sum of self numbers by number you limited: %d\n", i);
    return 0;
}

python 으로 작성하였습니다.

nums_list = []

for i in range(1, 5000):             #5000까지의 d function image를 넣는다. 자기 자신을 더해야하므로 d(n) > n 이 항상 성립한다.
    n = i + i%10 + (i%100)//10 + (i%1000)//100 + i//1000
    if n not in nums_list :
        nums_list.append(n)

sum = 0            #이제 1~5000 까지 d function 으로 만들 수 없는 수를 구한다.
for i in range(1, 5001):
    if i not in nums_list:
        sum = sum + i

print(sum)

1227365

첫 문제 풀어봤습니다. 아직 초보라 많이 미숙합니다ㅎㅎ

이런 식으로 풀이한다면 알고리즘 수행시간이 꽤 길어질 듯 합니다.

/*
어떤 자연수 n이 있을 때, d(n)을 n의 각 자릿수 숫자들과 n 자신을 더한 숫자라고 정의하자.
예를 들어
d(91) = 9 + 1 + 91 = 101
이 때, n을 d(n)의 제네레이터(generator)라고 한다. 위의 예에서 91은 101의 제네레이터이다.

어떤 숫자들은 하나 이상의 제네레이터를 가지고 있는데, 101의 제네레이터는 91 뿐 아니라 100도 있다. 그런데 반대로, 제네레이터가 없는 숫자들도 있으며,
이런 숫자를 인도의 수학자 Kaprekar가 셀프 넘버(self-number)라 이름 붙였다. 예를 들어 1,3,5,7,9,20,31 은 셀프 넘버 들이다.
1 이상이고 5000 보다 작은 모든 셀프 넘버들의 합을 구하라. 
*/

// 1. 1에서 5000까지 수 중에서 Generator를 체크한다. 그 중 제네레이터 인 것은 미리 설정해둔 배열에 True로 표시한다.
// 2. 마지막으로 1에서 5000까지 수 중에서 미리 설정해둔 배열에 False값이 있는 것만 차례대로 더해나간 후 합계를 출력한다.

public class Nexon_problem{

    static boolean[] check = new boolean[5000];

    public static void main(String [] args)
    {
        int fourth, third, second, first, sum = 0;

        for(int i=1; i<5000; i++)
        {
            fourth=(i/1000)%10;
            third=(i/100)%10;
            second=(i/10)%10;
            first=i%10;
            sum = fourth+third+second+first+i;

            if((1<=sum) && (sum<5000))
                check[sum] = true;
        }

        int total = 0;

        for(int j=1; j<5000; j++)
        {
            if(check[j]==false)
                total += j;
        }

        System.out.println("total: " + total);
    }
}

swift로 작성해보았습니다

let MIN_NUMBER = 1
let MAX_NUMBER = 5000

// 숫자 제네레이터 함수
// ex) d(91) = 9 + 1 + 91 = 101
func generator(number : Int) -> Int{

    var total = 0
    for char in Array(String(number)){
        total += String(char).toInt()!
    }

    return total + number
}

// number hashSet
var entireNumbers : Set<Int> = Set<Int>(MIN_NUMBER...MAX_NUMBER)

// 주어진 범위에서 generator에 의해 생성 된 값을 제거
for num in MIN_NUMBER...MAX_NUMBER{
    entireNumbers.remove(generator(num))
}

// 남아있는 hashSet 요소들이 셀프 넘버이므로 요소들을 모두 더한다.
let sum = reduce(entireNumbers, 0, {return $0 + $1})
println(sum)

자바코드

public class FindSelfNumber { private static final int endNum =5000;

public static void main(String[] args) {
    int sumSelfNum = 0 ;

    for(int i =1; i<endNum; i++){
        if(checkSelfNum(i)){                         // SelfNumber라고 확인될 시 sumSelfNum 변수에 더함.
            sumSelfNum +=i;
        }
    }

    System.out.println("1~"+endNum+"까지의 SelfNumber의 합은 : " +sumSelfNum);
}

public static int findGenerator(int selfNum){                    // 받은 숫자의 각 자리수를 모두 더함.
    int nmg=selfNum%10;

    if(selfNum >=10){
        selfNum /=10;
        nmg+=findGenerator(selfNum);
    }
    return nmg;
}

public static boolean checkSelfNum(int num){         // 제너레이터가 존재하지 않는 경우 SelfNumber 라고 생각하여 true를 반환
    boolean check = true;

    for(int i =1; i<num; i++){
        if(num == i+findGenerator(i)){
            check = false;
            break;
        }
    }

    return check;
}

}

자바라 짜봤습니다.

정답인지는 잘 모르겠어요 지적부탁드립니다.

결과 창 : 1~5000까지의 SelfNumber의 합은 : 1227365

python 2.7입니다. d(abcd)의 값이 1001a+101b+11c+2d라서 self number집합 만들어서 여집합을 구했어요~

#365.py


#data 
set1=set(range(1,5001))
set2=set()
for a in range(5):
    for b in range(10):
        for c in range(10):
            for d in range(10):
                set2.add(int(1001*a+101*b+11*c+2*d))

answer_set= set1-set2
print sum(answer_set)

파이썬 코딩으로 어떻게 하면 되는지 찾아봤어요~. 전에 푸신 코드를 참고했습니다!

#393.py
print str(range(10001)).count('8')

set range 4999
set sum_all_num 0
for {set x 1} {$x <= $range} {incr x} {
    set sum_all_num [ expr $sum_all_num + $x ]
    set split_x_num [ split $x {} ]
    set generator   [ expr $x + [ join $split_x_num "+" ]]
    if { $generator <= $range } {
        lappend generator_num_list  $generator
    }
}
set sum_generator_num [ expr [ join [ lsort -integer -unique $generator_num_list ] "+" ]]
set sum [ expr $sum_all_num - $sum_generator_num ]


Tcl/tk 입니다.
문제 풀이보다는 문제 자체를 이해하는데 더 오래걸렸네요.ㅠ

C#으로 재귀함수를 이용해서 작성해 보았습니다.

        private void button1_Click(object sender, EventArgs e)
        {
            List<int> sumArray = new List<int>();
            for (int i = 1; i <= 5000; i++)
            {
                sumArray.Add(sumDigits(i) + i);
            }
            int sum = 0;
            for(int i = 1; i <= 5000; i++)
            {
                bool isIn = sumArray.Contains(i);
                if(!isIn) sum += i;
            }
            Console.WriteLine(sum.ToString());
        }
        private int sumDigits(int number)
        {
            int perTen = number / 10;
            if (perTen == 0) return number;
            else return number - perTen * 10 + sumDigits(perTen);
        }

c언어로 작성했습니다. 코드가 별로 비효율적이지만 나름 구현해보려고 노력했습니다.

int i,result=0,gnum=0,check[5000]={0};


for(i=1;i<5001;i++)
{
    gnum=((i%10000-i%1000)/1000)+((i%1000-i%100)/100)+((i%100-i%10)/10)+i%10+i;
    if(gnum<=5000)
        check[gnum]=1;
}

for(i=0;i<5000;i++)
{
    if(check[i]==0)
        result += i;
}

printf("%d",result);
system("pause");
return 0;

int main()
{
    int c, s1, s2, s3, s4;
    int a[5000];
    int sum = 0;
    for(int i = 0; i < 5000; i++) {
     a[i] = i+1;
    }

    for(int i = 0; i < 5000; i++) {
     s1 = i/1000;
     s2 = (i/1000 - s1*1000)/100;
     s3 = ((i/1000 - s1*1000) - s2*100)/10;
     s4 = (((i/1000 - s1*1000) - s2*100) - s3*10);

     c = s1 + s2 + s3 +s4 + i;

     if ( c < 5000) a[c] = 0;
     }

     for(int i = 0; i < 5000; i++) {
      sum += a[i];
     }

   cout << "합: " << sum << endl;

   return 0;
}

문법만 lisp 이네요 ㅠ

(defun generator (n)
    (let
        (
            (sum n)
            (num-list (coerce (princ-to-string n) 'list))
        )
        (dolist (num num-list)
            (setf sum (+ sum (digit-char-p num)))
        )
        sum
    )
)

(let*
    (
        (generatable-set (loop for n from 1 to 5000 collect (generator n)))
        (selfnumber-set (loop for n from 1 to 5000 when (not (find n generatable-set)) collect n))

        (sum 0)
    )
    (mapcar
        (lambda (i)
            (when (<= i 5000)
                (setf sum (+ sum i))
            )
        )
        selfnumber-set
    )
    sum
)

PHP 로 작성했습니다.

<?php
    const BEGIN = 1;
    const END = 5000;

    // 1~5000까지의 숫자를 배열로 저장     
    $arr = range(BEGIN, END);

    // Genarate : 각 자리수의 합 + 원래 자기의 수
    $generate = function($arg) {
        return array_sum(str_split($arg, 1)) + $arg;
    };

    // 1~5000까지의 Generate의 숫자를 확인하여
    // Generate가 존재하면 숫자를 저장한 배열에서
    // 해당 값이 존재하면 0으로 셋팅한다.
    foreach (range(BEGIN, END) as $value) 
    {
        $key = array_search($generate($value), $arr);

        if(!empty($key)) $arr[$key] = 0;

    }

    echo "result is ".array_sum($arr);

?>

#!/usr/bin/python

tmp_sum = 0             ## 하나의 제너레이터로 나올 수 있는 수를 잠시동안 넣을 변수
digit = 0
sum = []                ## 여기는 1~5000까지의 범위의 제너레이터를 이용해 나울 수 있는 수를 넣을 리스트  
self_num = []           ## 변수 이름 그대로 self_number들이 들어갈 리스트
self_num.append(1)      ## 1이 self_number이기 때문에 리스트에 미리 넣음. 사실 line 24에 나오는  for funtion에서 1이 추가가 안됨
result = 0              ## self_number의 합을 여기다가 넣을거다

for i in range(1,5001): ## 여기는 1~5000까지의 범위의 제너레이터를 이용해 나울 수 있는 수를 리스트에 추가한다

    digit = len(str(i)) ## 변수 digit, 이름 그대로 한 제너레이터의 숫자 길이를 구함 
    digit -= 1          ## 1을 미리 빼는 이유는 line 16 에서 digit이 array index로 쓰이기 때문이다

    tmp_sum =+ i        ## tmp_sum에다가 generator 숫자를 더함

    while digit >= 0:   ## tmp_sum을 구하는 과정이다    
        tmp_sum += int(str(i)[digit])
        digit -= 1

    sum.append(tmp_sum) ## sum에 generator로 구한 수를 넣는 과정

sum.sort()              ## 구한 숫자들을 크기순서대로 재배열한다

for i in range(4999):   ## 여기서부터 self_number 를 구하기 시작한다.
    a = sum[i]          ##slef_number 를 구하는 여러 방법중에 내가 생각한 방법은 
    b = sum[(i + 1)]    ##2개의 숫자를 서로 비교해서 그 숫자들 사이의 정수를 self_number
    c = b - a -1        ##리스트에 넣는 방법이다 
    while c > 0:
        d = b - c       ## 변수 d는 두 숫자사의 값이다
        self_num.append(d)
        c -= 1
'''
for i in range(len(self_num)):  ## 이상하게도 이 방법을 사용할려고 하면  
    if self_num[i] > 5000:      ##IndexError: list index out of range
        del self_num[(i)]       ##라는 에러를 낸다 근데 아무리 생각해도 i라는 
                                ##index는 self_num index범위안에 있다. 

'''
del self_num[499]               ##그래서 직접 하나씩 없앴다.
del self_num[498]
del self_num[497]
del self_num[496]
del self_num[495]
del self_num[494]

#print(self_num)

for a in self_num:      ## 모든 self_number의 합을 구하는 과정
    result += a
print(result)

#include <stdio.h>

int total[5001];

int main() {

    int temp;
    int sum;
    for(int i=1;i<=5000;i++) {
        for(int j=1;j<=i;j++) {
            temp=j;
            sum = j;
            while(temp!=0) {
                sum += temp%10;
                temp/=10;
            }
            if(sum==i){
            total[i]=1;
            break;
            }
        }
    }
    for(int i =1;i<5000;i++) {
        if(total[i]==0)
        printf("%d  ",i);
    }
}

합을 구하는 건 그냥 그래서 셀프 넘버를 출력하는 프로그램입니다. 너무 좋은 풀이 법들이 많네요. 특히 C++이 최고인 줄 알았는데 파이썬의 강력함에 놀라고 갑니다.
파이썬 공부해야겠네요.

int r = 0;
int Ge(int n)
{ 
   int r = n;
   while(n != 0)
   {
     r += n%10;
     n = n / 10;
    }
}
static void main(string[] args)
{
  bool[] selfs = new bool[5001];
  for(int i = 1; i < 5000; i++)
  {
    if(Ge(i) <=5000)
    {
      selfs[i] = false;
     }
   }
     for(int i = 1; i < 5000; i++)
  {
    if(selfs[i])
    r += i;
   } 
   Console.WriteLine(r);
}

#include <stdio.h>

int main() {
    int a[5000];
    int b,c,d,e;
    int sum = 0;
    int i;
    for(i=1;i<5000;i++){
        a[i] = i+1;
    }
    for(i=0; i<5000; i++){
        b = i/1000;
        c = (i/1000 - b*1000)/100;
        d = ((i/1000 - b*1000) - c*100)/10;
        e = (((i/1000 - b*1000) - c*100) - d*10);

        sum = b + c + d + e;
        if(sum < 5000){
            a[c] = 0;
        }
        for(int i=0; i <5000; i++){
            sum += a[i];
        }
    }
    printf("%d", sum);
    return 0;

Python 2.7.8 사용중입니다.

def gen(n):
    y=n
    y+=sum([int(str(n)[i]) for i in range(len(str(n)))])
    return y
a=[gen(n) for n in range(1,5000)]
b=[i for i in range(1,5000) if not i in a]

print sum(b)

=> 첫번재 작성한 버젼

print sum(set(range(1,5000))-{x + sum([int(i) for i in str(x)]) for x in range(1,5000)})

=> 코드들 참조해서, 두번째 작성한 버젼

#include <stdio.h>
#include <Windows.h>


int func1(int generator)
{
    int num = generator;
    while( generator > 0)
    {

        num += generator % 10;
        generator /= 10;
    }
    return num;
}
int main()
{
    bool table[5001];
    int self = 0;

    for(int i=0;i<=5000;i++)
        table[i] = true;

    for(int i=0;i<=5000;i++)
    {
        if(table[i])
            self += i;

        int generator = func1(i);

        if( generator <= 5000 )
            table[generator] = false;
    }


    printf("%d",self);
    system("pause");
}

파이썬입니다~

result = {}
for i in range(1, 5000):
    n = i + sum([int(x) for x in str(i)])
    if n in result:
        result[n].append(i) # i는 n의 제너레이터
    else:
        result[n] = [i]
ans = 4999 * 5000 / 2 - sum([x for x in result.keys() if x < 5000])
print(ans)

package test;

public class SelfNumber {


    public static void main(String[] args){

        int[] result = new int[4999];
        for( int i = 1; i < 5000; i++){
            result[i-1] = i;
        }

        int sum = 0;
        for( int i = 1; i < 5000; i++){
            sum += i;
            String temp = String.valueOf(i);
            for( int j = 0; j < temp.length(); j++){
                sum += Integer.parseInt(temp.substring(j, j+1));
            }
            if( sum < 5000){
                result[sum-1] = 0;
            }

            sum = 0;
        }

        int totalResult = 0;
        for( int i = 1; i < 5000; i++){
            if( result[i-1] != 0 ){
                totalResult +=result[i-1];

            }
        }
        System.out.println(totalResult);
    }
}

import java.util.*;

public class dojo3
{
  public static void main(String[] args)
  {
    int count = 0;
      int sum = 0;
    String st = "";
    boolean[] ans= new boolean[5001];
    Arrays.fill(ans,true);
    for(int i=0 ; i<=5000;i++){
      if(gen(i)<=5000){
      ans[gen(i)] = false;
      }
    }
    for(int j=0;j<=5000;j++)
    {
      if(ans[j] == true)
      {
        count++;
        sum += j;
        st = st + "  " + Integer.toString(j);
      }
    }
    System.out.println("total nums : " + count);
    System.out.println("Total sums : " + sum);
    System.out.println(st);

  }

  public static int gen(int a)
  {
    String s = Integer.toString(a);
    char[] b = s.toCharArray();
    int[] c = new int[b.length]; 
    Arrays.fill(c,0);
    for(int i = 0 ; i<b.length;i++)
    {
     c[i] = Integer.parseInt(Character.toString(b[i]));
    }
    int tot = 0;
    for(int i = 0 ; i<c.length;i++)
    {
      tot +=c[i];
    }
    tot+=a;
    return tot;
  }
}

total nums : 494 Total sums : 1227365 1 3 5 7 9 20 31 42 53 64 75 86 97 108 110 121 132 143 154 165 176 187 198 209 211 222 233 244 255 266 277 288 299 310 312 323 334 345 356 367 378 389 400 411 413 424 435 446 457 468 479 490 501 512 514 525 536 547 558 569 580 591 602 613 615 626 637 648 659 670 681 692 703 714 716 727 738 749 760 771 782 793 804 815 817 828 839 850 861 872 883 894 905 916 918 929 940 951 962 973 984 995 1006 1021 1032 1043 1054 1065 1076 1087 1098 1109 1111 1122 1133 1144 1155 1166 1177 1188 1199 1210 1212 1223 1234 1245 1256 1267 1278 1289 1300 1311 1313 1324 1335 1346 1357 1368 1379 1390 1401 1412 1414 1425 1436 1447 1458 1469 1480 1491 1502 1513 1515 1526 1537 1548 1559 1570 1581 1592 1603 1614 1616 1627 1638 1649 1660 1671 1682 1693 1704 1715 1717 1728 1739 1750 1761 1772 1783 1794 1805 1816 1818 1829 1840 1851 1862 1873 1884 1895 1906 1917 1919 1930 1941 1952 1963 1974 1985 1996 2007 2022 2033 2044 2055 2066 2077 2088 2099 2110 2112 2123 2134 2145 2156 2167 2178 2189 2200 2211 2213 2224 2235 2246 2257 2268 2279 2290 2301 2312 2314 2325 2336 2347 2358 2369 2380 2391 2402 2413 2415 2426 2437 2448 2459 2470 2481 2492 2503 2514 2516 2527 2538 2549 2560 2571 2582 2593 2604 2615 2617 2628 2639 2650 2661 2672 2683 2694 2705 2716 2718 2729 2740 2751 2762 2773 2784 2795 2806 2817 2819 2830 2841 2852 2863 2874 2885 2896 2907 2918 2920 2931 2942 2953 2964 2975 2986 2997 3008 3023 3034 3045 3056 3067 3078 3089 3100 3111 3113 3124 3135 3146 3157 3168 3179 3190 3201 3212 3214 3225 3236 3247 3258 3269 3280 3291 3302 3313 3315 3326 3337 3348 3359 3370 3381 3392 3403 3414 3416 3427 3438 3449 3460 3471 3482 3493 3504 3515 3517 3528 3539 3550 3561 3572 3583 3594 3605 3616 3618 3629 3640 3651 3662 3673 3684 3695 3706 3717 3719 3730 3741 3752 3763 3774 3785 3796 3807 3818 3820 3831 3842 3853 3864 3875 3886 3897 3908 3919 3921 3932 3943 3954 3965 3976 3987 3998 4009 4024 4035 4046 4057 4068 4079 4090 4101 4112 4114 4125 4136 4147 4158 4169 4180 4191 4202 4213 4215 4226 4237 4248 4259 4270 4281 4292 4303 4314 4316 4327 4338 4349 4360 4371 4382 4393 4404 4415 4417 4428 4439 4450 4461 4472 4483 4494 4505 4516 4518 4529 4540 4551 4562 4573 4584 4595 4606 4617 4619 4630 4641 4652 4663 4674 4685 4696 4707 4718 4720 4731 4742 4753 4764 4775 4786 4797 4808 4819 4821 4832 4843 4854 4865 4876 4887 4898 4909 4920 4922 4933 4944 4955 4966 4977 4988 4999

public class NexonRecruiting {

    private boolean[] field;

    /**
     * @param num
     */
    public NexonRecruiting(int num) {
        field = new boolean[num];

        for (int i = 0; i < num; i++) {
            field[i] = false;
        }
        run(num);
    }

    /**
     * @param generator
     * @return
     */
    int formula(int generator) {

        int d_n = generator;
        int tmp = generator;

        while (tmp > 0) {

            d_n += tmp % 10;
            tmp = tmp / 10;
        }

        return d_n;
    }

    /**
     * @param num
     */
    public void run(int num){
        int sum=0;

        for(int i=1; i<num; i++){
            //case, not self-number
            if(i != formula(i)){
                if(formula(i) >= num)
                    continue;
                field[formula(i)] = true;

            }
        }

        //sum(self-number)
        for(int i=1; i<num; i++){
            if(field[i] == false){
                sum += i;
            }
        }

        System.out.println("1이상이고 " + num +"보다 작은 모든 셀프 넘버들의 합은 "+ sum);

    }
}

#include <iostream>
using namespace std;

int d(int num)
{
    int sum = 0;
    sum += num;
    while(num){ 
        sum += num % 10;
        num/=10;        
    }

    return sum;
}


void main(void)
{

    int num = 0;
    int i = 0;
    int j = 0;

    for(int k = 1; k <= 5000; ++k)
        num += k;

    while(j < 5000){
        j = d(i++);
        num -= j;
    }   

    cout<<"결과는 : "<<num<<endl;      
}

해당 범위의 총 합에서 셀프넘버가 아닌 숫자를 빼는 방법으로 구현해 봤습니다. 사용 언어는 visual c++입니다. 초보라 많이 부족합니다.조언 부탁드립니다.

public class D {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>();
        int res = 0;

        for(int i = 1; i <= 5000; i++) {
            list.add(d(i));
        }

        for(int i = 1; i <= 5000; i++) {
            int flag = 0;
            for(int n : list) {
                if(i == n) {
                    flag = 1;
                    break;
                }
            }

            if(flag == 0) {
                System.out.println(i);
                res += i;
            }
        }

        System.out.println(res);    // 1227365
    }

    public static int d(int n) {
        String temp = Integer.toString(n);
        int res = n;

        for(int i = 0; i < temp.length(); i++) {
            res += (temp.charAt(i) - '0');
        }

        return res;
    }
}

String gen = ""; for(int i = 1 ; i < 5000; i++){ int count = 0; int sum = 0;
String str = Integer.toString(i);

        for (int j = 0; j < str.length(); j++) {
                count = count + Integer.parseInt(str.substring(j,j+1)); 
        }
        sum = count + i;

        gen = gen +","+ sum;
        count = 0;

    }
    int total = 0;

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

        if(!gen.contains(","+Integer.toString(i)+",")){
            total += i;         
        }

    }
    System.out.println(total);

쩝 다른분들이 만든거를 보니 초라해지네요 ㄷㄷ

public class Generator {
    private Integer[] generator;
    public Generator(){
        SetNumber();
    }
    public void SetNumber(){
        generator = new Integer[4999];
    }
    public void generatorAnswer(){
        int sum=0, z = 0;
        for(int i = 1 ; i < 5000 ;i++){
            z = i;
            while(z > 0){
                sum += z%10;
                z /= 10;
            }
            sum += i;
            this.generator[i-1] = sum;
            sum =  0;
        }
    }
    public void SelfNum(){
        int sum = 0; Boolean flag;
        generatorAnswer();
        for(int i = 1 ; i <= 5000 ; i++){
            flag = true;
            for(int j = 0 ; j < 4999 ; j++){
                if(this.generator[j] == i){
                    flag = false; 
                }
            }
            if(flag == true){
                sum += i;
            }
        }
        System.out.println(sum);
    }
    public static void main(String[] args) {
        Generator number = new Generator();
        number.SelfNum();
    }
}

int generator(int input)
{
    int result = input;

    while (input > 0)
    {
        result += input % 10;
        input /= 10;
    }

    return result;
}

void exce1()
{
    int nonSelf[5000];
    int sum = 5001 * 2500;

    memset(nonSelf, 0, sizeof(nonSelf));
    for (int i = 1; i <= 5000; i++)
    {
        if (generator(i) <= 5000)
        {
            nonSelf[generator(i) - 1] = 1;
        }
    }
    for (int i = 0; i < 5000; i++)
    {
        if (nonSelf[i] == 1)
            sum -= (i + 1);
    }

    printf("결과는 %d 입니다.", sum);
}

논셀프넘버를 먼저 추린다음에 1~5000 전체 합에서 빼는식으로 구하였습니다.

# 1~5000까지의 generator를 다 구한후 중복값이 0개를 가지는 값들을 구했습니다.

def generator(ibuff):
    res = 0
    for i in range (0, len(ibuff)):
        res += int(ibuff[i])
    res += int(ibuff)
    return res

generator_list = []
for i in range(0,5000):
    generator_list.append( generator(str(i)) )

res_sum =0 
for i in range(0,5000):
    if generator_list.count(i) < 1:
        res_sum += i

print res_sum

gen = []
for i in range(1, 5000):
    tmpStr = str(i)
    tmpNum = i
    for j in range(len(tmpStr)):
        tmpNum += int(tmpStr[j])
    gen.append(tmpNum)

gen = [x for x in gen if x < 5000]
genTotal = sum(set(gen))
answerTotal = sum(set(range(5000)))

print(answerTotal - genTotal)

__author__ = 'Lee'


def make_d(n):
    l = list(str(n))
    target = 0
    for i in l:
        target += int(i)
    result = int(n) + target
    return result


def cal():
    num_set = {0,}
    num_ori = {0,}
    y = 0
    for i in range(1,5001):
        num_ori.add(i)
        num_set.add(make_d(i))
    result = num_ori - num_set
    for j in range(1, len(result)+1):
        y += result.pop()
    return y

print(cal())


열심히 배우고 있어요~

package test;

import java.util.ArrayList;
import java.util.Arrays;

public class SelfNumber {
    public static void main(String[] args) {
        int num, sum = 0, nonsum = 0;
        int[] index = new int[5000];
        int[] hasGenerator = new int[5000];
        ArrayList<Integer> nonself = new ArrayList<Integer>();

        for(num = 1;num<=5000;num++){
            index[num-1] = num;
            calGenerator(num);
            sum += num;
            hasGenerator[num-1] = calGenerator(num);
            int i = num - 1;

            if(calGenerator(num)>=1 && calGenerator(num)<5000){
                if(!nonself.contains(hasGenerator[i])){
                    nonself.add(hasGenerator[i]);
                    nonsum += hasGenerator[i];
                }
            }
        }
        sum -= 5000;
        System.out.println(sum - nonsum);
    }   
    public static int calGenerator(int num){
        int gen=0;      
        if(num>=1000){
            gen = num + (num/1000)%10 + (num/100)%10 + (num/10)%10 + num%10;
        } 
        if(num>=100 && num<1000) {
            gen = num + (num/100)%10 + (num/10)%10 + num%10;            
        } 
        if(num>=10 && num<100){
            gen = num + (num/10)%10 + num%10;   
        } 
        if(num<10) {
            gen = num + num%10;
        }
        return gen;
    }
}

#include <stdio.h>
#include <stdlib.h>


int listing[10000];

int quotient (int a, int b);
int generator (int d);
int lister(int ff);


int main(void)
{
    int findout;
    printf("Please insert an appropriate number: ");
    scanf("%d", &findout);
    if (findout <= 0 || findout > 5000)
    {
        printf("Meaningless Number. \nComputing interrupted.\n");
        exit(1);
    }/*
    else
    {
        int listing[findout];
    }*/

    int cnter;
    for (cnter = 1; cnter <= 5000; cnter++)
    {
        /*printf("Meaningless Number. \nComputing interrupted.\n");*/
        if(identifier(cnter) == 0)
        {
            /*printf("Meaningless Number. \nComputing interrupted.\n");*/
            listing[cnter] = cnter;
        }
    }

    int ii;
    int total;
    for (ii = 1; ii <= findout; ii++)
    {
        printf("%d, ", listing[ii]);
        total = total + listing[ii];
    }

    printf("\n\nThe Summary is: %d !!!", total);

    return 0;
}


int quotient (int a, int b)
{
    int c = a % b;
    a = a - c;
    int ddd;
    ddd = a / b;
    return ddd;
}

int generator (int d)
{   
    int tmp = d;
    int cnt;
    int digit = 0;
    for(cnt = 1; (d / cnt) > 0; cnt = (cnt*10))
    {
        if (cnt == 1)
        {
            digit = digit + (d % 10);
        }
        else
        {
            digit = digit + ((d/cnt) % 10);
        }
    }

    /* get the aggregate of each digit */
    int summ = 0;
    summ = digit + d;

    return summ;
}

int identifier(int fff)
{
    int cnti;
    int trorfal;
    for(cnti = 1; cnti <= fff; cnti++)
    {
        int tmp;
        tmp = generator(cnti);
        if (tmp == fff)
        {
            trorfal = 1;
            break;
        }
        else
        {
            trorfal = 0;
        }
    }

    return trorfal;
}

C로 작성했습니다.

구조화한 설계를 하면서, 배열을 주어진 숫자 범위보다 넉넉히 크게 하였습니다. 그래도 가변적으로 배열의 크기를 조정하지는 못했네요. 너무 길지만...가독성만 높다고 생각합니다. ㅠㅠ

추가. 중간에 listing 배열을 재정의하여, 입력되는 숫자값대로 배열의 크기를 재조정하려고 했던 것이 모든 셀프 넘버들의 합 값을 어그러뜨리는 결과를 낳는다는 사실을 확인하였습니다. 이런 식으로 재정의하면 안 되는 줄 몰랐는데...다른 함수들에서는 이것이 문제를 일으키지 않았지만 main 함수 내에서의 이러한 잘못된 재정의가 오류를 불러일으킴을 확인하고, 값을 다시 구했습니다. 답은 1227365로 도출되었습니다.

Ruby 입니다. 아직 초보라서, 다른 분들 풀이 좀 참고해서 해봤습니다.

arr = (1...5000).to_a
for x in 1...5000
    d_n = x
    for y in x.to_s.split(//)
        d_n += y.to_i
    end
    if arr.include? d_n
        arr.delete(d_n)
    end
end
puts arr.inject(:+)

def d(n):
    sum=n
    for i in str(n):
        sum+=int(i)
        if sum>5000:
            return 0
    return sum

print(sum(set(range(1,5001))-set(map(d,range(1,5000)))))

같은 파이선인데 1줄이라니;; 인간인가;;

c++로 짜보았습니다. self number들도 모두 출력하게끔 프로그램하였습니다.

#include <stdio.h>
int main(void)
{
    int num, gen, chk = 0, sum = 0; //http://codingdojang.com/scode/365
    printf("Self number is : \n");
    for (num = 1; num < 5000; num++)
    {
        for (gen = 1; gen < num; gen++)
        {

            if ((gen + (gen / 1000) + (gen / 100 - 10 * (gen / 1000)) + (gen / 10 - 10 * (gen / 100)) + (gen % 10)) == num)
            {
                chk = 1;
                break;
            }
        }
        if (chk == 0)
        {
            printf("%4d ", num);
            sum = sum + num;
        }
        chk = 0;
    }
    printf("\n\n5000 미만의 Self number 들의 합은 %d\n", sum);
    return 0;
}

#include<iostream>
using namespace std;

int gen(int num1){
    int sum=0;
    sum+=num1;
    while(num1){
        sum+=(num1%10);
        num1=num1/10;
    }
    return sum; //제너레이팅 결과값
}

int checkself(int sum){
    for(int i=0;i<5000;i++){
    if(sum==gen(i)) return false;
    }
    return true;
}


int main(){
    int sum=0;
    for(int j=1;j<5000;j++){
        if(checkself(j)==true)
        sum+=j;
    }
    cout<<sum<<endl;
    return 0;
}

i의 범위 때문에 고민을 좀 많이 했지만 해결했습니다. 답 : 1227365

public class Main {

    public static void main(String[] args) {
        ArrayList<Integer> sample = new ArrayList<Integer>();
        ArrayList<Integer> result = new ArrayList<Integer>();
        int sum = 0;

        for (int i = 1; i < 5001; i++) {
            sample.add(i);
        }

        result.addAll(sample);

        for (Integer ig : sample) {
            if (generator(ig) < 5001) {
                result.set(sample.indexOf(generator(ig)), 0);
            } else {
                break;
            }
        }

        for (int i = 0; i < result.size(); i++) {
            sum += result.get(i);
        }
        System.out.println(sum);
    }

    public static int generator(int resource) {
        int sum = 0;
        String[] temp = new String(resource+"").split("");
        for (int i = 0; i < temp.length; i++) {
            sum += Integer.parseInt(temp[i]);
        }
        return resource+sum;
    }
}

출력결과 : 1227365

#include<stdio.h>
int Split(int num);
typedef enum {false, true} bool;

int main(void){
  bool arr[5001] ={0,};
  int i,result=0,num;

  for(i=1; i<=5000;i++){
    num = Split(i);
    if(num>=1 && num<=5000) arr[num] = 1;
    if(arr[i]==0) result +=i;
  }

  system("pause");
  return 0;
}

int Split(int num){
   int n=0;
   n = num/1000+((num/100)%10)+((num/10)%10)+num%10+num;  
   return n;
}

C로 만들었습니다.

def d(n): return sum( int(x) for x in str(n) ) + n
print sum( set(range(1, 5001)) - set(d(n) for n in range(1, 5001)) )

안녕하세요, 가입하고서 첫 풀이 등록하게 되었네요.
한창 재미를 붙여가고 있는 Python(2.7.9)으로 작성해보았습니다.

문제의 답은 1,227,365로 확인했습니다.

앞으로 잘 부탁 드리겠습니다!

Python3으로 구현했습니다. 더 짧게 작성하신 훌륭한 분들도 많네요

nums = set(range(1, 5000))
for i in range(1, 5000):
    non_self = sum(map(int, str(i))) + i
    try:
        nums.remove(non_self)
    except KeyError:
        pass

print(sum(nums))

Python 3.5

def getSub(start,end) :
    sSub=set()
    valueList = list(range(start,end+1))
    for j in valueList :
        value = str(j)
        result = 0
        for i in range(0,len(value)) :
            result += int(value[i])
        sSub.add(result + int(value))
    return sSub

S_N = 1
E_N = 4999

sAll = set(range(S_N, E_N+1))
selfNumber = sum(sAll - getSub(S_N, E_N))
print(selfNumber)

#include <stdio.h>

void main(){ 
int i,j,temp,sum_of_selfnum;

for(i=0; i<5000; i++){                               //1부터 5000사이에 셀프넘버 구하기
    for(j=1; j<i; j++){                              //1부터 자기 보다 작은 숫자까지 제너레이터로 설정하여 계산해봄
        temp = j%10 + (j/10)%10 + (j/100)%10 + (j/1000)%10;
        if(temp == j )  contitnue;                  //제너레이트가 존재시 셀프넘버가 아니므로 continue
        else if(j == i) sum_of_selfnum += j;     //for문을 끝까지 돌면 제너레이트가 없으므로 셀프넘버에 해당됨
       }
}
printf("%d", sum_of_selfnum);
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace selfNumber
{
    class Program
    {
        static void Main(string[] args)
        {   
            int nMaxArray = 5000;       // 1 ~ 어떤숫자까지 체크 할것인가(자연수)
            int nMaxCheckValue = 5000;  // 루프돌면서 체크할 숫자의 Max값

            bool[] arIsNotSelfNumber = new bool[nMaxArray];
            for (int nCnt = 1; nCnt <= nMaxCheckValue; nCnt++)
            {
                int nGenResult = getGenerator(nCnt);    // while루프함수 버전

                if (nGenResult - 1 < nMaxArray)
                {
                    arIsNotSelfNumber[nGenResult - 1] = true;
                }
            }

            int nSumNaturalNum = 0;
            for (int nCnt = 1; nCnt <= nMaxArray; nCnt++)
            {
                if (arIsNotSelfNumber[nCnt - 1] == false)
                {
                    nSumNaturalNum += nCnt;
                }
            }


            System.Diagnostics.Debug.Print("1 ~ " + nMaxArray + " 까지의 셀프넘버의 합은 : " + nSumNaturalNum);

        }

        static int getGenerator(int nValue)
        {
            int nResult = 0;
            nResult += nValue;

            int nCopiedValue = nValue;
            bool bLoop = true;
            while (bLoop)
            {
                if (nCopiedValue / 10 != 0)
                {
                    nResult += nCopiedValue % 10;
                    nCopiedValue /= 10;
                    bLoop = true;
                }
                else
                {
                    nResult += nCopiedValue;
                    bLoop = false;
                }

            }

            return nResult;
        }

    }
}

const int MAX = 5000;
bool[] isdn = new bool[MAX];
int t = 0, dn = 0, sum = 0;

for (int i = 0; i < MAX; t = dn = i++)
{
    do dn += t % 10;
    while ((t /= 10) >= 1);

    if (dn < MAX) isdn[dn] = true;
    if (!isdn[i]) sum += i;
}

C#으로 작성하였습니다. 순차적인 정수배열이 필요없는 인덱스 방식을 생각해보았습니다. 그리고 셀프넘버는 룹을 돌며 나오는 d(n)보다 항상 작으므로 하나의 for문으로도 간단히 처리할 수 있었습니다. 1000만개를 돌렸을때, 약 0.6초의 계산시간이 소요되었습니다.

C#

List<int> srcAry = Enumerable.Range(1, 5000 - 1).ToList();

// 제네레이터값들 획득
var noSelfNums = srcAry.Select(_v => _v.ToString().ToCharArray().Select(_c => _c - 48).Sum() + _v).ToList();

// 셀프넘버 획득
srcAry.RemoveAll(_v => noSelfNums.IndexOf(_v) >= 0);

// 합 출력
Console.WriteLine(srcAry.Sum());

-Output-------
1227365

#넥슨 입사문제 중에서

if __name__ == "__main__":
    list = list(range(1,5000))
    selfnum = list.copy()
    result = 0
    for i in list:
        k=0
        for j in str(i):
            k+=int(j)
        k+=i
        try:
            selfnum.remove(k)
        except:
            pass
    for i in selfnum:
        result+=i
    print(result)

#include <iostream>
#include <map>

using namespace std;




int calculate(int num)
{
    int total = num;

    int tenPos = 1;
    while (num > 0)
    {
        tenPos *= 10;

        int sliceNum = num % tenPos;
        total += sliceNum / (tenPos / 10);

        num -= sliceNum;
    }


    return total;
}


int main()
{
    std::map<int, int> notSelfNumbers;

    for (int i = 1; i < 5000; ++i)
    {
        notSelfNumbers.insert(std::make_pair(calculate(i), i));
    }


    int total = 0;

    for (int i = 1; i < 5000; ++i)
    {
        if (notSelfNumbers.find(i) == notSelfNumbers.end())
        {
            total += i;
        }
    }

    cout << total << endl;


    return 0;
}

C++ 초짜가 짠 효율성 없는 코드입니다. 다들 풀이가 예술이시네요...ㄷㄷ 특히 파이썬, C#...

#include <stdio.h>
int generator(int n,int j);
int main(void){
        int arr[5000];
        int i,j,k,gencheck,sum=0;
        for(i=0;i<5000;i++){
                arr[i]=(i+1);
        }
        for(i=0;i<5000;i++){
                for(j=0,k=i;;j++){
                        k=k/10;
                        if(k<=0)
                                break;
                }
                gencheck=generator(i,j);
                if(gencheck<5000){
                        arr[gencheck-1]=0;
                }
        }
        for(i=0;i<5000;i++){
                printf("arr[%d]=%d\n",i,arr[i]);
                sum+=arr[i];
        }
        sum-=5000;
        printf("%d\n",sum);
        return 0;
}
int generator(int n,int j){
        int sum=n;
        double i=10;
        for(;j>-1;j--){
                sum+=(n%10);
                n/=10;
                i*=10;
        }
        return sum;
}

휴,,,,,, 방식은 길이5000배열에 1부터 5000까지 넣어놓고 제너레이트가 있는 배열값을 전부 0으로 바꾼뒤 전부 더해주는겁니다,, 5000보다 적은수라고 해서 마지막 5000을 빼주었습니다.

class List():
    def __init__(self,list1):
        self.list1 = list1

    def __sub__(self, other):
        for x in other.list1:
            while self.list1.count(x):
                self.list1.remove(x)
        return self.list1


if __name__ == '__main__':
    non_self = []

    for x in range(1,5000):
        non_self_num = sum([int(x) for x in str(x)]) + x
        non_self.append(non_self_num)
        if non_self_num > 5000:
            break

    self_num = List(list(range(1,5001))) - List(non_self)
    print('The total sum. of self number is %d' % sum(self_num))

def generated(x):
    npt = str(x)
    lst = []
    for i in npt:
        lst.append(eval(i))
    return sum(lst) + x

lst = []
for i in range(1, 5001):
    lst.append(generated(i))

result = []
for i in range(1, 5001):
    if i not in lst:
        result.append(i)

print result
print sum(result)

일단 제너레이터 함수를 그대로 옮겨적습니다(꼼수로 eval() 을 썼습니다) 그리고 그걸 5000까지 돌린 다음에 1~5000 집합과 위 집합의 차집합을 꺼내서 더합니다

#include <stdio.h>
#include <stdlib.h>

int isSelfNumber(int number);
int gen(int n);

int main(int argc, char* argv[])
{
    int i=0, a=0, b=0, sum=0, cnt=0;
    int tmp=0;
    time_t start,end; 


    if (argc!=3) {
        printf("ERROR: Input argument missing. Usage: generator.exe 1 5000");
        return 0;
    }

    a = atoi(argv[1]);
    b = atoi(argv[2]);

    for (i=a; i<=b; i++) {
        if (isSelfNumber(i)){
            tmp+=i;
            cnt++;
        }
    }

    printf("Total number of selfnumber between %d and %d is %d, and summation is %d.\n", a, b, cnt, tmp);

    return 0;
}



int isSelfNumber(int number)
{
    int i=0, b=0, cnt=0;
    int temp = 0;

    for (i=1; i<number; i++) {
        b = gen(i);
        if (number==b){
            cnt++;
        }
    }

    if (cnt==0)
        return 1;
    else
        return 0;

}

int gen(int n)
{
    int b=0, c=0;

    c = n; 
    while(c > 0){
        b += c%10;
        c = (int)(c/10);
    }
    b+=n;

    return b;
}

• 저도 파이썬으로 해보고 싶습니다.. 공부좀 해야겠어요..
• for loop 별로 for loop 포함된 함수를 콜하고, 그 안에서 while loop을 돌리다 보니, 속도 측면에서는 개선이 필요할 듯 합니다.
• Total number of selfnumber between 1 and 5000 is 494, and summation is 1227365.

• python 으로 작성하였습니다. set과 차집합을 이용하였습니다.

dn=set([n+sum([int(a) for a in str(n)]) for n in range(1,5000)])
u=set(range(1,5000))

print sum(u-dn) 

sum(set(range(1, 5000)) - {x + sum([int(a) for a in str(x)]) for x in range(1, 5000)})

소스코드 이해함.

((1...5000).to_a - (1...5000).map{ |i| i.to_s.split("").push(i).map{ |i| i.to_i }.inject(:+) }).inject(:+)

루비 2.1.5입니다

#include <stdio.h>

int calcGenerator(int n) {
    int temp = n;
    int generator = n;

    while (temp != 0) {
        generator += (temp % 10);
        temp = temp / 10;
    }

    return generator;
}

int main( ) {
    int i;
    int generator;
    int selfnumberArr[5001] = {0,};

    for (i = 1; i <= 5000; i++) {
        generator = calcGenerator(i);
        if (generator <= 5000) {
            selfnumberArr[generator] = 1;
        }
    }

    result = 0;
    for (i = 1; i <= 5000; i++) {
        if (selfnumberArr[i] == 1) {
            result += i;
        }
    }

    printf("%d\n", result);
}

Python으로 작성

generate = lambda n : n + sum([int(x) for x in str(n)])
print(sum(set(range(1, 5000)) - set([generate(x) for x in range(1, 5000)])))

결과
1227365

Haskell

import Data.Char
import Data.List
generate n = n + sum [digitToInt x | x <- (show n)]
print $ sum $ [1..4999] \\ [generate x|x<-[1..4999]] 

결과
1227365

/* Swift 2.1 */
func generate(n: Int) -> Int {
    let nComponents = String(n).characters.map { Int(String($0)) ?? 0 }
    return nComponents.reduce(0) { $0 + $1 } + n
}

let maxNumber = 5000
let nonSelfNumbers: [Int] = Array(1...maxNumber).map { generate($0) }
let sumOfSelfNumbers = Array(Set(1...maxNumber).subtract(Set(nonSelfNumbers))).reduce(0) { $0 + $1 }

전체에서 non-self-number인 값들을 제하는 방식입니다.

# coding: utf-8
# 셀프넘버 1~5000까지의 합을 구하라

def d(n):
    result = 0

    if len(str(n)) == 1:    # 한자리 일때 자신 더하기
        result = n + n
    elif len(str(n)) > 1:   # 한자리 이상일때는 각 자리수 더하기 
        for c in str(n):
            result += int(c)
        result += n 

    return result

if __name__ == '__main__':
    # 제네레이터 있는 값들만 리스트로 저장
    # 제한값보다 높게 잡아야 해당값들을 저장할 수 있다. 
    first_list = [d(n) for n in range(6000)]
    sum = 0
    # 0~5000까지 돌면서 리스트에 없는값(셀프넘버)만 저장 
    for i in range(5001):
        if i not in first_list:
            sum += i

    print sum

package main

import (
    "strconv"
    "fmt"
)

func FuncD(num int) int {
    sum := num
    str_num := strconv.Itoa(num)
    for i := 0; i < len(str_num); i++ {
        sum += int(str_num[i] - '0')
    }
    return sum
}

func main()  {
    m := make(map[int]bool)
    for i := 1; i <= 5000; i++ {
        m[i] = true
    }

    for i := 1; i <= 5000; i++ {
        n := FuncD(i)
        delete(m, n)
    }

    var sum int
    for key := range(m) {
        sum += key
    }

    fmt.Print(sum)
}

할줄 아는게 자바밖에 없어서 ㅎㅎ

public class Application {
    static boolean arr[] = new boolean[5000];

    public static void main(String[] args) {
        int gen = 1;
        int sum = 0;
        while (true) {
            int ret = d(gen++);
            if(ret == -1)
                break;
            sum += ret;
        }
        int result = 4999*(5000)/2-sum;
        System.out.println(result);
    }

    static public int d(int gen){
        int a = gen/1000;
        int b = gen/100 % 10;
        int c = gen/10 % 10;
        int d = gen/1 % 10 ;
        int ret = a+b+c+d+gen;
        if(ret >= 5000)
            return -1;
        if(!arr[ret])
            arr[ret] = true;
        else 
            return 0;

        return ret;
    }

}

결과 : 1227365

시간 복잡도 O(n) 정도가 최선일 것 같습니다.

자바스크립트로 풀었스빈당.

<script>
var val_sum = 0;

for(var i=1; i<5000; i++)
{
    if(calc_gen(i))
        val_sum += i;
}

console.log(val_sum);

function calc_gen(val)
{               
    for(var i=1; i<val; i++)
    {
        var str = i.toString();
        var sum = i;

        for(var j=0; j<str.length; j++)
        {
            sum += parseInt(str[j]);
        }
        if(val == sum)
            return false;;
    }
    return true;
}       
</script>

답 : 1227365

Python3 : numpy + anaconda accelerate를 이용해 작성하였습니다. 확실히 cuda로 수행하니 속도가 빠르군요~ ^^

import numpy as np
from accelerate.cuda import cuda

@cuda.jit(argtypes=[cuda.numba.i4[:], cuda.numba.i4[:]])
def cuda_generate(a, b):
    i = cuda.grid(1)
    n = a[i]
    s = 0
    while n > 0:
        s += n%10
        n = int(n/10)
    b[i] = s + a[i]

griddim = 50, 1
blockdim = 100, 1, 1

N = griddim[0] * blockdim[0]
a = np.array(range(1,5001), dtype=np.int32)
b = np.empty_like(a)

cuda_generate_configured = cuda_generate.configure(griddim, blockdim)
cuda_generate_configured(a, b)
print(sum(np.setdiff1d(a,b)))

결과
1227365

list_1 = list(range(1,5001))
list_2 = list(range(1,5001))
for a in list_1:
    if len(str(a)) == 1:
        k = a + a
        try:
            list_2.remove(k)
        except:
            pass
    elif len(str(a)) == 2:
        k = a + int(str(a)[0]) + int(str(a)[1])
        try:
            list_2.remove(k)
        except:
            pass
    elif len(str(a)) == 3:
        k = a + int(str(a)[0]) + int(str(a)[1]) + int(str(a)[2])
        try:
            list_2.remove(k)
        except:
            pass
    elif len(str(a)) == 4:
        k = a + int(str(a)[0]) + int(str(a)[1]) + int(str(a)[2]) + int(str(a)[3])
        try:
            list_2.remove(k)
        except:
            pass
    if a == 5000:
        print(sum(list_2))

처음해봐서 어렵네요. ㄷㄷ 파이썬입니다.

public void getSelfNumberSum(){

        //먼저 숫자를 넣어놓고, 지우는 방식으로.
        Map<Integer, Boolean> selfNumberMap = new HashMap<Integer, Boolean>();
        int no = 1;
        while(no < 5000){
            selfNumberMap.put(no, true);
            no++;
        }

        for(int i=1; i < 5000; i++){
            String num = String.valueOf(i);
            int numSum = 0;
            for( int j=0; j < num.length(); j++){
                numSum += Integer.parseInt(num.substring(j, j+1));
            }
            numSum += i;

            //제너레이터가 있는 숫자는 셀프넘버 맵에서 제거
            selfNumberMap.remove(numSum);

        }

        Set<Integer> selfNumbers = selfNumberMap.keySet();
        Iterator<Integer> it = selfNumbers.iterator();
        int sum = 0;
        while(it.hasNext()){
            sum += it.next();
        }

        System.out.println("self number's sum= " + sum);

    }

print """ 
coded in Python 2.7.10
This program is to sum self numbers 
from START number to LAST number (not included). 
"""
start=raw_input("Enter START number: ")
end=raw_input("Enter LAST number:")
(m,n)= (int(start), int(end))
a=set(range(m,n))
b=set([])
for x in range(m,n):
  y=x+sum(int(i) for i in str(x))
  if int(y)<n: b= b|set([y,])
self_numbers=a-b
print "Self-numbers from %d to %d =" %(m,n), sorted(self_numbers)
print "Sum of integers over %d ~ %d = " %(m,n-1), sum(a)
print "Sum of non-self-numbers = ",sum(b)
print "Sum of self-numbers = ", sum(a)-sum(b)

#coding: CP949
A=list(map(str,range(1,5000)))
List= []
result=[]
for i in A:
    K=int(i)
    for j in i:
        K+=int(j)
    List.append(K)
List=set(List)
A=list(range(1,5000))
for i in List:
    if i in A:
        A.remove(i)
print(A)
파이썬 3.4

python 3.5

def d(n):
    result = n
    for x in str(n):
        result += int(x)
    return result

total = sum([i for i in range(1, 5000)])
generator_total = sum(set([d(i) for i in range(1, 5000) if d(i)<5000]))

print(total-generator_total)

Java

import java.util.Scanner;


class Generator{

    public int generator(int num){
        String number = Integer.toString(num);
        int result = 0;
        int n;

        for(int i = 0; i < number.length(); i++){

            n = number.charAt(i);
            result += Character.getNumericValue(n);
        }

        return result + num;
      }
  }


public class Nexon{

    public static void main(String[] args){

        Generator d = new Generator();
        Scanner input = new Scanner(System.in);


        System.out.print("숫자 입력: ");
        int value = input.nextInt();

        System.out.println(d.generator(value));
    }
}

def generate(x):
    total = 0
    for i in range(len(str(x))):
        total += int(str(x)[i])
    total += x
    return total

if __name__ == '__main__':
    while 1:
        li = []
        last = int(input("목표 지점: "))
        for x in range(1,last):
            if generate(x)<last:li.append(generate(x))
            else:break
        print(sum(set(x for x in range(1,last))-set(li)))

파이썬 3.5.1

import java.util.*;

public class selfNumber {
    public static void main(String[] args) {
        int target = 5000;
        int result = ((target+1)*target)/2;
        HashSet<Integer> list = new HashSet<Integer>();
        for(int i = 1; i <= target; i++){
            int sum = i;
            String xS = ""+i;
            for (int j = 0; j < xS.length(); j++){
                sum += Integer.parseInt(String.valueOf(xS.charAt(j)));
            }
            if (sum<=target)
                list.add(sum);
            }
        for (Integer i:list)
            result -= i;
        System.out.println(result);
    }
}

자바

int sumOfSelfNums() {
        int div = 1;
        boolean [] noSelf = new boolean[5000];
        int selfSum = 0;

        for(int n=1; n<5000; n++) {
            int sum = 0;

            while(n / div >= 10) {
                div *= 10;
            }

            int m = n;

            while(m >= 10) {
                sum += m / div;
                m = m % div;
                div /= 10;
            }
            sum += m;
            sum += n;

            if((sum >= 1) && (sum < 5000)) {
                noSelf[sum] = true;
            }
        }

        for(int i=1; i<5000; i++){
            if(noSelf[i] == false){
                selfSum = selfSum + i;
            }
        }

        return selfSum;
    }

java로 작성했습니다.

nums = range(1,5001) # Total number set 1~5000
non_selfnums=[sum([int(i) for i in str(num)]) + num for num in nums]  # non-self number set
selfnums = set(nums) - set(non_selfnums)  # (Total number set)-(non-self number set)=self number set

print(sum(selfnums))

def generator(n):           # 제네레이터 결과값 계산
    gen_num = n
    for num in str(n):
        gen_num += int(num)
    return gen_num

def generators(n):          # 제네레이터 함수로 결과값들 리스트 만들기.
    gen_result_list = []
    for gen_num in n:
        gen_result_list.append(generator(gen_num))
    return gen_result_list

numbers = range(5001)       #범위지정
print sum(set(numbers) - set(generators(numbers))) # 차집합을 이용해서 최종결과계산 ( 범위리스트 - 제네레이터 결과값들 리스트 )

파이썬 3.4.2입니다.

def d(n):
    s = ' '.join(str(n)) # 들어온 숫자를 문자열로 변환해 사이사이에 띄어쓰기
    s = sum(list(map(int,s.split()))) # 그 문자열을 띄어쓰기를 기준으로 나눠 생성한 리스트의 각각의 성분을 정수화하고 그것을 더함 -> 각 자릿수의 합
    return s + n # 그 숫자와 원래의 숫자를 넘겨준다.

subj = set(range(1,5001)) # 1부터 5000까지의 자연수가 들어있는 집합
nonself = set() # '셀프 숫자'가 아닌 것이 들어갈 집합
for i in range(1,5001): # 1부터 5000까지
    nonself.add(d(i)) # 모두 계산한 것을 집어는다. 이때 중복이 안됨.

print(sum(subj-nonself)) # subj에서 nonself를 빼면 남는 것은 제너레이터가 없는 집합들. 이를 더해주면 된다.

C#으로 작성했습니다. Hashtable을 사용했습니다.

using System.Collections;

        public int SumOfSelfNumbers(int n)
        {
            var sum = 0;
            var outputs = new Hashtable();
            for (int i = 1; i < n; i++)
            {
                var d = i/1000 + (i%1000)/100 + (i%100)/10 + i%10 + i;
                outputs[d] = i;
            }
            for (int i = 1; i <= n; i++) sum += outputs.ContainsKey(i) ? 0 : i;
            return sum;
        }

이렇게 만들어 보았습니다.

https://scratch.mit.edu/projects/104753260/#editor

정답이 1223023 맞나요? 아래와 같이 풀었습니다. 일단 1~5000까지 제너레이팅 한 후에, 배열에다가 각 값의 인덱스에 -1로 표기를 해서 -1 아닌 인덱스만더해서 값을 냈습니다.

   public int sumOfSelfNumber(int num) {
        int sum = 0;
        int[] result = new int[num+1];
        int d = 0;
        for(int i = 1  ; i <= num ;i++){
            d = generator(i);
            if(d <= num)
               result[d] = -1;
        }

        for(int i = 1  ; i <=num ; i++){
            if(result[i] != -1){
                sum += i;
            }
        }
        System.out.println("sum : " + sum);
        return sum;
    }
    public int generator(int num){


        int result = num;
        result += num %10;
        while(num > 10){
            num = num / 10;
            result += num % 10 ;
        }

        return result;
    }

def ddn(a):                   
    ddsum=a
    for i in str(a):
        ddsum += int(i)
    return ddsum
k=set()
l=set()
sum=0
for i in range(1,5000):                       
    k.add(ddn(i))
for j in range(1,5000):
    l.add(j)
    if l.union(k) != k:
        sum += j
        l.remove(j)
print(sum)

java 최신버전으로 작성했습니다. 지적 감사히 받아들이겠습니다.

class Main{
    public static void main(String[] args){
        int selfSum=0;
        int input=5000;
        for(int i=1;i<input;i++){
            boolean geneFind=false;
            String n="";
            int sum=0;
            int d=i;
            for(int j=1;j<=i;j++){
                n=String.valueOf(j);
                sum=0;
                for(int k=0;k<n.length();k++){
                    sum+=(int)n.charAt(k)-48;
                }
                if((Integer.parseInt(n)+sum)==d){
                    //System.out.println(n+"은 "+d+"의 제네레이터 입니다.");
                    geneFind=true;
                }   
            }
            if(geneFind==false){
                System.out.println(d+"는 셀프넘버이다.");
                selfSum+=d;
            }
        }
        System.out.println(input+"까지의 셀프넘버 총합:"+selfSum);
    }
}

Python 3.4

bucket = set(range(1, 5000))

for n in range(1, 5000):
    bucket -= {n + sum([int(x) for x in str(n)])}

print(sum(bucket))

Ruby

generator = ->n { n.digits.sum + n }
sum_of_selfnums = ->limit { ([*1..limit] - (1..limit).map(&generator)).sum }

Test

expect(generator[91]).to eq 101
expect(sum_of_selfnums[5000]).to eq 1227365

    final Logger logger = LoggerFactory.getLogger(CodeTest2.class);

    private Integer plus(Integer number) {
        return (number % 10) + (number >= 10 ? plus(number / 10) : 0);
    }

    private int generator(int d) {
        return d + plus(d);
    }

    @Test
    public void 각자리수의합() {
        int sum = 0;
        for(int i=1;i<5000;i++) {
            sum+= generator(i);
        }
        logger.debug("{}", sum);
    }

파이썬3.5

d = lambda n: sum(int(x) for x in str(n)) + n
a = {n for n in range(1, 5000)}
b = {d(n) for n in range(1, 5000)}
print(sum(a-b))

파이썬 3입니다. 프로그래밍을 배운지 얼마 안되서그런지 초보티가 너무나는거같네요ㅎㅎ

def d(n):
    a=list(str(n))
    b=[]
    while a:
        b.append(int(a.pop()))
    return sum(b)+n

selfnumber=list(range(5000))

for i in range(5000):
    if d(i)>=5000:
        continue
    selfnumber[d(i)]=0

print(sum(selfnumber))

int _tmain(int argc, _TCHAR* argv[])
{
    int nNumberpool[5001] = {0,};
    int nNonGeneratorCountpool[5000];
    int nSum = 0;
    for (int n = 1; n <= 5000; n++)
    {
        int nFirst = n /1000;
        int nSecond = (n % 1000) / 100;
        int nTherd = (n % 100) / 10;
        int nFist = n % 10;

        int nGenerator = n + nFirst + nSecond + nTherd + nFist;

        if (nGenerator <= 5000)
        {

            nNumberpool[nGenerator]++;
        }

    }

    for (int n = 1; n <= 5000; n++)
    {
        if(nNumberpool[n] == 0)
        {
            nSum += n;
        }
    }

    cout <<nSum;

    return 0;
}

n = c(1:4999)
a = sapply(n, function(x){
  tmp = x; tmp1 = c(tmp)
  for(i in 1:nchar(tmp)) tmp1[i+1] = as.integer(substr(tmp, i, i)); tmp2 = sum(tmp1)
  return(tmp2)
})

sum(subset(n, !(n %in% a)))

public static int getSumOfSelfNumbers(int maxRange){
        int sum = 0;

        LinkedHashSet<Integer> hasGenerator = new LinkedHashSet<Integer>();
        for(int num = 1; num<=maxRange; num++){
            int dn = num;
            String s = Integer.toString(num);

            for(int j = 0; j<s.length(); j++){
                dn += Integer.parseInt(s.substring(j, j+1));
            }

            hasGenerator.add(dn);
        }

        for(int num = 1; num <= maxRange; num++){
            if(!hasGenerator.contains(num)){
                sum += num;
            }
        }

        return sum; 
    }

답은 1227365

def d(n):
    result = n
    for i in str(n):
        result += int(i)
    return result

mems = []
sum = 0
for j in range(1, 5000):
    if d(j) not in mems:
        mems.append(d(j))
for k in range(1, 5000):
    if k not in mems:
        sum += k
print(sum)

파이썬 3.5로 작성하였습니다.

결과값은 [1227365]가 나왔습니다.

부족한 점이 많습니다.

열심히 배우겠습니다. 감사합니다.

#include <stdio.h>

int generator(int n)
{
    int sum = n;
    while (n > 0)
    {
        sum += n % 10;
        n /= 10;
    }

    return sum;
}

int main()
{
    int arr[5100] = {0,};
    int sum=0;
    for (int i = 1; i <= 5000; i++)
    {
        arr[generator(i)] = true;
    }

    for (int i = 1; i < 5000; i++)
    {
        if (!arr[i])
            sum += i;
    }
    printf("합:%d\n", sum);

    return 0;
}

에라토스테네스의 체랑 비슷한 방법으로 풀었습니다

```

include

int main(){

// 제너레이터 구하기 .  범위는 1~ 5000.
// generator ? d(91) = 1 + 9 + 91 = 101임.91을 101의 제네레이터라고함.
// 제네레이터가 없는수(셀프넘버. self Number)들이 있는데, 이 수들을 구하여라 .
int arr[5000] = {0};
int i = 0;
while(i <= 5000){
    char chList[4];
    int tmp = i;
    int result = i;
    int j = 0;
    while(j < 4){
        chList[j] = tmp%10;
        tmp/=10;

        result += chList[j];
        j++;
    }
    if(result < 5000)
        arr[result]++;
    i++;
}
i = 0;
int sum = 0;
while(i < 5000){
    if(arr[i] ==0){
        sum+= i;
    }
    i++;
}
printf("[%d]",sum);
return 0;

} ```이게 맞을진 모르겠네요 .. :(

좀더 간단하고 쉽게할수있는방법이 있을것같은데, 생각좀해봐야겠네요 ㅎㅎ

파이썬 3.5로 풀었습니다.

def d(n):
    return n + sum([int(x) for x in str(n)])

S = set(range(1, 5000))
A = set([d(n) for n in range(1, 5000)])
print(sum(S-A))

def d_func(n) :
    x = n / 1000
    y = (n - (x*1000)) / 100
    z = (n - (x*1000) - (y*100)) / 10
    c = (n - (x*1000) - (y*100) - (z*10))
    result=n+x+y+z+c
    return result


A = set(range(1,5000))
B = set(d_func(n) for n in range(1,10000))
C = A-B

print sum(C)

#include <stdio.h>
#define MAX 5000
#define TRUE 1
#define FALSE 0
int Self_Num(int var);

int main(void)
{
    int i, result;
    result = 0;

    for (i = 1; i < MAX; i++) {
        if (Self_Num(i) == TRUE)
            result += i;
        else
            continue;
    }

    printf("%d\n", result);
    return 0;
}

int Self_Num(int var) //Self Number을 판별하는 함수//
{
    int i, digit_sum, result, temp, flag;
    digit_sum = 0;
    flag = TRUE;

    for (i = 1; i < var; i++) {
        temp = i;

        while (i >= 10) { //각 자릿수의 합//
            digit_sum += i % 10;
            i /= 10;
        }
        digit_sum += i;

        result = temp + digit_sum; //각 자릿수 + 원래 숫자//

        if (result == var) { //결과 값이 변수와 같으면? (제너레이터가 존재하면? -> Self Number가 아니다.)
            flag = FALSE;
            break;
        }

        else {
            digit_sum = 0;
            i = temp;
            continue;
        }
    }
    return flag;
}

int sum=0;
boolean[] generator = new boolean[5000];

for (int i = 1; i < 5000; i++) {
    int num = i + i%10 + i/10%10 + (i/100)%10 + i/1000%10;
    if (num<5000) generator[num] = true;
}
for (int i = 1; i < 5000; i++) {
    if (generator[i]==false) sum+=i;
}
System.out.println(sum);

package m1606;

import java.util.HashMap;

public class Test2 {

    /*
    어떤 자연수 n이 있을 때, d(n)을 n의 각 자릿수 숫자들과 n 자신을 더한 숫자라고 정의하자.

    예를 들어

    d(91) = 9 + 1 + 91 = 101

    이 때, n을 d(n)의 제네레이터(generator)라고 한다. 위의 예에서 91은 101의 제네레이터이다.

    어떤 숫자들은 하나 이상의 제네레이터를 가지고 있는데, 101의 제네레이터는 91 뿐 아니라 100도 있다. 그런데 반대로, 제네레이터가 없는 숫자들도 있으며, 이런 숫자를 인도의 수학자 Kaprekar가 셀프 넘버(self-number)라 이름 붙였다. 예를 들어 1,3,5,7,9,20,31 은 셀프 넘버 들이다.

    1 이상이고 5000 보다 작은 모든 셀프 넘버들의 합을 구하라.
*/

    public static void main(String[] args) {
        HashMap<Integer, Integer> genList = new HashMap<Integer, Integer>();

        int genNumber = 0;
        int iNum = 0;
        while(getGenerator(iNum) < 5000){
            genList.put(iNum, getGenerator(iNum));
            iNum++;
        }


        for(int i = 0; i < genList.size(); i++){
            if(!genList.containsValue(i)){
                System.out.println(i);
                genNumber += i; 
            }
        }

        System.out.println("genNumber : " + genNumber);

    }

    public static int getGenerator(int sNum){
        int retVal = sNum;
        String strNum = String.valueOf(sNum);

        int numlength = String.valueOf(sNum).length();
        for(int i = 0; i < numlength; i++){
            retVal += Integer.parseInt(strNum.substring(i, i+1));
        }

        return retVal;
    }

}

import java.util.ArrayList;

public class test {
    public static void main(String[] argv) {

        int a = 0 ;
        int x = 0 ;
        ArrayList<Integer> listGenerator = new ArrayList<Integer>();

        while(a < 5000){
            listGenerator.add(generator(a));
            a++;
        }


        for(int i = 0; i<5000; i++){
            if(!listGenerator.contains(i)){
                x += i;
            }
        }

        System.out.println(x);
    }


    public static int generator(int a){
        String tempStr = String.valueOf(a);
        int y = 0;

        for(int i = 0 ; i<tempStr.length(); i++){
            y += Integer.parseInt(tempStr.substring(i, i+1));
        }

        return y+a;

    }

}

GCC

c;i;j;a[9999];main(b){for(;++i<5001;a[b]++,a[i]||(c+=i))for(b=j=i;j;j/=10)b+=j%10;printf("%d",c);}

수학적으로 풀면 매우 쉽게 해결할 수 있겠지만 C++를 많이 사용해보려고 C++의 기능을 사용해서 작성해봤습니다.

#include <iostream>
#include <string>
#include <vector>

unsigned int d_fn(int num);
int main(void) {
    std::vector<int> arr;
    unsigned int d_sum;
    bool exists;
    for (auto idx = 1; idx <= 5000; idx++) {
        d_sum = d_fn(idx);
        exists = std::find(std::begin(arr), std::end(arr), d_sum) != std::end(arr);
        if (!exists) {
            arr.push_back(d_sum);
        }
    }
    d_sum = 0;
    for (auto idx = 1; idx <= 5000; idx++) {
        exists = std::find(std::begin(arr), std::end(arr), idx) != std::end(arr);
        if (!exists) {
            d_sum += idx;
        }
    }
    std::cout << d_sum << std::endl;
}
unsigned int d_fn(int num) {
    std::string st;
    unsigned int d_sum;
    st = std::to_string(num);
    d_sum = num;
    for (auto i = 0; i < st.length(); i++) {
        d_sum += (int)(st[i] - 48);
    }
    return d_sum;
}

array= [True] * 5001
result = 5000 * ( 5000+1 )//2


ret = 0
temp = 0

for n in range(1, 5001) :
    temp = n
    while temp > 0 :
        ret += temp % 10
        temp = temp // 10

    ret+=n
    if n != ret and ret < 5001 and array[ret] != False:
        array[ret] = False
        result -= ret
    ret = 0

print (result)

자바로 만들어 봤어요 아직 많이 배워야 하는 단계라 정말 많이 부족한 것 같습니다.

public static void main(String[] args) {

        final int Number=5000;
        int Notgenerator =0;
        final int Number_48= 48;

        ArrayList<Integer> generator = new ArrayList<Integer>();

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

            String text = String.valueOf(i);

            switch (text.length()-1) {
            case 0:
                generator.add(((int)text.charAt(0)-Number_48) + Integer.parseInt(text)); 
                break;
            case 1:
                generator.add(((int) text.charAt(0)-Number_48) +((int)text.charAt(1)-Number_48)  +
                                Integer.parseInt(text)); 
                break;
            case 2:
                generator.add(((int) text.charAt(0)-Number_48) +((int) text.charAt(1)-Number_48)+
                                   ((int) text.charAt(2)-Number_48) + Integer.parseInt(text));
                break;
            case 3:
                generator.add(((int) text.charAt(0)-Number_48)+((int) text.charAt(1)-Number_48)+
                                   ((int) text.charAt(2)-Number_48)+((int) text.charAt(3)-Number_48) +
                                  Integer.parseInt(text));
                break;

            default:
                break;
            }
        }
        for(int j=1; j<Number;j++){
            if(!generator.contains(j)){
                Notgenerator += j;
            }
        }
        System.out.println("1이상이고 5000보다 작은 모든 셀프넘버의 합은  "+Notgenerator+" 입니다.");
    }

1이상이고 5000이하인 셀프넘버의 합은 1227365 입니다.

C# 으로 해봤습니다.

    public void Display()
    {
        Stopwatch sw = new Stopwatch();
        sw.Start();
        int sumresult = 0;

        for(int i = 0; i < 5000; i++)
        {
            int result = D(i+1);//0부터 for문 돌렸으니... 
            if (result == i)// 같으면 셀프넘버
                sumresult += i; //셀프넘버 더하기
        }

        sw.Stop();
        Console.WriteLine("Test(" + row + ") result is " + sumresult + " ("+ sw.ElapsedMilliseconds.ToString() + "ms)");
    }
    private int D(int n)
    {
        int su = 0;
        int sum = 0;
        int number = n;

        while (number > 0)
        {
            su = n % 10; //1의자리숫자를 구한다.
            sum += su; // 구한 1의자리 숫자를 더한다.
            number = number / 10; //10으로 나눈다. (만약 3자리였으면 2자리 다시돌면 1자리 로 될것)
        }
        sum = sum + n;
        return sum;
    }

c입니다. 이론없이 무작정 돌렸습니다. 값이 나오면 flag에 1을넣고 안나오면 0을넣어서 0~MAX까지 0인것들의 index를 더했습니다.!! 초보벗어나고싶네요. 바로바로 코딩되어졌으면 좋겠네용 ㅎㅎ

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<malloc.h>

#define MAX 5000
int d(int n)
{

    int sum = n;
    while (n)
    {
        sum += n % 10;
        n /= 10;
    }
    return sum;

}
int generate_and_sum_self_number(bool flag[])
{
    int sum = 0;
    for (int i = 1; i < MAX; i++)
    {
        int g = d(i);
        if (g < MAX)
            flag[g] = true;
        if (flag[i] == false)
            sum += i;
    }
    return sum;
}
int main()
{
    bool flag[MAX] = { 0 };
    printf("%d", generate_and_sum_self_number(flag));
}

1~5000까지의 generated number 를 구한 후 generated number 를 제외하여 self number를 구한다. 그 후 전체 self number를 합하여 답을 낸다.

이 때, 1은 기본으로 self number에 포함합니다.

max_range = 5000
self_number = ([1])
generated_number = ([])

for i in range(1, max_range):
    k_temp = sum([int(k) for k in str(i)])+i;
    generated_number.append(k_temp);

generated_number.sort()

index_point = 0
for i in range(2, max_range):
    if i < generated_number[index_point]:
        self_number.append(i);
    elif i == generated_number[index_point]:
        index_point += 1;
        while generated_number[index_point] <= i:
            index_point += 1;

sum_self_number = sum(k for k in self_number)

print(sum_self_number)

Delphi 2010

function SelfNumber(N: Integer): Integer;
var
  isSelfNo: array of boolean;
  sumOfSelfNo, k, _d, i: Integer;

  function d(k: Integer): Integer;
  var
    res: Integer;
  begin
    res := k;
    while (k <> 0) do
    begin
      Inc(res, k mod 10);
      k := k div 10;
    end;
    result := res;
  end;

begin
  SetLength(isSelfNo, N+1);
  for i := 0 to N  do // 초기화
    isSelfNo[i] := false;

  sumOfSelfNo := 0;
  k := 1;
  while (k <= N) do
  begin
    if not isSelfNo[k] then
      Inc(sumOfSelfNo, k);
    _d := d(k);
    if (_d <= N) then
      isSelfNo[_d] := true;
    Inc(k);
  end;
  result := sumOfSelfNo;
end;

Python 3.5

def d(n):
    sum=0
    s=str(n)
    for i in s:
        sum+=int(i)
    sum+=n
    return sum

list=[]
for i in range(1,5050):
    list.append(0)
for i in range(1,5000):
    list[d(i)]+=1
result=0
for i in range(1,5000):
    if list[i]==0:
        print("셀프넘버: %d" % i)
        result+=i
print("최종 셀프넘버의 합: %d" % result)

#include <iostream>

using namespace std;

int selfNumber[5000];
bool CalculateDnum(int num);

int main(void)
{
    int sum = 0;
    bool out = true;
    int idx = 1;
    for (int i = 0; i < 5000; i++)
    {
        selfNumber[i] = i;
    }
    while (out)
    {
        out = CalculateDnum(idx);
        idx++;
    }
    for (int i = 0; i < 5000; i++)
    {
        sum+= selfNumber[i];
    }
    cout << sum << endl;
    getchar();
    return 0;
}

bool CalculateDnum(int num)
{
    int tmp = num;
    int a, b, c, d = 0;
    int dNum = 0;

    a = tmp%10;
    b = tmp%100*0.1f;
    c = tmp%1000*0.01f;
    d = tmp%10000*0.001f;

    dNum = a + b + c + d + tmp;

    if (dNum >=5000)
    {
        return false;
    }
    else
    {
        selfNumber[dNum] = 0;
        return true;
    }
}

c++로 짰습니다. 처음인데 재밋네요.. 하다보면 늘겠죠....

#d(n)은 n의 각 자리수와 n 자신을 더한 수
#d(91)=9+1+91=101, d(100)=1+0+0+100=101
#셀프넘버 : d(generator)=n을 만족하는 generator가 없는 수
#1에서 5000사이의 셀프넘버의 합

def d(n):
    result=n
    string=str(n)
    for k in range(0, len(string)):
        result+=int(string[k])
    return result

#d(n)>n이 항상 성립한다.

#good은 d(n)결과값으로, 하나 이상의 제너레이터를 가지는 수
good=[]
for k in range(1, 5001):
    print('%3d : %3d' %(k, d(k)))
    good.append(d(k))
print()
good.sort()

#self는 셀프넘버 리스트
self=[]
for k in range (1, 5001):
    if k not in good:
        print(k)
        self.append(k)

answer=sum(self)
print("셀프넘버의 합은 %d" %answer)

#My result code
original = 1
temp = 0
allSet=set()
tempSet=set()
sumResult=0

while temp < 5000:
    temp = 0
    copyNumber = original
    temp += copyNumber
    while copyNumber :
        temp += copyNumber%10
        copyNumber = int(copyNumber/10)
    if temp >= 5000:break
    tempSet.add(temp)
    original+=1

for i in range(1,5000):
    allSet.add(i)

result = list(allSet - tempSet)
result.sort()
print(result)

for i in list(result):
    sumResult+=i
print(sumResult)

아직 python에 익숙하지 못해서 힘드네요...

s=[]
for i in range(1,5000):
    s += [i+eval("+".join(str(i)))]
print(sum(set(range(1,5000))-set(s)))

Python 3.5.2 입니다.

#include <iostream>
#include <stdio.h>
using namespace std;

int main()
{
    int max = 5000;
    int a, b, c, d;
    int sum = 0;
    int selfNumSum = 0;
    int* g = new int[5001];
    bool isGenerator[5001];
    for (int i = 0; i < 5000; i++)
    {
        isGenerator[i] = false;
    }
    for (int i = 0; i < 5000; i++)
    {
        g[i] = i + 1;
        a = (g[i] % 10000) / 1000;
        b = (g[i] % 1000) / 100;
        c = (g[i] % 100) / 10;
        d = (g[i] % 10);
        sum = g[i] + a + b + c + d;
        if (sum < 5000)
        {
            isGenerator[sum] = true;
        }
        if (isGenerator[i] == false)
        {
            if (i != 0)
            {
                selfNumSum += i;
            }
        }
    }
    cout << selfNumSum << endl;
}

def generator(seed):

    strSeed = str(seed)
    result = seed 

    for i in range(len(strSeed)) :
        result = result + int(strSeed[i])

    return result 

def sumSelfNumer():

    dic = {}
    for i in range(1, 5001) :
        dic[i] = generator(i)

    geneList = list(dic.values())

    sum = 0

    for i in range (1, 5001) :
        if i not in geneList :
            sum = sum + i


    print(sum)




def main():
    sumSelfNumer()

if __name__ == "__main__":
    main()

#include <stdio.h>

static const int nMaxNum = 5000;

int CalcGenerater(int n);
bool isGenerater(int n);

int main()
{
    int nSumIsNoSelfNum=0;
    bool bHaveGenerater[nMaxNum+32]={0};    //이부분을  bool bHaveGenerater[nMaxNum]={0}; 의 배열값으로 하면 스택오버플로나는데 왜그렇죠
    int nNum[nMaxNum]={0};


    for(int i = 1; i<=nMaxNum; i++)
    {
        nNum[i-1] = CalcGenerater(i);
        bHaveGenerater[nNum[i-1]-1] = isGenerater(nNum[i-1]);
    }

    for(int i=1; i<=nMaxNum; i++)
    {
        if(!bHaveGenerater[i-1])
            nSumIsNoSelfNum += (i);
    }

    printf("결과 : %d  ", nSumIsNoSelfNum);

    return 0;
}

int CalcGenerater(int n)
{
    return (n + (n/1000) + (n%1000)/100 + (n%100)/10 + n%10);
}

bool isGenerater(int n)
{
    if(n <= nMaxNum)
        return true;

    return false;
}

python 3.5 1-5000까지의 수 집합에서 1-5000까지의 제너레이트된 수의 집합을 뺍니다. (d(n)은 항상 자기자신 n 을 더하니까 n보다 작을 수 없으므로 제너레이트된 수의 집합이 항상 많습니다)

result = list(set(range(1,5000)) - set(eval("+".join(str(i))) + i for i in range(1, 5000)))
result.sort()

print(result)

class selfnum{
    int[] zene = new int[5001];
    int sum = 0;
    int ze=0;
    selfnum(){
        for(int i = 0 ; i<5001;i++)  zene[i]=i;
        for(int i = 1 ; sum<=5000;i++){
            zene[sum]=0;
            sum=0;
            ze = i;
            sum = ze+sum;
            for(int j=0;ze>0;j++){
                sum = sum+ze%10;
                ze=ze/10;
            }
        }
        sum=0;
        for(int i = 0 ; i<5001;i++)  sum=sum+zene[i];
        System.out.println(sum);

    }
}
public class lv2_12 {
    public static void main(String[] args) {
        selfnum s = new selfnum();
    }
}

자바 스크립트 입니다.

var arr = new Array(5001);

for(var i = 1; i <= 5000; i++){
    var tmpNum = i;
    var sum = i;
    while(tmpNum > 0){
        sum += (tmpNum % 10);
        tmpNum = parseInt(tmpNum / 10);
    }

    if(sum <= 5000){
        arr[sum] = 1;
    }
}

var selfSum = 0;

for(var i = 1; i <= 5000; i++){
    if(arr[i] == undefined) selfSum += i;
}

document.write("selfSum : " + selfSum);

1. 1~5000까지 자신부터 시작해서 10의 나머지를 하나씩 더하여 해당 인덱스에 단순히 1을 채우는 구조입니다.
2. 1이 채워지지 않은 배열이 있다면 셀프 넘버로 볼 수 있기 때문에 undefined을 체크해서 해당 인덱스의 합을 구하는 구조입니다.
3. 자바 스크립트에서 배열의 초기값은 undefined 입니다.

def d(n):
    N = set(range(1,n))   # 1~5000 전체 집합

    C = set([ num + sum( [int(comp) for comp in str(num)] ) for num in range(1,n)])
    # 일의 자리 + 십의자리 + number의 합 집합

    result = sum(N-C)
    # 집합의 차집합이니까 N에 없는 요소는 제외된다

    return result

1~5000보다 작은경우의 결과 값은 1227365

처음엔 아무 감도 잡히지 않았지만 위의 풀이를 보고 풀 수 있었습니다. 그대로 배낀 것 같지만ㅋㅋ

def d(n): return n + sum([int(x) for x in str(n)])

s = set(range(5000))
z = set([d(n) for n in range(5000)])

print(sum(s-z))

#include<stdio.h>
#include<stdlib.h>

struct number {
    int generator;
    int nGenerator;
};

void main(void) {
    int n = 31;
    int selfnumber;
    number* d = (number*) malloc (sizeof(number) * n+1);
    for(int i = 1 ; i <= n ; i++) 
        d[i].nGenerator = 0;

    for(int i = 1 ; i <= n ; i++) {
        d[i].generator =  i/1000 + (i%1000)/100 + (i%100) / 10 + (i%10) + i;
    }
    for(int i = 1 ; i <= n ; i++) {
        for(int j = 1 ; j<=n ; j++)
        if( i == d[j].generator)
            d[i].nGenerator ++;
    }

    for(int i = 1 ; i <= n ; i++) 
        if(d[i].nGenerator == 0 || d[i].nGenerator > 1)
            printf("%d\t", i);


}

def generator(num):
    digit=10
    digitcnt = 1    #입력된 값의 자릿수 카운트입니다.
    numcopy = num   
    while num > digit:
        digitcnt = digitcnt + 1
        digit = digit * 10

    sum = 0
#   d(91) = 9 + 1 + 91 = 101    계산하는 과정입니다.
    for i in range(0,digitcnt+1):
        sum= sum+num // digit
        num = num - num//digit*digit
        digit = digit / 10
    return sum+numcopy

num=[0]*5000    
sum =0
for i in range(0,5000):
    idx = generator(i)
    if idx <5000:
        num[idx]=1      #제네레이터를 체크합니다.

for i in range(1,len(num)):
    if num[i]==0 :  #SELF_NUMBER 확인하여 더합니다.
        sum = sum +i

자바

package study;

public class study {

    public static void main(String[] args) {
        System.out.println(solve(5000));
    }

    public static int solve(int n){
        int i, j, sum=0;

        for(i=1; i<n; i++){
            for(j=1; j<i; j++){
                int k=j+(j%10)+(j/10)%10+(j/100)%10+(j/1000)%10;
                if(k==i){
                    break;
                }
            }

            if(j==i){
                sum+=i;
            }
        }
        return sum;
    }
}

#include <stdio.h>

int d(int n){
    int s = 0;
    s += n;
    while(n > 0) {
        s += (n % 10);
        n = n / 10;
    }
    return s;
}

int main(){
    int a[5000];
    int dn = 0, s = 0;
    for(int i = 1; i < 5000; i++){
        a[i] = 0;
    }
    for(int i = 1; i < 5000; i++){
        dn = d(i);
        if(dn < 5000){
            a[dn] = 1;
        }
    }
    for(int i = 1; i < 5000; i++){
        if(a[i]==0){
            s += i;
        }
    }
    printf("%d",s);
}

한 줄에 마치신 분도 있고, 대박 신세계네요!!! 퇴근하고 틈틈이 책으로 파이썬을 배우고 있는데 많이 배우고 싶습니다. 잘 부탁드립니다.

n_number = list(range(1,5000))
reference = n_number[:]
for i in reference:
    digit_number = len(str(i))
    de_generator = 0
    for j in range(digit_number):
        de_generator += eval(str(i)[j])
    else:
        de_generator += i

    if de_generator in n_number:
        n_number.remove(de_generator)
    else:pass
n_number_sum = 0
for i in n_number:
    n_number_sum += i
    # print(n_number_sum)
print("The sum is",n_number_sum)

결과값은 1227365가 나왔어요 조금은 무식하게 짠거 같네요..

#include <stdio.h>

int main(void)
{
    int i = 0;
    int result = 0;
    int sum = 0;
    int num[5000]= {0,};

    for(i=0; i<5000; i++){
        num[i] = i+1;
    }

    for(i=0; i<5000; i++){
        result = d(i);
        printf("d(%d)  = %d \r\n", i, result);

        if((result < 5001) && (result != 0)){
            num[result-1] = 0;
        }
    }


    for(i=0; i<5000; i++){
        sum += num[i];
    }

    printf("sum  = %d", sum);

    return 0;
}


int d(int a){

    int result = a;
    int num = a;

    while(num != 0){
        result += num%10;
        num = num/10; 
    }

    return result;
}

def chkSelfNum(chkNum, period):
    trueFalse = True

    for num in range(1,(period+1)):
        if num > chkNum:
            break

        digit = len(str(num))
        sum = 0 
        for n in range(digit):
            sum = sum + int(str(num)[n])

        sum = sum + num 

        if sum == chkNum:
            trueFalse = False
            break

    return trueFalse

def main():
    selfNum = []
    for num in range(1,5000+1):
        if chkSelfNum(num, 5000) == True:
            selfNum.append(num)

    print("selfnumber are : ", selfNum)



if __name__ == '__main__':
    main()

간단하게 구현해보았습니다. 시간복잡도는 o(k*n)

public class FindSimpleNumber {
    private boolean[] hasGenerator;
    private final int MAX = 5000;

    public FindSimpleNumber() {
        this.hasGenerator = new boolean[MAX+1];
    }

    public int getSimpleNumberSum(){
        int sum = 0;
        for(int i=0; i<=MAX; i++){
            if(!hasGenerator[i]){
                sum+=i;
            }
            hasGenerator[isGenerator(i)] = true;
        }
        return sum;
    }
    private int isGenerator(int number){
        int result = number;
        while(number>0){
            result += (number%10);
            number/=10;
        }
        return result>MAX?0:result;
    }
}

Java 풀이입니다.

import java.util.ArrayList;

public class SelfNumber {

    public static void main(String[] args) {

        long start = System.currentTimeMillis();

        int n = 5000;

        ArrayList<Integer> selfNumbers = new ArrayList<>();
        for(int i = 1; i< n; i++){
            selfNumbers.add(i);
        }

        for(int i = 0; i < n; i++){
            int nonSelfNumber = d(i + 1);
            if(nonSelfNumber < n){
                Boolean res = selfNumbers.remove((Object)(nonSelfNumber));
            }
        }

        int sum = 0;
        for(int sn : selfNumbers){
            sum += sn;
        }

        System.out.println("sum : " + sum + ", time : " + (System.currentTimeMillis() - start) + "ms");
    }

    public static int d(int generator){
        int res = generator;
        while(true){
            res += generator % 10;
            if(generator / 10 == 0){
                break;
            }
            generator = generator / 10;
        }

        return res;
    }

}

#include <iostream>

inline int d(int n)
{
    int generator = n;

    while (n > 0)
    {
        generator += n % 10;
        n /= 10;
    }
    return generator;
}

int main(void)
{
    bool isSelfNumber[5000];
    int sum = 0;

    std::fill_n(isSelfNumber, 5000, true);

    for (int i = 1; i < 5001; i++)
    {
        int d_ = d(i);
        if(d_ <5000)
            isSelfNumber[d_] = false;
    }

    for (int i = 1; i < 5001; i++)
    {
        if (isSelfNumber[i])
            sum += i;
    }

    std::cout << sum << std::endl;
    return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <list>
#include <windows.h>
#include <stdio.h>
#include <string>

#define MAX 5000

using namespace std;


int main(void) {
    int ary[MAX] = { 0, };
    int i,n, gen, tself = 0;

    for (i = 0; i < MAX; i++) {
        ary[i] = i;
    }

    for (i = 0; i < MAX; i++) {
        n = i;
        gen = 0;
        while (n) {
            gen += n % 10;
            n = n / 10;
        }
        gen += i;
        if (gen < MAX) {
            ary[gen] = 0;
        }
        //generator을 찾아 0으로 ~
    }

    for (i = 0; i < MAX; i++) {
        tself += ary[i];
    }

    printf("total sum of selfnum : %d\n", tself);

    system("pause");
    return 0;

}

#include <stdio.h>

#define MAX_N 11111
int chk[MAX_N];
int f(int x){
    int ret = x;
    while(x){
        ret += x % 10;
        x /= 10;    
    }
    return ret;
}
int main(){
    int i, sum=0;
    for(i=1;i<=5000;i++) chk[f(i)] = 1;
    for(i=1;i<=5000;i++) if(!chk[i]) sum+=i;
    printf("%d\n", sum);
    return 0;
}

채점해보고 싶네요..

파이썬

def selfNum(n):
    return(n + sum([int(i) for i in str(n)]))

print(sum(set(range(5000)).difference(set([selfNum(n) for n in range(5000)]))))

Python 코드입니다.

All = [x for x in range(1,5001)]
gen = []

def generator(n):
    return (n + n//1000 + (n//100)%10 + (n//10)%10 + n%10)

for i in All:
    if generator(i) in All:
        gen.append(generator(i))

for i in gen:
    if i in All:
        All.remove(i)

print(sum(All))

파이썬 초보입니다. 많은 피드백 부탁드립니다!!

import java.util.ArrayList;

public class Nexon {

    static ArrayList<Integer> generatorList = new ArrayList<Integer>();

    public static void main(String[] args) {

        for(int i=1; i<5000; i++){
            int number = 0;
            String[] selfNumber = Integer.toString(i).split("|");
            for(int j=0; j<selfNumber.length; j++){
                number += Integer.parseInt(selfNumber[j]);
            }

            number = number + i;

            generatorList.add(number);

        }

        int sum = 0;

        for(int i=1; i<5000; i++){
            if(!generatorList.contains(i)){
                System.out.println(i);
                sum = sum + i;
            }

        }

        System.out.println(sum);

    }
}

import java.util.ArrayList;
import java.util.List;

public class nex1 {
    public void save()
    {
        int i=1;
        int sum = 0;
        List<Integer> ExrtaList = new ArrayList<Integer>();
        while(i<5000)
        {
            for(int j=0;j<i;j++)
            {

                int a1000 = j/1000;
                int a100 = (j-(a1000*1000))/100;
                int a10 = (j-(a1000*1000)-(a100*100))/10;
                int a1 = (j-(a1000*1000)-(a100*100) - (a10*10));
                if(i==(j+a1000+a100+a10+a1))
                {
                    if(ExrtaList.indexOf(i)==-1)
                    {
                        ExrtaList.add(i);
                    }
                }                   
            }       
            i++;
        }
        i=1;
        while(i<5000)
        {
            if(ExrtaList.indexOf(i)==-1)
            {
                sum+=i;
            }
        }
    }
}

#include <iostream>

using namespace std;

int d(int a) {

    int result = a;
    int num = a;

    while (num != 0) {
        result += num % 10;
        num = num / 10;
    }

    return result;
}

int main(void)
{
    int list[5000] = { 0, };
    int sumList = 0;
    int sum = 0;

    for (int i = 0; i < 5000; i++)
    {
        if (d(i) < 5000) 
        {
            list[d(i)] = d(i);
        }       
    }
// 0으로 초기화된 리스트에서 제네레이터를 보유한 숫자의 배열만 골라서 제네레이터를 보유한 숫자를 값으로 부여합니다. 
// 중복은 덮어씌워집니다.

    for (int i = 0; i < 5000; i++)
    {
        sumList += list[i];
    }
// 전체 배열을 합산합니다. 제네레이터를 보유한 숫자가 아니면 0 이기때문에 반영되지 않습니다. 

    for (int i = 0; i < 5000; i++) 
    {
        sum += i;
    }
// 전체 숫자를 합산합니다. 

    cout << sum-sumList << endl;


    return 0; 
}

앞서 작성하신 코드를 보고 나름대로 이해해보고 작성해봤습니다. 결과는 1227365로 나왔는데 결과에 끼워맞춰진거는 아닌지 불안하네요. C++ 입니다.

Number = range(1,5000)
unselfies = []

def d(n):
    result = sum(list(map(int, str(n)))) + n
    return result

n = 0
while d(n) < 5000:
    result = d(n)
    n = n+1
    unselfies.append(result)


selfies = [x for x in list(Number) if x not in unselfies]
print(sum(selfies))

Python 3.5.2

Java

import java.util.Arrays;
import java.util.Map;
import java.util.function.Function;
import java.util.function.IntUnaryOperator;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class SelfGeneratorTest {

    public static void main(String[] args) {
        IntUnaryOperator getGen = i -> i + Arrays.stream(String.valueOf(i).split("")).mapToInt(Integer::parseInt).sum();
        Map<Integer, Long> genMap = IntStream.rangeClosed(1, 5000).map(getGen).boxed().collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
        System.out.println(IntStream.rangeClosed(1, 5000).filter(i -> !genMap.containsKey(i)).sum());
    }
}

1227365

public static void main(String[] args)
    {
        int k=0;
        int[] pass = new int[5000];
        int pw2=0;
        int pw1=0;
        int count=0;
        int num_hap=0;
        for (int num = 1 ; num < 5000 ; num++)  //1부터 4999 사이의 제너레이터를 가질 수 있는 수 구하기
        {
            int sum = 0;
            String num_c = "" + num;

            if (num_c.length() == 1) sum = num+num;
            if (num_c.length() == 2) sum = num+ (num/10) + (num%10);
            if (num_c.length() == 3) sum = num+ (num/100)  +(num/10)%10 + (num%10);
            if (num_c.length() == 4) sum = num+ (num/1000) + (num/100)%10  +(num/10)%100%10 + (num%10);

            if (sum < 5000) //제너레이터를 가질 수 있는 수가 5000미만이면 pass배열에 값을 차례대로 저장
            {
                pass[k] = sum;
                k++;
            }

        }
        for (int j1 = 0; j1 <=k ; j1++) //중복되는 값 빼주기
        {
            for (int j2 = 0; j2 <=k ; j2++)
            {
                if (pass[j1] == pass[j2]) 
                {
                    count++;
                    if (count == 2) {pass[j1] = 0; count = 1;}
                }

            }
            count = 0;  
            pw2 = pw2 + pass[j1];
        }

        while (num_hap < 5000) // 1부터 4999까지 더하기
        {
            pw1 = pw1 + num_hap;
            num_hap++;
        }   
        System.out.println(pw1-pw2); //4999까지의 합 - 제너레이터를 가질 수 있는 수의 합(답)
    }

거의 스파게티 코딩 수준..

Python

num_list=list(range(1,5001))
tot=0
for i in range(1,5001):
    num_list.append(i)
for i in range(1,5001):
    gen_num=0
    for j in range(len(str(i))):
        gen_num+=int(str(i)[j])
    gen_num+=i
    if gen_num in num_list:
        num_list.remove(gen_num)
for i in range(len(num_list)):
    tot+=num_list[i]
print(tot)

temp = 0
arr = [0 for _ in range(5001)]
for i in range(1, 5001):
    sum_v = 0
    temp = i
    while temp >= 10 :
    sum_v += temp % 10
    temp = temp / 10
    sum_v += temp
    sum_v += i

    if sum_v >= 5000: continue
    arr[sum_v] += 1

sum_v = 0
for i in range(1, 5000):
    if arr[i] == 0:
    sum_v += i

print sum_v

5000까지의 Generator을 구하여 Set에 넣고, Set에 없는 수만 더하는 방식으로 풀었습니다.

결과는 1227365

import static org.junit.Assert.assertEquals;

import java.util.Set;
import java.util.TreeSet;

import org.junit.Test;

public class SumSelftNumber {

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

    public int sumSelftNumber(final int n) {
        Set<Integer> set = new TreeSet<>();

        for(int i = 1; i < 5000; i++) {
            int sum = i;
            int num = i;

            while(num != 0) {
                sum += num % 10;
                num /= 10;
            }

            set.add(sum);
        }

        int sumOfSelfNumbers = 0;

        for(int i = 1; i < 5000; i++) {
            if(!set.contains(i))
                sumOfSelfNumbers += i;
        }

        return sumOfSelfNumbers;
    }

    @Test
    public void testSumOfSelfNumbers() {
        assertEquals(1227365, sumSelftNumber(5000));
    }
}

1 이상이고 5000 보다 작은 모든 셀프 넘버들의 합을 구하라.

int sum = 0;
for (int i=1; i<5000; i++) {
  if (selfNumber(i)) {
    sum += i;
  }
}
printf("%d\n", sum);

제네레이터가 없는 숫자들도 있으며, 이런 숫자를 인도의 수학자 Kaprekar가 셀프 넘버(self-number)

int selfNumber(int n) {
    return countGenerators(n) == 0;
}

int countGenerators(int n) {
    int count = 0;
    for (int i=0; i<n; i++) {
        if (generate(i) == n) {
            count++;
        }
    }
    return count;
}

d(n)을 n의 각 자릿수 숫자들과 n 자신을 더한 숫자. n을 d(n)의 제네레이터(generator)라고 한다.

int generate(int n) {
    return n + sumDigits(n);
}

int sumDigits(int n) {
    int sum = 0;
    while (n > 0) {
        sum += n % 10;
        n /= 10;
    }
    return sum;
}

public class Main {

    public static void main(String[] args) {
    // write your code here
        int sum = 0;
        for (int i=1 ; i <= 5000; i++){
            if (isSelfNumber(i)){
                sum += i;
            }
        }
        System.out.println(sum);
    }

    private static boolean isSelfNumber(int i){
        for (int j=1; j <= i; j++){
            if (j+sumNumber(j) == i){
                return false;
            }
        }
        return true;
    }

    private static int sumNumber(int i){
        int sum = i % 10;
        if(i >= 10){
            sum += sumNumber(i / 10);
        }
        return sum;
    }
}

def tolist(int):
    string =str(int)
    mlist = []
    for i in range(0, len(string)):
        mlist.append(string[i:i+1])
    return mlist

list = list(range(1,5000))
result = 0
for i in range(1,5000):
    temp = 0
    for j in tolist(i):
        temp += int(j)
    temp += i
    try:list.remove(temp)
    except: pass
for i in list :
    result += i
print(" 셀프 넘버의 합 :", result)

def d(n):
    result = 0
    for i in str(n):
        result += int(i)
    return result+n

numbers = list(range(1,5000+1))

for i in range(5000):
    if d(i) in numbers:
        numbers.remove(d(i))
sum = 0
for x in numbers:
    sum += x
print(sum)

package practice_2; import java.util.ArrayList;

public class Practice_2 {

/**
 * @param args the command line arguments
 */
public static void main(String[] args) {
    boolean[]sample = new boolean[5000];
    ArrayList<Integer> generatedNumber = new ArrayList<Integer>();
    ArrayList<Integer> results = new ArrayList<Integer>();
    Generator gene = new Generator();
    int sum = 1;

    //1. init sample
    for(int i = 0; i<5000; i++){
        sample[i]= false;
        generatedNumber.add( gene.sumNum(i+1));
    }
    //2.compare;
    for(int i = 1; i < 5000; i++){  
        if( generatedNumber.get(i-1)>4999){
            break;
        }
        sample[generatedNumber.get(i-1)] = true;
    }

    for(int i = 0; i< 5000; i++){
        if(sample[i] == false){
            sum = sum+i;
        }
    }
    System.out.println(sum);  
}

}

import java.util.ArrayList;

public class Generator {

public int sumNum(int n){
    int dn=0;
    int origin = n;
    int numSize = 1;  //자릿수
    int initDivSeed = 1;
    int subSum = 0;

    //1. n의 자릿수 구하기
    for (int i = 10; i<=n; i = i*10){
        numSize++;
    }

    //2. 첫 seed 구하기
    for (int i = 1; i<numSize; i++){
        initDivSeed = initDivSeed * 10;
    }

    //3.나누면서 합계구하기
    for(int i = initDivSeed ; i> 0;i = i/10 ){
        subSum += n /i;
        n = n - (n/i * i);
    }

    //4.total dn구하기
    dn = subSum + origin;

    return dn;


}

}

답은 1227366 나왔습니다.

static void Main(string[] args)
{
    List<int> list      = new List<int>();
    List<int> self_list = new List<int>();
    for (int i = 1; i <= 5000; i++)
    {
        list.Add(i);
        self_list.Add(i);
    }

    foreach(int x in list)
    {
        var gen = Generator(x);
        if (list.Contains(gen))
            self_list.Remove(gen);
    }

    var sum = self_list.Sum();

    Console.WriteLine(sum);
}

static int Generator(int x)
{
    string[] value = x.ToString().ToCharArray().Select(z => Convert.ToString(z)).ToArray();

    int result = 0;
    for (int i=0; i< value.Length; i++)
    {
        if(!string.IsNullOrEmpty(value[i]))
        {
            result += Convert.ToInt32(value[i]);
        }
    }

    return (result += x);
}

숫자를 문자배열로 바꿔서 더하고, 제너레이트인것들을 리스트에서 제외하고 합을 구해봤습니다. 어렵네요.

JAVA로 작성했습니다.

SelfGenerator 의 총 합은 1227365 이네요.

package Questions;

import java.util.ArrayList;

public class SumSelfGenerator {

    public static void main(String[] args) {

        Generator generator = new Generator();

        int startNum = 1;
        int endNum = 5000;
        int sumOfGen = 0;

        ArrayList<Integer> numArr = new ArrayList<Integer>(); 

        //1~5000 까지 배열에 저장.
        long lStartTime = System.currentTimeMillis();

        for (int i = startNum; i < endNum; i++) {
            numArr.add(i-1, i);
        }

        //d(1) ~ d(5000)  => 값을 계산해서 나오는 값을 찾아서 삭제
        for (int i = startNum; i < endNum; i++) {
            int n = generator.calcGen(i);
            if (numArr.contains(n)) {
                numArr.remove(numArr.indexOf(n));
            }
        }

        //나머지 배열의 값을 Sum
        for (int i = 0; i < numArr.size(); i++) {
            sumOfGen += numArr.get(i);
        }
        long lDuration = System.currentTimeMillis() - lStartTime;
        System.out.println(String.format("Elapsed Time: %.3f seconds", lDuration/ 1000.0f));
        System.out.println(String.format("Sum of SelfGenerator Numbers: %d", sumOfGen));

    }
}

final class Generator {

    public Generator()  {

    }

    public int calcGen(int num) {
        String str = String.valueOf(num);

        int ret = 0; 
        for (int i = 0; i < str.length(); i++)  {
            String token = String.format("%s", str.charAt(i));
            ret += Integer.parseInt(token);
        }

        return ret + num;
    }
}

def f(n): 
    li = []
    li.append(int(n/1000))
    li.append(int(n/100)-10*int(n/1000))
    li.append(int(n/10)-10*int(n/100))
    li.append(n%10)
    return li

def d(n):
    s = n
    for i in range(4):
        for j in range(1, 10):
            if j == f(n)[i]:
                s += j
    return s

def test(n):
    for i in range(n-36,n):
        if n == d(i):
            return False
    return True

a = 0
for n in range(1, 5000):
    if test(n):
        a += n
        print("셀프 숫자:%s        합: %s" % (n, a))

a = [0 for _ in range(5000)]
sum = 0
for i in range(1, 5001):
    temp_string = str(i)
    sum = 0
    for string in temp_string:
       sum = sum + int(string)

    sum = sum + i
    if sum > 5000:
        continue

    a[sum - 1] = a[sum - 1] + 1

sum = 0
for i in range(5000):
    if a[i] == 0:
        sum = sum + (i + 1)

print sum

Stopwatch sw = Stopwatch.StartNew();
int SIZE = 4999;
Func<int, int> generator = (n) => (n.ToString().Sum(k => Convert.ToInt32(k.ToString()))) + n;
int[] nonselfnum = Enumerable.Range(1, SIZE).Select(k => generator(k)).Distinct().ToArray();
int selfnumSum = Enumerable.Range(1, SIZE).Where(k => !nonselfnum.Contains(k)).Sum();
sw.Stop();
Console.WriteLine($"Elapsed MillSecond : {sw.ElapsedMilliseconds}, Value : {selfnumSum}");

Elapsed MillSecond : 24, Value : 1227365

C로 작성```{.cpp}

include

int main(void) { int range, tot, i, j, set, storage, temporary;

range = 5000;
tot = 0;
storage = 0;
temporary = 1;

for (i = 1; i <= 5000; i++)
{
    temporary = 1;

    for (j = 1; j <= i; j++)
    {
        set = j;
        storage = 0;

        while (set > 0)
        {
            storage += set % 10;
            set /= 10;
        }
        if (i == storage + j)
        {
            temporary = -1;
            break;
        }
    }
    if (temporary == 1)
    {
        tot += i;
    }
}
printf("%d", tot);

return 0;

}

```

def d(x):
    Number_str = str(x)
    result = 0
    for x in Number_str:
        result += int(x)
    result += int(Number_str)
    return result


def is_Non_self_Number(Number):
    is_Non_self_Number = False
    for x in range(1,Number):
        if (d(x) == Number):
            is_Non_self_Number = True
            break
    return is_Non_self_Number

result = 0
for a in range(1, 5000):
    if (is_Non_self_Number(a) == False):
        result += a
result

파이썬 3.4.4 예전에 파이썬 하다가 입대하느라 못했는데 다시 입대후에 연습하고있습니다. 파이썬의 특징 간결함을 더욱 살리기위해 더 노력해볼생각입니다. 18/02/22

def find_func(x):
    tmp = 0
    for y in range(0,len(x)):
        tmp += int(x[y])
    tmp += int(x)

    return tmp

dic_x = dict()
dic_x = {x:find_func(str(x)) for x in range(1,5000) }

result = 0
for a in range(1,5001):
    if a in dic_x.values():
        pass
    else:
        result += a

print(result)

print(sum(set(range(1, 5000)) - set([sum(map(int, str(x))) + x for x in range(1, 5000)])))

Python 3.5.2에서 작성하였습니다.

sum(set(range(1,5000)) - {x+sum([int(a) for a in str(x)]) for x in range(1,5000)})

MATLAB으로 작성하였습니다.

A = 1 : 5000;
B = zeros(1, 5000);

for x = 1 : 5000
    sum1 = 0;
    t = num2str(x);
    for n = 1 : length(t)
        sum1 = sum1 + str2double(t(n));
    end
    B(x) = sum1 + x;
end

sum(setdiff(A, B))

ans = 1227365

def generated(num):

strNum = str(num)    
strlen = len(strNum)

ret = 0
if strlen <= 1:
    ret = num+num
else:     
    ret = num;
    for x in range(0, strlen):      
        ret = ret + int(strNum[x])

return ret

if name == "main":

selfList = []
for ii in range(1, 5000):
    generatedNum = generated(ii)
    selfList.append(generatedNum)

selfList.sort()

tt = 0
for ii in range(1, 5000):
    if not ii in selfList :     
        tt = tt + ii

print("self number total : %s" % tt)

public class Ex_1 {
    public static void main(String[] args) {
        SelfNumber s = new SelfNumber(5000);    // 1 ~ 지정한 숫자 보다 작은 셀프 넘버의 합계 구하기
        System.out.println(s.SelfNumber());
    }
}

class SelfNumber {
    static int n;

    // 1. 생성자를 통해 시작값과 끝값 초기화
    public SelfNumber(int n){
        this.n = n;
    }

    int SelfNumber() {
        int[] gener = new int[n-1];     //gener를 담기위한 배열
        int[] self = new int[n-1];      //셀프넘버를 담기위한 배열
        int sum = 0;                    // 셀프넘버의 합을 더할 변수

        //1부터 끝값까지 모든 수의 gener를 구해 저장
        for (int i = 1; i < n; i++) {
            gener[i-1] = play(i);
        }

        //gener에 담긴 값 중 n보다 작은 애들만 self배열에 1의 값을 넣는다. gener로 나온 숫자와 안나온 숫자를 구분하기 위함
        for (int i = 0; i < self.length; i++) {
            int num = gener[i];
            if (num<n) {
                self[num-1] = 1;
            }else{
                continue;
            }
        }
        //self배열에 값이 0이면 나오지 않은 숫자이므로 sum배열에 더한다.
        for (int i = 0; i < self.length; i++) {
            if (self[i]==1) {
                continue;
            }else if(self[i]==0){
                sum+=(i+1);

            }
        }

        return sum;
    }

    //generator를 구하는 방법 : 각 자리의 수 + 자기자신 구하기
    int play(int n) {
        int sum = n + (n % 10);
        while (n >= 10) {
            n = n / 10;
            sum += n % 10;
        }
        return sum;

    }

}

selfnum = []
s2 = set()

for i in range(1,1000):
    s2.add(i)
    #print(s2)

for i in range(0,10000):
    chk = str(i)
    chk_sum = 0
    for j in range(0,len(chk)):
        chk_sum = chk_sum + int(chk[j])     
    chk_sum = chk_sum + i
    selfnum.append(chk_sum)

s1 = set(selfnum)
print(s2 -s1)

풀이방법 - 제네레이터로 생성되는 숫자를 모두 구함 - 1~1000까지의 집합에서 생성된 숫잡 차집합

결과값 - {512, 1, 514, 3, 5, 7, 9, 525, 20, 536, 31, 547, 42, 558, 53, 569, 64, 580, 75, 591, 86, 602, 97, 613, 615, 108, 110, 626, 121, 637, 132, 648, 143, 659, 154, 670, 165, 681, 176, 692, 187, 703, 198, 714, 716, 209, 211, 727, 222, 738, 233, 749, 244, 760, 255, 771, 266, 782, 277, 793, 288, 804, 299, 815, 817, 310, 312, 828, 323, 839, 334, 850, 345, 861, 356, 872, 367, 883, 378, 894, 389, 905, 400, 916, 918, 411, 413, 929, 424, 940, 435, 951, 446, 962, 457, 973, 468, 984, 479, 995, 490, 501}

A = range(1,5000)
B = []
for i in A:
    dn = 0
    for j in list(str(i)):
        dn += j
    dn += i
    B.append(dn)

C = []
for i in A:
    if i not in B:
        C.append(i)

S = 0
for i in C:
    S += i

print(S)
>>>1227365

C로 풀었습니다. 어떻게 하면 더 효율적으로 self number인지를 테스트 할 수 있는지가 관건인 것 같은데 이렇게 무식하게 밖에 생각을 못해서, 조금 더 고민을 해봐야 할 것 같습니다.

#include <stdio.h>


// self number test
int isSelf(int target);
// 문제에서 제시된 d(n)
int d(int n);
// 자리수 합 구하는 함수
int permute(int n);


int main(void)
{
    int sum = 0;
    for(int i = 1; i < 5000; i++)
    {
        sum += isSelf(i) * i;
    }
    printf("Result = %d\n", sum);
    return 0;

}

int isSelf(int target)
{
    for(int i = 1; i < target; i++)
    {
        // if generator exist
        if(d(i) == target)
        {
            return 0;
        }
    }
    return 1;
}

inline int d(int n)
{
    return n + permute(n);
}

int permute(int n)
{
    if(n < 10)
        return n;
    else 
    {
        return n % 10 + permute(n / 10);
    }
}

#include<iostream>
using namespace std;

void main() {
    int count = 1, X, Y, sum = 0;
    int self_number[5000] = { 0, };
    int result = 0;
    while (count < 5000) {
        X = count;
        sum = X;
        count++;
        while (X != 0) {
            Y = X % 10;
            X = X / 10;
            sum += Y;
        }
        if (sum < 5000)
            self_number[sum - 1] ++;
    }

    for (int i = 0; i < 5000; i++) {
        if (self_number[i] == 0) {
            cout << i + 1 << "  ";
            result += i + 1;
        }
    }
    cout <<endl << result;
}

아...5000보다면 5000이 안들어가는건가요...?? 1232365 이 나와버리네요....크 ㅋㅋ어떻게 빼야되지...

아름다운 코드군요 , 윗분의 답을 많이 참조했습니다 . 참고로 이건 답이 아닙니다 연습용으로 올림!

if __name__ == '__main__':
    print sum(set(range(1,5000)) -  set( x + sum([int(y) for y in str(x)]) for x in range(1,5000) ))
    #{x + sum([int(a) for a in str(x)]) for x in range(1, 5000)}

numbers = range(1, 5000)

k = 0

for i in range(1, 5000):

    for j in str(i):

        k = k + int(j)

    k = k + i

    try:
        numbers[k-1] = 0
    except:
        pass

    k = 0

for i in numbers:
    k = k + i

print k

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

package codingdojang;

import java.util.HashSet;

public class Number1 {

    public static void main(String[] args) {

        HashSet<Integer> numbers = new HashSet<Integer>();

        for ( int i = 1 ; i < 5000 ; i++ )
            numbers.add(i);

        for ( int i = 1 ; i < 5000 ; i++ )
            numbers.remove(generate(String.valueOf(i)));

        int sum = 0;

        for ( int i : numbers )
            sum += i;

        System.out.println(sum);

    }

    private static int generate(String number) {

        int k = 0;

        for ( int i = 0 ; i < number.length() ; i++ ) {

            k += Character.getNumericValue(number.charAt(i));

        }

        k += Integer.parseInt(number);

        return k;

    }

}

자바로 작성했습니다.

$max = 4999;
$array = range(0,$max);

for($num=1;$num<=$max;$num++){
    $array_num = str_split($num);
    $sum = 0;
    foreach($array_num as $val){
        $sum += $val;
    }
    $sum += $num;
    unset($array[$sum]);
}
unset($array[0]);
foreach($array as $num) $total_sum += $num;
echo sprintf("total count:%s",count($array));
echo "\n";
echo sprintf("total sum:%s",$total_sum);

#include <stdio.h>

int Number (int n, int *cnt);
int Generator (int n);

int main(void)
{
    int n=0,i,dn=0;
    int arr[5001] = {0};
    int sum=0;

    for(n=0 ; dn<=5000 ; n++) {
    dn = Generator(n);
    arr[dn] = 1;    

    }

    for(n=0;n<=5000;n++)
    {
        if(arr[n] == 0)
            sum+=n; 
    }
    printf("셀프넘버들의 합은 %d",sum);      //정답 : 1227365 출력
    return 0;
}

int Generator (int n)
{
    int dn = 0,num;
    int i,cnt=0;
    int ten=1;
    num = Number(n,&cnt);

    while(num>=0)   {
        for(i=1;i<num;i++)
            ten*=10;
        dn += (n/ten) % 10;
        num--;
        ten=1;
        if(num ==0) {
            dn += n;
            break;
        }
    }
    return dn;
}

int Number (int n, int *cnt)
{
    int number;
    number = n/10;
    if(number == 0){
        *cnt+=1;
        return *cnt;
    }
    else{
        *cnt+=1;
        Number(number,cnt);
    }
}   

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

import java.util.ArrayList;
import java.util.Arrays;

public class SelfNumber {
    static int sum;
    public static void main(String[] args) {

        ArrayList<Integer> list = new ArrayList<Integer>();

        int finishNum = 5000;
        for(int i = 1; i < finishNum; i++){
            list.add(i);
        }
        for(int i = 1; i < finishNum; i++){
            list.remove((generateNum(i)<finishNum)?generateNum(i):false);
        }

        list.stream().forEach((i) -> {
            sum += i;
        });

        System.out.println(sum);
    }

    private static int generateNum(int i) {
        int gab = 0;
        if(i < 10){
            gab +=  (i-(i/10)*10)/1;
        } else if(i < 100){
            gab +=  (i-(i/100)*100)/10 + (i-(i/10)*10)/1;
        } else if (i < 1000){
            gab +=  (i-(i/1000)*1000)/100 + (i-(i/100)*100)/10 + (i-(i/10)*10)/1;
        } else if (i < 10000){
            gab +=  (i-(i/10000)*10000)/1000 + (i-(i/1000)*1000)/100 + (i-(i/100)*100)/10 + (i-(i/10)*10)/1;
        }
        return gab+i;
    }
}

다른 분 코드 참고했어요

package codingdojang;
//num1
public class nexon {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        boolean[] num=new boolean[5001];
        int a,b,c,d,result, sum=0;
        for(int i=1;i<=5000;i++){
            a=i/1000;
            b=(i%1000)/100;
            c=(i%100)/10;
            d=(i%10);

            result=a+b+c+d+i;

            if(result>0&&result<=5000){
                num[result]=true;
            }

        }
        for(int i=1;i<=5000;i++){
            if(num[i]==false)
                sum+=i;
        }
        System.out.println(sum);
    }

}

            const int MAX = 5000;

            var resultList = new bool[MAX]; 

            for (int i = 1; i < MAX; i++)
            {
                int temp = i;
                int sum = 0;

                while (temp != 0)
                {
                    sum += temp % 10;
                    temp /= 10;
                }

                sum += i;

                if (sum < MAX)
                    resultList[sum] = true;
            }

            int result = 0;

            for(int i = 1; i < MAX; i++)
            {
                result += resultList[i] ? 0 : i;
            }

            Console.WriteLine($"result : {result}");

clear;clc;
A=0;
for a=0:5
    for b=0:9
        for c=0:9
            for d=0:9  
            B=1001*a+101*b+11*c+2*d;
            if B > 5000
                B=0;
            end
            A=A+B;
            end
        end
    end
end
S=sum(0:5000); % 0부터 5000까지의 모든 합
D=S-A % 0부터 5000까지의 모든 합에서 모든 generator 수 들의 합 뺀거_즉  self_number 들의 합

ans=47830

뭐가 틀린거죠? MatLab 초보자인데 코딩이 참 어렵네요ㅡㅡ MatLab 고수님께 부탁합니다ㅠㅠ 제 코딩에서 도데체 뭐가 잘 못 된거죠??

public class newCompany {

    static int[] num ;
    static final int SIZE = 5000;
    public static void main(String argv[]) throws Exception {

        setNum(SIZE);

        System.out.println(setCal());


      }

    private static void setNum(int val){
        num= new int[val];
        for(int i = 0; i<SIZE; i++){

            num[i] = i;

        }

    }



    private static int setCal(){
        int temp = 0;
        int sum = 0;
        for(int i = 0; i<SIZE; i++){

            temp = i + divide(i);

            if(temp<SIZE)
            num[temp]= 0;

        }


        for(int i=0; i<SIZE; i++){

            sum+=num[i];

        }
        return sum;


    }

    private static int divide(int val){


        return val/1000+ (val%1000)/100 + (val%100)/10 + val%10;


    }


}

#include<iostream>
using namespace std;

bool contain_num(int input)
{
    int count;
    int *generator = new int[input];
    for (int i = 1; i < input; i++)
    {
        if (i < 10)
        {
            generator[i - 1] = i + i;
        }
        else if (i < 100)
        {
            generator[i - 1] = (i / 10) + (i % 10) + i;
        }
        else if (i < 1000)
        {
            generator[i - 1] = (i / 100) + ((i / 10) % 10) + (i % 10) + i;
        }
        else if (i < 10000)
        {
            generator[i - 1] = (i / 1000) + ((i / 100) % 10) + ((i / 10) % 10)+ (i % 10) + i;
        }
    }
    for (count = 0; count < input; count++)
    {
        if (input == generator[count])
        {
            return false;
        }
    }
    if (count == input)
        return true;
}
int main()
{
    int sum = 0;
    for (int i = 1; i < 5000; i++) {
        if (contain_num(i) == true)
        {
            sum += i;
        }
    }
    cout << "합계 : " << sum << endl;
    return 0;
}

무식하게 풀어보았습니다.

def func(n):
    return [int(each_number) for each_number in str(n)]

def d(n):
    return sum(func(n)) + n

self_number = list()

for i in range(1, 5000):
    flag = True
    for j in range(1, 5000):
        if i == d(j):
            flag = False
            break
    if flag:
        self_number.append(i)

print(sum(self_number)) # 결과값 : 1227365

한 십몇초 걸리는군요. ㅠㅠ

아 java로 짰습니다. 왠지 부끄럽네요. ㅠㅠ

import java.util.ArrayList;

public class Generator {
    private ArrayList<Integer> ar= null;

    public Generator(){
        ar = new ArrayList<Integer>();
    }

    public static void main(String[] args) {
        Generator gen = new Generator();
        ArrayList<Integer> tempAr = gen.setArray();

        int sum = 0;

        for(int inx = 1; inx < 5000; inx++){
            if(tempAr.contains(inx) == false){
                sum = sum+inx;
            }
        }

        System.out.println("sum ==> " + sum);

    }

    public ArrayList<Integer> setArray(){
        for(int inx = 1; inx < 5000; inx++){
            ar.add(d(inx));
        }

        return ar;
    }   


    public int d(int number){
        int result = 0;

        String tempStr = "" + number;

        for(int jnx = 0; jnx < tempStr.length(); jnx++){
            result = result + Integer.parseInt(tempStr.substring(jnx, jnx+1));
        }

        result = result + number;
        return result;
    }
}

c++입니다. 파이썬 코드를 보니 주눅드는군요.. ㅋㅋ

#define N 5000

void main(){
    bool* selfNums = new bool[N];
    memset(selfNums, false, N);

    int res = 0, sum = 0, val = 0;
    for(int i=1; sum<N; i++)
    {
        sum = val = i;
        while(val>=10)
        {
            sum += val%10;
            val /= 10;
        }
        sum += val;

        if(sum < N)
        {
            selfNums[sum] = true;
        }
    }

    for(int i=0; i<N; i++)
    {
        if(selfNums[i] == false)
        {
            res += i;
        }
    }

    delete[] selfNums;
    cout << res << endl;
}

#include <stdio.h>
/*
어떤 자연수 n이 있을 때, d(n)을 n의 각 자릿수 숫자들과 n 자신을 더한 숫자라고 정의하자.

예를 들어

d(91) = 9 + 1 + 91 = 101
이 때, n을 d(n)의 제네레이터(generator)라고 한다. 위의 예에서 91은 101의 제네레이터이다.

어떤 숫자들은 하나 이상의 제네레이터를 가지고 있는데, 101의 제네레이터는 91 뿐 아니라 100도 있다. 
그런데 반대로, 제네레이터가 없는 숫자들도 있으며, 이런 숫자를 인도의 수학자 Kaprekar가 셀프 넘버(self-number)라 이름 붙였다. 
예를 들어 1,3,5,7,9,20,31 은 셀프 넘버 들이다.

1 이상이고 5000 보다 작은 모든 셀프 넘버들의 합을 구하라.
*/

/*
1.  1~5000 까지의 숫자의 모든 d(n) 을 정렬한 뒤 1~5000까지의 자연수중 없는 숫자를 Sum 한다.
2.  1~5000 까지의 숫자중 generator가 있는지 검사 후 없는 숫자를 Sum 한다.
*/
int main()
{
    // 방법 1
    {
        int sum = 0;
        const int MAX_Digit = 4;
        int _num;
        int div_num;
        int Gen_n = 0;

        int arr[10000];
        for (int num = 1; num < 5001; num++)
        {
            _num = num;
            div_num = 1;
            Gen_n = num;
            for (int i = 0; i < MAX_Digit; i++)
            {
                _num /= div_num;
                Gen_n += _num % 10;
                if (_num / 10 == 0)
                    break;
                div_num *= 10;
            }
            arr[Gen_n] = 1;

            if (arr[num] != 1)
            {
                sum += num;
                printf("num = %d\n", num);
            }
        }
        printf("sum = %d\n", sum);
    }

    return 0;
}

def func_dn(n):
    return n + sum([int(ni) for ni in str(n)])

self_numbers = set(range(1,5000)) - set([func_dn(n) for n in range(1,5000)])

print('sum of self numbers:', sum(self_numbers))

def d(n):
    n=str(n)
    result=0
    for i in n:
        result+=int(i)
    return result+int(n)

dlist = [d(i) for i in range(1,5001)]

result=0
for i in range(1,5001):
    if i not in dlist:
        result+=i
print(result)

Python으로 작성해봤는데, 처음이라 허접합니다. 많이 보고 배워야 겠어요.

j = [0] * 5001
i = 1
while i < 5000:
    t = 0
    for a in (str(i)):
        t += int(a)
    s = t + i
    if s < 5000:
        j[s] = s
    i += 1

i = 1
t = 0
while i < 5000:
    if j[i] == int(0):
        t += i
    i += 1

print(str(t))

**import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet**;

public class Generator {

    public static void main(String[] args) {
        int gen = 0;
        int gen2 = 0;
        int sum = 0;
        **ArrayList<Integer>** arr = new ArrayList<Integer>();
        HashSet<Integer> hs = new HashSet();

        arr.add(0);

        **for**(int i = 1; i < 5000; i++, gen = 0){
            gen += i;
            **for**(int j = i; j != 0; j /= 10){
                gen += (j % 10);
            }   
            arr.add(gen);
        }

        hs.addAll(arr);
        arr.clear();
        arr.addAll(hs);
        Collections.sort(arr);

        **for**(int i = 0; i <arr.size() - 1 && gen < 5000; i++){
            gen = arr.get(i + 1);
            gen2 = arr.get(i);
            **for**(; (gen-1) > gen2; gen--)
                **sum += gen;**
        }
        System.out.println(sum);

    }


}

/*

dev : peanutBro

date : 170218

content : 

어떤 자연수 n이 있을 때, d(n)을 n의 각 자릿수 숫자들과 n 자신을 더한 숫자라고 정의하자.

예를 들어

d(91) = 9 + 1 + 91 = 101
이 때, n을 d(n)의 제네레이터(generator)라고 한다. 위의 예에서 91은 101의 제네레이터이다.

어떤 숫자들은 하나 이상의 제네레이터를 가지고 있는데, 101의 제네레이터는 91 뿐 아니라 100도 있다. 그런데 반대로, 제네레이터가 없는 숫자들도 있으며, 이런 숫자를 인도의 수학자 Kaprekar가 셀프 넘버(self-number)라 이름 붙였다. 예를 들어 1,3,5,7,9,20,31 은 셀프 넘버 들이다.

1 이상이고 5000 보다 작은 모든 셀프 넘버들의 합을 구하라.

*/

#ifdef _MSC_VER
#define _CRT_SECURE_NO_WARNINGS
#endif

#include <iostream>
#include <string>
#include <stack>

using namespace std;

const int MAX_NUM = 5000;

int main(void)
{
    int resultNumber = 0;
    bool generatorCheck[MAX_NUM];

    for (int i = 0; i < MAX_NUM; i++)
    {
        generatorCheck[i] = false;
    }

    for (int i = 1; i <= MAX_NUM; i++)
    {
        int addNumber = i;
        char* buf = new char[4];
        _itoa(i, buf, 10);
        string numString(buf);
        for (int j = 0; j < numString.length(); j++)
        {
            addNumber += (numString[j] - '0');
        }
        if (addNumber >= 1 && addNumber <= MAX_NUM)
        {
            generatorCheck[addNumber - 1] = true;
        }
    }

    for (int i = 0; i < MAX_NUM; i++)
    {
        if (!(generatorCheck[i]))
        {
            resultNumber += i + 1;
            //cout << i + 1 << " ";
        }
    }
    cout << resultNumber << endl;

    return 0;
}

정답 : 1227365

파이썬을 이제 막 배우기 시작해서 익히는 중입니다.

nums = list(range(1,5000))
for i in range(1, 5000):
    numstr = str(i)
    summ = i
    for j in range(len(numstr)):
        summ += int(numstr[j])
    if summ < 4999:
        nums[summ-1] = 0

selfnum = 0
for k in range(4999):
    selfnum += nums[k]

print("Answer: " + str(selfnum))

python 3.5.2

answer is .1227365

def main() :
    L = list(range(1,5000))
    for i in range(1,5000) :
        if L.count(g(i)) > 0 :
            L.remove(g(i))

    print(sum(L))


def g(n) :
    rt = 0
    for x in str(n) :
        rt += int(x)
    rt = rt + n
    return rt


if __name__ == '__main__' :
    L=[]
    main()

result = []
result = set(range(1,5000)) - set(i + sum(int(stri) for stri in str(i)) for i in range(1,5000))
print(sum(result))

당연하게 짜봤습니다 ㅎㅎ

#include <iostream>
using namespace std;

int d(int);

int main() {
    int sum = 0;
    int arr[5000] = { 0 };

    for (int i = 1; i < 5000; i++) {
        arr[i - 1] = d(i);
    }

    // search self-number
    for (int i = 1; i < 5000; i++) {

        // in array
        for (int j = 0; j < 5000; j++) {
            if (arr[j] == i) {
                break;
            }

            if (j == 4999) {
                sum += i;
            }
        }
    }

    cout << sum << endl;

    return 0;
}

int d(int generator) {
    int temp = generator;
    int result = 0;

    while (temp > 0) {
        result += (temp % 10);

        temp = (temp / 10);
    }

    return result + generator;
}

def createdn(n):
  tem = []
  for i in range(1,n+1):
    a = format(i,'04')
    sum = int(a[0]) + int(a[1])+ int(a[2])+int(a[3]) + int(a)
    tem.append(sum)
  return list(set(tem))

dn = [x for x in createdn(5000) if x<5000]
full = list(range(1,5000))
result = [x for x in full if x not in dn]

resultsum = 0
for i in result:
  resultsum += i

print(resultsum)

// Swift 3.0
var sum = 0;
func main() {
    var selfNumbers = [Int](repeatElement(0, count: 5000))
    for i in 0..<5000{
        let noneSelfNumer = generator(value: i + 1) - 1

        if noneSelfNumer < 5000{
            selfNumbers[noneSelfNumer] = 1
        }

        if selfNumbers[i] == 0{
            sum += i + 1
        }
    }
}

func generator(value: Int) -> Int{
    var stremNum = value;
    var sum = value;
    while stremNum != 0 {
        sum += stremNum % 10
        stremNum /= 10
    }
    return sum
}

main()
print(sum)

결과적으로 selfNumbers[i] 가 0이면 i+1 은 self-number 입니다.

static boolean[] generated= new boolean[5000];
    static int numTemp = 0;
    static int sum=0;
    static int result=0;

    public static void main(String[] args){
        for(int i=1; i<5000; i++){
            generate(i);
        }
        for(int i=1; i<5000; i++){
            if(!generated[i]){
                result +=i;
            }
        }
        System.out.println(result);

    }

    public static void generate(int num){
        numTemp = num;
        sum = 0;
        while(num>0){
            sum += num % 10;
            num/=10;
        }
        sum +=numTemp;
        generateCheck(sum);
    }

    public static void generateCheck(int sum) {
        if(sum >= 1 && sum < 5000){
            generated[sum] = true;
        }

    }

def cal(gen):
    result = gen
    for i in str(gen):
        result += int(i)
    return result

gen_list = []
for i in range(1, 5000):
    gen_list.append(cal(i))
print(sum(set(range(1, 5000)) - set(gen_list)))

nums_list = range(1, 5000)
by_generator_list = []

for i in nums_list:
    nums = 0
    for ii in str(i):
        nums += int(ii)
    nums += i
    by_generator_list.append(nums)

for i in by_generator_list:
    if i in nums_list: nums_list.remove(i)

print sum(nums_list)

def d(number):
    total = number
    number = str(number)
    for i in number:
        total += int(i)
    return total

self_number_total = 0
self_number_set = set()

for i in range(1,5000):
    self_number_set.add(d(i))

for i in range(1,5000):
    if not i in self_number_set:
        self_number_total += i

print(self_number_total)

/****************************************************************************************
어떤 자연수 n이 있을 때, d(n)을 n의 각 자릿수 숫자들과 n 자신을 더한 숫자라고 정의하자.

예를 들어

d(91) = 9 + 1 + 91 = 101
이 때, n을 d(n)의 제네레이터(generator)라고 한다. 위의 예에서 91은 101의 제네레이터이다.

어떤 숫자들은 하나 이상의 제네레이터를 가지고 있는데, 101의 제네레이터는 91 뿐 아니라 100도 있다. 그런데 반대로, 제네레이터가 없는 숫자들도 있으며,
이런 숫자를 인도의 수학자 Kaprekar가 셀프 넘버(self-number)라 이름 붙였다. 예를 들어 1,3,5,7,9,20,31 은 셀프 넘버 들이다.

1 이상이고 5000 보다 작은 모든 셀프 넘버들의 합을 구하라.
****************************************************************************************/

#include<stdio.h>

#define SIZE        5000
#define FALSE       0x00
#define TRUE        0x01

int Power(int base, int index);
int Generator(int input);
void Init_BYTE_arr(char* arr,int size);

int main(void)
{
    char data[SIZE];
    int i,sum_of_self_num=0,temp;

    Init_BYTE_arr(data,SIZE);

    for(i=1;i<=SIZE;i++)
    {
        temp=Generator(i);
        if(temp <= SIZE)
            data[temp]=TRUE;
    }

    for(i=1;i<=SIZE;i++)
    {
        if(data[i]==FALSE)
            sum_of_self_num+=i;
    }

    printf("%d",sum_of_self_num);

    return 0;
}

int Power(int base, int index)
{
    int result=1, i;
    for(i=0;i<index;i++)
    {
        result *= base;
    }
    return result;
}

int Generator(int input)
{
    int result=0,temp=0;
    int i;

    result+=input;

    for(i=3;i>=0;i--)
    {
        temp         = input/Power(10,i);
        input   -= temp*Power(10,i);
        result  += temp;
    }

    return result;
}

void Init_BYTE_arr(char* arr,int size)
{
    int i;

    for(i=0;i<size;i++)
        arr[i]=FALSE;
}

using System;
using System.Collections.Generic;

class Program
{
    static void Main(string[] args)
    {
        try
        {
            List<int> intGeneratorList = new List<int>();
            int intSelfNumSum          = 0;

            for (int i = 1; i < 5000; i++)
            {
                if(intGeneratorList.Contains(i) == false)
                {
                    intSelfNumSum += i;
                }
                intGeneratorList.Add(GetGenerator(i));
            }

            Console.WriteLine("정답: " + intSelfNumSum);

        }
        catch(Exception ex)
        {
            Console.WriteLine(ex.Message);
        }
        finally
        {
            Console.ReadKey();
        }
    }

    static int GetGenerator(int intNum)
    {
        int intSum       = 0;
        char[] chArray   = null;

        chArray = intNum.ToString().ToCharArray();

        for (int i = 0; i < chArray.Length; i++)
        {
            intSum += Int32.Parse(chArray[i].ToString());
        }

        return intSum + intNum;
    }
}

MATLAB 입니다. 답은 1227365 로 나오네요. 0.8 sec 정도 걸렸습니다.

clear all
close all
clc
tic

result=(1:5000); % potential candidates of self-numbers

for p=1:length(result) % p is a generator of a value candidate

    % itself + ...
    check_sum=p; 

    % + sum of each digit number
    string_p=num2str(p); 
    for q=1:length(string_p)
        check_sum=check_sum+str2num(string_p(q));
    end

    % excluding non self-numbers
    if check_sum <= max(result)
        result(check_sum)=0; 
    end
end

sum(result)

toc

public class GetMethod {
    int result =0;
    public int judgeGenerator(int num){
        for(int i = 0; i<num; i++){
            if ( num == i/1000+(i/100)%10+ (i/10)%10 + i%10+i){
                return 0;
            }
        }
        return num;
    }

    public static void main(String[] args){
        GetMethod obj = new GetMethod();
        for( int i = 1; i<5000; i++){
            obj.result += obj.judgeGenerator(i);
        }
        System.out.println(obj.result);
    }
}
많은분들이 올려주셨는데 저도 방금풀어본 코드로 올려봅니다.

파이썬 3.5.3 연습용 코드입니다.

a = [x for x in range(1,5000)]


for x in range(1,5000):

    result = 0
    for y in str(x):
        result = result + int(y)

    result = result + x

    try:
        a.remove(result)

    except:
        pass

print(a)

#include <iostream>

static const int N = 5000;

int d(int);

void main() 
{
    int count = 0;              //for문의 실행횟수 카운터
    int temp = 0;               //d() 함수의 결과물 임시보관
    bool selfNumChecker[N + 1]; //셀프 넘버인지 아닌지 확인용
    int result = 0;             //최종결과물

    for(count = 0; count < N; count++) selfNumChecker[count] = true;

    for(count = 0, result = 0; count < N; count++)
    {
        result += count;
        temp = d(count);
        if((temp <= 5000) && (selfNumChecker[temp] == true))
        {
            result -= temp;
            selfNumChecker[temp] = false;
        }
    }

    std::cout << result << std::endl;

    return ;
}

int d(int n)
{
    int result = n;

    while(n != 0)
    {
        result += n % 10;
        n /= 10;
    }

    return result;
}

재밌네요

def d(n): return n + sum([int(i) for i in str(n)])

answer = sum(n for n in range(5000))

chk = []

for i in range(5000):
    g = d(i)
    if(g<5000 and not g in chk):
        answer -= g
        chk.append(g)

print(answer)

올해 복학하고 처음 짜봅니다... 군대 갔다오니 머리에 기름칠이 필요한 것 갔습니다. ㅠㅠ

   class Program
    {
        static void Main(string[] args)
        {
            int sum = 0;
            List<int> generatorList = new List<int>();
            for(int i=1; i<5000; i++)
            {
                int generatorResult = Generator(i);
                if (generatorResult < 5000)
                {
                    generatorList.Add(generatorResult);
                }
            }

            sum = Enumerable.Range(1, 5000).Where(x => !generatorList.Contains(x) && x <5000).Sum();
            Console.WriteLine(sum);
            Console.ReadLine();
        }

        private static int Generator(int inputNum)
        {
            string str = inputNum.ToString();
            int result = 0;

            for(int i=0; i<str.Length; i++)
            {
                result += Convert.ToInt32(str[i].ToString());
            }

            result += inputNum;

            return result;
        }
    }

간단하게 풀어보았습니다 python 3.6.0

def ComputeNumber( n ) :
    res = n
    for i in str( n ):
        res += int( i )
    return res


tempList = [ComputeNumber(i) for i in range(1, 5000)]
result = sum( [ i for i in range(1, 5000) if i not in tempList] )

print( result )

C언어로 풀어 봤는데 1227365 맞나요?

#include<stdio.h>

int generator(int n){

int sum = 0;
int result = n;

while(result>0)
{    
    sum += result%10;
    result = result/10;
}
return sum + n;
}

int main(){

int sum = 0;
int i = 0, j = 0;
int genList[5000] = {0,};

for(i=0;i<5000;i++){
    genList[i] = generator(i+1);
    sum += (i+1);
}

for(i=0;i<5000;i++)
{
    for(j=0;j<5000;j++)
    {
        if(genList[j] == i+1){
            sum -= genList[j];
            break;
        }

    }
}
printf("%d", sum);

return 0;
}

어렵네요... Java 입니다

import java.util.Arrays;

public class Test {

      public static void Excute(){

            boolean[] noSelfList = new boolean[5000];           
            // 초기화          
            Arrays.fill(noSelfList, false);

            int g=1;// 제너레이터
            while(g<5001){
                // num(g) = deGenerator(no-self num)
                int num=getDeGenerator(g);
                if(num < 5000){
                    // num은 self num 이 아니다.
                    noSelfList[num] = true;
                }
                g++;
            }

            int count = 0;
            int result = 0;
            System.out.println("## Self Num List ##");

            for(int i=1;i<5000;i++){                
                if(noSelfList[i] == false){
                    System.out.println(i);
                    result=result+i;
                    count++;
                }               
            }                   
            System.out.println("## Self Num Count : "+count);
            System.out.println("## Self Num Sum : "+result);
        }

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

        // DeGenerater = d(generator)
        public static int getDeGenerator(int generator){
            // 자기자신을 더함
            int result=generator;

            // 자릿수
            int g_length  = String.valueOf(generator).length();

            // 각 자릿수 합
            for(int i=0;i<g_length;i++){              
                int p = generator%10;
                result+=p;              
                generator=generator/10;
            }

            // 자기자신을 제너레이터로 가진 넘버(no-self number)를 반환
            return result;
        }


}

C로 작성했습니다. 최대한 간단하게 만들려고 했는데 잘 안되네요. 초보라서 부족한 부분이 많으니 너그럽게 봐주시고 부족한 부분이 있으면 지적바랍니다.

#include <stdio.h>

#define DIVIDE(a, b, c, d, e) b = a/1000, c = a/100-10*b, d = a/10-100*b-10*c, e = a-b*1000-c*100-d*10
#define SUM(a, b, c, d, e) a + b + c + d + e

#define MAX 5000

int main(){

    int sum = 0;
    int num[MAX];
    int a, b, c, d;
    int temp;

    for(int i = 0; i < MAX; i++){

        DIVIDE(i, a, b, c, d); // 자릿 수 분리

        temp = SUM(a, b, c, d, i); // 자릿 수 + 자신

        if(temp <= MAX){
            if(num[temp - 1] != temp)
                num[temp - 1] = temp;
        } // MAX 넘는 수 필터링
    } // 제네레이터 넘버 자기 위치에 저장

    for(int i = 0; i < MAX; i++){
        if(num[i] != i + 1)
            sum += (i + 1);
    } // 제네레이터 숫자 필터링 후 덧셈

    printf("%d", sum);

    return 0;
}

public class Q1 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int i=1, n=1, dn, result=0;
        int[] arr1 = new int[5000];
        int[] arr2 = new int[5000];

        for(n=1; n<5000; n++) {
            arr1[n] = n;
            dn = n + n/1000 + (n%1000)/100 + (n%100)/10 + (n%10)/1;
            arr2[n] = dn;
        }

        for(n=1; n<5000; n++) {
            for(i=1; i<5000; i++) {
                if(arr1[n] == arr2[i]) {
                    arr1[n] = 0;
                }
            }
        }

        for(n=1; n<5000; n++){
            result += arr1[n];
        }
        System.out.println(result);
    }
}

답: 1227365

.....답은 나오는데 코드가 너무 허졉하군요 뭔가 코딩한게 아니라 그냥 수학문제 푼 기분이예요.. 더 공부해서 더 나은 코드를 만들어 볼게요

#include <iostream>                                                             

using namespace std;                                                            

int main(void)                                                                  
{                                                                               
    int i;                                                                      
    int sum = 0;                                                                
    int self_num;                                                               

    const int max_buf = (4999 + 4 + 9 + 9 + 9);                                 
    bool arr[max_buf] = {0, };                                                  

    for (i = 1; i <= 5000; i++)                                                 
    {                                                                           
        self_num =                                                              
            (i + (i / 1000 % 10) + (i / 100 % 10) + (i / 10 % 10) + (i % 10));  

        arr[self_num - 1] = true;                                               

        if (arr[i - 1] == 0)                                                    
            sum += i;                                                           
    }                                                                           

    cout << "sum : " << sum << endl;                                            

    return 0;                                                                   
}         

흠,, 이렇게 하면 되나요??

c언어로 풀었읍니다.

#include < stdio.h>

void main() {

    int i, j, temp, number, sum = 0;

    _Bool ar[5000] = { 0, };

    for (i = 1; i <= 5000; i++) {
        temp = i;
        number = 0;
        while (temp) {
            number += temp % 10;
            temp /= 10;
        }
        number += i;
        if (number <= 5000) {
            ar[number - 1] = 1;
        }
    }
    for (i = 0; i <= 5000; i++)
        if (ar[i] == 0)
            sum += i+1;

    printf("Self-Number Sum : %d\n", sum);
}

def get_generated(number):
    return sum(map(int, str(number))) + number


# Generated number is greater than generator number.
# So use 1 ~ 5000 as generator to get all of
# generated number between 1 and 5000.
generated = set(
    get_generated(number)
    for number in range(1, 5000)
)

sum_of_self_numbers = sum(
    number
    for number in range(1, 5000)
    if number not in generated
)

print(sum_of_self_numbers)

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

void initSelfNumList(std::set<int> &selfNumLst)
{
    for (int num = 1; num < 5000; num++)
    {
        selfNumLst.insert(num);
    }
}

int calSelfNumSum(const std::set<int> &selfNumLst)
{
    int tot = 0;

    std::set<int>::iterator selfNumItor;
    for (selfNumItor = selfNumLst.begin(); selfNumItor != selfNumLst.end(); selfNumItor++)
    {
        tot += (*selfNumItor);
    }

    return tot;
}

void main()
{
    std::set<int> selfNumLst;
    std::set<int>::iterator selfNumItor;
    initSelfNumList(selfNumLst);

    for (int num = 1; num < 5000; num++)
    {
        char strNum[5] = { 0 };
        _itoa_s(num, strNum, 10);

        int sum = 0;
        for (int i = 0; i < 5; i++)
        {
            if (strNum[i] - '0' < 0)
                continue;
            sum += (strNum[i] - '0');
        }
        sum += num;

        selfNumItor = selfNumLst.find(sum);
        if (selfNumItor != selfNumLst.end())
        {
            selfNumLst.erase(selfNumItor);
        }
    }

    int tot = calSelfNumSum(selfNumLst);
}

xx = []
for i in range(1,5001):
    if i >= 1000:
        a1 = i // (10**3)
        b1 = (i - a1 * (10**3)) // (10**2)
        c1 = (i - a1 * (10**3) - b1 * (10**2)) // 10
        d1 = (i - a1 * (10**3) - b1 * (10**2) - c1 * 10)
        x1 = (a1+b1+c1+d1+i)
        xx.append(x1)
    elif i >=100:
        a2 = 0
        b2 = i//(10**2)
        c2 = (i - b2 * (10**2)) // 10
        d2 = (i - b2 * (10**2) - c2 * 10 )
        x2 = (a2+b2+c2+d2+i)
        xx.append(x2)

    else:
        a3 = 0
        b3 = 0
        c3 = i//10
        d3 = (i-c3*10)
        x3= (a3 + b3 + c3 + d3 + i)
        xx.append(x3)

xxx = list(set(xx))
kk = []
for k in range(1,5001):
    if k not in xx:
        kk.append(k)
        ksum =sum(list(kk))

print(ksum)

private static int sumOfSelfNum(int n){
        boolean generators[] = new boolean[n];

        for(int i=1; i<=n; i++){
            int sum = i;
            sum += i % 10;
            sum += (i / 10) % 10;
            sum += (i / 100) % 10;
            sum += (i / 1000);

            if(sum <= n){
                generators[sum-1] = true;
            }
        }

        int sumOfSelfNum = 0;
        for(int j=0; j<generators.length; j++){
            if(generators[j] == false){
                sumOfSelfNum += (j+1);
            }
        }

        return sumOfSelfNum;
    }

package training;

import java.util.ArrayList;

// d(91) = 9 + 1 + 91 = 101
public class NGenerator {

    public static void main(String[] args) {
        int iSum = 0;       
        ArrayList<Integer> arr = new ArrayList();

        for(int i=1;i<5000;i++){
            if(isSelfNum(i)){
                arr.add(i);
                iSum += i;
            }
        }
        System.out.println(arr);
        System.out.println("Sum of all Self number between 1 to 5000 : " + iSum);
    }

    public static boolean isSelfNum(int iNum){
        boolean isSelfNum = true;
        for(int i=1;i<iNum;i++){
            if(iNum == generator(i)){
                isSelfNum = false;
            }
        }
        return isSelfNum;
    }

    public static int generator(int iNum){
        String strNum = String.valueOf(iNum);
        int iSum = 0;
        for(int i=0;i<strNum.length();i++){
            iSum += Integer.parseInt(strNum.substring(i, i+1));
        }
        return iSum+iNum;
    }

}

import java.util.Arrays;
class Practice02 {
    public static void main(String[] args) {

        int[] arr = Math_arr.selfNumArr(5000);

        System.out.println(Arrays.toString(arr));
    }
}

import java.util.Arrays;
class Practice02 {
    public static void main(String[] args) {

        int[] arr = Math_arr.selfNumArr(35);

        System.out.println(Arrays.toString(arr));
    }
}

class Math_arr {
    // 1 ~ v 사이의 self-number들로 구성된 배열을 반환하는 메서드
    static int[] selfNumArr(int v){
        int[] arr = new int[v];

        // 1. arr 배열에 1 ~ v 까지 저장
        for(int i = 0 ; i < v ; i++){
            arr[i] = i+1;
        }

        // 2. arr 배열에서 self-number가 아닌 값들은 전부 0으로 변환
        for(int i = 1 ; i <= v ; i++){
            int temp = i;
            int temp_sum = 0;
            while(temp > 0){
                temp_sum += temp%10;
                temp /= 10;
            }

            temp_sum += i;
            if(temp_sum-1 < v){
                arr[temp_sum-1] = 0;
            }
        }

        // 3. arr 배열에서 self-number의 개수를 구해서 cnt에 저장
        int cnt = 0;
        for(int o : arr){
            if( o != 0 ){ 
                cnt++; 
            }
        }

        // 4. 크기가 cnt만큼인 arr_ret배열을 생성
        int[] arr_ret = new int[cnt];

        // 5. cnt 만큼 반복문 ; arr 배열에서 0이 아닌값을 만날때마다 
        // arr_ret배열에 값을 추가
        int idx = 0;
        for(int i = 0 ; i < cnt ; i++){
            while(true){
                if(arr[idx] != 0){
                    arr_ret[i] = arr[idx];
                    idx++;
                    break;
                }else{
                    idx++;
                }
            }
        }

        return arr_ret;

    }
}

k = 0
T = []
G = set(range(1,5000)) 

for i in range(1,5000):
    for j in str(i):
        k+=int(j)
    T.append(k+i)
    k = 0

print sum(G-set(T))

range(1, 5000).filter(i -> range(1, i).filter(j -> (String.valueOf(j).chars().map(x -> x - '0').sum() + j == i)).sum() == 0).sum();

자바 8

/*************************************************

java version "1.8.0_101" 64bits 

MacOS 10.12.4
Eclipse Neon.3 Release 4.6.3

어떤 자연수 n이 있을 때, d(n)을 n의 각 자릿수 숫자들과 n 자신을 더한 숫자라고 정의하자.
예를 들어
d(91) = 9 + 1 + 91 = 101
이 때, n을 d(n)의 제네레이터(generator)라고 한다. 위의 예에서 91은 101의 제네레이터이다.
어떤 숫자들은 하나 이상의 제네레이터를 가지고 있는데, 101의 제네레이터는 91 뿐 아니라 100도 있다. 
그런데 반대로, 제네레이터가 없는 숫자들도 있으며, 이런 숫자를 인도의 수학자 Kaprekar가 
셀프 넘버(self-number)라 이름 붙였다. 예를 들어 1,3,5,7,9,20,31 은 셀프 넘버 들이다.
1 이상이고 5000 보다 작은 모든 셀프 넘버들의 합을 구하라.

1. 제네레이터가 없는 숫자가 셀프 넘버이기 때문에 전체 숫자에서 제네레이터를 지우는 형태로 찾아야한다.
   이를 위해서는 엘리먼트의 추가/삭제가 용이한 ArrayList를 이용한다.
2. Generator를 구하기 위한 함수를 별도로 만들어서 코드의 시인성을 높인다.

결과 : 1227365

고생했던 부분
1. ArrayList에서 엘리먼트를 삭제할 때 remove() 메쏘드를 사용했는데,
   remove()의 오퍼랜드로 integer를 입력하면 해당 숫자를 찾아 지우는 것이 아니라
   삭제할 엘리먼트의 인덱스 번호로 인식을 한다.
   즉 remove("A")라고 하면 "A"라는 엘리먼트를 삭제하지만
   remove(5)라고 하면 5번째 엘리먼트를 삭제한다.
   이때는 indexOf() 메쏘드를 사용하면 된다.
***************************************************/

import java.util.ArrayList; 
import java.lang.Math;

public class Java_generator {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int N = 5000;
        ArrayList<Integer> sn = new ArrayList<Integer>();

        for (int i = 1; i <= N; i++){
            sn.add(i);
        }

        int gen = 0;
        for (int i = 1; i <= N; i++){
            gen = generator(i);
            if(sn.contains(gen)){
                sn.remove(sn.indexOf(gen));
            }
        }

        int result = 0;
        for (int i = 0; i < sn.size(); i++){
            result = result + sn.get(i);
        }
        System.out.println(result);
    }

    public static int generator(int number){
        int result = number;
        int length = (int)Math.log10(number);
        for(int i = 0; i <= length; i++){
            result = result + (number % 10);
            number = (int)number/10;
        }
        return result;
    }

}

파이썬 막 공부중입니다. 숫자 구간의 list를 미리 만들어 두고, generator를 제외한 후 남은 숫자를 더하는 방법으로 풀었습니다.

min_num, max_num = 1, 5000
chk_num, gen_num, sum_num = 0, 0, 0
self_num_list = []

def Generator(num):
    gen = num
    while num > 0 :
        mod = num % 10
        num = num // 10
        gen += mod
    return gen

print("%d ~ %d 사이의 self-number 합 구하기" % (min_num, max_num))

self_num_list = list(range(min_num, max_num+1))

for chk_num in range(min_num, max_num+1) :

    gen_num = Generator(chk_num)

    if gen_num <= max_num :
        try :
            self_num_list.remove(gen_num)
        except ValueError :
            pass

for i in range(0, len(self_num_list)) :
    sum_num += self_num_list[i]

print("합 : %d" % sum_num)

        private void Generator(int num)
        {
            int sum = 0;
            int res = 0;
            num++;
            bool[] std = new bool[num];
            string str = "";

            for (int i = 1; i < num; i++)
            {
                res = makeGenerator(i);
                if(res < num)
                    std[res] = true;
            }

            for (int i = 1; i < num; i++)
            {
                if (!std[i])
                {
                    str += string.Format(" {0} ", i);
                    sum += i;
                }
            }

            MessageBox.Show(str + "총 합 = " + sum.ToString()); 
        }

        private int makeGenerator(int num)
        {
            int sum = num;
            string str = num.ToString();
            for (int i = 0; i < str.Length; i++)
                sum += Convert.ToInt32(str[i].ToString());

            return sum;
        }

import java.util.ArrayList;
import java.util.HashSet;

public class test {

    public static void main(String[] args) {

        int one;
        int ten;
        int hundred;
        int thousand;
        ArrayList noSelfNumber = new ArrayList();

        for(int i=1 ; i<=5000 ; i++)
        {
            if(i>=1 && i<10)
            {
                one = i;
                noSelfNumber.add(one+i);
            }
            else if(i>=10 && i<100)
            {
                one = i%10;
                ten = i/10;
                noSelfNumber.add(one+ten+i);
            }
            else if(i>=100 && i<1000)
            {
                one = i%10;
                hundred = i/100;    
                ten = i/10 - hundred*10;
                noSelfNumber.add(one+ten+hundred+i);
            }
            else if(i>=1000 && i<=5000)
            {
                one = i%10;
                thousand = i/1000;
                hundred = i/100-thousand*10;
                ten = i/10-thousand*100-hundred*10;
                noSelfNumber.add(one+ten+hundred+thousand+i);
            }   
        }

        HashSet noDupl = new HashSet(noSelfNumber);
        ArrayList noSelfNumber2 = new ArrayList(noDupl);

        int sum = 0;
        int nosum = 0;
        for(int i=0; i<=5000; i++){
            sum+=i;
            if(i<noSelfNumber2.size() && (Integer)noSelfNumber2.get(i)<=5000)
                nosum+=(Integer)noSelfNumber2.get(i);
        }

        System.out.println(sum-nosum);

    }

}

1. 차집합을 이용

selfnumset = set(range(1,5000))

for i in range(1,5000):
    non_selfnum = 0
    sum_hub = 0
    for j in str(i):
        sum_hub += int(j)
    non_selfnum = sum_hub + i
    selfnumset = selfnumset - set([non_selfnum])

result = 0
for i in list(selfnumset):
    result += i
print(result)

int[] Gen = new int[5050];
int sum = 0;

for (int i=1; i<10; i++){
  Gen[i + i] += 1;
}

for (int i=10; i<100; i++){
  Gen[i%10 + i/10 + i] += 1;
}

for (int i=100; i<1000; i++){
  int j = i%100;
  Gen[ i/100 + j/10 + j%10 + i ] += 1;
}

for (int i=1000; i<5000; i++){
  int j = i%1000;
  int k = j%100;
  Gen[ i/1000 + j/100 + k/10 + k%10 + i ] += 1;
}

for (int i=1; i<5000; i++){
  if (Gen[i]==0){sum+=i;}
}

println(sum);

답: 1227365

A=[]
for x in range (1,10000,1) :
    A= A + [ x ]
for x in range ( 1, 5000, 1 ) :
    if ( ( x / 1000) >= 1 ) :
        b = int( x / 1000 )+(int(x/100) %10) +(int(x/10)%10)  + (x%10) + x
        A[ b - 1 ] = 0
    elif ((x/100)>=1):
        b= int(x/100)+(int(x/10)%10)+ x%10 + x
        A[b-1]=0
    elif ((x/10)>=1):
        b=int(x/10)+ x%10 + x
        A[b-1]=0
    else:
        b= x + x
        A[b - 1] = 0
print(sum(A[:5001]))

def selfnum(N):

List1 = [] 
for i in range(1,N+1):
    flag = False
    temp = 0
    for a in range(10):
        if flag == True:
            break
        for b in range(10):
            if flag == True:
                break
            for c in range(10):
                if flag == True:
                    break
                for d in range(10):

                    if a*1000 + b*100 + c*10 + d + a + b + c + d == i:
                        temp = i
                        flag = True
                        break



    if temp == 0:
        List1.append(i)

print("selfnum= %s" % List1)
print("sum of all selfnumbers = %s" %str(sum(List1)))

import sys print (sys.version)

"""3.5.3 |Anaconda custom (x86_64)| (default, Mar 6 2017, 12:15:08) [GCC 4.2.1 Compatible Apple LLVM 6.0 (clang-600.0.57)]"""

num_list=[] for n in range(5000): str_n=str(n) sum_n=0 for i in range(len(str_n)): sum_n+=int(str_n[i]) sum_n+=n num_list.append(sum_n)

self_num=[] for i in range(5001): if i not in list(set(num_list)): self_num.append(i) else: next

sum(self_num)

answer : 1227365

Swift

• xcode
• macOS command line project

// n + n%10 + (n/10^1)%10 + (n/10^2)%10 ... = d(n)
// d(n) > n
// d(5000) = 5005 > 5000 즉, d(n) 아무리 작아도 n + 1임
// 1 <= n < 5000인 각 n에 대해 d(n) 구하면 5000보다 작은 모든 d(n)을 구할 수 있음.
// 요렇게 구한 d(n) 값들을 검색 속도가 빠른 자료구조(여기서는 RB트리)에 담아뒀다가
// 1~4999 중에서 5000 보다 작은 d(n) 값을 제외한 나머지 값들의 합을 구함
//
// RBTree는 굳이 여기에 다 작성할 필욘 없을 것 같고, 대신 다른 자료구조에 담아 처리해도 됨

func d(gen: UInt, order: UInt) -> UInt {
    let q = gen/(UInt(pow(Double(10), Double(order))))
    if q == 0 { return 0 }

    return q%10 + d(gen: gen, order:order+1)
}


func solveP2() {

    let rbTree: RBTree = RBTree()

    for i in 1..<5000 {
        let n = UInt(i)
        rbTree.insert(n + d(gen: n, order:0))
    }

    var counter: Int = 0
    var sum: UInt = 0
    for i in 1..<5000 {
        let n = UInt(i)
        let node = rbTree.find(n)
        if node.value == nil {
            print(n, terminator:", ")
            counter += 1
            sum += n
        }
    }
    print("")
    print("Number of Self Numbers : \(counter)")
    print("Sum of Self Numbers : \(sum)")


}

a=list(range(1,5001))
b=[]
sum=0
#자리수 구하는 함수
def ten(num):
    i=0
    while num//(10**i)!=0:
        i+=1
    return i-1
#제너레이트
def produce(n):
    i=ten(n)
    t=n
    a=0
    while i>=0:
        a+=t//(10**i)
        t-=(t//(10**i))*(10**i)
        i-=1
    a+=n
    return a
#제너레이트한 수를 b에 담는다.
for num in a:
    b.append(produce(num))
#집합을 사용해서 c에 셀프넘버를 담는다.
c=set(a)-set(b)
c=list(c)
#셀프넘버를 모두 더한다.
for num in c:
    sum+=num
print(sum)

def dn(x):
    dn=x
    while 1:
        if x>=1000:
            dn+=(int)(x/1000)
            x=x%1000
        if x>=100:
            dn+=(int)(x/100)
            x=x%100
        if x>=10:
            dn+=(int)(x/10)
            x=x%10
        if x<10:
            dn+=x
            break
    return dn
a=[]
index_number=sum(set(range(1,5000)))#number배열
for i in range(1,5000):
    if(dn(i)<5000):
        a.append(dn(i))
a=sum(set(a))
print(index_number-a)

def getGenerator(n):
    sum = n
    for i in list(str(n)):
        sum += int(i)
    return sum

if __name__ == "__main__":
    gen_map = {}
    for i in range(1, 5000):
        gen_num = getGenerator(i)
        gen_map[gen_num] = i

    result = 0
    for i in range(1, 5000):
        if i not in gen_map:
            result += i
    print( result )

python 3.6 일반공식을 구해보려고 했으나 일단 차집합으로 풀고 나서 생각해보렵니다.

num_set = {n for n in range(1,5001)}
no_self_set = {a+sum([int(i) for i in str(a)]) for a in range(1,5001)}
print(sum(num_set - no_self_set))

#include <stdio.h>
//5000개 배열을 만들어 셀프넘버를 기록, 총 합을 구하는 방식입니다
int main(void) {
    int self[6000];
    int i,a,b,c,d,dn,n,sum=0;
    for(i=0;i<5000;i++){ //5000미만의 자연수 배열
        self[i]=1;
    }
    for(d=0;d<5;d++){   //1000의 자리 0~4
        for(c=0;c<10;c++){  //100의자리 0~9
            for(b=0;b<10;b++){ //10의 자리 0~9
                for(a=0;a<10;a++){  //1의자리 0~9
                    n=a+10*b+100*c+1000*d; //n은 dcba인 수
                    dn=a+b+c+d+n;       //d(n)은 d+c+b+a+n
                    self[dn]=0;         //셀프넘버가 아니면 배열이 0
                }
            }
        }
    }
    for(i=0;i<5000;i++){ //셀프넘버 합
        if(self[i]==1&&i<5000)
        sum=sum+i;
    }
    printf("%d",sum); //출력
    return 0;
}

전수조사밖에 떠오르는게 없네요 더 간결하게 적으신 분들 코드 보고 좀 배워야겠어요

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]) {

    int num;
    int i,j;

    for(i = 1; i < 5000; i++)
    {
        for(j = 1; j <= i;j++)
        {
            if( count(j) == i )
            {
                j = 0;
                break;
            }
        }
        if(j != 0)
            printf("%d ", i);
    }

    return 0;
}




int count(int num)
//Find Generator
{
    int arr[4] = {0,0,0,0};
    int sum, i;

    sum = num;

    for(i = 3 ; i >= 0 ; i--)
    {

        arr[i] = num % 10;
        num /= 10;

        if(num < 0)
        {
            break;
        }
    }

    for(i = 0 ; i < 4 ; i++)
    {
        sum+=arr[i];
    }

    return sum;
}

w = 1
v = 0
m = []
l = []

def s(x, n):
    a = x%(10**(n+1)) - x%(10**n)
    return a

def d(n):
    v = n + s(n, 3) + s(n, 2) + s(n, 1) + s(n, 0)
    return v

while w <= 5000:
     m.append(d(w))

while w <= 5000:
    l.append(w)

for k in m:
   for u in l:
        if k == u:
            l.remove(u)

x = sum(l)

print(x)

흠... 항상 다 풀고 컴퓨터 돌리면 실행이 한참 걸리네요. 인터프리터 언어라서 그런가요?

#include <iostream>
using namespace std;

int d(int n) { return n + n / 1000 + (n % 1000) / 100 + ((n % 1000) % 100) / 10 + ((n % 1000) % 100) % 10; }

int main(void) {

    int len = 20;
    int * n = new int[len];

    for (int i = 1; i <= len; i++)
        n[d(i)] = true;

    int sum = 0;
    for (int i = 1; i <= len; i++) {
        if (n[i] != 1)
            sum += i;
    }

    cout << sum << endl;
}

c로 풀이

#include <stdio.h>
int generator(int n);
int same_gen(int n);
int main(void)
{
    int i,sum=0;
    for(i=1;i<=5000;i++) sum=sum+i-(same_gen(i)*generator(i));
    printf("%d",sum);
    return 0;
}
int generator(int n)
{
    int m;
    m=(n+(n/1000)+((n%1000)/100)+((n%100)/10)+(n%10));
    if (m<=5000) return m;
    else return 0;
}
int same_gen(int n)
{
    int i,num=0;
    for(i=n+1;i<=5000;i++) if(generator(i)==generator(n)) num++;
    if (num==0) return 1;
    else return 0;
}

// 넥슨 입사 문제: 셀프 넘버 - C#

using System;
using System.Collections.Generic;

namespace selfnumber
{
    class nana
    {
        static void Main(string[] args)
        {
            List<int> generator = new List<int>();
            List<int> self = new List<int>();

            for (int i = 1; i < 5000; i++)
            {
                if (i < 10)
                    generator.Add(i + i);
                else if (i < 100)
                    generator.Add(i / 10 + i % 10 + i);
                else if (i < 1000)
                    generator.Add(i / 100 + i / 10 % 10 + i % 10 + i);
                else
                    generator.Add(i / 1000 + i / 100 % 10 + i / 10 % 10 + i % 10 + i);
            }
            generator.Sort();
            for (int i = 0; i < 5000; i++)
                if (!(generator.Contains(i)))
                    self.Add(i);

            int sum = 0;
            foreach (int i in self)
                sum += i;
            Console.WriteLine(sum);
            // 답은 1227365
        }
    }
}

파이썬(은 사랑) 입니다

def self_number(): 
    li = []
    for i in range(1,5001):
        li.append(i + sum([int(j) for j in str(i)]))

    return sum(set(range(1,5001)) - set(li))

sum(set(range(1, 5000)) - {x + sum([int(a) for a in str(x)]) for x in range(1, 5000)})

javascript(ES6)

var selfnumbers = Array.from(Array(5000), (_, i) => i + 1);
var add = (a, b) => a + b;
var str2int = s => parseInt(s, 10)
var gen = n => n + ("" + n).split('').map(str2int).reduce(add);

for (let i = 1; i <= 5000; i++) {
    selfnumbers[gen(i) - 1] = 0;
}

var sum = selfnumbers.reduce(add);

console.log(sum);

for 문 없이 아래와 같이 할 수도 있는데, 그러면 selfnumbers 가 chain 되지 않아서 .reduce 를 chain 할 수가 없음

selfnumbers.map((v, i, a) => { a[gen(i + 1) - 1] = 0 })
var sum = selfnumbers.reduce(add);

파이썬 코드에 감명받아서, 차집합으로 다시 풀어봤습니다.

var numbers = Array.from(Array(5000), (value, index) => index + 1);
var add = (a, b) => (+a) + (+b);
var genned = new Set(numbers.map(n => n + `${n}`.split('').reduce(add, 0)));
var selfsum = numbers.filter(x => !genned.has(x)).reduce(add, 0);

console.log(selfsum);

lir = []
ans = 0

for i in range(1,5001):
    lir.append(i)

for i in range(1,5001):
    print(i)
    for j in range(1,5001):
        a = j//1000
        b = (j-a*1000)//100
        c = (j-a*1000-b*100)//10
        d = (j-a*1000-b*100-c*10)
        if a+b+c+d+j == i:
            if lir.count(i) != 0:
                lir.remove(i)

for i in lir:
    ans += i

print(ans)

포문으로 간단하게 해봤습니다..

#include<stdio.h>

int main(void)
{
    int sum_seq = 0;
    int judge = 0;
    int sum = 0;
    int a, b, c, d;
    int i;

    for (i = 0;i < 5000;i++) {
        sum_seq += i;
    }

    for (i = 0;i < 5000;i++) {
        judge = 0;
        for (a = 0; a < 5; a++) {
            for (b = 0; b < 10; b++) {
                for (c = 0;c < 10; c++) {
                    for (d = 0; d < 10; d++) {
                        if (i == 1001 * a + 101 * b + 11 * c + 2 * d) {
                            sum += i;
                            judge += 1;
                            break;
                        }
                    }
                    if(judge!=0)
                    break;
                }
                if (judge != 0)
                break;
            }
            if (judge != 0)
            break;
        }
    }

    printf("sum = %d", sum_seq - sum);

    return 0;
}

array={0}
for i in range(5001):
    array.add(i)


for a in range(10):
    for b in range(10):
        for c in range(10):
            for d in range(10):
                array = array - {1001*a+101*b+11*c+2*d}

_sum = 0
listarray = list(array)

for j in range(len(listarray)):
    _sum = _sum + listarray[j]

/*
프로그램 내용 : 어떤 자연수 n이 있을 때, d(n)을 n의 각 자릿수 숫자들과 n 자신을 더한 숫자라고 정의하자.

예를 들어


d(91) = 9 + 1 + 91 = 101

이 때, n을 d(n)의 제네레이터(generator)라고 한다. 위의 예에서 91은 101의 제네레이터이다.

어떤 숫자들은 하나 이상의 제네레이터를 가지고 있는데, 101의 제네레이터는 91 뿐 아니라 100도 있다.
그런데 반대로, 제네레이터가 없는 숫자들도 있으며, 이런 숫자를 인도의 수학자 Kaprekar가 셀프 넘버(self-number)라 이름 붙였다.
예를 들어 1,3,5,7,9,20,31 은 셀프 넘버 들이다.

1 이상이고 5000 보다 작은 모든 셀프 넘버들의 합을 구하라.

작성한 날짜   : 2017년 6월 20일
*/
#include <stdio.h>

#define len 5000

int d(int num)
{
    int sum = num;  //처음 숫자를 저장

    while (num > 0)
    {
        sum += num % 10;    
        num /= 10;  //num이 0이될때 까지 저장한다
    }

    return sum;
}

int main()
{
    int gen[len] = { 0 };
    int sum = 0;

    for (int i = 1; i < len; i++)
    {
        if (d(i) < len) //5000보다 작으면 실행
        {
            gen[d(i)] = 1;  //1로 체크
        }
    }

    for (int i = 1; i < len; i++)
    {
        if (gen[i] == 0)
        {
            sum += i;   //제네레이터가 없는 셀프넘버 합 계산
        }
    }

    printf("%d\n", sum);

    return 0;
}

go로 풀어봤습니다.

// ysoftman
package main

import (
    "fmt"
)

const mxvalue int = 5000

func main() {
    var result map[int]int
    result = make(map[int]int)
    for i := 1; i < mxvalue; i++ {
        result[i] = 0
    }
    for i := 1; i < mxvalue; i++ {
        temp := i
        sum := 0
        for temp > 0 {
            sum += temp % 10
            temp = temp / 10
        }
        sum += i
        // fmt.Println(i, "->", sum)
        result[sum] = 1
    }
    sum := 0
    for i := 1; i < mxvalue; i++ {
        if result[i] == 0 {
            // fmt.Println(i)
            sum += i
        }
    }
    fmt.Println(sum)
}

파이썬으로 풀어보았습니다. 초보라 많이 미숙합니다.

def check():
    genGroup = set()
    for a in range(1,5000):
        numGroup = []
        numsGroup = []
        total = 0
        for n in range(4):
            numGroup.append(a // 10**n)
        numsGroup = list(map(lambda num: num % 10, numGroup))
        for i in numsGroup:
            total += i
        b = total + a
        genGroup.add(b)
    return genGroup

allGroup = set(range(1,5000))
selfGroup = allGroup - check()
total = 0
for n in selfGroup:
    total += n
print(total)

g = []
not_g = []

def d(x):
    num_str = list(str(x))

    plus = x

    for member in num_str:
        plus = plus + int(member)

    return(plus)


for member in range(5000):
    g.append(d(member))

for member in range(5000):
    if member not in g:
        not_g.append(member)

print(sum(not_g))

[Python 3.6]

def d(generator):
    result = generator
    for num in str(generator):
        result += int(num)
    return result

nonselfnum = set()
for num in range(5000):
    nonselfnum.add(d(num))
selfnum = set(range(5000))-nonselfnum

print(sum(selfnum))

이중 배열을 사용하여 풀었습니다.

public class generate
{
  public static void main(String[] args)
  {
    //이중 배열
    int[][] numbers = new int[5000][2];
    int result = 0;

    for(int i = 0; i < 5000; i++)
    {
      numbers[i][0] = i;//1~4999까지의 값
      numbers[i][1] = 0;//셀프함수 여부
    }

    for(int i = 0; i < 5000; i++)
    {
      int temp = numbers[i][0];
      int calTemp = temp;

      while(temp > 0)//각 자리수로 parsing
      {
        calTemp += temp % 10;
        temp = temp / 10;
      }

      if(calTemp < 5000)//계산된 값이 범위 내에 있을 경우
      {
        numbers[calTemp][1] = -1;//해당 값의 셀프숫자 여부를 -1로 수정함
      }

      if(numbers[i][1] != -1)//현재 계산한 숫자가 셀프 숫자인 경우 result에 합산.
      {
        result += numbers[i][0];
      }
    }


    System.out.println(result);

  }
}

public static void main(String[] args) {

        int sum = findSelfNumber();
        System.out.println("The sum of self numbers: " + sum);
    }

    public static int findSelfNumber() {
        boolean[] numbers = new boolean[5001];

        for (int i=1; i<=5000; i++) {
            int gen = getGenerator(i);
            if (gen >= 1 && gen <= 5000) {
                numbers[gen] = true;
            }
        }

        int sum = 0;
        for (int i=1; i<=5000; i++) {
            if(!numbers[i]) {
                sum += i;
            }
        }
        return sum;
    }

    public static int getGenerator(int n) {
        int generator = n;
        String num = Integer.toString(n);
        for (int i=0; i<num.length(); i++) {
            generator += Integer.valueOf(String.valueOf(num.charAt(i)));
        }

        return generator;
    }

#include <iostream>
#include <cstdio>

using namespace std;

int getValuebyGenerator(int);

int main()
{
    int num[5000];
    int haveGenerator[5000] = {0,};
    int i = 0;
    int result = 0;

    for (i = 1; i <=5000; i++)
        num[i-1] = getValuebyGenerator(i);

    for (i = 0; i < 5000; i++) {
        if (num[i] <= 5000)
            haveGenerator[(num[i] - 1)] = 1;
    }

    for (i = 0; i < 5000; i++) {
        if (haveGenerator[i] == 0) {
            result += (i + 1);
            cout << i+1 << "  ";
        }
    }

    cout << endl << endl << "result : " << result << endl;
    return 0;   
}

int getValuebyGenerator(int x)
{
    return (x + x/1000 + (x%1000)/100 + (x%100)/10 + x%10);
}

public class Ex2 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("셀프넘버 합: " + sumOfSelfnum());

    }   


    private static int sumOfSelfnum() {
        ArrayList<Integer> notSelfnums = calcNotSelfnum();
        int sumOfSelfnum = 0;

        for(int i=1; i< 5000; i++) {
            if(!notSelfnums.contains(i))
                sumOfSelfnum += i;
        }

        return sumOfSelfnum;
    }

    private static ArrayList<Integer> calcNotSelfnum() {
        ArrayList<Integer> arr = new ArrayList<>();

        for(int i=1; i< 5000; i++) {
            //제네레이터를 갖는 수를 구한다.
            int temp = i;
            int generator = temp;
            do {
                generator += temp%10;
                temp /= 10;
            }while(temp != 0);


            if(generator < 5000) {
                arr.add(generator);
                System.out.println("삽입: " + generator);
            }
        }

        return arr;
    }   
}

Python으로 풀었습니다. (1227365)

def solve(max):
    total = 0
    non_self = set()
    for x in range(1, max + 1):
        if x not in non_self:
            total += x
        non_self.add(x + eval('+'.join(str(x))))
    return total

print(solve(5000))

all = set(range(1,5000))
gen = {eval('+'.join(str(n))) + n for n in all}
selfnum = all - gen
print(sum(selfnum))

    static int d(int n){
        int result=0, limit=0;
        result += n;

        for(int i=1; i<=n; i*=10) limit = i;
        for(int i=limit; i>=1; i/= 10) {
            result += n/i;
            n -= (n/i)*i;
        }
        return result;
    }

    public static void main(String[] args){
        int num[] = new int[5000];
        int i=0, sum=0;

        for(int j=0; j<num.length; j++) num[j] = j+1;
        for(int j=0; j<num.length; j++) {
            if(d(j+1) <= 5000) num[d(j+1)-1] = 0;
        }
        for(int j=0; j<num.length; j++){
            if(num[j] != 0) {
                sum+= num[j];
                System.out.println(num[j]);
            }
        }
        System.out.println("1 이상이고 5000 보다 작은 모든 셀프 넘버들의 합은 " + sum + "이다.");
    }
}

def mygen(num):
    sum = 0
    for i in str(num):
        sum += int(i)
    return (sum + num)

oneto5000 = set(list(range(1,5000)))
notselfnum = set()
for i in range(1,5000):
    notselfnum.update([mygen(i)])

print(sum(oneto5000-notselfnum))

package java_tutorial;

public class Selfnumber {

    public static void main(String[] args) {

        boolean [] generator = new boolean[5000];
        int generNum = 0;
        int sum = 0;

        for(int i= 1; i < 5000; i++)
        {
                generNum = (i/1000) + (i/100)%10 + (i/10)%100 + i%1000 + i;
                if(generNum>0 && generNum<5000)
                {
                        generator[generNum] = true;
                }
        }

        for(int i = 1; i < 5000; i++) 
        {
                if(generator[i]==false)
                {
                        sum += i;
                }
        }

        System.out.println("The answer is " + sum);
    }

}

파이썬  초보자 입니다... 

total = []
for k in range(1, 5001):
    total.append(k)



for i in range(1,5001):
    sum = 0
    for j in str(i):
        sum += int(j)
    sum += i

    if sum in total:
        total.remove(sum)
    else :
        continue

sumValue = 0
for num in total:
    sumValue += num

print(sumValue)

#include<stdio.h>

int d(int n);

int main(void)
{
    int arr[5000];
    int n = 5000;
    int i, j; 
    int total = 0;
    for (i = 0; i < 5000; i++)
        arr[i] = i + 1;
    for (i = 0; i < 5000; i++)
        for (j = 0; j < 5000; j++)
            if (arr[i] == d(j))
                arr[i] = 0;
    for (i = 0; i < 5000; i++)
        total += arr[i];
    printf("%d", total);
    return 0;
}

int d(int n)
{
    int temp = n;
    int gen = 0;
    while (temp * 10 / 10 != 0)
    {
        gen += temp % 10;
        temp = temp / 10;
    }
    gen = gen + n;
    return gen;
}

# Generator function
def d(number) :
    result = 0
    for i in range(0, len(str(number))) :
        result += int(str(number)[i])
    return result + number

# Non-selfnumbers
non_selfnumbers = []
n = 1
while True :
    non_selfnumbers.append(d(n))
    n += 1
    if n >= 5000 :
        break

# Numbers in range 1 ~ 5000
total_numbers = []
for i in range(1, 5001) :
    total_numbers.append(i)

# Lists to sets
s1 = set(non_selfnumbers)
s2 = set(total_numbers)

# The result
print(sum(s2) - sum(s1 & s2))

li = list(range(1,5000))
for i in range(1,5000):
    a = i//1000+(i%1000//100)+(i%100//10)+(i%10)+i
    if a in li:
        li.remove(a)
    else:
        continue
sum(li)

import java.util.HashSet;
import java.util.Set;

public class Lv2 {

    public int func(int num){
        Set<Integer> set = new HashSet<Integer>();
        int result = 0;
        for(int i = 1; i< num; i++)
            set.add(new Integer(i));
        for(int i = 1; i<=num;i++){
            int gen = 0;
            char[] chars = String.valueOf(i).toCharArray();
            for(int j = 0; j< chars.length;j++)
                gen += chars[j] - 48;
            gen += i;
            set.remove(gen);
        }
        for (Integer integer : set) {
            result += integer;
        }
        return result;
    }
    public static void main(String[] args){

        Lv2 obj = new Lv2();
        System.out.println(obj.func(5000));
    }
}

1부터 5000까지의 숫자의 제네레이터를 모두 구해 리스트에 넣고, 1부터 5000까지 수들 중에 제네레이터에 해당되는 수를 제외한 다음 나머지를 더하면 됩니다.(코드는 참조하지 않음)

def digit_sum(n):
    sum = 0
    while n:
        sum,n = sum+ n%10, n//10
    return sum

total = []
for i in range(1,5000):
    total.append(i+digit_sum(i))

selfnumber = (set(list(range(1,5001)))-set(total))

print(sum(selfnumber))

def d(n):

    result = 0

    for num in str(n):
        result += int(num)
    result += n

    return result

nums = set(range(1, 5000+1))
d_nums = set()

for num in nums:
    d_nums.add(d(num))

s_nums = nums - d_nums

print(sum(s_nums))

실행결과: 1227365

python3로 작성했고, 차집합연산을 이용하기 위해서 집합(set) 자료형을 사용하였습니다.

#include <iostream>
#include <cstdlib>

using namespace std;

#define MAX 5000

int get_val(int num)
{
    return (num / 1000 + (num % 1000) / 100 + (num % 100) / 10 + num % 10 + num);
}


void main() {

    bool check[MAX] = { 0, };

    int ch_target = 0;

    int ch_sum = 0;

    for (int i = 0; i < MAX; i++) {

        ch_sum = get_val(i);
        check[ch_sum] = 1;
        ch_sum = 0;
    }


    for (int j = 0; j < MAX; j++) {
        if (check[j] == 0) {
            //cout << "self-num =  ";
            ch_sum += j;
        }
    }

    cout << endl << "결과 = " << ch_sum << endl; 

    system("pause");

}

R로 작성하였습니다.

{.r}
gene <- function(x) {
  result <- sum(as.numeric(unlist(strsplit(as.character(x),""))))+x
  return(result)
}

a <- 1:5000
b <- sapply(a, gene)
self <- setdiff(a,b)
sum(self)

def d(n): result=n while n!=0: result+=n%10 n//=10 return result

A=[d(n) for n in range(5000)] B=[n for n in range(5000) if n not in A] print(sum(B))

Python 3

파이썬으로 작성되었습니다.

list1 = list(range(1, 5000))

for i in range(5000):
    remove_num = (i % 10000) // 1000 + (i % 1000) // 100 + (i % 100) // 10 + (i % 10) // 1 + i
    if remove_num in list1:
        list1.remove(remove_num)


sum = 0
for i in list1:
    sum += i

print(sum)

result = 1227365

: 셀프 넘버를 구하는 방법은 구현이 잘 안되어서 셀프 넘버가 아닌 값을 제거하는 방식으로 구현해봤습니다. 1부터 5000까지의 리스트를 생성후 for문을 통해 돌면서 제너레이터를 가진 값들을 모두 소거하는 방식입니다.

def d(num):
    num=str(num)
    s=int(num)
    for i in num:
        s+=int(i)
    return(s)
total= 0
self_num = []
for i in range(1,5000):
    self_num.append(d(i))
for i in range(1,5000):
    if i not in self_num:
        total += i

print(total)

def d(n): return n+sum([int(i) for i in str(n)])

origin = set(range(1,5000))
setfunc = set([d(n) for n in range(1,5000)])

print (sum(origin - setfunc))

C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int charToInt(char c);
int main()
{
    char *p = (char*)malloc(sizeof(char)*4);
    int arr[5000];
    int cnt = 0;
    for(int i=0;i<5000;i++)
        arr[i] = 0;
    int result = 0;
    for(int i=1;i<=5000;i++)
    {
        sprintf(p,"%d",i);
        int len = strlen(p);
        for(int j=0;j<len;j++)
        {
            result = result + charToInt(p[j]);
        }

        arr[cnt] = atoi(p) + result;
        result=0;
        cnt++;  
    }
    for(int i=0;i<5000;i++)
        printf("%d ",arr[i]);
    int flag = 0;
    for(int i=0;i<5000;i++)
    {
        for(int j=0;j<5000;j++)
        {
            if(i==arr[j])
                flag = 1;       
        }
        if(flag == 1)
            printf("%d ",i);
    }
    return 0;
}
int charToInt(char c)
{
    printf("%d\n",(int)c - 48);
    return (int)c - 48;
}

a=sum(set(range(1,5000))-{x+sum([int(i) for i in str(x)]) for x in range(1,5000)})
print(a)

def noneSelfNumber(num):
    k=0
    k+=num
    while num>0:
        k=k+num%10
        num=num//10
    return k

D=set([noneSelfNumber(n) for n in range(32)])

Z=set([n for n in range(32) if n not in D])

print(sum(Z))

깔끔하게 작성하기 쉽지 않네요.

def GetNotSelfNo(n) :
    sub = 0
    for i in str(n) :
        sub = sub + int(i)
    return sub + n

origin = set(range(1, 5001))

none_self_no = set()
for i in range(1, 5000) : 
    none_self_no.add(GetNotSelfNo(i))
print(none_self_no)

self_no = origin - none_self_no
print(self_no)

final_sum = 0;
for n in self_no :
    final_sum += n

print(final_sum)

def d(num):
    tot = 0
    num_str = str(num)
    for char in num_str:
        tot += int(char)
    tot += num
    return tot

arr1 = []
for cnt in range(1, 5000):
    arr1.append(d(cnt))

arr1 = set(arr1)
arr2 = set(range(1, 5000))

print(sum(arr2 - arr1))

def generator(n):
    n =str(n)
    sum =int(n)
    for i in n:
        sum += int(i)
    return sum
total = 0
selfList = [generator(i) for i in range(5000)]
for i in range(5000):
    if i not in selfList:
        total += i
print(total)

문제풀면서 다른분 정보 좋은거 많이 배워가네요 저는 가장 단순판 방법으로 했어요.

def d(n):
    tot = n
    for i in str(n):
        tot += int(i)
    return tot

generator = []
cnt = 1

for i in range(1,5001):
    generator.append(i)

while 1:
    res = d(cnt)
    if res > 5000:
        break
    if res in generator:
        generator.remove(d(cnt))
    cnt += 1

print(sum(generator))

public class Example1 {
    public static void main(String[] args) {
        Example1 ex = new Example1();
        LinkedHashSet<Integer> setInteger = new LinkedHashSet<Integer>();   

        for (int i = 0; i < 5000; i++) {
            setInteger.add(ex.getGeneratorNum(i));
        }

        int sum = 0;
        for (int i = 0; i < 5000; i++) {
            if (!setInteger.contains(i))
                sum += i;
        }

        System.out.println(sum);

    }

    private int getGeneratorNum(int n) {
        int num = 0;

        String str = String.valueOf(n);
        for (int i = 0; i < str.length(); i++) {
            num += Integer.parseInt(str.substring(i, i + 1));
        }
        return num + n;
    }
}

LinkedHashSet을 사용한 이유는 순차적으로 집어 넣을려고 사용했습니다.

// golang 1.9
package main

import (
    "fmt"
    "strconv"
)

func main() {
    // mapping the generated
    dned := make(map[int]int)
    for i := 1; i <= 5000; i++ {
        dned[d(i)] += 1
    }
    // sum self numbers
    var sum int = 0
    for i := 1; i < 5000; i++ {
        if _, exist := dned[i]; !exist {
            sum += i
        }
    }
    fmt.Println(sum)
}

// calculate generated number, d(n)
func d(n int) int {
    nstr := strconv.Itoa(n)
    var calc int = n
    for i := 0; i < len(nstr); i++ {
        cnvVal, _ := strconv.Atoi(nstr[i : i+1])
        calc += cnvVal
    }
    return calc
}

// ans: 1227365

#01

def gen(n):
    r = n
    for i in str(n):
        r += int(i)
    return r

list = []
self = []

for i in range(1, 5000):
    r = gen(i)
    list.append(r)

for i in range(1, 5000):
    if not i in list:
        self.append(i)
    a = sum(self)
print(a)

오늘 처음 문제 풀어 봤습니다!!

public class Ex {
    public static void main(String[] args) {
        int sum = 0;


        String[] str = new String[5000];
        for(int i=0;i<str.length;i++) {
            str[i] = String.valueOf(i);
        }
        boolean[] flag = new boolean[5000];

        for(int i=1;i<str.length;i++) {
            int length = str[i].length();
            int value = 0;
            for(int k=0;k<length;k++) {
                int x = Integer.parseInt(str[i].substring(k, k+1));
                value += x;
            }
            value += i;
            if(value < 5000)
                flag[value] = true;
        }

        for(int i=1;i<5000;i++) {
            if(flag[i] == false) {
                sum += i;
            }
        }

        System.out.println(sum);
    }
}

자바로 풀었습니다. 1 ~ 5000의 각 값을 연산하여 제네레이터를 가질 수 있는 값을 찾은 후 제네레이터를 가지지 못한 값을 추출하는 방식으로 풀었네요. 좀 더 개선해 볼 부분들이 있을 듯...

public class SumOfSelfNumber {

    private static final int MAX_NUM = 5000;

    public static void main(String[] args) {
        List<Integer> hasGenerators = new ArrayList<>();
        int sumSelfNum = 0;

        for(int i = 1; i < MAX_NUM; i++) {
            String num = String.valueOf(i);
            int sumOfNumElement = 0;

            for(int j = 0; j < num.length(); j++) {
                sumOfNumElement += Integer.valueOf(num.substring(j, j + 1));
            }

            hasGenerators.add(sumOfNumElement + i);
        }

        for(int i = 0; i < MAX_NUM; i++) {
            if(!hasGenerators.contains(i)) {
                sumSelfNum += i;
            }
        }

        System.out.println("sum of self number is " + sumSelfNum);
    }
}

자바로 했습니다~ 첫 문제풀이 ㅎㅎ 지적 감사하게 받겠습니다. 모두들 좋은 하루 되시길^0^

public class Number1 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int n;
        int dn;
        int sum = 0;
        int[] generatorNum = new int [5000]; 
        boolean flag = false;

        for(int i=0;i<5000;i++) {  //제네레이터 수를 배열에 저장한다.
            n = i+1; 
            dn = (n/1000) + (n/100)%10 + (n/10)%10 + (n%10) + n;
            generatorNum[i] = dn;
        }

        for(int j=1; j<5000; j++) { //제네레이터 수를 제외한 수를 sum에 더한다.
            flag = false;
            for(int k=0;k<5000;k++) {
                if(generatorNum[k] == j) {
                    flag = true;
                }
            }
            if(flag == false) {
                sum += j;
            }
        }
        System.out.print(sum);
    }
}

실행결과 : 1227365

# -*- coding:utf-8 -*-
# python 3.6

maxAmount = 5000  # 최대값
# generating
gen = [n + sum([int(i) for i in str(n)]) for n in range(1, maxAmount)]
# 차집합으로 self-number 계산
selfNum = set([i for i in range(1, maxAmount)]) - set(gen)

print(sum(selfNum))
# ans: 1227365

x=list(range(1,5001))
index=[1]*5000
for i in range(1,5001):
    d=i%10+int((i%100)/10)+int((i%1000)/100)+int(i/1000)+i
    if d<=5000:
        x[d-1]=0
print(sum(x))

1)숫자 각자리 수를 어떻게 합할지 고민하다가 저렇게 했는데 다른 분들 코드를 보니 문자열에서 for 돌리면 숫자 한개씩 가져오는군요.. 2)어떤 숫자의 generator는 반드시 어떤 숫자보다 작으므로, 1~5000 사이의 어떤 숫자a가 셀프넘버가 아니라면 반드시 a보다 작은 숫자 중에 generator가 있습니다. 3)그래서 1~5000을 가지는 리스트 x를 만들고, for 문을 통해 1~5000사이의 숫자를 d()의 넣은 결과들을 리스트 x에서 탈락시켜줍니다. 4)마지막으로 합하여 출력합니다.

    public static int d(int n) {

        if (n<10) return n;
        return n%10 + d(n/10);
    }

    public static void main(String[] args) {

        int[] chk = new int[5001];

        // 제너레이터보다 낮은 숫자는 나오지 않기 때문에 5000 까지만 수행
        for (int i = 1; i < 5000 ; i++) {    
            int num = d(i);
            if(num+i < 5000) chk[num+i] = 1;
        }

        int sum = 0;
        for (int i = 1; i < 5000 ; i++) {
            if (chk[i] == 0) sum += i; 
        }

        System.out.println(sum);        
    }

def d(n):
    s_n=str(n)
    i=0
    list=[]
    list_sum=0
    while i<len(s_n):
        list.append(s_n[i])
        i=i+1
    for list_element in list:
        list_sum=list_sum+int(list_element)
    return list_sum+n


#1<n<4975 일때 d의 list--d(4975)=5000이므로 n의 범위를 저렇게 정함
d_number=[]
for n in range(1,4976):
    d_number.append(d(n))

#1~5000까지의 list
number=[]
for int_ in range(1,5001):
    number.append(int_)

#1~5000에서 d의 list값을 뺀 list(즉 self_number의 list)
for remove_num in d_number:
    if remove_num in number:    
        number.remove(remove_num)

self_number=number

#self_number의 합을 구하는 식
sum_selfnumber=0
for x in self_number:
    sum_selfnumber=sum_selfnumber+x

print(sum_selfnumber)

include

using namespace std;

static const int N = 5000;

int d(int n) { int res = n; while (n != 0) { res += n % 10; n /= 10; } return res; }

int main() { bool isSelfNo[N + 1]; for (int i = 0; i <= N; i++) isSelfNo[i] = true; int sumOfSelfNo = 0; int n = 1; while (n <= N) { if (isSelfNo[n]) sumOfSelfNo += n; int _d = d(n); if (_d <= N) isSelfNo[_d] = false; n++; } cout << sumOfSelfNo << endl; }

#include <iostream>
#include <vector>
#include <stack>
#include <math.h>

using namespace std;


int check_digit(int num) {
    int count = 0;
    while (1) {
        count++;
        if (num < pow(10, count))
            return count;
    }
}

int pick_num(int num, int digit) {
    int num1 = pow(10, digit);
    int num2 = pow(10, digit - 1);
    int result = (num%num1 - num%num2)/pow(10,digit-1);
    return result;
}

int d(int num) {
    int digit = check_digit(num);
    int result = num;
    for (int i = 1; i < digit + 1; i++) {
        result += pick_num(num, i);
    }
    return result;
}

vector<int> self_number(int num) {
    vector<int> v(num + 1, 1);
    for (int i = 0; i < num + 2; i++) {
        int num_d = d(i);
        if (num_d <= num)
            v[num_d] = 0;
    }
    return v;
}


int main() {
    int num = 10;
    cout << "Type number" << endl;
    cin >> num;
    vector<int> v = self_number(num);
    int sum = 0;

    for (int i = 0; i <= num; i++) {
        if (v[i] == 1)
            sum += i;
    }
    cout << "Sum of self numbers under" << num << " is : " << sum << endl;
}

'''Python the sum is 1227365''' def d(n): sumSTR=0 for i in list(str(n)): sumSTR+=int(i) return int(sumSTR)+n

a=[] for n in range(1,5000): if d(n)<=5000: a.append(d(n))

print(sum([x for x in range(1,5001) if x not in a]))

#include<stdio.h>

int main()
{
    int number, gen, gen_digit;
    int sum_of_digits, sum_of_self_numbers=0;

    for(number = 1 ; number <= 5000 ; number++)
    {
        for(gen = 1 ; gen < number ; gen++)
        {
            gen_digit = gen;
            sum_of_digits = 0;
            while(gen_digit)
            {
                sum_of_digits += gen_digit % 10;
                gen_digit /= 10;
            }

            if(number == (gen + sum_of_digits))
            {
                sum_of_self_numbers += number;
            }
        }//내부 for의 끝
    }//외부 for의 끝

    printf("1 ~ 5000 까지의 Self-number들의 합 : %d\n", sum_of_self_numbers);

    return 0;
}//main의 끝

public class ex1 {

public static void main(String[] args) {
    boolean[] gen = new boolean[5001];
    int a,b,c,d;
    int sum = 0;

    for(int i=1; i < 5001; i++) {
        a = (i/1000)%10;
        b = (i/100)%10;
        c = (i/10)%10;
        d = (i/1)%10;

        if(a+b+c+d+i <= 5000)
        gen[a+b+c+d+i] = true;
    }

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

        if(gen[i] == false) {
            sum += i;
        }
    }

    System.out.println(sum);
}

}

def getgen(n):
    s = n
    while n > 0 :
        s += n%10
        n //= 10
    return s

selnum = list(range(1,5001))
for i in range(1,5001):
    gen = getgen(i)
    if gen in selnum:
        selnum.remove(gen)

print(sum(selnum))

asum = set()
tsum = set()
for x in range(1, 5000):
    asum.add(x)
    tmp = str(x)
    sm = x;
    for z in tmp:
        sm += int(z)
    if sm < 5000:
        tsum.add(sm)

print(sum(asum - tsum))

def generator(number):
    sum = number
    while number > 0:
        sum += number % 10
        number = number // 10

    return sum

gen_numbers = set()
values = set()
for n in range(1, 5000):
    values.add(n)
    gen_numbers.add(generator(n))

self_numbers = values - gen_numbers

sum = 0
for v in self_numbers:
    sum += v

라이브러리 없이 단순 사칙연산 & OnOff로 해결했습니다.

public class generatorSum {
    public static void main(String[] args) {
        int sumResult = 0; boolean match = false;

        for(int selfNum = 1; selfNum < 5000; selfNum++) {
            for(int generator = 1; generator <= selfNum; generator++) {
                int generatorNum =
                        (generator / 1000)
                        +(generator / 100) % 10
                        +(generator / 10) % 10
                        +(generator % 10)
                        +generator;
                if(generatorNum == selfNum) {
                    match = true;
                }
            }
            if(match == false) {
                sumResult += selfNum;
            } else {
                match = false;
            }
        }
        System.out.println("Result : " +sumResult);
    }
}

package problem.Korea.codingdojang;


//어떤 자연수 n이 있을 때, d(n)을 n의 각 자릿수 숫자들과 n 자신을 더한 숫자라고 정의하자.
//
//예를 들어
//
//d(91) = 9 + 1 + 91 = 101
//이 때, n을 d(n)의 제네레이터(generator)라고 한다. 위의 예에서 91은 101의 제네레이터이다.
//
//어떤 숫자들은 하나 이상의 제네레이터를 가지고 있는데, 101의 제네레이터는 91 뿐 아니라 100도 있다. 그런데 반대로, 제네레이터가 없는 숫자들도 있으며, 이런 숫자를 인도의 수학자 Kaprekar가 셀프 넘버(self-number)라 이름 붙였다. 예를 들어 1,3,5,7,9,20,31 은 셀프 넘버 들이다.
//
//1 이상이고 5000 보다 작은 모든 셀프 넘버들의 합을 구하라.

public class NexonTest {

    public static int selfNumberSum(int input) {
        int result = 0, i = 0, num_i = 0;
        int generatorCheck = 0;
        int[] selfNumber = new int[input];

        for(i=0; i<input; i++) {
            selfNumber[i] = 0;
        } // 셀프 넘버 일 경우 0으로 남도록 한다

        for(i=0; i<input; i++) {
            num_i = i+1;
            generatorCheck = num_i; // 제너레이터를 통해 만들어지는 숫자를 저장. 최초로 자신을 더하도록 한다
            while(num_i != 0) { // 각 자릿수를 더하도록 한다
                generatorCheck += num_i%10;
                num_i /= 10;            
            }
            if(generatorCheck <= input) {
                selfNumber[generatorCheck-1] = 1;
            }
        } // 제너레이터가 있는 숫자일 경우 1로 바꾸도록 한다

        for(i=0; i<input; i++) {
            if(selfNumber[i] == 0) {
                result += i+1;
            }
        } // 0이 담겨져 있는 숫자의 경우 셀프 넘버이므로 이 숫자를 result에 더하도록 한다


        return result;
    }

    public static void main(String[] args) {
        System.out.println(selfNumberSum(5000));

    }

}

generator_set = set()
union_set = set()


def get_generator_num(str_num):
    return sum(map(int, str_num)) + int(str_num)


for i in range(1, 5001):
    rval = get_generator_num(str(i))
    generator_set.add(rval)
    union_set.add(i)

print(sum(union_set - generator_set))

#include <iostream>
using namespace std;

int set[5000];

int main()
{
    for (int k = 0; k<5000; k++)
    {
        set[k] = k;
    }

    for (int c = 0; c<5; c++) // 천
    {
        for (int b = 0; b<10; b++) // 백
        {
            for (int s = 0; s<10; s++) // 십
            {
                for (int i = 0; i<10; i++) // 일
                {
                    int sum = 1000*c + 100*b + 10*s + i + (c+b+s+i);
                    if (sum<5000)
                    {
                        set[sum] = 0;
                    }
                }
            }
        }
    }

    int k = 0;
    int selfsum = 0;
    while (k<5000)
    {
        selfsum = selfsum + set[k];
        k = k+1;
    }

    cout<<selfsum;

    return 0;
}

C++ 배운지 얼마 안된 초보자가 써본 코드입니다. 코딩도장에서 푼 첫 문제입니다. 매우 느릴것같네요.

def listrizer(i):
    list_ex = []
    j = len(str(i))
    for k in range(j):
        list_ex.append(int(str(i)[k]))
    return sum(list_ex, i)

list1 = []
list2 = []

for i in range(5001):
    k = listrizer(i)
    list1.append(k)

for i in range(5001):
    list2.append(i)

set1 = set(list1)
set2 = set(list2)
set3 = set2 - set1
list3 = list(set3)
list3.sort()


#print (list1)
#print (list2)
#print (set3)
#print (list3)
print (sum(list3))

public class Generator {

    public static void main(String[] args) {    
        int genSum = 0;

        for(int num = 1; num<5000; num++)
        {
            for(int num2 = 1; num2<500; num2++)
            {
                if(num == Gener(num2))
                {
                    break;
                }
                if(num2 == 499)
                {
                    genSum += num;
                }
            }
        }

        System.out.println(genSum);

    }

    public static int Gener(int a)
    {
        int num = a;
        int one = num / 1000;
        num -= one * 1000;
        int two = num / 100;
        num -= two * 100;
        int three = num / 10;
        num -= three * 10;
        int four = num;

        int sum = one + two + three + four;

        return sum + a; 
    }

}

    int array[6000] = { 0, };
    int sum = 0;
    for (int i = 1 ; i < 5000; i++)
    {
        int temp = i;
        while (temp)
        {
            sum += (temp % 10);
            temp /= 10;
        }
        array[sum + i] = sum + i;
        sum = 0;
    }

    for (int i = 0; i < 5000 ; i++)
        if (array[i] == 0) { sum += i; }

    cout << "결과값 : " << sum << endl;

include "stdio.h"

include "stdlib.h"

include "string.h"

include "stdbool.h"

define MAX_NUMBER 10000

int Generator(int number);

int main(void) { int sum = 0; bool selfNumber[MAX_NUMBER + 1]; memset(selfNumber, true, sizeof(selfNumber));

for (int i = 1; i <= MAX_NUMBER; i++) //1부터 10000까지 셀프넘버 검사
{
    int generator = Generator(i);

    if (generator <= MAX_NUMBER) // 셀프넘버 아님
        selfNumber[generator] = false;
}

for (int i = 1; i <= MAX_NUMBER; i++) //1부터 10000까지 셀프넘버라면 출력함
{
    if (selfNumber[i] == true)
    {
        printf("Self-Number found !!! : %d\n", i); //< 이부분이 원하는 답이겠네요.
                                                   // sum += i;
    }
}

//printf("Sum of Self-Number = %d\n", sum);//1~부터 10000 사이의 셀프넘버의 합을 출력함.

return 0;

}

int Generator(int number) { int total = 0; int mod;

total += number; // 일단 자신을 더한다.

while (number>0) // 자릿 수를 줄여가면서 첫번째 자리를 더한다.
{
    mod = number % 10;
    number = number / 10;
    total = total + mod;
}


return total;

}

package test;

public class test02 {

public static void main(String[] args) {
    // TODO Auto-generated method stub
    int sum = 0;

    out : for(int i = 1; i < 5000; i++) // 5000까지 반복
    {
        for(int j = 1; j < i; j++)
        {
            if(i == Generator(j)) //제너레이터가 아니면
            {
                continue out;
            }
        }
        sum += i;
    }
    System.out.println(sum);
}
private static int Generator(int n) //제너레이터 구하기
{
    int x1 = n % 10; // 1의자리
    int x10 = (n / 10) % 10; //10의자리
    int x100 = (n / 100) % 10; //100의자리
    int x1000 = n / 1000; //1000의자리

    return n + x1 + x10 + x100 + x1000; //제너레이터 결과
}

}

저는 해당 코드를 파이썬으로 작성했습니다. 우선 d(number) 함수를 작성한 뒤, 1에서 5000까지 순서대로 구성된 집합을 a집합으로, generated number을 b집합으로 정했습니다. 1에서 5000으로 만들어진 숫자 중에는 d(n)함수에 넣었을 때, 5000을 넘는 것이 있으므로 해당 숫자들은 제외하여 집합 b에 저장하였습니다. 그 다음, a집합과 b집합의 교집합을 제외한 나머지를 저장하여 self number_list를 만들고, sum함수를 이용하여 더하였습니다.

def d(number):
    sum = number
    for i in list(str(number)):
        sum += int(i)
    return sum

a = []
for i in range(1,5001):
    a.append(i)

b = []
for i in range(1,5001):
    if d(i) > 5000:
        break
    else:
        b.append(d(i))

selfnumber_list = set(a)^set(b)
print(sum(selfnumber_list))

#include <iostream>
using namespace std;

int main(){
    int Arr[5000];
    for (int i = 0; i < 5000; i++){
        Arr[i] = i + 1;
    }
    int number = 0;
    for (int i = 0; i < 5000; i++){
        number = i % 10 + i / 10 + i / 100 + i / 1000;
        Arr[number] = 0;
    }
    int total = 0;
    for (int i = 0; i < 5000; i++){
        total += Arr[i];
    }
    cout << total;
    return total;
}

def dgen(n) :
    k = str(n)
    k = list(k)
    for i in k :
        n += int(i)
    return n

self = set(range(1,5000)) - set([dgen(i) for i in range(1,5000)])

print(sum(self))

public class Main {

    public static void main(String[] args) {
        int size = 4999;
        int[] a = new int[size];
        for(int i=0; i<size; i++){
                int gen = (i+1)/1000+((i+1)/100)%10+((i+1)/10)%10+(i+1)%10+i+1;
                if(gen < size) a[gen-1] = -1;
        }
        int sum=0;
        for(int i=0;i<size; i++){
            if(a[i]!=-1) sum = sum+i+1;
        }
        System.out.println(sum);
    }

}

public class Generator {
    public static void main(String[] args) {
        ArrayList<Integer> allNum = new ArrayList<>();
        ArrayList<Integer> genNum = new ArrayList<>();
        ArrayList<Integer> selfNum = new ArrayList<>();

        final int num = 5000;
        int a, b, c, d, sum;
        a = b = c = d = sum = 0;

        for (int i = 1; i < num; i++) {
            allNum.add(i);
        }

        for (int i = 0; i < allNum.size(); i++) {
            a = allNum.get(i) % 10;
            b = (allNum.get(i) / 10) % 10;
            c = (allNum.get(i) / 100) % 10;
            d = allNum.get(i) / 1000;

            if (!genNum.contains(a + b + c + d + allNum.get(i))) {
                genNum.add(a + b + c + d + allNum.get(i));
            }
        }

        for (int i = 0; i < allNum.size(); i++) {
            if (!genNum.contains(allNum.get(i))) {
                selfNum.add(allNum.get(i));
            }
        }
        for (int i = 0; i < selfNum.size(); i++) {
            sum += selfNum.get(i);
        }
        System.out.println(sum);
    }

}

public static int sumNum(int n) { int result = 0; for(int i =1 ; i < n; i++){ for (int j = 1; j <= i; j++) { String test = j+""; int test2 =0; for (int k = 0; k < test.length(); k++) { test2 += Integer.parseInt(test.charAt(k)+""); } if (i == test2+j) { break; }else if(i ==j){ result += j; System.out.println(j); } } } return result; }

체감상 lv3 정도 되는 문제라고 생각합니다. 2는 아닌거 같은데.. 제 실력 부족이겠죠 ㅡㅜ 어찌됬든 풀었습니다.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Nexon_Generator_
{
    class Program
    {
        static void Main(string[] args)
        {
            //각 자리 숫자 들과 자신을 더한 숫자
            int answer = 0;
            int divideNum = 1;
            int digit;
            List<int> list = new List<int>();

            for (int i = 1; i < 5000; i++)
            {
                while (i / divideNum >= 1) //자릿수들의 합
                {
                    digit = i % (divideNum * 10);
                    digit /= divideNum;
                    answer += digit;
                    divideNum *= 10;
                }
                list.Add(i + answer); //제너레이터가 있는수 저장
                divideNum = 1;
                answer = 0;
            }
            bool flag = false;
            answer = 0;
            list.Sort(); //오름차순 정렬
            for(int i = 0; i < 5000; i++)
            {
                foreach(int l in list)
                {
                    if(i == l) //셀프 넘버가 아닌수
                    {
                        flag = true;
                        break;
                    }
                    else if(i <= l)
                    {
                        break;
                    }
                }
                if(flag == true)
                {
                    flag = false;
                    continue;
                }
                //Console.WriteLine(i); //셀프 넘버 출력
                answer += i;
            }
            Console.WriteLine(answer);
        }
    }
}

# 한글 처리 in Atom 1.21.1 + Anaconda(Python 3.6.3) on Mac
import sys
import io

sys.stdout = io.TextIOWrapper(sys.stdout.detach(), encoding='utf-8')
sys.stderr = io.TextIOWrapper(sys.stderr.detach(), encoding='utf-8')

# 어떤 자연수 n이 있을 때, d(n)을 n의 각 자릿수 숫자들과 n 자신을 더한 숫자라고 정의하자.
# 예를 들어
# d(91) = 9 + 1 + 91 = 101
# 이 때, n을 d(n)의 제네레이터(generator)라고 한다. 위의 예에서 91은 101의 제네레이터이다.
# 어떤 숫자들은 하나 이상의 제네레이터를 가지고 있는데, 101의 제네레이터는 91 뿐 아니라 100도 있다.
# 그런데 반대로, 제네레이터가 없는 숫자들도 있으며,
# 이런 숫자를 인도의 수학자 Kaprekar가 셀프 넘버(self-number)라 이름 붙였다.
# 예를 들어 1,3,5,7,9,20,31 은 셀프 넘버 들이다.
# 1 이상이고 5000 보다 작은 모든 셀프 넘버들의 합을 구하라.

print(sum(set(range(1, 5000)) - set([i + sum([int(number)
                                              for number in str(i)]) for i in range(1, 5000)])))

return sum(set(x for x in range(1,10)) - set(n + sum(map(int, str(n))) for n in range(1,10)))

처음에는 def로 선언했지만, lambda가 좀더 축약된 표현이라서 수정함

def find_generator(input):
    str01 = str(input)
    num = 0
    for i in str01:
        num = num+int(i)
    num = num+int(input)
    return num
# 좀 더 간단하게 아래와 같이 수정
find_g = lambda x : x  + sum([int(n) for n in str(x)])

r_01 = [find_g(inx) for inx in range(5000)]
s_01 = set(r_01)
s_02 = set([n for n in range(1,5001)])

r_02 = list(s_02-s_01)
result = sum(r_02)
print(result)

using System;
using System.Collections.Generic;
namespace Test
{
    class MainClass
    {

        public static void Main (string[] args)
        {
            int N = 5000;
            List<int> list = new List<int> ();
            for (int i = 0; i < N; i++)
                list.Add (i);
            list.Remove (0);
            for (int i = 1; i < N; i++) {
                if (list.Contains (dn (i)) == true) {
                    list.Remove (dn (i));
                } else {
                }
            }
            int l = 0;
            for (int i = 0; i < list.Count; i++) {
                l += list [i];
            }
            Console.WriteLine (l);
        }


        public static int dn (int n){
            int[] sep = separator (n);
            int r = n;
            for (int i = 0; i < sep.Length; i++) {
                r += sep [i];
            }
            return r;
        }

        public static int[] separator(int k)
        {
            string a = k.ToString();

            int[] ri = new int[a.Length];
            for (int i = 0; i < ri.Length; i++) {
                ri [i] = Convert.ToInt32 (a [i].ToString());
            }
            return ri;
        }
    }
}

sum([x for x in range(1,5000) if x not in map(lambda a: sum([int(a) for a in str(a)])+a, range(1,5000))])

include

int d(int n){ int first = 0; int sum =0;

for(int i=1000;i>0;i /10){ first = n / i; n -=(first * i); sum += first; }

return sum; }

int main(void){ int n=0; int generator =0

prinf("input : "); scanf("%d", &n);

generator = d(n); print("d(%d) = %d", n, generator); }

int main()
{
    int i;
    int ghavnum=0 ;
    int arr[5000];
    int k;
    int total=0;

    for (i = 0; i < 5000; i++)
    {
        arr[i] = 0;
    }




    for (i = 1; i <= 5000; i++)
    {
        k = i;
        ghavnum = i;
        while (k > 0)
        {

            ghavnum += k % 10;
            k = k / 10;
        }
        if (ghavnum > 0 && ghavnum <= 5000)
        {
            arr[ghavnum - 1] = 1;
            printf("%d,", ghavnum);
        }


    }



    for (i = 0; i < 5000; i++)
    {
        if (arr[i] == 0)
            total += (i + 1);
    }

    printf("%d", total);

    getchar();
    return 0;

}

def getSumAllDigit(num):
    numStr = str(num)
    result = 0;
    for digit in numStr:
        result += int(digit)
    return result

def d(num):
    for i in range(0, num):
        if(i > num) :
            return False # 제너레이터는 입력받은 숫자보다 클수는 없다
        elif(getSumAllDigit(i) + i == num) :
            return True
    return  False

MAX_NUM = 5000
#for i in range(1, MAX_NUM):
#    print(str(i) + "," + str(d(i)))

newList = [i for i in range(1, MAX_NUM) if d(i) == False]
print(sum(newList))

const d = n => n + n.toString().split('').map(v => +v).reduce((s, v) => s + v);
const numbers = Array.from(Array(5000), (v, i) => i + 1);

for (let i = 1; i < 5000; i++) {
  numbers[d(i) - 1] = 0;
}

const result = numbers.reduce((s, v) => s + v, 0);

console.log(result, result === 1227365);

Common Lisp

(defun foo (max)
  (labels ((fun-gen (num)
           (+ num (apply #'+ (map 'list #'digit-char-p (prin1-to-string num))))))    

    (let ((num-list (loop for n from 1 below max collect n))
          (gen-list (loop for n from 1 below max collect (fun-gen n))))    

      (apply #'+ (set-difference num-list gen-list)))))

>(foo 5000)
>1227365

li = []
exist=0
max1 = (4999 * 5000) / 2
for i in range(1,5000):
    g = i + sum([int(a) for a in str(i)])
    exist=0
    for j in li:
        if j == g:
            exist=1
            break

    if g >= 5000 or exist == 1:
        g = 0
    else:
        li.append(g)
    max1 = max1 - g


print(max1)


# 1227365

def d(n):
    y = n
    while n > 0:
        y += n % 10
        n //= 10
    return y

Z = [d(n) for n in range(5000)]
A = [n for n in range(5000) if n not in Z]
print(sum(A))

import java.util.ArrayList;

public class Nexon {
    public static void main(String[] args) {
        Nexon N = new Nexon();
        ArrayList<Integer> generator = new ArrayList<>();
        int n=0;
        for(int i =0; i<5000;i++){
            generator.add(N.Generator(i));
        }
        for(int i = 0; i <= 5000; i++){
            if(generator.contains(i)){

            }else {
                n += i;
            }
        }
        System.out.println(n);
    }

    public int Generator(int n) {
        int answer = 0;
        int count=0;
        String[] num;
        num = String.valueOf(n).split("");
        int k = String.valueOf(n).length();
        for(int i = 0 ; i< k; i++){
            answer += Integer.parseInt(num[i]);
        }
        answer += n;
        return answer;
    }
}

#include <iostream>
using namespace std;

inline int Generator(int num)
{
    int temp = num;
    while (1)
    {
        temp += num % 10;
        num /= 10;
        if (num == 0)break;
    }

    return temp;
}

class SelfNumbers
{
private:
    int Total;
    int *GeneratorNumber;
    int Size;
    int Number;

    void Allocate(int num)
    {
        Size++;
        GeneratorNumber = (int*)realloc(GeneratorNumber, sizeof(int)*Size);
        GeneratorNumber[Size - 1] = num;
    }

    bool Search(int num)
    {
        for (int i = 0; i < Size; i++)
            if (GeneratorNumber[i] == num)
                return false;
        return true;
    }

    void Update(int num)
    {
        if (Search(num))
            Allocate(num);
    }
public:

    void ViewSelfNumbersTotal()
    {
        for (int i = 0; i < Number + 1; i++)
        {
            if (Search(i) == true)
                Total += i;
        }
        cout << Total << endl;
    }

    SelfNumbers(int how)
        :Total(0)
        , GeneratorNumber(nullptr)
        , Size(0)
        , Number(how)
    {
        for (int i = 0; i < Number; i++)
            this->Update(Generator(i));
    }
    ~SelfNumbers()
    {
        free(GeneratorNumber);
    }
};


void main()
{
    SelfNumbers* SN;
    SN = new SelfNumbers(5000);
    SN->ViewSelfNumbersTotal();
    delete SN;

    system("pause");
}

visual studio 2017 C++

U = range(1, 5001)

for num in range(1, 5001):
    i = ii = iii = iiii = 0

    i = num%10/1
    if num > 9:
        ii = num%100/10
        if num > 99:
            iii = num%1000/100
            if num > 999:
                iiii = num%10000/1000
    s = i+ii+iii+iiii+num
    if s in U:
        U.remove(s)

#print U[:20], "..."
print sum(U)

d_fn = lambda n: n + sum([int(i) for i in str(n)])


generator = set(d_fn(i) for i in range(1, 5000))
y = set(range(1,5000))

ans = y.difference(generator)

print(sum(ans))

#include <stdio.h>
#include <math.h>
#include <memory.h>

class CDojo1_SelfNum
{
public:
    CDojo1_SelfNum() {};
    ~CDojo1_SelfNum() {};

    int Solve(int inputNum);

private:
    int CalGeneratorNum(int inputNum);
};

int CDojo1_SelfNum::CalGeneratorNum(int inputNum)
{
    int retVal = 0;

    int calNum = inputNum;
    int digit = 0;
    int modVal = 10;
    do
    {
        digit = (calNum % modVal);
        retVal += digit;
        calNum *= 0.1f;
    } while (calNum != 0);

    retVal += inputNum;

    return retVal;
}

int CDojo1_SelfNum::Solve(int inputNum)
{
    int retval = 0;

    const int AllocSize = inputNum + 1;
    bool* selfNumInfo = new bool[AllocSize];
    memset(selfNumInfo, true, sizeof(bool)*AllocSize);

    for (int i = 1; i <= inputNum; i++)
    {
        int GeneratorNum = CalGeneratorNum(i);
        if (GeneratorNum <= inputNum)
        {
            selfNumInfo[GeneratorNum] = false;
        }
    }

    for (int i = 1; i <= inputNum; i++)
    {
        if (selfNumInfo[i] == true)
            retval += i;
    }

    delete[] selfNumInfo;

    return retval;
}


int main()
{
    CDojo1_SelfNum exam;

    printf("%.2f\n", exam.Solve(5000));
}

def make_gen(num):
    self_num =[]
    not_self = []
    for n in range(num):
        gen_add =[]
        for i in range(len(str(n))):
             gen_add.append(int(str(n)[i]))
        not_self.append(sum(gen_add)+n)


    for x in range(num):
        if x not in not_self:
            self_num.append(x)

    return sum(self_num)

print (make_gen(5000))

def d(n):
    res=n
    n=str(n)
    for i in n:
        res+=int(i)
    return res

count=0
number=list()
for gen in range(1,5000):
    number.append(d(gen))
for i in range(1,5000):
    if i not in number:
        count+=i
print(count)

allnum = set(range(1,5000))
snum = set()
result = 0

for i in range(1,5000):
    lennum = len(str(i)) + 1
    num = i

    for n in range(1, lennum):
        q, r = divmod(i, 10)
        num += r
        i = q

        if q == 0:
            snum.add(num)
            break

nonsnum = list(allnum - snum)

for a in nonsnum:
    result += a

print(result)

data = []
for i in range (1, 5000) :
    tot = 0
    s = str(i)
    for j in range(0, len(s)) :
        tot += int(s[j])
    result = tot + i
    data.append(result)
# print(data)
r_data = []
for k in range (1, 5000) :
   if k in data : continue
   else :
       r_data.append(k)
print(sum(r_data))

public static void main(String[] args) { calculateNumbersHasGenerator(); int sum = 0; for (int i = 0; i < 5001; i++) if (!hasGenerator(i)) sum += i; System.out.println("합 : "+sum); }

private static boolean hasGenerator(int num)
{
    return numbersHasGenerator.contains(num);
}

private static ArrayList<Integer> numbersHasGenerator;

private static void calculateNumbersHasGenerator()
{
    numbersHasGenerator = new ArrayList<Integer>();
    for (int i = 0; i <= 5000; i++)
    {
        String num = String.valueOf(i);
        int no = 0;
        for (int n = 0; n < num.length(); n++)
            no += Integer.parseInt(num.substring(n, n + 1));
        numbersHasGenerator.add(no + i);
    }
}

public class Main{

    public static int selfNumberSum(int input) {
        int result = 0, i = 0, num_i = 0;
        int generatorCheck = 0;
        int[] selfNumber = new int[input];

        for(i=0; i<input; i++) {
            selfNumber[i] = 0;
        } // 셀프 넘버 일 경우 0으로 남도록 한다

        for(i=1; i<=input; i++) {
            num_i = i;
            generatorCheck = num_i; // 제너레이터를 통해 만들어지는 숫자를 저장. 최초로 자신을 더하도록 한다
            while(num_i != 0) { // 각 자릿수를 더하도록 한다
                generatorCheck += num_i%10;
                num_i /= 10;            
            }
            if(generatorCheck <= input) {
                selfNumber[generatorCheck-1] = 1;
            }
        } // 제너레이터가 있는 숫자일 경우 1로 바꾸도록 한다

        for(i=0; i<input; i++) {
            if(selfNumber[i] == 0) {
                result += i+1;
            }
        } // 0이 담겨져 있는 숫자의 경우 셀프 넘버이므로 이 숫자를 result에 더하도록 한다


        return result;
    }

    public static void main(String[] args) {
        System.out.println(selfNumberSum(5000));

    }

}

hab = 0
sel = 0
glo = 0
for i in range(1,5000): 
   for a in range(0,i):
       hab+=a
       gen=str(a)
       for j in range(len(gen)):
           hab+=int(gen[j])
       if(hab == i):
         sel = 1
       hab = 0
   if(sel == 0):
       print(i)
       glo += i
   sel = 0
print(glo)

selfNumbers = []

arr = []
genNumbers = range(1, 5000)

for v1 in genNumbers:
    str_v1 = str(v1)
    digits = len(str_v1)

    mySum = 0;
    for idx in range(0, digits):
        mySum = mySum + int(str_v1[idx])
    mySum = mySum + v1
    arr.append(mySum)

for idx in range(1, 5000):
    cnt = arr.count(idx)
    if cnt == 0:
        selfNumbers.append(idx)        

print("===============================")
print("합계: " + str(sum(selfNumbers)))

def dg(num):
    return(sum(list(map(int, list(str(num)))))+num)

nums=set(range(1, 5000))
summ=0
n=1
while summ<=4999:
    summ=dg(n)
    nums=nums-{summ}
    n+=1

print(sum(nums))

def d(n):
    sum_x = 0
    str_n = str(n)
    for x in str_n:
        sum_x = sum_x + int(x)
    return sum_x + n

mb = []
for x in range(1,5000):
    if d(x) < 5000:
        mb.append(d(x))

pr = 0
for k in list(range(1, 5000)):
    if k not in mb:
        pr = pr + k
print(pr)

2시간 만에 겨우 풀었네요..완전 노가다로 푼듯ㅠㅠ

package programming;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

public class nexon {

    public static void main(String[] args) {

        int self=1,i;
        int result = 0;
        long sum=0;
        int x=1;


        int arr[] = new int[5000];

        for(i=1;i<5000;i++)
            arr[i] = i;

        while(genCalc(x)<5000){
            int index;

            index = genCalc(x);

            if(arr[index]==genCalc(x))
                arr[index] = 0;


            x++;
        }

        for(i=1;i<arr.length;i++){
            if(arr[i]!=0)
                sum+=arr[i];
        }


        System.out.println(sum);
    }

    static int genCalc(int x){
        int gen = 0;

        if(x>=1000)
            gen = (x/1000)+(x%1000)/100 + ((x%1000)%100)/10 + ((x%1000)%100)%10 + x;
        else if(x>=100)
            gen = (x/100)+(x%100)/10 + (x%100)%10 + x;
        else if(x>=10)
            gen = (x/10)+(x%10)+x;
        else if(x<10)
            gen = (x%10)+x;

        return gen;
    }

}

파이썬 공부하고 처음 풀어봐요. 파이썬3 입니다.

def d(n):
    return sum(int(x) for x in str(n)) + n
nums = list(range(1, 5000))
for n in range(1, 5000):
    try:
        nums.remove(d(n))
    except:
        pass
print(sum(nums))

def generator(number):
    factornum = 0
    for i in range (len(str(number))):
        factornum = factornum + int(str(number)[i])
    factornum += number
    return factornum

def whichoneiswhich(limitation1,limitation2):
    result = 0
    # make a list that contains from 1 to limitation1.
    possiblefactornum = []
    for i in range(1,limitation1+1):
        possiblefactornum.append(i)
    for k in range(1,limitation2+1):
        generator(k)
        try: possiblefactornum.remove(generator(k))
        except: ValueError
    for j in possiblefactornum:
        result += j
    return result

print(whichoneiswhich(5000,10000))