Method List explanation on a Cut index method

Could someone give me an explanation line by line of the cut method bellow-- public void Cut(int location). I also included the overall class from where this method is located bellow. Thank you.


public void Cut(int location)
        {
            int cutIndex = cards.Count - location;
            Card[] newCards = new Card[cards.Count];
            cards.CopyTo(cutIndex, newCards, 0, location);
            cards.CopyTo(0, newCards, location, cutIndex);
            cards.Clear();
            cards.InsertRange(0, newCards);
        }

Open in new window


Card class bellow:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace UsingDeckClass
{
    /// <summary>
    /// Provides a class for a deck of cards
    /// </summary>
    public class Deck
    {
        #region Fields

        List<Card> cards = new List<Card>();

        #endregion

        #region Constructors

        /// <summary>
        /// Constructor
        /// </summary>
        public Deck()
        {
            // fill the deck with cards
            foreach (Suit suit in Enum.GetValues(typeof(Suit)))
            {
                foreach (Rank rank in Enum.GetValues(typeof(Rank)))
                {
                    cards.Add(new Card(rank.ToString(), suit.ToString()));
                }
            }
        }

        #endregion

        #region Properties

        /// <summary>
        /// Gets whether the deck is empty
        /// </summary>
        public bool Empty
        {
            get { return cards.Count == 0; }
        }

        #endregion

        #region Public methods

        /// <summary>
        /// Cuts the deck of cards at the given location
        /// </summary>
        /// <param name="location">the location at which to cut the deck</param>
        public void Cut(int location)
        {
            //int cutIndex = cards.Count - location;
            //List<Card> newCards = new List<Card>(cards.Count);
            //for (int i = cutIndex; i < cards.Count; i++)
            //{
            //    newCards.Add(cards[i]);
            //}
            //for (int i = 0; i < cutIndex; i++)
            //{
            //    newCards.Add(cards[i]);
            //}
            //cards = newCards;

            int cutIndex = cards.Count - location;
            Card[] newCards = new Card[cards.Count];
            cards.CopyTo(cutIndex, newCards, 0, location);
            cards.CopyTo(0, newCards, location, cutIndex);
            cards.Clear();
            cards.InsertRange(0, newCards);
        }

        /// <summary>
        /// Shuffles the deck
        /// 
        /// Reference: http://download.oracle.com/javase/1.5.0/docs/api/java/util/Collections.html#shuffle%28java.util.List%29
        /// </summary>
        public void Shuffle()
        {
            Random rand = new Random();
            for (int i = cards.Count - 1; i > 0; i--)
            {
                int randomIndex = rand.Next(i + 1);
                Card tempCard = cards[i];
                cards[i] = cards[randomIndex];
                cards[randomIndex] = tempCard;
            }
        }

        /// <summary>
        /// Takes the top card from the deck. If the deck is empty, returns null
        /// </summary>
        /// <returns>the top card</returns>
        public Card TakeTopCard()
        {
            if (!Empty)
            {
                Card topCard = cards[cards.Count - 1];
                cards.RemoveAt(cards.Count - 1);
                return topCard;
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        /// Prints the contents of the deck
        /// </summary>
        public void Print()
        {
            foreach (Card card in cards)
            {
                Console.WriteLine(card.Rank + " of " + card.Suit);
            }
        }
        #endregion
    }
}

Open in new window

yguyon28Asked:
Who is Participating?
 
AndyAinscowFreelance programmer / ConsultantCommented:
public void Cut(int location)
        {
//zero based index in array, find where the actual cut is to take place
            int cutIndex = cards.Count - location;
//creating a new array
            Card[] newCards = new Card[cards.Count];
//copy one section to temp array
            cards.CopyTo(cutIndex, newCards, 0, location);
//copy other section to temp array
            cards.CopyTo(0, newCards, location, cutIndex);
//empty original array
            cards.Clear();
//copy temp array into the original array
            cards.InsertRange(0, newCards);
        }
0
 
AndyAinscowFreelance programmer / ConsultantCommented:
Basically it is just cut/pasting a section of the list whilst maintaining the ordering.
eg.
If the list is 1 2 3 4 5 6 7 after the function it may well be 5 6 7 1 2 3 4

It does it by creating a new array (large enough to hold all the current array) then copies from the current array the two sections, removes the contents of the original array then copies this complete temporary array back into the original.
0
 
yguyon28Author Commented:
great explanation but can I have a line by line explanation of my code?
0
Question has a verified solution.

Are you are experiencing a similar issue? Get a personalized answer when you ask a related question.

Have a better answer? Share it in a comment.

All Courses

From novice to tech pro — start learning today.