This project explores the fascinating mathematical phenomenon known as the Kaprekar Constant (6174), discovered by Indian mathematician Dattatraya Ramchandra Kaprekar in 1949. Despite having no formal mathematical training, Kaprekar unveiled this mysterious number at a symposium, revealing a remarkable property that occurs when performing a simple iterative arithmetic operation on four-digit numbers.
The 6174 constant demonstrates that starting with any four-digit number (with at least two different digits), and repeatedly applying a specific subtraction process, you will always reach 6174 within a maximum of seven iterations. Once 6174 is reached, the process enters an infinite loop, always returning to 6174. This intriguing property has captivated mathematicians and number theory enthusiasts for decades.
Core Features:
The Kaprekar routine follows a simple yet elegant algorithm that transforms any four-digit number into the constant 6174 through iterative subtraction operations.
The algorithm operates through the following steps:
Example with 1000:
\[1000 \rightarrow 1000 - 0001 = 0999\] \[0999 \rightarrow 9990 - 0999 = 8991\] \[8991 \rightarrow 9981 - 1899 = 8082\] \[8082 \rightarrow 8820 - 0288 = 8532\] \[8532 \rightarrow 8532 - 2358 = 6174\]
and the loop continues indefinitely:
\[6174 \rightarrow 7641 - 1467 = 6174\]
The Kaprekar constant exhibits several remarkable properties:
Convergence Property:
For any four-digit number \(n\) with at least two different digits:
\[K(K(K(...K(n)...))) = 6174\]
where \(K\) represents the Kaprekar operation, and the maximum depth of iteration is 7.
Fixed Point Property:
Once 6174 is reached, the operation becomes idempotent:
\[K(6174) = 7641 - 1467 = 6174\]
Three-Digit Variant:
The Kaprekar constant for three-digit numbers is 495:
\[K_3(K_3(K_3(...K_3(n)...))) = 495\]
with a maximum of 6 iterations.
The Python implementation uses string manipulation for digit extraction and sorting, ensuring proper handling of leading zeros. The algorithm maintains a while loop that continues until the Kaprekar constant is reached, with each iteration displaying the operation performed.
For a four-digit number \(n\) with digits \(d_1, d_2, d_3, d_4\):
\[K(n) = \max(\text{permutations}(d_1, d_2, d_3, d_4)) - \min(\text{permutations}(d_1, d_2, d_3, d_4))\]
Given a number \(n\) with digits extracted into array \(D = [d_1, d_2, d_3, d_4]\):
\[n_{\text{desc}} = \sum_{i=1}^{4} d_i^{\text{sorted(desc)}} \cdot 10^{4-i}\]
\[n_{\text{asc}} = \sum_{i=1}^{4} d_i^{\text{sorted(asc)}} \cdot 10^{4-i}\]
The sequence of operations can be represented as:
\[n_0 = \text{initial number}\]
\[n_{k+1} = K(n_k) \quad \text{for } k = 0, 1, 2, ...\]
Convergence occurs when:
\[\exists m \leq 7 : n_m = 6174\]
The convergence to 6174 is guaranteed by the following properties:
requirements.txt
# No external dependencies required
# Python 3.6+ standard library only# Clone the repository
git clone https://github.com/yourusername/6174-Kaprekar-Constant-with-Python-Programming.git
cd 6174-Kaprekar-Constant-with-Python-Programming
# No additional installation required - uses Python standard library6174-Kaprekar-Constant-with-Python-Programming-main
├── 6174-Kaprekar-Constant-with-Python-Programming.py
├── README.md
└── LICENSEBasic Usage:
def kaprekar(num):
if num == 6174:
print("Result: 6174")
return
while num != 6174:
digits = [int(d) for d in str(num)]
while len(digits) < 4:
digits.insert(0, 0)
ascending = int(''.join(map(str, sorted(digits))))
descending = int(''.join(map(str, sorted(digits, reverse=True))))
num = descending - ascending
print(f"{descending:04d} - {ascending:04d} = {num:04d}")
# Example usage
kaprekar(1000)Output:
1000 - 0001 = 0999
9990 - 0999 = 8991
9981 - 1899 = 8082
8820 - 0288 = 8532
8532 - 2358 = 6174Basic Usage:
def kaprekar_3(num):
if num == 495:
print("Result: 495")
return
while num != 495:
digits = [int(d) for d in str(num)]
while len(digits) < 3:
digits.insert(0, 0)
ascending = int(''.join(map(str, sorted(digits))))
descending = int(''.join(map(str, sorted(digits, reverse=True))))
num = descending - ascending
print(f"{descending:03d} - {ascending:03d} = {num:03d}")
# Example usage
kaprekar_3(8)Output:
800 - 008 = 792
972 - 279 = 693
963 - 369 = 594
954 - 459 = 495# 6174 Kaprekar Constant with Python Programming
def kaprekar(num): # Define the Kaprekar function
if num == 6174: # If the number is 6174, operation is finished
print("Result: 6174")
return
while num != 6174: # Loop continues until number reaches 6174
# Separate the digits of the number and assign to array
digits = [int(d) for d in str(num)]
# Add leading zeros until array has 4 digits
while len(digits) < 4:
digits.insert(0, 0)
# Create new numbers by sorting digits ascending and descending
ascending = int(''.join(map(str, sorted(digits))))
descending = int(''.join(map(str, sorted(digits, reverse=True))))
# Calculate difference and assign to num for next iteration
num = descending - ascending
# Print operation steps and result
print(f"{descending:04d} - {ascending:04d} = {num:04d}")
# Test with your chosen four-digit number
kaprekar(1000)# Test various starting numbers
test_numbers = [1, 60, 803, 1000, 2791, 5094, 3006, 8000]
for num in test_numbers:
print(f"\nStarting with {num:04d}:")
kaprekar(num)
print("-" * 30)Fast Convergence Examples:
| Starting Number | Iterations | Path |
|---|---|---|
| 1000 | 5 | 1000→0999→8991→8082→8532→6174 |
| 2791 | 4 | 2791→7173→6354→3087→8352→6174 |
| 5094 | 3 | 5094→4086→8172→7443→3996→6174 |
Maximum Iterations:
| Starting Number | Iterations | Note |
|---|---|---|
| 1234 | 7 | Maximum iteration depth |
| 5678 | 7 | Requires full 7 steps |
Single-Step Convergence:
| Starting Number | Result | Direct Path |
|---|---|---|
| 7641 | 6174 | 7641→6174 (immediate) |
Example Sequences:
| Starting Number | Iterations | Path |
|---|---|---|
| 8 | 4 | 008→792→693→594→495 |
| 100 | 5 | 100→099→891→792→693→594→495 |
| 523 | 3 | 523→396→693→594→495 |
Four-Digit Numbers (6174):
| Metric | Value |
|---|---|
| Total valid numbers | 9,000 (excluding repdigits) |
| Maximum iterations | 7 |
| Average iterations | ~5.2 |
| Numbers requiring 7 iterations | ~78 |
| Numbers with 1 iteration | 356 |
Three-Digit Numbers (495):
| Metric | Value |
|---|---|
| Total valid numbers | 900 (excluding repdigits) |
| Maximum iterations | 6 |
| Average iterations | ~4.8 |
Repdigits (Invalid Input):
Numbers with all identical digits (1111, 2222, etc.) result in 0:
\[9999 - 9999 = 0\]
These are excluded from valid Kaprekar inputs.
Single Iteration Examples:
| Number | Descending | Ascending | Result |
|---|---|---|---|
| 7641 | 7641 | 1467 | 6174 |
| 6714 | 7641 | 1467 | 6174 |
| 4176 | 7641 | 1467 | 6174 |
[Input: Four-Digit Number n]
↓
[Check if n = 6174]
├─ YES → [Output: "Result: 6174"]
└─ NO ↓
[Extract Digits: d₁, d₂, d₃, d₄]
↓
[Ensure 4 Digits: Add Leading Zeros]
↓
[Sort Ascending: n_asc = d↑₁d↑₂d↑₃d↑₄]
↓
[Sort Descending: n_desc = d↓₁d↓₂d↓₃d↓₄]
↓
[Calculate Difference: n_new = n_desc - n_asc]
↓
[Display Operation]
↓
[Update n ← n_new]
↓
[Loop Back to Check if n = 6174]
↓
[Convergence at 6174]Time Complexity: \(O(k \cdot d \log d)\)
Space Complexity: \(O(d)\)
Total Operations: Maximum 7 iterations × 4 digits = 28 digit operations
str(), int(), sorted(), len(), map(), join()| Component | Implementation | Purpose |
|---|---|---|
| Programming Language | Python 3.6+ | Core implementation |
| Digit Extraction | List comprehension | Convert number to digit array |
| Sorting | sorted() function | Arrange digits ascending/descending |
| String Manipulation | join() + map() | Reconstruct numbers from digits |
| Formatting | f-strings | Display operations with leading zeros |
| Control Flow | while loop | Iterate until convergence |
| Characteristic | Value | Notes |
|---|---|---|
| Execution Speed | <1 ms per number | Negligible computation time |
| Memory Usage | <1 KB | Minimal memory footprint |
| Scalability | O(1) per number | Constant maximum iterations |
This project is open source and available under the Apache License 2.0.
This project pays tribute to Dattatraya Ramchandra Kaprekar (1905-1986), whose curiosity about numbers led to the discovery of this remarkable constant. Despite lacking formal mathematical training, his contributions to recreational mathematics have inspired generations of mathematicians and computer scientists. The simplicity and elegance of the 6174 constant exemplify how profound mathematical truths can emerge from elementary operations.
Special thanks to the mathematical community for preserving and expanding upon Kaprekar's work, and to educators worldwide who use this constant to inspire students in number theory and computational thinking.
Note: This project is designed for educational and recreational purposes. The Kaprekar routine demonstrates fundamental concepts in number theory, algorithm design, and convergence analysis. While the implementation is straightforward, the underlying mathematics reveals deep connections between digit manipulation, modular arithmetic, and iterative processes. Readers are encouraged to explore variations of the Kaprekar routine with different digit counts and to investigate the mathematical properties that guarantee convergence.