[C#] Add new Concept Exercise: arrays about concepts

[NextNebula]

I think to be more inclusive it is better to move to a predefined example. Not all students have a work week. Maybe they do not have a job, maybe they are students that do not see their study as work, maybe they have a very irregular job, etc. It is not needed for the exercise to ask students to think about that.

An example like this should be fine: Jane has a fixed work schedule, she works 8 hours on Monday, Tuesday and Thursday. On Wednesday and Friday, Jane works 4 hours. Saturday and Sunday Jane doesn't work.

Some exercises for methods can be.

• Write a method called RegularWorkWeek that returns the regular work week for Jane. (when a week has 7 days and begins on Sunday)

public static int[] RegularWorkWeek()
{
    throw new NotImplementedException("...");
}

• Write a method called TotalHoursWorked that returns the total sum of hours Jane works in a week. (itterate over array and reading from array)

public static int TotalHoursWorked()
{
    var hours = WorkingHours.RegularWorkWeek();
    throw new NotImplementedException("...");
}

• Write a method called HoursWorkedOnDay that takes in a day number and returns the amount of hours worked.

public static int HoursWorkedOnDay(int dayOfTheWeek)
{
    var hours = WorkingHours.RegularWorkWeek();
    throw new NotImplementedException("...");
}

• Write a method called WorkWeekChanged that takes in a day number and a amount of hours work that returns a changed array using those two parameters.

public static int[] WorkWeekChanged(int dayOfTheWeek, int hoursWorked)
{
    var hours = WorkingHours.RegularWorkWeek();
    throw new NotImplementedException("...");
}

[ErikSchierboom]

Write an array that represents the hours you work every day for the week (when a week has 7 days and begins on Sunday)

Yeah, I like that. So maybe we would have a stub method like this:

public static int[] RegularWorkWeek()
{
    throw new NotImplementedException("...");
}

Then we could indeed have the other methods take the hours array returned by the RegularWorkWeek method. A test would look like this:

[Fact]
public void HoursOnFriday()
{
     var hours = WorkingHours.RegularWorkWeek();
     var actual = WorkingHours.OnFriday(hours);
     Assert.Equal(8, actual);
}

Note that we'd have to use different hours in the array to force a correct implementation, but I feel like this could work.

One small note: we should try to make things use the least amount of math. So I feel the sum of hours (TotalHoursWorked) is fine, but I'd rather we'd not use the average.

@exercism/csharp what do you think?

[ErikSchierboom]

@MarkusReynolds1989 It might be easier to review if you were to create a (draft) PR. Could you do that?

[ErikSchierboom]

I put null because I want to make sure that the students are learning to test for edge cases.

I see, but I'd rather prefer having a separate exercise for error handling an a separate one for dealing with null's (we could even teach the fancy C# 8 nullable features).

The downside of that approach would be require a dependency on enums for this exercise.

Yeah, and the enums exercise currently requires some more advanced Concepts (generics and out parameters). So that might not be the best of options unfortunately :( An alternative would be to simplify the enums exercise.

I think overall them writing their own array would probably be a better fit.

Yeah, we can enforce this by having a method that will return an array. Students will then be forced to write an array.

[ErikSchierboom]

I think so. Are the above comments clear?

[ErikSchierboom]

There is an open PR that creates an array exercise for JavaScript. It might be convenient to port that exercise instead of having to come up with everything ourselves, as much of the groundwork in that exercise can be re-used for a C# exercise (the theme/context), instructions, etc. For an example on how to do a port of an existing exercise, see this video. The JS exercise would need so minor changes, for example arrays in C# have a fixed length and don't in JavaScript, but we can work with that I think.

@MarkusReynolds1989 what do you think? Are you still interested in working on this exercise?

[MarkusReynolds1989]

I'll open up that other issue but I'll go ahead and work on this too.
Would you please assign this to me?

[MarkusReynolds1989]

https://github.com/markusreynolds1989-fork/v3/tree/arrays/languages/csharp/concept-exercises/arrays
I have some initial concepts in Arrays.cs

[ErikSchierboom]

@MarkusReynolds1989 Done. I'll look at the initial concepts tomorrow

[MarkusReynolds1989]

So in my mind the input of the methods is either the static array that we can provide or null. I put null because I want to make sure that the students are learning to test for edge cases. We could change this to where the student writes their own array, and we could have them make up their own hours worked for the week and then adjust the tests to fit that pretty easily. I think overall them writing their own array would probably be a better fit.

[robkeim]

Cool stuff @MarkusReynolds1989!

If we're looking to demonstrate array access as well, maybe we could have a method:

public int GetHoursWorkedPerDay(DayOfWeek dayOfWeek)

The downside of that approach would be require a dependency on enums for this exercise. If we want to avoid enums, we could always have the day of the week be an int passed and then you'd have a simple index after checking for out of bounds values.

[MarkusReynolds1989]

I put null because I want to make sure that the students are learning to test for edge cases.

I see, but I'd rather prefer having a separate exercise for error handling an a separate one for dealing with null's (we could even teach the fancy C# 8 nullable features).

The downside of that approach would be require a dependency on enums for this exercise.

Yeah, and the enums exercise currently requires some more advanced Concepts (generics and out parameters). So that might not be the best of options unfortunately :( An alternative would be to simplify the enums exercise.

I think overall them writing their own array would probably be a better fit.

Yeah, we can enforce this by having a method that will return an array. Students will then be forced to write an array.

Ah okay, then we can do away with all empty input tests and just really focus on testing the array the student writes and the other methods.
How about this:
Write an array that represents the hours you work every day for the week (when a week has 7 days and begins on Sunday)

int[] hoursPerDay = int[]{0,8,8,8,8,8,0};

then they write that array and the methods to operate on it, such as sum of hours, avg hours, and the index of the 2nd most hours worked or amount of hours worked on Friday.

[MarkusReynolds1989]

I'm opening the floor to anyone with more method ideas to thoroughly test the array the student writes out.
I like finding the sum and the index. What about a method that finds the first day where the most hours were worked? They could do that with a for loop with just using the built in Array.Sort -> .Reverse and getting the index of the first result.

[ErikSchierboom]

What about a method that finds the first day where the most hours were worked? They could do that with a for loop with just using the built in Array.Sort -> .Reverse and getting the index of the first result.

I like that! Really nice.

[batibot323]

I'm opening the floor to anyone with more method ideas to thoroughly test the array the student writes out.

What about a method that would return a new array containing minutes worked instead of hours? That could be the next step after implementing the TotalHoursWorked(), to practice iterating over an array.

We can also test the use of .Length and making another array from an existing one by requiring to return an array that would only display Monday-Friday. This would be a step up from the HoursOnFriday() method.

[ErikSchierboom]

@EarthlingRich Great suggestions!

[robkeim]

I really like the conversion to minutes worked because that tests iteration and forces the student to create a new array. Another way to test creating a new array would be to return a "sub" array of only the days during the week, or only the weekend days.

On small nit regarding the first day of the week, I think it makes sense to follow ISO-8601 and start the on Monday instead of Sunday:
https://en.wikipedia.org/wiki/ISO_8601

[NextNebula]

I agree with the starting on Monday, makes more sense for where I live. It is good to follow a standard. But we should keep stating when the week starts, because this differs per area.

The conversion in minutes sounds like a good exercise for students to create a new array.

[robkeim]

But we should keep stating when the week starts, because this differs per area.

Yes, we'll definitely need to do that in any case

[ErikSchierboom]

BTW With #663 opened, we could consider depending on the enums-basic Concept for this exercise, to allow use of the WeekDay enum. Another option would be for the dates exercise to depend on the enums-basic Concept and then use one of the date-based enumerations (e.g. WeekDay).

[MarkusReynolds1989]

Are we ready for me to write a new version of this based on what we discussed?

[MarkusReynolds1989]

There is an open PR that creates an array exercise for JavaScript. It might be convenient to port that exercise instead of having to come up with everything ourselves, as much of the groundwork in that exercise can be re-used for a C# exercise (the theme/context), instructions, etc. For an example on how to do a port of an existing exercise, see this video. The JS exercise would need so minor changes, for example arrays in C# have a fixed length and don't in JavaScript, but we can work with that I think.

@MarkusReynolds1989 what do you think? Are you still interested in working on this exercise?

Hey Erik,
I'll go ahead and just work on porting that exercise then, if there's a great example no reason to reinvent the wheel. I'll watch the video and work on that some time today.

[ErikSchierboom]

Awesome! This video is also a great one to watch.

[ErikSchierboom]

Having looked at the JavaScript exercise, I'm thinking that might actually be a better exercise to port to the C# lists exercise, as it will remove and add items.