DEV Community: Ganesh Sarwate

Check the Examination

Ganesh Sarwate — Sat, 10 Aug 2019 00:44:24 +0000

Introduction

This is a problem from Codewars.

Problem

The first input array contains the correct answers to an exam, like ["a", "a", "b", "d"]. The second one is "answers" array and contains student's answers.

The two arrays are not empty and are the same length. Return the score for this array of answers, giving +4 for each correct answer, -1 for each incorrect answer, and +0 for each blank answer(empty string).

If the score < 0, return 0.

For example:

checkExam(["a", "a", "b", "b"], ["a", "c", "b", "d"]) → 6
checkExam(["a", "a", "c", "b"], ["a", "a", "b",  ""]) → 7
checkExam(["a", "a", "b", "c"], ["a", "a", "b", "c"]) → 16
checkExam(["b", "c", "b", "a"], ["",  "a", "a", "c"]) → 0

Manual Solution (Human Intelligence)

The problem mentions two arrays. Since we are using Elixir, we will refer to them as lists.

Steps:

Start with a score of 0
Look at the first entry in the correct_answer list
Look at the entry in the answer list at the same position as correct_answer list
- If the answer entry is empty, add 0 to score
- Otherwise compare the entry in the correct_answer list with the entry in the answer list
  - If both entries match, then add 4 to the score
  - Otherwise, subtract 1 from the score
Look at the next entry in the correct_answer list and repeat Step 3 if the entry exists
If there are no more entries in the correct_answer list
- If the score is negative, then score is 0
- Otherwise, report score and stop

Solution (Elixir)

We could walk through the correct_answer list and the answer list in parallel and compare them as outlined in the manual solution. But, there is a better way.

We can combine both lists so that we can walk through that combined list and compare entries in the list to score.

The structure of our code will be:

Combine list
|> Check answers and determine the score of the exam
|> Report final score

Combine lists

The Elixir function Enum.zip/2 allows us to zip corresponding elements from two enumerables (in our case lists) into one list of tuples.

Enum.zip(correct_answer_list, answer_list)

In our example, we are combining two enumerables with the Enum.zip/2 function, but the Elixir function Enum.zip/1 allows us to combine more than two enumerables, as well.

Check answers and determine the score of the exam

Next, we want to check the entries in the list. Each entry is a tuple in the form of {correct_answer, answer}. We can compare elements within a tuple with each other. There are several ways to do so in Elixir. Let's take a look at a few of those approaches.

Build our own function to walk through list

defp compare([], acc), do: acc

defp compare([head | tail], acc) do
  compare(tail, score(head, acc))
end

In the above code, we have created two compare/2 functions to walk through the combined list. They both are private functions which we will call from our main function.

These functions accept two parameters. The first one is the combined list we built earlier. The second parameter is an accumulator, acc, with which we accumulate the results of our comparisions.

These functions allow us to walk through the list recursively and, at the same time, accumulate the result of each of the comparisions.

The first function is a 'stop' condition for our recurssion. When we reach the end of the list, we stop and return the score. Note that, as the second function calls itself as the last thing, it is a tail call and Elixir/Erlang will accordingly perform tail-call optimization.

defp score({_expected, answer}, acc) when answer == "", do: acc
defp score({expected, answer}, acc) when expected == answer, do: acc + 4
defp score({expected, answer}, acc) when expected != answer, do: acc - 1

Next we created three private score/2 functions which are called from compare/2. They allow us to compare the expected answer with the actual answer. They allow us branching of conditional logic using multiclause functions.

These functions accept two parameters. The first one is a tuple in the form of {expected_answer, answer} which is an element of the combined list we built earlier. The second parameter is an accumulator, acc, with which we accumulate the results of our comparisions.

We could have used conditional constructs such as if, case, and cond etc. in the compare/2 function. However, by using multiclause functions, the logic for handling the conditions is seperated from the higher level (calling) function. The code for conditions is cleaner and self-descriptive.

These three functions will update the acc (score) and return it to the compare/2 function.

Use Enum module to reduce the list to score

Enum.zip(correct, answer)
|> Enum.reduce(0, &score/2)

With this approach, we use the Elixir Enum.reduce/3 module to walk through the combined list. The function takes in three arguments:

enumerable (combined list produced by Enum.zip/2)
accumulator (to store the result of reduction)
function (to compare the answers)

The accumulator will start with 0 (as per our manual Step 1). We will use the score/2 functions (as discussed in the earlier approach) to calculate the score. The score/2 function will get two parameters - a tuple for comparision and the accumulator.

Report final score

defp final_score(score) when score < 0, do: 0
defp final_score(score), do: score

Lastly, we can compare the score to check the final tally. If the score is negative, we return the tally as 0. Otherwise, we return the score as a tally.

Final code

defmodule CheckExam do
  def check_exam(correct, answer) do
    Enum.zip(correct, answer)
    |> Enum.reduce(0, &score/2)
    |> final_score()
  end

  defp score({_expected, answer}, acc) when answer == "", do: acc
  defp score({expected, answer}, acc) when expected == answer, do: acc + 4
  defp score({expected, answer}, acc) when expected != answer, do: acc - 1

  defp final_score(score) when score < 0, do: 0
  defp final_score(score), do: score
end

Meetup

Ganesh Sarwate — Sun, 04 Aug 2019 00:17:41 +0000

Introduction

This is a step-by-step solution for the exercism.io problem ‘Meetup’ which can be seen here (you need to be signed-in).

Problem

Calculate the date of meetups.

Typically meetups happen on the same day of the week. In this exercise, you will take a description of a meetup date, and return the actual meetup date.

Examples of general descriptions are:

The first Monday of January 2017
The third Tuesday of January 2017
The wednesteenth of January 2017
The last Thursday of January 2017

The descriptors you are expected to parse are: first, second, third, fourth, fifth, last, monteenth, tuesteenth, wednesteenth, thursteenth, friteenth, saturteenth, sunteenth

Note that "monteenth", "tuesteenth", etc are all made up words. There was a meetup whose members realized that there are exactly 7 numbered days in a month that end in '-teenth'. Therefore, one is guaranteed that each day of the week (Monday, Tuesday, ...) will have exactly one date that is named with '-teenth' in every month.

Given examples of a meetup dates, each containing a month, day, year, and descriptor calculate the date of the actual meetup. For example, if given "The first Monday of January 2017", the correct meetup date is 2017/1/2.

Solution

The problem may seem complex because of its lengthy description and large number of test cases, but it can be solved by taking apart the information we're given into smaller parts through a step-by-step approach. Elixir, being a functional and declarative language, works very well for this approach.

Let us take a look at the tests to get more details about the inputs given and expected output.

Inputs given:

Year (4-digit)
Month (1-digit or 2-digit)
Day of the Week (atoms for weekdays such as :monday, :tuesday etc.)
Schedule (first (1st week), second (2nd week) ... teenth (seven days ending with teenth e.g. 13th))

Expected output:

A tuple with {yyyy, mm, dd}

Steps

If we look at the problem closely, we can see that we need to find out a date of meetup based on day of the week and a schedule. The schedule is based on a seven-day range. So first we need to find out seven-day range and dates within that range. Once we find out the dates, we can find out the days of the week for those dates. Lastly we can pick up the date that matches the requested day of the week to find the answer.

High level code with steps looks like this

find_day_range(year, month, schedule)
|> find_date(year, month, weekday)

Step 1 - Find the seven-day range

Seven-day range is based on schedule, year, and month. Dates in the range are either fixed or varying.

Fixed days range

Dates within first, second, third, and fourth week are fixed e.g. first week is from 1st of the month to 7th of the month, second week is from 8th of the month to 14th of the month and so on. Similarly ‘teenth’ schedule has fixed dates - from 13th of the month to 19th of the month (and that makes 7 days or a week). So we can define fix range as following:

@day_range_map %{
  first: 1..7,
  second: 8..14,
  third: 15..21,
  fourth: 22..28,
  teenth: 13..19
}

name: day_range_map
type: map
key: schedule
value: day range

Varying days range

Dates within last week’ s schedules will be varying and depend upon month and year. For months January, March, May, July, August, October, and December we have 31 days and for all other months other that February we have 30 days. For February we can have 29 days for leap year and 28 days for non-leap years. Therefore we also need to consider the year while calculating last week for February. With all the above conditions we have last week that contains following ranges of dates.

22 23 24 25 26 27 28            # For month with 28 days
   23 24 25 26 27 28 29         # For month with 29 days
      24 25 26 27 28 29 30      # For month with 30 days
         25 26 27 28 29 30 31   # For month with 31 days

So dates for last week fall in range of 22 and 31 depending upon month and year. We can find the number of days using given month and year. Number of days is same as last day of the month. We will be using Erlang function :calendar.last_day_of_the_month/2 to find out last day of the month. Range will be between last day of the month and six days prior to that day.

Function for finding the range

In this function we compare the schedule. If the schedule is anything other than ‘:last’, we find the range using day_range_map. For ‘:last’ schedule we calculate range as explained above in ‘Varying days range’.

Function name: find_day_range

Function input: year, month, schedule

Function body:

case schedule do
  :last ->
    last_day_of_the_month = :calendar.last_day_of_the_month(year, month)
    (last_day_of_the_month - 6)..last_day_of_the_month

  _ ->
    @day_range_map[schedule]
end


Function output: range

Alternatively we can use Elixir function Date.days_in_month/1 to calculate number of days in a month. The function requires date as a parameter, We can use Date.from_erl!/1 function to get the date which returns Date sigil e.g. ~D[2019-01-13]. Date.from_erl!/1 function needs {year, month, day} tuple as parameter. We already have year and month. We will use 1 (1st of the month) as a day.

date = Date.from_erl!({year, month, 1})
Date.days_in_month(date)

Step 2 - Find date

Find the day of week for all dates within the range in step 1

Now given a range, year, and month we want to find out weekdays for each of the day in the range. Range has seven consecutive days, so we will have unique weekday for each of the day in the range.

We need to create the dictionary with mapping %{ day_of_week_number => {year, month, day}}

Let us find out how we get the day of the week if we know the date. In Elixir the day of the week is numbered 1 to 7 from Monday to Sunday. Therefore Monday is 1 and Sunday is 7. For example if year is 2019 and month is 1, the day of the week for January 13, 2019 is 7(Sunday), January 14, 2019 is 1 (Monday) and so on.

Let us see how we find out day of the week for January 13, 2019. We will use IEx to get started.

Using Erlang function :calendar.day_of_the_week/3

iex(1)> :calendar.day_of_the_week(2019, 1, 13)
7

Now we can find day of week for each element of the range. We can use Enum.reduce/3 function to reduce the range to the map of %{ day_of_week_number => {year, month, day}}.

iex(1)> year = 2019
2019
iex(2)> month = 1
1
iex(3)> range = 13..19
13..19
iex(4)> range |>
...(4)> Enum.reduce(%{}, fn day, acc ->
...(4)> Map.put(acc, :calendar.day_of_the_week(year, month, day), {year, month, day})
...(4)> end)
%{
  1 => {2019, 1, 14},
  2 => {2019, 1, 15},
  3 => {2019, 1, 16},
  4 => {2019, 1, 17},
  5 => {2019, 1, 18},
  6 => {2019, 1, 19},
  7 => {2019, 1, 13}
}

Note: the map is ordered by day of week.

Alternatively we can use Elixir function Date.day_of_week/1 to find day of the week. This function expects Date sigil as an argument e.g. ~D[2019-01-13]. We have three pieces of information - year, month, and day. Therefore we will create the Sigil first. Elixir Date.new/3 will create the sigil based on year, month, and day.

iex(1)> Date.from_erl!({2019, 1, 13})
~D[2019-01-13]

Now we can find the day of the week

iex(2)> Date.from_erl!({2019, 1, 13}) |> Date.day_of_week()
7

Day of the week on January 13, 2019 was Sunday. So the expected answer is 7.

Match the weekday parameter with the day of week map

Since we know weekday, we will find out the matching weekday in the above range

The date for the matching weekday is the answer.

Now we need to find out the map entry based on what was the weekday requested in input. If we are looking for Sunday, then we need to find the value of key 7. What we are given is an atom for the weekday e.g. :sunday. We need to map that to number 7. To achieve that we can create following Map:

@weekday_map %{
  monday: 1,
  tuesday: 2,
  wednesday: 3,
  thursday: 4,
  friday: 5,
  saturday: 6,
  sunday: 7
}

name: weekday_map
type: map
key: weekday
value: weekday in number

We can use above map to fetch the value from the map created above.

Map.fetch!(@weekday_map[weekday])

So the completed function looks like below:

Function input: range, year, month, weekday

Function body:

range
|> Enum.reduce(%{}, fn day, acc ->
  Map.put(acc, :calendar.day_of_the_week(year, month, day), {year, month, day})
end)
|> Map.fetch!(@weekday_map[weekday])

Function output: {year, month, day}

Alternate Elixir code to get day of week using Date.day_of_week/1:

Map.put(acc, Date.day_of_week(Date.from_erl!({year, month, day})), {year, month, day})

We can also use Enum.find/2 instead of Map.fetch! If we decide to do so we can create list of tuples and find the matching date for the weekday.

Function input: range, year, month, weekday

Function body:

range
|> Enum.map(fn day ->
  {:calendar.day_of_the_week(year, month, day), {year, month, day}}
end)
|> Enum.find(fn {x, dt} -> x == @weekday_map[weekday] end)

Function output: {year, month, day}

Alternate Elixir code to get day of week using Date.day_of_week/1:

{Date.day_of_week(Date.from_erl!({year, month, day})), {year, month, day}}

Final code

@weekday_map %{
  monday: 1,
  tuesday: 2,
  wednesday: 3,
  thursday: 4,
  friday: 5,
  saturday: 6,
  sunday: 7
}

@day_range_map %{
  first: 1..7,
  second: 8..14,
  third: 15..21,
  fourth: 22..28,
  teenth: 13..19
}

def meetup(year, month, weekday, schedule) do
  find_day_range(year, month, schedule)
  |> find_date(year, month, weekday)
end

defp find_day_range(year, month, schedule) do
  case schedule do
    :last ->
      last_day_of_the_month = :calendar.last_day_of_the_month(year, month)
      (last_day_of_the_month - 6)..last_day_of_the_month

    _ ->
      @day_range_map[schedule]
  end
end

defp find_date(range, year, month, weekday) do
  range
  |> Enum.reduce(%{}, fn day, acc ->
    Map.put(acc, :calendar.day_of_the_week(year, month, day), {year, month, day})
  end)
  |> Map.fetch!(@weekday_map[weekday])
end