Step by Step solution about How to resolve the algorithm Lychrel numbers step by step in the Kotlin programming language

Code Overview:

This Kotlin program determines Lychrel numbers and their properties within a given range. Lychrel numbers are numbers that never produce a palindrome after a finite number of iterations by adding the reverse of their digits.

Constants:

• ITERATIONS: Maximum number of iterations to check if a number is Lychrel.
• LIMIT: Upper limit of the range to search for Lychrel numbers.

Variable Declarations:

• bigLimit: BigInteger representation of LIMIT.
• lychrelSieve: Array used as a sieve to track Lychrel properties (0: not Lychrel, 1: Seed Lychrel, 2: Related Lychrel).
• seedLychrels: Mutable list to store Seed Lychrel numbers.
• relatedLychrels: Mutable set to store Related Lychrel numbers.

Functions:

• isPalindrome: Checks if a BigInteger is a palindrome.
• lychrelTest: Performs the Lychrel test on a given integer i and updates the lychrelSieve, seedLychrels, and relatedLychrels accordingly.

Main Function:

• Iterates through the range [1, LIMIT] and performs the Lychrel test on each number.
• Counts the number of related Lychrel numbers.

Output:

• Prints the number of Seed Lychrel numbers and their values.
• Prints the number of Related Lychrel numbers.
• Prints the number of palindromic Lychrel numbers and their values.

Algorithm:

The program uses a sieve approach to efficiently determine Lychrel numbers:

1. Initialize the lychrelSieve array to all zeros.
2. For each number i in the range [1, LIMIT]:
   • If i has already been processed (i.e., lychrelSieve[i] != 0), skip it.
   • Otherwise, perform the Lychrel test on i using the lychrelTest function.
   • Update the lychrelSieve array based on the test results.
   • If i is a Seed Lychrel number, add it to the seedLychrels list.
   • If i is a Related Lychrel number, add it to the relatedLychrels set.
3. Count the number of related Lychrel numbers.
4. Find and print the palindromic Lychrel numbers by checking if the Lychrel numbers are also palindromes.

By using this approach, the program efficiently determines and summarizes the properties of Lychrel numbers within the specified range.

// version 1.0.6

import java.math.BigInteger

const val ITERATIONS = 500
const val LIMIT = 10000

val bigLimit = BigInteger.valueOf(LIMIT.toLong())

// In the sieve,  0 = not Lychrel, 1 = Seed Lychrel, 2 = Related Lychrel
val lychrelSieve    = IntArray(LIMIT + 1)  // all zero by default
val seedLychrels    = mutableListOf<Int>()
val relatedLychrels = mutableSetOf<BigInteger>()

fun isPalindrome(bi: BigInteger): Boolean {
    val s = bi.toString()
    return s == s.reversed()
}

fun lychrelTest(i: Int, seq: MutableList<BigInteger>){
    if (i < 1) return
    var bi = BigInteger.valueOf(i.toLong())
    (1 .. ITERATIONS).forEach {
        bi += BigInteger(bi.toString().reversed())
        seq.add(bi)
        if (isPalindrome(bi)) return
    }
    for (j in 0 until seq.size) {
        if (seq[j] <= bigLimit) lychrelSieve[seq[j].toInt()] = 2 
        else break
    } 
    val sizeBefore = relatedLychrels.size
    relatedLychrels.addAll(seq)  // if all of these can be added 'i' must be a seed Lychrel
    if (relatedLychrels.size - sizeBefore == seq.size) {
        seedLychrels.add(i)
        lychrelSieve[i] = 1 
    }
    else {
        relatedLychrels.add(BigInteger.valueOf(i.toLong()))
        lychrelSieve[i] = 2
    }        
}

fun main(args: Array<String>) {   
    val seq  = mutableListOf<BigInteger>()
    for (i in 1 .. LIMIT) 
        if (lychrelSieve[i] == 0) { 
           seq.clear() 
           lychrelTest(i, seq)
        } 
    var related = lychrelSieve.count { it == 2 }
    println("Lychrel numbers in the range [1, $LIMIT]")
    println("Maximum iterations = $ITERATIONS")
    println("\nThere are ${seedLychrels.size} seed Lychrel numbers, namely")
    println(seedLychrels)
    println("\nThere are also $related related Lychrel numbers in this range")    
    val palindromes = mutableListOf<Int>()
    for (i in 1 .. LIMIT)
        if (lychrelSieve[i] > 0 && isPalindrome(BigInteger.valueOf(i.toLong()))) palindromes.add(i)
    println("\nThere are ${palindromes.size} palindromic Lychrel numbers, namely")
    println(palindromes)
}