I am attempting to accept input from the console in Kotlin but it is difficult because I am not too sure about the syntax.
I begin with the main
fun main(args: Array<String>) {
}
WHAT should I enter after this? I am aware that the println() and readline() are involved but I do not know how to structure them.
Objective: prompt user to enter a number, the number entered is multiplied by 6, program returns the result to the console display.
Note that since Kotlin 1.6 readLine()!! should be replaced with
readln().
Here are A+B examples in Kotlin reading from stdin:
fun main() {
val (a, b) = readLine()!!.split(' ')
println(a.toInt() + b.toInt())
}
or
fun main(vararg args: String) {
val (a, b) = readLine()!!.split(' ').map(String::toInt)
println(a + b)
}
or
fun readInts() = readLine()!!.split(' ').map { it.toInt() }
fun main(vararg args: String) {
val (a, b) = readInts()
println(a + b)
}
or
import java.util.Scanner
fun main() {
val input = Scanner(System.`in`)
val a = input.nextInt()
val b = input.nextInt()
println(a + b)
}
or
with(Scanner(System.`in`)) {
val a = nextInt()
val b = nextInt()
println(a + b)
}
Competitive programming
Must-read intro: https://kotlinlang.org/docs/tutorials/competitive-programming.html
Must-watch Kotlin productivity videos: https://www.jetbrains.com/icpc/
Here is an (inspired by the article) extended bunch of helper functions for reading all possible types, lists, arrays, 2d-arrays, etc:
private fun readln() = readLine()!!
private fun readlnByte() = readln().toByte()
private fun readlnShort() = readln().toShort()
private fun readlnInt() = readln().toInt()
private fun readlnLong() = readln().toLong()
private fun readlnFloat() = readln().toFloat()
private fun readlnDouble() = readln().toDouble()
private fun readlnBigInt(radix: Int = 10) = readln().toBigInteger(radix)
private fun readlnBigDecimal() = readln().toBigDecimal()
private fun lineSequence(limit: Int = Int.MAX_VALUE) = generateSequence { readLine() }.constrainOnce().take(limit)
private fun readlnStrings() = readln().split(' ')
private fun readlnBytes() = readlnStrings().map { it.toByte() }
private fun readlnShorts() = readlnStrings().map { it.toShort() }
private fun readlnInts() = readlnStrings().map { it.toInt() }
private fun readlnLongs() = readlnStrings().map { it.toLong() }
private fun readlnFloats() = readlnStrings().map { it.toFloat() }
private fun readlnDoubles() = readlnStrings().map { it.toDouble() }
private fun readByteArray() = readlnStrings().run { ByteArray(size) { get(it).toByte() } }
private fun readShortArray() = readlnStrings().run { ShortArray(size) { get(it).toShort() } }
private fun readIntArray() = readlnStrings().run { IntArray(size) { get(it).toInt() } }
private fun readLongArray() = readlnStrings().run { LongArray(size) { get(it).toLong() } }
private fun readFloatArray() = readlnStrings().run { FloatArray(size) { get(it).toFloat() } }
private fun readDoubleArray() = readlnStrings().run { DoubleArray(size) { get(it).toDouble() } }
private fun readlnByteArray(n: Int) = ByteArray(n) { readlnByte() }
private fun readlnShortArray(n: Int) = ShortArray(n) { readlnShort() }
private fun readlnIntArray(n: Int) = IntArray(n) { readlnInt() }
private fun readlnLongArray(n: Int) = LongArray(n) { readlnLong() }
private fun readlnFloatArray(n: Int) = FloatArray(n) { readlnFloat() }
private fun readlnDoubleArray(n: Int) = DoubleArray(n) { readlnDouble() }
private fun readByteArray2d(rows: Int, cols: Int) = Array(rows) { readByteArray().also { require(it.size == cols) } }
private fun readShortArray2d(rows: Int, cols: Int) = Array(rows) { readShortArray().also { require(it.size == cols) } }
private fun readLongArray2d(rows: Int, cols: Int) = Array(rows) { readLongArray().also { require(it.size == cols) } }
private fun readIntArray2d(rows: Int, cols: Int) = Array(rows) { readIntArray().also { require(it.size == cols) } }
private fun readFloatArray2d(rows: Int, cols: Int) = Array(rows) { readFloatArray().also { require(it.size == cols) } }
private fun readDoubleArray2d(rows: Int, cols: Int) = Array(rows) { readDoubleArray().also { require(it.size == cols) } }
private fun isWhiteSpace(c: Char) = c in " \r\n\t"
// JVM-only targeting code follows next
// readString() via sequence is still slightly faster than Scanner
private fun readString() = generateSequence { System.`in`.read().toChar() }
.dropWhile { isWhiteSpace(it) }.takeWhile { !isWhiteSpace(it) }.joinToString("")
private fun readByte() = readString().toByte()
private fun readShort() = readString().toShort()
private fun readInt() = readString().toInt()
private fun readLong() = readString().toLong()
private fun readFloat() = readString().toFloat()
private fun readDouble() = readString().toDouble()
private fun readBigInt(radix: Int = 10) = readString().toBigInteger(radix)
private fun readBigDecimal() = readString().toBigDecimal()
private fun readBytes(n: Int) = generateSequence { readByte() }.take(n)
private fun readShorts(n: Int) = generateSequence { readShort() }.take(n)
private fun readInts(n: Int) = generateSequence { readInt() }.take(n)
private fun readLongs(n: Int) = generateSequence { readLong() }.take(n)
private fun readFloats(n: Int) = generateSequence { readFloat() }.take(n)
private fun readDoubles(n: Int) = generateSequence { readDouble() }.take(n)
Beware that Scanner is somewhat slow. This may be important in some cases like competitive programming where program's execution on large inputs could be made up to two times faster just by replacing Scanner with plain readLine. Even my suboptimal readString() implementation tokenizing via sequence is slightly faster. It allows to read input tokens until any next whitespace unlike Kotlin's built-in readLine().
I hope someday a concise, crossplatform, performant, universal for both console and files input parsing support would be introduced in Kotlin stdlib. Like readInt, readLong, etc global and Reader extension functions.
This would be very userful not only for competitive programming but also for learning Kotlin as first language.
A concept of reading a number shouldn't require first explaining collections, lambdas and monads.
Bonus
Sometimes you start with console input/output but then need to switch to files.
It becomes too tedious to prepend every read or write call with file stream variable.
Here is a peace of Kotlin magic that allows to just wrap unchanged console code with a couple of lines to force it read and write to files also ensuring they are closed properly:
fun <T : Closeable, R> T.useWith(block: T.() -> R): R = use { with(it, block) }
File("a.in").bufferedReader().useWith {
File("a.out").printWriter().useWith {
val (a, b) = readLine()!!.split(' ').map(String::toInt)
println(a + b)
}
}
Scanner(File("b.in")).useWith {
PrintWriter("b.out").useWith {
val a = nextInt()
val b = nextInt()
println(a + b)
}
}
Wrapping lines can be quickly commented out when happens a need to switch back to console.
Use readLine() to take input from user,
ATQ:
fun main(args:Array<String>){
print("Enter a number")
var variableName:Int = readLine()!!.toInt() // readLine() is used to accept the String value and ".toInt()" will convert the string to Int.
var result:Int= variableName*6
print("The output is:$result")
}
There are multiple alternatives to handle Console I/O with Kotlin.
1. Using the Kotlin Standard Library: The Kotlin standard library provides us extensions to handling I/O based on the classes of the JDK.
To print in the console we can use the print function. If we run the following snippet:
print("Hello from Kotlin")
We’ll see the following message displayed on our terminal:
Hello from Kotlin
Behind-the-scenes this function uses the Java System.out.print method. Also, the library offers us the println alternative function, witch adds the line separator at the end of the message.
In order to read from the console, we can use readLine function:
val inputText = readLine()
2. Using the Java Standard Library: Kotlin has great interoperability with Java. Thus, we can use the standard I/O classes from the JDK in our programs in case we need them.
2.1. Using the Scanner Class: Using the Scanner class is very straightforward; we only need to create an instance and use the nextLine method:
val scanner = Scanner(System.`in`)
val readText = scanner.nextLine()
Note that we are escaping the in property with backticks because it’s a keyword in Kotlin.
2.2. Using the BufferedReader Class: To use the BufferedReader class to read from the standard input stream, we first need to instantiate with System.in:
val reader = BufferedReader(InputStreamReader(System.`in`))
And then we can use its methods — for example, readLine():
val readText = reader.readLine()
2.3. Using the Console Class: Unlike the two previous classes, the Console class has additional methods for handling console I/O, like readPassword and printf.
In order to use the Console class we need to get the instance from the System class:
val console = System.console()
val readText = console.readLine()
Also, thanks to Kotlin’s interoperability with Java, we can use additional Java libraries for handling I/O.
In your case, after reading the input you can convert the String value to Int using the toInt() function.
fun readInts(separator: Char = ' ') =
readLine()!!.split(separator).map(String::toInt)
fun main(args: Array<String>) {
var A : List<Int> = readInts()
}
By default readLine takes input as string
toInt can be used to convert it to integer
fun main(args:Array<String>){
var first: Int
var second: Int
println("Enter the first number")
first = readLine()!!.toInt()
println("Enter the second number")
second= readLine()!!.toInt()
println("The sum is ${first + second}")
}
Below is the basic function to take the system input
fun main(args: Array<String>) {
val sc = Scanner(System.`in`)
val num1 = sc.nextInt()
val num2 = sc.nextInt()
val sum = solveMeFirst(num1, num2)
println(sum)
}
Just create a scan function
fun scan():String{
var str ="";
while ( str==""){
str = readLine().toString()
}
return str;
}
Use like
fun main() {
println("Enter number 1")
val a = scan().toInt()
println("Enter number 2")
val b = scan().toInt()
println(a + b);
}
You can use readLine().
fun main(args: Array<String>) {
println("What's your name?")
val inputText = readLine()
println(“Your name is " + inputText)
}
Related
I'm in a situation where I'm trying to setup some data and then call a service. Each step can fail, so I'm trying to use Arrow's Either to manage this.
But I'm ending up with a lot of nested flatMaps.
The following code snippet illustrates what I'm trying to do:
import arrow.core.Either
import arrow.core.flatMap
typealias ErrorResponse = String
typealias SuccessResponse = String
data class Foo(val userId: Int, val orderId: Int, val otherField: String)
data class User(val userId: Int, val username: String)
data class Order(val orderId: Int, val otherField: String)
interface MyService {
fun doSomething(foo: Foo, user: User, order: Order): Either<ErrorResponse, SuccessResponse> {
return Either.Right("ok")
}
}
fun parseJson(raw: String): Either<ErrorResponse, Foo> = TODO()
fun lookupUser(userId: Int): Either<ErrorResponse, User> = TODO()
fun lookupOrder(orderId: Int): Either<ErrorResponse, Order> = TODO()
fun start(rawData: String, myService: MyService): Either<ErrorResponse, SuccessResponse> {
val foo = parseJson(rawData)
val user = foo.flatMap {
lookupUser(it.userId)
}
//I want to lookupOrder only when foo and lookupUser are successful
val order = user.flatMap {
foo.flatMap { lookupOrder(it.orderId) }
}
//Only when all 3 are successful, call the service
return foo.flatMap { f ->
user.flatMap { u ->
order.flatMap { o ->
myService.doSomething(f, u, o)
}
}
}
}
I'm sure there is a better way to do this. Can someone help me with an idiomatic approach?
You can use the either { } DSL, this is available in a suspend manner or in a non-suspend manner through the either.eager { } builder.
That way you can use suspend fun <E, A> Either<E, A>.bind(): A.
Rewriting your code example:
fun start(rawData: String, myService: MyService): Either<ErrorResponse, SuccessResponse> =
either.eager {
val foo = parseJson(rawData).bind()
val user = lookupUser(foo.userId).bind()
val order = lookupOrder(foo.orderId).bind()
myService.doSomething(foo, user, order).bind()
}
If you run into an Either.Left, then bind() will short-circuit the either.eager block and return with the encountered Either.Left value.
I'm looking for a way to pass an argument into a Kotlin sequence function similar to how it works in JS:
function *gen () {
console.log(yield) // prints 1
console.log(yield) // prints 2
}
const it = gen()
it.next() // first iteration will execute the first yield and pause
it.next(1) // we pass 1 to the first yield which will be printed
it.next(2) // we pass 2 to the second yield which will be printed
Something like this in Kotlin:
fun main() {
val it = gen().iterator()
// Iterator#next() doesn't expect an argument
it.next(1)
it.next(2)
}
fun gen() = sequence {
println(yield(null)) // Would print 1
println(yield(null)) // Would print 2
}
Kotlin Sequences do not support passing arguments to each yield, but you have at least 2 ways to implement needed behaviour:
Using actors:
class NextQuery<A, T>(val arg: A, val next: CompletableDeferred<T> = CompletableDeferred())
fun test() = runBlocking {
val actor = GlobalScope.actor<NextQuery<String, Int>> {
for (nextQuery in channel) {
nextQuery.next.complete(nextQuery.arg.length)
}
}
val query1 = NextQuery<String, Int>("12345")
actor.send(query1)
println(query1.next.await())
val query2 = NextQuery<String, Int>("1234")
actor.send(query2)
println(query2.next.await())
}
Using channels:
class ArgSequenceScope<out A, in T>(
private val argChannel: ReceiveChannel<A>,
private val nextChannel: SendChannel<T>
) {
suspend fun yield(next: T) {
nextChannel.send(next)
}
suspend fun arg(): A = argChannel.receive()
}
class ArgSequence<in A, out T>(
private val argChannel: SendChannel<A>,
private val nextChannel: ReceiveChannel<T>
) {
suspend fun next(arg: A): T {
argChannel.send(arg)
return nextChannel.receive()
}
}
fun <A, T> sequenceWithArg(block: suspend ArgSequenceScope<A, T>.() -> Unit): ArgSequence<A, T> {
val argChannel = Channel<A>()
val nextChannel = Channel<T>()
val argSequenceScope = ArgSequenceScope(argChannel, nextChannel)
GlobalScope.launch {
argSequenceScope.block()
argChannel.close()
nextChannel.close()
}
return ArgSequence(argChannel, nextChannel)
}
fun test() {
val sequence = sequenceWithArg<String, Int> {
yield(arg().length)
yield(arg().length)
}
runBlocking {
println(sequence.next("12345"))
println(sequence.next("1234"))
}
}
I came across the following code:
import io.reactivex.Observable
import io.reactivex.functions.BiFunction
import java.util.concurrent.TimeUnit
class ExpBackoff(
private val jitter: Jitter,
private val delay: Long,
private val unit: TimeUnit,
private val retries: Int = 0
) : Function<Observable<out Throwable>, Observable<Long>> {
#Throws(Exception::class)
override fun apply(observable: Observable<out Throwable>): Observable<Long> {
return observable
.zipWith(Observable.range(1, retries), BiFunction<Throwable, Int, Int> { _, retryCount ->
retryCount
})
.flatMap { attemptNumber -> Observable.timer(getNewInterval(attemptNumber), unit) }
}
private fun getNewInterval(retryCount: Int): Long {
var newInterval = (delay * Math.pow(retryCount.toDouble(), 2.0) * jitter.get()).toLong()
if (newInterval < 0) {
newInterval = Long.MAX_VALUE
}
return newInterval
}
}
located at:
https://leandrofavarin.com/exponential-backoff-rxjava-operator-with-jitter
This code doesn't compile. This line is wrong:
Function<Observable<out Throwable>, Observable<Long>>
Function only takes a single argument. I am really confused here. The person who wrote the article clearly indicates that he wrote this code and I assume it works or at least worked at the time he wrote it. But I doubt that Kotlin changed the interface for Function. Even if I remove the second parameter, the code will not compile because the apply function cannot be overridden as this is not part of the Function interface.
How can I fix this issue?
Looks like you are missing correct Function import. The following code works in my IDE.
import io.reactivex.Observable
import io.reactivex.functions.BiFunction
import io.reactivex.functions.Function
import java.util.concurrent.TimeUnit
class ExpBackoff(
private val jitter: Jitter,
private val delay: Long,
private val unit: TimeUnit,
private val retries: Int = 0
) : Function<Observable<out Throwable>, Observable<Long>> {
#Throws(Exception::class)
override fun apply(observable: Observable<out Throwable>): Observable<Long> {
return observable
.zipWith(Observable.range(1, retries), BiFunction<Throwable, Int, Int> { _, retryCount ->
retryCount
})
.flatMap { attemptNumber -> Observable.timer(getNewInterval(attemptNumber), unit) }
}
private fun getNewInterval(retryCount: Int): Long {
var newInterval = (delay * Math.pow(retryCount.toDouble(), 2.0) * jitter.get()).toLong()
if (newInterval < 0) {
newInterval = Long.MAX_VALUE
}
return newInterval
}
}
Is there a Kotlin Equivalent of C#'s Task.WhenAll?
I came up with the code below, but I wonder if it is possible to write whenAll so that it only suspends once.
fun main(args: Array<String>) = runBlocking {
println("Start")
val serviceA = KotlinServiceA()
val serviceB = KotlinServiceB()
val deferredA = async(CommonPool) { serviceA.operationA() }
val deferredB = async(CommonPool) { serviceB.operationB() }
var tasks = arrayOf(deferredA, deferredB)
tasks.whenAll()
println("End")
}
suspend fun Array<Deferred<Unit>>.whenAll() : Unit {
for (task in this) {
task.await()
}
}
There is a awaitAll() function that does the job.
val deferredArray: Array<Deferred<Unit>> = arrayOf()
val awaitAllArray = awaitAll(*deferredArray)
If you work with Collection then you can use the awaitAll() extension function
val deferredList: List<Deferred<Unit>> = listOf()
val awaitAllList = deferredList.awaitAll()
I wrote down this code:
open class Test(){
override fun toString(): String {
return "This is test!"
}
}
fun createTestX(): Test {
return object : Test() {
override fun toString(): String {
return super.toString() + "XXX"
}
}
}
fun main(args: Array<String>) {
val x = createTestX()
println(x)
}
It works as expected but I am curious whether is it possible to change method of instance using for example lambda like this:
val x = Test()
x.toString = () -> x.toString() + "XXX"
What you can do
class C {
var example:()->String = this::toString
}
fun main(args: Array<String>) {
val c = C()
println(c.example())
c.example = {"ABCDEF"}
println(c.example())
}
Limitations
Although this works for swapping fields, you cannot use it to override methods. This can be worked around by defining the method to invoke the field.
class C {
var example:()->String = {"ABC"}
override fun toString() = example()
}
fun main(args: Array<String>) {
val c = C()
println(c)
c.example = {"DEF"}
println(c)
}
Output:
ABC
DEF