The greatest common divisor (or GCD) of two integers is the largest positive integer that divides two of these integers. The first of the Recursion problems on the Functional track at Hackerrank is computing the GCD using the Euclidean Algorithm. In this algorythm the largest from the pair is replaced

This is the last from the introductional problems in the Functional Programming domain on Hackerrank. This also might be most complicated among the introductionary problems: You are given the cartesian coordinates of a set of points in a 2D plane. When traversed sequentially, these points form a Polygon, P, which

The problem of computing perimeter of the polygon is one of the easy problems, but it requires a bit more programming. You are given the cartesian coordinates of a set of points in a 2D plane. When traversed sequentially, these points form a Polygon, P, which is not self-intersecting. Compute

The Functions or Not? problem is defined as follows: You are given a set of unique (x, y) ordered pairs constituting a relation. For each of these relations, identify whether they may possibly represent a valid function or not. On a new line for each test case, print YES if

The last one from reduction problems is following: Reduce the following expression, using the beta-rule, to no more than one term. If the expression cannot be reduced, enter "CAN'T REDUCE". (λg.((λf.((λx.(f(xx)))(λx.(f(xx)))))g)) Well, now I (and you, if you follow) understand

The next problem, Area Under Curves and Volume of Revolving a Curve, in mathematically advance so I introduce some therms and facts first. Numerical integration is the measuring the area between function and axis, which is done by evaluating function in many points closing to each other and adding together

The problem Evaluating e^x: The series expansion of eˣ is given by $$1 + x + \frac{x^2} {2!} + \frac{x^3} {3!} + \frac{x^4} {4!} + ...$$ Evaluate eˣ for given values of x by using the above expansion for the first 10 terms. This problem is interesting because it

The problem Updating List requires learning how to generate one list from another. Update the values of a list with their absolute values. In many other programming languages the common approach is to update the array items: a[i] = abs(a[i]);, e.g. modify the shared state. The functional

The problem List Length is interesting because it can be solved using mutable counter but it also can be solved in more functional way. Count the number of elements in an array without using count, size or length operators (or their equivalents). First, let's see on the solution using mutable

The problem Sum of Odd Elements: You are given a list. Return the sum of odd elements from the given list. The solusion is basically just an invocation of the List.fold from the standard library: let f arr = arr |> List.fold (fun s v -> if Math.

The problem Reverse a List encourages to learn List.rev. You are given a list of elements. Reverse the list without using the reverse function. The simplest implementation is not very efficient one but it works good enough to pass the tests: let rev (lst : List<'T>) = let

The problem Array Of N Elements requires to write the function that returns N items. The string serialisation of the data structure should be very specific and similar to [ 1, 2, 3 ]. In the previous solutions I've generated the items using sequences. If sequences was allowed, the solution would be

The next one is Filter Positions in a List: For a given list with N integers, return a new list removing the elements at odd positions. There are a few methods in the Seq module that looks relevant: iteri and mapi. They both apply the function considering the index of

The next HackerRank functional problem is Filter Array. Filter a given array of integers and output only those values that are less than a specified value X. The idea is to create a filtering function, not using the one from the standard library. With what is already known from solving

This is going to be more interesting than[1] previous[2] three[3]. Given a list, repeat each element in the list n amount of times. The first line of the input is a number specifying how many times repeat every element of the list. The list items follow this