newbie1

How to get min values structs from array?

Hi, I have an array of structs:

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

What i want is return the struct with minimum value. if there is more than 1 struct which contains minimum value like “1” it should return all of them. in this case it should return:

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

The check is on “count”

Thanks in advance

7 comments

#book-introducing-elixir

0 6571 7

2020-07-08 18:06:55 UTC

Most Liked

peerreynders

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).

Post #1

OvermindDL1

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}]}

Post #3

peerreynders

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

Post #4

Last Post!

xoron

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))

Post #7