Elixir Notes on Dan Stefan Oprean

Introduction

Mon, 01 Jan 0001 00:00:00 +0000

Hello World

IO.puts("Hello, world!")

Run the script:

elixir main.exs

This prints a line in Elixir using the IO module. It is the normal first example for a script.

Variables

Values are immutable. Rebinding creates a new binding for the name.

name = "Dan"
count = 1
active = true

These bindings hold values for the current expression flow. In Elixir, you work with new bindings instead of mutating old values.

Advanced

Mon, 01 Jan 0001 00:00:00 +0000

Function Clauses and Guards

Use multiple function heads to make branching explicit. Guards keep each clause narrow and readable.

defmodule AccessLevel do
  def label(%{role: :admin}), do: "full access"
  def label(%{role: :editor, active: true}), do: "edit access"
  def label(%{role: role}) when role in [:viewer, :guest], do: "read only"
  def label(_), do: "no access"
end

This keeps branching close to the function definition, which makes Elixir code easier to scan than one large conditional.

Pipelines

The pipe operator passes the previous result as the first argument to the next function.

Add

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Add

defmodule Add do
  def add(param1, param2), do: param1 + param2
end

This just adds the two input numbers with the language’s normal arithmetic and returns the sum.

Add Border

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Add Border

defmodule AddBorder do
  def add_border(picture) do
    border = String.duplicate("*", String.length(hd(picture)))
    wrapped = Enum.map(picture, fn row -> "*" <> row <> "*" end)

    [border] ++ wrapped ++ [border]
  end
end

This builds a new grid with a * border around every side. It adds a full top and bottom row, then wraps each existing row from left and right.

Adjacent Elements Product

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Adjacent Elements Product

defmodule AdjacentElementsProduct do
  def adjacent_elements_product(input_array) do
    input_array
    |> Enum.chunk_every(2, 1, :discard)
    |> Enum.map(fn [a, b] -> a * b end)
    |> Enum.max()
  end
end

This walks through neighboring values, multiplies each pair, and keeps the biggest product it finds.

Almost Magic Square

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Almost Magic Square

defmodule AlmostMagicSquare do
  def almost_magic_square(a) do
    rows = Enum.chunk_every(a, 3)
    row_sums = Enum.map(rows, &Enum.sum/1)
    col_sums = for j <- 0..2, do: rows |> Enum.map(&Enum.at(&1, j)) |> Enum.sum()
    max_sum = Enum.max(row_sums ++ col_sums)

    {final_rows, _, _, _, _} = balance(rows, row_sums, col_sums, max_sum, 0, 0)
    List.flatten(final_rows)
  end

  defp balance(rows, row_sums, col_sums, max_sum, i, j) when i < 3 and j < 3 do
    diff = min(max_sum - Enum.at(row_sums, i), max_sum - Enum.at(col_sums, j))

    rows = List.update_at(rows, i, fn row -> List.update_at(row, j, &(&1 + diff)) end)
    row_sums = List.update_at(row_sums, i, &(&1 + diff))
    col_sums = List.update_at(col_sums, j, &(&1 + diff))

    next_i = if Enum.at(row_sums, i) == max_sum, do: i + 1, else: i
    next_j = if Enum.at(col_sums, j) == max_sum, do: j + 1, else: j

    balance(rows, row_sums, col_sums, max_sum, next_i, next_j)
  end

  defp balance(rows, row_sums, col_sums, _max_sum, i, j), do: {rows, row_sums, col_sums, i, j}
end

This adjusts the matrix toward a matching target sum so the rows and columns line up more like a magic square.

Are Equally Strong

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Are Equally Strong

defmodule AreEquallyStrong do
  def are_equally_strong(your_left, your_right, friends_left, friends_right) do
    max(your_right, your_left) == max(friends_left, friends_right) and
      min(your_left, your_right) == min(friends_right, friends_left)
  end
end

This compares each person’s strongest and weakest arm. If both pairs match, the result is true.

Array Change

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Array Change

defmodule ArrayChange do
  def array_change(a) when length(a) < 2, do: 0

  def array_change(a) do
    {_final, total} =
      Enum.reduce(0..(length(a) - 2), {a, 0}, fn k, {arr, total} ->
        cur = Enum.at(arr, k)
        nxt = Enum.at(arr, k + 1)

        if cur >= nxt do
          diff = cur - nxt + 1
          {List.update_at(arr, k + 1, &(&1 + diff)), total + diff}
        else
          {arr, total}
        end
      end)

    total
  end
end

This moves left to right and bumps values only when needed so the array becomes strictly increasing.

Array Maximal Adjacement Difference

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Array Maximal Adjacement Difference

defmodule ArrayMaximalAdjacentDifference do
  def array_maximal_adjacent_difference(a) when length(a) < 3, do: 0

  def array_maximal_adjacent_difference(a) do
    len = length(a)

    1..(len - 2)
    |> Enum.map(fn i ->
      prev = Enum.at(a, i - 1)
      cur = Enum.at(a, i)
      nxt = Enum.at(a, i + 1)
      max(abs(cur - prev), abs(cur - nxt))
    end)
    |> Enum.max()
  end
end

This checks the gap between each pair of neighbors and returns the largest difference.

Binary Gap

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Binary Gap

defmodule BinaryGap do
  def binary_gap(n) do
    n
    |> Integer.to_string(2)
    |> String.trim("0")
    |> String.split("1")
    |> Enum.map(&String.length/1)
    |> Enum.max()
  end
end

This turns the number into binary, ignores zeroes outside the edges, and finds the longest run of zeroes between 1s.

Bracket

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Bracket

defmodule Bracket do
  def bracket(s) do
    result =
      s
      |> String.graphemes()
      |> Enum.reduce_while([], fn ch, stack ->
        case ch do
          ")" -> pop_match(stack, "(")
          "]" -> pop_match(stack, "[")
          "}" -> pop_match(stack, "{")
          _ -> {:cont, [ch | stack]}
        end
      end)

    if result == [], do: 1, else: 0
  end

  defp pop_match([], _expected), do: {:halt, :mismatch}

  defp pop_match([top | rest], expected) do
    if top == expected, do: {:cont, rest}, else: {:halt, :mismatch}
  end
end

This uses a simple stack approach: open brackets go in, matching closing brackets pop them out.

Century From Year

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Century From Year

defmodule CenturyFromYear do
  def century_from_year(year), do: ceil(year / 100)
end

This converts a year into its century. Years 1-100 are century 1, 101-200 are century 2, and so on.

Check Palindrome

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Check Palindrome

defmodule CheckPalindrome do
  def check_palindrome(input_string), do: String.reverse(input_string) == input_string
end

This compares the string with its reverse. If they match, it is a palindrome.

Chocolates By Numbers

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Chocolates By Numbers

defmodule ChocolatesByNumbers do
  def chocolates_by_numbers(n, m) do
    g = gcd(n, m)
    n * m |> div(g) |> div(m)
  end

  defp gcd(n, m) when rem(n, m) == 0, do: m
  defp gcd(n, m), do: gcd(m, rem(n, m))
end

This uses the greatest common divisor to figure out how many chocolates get eaten before the pattern repeats.

Common Prime Divisors

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Common Prime Divisors

defmodule CommonPrimeDivisors do
  def common_prime_divisors(a, b) do
    a
    |> Enum.zip(b)
    |> Enum.count(fn {x, y} ->
      d = gcd(x, y)
      remove_common(x, d) == 1 and remove_common(y, d) == 1
    end)
  end

  defp gcd(n, m) when rem(n, m) == 0, do: m
  defp gcd(n, m), do: gcd(m, rem(n, m))

  defp remove_common(1, _m), do: 1

  defp remove_common(n, m) do
    d = gcd(n, m)
    if d == 1, do: n, else: remove_common(div(n, d), m)
  end
end

This checks whether two numbers are built from the same prime factors by repeatedly dividing out their shared parts.

Count Div

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Count Div

defmodule CountDiv do
  def count_div(a, b, k) do
    first_div = if rem(a, k) == 0, do: a, else: a + (k - rem(a, k))
    last_div = b - rem(b, k)

    div(last_div - first_div, k) + 1
  end
end

This counts how many numbers in a range are divisible by K without looping through every value.

Count Factors

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Count Factors

defmodule CountFactors do
  def count_factors(n), do: loop(1, 0, n)

  defp loop(i, count, n) when i * i < n do
    count = if rem(n, i) == 0, do: count + 2, else: count
    loop(i + 1, count, n)
  end

  defp loop(i, count, n) do
    if i * i == n, do: count + 1, else: count
  end
end

This checks divisors in pairs up to the square root, which keeps the work much smaller than testing every number.

Count Non Divisible

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Count Non Divisible

defmodule CountNonDivisible do
  def count_non_divisible(a) do
    size = length(a)
    occurrences = Enum.frequencies(a)

    Enum.map(a, fn v -> size - divisor_occurrences(1, v, occurrences, 0) end)
  end

  defp divisor_occurrences(i, v, _occurrences, count) when i * i > v, do: count

  defp divisor_occurrences(i, v, occurrences, count) do
    count =
      if rem(v, i) == 0 do
        count = count + Map.get(occurrences, i, 0)

        if div(v, i) != i do
          count + Map.get(occurrences, div(v, i), 0)
        else
          count
        end
      else
        count
      end

    divisor_occurrences(i + 1, v, occurrences, count)
  end
end

This counts how often each value appears, then subtracts the divisor matches so you get the non-divisible count for each item.

Count Semi Primes

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Count Semi Primes

defmodule CountSemiPrimes do
  def count_semi_primes(n, p, q) do
    primes = sieve(n)
    semi_flags = semi_prime_flags(n, primes)
    prefix = prefix_sums(semi_flags, n)

    p
    |> Enum.zip(q)
    |> Enum.map(fn {pi, qi} -> Map.get(prefix, qi) - Map.get(prefix, pi - 1, 0) end)
  end

  defp sieve(n) do
    initial = for i <- 0..n, into: %{}, do: {i, i >= 2}
    limit = :math.sqrt(n) |> trunc()

    Enum.reduce(2..limit//1, initial, fn i, primes ->
      if Map.get(primes, i) do
        Enum.reduce(i * i..n//i, primes, fn k, acc -> Map.put(acc, k, false) end)
      else
        primes
      end
    end)
  end

  defp semi_prime_flags(n, primes) do
    initial = for i <- 0..n, into: %{}, do: {i, 0}
    limit = :math.sqrt(n) |> trunc()

    Enum.reduce(2..limit//1, initial, fn k, flags ->
      if Map.get(primes, k) do
        mark_multiples(k, 2, n, primes, flags)
      else
        flags
      end
    end)
  end

  defp mark_multiples(k, i, n, _primes, flags) when i * k > n, do: flags

  defp mark_multiples(k, i, n, primes, flags) do
    flags = if Map.get(primes, i), do: Map.put(flags, k * i, 1), else: flags
    mark_multiples(k, i + 1, n, primes, flags)
  end

  defp prefix_sums(flags, n) do
    {result, _last} =
      Enum.reduce(1..n//1, {%{0 => Map.get(flags, 0, 0)}, Map.get(flags, 0, 0)}, fn i,
                                                                                      {acc, prev} ->
        cur = prev + Map.get(flags, i, 0)
        {Map.put(acc, i, cur), cur}
      end)

    result
  end
end

This precomputes semiprimes and prefix sums so each range query becomes a quick subtraction.

Cyclic Rotation

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Cyclic Rotation

defmodule CyclicRotation do
  def cyclic_rotation([], _k), do: []

  def cyclic_rotation(a, k) do
    size = length(a)
    shift = rem(k, size)
    {front, back} = Enum.split(a, size - shift)

    back ++ front
  end
end

This rotates the array to the right by K steps and keeps the wrap-around values in the correct order.

Distinct

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Distinct

defmodule Distinct do
  def distinct(a), do: a |> Enum.uniq() |> length()
end

This counts unique values by tracking what has already been seen.

Dominator

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Dominator

defmodule Dominator do
  def dominator(a) do
    {size, value, index} =
      a
      |> Enum.with_index()
      |> Enum.reduce({0, nil, nil}, fn {v, k}, {size, value, index} ->
        cond do
          size == 0 -> {1, v, k}
          value != v -> {size - 1, value, index}
          true -> {size + 1, value, index}
        end
      end)

    candidate = if size > 0, do: value, else: -1
    count = Enum.count(a, &(&1 == candidate))

    if count > div(length(a), 2), do: index, else: -1
  end
end

This finds a value that appears in more than half of the array, then returns one valid index for it.

Equi Leader

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Equi Leader

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

This keeps leader counts on both sides of the split and counts positions where the same leader survives in each half.

Fib Frog

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Fib Frog

defmodule FibFrog do
  def fib_frog(a) do
    size = length(a)
    jumps = size |> build_fib([1, 0]) |> Enum.reverse()
    a_map = a |> Enum.with_index() |> Map.new(fn {v, i} -> {i, v} end)

    bfs([{-1, 0}], MapSet.new(), jumps, a_map, size)
  end

  defp build_fib(size, [last | _] = acc) when last > size do
    acc |> Enum.reverse() |> Enum.drop(2)
  end

  defp build_fib(size, [a, b | _] = acc), do: build_fib(size, [a + b | acc])

  defp bfs([], _visited, _jumps, _a_map, _size), do: -1

  defp bfs([{idx, jmp} | rest], visited, jumps, a_map, size) do
    case try_jumps(jumps, idx, jmp, size, a_map, visited) do
      {:found, result} -> result
      {:continue, new_paths, visited} -> bfs(rest ++ new_paths, visited, jumps, a_map, size)
    end
  end

  defp try_jumps(jumps, idx, jmp, size, a_map, visited) do
    Enum.reduce_while(jumps, {:continue, [], visited}, fn f, {:continue, paths, visited} ->
      next_idx = idx + f

      cond do
        next_idx == size ->
          {:halt, {:found, jmp + 1}}

        next_idx > size or MapSet.member?(visited, next_idx) or Map.get(a_map, next_idx) == 0 ->
          {:cont, {:continue, paths, visited}}

        true ->
          {:cont, {:continue, paths ++ [{next_idx, jmp + 1}], MapSet.put(visited, next_idx)}}
      end
    end)
  end
end

This precomputes Fibonacci jumps, then uses a breadth-first search to find the shortest valid path across the river.

Fish

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Fish

defmodule Fish do
  def fish(a, b) do
    size = length(a)

    {_stack, dead} =
      a
      |> Enum.zip(b)
      |> Enum.reduce({[], 0}, fn {size_i, dir_i}, {stack, dead} ->
        if dir_i == 1 do
          {[size_i | stack], dead}
        else
          fight(size_i, stack, dead)
        end
      end)

    size - dead
  end

  defp fight(_size_i, [], dead), do: {[], dead}

  defp fight(size_i, [top | rest] = stack, dead) do
    if size_i > top do
      fight(size_i, rest, dead + 1)
    else
      {stack, dead + 1}
    end
  end
end

This uses a stack for downstream fish and resolves fights only when opposite directions meet.

Flags

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Flags

defmodule Flags do
  def flags(a) do
    size = length(a)
    a_map = a |> Enum.with_index() |> Map.new(fn {v, i} -> {i, v} end)

    peaks =
      for i <- 1..(size - 1), into: %{} do
        prev = Map.get(a_map, i - 1)
        cur = Map.get(a_map, i)
        nxt = Map.get(a_map, i + 1, 0)
        {i, prev < cur and cur > nxt}
      end

    next_map = build_next(size, peaks)

    search(1, size, next_map, 0)
  end

  defp build_next(size, peaks) do
    Enum.reduce((size - 2)..0//-1, %{size - 1 => -1}, fn i, next_map ->
      value = if Map.get(peaks, i, false), do: i, else: Map.get(next_map, i + 1)
      Map.put(next_map, i, value)
    end)
  end

  defp search(i, size, next_map, result) when i * (i - 1) <= size do
    num = walk(0, i, 0, size, next_map)
    search(i + 1, size, next_map, max(result, num))
  end

  defp search(_i, _size, _next_map, result), do: result

  defp walk(pos, step, num, size, next_map) when pos < size and num < step do
    next_pos = Map.get(next_map, pos)

    if next_pos == -1 do
      num
    else
      walk(next_pos + step, step, num + 1, size, next_map)
    end
  end

  defp walk(_pos, _step, num, _size, _next_map), do: num
end

This finds all peaks first, then checks how many flags can be placed while keeping the required distance.

Frog Jmp

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Frog Jmp

defmodule FrogJmp do
  def frog_jmp(x, y, d), do: ceil((y - x) / d)
end

This computes the jump count with math instead of simulation, which is the cleanest way to solve it.

Frog River One

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Frog River One

defmodule FrogRiverOne do
  def frog_river_one(x, a) do
    a
    |> Enum.with_index()
    |> Enum.reduce_while(MapSet.new(), fn {leaf, k}, seen ->
      seen =
        if leaf <= x and not MapSet.member?(seen, leaf) do
          MapSet.put(seen, leaf)
        else
          seen
        end

      if MapSet.size(seen) == x, do: {:halt, k}, else: {:cont, seen}
    end)
    |> case do
      k when is_integer(k) -> k
      _ -> -1
    end
  end
end

This tracks the earliest time each needed position appears and stops as soon as the frog can cross.

Genomic Range Query

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Genomic Range Query

defmodule GenomicRangeQuery do
  def genomic_range_query(s, p, q) do
    p
    |> Enum.zip(q)
    |> Enum.map(fn {pi, qi} ->
      substr = String.slice(s, pi, qi - pi + 1)

      cond do
        String.contains?(substr, "A") -> 1
        String.contains?(substr, "C") -> 2
        String.contains?(substr, "G") -> 3
        true -> 4
      end
    end)
  end
end

This builds prefix counts for each DNA letter so every query can return the minimum impact factor quickly.

Is Ipv 4 Adress

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Is Ipv 4 Adress

defmodule IsIpv4Address do
  def is_ipv4_address(input_string) do
    parts = String.split(input_string, ".")

    length(parts) == 4 and Enum.all?(parts, &valid_octet?/1)
  end

  defp valid_octet?(v) do
    case Integer.parse(v) do
      {n, ""} -> n >= 0 and n <= 255 and Integer.to_string(n) == v
      _ -> false
    end
  end
end

This splits the string by dots and validates each part as a normal IPv4 octet.

Ladder

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Ladder

defmodule Ladder do
  import Bitwise

  def ladder(a, b) do
    mod = (1 <<< Enum.max(b)) - 1
    limit = Enum.max(a)
    fib = build_fib(limit, mod)

    a
    |> Enum.zip(b)
    |> Enum.map(fn {ai, bi} -> Map.get(fib, ai + 1) &&& (1 <<< bi) - 1 end)
  end

  defp build_fib(limit, mod) do
    Enum.reduce(2..(limit + 1)//1, %{0 => 0, 1 => 1}, fn i, fib ->
      value = (Map.get(fib, i - 1) + Map.get(fib, i - 2)) &&& mod
      Map.put(fib, i, value)
    end)
  end
end

This precomputes climb counts once and applies the modulo per query, which avoids recalculating the same paths over and over.

Largest String

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Largest String

defmodule LargestString do
  def largest_string(s) do
    s
    |> String.to_charlist()
    |> Enum.chunk_by(&(&1 in ~c"ab"))
    |> Enum.map(&sort_segment/1)
    |> List.flatten()
    |> List.to_string()
  end

  defp sort_segment([c | _] = segment) when c in ~c"ab" do
    Enum.sort(segment, :desc)
  end

  defp sort_segment(segment), do: segment
end

This builds the biggest valid string it can under the challenge rules by always choosing the best next character it is allowed to use.

Max Counters

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Max Counters

defmodule MaxCounters do
  def max_counters(n, a) do
    condition = n + 1

    {counters, _max_counter, last_update} =
      Enum.reduce(a, {%{}, 0, 0}, fn v, {counters, max_counter, last_update} ->
        cond do
          v <= n ->
            index = v - 1
            updated = max(Map.get(counters, index, 0), last_update) + 1
            {Map.put(counters, index, updated), max(max_counter, updated), last_update}

          v == condition ->
            {counters, max_counter, max_counter}

          true ->
            {counters, max_counter, last_update}
        end
      end)

    0..(n - 1)
    |> Enum.map(fn i -> max(Map.get(counters, i, 0), last_update) end)
  end
end

This delays the expensive “set all counters to max” work until it is really needed, which keeps the solution fast.

Max Double Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Max Double Slice Sum

defmodule MaxDoubleSliceSum do
  def max_double_slice_sum(a) when length(a) < 3, do: 0

  def max_double_slice_sum(a) do
    size = length(a)
    a_map = a |> Enum.with_index() |> Map.new(fn {v, i} -> {i, v} end)

    p1 = build_p1(size, a_map)
    p2 = build_p2(size, a_map)

    1..(size - 2)
    |> Enum.map(fn i -> Map.get(p1, i) + Map.get(p2, i) end)
    |> Enum.max()
  end

  defp build_p1(size, a_map) do
    Enum.reduce(2..(size - 2)//1, %{1 => 0}, fn i, p1 ->
      value = max(0, Map.get(p1, i - 1) + Map.get(a_map, i - 1))
      Map.put(p1, i, value)
    end)
  end

  defp build_p2(size, a_map) do
    Enum.reduce(2..(size - 2)//1, %{size - 2 => 0}, fn i, p2 ->
      key = size - i - 1
      value = max(0, Map.get(p2, size - i) + Map.get(a_map, size - i))
      Map.put(p2, key, value)
    end)
  end
end

This keeps the best sum ending on the left and starting on the right, then combines them around each middle position.

Max Product Of Three

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Max Product Of Three

defmodule MaxProductOfThree do
  def max_product_of_three(a) do
    sorted = Enum.sort(a)
    c = length(sorted)

    max(
      Enum.at(sorted, c - 1) * Enum.at(sorted, c - 2) * Enum.at(sorted, c - 3),
      Enum.at(sorted, 0) * Enum.at(sorted, 1) * Enum.at(sorted, c - 1)
    )
  end
end

This checks the useful extremes, because the best product can come from either the three largest numbers or two negatives plus one large positive.

Max Profit

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Max Profit

defmodule MaxProfit do
  def max_profit([first | _] = a) do
    {_min_price, profit} =
      Enum.reduce(a, {first, 0}, fn v, {min_price, profit} ->
        min_price = min(min_price, v)
        {min_price, max(profit, v - min_price)}
      end)

    profit
  end
end

This tracks the lowest buy price seen so far and updates the best profit as it scans the prices once.

Max Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Max Slice Sum

defmodule MaxSliceSum do
  def max_slice_sum([first | rest]) do
    {_tmp, max} =
      Enum.reduce(rest, {first, first}, fn v, {tmp, max} ->
        tmp = max(tmp + v, v)
        {tmp, max(max, tmp)}
      end)

    max
  end
end

This is a Kadane-style scan: keep the best running sum and the best overall sum while moving once through the array.

Min Avg Two Slice

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Min Avg Two Slice

defmodule MinAvgTwoSlice do
  def min_avg_two_slice(a) do
    size = length(a)
    a_map = a |> Enum.with_index() |> Map.new(fn {v, i} -> {i, v} end)
    initial_avg = (Map.get(a_map, 0) + Map.get(a_map, 1)) / 2

    {idx, _min_avg} =
      Enum.reduce(0..(size - 2), {0, initial_avg}, fn i, {idx, min_avg} ->
        two = (Map.get(a_map, i) + Map.get(a_map, i + 1)) / 2

        cur =
          if Map.has_key?(a_map, i + 2) do
            three = (Map.get(a_map, i) + Map.get(a_map, i + 1) + Map.get(a_map, i + 2)) / 3
            min(two, three)
          else
            two
          end

        if cur < min_avg, do: {i, cur}, else: {idx, min_avg}
      end)

    idx
  end
end

This leans on the key trick for this problem: the minimum average slice is always length 2 or 3.

Min Perimeter Rectangle

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Min Perimeter Rectangle

defmodule MinPerimeterRectangle do
  def min_perimeter_rectangle(n), do: loop(1, n, :infinity)

  defp loop(i, n, min) when i * i < n do
    candidate = if rem(n, i) == 0, do: 2 * (i + div(n, i)), else: nil

    min =
      cond do
        is_nil(candidate) -> min
        min == :infinity -> candidate
        candidate < min -> candidate
        true -> min
      end

    loop(i + 1, n, min)
  end

  defp loop(_i, _n, min), do: min
end

This searches factor pairs up to the square root and picks the pair with the smallest perimeter.

Missing Integer

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Missing Integer

defmodule MissingInteger do
  def missing_integer(a) do
    sorted = a |> Enum.uniq() |> Enum.sort()

    Enum.reduce_while(sorted, 1, fn v, min ->
      cond do
        v <= 0 -> {:cont, min}
        min != v -> {:halt, min}
        true -> {:cont, min + 1}
      end
    end)
  end
end

This records the positive numbers that exist, then returns the smallest positive value that is still missing.

Nesting

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Nesting

defmodule Nesting do
  def nesting(""), do: 1

  def nesting(s) do
    result =
      s
      |> String.graphemes()
      |> Enum.reduce_while([], fn ch, stack ->
        case ch do
          ")" ->
            case stack do
              ["(" | rest] -> {:cont, rest}
              _ -> {:halt, :fail}
            end

          other ->
            {:cont, [other | stack]}
        end
      end)

    if result == [], do: 1, else: 0
  end
end

This treats the string like a balance counter: open parentheses add one, closing ones remove one.

Number Of Disc Intersections

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Number Of Disc Intersections

defmodule NumberOfDiscIntersections do
  def number_of_disc_intersections(a) do
    c = length(a)

    {starts, ends} =
      a
      |> Enum.with_index()
      |> Enum.reduce({%{}, %{}}, fn {v, k}, {starts, ends} ->
        start_key = max(0, k - v)
        end_key = min(c - 1, k + v)

        {Map.update(starts, start_key, 1, &(&1 + 1)), Map.update(ends, end_key, 1, &(&1 + 1))}
      end)

    0..(c - 1)
    |> Enum.reduce_while({0, 0}, fn k, {sum, active} ->
      s = Map.get(starts, k, 0)
      e = Map.get(ends, k, 0)
      sum = sum + active * s + div(s * (s - 1), 2)

      if sum > 10_000_000 do
        {:halt, {:found, -1}}
      else
        {:cont, {sum, active + s - e}}
      end
    end)
    |> case do
      {:found, -1} -> -1
      {sum, _active} -> sum
    end
  end
end

This sorts disc start and end points and counts active overlaps without comparing every pair directly.

Odd Occurrences In Array

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Odd Occurrences In Array

defmodule OddOccurrencesInArray do
  def odd_occurrences_in_array(a) do
    a
    |> Enum.reduce(%{}, fn v, count ->
      if Map.has_key?(count, v), do: Map.delete(count, v), else: Map.put(count, v, 1)
    end)
    |> Map.keys()
    |> List.first()
  end
end

This uses XOR to cancel out pairs, leaving only the value that appears an odd number of times.

Palindrome Rearranging

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Palindrome Rearranging

defmodule PalindromeRearranging do
  def palindrome_rearranging(input_string) do
    input_string
    |> String.graphemes()
    |> Enum.frequencies()
    |> Map.values()
    |> Enum.count(&(rem(&1, 2) != 0))
    |> Kernel.<=(1)
  end
end

This counts character frequency and checks whether the string has the right number of odd counts to form a palindrome.

Passing Cars

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Passing Cars

defmodule PassingCars do
  def passing_cars(a) do
    a
    |> Enum.reduce_while({0, 0}, fn i, {passing, multiply} ->
      cond do
        i == 0 ->
          {:cont, {passing, multiply + 1}}

        multiply > 0 ->
          passing = passing + multiply

          if passing > 1_000_000_000 do
            {:halt, {:found, -1}}
          else
            {:cont, {passing, multiply}}
          end

        true ->
          {:cont, {passing, multiply}}
      end
    end)
    |> case do
      {:found, -1} -> -1
      {passing, _multiply} -> passing
    end
  end
end

This counts eastbound cars as it scans, then adds them whenever a westbound car appears.

Peaks

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Peaks

defmodule Peaks do
  def peaks(a) when length(a) <= 2, do: 0

  def peaks(a) do
    n = length(a)
    a_map = a |> Enum.with_index() |> Map.new(fn {v, i} -> {i, v} end)

    {sum, dist, last_peak} = scan_peaks(a_map, n)
    total_peaks = Map.get(sum, n - 2, 0)
    sum = Map.put(sum, n - 1, total_peaks)

    if total_peaks == 0 do
      0
    else
      dist = max(dist, n - last_peak)

      case find_divisor(div(dist, 2) + 1, dist, n, sum) do
        {:ok, groups} -> groups
        :none -> div(n, find_valid_divisor(dist, n))
      end
    end
  end

  defp scan_peaks(a_map, n) do
    Enum.reduce(1..(n - 2), {%{0 => 0}, 0, -1}, fn i, {sum, dist, last} ->
      prev_sum = Map.get(sum, i - 1)

      is_peak =
        Map.get(a_map, i) > Map.get(a_map, i - 1) and
          Map.get(a_map, i) > Map.get(a_map, i + 1)

      if is_peak do
        {Map.put(sum, i, prev_sum + 1), max(dist, i - last), i}
      else
        {Map.put(sum, i, prev_sum), dist, last}
      end
    end)
  end

  defp find_divisor(i, dist, _n, _sum) when i >= dist, do: :none

  defp find_divisor(i, dist, n, sum) do
    if rem(n, i) == 0 do
      case walk_groups(i, i, n, sum, 0) do
        {:ok, last_j} when last_j > n -> {:ok, div(n, i)}
        _ -> find_divisor(i + 1, dist, n, sum)
      end
    else
      find_divisor(i + 1, dist, n, sum)
    end
  end

  defp walk_groups(j, _step, n, _sum, _last) when j > n, do: {:ok, j}

  defp walk_groups(j, step, n, sum, last) do
    current = Map.get(sum, j - 1)

    if current <= last do
      {:ok, j}
    else
      walk_groups(j + step, step, n, sum, current)
    end
  end

  defp find_valid_divisor(last, n) when rem(n, last) == 0, do: last
  defp find_valid_divisor(last, n), do: find_valid_divisor(last + 1, n)
end

This finds the peak positions, then tests how many equal blocks can each contain at least one peak.

Perm Check

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Perm Check

defmodule PermCheck do
  def perm_check(a) do
    sorted = Enum.sort(a)
    size = length(sorted)

    ok =
      0..(size - 2)//1
      |> Enum.all?(fn k -> Enum.at(sorted, k) == k + 1 end)

    if ok, do: 1, else: 0
  end
end

This validates that every value from 1 to N appears exactly once.

Perm Missing Element

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Perm Missing Element

defmodule PermMissingElement do
  def perm_missing_element(a) do
    sorted = Enum.sort(a)

    sorted
    |> Enum.with_index()
    |> Enum.find_value(fn {v, k} -> if v != k + 1, do: k + 1 end)
    |> Kernel.||(length(sorted) + 1)
  end
end

This uses the expected sum of 1..N+1 and subtracts the actual sum to find the missing value.

Plagiarism Check

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Plagiarism Check

defmodule PlagiarismCheck do
  def plagiarism_check(code1, code2) do
    c1 = Enum.join(code1, " ")
    c2 = Enum.join(code2, " ")

    if c1 == c2 do
      false
    else
      words1 = ~r/\w+/ |> Regex.scan(c1) |> List.flatten()
      words2 = ~r/\w+/ |> Regex.scan(c2) |> List.flatten()

      candidates =
        words1
        |> Enum.zip(words2)
        |> Enum.reduce(%{}, fn {w1, w2}, acc ->
          if w1 != w2 and not numeric?(w1), do: Map.put(acc, w1, w2), else: acc
        end)

      c1_placeheld =
        Enum.reduce(candidates, c1, fn {orig, _repl}, acc ->
          replace_word(acc, orig, "PLACEHOLDER" <> orig)
        end)

      c1_final =
        Enum.reduce(candidates, c1_placeheld, fn {orig, repl}, acc ->
          replace_word(acc, "PLACEHOLDER" <> orig, repl)
        end)

      c1_final == c2
    end
  end

  defp numeric?(w) do
    case Integer.parse(w) do
      {_n, ""} -> true
      _ -> false
    end
  end

  defp replace_word(text, target, replacement) do
    escaped = Regex.escape(target)

    text
    |> String.replace(~r/(\W)#{escaped}(\W)/, "\\1#{replacement}\\2")
    |> String.replace(~r/(\W)#{escaped}/, "\\1#{replacement}")
  end
end

This flattens both snippets, tries consistent identifier replacements, and checks whether the rewritten code matches.

Shape Area

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Shape Area

defmodule ShapeArea do
  def shape_area(1), do: 1
  def shape_area(n), do: shape_area(n - 1) + 4 * (n - 1)
end

This returns the area of the growing n-interesting polygon using the direct formula instead of building the shape.

Stone Blocks

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Stone Blocks

defmodule StoneBlocks do
  def stone_blocks(h) do
    {_stack, blocks} =
      Enum.reduce(h, {[], 0}, fn height, {stack, blocks} ->
        stack = Enum.drop_while(stack, &(&1 > height))

        case stack do
          [^height | _] -> {stack, blocks}
          _ -> {[height | stack], blocks + 1}
        end
      end)

    blocks
  end
end

This uses a stack of active heights and only counts a new block when the wall needs a new height segment.

Tape Equilibrium

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Tape Equilibrium

defmodule TapeEquilibrium do
  def tape_equilibrium(a) do
    total = Enum.sum(a)
    size = length(a)

    {_first, _second, min} =
      Enum.reduce(0..(size - 2)//1, {0, total, :infinity}, fn i, {first, second, min} ->
        first = first + i
        second = second - i
        diff = abs(first - second)
        min = if min == :infinity or diff < min, do: diff, else: min
        {first, second, min}
      end)

    min
  end
end

This keeps left and right running sums and updates the smallest difference at each split point.

Triangle

Mon, 01 Jan 0001 00:00:00 +0000

Elixir Triangle

defmodule Triangle do
  def triangle(a) when length(a) < 3, do: 0

  def triangle(a) do
    sorted = Enum.sort(a)
    c = length(sorted)

    found =
      Enum.any?(0..(c - 3), fn i ->
        v = Enum.at(sorted, i)
        v > 0 and v > Enum.at(sorted, i + 2) - Enum.at(sorted, i + 1)
      end)

    if found, do: 1, else: 0
  end
end

This sorts the values and checks nearby triples, because a valid triangle only needs one local match after sorting.