C# ArrayList.RemoveAt方法代码示例

 public int makePalindrome(int[] seq)
 {
     ArrayList pal = new ArrayList();
     for (int i = 0; i < seq.Length; i++)
     {
         pal.Add(seq[i]);
     }
     int left = 0;
     int right = pal.Count - 1;
     int moves = 0;
     while (left < right)
     {
         if ((int)pal[left] < (int)pal[right])
         {
             pal[left] = (int)pal[left] + (int)pal[left + 1];
             pal.RemoveAt(left + 1);
             right--;
             moves++;
         }
         else if ((int)pal[left] > (int)pal[right])
         {
             pal[right] = (int)pal[right] + (int)pal[right - 1];
             pal.RemoveAt(right - 1);
             right--;
             moves++;
         }
         else
         {
             left++;
             right--;
         }
     }
     return moves;
 }

    public void initialize(int numCharacters)
    {
        spawnPoints = new ArrayList ();

        for (int i = 1; i <= 40; i++) {
            GameObject tempObject = GameObject.Find("SpawnPoint" + i);

            if(tempObject)
                spawnPoints.Add(tempObject);
        }

        ArrayList initialSpawnPoints = new ArrayList();
        initialSpawnPoints.AddRange (spawnPoints);

        characterList = new ArrayList ();

        int randomSpawnIndex = Random.Range (0, initialSpawnPoints.Count - 1);
        makeCharacter("Player", "Materials/Player1Color", "Player", ((GameObject)initialSpawnPoints[randomSpawnIndex]).transform.position, new Color (0, 1, 0));
        initialSpawnPoints.RemoveAt (randomSpawnIndex);

        for(int j = 1; j < numCharacters; j++) {
            randomSpawnIndex = Random.Range (0, initialSpawnPoints.Count - 1);
            makeCharacter ("Player", "Materials/EnemyColor", "MediumAI", ((GameObject)initialSpawnPoints[randomSpawnIndex]).transform.position, new Color (1, 0, 0));
            initialSpawnPoints.RemoveAt (randomSpawnIndex);
        }
    }

    public void calculateCheckpoints()
    {
        LevelPropertiesScript properties = LevelPropertiesScript.sharedInstance();
        this.checkpoints = new ArrayList(properties.powerups.Count);

        ArrayList placesToGo = new ArrayList(properties.powerups.Count);
        foreach (GameObject powerup in properties.powerups)
        {
            placesToGo.Add(powerup.transform.position);
        }

        Vector3 nextPos = (Vector3)placesToGo[0];
        this.checkpoints.Add(nextPos);
        placesToGo.RemoveAt(0);
        while (placesToGo.Count > 0)
        {
            float minDistance = float.MaxValue;
            Vector3 closestPosition = nextPos;
            foreach (Vector3 position in placesToGo)
            {
                float dist = Vector3.SqrMagnitude(position - nextPos);
                if (dist < minDistance)
                {
                    closestPosition = position;
                    minDistance = dist;
                }
            }

            nextPos = closestPosition;
            this.checkpoints.Add(closestPosition);
            placesToGo.Remove(closestPosition);
        }
    }

        static void playWithArrayList()
        {
            ArrayList lst = new ArrayList() {1,2,3};
            Debug.WriteLine("capacity {0}", lst.Capacity);
            Debug.WriteLine("count {0}", lst.Count);
            int a = 0;
            lst.Add(a = 15);
            lst.Add(null);
            lst.Add(new Car("diesel", 150, 200));
            lst.Add(10.25f);
            Debug.WriteLine("capacity {0}", lst.Capacity);
            Debug.WriteLine("count {0}", lst.Count);
            lst.Insert(2, "insert");
            lst.Add(15);
            Debug.WriteLine("capacity {0}", lst.Capacity);
            Debug.WriteLine("count {0}", lst.Count);
            lst.RemoveAt(1);
            lst.Add(a);
            lst.Remove(a);
            lst.Remove(15);
            Debug.WriteLine("capacity {0}", lst.Capacity);
            Debug.WriteLine("count {0}", lst.Count);
            Console.WriteLine(lst.IndexOf(15));

            foreach (Object obj in lst)
                Console.WriteLine(obj);
        }

    public static string[] getFilesFromBaseDir()
    {
        string baseDir = "~/";

        List<string> fileResults = new List<string>();
        ArrayList directories = new ArrayList();

        // Add inital Directory to our ArrayList
        directories.Add(baseDir);

        // Loop while there is something in our ArrayList
        while (directories.Count > 0)
        {
            // Get directory from ArrayList
            string currentDir = directories[0].ToString();

            // Remove element from ArrayList
            directories.RemoveAt(0);

            // Add all files in this directory
         //   foreach (string fileName in Directory.GetFiles(currentDir, "*.*"))
         //   {
         //       fileResults.Add(fileName);
         //   }

            // Add all directories in currentDir
            foreach (string dirName in Directory.GetDirectories(currentDir))
            {
                directories.Add(dirName);
            }
        }
        return fileResults.ToArray();
    }

    void CreateOperation()
    {
        ArrayList indexArray = new ArrayList ();
        ArrayList selectedIndex = new ArrayList ();
        firstOperator = (int)(1 + Random.value * 9);
        secondOperator = (int)(1 + Random.value * 9);
        for (int i = 0; i < 5; i++) {
            indexArray.Add (i);
        }
        for (int i = 0; i < 5; i++) {
            int selected = (int)(Random.value * (indexArray.Count - 1));
            selectedIndex.Add (indexArray[selected]);
            indexArray.RemoveAt(selected);
        }
        answers [0] = firstOperator * secondOperator;
        answers [1] = firstOperator + secondOperator;
        answers [2] = (firstOperator * 10) + secondOperator;
        answers [3] = (int)(1 + Random.value * 99);
        answers [4] = (int)(1 + Random.value * 99);
        correctAnswer = answers [0].ToString ();

        for (int i = 0; i < 5; i++) {
            balls [i].text = answers [(int)selectedIndex[i]].ToString();
        }

        operationText.text = firstOperator.ToString() + " X " + secondOperator.ToString();
    }

 private void Permute(int[] dig, ArrayList chosen)
 {
     if (chosen.Count == dig.Length) {
         int num = 0;
         int baseNum = 1;
         for (int i=0; i < chosen.Count; i++) {
             num += dig[(int)chosen[i]]*baseNum;
             baseNum *= 10;
         }
         if (!res.ContainsKey(num))
             res.Add(num, true);
         return;
     }
     for (int i = 0; i < dig.Length; i++)
     {
         bool found = false;
         for (int j = 0; j < chosen.Count; j++)
         {
             if ((int)chosen[j] == i)
                 found = true;
         }
         if (found)
             continue;
         chosen.Add(i);
         Permute(dig, chosen);
         chosen.RemoveAt(chosen.Count - 1);
     }
 }

    void Search(ArrayList array, float effectDist)
    {
        if (array == null) return;

        int i = 0;
        while (i < array.Count)
        {
            GameObject target = array[i] as GameObject;
            if (target == null)
            {
                i++;
                continue;
            }

            float dist = Vector3.Distance(target.transform.position, player.transform.position);
            if (dist < effectDist)
            {
                // 指定距離以内だったらアクティブソナーがヒット
                target.BroadcastMessage("OnActiveSonar");
                // ソナー対象リストから外す
                array.RemoveAt(i);
            }
            else i++;
        }
    }

	// Use this for initialization
	void Start()
	{
		this.playerCanClick = true;

		this.aCards = new ArrayList();
		this.aGrid = new Card[rows][];

		this.aCardsFlipped = new ArrayList();

		BuildDeck();

		for (int i = 0; i < rows; i++)
		{
			aGrid[i] = new Card[cols];

			for (int j = 0; j < cols; j++)
			{
				int someNum = UnityEngine.Random.Range(0, aCards.Count);
				aGrid[i][j] = (Card)aCards[someNum];
				aCards.RemoveAt(someNum);
			}
		}


	}

    // Use this for initialization
    void Start()
    {
        ArrayList list = new ArrayList ();
        int score = PlayerPrefs.GetInt ("endScore");

        for (int i = 1; i<=10; i++) {
            key = "highScore" + i;
            keyscore = PlayerPrefs.GetInt(key);
            list.Add(keyscore);

            //PlayerPrefs.SetInt (key, 0);
        }

        lowestScore = PlayerPrefs.GetInt ("highScore10");
        Debug.Log ("lowest score" + lowestScore);

        if (score > lowestScore)
        {
            list.Add (score);
            list.Sort ();
            list.Reverse();
            list.RemoveAt(10);

            for (int i = 1; i<=10; i++) {
                key = "highScore" + i;
                PlayerPrefs.SetInt(key, (int)list[i-1]);
            }
        }
    }

    public void DeleteNode(int i)
    {
        if (i < 0 || i >= nodes.Length) Debug.LogError("You are  trying to DELETE a node which does not exist. Max node index : " +  (nodes.Length - 1) + " . Index wanted : " + i);

        ArrayList n = new ArrayList(nodes);
        ArrayList ha = new ArrayList(handlesA);
        ArrayList hb = new ArrayList(handlesB);
        //ArrayList a = new ArrayList(A);
        //ArrayList b = new ArrayList(B);
        //ArrayList c = new ArrayList(C);

        n.RemoveAt(i);
        ha.RemoveAt(i);
        hb.RemoveAt(i);
        //a.RemoveAt(i);
        //b.RemoveAt(i);
        //c.RemoveAt(i);

        nodes =     (Vector3 []) n.ToArray(typeof(Vector3));
        handlesA =     (Vector3 []) ha.ToArray(typeof(Vector3));
        handlesB =     (Vector3 []) hb.ToArray(typeof(Vector3));
        //A =         (Vector3 []) a.ToArray(typeof(Vector3));
        //B =         (Vector3 []) b.ToArray(typeof(Vector3));
        //C =         (Vector3 []) c.ToArray(typeof(Vector3));
    }

    public void fill4(int x, int y, Color32 oldColor, Color32 newColor)
    {
        ArrayList stack = new ArrayList();

        stack.Add(new Vec2i(x,y));

        int emergency = 10000;

        while(stack.Count > 0 && emergency >= 0) {

            Vec2i pixel = (Vec2i)stack[stack.Count - 1];
            stack.RemoveAt(stack.Count - 1);

            if(canvas.GetPixel(pixel.x, pixel.y) == oldColor) {

                canvas.SetPixel(pixel.x, pixel.y, newColor);

                if(pixel.x + 1 < 96 && canvas.GetPixel(pixel.x + 1, pixel.y) == oldColor)
                    stack.Add(new Vec2i(pixel.x + 1, pixel.y));

                if(pixel.x - 1 >= 0 && canvas.GetPixel(pixel.x - 1, pixel.y) == oldColor)
                    stack.Add(new Vec2i(pixel.x - 1, pixel.y));

                if(pixel.y + 1 < 64 && canvas.GetPixel(pixel.x, pixel.y + 1) == oldColor)
                    stack.Add(new Vec2i(pixel.x, pixel.y + 1));

                if(pixel.y - 1 >= 0 && canvas.GetPixel(pixel.x, pixel.y - 1) == oldColor)
                    stack.Add(new Vec2i(pixel.x, pixel.y - 1));

            }

            emergency--;

        }
    }

 public static void AddNewsToCur(ArrayList allNews, ArrayList curNews)
 {
     if (allNews.Count > 0) {
         int i = UnityEngine.Random.Range(0, allNews.Count);
         curNews.Add(allNews[i]);
         allNews.RemoveAt(i);
     }
 }

 public int calculate(string[] cards)
 {
     ArrayList c = new ArrayList(cards);
     int removed = 0;
     bool moved = true;
     while (moved)
     {
         moved = false;
         int bestRem = -1;
         int bestRemScore = 0;
         for (int i = 1; i < c.Count-1; i++)
         {
             int common = comp((string)c[i - 1], (string)c[i + 1]);
             if (common >= 2)
             {
                 int score = 3;
                 if (i > 1)
                 {
                     int comB = comp((string)c[i - 2], (string)c[i]);
                     int comC = comp((string)c[i - 2], (string)c[i + 1]);
                     if (comB >= 2 && comC < 2)
                     {
                         score--;
                     }
                     else if (comB < 2 && comC >= 2)
                     {
                         score++;
                     }
                 }
                 if (i < c.Count - 2)
                 {
                     int comB = comp((string)c[i + 2], (string)c[i]);
                     int comC = comp((string)c[i - 1], (string)c[i + 2]);
                     if (comB >= 2 && comC < 2)
                     {
                         score--;
                     }
                     else if (comB < 2 && comC >= 2)
                     {
                         score++;
                     }
                 }
                 if (score > bestRemScore)
                 {
                     bestRemScore = score;
                     bestRem = i;
                 }
             }
         }
         if (bestRem != -1)
         {
             c.RemoveAt(bestRem);
             moved = true;
             removed++;
         }
     }
     return removed;
 }

	// Use this for initialization
	void Start () 
	{
		// Grab the tree array from the terrain
		treeArray = new ArrayList(Terrain.activeTerrain.terrainData.treeInstances);
		int originalCount = treeArray.Count -1;
		//Debug.Log("Tree instances: " + originalCount);
		
		// Substitute all the trees for game objects
		for(int i = 0; i <= originalCount; i++)
		{
			GameObject newTree = null;
			
			switch(((TreeInstance)treeArray[0]).prototypeIndex)
			{
				case 0 : 
				{
					newTree = GameObject.Instantiate(Resources.Load("PoC Prefabs/OakTree")) as GameObject;
				}; break; 
				
				case 1 : 
				{
					newTree = GameObject.Instantiate(Resources.Load("PoC Prefabs/PalmTree")) as GameObject;
				}; break; 
				
				default : 
				{
					return;
				}
			}
			
			// Set the properties
			newTree.transform.position = new Vector3(
				Terrain.activeTerrain.terrainData.size.x * ((TreeInstance)treeArray[0]).position.x, 
				Terrain.activeTerrain.terrainData.size.y * ((TreeInstance)treeArray[0]).position.y, 
				Terrain.activeTerrain.terrainData.size.z * ((TreeInstance)treeArray[0]).position.z
			);
			
			newTree.transform.localScale = new Vector3(
				((TreeInstance)treeArray[0]).widthScale, 
				((TreeInstance)treeArray[0]).heightScale, 
				((TreeInstance)treeArray[0]).widthScale
			);
			
			// Remove this tree
			treeArray.RemoveAt(0);
		}
		
		// Remove the built-in trees from the terrain
		TreeInstance[] tmpArray = new TreeInstance[0];
		treeArray.CopyTo(tmpArray);
		Terrain.activeTerrain.terrainData.treeInstances = tmpArray;
		
		// Refresh the terrain
		float[,] heights = Terrain.activeTerrain.terrainData.GetHeights(0, 0, 0, 0);
		Terrain.activeTerrain.terrainData.SetHeights(0, 0, heights);
		
		//Debug.Log("Done");
	}