Kotlin Strings

1.
  fun findDuplicates(input: String) {
    val charFrequencyMap = mutableMapOf<Char, Int>()

    for (char in input) {
        charFrequencyMap[char] = charFrequencyMap.getOrDefault(char, 0) + 1
    }

    println("Duplicate characters in the string:")
    for ((char, frequency) in charFrequencyMap) {
        if (frequency > 1) {
            println("$char - $frequency times")
        }
    }
}

fun main() {
    val testString = "programming"

    findDuplicates(testString)
}

2.
fun reverseString(input: String): String {
    val charArray = input.toCharArray()
    val reversedCharArray = CharArray(charArray.size)

    for (i in charArray.indices) {
        reversedCharArray[i] = charArray[charArray.size - 1 - i]
    }

    return String(reversedCharArray)
}

fun main() {
    val originalString = "Hello, Kotlin!"
    val reversedString = reverseString(originalString)

    println("Original String: $originalString")
    println("Reversed String: $reversedString")
}

3. 
fun areAnagrams(str1: String, str2: String): Boolean {
    // Remove spaces and convert to lowercase for case-insensitive comparison
    val cleanedStr1 = str1.replace("\\s".toRegex(), "").toLowerCase()
    val cleanedStr2 = str2.replace("\\s".toRegex(), "").toLowerCase()

    // Check if the lengths are the same
    if (cleanedStr1.length != cleanedStr2.length) {
        return false
    }

    // Create character frequency maps
    val charFrequency1 = mutableMapOf<Char, Int>()
    val charFrequency2 = mutableMapOf<Char, Int>()

    // Update character frequencies for str1
    for (char in cleanedStr1) {
        charFrequency1[char] = charFrequency1.getOrDefault(char, 0) + 1
    }

    // Update character frequencies for str2
    for (char in cleanedStr2) {
        charFrequency2[char] = charFrequency2.getOrDefault(char, 0) + 1
    }

    // Compare character frequencies
    return charFrequency1 == charFrequency2
}

fun main() {
    val string1 = "listen"
    val string2 = "silent"

    if (areAnagrams(string1, string2)) {
        println("$string1 and $string2 are anagrams.")
    } else {
        println("$string1 and $string2 are not anagrams.")
    }
}

4. 
fun generatePermutations(input: String, current: String = "", result: MutableList<String>) {
    if (input.isEmpty()) {
        result.add(current)
        return
    }

    for (i in input.indices) {
        val remaining = input.substring(0, i) + input.substring(i + 1)
        generatePermutations(remaining, current + input[i], result)
    }
}

fun findAllPermutations(input: String): List<String> {
    val result = mutableListOf<String>()
    generatePermutations(input, "", result)
    return result
}

fun main() {
    val testString = "abc"
    val permutations = findAllPermutations(testString)

    println("Permutations of $testString:")
    for (permutation in permutations) {
        println(permutation)
    }
}


  5.
fun containsOnlyDigits(input: String): Boolean {
    for (char in input) {
        if (char !in '0'..'9') {
            return false
        }
    }
    return true
}


6.
fun findDuplicates(input: String): List<Char> {
    val charFrequencyMap = mutableMapOf<Char, Int>()
    val duplicates = mutableListOf<Char>()

    for (char in input) {
        charFrequencyMap[char] = charFrequencyMap.getOrDefault(char, 0) + 1
        if (charFrequencyMap[char] == 2) {
            duplicates.add(char)
        }
    }

    return duplicates
}

7.
fun countVowelsAndConsonants(input: String): Pair<Int, Int> {
    val vowels = "aeiouAEIOU"
    var vowelCount = 0
    var consonantCount = 0

    for (char in input) {
        if (char.isLetter()) {
            if (char.toLowerCase() in vowels) {
                vowelCount++
            } else {
                consonantCount++
            }
        }
    }

    return Pair(vowelCount, consonantCount)
}

8.
fun findCharOccurrences(input: String, targetChar: Char): Int {
    return input.count { it == targetChar }
}

9.
fun firstNonRepeatedChar(input: String): Char? {
    val charFrequencyMap = mutableMapOf<Char, Int>()

    for (char in input) {
        charFrequencyMap[char] = charFrequencyMap.getOrDefault(char, 0) + 1
    }

    for (char in input) {
        if (charFrequencyMap[char] == 1) {
            return char
        }
    }

    return null
}

10.
fun reverseWords(sentence: String): String {
    val words = mutableListOf<String>()
    var currentWord = StringBuilder()

    for (char in sentence) {
        if (char.isWhitespace()) {
            if (currentWord.isNotEmpty()) {
                words.add(currentWord.toString())
                currentWord.clear()
            }
        } else {
            currentWord.append(char)
        }
    }

    if (currentWord.isNotEmpty()) {
        words.add(currentWord.toString())
    }

    return words.reversed().joinToString(" ")
}

fun main() {
    val testSentence = "Hello Kotlin World"

    val reversedSentence = reverseWords(testSentence)

    println("Original Sentence: $testSentence")
    println("Reversed Words: $reversedSentence")
}