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

class Solution {
    public static final int POSITION = 0;
    public static final int LIMIT = 1;
    public long minimumTotalDistance(List<Integer> robot, int[][] factory) {
        Collections.sort(robot);
        long[][][] memo = new long[robot.size()][factory.length][robot.size() + 1];
        for (int i = 0; i < robot.size(); i++) {
            for (int j = 0; j < factory.length; j++) {
                Arrays.fill(memo[i][j], -1);
            }
        }
        Arrays.sort(factory, (a, b) -> a[POSITION] - b[POSITION]);

        return minimumMovement(0, 0, 1, robot, factory, memo);
    }

    public long minimumMovement(int curRobot, int curFactory, int curSlot, List<Integer> robotPositions, int[][] factory, long[][][] memo) {
        if (curRobot == robotPositions.size() && curFactory == factory.length) {
            return 0;
        }

        if (curFactory == factory.length) {
            return 2L * 1_000_000_000 * 100 + 1;
        }
            
        if (curRobot == robotPositions.size()) {
            return 0;
        }

        if (memo[curRobot][curFactory][curSlot] != -1) {
            return memo[curRobot][curFactory][curSlot];
        }

        int nextFactory = curFactory, nextSlot = curSlot;
        if (curSlot + 1 > factory[curFactory][LIMIT]) {
            nextFactory = curFactory + 1;
            nextSlot = 1;
        } else {
            nextSlot = curSlot + 1;
        }

        long minMove = minimumMovement(curRobot, nextFactory, nextSlot, robotPositions, factory, memo);
        if (factory[curFactory][LIMIT] != 0) {
            minMove = Math.min(
                minMove,
                minimumMovement(
                    curRobot + 1,
                    nextFactory,
                    nextSlot,
                    robotPositions,
                    factory,
                    memo
                ) + Math.abs(factory[curFactory][POSITION] - robotPositions.get(curRobot))
            );
        }

        memo[curRobot][curFactory][curSlot] = minMove;

        return minMove;
    }
}

class Solution:
    def minimumTotalDistance(self, robot: List[int], factory: List[List[int]]) -> int:
        robot = sorted(robot)
        factory = sorted(factory)

        limits = []
        for p, l in factory:
            for i in range(l):
                limits.append(p)

        n = len(robot)
        m = len(limits)
        @lru_cache(None)
        def dfs(i, j):
            if i == n:
                return 0
            if j == m or n - i > m - j:
                return inf
           
            take = abs(robot[i] - limits[j]) + dfs(i + 1, j + 1)
            skip = dfs(i, j + 1)
            return min(take, skip)

        result = dfs(0, 0)
        dfs.cache_clear()
        return result

class Solution {
public:
    string makeFancyString(string s) {
        string ans = "";
        for (int i = 0; i < s.length(); i++) {
            if (ans.length() < 2) {
                ans += s[i];
            }
            else {
                if (s[i] == ans[ans.length() - 2] && s[i] == ans[ans.length() - 1]) continue;
                else {
                    ans += s[i];
                }
            }
        }

        return ans;
        
    }
};

class Solution:
    def makeFancyString(self, s: str) -> str:
        if len(s) < 3:
            return s

        rs = ""
        rs += s[0]
        rs += s[1]
        index = 2
        
        while (index < len(s)):
            if (s[index - 1] != s[index] or s[index] != s[index - 2]):
                rs += s[index]

            index += 1

        return rs

function makeFancyString(s: string): string {
    if (s.length < 3) return s;
    let prev1 = s[0], prev2 = s[1], res = prev1 + prev2;
    for (let i = 2; i < s.length; i++) {
        if (s[i] !== prev1 || s[i] !== prev2) {
            res+= s[i];
            prev2 = s[i];
            prev1 = s[i-1]
        }
    }
    return res;
};

class Solution {
    public String makeFancyString(String s) {
        StringBuilder sb = new StringBuilder();
        int freq = 1;
        char[] chars = s.toCharArray();
        sb.append(chars[0]);
        for (int i = 1; i < chars.length; i++) {
            if (chars[i] != chars[i - 1]) {
                freq = 0;
            }
            if (freq > 1) {
                continue;
            }
            sb.append(chars[i]);
            freq++;
        }
        return sb.toString();
    }
}

class Solution {
public:
    string makeFancyString(string s) {
        string ans = "";
        for (int i = 0; i < s.size(); i++) {
            if (i < s.size() - 2) {
                if (!(s[i] == s[i+1] && s[i] == s[i+2])) ans += s[i];
            }
            else ans += s[i];
        }
        return ans;
    }
};

    public String makeFancyString(String s)
    {
        StringBuilder res = new StringBuilder();
        res.append(s.charAt(0));
        var n = s.length();
        var counter = 1;
        for (int i = 1; i < n; i++)
        {
            if (s.charAt(i) == res.charAt(res.length() - 1))
            {
                counter++;
                if (counter < 3)
                {
                    res.append(s.charAt(i));
                }
            } else
            {
                counter = 1;
                res.append(s.charAt(i));
            }
        }
        return res.toString();
    }

class Solution {
    public String makeFancyString(String s) {
        StringBuilder sb = new StringBuilder();
        int cnt = 1;
        char last = s.charAt(0);
        sb.append(last);
        
        for(int i =  1 ;i<s.length();i++){
            if(s.charAt(i)==last){
                cnt++;
                if(cnt>2) continue;
            }
            else{
                cnt=1;
                last = s.charAt(i);
            }
            sb.append(last);
        }
        return sb.toString();
    }
}

class Solution:
    def minimumTotalDistance(self, robot: List[int], factory: List[List[int]]) -> int:
        robot.sort()
        factory.sort()

        factory_positions = []
        for f in factory:
            for i in range(f[1]):
                factory_positions.append(f[0])
        
        m, n = len(robot), len(factory_positions)       
        @lru_cache(9000)
        def dp(r, f):
            if f == n and r < m :
                return 10**12
            if r == m:
                return 0

            return min(dp(r+1, f+1) + abs(robot[r] - factory_positions[f]), dp(r, f+1))
        return dp(0, 0)

class Solution:
    def makeFancyString(self, s: str) -> str:
        if len(s) < 3:
            return s
        result = s[:2]
        for c in s[2:]:
            if c == result[-1] and c == result[-2]:
                continue
            result += c
        return result

var makeFancyString = function(s) {
    return s.replaceAll(/(.)\1{2,}/g, '$1$1');
};

class Solution {
    public String makeFancyString(String s) {
        StringBuilder sb = new StringBuilder();
        char pre = '0';
        int times = 1;
        for(char c:s.toCharArray()){
            if(c!=pre)
                times=1;
            else
                times++;
            if(times<3)
                sb.append(c);
            pre = c;
        }
        return sb.toString();
    }
}

class Solution {

    /**
     * @param String $s
     * @return String
     */
    function makeFancyString($s) {
        if (strlen($s) < 3) return $s;

        $ans = $s[0];
        $stack = [$s[0]];
        for ($i=1; $i<strlen($s); $i++) {
            $prev = array_pop($stack);
            if ($prev != $s[$i]) {
                $stack = [$s[$i]];
                $ans .= $s[$i];
                continue;
            }

            if (count($stack) == 1) {  
                $stack[] = $prev;
                continue;
            }

            $stack[] = $prev;
            $stack[] = $s[$i];
            $ans .= $s[$i];  
        }

        return $ans;
    }
}