public void TwoFactorialIsTwo()
{
FactorialCalculator calculator = new FactorialCalculator();
float result = calculator.GetFactorial(2);
Assert.AreEqual(2, result);
}
public void TestCalculateFactorial(int n, int expectedFactorial)
{
var factorialCalculator = new FactorialCalculator();
var actualFactorial = factorialCalculator.Factorial(n);
Assert.AreEqual(expectedFactorial, actualFactorial);
}
public void ThreeFactorialIsSix()
{
FactorialCalculator calculator = new FactorialCalculator();
float result = calculator.GetFactorial(3);
Assert.AreEqual(6, result);
}
public void OneFactorialIsOne()
{
FactorialCalculator calculator = new FactorialCalculator();
float result = calculator.GetFactorial(1);
Assert.AreEqual(1, result);
}
public void TestFactorialOutsideLimit()
{
FactorialCalculator facCal = new FactorialCalculator();
var exception = Assert.Throws <System.NotSupportedException>(() => facCal.Calculate(11));
Assert.That(exception.Message, Is.EqualTo("n > 10 is not supported"));
}
static void Main(string[] args)
{
var factorialResult = new FactorialCalculator(new FactorialWebService())
.Calculate(1000);
Console.WriteLine("The factorial is {0}", factorialResult);
Console.ReadLine();
}
public MathController(
FactorialCalculator factorialCalculator,
FibonacciCalculator fibonacciCalculator,
RandomSquareCalculator randomSquareCalculator)
{
_factorialCalculator = factorialCalculator;
_fibonacciCalculator = fibonacciCalculator;
_randomSquareCalculator = randomSquareCalculator;
}
public void FactorialTest()
{
var fac = new FactorialCalculator();
// var result1 = fac.Factorial(3);
// Console.WriteLine(result1);
var result2 = fac.Factorial(10);
Console.WriteLine(result2);
}
public JsonResult CalculateFactorial(int number)
{
float result;
FactorialCalculator factorialCalculator = new FactorialCalculator();
result = factorialCalculator.GetFactorial(number);
Process process = new Process();
process.SaveToServer(number, result);
return(Json(result, "application/json"));
}
public static void PrintFactorialYield(uint numberToCalculate)
{
FactorialCalculator factorialCalculator = new FactorialCalculator();
int counter = 0;
int result = 0;
foreach (int currentResult in factorialCalculator)
{
factorialCalculator.calculateNext = ++counter < numberToCalculate;
result = currentResult;
}
Console.WriteLine(result);
}
static void Main(string[] args)
{
var random = new System.Random();
var calculator = new FactorialCalculator();
while (true)
{
var value = random.Next(1, 10);
var result = calculator.Calculate(value);
Console.WriteLine($"Faktoriál hodnoty {value} je {result}!");
}
}
public void TestGeneratePermutationFromKey(int numObjects)
{
var factorial = new FactorialCalculator().Factorial(numObjects);
var permutationGenerator = new PermutationGenerator();
var permutationSet = new HashSet <string>();
for (int i = 0; i < factorial; i++)
{
var permutation = permutationGenerator.GeneratePermutationFromKey(i, numObjects).GetPermutation();
var permutationString = permutation.Aggregate("", (agg, digit) => $"{agg}{digit}");
Assert.False(permutationSet.Contains(permutationString));
permutationSet.Add(permutationString);
}
Assert.AreEqual(factorial, permutationSet.Count);
}
private static double GetNumberOfCombinations(int objectsCount, int objectsCountInCombination)
{
var diff = objectsCount - objectsCountInCombination;
if (diff == 0)
{
return(1);
}
var divident = FactorialCalculator.Factorial(objectsCount);
var divisor = FactorialCalculator.Factorial(objectsCountInCombination) * FactorialCalculator.Factorial(diff);
var numberOfCombinations = divident / divisor;
return(numberOfCombinations);
}
public void TestFactorial()
{
var calculator = new FactorialCalculator();
var expected = Enumerable.Range(1, 10).Select(i => new { i, r = calculator.Factorial(i) }).ToDictionary(key => key.i, value => value.r);
foreach (var pair in expected)
{
Assert.AreEqual(pair.Value, calculator.Calculate(pair.Key).Match(x => x, x => x.Value));
}
foreach (var pair in expected)
{
Assert.AreEqual(pair.Value, calculator.Calculate(pair.Key).Match(x => x, x => x.Value));
}
}
static void Main(string[] args)
{
string line = null;
var calculator = new FactorialCalculator();
do
{
if (Int32.TryParse(line, out var value))
{
var result = calculator.Calculate(value);
Console.WriteLine($"Faktoriál hodnoty {value} je {result}!");
}
Console.WriteLine($"Zadejte hodnotu pro výpočet faktoriálu:");
line = Console.ReadLine();
} while (line.ToLower() != "y");
}
public void Setup() => _calculator = new FactorialCalculator();
public int TestFactorialInLimit(int number)
{
FactorialCalculator facCal = new FactorialCalculator();
return(facCal.Calculate(number));
}
public void TestHatvanyCalculato()
{
FactorialCalculator.FactorialRecursion(-3);
FactorialCalculator.ExponentiationRecursion(-2, 8);
}
public void TestHatvanyCalculator()
{
Assert.AreEqual(1, FactorialCalculator.ExponentiationRecursion(2, 0));
Assert.AreEqual(256, FactorialCalculator.ExponentiationRecursion(2, 8));
Assert.AreEqual(19683, FactorialCalculator.ExponentiationRecursion(3, 9));
}
public void TestFactorialCalculation()
{
Assert.AreEqual(1, FactorialCalculator.FactorialRecursion(1));
Assert.AreEqual(6, FactorialCalculator.FactorialRecursion(3));
Assert.AreEqual(120, FactorialCalculator.FactorialRecursion(5));
}
public void SetUp()
{
_calculator = new FactorialCalculator();
}
static void Main(string[] args)
{
string[] strings =
{
"(){}",
")"
};
foreach (var s in strings)
{
string results = BracketDelimiter.IsBalanced(s) ? "succes" : "niet oké";
Debug.WriteLine(results);
}
var resultTot = PostfixCalculator.Calculate("12 10-2+25*10/");
Console.WriteLine(resultTot);
//BracketDelimiter.IsBalanced("(){}");
//BracketDelimiter.IsBalanced("()");
//BracketDelimiter.IsBalanced("((");
//BracketDelimiter.IsBalanced("{()}");
//BracketDelimiter.IsBalanced("{()");
//BracketDelimiter.IsBalanced("''");
////var resultS = BracketDelimiter.IsBalanced("<?<??>?>");
//var resultSS = BracketDelimiter.IsBalanced("for(int i = 0; i< 100; i++){}");
//Console.WriteLine(resultSS);
Console.ReadLine();
return;
OddNumberPrinter.ExecuteEven(2);
OddNumberPrinter.ExecuteOdd(3);
var result = InterestCalculator.Calculate(2, 1, 5000);
List <string> items = new List <string> {
"a", "b", "c", "d", "e", "f", "g"
};
Permutation.Permutations(items);
Console.WriteLine(Permutation.GetPermutationCount);
//Printer.PrintAsc();
//Console.WriteLine(NaturalCounter.Execute(5));
//DigitSeperator.Execute(255);
//Console.WriteLine(DigitCounter.Execute(12345));
//OddNumberPrinter.Execute(20);
ItterativeIndex ittIdIndex = new ItterativeIndex();
int value = ittIdIndex.IndexOf(new int[] { 1, 2, 3, 4, 5 }, 5, 0);
IsPrime.Execute(37, 37 / 2);
IsPalindrome.Execute("ABBA");
Console.WriteLine(
FactorialCalculator.Execute(8));
//ForLoopProblem.Problem();
char startPeg = 'A'; // start tower in output
char endPeg = 'C'; // end tower in output
char tempPeg = 'B'; // temporary tower in output
int totalDisks = 1200; // number of disks
//TowersOfHanoi.Solve(totalDisks, startPeg, endPeg, tempPeg);
int[,] random = new int[, ]
{
{ 200, 400 },
{ 2000, 4176 },
{ 20000, 40000 },
{ 50000, 50000 }
};
//var c = _2DArraySum.GetHighestSum(random);
var getHighestSummedArray = new _2DArraySumAsClass <int[, ]>();
Console.WriteLine("Highest value" + getHighestSummedArray.GetHighestSum(random));
//Create linked list
LinkedListExercise linkedListExercise = new LinkedListExercise();
//Add data
linkedListExercise.Employees.AddLast(new Employee("Bob", 5));
linkedListExercise.Employees.AddLast(new Employee("Alice", 5000));
//ShallowCopy with IClonable
var shallowCopy = linkedListExercise.ShallowCopy();
//Shallow copy with Collection<T>() ctor
var shallowCopyCollection = linkedListExercise.ShallowCopyCollection();
//Deep copy
var deepCopy = linkedListExercise.DeepCopy();
//var bucketSort = new BucketSort();
//bucketSort.Execute(new[] { 8, 2, 122, 1, 99, 3, 4, 2 });
//BubbleSort bubbleSort = new BubbleSort();
//var res = bubbleSort.Execute(new int[]{8,2, 122, 1});
//var x = new Solution3();
//x.Slow(100);
//x.Fast(100);
//var binarySearch = new BinarySearch();
//var array = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
//int pos = binarySearch.Execute(array, 10);
//var input = "8,1,6;3,5,7;4,9,2";
//var array = (from x in input.Split(',', ';') select int.Parse(x)).ToArray();
//var magic = new MagicSquare();
//magic.Execute(3);
//magic.ExecuteCorrect(3);
//MagicSquare.RunMagicSquare(3);
//Binary Search recurisve.
//int[] testArray = { 1,2,3,4,5,6,7,8,9,10,11,12};
//var length = testArray.Length;
//var searchFor = 10;
//Console.WriteLine(BinarySearch.RecursiveV2(searchFor, testArray, 0, length));
//Console.WriteLine($"Self made {BinarySearch.BinarySearchRecursiveSelf(testArray, 0, length, searchFor)}");
//Console.WriteLine(
// ADS.Core.Lesson_2.Converter.DecimalToBin(10));
//Console.WriteLine("Bin 2 dec " + ADS.Core.Lesson_2.Converter.Bin2dec(1100));
//Console.WriteLine(ADS.Core.Lesson_2.Converter.BinToDecimal("10101"));
//Console.WriteLine(Palindrome.IsPalindrome("racecar"));
// Console.WriteLine(ReverseString.ExecuteV1("ban"));
// Console.WriteLine(ReverseString.Execute("ban"));
// ArrayCombiner arrayCombiner = new ArrayCombiner();
//var x = arrayCombiner.Execute(new int[] { 1, 2, 3, 5, 8, 13, 21, 34, 55, 89 },
// new int[] { 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024 });
//ArrayListCombiner arrayListCombiner = new ArrayListCombiner();
// var y = arrayListCombiner.Merge(new List<int> { 1, 2, 3, 5, 8, 13, 21, 34, 55, 89 },
// new List<int> { 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024 });
// Create first polynomial
var polynomial1 = new Polynomial();
polynomial1.Add(new Term(1, 2));
polynomial1.Add(new Term(2, 2));
polynomial1.Add(new Term(3, 0));
// Create second polynomial
var polynomial2 = new Polynomial();
polynomial2.Add(new Term(-1, 3));
polynomial2.Add(new Term(1, 1));
polynomial2.Add(new Term(1, 2));
Stopwatch x = new Stopwatch();
x.Start();
Polynomial polyX = polynomial1.SumWorking(polynomial2);
var termsWorking = polyX.GetAllTerms();
x.Stop();
Console.WriteLine(x.ElapsedTicks + "TICKS");
x.Reset();
x.Start();
Polynomial polyOptimized = polynomial1.OptimizedAlgorithm(polynomial2);
var optimzedTerms = polyX.GetAllTerms();
x.Stop();
Console.WriteLine(x.ElapsedTicks + "TICKS");
x.Reset();
// Determine the sum
Polynomial polynomialSum = polynomial1.Sum(polynomial2);
var terms = polynomialSum.GetAllTerms();
for (int i = 0; i < polynomialSum.GetAllTerms().Count; i++)
{
Console.Write($"{terms[i].toString()}\t");
}
//TowersOfHanoi.Solve(64);
//TowersOfHanoi.TowerHanoi(3);
//-> coeff = 1 - X^ > ex3
//2X^3
//-5^0
//var c = BinarySearch.binarySearchFloris(new int[] { 1,2,3,4,5,6,7,8,9,10 }, 2);
Hangman hangman = new Hangman();
hangman.ChooseWord();
bool val = true;
while (val)
{
string input = Console.ReadLine();
hangman.GuessWord(input);
if (input == "exit")
{
val = false;
}
}
int[] arr1 = new int[] { 1, 2, 3, 5, 8, 13, 21, 34, 55, 89 };
int[] arr2 = new int[] { 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024 };
int[] execute = ArrayCombiner.combineArray(arr2, arr1);
//var intList = new ArrayList();
//intList[1] as int? = 2;
var res12 = ArrayListCombiner.Merge(new ArrayList()
{
1, 2, 3, 4
}, new ArrayList()
{
1, 2, 3, 4
});
int max = MaxRec.Execute(new int[] { 1, 2, 3, 4, 1204 });
Console.WriteLine();
//Console.WriteLine(Converter.BinToDecimal("1011"));
Console.ReadLine();
}
public bool RunOperation(int choice)
{
switch (choice)
{
case 1:
var t1 = new FactorialCalculator();
t1.Run();
break;
case 2:
var t2 = new TelephoneDirectorySearch();
t2.Run();
break;
case 3:
var t3 = new ArrayIsSorted();
t3.Run();
break;
case 4:
var t4 = new MergeSort();
t4.Run();
break;
case 5:
var t5 = new BubbleSort();
t5.Run();
break;
case 6:
var t6 = new BruteForcePasswordGenerator.BruteForcePasswordGenerator();
t6.Run();
break;
case 7:
var t7 = new BruteForcePasswordGeneratorCSharp.BruteForcePasswordGenerator();
t7.Run();
break;
case 8:
var t8 = new QuickSort();
t8.Run();
break;
case 9:
var t9 = new DepthFirstSearch();
t9.Run();
break;
case 10:
var t10 = new BreadthFirstSearch();
t10.Run();
break;
// Quit case
case 0:
return(true);
// Invalid choice case
default:
Console.WriteLine("\nInvalid menu choice selected");
break;
}
return(false);
}
public FactorialTests()
{
_factorialCalculator = new FactorialCalculator();
_calculator = new Calculator();
}
public void Setup()
{
_factorialWebService = MockRepository.GenerateMock <IFactorialWebService>();
_factorialCalculator = new FactorialCalculator(_factorialWebService);
}
public static void Task()
{
PrimeNumberGenerator.CalculatePrimeNumbers(10000);
FactorialCalculator.CalculateFactorial(5000);
}
public PermutationGenerator()
{
this._factorialCalculator = new FactorialCalculator();
this._random = new Random();
}
public void Setup()
{
factorialCalculator = new FactorialCalculator();
}
public void SetUp()
{
_calculator = new FactorialCalculator();
}
