Just Kotlin!!!!

Author: amangautam1

src/Basic/AbstractClass.kt

@@ -0,0 +1,24 @@
+package Basic
+
+abstract class School(var name: String, std: Int) {
+    var school = "ABC School"
+    fun name(): String {
+        return name;
+    }
+
+    abstract fun showprofile()
+}
+
+class Student(name: String, var std: Int) : School(name, std) {
+    override fun showprofile() {
+        println(" School : $school\n Name : $name, Class : $std")
+    }
+}
+
+fun main(Args: Array<String>) {
+    var obj = Student("Krishna", 4)
+    println(" Calling Abstract method")
+    obj.showprofile()
+    println("\n calling non abstract method")
+    println(" Name : ${obj.name()}")
+}

src/Basic/Interfaces.kt

@@ -0,0 +1,39 @@
+package Basic
+
+interface twoWheeler {
+    fun getDeatils() {       //method with code
+        println("This is an interface providing a method getPrice() which returns price as per quantity ")
+    }
+
+    var price: Int                              // property
+    fun getPrice(qt: Int): Int                 // abstract method
+}
+
+class bajaj : twoWheeler {
+    override var price = 45000
+    override fun getPrice(qt: Int): Int {
+        return qt * price
+    }
+}
+
+class hero : twoWheeler {
+    override var price = 50000
+    override fun getPrice(qt: Int): Int {
+        return (qt * price + 4500)
+    }
+}
+
+fun main(args: Array<String>) {
+    var platina = bajaj()
+    platina.getDeatils()
+    println("Enter quantity for platina  : ")
+    var qt = readLine()!!.toInt()
+    print(" Your Price : ")
+    println(platina.getPrice(qt))
+
+    var passion = hero()
+    println("Enter quantity for passion  : ")
+    qt = readLine()!!.toInt()
+    print(" Your Price : ")
+    println(passion.getPrice(qt))
+}

src/Basic/multipleInterfaces.kt

@@ -0,0 +1,26 @@
+package Basic
+
+interface A {
+    fun display() {
+        println("this is interface A")
+    }
+}
+
+interface B {
+    fun display() {
+        println("this is interface B")
+    }
+}
+
+class C : A, B {
+    override fun display() {
+        super<A>.display()
+        super< B>.display()
+
+    }
+}
+
+fun main(args: Array<String>) {
+    var ob = C()
+    ob.display()
+}

src/Data_Structure/BucketSort.kt

@@ -0,0 +1,49 @@
+package Data_Structure
+
+import java.util.*
+
+fun insertion_sort(A: ArrayList<Double>) {
+    var n = A.size
+    var i: Int
+    for (j in 1 until n) {
+        var key = A[j]
+        i = j - 1
+        while (i >= 0 && A[i] > key) {
+            A[i + 1] = A[i]
+            i--
+        }
+        A[i + 1] = key
+    }
+}
+
+fun bucket_sort(A: Array<Double>) {
+    var n = A.size
+    var bucket = Array<ArrayList<Double>>(n, { i -> ArrayList() })   // creating buckets with n size
+    for (i in 0..A.size - 1) {
+        bucket[Math.floor(n * A[i]).toInt()].add(A[i])             // adding element a[i] into position n*a[i]
+    }
+    for (i in 0..A.size - 1) {
+        insertion_sort(bucket[i])                               // sorting a list using inserton sort
+    }
+    for (i in 1..A.size - 1) {
+        bucket[0].addAll(bucket[i])                              // concatenate all the buckets
+    }
+    println("After sorting :")
+    for (i in bucket[0]) {
+        print("$i ")                                            // print the sorted elements
+    }
+}
+
+fun main(arg: Array<String>) {
+    print("Enter no. of elements :")
+    var n = readLine()!!.toInt()
+
+    println("Enter elements : ")
+    var A = Array(n, { 0.0 })
+    for (i in 0 until n)
+        A[i] = readLine()!!.toDouble()
+
+    bucket_sort(A)
+
+}
+

src/Data_Structure/CountingSort.kt

@@ -0,0 +1,40 @@
+package Data_Structure
+
+fun counting_sort(A: Array<Int>, max: Int) {
+    var B = Array<Int>(A.size, { 0 })   // Array in which result will store
+    var C = Array<Int>(max, { 0 })      // count array
+    for (i in 0..A.size - 1) {
+        C[A[i] - 1] = C[A[i] - 1] + 1    //count the no. of occurrence of a particular element store in count array
+    }
+    for (i in 1..C.size - 1) {
+        C[i] = C[i] + C[i - 1]          // calculate commutative sum
+    }
+    for (i in A.size - 1 downTo 0) {
+        B[C[A[i] - 1] - 1] = A[i]                  // place the element at its position
+        C[A[i] - 1] = C[A[i] - 1] - 1              // decrease the occurrence of the element by 1
+    }
+    println("After sorting :")
+    for (i in B) {
+        print("$i ")
+    }
+
+}
+
+fun main(arg: Array<String>) {
+    print("Enter no. of elements :")
+    var n = readLine()!!.toInt()
+
+    println("Enter elements : ")
+    var A = Array(n, { 0 })
+    for (i in 0 until n)
+        A[i] = readLine()!!.toInt()
+    // calculate maximum element from array
+    var max = A[0];
+    for (i in A) {
+        if (i > max) {
+            max = i
+        }
+    }
+    counting_sort(A, max)
+}
+

src/Data_Structure/Euclid.kt

@@ -0,0 +1,28 @@
+package Data_Structure
+
+fun gcd_1(a: Int, b: Int): Int {
+    var a = a
+    var b = b
+    while (b != 0) {
+        var t = b;
+        b = a % b;
+        a = t;
+    }
+    return a
+}
+
+fun gcd_2(a: Int, b: Int): Int {
+    if (b == 0)
+        return a
+    else
+        return gcd_2(b, a % b)
+}
+
+fun main(args: Array<String>) {
+    println("Enter two number ")
+    var a = readLine()!!.toInt()
+    var b = readLine()!!.toInt()
+
+    println("Using iterative function GCD = ${gcd_1(a, b)}")
+    println("using recursive function GCD = ${gcd_2(a, b)}")
+}

src/Data_Structure/InsertionSort.kt

@@ -14,6 +14,7 @@ fun insertion_sort(A: Array<Int>) {
     }
 }
 
+
 fun main(arg: Array<String>) {
     print("Enter no. of elements :")
     var n = readLine()!!.toInt()

src/Data_Structure/SinglyLinkedList.kt

@@ -0,0 +1,72 @@
+package Data_Structure
+
+import kotlin.system.exitProcess
+
+data class SinglyLinkedList(var value: Int, var link: SinglyLinkedList? = null)
+
+class TestList {
+    var start: SinglyLinkedList? = null
+
+    init {
+
+    }
+
+    fun insert(value: Int) {
+        var ptr = SinglyLinkedList(value, null)
+        if (start == null) {
+            start = ptr
+        } else {
+            ptr.link = start
+            start = ptr
+        }
+    }
+
+    fun delete() {
+        if (start == null) {
+            print("underFlow!!")
+            exitProcess(0)
+        } else {
+            start = start?.link
+        }
+    }
+
+    fun traverse() {
+        if (start?.link == null) {
+            print("underFlow!!")
+            return
+        }
+
+        var ptr1 = start
+        while (ptr1?.link != null) {
+            print("${ptr1.value}")
+            ptr1 = ptr1.link
+        }
+        print(ptr1?.value)
+    }
+}
+
+fun main(str: Array<String>) {
+    while (true) {
+        println(" Linked List Menu ")
+        println(" 1. Insert at begining")
+        println(" 2. Delete")
+        println(" 3. Traverse")
+        println(" 4. Exit")
+        var ob = TestList()
+        var ch = readLine()!!.toInt()
+        when (ch) {
+            1 -> {
+                print("Enter element : ")
+                var element = readLine()!!.toInt()
+                ob.insert(element)
+            }
+            2 -> {
+                ob.delete()
+                print("Deleted")
+            }
+            3 -> {
+                ob.traverse()
+            }
+        }
+    }
+}