C# Random Data Generation Exercises: 20 Coding Problems with Solutions

using System;

class Program
{
    static void Main()
    {
        Random random = new Random();

        Console.WriteLine("Random integers:");
        for (int i = 0; i < 5; i++)
        {
            int value = random.Next(50, 151);
            Console.WriteLine(value);
        }

        Console.WriteLine("Random doubles:");
        for (int i = 0; i < 5; i++)
        {
            double value = 10.0 + random.NextDouble() * (50.0 - 10.0);
            Console.WriteLine(value);
        }
    }
}Code language: C# (cs)

Explanation:

• new Random(): A single shared instance is created once and reused for every call, since creating a new Random instance repeatedly in a tight loop can produce identical values on some systems due to the same seed being derived from the clock.
• random.Next(50, 151): Generates an integer from 50 up to, but not including, 151, effectively covering the inclusive range from 50 to 150.
• 10.0 + random.NextDouble() * (50.0 - 10.0): Scales the 0.0-to-1.0 value from NextDouble() into the desired 10.0-to-50.0 range, by multiplying by the range’s width and adding the minimum value as an offset.
• Output varies by run: Since no fixed seed is provided, each execution of the program produces a different sequence of random values.

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

class Program
{
    static void Main()
    {
        int seed = 42;
        Random randomA = new Random(seed);
        Random randomB = new Random(seed);

        List<int> listA = new List<int>();
        List<int> listB = new List<int>();

        for (int i = 0; i < 10; i++)
        {
            listA.Add(randomA.Next(1, 100));
            listB.Add(randomB.Next(1, 100));
        }

        bool areIdentical = listA.SequenceEqual(listB);
        Console.WriteLine(areIdentical);
    }
}Code language: C# (cs)

Explanation:

• new Random(seed): Passing the same seed value to both constructors ensures each instance starts from the exact same internal state, producing the same sequence of “random” numbers.
• Two separate loops: Generate ten numbers from each instance independently, but since both started from the same seed, their sequences end up matching value for value.
• listA.SequenceEqual(listB): Compares the two lists element by element, returning true only if every corresponding pair of values is equal and both lists are the same length.
• Practical use: Seeding is useful for testing, since it lets a “random” scenario be reproduced exactly on demand rather than varying unpredictably between runs.

using System;

class Program
{
    static void Main()
    {
        Random random = new Random();
        char[,] grid = new char[5, 5];

        for (int row = 0; row < 5; row++)
        {
            for (int col = 0; col < 5; col++)
            {
                grid[row, col] = (char)('A' + random.Next(0, 26));
            }
        }

        for (int row = 0; row < 5; row++)
        {
            for (int col = 0; col < 5; col++)
            {
                Console.Write(grid[row, col]);
            }
            Console.WriteLine();
        }
    }
}Code language: C# (cs)

Explanation:

• char[5, 5] grid: Declares a two-dimensional array with 5 rows and 5 columns, capable of holding 25 individual characters.
• random.Next(0, 26): Generates an integer from 0 to 25, matching the 26 letters of the alphabet.
• (char)('A' + random.Next(0, 26)): Adds that random offset to the character 'A', producing a random uppercase letter, since characters can be treated as numeric values in C#.
• Nested loops for printing: The outer loop moves through each row, while the inner loop prints every character in that row before a newline is written.

using System;

class Program
{
    static Random random = new Random();

    static bool GetBiasedBool(double trueProbability)
    {
        return random.NextDouble() < trueProbability;
    }

    static void Main()
    {
        int trueCount = 0;
        int totalRuns = 10000;

        for (int i = 0; i < totalRuns; i++)
        {
            if (GetBiasedBool(0.75))
            {
                trueCount++;
            }
        }

        Console.WriteLine(trueCount + " out of " + totalRuns + " were true");
    }
}Code language: C# (cs)

Explanation:

• random.NextDouble() < trueProbability: Compares a random fraction between 0.0 and 1.0 against the given probability, so a higher trueProbability makes the comparison succeed more often.
• Proportional bias: Since NextDouble() produces a roughly uniform spread of values across its range, a threshold of 0.75 causes the comparison to succeed for about 75% of all generated fractions.
• Repeated testing: Calling GetBiasedBool many times and counting the true results is the practical way to confirm a probability-based method behaves as expected, since any single call could go either way.
• Static Random field: Reusing one shared Random instance across all 10000 calls avoids the correlated-output problem that can occur from creating many Random instances in quick succession.

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

class Program
{
    static void Main()
    {
        Random random = new Random();

        string upper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
        string lower = "abcdefghijklmnopqrstuvwxyz";
        string digits = "0123456789";
        string special = "!@#$%";
        string all = upper + lower + digits + special;

        List<char> passwordChars = new List<char>();

        for (int i = 0; i < 2; i++)
        {
            passwordChars.Add(upper[random.Next(upper.Length)]);
            passwordChars.Add(lower[random.Next(lower.Length)]);
            passwordChars.Add(digits[random.Next(digits.Length)]);
            passwordChars.Add(special[random.Next(special.Length)]);
        }

        while (passwordChars.Count < 12)
        {
            passwordChars.Add(all[random.Next(all.Length)]);
        }

        string password = new string(passwordChars.OrderBy(c => random.Next()).ToArray());
        Console.WriteLine(password);
    }
}Code language: C# (cs)

Explanation:

• Four separate character sets: upper, lower, digits, and special each represent one required category, kept apart so exactly 2 characters can be drawn from each.
• Guaranteed minimums: The first loop adds 2 characters from every category before anything else, ensuring the final password can never fall short of the requirement no matter how the rest of the fill turns out.
• while (passwordChars.Count < 12): Fills any remaining slots by drawing randomly from the combined all string, which includes every category.
• OrderBy(c => random.Next()): Shuffles the list of characters into a random order before joining them into the final string, so the guaranteed characters don’t always appear in the same fixed positions.

using System;
using System.Security.Cryptography;

class Program
{
    static void Main()
    {
        byte[] tokenBytes = new byte[32];
        RandomNumberGenerator.Fill(tokenBytes);

        string token = Convert.ToHexString(tokenBytes);
        Console.WriteLine(token);
    }
}Code language: C# (cs)

Explanation:

• new byte[32]: Allocates an empty array with room for exactly 32 random bytes, matching the requested token size.
• RandomNumberGenerator.Fill(tokenBytes): Populates the array with cryptographically secure random values, generated by the operating system’s secure random source rather than a predictable algorithm.
• Convert.ToHexString(tokenBytes): Converts the raw bytes into a readable hexadecimal string, doubling the character count since each byte becomes two hex characters.
• Why not System.Random: System.Random is designed for speed and statistical distribution, not unpredictability against an attacker, so it isn’t suitable for anything security-sensitive like a password reset token.

using System;
using System.Text;

class Program
{
    static void Main()
    {
        Random random = new Random();
        string vowels = "aeiou";
        string consonants = "bcdfghjklmnpqrstvwxyz";

        StringBuilder result = new StringBuilder();

        for (int i = 0; i < 6; i++)
        {
            if (i % 2 == 0)
            {
                result.Append(consonants[random.Next(consonants.Length)]);
            }
            else
            {
                result.Append(vowels[random.Next(vowels.Length)]);
            }
        }

        Console.WriteLine(result.ToString());
    }
}Code language: C# (cs)

Explanation:

• vowels and consonants: Two separate strings acting as the pools to randomly choose from, depending on which type of letter belongs at the current position.
• i % 2 == 0: Alternates between the two pools based on whether the current index is even or odd, starting with a consonant at position 0.
• consonants[random.Next(consonants.Length)]: Picks one random character from the consonants string, using a random index within its valid range.
• StringBuilder: Accumulates each chosen character efficiently before converting the whole sequence into a final string with ToString().

using System;
using System.Text;

class Program
{
    static string GenerateFromMask(string mask)
    {
        Random random = new Random();
        StringBuilder result = new StringBuilder();

        foreach (char c in mask)
        {
            if (c == '#')
            {
                result.Append(random.Next(0, 10));
            }
            else
            {
                result.Append(c);
            }
        }

        return result.ToString();
    }

    static void Main()
    {
        string identifier = GenerateFromMask("ABC-###-XY");
        Console.WriteLine(identifier);
    }
}Code language: C# (cs)

Explanation:

• foreach (char c in mask): Walks through the mask one character at a time, examining each one individually.
• if (c == '#'): Checks whether the current character is the designated placeholder symbol.
• random.Next(0, 10): Generates a single random digit from 0 to 9 whenever a placeholder is encountered, appending it in place of the #.
• else { result.Append(c); }: Preserves every non-placeholder character exactly as it appears in the original mask, keeping the surrounding structure like “ABC-” and “-XY” intact.

using System;

class Program
{
    static void Main()
    {
        Random random = new Random();
        DateTime start = new DateTime(2020, 1, 1);
        DateTime end = new DateTime(2025, 12, 31);

        TimeSpan span = end - start;
        long randomTicks = (long)(random.NextDouble() * span.Ticks);

        DateTime randomDate = start.AddTicks(randomTicks);
        Console.WriteLine(randomDate);
    }
}Code language: C# (cs)

Explanation:

• TimeSpan span = end - start: Measures the total duration between the two boundary dates, expressed as a TimeSpan with an underlying tick count.
• random.NextDouble() * span.Ticks: Scales a random fraction between 0.0 and 1.0 by the total number of ticks in the span, producing a random offset somewhere within that duration.
• start.AddTicks(randomTicks): Adds that random offset to the start date, landing on a random point that could fall on any day and at any time within the entire range.
• Randomizing both date and time together: Since ticks represent the smallest unit of time in a DateTime, this approach naturally randomizes the time of day along with the date, rather than only picking a random day and defaulting to midnight.

using System;

class Program
{
    static void Main()
    {
        Random random = new Random();
        double centerLatitude = 40.7128;
        double centerLongitude = -74.0060;
        double radiusKm = 5;

        for (int i = 0; i < 10; i++)
        {
            double angle = random.NextDouble() * 2 * Math.PI;
            double distance = radiusKm * Math.Sqrt(random.NextDouble());

            double latOffset = (distance / 111.0) * Math.Cos(angle);
            double lngOffset = (distance / (111.0 * Math.Cos(centerLatitude * Math.PI / 180))) * Math.Sin(angle);

            double randomLat = centerLatitude + latOffset;
            double randomLng = centerLongitude + lngOffset;

            Console.WriteLine(randomLat + ", " + randomLng);
        }
    }
}Code language: C# (cs)

Explanation:

• random.NextDouble() * 2 * Math.PI: Picks a random direction around the center point, covering the full 360 degrees of a circle expressed in radians.
• radiusKm * Math.Sqrt(random.NextDouble()): Picks a random distance from the center, using a square root so points are spread evenly across the circle’s entire area rather than bunching up near the middle.
• distance / 111.0: Converts a distance in kilometers into an approximate change in latitude degrees, since one degree of latitude is roughly 111 kilometers everywhere on Earth.
• Longitude adjustment with Math.Cos(centerLatitude * Math.PI / 180): Accounts for the fact that a degree of longitude covers less physical distance the farther a point is from the equator, since lines of longitude converge toward the poles.

using System;

class Program
{
    static void Main()
    {
        Random random = new Random();

        byte r = (byte)random.Next(0, 256);
        byte g = (byte)random.Next(0, 256);
        byte b = (byte)random.Next(0, 256);

        (byte R, byte G, byte B) color = (r, g, b);

        string hex = "#" + color.R.ToString("X2") + color.G.ToString("X2") + color.B.ToString("X2");
        Console.WriteLine(hex);
    }
}Code language: C# (cs)

Explanation:

• random.Next(0, 256): Generates an integer from 0 to 255, matching the full valid range of a single byte.
• (byte)random.Next(0, 256): Casts that integer down to a byte, since Next itself returns an int rather than a byte directly.
• (byte R, byte G, byte B) color = (r, g, b): Packages the three separate byte values into a single named tuple, making them easy to pass around or return together.
• ToString("X2"): Formats each byte as exactly two uppercase hexadecimal digits, padding with a leading zero for values below 16 so every channel always contributes exactly two characters to the final string.

using System;

class Program
{
    static void Main()
    {
        Random random = new Random();
        int minMinutes = 30;
        int maxMinutes = 8 * 60;

        int randomMinutes = random.Next(minMinutes, maxMinutes + 1);
        TimeSpan duration = TimeSpan.FromMinutes(randomMinutes);

        Console.WriteLine(duration);
    }
}Code language: C# (cs)

Explanation:

• int maxMinutes = 8 * 60: Converts the 8-hour upper boundary into its equivalent number of minutes, so both boundaries are expressed in the same unit.
• random.Next(minMinutes, maxMinutes + 1): Generates a random integer between 30 and 480 minutes, inclusive, since Next‘s upper bound is normally exclusive.
• TimeSpan.FromMinutes(randomMinutes): Converts the random minute count into a proper TimeSpan value, which automatically handles the conversion into hours, minutes, and seconds internally.
• Console.WriteLine(duration): Prints the TimeSpan using its default format, displaying the duration as hours, minutes, and seconds.

using System;
using System.Collections.Generic;

class User
{
    public Guid Id { get; set; }
    public string Username { get; set; }
    public int Age { get; set; }
    public bool IsActive { get; set; }
}

class Program
{
    static void Main()
    {
        Random random = new Random();
        List<User> users = new List<User>();

        for (int i = 0; i < 100; i++)
        {
            User user = new User
            {
                Id = Guid.NewGuid(),
                Username = "user" + random.Next(100, 1000),
                Age = random.Next(18, 66),
                IsActive = random.Next(0, 2) == 1
            };

            users.Add(user);
        }

        Console.WriteLine("Id: " + users[0].Id + ", Username: " + users[0].Username + ", Age: " + users[0].Age + ", IsActive: " + users[0].IsActive);
    }
}Code language: C# (cs)

Explanation:

• Guid.NewGuid(): Generates a statistically unique identifier for each user, without needing to track previously used values to avoid collisions.
• "user" + random.Next(100, 1000): Builds a simple but varied username by appending a random three-digit number to a fixed prefix.
• random.Next(18, 66): Generates a random age within a realistic adult range, from 18 up to 65 inclusive.
• random.Next(0, 2) == 1: Generates a random boolean by picking either 0 or 1 and comparing it to 1, since Random doesn’t have a dedicated method for generating booleans directly.

using System;

class Program
{
    static void Main()
    {
        Random random = new Random();
        int firstOctet;

        do
        {
            firstOctet = random.Next(0, 256);
        } while (firstOctet == 0);

        int secondOctet = random.Next(0, 256);
        int thirdOctet = random.Next(0, 256);
        int fourthOctet = random.Next(0, 256);

        string ipAddress = firstOctet + "." + secondOctet + "." + thirdOctet + "." + fourthOctet;
        Console.WriteLine(ipAddress);
    }
}Code language: C# (cs)

Explanation:

• do { firstOctet = random.Next(0, 256); } while (firstOctet == 0);: Keeps regenerating the first octet specifically until it produces a value other than 0, avoiding the reserved 0.0.0.0-style address.
• The remaining three octets: Each generated independently using the full 0-to-255 range, since only the first octet needs the extra restriction in this exercise.
• String concatenation with periods: Joins the four octet values into the standard dotted format expected of an IPv4 address.
• do-while loop: Chosen over a plain if check because it guarantees the value is generated at least once and keeps retrying only when the excluded case actually occurs.

using System;
using System.Text;

class Program
{
    static int CalculateLuhnCheckDigit(string digits)
    {
        int sum = 0;
        bool doubleDigit = true;

        for (int i = digits.Length - 1; i >= 0; i--)
        {
            int digit = digits[i] - '0';

            if (doubleDigit)
            {
                digit *= 2;
                if (digit > 9)
                {
                    digit -= 9;
                }
            }

            sum += digit;
            doubleDigit = !doubleDigit;
        }

        int remainder = sum % 10;
        return remainder == 0 ? 0 : 10 - remainder;
    }

    static void Main()
    {
        Random random = new Random();
        StringBuilder cardDigits = new StringBuilder();

        for (int i = 0; i < 15; i++)
        {
            cardDigits.Append(random.Next(0, 10));
        }

        int checkDigit = CalculateLuhnCheckDigit(cardDigits.ToString());
        string cardNumber = cardDigits.ToString() + checkDigit;

        Console.WriteLine(cardNumber);
    }
}Code language: C# (cs)

Explanation:

• for (int i = 0; i < 15; i++): Generates the first fifteen digits of the card number completely at random, one at a time.
• CalculateLuhnCheckDigit: Implements the Luhn algorithm, doubling every second digit counted from the right and subtracting 9 whenever that doubled value exceeds 9, then summing every digit together.
• 10 - remainder: Determines the specific check digit needed to bring the total sum up to the next multiple of 10, which is the exact rule the Luhn algorithm’s validation check relies on.
• Appending the check digit last: Completes the 16-digit number so that running the same Luhn calculation over the full number, including the new check digit, confirms it as valid.

using System;
using System.Collections.Generic;

class Program
{
    static Random random = new Random();

    static void Shuffle<T>(List<T> list)
    {
        for (int i = list.Count - 1; i > 0; i--)
        {
            int j = random.Next(0, i + 1);
            T temp = list[i];
            list[i] = list[j];
            list[j] = temp;
        }
    }

    static void Main()
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
        Shuffle(numbers);

        Console.WriteLine(string.Join(", ", numbers));
    }
}Code language: C# (cs)

Explanation:

• static void Shuffle<T>(List<T> list): The <T> type parameter lets this single method shuffle a list of integers, strings, or any other type without rewriting it for each one.
• for (int i = list.Count - 1; i > 0; i--): Walks backward through the list, treating each position as the “current” slot to be finalized.
• random.Next(0, i + 1): Picks a random index from anywhere in the still-unshuffled portion of the list, including the current position itself.
• Swapping list[i] and list[j]: Exchanges the two elements in place, which is what makes Fisher-Yates modify the original list directly rather than producing a new one.

using System;

class Program
{
    static void Main()
    {
        Random random = new Random();
        string[] cities = { "Tokyo", "Paris", "Cairo", "Lima", "Oslo" };

        for (int i = 0; i < 5; i++)
        {
            string selected = cities[random.Next(cities.Length)];
            Console.WriteLine(selected);
        }
    }
}Code language: C# (cs)

Explanation:

• cities[random.Next(cities.Length)]: Picks one random element from the array using a freshly generated random index each time.
• Independent picks: Since every loop iteration generates a brand new random index without excluding any previous selections, the same city can legitimately appear more than once in the results.
• for (int i = 0; i < 5; i++): Controls the total number of picks, regardless of how many distinct values end up appearing.
• No tracking needed: Unlike selection without replacement, this approach doesn’t need to remove or mark previously chosen elements, since repeats are allowed by design.

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

class Program
{
    static void Main()
    {
        Random random = new Random();
        List<string> items = new List<string>();

        for (int i = 1; i <= 10; i++)
        {
            items.Add("Item" + i);
        }

        List<string> selected = items.OrderBy(x => random.Next()).Take(3).ToList();

        Console.WriteLine(string.Join(", ", selected));
    }
}Code language: C# (cs)

Explanation:

• items.OrderBy(x => random.Next()): Reorders the entire list into a random sequence by sorting according to a freshly generated random number for each element.
• .Take(3): Grabs the first three elements from that shuffled sequence, effectively selecting three random items from the original list.
• Guaranteed uniqueness: Since OrderBy simply rearranges existing elements rather than duplicating them, no single item can appear twice in the shuffled sequence or in the final selection.
• .ToList(): Converts the resulting LINQ query into a concrete List<string>, so it can be printed, stored, or passed around like any other list.

using System;

class Program
{
    static string GetWeightedRandomItem(string[] items, int[] weights)
    {
        Random random = new Random();
        int totalWeight = 0;

        foreach (int weight in weights)
        {
            totalWeight += weight;
        }

        int randomValue = random.Next(0, totalWeight);

        for (int i = 0; i < items.Length; i++)
        {
            if (randomValue < weights[i])
            {
                return items[i];
            }
            randomValue -= weights[i];
        }

        return items[items.Length - 1];
    }

    static void Main()
    {
        string[] items = { "Common Item", "Rare Item", "Epic Item" };
        int[] weights = { 80, 15, 5 };

        string result = GetWeightedRandomItem(items, weights);
        Console.WriteLine(result);
    }
}Code language: C# (cs)

Explanation:

• int totalWeight: Sums every weight in the array together, establishing the full range that the random number needs to cover.
• random.Next(0, totalWeight): Generates a single random number somewhere within that combined range, from 0 up to just under the total.
• if (randomValue < weights[i]): Checks whether the random number falls within the current item’s “slice” of the total range; if so, that item is the selected result.
• randomValue -= weights[i]: Shrinks the random number by the current item’s weight whenever it doesn’t fall within that item’s slice, moving on to check the next item’s slice using the same, now-reduced number.

using System;

class Program
{
    static string GetWeightedRandomItem(string[] items, int[] weights)
    {
        Random random = new Random();
        int totalWeight = 0;

        foreach (int weight in weights)
        {
            totalWeight += weight;
        }

        int randomValue = random.Next(0, totalWeight);

        for (int i = 0; i < items.Length; i++)
        {
            if (randomValue < weights[i])
            {
                return items[i];
            }
            randomValue -= weights[i];
        }

        return items[items.Length - 1];
    }

    static void Main()
    {
        string[] items = { "Common Item", "Rare Item", "Epic Item" };
        int[] weights = { 80, 15, 5 };

        string result = GetWeightedRandomItem(items, weights);
        Console.WriteLine(result);
    }
}Code language: C# (cs)

Explanation:

• int totalWeight: Sums every weight in the array together, establishing the full range that the random number needs to cover.
• random.Next(0, totalWeight): Generates a single random number somewhere within that combined range, from 0 up to just under the total.
• if (randomValue < weights[i]): Checks whether the random number falls within the current item’s “slice” of the total range; if so, that item is the selected result.
• randomValue -= weights[i]: Shrinks the random number by the current item’s weight whenever it doesn’t fall within that item’s slice, moving on to check the next item’s slice using the same, now-reduced number.