17. Letter Combinations of a Phone Number

https://leetcode.com/problems/letter-combinations-of-a-phone-number/

C++

class Solution {
public:
    vector<string> combile(vector<string> vec1, vector<char> vec2) {
        vector<string> result;
        if (vec1.empty()) {
            for (auto& c : vec2) {
                result.emplace_back(string(1, c));
            }
            return result;
        }
        if (vec2.empty()) {
            return vec1;
        }
        for (auto& s : vec1) {
            for (auto& c : vec2) {
                result.emplace_back(s + c);
            }
        }
        return result;
    }
    vector<string> letterCombinations(string digits) {
        vector<vector<char>> vec = {
            {},
            {},
            {'a', 'b', 'c'},
            {'d', 'e', 'f'},
            {'g', 'h', 'i'},
            {'j', 'k', 'l'},
            {'m', 'n', 'o'},
            {'p', 'q', 'r', 's'},
            {'t', 'u', 'v'},
            {'w', 'x', 'y', 'z'}
        };
        vector<string> result;
        for (int i = 0; i < digits.length(); i++) {
            result = combile(result, vec[digits[i] - '0']);
        }
        return result;
    }
};

Go

func letterCombinations(digits string) []string {
  arr := [][]byte{
    {},
    {},
    {'a', 'b', 'c'},
    {'d', 'e', 'f'},
    {'g', 'h', 'i'},
    {'j', 'k', 'l'},
    {'m', 'n', 'o'},
    {'p', 'q', 'r', 's'},
    {'t', 'u', 'v'},
    {'w', 'x', 'y', 'z'},
  }
  combine := func(arr1 []string, arr2 []byte) (result []string) {
    if len(arr1) == 0 {
      for _, c := range arr2 {
        result = append(result, string(c))
      }
      return
    }
    if len(arr2) == 0 {
      return arr1
    }
    for _, c1 := range arr1 {
      for _, c2 := range arr2 {
        result = append(result, string(c1)+string(c2))
      }
    }
    return
  }

  var result []string
  for _, c := range digits {
    result = combine(result, arr[c-'0'])
  }
  return result
}

JavaScript

/**
 * @param {string} digits
 * @return {string[]}
 */
var letterCombinations = function(digits) {
  var table = [
    [],
    [],
    ['a', 'b', 'c'],
    ['d', 'e', 'f'],
    ['g', 'h', 'i'],
    ['j', 'k', 'l'],
    ['m', 'n', 'o'],
    ['p', 'q', 'r', 's'],
    ['t', 'u', 'v'],
    ['w', 'x', 'y', 'z']
  ]
  digits = digits.split('')
  var result = digits.reduce((ret, num) => {
    return combine(ret, table[num])
  }, [])
  return result

  function combine(arr1, arr2) {
    if (!arr1.length) {
      return arr2
    }
    if (!arr2.length) {
      return arr1
    }
    var result = []
    arr1.forEach(a => {
      arr2.forEach(b => {
        result.push(a + b)
      })
    })
    return result
  }
}

Python

from functools import reduce


class Solution(object):

    def letterCombinations(self, digits):
        """
        :type digits: str
        :rtype: List[str]
        """
        table = [
            [],
            [],
            ['a', 'b', 'c'],
            ['d', 'e', 'f'],
            ['g', 'h', 'i'],
            ['j', 'k', 'l'],
            ['m', 'n', 'o'],
            ['p', 'q', 'r', 's'],
            ['t', 'u', 'v'],
            ['w', 'x', 'y', 'z']
        ]
        letters = [table[int(num)] for num in list(digits)]

        def combine(l1, l2):
            if not l1:
                return l2
            if not l2:
                return l1
            result = []
            for a in l1:
                for b in l2:
                    result.append(a + b)
            return result

        return reduce(combine, letters, [])