defmodule Fpea do

  @moduledoc """
  Példák az FP előadásokhoz

  @author "hanak@emt.bme.hu"
  @date   "$LastChangedDate: 2024-09-22 14:41:28 +0200 (Sun, 22 Sep 2024) $$"
  """

  # A fájl nevét csupa kisbetűvel kell írni, szóköz helyett aláhúzás-jellel (snake case)
  # A modul nevét egybe kell írni, a szavakat nagybetűvel kell kezdeni (camel case)

  @spec fac(n::integer()) :: f::integer()
  # f = n! (azaz f az n faktoriálisa)
  def fac(0), do: 1            # ha az n=0 mintaillesztés sikeres
  def fac(n), do: n * fac(n-1) # ha az n=0 mintaillesztés sikertelen

  @spec sum(xs::[integer()]) :: s::integer()
  # Az xs számlista összege s
  def sum([]), do: 0
  def sum(xs)  do x = hd(xs); rs = tl(xs); x + sum rs end

  @spec append(xs::[any()], ys::[any()]) :: rs::[any()]
  # rs az xs lista ys elé fűzésével kapott lista
  def append([], ys), do: ys
  def append(xs, ys), do: [(hd xs) | (append (tl xs), ys)]

  @spec revapp(xs::[any()], ys::[any()]) :: rs::[any()]
  # rs a megfordított xs lista ys elé fűzésével kapott lista
  def revapp([], ys), do: ys
  def revapp(xs, ys), do: revapp((tl xs), [(hd xs) | ys])

  @spec sum_of_squares(a::number(), b::number()) :: s::number()
  def sum_of_squares(a,b), do: sqr(a) + sqr(b)
  defp sqr(a), do: a*a # p[rivate], i.e. local in this module

  def sum_of_sqrs_b5(a, b \\ 5), do: sqr(a) + sqr(b)

  def sum_of_sqrs_a6b5(a \\ 6, b \\ 5), do: sqr(a) + sqr(b)

  def head([]),      do: {:error, nil}
  def head([x|_xs]), do: {:ok, x}
  
  _tail = fn [] -> {:error, nil}; [_x|xs] -> {:ok, xs} end
  # cnt_a = fn [] -> 0; [_x|xs] -> (cnt_a xs) + 1 end

  def cnt_n([]), do: 0; def cnt_n([_x|xs]), do: (cnt_n xs) + 1

  def hello_1(msg, name), do: (IO.write msg; IO.puts ", mizújs, #{name}?")

  def hello_2(msg, name), do: (  # csoportosítás zárójelezéssel
    IO.write msg                 # pontosvessző helyett új sorba
    IO.puts ", mizújs, #{name}?"
  )

  def hello_3(msg, name) do      # zárójel helyett do...end
    IO.write msg
    IO.puts ", mizújs, #{name}?"
  end

  # Már látott megoldás
  # def fac(0), do: 1            # ha az n=0 mintaillesztés sikeres
  # def fac(n), do: n * fac(n-1) # ha az n=0 mintaillesztés sikertelen

  def fac_1(0),            do: 1            # ha az n=0 mintaillesztés sikeres
  def fac_1(n) when n > 0, do: n * fac_1(n-1) # ha az n=0 mintaillesztés sikertelen

  def fac_2(0),                             do: 1              # ha az n=0 mintaillesztés sikeres
  def fac_2(n) when is_integer(n) and n > 0, do: n * fac_2(n-1) # ha az n=0 mintaillesztés sikertelen

  def filter(_pred, []), do: []
  def filter(pred, [x|xs]) do
    cond do
      pred.(x) ->
	[x | filter(pred, xs)]
      true
	-> filter(pred, xs)
    end
  end

  @spec pitag(n::integer()) :: ps::[{integer(),integer(),integer()}]
  def pitag(n), do:
    (ls = 1..n
     for a <- ls, b <- ls, a <= b,
         c <- ls, a + b + c <= n,
         a * a + b * b === c * c,
           do: {a, b, c}
    )

  @spec freq(val::any(), ls::[any()]) :: n::integer()
  #  ls-ben a val értékű elemek száma n
  def freq(val, ls), do:
    length(for x <- ls, b = (x === val), do: b)

  def qsort([]), do: []
  def qsort([pivot|tail]), do:
    qsort(for x <- tail, x < pivot, do: x) ++
      [ pivot | qsort(for x <- tail, x >= pivot, do: x) ]

  @spec perms(xs::[any()]) :: pss::[[any()]]
  # Az xs lista elemeinek összes permutációját tartalmazó lista pss
  def perms([]), do: [[]]
  def perms(xs), do: (for y <- xs, ys <- perms(xs--[y]), do: [y|ys])

  @type asciicode() :: integer()
  @spec to_decval_cond(hexval::asciicode()) :: d::integer()
  def to_decval_cond(hexval) do
    cond do
      ?0 <= hexval && hexval <= ?9 -> hexval - ?0
      ?a <= hexval and hexval <= ?f -> hexval - ?a + 10
    end
  end
  
  def to_decval_cond2(hexval) do
    cond do
      ?0 <= hexval and hexval <= ?9 -> hexval - ?0
      ?a <= hexval and hexval <= ?f -> hexval - ?a + 10
      true                         -> nil
    end
  end
  
  def to_decval_cond3(hexval) do
    cond do
      ?0 <= hexval && hexval <= ?9 -> {:ok, hexval - ?0}
      ?a <= hexval && hexval <= ?f -> {:ok, hexval - ?a + 10}
      true                         -> :error
    end
  end
  
  @spec to_decval_case(hexval::asciicode()) :: d::integer()
  def to_decval_case(hexval) do
    case hexval do
      hv when ?0 <= hv and hv <= ?9
	 -> hv - ?0
      ?a -> 10
      ?b -> 11
      ?c -> 12
      ?d -> 13
      ?e -> 14
      ?f -> 15
      _  -> nil
    end
  end

  def to_decval_case2(hexval), do:
    (case hexval do
       _ when ?0 <= hexval and hexval <= ?9 ->
 	 hexval - ?0
       _ when ?a <= hexval and hexval <= ?f ->
	 hexval - ?a + 10
       _ ->
	 nil
    end)
    
end