algorithm: letter combinations

[hiitesh1127]

 know more

It is one of the most common Backtracking Problems asked during interviews

Describe your change:

• Add an algorithm?
• Fix a bug or typo in an existing algorithm?
• Documentation change?

Checklist:

• I have read CONTRIBUTING.md.
• This pull request is all my own work -- I have not plagiarized.
• I know that pull requests will not be merged if they fail the automated tests.
• This PR only changes one algorithm file. To ease review, please open separate PRs for separate algorithms.
• All new JavaScript files are placed inside an existing directory.
• All filenames should use the UpperCamelCase (PascalCase) style. There should be no spaces in filenames.
  Example:UserProfile.js is allowed but userprofile.js,Userprofile.js,user-Profile.js,userProfile.js are not
• All new algorithms have a URL in its comments that points to Wikipedia or other similar explanation.
• If this pull request resolves one or more open issues then the commit message contains Fixes: #{$ISSUE_NO}.

[appgurueu]

How is this a backtracking problem? At first glance this appears to be a simple combinatorial problem: Finding the cross product of the sets of possible letters for all numbers.

[hiitesh1127]

@appgurueu Sir you are correct when there are just two digits in the provided string, but if we analyze the scenario of three digits, we notice that we need to backtrack for the second digit string.

[appgurueu]

@appgurueu Sir you are correct when there are just two digits in the provided string, but if we analyze the scenario of three digits, we notice that we need to backtrack for the second digit string.

I wrote the following solution which got accepted in Go:

func letterCombinations(digits string) []string {
    if digits == "" {
        return []string{}
    }
    letters := [8]string{"abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"}
    res := []string{""}
    for _, digit := range digits {
        nextRes := []string{}
        for _, letter := range letters[digit - '2'] {
            for _, str := range res {
                nextRes = append(nextRes, str + string(letter))
            }
        }
        res = nextRes
    }
    return res
}

this problem does not inherently require recursion or backtracking? As said, it's just the cartesian product $\{a, b, c\} \times \{d, e, f\} \times \{g, h, i\}$ f.E. for $123$.

[hiitesh1127]

Okay Sir,

I guess your solution is iterative and mine is recursive
My backtracking approach for this solution is
we need to backtrack for node no 3's

https://www.interviewbit.com/blog/letter-combinations-of-a-phone-number/

[appgurueu]

Backtracking is a class of algorithm for finding solutions to some computational problems, notably constraint satisfaction problems, that incrementally builds candidates to the solutions, and abandons a candidate as soon as it determines that the candidate cannot possibly be completed to a valid solution.

- from https://en.wikipedia.org/wiki/Backtracking

I don't see how this definition is met - no "candidates" are "abandoned" (if I'm missing something, please explain). All I see is a simple combinatorial algorithm. LeetCode and InterviewBit are probably getting their terminology wrong. @raklaptudirm your opinion? Should this go under "Backtracking" or just "Recursion"?

In the Lua repo I prefer to categorize algorithms not by the applied "strategy", but rather strictly by the problem they solve.

[hiitesh1127]

Please review @raklaptudirm

[raklaptudirm]

I guess recursive would be best.

[hiitesh1127]

I guess recursive would be best.

Okay I will update

[hiitesh1127]

Done @appgurueu @raklaptudirm