Welcome to Subscribe On Youtube

1415. The k-th Lexicographical String of All Happy Strings of Length n

Description

A happy string is a string that:

  • consists only of letters of the set ['a', 'b', 'c'].
  • s[i] != s[i + 1] for all values of i from 1 to s.length - 1 (string is 1-indexed).

For example, strings "abc", "ac", "b" and "abcbabcbcb" are all happy strings and strings "aa", "baa" and "ababbc" are not happy strings.

Given two integers n and k, consider a list of all happy strings of length n sorted in lexicographical order.

Return the kth string of this list or return an empty string if there are less than k happy strings of length n.

 

Example 1:

Input: n = 1, k = 3
Output: "c"
Explanation: The list ["a", "b", "c"] contains all happy strings of length 1. The third string is "c".

Example 2:

Input: n = 1, k = 4
Output: ""
Explanation: There are only 3 happy strings of length 1.

Example 3:

Input: n = 3, k = 9
Output: "cab"
Explanation: There are 12 different happy string of length 3 ["aba", "abc", "aca", "acb", "bab", "bac", "bca", "bcb", "cab", "cac", "cba", "cbc"]. You will find the 9th string = "cab"

 

Constraints:

  • 1 <= n <= 10
  • 1 <= k <= 100

Solutions

  • class Solution {
        private List<String> ans = new ArrayList<>();
    
        public String getHappyString(int n, int k) {
            dfs("", n);
            return ans.size() < k ? "" : ans.get(k - 1);
        }
    
        private void dfs(String t, int n) {
            if (t.length() == n) {
                ans.add(t);
                return;
            }
            for (char c : "abc".toCharArray()) {
                if (t.length() > 0 && t.charAt(t.length() - 1) == c) {
                    continue;
                }
                dfs(t + c, n);
            }
        }
    }
    
  • class Solution {
    public:
        vector<string> ans;
        string getHappyString(int n, int k) {
            dfs("", n);
            return ans.size() < k ? "" : ans[k - 1];
        }
    
        void dfs(string t, int n) {
            if (t.size() == n) {
                ans.push_back(t);
                return;
            }
            for (int c = 'a'; c <= 'c'; ++c) {
                if (t.size() && t.back() == c) continue;
                t.push_back(c);
                dfs(t, n);
                t.pop_back();
            }
        }
    };
    
  • class Solution:
        def getHappyString(self, n: int, k: int) -> str:
            def dfs(t):
                if len(t) == n:
                    ans.append(t)
                    return
                for c in 'abc':
                    if t and t[-1] == c:
                        continue
                    dfs(t + c)
    
            ans = []
            dfs('')
            return '' if len(ans) < k else ans[k - 1]
    
    
  • function getHappyString(n: number, k: number): string {
        const ans: string[] = [];
    
        const dfs = (s = '') => {
            if (s.length === n) {
                ans.push(s);
                return;
            }
    
            for (const ch of 'abc') {
                if (s.at(-1) === ch) continue;
                dfs(s + ch);
            }
        };
    
        dfs();
    
        return ans[k - 1] ?? '';
    }
    
    
  • function getHappyString(n, k) {
        const ans = [];
    
        const dfs = (s = '') => {
            if (s.length === n) {
                ans.push(s);
                return;
            }
    
            for (const ch of 'abc') {
                if (s.at(-1) === ch) continue;
                dfs(s + ch);
            }
        };
    
        dfs();
    
        return ans[k - 1] ?? '';
    }
    
    
  • func getHappyString(n int, k int) string {
        ans := []string{}
        var s []byte
    
        var dfs func()
        dfs = func() {
            if len(s) == n {
                ans = append(ans, string(s))
                return
            }
            if len(ans) >= k {
                return
            }
            for c := byte('a'); c <= 'c'; c++ {
                if len(s) == 0 || s[len(s)-1] != c {
                    s = append(s, c)
                    dfs()
                    s = s[:len(s)-1]
                }
            }
        }
    
        dfs()
        if len(ans) < k {
            return ""
        }
        return ans[k-1]
    }
    
    
  • public class Solution {
        public string GetHappyString(int n, int k) {
            List<string> ans = new List<string>();
            StringBuilder s = new StringBuilder();
    
            void Dfs() {
                if (s.Length == n) {
                    ans.Add(s.ToString());
                    return;
                }
                if (ans.Count >= k) {
                    return;
                }
                foreach (char c in "abc") {
                    if (s.Length == 0 || s[s.Length - 1] != c) {
                        s.Append(c);
                        Dfs();
                        s.Length--;
                    }
                }
            }
    
            Dfs();
            return ans.Count < k ? "" : ans[k - 1];
        }
    }
    
    
  • impl Solution {
        pub fn get_happy_string(n: i32, k: i32) -> String {
            let mut ans = Vec::new();
            let mut s = String::new();
            let mut k = k;
    
            fn dfs(n: i32, s: &mut String, ans: &mut Vec<String>, k: &mut i32) {
                if s.len() == n as usize {
                    ans.push(s.clone());
                    return;
                }
                if ans.len() >= *k as usize {
                    return;
                }
                for c in "abc".chars() {
                    if s.is_empty() || s.chars().last() != Some(c) {
                        s.push(c);
                        dfs(n, s, ans, k);
                        s.pop();
                    }
                }
            }
    
            dfs(n, &mut s, &mut ans, &mut k);
            if ans.len() < k as usize {
                "".to_string()
            } else {
                ans[(k - 1) as usize].clone()
            }
        }
    }
    
    

All Problems

All Solutions