C# Stack.ElementAt方法代码示例

        public void ElementAt()
        {
            var stack = new Stack();

            stack.Push(Integer256.Zero);
            stack.Push(Integer256.One);
            stack.Push(Integer256.Two);
            stack.Push(Integer256.Three);

            Assert.AreEqual(Integer256.Zero, stack.ElementAt(3));
            Assert.AreEqual(Integer256.One, stack.ElementAt(2));
            Assert.AreEqual(Integer256.Two, stack.ElementAt(1));
            Assert.AreEqual(Integer256.Three, stack.ElementAt(0));
        }

        /// <summary>
        /// Строит выпуклую оболочку по точкам.
        /// </summary>
        /// <param name="aXPoints">Координаты X.</param>
        /// <param name="aYPoints">Координаты Y.</param>
        /// <param name="aSideValue">Направление выпуклой оболочки (-1 или 1).</param>
        /// <returns>индексы седловых точек.</returns>
        public static int[] Build(double[] aXPoints, double[] aYPoints, int aSideValue)
        {
            CheckRegulations(aXPoints, aYPoints, aSideValue);

            var saddlePoints = new Stack<int>();
            var preLastPoint = 0;
            var lastPoint = 1;
            saddlePoints.Push(preLastPoint);
            saddlePoints.Push(lastPoint);

            var pointsCount = aXPoints.Length;
            for (var i = 2; i < pointsCount; ++i) {
                while (lastPoint != 0 &&
                       !IsSameDirection(aXPoints[preLastPoint],
                                        aYPoints[preLastPoint],
                                        aXPoints[i],
                                        aYPoints[i],
                                        aXPoints[lastPoint],
                                        aYPoints[lastPoint],
                                        aSideValue)) {
                    lastPoint = preLastPoint;
                    saddlePoints.Pop();
                    if (preLastPoint == 0) {
                        preLastPoint = -1;
                    }
                    else {
                        preLastPoint = saddlePoints.ElementAt(1);
                    }
                }

                preLastPoint = lastPoint;
                lastPoint = i;
                saddlePoints.Push(i);
            }

            return saddlePoints.Reverse().ToArray();
        }

 // Add multiple game pieces to the stack at this position.
 public void Add(Stack<TzaarPiece> somePieces)
 {
     for (int i = somePieces.Count - 1; i >= 0; i--)
         this.pieces.Push(somePieces.ElementAt(i));
 }

        private void button1_Click(object sender, EventArgs e)
        {
            if(!checkend)
            {
            card p1_drawcard,p2_drawcard;

            p1_drawcard = p1_deck.drawcard();
            p2_drawcard = p2_deck.drawcard();

            P1_txt.Text = p1_drawcard.getname();
            P2_txt.Text = p2_drawcard.getname();

            if (p1_drawcard.getval() != p2_drawcard.getval())
            {
                p1_drawagain.Text = "";
                p2_drawagain.Text = "";

                if (p1_drawcard.getval() > p2_drawcard.getval())
                {
                    p1_deck.pushcard(p1_drawcard);
                    p1_deck.pushcard(p2_drawcard);
                    maintxt.Text = "P1 Win this Match";

                }
                else
                {
                    p2_deck.pushcard(p1_drawcard);
                    p2_deck.pushcard(p2_drawcard);
                    maintxt.Text = "P2 Win this Match";

                }
            }
            else
            {
                int sameval = p1_drawcard.getval();
                if(sameval == 14)
                { sameval = 1; }

                p1_drawagain.Text = "P1 Draw Again";
                p2_drawagain.Text = "P2 Draw Again";

                Stack<card> p1_card_again = new Stack<card>(0);
                Stack<card> p2_card_again = new Stack<card>(0);

                if(p1_deck.getnumcard()<sameval)
                {
                    for (int i = 0; i < p1_deck.getnumcard(); i++)
                    {
                        p1_card_again.Push(p1_deck.drawcard());
                        p1_drawagain.Text += " "+p1_card_again.ElementAt(0).getname();
                    }
                }
                else
                {
                    for (int i = 0; i < sameval; i++)
                    {
                        p1_card_again.Push(p1_deck.drawcard());
                        p1_drawagain.Text += " " + p1_card_again.ElementAt(0).getname();
                    }
                }

                if (p2_deck.getnumcard() < sameval)
                {
                    for (int i = 0; i < p2_deck.getnumcard(); i++)
                    {
                        p2_card_again.Push(p2_deck.drawcard());
                        p2_drawagain.Text += " " + p2_card_again.ElementAt(0).getname();
                    }
                }
                else
                {
                    for (int i = 0; i < sameval; i++)
                    {
                        p2_card_again.Push(p2_deck.drawcard());
                        p2_drawagain.Text += " " + p2_card_again.ElementAt(0).getname();
                    }
                }

                if (p1_card_again.ElementAt(p1_card_again.Count-1).getval() > p2_card_again.ElementAt(p2_card_again.Count - 1).getval())
                {
                    int p1_again_size = p1_card_again.Count;
                    int p2_again_size = p2_card_again.Count;

                    for (int i = 0; i < p1_again_size; i++)
                    {
                        p1_deck.pushcard(p1_card_again.Pop());
                    }

                    for (int i = 0; i < p2_again_size; i++)
                    {
                        p1_deck.pushcard(p2_card_again.Pop());
                    }

                    p1_deck.pushcard(p1_drawcard);
                    p1_deck.pushcard(p2_drawcard);
                    maintxt.Text = "P1 Win this Match";

                }
                else if (p1_card_again.ElementAt(p1_card_again.Count - 1).getval() < p2_card_again.ElementAt(p2_card_again.Count - 1).getval())
                {
//.........这里部分代码省略.........

//.........这里部分代码省略.........
                        map[top.X + x, top.Y] = false;
                        continue;
                    }

                    if (map[top.X, top.Y + y])
                    {
                        way.Push(new Point(top.X, top.Y + y));
                        map[top.X, top.Y + y] = false;
                        continue;
                    }

                    way.Pop();
                }
                else
                {
                    if (map[top.X, top.Y + y])
                    {
                        way.Push(new Point(top.X, top.Y + y));
                        map[top.X, top.Y + y] = false;
                        continue;
                    }
                    if (map[top.X + x, top.Y])
                    {
                        way.Push(new Point(top.X + x, top.Y));
                        map[top.X + x, top.Y] = false;
                        continue;
                    }

                    x *= -1;
                    y *= -1;

                    if (map[top.X, top.Y + y])
                    {
                        way.Push(new Point(top.X, top.Y + y));
                        map[top.X, top.Y + y] = false;
                        continue;
                    }
                    if (map[top.X + x, top.Y])
                    {
                        way.Push(new Point(top.X + x, top.Y));
                        map[top.X + x, top.Y] = false;
                        continue;
                    }

                    way.Pop();
                }
            }//end for

            if (found && !food_eaten)
            {

                Point next = way.ElementAt<Point>(way.Count - 2);

                int x = next.X - AIHead.X;
                int y = next.Y - AIHead.Y;

                if (x == 0)
                {
                    if (y > 0)
                    {
                        AI.turn(Direction.Down);
                    }
                    else
                    {
                        AI.turn(Direction.Up);
                    }
                }
                else if (y == 0)
                {
                    if (x > 0)
                    {
                        AI.turn(Direction.Right);
                    }
                    else
                    {
                        AI.turn(Direction.Left);
                    }
                }
            }
            else
            {
                //实际上这里是最初版本的AI移动代码
                if (contains[AIHead.X - 1, AIHead.Y] == Contain.empty || contains[AIHead.X - 1, AIHead.Y] == Contain.food)
                {
                    AI.turn(Direction.Left);
                }
                else if (contains[AIHead.X + 1, AIHead.Y] == Contain.empty || contains[AIHead.X + 1, AIHead.Y] == Contain.food)
                {
                    AI.turn(Direction.Right);
                }
                else if (contains[AIHead.X, AIHead.Y - 1] == Contain.empty || contains[AIHead.X - 1, AIHead.Y - 1] == Contain.food)
                {
                    AI.turn(Direction.Up);
                }
                else if (contains[AIHead.X, AIHead.Y + 1] == Contain.empty || contains[AIHead.X - 1, AIHead.Y + 1] == Contain.food)
                {
                    AI.turn(Direction.Down);
                }
            }
        }

        public List<TopoModel> SplitIntoSurfaces()
        {
            CountShells();
            foreach (TopoTriangle tri in triangles)
                tri.algHelper = tri.shell;

            List<TopoModel> models = new List<TopoModel>();
            Dictionary<int, TopoModel> modelMap = new Dictionary<int, TopoModel>();
            foreach (TopoTriangle tri in triangles)
            {
                int shell = tri.algHelper;
                if (modelMap.ContainsKey(shell))
                {
                    RHVector3 v1 = tri.vertices[0].pos;
                    RHVector3 v2 = tri.vertices[1].pos;
                    RHVector3 v3 = tri.vertices[2].pos;
                    RHVector3 n = tri.normal;
                    modelMap[shell].addTriangle(v1.x, v1.y, v1.z, v2.x, v2.y, v2.z, v3.x, v3.y, v3.z, n.x, n.y, n.z);
                }
                else
                {
                    List<TopoTriangleDistance> intersections = new List<TopoTriangleDistance>();
                    RHVector3 lineStart = tri.Center;
                    RHVector3 lineDirection = tri.normal;
                    double delta;
                    foreach (TopoTriangle test in triangles)
                    {
                        if(test.IntersectsLine(lineStart, lineDirection, out delta))
                        {
                            intersections.Add(new TopoTriangleDistance(delta,test));
                        }
                    }
                    intersections.Sort();
                    Stack<TopoTriangleDistance> tdStack = new Stack<TopoTriangleDistance>();
                    foreach (TopoTriangleDistance td in intersections)
                    {
                        if (td.triangle == tri)
                        {
                            TopoModel m = null;
                            if ((tdStack.Count & 2) == 0)
                            {
                                m = new TopoModel();
                                models.Add(m);
                                modelMap.Add(shell, m);
                            }
                            else
                            {
                                int trueShell = tdStack.ElementAt(tdStack.Count-1).triangle.algHelper;
                                foreach (TopoTriangle t in triangles)
                                {
                                    if (t.algHelper == shell)
                                        t.algHelper = trueShell;
                                }
                                if (modelMap.ContainsKey(trueShell))
                                    m = modelMap[trueShell];
                                else
                                {
                                    m = new TopoModel();
                                    models.Add(m);
                                    modelMap.Add(shell, m);
                                }
                            }
                            RHVector3 v1 = tri.vertices[0].pos;
                            RHVector3 v2 = tri.vertices[1].pos;
                            RHVector3 v3 = tri.vertices[2].pos;
                            RHVector3 n = tri.normal;
                            m.addTriangle(v1.x, v1.y, v1.z, v2.x, v2.y, v2.z, v3.x, v3.y, v3.z, n.x, n.y, n.z);
                            break;
                        }
                        else if (tdStack.Count > 0 && tdStack.Peek().triangle.algHelper == td.triangle.algHelper)
                        {
                            tdStack.Pop();
                        }
                        else
                        {
                            tdStack.Push(td);
                        }
                    }
                }
            }
            foreach (TopoModel m in models)
            {
                m.Analyse();
            }
            return models;
        }

        public void ValidRedoStatesAfterMultilevelUndo()
        {
            var correctRedoStates = new Stack<SensorState>();
            correctRedoStates.Push(new SensorState(_undoSensor, new DateTime(2011, 8, 12),
                                                       new Dictionary<DateTime, float> { { new DateTime(2011, 8, 12), 66.77f } }, null));
            correctRedoStates.Push(new SensorState(_undoSensor, new DateTime(2011, 8, 11),
                                            new Dictionary<DateTime, float> { { new DateTime(2011, 8, 12), 66.77f } }, null));

            _undoSensor.Undo(); // At least 1 item must be on undo stack (current state)

            Assert.AreEqual(correctRedoStates.ElementAt(1), _undoSensor.RedoStates[0]);
        }

 public string GetStackValue(Stack<char> s)
 {
     string tmp = "";
     for (int i = s.Count - 1; i >= 0; --i)
     {
         tmp += s.ElementAt(i);
     }
     return tmp;
 }

 private string Trans2Syn(string s)
 {
     JudgeChar jc = new JudgeChar();
     Stack<char> ts = new Stack<char> { };
     for (int i = 0; i < s.Length; ++i)
     {
         if (jc.isDigit(s[i]))
         {
             if (ts.Count == 0 || ts.Peek() != 'i')
             {
                 ts.Push('i');
             }
         }
         else
         {
             ts.Push(s[i]);
         }
     }
     string tmp = "";
     for (int i = ts.Count - 1; i >= 0;--i )
     {
         tmp += ts.ElementAt(i);
     }
     return tmp;
 }

 private string GetStackString(Stack<int> stack)
 {
     int result = 0;
     for (int i = 0; i < stack.Count; i++)
     {
         result += (int)(Math.Pow(10, i) * stack.ElementAt(i));
     }
     return result.ToString();
 }

 public bool CanStackRule(Stack<char> s)
 {
     if (s.Count >= 3)
     {
         int k = 0;
         string tmp = "";
         for (int i = 0; k < 3; ++i,++k)
         {
             tmp += s.ElementAt(i);
         }
         if (word.Contains(tmp))
         {
             return true;
         }
     }
     return false;
 }

 private string StackContent(Stack<int> stack)
 {
     string res = string.Empty;
     for (int i = stack.Count - 1; i >= 0; i--)
     {
         res += stack.ElementAt(i); ;
     }
     return res;
 }

        public static void reconocer(String cadena, Clases.Automata automata)
    {
        Stack<Clases.Estado> estadoactual = new Stack<Clases.Estado>();
        
        for (int i = 0; i < automata.listEstados.Count; i++)
        {
            if (automata.listEstados.ElementAt(i).nombre.Equals(automata.inicial))
            {
                estadoactual.Push(automata.listEstados.ElementAt(i));
                for (int j = 0; j < cadena.Length; j++)
                {
                    for (int k = 0; k < estadoactual.Peek().listTransiciones.Count; k++)
                    {
                       // System.out.println(String.valueOf(cadena.charAt(j)));
                        if (cadena.Substring(j,1).Equals(estadoactual.Peek().listTransiciones.ElementAt(k).simbolo))
                        {
                            for (int l = 0; l < automata.listEstados.Count; l++)
                            {
                                if(automata.listEstados.ElementAt(l).nombre.Equals(estadoactual.Peek().listTransiciones.ElementAt(k).destino))
                                {
                                    estadoactual.Push(automata.listEstados.ElementAt(l));
                                    break;
                                }
                            }
                            
                        }
                    }
                }

            }
        }

        if (estadoactual.Peek().aceptador)
        {
            
            Console.WriteLine(cadena + "Es aceptada");
            
        }
        else 
        {
            Console.WriteLine(cadena + "NO Es aceptada");
        }
        for (int i = estadoactual.Count-1; i >= 0; i--) {

            Console.WriteLine(estadoactual.ElementAt(i).nombre);

        }
     
    }

//.........这里部分代码省略.........
            /*
             * Clearing stack before use it;
             */
            try
            {
                _pbStack.clearStack();
                if (floatAnswer || _outputQueue.Any(v => v.Operator == "/"))
                {
                    //var dblStack = new Stack<double>();

                    // Type{integer,float,operator, memory},{value/mem index}
                    var newStack = new Stack<StackData>();
                    String leftOperand, rightOperand;
                    int leftOperandInt, rightOperandInt;
                    foreach (var nc in _outputQueue)
                    {
                        if (nc.NumberType == NumberClass.NumberTypes.Integer)
                        {
                            newStack.Push(new StackData("int", nc.IntNumber));
                            continue;
                        }

                        if (nc.NumberType == NumberClass.NumberTypes.Float)
                        {
                            newStack.Push(new StackData("float", nc.FloatNumber));
                            continue;
                        }

                        if (nc.NumberType == NumberClass.NumberTypes.Operator)
                        {

                            // Stack filling
                            // if left operand aren't memory cell and right aren't memory cell
                            if ((newStack.Peek().dataType != "mem") && (newStack.ElementAt(1).dataType != "mem"))
                            {
                                rightOperand = newStack.Pop().dataValue.ToString();
                                leftOperand = newStack.Pop().dataValue.ToString();

                                _pbStack.PushCommand(nc.Operator, leftOperand, rightOperand);
                            }
                            else
                            {
                                // if left operand stored in memory
                                if (newStack.Peek().dataType == "mem")
                                {
                                    if (newStack.ElementAt(1).dataType != "mem")
                                    {
                                        leftOperandInt = (int)newStack.Pop().dataValue;
                                        rightOperand = newStack.Pop().dataValue.ToString();

                                        // use push with memory index for left operand
                                        _pbStack.PushCommand(nc.Operator, leftOperandInt, rightOperand);
                                    }
                                    else
                                    {
                                        leftOperandInt = (int)newStack.Pop().dataValue;
                                        rightOperandInt = (int)newStack.Pop().dataValue;
                                        // use push with memory index for left operand
                                        // TODO: Implement Push Command for KOP MEM MEM
                                        _pbStack.PushCommand(nc.Operator, leftOperandInt, rightOperandInt);
                                    }
                                }
                                else
                                {
                                    /* If right operand stored in memory */
                                    // Get left operand value

    public void InterpretStackTypes(IDictionary<int, ILOpCode> aOpCodes, Stack<Type> aStack, ref bool aSituationChanged, int aMaxRecursionDepth)
    {
      if (Processed)
      {
        ILInterpretationDebugLine(() => String.Format("{0} skipped for reinterpretation", this));
        return;
      }
      Processed = true;
      ILInterpretationDebugLine(() =>
                                {
                                  var sb = new StringBuilder();
                                  sb.AppendFormat("Interpreting {0}. StackCount = {1}. Contents: ", this, aStack.Count);
                                  foreach (var item in aStack)
                                  {
                                    if (item == null)
                                    {
                                      sb.Append("**NULL**, ");
                                    }
                                    else
                                    {
                                      sb.AppendFormat("{0}, ", item.FullName);
                                    }
                                  }
                                  return sb.ToString().Trim(',', ' ');
                                });
      if (aMaxRecursionDepth == 0)
      {
        throw new Exception("Safety Error: MaxRecursionDepth reached!");
      }

      if (StackOffsetBeforeExecution == null)
      {
        StackOffsetBeforeExecution = 0;
        foreach (var item in aStack)
        {
          if (item == null)
          {
            StackOffsetBeforeExecution = null;
            break;
          }
          StackOffsetBeforeExecution += ILOp.Align(ILOp.SizeOfType(item), 4);
        }
      }

      // if current instruction is the first instruction of a catch statement, "push" the exception type now
      if (CurrentExceptionHandler != null &&
          CurrentExceptionHandler.HandlerOffset == Position)
      {
        if (CurrentExceptionHandler.Flags != SR.ExceptionHandlingClauseOptions.Finally)
        {
          aStack.Push(CurrentExceptionHandler.CatchType);
        }
      }

      if (StackPopTypes.Length > aStack.Count)
      {
        throw new Exception(String.Format("OpCode {0} tries to pop more stuff from analytical stack than there is!", this));
      }

      for (int i = 0; i < StackPopTypes.Length; i++)
      {
        var xActualStackItem = aStack.ElementAt(i);
        if (xActualStackItem == null)
        {
          continue;
        }
        if (StackPopTypes[i] == null)
        {
          StackPopTypes[i] = xActualStackItem;
          aSituationChanged = true;
        }
        if (StackPopTypes[i] != xActualStackItem
          && !StackPopTypes[i].IsAssignableFrom(xActualStackItem)
          && !((StackPopTypes[i].IsPointer || StackPopTypes[i].IsByRef) && (xActualStackItem.IsPointer || xActualStackItem.IsByRef)))
        {
          throw new Exception(String.Format("OpCode {0} tries to pop item at stack position {1} with type {2}, but actual type is {3}",
            this, i, StackPopTypes[i], xActualStackItem));
        }
      }

      foreach (var xPopItem in StackPopTypes)
      {
        aStack.Pop();
      }
      try
      {
        DoInterpretStackTypes(ref aSituationChanged);
      }
      catch (Exception E)
      {
        throw new Exception("Error interpreting stacktypes for " + this, E);
      }
      foreach (var xPushItem in StackPushTypes)
      {
        aStack.Push(xPushItem);
      }
      DoInterpretNextInstructionStackTypes(aOpCodes, aStack, ref aSituationChanged, aMaxRecursionDepth);
    }