defmodule EquiLeader do
  def equi_leader(a) do
    {leader_size, value} =
      Enum.reduce(a, {0, nil}, fn v, {size, value} ->
        cond do
          size == 0 -> {1, v}
          value != v -> {size - 1, value}
          true -> {size + 1, value}
        end
      end)

    count = length(a)
    candidate = if leader_size > 0, do: value, else: -1
    leader_count = Enum.count(a, &(&1 == candidate))
    leader = if leader_count > div(count, 2), do: candidate, else: -1

    {equi_leaders, _l_leader_count} =
      a
      |> Enum.with_index()
      |> Enum.reduce({0, 0}, fn {v, k}, {equi_leaders, l_leader_count} ->
        left_half = div(k + 1, 2)
        right_half = div(count - k - 1, 2)
        l_leader_count = if v == leader, do: l_leader_count + 1, else: l_leader_count
        r_leader_count = leader_count - l_leader_count

        equi_leaders =
          if l_leader_count > left_half and r_leader_count > right_half do
            equi_leaders + 1
          else
            equi_leaders
          end

        {equi_leaders, l_leader_count}
      end)

    equi_leaders
  end
end

-module(equi_leader).
-export([equi_leader/1]).

equi_leader(A) ->
    N = length(A),
    {LeaderSize, LeaderValue} = leader_scan(A),
    Candidate = case LeaderSize > 0 of
        true -> LeaderValue;
        false -> -1
    end,
    LeaderCount = length([X || X <- A, X =:= Candidate]),
    Leader = case LeaderCount > N / 2 of
        true -> Candidate;
        false -> -1
    end,
    {_, Count} = lists:foldl(fun({K, V}, {LCount, Equi}) ->
        LCount1 = case V =:= Leader of
            true -> LCount + 1;
            false -> LCount
        end,
        LeftHalf = (K + 1) div 2,
        RightHalf = (N - K - 1) div 2,
        RCount = LeaderCount - LCount1,
        Equi1 = case LCount1 > LeftHalf andalso RCount > RightHalf of
            true -> Equi + 1;
            false -> Equi
        end,
        {LCount1, Equi1}
    end, {0, 0}, lists:zip(lists:seq(0, N - 1), A)),
    Count.

leader_scan(A) ->
    lists:foldl(fun(V, {Size, Value}) ->
        case Size of
            0 -> {1, V};
            _ ->
                case Value =:= V of
                    true -> {Size + 1, Value};
                    false -> {Size - 1, Value}
                end
        end
    end, {0, undefined}, A).

func equiLeader(a []int) int {
	leaderSize, value := 0, 0
	for _, v := range a {
		switch {
		case leaderSize == 0:
			leaderSize++
			value = v
		case value != v:
			leaderSize--
		default:
			leaderSize++
		}
	}

	candidate := -1
	if leaderSize > 0 {
		candidate = value
	}

	leaderCount := 0
	for _, v := range a {
		if v == candidate {
			leaderCount++
		}
	}

	leader := -1
	if leaderCount > len(a)/2 {
		leader = candidate
	}

	count := len(a)
	lLeaderCount, equiLeaders := 0, 0
	for k, v := range a {
		leftHalf := (k + 1) / 2
		rightHalf := (count - k - 1) / 2
		if v == leader {
			lLeaderCount++
		}

		rLeaderCount := leaderCount - lLeaderCount
		if lLeaderCount > leftHalf && rLeaderCount > rightHalf {
			equiLeaders++
		}
	}

	return equiLeaders
}

equiLeader :: [Int] -> Int
equiLeader a = length (filter isEqui (zip3 [0 ..] a prefixLeaderCounts))
  where
    n = length a

    (size, value) = foldl step (0, 0) a
    step (sz, val) v
      | sz == 0   = (1, v)
      | val /= v  = (sz - 1, val)
      | otherwise = (sz + 1, val)

    candidate   = if size > 0 then value else -1
    leaderCount = length (filter (== candidate) a)
    leader      = if leaderCount > n `div` 2 then candidate else -1

    prefixLeaderCounts = scanl1 (+) [if v == leader then 1 else 0 | v <- a]

    isEqui (k, _, lLeaderCount) =
      let leftHalf     = (k + 1) `div` 2
          rightHalf     = (n - k - 1) `div` 2
          rLeaderCount = leaderCount - lLeaderCount
      in  lLeaderCount > leftHalf && rLeaderCount > rightHalf

public class Solution {
    public static int equiLeader(int[] a) {
        int leaderSize = 0;
        int value = 0;

        for (int v : a) {
            if (leaderSize == 0) {
                leaderSize++;
                value = v;
            } else if (value != v) {
                leaderSize--;
            } else {
                leaderSize++;
            }
        }
        int candidate = leaderSize > 0 ? value : -1;

        int leaderCount = 0;
        for (int v : a) {
            if (v == candidate) {
                leaderCount++;
            }
        }
        int leader = -1;
        if (leaderCount > a.length / 2.0) {
            leader = candidate;
        }

        int count = a.length;
        int lLeaderCount = 0;
        int equiLeaders = 0;

        for (int k = 0; k < count; k++) {
            int v = a[k];
            int leftHalf = (k + 1) / 2;
            int rightHalf = (count - k - 1) / 2;
            if (v == leader) {
                lLeaderCount++;
            }

            int rLeaderCount = leaderCount - lLeaderCount;
            if (lLeaderCount > leftHalf && rLeaderCount > rightHalf) {
                equiLeaders++;
            }
        }

        return equiLeaders;
    }
}

(defun equi-leader (a)
  (let ((vec (coerce a 'vector))
        (leader-size 0) (value 0))
    (loop for v across vec
          do (cond
               ((zerop leader-size) (incf leader-size) (setf value v))
               ((/= value v) (decf leader-size))
               (t (incf leader-size))))
    (let* ((candidate (if (> leader-size 0) value -1))
           (leader-count 0))
      (loop for v across vec do (when (= v candidate) (incf leader-count)))
      (let ((leader (if (> leader-count (/ (length vec) 2)) candidate -1))
            (count (length vec))
            (l-leader-count 0)
            (equi-leaders 0))
        (loop for k from 0 below count
              for v = (aref vec k)
              do (let ((left-half (floor (1+ k) 2))
                       (right-half (floor (- count k 1) 2)))
                   (when (= v leader) (incf l-leader-count))
                   (let ((r-leader-count (- leader-count l-leader-count)))
                     (when (and (> l-leader-count left-half)
                                (> r-leader-count right-half))
                       (incf equi-leaders)))))
        equi-leaders))))

function equiLeader(array $a): int
{
    $leaderSize = $value = $leaderCount = 0;
    foreach ($a as $k => $v) {
        if ($leaderSize === 0) {
            $leaderSize++;
            $value = $v;
        } elseif ($value !== $v) {
            $leaderSize--;
        } else {
            $leaderSize++;
        }
    }
    $candidate = $leaderSize > 0 ? $value : -1;

    foreach ($a as $v) {
        if ($v === $candidate) {
            $leaderCount++;
        }
    }
    $leader = -1;
    if ($leaderCount > count($a) / 2) {
        $leader = $candidate;
    }

    $count        = count($a);
    $lLeaderCount = $equiLeaders = 0;

    foreach ($a as $k => $v) {
        $leftHalf  = (int)(($k + 1) / 2);
        $rightHalf = (int)(($count - $k - 1) / 2);
        if ($v === $leader) {
            $lLeaderCount++;
        }

        $rLeaderCount = $leaderCount - $lLeaderCount;
        if ($lLeaderCount > $leftHalf && $rLeaderCount > $rightHalf) {
            $equiLeaders++;
        }

    }

    return $equiLeaders;
}

def equi_leader(a: list[int]) -> int:
    leader_size = value = 0
    for v in a:
        if leader_size == 0:
            leader_size += 1
            value = v
        elif value != v:
            leader_size -= 1
        else:
            leader_size += 1
    candidate = value if leader_size > 0 else -1

    count = len(a)
    leader_count = sum(1 for v in a if v == candidate)
    leader = candidate if leader_count > count / 2 else -1

    l_leader_count = 0
    equi_leaders = 0
    for k, v in enumerate(a):
        left_half = (k + 1) // 2
        right_half = (count - k - 1) // 2
        if v == leader:
            l_leader_count += 1

        r_leader_count = leader_count - l_leader_count
        if l_leader_count > left_half and r_leader_count > right_half:
            equi_leaders += 1

    return equi_leaders

fn equi_leader(a: &[i64]) -> i64 {
    let mut leader_size = 0i64;
    let mut value = 0;
    for &v in a {
        if leader_size == 0 {
            leader_size += 1;
            value = v;
        } else if value != v {
            leader_size -= 1;
        } else {
            leader_size += 1;
        }
    }
    let candidate = if leader_size > 0 { value } else { -1 };

    let leader_count = a.iter().filter(|&&v| v == candidate).count() as i64;
    let leader = if leader_count > a.len() as i64 / 2 { candidate } else { -1 };

    let count = a.len() as i64;
    let mut l_leader_count = 0i64;
    let mut equi_leaders = 0i64;

    for (k, &v) in a.iter().enumerate() {
        let k = k as i64;
        let left_half = (k + 1) / 2;
        let right_half = (count - k - 1) / 2;
        if v == leader {
            l_leader_count += 1;
        }

        let r_leader_count = leader_count - l_leader_count;
        if l_leader_count > left_half && r_leader_count > right_half {
            equi_leaders += 1;
        }
    }

    equi_leaders
}

function equiLeader(a: number[]): number {
  let leaderSize = 0;
  let value = 0;

  for (const v of a) {
    if (leaderSize === 0) {
      leaderSize++;
      value = v;
    } else if (value !== v) {
      leaderSize--;
    } else {
      leaderSize++;
    }
  }

  const candidate = leaderSize > 0 ? value : -1;

  let leaderCount = 0;
  for (const v of a) {
    if (v === candidate) {
      leaderCount++;
    }
  }

  let leader = -1;
  if (leaderCount > a.length / 2) {
    leader = candidate;
  }

  const count = a.length;
  let lLeaderCount = 0;
  let equiLeaders = 0;

  for (let k = 0; k < count; k++) {
    const v = a[k];
    const leftHalf = Math.trunc((k + 1) / 2);
    const rightHalf = Math.trunc((count - k - 1) / 2);
    if (v === leader) {
      lLeaderCount++;
    }

    const rLeaderCount = leaderCount - lLeaderCount;
    if (lLeaderCount > leftHalf && rLeaderCount > rightHalf) {
      equiLeaders++;
    }
  }

  return equiLeaders;
}