Elixir Enum Functions

Question 1

Returns a map with keys as unique elements of enumerable and values as the count of every element.

Answer 1

frequencies(enumerable)

Question 2

Returns true if fun.(element) is truthy for all elements in enumerable.

Answer 2

all?(enumerable, fun \ fn x -> x end)

Question 3

Returns true if fun.(element) is truthy for at least one element in enumerable.

Answer 3

any?(enumerable, fun \ fn x -> x end)

Question 4

Finds the element at the given index (zero-based).

Answer 4

at(t(), index(), default()) :: element() | default()

Question 5

Splits enumerable on every element for which fun returns a new value.

Answer 5

chunk_by(enumerable, fun)

Question 6

Shortcut to chunk_every(enumerable, count, count).

Answer 6

chunk_every(enumerable, count)

Question 7

Returns list of lists containing count elements each, where each new chunk starts step elements into the enumerable.

Answer 7

chunk_every(enumerable, count, step, leftover \ [])

Question 8

Chunks the enumerable with fine grained control when every chunk is emitted.

Answer 8

chunk_while(enumerable, acc, chunk_fun, after_fun)

Question 9

Turn a list of lists into a single list

Answer 9

concat(enumerables)

Question 10

Concatenates the enumerable on the right with the enumerable on the left.

Answer 10

concat(left, right)

Question 11

Returns the size of the enumerable.

Answer 11

count(enumerable)

Question 12

Returns the count of elements in the enumerable for which fun returns a truthy value.

Answer 12

count(enumerable, fun)

Question 13

Enumerates the enumerable, returning a list where all consecutive duplicated elements are collapsed to a single element.

Answer 13

dedup(enumerable)

Question 14

Enumerates the enumerable, returning a list where all elements that return the same value from a function are collapsed to a single element.

Answer 14

dedup_by(enumerable, fun)

Question 15

Deletes the elements from the start or end of enumerable

Answer 15

drop(enumerable, amount)

Question 16

Returns a list with every nth element in the enumerable dropped, starting with the first element.

Answer 16

drop_every(enumerable, nth)

Question 17

Drops elements at the beginning of the enumerable while fun returns a truthy value.

Answer 17

drop_while(enumerable, fun)

Question 18

Invokes the given fun for each element in the enumerable.

Answer 18

each(enumerable, fun)

Question 19

Returns true if no elements in enumerable

Answer 19

empty?(enumerable)

Question 20

Finds the element at the given index (zero-based). and returns {:ok, element} or :error

Answer 20

fetch(enumerable, index)

Question 21

Finds the element at the given index (zero-based). Raises if index is out of bounds.

Answer 21

fetch!(enumerable, index)

Question 22

Returns the elements for which a function returns a truthy value

Answer 22

filter(enumerable, fun)

Question 23

Returns the first element for which fun returns a truthy value. If no such element is found, returns default.

Answer 23

find(enumerable, default \ nil, fun)

Question 24

Similar to find/3, but returns the index (zero-based) of the element instead of the element itself.

Answer 24

find_index(enumerable, fun)

Question 25

Similar to find/3, but returns the value of the function invocation instead of the element itself.

Answer 25

find_value(enumerable, default \\ nil, fun)

Question 26

Maps the given fun over enumerable and flattens the result.

Answer 26

flat_map(enumerable, fun)

Question 27

Maps and reduces an enumerable, flattening the given results (only one level deep).

Answer 27

flat_map_reduce(enumerable, acc, fun)

Question 28

Returns a map with keys as unique elements of enumerable and values as the count of every element.

Answer 28

frequencies(enumerable)

Question 29

Returns a map with keys as unique elements given by key_fun and values as the count of every element.

Answer 29

frequencies_by(enumerable, key_fun)

Question 30

Splits the enumerable into groups based on key_fun.

Answer 30

group_by(enumerable, key_fun, value_fun \\ fn x -> x end)

Question 31

Intersperses element between each element of the enumeration.

Answer 31

intersperse(enumerable, element)

Question 32

Inserts the given enumerable into a collectable.

Answer 32

into(enumerable, collectable)

Question 33

Inserts the given enumerable into a collectable according to the transformation function.

Answer 33

into(enumerable, collectable, transform)

Question 34

Turn an enumerable into a binary with a joiner

Answer 34

join(enumerable, joiner \\ "")

Question 35

Returns a list where each element is the result of invoking fun on each corresponding element of enumerable.

Answer 35

map(enumerable, fun)

Question 36

Returns a list of results of invoking fun on every nth element of enumerable, starting with the first element.

Answer 36

map_every(enumerable, nth, fun)

Question 37

Maps and intersperses the given enumerable in one pass.

Answer 37

map_intersperse(enumerable, separator, mapper)

Question 38

Maps and joins the given enumerable in one pass.

Answer 38

map_join(enumerable, joiner \\ "", mapper)

Question 39

Invokes the given function to each element in the enumerable to reduce it to a single element, while keeping an accumulator.

Answer 39

map_reduce(enumerable, acc, fun)

Question 40

Returns the maximal element in the enumerable according to Erlang's term ordering.

Answer 40

max(enumerable, sorter \\ &>=/2, empty_fallback \\ fn -> raise(Enum.EmptyError) end)

Question 41

Returns the maximal element in the enumerable as calculated by the given fun.

Answer 41

max_by(enumerable, fun, sorter \\ &>=/2, empty_fallback \\ fn -> raise(Enum.EmptyError) end)

Question 42

Checks if element exists within the enumerable.

Answer 42

member?(enumerable, element)

Question 43

Returns the minimal element in the enumerable according to Erlang's term ordering.

Answer 43

min(enumerable, sorter \\ &<=/2, empty_fallback \\ fn -> raise(Enum.EmptyError) end)

Question 44

Returns the minimal element in the enumerable as calculated by the given fun.

Answer 44

min_by(enumerable, fun, sorter \\ &<=/2, empty_fallback \\ fn -> raise(Enum.EmptyError) end)

Question 45

Returns a tuple with the minimal and the maximal elements in the enumerable according to Erlang's term ordering.

Answer 45

min_max(enumerable, empty_fallback \\ fn -> raise(Enum.EmptyError) end)

Question 46

Returns a tuple with the minimal and the maximal elements in the enumerable as calculated by the given function.

Answer 46

min_max_by(enumerable, fun, empty_fallback \\ fn -> raise(Enum.EmptyError) end)

Question 47

Returns a random element of an enumerable.

Answer 47

random(enumerable)

Question 48

Invokes fun for each element in the enumerable with the accumulator.

Answer 48

reduce(enumerable, fun)

Question 49

Invokes fun for each element in the enumerable with the accumulator.

Answer 49

reduce(enumerable, acc, fun)

Question 50

Reduces enumerable until fun returns {:halt, term}.

Answer 50

reduce_while(enumerable, acc, fun)

Question 51

Returns a list of elements in enumerable excluding those for which the function fun returns a truthy value.

Answer 51

reject(enumerable, fun)

Question 52

Returns a list of elements in enumerable in reverse order.

Answer 52

reverse(enumerable)

Question 53

Reverses the elements in enumerable, appends the tail, and returns it as a list.

Answer 53

reverse(enumerable, tail)

Question 54

Reverses the enumerable in the range from initial start_index through count elements.

Answer 54

reverse_slice(enumerable, start_index, count)

Question 55

Applies the given function to each element in the enumerable, storing the result in a list and passing it as the accumulator for the next computation. Uses the first element in the enumerable as the starting value.

Answer 55

scan(enumerable, fun)

Question 56

Applies the given function to each element in the enumerable, storing the result in a list and passing it as the accumulator for the next computation. Uses the given acc as the starting value.

Answer 56

scan(enumerable, acc, fun)

Question 57

Returns a list with elements in random order

Answer 57

shuffle(enumerable)

Question 58

Returns a subset list of the given enumerable by index_range.

Answer 58

slice(enumerable, index_range)

Question 59

Returns a subset list of the given enumerable, from start_index (zero-based) with amount number of elements if available.

Answer 59

slice(enumerable, start_index, amount)

Question 60

Sorts the enumerable according to Erlang's term ordering.

Answer 60

sort(enumerable)

Question 61

Sorts the enumerable by the given function.

Answer 61

sort(enumerable, fun)

Question 62

Sorts the mapped results of the enumerable according to the provided sorter function.

Answer 62

sort_by(enumerable, mapper, sorter \\ &<=/2)

Question 63

Splits the enumerable into two enumerables, leaving count elements in the first one.

Answer 63

split(enumerable, count)

Question 64

Splits enumerable in two at the position of the element for which fun returns a falsy value (false or nil) for the first time.

Answer 64

split_while(enumerable, fun)

Question 65

Splits the enumerable in two lists according to the given function fun.

Answer 65

split_with(enumerable, fun)

Question 66

Returns the sum of all elements.

Answer 66

sum(enumerable)

Question 67

Takes an amount of elements from the beginning or the end of the enumerable.

Answer 67

take(enumerable, amount)

Question 68

Returns a list of every nth element in the enumerable, starting with the first element.

Answer 68

take_every(enumerable, nth)

Question 69

Takes count random elements from enumerable.

Answer 69

take_random(enumerable, count)

Question 70

Takes the elements from the beginning of the enumerable while fun returns a truthy value.

Answer 70

take_while(enumerable, fun)

Question 71

Converts enumerable to a list.

Answer 71

to_list(enumerable)

Question 72

Enumerates the enumerable, removing all duplicated elements.

Answer 72

uniq(enumerable)

Question 73

Enumerates the enumerable, by removing the elements for which function fun returned duplicate elements.

Answer 73

uniq_by(enumerable, fun)

Question 74

Opposite of zip/2. Extracts two-element tuples from the given enumerable and groups them together.

Answer 74

unzip(enumerable)

Question 75

Returns the enumerable with each element wrapped in a tuple alongside its index.

Answer 75

with_index(enumerable, offset \\ 0)

Question 76

Zips corresponding elements from a finite collection of enumerables into one list of tuples.

Answer 76

zip(enumerables)

Question 77

Zips corresponding elements from two enumerables into one list of tuples.

Answer 77

zip(enumerable1, enumerable2)