Kotlin Coding Test Course, DNA Password

Coding tests play an important role in the hiring process of software developers, with many companies devising various problems to evaluate candidates’ algorithm problem-solving skills. In this chapter, we will take a closer look at how to solve the ‘DNA Password’ problem using Kotlin.

Problem Description

The DNA Password problem has the following conditions:

  • A DNA password is a string composed of the letters A, C, G, and T.
  • You need to find a substring in the given DNA string that meets specific conditions.
  • Each DNA string must contain at least M of specific characters.

For example, if the DNA string is “ACGTACGT” and M=2, then ‘A’ must appear at least twice, and ‘C’ must appear at least twice.

Example Problem

Given DNA string: ACGTACGT
Required character count: M=2
Required DNA characters: {‘A’, ‘C’}

Goal

The goal is to find all substrings in the given DNA string that satisfy the required characters and count them.

Problem-Solving Approach

To solve this problem, we will use the sliding window technique. This technique involves moving a window over the given string while checking the required character count.

Explanation of the Sliding Window Technique

The sliding window proceeds through the following steps:

  • Set the starting and ending points of the window and check if the initial state meets the conditions.
  • Move the window while checking the number of required characters at each position.
  • If the number of characters meets the condition, increase the count.

Kotlin Code Implementation

Here is the Kotlin code to solve the DNA Password problem:


fun countDnaPasswords(dna: String, requiredChars: Set, minCount: Int): Int {
    val charCount = mutableMapOf()
    var validPasswords = 0
    var left = 0

    for (right in dna.indices) {
        charCount[dna[right]] = charCount.getOrDefault(dna[right], 0) + 1

        while (requiredChars.all { charCount.getOrDefault(it, 0) >= minCount }) {
            validPasswords++
            charCount[dna[left]] = charCount[dna[left]]!! - 1
            if (charCount[dna[left]] == 0) {
                charCount.remove(dna[left])
            }
            left++
        }
    }

    return validPasswords
}

// Example usage
fun main() {
    val dna = "ACGTACGT"
    val requiredChars = setOf('A', 'C')
    val minCount = 2
    println(countDnaPasswords(dna, requiredChars, minCount))  // Output: 6
}

Code Explanation

The code above operates with the following logic:

  • Function Definition: The countDnaPasswords function takes the DNA string, a set of required characters, and the minimum number of required characters as parameters.
  • Initialization of Count: It initializes a map to count the occurrence of required characters.
  • Sliding Window Implementation: It traverses the string using a right pointer while updating the count of each character.
  • Condition Check: When all required characters are satisfied, it increments the count and moves the left pointer to reduce the window.

Complexity Analysis

The time complexity of the above algorithm is O(n). This is because it checks the required characters by traversing the string once. The additional space complexity is O(1), which may vary depending on the number of required characters, but since it stores a maximum of 4 characters, it is constant space.

Conclusion

In this post, we learned the sliding window technique through the DNA Password problem and explored how to solve it using Kotlin. These algorithm problems are very useful in the job preparation process and will help with coding test preparation. It is recommended to modify and apply the code to various situations and practice more problems.

In the next post, we will cover a wider range of algorithm problems, so please stay tuned!