Exercise 1

1-1 & 1-2

defmodule Fibonacci do
  def sum_even_fibonacci(limit) do
    tail_sum_even_fibonacci(1, 2, 0, limit)
  end

  defp tail_sum_even_fibonacci(a, b, acc, limit) when a > limit do
    acc
  end

  defp tail_sum_even_fibonacci(a, b, acc, limit) do
    new_acc = if rem(a, 2) == 0, do: acc + a, else: acc
    tail_sum_even_fibonacci(b, a + b, new_acc, limit)
  end

  def find_largest_palindrome do
    max_palindrome =
      for a <- 999..100, b <- 999..100, is_palindrome?(a * b) do
        a * b
      end
      |> Enum.max()

    max_palindrome
  end

  defp is_palindrome?(n) do
    Integer.to_string(n) == Integer.to_string(n) |> String.reverse()
  end
end

# Beispielaufruf mit einer Grenze von 4 Millionen
limit = 4_000_000
result = Fibonacci.sum_even_fibonacci(limit)
result2 = Fibonacci.find_largest_palindrome()

IO.puts("Sum of even Fibonacci numbers below #{limit}: #{result}")
IO.puts("Größtes Palindrom aus dem Produkt zweier zweistelliger Zahlen: #{result2}")

1-3

defmodule CountAndSay do
  def generate(n) do
    generate_recursive(n, "1")
  end

  defp generate_recursive(1, acc) do
    acc
  end

  defp generate_recursive(n, acc) do
    new_seq = calculate(acc)
    generate_recursive(n - 1, new_seq)
  end

  defp calculate(input) do
    # Die Eingabe in Grapheme-Cluster zerlegen, um sicherzustellen, dass
    # jede Ziffer als einzelnes Zeichen behandelt wird.
    calculate_recursive(String.graphemes(input), "", "", 0)
  end

  defp calculate_recursive([], result, last_digit, count) do
    append(result, count, last_digit)
  end

  defp calculate_recursive([head | tail], result, last_digit, count) do
    digit = head

    if last_digit == "" or digit == last_digit do
      calculate_recursive(tail, result, digit, count + 1)
    else
      new_result = append(result, count, last_digit)
      calculate_recursive(tail, new_result, digit, 1)
    end
  end

  defp append(result, count, digit) do
    result <> "#{count}#{digit}"
  end
end

IO.puts(CountAndSay.generate(2))
IO.puts(CountAndSay.generate(4))
IO.puts(CountAndSay.generate(5))
IO.puts(CountAndSay.generate(6))
IO.puts(CountAndSay.generate(9))
IO.puts(CountAndSay.generate(10))

1-4 & 1-5

defmodule Diceware do
  def get_map(file_name) do
    {:ok, file} = File.read(file_name)
    result_map = %{}

    # Map mit key = erste Wort der Zeile und value = zweite Wort der Zeile
    file
    |> String.trim()
    |> String.split("\n")
    |> Enum.map(fn line -> String.split(line, " ") end)
    |> Enum.reduce(result_map, fn [key, value], acc -> Map.put(acc, key, value) end)
  end

  def gen_password(map, number_of_keys) do
    number_of_keys = abs(number_of_keys)

    random_numbers_list =
      Enum.map(1..number_of_keys, fn _ ->
        Enum.join(Enum.map(1..5, fn _ -> Integer.to_string(Enum.random(1..6)) end), "")
      end)

    IO.inspect(random_numbers_list, label: "Generated Keys:")

    # existing_keys = Map.keys(map)
    # IO.inspect(existing_keys, label: "Existing Keys in Map:")

    values_list =
      Enum.map(random_numbers_list, fn key ->
        value = Map.get(map, key, "Not found")
        IO.inspect(value, label: "Value for key #{key}:")
      end)

    Enum.join(values_list, "")
  end
end

file_path = "/Users/dav00731/Desktop/Uni/WebApllication/diceware_german.txt"
result_map = Diceware.get_map(file_path)
# IO.inspect(result_map)

number_of_keys = -5
password = Diceware.gen_password(result_map, number_of_keys)
IO.inspect(password)

Ergänzungen

# defmodule E do
#   fib() do
#     |> Stream.filter(fn n -> rem(n,2) == 0 end)
#     |> Stream.take_while(fn n -> n < 4000000 end) #Zhang hatte hier filter genutzt (das war dann eine ewige Schleife)
#     |> Enum.sum()
#   end
# end

defmodule Example do
  # Lauflängen Codierung
  def run_length(a) do
    tail_run_length(a, [])
  end

  defp tail_run_length([], acc) do
    acc
  end

  defp tail_run_length([h | t], acc) do
    IO.puts("Input: #{[h | t]}")
    next_run = [h | t] |> Enum.take_while(&amp;(&amp;1 == h))
    rest = [h | t] |> Enum.drop_while(&amp;(&amp;1 == h))
    new_acc = acc ++ [{length(next_run), h}]

    # Konvertiere Tupel in Strings für die Ausgabe
    next_run_str = Enum.map(next_run, &amp;to_string/1)
    new_acc_str = Enum.map(new_acc, &amp;"{#{elem(&amp;1, 0)}, #{elem(&amp;1, 1)}}")

    IO.puts(
      "Input: #{[h | t]}, Next Run: #{next_run_str}, Rest: #{rest}, Accumulator: #{new_acc_str}"
    )

    tail_run_length(rest, new_acc)
  end
end

input_list = [1, 1, 1, 2, 2, 3, 4, 4, 4, 4, 5]
Example.run_length(input_list)