public void IntegerSet_Constructor_Test()
{
IntegerSet end = new IntegerSet(1, 2, 3, 4, 5);
Assert.AreEqual(5, end.Count);
Assert.AreEqual(1, end[0]);
Assert.AreEqual(2, end[1]);
Assert.AreEqual(3, end[2]);
Assert.AreEqual(4, end[3]);
Assert.AreEqual(5, end[4]);
}
// Method comparing two objects data within an array
public bool IsEqualTo(IntegerSet k)
{
for(int i = 0; i < array1.Length; i++)
{
if (k.array1[i] != array1[i])
{
return false;
}
}
return true;
}
public void IntegerSet_AddOperator_Test()
{
IntegerSet start = new IntegerSet(1, 2, 3, 4, 5);
IntegerSet end = start + 8;
Assert.AreEqual(5, end.Count);
Assert.AreEqual(9, end[0]);
Assert.AreEqual(10, end[1]);
Assert.AreEqual(11, end[2]);
Assert.AreEqual(12, end[3]);
Assert.AreEqual(13, end[4]);
}
private Boolean TextToIntset(string text, IntegerSet set)
{
// check if the input text is empty or null
if (String.IsNullOrWhiteSpace(text))
{
set.Clear();
return(true);
}
// if the text has characters, try to add in a set
try
{
foreach (var x in text.Split(','))
{
try
{
set.InsertElement(Int32.Parse(x));
}
catch (FormatException e)
{
set.Clear();
StatusOut = e.Message;
return(false);
}
catch (ArgumentNullException e)
{
set.Clear();
StatusOut = e.Message;
return(false);
}
catch (OverflowException e)
{
set.Clear();
StatusOut = e.Message;
return(false);
}
}
}
catch (Exception e)
{
StatusOut = e.Message;
return(false);
}
return(true);
}
/// <summary>
/// Return an integer set from the input string (comma seperated list of integers)
/// </summary>
/// <param name="input"></param>
/// <returns>null is input string is invalid</returns>
private static IntegerSet GetNumbers(string input)
{
IntegerSet set = new IntegerSet();
string[] numbers = input.Split(',');
if (numbers.Length == 0)
return null;
foreach (string c in numbers)
{
int result;
if (int.TryParse(c.Trim(), out result))
set.Add(result);
else
return null;
}
return set;
}
/// <summary>
/// b. Method Intersection creates a third set which is the set-theoretic intersection of two existing sets (i.e., an element of the third set's
/// array is set to false if that element is false in either or both of the existing sets - otherwise, the element of the third set is set to true).
/// </summary>
/// <param name="rightSet"></param> Comparing the left and right set
/// <returns></returns> A intersection set that shows the repeating values from both left and right sets.
public IntegerSet Intersection(IntegerSet secondSet)
{
// Create a temporary set to return back to the main that acts as the Intersection Set.
IntegerSet tempSet = new IntegerSet();
// Create a for loop to traverse through both sets to form a separate Intersection Set
for (int index = 0; index <= 100; index++)
{
// Condition statement to combine both sets to find commonality.
if ((_integers[index] == true) && (secondSet._integers[index] == true))
{
tempSet._integers[index] = true;
}
}
// Return Intersection Set
return(tempSet);
}
/// <summary>
/// a. Method Union creates a third set that is the set-theoretic union of two existing sets (i.e., an element of the third set's array
/// is set to true if that element is true in either or both of the existing sets-otherwise, the element of the third set is set to false).
/// </summary>
/// <param name="rightSet"></param> Comparing the left and right set.
/// <returns></returns> A union set that contains both numbers of both sets and shows duplicate only once.
public IntegerSet Union(IntegerSet secondSet)
{
// Create a temporary set to return back to the main that acts as the Union Set
IntegerSet tempSet = new IntegerSet();
// Create a for loop to traverse through both sets to form a separate Union Set
for (int index = 0; index <= 100; index++)
{
// Condition statement to combine both sets while dealing with duplicates
if ((_integers[index] == true) || (secondSet._integers[index] == true))
{
tempSet._integers[index] = true;
}
}
// Return Temporary Set
return(tempSet);
}
private static IntegerSet BuildRequiredCompilerWarningsSet()
{
var result = new IntegerSet();
result.Add(4018);
result.Add(4146);
result.Add(4244);
result.Add(4267);
result.Add(4302);
result.Add(4308);
result.Add(4509);
result.Add(4532);
result.Add(4533);
result.Add(4700);
result.Add(4789);
result.Add(4995);
result.Add(4996);
return(result);
}
/// <summary>
/// This function finds the union between two IntegerSet objects and returns the set.
/// </summary>
/// <param name="otherSet">The other IntegerSet object.</param>
/// <returns>The resultant set which contains the union of the two sets.</returns>
public IntegerSet Union(IntegerSet otherSet)
{
IntegerSet resultSet = new IntegerSet();
int counter = 0;
foreach (bool value in otherSet.Set)
{
if (value)
{
resultSet.Set[counter] = true;
}
else if (_set[counter])
{
resultSet.Set[counter] = true;
}
counter++;
}
return(resultSet);
}
public AtomicActionRendererTest()
{
_record = new RecordingActionRenderer <Arithmetic>();
_renderer = new AtomicActionRenderer <Arithmetic>(_record);
_fx = new IntegerSet(new BigInteger?[] { 0 }, null, new[] { _renderer });
(_successTx, _) = _fx.Sign(
0,
Arithmetic.Add(1),
Arithmetic.Mul(2),
Arithmetic.Add(3)
);
// failing transaction; should not be rendered:
_fx.Sign(
0,
Arithmetic.Add(1),
new Arithmetic(),
Arithmetic.Add(3)
);
_record.ResetRecords();
}
private static IntegerSet BuildRequiredCompilerWarningsSet()
{
var result = new IntegerSet
{
4018,
4146,
4244,
4267,
4302,
4308,
4509,
4532,
4533,
4700,
4789,
4995,
4996
};
return(result);
}
static void Main(string[] args)
{
IntegerSet set1 = new IntegerSet(); //New up the IntegerSet for set1
IntegerSet set2 = new IntegerSet(); //New up the IntegerSet for set2
IntegerSet set3 = new IntegerSet(); //New up the IntegerSet for set3
set1.InsertElement(1); //Set 1 of numbers to test
set1.InsertElement(2);
set1.InsertElement(3);
set1.InsertElement(10);
set1.InsertElement(5);
set2.InsertElement(3); //Set 2 of number to test
set2.InsertElement(4);
set2.InsertElement(5);
set2.InsertElement(10);
set2.InsertElement(12);
set3.InsertElement(1); //Set 3 of number to test
set3.InsertElement(2);
set3.InsertElement(3);
set3.InsertElement(10);
set3.InsertElement(5);
set3.InsertElement(99);
Console.WriteLine("Set 1: " + set1.ToString()); //Display the ToString method
Console.WriteLine("Set 2: " + set2.ToString()); //Display the ToString method
DisplayUnion(set1,set2); //Display Union method
DisplayIntersection(set1, set2); //Display Intersection method
DisplayInsertElement(set1); //Display InsertElement method
DisplayDeleteElement(set2); //Display DeleteElement method
DisplayEmptyIntegerSet(); //Display EmptyIntegerSet method
if (!set1.IsEqualTo(set2)) //To test the IsEqualTo method
{
Console.WriteLine("Set 1 is NOT equal to Set 2");
}
if (set1.IsEqualTo(set3))
{
Console.WriteLine("Set 1 is equal to Set 3");
}
}
private static void TestingCtors()
{
Console.WriteLine("Testing c'tors / d'tor: ");
IntegerSet s1 = new IntegerSet();
Console.WriteLine("s1: {0}", s1);
int[] elems1 = { -2, -1, 0, 1, 2, -1, -2 };
IntegerSet s2 = new IntegerSet(elems1);
Console.WriteLine("s2: {0}", s2);
int[] elems2 = { -1, 1, 2, 3, 1, 2, 3, 1, 2, 3, -1 };
IntegerSet s3 = new IntegerSet(elems2);
Console.WriteLine("s3: {0}", s3);
Console.WriteLine("s1.IsEmpty: {0}", s1.IsEmpty);
Console.WriteLine("s2.IsEmpty: {0}", s2.IsEmpty);
Console.WriteLine("s3.IsEmpty: {0}", s3.IsEmpty);
}
private static void TestingOperators()
{
// testing union set
IntegerSet s1 = new IntegerSet();
IntegerSet s2 = new IntegerSet();
for (int i = 0; i < 7; i++)
{
s1.Insert(i);
}
for (int i = 2; i < 9; i++)
{
s2.Insert(i);
}
Console.WriteLine("s1: {0}", s1);
Console.WriteLine("s2: {0}", s2);
Console.WriteLine("s1+s2: {0}", s1 + s2);
// testing intersection set
Console.WriteLine("s1^s2: {0}", s1 ^ s2);
// testing ==-operator
Console.WriteLine("s1 == s2: {0}", s1 == s2);
s2.Insert(0);
s2.Insert(1);
s2.Remove(7);
s2.Remove(8);
Console.WriteLine("s2: {0}", s2);
Console.WriteLine("s1 == s2: {0}", s1 == s2);
Console.WriteLine("s1 != s2: {0}", s1 != s2);
// testing subset operator
Console.WriteLine("s1: {0}", s1);
Console.WriteLine("s2: {0}", s2);
Console.WriteLine("s1 <= s2: {0}", s1 <= s2);
s1.Insert(7);
Console.WriteLine("s1: {0}", s1);
Console.WriteLine("s1 <= s2: {0}", s1 <= s2);
}
private static void TestingRemove()
{
IntegerSet s = new IntegerSet();
for (int i = 0; i < 20; i++)
{
s.Insert(i);
}
Console.WriteLine("s: {0}", s);
s.Remove(5);
s.Remove(1);
s.Remove(8);
Console.WriteLine("s: {0}", s);
s.Remove(11);
Console.WriteLine("s: {0}", s);
s.Remove(16);
Console.WriteLine("s: {0}", s);
s.Remove(19);
Console.WriteLine("s: {0}", s);
}
private static void PlayGame()
{
Console.WriteLine("How many big numbers would you like, please enter a number between 1 and 6");
ConsoleKeyInfo input = Console.ReadKey();
int numBigNumbers;
string keyValue = input.KeyChar.ToString();
while (!int.TryParse(keyValue, out numBigNumbers) ||
numBigNumbers < 1 ||
numBigNumbers > 6)
{
Console.WriteLine();
Console.WriteLine("Invalid number entered");
Console.WriteLine("Please enter a number between 1 and 6");
input = Console.ReadKey();
keyValue = input.KeyChar.ToString();
}
// Calculate the numbers used in this game
List <int> numbers = new List <int>();
for (int i = 0; i < numBigNumbers; ++i)
{
numbers.Add(RandomNumberHelper.RandomIntegerFromSet(25, 50, 75, 100));
}
for (int i = 0; i < 6 - numBigNumbers; ++i)
{
numbers.Add(RandomNumberHelper.RandomInteger(1, 10));
}
IntegerSet sourceNumbers = new IntegerSet(numbers);
int targetNumber = RandomNumberHelper.RandomInteger(101, 999);
Console.WriteLine();
Console.WriteLine("The game is to find {0} from the set of numbers {1}, you have 30 seconds starting from now", targetNumber, sourceNumbers.ToString());
Console.WriteLine();
// Show Timer
Task timer = Task.Factory.StartNew(() => TimerCountDown(30));
// Calculate Answer
DownCountGame game = new DownCountGame(targetNumber, sourceNumbers);
Task <Solutions> calculationTask = CalculateSoultionASync(game);
timer.Wait();
// Display Result
if (calculationTask.IsCompleted)
{
try
{
Solutions solutions = calculationTask.Result;
if (solutions.Count == 0)
{
Console.WriteLine("Downcount could not find a solution");
}
else
{
IEquation solution = solutions[0];
if (solution.Value == game.TargetNumber)
{
Console.WriteLine("Downcount found an exact solution");
Console.WriteLine("{0} = {1}", targetNumber, solution.ToString());
}
else
{
decimal closeValue = solution.Value;
Console.WriteLine("Downcount found a solution within {0} of the original target number", game.TargetNumber - closeValue);
Console.WriteLine("{0} = {1}", solution.Value, solution.ToString());
}
}
}
catch (Exception ex)
{
Console.WriteLine(string.Format("An error occured calculating the solution: {0}", ex.ToString()));
}
}
else
{
// We ran out of time
Console.WriteLine("Downcount could not find a solution in the time given");
}
Console.WriteLine();
}
public void IntegerSet_DivideOperatorTest2()
{
IntegerSet start = new IntegerSet(1, 2, 3, 4, 5);
IntegerSet end = start / 8;
Assert.AreEqual(0, end.Count);
}
public void IntegerSet_DivideOperatorTest1()
{
IntegerSet start = new IntegerSet(1, 2, 3, 4, 5);
IntegerSet end = start / 2;
Assert.AreEqual(2, end.Count);
Assert.AreEqual(1, end[0]);
Assert.AreEqual(2, end[1]);
}
static void Main(string[] args)
{
try
{
// Test for the empty set
IntegerSet empty = new IntegerSet();
Console.WriteLine("Low Range: {0}", empty.LOW_RANGE);
Console.WriteLine("High Range: {0}", empty.HIGH_RANGE);
Console.WriteLine("Empty set: {0} \n", empty);
// Test InsertElement method is set A
IntegerSet setA = new IntegerSet();
setA.InsertElement(0);
setA.InsertElement(1);
setA.InsertElement(50);
setA.InsertElement(100);
Console.WriteLine("Insert elements in Set A: {0}", setA);
// Test InsertElement method is set B
IntegerSet setB = new IntegerSet();
setB.InsertElement(100);
setB.InsertElement(99);
setB.InsertElement(50);
setB.InsertElement(0);
Console.WriteLine("Insert elements in Set B: {0} \n", setB);
// Test DeleteElement method in set A and B
setA.DeleteElement(100);
setA.DeleteElement(99); // element not in set
setB.DeleteElement(0);
Console.WriteLine("Delete 100 from Set A: {0}", setA);
Console.WriteLine("Delete 0 from Set B: {0} \n", setB);
// Test Union method for set A and B
IntegerSet unionSet = setA.Union(setB);
Console.WriteLine("Union of A and B: {0} \n", unionSet);
// Test Intersection method for set A and B
IntegerSet intersectSet = setA.Intersection(setB);
Console.WriteLine("Intersection of A and B: {0} \n", intersectSet);
// Test IsEqualTo method for set A, B, and C
IntegerSet setC = new IntegerSet();
setC.InsertElement(0);
setC.InsertElement(1);
setC.InsertElement(50);
Console.WriteLine("Set A: {0}", setA);
Console.WriteLine("Set B: {0}", setB);
Console.WriteLine("Set C: {0}", setC);
Console.WriteLine("Is Set A equal to Set B? {0}", setA.IsEqualTo(setB));
Console.WriteLine("Is Set A equal to Set C? {0} \n", setA.IsEqualTo(setC));
// Test isValid private method
Console.WriteLine("Try to insert element 999");
setA.InsertElement(999);
}
catch (IndexOutOfRangeException ex)
{
Console.WriteLine("*******************************************");
Console.WriteLine(ex.Message);
Console.WriteLine("*******************************************");
}
// Freeze console window
Console.ReadLine();
}
//To test InsertElement method
static void DisplayInsertElement(IntegerSet set1)
{
Console.WriteLine("Before InsertElement in Set 2: " + set1.ToString());
set1.InsertElement(99);
Console.WriteLine("After InsertElement in Set 2: " + set1.ToString());
}
public void Combine()
{
_set1.Clear();
_set2.Clear();
ErrorText = "";
UnionText = "---";
IntersectionText = "---";
errorMessage[0] = "";
errorMessage[1] = "";
try
{
string[] array1 = Set1Input.Split(',');
string[] array2 = Set2Input.Split(',');
int[] arrayUno = new int[array1.Length];
int[] arrayDos = new int[array2.Length];
for (int i = 0; i < arrayUno.Length; i++)
{
arrayUno[i] = Int32.Parse(array1[i]);
}
for (int i = 0; i < arrayDos.Length; i++)
{
arrayDos[i] = Int32.Parse(array2[i]);
}
foreach (uint i in arrayUno)
{
try
{
if (i > 100)
{
throw new System.ArgumentException("value can't be greater than 100", "Set 1");
break;
}
//uint j = uint.Parse(i);
_set1.InsertElement(i);
ErrorText = "";
}
catch (Exception e)
{
errorMessage[0] = e.Message;
UnionText = "---";
IntersectionText = "---";
}
}
foreach (uint i in arrayDos)
{
try
{
if (i > 100)
{
throw new System.ArgumentException("value can't be greater than 100", "Set 2");
break;
}
//uint j = uint.Parse(i);
_set2.InsertElement(i);
ErrorText = "";
}
catch (Exception e)
{
errorMessage[1] = "\n" + e.Message;
UnionText = "---";
IntersectionText = "---";
}
}
}
catch (Exception e)
{
errorMessage[0] = e.Message;
UnionText = "---";
IntersectionText = "---";
}
if (errorMessage[0] == "" && errorMessage[1] == "")
{
IntersectionText = "---";
UnionText = "---";
ErrorText = "";
IntegerSet intersectSet = _set1.Intersection(_set2);
IntegerSet unionSet = _set1.Union(_set2);
UnionText = unionSet.ToString();
IntersectionText = intersectSet.ToString();
ErrorText = "SUCCESS!";
}
else
{
ErrorText = errorMessage[0] + "\n" + errorMessage[1];
}
}
public void Calculate()
{
set1.Clear();
set2.Clear();
try
{
ErrorTextOutput = "";
TopBoxTextOutput = "";
BottomBoxTextOutput = "";
string[] input1String = _topBoxTextInput.Split(',');
string[] input2String = _bottomBoxTextInput.Split(',');
int size1 = input1String.Length;
int size2 = input2String.Length;
int[] input1 = new int[size1];
int[] input2 = new int[size2];
for (int i = 0; i < size1; i++)
{
input1[i] = Int32.Parse(input1String[i]);
}
for (int i = 0; i < size2; i++)
{
input2[i] = Int32.Parse(input2String[i]);
}
foreach (int i in input1)
{
try{
set1.InsertElement(i);
ErrorTextOutput = "";
}catch (Exception e) {
ErrorTextOutput = e.Message;
TopBoxTextOutput = "";
BottomBoxTextOutput = "";
}
}
foreach (int i in input2)
{
try {
set2.InsertElement(i);
ErrorTextOutput = "";
}catch (Exception e) {
ErrorTextOutput = e.Message;
TopBoxTextOutput = "";
BottomBoxTextOutput = "";
}
}
}
catch (Exception e) {
ErrorTextOutput = e.Message;
TopBoxTextOutput = "";
BottomBoxTextOutput = "";
}
if (ErrorTextOutput == "")
{
TopBoxTextOutput = "";
BottomBoxTextOutput = "";
IntegerSet intersection = set1.Intersection(set2);
IntegerSet union = set1.Union(set2);
TopBoxTextOutput = union.ToString();
BottomBoxTextOutput = intersection.ToString();
}
}
public void IntegerSet_ToString_Test()
{
IntegerSet end = new IntegerSet(1, 2, 3, 4, 5);
Assert.AreEqual("{1, 2, 3, 4, 5}", end.ToString());
}
public void IntegerSet_MultiplyOperator_Test()
{
IntegerSet start = new IntegerSet(1, 2, 3, 4, 5);
IntegerSet end = start * 2;
Assert.AreEqual(5, end.Count);
Assert.AreEqual(2, end[0]);
Assert.AreEqual(4, end[1]);
Assert.AreEqual(6, end[2]);
Assert.AreEqual(8, end[3]);
Assert.AreEqual(10, end[4]);
}
//To test DeleteElement method
static void DisplayDeleteElement(IntegerSet set2)
{
Console.WriteLine("Before DeleteElement in Set 2: " + set2.ToString());
set2.DeleteElement(5);
Console.WriteLine("After DeleteElement in Set 2: " + set2.ToString());
}
//To test Union method
static void DisplayUnion(IntegerSet set1, IntegerSet set2)
{
IntegerSet union = set1.Union(set2);
Console.WriteLine("Union Method: " + union.ToString());
}
//To test Intersection method
static void DisplayIntersection(IntegerSet set1, IntegerSet set2)
{
IntegerSet intersection = set1.Intersection(set2);
Console.WriteLine("Intersection Method: " + intersection.ToString());
}
public DownCountGame(int target, params int[] numbers)
{
TargetNumber = target;
Numbers = new IntegerSet(numbers);
}
public DownCountGame(int target, IEnumerable<int> numbers)
{
TargetNumber = target;
Numbers = new IntegerSet(numbers);
}
public void Convert() // this function will be called when the compute button is pressed.
{
In1Text = In1Text.TrimEnd(',', ' ');
In2Text = In2Text.TrimEnd(',', ' ');
string[] arr1 = In1Text.Split(',', '，');
string[] arr2 = In2Text.Split(',', '，'); //seperate words into arrays
_s1.Clear();
_s2.Clear(); //make sure s1 and s2 are clear before use.
ErrText = ""; //clear error message
ErrColor = Brushes.Black;
if (In1Text == "")
{
ErrText += "Set 1 is empty\n";
}
else
{
foreach (string i in arr1)
{
try
{
//if (i == "") continue;
uint j = uint.Parse(i);
if (j > 100)
{
throw new Exception("Number Exceed max value 100!");
}
_s1.InsertElement(j);
}
catch (Exception e)
{
ErrColor = Brushes.Red;
ErrText += e.Message;
_s1.Clear();
UnionText = "";
InterText = "";
return;
}
}
}
if (In2Text == "")
{
ErrText += "Set 2 is empty\n";
}
else
{
foreach (string i in arr2)
{
try
{
//if (i == "") continue;
uint j = uint.Parse(i);
if (j > 100)
{
throw new Exception("Number Exceed max value 100!");
}
_s2.InsertElement(j);
}
catch (Exception e)
{
ErrColor = Brushes.Red;
ErrText += e.Message;
_s2.Clear();
UnionText = "";
InterText = "";
return;
}
}
}
IntegerSet inter = _s1.Intersection(_s2);
IntegerSet uni = _s1.Union(_s2);
UnionText = uni.ToString();
InterText = inter.ToString();
ErrText += "Here is the result\n";
}
private static IntegerSet BuildRequiredCompilerWarningsSet()
{
var result = new IntegerSet();
result.Add(4018);
result.Add(4146);
result.Add(4244);
result.Add(4267);
result.Add(4302);
result.Add(4308);
result.Add(4509);
result.Add(4532);
result.Add(4533);
result.Add(4700);
result.Add(4789);
result.Add(4995);
result.Add(4996);
return result;
}
//To test DisplayEmptyIntegerSet method
static void DisplayEmptyIntegerSet()
{
IntegerSet emptySet = new IntegerSet();
Console.WriteLine("Empty Set: " + emptySet.ToString());
}
private static void PlayGame()
{
Console.WriteLine("How many big numbers would you like, please enter a number between 1 and 6");
ConsoleKeyInfo input = Console.ReadKey();
int numBigNumbers;
string keyValue = input.KeyChar.ToString();
while (!int.TryParse(keyValue, out numBigNumbers) ||
numBigNumbers < 1 ||
numBigNumbers > 6)
{
Console.WriteLine();
Console.WriteLine("Invalid number entered");
Console.WriteLine("Please enter a number between 1 and 6");
input = Console.ReadKey();
keyValue = input.KeyChar.ToString();
}
// Calculate the numbers used in this game
List<int> numbers = new List<int>();
for (int i = 0; i < numBigNumbers; ++i)
{
numbers.Add(RandomNumberHelper.RandomIntegerFromSet(25, 50, 75, 100));
}
for (int i = 0; i < 6 - numBigNumbers; ++i)
{
numbers.Add(RandomNumberHelper.RandomInteger(1, 10));
}
IntegerSet sourceNumbers = new IntegerSet(numbers);
int targetNumber = RandomNumberHelper.RandomInteger(101, 999);
Console.WriteLine();
Console.WriteLine("The game is to find {0} from the set of numbers {1}, you have 30 seconds starting from now", targetNumber, sourceNumbers.ToString());
Console.WriteLine();
// Show Timer
Task timer = Task.Factory.StartNew(() => TimerCountDown(30));
// Calculate Answer
DownCountGame game = new DownCountGame(targetNumber, sourceNumbers);
Task<Solutions> calculationTask = CalculateSoultionASync(game);
timer.Wait();
// Display Result
if (calculationTask.IsCompleted)
{
try
{
Solutions solutions = calculationTask.Result;
if (solutions.Count == 0)
{
Console.WriteLine("Downcount could not find a solution");
}
else
{
IEquation solution = solutions[0];
if (solution.Value == game.TargetNumber)
{
Console.WriteLine("Downcount found an exact solution");
Console.WriteLine("{0} = {1}", targetNumber, solution.ToString());
}
else
{
decimal closeValue = solution.Value;
Console.WriteLine("Downcount found a solution within {0} of the original target number", game.TargetNumber - closeValue);
Console.WriteLine("{0} = {1}", solution.Value, solution.ToString());
}
}
}
catch (Exception ex)
{
Console.WriteLine(string.Format("An error occured calculating the solution: {0}", ex.ToString()));
}
}
else
{
// We ran out of time
Console.WriteLine("Downcount could not find a solution in the time given");
}
Console.WriteLine();
}
public void IntegerSet_SubtractOperator_Test()
{
IntegerSet start = new IntegerSet(1, 2, 3, 4, 5);
IntegerSet end = start - 8;
Assert.AreEqual(5, end.Count);
Assert.AreEqual(-7, end[0]);
Assert.AreEqual(-6, end[1]);
Assert.AreEqual(-5, end[2]);
Assert.AreEqual(-4, end[3]);
Assert.AreEqual(-3, end[4]);
}
public void IntegerSet_ToString_Test()
{
IntegerSet end = new IntegerSet(1, 2, 3, 4, 5);
Assert.AreEqual("{1, 2, 3, 4, 5}", end.ToString());
}
public ModelHW()
{
setA = new IntegerSet();
setB = new IntegerSet();
}
public void IntegerSet_Subset_ArgumentOutOfRangeTest2()
{
IntegerSet start = new IntegerSet(1, 2, 3, 4, 5);
IntegerSet end = start.SubsetNotIncluding(-1);
}
public void IntegerSet_Subset_ArgumentOutOfRangeTest1()
{
IntegerSet start = new IntegerSet(1, 2, 3, 4, 5);
IntegerSet end = start.SubsetNotIncluding(7);
}
public void IntegerSet_Subset_Test()
{
IntegerSet start = new IntegerSet(1, 2, 3, 4, 5);
IntegerSet end = start.SubsetNotIncluding(1);
Assert.AreEqual(4, end.Count);
Assert.AreEqual(1, end[0]);
Assert.AreEqual(3, end[1]);
Assert.AreEqual(4, end[2]);
Assert.AreEqual(5, end[3]);
}
public void Parsing()
{
Assert.IsTrue(IntegerSet.TryParse("[1-10,12-33]", out var set));
Assert.AreEqual(new IntegerSet((1, 10), (12, 33)), set);
}
