C# LinkedList.Where方法代码示例

 /// <summary>
 /// Initializes a new instance of the PlayerStats class.
 /// </summary>
 public PlayerStats(LinkedList<Turn> turns, Player player)
 {
     Handicap = player.Handicap;
     _playerId = player.Id;
     _turns = turns;
     _playerTurns = _turns.Where(t => t.PlayerId == _playerId);
 }

        public void Where_ICollection_ExecutionIsDeferred()
        {
            bool funcCalled = false;
            ICollection<Func<bool>> source = new LinkedList<Func<bool>>(new List<Func<bool>>() { () => { funcCalled = true; return true; } });

            IEnumerable<Func<bool>> query = source.Where(value => value());
            Assert.False(funcCalled);

            query = source.Where((value, index) => value());
            Assert.False(funcCalled);
        }

 public static void Run()
 {
     using (FastScanner fs = new FastScanner(new BufferedStream(Console.OpenStandardInput())))
     using (StreamWriter writer = new StreamWriter(new BufferedStream(Console.OpenStandardOutput())))
     {
         int n = fs.NextInt();
         LinkedList<int>[] adjList = new LinkedList<int>[n];
         int[] p = new int[n];
         for (int i = 0; i < n; i++)
         {
             adjList[i] = new LinkedList<int>();
         }
         for (int u = 0; u < n; u++)
         {
             int v = fs.NextInt() - 1;
             p[u] = v;
             adjList[u].AddLast(v);
             if (u != v) adjList[v].AddLast(u);
         }
         LinkedList<int> comps = new LinkedList<int>();
         bool[] visited = new bool[n];
         for (int u = 0; u < n; u++)
         {
             if (!visited[u]) 
             {
                 int r = -1;
                 DoDfs(u, adjList, visited, p, -1, ref r);
                 comps.AddLast(r);
             }
         }
         int k = comps.Count - 1;
         int root = comps.Where(u => u == p[u]).DefaultIfEmpty(-1).First();
         if (root == -1) 
         {
             root = comps.First();
             p[root] = root;
             k++;
         }
         foreach (int u in comps)
         {
             if (u != root) p[u] = root;
         }
         writer.WriteLine(k);
         for (int i = 0; i < n; i++)
         {
             writer.Write(p[i] + 1 + " ");
         }
     }
 }

        protected IEnumerable<Event> GetEvents(FunenAddressExtractor extractor)
        {
            if (_report.Uri == "/Fyn/da/lokalnyt/Doegnrapporter/Uddrag+af+døgnrapporten+for+tirsdag+den+11.+maj+2010.htm")
            {
                // this is a duplicate
                yield break;
            }

            var span = _document.Value.DocumentNode.SelectSingleNode(
                "//span[@id='Articlewithindexpagecontrol_XMLliste1']/span");

            var ns = (span.SelectNodes("p[@class='MsoNormal']") ?? Enumerable.Empty<HtmlNode>()).
                Concat((span.SelectNodes("span") ?? Enumerable.Empty<HtmlNode>()));

            if (ns == null || ns.Count() == 0)
            {
                // this is for East Jutland, which uses more or less the same code
                ns = span.SelectNodes("p");
            }

            if (ns == null || ns.Count() == 0)
            {
                yield break;
            }

            ns = ns.Where(n => n.InnerText.Contains("Sket: "));

            foreach (var n in ns)
            {
                var texters = new LinkedList<HtmlNode>(
                    n.DescendantNodes().Where(_ => _.Name.ToLower() == "#text" &&
                        !string.IsNullOrEmpty(_.InnerText.Trim())));

                IEnumerable<HtmlNode> addressnodes = null;
                try
                {
                    addressnodes = extractor.GetAddressNodes(texters);

                    if (addressnodes == null || addressnodes.Count() != 1)
                        continue;
                }
                catch (Exception e)
                {
                    continue;
                }

                var addressnodell = texters.Find(addressnodes.Single());
                if (addressnodell.Previous == null)
                {
                    // no title
                    continue;
                }
                var titlenode = texters.Find(addressnodes.Single()).Previous.Value.InnerText;

                var timenodes = texters.Where(_ => _.InnerText.Trim().StartsWith("Sket: "));

                if (timenodes.Count() > 1)
                {
                    continue;
                }

                var timenode = timenodes.Single();
                string body = null;
                if (texters.Find(timenode).Next != null)
                {
                    body = texters.Find(timenode).Next.Value.InnerText;
                }
                else
                {
                    // no body, too bad
                }
                var addressminuspostcode = extractor.GetAddressNodesMinusPostcode(addressnodes);

                var splits = extractor.SplitAddress(addressminuspostcode);
                var placestring = splits.First();

                string street = null;
                if (splits.Count() > 1)
                {
                    street = splits.Skip(1).Aggregate((a, b) => a + " - " + b);
                }

                var timestring = timenode.InnerText.Replace("Sket: ", "").
                    Split(new string[] { " - " }, StringSplitOptions.RemoveEmptyEntries).
                    First().Trim()
                    .ToLower()
                    .Split(new [] { "til" }, StringSplitOptions.RemoveEmptyEntries)
                    .First().Trim();

                DateTime? time = null;
                try
                {
                    time = DateTime.ParseExact(timestring, "dd/MM/yyyy HH:mm",
                        CultureInfo.InvariantCulture);
                    if (time.Value.Year < 1991)
                    {
                        continue;
                    }
                }
                catch(Exception e)
//.........这里部分代码省略.........

        private int[] FindBestSequence()
        {
            var states = new LinkedList<ActivityState>(values.Select(
                x => new ActivityState(x, E, 0)));

            while (true)
            {
                var biggestUnset = states
                    .Where(x => x.AllocatedEnergy < x.AvailableEnergy)
                    .OrderByDescending(x => x.Value)
                    .FirstOrDefault();

                if (biggestUnset == null) break;

                // take the max we can
                biggestUnset.AllocatedEnergy = biggestUnset.AvailableEnergy;

                // propagate the change
                var node = states.Find(biggestUnset);
                PropagateConstrainBackward(node);
                PropagateConstrainForward(node);
            }

            Debug.Assert(states.All(x=>x.AllocatedEnergy == x.AvailableEnergy));

            return states.Select(x => x.AllocatedEnergy).ToArray();
        }

			/// <summary> Adds an edge to the edge list and recalculates edge collection. </summary>
			/// <param name="rect"> The rectangle. </param>
			private void AddEdgeToCollection(Rect rect)
			{
				_linkedList.AddLast(rect);
				if (_edgeItemList == null)
				{
					_edgeItemList = new List<EdgeItem>();
					_edgeItemList.Add(new EdgeItem(_areaLimit1, _areaLimit2, _minAreaLevel, _areaLimit1, _areaLimit2));
				}
				_edgeItemList.Add(_transposed ? new EdgeItem(rect.Top, rect.Bottom, rect.Right, _areaLimit1, _areaLimit2) : new EdgeItem(rect.Left, rect.Right, rect.Bottom, _areaLimit1, _areaLimit2));
				_edgeItemList = _edgeItemList.AsEnumerable().OrderBy(r => r.Level).ToList();

				// adjust item sizes if overlapped by item with greater edge, removing items that are too small or completely overlapped
				_edgeItemCollection = new LinkedList<EdgeItem>(_edgeItemList);
				LinkedListNode<EdgeItem> index = _edgeItemCollection.First;
				while (index != null)
				{
					if (CheckForOverlap(index, _edgeItemList) == CompareActions.Delete)
					{
						_edgeItemList.Remove(index.Value);
					}
					index = index.Next;
				}

				// calculate extents of each edge
				_edgeItemCollection = new LinkedList<EdgeItem>(_edgeItemList);
				index = _edgeItemCollection.First;
				while (index != null)
				{
					GetExpandedEdgeItem(index);
					index = index.Next;
				}

				// level off close edges
				index = _edgeItemCollection.First;
				while ((index != null)/* && (index.Next != null)*/)
				{
					List<EdgeItem> closeItems = _edgeItemCollection.Where(edge => index.Value.CanBeMerged(edge, AlignLimit, AlignOnLesserEdge)).ToList();
					foreach (var closeItem in closeItems)
					{
						closeItem.Level = index.Value.Level;
						closeItem.EdgeLimit1 = _areaLimit1;
						closeItem.EdgeLimit2 = _areaLimit2;
						var closeIndex = index.List.Find(closeItem);
						GetExpandedEdgeItem(closeIndex);
					}
					index = index.Next;
				}
			}

 public virtual IEnumerable<HtmlNode> GetAddressNodes(LinkedList<HtmlNode> nodes)
 {
     int postcode = 0;
     return nodes.Where(_ => int.TryParse(_.InnerText.Split(' ').First(), out postcode) &&
             postcode > 999);
 }

        public static int PullItems()
        {
            var list = new LinkedList<ElmahErrorItem>();

            XDocument xdoc = XDocument.Load(ConfigManager.Config.RssUrl);

            dynamic rss = xdoc.Root.ToDynamic();

            dynamic[] items = rss.channel["item"];

            foreach (dynamic item in items)
            {
                string pubDate = item.pubDate;

                list.AddLast(new ElmahErrorItem
                                 {
                                     Title = item.title,
                                     Description = item.description,
                                     PubDate =
                                         DateTime.ParseExact(pubDate, "r", CultureInfo.InvariantCulture,
                                                             DateTimeStyles.AssumeUniversal),
                                     Link = item.link
                                 });
            }

            var newList = (LatestItem != null
                ? list.Where(i => i.PubDate >= LatestItem.PubDate && i.Link != LatestItem.Link)
                : list)
                .ToArray();

            if (newList.Length > 0)
            {
                var latestItems = newList.Concat(LatestItems)
                    .Take(30).ToList();

                for (int i = 0; i < latestItems.Count; i++)
                {
                    latestItems[i].Number = i + 1;
                }

                LatestItems = latestItems;

                LatestItem = LatestItems.First();

                SaveLatestItemToTheDisk();
            }

            return newList.Length;
        }

        /// <summary>
        /// Converts t attribute to transforms.
        /// </summary>
        /// <param name="f">the field</param>
        public void ExpandShortHandTransforms(TflField f) {

            var list = new LinkedList<TflTransform>();
            var lastTransform = new TflTransform();
            var methods = f.T == string.Empty ? new String[0] : Common.Split(f.T, ").").Where(t => !string.IsNullOrEmpty(t));

            foreach (var method in methods) {
                // translate previous copy to parameters, making them compatible with verbose xml transforms
                if (lastTransform.Method == "copy") {
                    var tempParameter = lastTransform.Parameter;
                    var tempParameters = lastTransform.Parameters;
                    var transform = lastTransform = Interpret(method, f, lastTransform);
                    transform.Parameter = tempParameter;
                    transform.Parameters = tempParameters;
                    list.RemoveLast(); //remove previous copy
                    list.AddLast(transform);
                } else {
                    lastTransform = Interpret(method, f, lastTransform);
                    list.AddLast(lastTransform);
                }
            }

            foreach (var transform in f.Transforms) {
                // expand shorthand transforms
                if (transform.Method.Equals("t") || transform.Method.Equals("shorthand")) {
                    var tempField = new TflField { T = transform.T };
                    ExpandShortHandTransforms(tempField);
                    foreach (var t in tempField.Transforms) {
                        list.AddLast(t);
                    }
                } else {
                    list.AddLast(transform);
                }
            }

            f.Transforms = list.Where(t => t.Method != "guard").ToList();
        }

        public void Where_IEnumerable_ReturnsExpectedValues_Complex()
        {
            IEnumerable<int> source = new LinkedList<int>(new List<int> { 2, 1, 3, 5, 4 });
            Func<int, int, bool> complexPredicate = (value, index) => { return (value == index); };

            IEnumerable<int> result = source.Where(complexPredicate);

            Assert.Equal(2, result.Count());
            Assert.Equal(1, result.ElementAt(0));
            Assert.Equal(4, result.ElementAt(1));
        }

        private int[] FindBestSequence()
        {
            var states = new LinkedList<ActivityState>(values.Select(
                x => new ActivityState(x, E)));

            while (true)
            {
                var current = states
                    .Where(x => x.AllocatedEnergy == null)
                    .OrderByDescending(x => x.Value)
                    .FirstOrDefault();

                if (current == null) break;

                Debug.Assert(current.EnergyBefore >= 0);
                Debug.Assert(current.EnergyBefore <= E);
                Debug.Assert(current.EnergyAfter >= 0);
                Debug.Assert(current.EnergyAfter <= E);
                Debug.Assert(current.EnergyAfter <= current.EnergyBefore);

                // take the max we can
                current.AllocatedEnergy = current.EnergyBefore - current.EnergyAfter;

                // propagate the change
                var node = states.Find(current);
                PropagateForward(node, current.EnergyAfter + R);
                PropagateBackward(node, current.EnergyBefore - R);
            }

            return states.Select(x => x.AllocatedEnergy.Value).ToArray();
        }

        private void RebuildEquation(Component2 component)
        {
            ModelDoc2 model = component.IGetModelDoc();
            if (model != null && model.GetConfigurationCount() > 1 &&
                                            model.GetEquationMgr().GetCount() > 0)
            {
                var compList = new LinkedList<Component2>();
                if (GetComponents(component, compList, true, false))
                {
                    foreach (var component2 in compList)
                    {
                        int eqCount = model.GetEquationMgr().GetCount();
                        for (int i = 0; i <= eqCount; i++)
                        {
                            var name = component2.Name;
                            string eq = model.GetEquationMgr().get_Equation(i);
                            if (eq.Contains(Path.GetFileNameWithoutExtension(component2.GetPathName())))
                            {
                                if (component2.IsSuppressed())
                                {
                                    name = component2.Name;
                                    if (compList.Where(x =>
                                                       x.GetPathName() ==
                                                       component2.GetPathName() &&
                                                       x.IsSuppressed() == false).Count() >
                                        0)
                                        model.GetEquationMgr().Suppression[i] = false;
                                    else
                                        model.GetEquationMgr().Suppression[i] = true;
                                }
                                else
                                    model.GetEquationMgr().Suppression[i] = false;
                            }
                            else
                            {
                                string fn = Path.GetFileNameWithoutExtension(component2.GetPathName());

                                if (Properties.Settings.Default.CashModeOn && fn.Length > 5 && eq.Length > 5 && fn.ToUpper().Last() == 'P' && eq.Contains(fn.Substring(0, fn.Length - 4)))
                                {
                                    //�������� ��� ���������
                                    string orig = fn.Substring(0, fn.Length - 4);
                                    string whatToReplace = eq.Substring(eq.IndexOf(orig) + orig.Length, 4);
                                    string replaceWith = fn.Substring(fn.Length - 4, 4);
                                    string newEq = eq.Replace(whatToReplace, replaceWith);
                                    model.GetEquationMgr().set_Equation(i, newEq);
                                }
                            }
                        }
                        if (model.GetType() == (int)swDocumentTypes_e.swDocASSEMBLY)
                            RebuildEquation(component2);
                    }
                }
                model.ForceRebuild3(true);
            }
        }

        public List<PlanStep> GetBasePlan(IEnumerable<Resource> resources, IEnumerable<Job> jobs, IEnumerable<double[]> dependencyValues)
        {
            //Initialization
            var dataContainer = new SchedulingDataContainer(resources, jobs, dependencyValues);
            var plan = new List<PlanStep>();
            var unfinishedJobs = new LinkedList<Job>(dataContainer.Jobs);
            var resArr = resources.ToArray();

            var resourcesForStep = new Resource[resArr.Length];
            int stepNumber = 1;
            //Repeat while we have unfinished jobs
            while (unfinishedJobs.Count> 0)
            {
                //Set up resources per step
                for (int r = 0; r < resArr.Length; r++) resourcesForStep[r] = resArr[r].DeepCopy();

                //Select jobs we can plan
                var jobsPossibleToExecute = unfinishedJobs.Where(j => j.CanStart()).ToList();
                //Put to heap with greed comparer
                var jobHeap = new Heap<Job>(jobsPossibleToExecute, jobsPossibleToExecute.Count(), new JobGreedyComparer());
                var jobsForStep = new List<RunningJob>();
                do
                {
                    //Take first
                    var jobToExecute = jobHeap.PopRoot();
                    //Check we can plan it
                    //and compute intensity
                    var maxIntensity = CalcMaxPossibleIntensity(jobToExecute, resourcesForStep);
                    if (maxIntensity > 0)
                    {
                        //Start job
                        jobToExecute.State = JobState.Started;
                        //calc spended resources, remaining resources and time
                        foreach (var resource in resourcesForStep)
                        {
                            var jobResourceDependency = jobToExecute.ResourceDependencies.FirstOrDefault(d => d.Resource.Number == resource.Number);
                            if (jobResourceDependency != null)
                                resource.Value -= jobResourceDependency.Value*maxIntensity;
                        }

                        var time = jobToExecute.RemainingVolume/maxIntensity;
                        jobsForStep.Add(new RunningJob(jobToExecute, maxIntensity, time,
                            plan.LastOrDefault()!=null?plan.LastOrDefault().TimeEnd:0));
                    }

                    //Repeat while we have some jobs
                    //TODO: Optimize, maybe we don't need to check all jobs
                } while (jobHeap.Count>0);

                var stepTime = jobsForStep.Min(j => j.RunTime);
                var startTime = (plan.Count > 0) ? plan.Last().TimeEnd : 0;
                //Create PlanStep at this moment
                var step = new PlanStep(jobsForStep, startTime, stepTime + startTime, stepNumber++);
                //Compute all jobs to finish
                foreach (var runningJob in jobsForStep)
                {
                    if (runningJob.RunTime.FloatEquals(stepTime))
                    {
                        runningJob.JobReference.State = JobState.Finished;
                        runningJob.JobReference.RemainingVolume = 0;
                        unfinishedJobs.Remove(runningJob.JobReference);
                    }
                    else
                    {
                        var completed = runningJob.Intencity*stepTime;
                        runningJob.JobReference.RemainingVolume -= completed;
                        runningJob.RunTime = step.TimeDelta;
                    }
                }

                //Memorize job progress
                plan.Add(step);
            }

            return plan;
        }

        public System.Collections.Generic.ICollection<GameObject> GetColliders(GameObject obj)
        {
            IList<GameObject> colliders = new LinkedList<GameObject>();

            // Get all possible colliders exept myself and bullets
            colliders.AddRange(collisionCuller.GetPossibleColliders(obj).Where(x => x != obj));

            // Add tiles collisions
            var tileColliders = Map.GetPossibleColliders(obj.GetHitRectangle());
            colliders.AddRange(tileColliders);

            // At last only return those who intersects
            return colliders.Where(x => x.GetHitRectangle().Intersects(obj.GetHitRectangle()) && (x.Blocks(obj) || obj.Blocks(x))).ToList();

        }

        static void Main(string[] args)
        {
            const string fileName = "B-small-attempt3";

            var input = File.ReadAllLines("../../" + fileName + ".in");
            var cases = new List<Case>();

            // read input
            int testCasesCount = int.Parse(input[0]);

            int lineIndex = 0;
            for (int i = 0; i < testCasesCount; ++i)
            {
                var c = new Case();
                c.CaseNumber = i + 1;

                c.N = int.Parse(input[++lineIndex]);

                var nodes = new LinkedList<Node>();
                for (int j = 0; j < c.N; ++j)
                {
                    var n = new Node();
                    n.Index = j + 1;
                    nodes.AddLast(n);
                }
                c.Nodes = nodes.Where(x => x.Index >0);

                for (int j = 0; j < c.N-1; ++j)
                {
                    int[] edge = input[++lineIndex].Split().Select(x => int.Parse(x)).ToArray();
                    var first = c.Nodes.First(x => x.Index == edge[0]);
                    var second = c.Nodes.First(x => x.Index == edge[1]);
                    first.Connections.AddLast(second);
                    second.Connections.AddLast(first);
                }

                cases.Add(c);
            }

            // process cases

            var output = new List<string>();

            foreach (var c in cases)
            {
                //possible root has 2 children (connections)
                var roots = c.Nodes.Where(x => x.Connections.Count == 2);

                int maxNodes = 1;
                foreach (var r in roots)
                {
                    var nodes = c.Nodes.ToList();
                    foreach (var n in nodes)
                    {
                        n.Parent = null;
                    }

                    int nodesCount = 1;

                    var root = nodes.First(x => x.Index == r.Index);

                    VisitChildren(root, ref nodesCount);

                    maxNodes = nodesCount > maxNodes ? nodesCount : maxNodes;
                    if (maxNodes == c.N)
                    {
                        break;
                    }
                }

                output.Add("Case #" + c.CaseNumber + ": " + (c.N - maxNodes));
            }

            File.WriteAllLines("../../" + fileName + ".out", output);
        }