• 카테고리

    질문 & 답변
  • 세부 분야

    프로그래밍 언어

  • 해결 여부

    미해결

5.9 난수 만들기, rand()를 쓸 때 계속 같은 숫자가 나오는 이유

22.02.23 22:04 작성 조회수 704

0

안녕하세요, 

<5.9 난수 만들기> 강의를 듣다 궁금한 점이 생겨 질문을 남깁니다. 

std::time을 사용해 seed를 random하게 생성하는데도 불구하고,

rand()로 여러 숫자를 출력할때, build를 다시했는데도 첫 숫자가 항상 동일하게 나옵니다. 

50개 숫자 중 나머지 49개는 다 다르게 나옵니다. 첫번째 숫자만 같은 숫자로 계속 나와요. (62로...)

이유가 무엇일까요? 

 

 

답변 1

답변을 작성해보세요.

1

강민철님의 프로필

강민철

2022.02.23

안녕하세요 :)

흠..

제 생각에는 코드 상의 문제라기보다는 컴파일러, 즉 Visual Studio와 연관이 있는 것 같습니다.

다른 컴파일러, 이를테면 g++이나 clang++으로 빌드했을 때에는 아래와 같이 잘 빌드되거든요.

아래는 g++ 컴파일러로 빌드 후 반복 실행한 결과입니다.

$ g++ rand.cpp
$ ./a.out
29      3       90      38      92
31      58      28      38      56
72      9       27      54      28
79      8       89      68      75
81      87      100     1       67
81      73      14      5       44
21      34      47      10      71
38      40      28      66      78
84      37      87      10      90
14      89      98      3       57
73      84      43      72      84
10      53      57      23      57
1       43      90      47      53
60      85      93      88      50
70      71      87      56      81
77      70      70      75      73
26      47      56      68      19
40      77      71      97      100
27      97      43      16      44
96      76      28      88      63
$ ./a.out
87      27      81      34      73
97      17      67      30      32
25      8       48      20      26
18      13      69      27      74
3       79      62      63      37
25      37      24      34      39
57      20      66      37      54
38      34      70      4       63
2       29      71      49      48
96      66      61      65      92
34      67      70      96      30
7       21      67      30      54
5       86      74      70      23
27      8       56      96      11
19      98      39      89      46
87      85      11      47      49
3       81      16      73      76
45      79      96      11      9
50      16      95      23      86
17      49      93      73      45
$ ./a.out
58      9       41      47      59
91      88      25      40      98
26      90      77      79      23
59      98      20      14      55
66      88      51      85      31
19      76      60      100     99
77      57      7       17      4
66      7       92      90      47
90      16      36      66      94
59      25      92      78      38
46      44      25      96      29
56      15      4       16      14
3       93      71      10      9
75      75      16      67      64
63      56      79      98      22
73      57      46      64      35
84      10      78      8       6
6       64      20      10      79
34      12      71      4       21
80      79      95      96      45

 

그리고 아래는 clang++으로 빌드한 결과입니다.

$ clang++ rand.cpp
$ ./a.out
13      34      16      88      32
89      18      78      43      53
66      28      90      71      94
25      74      32      100     43
4       79      78      12      64
23      20      70      80      82
82      92      15      98      80
46      86      97      23      28
49      89      56      39      59
49      63      33      80      63
75      84      42      53      96
6       75      16      75      55
97      57      46      11      54
25      57      40      22      80
67      71      69      22      9
28      71      72      60      51
35      34      35      76      87
30      81      61      46      56
15      42      12      61      53
66      86      10      5       8
$ ./a.out
71      8       57      35      63
5       77      17      84      79
70      27      11      37      42
64      29      11      9       92
77      72      41      24      84
69      84      30      10      77
68      80      84      25      15
46      30      91      62      13
69      32      40      79      68
81      43      97      92      52
89      68      23      29      91
6       98      75      36      7
51      4       87      35      28
1       81      57      91      43
70      60      74      10      39
42      90      81      39      82
32      27      49      54      56
40      60      53      14      96
60      65      99      46      99
27      46      80      83      37
$ ./a.out
92      41      18      99      100
100     49      26      96      46
72      10      91      48      41
56      66      15      48      25
92      83      32      49      81
66      27      20      79      91
93      71      31      10      70
31      9       18      56      5
64      28      14      55      75
54      10      41      69      58
65      60      41      97      9
21      62      36      41      40
27      33      11      57      43
80      88      51      98      43
56      61      70      69      15
45      23      25      85      92
83      50      52      23      46
60      44      7       96      84
47      22      17      57      79
59      37      66      10      35

 

그리고, Visual Studio 2017에서 Clean Solution을 한 뒤,

(Visual Studio를 껐다) 일정 시간이 지나고 다시 실행하면

아래와 같이 서로 다른 수가 나옵니다.

# 1차 시도
15      72      27      20      13
30      88      45      55      23
68      10      40      71      86
35      97      72      65      87
94      70      53      1       25
26      10      46      95      63
2       50      81      92      5
3       8       9       77      58
4       35      95      22      71
14      12      1       47      47
47      48      88      50      43
100     47      34      9       57
80      97      98      72      56
8       17      20      1       95
35      2       47      97      73
72      22      9       51      18
62      67      80      3       62
6       53      89      46      51
48      54      1       44      86
25      24      99      52      29	


# 2차 시도
17      18      2       90      59
51      45      17      93      64
65      40      77      34      60
46      75      36      33      83
2       95      54      61      42
87      71      59      17      84
81      92      31      9       88
86      32      87      50      11
29      65      42      45      25
86      41      90      69      82
60      29      8       87      29
38      49      11      65      51
91      6       16      85      57
42      21      17      69      23
82      39      10      88      84
62      14      90      49      4
10      28      77      44      89
9       51      53      3       16
62      6       63      70      22
74      58      47      37      100

# 3차 시도
19      88      24      55      87
31      73      91      64      49
83      64      73      24      86
76      70      69      50      49
42      93      94      57      52
29      6       10      68      7
47      32      69      94      35
50      74      86      93      25
69      69      64      58      92
43      68      94      52      18
12      51      30      79      12
10      46      36      61      83
49      40      84      96      91
96      24      12      59      44
96      22      35      48      45
33      23      59      62      75
52      88      89      72      73
60      52      78      61      88
68      41      43      30      66
82      64      80      60      61

 

너무 바로 반복적으로 시도하지 마시고,

Clean Soultion을 해보신 뒤 시간이 충분히 지나고 다시 실행해보세요! 

안녕하세요? 

답변 정말 감사드립니다! 

궁금한 점이 남아있어 구글에서 열심히 찾아봤어요. 

말씀하신것 처럼 일정 시간이 지나면 첫번째 숫자가 바뀌기 시작합니다. 

검색 결과에 따르면 이건 아마 std::time(0) 자체의 limitation인것 같아요. 

The issue is that the random number generator is being seeded with a values that are very close together - each run of the program only changes the return value of time() by a small amount - maybe 1 second, maybe even none! The rather poor standard random number generator then uses these similar seed values to generate apparently identical initial random numbers. Basically, you need a better initial seed generator than time() and a better random number generator than rand().

time의 값을 초단위로 보면 아주 살짝만 바뀐다고 하네요. 그렇기에 짧은 시간 내에 연속 해서 run하면, 매우 비슷한 seed 숫자가 계속 넣어지는게 원인이었던것 같아요. seed가 거의 동일하기 때문에 비슷해 보이는 값이 출력이 됐던걸로 보입니다. 

그러니 random numbers를 정밀하게 만들어야 한다면.. time()은 쓰지 않는거로 ㅎㅎ..

https://stackoverflow.com/questions/3032726/rand-generating-the-same-number-even-with-srandtimenull-in-my-main

 

강민철님의 프로필

강민철

2022.02.24

아하 흥미롭네요.

리눅스에서는 실시간으로 바뀌는데 말이죠..

좋은 정보 감사합니다.