How to get min values structs from array?

A list of maps actually …

There is a Enum.min_by/3 but that returns only a single value. But all these functions are linked to the source so you can find out how that works - it turns out that it is based on - Lists.foldl/3 - a function you can use to solve your problem (or Enum.reduce/3).

Now both reduce and foldl work on an accumulator value - my choice would be a tuple like (min_value, [maps_with_min_value]). So every time a new element of the list is inspected a decision has to be made:

• Is this lower than min_value? If yes, start a new list for the new min value resulting in a tuple (new_min_value, [map_with_new_min_value])
• Is this equal to min_value? If yes, add the new map to the list, i.e. (min_value,[new_map| others])
• Otherwise leave the tuple unchanged.

Note also that you should also account for being handed an empty list - i.e. there is no minimum - then the resulting list should simply be empty. But if there are any maps to process in the list you simply take the first map as your initial minimum for the accumulator and process the remainder of the list with foldl or reduce.

PS: With pattern matching you can just use the list as an accumulator (i.e. peek inside the first element of the list rather than holding min_value separately).

I think peerreynders gave the most professional answer.

You can use this function,

  def getmin(maplst, key) do
    m = maplst |> Enum.map(fn(x) -> Map.get(x, key) end) |> Enum.min
    Enum.filter(maplst, fn(x) -> Map.get(x, key) == m end)
  end

in your case put in your

array = [%{count: 1, img: 1}, %{count: 1, img: 2}, %{count: 3, img: 3}, %{count: 1, img: 4}]

and :count as arguments and it should work.

I’m sure there’s a more elegant way to solve your problem, this is just what I came up with.

If you want it to output in exactly the same output as you stated (so the same order as the original) then I’d just do this:

╰─➤  iex
Erlang/OTP 20 [erts-9.1] [source] [64-bit] [smp:2:2] [ds:2:2:10] [async-threads:10] [hipe] [kernel-poll:false]

Interactive Elixir (1.6.1) - press Ctrl+C to exit (type h() ENTER for help)
iex(1)> array = [%{count: 1, img: 1}, %{count: 1, img: 2}, %{count: 3, img: 3}, %{count: 1, img: 4}]
[
  %{count: 1, img: 1},
  %{count: 1, img: 2},
  %{count: 3, img: 3},
  %{count: 1, img: 4}
]
iex(2)> {_, array} = Enum.reduce(Enum.reverse(array), {nil, []}, fn
...(2)>   %{count: count} = v, {c, a} when count < c -> {count, [v]}
...(2)>   %{count: count} = v, {count, a} -> {count, [v | a]}
...(2)>   _, acc -> acc
...(2)> end)
{1, [%{count: 1, img: 1}, %{count: 1, img: 2}, %{count: 1, img: 4}]}

It’s worth noting that this approach relies on term ordering:

number < atom < reference < function < port < pid < tuple < map < list < bitstring

i.e. because nil is actually :nil (i.e. an atom)

number < nil

is always true

Correct, this is precisely one of the aspects I was using.

/me often compares a number to an atom in such cases, it is very convenient, an old habit from erlang…

I actually originally typed :infinite there as that is what I usually do from erlang, but nil I figured is more understandable for Elixir’ians as :infinite could be deemed as magical when it is not. ^.^

Another option for your entertainment:

def min_values([head | tail]) do
  acc_min = fn(x, [a | _] = acc) ->
    cond do
      x.count == a.count -> [x | acc]
      x.count > a.count -> acc
      x.count < a.count -> [x]
    end
  end

  List.foldl(tail, [head], acc_min) |> Enum.reverse()
end

edit Hah, teaches me to skim too quickly, looks like thats pretty much exactly what peerreynders described but without dealing with empty lists. Here’s a better recursive version:

def min_values(list, acc \\ [])
def min_values([head | tail], []), do: min_values(tail, [head])
def min_values([head | tail], [%{count: val} | _] = acc) do
  cond do
    head.count == val -> min_values(tail, [head | acc])
    head.count > val -> min_values(tail, acc)
    head.count < val -> min_values(tail, [head])
  end
end
def min_values([], acc), do: Enum.reverse(acc)

Here Simple solution not for used just for practice.Suggest any improvement.
Please Confirm that recursion tail call applied and idiomatic code thanks.

defmodule ListOperator do
  def findValue([head | tail]) do
    minValues(tail, [head])
  end

  defp minValues([%{count: count} | tail], [%{count: min_count} | _tail] = main_head)
       when count > min_count do
    minValues(tail, main_head)
  end

  defp minValues([%{count: count} = head | tail], [%{count: min_count} | _tail])
       when count < min_count do
    minValues(tail, [head])
  end

  defp minValues([%{count: count} = head | tail], [%{count: min_count} | _tail] = main_head)
       when count == min_count do
    minValues(tail, [head | main_head])
  end

  defp minValues([], value), do: value
end

array = [
  %{count: 4, img: 1},
  %{count: 8, img: 2},
  %{count: 3, img: 3},
  %{count: 5, img: 4},
  %{count: 5, img: 1},
  %{count: 7, img: 2},
  %{count: 3, img: 3},
  %{count: 9, img: 4},
  %{count: 4, img: 1},
  %{count: 8, img: 2},
  %{count: 3, img: 3},
  %{count: 5, img: 4},
  %{count: 5, img: 1},
  %{count: 7, img: 2},
  %{count: 3, img: 3},
  %{count: 9, img: 4}
]

IO.inspect(ListOperator.findValue(array))