public void NextWeapon() { if (currentWeaponIndex.Equals(availableWeapons.Last)) { currentWeaponIndex = availableWeapons.First; } else { currentWeaponIndex = currentWeaponIndex.Next; } RenderCurrentWeapon(); }
private void UndoPerson() { if (CurrentNode.Equals(PersonList.First)) { Console.WriteLine(); Console.WriteLine("It is the first modification. Press any key to continue"); Console.ReadKey(); } else { CurrentNode = CurrentNode.Previous; } }
public bool RemoveCustomerFromContract(int customerID, int contractID) { LinkedListNode <Customer> customerTemp = _customersList.First; LinkedListNode <Contract> contractTemp = _contractList.First; while (!customerTemp.Equals(null)) { if (customerTemp.Value.getID() == customerID) { break; } else { customerTemp = customerTemp.Next; } } if (customerTemp.Equals(null)) { Console.WriteLine("Customer with that ID not found"); return(false); } if (customerTemp.Value.getOnContractFlag() == false) { Console.WriteLine("Customer with that ID is not on a contract"); return(false); } while (!contractTemp.Equals(null)) { if (contractTemp.Value.getID() == contractID) { break; } else { contractTemp = contractTemp.Next; } } if (contractTemp.Equals(null)) { Console.WriteLine("Contract with that ID not found"); return(false); } if (contractTemp.Value.GetCustomerID() != customerID) { Console.WriteLine("Contract's customerID does not match the one we are trying to remove"); return(false); } customerTemp.Value.setOnContractFlag(false); contractTemp.Value.SetCustomer(null); return(true); }
public void remove_all_link_animations() { while (FirstCyclic != null && FirstCyclic.Previous != null) { if (CurrAnim.Equals(FirstCyclic.Previous)) { CurrAnim = FirstCyclic; if (CurrAnim != null) { FrameNumber = CurrAnim.Value.get_starting_frame(); } } AnimList.Remove(FirstCyclic.Previous); } }
public static LinkedList <string> RealWorldExample1(IList <string> pagesToNavigate) { //Init var highScorePages = new LinkedList <string>(); string baseUrl = "https://football.ua/"; IWebDriver webDriver = WebDriverInitialization.Instance.Driver; //Act //Navigate pages and receive goals pagesToNavigate.ToList().ForEach(page => { webDriver.Navigate().GoToUrl(baseUrl + page); highScorePages.AddLast(baseUrl + page); } ); Dictionary <string, int> scorePerPage = PagesDbEmulator.GetScorePerPage(); LinkedListNode <string> node = highScorePages.First; while (!node.Equals(null)) { int score = scorePerPage[node.Value]; if (score < 11) { highScorePages.Remove(node); } node = node.Next; } return(highScorePages); }
private void CleanTail(LinkedListNode <Person> currentNode) { LinkedListNode <Person> node = PersonList.Last; while (!node.Equals(currentNode)) { node = node.Previous; PersonList.RemoveLast(); } }
// Recursively check each row in the position from the bottom up until an available one is found, and return that private LinkedListNode <Token[]> AddWrapper(int position, ref LinkedListNode <Token[]> row, int pColor) { LinkedListNode <Token[]> next = row.Next; if (row.Equals(row.List.First)) { return(AddWrapper(position, ref next, pColor)); } else if (row.Equals(row.List.Last)) { return(null); } else if (row.Value[position].GetColor() != 0) { return(AddWrapper(position, ref next, pColor)); } else { return(row); } }
public void ChangePerson() { Person person = EnterPerson(); Console.Write("Person: "); person.Display(); PersonList.AddAfter(CurrentNode, person); CurrentNode = CurrentNode.Next; if (!CurrentNode.Equals(PersonList.Last)) { CleanTail(CurrentNode); } }
/** * Returns a list of Directions. The angle of the first direction is always zero, because if there is no * previous point or node passed in, the robot assumes that it is starting off facing the * correct direction. * * @param scale The coordinates/unit of measurement as determined by the map. * @return A LinkedList of Direction objects specifying the correct order of direction. */ public LinkedList <Direction> getListOfDirections(double scale) { LinkedList <Direction> listOfDirections = new LinkedList <Direction>(); Node previousNode = null; LinkedListNode <Node> currentLinkedListNode = listOfNodes.First; while (!currentLinkedListNode.Equals(listOfNodes.Last)) { LinkedListNode <Node> nextLinkedListNode = currentLinkedListNode.Next; Node currentNode = currentLinkedListNode.Value; Node nextNode = nextLinkedListNode.Value; listOfDirections.AddLast(new Direction(previousNode, currentNode, nextNode, scale)); previousNode = currentNode; currentLinkedListNode = nextLinkedListNode; } return(listOfDirections); }
/// <summary> /// Создание нового объекта возможно только после того как созданы узлы вершин /// </summary> /// <param name="tg"></param> /// <param name="edgeNum"></param> public EdgeGraphNode(TriangleGraph tg, short edgeNum, Point2d pt) { if (edgeNum > 2 || edgeNum < 0) { throw new ArgumentException(nameof(edgeNum)); } if (!tg.vertexNodes.All(n => n != null)) { throw new ArgumentException(nameof(tg)); } TriangleGraph = tg; EdgeNum = edgeNum; //Расчитать параметр для этого узла Parameter = (pt - tg.vert2dLocs[edgeNum]).Length / tg.edgesLength[edgeNum]; //Добавить узел в нужное место в графе, заполнить свойство LinkedListNode LinkedListNode <GraphNode> lln = tg.vertexNodes[edgeNum]; do { lln = lln.Next != null ? lln.Next : lln.List.First; EdgeGraphNode edgeNode = lln.Value as EdgeGraphNode; if (edgeNode != null && edgeNode.Parameter > Parameter) { //Если обнаружен узел с большим параметром, то выход из цикла break; } } while (!(lln.Value is VertexGraphNode)); if (!lln.Equals(tg.vertexNodes[0])) { LinkedListNode = tg.graphNodes.AddBefore(lln, this); } else//????На первом месте в списке всегда должна быть первая вершина. Перед ней ничего не вставляется. Вместо этого в конец списка { LinkedListNode = tg.graphNodes.AddLast(this); } }
// time complexity: O(n^2) // space complexity: O(1) public static LinkedList <int> RemoveDups2(LinkedList <int> lnkUnsorted) { LinkedListNode <int> node = lnkUnsorted.First; while (node != null) { LinkedListNode <int> node2 = lnkUnsorted.First; while (node2 != null) { if (node2.Value == node.Value && !node2.Equals(node)) { lnkUnsorted.Remove(node2); } node2 = node2.Next; } node = node.Next; } return(lnkUnsorted); }
public static LinkedListNode <int> GetIntersectionNode(LinkedList <int> linkedList1, LinkedList <int> linkedList2) { if (linkedList1 == null || linkedList2 == null) { return(null); } LinkedList <int> shortLinkedList; LinkedList <int> longLinkedList; if (linkedList1.Count > linkedList2.Count) { shortLinkedList = linkedList2; longLinkedList = linkedList1; } else { shortLinkedList = linkedList1; longLinkedList = linkedList2; } LinkedListNode <int> shortLinkedListHead = shortLinkedList.First; LinkedListNode <int> longLinkedListHead = longLinkedList.First; for (int i = 0; i < longLinkedList.Count - shortLinkedList.Count; i++) { longLinkedListHead = longLinkedListHead.Next; } while (shortLinkedListHead.Next != null) { if (shortLinkedListHead.Equals(longLinkedListHead)) { return(shortLinkedListHead); } shortLinkedListHead = shortLinkedListHead.Next; longLinkedListHead = longLinkedListHead.Next; } return(null); }
private void DoDelete(LinkedListNode <FileSystemModelEntry> node) { if (node == null) { return; } if (_lastVisibleNode != null && _lastVisibleNode.Equals(node)) { _lastVisibleNode = _lastVisibleNode.Previous; } if (node.Value.Visible) { node.Value.Visible = false; _visibleEntriesCount--; Debug.Assert(_visibleEntriesCount >= 0); } _entries.Remove(node); }
public void invokeCommand(Command c) { if (commands.Count == 0 || currentCommand.Equals(dummyFirst)) { commands.Clear(); commands.AddLast(c); currentCommand = commands.First; } else { while (!currentCommand.Equals(commands.Last)) { commands.RemoveLast(); } commands.AddAfter(currentCommand, c); currentCommand = currentCommand.Next; } currentCommand.Value.execute(); }
public bool is_first_cyclic() { return(CurrAnim == null || CurrAnim.Equals(FirstCyclic)); }
public static int MaxProfitWithKTransactions(int[] prices, int k) { LinkedList <int[]> trends = new LinkedList <int[]>(); int tempstart = 0; int tempend = 0; trends.AddFirst(new int[] { 0, 0, 0, 0 }); LinkedListNode <int[]> current = trends.Last; for (int i = 1; i < prices.Length; i++) { current = trends.Last; if (prices[i] > prices[i - 1]) { tempend = i; current.Value = new int[] { tempstart, tempend, prices[tempstart], prices[tempend] }; } else { if (i != prices.Length - 1) { trends.AddLast(new int[] { tempstart, tempend, prices[tempstart], prices[tempend] }); } tempstart = i; tempend = i; } } //TRENDS is the initial trends case, there are no limits for how many increases there are. //Now we implement a way of merging or removing the transactions with minimal loss. int profit = 0; if (k >= trends.Count) //no minimizing necessary //calculate profit full { foreach (int[] data in trends) { profit += (data[3] - data[2]); //profit adds finish - initial } } LinkedList <int[]> merging = trends; for (int i = trends.Count; i > k; i -= 1) //removal / merge { LinkedListNode <int[]> lowestcausenode = trends.First; //Just a node. int lowestcause = 10000; LinkedListNode <int[]> currentnode = trends.First; bool finalremoval = false; bool first = true; for (int index = 0; index < trends.Count; index++) { int cause = 0; bool isremoval = false; int[] data = currentnode.Value; if (currentnode.Equals(trends.First) || currentnode.Equals(trends.Last)) { if (currentnode.Equals(trends.First)) //.. { lowestcause = data[3] - data[2]; //this is just to set the lowestcause as a base!!! } //.. cause = data[3] - data[2]; isremoval = true; } else //MERGE the current into the next and find the cause (PROFIT 1 + PROFIT 2) - (2LAST - 1START) { int[] next = currentnode.Next.Value; int tprofit = (data[3] - data[2]) + (next[3] - next[2]); int tnewprofit = (next[3] - data[2]); cause = tprofit - tnewprofit; } if (currentnode.Equals(trends.First)) { int[] next = currentnode.Next.Value; int tprofit = (data[3] - data[2]) + (next[3] - next[2]); int tnewprofit = (next[3] - data[2]); if (tprofit - tnewprofit < cause) { cause = tprofit - tnewprofit; } } if (first) { first = false; lowestcause = cause; lowestcausenode = currentnode; finalremoval = isremoval; } if (cause < lowestcause) { lowestcause = cause; lowestcausenode = currentnode; finalremoval = isremoval; } currentnode = currentnode.Next; if (currentnode == null) { break; } } if (finalremoval) { merging.Remove(currentnode); } else { int[] currentdata = lowestcausenode.Value; int[] nextdata = lowestcausenode.Next.Value; merging.Remove(lowestcausenode.Next); lowestcausenode.Value = new int[] { currentdata[0], nextdata[1], currentdata[2], nextdata[3] }; } //merging / removal complete foreach (int[] data in merging) { profit += (data[3] - data[2]); //profit adds finish - initial } } return(profit); }
/// <summary> /// Calculates the shortest path between the airplane and the point through which it has to leave the airspace. /// </summary> /// <param name="points">All the checkpoints in the airspace. No airstrips, no airplanes.</param> /// <param name="exitCheckpoint">The checkpoint through which the plane has to leave the airspace.</param> public void CalculateShortestPathLeavingAirspace(List <Checkpoint> points) { this.ReachableNodes.Clear(); this.ShortestPath.Clear(); foreach (Checkpoint point in points) { if (target == null && point.ParentCellType == CellType.FINAL) { this.AddSingleDestination(point, CalculateTimeBetweenPoints(point)); } else if (target != null && target.Equals(ShortestPath.Last) ) //if this doesn't work: ((Checkpoint)target.Value).ParentCellType == Cell.BORDER { ShortestPath.Clear(); ShortestPath.AddFirst(target); return; } else if (target != null && point.ParentCellType == ((Checkpoint)target.Value).ParentCellType) { this.AddSingleDestination(point, CalculateTimeBetweenPoints(point)); } point.ShortestPath.Clear(); point.DistanceFromSource = int.MaxValue; } exitDestination.DistanceFromSource = int.MaxValue; exitDestination.ShortestPath.Clear(); HashSet <AbstractCheckpoint> settledCheckpoints = new HashSet <AbstractCheckpoint>(); HashSet <AbstractCheckpoint> unsettledCheckpoints = new HashSet <AbstractCheckpoint> { this }; while (unsettledCheckpoints.Count != 0) { AbstractCheckpoint currentCheckpnt = this.GetLowestDistanceNode(unsettledCheckpoints); unsettledCheckpoints.Remove(currentCheckpnt); foreach (var pair in currentCheckpnt.ReachableNodes) { AbstractCheckpoint reachableCheckpoint = pair.Key; double edgeWeight = pair.Value; if (!settledCheckpoints.Contains(reachableCheckpoint)) { var shortestPath = CalculateMinDistance(reachableCheckpoint, edgeWeight, currentCheckpnt); if (shortestPath != null && reachableCheckpoint.GetType() == typeof(Checkpoint) && ((Checkpoint)reachableCheckpoint).ParentCellType == CellType.BORDER) { shortestPath.AddLast(reachableCheckpoint); this.ShortestPath = new LinkedList <AbstractCheckpoint>(); var pathNode = shortestPath.First; while (pathNode != null) { this.ShortestPath.AddLast(pathNode.Value); pathNode = pathNode.Next; } } unsettledCheckpoints.Add(reachableCheckpoint); } } settledCheckpoints.Add(currentCheckpnt); } if (this.ShortestPath.Count != 0) { movingDirectionHasChanged = true; target = ShortestPath.First; target = target.Next; } }
private bool Overlap(LinkedListNode<ShiftABGameObject> node, LinkedListNode<ShiftABGameObject> otherNode, int patternSize) { for (int i = 0; i < patternSize; i++) { if(node == null) break; if(node.Equals(otherNode)) return true; node = node.Next; } return false; }