Programming Forums - populate array with random nonrepeating #'s

Programming Forums (http://www.programmingforums.org/forumindex.php)

- C# (http://www.programmingforums.org/forum16.html)

- - populate array with random nonrepeating #'s (http://www.programmingforums.org/showthread.php?t=15729)

populate array with random nonrepeating #'s

I am trying to fill an array with random #'s from 1 to 42 using every number in the range exactly once. here is what I have:

private void frmMain_Load(object sender, System.EventArgs e)
                {
                        //seed the random number function
                        DateTime dtmCurrent = DateTime.Now;
                        generateRandom = new Random(dtmCurrent.Millisecond);
 
                        //fill array with random #'s from 1 to 42
                        int intAdd = 0;
                        while(intAdd < 42)
                        {
                                intStore = generateRandom.Next(1,42);
                                //check to see if array contains generated #
                                foreach(int intBoard1 in intBoard)
                                {
                                        if(intStore == intBoard1)
                                        {
                                                bln_isSame = true;
                                        }
                                        else
                                        {
                                                bln_isSame = false;
                                        }
                                }
                                //if array doesn't contain generated number then add it to the array in next position
                                if(bln_isSame == false)
                                {
                                        intBoard[intAdd] = intStore;
                                        intAdd++;
                                }
                        }
                        int intIndex=0;
                        //write array to a file for test
                        StreamWriter arrayStreamWriter = new StreamWriter("C:\\Documents and Settings\\Owner.Gir\\My Documents\\Visual Studio Projects\\Memory\\array.txt",true);
                        while(intIndex < 42)
                        {
                                arrayStreamWriter.WriteLine(intBoard[intIndex]);
                                intIndex++;
                        }
                        arrayStreamWriter.Close();
                }

a few of the variables are declared at the class level so I didn't show their declaration. This code seems to compile but I get a list that has repeats in it when I print the array to a file. Is there a shuffle method or something super obvious that I am missing? I am using VS 2003 for this project.

Re: populate array with random nonrepeating #'s

Should it not just be as simple as checking storing the last number to be generated and stored, then checking it agaisnt the new number to see if it is the same if it is then generate a new number?

Sorry, re-read you may want to store each randomly generated number in an array then check each new number against those in the array.

im confusing myself lol

Chris

Re: populate array with random nonrepeating #'s

thank u...storing the random numbers in an array first seemed to do what i needed, however i am still getting a 0 printed at the end of my list. Any ideas on why i get this and how to get rid of it?

Re: populate array with random nonrepeating #'s

You want to fill an array with a length of fourty-two, with numbers one to fourty-two and further yet the numbers should be at random points in the array, right?

If I got that right, why not just fill the array with values one through to fourty-two and manually shuffle the array?

Anyway, continuing with your own technique, this ought to help:

        static int[] DoNumbersThing()
        {
            const int MIN = 1;
            const int MAX = 43;
 
            int intRnd = 0;
            Random rnd = new Random();
            List<int> intList = new List<int>(MAX);
            while (intList.Count != intList.Capacity - MIN)
            {
                intRnd = rnd.Next(MIN, MAX);
                if (!intList.Contains(intRnd))
                    intList.Add(intRnd);
                else continue;
            }
            return intList.ToArray();
        }

Re: populate array with random nonrepeating #'s

Quote:

Originally Posted by Alias (Post 144527)

Indeed this is a good way of looking at doing this, it would sure that you do notn have duplicates, and you could simple use a random number to access different slots of the array. Using the same technique to ensure that you do not choose the same slot.

But working with what you have, you may find that the reason you have a 0 at the end is simple you have declared and array of size 43 instead of 42, not sure on that but quite often that is the reason behind it.

Alias, just added a method Using ArrayLists or Vectors, not sure if C# uses arraylists im sure he will clarify which it is, which does indeed make things simpler for you.

Chris

Re: populate array with random nonrepeating #'s

If you add the following classes to your project, you can populate a list like this:

List<int> list = new List<int>();
list.AddRange(new RandomizedSeries(0, 20));

Series.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace RandomUnique
{
    class Series : IEnumerable<int>, IEnumerator<int>
    {
        private readonly int begin, end;
        private bool counting = false;
        private int current;
 
        public Series(int end) : this(0, end)
        {
        }
 
        public Series(int begin, int end)
        {
            this.begin = begin;
            this.end = end;
        }
 
        #region IEnumerable<int> Members
 
        public IEnumerator<int> GetEnumerator()
        {
            return this;
        }
 
        #endregion
 
        #region IEnumerable Members
 
        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return this;
        }
 
        #endregion
 
        #region IEnumerator<int> Members
 
        public int Current
        {
            get { return current; }
        }
 
        #endregion
 
        #region IDisposable Members
 
        public void Dispose()
        {
        }
 
        #endregion
 
        #region IEnumerator Members
 
        object System.Collections.IEnumerator.Current
        {
            get { return Current; }
        }
 
        public bool MoveNext()
        {
            if (!counting)
            {
                current = begin;
                counting = true;
            }
            else
            {
                counting = ++current < end;
            }
            return counting;
        }
 
        public void Reset()
        {
            counting = false;
        }
 
        #endregion
    }
}

RandomizedSeries.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace RandomUnique
{
    class RandomizedSeries : IEnumerable<int>, IEnumerator<int>
    {
        private Random random = new Random();
        private readonly int begin, end;
        private bool counting = false;
        private int index = 0;
        private List<int> list;    
 
        public RandomizedSeries(int end) : this(0, end)
        {
        }
 
        public RandomizedSeries(int begin, int end)
        {
            this.begin = begin;
            this.end = end;
        }
 
 
 
        #region IEnumerable<int> Members
 
        public IEnumerator<int> GetEnumerator()
        {
            return this;
        }
 
        #endregion
 
        #region IEnumerable Members
 
        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return this;
        }
 
        #endregion
 
        #region IEnumerator<int> Members
 
        public int Current
        {
            get
            {
                return list[index];
            }
        }
 
        #endregion
 
        #region IDisposable Members
 
        public void Dispose()
        {
        }
 
        #endregion
 
        #region IEnumerator Members
 
        object System.Collections.IEnumerator.Current
        {
            get { return Current; }
        }
 
        public bool MoveNext()
        {
            if (!counting)
            {
                list = new List<int>();
                list.AddRange(new Series(begin, end));
                counting = true;
            }
            else
            {
                list.RemoveAt(index);
            }
            index = random.Next(0, list.Count);
            return list.Count > 0;
        }
 
        public void Reset()
        {
            counting = false;
        }
 
        #endregion
    }
}

Re: populate array with random nonrepeating #'s

i got it working but your code was much more concise alias. I might replace mine anyway. Thank you guys for your help.

Re: populate array with random nonrepeating #'s

i was thinking about this today and realized that it would make sense to randomize any enumerable. thus:

RandomEnumerable.cs

using System;
using System.Collections;
using System.Collections.Generic;
 
namespace RandomEnumerable
{
    public class RandomEnumerable<T> : IEnumerable<T>, IEnumerator<T>
    {
        private readonly Random random;
        private readonly IEnumerable<T> enumerable;
        private List<T> list;
        private int current;
 
        public RandomEnumerable(Random random, IEnumerable<T> enumerable)
        {
            this.random = random;
            this.enumerable = enumerable;
        }
 
        #region IEnumerable<T> Members
 
        IEnumerator<T> IEnumerable<T>.GetEnumerator()
        {
            return this;
        }
 
        IEnumerator IEnumerable.GetEnumerator()
        {
            return this;
        }
 
        #endregion
 
        #region IEnumerator<T> Members
 
        T IEnumerator<T>.Current
        {
            get { return list[current]; }
        }
 
        void IDisposable.Dispose()
        {
        }
 
        object IEnumerator.Current
        {
            get { return list[current]; }
        }
 
        bool IEnumerator.MoveNext()
        {
            if (list == null)
            {
                list = new List<T>();
                list.AddRange(enumerable);
            }
            else
            {
                list.RemoveAt(current);
            }
            current = random.Next(0, list.Count);
            return list.Count > 0;
        }
 
        void IEnumerator.Reset()
        {
            list = null;
        }
 
        #endregion
    }
}

p.s. this forum sure sucks at highlighting c#

Re: populate array with random nonrepeating #'s

i suck at writing enumerables... i tried to use mine in a different program and found they needed to be modified. here they are:

Series.cs

using System.Collections;
using System.Collections.Generic;
 
namespace RandomEnumerable
{
    public class Series : IEnumerable<int>
    {
        private readonly int begin, end;
 
        public Series(int end)
            : this(0, end)
        {
        }
 
        public Series(int begin, int end)
        {
            this.begin = begin;
            this.end = end;
        }
 
        #region IEnumerable<int> Members
 
        public IEnumerator<int> GetEnumerator()
        {
            return new Enumerator(begin, end);
        }
 
        IEnumerator IEnumerable.GetEnumerator()
        {
            return new Enumerator(begin, end);
        }
 
        #endregion
 
        #region Nested type: Enumerator
 
        private class Enumerator : IEnumerator<int>
        {
            private readonly int begin, end;
            private bool counting = false;
            private int current;
 
            public Enumerator(int begin, int end)
            {
                this.begin = begin;
                this.end = end;
            }
 
            #region IEnumerator<int> Members
 
            public int Current
            {
                get { return current; }
            }
 
            public void Dispose()
            {
            }
 
            object IEnumerator.Current
            {
                get { return Current; }
            }
 
            public bool MoveNext()
            {
                if (!counting)
                {
                    current = begin;
                    counting = true;
                }
                else
                {
                    counting = ++current < end;
                }
                return counting;
            }
 
            public void Reset()
            {
                counting = false;
            }
 
            #endregion
        }
 
        #endregion
    }
}

RandomEnumerable.cs

using System;
using System.Collections;
using System.Collections.Generic;
 
namespace RandomEnumerable
{
    public class RandomEnumerable<T> : IEnumerable<T>
    {
        private readonly IEnumerable<T> enumerable;
        private readonly Random random;
 
        public RandomEnumerable(Random random, IEnumerable<T> enumerable)
        {
            this.random = random;
            this.enumerable = enumerable;
        }
 
        #region IEnumerable<T> Members
 
        IEnumerator<T> IEnumerable<T>.GetEnumerator()
        {
            return new Enumerator<T>(random, enumerable);
        }
 
        IEnumerator IEnumerable.GetEnumerator()
        {
            return new Enumerator<T>(random, enumerable);
        }
 
        #endregion
 
        #region Nested type: Enumerator
 
        private class Enumerator<T> : IEnumerator<T>
        {
            private readonly IEnumerable<T> enumerable;
            private readonly Random random;
            private int current;
            private List<T> list;
 
            public Enumerator(Random random, IEnumerable<T> enumerable)
            {
                this.random = random;
                this.enumerable = enumerable;
            }
 
            #region IEnumerator<T> Members
 
            T IEnumerator<T>.Current
            {
                get { return list[current]; }
            }
 
            void IDisposable.Dispose()
            {
            }
 
            object IEnumerator.Current
            {
                get { return list[current]; }
            }
 
            bool IEnumerator.MoveNext()
            {
                if (list == null)
                {
                    list = new List<T>();
                    list.AddRange(enumerable);
                }
                else
                {
                    list.RemoveAt(current);
                }
                current = random.Next(0, list.Count);
                return list.Count > 0;
            }
 
            void IEnumerator.Reset()
            {
                list = null;
            }
 
            #endregion
        }
 
        #endregion
    }
}

Re: populate array with random nonrepeating #'s

mbd, thats alot of work to do nothing.