DEV Community: Chetan garg

Untangle your String on Java/Kotlin

Chetan garg — Sun, 15 May 2022 07:00:04 +0000

Originally Posted on https://chetangupta.net/strings/

In any Programming languages to perform any kind of computation you always work with Numeric(Int, float, double etc), Boolean and Strings kind of data. They are said to be core or primitive data types which you need even for creating complex structures/classes, and know these in detail would always make help you design better code, and choose correct combination of data to get accurate outputs from your functions/programs.

In this Article we will be diving deep into concept of String. Understand how they work in Java, and what all operations you can perform on them, so without any dues lets get started!

What is a string in java?

String?, first question that should pop into you mind is what are they? and how do they look like? and answer from them are quiet simple, just like in our English Grammer, String are nothing but collections are some characters (alphabets and symbols) put together. It doesn't a string that you make sense or not, till is a group of characters its a string. For example “This is a sample String”, or even “zxczxvc adsad qwe” is also a string.

Different programming languages have different way to represent string, for example some represent it like ‘hello world’ or “hello world”, point to be noted is that string can start from single quotes - ‘ or double Quotes - “”. Also by Language design, there is a possibility language doesn't support string types directly, they might support Character as the primitive type and Strings could be formed with combination of these Characters. If a Language supports Character type then character always starts with single quotes and String will Start with double quotes.

Anyways enough with the background, coming back to the language we are here to learn which is TADA… Java, String here is not a primitive datatype, even thou it comes packed with the language. Java Supports Character type ie. char data type. lets look at its example :

Example of Character type :

char thisIsa = 'a';
char thisIsA = 'A';

Just for your information thisIsa is not equal to thisIsA. There is lot to learn about character we wont be digging deep into it (you can learn more about them from here → https://chetangupta.net).

Example of String type :

    String thisIsA = "A";
    String thisIsa = "a";

Same go there thisIsa is not equal to thisIsA, as Strings are case sensitive. hope you got the gist and some background about strings now…

If so, riddle me this?

    char thisIsA = 'A';
    String thisIsAlsoA = "A";

Since we have said String are collection of sequence of Character will String variable thisIsAlsoA is equal to thisIsA? If your curious enough think, if you couldn't find the stick around till the end of the article…

How to create a string object?

Let’s go a layer deep in String creation process in Java. The way we have created String using double quotes is called creating String Literal.

Example :

    String a = "A";
    String greet = "Hello World!";
    String pokemon = "Pikachu";

Other way to create it is using String Object, since we know in Java object creation is done using new operator thus we will create string like String apple = new String("apple");

Some more example :

    String a = new String("A");
    String greet = new String("Hello World!");
    String pokemon = new String("Pikachu");

You might think what is the difference? and also why should I create it using Object method, look more lengthy? Well that you need to understand what actually is happening under the hood in Java memory model.

When we create String Literal, JVM looks in the String Pool to check same value already exist or not. If found it would return the object reference, if not then it create new string object with given value and stores in String pool.

P.S : To learn more about String Pool checkout https://chetangupta.net.

And When we create object using new operator, then two things happen, the string value that we passed would check and placed in String pool, but the object of String is created into heap memory. Thus this method would take longer time to execute, other side to keep in mind is that it will construct a new object every time.

Okay, knowing this background is good but how does it explain the new operator use case ?
Let’s understand :

A String literal is a String Object, but a String Object is not always a String literal. Literal also represents fixed values i.e. constants, this means String literals once created cannot be modified thus its often said that Java Strings are immutable. we will discuss more about them later. But String Object is different its is designed to be mutated.

Thus whenever we are dealing string with requires lot of updation we will prefer String Objects over String Literals.

Always prefer to use StringBuffers or StringBuilders to make String Objects that are required lots of modifications. Go for StringBuilders cause they are modern than StringBuffers and have more functionality.

Example :

    StringBuilder greetBuilder = new StringBuilder("");

    greetBuilder.append("hello");
    greetBuilder.append(" ");
    greetBuilder.append("World");
    greetBuilder.append("!");

    String greet = greetBuilder.toString();
    System.out.println(greet) // output : hello World!

Hoping you now have understanding of the role of String Objects vs String Literals.

Strings Operations and Methods :

Now here comes the interesting part, let’s explore what the possible operation we can perform over String data-type :

Length of String:

If you want to know the length of the string i.e. total number of characters int the String, then use function length() over string example :

    String apple = "Apple";
    println(apple.length()); // output --> 5
Character at Index :

Since String is a sequence of character we can get character according to a given index. So we can get character at a index using charAt(index)

Example :

    // if we want to get `l` from string apple then
    String apple = "Apple";
    println(apple.charAt(3)); // output --> `l`

Note : Do understand that Strings are immutable i.e. you can read value at index but cannot update value on the given index, i.e there is not setCharAt(index) like function on String.

Concatenation/Adding of Strings :

We can add two string i.e. also called Concatenation into single string using concat() function .
Note : the new concatenated string that we get after operation will be new string, cause String are immutable.

Example :

    String apple = "Apple";
    String orange = "Orange";
    println(apple.concat(orange)); // output --> AppleOrange
    println(orange.concat(apple)); // output --> OrangeApple

SubString :

Substring means taking a part of string based on given indexes. There are two overloaded function method for this :

subString(int startIndex) : String : it will return string from start index to end of string
subString(int startIndex, int endIndex):String : it will return string from start index to the end index

Example :

    String orange = "Orange";
    println(orange.substring(/*StartIndex*/4)); // output --> ge
    println(orange.substring(/*StartIndex*/1,/*EndIndex*/5)); // output --> rang

Contains :

We use Contains to check if String contains another string or not. Note: in background it checks for CharSequence for faster evaluation than check each words. (learn more about that from here: https://chetangupta.net.

Example :

    String orange = "Orange";
    println(orange.contains("range")); // output --> true
    println(orange.contains("apple")); // output --> false

Join Strings :

Join as name suggest it would join two strings, but you might wonder what is the difference between join and concat?

Just look the parameters they are receiving, for Join you can transfer ‘n’ number for strings but for concat it would work only two strings,
Join as ability to provide delimiter/separator i.e. symbol to use when it is merging the String.
Unlike concat, Join is a static function over String class .

Example :

    String apple = "Apple";
    String orange = "Orange";
    String berry = "StrawBerries";
    String seperator = "|";
    println(String.join(seperator,apple,orange,berry)); 
    // output --> Apple|Orange|StrawBerries

Comparing to Strings:

Just for your knowledge when we perform a comparing operation, we are censored wether two items are equal, first item is greater than(>) second item or first item is smaller than(<) second item.

In Programming, comparison function returns integer value to represent same scenarios.

    if item1 == item2 then returns 0,
    if item1 > item2 then returns 1,
    if item1 < item2 then returns -1,

In String, these comparison is lexicographically(dictionary order) based i.e

    if string1 == string2 then returns 0
    if string1 > string2 then returns 1, (string 1 comes ahead in dictinoary order)
    if string1 < string2 then returns -1, (string 2 comes ahead in dictinoary order)

In Java, we have two functions for comparing string in Java.

compareTo() : This compares two string but is case sensitive.
compareToIgnoreCase() : This compares two string but is case in-sensitive.

Lets see example :

    // case sensitive comparison
    String apple = "Apple";
    println(apple.compareTo("Apple")); // output  --> 0
    println(apple.compareTo("apple")); // output  --> -32

    // case in-sensitive comparison
    String apple = "Apple";
    println(apple.compareToIgnoreCase("Apple")); // output  --> 0
    println(apple.compareToIgnoreCase("apple")); // output  --> 0

Casing in String :

We can control casing of our String character using two function :

toUpperCase() : this function upper case all of the characters in out string,
toLowerCase(): similarly this function lower case all of the characters in out string.

    String apple = "ApPlE";
    println(apple); // output --> ApPlE
    println(apple.toUpperCase()); // output --> APPLE
    println(apple.toLowerCase()); // output --> apple

Stripping White Space :

String values can often have white spaces in them, from beginning or in the end. Note : Space between the Characters are not white space. we can use trim() function to remove them.

    String appleTrimmed = " apple ".trim();
    println(appleTrimmed) // output --> apple
    println(appleTrimmed.length()) // output --> 5

Replace Character in String :

If you want to replaces character from old char to new character.

Note : Keep in mind replacing character is a string is not same process as setting character at some index in a string. Rule that Strings are immutable will also be applied there, thus when you try to replace a character you get a entire new string with replaced character.

Example :

    String apple = "apple";
    println(apple.replace("a","pinea")); // output --> pineapple

String Concatenation using “+” operator

We have already seen two ways to join two string, one is concat and other is join, but a very common pattern you will encounter you will see for concatenating two strings would be “+”.

Using “+” operator works very same with concat function. Example :

    String apple = "apple";
    String orange = "Orange";
    String berry = "StrawBerries";

    println(apple.concat(orange).concat(berry)); // output --> appleOrangeStrawBerries
    println(apple + orange + berry); // output --> appleOrangeStrawBerries

Which one should we use?

In our opinion comparing between “concat()” and “+”, “+” operator seems more readable, but be careful using it with numeric type data.

Example :

    int orangeCount = 5;
    int berryCount = 5;
    println("fruits count:" + orangeCount + berryCount); 
    // wrong output --> fruits count:55

    println("fruits count:" + (orangeCount + berryCount)); 
    // right output --> fruits count:10

But as we suggested this as same issue as concat, since Strings are immutable we are basically creating new string better and faster way would be to use StringBuilder.

Creating Format Strings

We have covered lot of the core functionalities of the string, and we can clearly see a use-case in which we are appending strings with string, float, numbers etc… what if we can have placeholder values in string and on runtime these place holder could be replaced with values we want to put?

This is what String.format() function does. We create a string with placeholder/specifiers and we populate them with the value, we also call such type of string as template strings.

We use different specifier for different type of data type, most commonly use once are :

%b for boolean,
%s for Strings,
%d for Integers only numbers
%f for floating point numbers

and others are there which you read more from here : https://chetangupta.net/

Example :

println(String.format("%s has %d apple, and %d oranges", "John Doe", 3, 2));
// output --> John Doe has 3 apple, and 2 oranges

Note : values are placed into the template position according to their occurrence in function parameter,

Compare to concat or plus operator this method is useful when you are working with very long strings. Performance wise its not as great as StringBuilder cause it need to parse entire string and parameters before generating string.

Escape character in Strings

While we are working with long string, if we try to break it into two parts most obvious thing which would come to your mind would be to press enter and continue with your string in next line, but if you try to do that compiler will treat you Syntax error, for instance :

    String message = " 
        I want to make 
        very lengthy String!
    ";

To do these kind of functionality, you need to use special characters for \n in the string for adding new line in the string.

    String message = "\nI want to make\nvery lengthy String!";
    /* 
    * Output :
    * I want to make
    * very lengthy String!
    */

Escaped Character :

\t → add horizontal tab 
\n → add new line
\’ → add single quotes in String
\” → add double quotes in String
\\ → add backslash in the String

Examples :

    String message = "Hello\tWorld!";
    println(message); // output --> Hello  World!

    message = "Hello\nWorld!";
    println(message); 
    /*
    * Output -->
    *  Hello
    *  World!
    */

    message = "Hello\'World\'!";
    println(message); // output --> Hello'World'!

    message = "Hello\"World!\"";
    println(message); // output --> Hello"World!"

    message = "Hello\\World!\\";
    println(message); // output --> Hello\World!\

Java Strings are Immutable

If you read entire article thoroughly you have head us repeating this statement again and again. This is because its the main mechanism by which Java Strings function.

Key reason of having String as immutable is to have benefit of caching, performance and safety.

String is the most widely used data structure in any program and JVM optimizes the amount of memory allocated for them by storing only one copy of each String in the String pool.

Thus caching the String literals and reusing them saves a lot of heap space because different String variables refer to the same object in the String pool saving crucial memory resource and improve performance of the application in general.

One added advantage of String being immutable makes them thread-safe so Strings in concurrent environment are safe to read and update.

Bonus : Riddle Solution

   char thisIsA = 'A';
    String thisIsAlsoA = "A";

is thisIsAlsoA is equal to thisIsA? this was the riddle we asked.

If you think Yes, then sorry mate! you are wrong. Conceptually you are right this should be correct but the issue is that Java is not dynamically typed language its a statically typed. Thus Types play major role here. Since type of String and char didn't match it failed. It wouldn’t have failed in language like JavaScript.

one more thing… String is collection of char right?, thus we can convert our String into Character Array using toCharArray() , since Array is a collection thus justifying our statement programatically and if we compare first index position of the array with the character it would be equal. Nice !

Conclusion

Lets have small recap :

We learned String is collection of sequence of Characters
In Java we can create String in two ways - String literals and String Objects
There are various operation that we can perform on strings - concat, length, compare and many more
What are special escape characters in Strings
Most importantly why String are Immutable!

We hope you have learned a lot and untangled all the mysteries and doubts around Java String. Until next time happy hacking!

Confused over reverse, reversed, and asReveresed ? in Kotlin

Chetan garg — Thu, 21 Apr 2022 19:04:52 +0000

Let’s solve a question and learn more about it.
Originally post on https://chetangupta.net/bbk8/

Hi, I’m back with another question, and it’s very common and easy. You might have done this zillions of times.
Question: Write a program to reverse an array or string :

Example :
Input1 :  arr[] = {4, 5, 1, 2}
Output : arr[] = {2, 1, 5, 4}

Try it put yourself 👨🏻‍💻👇🏻:
https://www.geeksforgeeks.org/write-a-program-to-reverse-an-array-or-string/

Well before we go into Kotlin’s standard library solution let’s look at ways to solve it manually :

Solution 1: Taking Extra Space

by taking extra space I mean we will use another list to reverse the list,

fun main() {
    val input1 = listOf(4, 5, 1, 2)
    println(input1.reverseExtraSpace()) // [2, 1, 5, 4]
}

fun List<Int>.reverseExtraSpace(): List<Int> {
    val result = mutableListOf<Int>()
    for (index in indices) {
        val lastIndex = lastIndex - index
        result.add(get(lastIndex))
    }
    return result
}

Vola! with lots of code we are done reversing our array!
Let’s analyze this approach and see the Pros and Cons :

Pros :

It’s an extension function — which means would only be visible on Receivers it’s assigned to, here Receiver is List and reverseExtraSpace function would be visible to this only. (we can make it more generalized using generics)
The input list is not getting modified i.e. after reversing if we made changes in the original list it would be accidentally reflected into the reversed list.
Mutations are scope in the body of the extension only, you get a read-only list from the return type. All in all this code is very safe and sound.

Cons :

It has to iterate over the entire list.
We take more space to store reversed list.

…huh.. what do you mean this approach is not good? The interviewer will ask to optimize for space.

Well when we are in an interview setting we have to show them our A-Game in terms of using your brain, but you need to explain to them as well writing code for correct and predictable behavior is much more important, than minor optimization. It should be the last part of your code evaluation metric unless it impacts the usability of the application.

but in case he didn’t agree and insist on the better solution then …

Solution 2 : Not Taking Extra Space

So we will not create any array.

fun main() {
    val input1 = listOf(4, 5, 1, 2)
    println(input1.reverseNoExtraSpace()) // [2, 1, 5, 4]
}
fun List<Int>.reverseNoExtraSpace(): List<Int> = with(this.toMutableList()) {
    val mid = lastIndex / 2
    (0..mid).forEach {
        val firstIndex = it
        val lastIndex = lastIndex - it
        val first = get(firstIndex)
        val last = get(lastIndex)
        //swap
        set(firstIndex, last)
        set(lastIndex, first)
    }
    this
}

and done! without using extra space.

It’s very easy to mess up implementation and loss the Pros of Solution 1, remember its important to understand what kind of data you are sending as input, exposing as output and scope in which mutation should be allowed.

Note in Kotlin that when we convert list to a Mutable list isn't a typecast, a new mutable list with the same items gets created. To remove that cost you need to take MutableList instead of List from the beginning.

Or you can use IntArray if you like.

Solution 3 : Using Standard Library Functions

Now the nice part, by going through these solutions you already have know-how under the hood reverse operation works. In Kotlin standard library uses solution 2 as its base.
On our List collection, we have two ways to reverse the order of the list:

reversed — https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/reversed.html
asReversed — https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/as-reversed.html

both of them returns list in reversed order, but when you use reversed any changes done in original list is not reflected in reversed list. Thus make it safer to use it with mutable collections.

Example :

val list = mutableListOf(1,2,3,4) // mutable list
val reversed   = list.reversed()
val asReversed = list.asReversed()
println(list) // [1,2,3,4]
println(reversed) // [4,3,2,1]
println(asReversed) // [4,3,2,1]
list.set(1,9)
println(list) // [1,9,3,4]
println(reversed) // [4,3,2,1]
println(asReversed) // [4,3,9,1]

Note — If you are using List which is a read-only collection this issue isn’t there at all. because you can’t modify a List unless you convert it into a Mutable List, and even if you try to convert it would be an entirely new list, not the same list which you have reversed. So for List using reversed and asReversed is similar.
but for a general rule, I will strongly recommend using reversed over asReversed.

Bonus Part — Reverse

Talking about Mutable-List, we have an additional reverse function — https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/reverse.html
it Reverses elements in the list in place which means :

val input = mutableListOf(1,2,3,4,5)
println(input) // [1, 2, 3, 4, 5]
input.reverse() // retuns Unit not a list i.e. updates the exisiting list
println(input) // [5, 4, 3, 2, 1]

i.e. use it wisely.

Conclusion 💆🏻‍♀️

That’s all folks! Hope this helps someone.
Hope you find it informative and if you have any feedback or post request or want to subscribe to my mailing list forms are below.

https://chetangupta.net/updates/

Do consider Clap to show your appreciation, until next time. Happy Hacking! 👩‍💻

BBK#6: Equal sides 🤝

Chetan garg — Wed, 20 Jan 2021 06:47:40 +0000

Don't be a Java-ish dev in a Kotlin-ish world, improve your knowledge about Koltin Standard Library and write better Kotlin code. ✌🏻 If your Java dev migrating to Kotlin this will help you learn a lot!

originally published on https://chetangupta.net/bbk7/

Question: For a given array, find Index N where the sum of integers to the left of N is equal to the sum of integers to the right of N, If there is no index that would make this return -1.

Example : 

for an array {1,2,3,4,3,2,1}
output would be 3 because at the 4th position of the array, 
the sum of left side of the index ({1,2,3}) and the sum of the right side of the index ({3,2,1}) both are equal to 6.

Try it put yourself :
👨🏻‍💻👉 Try Yourself

Some Code Philosophy Ranting..

I always categorize writing code into 3 levels.

Level 1 : Write for correctness

You just go all in without minding best practices or patterns, just aim for the right output on all of your use-cases. The only optimisation I suggest to do here is to keep your code readable and write descriptive names or at-least comments.

Level 2 : Refactor to make it maintainable

Once your code is working correctly, now is the time to make it maintainable, your aim is to preserve functionality, just update architecture, rename your variables, figure out ways to remove those comments and convert code into self expressive functions or variables. You DON'T change the functionality or algorithm used to solve the problem.

Level 3 : Optimize for memory and storage

90% of your code wouldn’t be needing this step if you have mastered level 1 and 2. You will come to this step only when its critical to business or to your app performance. Micro optimization just ruins your code, not make it good. Anyways In this step your aim is to keep algorithm and architecture intact don’t change it. You have to change data structure or replace internals of your functions with code which return out the same result in better performance.

Lets do it..

Naive Algorithm to solve this would be

Compute sum from first n items lets call it as leftSum
Compute sum remaining, i.e. n to last item of array, lets call it rightSum
if both sums are equal print the index, else print -1

Solution 1:

Same old imperative way. 😪


fun findEvenIndex(arr: IntArray): Int {

    var evenIndex = 0

    // Loop max till the size of array
    while (evenIndex != arr.size) {

        // sum accumulator loop
        var loopCounter = 0

        // indicates sum from left side
        var leftSum = 0

        // indicates sum of remaining items
        var rightSum = 0

        // loop till the end of list and compute left and write sums
        while (loopCounter != arr.size) {
            when{
                loopCounter < evenIndex -> leftSum += arr[loopCounter] 
                loopCounter == evenIndex -> {
                    leftSum+=arr[loopCounter]
                    rightSum+=arr[loopCounter]
                }
                else -> rightSum += arr[loopCounter]
            }
            ++loopCounter
        }

        // compare sum
        if (leftSum == rightSum) {
            // return found index
            return evenIndex
        } else {
            // proceed for second round in loop
            ++evenIndex
        }
    }

    // index not found
    return -1
}

// 👨🏻‍🔧 complexity : O(n^2)
// ⏱ performance : took 2.48 ms on my machine

This is an example how you don’t write the code, its fine when you are just getting started, but as your experience builds up, you need to make your code maintainable 👾.

Even with the descriptive naming without comments I need to create mental a map of every step and track what this code does. Also the common accumulator pattern issue of mutability is applied here.

Checkout why accumulator pattern in imperative style is bad.💡

checkout 👉 Accumulator|Fold-Reduce

Solution 2:

We were using an accumulator to calculate the sum, instead of that why don’t we split the array into smaller chunks and find the sum?

Let’s do that by using Sublist()
Sublist


fun findEvenIndex(arr: IntArray): Int {
    val list = arr.toList()
    for (index in arr.indices) {
        val leftSum = list.subList(0, index + 1).sum()
        val rightSum = list.subList(index, arr.size).sum()
        if (leftSum == rightSum) {
            return index
        }
    }
    return -1
}

// 👨🏻‍🔧 complexity : O(n)
// ⏱ performance : took 22.5 ms on my machine

SubList Ranting…

If you are coming from Java background, subList is the function that comes to your mind when you want to split the array on particular index, but there is an inherit issue hidden in this function, let's understand that with example.



  val list = mutableListOf(1, 2, 3, 4, 5)
  println(list)
  // output : [1, 2, 3, 4, 5]

  val subs = list.subList(0, 3)
  println(subs)
  // output : [1, 2, 3]

  println(list)
  // output : [1, 2, 3, 4, 5]

  list[0] = 5
  println(subs)
  // output : [5, 2, 3]

  println(list)
  // output : [5, 2, 3, 4, 5]

You see its using the same list reference to show you value in your subList, this could lead to accidental mutations, let's see next solution which is an example of Level 3 and also fixes this issue.

Solve many more 👇🏻

Big-Brain-Kotlin

Solution 3:
Another function that is available in Kotlin Stdlib that can split your array is Slice()
Slice

Unlike sublist it doesn’t use the same reference to the List, it generates a new copy. We also have sliceArray() which is specific to Arrays, instead of the List so we don’t have to covert our array to List and save one more computation.

fun findEvenIndex(arr: IntArray): Int {
    for (index in arr.indices) {
        val leftSum = arr.sliceArray(0 .. index).sum()
        val rightSum = arr.sliceArray(index .. arr.lastIndex).sum()
        if (leftSum == rightSum) {
            return index
        }
    }
    return -1
}

// 👨🏻‍🔧 complexity : O(n)
// ⏱ performance : took 2.48 ms on my machine

Nice, We have optimized our code from ~22 ms to ~2 ms and achieved Level 3.

There is one bonus way to solve it in more concise ways.
for that you need to check out my personal site BBK-7:Equal Sides 🤝

Until next time. Happy Hacking! 👩‍💻

👥 Social

BBK#5: The Morse Code 🤫

Chetan garg — Tue, 29 Dec 2020 06:08:10 +0000

I have a secret code for you to crack detective! 🕵️‍♀️

originally published on https://chetangupta.net/bbk-main/

This quiz was suggested by Rohan Singh on Twitter, sorry for the delay mate!

Question: You have received a secret message! unfortunately, you can't just read it, it is encoded in Morse code. Your task is to implement a function that would take the morse code as input and return a human-readable string. 3 spaces are used to separate words and
Extra spaces before or after the code have no meaning and should be ignored.

Message : -. - - - ..- …. .- …- . .- -… .. - . -… .-. .- .. -. ..-. - - .-. -.- - - - .-.. .. -.
val morseCode = "-.-- --- ..-   .... .- ...- .   .-   -... .. --.   -... .-. .- .. -.   ..-. --- .-.   -.- --- - .-.. .. -."  
// write a function that converts this MorseCode to English fun decodeMorse(morseCode:String):String{   
 // .. do stuff 
}

Given Morse Code Decoder

val morseDecoder = mapOf<String, String>(
        ".-" to "A",
        "-..." to "B",
        "-.-." to "C",
        "-.." to "D",
        "." to "E",
        "..-." to "F",
        "--." to "G",
        "...." to "H",
        ".." to "I",
        ".---" to "J",
        "-.-" to "K",
        ".-.." to "L",
        "--" to "M",
        "-." to "N",
        "---" to "O",
        ".--." to "P",
        "--.-" to "Q",
        ".-." to "R",
        "..." to "S",
        "-" to "T",
        "..-" to "U",
        "...-" to "V",
        ".--" to "W",
        "-..-" to "X",
        "-.--" to "Y",
        "--.." to "Z",
        ".----" to "1",
        "..---" to "2",
        "...--" to "3",
        "....-" to "4",
        "....." to "5",
        "-...." to "6",
        "--..." to "7",
        "---.." to "8",
        "----." to "9",
        "-----" to "0",
        "" to " ",
        ".-.-.-" to ".",
        "--..--" to ",",
        "---..." to ".",
        "..--.." to "?",
        "-.-.--" to "!",
        "...---..." to "SOS",
        "-....-" to "''",
        "-..-." to "/",
        "-.--.-" to "()",
        ".--.-." to "@",
        "-...-" to "="
)

Try it put yourself :
👨🏻‍💻👉 Try Yourself

Solution 1:

Same old imperative way. 😪

fun decodeMorse(code: String): String {
    val morseWords = code.split("   ")
    val humanized = StringBuilder()
    for (morseWord in morseWords) {
        val morseChars = morseWord.split(" ")
        for (morseChar in morseChars) {
            if (morseChar.isNotEmpty()) {
                humanized.append(morseDecoder.get(morseChar))
            }
        }
        humanized.append(" ")
    }
    return humanized.toString()
}
// 👨🏻‍🔧 complexity : O(n^2)
// ⏱ performance : took 509.0 us on my machine

Btw there is nothing wrong in this way, just the loops make it very expressive, there is no issue of mutations and accidental updates in it. 🙌🏻

Checkout why accumulator pattern in imperative style is bad.💡

checkout 👉 Accumulator|Fold-Reduce

Solution 2:

Imperative equivalent code in functional style | Stdlib function

fun decodeMorse(code: String): String {
    return code.trim()
        .split("   ")
        .joinToString(separator = " ") { word ->
            word.split(" ")
                    .map { letter -> morseDecoder[letter] ?: "" }
                    .joinToString(separator = "")
        }
}
// 👨🏻‍🔧 complexity : O(n^2)
// ⏱ performance : took 639.0 us on my machine

The performance hit of there is due to joinToString operation one at the outer loop and multiple times into the inner loop, not good! dood (dude)...☹️

learn joinToString and it's advanced use cases 💡

checkout 👉 list-to-string

Solution 3:

What if we call it once? , if we eliminate the nesting, i.e flatten our words to char?

👨🏻‍💻 Let's flatten our List using FlatMap

flatMap

fun decodeMorse(code: String) = code
        .split("  ")
        .flatMap { it.split(" ") }
        .map {morseDecoder.get(it)?:"" }
        .joinToString("")

// 👨🏻‍🔧 complexity : O(n)
// ⏱ performance : took 464.0 us us on my machine
Whola!

Solution 4:

Or Change the way you are solving this problem 💁‍♀️

fun decodeMorse(code: String): String {
    return code.trim()
        .replace("  ", " ")
        .split(" ")
        .map { morseDecoder[it]?:"" }
        .joinToString(" ")
}
// 👨🏻‍🔧 complexity : O(n)
// ⏱ performance : took 441.0 us on my machine

Don't get attached to a solution!

Conclusion

The aim of these articles is not hated on Java, but to help people learn various ways in which they can write the same logic better and more Kotlin standard library-focused way.
Hope you find it informative and if you have any feedback or post request or want to subscribe to my mailing list forms are below.

Until next time. Happy Hacking! 👩‍💻

Solve many more 👇🏻

Big-Brain-Kotlin

Data Structures in Kotlin | Linked-List

Chetan garg — Wed, 23 Dec 2020 04:02:04 +0000

Hola Amigos! 🙌, I do tech blogging at AndroidBites, do check it out.

This page is dedicated to my learning of DataStructure. I never took time to learn them up and always been scared of them, but actual growth comes from fighting your fears, so I have decided to create my own version of them and entirely in Kotlin.
So my aim is to :

Create my own data structure implementations
provide them with the behavior as close the standard library
Battle-tested and Entirely in Kotlin

I believe in sharing so if you like to share too your always invited to contribute! 🤩
Let's grow together 💪🏻 ! happy hacking 💻.
P.S : Don't forget to show love and support 🥰 by sharing! & providing feedback! 📝 and PRs are always welcome

Chao!

📖 Repository

DataStructure-in-Kotlin

⏰ MileStones

Linked-List 1 : Create| Read | Update | Delete

👥 Social

Copyright [2020] [Chetan gupta] [chetangupta.net]
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

     http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.

AndroidBites | Deepest Dive into View-Binding

Chetan garg — Sun, 06 Dec 2020 09:46:45 +0000

I'm pretty late to the party but here is my blog on view-binding,
It's pretty much more in-depth than others you would find in the community.

Glossary

Is data binding not working in all the modules? Why your fields are not getting generated?
How to view the source code of your generated binding classes?
Generated classes are Kotlin or Java? and why?
Do View-binding views are never null?
How to access included views? and tags?
How to bind Activities, Fragments, Adapters, and CustomViews?
When to use bind and Inflate?
Controlling ViewBinding Generation?
Reducing boilerplate code with Delegates and Base-Class for ViewBinding in Activity and Fragments?
Common mistakes and Anti-patterns in ViewBinding?

Hope to see you on the other side...

👉 AndroidBites | View-Binding

Until next time. Happy Hacking! 👩‍💻

BigBrainKotlin#4 | Among Us

Chetan garg — Mon, 30 Nov 2020 08:19:22 +0000

Don't be a Java-ish dev in Kotlin-ish world, improve your knowledge about Koltin Standard Library and write better Kotlin code. ✌🏻 If your Java dev migrating to Kotlin this will help you learn alot!

The aim of these articles is not hate on Java, but to help people learn various ways in which they can write the same logic better and more Kotlin standard library focused way.

Question:
Find the imposter from the given array with at least 3 items, it's either entirely comprised of odd integers or entirely comprised of even integers except for a single integer N. Write a method that takes the array as an argument and returns this "Imposter" N...

imposter(arrayOf(2,6,8,-10,3)) => returns 3

imposter(arrayOf(206847684,1056521,7,17,1901,21104421,7,1,35521,1,7781)) => returns 206847684

imposter(arrayOf(Integer.MAX_VALUE, 0, 1))=> returns 0

Try it out yourself, or submit it in the comments before checking out my solutions.

👉 BigBrainKotlin#4

Hope to see you on the other side...

Until next time. Happy Hacking! 👩‍💻

BigBrainKotlin#3 | Spin My Words...

Chetan garg — Mon, 30 Nov 2020 08:15:54 +0000

The aim of these articles is not hate on Java, but to help people learn various ways in which they can write the same logic better and more Kotlin standard library focused way.

Question:
Write a function that reversed all words in the String whose length is five or more letter words reversed.

spinWords( "Hey fellow warriors" ) => returns "Hey wollef sroirraw" 
spinWords( "This is a test") => returns "This is a test" 
spinWords( "This is another test" )=> returns "This is rehtona test"

Try it out yourself, or submit it in the comments before checking out my solutions.

👉 BigBrainKotlin#3

Hope to see you on the other side...

Until next time. Happy Hacking! 👩‍💻

BigBrainKotlin#2 | Mumbling...

Chetan garg — Mon, 30 Nov 2020 08:13:18 +0000

The aim of these articles is not hate on Java, but to help people learn various ways in which they can write the same logic better and more Kotlin standard library focused way.

Question:
This time no story, no theory. The examples below show you how to do :

mummble("abcd") -> "A-Bb-Ccc-Dddd"
mummble("RqaEzty") -> "R-Qq-Aaa-Eeee-Zzzzz-Tttttt-Yyyyyyy"
mummble("cwAt") -> "C-Ww-Aaa-Tttt"

Try it out yourself, or submit it in the comments before checking out my solutions.

👉 BigBrainKotlin#2

Hope to see you on the other side...

Until next time. Happy Hacking! 👩‍💻

BigBrainKotlin#1 | Find Max and Min

Chetan garg — Mon, 30 Nov 2020 08:09:47 +0000

The aim of these articles is not hate on Java, but to help people learn various ways in which they can write the same logic better and more Kotlin standard library focused way.

Question:
Print the Highest and Lowest number from the input string.
8 3 -5 42 -1 0 0 -9 4 7 4 -4

Try it out yourself, or submit it in the comments before checking out my solutions.

👉 BigBrainKotlin#1

Hope to see you on the other side...

Until next time. Happy Hacking! 👩‍💻

Implement LRU Caching into your Repository | Androidbites

Chetan garg — Mon, 07 Sep 2020 04:48:33 +0000

Hi Devs, Repository pattern is available in almost every codebase, people often design it pretty well but often miss out on the caching behavior from It and rely on retrofit caching or Live data for caching data or put on some hack in the android lifecycle to only get data once to save APIs calls.

follow up the following article and learn how to implement LRU cache in your repository in 5 easy steps.

👉 AndroidBites|cache-repository

Hope to see you on the other side...

Until next time. Happy Hacking! 👩‍💻

3 List To String Tips You probably didn't know

Chetan garg — Sun, 23 Aug 2020 18:01:18 +0000

Hi #androidDevs, This is Androidbites where I try to break down a small concept into an understandable code snippet and share my learning experience with it.

String to List conversions and back to it i.e List to String are very much crucial operations need to know if you're into competitive programming. Today let's explore how to do that in Kotlin...

to learn more advance operations that can be performed on the joinToString() follow up from:

https://chetangupta.net/list-to-string/

see you on the other side 😈

Happy Hacking!

Follow me: LinkedIn : bit.ly/ch8n-linkdIn Medium : bit.ly/ch8n-medium Twitter: bit.ly/ch8n-twitter StackOverflow : bit.ly/ch8n-stackOflow CodeWars : bit.ly/ch8n-codewar Portfolio : bit.ly/ch8n-home Github : bit.ly/ch8n-git Instagram : bit.ly/ch8n-insta Youtube: bit.ly/ch8n-youtube