A helpful way to think about these situations is to think about the types.

Enum.reduce expects a function of type (element, accumulator) -> accumulator and returns a result of type accumulator.

Enum.scan expects a function of type (element, accumulator) -> accumulator and returns a result of type [accumulator], so it’s worth considering if you’re expecting a list of results.

A good example for comparing the two is with lists of integers:

numbers = [1, 2, 3, 4]

Enum.reduce(numbers, 0, fn n, acc ->
  n + acc
end)
# returns the TOTAL: 10

Enum.scan(numbers, 0, fn n, acc ->
  n + acc
end)
# returns the list of SUBTOTALS: [1, 3, 6, 10]

In your example, using binaries (like "1$#$Bruce Waine, Batman") as an accumulator type is less than ideal. A better intermediate format would be a tuple like {1, "Bruce Waine, Batman"}, resulting in code like:

business_card
|> String.split("\n")
|> Enum.scan({0, ""}, fn line, {acc_number, _} ->
  {acc_number+1, line}
end)
|> Enum.map(fn {n, line} ->
  "#{n}$#$#{line}
end)

You don’t exactly need Enum.reduce then, you likely need Enum.with_index plus Enum.map, but it can be done with Enum.reduce by using a tuple accumulator as @kip showed you.

Whatever the function returns become acc on the next iteration. And whatever acc is at the end is returned by Enum.reduce/3. Therefore you will be accumulating a list of results in many common cases, including this one.

Think more along the lines of:

{count, results} =
  Enum.reduce(cards, {0, []}, fn (x, {seq, acc) ->
    seq = seq + 1
    {seq, "#{seq}$#$#{x}"}
  end)