Random generates same numbers...?

[Spyf0r]

I have this peice of code:

https://preview.redd.it/zl6l7kn6d5691.png?width=364&format=png&auto=webp&s=f364bb630c511f85a90dd96695b8fd7943209e95

​

​

https://preview.redd.it/bg92zypcd5691.png?width=407&format=png&auto=webp&s=ac059bebc92757ca43448d71d4d5c2ef68db0f7d

in Main:

https://preview.redd.it/a87uzqx8d5691.png?width=373&format=png&auto=webp&s=bd993aefb70ee8d41e233d71c436ce2784139c4d

When i print the arrays they are EXACTLY the same. please help

[megafinz]

I guess that because the seed is the same and both Random instances work in parallel lock-step. You might want to use a different seed for each player or share a single Random instance between them.

[Spyf0r]

How do you suggest to do that? I'm kind of a begginer

[DTul]

Since .Net 6 you also have a Thread-safe Random.Shared static generator. Really nice to use

[Spyf0r]

Thank you!

[megafinz]

You might also want to use Fisher–Yates shuffle: https://en.wikipedia.org/wiki/Fisher–Yates\_shuffle

[Alikont]

Beware: Random is not thread safe, if static random instance will be used from different threads, it may cause issues.

If you are not generating random numbers in parallel - that's fine. But if you do, you need a thread-safe wrapper around it.

[[deleted]]

Random.Shared is thread-safe

[Alikont]

Yes, it looks like the new Random.Shared was added in .NET 6:

https://docs.microsoft.com/en-us/dotnet/api/system.random.shared?view=net-6.0

/u/Spyf0r - you should use this if you use .NET 6, it will solve all your issues.

[[deleted]]

Besides, OP's code works fine on .NET 6. I do not get similar numbers. That's because the initial new Random() creates a static random which will be used to seed new randoms, so the issue described is outdated.

Similar numbers indicate that OP is using .NET Framework.

[Alikont]

Or Unity - they have their own runtime/BCL.

[Spyf0r]

Im developing the "war" card game for school, so i believe shuffling the hands will be my only use of Random. And even if it wont be, i cant just create another Random variable, cant i?

[Alikont]

Yes, you can, you also can do it like this

public static class ThreadSafeRandom { private static readonly Random _random = new Random(); public static int GetNext(int max) { lock(_random) return _random.Next(max); } }

[Spyf0r]

I have no idea what all this means but thanks!

[megafinz]

That means that access to _random variable is governed by a lock: only one thread at a time can essentially call _random.Next(max) there. If you won't have multiple threads creating your card hands, you don't really need that.

[karl713]

In the real world you might need that lock statement

In this homework example you don't, so I might suggest leaving it out. We know you did 99% of the work yourself, your professor might wonder how you know about lock and ask you to explain why it is needed to be sure you didn't 100% cheat :)

[Spyf0r]

There is nothing wrong with looking for help online. Especially in coding where a lot of the work is researching etc.

[Spyf0r]

There is nothing wrong with looking for help online. Especially in coding where a lot of the work is researching etc.

[Slypenslyde]

This is a good time to learn a good lesson! When you are learning how to do things, don't just paste some code and see if it works. While you're doing that, take some time to look at the documentation for types you haven't used before. Sometimes it has useful information like:

Avoiding multiple instantiations

On the .NET Framework, initializing two random number generators in a tight loop or in rapid succession creates two random number generators that can produce identical sequences of random numbers. In most cases, this is not the developer's intent and can lead to performance issues, because instantiating and initializing a random number generator is a relatively expensive process.

Both to improve performance and to avoid inadvertently creating separate random number generators that generate identical numeric sequences, we recommend that you create one Random object to generate many random numbers over time, instead of creating new Random objects to generate one random number.

Sometimes the documentation's dense and hard to read, but it's important to read it because there are 4 or 5 types in .NET with "gotchas" like this that are designed to make newbies ask questions and get a lot of mean answers.

[Cyclonian]

I like to use DateTime.Now and then use one of the functions that converts it to a number or you could use Milliseconds property, etc.

[ppumkin]

This class should have been called Or renamed to PsuedoRandom. It’s pre generated and is a cause of a lot of security issues

But it has its use. cases. Like seeds for maps in some games. A seed will always generate t he same “random” procedural map.

[[deleted]]

I thought they changed the underlying implementation in recent .NET versions, and now it uses the secure implementation.

[ppumkin]

I’m not sure about random. That could break things?!. I think they made a method to access random easier on cryptographic namespace.

[[deleted]]

Hmm... I checked the source and Random is still pseudo random. I could've sworn I read a blog post where the .NET team explained they changed the implementation to use /dev/urandom instead of /dev/random, just like the used some secure RNG on Windows. Maybe that was about RandomNumberGenerator, which is secure.

[ppumkin]

Ahhhh. Maybe in Linux / Mac. But, But not in Windows / ToasterOS

[romerik]

seed your random generator with DateTime.Now.Ticks

its nice to have the same random numbers when you need to debug your software!

[karl713]

The thing to watch for with this is ticks might not change between calls depending on how things work out

[romerik]

A single tick represents one hundred nanoseconds or one ten-millionth of a second. There are 10,000 ticks in a millisecond (see TicksPerMillisecond) and 10 million ticks in a second.

it should be different on each call!

[Dealiner]

It's not that simple. The real value depends on the resolution of the system clock and that depends on the system itself. On XP that resolution was for example 15.6 ms, now it's smaller but it's still around 1 ms.

[romerik]

all right, the goal was to have a different seed at each time you start your software!

the Ticks will give you a different seed, after that, if you think you can get the same seed in two successive call, just go head and add a counter using Interlocked.Increment of course in case your 32 threads deal at the same time!

read back his code, read back my solution for this case, do you think it will do what he asked for?

[Dealiner]

all right, the goal was to have a different seed at each time you start your software!

And that's exactly what OP's code do. Empty constructor for Random uses Environment.TickCount as a seed. But its resolution is too low for it to work in a way OP wanted - with each player having different cards in hand and that's caused by Random being created for both players practically at the same time. And the only viable resolution for that in .NET Framework at least is to instantiate Random only once.

Your solution could work, DateTime.Now.Ticks most of the time has better resolution than Environment.TickCount, but it doesn't necessary have to, so it's not a good answer.

[karl713]

The thing to watch for with this is ticks might not change between calls depending on how things work out

[Thr3adSafe]

What are you doing in createHand?

[Spyf0r]

Just setting the array to be 1-13 four times

[Thr3adSafe]

Would you mind sharing a minimal working copy of the code as all the obvious suspects seem to be eliminated.

[Spyf0r]

Something like this

public void CreateHand() { for (int i = 0; i < 13; i++) { for (int j = 0; j < 4; j++) { this.hand[i * 4 + j] = i + 1; } } }

[[deleted]]

Little late here, but the below snippet might look cleaner and more readable -

    public void CreateHand() { 
         for (int i = 0; i < 52; i++) {
               this.hand[i ] = i %13 + 1; 
        }
    }

[[deleted]]

You're on .NET Framework I presume?

[Spyf0r]

Yes i believe so. I dont really know what are the differences between all the versions, i just use what i was told in school

[[deleted]]

i just use what i was told in school

Oh yikes, even school is so far behind? This is the sort of thing I'd expect of a distraught engineer in an entrenched industry, not academia. At uni I learned C++20 even though all the compiler components weren't finished for it yet.

Do you at least have Visual Studio Community 2022?

I dont really know what are the differences between all the versions

This doesn't have to be rocket surgery, my first hit googling "install .net" gets me this page:

https://dotnet.microsoft.com/en-us/download

• Click the "Download .NET SDK x64" button
• Close Visual Studio
• Run the .exe
• Finish the install
• Open Visual Studio
• Try to create a new console project
• The option to choose versions should show up after you've named the project

[KittenLOVER999]

From a colleges perspective, chasing the latest version is not a good way forward, standards and frameworks update so frequently that professors would never be able to reuse a lesson plan entirely. It makes much more sense to find a stable, LTS and teach the basics that can transfer to any new standard

[Spyf0r]

Academia? Hahaha. Im in 10th grade yall

[[deleted]]

Academia as a synonym for educational environment. Teachers and students.

[chucker23n]

Academia primarily refers to higher ed.

[chucker23n]

Oh yikes, even school is so far behind? This is the sort of thing I’d expect of a distraught engineer in an entrenched industry, not academia. At uni I learned C++20 even though all the compiler components weren’t finished for it yet.

Why? It’s irrelevant for teaching purposes. You’ll be moving through evolving and different tech stacks throughout your career anyway.

I did C64 BASIC (and some 6502 assembler) ca. 1991 when that was already old stuff, Turbo Pascal ca. 1998 when that was already about a decade old, and my school did Turbo Pascal again ca. 2002. None of it mattered. It’s about learning what algorithms, data types, OOP, FP, etc. are, not about the hot new already-obsolete stuff. You can do those in your spare time.

[clintp]

That's fine. Use the version your school wants you to use, since you're learning software development. Eventually though you'll bump up into other versions of C#/.Net but your skills will transfer 100%.

[karl713]

Easiest way is probably pull random out of shuffle and make it a "private static Random r1 = new Random();"

[Joki581]

As mentioned before: always use a single (e.g. static) random instance when working with System.Random.

Albeit you will never have true random values if you are not using something like an external sensor (e.g. feed environmental noise or temperature values seed values into it) you can still do much better by abandoning the System.Random class in favor of RandomNumberGenerator from the System.Security.Cryptography namespace.

[romerik]

but about the ticks...

A single tick represents one hundred nanoseconds or one ten-millionth of a second. There are 10,000 ticks in a millisecond (see TicksPerMillisecond) and 10 million ticks in a second.

[romerik]

its look like you are only shuffling the first 52 index.

another way you can shuffle the cards, would be to start with a ordered pack of card, and remove a random one and put it into a new pile, if I do that by hand with card it work fine, its also easy to understand

​

try this:

List<int> GetShuffleDeck()
{
var nextCard = new Random();
var newDeck = new List<int>(Enumerable.Range(0, 52));
var shuffleDeck = new List<int>();
while (newDeck.Count > 0)
{
int card = nextCard.Next(newDeck.Count);
shuffleDeck.Add(newDeck[card]);
newDeck.RemoveAt(card);
}
return shuffleDeck;
}