def kaprekar_number(num):
    n = str(num**2).zfill(2)
    n = list(int(n[:i])+int(n[i:]) for i in range(1,len(n)//2+1) if 0 != int(n[i:]))
    return num in n

def kaprekar_numbers(num):
    return list(x for x in range(1,num+1) if kaprekar_number(x))

def kaprekar_digit(num):
    return list(x for x in range(10**(num-1),10**num) if kaprekar_number(x))


def kaprekar_constant(num, i = 0):
    if len(set(str(num).zfill(4))) != 1 and len(str(num)) < 5:
        while num != 6174:
            num,i = str(num).zfill(4),i+1
            num = int(''.join(sorted(num)[::-1]))-int(''.join(sorted(num)))
        return i
    return False

# Prob 1.
def kaprekar_number(num):
    num_sq = num ** 2
    if num_sq == num:
        return True
    num_sq_str = str(num_sq)
    for i in range(len(num_sq_str)-1):
        first = int(num_sq_str[:i+1])
        second = int(num_sq_str[i+1:])
        if (first + second) == num:
            if second == 0:
                return False
            return True
    return False

print(kaprekar_number(1))
print(kaprekar_number(45))
print(kaprekar_number(297))
print(kaprekar_number(3213))

# Prob 2.
def kaprekar_number_digit(digit):
    num_list = range(10 ** (digit-1), 10 ** (digit))
    return list(i for i in num_list if kaprekar_number(i))

print(kaprekar_number_digit(1))
print(kaprekar_number_digit(2))
print(kaprekar_number_digit(3))
print(kaprekar_number_digit(4))

# Prob 3
def kaprekar_number_under(num):
    return list(i for i in range(num+1) if kaprekar_number(i))

print(kaprekar_number_under(100))
print(kaprekar_number_under(1000))
print(kaprekar_number_under(9999))
print(kaprekar_number_under(22222))

풀이입니다~

# 카프리카 수 인지 확인하는 함수
def kaprekar_number(number):
    square = number ** 2
    str_square = str(square)
    if square > 9:
        for x in range(1, len(str_square) - 1):
            if int(str_square[:x]) + int(str_square[x:]) == number:
                return 'True'
        return 'False'
    else:
        if square == number:
            return 'True'
        return 'False'

# 입력받은 수를 작은순서대로 정렬해주는 함수
def make_sorted_number(number):
    temp = ''
    for x in sorted(str(number)):
        temp += x
    while len(temp) < 4:
        temp += '0'
    return int(temp)

# 입력받은 수를 큰 순서로 정렬해주는 함수
def make_reversed_number(number):
    temp = ''
    for x in reversed(sorted(str(number))):
        temp += x
    while len(temp) < 4:
        temp = '0' + temp
    return int(temp)

# 카프리카 상수 확인하는 함수
def kaprekar_constant(number):
    count = 0
    while make_reversed_number(number) - make_sorted_number(number) != 6174:
        if number > 1000 and number % 1111 == 0:
            return "False"
        elif 1000 > number > 100 and number % 111 == 0:
            return "False"
        elif 10 < number < 100 and number % 11 == 0:
            return "False"
        else:
            number = abs(make_reversed_number(number) - make_sorted_number(number))
            count += 1
    return count + 1

def Kafrica(number):
    if number == int(str(number**2)[:len(str(number**2))//2])+int(str(number**2)[len(str(number**2))//2:]): return True
    else: return False


print(Kafrica(45))



def Kafrica_2(number):
    count=1
    while count <v8:
        number = int(''.join(sorted(list(str(number).zfill(4)), reverse=True)))-int(''.join(sorted(list(str(number).zfill(4)))))
        if number == 6174: return count
        count+=1        
    return False

print(Kafrica_2(297))

Ruby

# 1. Checking if it's a kaprekar
kaprekar = ->n, sq=(n**2).to_s do 
  is_k = ->nums { n == nums.sum(&:to_i) && nums.all? {|s| s == "" or s.match?(/[^0]/)} }
  sq.size.times.any? {|i| is_k.([sq[0..i], sq[i+1..]]) }
end

# 2. Generates n-digit kaprekars
kaprekar_dgt = ->ndgt { (10**(ndgt-1)..10**(ndgt)-1).select &kaprekar }

# 3. All kaprekars less than limit
kaprekar_below = ->limit { (1..limit).select &kaprekar }

# 4. kapreka constant
kaprekar_const = ->n, cnt=0, num=n.to_s do
  (return false) if num.squeeze.size == 1
  sorted = num.rjust(4, '0').chars.sort
  n == 6174 ? cnt : kaprekar_const[(sorted.join.to_i - sorted.reverse.join.to_i).abs, cnt + 1]
end

Test

# 1. Check kaprekar
expect([1, 45, 99, 297].map(&kaprekar) ).to all be_truthy
expect([2, 100].map(&kaprekar) ).to all be_falsy

# 2. Generates n-digit kaprekars
expect(kaprekar_dgt[3]).to eq [297, 703, 999]

# 3. All kaprekars less than n
expect(kaprekar_below[1000]).to eq [1, 9, 45, 55, 99, 297, 703, 999]

# 4. Kaprekar constant
expect([4371, 21, 1, 1111].map(&kaprekar_const)).to eq [7, 3, false, false]

perl v5.20.2 for MSWin32-x64-multi-thread 실행확인.

수정1. 100과 같은 "0"이 들어가는 경우 예외처리

100은 카프리카 수가 아니다. 100² = 10000이고 100 + 00 = 100이지만, 00은 양수가 아니기 때문이다. (https://ko.wikipedia.org/wiki/%EC%B9%B4%ED%94%84%EB%A6%AC%EC%B9%B4_%EC%88%98)

수정2. &kaprekar_number1 수정. 코드 간소화 측면...

use strict;#착한 펄린이는 두개를 모두 씁니다.
use warnings;#착한 펄린이는 두개를 모두 씁니다.

sub kaprekar_number1
{#어떤 수를 입력 받고 그 수가 카프리카 수인지 아닌지를 출력하는 함수
    my $input=shift;
  my $result = &kaprekar_number($input);
  if($result)
    {
        return "True\n";
    }
    return "False\n";
}


sub kaprekar_number2
{#어떤 수를 입력 받고 자릿수가 그 수인 모든 카프리카 수를 출력하는 함수
    my $input=shift;
    if($input<1)
  {
   return "None\n"; #0자릿수 수는 없음.
  }
    my $limit=(10**$input);
    my $i=(10**($input-1));
    my $temp_result;
    my @result;
    while($i<$limit)
    {
        $temp_result=&kaprekar_number($i);
        if($temp_result)
        {
            push(@result,$temp_result);
        }
        $i++;
    }
    return "@result\n";
}

sub kaprekar_number3
{#어떤 수를 입력 받고 어떤 수 이하의 모든 카프리카 수를 출력하는 함수
    my $input=shift;
    if($input<0)
  {
   return "None\n"; #입력값이 0보다 작으면 무효.
  }
    my $i=$input;
    my $temp_result;
    my @result;
    while($i>0)
    {
        $temp_result=&kaprekar_number($i);
        if($temp_result)
        {
            push(@result,$temp_result);
        }
        $i--;
    }
    return "@result\n";
}

sub kaprekar_number
{#어떤 수를 입력 받고 그 수가 카프리카 수이면 그 수를 반환하는 함수 kaprekar_number1,3에서 사용.
    my $input=shift;
    if($input==1)
  {
  return 1;#제곱했을때 10미만인 카프리카수는 1뿐. 예외처리
  }
    my $inputs=$input*$input;
    $inputs="$inputs";
    my $a; my $b;
    for my $i (1..(length($inputs)-1))
    {
        $a=substr($inputs,0,$i);
        $b=substr($inputs,$i,(length($inputs)-$i));
        if(((int($a)+int($b))==$input)&&(int($a)!=0&&int($b)!=0))
        {
            return $input;
        }
    }
    return 0;
}

sub kaprekar_constant
{#어떤 수를 입력 받고 몇번이내로 6174가 완성 되었는지 출력하는 함수
    my $input=shift;
    if(($input>9999)||($input==0)||(($input%1111)==0))
    {
        return "False";
    }
    my $count=0;
    my $inputs="$input";
    if(length($inputs)<4)
    {
        for(my $i=0;$i<=4-length($inputs);$i++)
        {
            $inputs="0".$inputs;
        }
    }
    my @array=(substr($inputs,0,1),substr($inputs,1,1),substr($inputs,2,1),substr($inputs,3,1));
    my @arrayA=&sortingA(\@array);
    my $numA=$arrayA[0].$arrayA[1].$arrayA[2].$arrayA[3];
    my @arrayD=&sortingD(\@array);
    my $numD=$arrayD[0].$arrayD[1].$arrayD[2].$arrayD[3];
    my $result;
    for($count=1;$count<8;$count++)
    {
        $result=int($numD)-int($numA);
        if($result==6174)
        {
            return $count;
            last;
        }
        $result="$result";
        if(length($result)<4)
        {
            for(my $i=0;$i<=4-length($result);$i++)
            {
                $result="0".$result;
            }
        }
        @array=(substr($result,0,1),substr($result,1,1),substr($result,2,1),substr($result,3,1));
        @arrayA=&sortingA(\@array);
        $numA=$arrayA[0].$arrayA[1].$arrayA[2].$arrayA[3];
        @arrayD=&sortingD(\@array);
        $numD=$arrayD[0].$arrayD[1].$arrayD[2].$arrayD[3];
    }
    return "False\n";
}

sub sortingA
{#오름차순 정렬 함수
    my @input=@{+shift};
    foreach my $i (0..$#input-1) 
    {
        foreach my $j (1..$#input-$i) 
        {
            if($input[$j-1]>=$input[$j])
            {
                ($input[$j-1],$input[$j]) = ($input[$j],$input[$j-1]);
            }
        }
    }
    return @input;
}

sub sortingD
{#내림차순 정렬 함수
    my @input=@{+shift};
    my $size=$#input;
    foreach my $i (0..$size-1) 
    {
        foreach my $j (1..$size-$i) 
        {
            if($input[$j-1]<=$input[$j])
            {
                ($input[$j-1],$input[$j]) = ($input[$j],$input[$j-1]);
            }
        }
    }
    return @input;
}

print(&kaprekar_number1(22222));
print(&kaprekar_number2(1));
print(&kaprekar_number3(9));
print(&kaprekar_constant(14));

숫자와 문자열을 오가면서 처리하는 방식.

정렬 구현참고 https://zetawiki.com/wiki/Perl_%EA%B1%B0%ED%92%88%EC%A0%95%EB%A0%AC_%EA%B5%AC%ED%98%84

C#

using System;
using System.Collections.Generic;
using System.Numerics;
using System.Linq;

namespace CD214
{
    class Program
    {
        static void Main()
        {
            var result = new Kaprekar();

            // 유형 1
            Console.WriteLine(result.IsKaprekarNumber(1));
            Console.WriteLine(result.IsKaprekarNumber(45));
            Console.WriteLine(result.IsKaprekarNumber(297));
            Console.WriteLine(result.IsKaprekarNumber(3213));

            // 유형 2
            Console.WriteLine(string.Join(", ", result.GetNdigitKaprekarNumbers(5)));

            // 유형 3
            Console.WriteLine(string.Join(", ", result.GetKaprekarNumbersBelow(10000)));

            // 카프리카 상수
            Console.WriteLine(result.CountKaprekarRoutines(4371));
            Console.WriteLine(result.CountKaprekarRoutines(21));
            Console.WriteLine(result.CountKaprekarRoutines(1));
            Console.WriteLine(result.CountKaprekarRoutines(1111));

            Console.ReadKey();
        }
    }

    class Kaprekar
    {
        // (유형1) 카프리카 수인지 판단
        public bool IsKaprekarNumber(BigInteger aNum)
        {
            string str = (aNum * aNum).ToString();
            if (str.Length % 2 == 1) { str = "0" + str; }

            int divideIdx = str.Length / 2;
            BigInteger former = BigInteger.Parse(str.Substring(0, divideIdx));
            BigInteger latter = BigInteger.Parse(str.Substring(divideIdx, divideIdx));
            if (latter == 0) { return false; }

            return aNum == former + latter ? true : false;
        }

        // (유형2) ndigit 자리수의 카프리카 수 반환
        public List<BigInteger> GetNdigitKaprekarNumbers(int ndigit)
        {
            var result = new List<BigInteger>();
            for (var i = (BigInteger)Math.Pow(10, ndigit - 1); i < (BigInteger)Math.Pow(10, ndigit); i++)
            {
                if (IsKaprekarNumber(i)) { result.Add(i); }
            }
            return result;
        }

        // (유형 3) 특정 수 이하의 카프리카 수 반환
        public List<BigInteger> GetKaprekarNumbersBelow(BigInteger aNum)
        {
            var result = new List<BigInteger>();
            for (var i = 1; i <= aNum; i++)
            {
                if (IsKaprekarNumber(i)) { result.Add(i); }
            }
            return result;
        }

        // 카프리카 상수
        public string CountKaprekarRoutines(int aNum)
        {
            if (aNum <= 0 || aNum > 9999) { return false.ToString(); }

            int count = 0;
            int KaprekarConstant = 6174;
            do
            {
                string str = aNum.ToString().PadLeft(4, '0');
                if (str.Distinct().Count() == 1) { return false.ToString(); }
                var sorted = str.OrderByDescending(c => char.GetNumericValue(c)).ToArray();
                int bigger = int.Parse(new string(sorted));
                Array.Reverse(sorted);
                int smaller = int.Parse(new string(sorted));
                aNum = bigger - smaller;
                count++;
            } while (aNum != KaprekarConstant);

            return count.ToString();
        }
    }
}

문제풀이

규칙이 비교적 간단하고 답이 정해져 있어서 알고리즘을 짜는데 어려움은 없었습니다. 그러나 예외상황에 대해 if문을 자주 적용하여 이부분을 최소화하는 방법을 알 수 있었으면 좋겠습니다.

1. 카프리카수

def kaprekar_number(num):
    Sqnum = str(num**2)
    lsn = len(str(Sqnum))
    dec = 0

    if num==1: #1 예외적용
        return True

    for ln in range(1,lsn):
        if int(Sqnum[ln:]) != 0 : #뒤에 0인 숫자 제거
            Kaf = int(Sqnum[:ln])+int(Sqnum[ln:]) #두 부분으로 나눠서 더하기
            if Kaf==num :
                return True
    return False

2. 카프리카 상수

def kaprekar_constant(num):
    numLen = len(str(num))

    if numLen < 4:
        num = str(num)+'0'*(4-numLen) #적은 자릿수 맞춤

    if numLen > 4:
        return print('Please, input a 4-digit number') #4자리수 이상 입력안내

    KafC = int(''.join(sorted(str(num),reverse=True)))-int(''.join(sorted(str(num))))

    if KafC == 0:
        return False #같은 숫자로 구성된 값 False

    rutin = 1

    while KafC != 6174:

        if len(str(KafC)) < 4:
            KafC = str(KafC)+'0'*(4-len(str(KafC))) #1112와 같이 3자리 수가 되는 경우 오류 방지

        KafC = int(''.join(sorted(str(KafC),reverse=True)))-int(''.join(sorted(str(KafC))))
        rutin += 1

    return rutin

def kaprekar_number(num):
    if num <= 0:
        return False

    sqr = num**2
    sqr_str = str(sqr)
    for i in range(0, len(sqr_str)-1):
        a = int(sqr_str[:i+1])
        b = int(sqr_str[i+1:])
        if a != 0 and b != 0 and num == a + b:
            return True

    return num == 1

def kaprekar_constant(num):
    if num <= 0:
        return False

    count = 0
    while num != 6174:
        num_str = str(num)
        sz = len(num_str)
        if sz > 4:
            return False
        elif sz < 4:
            num_str = '0' * (4 - sz) + num_str

        low = ''.join(sorted(num_str))
        high = low[::-1]
        if low == high:
            return False

        num = int(high) - int(low)
        count += 1

    return count

def kaprekar_number_digit_all(num):
    digit = len(str(num))
    return [i for i in range(10**(digit-1), (10**digit)-1) if kaprekar_number(i)]


def kaprekar_number_low_all(num):
    return [i for i in range(1, num) if kaprekar_number(i)]

#카프리카수_유형1
def kaprekar_number(n):
    mul=str(n*n)
    l=len(mul)//2
    if l<1:
        #한자리 수인 경우
        if int(mul)+0==n:
            return True
    else :
        if int(mul[0:l])+int(mul[l:])==n:
            return True
    return False

#카프리카수 유형2
def kaprekar_number2(n):
    result=[]
    for i in range(pow(10,n-1),pow(10,n)):
        if kaprekar_number(i) :
            result.append(i)
    return result

#카프리카수 유형3
def kaprekar_number3(n):
    result=[]
    for i in range(1,n+1):
        if kaprekar_number(i):
            result.append(i)
    return result

#카프리카 상수
def karprekar_constant(n):
    num=list("0"*(4-len(str(n)))+str(n))
    num.sort(reverse=True)
    n_desc=int(''.join(num))
    num.sort()
    n_asc=int(''.join(num))
    return n_desc-n_asc

def main(n):
    cnt=1
    num=n
    while cnt<=7:
        num=karprekar_constant(num) 
        if num==6174:
            return cnt
        cnt+=1
    return False

유형 1

#kaprekar

def kaptrue(n):
    a=str(n**2)
    test=0
    for i in range(len(a)):
        if i==0:
            if n==n**2:
                print("""
True. %d**2=%d,
%d=%d"""%(n,n**2,n,n))
                test=1
                break
        else:
            a1=a[:i]
            a2=a[i:]
            if int(a1)+int(a2)==n:
                print("""True.
%d**2=%d.
%s+%s=%d"""%(n,n**2,a1,a2,n))
                test=1
                break
    if test==0: print("False")

while True:
    n=int(input("Input a positive integer: "))
    kaptrue(n)

유형3

def kaptrue(n):
    a=str(n**2)
    test=0
    for i in range(len(a)):
        if i==0:
            if n==n**2:
                test=1
                return True
        else:
            a1=a[:i]
            a2=a[i:]
            if int(a1)+int(a2)==n:
                test=1
                return True
    if test==0: return False

def kaprekar(n):
    kaprekar=[]
    for i in range(1,n+1):
        if kaptrue(i):
            kaprekar.append(i)
    return kaprekar

while True:
    n=int(input("Input a positive integer: "))
    print(kaprekar(n))

a = int(input())
b = int(input())
c = int(input())

#1
def is_Kaprekar(n):
    num = str(n**2)

    for i in range(len(num)):
        if i == 0:
            if int(num) == n:
                return 'True'
        elif int(num[:i]) + int(num[i:]) == n:
            return 'True'

    return 'False'


#2
def same_position_Kaprekar(n):
    pos = len(str(n))
    result = []
    for i in range(10 ** (pos-1), 10 ** pos):
        if is_Kaprekar(i) == 'True':
            result.append(i)
    return result


#3
def under_Kaprekar(n):
    result = []
    for i in range(1, n + 1):
        if is_Kaprekar(i) == 'True':
            result.append(i)
    return result



print(is_Kaprekar(a))
print(*same_position_Kaprekar(b), end = ' ')
print()
print(*under_Kaprekar(c), end = ' ')

# 카프리카 수인지 아닌지 판별하기
# 카프리카 수
def kaprica(n):
  sq = n ** 2
  l_sq = len(str(sq))
  if n == 1:
    return True

  for i in range(1,l_sq):
      if int(str(sq)[i:]) > 0:
        if (int(str(sq)[:i]) + int(str(sq)[i:])) == n:


          return True

  return False

# 자리수 n에 해당하는 모든 카프리수 구하기
def kaprica_decimal(n):
  for t in range(10 ** (n-1), 10 ** (n)):
    kaprica(t)

# n 이하 숫자 중 카프리카수 구하기
def kaprica_less(n):
  for k in range(1, n+1):
    if kaprica(k):
      print(k)


# 카프리카 루틴
def kaprica_routine(n):
  assert len(set(str(n))) > 1, 'set(str(n)) must be greather than 2'
  num = 0
  for i in range(n):
    if len(str(n)) != 4:
      n = int(str(n).ljust(4, "0"))
    str_max = int("".join(sorted(str(n), reverse=True)))
    str_min = int("".join(sorted(str(n))))

    num = str_max - str_min
    n = num

    if num == 6174:
      return i+1

#파프리카수 :어떤수의 제곱수를 둘로 나누어 더했을때 원래 수가 되는 것
def cafDIS(orinum):
    or2=orinum**2
    cr2=str(or2)
    if len(cr2)==1:
        cr2='0'+cr2
    lg=False
    for i in range(len(cr2)-1):
        if int(cr2[0:i+1])+int(cr2[i+1:len(cr2)]) == orinum:
            lg=True
            break
    return lg

print('파프리카수 판별')
print(cafDIS(1))
print(cafDIS(9))
print(cafDIS(45))
print(cafDIS(3213))

print('자릿수가 그수인 파프리카수')
nc=int(input('자릿수 입력'))
for i in range(10**(nc-1),10**nc):
    if cafDIS(i):
        print(i)

print('그 숫자 이하인 파프리카수')
nc=int(input('숫자입력'))
for i in range(nc+1):
    if cafDIS(i):
        print(i)

julia

function isKaprekarNumber(n::Integer)
    tmp = n^2
    len = length("$tmp")

    for i in 1:length("$tmp")
        d,r = divrem(tmp,10^i)
        (r != 0 && d + r == n) && return true
    end

    return false
end

function KaprekarConst(n::Integer,i::Int=0)
    n == 6174 && return i
    n == 0 && i > 7 && return false

    tmp = sort(split("$n",""))
    length(Set(tmp)) == 1 && return false

    return KaprekarConst(
        parse(Int, rpad(join(tmp[end:-1:1]),4,"0")) - parse(Int, join(tmp)),
        i+1
    )
end

let
    @show isKaprekarNumber(297)
    @show KaprekarConst(4371)
end

def kaprekar_number(n):
    string = str(n**2)
    if n**2 == n:
        return True
    else:
        for i in range(1,len(string)-1):
            if int(string[:i])+int(string[i:]) == n:
                return True
    return False



def kaprekar_constant(n):
    if n < 10 or n > 9999:
        return False

    step = 1

    while step < 8:
        numlist = []
        temp = ""
        if len(str(n)) < 4:
            temp = str(n) + "0"*(4-len(str(n)))
            numlist = list(temp)
        else:
            numlist = list(str(n))

        if int("".join(sorted(numlist,reverse=True)))-int("".join(sorted(numlist))) == 6174:
            return step
        else:
            n = int("".join(sorted(numlist,reverse=True)))-int("".join(sorted(numlist)))
            step += 1
    return False

입력된 숫자 이하의 카프리카 수를 모두 출력하는 코드입니다.

using System;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            int a, b;

            a = int.Parse(Console.ReadLine());

            while(a > 0)
            {
                b = a * a;
                //자릿수 추출

                int divide = 10;
                int i = 1;

                while (true)
                {
                    if (b >= divide)
                    {
                        i++;
                        b = b / divide;
                    }
                    else
                        break;
                }

                //앞자리 뒷자리
                int front, back; 

                //자릿수가 짝수 일때
                if (i % 2 == 0)
                {
                    divide = 10;
                    i /= 2;

                    for (int j = 1; j < i; j++)
                    {
                        divide *= 10;
                    }

                    back = (a * a) % divide;
                    front = (a * a) / divide;
                    //Console.WriteLine("{0}, {1}", front, back);

                    if (front + back == a)
                        Console.WriteLine("카프리카 수 : {0}", a);
                }
                a--;
            }
        }
    }
}

def num_splitter(n):
    num_string = str(n)
    splitted_string1 = ""
    splitted_string2 = ""
    num_list = list()
    if len(num_string)>=2:
        for x in range(1,len(num_string)):
            splitted_string1 = num_string[:x]
            splitted_string2 = num_string[x:]
            if int(splitted_string1)!=0 and int(splitted_string2)!=0:
                num_list.append([int(splitted_string1), int(splitted_string2)])
        return num_list
    else:
        num_list.append([n])
        return num_list


def is_kaprekar(n): #어떤 수를 입력 받고 그 수가 카프리카 수인지 아닌지
    n_squared = n**2
    decider = num_splitter(n_squared)
    boolean_list = list()
    for x in range(len(decider)):
        if sum(decider[x])==n:
            boolean_list.append('T')
        else:
            continue
    if 'T' in boolean_list:
        return True
    else:
        return False


def all_kaprekar(n): # 어떤 수를 입력 받고 자릿수가 그 수인 모든 카프리카 수
    for i in range(10**(n-1),10**n):
        a=is_kaprekar(i)
        if a==True:
            print("{}".format(i))

def less_than_kaprekar(n): # 어떤 수를 입력 받고 그 수 이하의 모든 카프리카 수
    for i in range(1,n+1):
        a = is_kaprekar(i)
        if a==True:
            print("{}".format(i))

def kaprekar_number(n):
    lis = []
    for num in range(1, n+1):
        sq_str = str(num**2).zfill(2)
        for i in range(0, len(sq_str) - 1):
            f, s = int(sq_str[:i + 1]), int(sq_str[i + 1:])
            if num == f + s:
                if s != 0:
                    lis.append(num)
    return lis

def iskaprekar_number(num):
    if num <= 0:
        return False

    sq_str = str(num**2).zfill(2)
    for i in range(0, len(sq_str)-1):
        f, s = int(sq_str[:i+1]), int(sq_str[i+1:])
        if num == f + s:
            if s != 0:
                return True
    return False

def kaprekar_constant(num, l=1):
    if l == 8: return False

    n_lis = list(str(num))

    if n_lis.count(n_lis[0]) == len(n_lis): return False

    a = ''.join(sorted(n_lis))
    b = ''.join(reversed(a))
    c = str(int(b)-int(a)).zfill(len(b))

    print(a, b, c)

    if int(c) == 6174: return l
    else: return kaprekar_constant(c, l+1)

상수에서 21은 어떻게 True가 나오는거지..

카프리카 수 1, 2, 3

def kaprekar_number_1(n):
    sqr = n * n
    divisor = 1
    while divisor <= sqr * 10:
        x, y = divmod(sqr, divisor)
        if y > 0 and x + y == n:
            return True

        divisor *= 10

    return False


def kaprekar_number_2(dig):
    return [x for x in range(10**(dig-1), 10**dig) if kaprekar_number_1(x)]


def kaprekar_number_3(n):
    return [x for x in range(1, n+1) if kaprekar_number_1(x)]

카프리카 상수(재귀)

무한 재귀를 막을 필요가 없어서 간단합니다.

def kaprekar_constant(n):
    s = str(n).zfill(4)

    if s == '6174':
        return 0

    if len(set(s)) == 1:
        print(False)
        exit()

    inc, dec = ''.join(sorted(s)), ''.join(sorted(s, reverse=True))
    return 1 + kaprekar_constant(int(dec) - int(inc))

카프리카 수, 유형 1번과 3번이 동시에 나오게 했습니다.

public class 카프리카수 {

    public static void main(String[] args) {

        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(1);

        for(int i=2; i<=n; i++) {
            StringBuffer bf1 = new StringBuffer();
            StringBuffer bf2 = new StringBuffer();
            String[] str = Integer.toString(i*i).split("");
            int a = str.length/2;
            if(str.length%2==0) {
                for(int j=0; j<a; j++) {
                    bf1.append(str[j]);
                    bf2.append(str[a+j]);
                }
            }
            else {
                for(int j=0; j<a; j++) {
                    bf1.append(str[j]);
                    bf2.append(str[j+a]);
                }
                bf2.append(str[str.length-1]);
            }
            try {
                if(Integer.parseInt(bf1.toString())+Integer.parseInt(bf2.toString())==i) {
                    list.add(i);
                }
            }catch(NumberFormatException e) {

            } catch(Exception e) {

            }
        }
        System.out.println(list);
        int count = 0;
        for(int i=0; i<list.size(); i++) {
            if(list.get(i)==n) {
                System.out.println(true);
                count++;
                break;
            }
        }
        if(count==0) {
            System.out.println(false);
        }
    }
}

카프리카 상수

public class 카프리카상수 {

    public static void main(String[] args) {

        Scanner scan = new Scanner(System.in);
        String[] str = scan.nextLine().split("");
        int[] arr = Arrays.stream(str).mapToInt(Integer::parseInt).toArray();

        ArrayList<Integer> list = new ArrayList<Integer>();
        for(int i=0; i<arr.length; i++) {
            list.add(arr[i]);
        }
        if(list.size()<4) {
            int k = list.size();
            for(int i=0; i<4-k;i++) {
                list.add(0);
            }
        }
        int count = 0;
        boolean check = true;
        for(int i=0; i<7; i++) {
            count++;
            Collections.sort(list);
            String s1 = list.stream().map(Object::toString).collect(Collectors.joining(""));
            Collections.reverse(list);
            String s2 = list.stream().map(Object::toString).collect(Collectors.joining(""));
            int a = Integer.parseInt(s2)-Integer.parseInt(s1);
            if(a==6174) {
                System.out.println(count);
                check = false;
                break;
            }
            list.clear();
            String[] str2 = Integer.toString(a).split("");
            for(int j=0; j<str2.length; j++) {
                list.add(Integer.parseInt(str2[j]));
            }
        }
        if(check) {
            System.out.println(false);
        }
    }
}

찾아보니 숫자 하나로만 이루어지지 않은 4자리 숫자라면 모든 수는 카프리카 상수 6174에 도달하게 된다네요.. 저는 그냥 풀었습니다...그래서 코드가 보기 불편할 것 같아요.. 리스트sort와 reverse를 이용해서 reverse(내림차순)-sort(오름차순)을 하고 이 값을 다시 list에 저장하는 방법으로 하였습니다. 그리고 입력값이 4자리가 아니면 list에 0을 부족한 만큼 추가하였습니다.

#유형1(카프리카 수인지 아닌지 확인)
n=input("양의 정수 n을 입력하십시오: ")
def KN(n):
    num=int(n)**2
    if int(n)==1: #1도 카프리카 수
        return True
    elif any([int(str(num)[:i+1])+int(str(num)[i+1:])==int(n) for i in range(len(str(num))-1) if int(str(num)[i+1:])!=0]): #제곱해서 두 부분으로 나눈 수 중 하나가 0이 아니면서 두 부분의 합이 원래 수가 되는 경우가 하나라도 있으면 True
        return True
    else:
        return False
print(KN(n))

#유형2(자릿수를 입력했을 때 그 자릿수를 가지는 카프리카 수 출력)
pn=int(input("자리수를 입력해주십시오: "))
def KPN(pn):
    return list(num for num in range(10**(pn-1),10**pn) if KN(num)) 
print(KPN(pn))

#유형3(어떤 수 이하의 모든 카프리카 수 출력)
un=int(input("양의 정수 n을 입력하십시오: "))
def KPUN(un):
    return list(num for num in range(1,un+1) if KN(num))  
print(KPUN(un))

#유형4(몇 번 이내에 카프리카 상수(6174)가 완성되었는가?)
fn=input("4자리 숫자를 입력하십시오: ")
def KC(fn):
    if len(fn)!=4 or len(set(str(fn)))==1:
        return False
    t=0
    while fn!=6174: #일단 들어가는 fn이 문자열이니 6174를 입력해도 while루프를 돌아 t=1로 나온다.(6174의 경우 1번 실행해도 6174가 된다.)
        lst=sorted(list(map(str,str(fn))))
        fn=int("".join(lst)[::-1])-int("".join(lst))
        t+=1
    return t
print(KC(fn))

카프리카 상수에서 6174는 카프리카 루틴을 1번 돌아도 6174니까 1을 출력하게 했습니다.

def kaprekar_number(x):
    for i in range (1,x+1):
        for j in range (0,len(str(i**2))):
            a=i**2//10**j
            b=i**2%10**j
            if a+b==i:
                if a>0 and b>0:
                    print (i,'...',i,'^2','=',i**2,'=>',a,'+',b,'=',a+b)

kaprekar_number(int(input('Input a number....')))

def kaprekar_number(N):
    M = N**2
    if len(str(M)) == 1:
        if M == N:return True
        elif M != N:return False
    elif len(str(M)) % 2 == 0:
        h = int(str(M)[:int(len(str(M))/2)]) + int(str(M)[int(len(str(M))/2):])
        if h == N:return True
        elif h != N:return False
    elif len(str(M)) % 2 == 1:
        h1 = int(str(M)[:int(len(str(M))/2)]) + int(str(M)[int(len(str(M))/2):])
        h2 = int(str(M)[:int(len(str(M))/2)+1]) + int(str(M)[int(len(str(M))/2)+1:])
        if h1 == N or h2 == N:return True
        elif h1 != N and h2 != N:return False
def kaprekar_constant(N):
    p,line = 0,0
    if len(str(N)) != 4:

        p = 4 - len(str(N))
    while True:
        line += 1
        Nstr,Mstr = "",""
        Nlist,Mlist = list(str(N)),list(str(N))
        truefalsecheck = 0
        check = int(str(N)[0])
        for j in range(p):
            Nlist.append('0')
            Mlist.append('0')
        p = 0
        for i in range(len(Nlist)):
            Nlist[i] = int(Nlist[i])
        for i in range(len(str(N))):
            if int(str(N)[i]) == check:
                truefalsecheck += 1
        if truefalsecheck == len(str(N)):return False
        elif truefalsecheck != len(str(N)):
            Nlist.sort()
            Mlist.sort()
            Mlist.reverse()             
            for j in range(len(Nlist)):
                Nstr += str(Nlist[j])
                Mstr += str(Mlist[j])
            if int(Mstr) - int(Nstr) == 6174:return line
            elif int(Mstr) - int(Nstr) != 6174:
                N = int(Mstr)-int(Nstr)
print(kaprekar_number(int(input())))
print(kaprekar_constant(int(input())))

def kaprekar_number(k):
    for num in k:
        kn = str(num**2)
        len_num, len_kn = len(str(num)), len(kn)
        if len_kn < 2 and (0+num**2) == num:
            print('True')
        elif (len_kn == 2 and len_num == 1) and (int(kn[:1])+int(kn[1:]) == num):
            print('True')
        elif len_kn > 2:
            for i in range(len_num, 0, -1):
                if int(kn[:len_num]) + int(kn[len_num:]) == num:
                    print('True')
        else: print('False')

if __name__ == '__main__':
    k = [1, 9, 45, 55, 99, 297, 703, 999, 2223, 2728,
         4879, 4950, 5050, 5292, 7272, 7777, 9999, 17344,
         22222, 38962, 77778, 82656, 95121, 99999, 142857,
         148149, 181819, 187110, 208495, 318682, 329967,
         351352, 356643, 390313, 461539, 466830, 499500,
         500500, 533170] # 모두 다 카프리카 수
    kaprekar_number(k)

class kaprekar() :

    def isKaprekar(self, n1) :
        nSq = str(n1**2)
        for i in range(0, len(nSq)-1) :
            if (int(nSq[:i+1])+int(nSq[i+1:])) == n1 : return True
        return False

    def searchKaprekarByDigit(self, n2) :
        result = []
        for d in range(10**(n2-1), 10**(n2)) :
            if self.isKaprekar(d) == True : result.append(d)
        return result

    def searchKaprekarUnder(self, n3) :
        result = []
        for u in range(1, n3+1) :
            if self.isKaprekar(u) == True : result.append(u)
        return result

if __name__ == "__main__" :
    a = kaprekar()
    print(a.isKaprekar(45))
    print(a.isKaprekar(99))
    print(a.isKaprekar(4879))
    print(a.isKaprekar(533160))
    print(a.searchKaprekarByDigit(4))
    print(a.searchKaprekarUnder(461539))

for를 이용해서 하나하나 확인하는 만큼 자릿수가 늘어나면 시간이 오래걸리네요.

결과

True
True
True
False
[1000, 2223, 2728, 4879, 4950, 5050, 5292, 7272, 7777, 9999]
[9, 10, 45, 55, 99, 100, 297, 703, 999, 1000, 2223, 2728, 4879, 4950, 5050, 5292, 7272, 7777, 9999, 10000, 17344, 22222, 38962, 77778, 82656, 95121, 99999, 100000, 142857, 148149, 181819, 187110, 208495, 318682, 329967, 351352, 356643, 390313, 461539]

카프리카 수 인지 확인하는 함수

def kaprekar_number(number): square = number ** 2 str_square = str(square) if square > 9: for x in range(1, len(str_square) - 1): if int(str_square[:x]) + int(str_square[x:]) == number: return 'True' return 'False' else: if square == number: return 'True' return 'False'

입력받은 수를 작은순서대로 정렬해주는 함수

def make_sorted_number(number): temp = '' for x in sorted(str(number)): temp += x while len(temp) < 4: temp += '0' return int(temp)

입력받은 수를 큰 순서로 정렬해주는 함수

def make_reversed_number(number): temp = '' for x in reversed(sorted(str(number))): temp += x while len(temp) < 4: temp = '0' + temp return int(temp)

카프리카 상수 확인하는 함수

def kaprekar_constant(number): count = 0 while make_reversed_number(number) - make_sorted_number(number) != 6174: if number > 1000 and number % 1111 == 0: return "False" elif 1000 > number > 100 and number % 111 == 0: return "False" elif 10 < number < 100 and number % 11 == 0: return "False" else: number = abs(make_reversed_number(number) - make_sorted_number(number)) count += 1 return count + 1```{.python}

카프리카 수 인지 확인하는 함수

def kaprekar_number(number): square = number ** 2 str_square = str(square) if square > 9: for x in range(1, len(str_square) - 1): if int(str_square[:x]) + int(str_square[x:]) == number: return 'True' return 'False' else: if square == number: return 'True' return 'False'

입력받은 수를 작은순서대로 정렬해주는 함수

def make_sorted_number(number): temp = '' for x in sorted(str(number)): temp += x while len(temp) < 4: temp += '0' return int(temp)

입력받은 수를 큰 순서로 정렬해주는 함수

def make_reversed_number(number): temp = '' for x in reversed(sorted(str(number))): temp += x while len(temp) < 4: temp = '0' + temp return int(temp)

카프리카 상수 확인하는 함수

def kaprekar_constant(number): count = 0 while make_reversed_number(number) - make_sorted_number(number) != 6174: if number > 1000 and number % 1111 == 0: return "False" elif 1000 > number > 100 and number % 111 == 0: return "False" elif 10 < number < 100 and number % 11 == 0: return "False" else: number = abs(make_reversed_number(number) - make_sorted_number(number)) count += 1 return count + 1 ```

def kn(a1):
    a = a1**2
    b = len(str(a))
    c = str(a)
    if b == 1:
        if a1 == a:
            return True
        else:
            return False 
    for i in range(1,b):
        d = c[0:i]
        e = c[i:b]
        f = int(d)+int(e)
        if f == a1:
            return(True)
    return(False)

print(kn(1))
print(kn(45))
print(kn(297))
print(kn(3213))


def kc(a):
    count = 0
    a = str(a)
    a1 = a[0:2]
    a2 = a[2:4]
    if a1 == a2:
        print(False)
        return
    while True:
        a += '0'*(4-len(a))
        a = ','.join(a)
        a = a.split(',')
        a.sort()
        sortd = a[:]
        a.reverse()
        reverd = a[:]
        sortd = ''.join(sortd)
        reverd = ''.join(reverd)
        count += 1
        minus = int(reverd)-int(sortd)
        if 6174 != minus:
            a = str(minus)
            continue
        print(f'반복 횟수는 {count} 입니다')
        break


kc(4371)
kc(21)
kc(1)
kc(1111)

#카프리카 수
def kaprekar_number(data):
    value = str(data**2)
    sum = 0
    if len(value) % 2 != 0:
        value = '0'+value  
    sum = int(value[:len(value)//2]) + int(value[len(value)//2:])
    if data == sum:
        return True
    else:
        return False
    #print(sum)

print(kaprekar_number(45))
print(kaprekar_number(297))
print(kaprekar_number(1))
print(kaprekar_number(3213))
print(kaprekar_number(5))

# 입력한수 이하 카프리카 수

input_data = int(input("수을 입력 하세요 : "))

value = list(i for i in range(1,input_data+1) if kaprekar_number(i))
print(value)


#카프리카 상수
def kaprekar_const(data):
    for i in range(1,8):
        value = str(data)
        value1 = (''.join(sorted(value)))
        value2 = (''.join(reversed(sorted(value))))
        data = int(value2)-int(value1)
        if data == 6174 and i <=7:
            print(i, data)
            return True


print(kaprekar_const(1342))

# 카프리카 수

import re


def kprekar_number(a):
    a_pow = str(a**2)
    if len(a_pow)==1:
        if a ==1 :
            return True
        else:
            return False
    else:
        for k in range(1,len(a_pow)):
            if int(a_pow[:k])+int(a_pow[k:])==a and int(a_pow[k:])>0:
                return True
                break
            if k==len(a_pow)-1:
                return False
                break

print(kprekar_number(1))
print(kprekar_number(45))
print(kprekar_number(297))
print(kprekar_number(3213))

#카프리카 상수


def convert (a):
    a = str(a)
    if len(a) ==4:
        return a
    else:
        while len(a)<4:
            a= '0'+a
        return a

def fun1 (a):
    a = convert(a)
    sort_str ="".join(sorted(list(str(a))))
    rev_str = "".join(reversed(sorted(list(str(a)))))
    return int(rev_str)-int(sort_str)

def kaprekar_constant (a):
    n= a
    for i in range(1,9):
        if i==8:
            return False
            break       
        if fun1(n) == 6174:
            return i
            break
        else:
            n = fun1(n)

print(kaprekar_constant(4371))
print(kaprekar_constant(21))
print(kaprekar_constant(1))
print(kaprekar_constant(1111))

카프리카 수

package org.javaturotials.ex;
import java.util.*;
import java.util.stream.Collectors;

public class test {
    public static void main(String[] args) {
        Scanner sc =new Scanner(System.in);
        int input = sc.nextInt();
        for(int z=1; z<=input; z++) {
        int num = z;
        String str = String.valueOf((int)Math.pow(num, 2));
        String[] arr = str.split("");
        String at = "";
        String bt = "";
        for(int i=0; i<arr.length; i++) {
            if(i+1<=arr.length/2) {
                at+=arr[i];
            }
            if(i+1>arr.length/2){
                bt+=arr[i];
            }
            }
        int result=0;
        if(arr.length==1) {result=num;}
        else{
            result = Integer.valueOf(at)+Integer.valueOf(bt);
        }

        if(result == num) {
            System.out.println(z);
        }
        }
    }
    }

카프리카 상수

package org.javaturotials.ex;
import java.lang.reflect.Array;
import java.util.*;
import java.util.stream.Collectors;

import javax.lang.model.type.ArrayType;

public class test {
    public static void main(String[] args) {
        Scanner sc =new Scanner(System.in);
        int count=0;
        String result="";
        String ss = "6174";
        String num =sc.next();
        int fx=0;
        if(num.length()==4) {
            while(true) {
            String[] arr = num.split("");
            int[] irr = new int[arr.length];
            Integer[] err = new Integer[arr.length];
            for(int i=0; i<arr.length; i++) {
                irr[i] = Integer.valueOf(arr[i]);
                err[i] = Integer.valueOf(arr[i]);
                for(int j=0; j<arr.length; j++) {
                    if(i!=j) {
                    if(arr[i]!=arr[j]) {
                        fx++;}
                    }
                }
            }
            if(fx==3) {break;}
            Arrays.sort(irr);
            Arrays.sort(err, Collections.reverseOrder());
            String at = "";
            String bt = "";
            for(int k=0; k<irr.length; k++) {
                at+=irr[k];
                bt+=err[k];
            }

            int sum = (int)Math.abs(Integer.valueOf(bt) - Integer.valueOf(at));
            String sums = String.valueOf(sum);
            if(sums.length()<4) {
                sums = String.valueOf(0*(4-sums.length())) + sums;
            }
            count++;
            if(sums.equals(ss)==true) {break;}
            num=sums;
        }
        }
        if(fx==0) System.out.println(false);
        else System.out.println(count);
    }
    }