thảo luận Leetcode mỗi ngày

class Solution:
    def getLucky(self, s: str, k: int) -> int:
        num_str = ''.join(str(ord(char) - ord('a') + 1) for char in s)
        
        for _ in range(k):
            num_str = str(sum(int(digit) for digit in num_str))
        
        return int(num_str)

public class Solution
{
    public int GetLucky(string s, int k)
    {
        int result = 0;
        for (int i = 0; i < s.Length; i++)
        {
            result += Transform(s[i] - 'a' + 1);
        }
        for (int i = 1; i < k; i++)
        {
            result = Transform(result);
        }

        return result;
    }

    private int Transform(int num)
    {
        int result = 0;
        while (num > 0)
        {
            result += num % 10;
            num /= 10;
        }

        return result;
    }
}

class Solution {

    /**
     * @param String $s
     * @param Integer $k
     * @return Integer
     */
    function getLucky($s, $k) {
        // convert chars to numbers
        $str = '';
        for ($i=0; $i<strlen($s); $i++) {
            $str .= ord($s[$i]) - 96;
        }
        
        // start get lucky by k
        $ans = 0;
        while ($k > 0) {
            $ans = 0;
            for ($i=0; $i<strlen($str); $i++) {
                $ans += (int)$str[$i];
            }
            $str = "$ans";
            $k--;
        }

        return $ans;
    }
}

fn digit_sum(number: i32, sum: i32) -> i32 {
    match number {
        num if num < 10 => sum + number,
        _ => digit_sum(number / 10, sum + number % 10),
    }
}
impl Solution {
    pub fn get_lucky(s: String, k: i32) -> i32 {
        let mut num: i32 = s
            .as_bytes()
            .iter()
            .map(|&c| digit_sum((c - b'a' + 1) as i32, 0))
            .sum();
        for _ in 0..(k as usize - 1) {
            num = digit_sum(num, 0)
        }
        num
    }
}

var getLucky = function(s, k) {
    const getPos = (c) => c.charCodeAt(0) - 'a'.charCodeAt(0) + 1;
    const convert = (s) => {
        let sum = 0;
        for (const c of s) {
            const pos = getPos(c);
            if (pos > 9) {
                sum += pos % 10;
                sum += Math.floor(pos / 10);
            } else {
                sum += pos;
            }
        }
        return sum;
    }

    const transform = (num, k) => {
        if (k <= 0) return num;
        while (k > 0) {
            let sum = 0;

            while (num > 0) {
                sum += num % 10;
                num = Math.floor(num / 10);
            }

            num = sum;
            k--;
        }

        return num;
    }

    return transform(convert(s), k - 1);
};

class Solution {
    public int getLucky(String s, int k) {
        String num = s;
        int sum = 0;
        StringBuilder sb = new StringBuilder();
        for(char c:num.toCharArray())
            sb.append(c-'a'+1);
        for(int i = 0; i < k; i++){
            sum = 0;
            for(char c: sb.toString().toCharArray()){
                sum+= c-'0';
            }
            sb = new StringBuilder(Integer.toString(sum));
        }
        return sum;
    }
}

class Solution {
    public int getLucky(String s, int k) {
        StringBuilder sb = new StringBuilder();
        int[] freq = new int[26];
        for (char c : s.toCharArray()) {
            freq[c - 'a']++;
        }
        for (int i = 0; i < 26; i++) {
            for (int j = 0; j < freq[i]; j++) {
                sb.append(i + 1);
            }
        }
        String res = sb.toString();
        int ans = 0;
        while (k > 0) {
            ans = 0;
            for (char c : res.toCharArray()) {
                ans += (c - '0');
            }
            res = String.valueOf(ans);
            k--;
        }
        return ans;
    }
}

class Solution {
    public String originalDigits(String s) {
        int[] count = new int[26];
        ArrayList<Integer> list = new ArrayList<Integer>();
        StringBuilder sb = new StringBuilder();
        char[] uniqueChar = new char[]{'z','w','x','s','v','f','r','h','t','i','o'};
        String[] string = new String[]{"zero","two","six","seven","five","four","three","eight","ten","nine","one"};
        int[] number = new int[]{0,2,6,7,5,4,3,8,10,9,1};

        for(char c:s.toCharArray())
            count[c-'a']++;

        for(int i = 0;i<uniqueChar.length;i++){
            while(count[uniqueChar[i]-'a']>0){
                for(char c:string[i].toCharArray())
                    count[c-'a']--;
                list.add(number[i]);
            }
        }

        Collections.sort(list);

        for(int c:list)
            sb.append(c);
        
        return sb.toString();
    }
}

class Solution {
    public int getLucky(String s, int k) {
        StringBuilder sb = new StringBuilder();
        for(int i = 0; i < s.length(); i++) {
            sb.append(s.charAt(i) - 96);
        }

        s = sb.toString();
        int temp = 0;

        while(k-- > 0) {
            for(int i = 0; i < s.length(); i++) {
                temp += s.charAt(i) - 48;
            }
            s = String.valueOf(temp);
            temp = 0;
        }

        return Integer.parseInt(s);
    }
}

class Solution {
    char[] uniqueChar = new char[]{'z', 'w', 'u', 'g', 'x', 'r', 'f', 'v', 'i', 'o'};
    String[] words = new String[]{"zero", "two", "four", "eight", "six", "three", "five", "seven", "nine", "one"};
    int[] order = new int[]{0, 2, 4, 8, 6, 3 , 5, 7, 9, 1};

    public String originalDigits(String s) {
        int[] counter = new int[26];
        int[] answer = new int[10];
        for (char c : s.toCharArray()) {
            counter[c - 'a']++;
        }

        for (int i = 0; i < order.length; i++) {
            int num = order[i];
            int unique = counter[uniqueChar[i] - 'a'];
            answer[num] = unique;
            for (char c : words[i].toCharArray()) {
                counter[c - 'a'] -= unique;
            }
        }

        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < answer[i]; j++) {
                sb.append(String.valueOf(i));
            }
        }

        return sb.toString();
    }
}

class Solution {
    int maxX = -1;
    int maxY = -1;
    public boolean canMeasureWater(int x, int y, int target) {
        maxX = x;
        maxY = y;
        boolean[][] isVisited = new boolean[x + 1][y + 1];
        isVisited[0][0] = true;

        return backtrack(0, 0, target, isVisited);
    }

    public boolean backtrack(int x, int y, int target, boolean[][] isVisited) {
        System.out.println(x + " " + y);
        if (x == target || y == target || x + y == target) {
            return true;
        }

        boolean canMesure = false;

        if (!isVisited[x][maxY]) {
            isVisited[x][maxY] = true;
            canMesure |= backtrack(x, maxY, target, isVisited);
        }

        if (!isVisited[maxX][y]) {
            isVisited[maxX][y] = true;
            canMesure |= backtrack(maxX, y, target, isVisited);
        }

        if (!isVisited[0][y]) {
            isVisited[0][y] = true;
            canMesure |= backtrack(0, y, target, isVisited);
        }

        if (!isVisited[x][0]) {
            isVisited[x][0] = true;
            canMesure |= backtrack(x, 0, target, isVisited);
        }

        int yAfterFill = Math.min(maxY, x + y);
        if (!isVisited[x + y - yAfterFill][yAfterFill]) {
            isVisited[x + y - yAfterFill][yAfterFill] = true;
            canMesure |= backtrack(x + y - yAfterFill , yAfterFill, target, isVisited);
        }

        int xAfterFill = Math.min(maxX, x + y);
        if (!isVisited[xAfterFill][x + y - xAfterFill]) {
            isVisited[xAfterFill][x + y - xAfterFill] = true;
            canMesure |= backtrack(xAfterFill, x + y - xAfterFill, target, isVisited);
        }

        return canMesure;
    }
}