• SEARCH

    통합검색
세모계
    • Dark Mode
    • GNB Always Open
    • GNB Height Maximize
    • Color
    • Brightness
    • SINCE 2015.01.19.
    • 세모계 세모계
    •   SEARCH
    • 세상의 모든 계산기  
      • 자유(질문) 게시판  
      • 계산기 뉴스/정보  
      • 수학, 과학, 공학 이야기  
      • 세모계 : 공지 게시판  
        • 구글 맞춤검색  
      • 세상의 모든 계산기  
        • 자유(질문) 게시판  
    • TI  
    • CASIO  
    • HP  
    • SHARP  
    • 일반(쌀집) 계산기  
    • 기타계산기  
    • 세모계
    • by ORANGEDAY
  • 세상의 모든 계산기 수학, 과학, 공학 이야기
    • 세상의 모든 계산기 수학, 과학, 공학 이야기 확률통계
    • 스피드런, 모든 스테이지 클리어 시, "총 플레이타임 < 최소 시간 기록" 일 확률은?

    • Profile
      • 세상의모든계산기
        *.105.205.197
      • 2024.09.04 - 21:52 2024.09.04 - 08:59  107  7

    게임 설정


    총 스테이지 : 60 stages 


    스테이지 타입 : 3 中 1 랜덤 확률로 등장
    - A타입 = 52% 확률, 클리어 타임 20초

    - B타입 = 25% 확률, 클리어 타임 100초
    - C타입 = 23% 확률, 클리어 타임 60초

    총 스테이지 60개를 모두 끝냈을 때, 

    최소 시간 기록(36분50초=2210초) 미만일 확률은?

     

    * 각 스테이지는 연속 플레이하는 것으로 한다. 

     

    image.png

     

    0
    0
    Attached file
    image.png 3.6KB 9
    이 게시물을..
    • 세상의모든계산기 세상의모든계산기 Lv. 25

      계산기는 거들 뿐
      혹은
      계산기를 거들 뿐

     댓글 7

      • Profile
      • 세상의모든계산기 (*.105.205.197) 2024.09.04 09:00 #comment_46575

        클라우드 3.5 Sonnet 답변


        이 문제를 해결하기 위해 단계별로 접근해 보겠습니다.

        1. 먼저 각 타입의 평균 등장 횟수와 총 클리어 시간을 계산합니다:
           A 타입: 60 * 0.52 = 31.2회, 31.2 * 20초 = 624초
           B 타입: 60 * 0.25 = 15회, 15 * 100초 = 1500초
           C 타입: 60 * 0.23 = 13.8회, 13.8 * 60초 = 828초

        2. 평균 총 클리어 시간:
           624 + 1500 + 828 = 2952초 = 49분 12초

        3. 표준편차를 계산하기 위해 각 타입의 분산을 구합니다:
           A 타입: (20 - 49.2)^2 * 0.52 = 445.536
           B 타입: (100 - 49.2)^2 * 0.25 = 645.04
           C 타입: (60 - 49.2)^2 * 0.23 = 26.772

        4. 총 분산:
           (445.536 + 645.04 + 26.772) * 60 = 67040.88

        5. 표준편차:
           sqrt(67040.88) = 258.92초 ≈ 4분 19초

        6. 36분 50초는 2210초입니다. 이를 z-점수로 변환합니다:
           z = (2210 - 2952) / 258.92 = -2.87

        7. 이 z-점수에 해당하는 확률을 구합니다:
           P(Z < -2.87) ≈ 0.0021 (0.21%)

        따라서 60개의 스테이지를 36분 50초 미만으로 클리어할 확률은 약 0.21%입니다.

        이 계산에는 중심극한정리를 적용하여 정규분포를 가정했습니다. 실제 분포는 완벽한 정규분포가 아닐 수 있으므로, 이 결과는 근사치임을 유의해야 합니다.

        추가 설명이 필요하거나 다른 질문이 있으시면 말씀해 주세요.

        0
        댓글
      • Profile
      • 세상의모든계산기 (*.105.205.197) 2024.09.04 09:01 #comment_46578

        ChatGPT-4o 답변


        우선, 각 타입의 스테이지가 등장할 확률을 기반으로, 예상되는 클리어 타임을 계산한 후, 이를 사용하여 60개 스테이지를 모두 클리어하는데 걸리는 시간을 구하고, 이를 통해 36분 50초(2,210초) 미만일 확률을 계산해야 합니다.

         1. 예상되는 클리어 타임 계산
        각 타입의 스테이지가 등장할 확률과 각 타입의 클리어 타임을 사용하여 예상되는 평균 클리어 타임을 계산합니다.

        - A 타입: 20초 (52% 확률)
        - B 타입: 100초 (1분 40초) (25% 확률)
        - C 타입: 60초 (1분) (23% 확률)

        평균 클리어 타임은 다음과 같이 계산됩니다.

        \[
        E(\text{Time}) = 0.52 \times 20 + 0.25 \times 100 + 0.23 \times 60
        \]

         2. 60개 스테이지의 총 클리어 타임 계산
        총 클리어 타임은 위에서 계산한 평균 클리어 타임에 60을 곱한 값입니다.

        \[
        \text{Total Expected Time} = 60 \times E(\text{Time})
        \]

         3. 36분 50초 미만일 확률
        클리어 타임이 36분 50초 미만일 확률은 정규분포를 사용하여 구할 수 있습니다. 이를 위해 필요한 것은 예상 총 클리어 타임의 분산과 표준 편차입니다.

         4. 계산 수행

        from scipy.stats import norm
        
        # 각 타입의 확률과 클리어 타임
        prob_A = 0.52
        prob_B = 0.25
        prob_C = 0.23
        
        time_A = 20  # A 타입 클리어 타임 (초)
        time_B = 100  # B 타입 클리어 타임 (초)
        time_C = 60  # C 타입 클리어 타임 (초)
        
        # 예상 클리어 타임 계산 (초 단위)
        expected_time_per_stage = (prob_A * time_A) + (prob_B * time_B) + (prob_C * time_C)
        
        # 60개 스테이지의 예상 총 클리어 타임
        total_expected_time = 60 * expected_time_per_stage
        
        # 각 타입의 분산 계산
        variance_A = prob_A * (time_A - expected_time_per_stage) ** 2
        variance_B = prob_B * (time_B - expected_time_per_stage) ** 2
        variance_C = prob_C * (time_C - expected_time_per_stage) ** 2
        
        # 총 분산과 표준 편차 계산
        total_variance_per_stage = variance_A + variance_B + variance_C
        total_variance = 60 * total_variance_per_stage
        total_std_dev = total_variance ** 0.5
        
        # 36분 50초 = 2210초 미만일 확률 계산
        target_time = 2210  # 36분 50초 (초 단위)
        
        # 정규 분포를 사용하여 36분 50초 미만일 확률 계산
        probability = norm.cdf(target_time, total_expected_time, total_std_dev)
        total_expected_time, total_std_dev, probability

        결과

        (2952.0, 258.69209497006284, 0.002063584899531624)


        이제 각 단계에 대한 계산을 수행하여 최종 확률을 구하겠습니다.

        60개의 스테이지를 모두 클리어하는 데 예상되는 평균 시간은 2,952초(49분 12초)이며, 표준 편차는 약 258.7초입니다.

        36분 50초(2,210초) 미만으로 클리어할 확률은 약 0.206%입니다. 이는 매우 낮은 확률입니다.

        0
        댓글
      • Profile
      • 세상의모든계산기 (*.105.205.197) 2024.09.04 09:15 #comment_46581

        (오답이지만 위의 2개 답변에 대하여) TI-nspire 로 확인


        image.png

         

         

        Attached file
        image.png 58.5KB / 8
        0
        댓글
      • Profile
      • 세상의모든계산기 (*.105.205.197) 2024.09.04 09:21 #comment_46585

        네이버 지식인 답변 : cr42****


         

        일단 어떤 상황일떄 시간 조건을 만족하나 보면

        60개 중 A,B,C가 a,b,c개 등장한다고 하면 소요시간은

        20a+100b+60c 초입니다. 이것이 36×60 + 50 = 2210초 미만이어야 합니다.

        20a+100b+60c<2210

        2a+10b+6c<221

        a+5b+3c<110.5

        a,b,c정수이므로 결국

        a+5b+3c≤110

        a+b+c + 4b+2c≤110

        60 + 4b+2c≤110

        4b+2c≤50

        2b+c≤25 를 만족하면 됩니다.

        ​

        이를 만족하는 (b,c)의 쌍은 b = k일때 c는 0에서 25-2k까지 26-2k)개 가능하므로

        Σ(k=0~12) (26-2k) = 26×13 - 2×12×13/2 = 26×13 - 12×13 = 14×13 = 182개 상황이 생깁니다.

        각 경우마다 a = 60-b-c로 구해지므로

        결국 조건을 만족하는 (a,b,c)의 쌍은 총 182개가 생깁니다.

        ​

        각 경우마다 (a+b+c)!/{a!*b!*c!} × 52%^a × 25%^b × 23%^c로 확률을 구할 수 있고

        그 확률 182개를 합친 것이 전체 목표한 확률이 됩니다.

        ​

        저 182개를 일일이 할 생각은 없고

        엑셀로 해 보니 총 확률은 약 0.162% 정도 됩니다.

        600번에 한 번이 좀 안 되는 확률입니다.

        ​

        ​

        엑셀로 한 것은 다음과 같습니다.

        (참고로 D2의 수식은 =+FACT(60)/FACT(A2)/FACT(B2)/FACT(C2)*52%^A2*25%^B2*23%^C2 로 넣었습니다.)

        전체 확률

        0.1620868923%

        0
        댓글
      • Profile
      • 세상의모든계산기 (*.105.205.197) 2024.09.04 09:23 #comment_46588

        파이썬 시뮬레이션 결과


        import random
        
        # 스테이지 타입별 확률과 클리어 시간
        prob_A = 0.52  # A 타입 등장 확률
        prob_B = 0.25  # B 타입 등장 확률
        prob_C = 0.23  # C 타입 등장 확률
        
        time_A = 20    # A 타입 클리어 시간 (초)
        time_B = 100   # B 타입 클리어 시간 (초)
        time_C = 60    # C 타입 클리어 시간 (초)
        
        # 총 스테이지 수와 목표 시간
        num_stages = 60
        target_time = 2210  # 36분 50초 = 2210초
        
        # 시뮬레이션 횟수
        num_simulations = 100000000  # 1억 번 시뮬레이션
        
        # 36분 50초 이하로 클리어한 횟수
        successful_runs = 0
        
        # 시뮬레이션 수행
        for _ in range(num_simulations):
            total_time = 0
        
            for _ in range(num_stages):
                rand = random.random()
                if rand < prob_A:
                    total_time += time_A
                elif rand < prob_A + prob_B:
                    total_time += time_B
                else:
                    total_time += time_C
        
            if total_time <= target_time:
                successful_runs += 1
        
        # 확률 계산
        probability = successful_runs / num_simulations
        
        print(f"60개의 스테이지를 36분 50초 이하로 클리어한 확률: {probability:.6f}")

         

        실행 결과 : 1억회
        60개의 스테이지를 36분 50초 이하로 클리어한 확률: 0.001623
        0
        댓글
      • Profile
      • 세상의모든계산기 (*.105.205.197) 2024.09.04 21:52 #comment_46604

        100만 시뮬레이션 분포 히스토그램


        image.png

         

        import random
        import matplotlib.pyplot as plt
        
        # 스테이지 타입별 확률과 클리어 시간
        prob_A = 0.52  # A 타입 등장 확률
        prob_B = 0.25  # B 타입 등장 확률
        prob_C = 0.23  # C 타입 등장 확률
        
        time_A = 20    # A 타입 클리어 시간 (초)
        time_B = 100   # B 타입 클리어 시간 (초)
        time_C = 60    # C 타입 클리어 시간 (초)
        
        # 총 스테이지 수와 목표 시간
        num_stages = 60
        target_time = 2210  # 36분 50초 = 2210초
        
        # 시뮬레이션 횟수
        num_simulations = 1000000  # 100만 번 시뮬레이션
        
        # 각 시뮬레이션에서의 총 클리어 시간을 저장할 리스트
        total_times = []
        
        # 시뮬레이션 수행
        for _ in range(num_simulations):
            total_time = 0
        
            for _ in range(num_stages):
                rand = random.random()
                if rand < prob_A:
                    total_time += time_A
                elif rand < prob_A + prob_B:
                    total_time += time_B
                else:
                    total_time += time_C
        
            total_times.append(total_time)
        
        # 히스토그램 그리기
        plt.hist(total_times, bins=100, color='skyblue', edgecolor='black')
        plt.axvline(target_time, color='red', linestyle='dashed', linewidth=1)
        plt.title('Distribution of Total Clear Time in Simulations')
        plt.xlabel('Total Clear Time (seconds)')
        plt.ylabel('Frequency')
        plt.show()

         

        Attached file
        image.png 39.0KB / 7
        0
        댓글
      • Profile
      • 세상의모든계산기 (*.105.205.197) 2024.09.04 09:48 #comment_46591

        확률 생성 함수(Probability Generating Function, PGF) 적용시


        이 문제를 해결하기 위해 확률 생성 함수(Probability Generating Function, PGF)를 사용할 수 있습니다.

         

        1. 각 스테이지의 PGF 정의:
           P(s) = 0.52s^20 + 0.25s^100 + 0.23s^60

         

        2. 60개 스테이지의 총 시간에 대한 PGF:
           P_total(s) = [P(s)]^60

         

        3. 2210초 이하의 확률 계산:
           우리가 찾는 확률은 P_total(s)의 s^0부터 s^2210 미만인 계수의 합입니다.

         

        이 계산은 매우 복잡하며, 컴퓨터의 도움 없이는 수행하기 어렵습니다. 파이썬을 사용하여 이 계산을 수행하는 프로그램을 작성해 보겠습니다.

        import numpy as np
        from scipy import stats
        
        def pgf_coefficient(n, k):
            return stats.binom.pmf(k, n, 0.52) * (20**k) * ((100**(n-k)) * 0.25 + (60**(n-k)) * 0.23)
        
        def calculate_exact_probability(max_time=2210, stages=60):
            # 동적 프로그래밍을 사용하여 PGF 계수 계산
            dp = np.zeros(max_time)  # 2210 대신 2209를 사용
            dp[0] = 1
        
            for _ in range(stages):
                new_dp = np.zeros(max_time)
                for i in range(max_time):
                    for j in range(min(i + 1, 101)):  # 100초가 최대 단일 스테이지 시간
                        if j == 20:
                            new_dp[i] += dp[i - j] * 0.52
                        elif j == 60:
                            new_dp[i] += dp[i - j] * 0.23
                        elif j == 100:
                            new_dp[i] += dp[i - j] * 0.25
                dp = new_dp
        
            return np.sum(dp)
        
        if __name__ == "__main__":
            exact_prob = calculate_exact_probability()
            print(f"정확한 확률 (2210초 미만): {exact_prob:.6f}")
            print(f"백분율: {exact_prob * 100:.4f}%")
        실행 결과
        정확한 확률 (2210초 미만): 0.00162086892288
        백분율: 0.162086892288%

         

        이 프로그램은 다음과 같이 작동합니다:

        1. `pgf_coefficient` 함수는 각 스테이지의 PGF 계수를 계산합니다.
        2. `calculate_exact_probability` 함수는 동적 프로그래밍을 사용하여 60개 스테이지의 총 시간에 대한 정확한 확률을 계산합니다.
        3. 최종적으로 2210초 (36분 50초) 미만의 정확한 확률을 계산합니다.

        0
        댓글
    • 댓글 입력
    • 에디터 전환
    댓글 쓰기 에디터 사용하기 닫기
    • 목록 목록
    • 목록
    7
    by OrangeDay
    • 세상의 모든 계산기 수학, 과학, 공학 이야기
    • allcalc.org
    • 세모계 all rights reserved.