Utilice Kotlin para resolver el problema de las combinaciones de letras de números de teléfono con retroceso

17. Combinaciones alfabéticas para números de teléfono.

Dificultad moderada

2474

Dada una  2-9 cadena que contiene solo números, devuelve todas las combinaciones posibles de letras que puede representar. Las respuestas se pueden devolver en  cualquier orden  .

La asignación de números a letras se proporciona de la siguiente manera (igual que para las teclas del teléfono). Tenga en cuenta que 1 no corresponde a ninguna letra.

Ejemplo 1:

输入： dígitos = "23"
输出： ["ad","ae","af","bd","be","bf","cd","ce","cf"]

Ejemplo 2:

Entrada: dígitos = ""
 Salida: []

Ejemplo 3:

Entrada: dígitos = "2"
 Salida: ["a","b","c"]

pista:

• 0 <= digits.length <= 4
• digits[i] es  ['2', '9'] un número en el rango.

Aprobados 696.168 Comprometidos 1.198.761

 respuesta:

Primero definimos un alfabeto que asigna números a las combinaciones de letras correspondientes. A continuación, se define un conjunto de resultados result. En la función letterCombinations, primero juzgamos el caso especial, si la cadena numérica está vacía, luego devolvemos una lista vacía. De lo contrario, comenzamos a llamar recursivamente a la función de rastreo backtrack.

En la función de retroceso, primero juzgamos si se ha alcanzado el final de la cadena numérica y, de ser así, agregamos la cadena combinada actual al conjunto de resultados. De lo contrario, tomamos la combinación de letras correspondiente al número actual y, para cada letra, la agregamos a la cadena combinada, llamamos a la backtrackfunción de forma recursiva y finalmente eliminamos la letra de la cadena combinada (regresando al paso anterior).

De esta forma, cuando regrese la función de retroceso, podremos obtener todas las combinaciones de letras.

class Solution {
     private val letterMap = arrayOf("", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz")
    private val result = mutableListOf<String>()
    fun letterCombinations(digits: String): List<String> {
        if (digits.isEmpty()) {
            return emptyList()
        }
        backtrack(digits, 0, StringBuilder())
        return result
    }
    private fun backtrack(digits: String, index: Int, combination: StringBuilder) {
        if (index == digits.length) {
            result.add(combination.toString())
            return
        }
        val digit = digits[index].toString().toInt()
        val letters = letterMap[digit]
        for (i in letters.indices) {
            combination.append(letters[i])
            backtrack(digits, index + 1, combination)
            combination.deleteCharAt(combination.length - 1)
        }
    }
}

El método de retroceso es una solución violenta, curiosamente no ha logrado repeticiones ni omisiones, aunque es exhaustivo, recoge todos los resultados que se ajustan a la situación. Si se dominan todos los métodos de retroceso, el juego de Sudoku deja de tener sentido.