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

function longestDiverseString(a: number, b: number, c: number): string {
    let result = ''
    const arr = [];
    arr.push(
        { val: a, label: 'a' },
        { val: b, label: 'b' },
        { val: c, label: 'c' }
    )
    const getQuatity = (numb: number) => {
        return numb > 1 ? 2 : 1
    }
    arr.sort((a, b) => b.val - a.val)
    let prev = ''
    while (true) {
        let curMax = arr[0];
        let quatity = 0;
        if (prev == curMax.label) {
            curMax = arr[1];
            quatity = 1
        };
        if (curMax.val < 1) break;
        quatity = quatity ? quatity : getQuatity(curMax.val)
        result += curMax.label.repeat(quatity);
        curMax.val -= quatity
        prev = curMax.label;
        arr.sort((a, b) => b.val - a.val)
    }
    return result;
};

public class Solution
{
    public string LongestDiverseString(int a, int b, int c)
    {
        int[] remains = new int[] {a, b, c};

        StringBuilder result = new();
        while (true)
        {
            int exclude = -1;
            if (2 <= result.Length)
            {
                if (result[^1] == result[^2])
                {
                    exclude = result[^1] - 'a';
                }
            }
            int letter = GetLetter(remains, exclude);
            if (letter == -1)
            {
                break;
            }
            result.Append((char)(letter + 'a'));
        }

        return result.ToString();
    }

    private int GetLetter(int[] remains, int exclude)
    {
        int candidate = 0;
        int max = 0;
        for (int i = 0; i < remains.Length; i++)
        {
            if (i == exclude)
            {
                continue;
            }
            int remain = remains[i];
            if (max < remain)
            {
                candidate = i;
                max = remain;
            }
        }
        if (max == 0)
        {
            return -1;
        }
        remains[candidate]--;
        return candidate;
    }
}

class Solution:
    def maximumSwap(self, num: int) -> int:
        ans = num
        num = str(num)
        n = len(num)
        digits = [num[i] for i in range(n)]
        for i in range(n):
            for j in range(i + 1, n):
                if digits[i] < digits[j]:
                    digits[i], digits[j] = digits[j], digits[i]
                    ans = max(ans, int(''.join(digits)))
                    digits[i], digits[j] = digits[j], digits[i]

        return ans

class Solution:
    def maximumSwap(self, num: int) -> int:
        ans = num
        def toDigitArr(num):
            base = 10
            arr = []
            while num > 0:
                arr.append(num%10)
                num//=10
                base*=10
           
            return arr[::-1]
       
        def toInt(arr):
            ans = 0
            n = len(arr)
            for i in range(n):
                ans = ans*10 + arr[i]

            return ans
     
        digits = toDigitArr(num)
        n = len(digits)
        for i in range(n):
            for j in range( i + 1, n):
                if digits[i] < digits[j]:
                    digits[i], digits[j] = digits[j], digits[i]
                    ans = max(ans, toInt(digits))
                    digits[i], digits[j] = digits[j], digits[i]

        return ans

class Solution:
    def maximumSwap(self, num: int) -> int:
        digits = list(str(num))
        n = len(digits)
        rightMax = [-1]*n
        rightMax[n - 1] = n - 1
        for i in range(n - 2, -1, -1):
            rightMax[i] = rightMax[i + 1] if digits[i] <= digits[rightMax[i + 1]] else i

        for i in range(n):
            if digits[i] < digits[rightMax[i]]:
                digits[i], digits[rightMax[i]] = digits[rightMax[i]], digits[i]
                return int(''.join(digits))

        return num

class Solution {
public:
    int maximumSwap(int num) {
        priority_queue<int> pq;
        vector<int> tmp;

        while (num > 0) {
            int temp = num % 10;
            pq.push(temp);
            tmp.push_back(temp);
            num /= 10;
        }

        int n = pq.size();

        for (int i = 0; i < n/2; i++) {
            int temp = tmp[i];
            tmp[i] = tmp[n - i - 1];
            tmp[n - i - 1] = temp;
        }

        for (int i = 0; i < n; i++) {
            if (tmp[i] != pq.top()) {
                for (int j = n - 1; j > i; j--) {
                    if (tmp[j] == pq.top()) {
                        int x = tmp[i];
                        tmp[i] = tmp[j];
                        tmp[j] = x;
                        break;
                    }
                }
                break;
            }
            else if (tmp[i] == pq.top()) {
                pq.pop();
            }
        }

        int ans = 0;
        for (int i = 0; i < n; i++) {
            ans += tmp[i];
            if (i != n - 1) {
                ans *= 10;
            }
        }
       
        return ans;
    }
};

class Solution {
public:
    int maximumSwap(int num) {
        string s = to_string(num);
        vector<char> max_num(s.size()+1);
        max_num[s.size()] = s.size()-1;

        for (int i = s.size() - 1; i >= 0; i--) {
            max_num[i] = i;
            if (s[i] <= s[max_num[i+1]]) {
                max_num[i] = max_num[i+1];
            }
        }

        for (int i = 0; i < s.size() - 1; i++) {
            if (s[i] < s[max_num[i+1]]) {
                swap(s[i], s[max_num[i+1]]);
                break;
            }
        }
        
        return stoi(s);
    }
};

function maximumSwap(num: number): number {
    const digits: number[] = num.toString().split('').map(Number);
    const idxes: number[] = new Array(10).fill(-1);

    for (let i = 0; i < digits.length; i++) {
        idxes[digits[i]] = i;
    }

    for (let i = 0; i < digits.length; i++) {
        for (let j = 9; j > digits[i]; j--) {
            if (idxes[j] > i) {
                [digits[i], digits[idxes[j]]] = [digits[idxes[j]], digits[i]];
                return parseInt(digits.join(''));
            }
        }
    }
    return num;
}