Adding a few elixir scripts

1. CalculatePi.ex --> Approximate a value of pi
2. FactorialIterative.ex --> Returns a factorial for a given n, in an iterative manner.  
3. FactorialRecursive.ex --> Returns a factorial for a given n, in an recursive manner.  
4. FibonacciIterative.ex --> Returns a Fibonacci value for a given n, in an iterative manner.  
5. FibonacciRecursive.ex --> Returns a Fibonacci value for a given n, in a recursive manner.  
6. MaxRecursive.ex --> Find largest value in a list.
7. README.md -> Basic overview document

Author: TestingGround00

src/elixir/CalculatePi.ex

@@ -0,0 +1,31 @@
+# Module to calculate an approximation of Pi
+defmodule PiApproximation do
+
+  # Function to calculate pi given number of terms
+  def calculate_pi(terms) do
+  
+    # Initialize pi accumulator 
+    pi = 0.0 
+
+    # Reduce over 1..terms range
+    # Accumulator is a tuple with pi, denominator, and operation
+    Enum.reduce(1..terms, {pi, 1.0, 1.0}, fn _, {acc_pi, acc_denom, acc_op} ->
+    
+      # Calculate new pi value    
+      new_pi = acc_pi + acc_op * (4.0 / acc_denom)
+
+      # Return tuple with updated values
+      {new_pi, acc_denom + 2.0, -acc_op} 
+    end) |> elem(0)
+  end
+
+end
+
+# Number of terms to approximate
+terms = 100_000  
+
+# Call approximation function
+result = PiApproximation.calculate_pi(terms)
+
+# Print result
+IO.puts(result)

src/elixir/FactorialIterative.ex

@@ -0,0 +1,26 @@
+defmodule Factorial do
+  # Define a module called Factorial.
+
+  def factorial(n) when n >= 0 do
+    # Calculate the factorial using Enum.reduce.
+    Enum.reduce(1..n, 1, &(&1 * &2))
+  end
+
+  defp format_factorial(i, result) do
+    # Format the output string.
+    "#{i}! = #{result}"
+  end
+
+  def main do
+    # Entry point of the program.
+    nums = [0, 1, 2, 3, 4, 5]
+
+    Enum.each(nums, fn i ->
+      # Iterate through the list of numbers.
+      result = factorial(i)
+      IO.puts(format_factorial(i, result))
+    end)
+  end
+end
+
+Factorial.main()  # Execute the program.

src/elixir/FactorialRecursive.ex

@@ -0,0 +1,23 @@
+# Define Math module for math utilities
+defmodule Math do
+
+  # Recursive factorial function
+  def factorial(0), do: 1 # Base case
+
+  def factorial(n) when n > 0 do 
+    # Recursive case
+    n * factorial(n-1) 
+  end
+
+end
+
+# Array of numbers to get factorials for
+nums = [0, 1, 2, 3, 4, 5] 
+
+# Loop through the nums array
+for i <- nums do
+
+  # Calculate and print factorial 
+  IO.puts "#{i}! = #{Math.factorial(i)}" 
+
+end

src/elixir/FibonacciIterative.ex

@@ -0,0 +1,24 @@
+# Define a Fibonacci module
+defmodule Fib do
+
+  # Function to calculate nth Fibonacci number
+  def fibonacci(n) when n >= 0 do
+  
+    # Initialize starting values  
+    last = 0
+    curr = 1
+
+    # Use Enum.reduce as a loop from 0 to n-1
+    Enum.reduce(0..(n-1), {last, curr}, fn _, {last, curr} ->
+      
+      # Update last and curr, returning as a tuple
+      {curr, curr + last}  
+    end)
+
+    # Return the last value after reducing
+    |> elem(0) 
+  end
+end
+
+# Print 10th Fibonacci number  
+IO.puts(Fib.fibonacci(10))

src/elixir/FibonacciRecursive.ex

@@ -0,0 +1,14 @@
+# Define a Fibonacci module
+defmodule Fibonacci do
+  # Base case: If n is 0 or 1, return n.
+  def fibonacci(n) when n <= 1, do: n
+
+  # Recursive case: Calculate the Fibonacci number by summing the results
+  # of the previous two Fibonacci numbers.
+  def fibonacci(n) do
+    fibonacci(n - 1) + fibonacci(n - 2)
+  end
+end
+
+# Print the Fibonacci number for n = 10.
+IO.puts("Fibonacci(n): #{Fibonacci.fibonacci(10)}")

src/elixir/MaxRecursive.ex

@@ -0,0 +1,19 @@
+defmodule MaxRecursive do
+  # Base case: When n is 1, return the first element of the list (head).
+  def max_recursive(nums, 1), do: hd(nums)
+
+  # Recursive case: Calculate the maximum recursively.
+  def max_recursive(nums, n) do
+    aux = max_recursive(nums, n - 1)
+    if aux > Enum.at(nums, n - 1) do
+      aux
+    else
+      Enum.at(nums, n - 1)
+    end
+  end
+end
+
+# Example usage
+nums = [1, 2, 3, 4, 32, 6, 7, 8, 9, 10]
+IO.inspect "nums = #{inspect(nums)}"
+IO.inspect "Max = #{MaxRecursive.max_recursive(nums, length(nums))}"

src/elixir/README.md

@@ -0,0 +1,112 @@
+## Elixir Language Basic Syntax Review
+Elixir is a general purpose programming language built on top of Erlang or Ericsson language. It is very efficient for building distributed, fault tolerant appications. It's been used by many companies like Pinterest, PagerDuty, FarmBot, E-Metro Tel etc.
+
+Key features:
+
+- Built especially for scalable and maintanable applications.
+- Everything is an expression
+- Compiles to bytecode
+- Built-in tooling for compilation, testing, debugging, formatting code etc.
+- Erlang functions can be called directly as it get compiled to Erlang bytecode.
+
+#### 1. Variables
+
+````elixir 
+variable-name = value
+````
+
+#### 2. Data types
+
+|Data type	   | Usage  |  Description |
+| ------------ | ------------ | ------------ |
+| Numeric  |x = 21|Elixir supports not only integer and float values but also a number can be defined in octal, hexadecimal and binary bases.   |
+| Atom  | :true|Atoms are constant values whose name is same as their value   |
+| Boolean  |  : false, :true| Either true or false, usually declared as atoms  |
+| Strings  | "Hello" | Strings are enclosed in double quotes(" ") and multi line strings are enclosed in triple double quotes(""" """)  |
+|Lists   |  ['a', 10, :true] | Lists are used to store different types of values and are represented in square brackets []  |
+|Tuples   | {'apple', 100, :false}  |  Similar to Lists and are represented in curly brackets {}. Tuples are good for accessing the values and lists are good for insertion and deletion of values |
+
+
+#### 3. Loops and Conditionals
+
+##### If-Else and If-Else:
+
+When ever you want to perform a set of operations based on a condition If is used.
+
+```elixir
+if condition do
+   #Code 
+end
+```
+
+When there is requirement to add code for false condition to IF block.
+
+```elixir
+if condition do
+   #Code 
+else
+    #code
+end
+```
+
+##### Unless and Unless-Else:
+
+Unless is similar to If but the code get executed only if the condition fails.
+
+````elixir
+unless condition do
+   #Code 
+end
+````
+
+Unless-Else is similar to If-Else but the code get executed only if the condition fails.
+
+````elixir
+unless condition do
+   #Code if condition fails
+else
+    #Code if condition satisfies
+end
+````
+
+##### Cond:
+Cond is used when you want to execute a piece of code based on multiple conditions.
+
+````elixir
+cond do
+   condition-1 -> #code if condition is true
+   condition-2 -> #code if condition is true
+   ...
+   true -> #code if none of the above are true
+end
+````
+
+##### Case:
+
+Case is similar to switch in C/C++ language.
+
+````elixir
+case value do
+    value-1 -> #code if value matches value-1
+	value-2 -> #code if value matches value-2
+	value-3 -> #code if value matches value-3
+	...
+	_ -> #code if value does not match any of the above and is similar to default in switch
+end
+````
+
+#### 4. Functions
+Function is a sub-routine which contains set of statements. Usually functions are written when multiple calls are required to same set of statements which increases re-usuability and modularity.
+
+Two types of functions are present in Elixir
+
+1. Anonymous Functions: Anonymous functions are functions with no name and they use `fn..end` constructs.
+2. Named functions: Assign names to functions so that they can be called easily. Always named functions are defined in modules.
+
+```elixir
+defmodule modulename do
+    def function_name(parameter1, parameter2) do
+        #code 
+    end
+end
+```