public Recursion() : this("foo") { this.m_child = this; // this.m_Parent = owner; // Stack overflow on next line analysis this.s.ToString(); //this.m_child.IsOpen = true; }
public void IsPalindrome() { // Arrange var recursion = new Recursion(); // Act var isRadarPalindrome1 = recursion.IsPalindrome("RADAR"); var isRadarPalindrome = recursion.IsPalindrome("RADDAR"); var isWrongPalindrome = recursion.IsPalindrome("Wrong"); // Assert Assert.IsTrue(isRadarPalindrome); Assert.IsTrue(isRadarPalindrome1); Assert.IsFalse(isWrongPalindrome); }
public void Opdracht10_MyListGetLast2547135Test() { //Arrange Recursion recursion = new Recursion(); MyList <int> list = new MyList <int>(25); list.Add(47); list.Add(13); list.Add(5); //Act int result = list.GetLast(); //Assert Assert.AreEqual(5, result); }
internal static bool DisposedByReturnValue(ArgumentSyntax candidate, SemanticModel semanticModel, CancellationToken cancellationToken, [NotNullWhen(true)] out ExpressionSyntax?creation) { if (candidate.TryFirstAncestor(out TypeDeclarationSyntax? containingTypeDeclaration) && semanticModel.TryGetNamedType(containingTypeDeclaration, cancellationToken, out var containingType)) { using var recursion = Recursion.Borrow(containingType, semanticModel, cancellationToken); if (recursion.Target(candidate) is { } target) { return(DisposedByReturnValue(target, recursion, out creation)); } } creation = null; return(false); }
public override string ToString() { if (Recursion.TryLock(this)) { try { return(SequenceToString(storage.GetSequence(offset), "[", "]", zo => zo.ToString())); } finally { Recursion.Unlock(this); } } return("[...]"); }
protected override string ToStringContextImpl(Context ctx, bool friendly) { if (Recursion.TryLock(this)) { try { return(SequenceToString(storage.GetSequence(offset), "[", "]", zo => zo.ToStringContext(ctx, friendly))); } finally { Recursion.Unlock(this); } } return("[...]"); }
public void Opdracht11_MyListCountAapNootMiesTest() { //Arrange Recursion recursion = new Recursion(); MyList <string> list = new MyList <string>("aap"); list.Add("noot"); list.Add("mies"); list.Add("geen idee wat daarna komt"); //Act int result = list.Count(); //Assert Assert.AreEqual(4, result); }
public void testgetEncryptedString() { var encString = Recursion.findEncryptedWord("abcxcba"); Assert.AreEqual("xbacbca", encString); encString = Recursion.findEncryptedWord("abcd"); Assert.AreEqual("bacd", encString); encString = Recursion.findEncryptedWord("abc"); Assert.AreEqual("bac", encString); encString = Recursion.findEncryptedWord("facebook"); Assert.AreEqual("eafcobok", encString); }
internal static bool Stores(LocalOrParameter localOrParameter, SemanticModel semanticModel, CancellationToken cancellationToken, [NotNullWhen(true)] out ISymbol?container) { using var recursion = Recursion.Borrow(localOrParameter.Symbol.ContainingType, semanticModel, cancellationToken); using var walker = UsagesWalker.Borrow(localOrParameter, semanticModel, cancellationToken); foreach (var usage in walker.Usages) { if (Stores(usage, recursion, out container)) { return(true); } } container = null; return(false); }
public void Opdracht12_MyListReverse2547135Test() { //Arrange var recursion = new Recursion(); var list = new MyList <int>(25); list.Add(47); list.Add(13); list.Add(5); //Act var result = list.Reverse().GetLast(); //Assert Assert.AreEqual(25, result); }
public void GetIncreasingSequenceTest() { Recursion target = new Recursion(); // TODO: Initialize to an appropriate value List <Recursion.HtWt> items = new List <Recursion.HtWt>(); // TODO: Initialize to an appropriate value items.Add(new Recursion.HtWt(1, 2)); items.Add(new Recursion.HtWt(2, 3)); items.Add(new Recursion.HtWt(1, 4)); items.Add(new Recursion.HtWt(5, 7)); items.Add(new Recursion.HtWt(3, 9)) ; List <Recursion.HtWt> expected = null; // TODO: Initialize to an appropriate value List <Recursion.HtWt> actual; actual = target.GetIncreasingSequence(items); }
public void Opdracht09_MergeSort51829342Test() { //Arrange Recursion recursion = new Recursion(); List <int> input = new List <int> { 5, 1, 8, 2, 9, 3, 4, 2 }; List <int> expectedResult = new List <int> { 1, 2, 2, 3, 4, 5, 8, 9 }; //Act List <int> result = recursion.MergeSort(input); //Assert CollectionAssert.AreEqual(expectedResult, result); }
public string MiddlePermutation(string s) { var rec = new Recursion(); rec.InputSet = rec.MakeCharArray(s); rec.CalcPermutation(0); var permutations = rec.Result.OrderBy(r => r).ToList(); var numberOfPermutations = permutations.Count; var result = permutations.Count == 0 ? s : permutations.ElementAt(numberOfPermutations % 2 == 0 ? numberOfPermutations / 2 - 1 : (numberOfPermutations + 1) / 2 - 1); return(result); }
public void Opdracht11_MyListEdgarsTest2() { //Arrange var recursion = new Recursion(); var list = new MyList <string>("aap"); list.Add("noot"); list.Add("mies"); list.Add("mifvses"); list.Add("vf"); list.Add("geen idee wat daarna komt"); //Act var result = list.Count(); //Assert Assert.AreEqual(6, result); }
public void PowersetProblem() { Recursion rec = new Recursion(); List <List <int> > results = rec.GetAllSubsetsProblem(new int[] { 3, 4 }); StringBuilder sb = new StringBuilder(); foreach (List <int> r in results) { sb.Clear(); foreach (int n in r) { sb.Append(n.ToString()); } Console.WriteLine(sb.ToString()); } }
public void TestFindPossiblePathsToReachACellInGrid() { var paths = Recursion.FindAllPathsToAGridCellFromTopLeftCorner(3, 3, 3, 3); Assert.IsNotNull(paths); Assert.AreEqual(paths.Count, 6); paths.ForEach(p => { Console.WriteLine(p); }); paths = Recursion.FindAllPathsToAGridCellFromTopLeftCorner(4, 4, 4, 4); Assert.IsNotNull(paths); paths.ForEach(p => { Console.WriteLine(p); }); }
private string GetItemsListCacheKey(Recursion recursion, int revision, string path) { switch (recursion) { case Recursion.Full: return(GetItemFullPathCacheKey(revision, path)); case Recursion.OneLevel: return(GetItemOneLevelCacheKey(revision, path)); case Recursion.None: return(GetItemNoRecursionCacheKey(revision, path)); default: throw new NotSupportedException(); } }
static void Main(string[] args) { Random random = new Random(); int counter = 0; while (true) { if (counter > 4) { break; } List <int> num = new List <int> { 1, 2, 3, 4, 5 }; //int n = random.Next(1, 5); //int n1 = random.Next(1, 5); //int n2 = random.Next(1, 5); //int n3 = random.Next(1, 5); //int n4 = random.Next(1, 5); HashSet <int> numbers = new HashSet <int>(); // if (n != n1 && n != n2 && n !=n3 && n != n4 && n1 != n2 && n1 != n3 && n1 != n4 && n2 != n3 && n2 != n4 && n3 != n4){ num //numbers.Add(n); //numbers.Add(n1); //numbers.Add(n2); //numbers.Add(n3); //numbers.Add(n4); counter++; foreach (var m in numbers) { Console.Write(m); } Console.WriteLine(); // } //Console.Write("Input String>"); string inputLine = "12345"; Recursion rec = new Recursion(); rec.InputSet = rec.MakeCharArray(inputLine); rec.CalcPermutation(0); Console.Write("# of Permutations: " + rec.PermutationCount); } }
public void FirstNaturalNumbers() { // Arrange var recursion = new Recursion(); var expected = new List <int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; // Act var actual = recursion.GetNaturalNumbers(10); // Assert Assert.AreEqual(10, actual.Count()); foreach (var foundNumber in actual) { Assert.IsTrue(expected.Contains(foundNumber)); } }
public List <string> ToStringCustom(Recursion limit) { List <string> tmp = new List <string>(); tmp.Add("Article " + Id + " " + ArtText); if ((Comments.Count == 0) || (limit == 0)) { return(tmp); } else { foreach (Comment item in Comments.Where(x => x.ParentId == null)) { tmp = tmp.Concat(item.ToStringCustom(limit--)).ToList(); } return(tmp); } }
/////////////////////////////////////////////////////////////////////////////////// void WaitForNumOfSeconds() { var wait = Recursion.Action <int>((count, stack) => { if (count == 0) { stack.Exit(); } else { Thread.Sleep(1000); WriteLine("tick..."); stack.Push(count - 1); } }); wait(5); }
public bool IsPredictable(Recursion recursion) { if (!hasValidConnection) { return(true); } if (!recursion?.TryEnter(this) ?? false) { return(false); } var isPredictable = validConnectedPorts.All(cop => cop.IsPredictable(recursion)); recursion?.Exit(this); return(isPredictable); }
public bool IsPredictable(Recursion recursion) { if (unit.isControlRoot) { return(true); } if (!recursion?.TryEnter(this) ?? false) { return(false); } var isPredictable = unit.relations.WithDestination(this).Where(r => r.source is ControlInput).All(r => ((ControlInput)r.source).IsPredictable(recursion)); recursion?.Exit(this); return(isPredictable); }
private List <T> GetValue(Recursion recursion) { float squaredRadius = Radius.GetValue <float>() * Radius.GetValue <float>(); Vector3 originPoint = Origin.GetValue <GameObject>().transform.position; T[] objects = Object.FindObjectsOfType <T>(); List <T> radius = new List <T>(objects.Length); for (int i = 0; i < objects.Length; i++) { if ((objects[i].transform.position - originPoint).sqrMagnitude < squaredRadius) { radius.Add(objects[i]); } } return(radius); }
public void Opdracht08_Merge102030100Test() { //Arrange var recursion = new Recursion(); var list_a = new List <int> { 10, 20, 30 }; var list_b = new List <int> { 100 }; var expectedResult = new List <int> { 10, 20, 30, 100 }; //Act var result = recursion.Merge(list_a, list_b); //Assert CollectionAssert.AreEqual(expectedResult, result); }
public void Opdracht08_Merge1020304025Test() { //Arrange Recursion recursion = new Recursion(); List <int> list_a = new List <int> { 10, 20, 30, 40 }; List <int> list_b = new List <int> { 25 }; List <int> expectedResult = new List <int> { 10, 20, 25, 30, 40 }; //Act List <int> result = recursion.Merge(list_a, list_b); //Assert CollectionAssert.AreEqual(expectedResult, result); }
public void Opdracht08_Merge13791379Test() { //Arrange Recursion recursion = new Recursion(); List <int> list_a = new List <int> { 1, 3, 7, 9 }; List <int> list_b = new List <int> { 1, 3, 7, 9 }; List <int> expectedResult = new List <int> { 1, 1, 3, 3, 7, 7, 9, 9 }; //Act List <int> result = recursion.Merge(list_a, list_b); //Assert CollectionAssert.AreEqual(expectedResult, result); }
/////////////////////////////////////////////////////////////////////////////////// void TailedRecursionWithLambda() { var fib_iter = Recursion.Func <int, int, int, int>( (fnext, f, count, stack) => { if (count == 0) { stack.Exit(f); } else { stack.Push(fnext + f, fnext, count - 1); } }); Func <int, int> fib = n => fib_iter(1, 0, n); fib(5); }
private static ItemMetaData GetItems(TFSSourceControlProvider sourceControlProvider, int version, string path, Recursion recursion, bool loadPropertiesFromFile) { // Make sure path is decoded ItemMetaData item = null; if (loadPropertiesFromFile) { item = sourceControlProvider.GetItems(version, Helper.Decode(path), recursion); } else { item = sourceControlProvider.GetItemsWithoutProperties(version, Helper.Decode(path), recursion); } return(item); }
public override string ToString() { string MaybeQuote(ZilObject zo) { return(zo is ZilAtom ? "'" + zo : zo.ToString()); } if (Recursion.TryLock(this)) { try { return($"%<OFFSET {Index} {MaybeQuote(StructurePattern)} {MaybeQuote(ValuePattern)}>"); } finally { Recursion.Unlock(this); } } return("%<OFFSET ...>"); }
protected override string ToStringContextImpl(Context ctx, bool friendly) { string MaybeQuote(ZilObject zo) { return(zo is ZilAtom ? "'" + zo : zo.ToStringContext(ctx, friendly)); } if (Recursion.TryLock(this)) { try { return($"%<OFFSET {Index} {MaybeQuote(StructurePattern)} {MaybeQuote(ValuePattern)}>"); } finally { Recursion.Unlock(this); } } return("%<OFFSET ...>"); }
public void initInventory() { inventorySkills = new baseSkill[14]; inventorySkills [0] = new Arrays (); inventorySkills [1] = new BreakAndContinue (); inventorySkills [2] = new DDOS (); inventorySkills [3] = new DefaultFunctions (); inventorySkills [4] = new FireWall (); inventorySkills [5] = new FunctionsWithInputOutput (); inventorySkills [6] = new FunctionsWithOutput (); inventorySkills [7] = new Hash (); inventorySkills [8] = new IfElse (); inventorySkills [9] = new InfiniteLoop (); inventorySkills [10] = new Loop (); inventorySkills [11] = new PacketSniffing (); inventorySkills [12] = new Recursion (); inventorySkills [13] = new Stack (); Debug.Log ("Finished Loading Inventory"); }
private void Initialize(Application anApp, bool bAllTypes, Recursion recur, bool bDebug, bool bVBNet, int nVersion) { this._app = anApp; string languageName = GetLanguageName(bVBNet, nVersion); LZ.Reverse.Info._bVBNet = bVBNet; LZ.Reverse.Info._nVersion = nVersion; this._bAllTypes = bAllTypes; this._recur = recur; LZ.Reverse.Info._bDebug = bDebug; this._mdl = (Model) this._app.CreateModel(0x18112060, "|Language=" + languageName + "|Diagram=ClassDiagram", OpenModelFlags.omf_Default); this._mdl.Name = "Reverse"; this._mdl.Code = "Reverse"; NamespaceMapping.Model = this._mdl; ProperRef.Model = this._mdl; TypeMapping.Clear(); }
public Reverser(Application anApp, bool bAllTypes, Recursion recur, bool bDebug, bool bVBNet, int nVersion) { this.Initialize(anApp, bAllTypes, recur, bDebug, bVBNet, nVersion); }
public Reverser(bool bAllTypes, Recursion recur, bool bDebug, bool bVBNet, int nVersion) { Application anApp = new ApplicationClass(); anApp.Locked = true; this.Initialize(anApp, bAllTypes, recur, bDebug, bVBNet, nVersion); }