Until high school, I was good at math and loved it. However, when I entered a liberal arts university, I lived a life far from mathematics. And it's been 10 years since I became a member of society ... I'm a system engineer who has developed only the left brain, who has forgotten both calculus and trigonometric functions. Recently, thanks to YouTube, I have gradually increased my chances to come into contact with mathematics. It is a good time to solve entrance exam questions and feel free to touch the unknown world of university mathematics.

Today, about the integer "** Kaprekar number **" with interesting properties introduced in the following video We will verify using Ruby.

- Original material "University Mathematics / Physics" Learned at Preparatory School Subtract the minimum from the maximum and restore![Kaprekar number]

The Kaprekar Number is an integer defined by one of the following:

- When squared and the sum is divided into the front part and the back part, it is equal to the original value.
- The value equal to the original value when the difference between the maximum and minimum digits is taken by rearranging the digits.

Source: Wikipedia

This time, we will look at Definition 2.

Take ** 495 ** as an example.

The maximum number that can be made by rearranging 495 is 954, and the minimum number is 459. 954 --459 = 495, so it's now equal to the original number ** 495 **! it's interesting!

Such numbers are called Kaprekar numbers. The number of digits we usually see is only countable.

Now let's get into the main Ruby program.

`kaprekar.rb`

```
num = 627
#Store in array
arr = num.to_s.split('').map!(&:to_i)
p arr # => [6, 2, 7]
#Sort to make maximum and minimum
max = arr.sort{ |a, b| a <=> b }.join('').to_i
min = arr.sort{ |a, b| b <=> a }.join('').to_i
p max # => 762
p min # => 267
#maximum-Determining if the minimum is the same as the original number
diff = max - min
p diff == num # => false
```

Now, by rewriting `num`

, you can judge ** only one arbitrary integer **.

From here, let's use iterative processing to find out if there is a Kaprekar number within ** a particular range **.

`kaprekar.rb`

```
result = []
num = 1
final = 1_000_000
while num < final do
arr = num.to_s.split('').map!(&:to_i)
min = arr.sort{ |a, b| a <=> b }.join('').to_i
max = arr.sort{ |a, b| b <=> a }.join('').to_i
diff = max - min
if diff == num
result.push("【#{num}】 #{max} - #{min} = #{diff}")
end
num += 1
end
if result.empty?
result.push("Not applicable")
end
puts result
```

(For readability, I dare not use the ternary operator)

`terminal`

```
【495】 954 - 459 = 495
【6174】 7641 - 1467 = 6174
【549945】 995544 - 445599 = 549945
【631764】 766431 - 134667 = 631764
```

In the above example, when I tried using up to 6 digit integers, I found 4 Kaprekar numbers. It is also strange that it does not exist in 5 digits!

It depends on the specifications of the PC, but it will take a long time to process it repeatedly 1 million times.

Look at the number 495 introduced at the beginning You have a mathematical sense when you immediately come up with 495 = 99 × 5. Yes, all Kaprekar numbers are ** multiples ** of 9.

So even if you don't do it 1 million times, you can reduce the processing even more by verifying only multiples of 9.

If you have a better way to write it, let us know in the comments!

** (Added on 2020/06/29) ** I received a comment immediately and posted the improved version in the comment section!

Recommended Posts