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

defmodule Solution do
  def inorder_traversal(root) do
    walk(root) |> List.flatten()
  end
      
  defp walk(nil), do: []
  defp walk(%TreeNode{val: v, left: l, right: r}), do: [walk(l), v, walk(r)]
end

class Solution {
    public int numberOfWeakCharacters(int[][] properties) {
        Arrays.sort(properties, new Comparator<int[]>(){
            public int compare(int[] a, int[] b){
                return a[0]-b[0];
            }
        });   
        
        int res=0;
        int n=properties.length;
        int[] d=new int[n];
        d[n-1]=properties[n-1][1];
        for(int i=n-2;i>=0;i--){
            d[i]=Math.max(d[i+1], properties[i][1]);
        }
        
        for(int i=0;i<n;i++){
            int greater=lowerBound(properties, properties[i][0]);
            if(greater>=0 && greater<n){
                if(d[greater]>properties[i][1]){
                    res++;
                }
            }
        }
        
        return res;
    }
    
    int lowerBound(int[][] properties, int target){
        int l=0;
        int r=properties.length-1;
        int res=r+1;
        while(l<=r){
            int m=(l+r)/2;
            if(properties[m][0]>target){
                r=m-1;
                res=m;
            }
            else{
                l=m+1;
            }
        }
        return res;
    }
}

class Solution {
public:
    int numberOfWeakCharacters(vector<vector<int>>& properties) {
        vector<int> max_def(100'004, 0);
        int min_atk = INT_MAX, max_atk = INT_MIN;
        for (auto &v : properties) {
            if (v[1] > max_def[v[0]])
                max_def[v[0]] = v[1];
            min_atk = min(min_atk, v[0]);
            max_atk = max(max_atk, v[0]);
        }
   
        std::partial_sum(
            make_reverse_iterator(begin(max_def) + max_atk + 1),
            make_reverse_iterator(begin(max_def) + min_atk),
            make_reverse_iterator(begin(max_def) + max_atk + 1),
            [](auto x, auto y) { return max(x, y); });
   
        int res = 0;
        for (auto &v : properties)
            if (v[1] < max_def[v[0]+1])
                ++res;
   
        return res;
    }
};

def number_of_weak_characters(prop)
  prop.sort! { |a, b| [a[0], b[1]] <=> [b[0], a[1]] }
  count = 0
  max_i = prop.length - 1
  i = prop.length - 2
  while i >= 0
    if prop[max_i][1] > prop[i][1]
      count += 1
    else
      max_i = i
    end
    i -= 1
  end
  count
end

return reduce(lambda p, n: [p[0] + int(n[1] < p[1]), n[1] if n[1] > p[1] else p[1]], sorted(properties, key=lambda n: (-n[0], n[1])), [0, -1])[0]

defmodule Solution do
  def number_of_weak_characters(properties) do
    properties
    |> Enum.sort_by(fn [atk, def] -> {-atk, def} end)
    |> Enum.reduce({0, 0}, fn [_, def], {max, count} ->
      cond do
        def < max -> {max, count + 1}
        true -> {def, count}
      end
    end)
    |> elem(1)
  end
end

struct Solution {
    int numberOfWeakCharacters(vector<vector<int>>& props) {
        vector<int> maxDefs((*max_element(begin(props), end(props)))[0] + 1, 0);
        for (const auto& p : props) maxDefs[p[0]] = max(maxDefs[p[0]], p[1]);
        exclusive_scan(maxDefs.rbegin(), maxDefs.rend(), maxDefs.rbegin(), 0, [](int a, int b) { return max(a, b); });
        return count_if(begin(props), end(props), [&](const auto& p) { return p[1] < maxDefs[p[0]]; });
    }
};

class Solution:
    def numberOfWeakCharacters(self, properties: List[List[int]]) -> int:
        count, max_sofar = 0, float("-inf")
        for _, i in sorted(properties, key=lambda x: (-x[0],x[1])):
            count = count + (1 if i<max_sofar else 0)
            max_sofar = max(i,max_sofar)
        return count