Welcome to the Lounge

public void BreakLasVegas(MissileLauncher Launcher)
{
    if(MissileAcquireAndCommandCheck == Enums.MissileStatus.Go)
    {
        if(SetTarget("LasVegas") == Enums.MissileStatus.Go)
        {
            if(CheckSecurityLocksAndAuthorization() == Enums.MissileStatus.Go)
            {
                // Let's break Las Vegas!
                Launcher.Launch();
            }
        }
    }
}

CodeWraith wrote:

I have lived with several Zen masters - all of them were cats.

harold aptroot wrote:

it does not choose a permutation with uniform probability across all possible permutations

public static class EnumerableExtensions
{
    private static Random rnd;

    // 'source is not altered
    public static IEnumerable<T> Shuffle<T>(this IEnumerable<T> source)
    {
        rnd = new Random(DateTime.Now.Millisecond);

        List<T> slist = source.ToList();

        int scount = slist.Count();

        int ndx;

        while (--scount >= 0)
        {
            ndx = rnd.Next(0, scount);

            yield return slist[ndx];

            slist.RemoveAt(ndx);
        }     
    }
}

while (--scount >= 0)
{
    ndx = rnd.Next(0, scount);

    yield return slist[ndx];

    // HA suggests: slist[scount - 1] into slist[ndx] (optionally set slist[scount - 1] to default(T)).

    slist[ndx] = slist[scount];
}

public static IEnumerable<T> Shuffle<T>(this IEnumerable<T> source, Random rng)
{
    T[] elements = source.ToArray();
    for (int i = elements.Length - 1; i >= 0; i--)
    {
        // Swap element "i" with a random earlier element it (or itself)
        // ... except we don't really need to swap it fully, as we can
        // return it immediately, and afterwards it's irrelevant.
        int swapIndex = rng.Next(i + 1);
        yield return elements[swapIndex];
        elements[swapIndex] = elements[i];
    }
}

private static Random rnd;

// 'source is not altered
public static IEnumerable<T> Shuffle<T>(this IEnumerable<T> source)
{
    rnd = new Random((Int32)DateTime.Now.Ticks);

    List<T> slist = source.ToList();

    int scount = slist.Count();

    int ndx;

    while (--scount >= 0)
    {
        ndx = rnd.Next(0, scount);

        yield return slist[ndx];

        // error
        slist[ndx] = slist[scount - 1];

        // no error
        // slist[ndx] = slist[scount];
    }     
}

Dan Neely wrote:

If you're seeding off of a time, you've got a much more serious problem than just a low number of bits of entropy. You're using a predictable seed which means an attacker can guess it relatively easily and pwn you much faster than brute force.

Jacquers wrote:

It works, but you don't necessarily understand the solution.