// Playing with making a subclass of my own super // class and making an infinite iterator to calculate // new elements to return. // Allowable input is 2 to 10000 with the result being // the number is a prime or the list of prime factors. // Single node template of the linked list storing // a value of whatever type, a pointer to the // previous node, and a pointer to the next node. data class Node(var value: T, var previous: Node? = null, var next: Node? = null) // Class providing a first in first out template for // a linked list. open class List() { // Pointers to the head and tail of the list plus // size of list. protected var head: Node? = null protected var tail: Node? = null var size: Int = 0 protected set // Create an interator over the list. operator open fun iterator(): Iterator = ListIterator(this, 0, size-1) // Provide this[index] to get read access to the // value within the node in that position. Head // points at index of zero. operator fun get(index: Int): T { // Find the node by starting with the head // node and copy of the index. While there // is another node and we haven't found the // right one, decrement the position and move // down the list. Return null or the node's // value. var node = head var position = index while (node != null && position != 0) { position -= 1 node = node.next } // while return node!!.value } // get // Provide this[index] to get write access to the // value within the node in that position. Head // points at index of zero. operator fun set(index: Int, value: T) { // If we have a valid index, find the node. // Start with the head node and copy of the // index. While there is another node and we // haven't found the right one, decrement the // position and move down the list. if (index >= 0) { var node = head var position = index while (node != null && position != 0) { position -= 1 node = node.next } // while // If we have found the node, update it's // value. if (node != null) node.value = value; } // if } // set // Push a new value on to the tail of the list. fun push(value: T) { // Allocate the new node with the passed in value. // If the head is null, make it point to the new // node. val newNode = Node(value) if (tail == null) head = newNode // Otherwise, make the current last node point to // the new node and the new node point back at it. else { tail?.next = newNode newNode.previous = tail } // if // The tail must point to the new node in either // case and increment the size. tail = newNode size++ } // push // Pop the first value off the list. fun pop(): T? = // If the head is null, return it. if (head == null) null // Otherwise, decrement the size, grab the // first node, make next node the new head, // make it's previous null, make the first // node's next pointer null, and return the // value. Note: testing for null shouldn't // be needed, but head might be changed // asynchronously so it is required. else { size-- val node = head head = head?.next head?.previous = null node?.next = null node?.value } // if // This function is called by default to print this // class so make a list of the values in the list. // An integer list will look like: [1, 2, 3]. override fun toString(): String { // Start the finished string with the open // bracket and process the list. var s = "[" var node = head while (node != null) { // Add the current node's value to the string, // move on the next node, and, if there is one, // add the comma to the string. s += "${node.value}" node = node.next if (node != null) s += ", " } // while // Return the finished string with the close // bracket. return s+"]" } // toString } // List // Create an iterator class allocating the list and // the current & end positions. class ListIterator(private val self: List, start: Int, private val end: Int): Iterator { private var current = start // Test to see if any more elements exist. override fun hasNext(): Boolean = current <= end // Return the value of the current element // incrementing to the next one. override fun next(): T = self[current++] } // ListIterator // Override the iterator and add a new method. class Primes: List() { // Create an interator over the list. operator override fun iterator(): Iterator = PrimesIterator(this) // Return the value of the last node. fun last(): Int = tail!!.value } // Primes // Create an iterator class to figure out the next // prime number so there is an infinite supply. class PrimesIterator(private val self: Primes): Iterator { // There is always another prime. override fun hasNext(): Boolean = true // Figure out the next prime adding it to our list. override fun next(): Int = // If our list is empty, our first is 2. if (self.size == 0) { self.push(2) 2 // Otherwise, if we returned 2, our second is 3. } else if (self.size == 1) { self.push(3) 3 // Otherwise, we can now find it by processing // our last one so do it. } else { // Take the last prime found and start at the // next odd number looping until a new one // is found. var number = self.last()+2 outer@ while (true) { // For each of the primes found so far, if // it divides evenly into the number, the // number can't be a prime so skip checking // the others. Otherwise, if the prime is // too big to be the smallest factor of the // number, the number must be a prime. // Otherwise, continue processing the next // prime. for (index in 0 until self.size) { val factor = self[index] if (number%factor == 0) break else if (factor*factor > number) break@outer } // for number += 2 } // while // No factor was found so add the prime to our // list and return it. self.push(number) number } // if } // PrimesIterator // Attempt to read the number to factor, default // to a 100, when the read failed to get a number, // and, if we did get a number, make sure it is // reasonable. fun number(): Int = try { var num = readLine()!!.toInt() if (num < 2 || num > 10000) { println("Number is not reasonable!\nDefaulting to 100.\n") num = 100 } // if num } catch (e: NullPointerException) { println("Failed to read!\nDefaulting to 100.\n") 100 } catch (e: NumberFormatException) { println("Invalid number!\nDefaulting to 100.\n") 100 } // try // Find the factors of a given number. fun main(args: Array) { // Create a list for primes, a second list for the // factors, read the number process, and make a // copy. For each of the primes, process it. Note: // The list will aways find another. val primes = Primes() val factors = List() val num = number() var result = num for (factor in primes) { // If the current prime is bigger than what is // left to be factored out of the number or // the factor proves the number is a prime, // exit the loop. if (factor > result || factor*factor > num) break // While the factor works, add it to the factor // list and divide it out so we can see if it // works once more. while (result%factor == 0) { factors.push(factor) result /= factor } // while } // for // If no factors were found, it is a prime number. if (factors.size == 0) println("$num is a prime.") // Otherwise, if the result is greater than one, // it's another prime so add it to the list before // displaying them. Note: if the last prime gets // divided by itself, result is one. If result is // larger, we exited because a prime squared was // bigger than the number. else { if (result > 1) factors.push(result) print("Factors of $num are: ") for (element in factors) print("$element ") println() } // if } // main

factors mn