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

class Solution {
    public boolean reorderedPowerOf2(int n) {
        char[] digits = String.valueOf(n).toCharArray();
        Arrays.sort(digits);
        n = 0;
     
        for (int i = digits.length - 1; i >= 0; i--) {
            n += Character.getNumericValue(digits[i]) * Math.pow(10, i);
        }
     
        return Arrays.asList(
            1, 2, 4, 8, 61, 32, 64, 821, 652, 521, 4210, 8420, 9640, 9821, 86431, 87632, 66553, 732110, 644221, 885422, 8765410,
            9752210, 9444310, 8888630, 77766211, 55443332, 88766410, 877432211, 866554432, 987653210, 184497518, 186509729
        ).contains(n);
    }
}

class Solution:
        def maxSumSubmatrix(self, matrix: List[List[int]], k: int) -> int:
            def maxSumSubarray(arr):
                sub_s_max = float('-inf')
                s_curr = 0
                prefix_sums = [float('inf')]
                for x in arr:
                    bisect.insort(prefix_sums, s_curr)
                    s_curr += x
                    i = bisect.bisect_left(prefix_sums, s_curr - k)
                    sub_s_max = max(sub_s_max, s_curr - prefix_sums[i])
                return sub_s_max
        
            m, n = len(matrix), len(matrix[0])
            for x in range(m):
                for y in range(n - 1):
                    matrix[x][y+1] += matrix[x][y]
            res = float('-inf')
            for y1 in range(n):
                for y2 in range(y1, n):
                    arr = [matrix[x][y2] - (matrix[x][y1-1] if y1 > 0 else 0) for x in range(m)]
                    res = max(res, maxSumSubarray(arr))
            return res

defmodule Solution do
  def max_sum_submatrix(matrix, k) do
    {row, col, matrix} = to_map(matrix, 0, 0, %{})

    for c1 <- 0..(col - 1), reduce: -100_001 do
      result ->
        for c2 <- c1..0, reduce: {[], result} do
          {rows, result} ->
            rows =
              case rows do
                [] ->
                  for r <- 0..(row - 1), do: Map.get(matrix, {r, c2})

                rs ->
                  calculate_presum(rs, 0, c2, matrix, [])
              end

            case larget_close_to_k(rows, :gb_sets.singleton(0), 0, nil, k) do
              nil -> {rows, result}
              res -> {rows, max(result, res)}
            end
        end
        |> elem(1)
    end
  end

  defp to_map([], row, col, map), do: {row, col, map}
  defp to_map([[x]], row, col, map), do: {row + 1, col + 1, Map.put(map, {row, col}, x)}
  defp to_map([[] | rest], row, _col, map), do: to_map(rest, row + 1, 0, map)

  defp to_map([[x | r_rest] | rest], row, col, map),
    do: to_map([r_rest | rest], row, col + 1, Map.put(map, {row, col}, x))

  defp calculate_presum([], _row, _col, _matrix, res), do: Enum.reverse(res)

  defp calculate_presum([x | rest], row, col, matrix, res),
    do:
      calculate_presum(rest, row + 1, col, matrix, [
        x + Map.get(matrix, {row, col}) | res
      ])

  defp larget_close_to_k([], _sums, _sum, res, _k), do: res

  defp larget_close_to_k([x | rest], sums, sum, res, k) do
    sum = sum + x

    iter = :gb_sets.iterator_from(sum - k, sums)

    res =
      case :gb_sets.next(iter) do
        {val, _} ->
          if res == nil do
            sum - val
          else
            max(res, sum - val)
          end

        _ ->
          res
      end

    larget_close_to_k(rest, :gb_sets.add(sum, sums), sum, res, k)
  end
end