Okay so I rewrote the code, is this more optimized...

# announcements

[sbeve]

Okay so I rewrote the code, is this more optimized? how can i make stuff better

fun rotateLetter(input: Char, rotations: Int): Char {
    var variableInput = input.toInt()
    val isUpperCase = variableInput in 65..90
    val isLowerCase = variableInput in 97..112

    when {
        isUpperCase -> {
            if (variableInput + rotations <= 90) variableInput += rotations
            else variableInput = 64 + (variableInput + rotations - 90)
        }
        isLowerCase -> {
            if (variableInput + rotations <= 122) variableInput += rotations
            else variableInput = 96 + (variableInput + rotations - 122)
        }
        else -> return input
    }

    return variableInput.toChar()
}

[ephemient]

may fail if rotations !in 0..25, that's something that % can address

[sbeve]

true

[sbeve]

idk how to fix that then

[ephemient]

it is possible to bind it all at once,

return when (val variableInput = input.toInt()) {
    65..90 -> { ... }
    97..112 -> { ... }
    else -> input
}

but that isn't really an optimization, just style

[sbeve]

i updated the code a little

[sbeve]

fun rotateLetter(input: Char, rotations: Int): Char {
    var variableInput = input.toInt()

    when {
        input.isUpperCase() -> {
            if (variableInput + rotations <= 90) variableInput += rotations
            else variableInput = 64 + (variableInput + rotations - 90)
        }
        input.isLowerCase() -> {
            if (variableInput + rotations <= 122) variableInput += rotations
            else variableInput = 96 + (variableInput + rotations - 122)
        }
        else -> return input
    }

    return variableInput.toChar()
}

[sbeve]

this is better

[ephemient]

you should learn what % modulus does, or check that rotations is in bounds

[sbeve]

i know what it does

[sbeve]

but i can't put my finger on how to use it

[ephemient]

no, that's worse: `isUpperCase()`/`isLowerCase()` will return true for non-ASCII characters

[sbeve]

O

[ephemient]

e.g. Á

[sbeve]

that isn't gonna be a problem is it?

[ephemient]

it is, because 'Á'.toInt() == 193

[sbeve]

oh

[sbeve]

anyway i could still use isUpperCase() and not face any problems?

[ephemient]

not without more checking, no

[sbeve]

not even with the help of %

[sbeve]

?

[ephemient]

no, because the other characters are not so nicely arranged

[sbeve]

okay i will change that back to how it was. How could i use the modulus function to not face that issue you told me about earlier?

[ephemient]

e.g. ÁB́Ć..Ź does not form a contiguous range

[sbeve]

O

[ephemient]

in fact, most of those do not even have a composed representation

[sbeve]

i see

[sbeve]

then i am gonna use the previous method of checking the case

[sbeve]

I also need to figure out how to use the modulus function

[sbeve]

i mean i know how it works

[sbeve]

but i dk how to use it in this particular scenario

[ephemient]

my code yesterday used it. try figuring it out (even if you ignore the bit twiddling)

[sbeve]

okay i will try to understand it. the modulus function is kinda hard to work with imo like picturing whats happening becomes complicated

[Animesh Sahu]

fun rotateLetter(input: Char, rotations: Int): Char =
    when {
        input in 'A'..'Z' -> {
            if (input + rotations % 26 <= 'Z') input + rotations % 26
            else input + rotations % 26 - 25
        }
        input in 'a'..'z' -> {
            if (input + rotations % 26 <= 'z') input + rotations % 26
            else input + rotations % 26 - 25
        }
        else -> input
    }

How about shortened 😛

[sbeve]

thank u