From 3fe3768ceb970cce412a58f8cbc760f38047fcdf Mon Sep 17 00:00:00 2001 From: Gonzalo Diaz Date: Fri, 21 Jun 2024 22:33:56 -0400 Subject: [PATCH] =?UTF-8?q?[Hacker=20Rank]=20Interview=20Preparation=20Kit?= =?UTF-8?q?:=20Greedy=20Algorithms:=20Luck=20Balance.=20Solved=20=E2=9C=93?= =?UTF-8?q?.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../greedy_algorithms/LuckBalance.Test.cs | 58 +++++++++++ .../greedy_algorithms/LuckBalance.cs | 62 ++++++++++++ .../greedy_algorithms/luck-balance.md | 97 +++++++++++++++++++ 3 files changed, 217 insertions(+) create mode 100644 algorithm-exercises-csharp-test/src/hackerrank/interview_preparation_kit/greedy_algorithms/LuckBalance.Test.cs create mode 100644 algorithm-exercises-csharp/src/hackerrank/interview_preparation_kit/greedy_algorithms/LuckBalance.cs create mode 100644 docs/hackerrank/interview_preparation_kit/greedy_algorithms/luck-balance.md diff --git a/algorithm-exercises-csharp-test/src/hackerrank/interview_preparation_kit/greedy_algorithms/LuckBalance.Test.cs b/algorithm-exercises-csharp-test/src/hackerrank/interview_preparation_kit/greedy_algorithms/LuckBalance.Test.cs new file mode 100644 index 0000000..4192838 --- /dev/null +++ b/algorithm-exercises-csharp-test/src/hackerrank/interview_preparation_kit/greedy_algorithms/LuckBalance.Test.cs @@ -0,0 +1,58 @@ +namespace algorithm_exercises_csharp.hackerrank.interview_preparation_kit; + +[TestClass] +public class LuckBalanceTest +{ + public class LuckBalanceTestCase + { + public string title = ""; + public int k; + public List> contests = []; + public int expected; + } + + private static readonly LuckBalanceTestCase[] tests = [ + new() + { + title = "Sample Test case 0", + k = 3, + contests = [[5, 1], [2, 1], [1, 1], [8, 1], [10, 0], [5, 0]], + expected = 29 + }, + new() + { + title = "Sample Test case 1", + k = 5, + contests = [[13, 1], [10, 1], [9, 1], [8, 1], [13, 1], [12, 1], [18, 1], [13, 1]], + expected = 42 + }, + new() + { + title = "Sample Test case 2", + k = 2, + contests = [[5, 1], [4, 0], [6, 1], [2, 1], [8, 0]], + expected = 21 + } + ]; + + [TestMethod] + public void testLuckBalance() + { + int result; + + foreach (LuckBalanceTestCase test in tests) + { + result = LuckBalance.luckBalance(test.k, test.contests); + Assert.AreEqual( + test.expected, + result, + String.Format( + "testLuckBalance({0}, {1}) => must be: {2}", + test.k, + test.contests.ToString(), + test.expected + ) + ); + } + } +} diff --git a/algorithm-exercises-csharp/src/hackerrank/interview_preparation_kit/greedy_algorithms/LuckBalance.cs b/algorithm-exercises-csharp/src/hackerrank/interview_preparation_kit/greedy_algorithms/LuckBalance.cs new file mode 100644 index 0000000..e86aa6f --- /dev/null +++ b/algorithm-exercises-csharp/src/hackerrank/interview_preparation_kit/greedy_algorithms/LuckBalance.cs @@ -0,0 +1,62 @@ +// @link Problem definition [[docs/hackerrank/interview_preparation_kit/greedy_algorithms/luck-balance.md]] + +namespace algorithm_exercises_csharp.hackerrank.interview_preparation_kit; + +using System.Diagnostics.CodeAnalysis; + +public class Competition(int _luck, int _important) +{ + public int luck => _luck; + public int important => _important; +} + +public class LuckBalance +{ + [ExcludeFromCodeCoverage] + protected LuckBalance() { } + + public static int luckBalance(int k, List> contests) + { + List important_competitions = []; + List nonimportant_competitions = []; + + foreach (var x in contests) + { + var luck = x[0]; + var important = x[1]; + + if (important == 1) + { + important_competitions.Add(new Competition(luck, important)); + } + else + { + nonimportant_competitions.Add(new Competition(luck, important)); + } + } + + important_competitions = [.. important_competitions + .OrderByDescending(s => s.important) + .ThenByDescending(s => s.luck)]; + + int total = 0; + int size = important_competitions.Count; + + for (int i = 0; i < Math.Min(k, size); i++) + { + total += important_competitions[i].luck; + } + + for (int i = Math.Min(k, size); i < size; i++) + { + total -= important_competitions[i].luck; + } + + foreach (Competition x in nonimportant_competitions) + { + total += x.luck; + } + + return total; + } +} diff --git a/docs/hackerrank/interview_preparation_kit/greedy_algorithms/luck-balance.md b/docs/hackerrank/interview_preparation_kit/greedy_algorithms/luck-balance.md new file mode 100644 index 0000000..5794a5a --- /dev/null +++ b/docs/hackerrank/interview_preparation_kit/greedy_algorithms/luck-balance.md @@ -0,0 +1,97 @@ +# [Greedy Algorithms: Luck Balance](https://www.hackerrank.com/challenges/luck-balance) + +- Difficulty: `#easy` +- Category: `#ProblemSolvingBasic` + +Lena is preparing for an important coding competition that is preceded +by a number of sequential preliminary contests. +Initially, her luck balance is 0. +She believes in "saving luck", and wants to check her theory. +Each contest is described by two integers, `L[i]` and `T[i]`: + +- `L[i]` is the amount of luck associated with a contest. +If Lena wins the contest, her luck balance will decrease by `L[i]`; +if she loses it, her luck balance will increase by `L[i]`. + +- `T[i]` denotes the contest's importance rating. +It's equal to `1` if the contest is important, and it's equal to `0` if it's unimportant. + +If Lena loses no more than `k` important contests, what is the maximum amount +of luck she can have after competing in all the preliminary contests? +This value may be negative. + +## Example + +```text +Contest L[i] T[i] +1 5 1 +2 1 1 +3 4 0 +``` + +If Lena loses all of the contests, her will be `5 + 1 +4 = 10`. +Since she is allowed to lose important contests, +and there are only `2` important contests, +she can lose all three contests to maximize her luck at `10`. + +If `k = 1`, she has to win at least of the important contests. +She would choose to win the lowest value important contest worth `1`. +Her final luck will be `5 + 4 - 1 = 8`. + +## Function Description + +Complete the luckBalance function in the editor below. + +luckBalance has the following parameter(s): + +- `int k`: the number of important contests Lena can lose +- `int contests[n][2]`: a 2D array of integers where each `contests[i]` +contains two integers that represent the luck balance and importance of the contest + +## Returns + +- `int`: the maximum luck balance achievable + +## Input Format + +The first line contains two space-separated integers `n` and `k`, +the number of preliminary contests and the maximum number +of important contests Lena can lose. + +Each of the next lines contains two space-separated integers, +`L[i]` and `T[i]`, the contest's luck balance and its importance rating. + +## Constraints + +- $ 1 \leq n \leq 100 $ +- $ 0 \leq k \leq N $ +- $ 1 \leq L[i] \leq 10^4 $ +- $ T[i] \isin \{0,1\} $ + +## Sample Input + +```text +STDIN Function +----- -------- +6 3 n = 6, k = 3 +5 1 contests = [[5, 1], [2, 1], [1, 1], [8, 1], [10, 0], [5, 0]] +2 1 +1 1 +8 1 +10 0 +5 0 +``` + +## Sample Output + +```text +29 +``` + +## Explanation + +There are `n = 6` contests. Of these contests, `4` are important +and she cannot lose more than of them. +Lena maximizes her luck if she wins the $ 3^{rd} $ important contest +(where `L[i] = 1`) and loses all of the other five contests for a total +luck balance of `5 + 2 + 8 + 10 + 5 - 1 = 29`.