カプレカ数

kaprekar_number.cpp

#include <iostream>
#include <algorithm>
#include <cmath>
#include <ctime>
#include <cstdio>

#define SIZE_OF_ARRAY(array) (sizeof(array)/sizeof(array[0]))

long long Stoll(std::string s) {
    if(s.empty()) {
        return 0;
    } else {
        return std::stoll(s);
    }
}

long long ArrayToLongLong(long long array[], int size) {
    long long ret = 0;
    int digit = size - 1;
    for(int i = 0; i < size; i++) {
        int pow = 1;
        for(int j = 0; j < digit; j++) {
            pow *= 10;
        }
        ret += pow * array[i];
        digit--;
    }
    return ret;
}

bool IsKaprekarNumber1(long long n) {
    std::string s = std::to_string(n * n);
    long long firstHalf  = Stoll(s.substr(0, s.length() / 2));
    long long latterHalf = Stoll(s.substr(s.length() / 2));

    return n == (firstHalf + latterHalf);
}

bool IsKaprekarNumber2(long long n) {
    long long array[std::to_string(n).length()];
    long long c = n;
    int i = 0;
    while(c > 0) {
        array[i] = c % 10;
        c /= 10;
        i++;
    }

    // min
    std::sort(array, array + SIZE_OF_ARRAY(array));
    long long min = ArrayToLongLong(array, SIZE_OF_ARRAY(array));

    // max
    std::sort(array, array + SIZE_OF_ARRAY(array), std::greater<long>());
    long long max = ArrayToLongLong(array, SIZE_OF_ARRAY(array));

    return n == (max - min);
}

int main(void) {
    std::cout << "--------------------" << std::endl;
    std::cout << "カプレカ数 定義1" << std::endl;
    for(long long i = 1; i <= 100000; i++) {
        if(IsKaprekarNumber1(i)) {
            std::cout << i << std::endl;
        }
    }

    time_t start = time(NULL);
    std::cout << "--------------------" << std::endl;
    std::cout << "カプレカ数 定義2" << std::endl;
    for(long long i = 0; i <= 100000000; i++) {
        if(i % 9 != 0) {
            continue;
        }

        if(IsKaprekarNumber2(i)) {
            std::cout << i << std::endl;
        }
    }
    time_t end = time(NULL);
    printf("処理時間(秒): %ld\n", end - start);
    std::cout << "--------------------" << std::endl;

    return 0;
}

kaprekar_number.go

package main

import (
	"fmt"
	"sort"
	"strconv"
	"strings"
	"sync"
	"time"
)

// カプレカ数（定義1）かどうか
func isKaprekarNumber1(num int) bool {
	s := strconv.Itoa(num * num)
	firstHalf, ferr := strconv.Atoi(s[:len(s)/2])
	if ferr != nil {
		firstHalf = 0
	}

	latterHalf, lerr := strconv.Atoi(s[len(s)/2:])
	if lerr != nil {
		latterHalf = 0
	}

	return num == (firstHalf + latterHalf)
}

// カプレカ数（定義2）かどうか
func isKaprekarNumber2(num int) bool {
	numStr := strconv.Itoa(num)
	length := len(numStr)
	chars := make([]string, length)
	for i := 0; i < length; i++ {
		chars[i] = string(numStr[i])
	}

	// min
	sort.Strings(chars)
	min, _ := strconv.Atoi(strings.Join(chars, ""))

	// max
	maxChars := make([]string, length)
	for i := 0; i < length; i++ {
		maxChars[i] = chars[length-(i+1)]
	}
	max, _ := strconv.Atoi(strings.Join(maxChars, ""))

	return num == (max - min)
}

func main() {
	fmt.Println("--------------------")
	fmt.Println("カプレカ数 定義1")
	for i := 1; i <= 100000; i++ {
		if isKaprekarNumber1(i) {
			fmt.Println(i)
		}
	}

	fmt.Println("--------------------")
	fmt.Println("カプレカ数 定義2")
	start := time.Now().Unix()

	var wg sync.WaitGroup
	for i := 0; i <= 100000000; i++ {
		if i%9 != 0 {
			continue
		}

		wg.Add(1)
		go func(num int) {
			if isKaprekarNumber2(num) {
				fmt.Println(num)
			}
			wg.Done()
		}(i)
	}
	wg.Wait()

	end := time.Now().Unix()
	fmt.Printf("%d秒\n", end-start)
	fmt.Println("--------------------")
}

kaprekar_number.rb

def kaprekar_number1?(n)
    s = (n ** 2).to_s
    
    first_half = s[0, s.size / 2].to_i
    latter_half = s[(s.size / 2)..-1].to_i
    
    n == (first_half + latter_half)
end

def kaprekar_number2?(n)
    min = n.to_s.chars.sort
    max = min.reverse
    min = min.join.to_i
    max = max.join.to_i
    
    n == (max - min)
end

puts '-' * 20
puts 'カプレカ数 定義1'
(1..100_000).select{|n| kaprekar_number1?(n)}.each do |n|
    puts n
end
puts '-' * 20

start_time = Time.now
puts 'カプレカ数 定義2'
(0..100_000_000).select{|n| n % 9 == 0}.select{|n| kaprekar_number2?(n)}.each do |n|
    puts n
end
end_time = Time.now
puts "time: #{end_time - start_time}"
puts '-' * 20

KaprekarNumber.java

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.LongStream;

public class KaprekarNumber {
    // カプレカ数（定義1）かどうか
    private static boolean isKaprekarNumber1(long n){
        var s = String.valueOf(n * n);
        var firstHalf = parseLong(s.substring(0, s.length() / 2));
        var latterHalf = parseLong(s.substring(s.length() / 2));

        return n == (firstHalf + latterHalf);
    }

    // カプレカ数（定義2）かどうか
    private static boolean isKaprekarNumber2(long n) {
        List<Character> chars = String.valueOf(n)
                                    .chars()
                                    .mapToObj(c -> (char)c)
                                    .collect(Collectors.toList());
        // min
        chars.sort(Comparator.naturalOrder());
        var min = parseLong(join(chars));

        // max
        Collections.reverse(chars);
        var max = parseLong(join(chars));

        return n == (max - min);
    }

    private static <T> String join(List<T> list) {
        var sb = new StringBuilder();
        for(T item : list) {
            sb.append(item);
        }
        return sb.toString();
    }

    private static long parseLong(String s) {
        if(s.isEmpty()) {
            return 0;
        } else {
            return Long.parseLong(s);
        }
    }

    public static void main(String[] args) {
        System.out.println("--------------------");
        System.out.println("カプレカ数 定義1");
        LongStream.rangeClosed(1, 100_000)
                .filter(KaprekarNumber::isKaprekarNumber1)
                .forEach(System.out::println);

        System.out.println("--------------------");
        System.out.println("カプレカ数 定義2");
        long start = System.nanoTime();
        LongStream.rangeClosed(0, 100_000_000)
                .parallel()
                .filter(n -> n % 9 == 0)
                .filter(KaprekarNumber::isKaprekarNumber2)
                .forEachOrdered(System.out::println);
        long end = System.nanoTime();

        System.out.printf("処理時間(ms): %d\n", (end - start) / 1_000_000);
        System.out.println("--------------------");
    }
}