BigIntegers

Basic.kt

import kotlinx.coroutines.*

/**
 * You can edit, run, and share this code. 
 * play.kotlinlang.org 
 */





fun main() {
   //println("Addition: "+add("98765432109876543210", "98765432109876543210"))
   //println("Multiplication: "+multiply("987654321098763453453534534534534534534123123543210",
   //                              "987654321098763453453534534534534534534123123543210"))

   //println("Exponentition: "+expo("3457", "345"))
   

    val result = multiply("111111111111111111111111111111111111",
                          "111111111111111111111111111111111111") ==
    "12345679012345679012345679012345678987654320987654320987654320987654321"
    
    println(result)
    
    //1223 => 1,495,729
    //122 => 14,884
}






fun expo(str1: String, str2: String): String {
   var temp = str1
   var i = "1"
   while(i != str2) {
       temp = multiply(temp, str1)
       i = add(i, "1")
   }
   return temp
}



fun multiply(str1: String, str2: String): String {

   // Which is big string
   val findBig = whichIsBig(str1, str2)
   val bigNum = findBig.first
   var smallNum = findBig.second

    
    val addition = mutableListOf<String>()
    for(i in 0 .. smallNum.length-1) {
        var temp = ""
        var add = 0
        for(j in bigNum.length-1 downTo 0) {
            val ans = (smallNum[i].toNumericValue() * bigNum[j].toNumericValue() + add).toString()
            add = 0
            if(ans.length>1) {
                temp+=ans[1]
                add = ans[0].toNumericValue()
            } else temp+=ans
        }
        if(add != 0) temp+=add
        addition.add(temp.reversed().append("0".repeat(smallNum.length-1-i)))
    }
    
//     var temp = addition[0]
//     for(i in 1 .. addition.size-1) {
//         temp = add(temp, addition[i])
//     }

    val temp = parallel(addition)[0]

    
  
    
    //var tmp = parallel(addition)[0]
    //if(addition.size > 2 && addition.size %2 !=0) tmp = add(tmp, addition.last())
    
    
    return temp
}


//[1111111000000, 111111100000, 11111110000, 1111111000, 111111100, 11111110, 1111111]


fun parallel(strs: List<String>) : List<String> {
    var tmp = strs

	while(tmp.size>1) {
      //println(tmp)
      
      val isEven = (tmp.size % 2 == 0)
      val temp = mutableListOf<String>()
      
      var start = 0
      var end = tmp.size-1
      if(!isEven) {
          start = 1
          end = tmp.size-2
      }
      
      for (i in start .. end step 2) {
         val tmp1 = add(tmp[i], tmp[i+1])
         temp.add(tmp1)
      }

      if(!isEven) temp.add(tmp[0])
        
      tmp = temp
    }
    
    
    return tmp
    
}





// fun parallel(strs: List<String>): List<String> {
//     if(strs.size>=2) return runBlocking {
//        val list = mutableListOf<Deferred<String>>()
//        for(i in 0 until strs.size/2) {
//           list.add(async { add(strs[2*i], strs[2*i+1]) } )
//        }
//        parallel(list.awaitAll())
//     }
    
//     else {
//         return strs
//     }
// }





fun add(str1: String, str2: String) : String {
   // Which is big string
   val findBig = whichIsBig(str1, str2)
   val bigNum = findBig.first
   var smallNum = findBig.second
   
    
   if(bigNum.length!=smallNum.length) smallNum = smallNum.prependZeros(bigNum.length-smallNum.length)
   
   var add = 0
   var temp = ""
   for (i in bigNum.length-1 downTo 0) {
      val ans = (bigNum[i].toNumericValue() + smallNum[i].toNumericValue() + add).toString()
      add = 0
      if(ans.length>1) {
      	temp+=ans[1]
      	add = ans[0].toNumericValue()
      } else temp+=ans
   }
   
   if(add != 0) temp+=add
   
   return temp.reversed()
}



fun whichIsBig(str1: String, str2: String): Pair<String, String> { 
    if (str1.length < str2.length) return (str2 to str1) //str2 is big
    else if(str1.length > str2.length) return (str1 to str2) //str1 is big
    else {
        for (i in 0 until str1.length) {
    		if (str1[i].toInt() > str2[i].toInt()) return (str1 to str2) //str1 is big
    		else if (str1[i].toInt() < str2[i].toInt()) return (str2 to str1) //str2 is big
    		else continue
  		}
    }
  return (str1 to str2) //Both are equals
}


fun Char.toNumericValue() = this.toString().toInt()

fun String.prepend(str: String) = str+this
fun String.append(str: String) = this+str

fun String.prependZeros(size: Int) = "0".repeat(size)+this
fun zeroString(size: Int) = "0".repeat(size)

test.kt

fun add2(str1: String, str2: String) : String {
   // Which is big string
   val findBig = whichIsBig(str1, str2)
   val bigNum = findBig.first
   var smallNum = findBig.second
    
   val diff = bigNum.length-smallNum.length
    
   val kavan = CharArray(bigNum.length+1)
   
   var add = 0
   var temp = ""
   for (i in bigNum.length-1 downTo 0) {
      var ans = (bigNum[i]-'0') + add
      
      (i-diff).let { if(it>=0) { ans += smallNum[it]-'0' } }
       
      add = 0
      
       (ans-10).let {
           if(it>0) { 
               temp+=it
               add = 1
           } else temp+=ans
       }
   }
   
   if(add != 0) temp+=add
   
   return temp.kreversed()
}


inline fun <R> measures(block1: () -> R, block2: () -> R)  {
    var k1 = 0L; var k2 = 0L;
    
    val start1 = System.nanoTime()
    for (i in 0 until 10000) {
        block1()
    }
    val end1 = System.nanoTime() - start1
    
    val start2 = System.nanoTime()
    for (i in 0 until 10000) {
        block2()
    }
    val end2 = System.nanoTime() - start2
    
    println("${block1()} $end1\n${block2()} $end2")
    
}