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

class Solution:
    def equationsPossible(self, equations: List[str]) -> bool:
        class Ufds:
            parent_node = {}
            def make_set(self, u):
                for i in u:
                    self.parent_node[i] = i
            def op_find(self, k):
                if self.parent_node[k] == k:
                    return k
                return self.op_find(self.parent_node[k])

            def op_union(self, a, b):
                x = self.op_find(a)
                y = self.op_find(b)
                self.parent_node[y] = x
               
        chars = set()
        for e in equations:
            chars.add(e[0])
            chars.add(e[3])
        uf = Ufds()
        uf.make_set(chars)
       
        for e in equations:
            if "!" not in e:
                uf.op_union(e[0], e[3])
       
       
        for e in equations:
            if "!" in e \
                and (uf.op_find(e[0]) == uf.op_find(e[3]) \
                or uf.op_find(e[3]) == uf.op_find(e[0])):
                    return False
       
        return True

/**
 * @param {number[]} nums1
 * @param {number[]} nums2
 * @return {number[]}
 */
var intersect = function(nums1, nums2) {
    if(nums1.length < nums2.length)
        {
            return intersect(nums2, nums1);
        }
    nums1.sort();
    nums2.sort();
    var i = 0;
    var j = 0;
    ans = new Array();
    while(i < nums1.length && j < nums2.length)
        {
            if(nums1[i] == nums2[j])
                {
                    ans.push(nums1[i]);
                    i++;
                    j++;
                    continue;
                }
            if(nums1[i] < nums2[j])
                {
                    i++;
                    continue;
                }
            if(nums1[i] > nums2[j])
                {
                    j++;
                    continue;
                }
        }
    return ans;
};

defmodule Solution do
  def equations_possible(equations) do
    equations
    |> Enum.reduce_while({[], []}, fn
      <<x, "!=", x>>, _ ->
        {:halt, false}

      <<x, "==", x>>, acc ->
        {:cont, acc}

      <<x::binary-size(1), "==", y::binary-size(1)>>, {equals, diffs} ->
        {:cont, {[{x, y} | equals], diffs}}

      <<x::binary-size(1), "!=", y::binary-size(1)>>, {equals, diffs} ->
        {:cont, {equals, [{x, y} | diffs]}}
    end)
    |> then(&if &1 == false, do: false, else: compute(&1))
  end

  defp sort_equals([], _used, [], result), do: Enum.reverse(result)

  defp sort_equals([], used, [{x, y} | rest] = remain, result) do
    remain
    |> Enum.reduce({result, used, [], :try_add}, fn
      {x, y}, {result, used, remain, :added} ->
        {result, used, [{x, y} | remain], :added}

      {x, y}, {result, used, remain, :try_add} ->
        if MapSet.member?(used, x) or MapSet.member?(used, y) do
          {[{x, y} | result], MapSet.put(used, x) |> MapSet.put(y), remain, :added}
        else
          {result, used, [{x, y} | remain], :try_add}
        end
    end)
    |> then(fn
      {result, used, remain, :added} ->
        sort_equals(remain, used, [], result)

      {result, used, _, _} ->
        sort_equals(rest, MapSet.put(used, x) |> MapSet.put(y), [], [{x, y} | result])
    end)
  end

  defp sort_equals([{x, y} | rest] = ip, used, remain, result) do
    if MapSet.size(used) == 0 do
      sort_equals(rest, MapSet.new([x, y]), remain, [{x, y} | result])
    else
      if MapSet.member?(used, x) or MapSet.member?(used, y) do
        sort_equals(rest, MapSet.put(used, x) |> MapSet.put(y), remain, [
          {x, y} | result
        ])
      else
        sort_equals(rest, used, [{x, y} | remain], result)
      end
    end
  end

  defp compute({equals, diffs}) do
    equals
    |> sort_equals(MapSet.new(), [], [])
    |> Enum.reduce({%{}, 0}, fn {x, y}, {values, seed} = acc ->
      case {Map.get(values, x), Map.get(values, y)} do
        {nil, nil} -> {Map.put(values, x, seed) |> Map.put(y, seed), seed + 1}
        {v, nil} -> {Map.put(values, y, v), seed}
        {nil, v} -> {Map.put(values, x, v), seed}
        {v, v} -> acc
      end
    end)
    |> then(fn {values, _} ->
      Enum.all?(diffs, fn {x, y} ->
        case {Map.get(values, x), Map.get(values, y)} do
          {nil, nil} -> true
          {v, v} -> false
          _ -> true
        end
      end)
    end)
  end
end