public int GetMinCoinsForBalance(int amount, int[] coins)

{

// create the dp array that contains the coins for 0...amount.

var dp = new int[amount + 1];

// initialize bigger value.

for(int i=0; i <= amount; i++)

{

dp[i] = amount + 1;

}

dp[0] = 0;

for (int i=0;i<= amount; i++)

{

for (int j=0; j< coins.Length; j++)

{

if (coins[j] <= i)

{

// In this case, take the min of dp[i] which is the current number of coins added so far

// and dp[i - coin[j]] which is the amount added previously plus current coin (1)

// [For instance, if the amount is 9 and if there are coins {1,6} and j=1 then dp[9-6] = dp[3] which will be 3 + 1 (current coind which is 6) = 4].

// In above case, when j=0 which is coin=1 then in first attempt the dp[9] = dp[9-1] + 1 = 9. As described above, the dp[9] will be 4.

dp[i] = Math.Min(dp[i], 1 + dp[i - coins[j]]);

}

else

{

break;

}

}

}

return dp[amount] > amount ? -1 : dp[amount];

}

int result = this.GetMinCoinsForBalance(19, new []{ 1, 6, 10 });

<Compile Include="BinaryTreeRightView.cs" />

using DataStructures.Libraries.Trees;

using Microsoft.VisualStudio.TestTools.UnitTesting;

using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Algorithms.Problem.BinaryTree.BinaryTreeView

public class BinaryTreeNodeEx

{

public BinaryTreeNode treeNode;

public int position;

}

[TestClass]

public class BinaryTreeRightView

{

public void PrintRightViewOfTree(BinaryTreeNode treeNode)

{

var queueBinaryTree = new Queue<BinaryTreeNode>();

queueBinaryTree.Enqueue(treeNode);

queueBinaryTree.Enqueue(null);

while (queueBinaryTree.Any())

{

BinaryTreeNode node = queueBinaryTree.Dequeue();

if (node == null && queueBinaryTree.Peek() != null)

{

Console.WriteLine(queueBinaryTree.Peek());

queueBinaryTree.Enqueue(null);

}

else

{

if (node.Right != null)

queueBinaryTree.Enqueue(node.Right);

if (node.Left != null)

queueBinaryTree.Enqueue(node.Left);

}

}

}

public void PrintTopViewOfTree(BinaryTreeNodeEx treeNode)

{

Dictionary<int, BinaryTreeNodeEx> dictionary = new Dictionary<int, BinaryTreeNodeEx>();

var queueBinaryTree = new Queue<BinaryTreeNodeEx>();

queueBinaryTree.Enqueue(treeNode);

dictionary.Add(0, treeNode);

while (queueBinaryTree.Any())

{

BinaryTreeNodeEx node = queueBinaryTree.Dequeue();

int leftPosition = node.position - 1;

int rightPosition = node.position + 1;

dictionary.Add(leftPosition, node);

}

}

[TestMethod]

public void ValidateTreeSpiralOrder()

{

var binarySearchTree = new BinarySearchTree();

binarySearchTree.PopulateDefaultBalanceTree();

int[] rightView = { 20, 30, 10, 5, 12, 25, 35 };

var spiralOrder = new BinaryTreeRightView();

spiralOrder.PrintRightViewOfTree(binarySearchTree.Root);

}

}

<Compile Include="ClimbingStairs.cs" />

<Compile Include="MinCoinChange.cs" />

<Compile Include="WightedJobScheduling.cs" />

using Microsoft.VisualStudio.TestTools.UnitTesting;

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace DynamicProgramming

[TestClass]

public class ClimbingStairs

{

/// <summary>

/// Returns the number of ways you can climb the stairs.

/// https://leetcode.com/problems/climbing-stairs/description/

/// </summary>

/// <param name="noOfStairs"></param>

/// <returns></returns>

public int ClimbingStairsMethod(int noOfStairs)

{

int[] dp = new int[noOfStairs + 1];

dp[0] = 1;

dp[1] = 1;

for(int i=2; i<= noOfStairs; i++)

{

/// Each time you either climb 1 or 2 steps.

dp[i] = dp[i - 1] + dp[i - 2];

}

return dp[noOfStairs];

}

[TestMethod]

public void TestMethod1()

{

int noOfWays = this.ClimbingStairsMethod(3);

Assert.AreEqual(noOfWays, 3);

}

}

using Microsoft.VisualStudio.TestTools.UnitTesting;

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Algorithms.Problem.Arrays

[TestClass]

public class MinCoinChange

{

public int GetMinCoinsForBalance(int amount, int[] coins)

{

// create the dp array that contains the coins for 0...amount.

var dp = new int[amount + 1];

// initialize bigger value.

for(int i=0; i <= amount; i++)

{

dp[i] = amount + 1;

}

dp[0] = 0;

for (int i=0;i<= amount; i++)

{

for (int j=0; j< coins.Length; j++)

{

if (coins[j] <= i)

{

// In this case, take the min of dp[i] which is the current number of coins added so far

// and dp[i - coin[j]] which is the amount added previously plus current coin (1)

// [For instance, if the amount is 9 and if there are coins {1,6} and j=1 then dp[9-6] = dp[3] which will be 3 + 1 (current coind which is 6) = 4].

// In above case, when j=0 which is coin=1 then in first attempt the dp[9] = dp[9-1] + 1 = 9. As described above, the dp[9] will be 4.

dp[i] = Math.Min(dp[i], 1 + dp[i - coins[j]]);

}

else

{

break;

}

}

}

return dp[amount] > amount ? -1 : dp[amount];

}

public int GetCoinsForBalance(int balance, int[] coins)

{

int minValue = Int16.MaxValue;

int coinCounter = 0;

if (balance == 0) return 0;

foreach(int coin in coins)

{

if (balance - coin >= 0)

{

coinCounter = this.GetCoinsForBalance(balance - coin, coins);

if (minValue > coinCounter)

{

minValue = coinCounter;

}

}

}

return minValue + 1;

}

[TestMethod]

public void TestMinCoinChange()

{

int result = this.GetMinCoinsForBalance(19, new []{ 1, 6, 10 });

Assert.AreEqual(result, 4);

}

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace DynamicProgramming

public class Job

{

public char JobName;

public int StartTime;

public int EndTime;

public int Weight;

public int CalculatedWeight;

public Job(char jobName, int startTime, int endTime, int weight)

{

this.JobName = jobName;

this.StartTime = startTime;

this.EndTime = endTime;

this.Weight = weight;

this.CalculatedWeight = weight;

}

}

[TestClass]

public class WightedJobScheduling

{

public int GetMaxJobSchedule(List<Job> jobs)

{

List<char> charList = new List<char>();

jobs.Sort(Comparer<Job>.Create((j1, j2) => j1.EndTime.CompareTo(j2.EndTime)));

for(int i=1; i< jobs.Count; i++)

{

for(int j=0; j< i; j++)

{

if (jobs[i].StartTime >= jobs[j].EndTime)

{

jobs[i].CalculatedWeight = Math.Max(jobs[i].CalculatedWeight, jobs[i].Weight + jobs[j].CalculatedWeight);

}

}

}

var maxProfitJob = jobs.Where((j) => j.CalculatedWeight == jobs.Max<Job>((job) => job.CalculatedWeight)).FirstOrDefault();

return maxProfitJob.CalculatedWeight;

}

[TestMethod]

public void TestMethod()

{

var jobs = new Job[] { new Job('a', 1,4, 3), new Job('b', 2, 6, 5), new Job('c', 4,7,2), new Job('d', 5, 9, 4), new Job('e', 6, 8, 6), new Job('f', 7, 10, 8)};

int maxProfit = this.GetMaxJobSchedule(jobs.ToList());

Assert.AreEqual(maxProfit, 13);

}

}

<Compile Include="Permutations.cs" />