도와주세요. - 뎁스노트

도와주세요.

1년 전

안녕하세요, 혼자 파이썬을 공부하고 있는 사람입니다.
현재 class 만들고 function 만드는 연습 문제를 풀고 있는데, 한 부분에서 막혀서 질문드립니다.

투표 프로그램을 파이썬으로 만들고자 하는데, booth의 개수와 impatience\_thresholdf를 조건으로 사용하고자 합니다.
booth가 하나일 때는 코드가 잘 돌아갑니다.

1. 다만 booth가 2개 이상이고, 투표를 하러 온 사람이 직전 사람의 departure time보다 늦게 왔지만 직전보다 그 전사람의 departure time이 투표를 하러 온 사람의 도착 시간보다 빨리 끝나 해당 booth가 비어있을 경우, 투표를 하러 온 사람이 도착한 바로 그 시점에 투표를 가능하도록 만들고 싶은데, 이부분에서 계속 막힙니다. ㅜㅜㅜ

***

* 아래는 결과물인데(booth 개수: 2, impatient\_threshold: 1000), 굵은 글씨로 표시한 voter의 경우 start time이 18.98 이여야 합니다. ㅜㅜ 제 예상은 booth 개수에 대한 조건문이 제대로 작동을 안하는 것 같은데 혹시 아니라면 어떤 부분이 추가/수정 되어야하는지 말씀주시면 감사하겠습니다.
    Arrival Voting Is Start Departure Has
    Time Duration Impatient Time Time Voted

***

13.38 4.37 F 13.38 17.75 T

15.58 0.12 F 17.75 17.86 T

17.92 4.15 F 17.92 22.07 T

**18.98 11.31 T 22.07 33.38 T**

26.54 5.51 F 33.38 38.89 T

29.31 0.71 F 38.89 39.60 T

43.15 5.38 F 43.15 48.54 T

44.97 4.09 T 48.54 52.62 T

49.22 9.52 F 52.62 62.15 T

49.90 18.05 F 62.15 80.19 T

***
* 모법 답안:
*Arrival        Voting             Is             Start         Departure             Has
Time           Duration           Impatient      Time          Time                  Voted
------------------------------------------------------------------------------------------
13.38           4.37                F             13.38         17.75                 T

15.58           0.12                F             15.58         15.70                 T

17.92           4.15                F             17.92         22.07                 T

18.98          11.31                T             18.98         30.29                 T

26.54           5.51                F             26.54         32.05                 T

29.31           0.71                F             30.29         31.00                 T

43.15           5.38                F             43.15         48.54                 T

44.97           4.09                T             44.97         49.06                 T

49.22           9.52                F             49.22         58.74                 T

49.90          18.05                F             49.90         67.94                 T

-----------------------------------------------------------------------------------------------------------------

helper class와 function은 아래와 같고, 제가 만들고자 하는 function은 simulate function 입니다.
제 simulate function에서 어떤 부분이 수정이 되어야하는지 말씀주시면 감사하겠습니다.
(helper class: VotingBooths 클래스는 수정이 불가능한 조건입니다.)

class Voter:
"""
Class for represents a voter in a precinct.

```
Attributes
----------
None

Methods
-------
    __init__(arrival_time, voting_duration, is_impatient): Initializes a Voter instance with the provided attributes.

"""

def __init__(self, arrival_time, voting_duration, is_impatient):
    """
    Initialize a Voter instance.

Args:
        arrival_time (float): The time at which the voter arrives at the precinct.
        voting_duration (float): The time it takes for the voter to complete the voting process.
        is_impatient (bool): A flag indicating whether the voter is impatient.

"""
    self.arrival_time = arrival_time
    self.voting_duration = voting_duration
    self.is_impatient = is_impatient
    self.start_time = None
    self.departure_time = None
    self.has_voted = False

def set_start_time(self, start_time):
    self.start_time = start_time

def set_departure_time(self, departure_time):
    self.departure_time = departure_time

def set_has_voted(self):
    self.has_voted = True
```

class VotingBooths:
"""
Class for representing a bank of voting booths.

```
Attributes
----------
None

Methods
-------
is_booth_available(): boolean
    is there at least one unoccupied booth
is_some_booth_occupied(): boolean
    is there at least one occupied booth
enter_booth(v): 
    add a voter to a booth. requires a booth to be available.
time_next_free(): float
    when will a booth be free next (only called when all the
    booths are occupied)
exit_booth():
    remove the next voter to depart from the booths and
    return the voter and their departure_time.
"""

def __init__(self, num_booths):
    """
    Initialize the voting booths.

Args:
        num_booths: (int) the number of voting booths in the bank
    """

self._num_booths = num_booths
    self._q = queue.PriorityQueue()

def is_booth_available(self):
    """Is at least one booth open"""
    return self._q.qsize() < self._num_booths

def is_some_booth_occupied(self):
    """Is at least one booth occupied"""
    return self._q.qsize() > 0

def enter_booth(self, v):
    """
    Add voter v to an open booth

Args:
        v: (Voter) the voter to add to the booth.

Requirements: there must be an open booth.
    """
    assert self.is_booth_available(), "All booths in use"
    assert v.start_time, "Voter's start time must be set."

dt = v.start_time + v.voting_duration
    self._q.put((dt, v))

def time_next_free(self):
    """
    When will the next voter leave?

Returns: next departure time

Requirements: there must be at least one occupied booth.
    """
    assert self.is_some_booth_occupied(), "No booths in use"

# PriorityQueue does not have a peek method.
    # So, do a get followed by a put.
    (dt, v) = self._q.get()
    self._q.put((dt, v))
    return dt

def exit_booth(self):
    """
    Remove voter with lowest departure time.

Returns: the voter and the voter's departure time

Requirements: there must be at least one occupied booth.
    """
    assert self.is_some_booth_occupied(), "No booths in use"

(dt, v) = self._q.get()
    return v, dtclass Voter:
"""
Class for represents a voter in a precinct.

Attributes
----------
None

Methods
-------
    __init__(arrival_time, voting_duration, is_impatient): Initializes a Voter instance with the provided attributes.

"""

def __init__(self, arrival_time, voting_duration, is_impatient):
    """
    Initialize a Voter instance.

def set_start_time(self, start_time):
    self.start_time = start_time

def set_departure_time(self, departure_time):
    self.departure_time = departure_time

def set_has_voted(self):
    self.has_voted = True
```

```
random.seed(seed)
voters = []
current_time = 0
start_time = 0  # Initialize start_time
for i in range(self.num_voters):
    gap, duration, impatience = util.gen_voter_parameters(self.arrival_rate, self.voting_duration_rate, self.impatience_prob)
    arrival_time = current_time + gap
    if arrival_time > self.hours_open * 60:
        # Discard late voters and stop generating.
        break

voter = Voter(arrival_time, duration, impatience)
    voters.append(voter)
    current_time = arrival_time

# Update start_time for the next voter
    start_time += duration

return voters
```

def simulate(self, seed, voting\_booths, impatience\_threshold):
"""
Simulate election day for the precinct using the specified seed,
voting\_booths, and impatience threshold.

```
Args:
    seed: (int) the seed for the random number generator
    voting_booths: (VotingBooths) the voting booths assigned to the
        precinct for the day
    impatience_threshold: (int) the number of minutes an impatient voter
        is willing to wait (inclusive)

Returns: (list of Voter) the list of Voters
"""

voters = self.__generate_voters__(seed)
voters.sort(key=lambda x: x.arrival_time)  # Sort the voters by arrival time

for i, voter in enumerate(voters):
    prev_voter = voters[i - 1] if i > 0 else None
    if i == 0:
        start_time = voter.arrival_time
    else:
        if prev_voter.departure_time is not None and voting_booths.is_booth_available():
            start_time = max(prev_voter.departure_time, voter.arrival_time)
        elif prev_voter.departure_time is not None and voter.arrival_time > prev_voter.departure_time:
            start_time = voter.arrival_time  # Use voter's arrival time
            if voting_booths.is_some_booth_occupied():
                start_time = min(voter.arrival_time, voting_booths.time_next_free())
        else:
            start_time = voter.arrival_time

if voter.is_impatient and (start_time - voter.arrival_time) > impatience_threshold * 3:
        # Voter leaves without voting
        start_time = None  # Set "Start Time" to None
        departure_time = None  # Set "Departure Time" to None
    else:
        departure_time = start_time + voter.voting_duration

voter.set_start_time(start_time)

if not voter.has_voted:
        if start_time is not None:
            voting_booths.enter_booth(voter)
            voter.set_departure_time(departure_time)
            voter.set_has_voted()

while voting_booths.is_some_booth_occupied():
        voter, departure_time = voting_booths.exit_booth()
        voter.set_has_voted()
        voter.set_departure_time(departure_time)

return voters
```

214

뎁스_2599

1년 전

댓글 2

답변 작성

이미지 첨부

피토니

코드를 분석해보면, simulate 함수에서 투표 부스에 접근하고 투표하는 로직에 문제가 있는 것 같습니다. 코드를 단계별로 해석하고 어떻게 수정할 수 있는지 살펴보겠습니다.

우선, simulate 함수의 로직을 단순화하기 위해 각 단계를 주석과 함께 설명하겠습니다

voters 리스트를 시간 순으로 정렬합니다.
각 투표자에 대해서:
1. 첫 번째 투표자면, 그들의 도착 시간이 시작 시간이 됩니다.
2. 그렇지 않으면 이전 투표자의 출발 시간과 현재 투표자의 도착 시간 중 더 큰 시간을 시작 시간으로 합니다.
3. 만약 투표자가 불만을 가지고 있고, 대기 시간이 impatience_threshold을 초과하면, 투표하지 않고 떠납니다.
투표자가 투표할 수 있으면, 부스에 들어가 투표하고, 투표가 완료되면 부스에서 나옵니다.

문제는 2번째 단계에서 voting_booths 인스턴스의 상태를 고려하지 않고, 단순히 이전 투표자의 출발 시간과 현재 투표자의 도착 시간만을 기준으로 시작 시간을 계산하고 있다는 점입니다. 투표 부스가 여러 개 있을 때는 부스 중 하나가 비어 있을 수도 있으므로 이전 투표자의 출발 시간이 아닌 가장 빨리 비는 부스를 기준으로 시작 시간을 계산해야 합니다.

simulate 함수의 로직을 다음과 같이 수정할 수 있습니다.

현재 투표자의 도착 시간이 이전 투표자의 출발 시간보다 이르거나 같은 경우, voting_booths.is_booth_available()을 확인하여 즉시 투표를 시작할 수 있는지 결정합니다.
현재 투표자의 도착 시간이 이전 투표자의 출발 시간보다 늦은 경우, 부스 중 하나가 비어 있는지 확인하고, 비어 있지 않다면 voting_booths.time_next_free()로 다음 부스가 언제 비는지 확인하여 해당 시간을 시작 시간으로 설정합니다.

이러한 변경 사항을 적용하면, 투표 부스의 수에 관계없이 투표 프로그램이 올바르게 동작할 것입니다.

다음은 수정된 simulate 함수의 핵심 부분입니다.

for i, voter in enumerate(voters):
    if i == 0 or not voting_booths.is_some_booth_occupied():
        # 첫 번째 투표자이거나 모든 부스가 비어있는 경우, 투표자의 도착 시간을 시작 시간으로 설정합니다.
        start_time = voter.arrival_time
    else:
        # 부스 중 하나가 비어있는지 확인합니다.
        if voting_booths.is_booth_available():
            # 투표자의 도착 시간과 다음 부스가 비는 시간 중 늦은 시간을 시작 시간으로 설정합니다.
            start_time = max(voter.arrival_time, voting_booths.time_next_free())
        else:
            # 모든 부스가 차 있으면, 다음 부스가 비는 시간을 시작 시간으로 설정합니다.
            start_time = voting_booths.time_next_free()

    # 투표자가 불만을 가지고 있고, 대기 시간이 인내심 한계를 초과하면 투표하지 않고 떠납니다.
    if voter.is_impatient and (start_time - voter.arrival_time) > impatience_threshold:
        continue  # 투표자는 투표하지 않고 떠납니다.

    # 투표자의 시작 시간과 출발 시간을 설정합니다.
    voter.set_start_time(start_time)
    departure_time = start_time + voter.voting_duration
    voter.set_departure_time(departure_time)

    # 투표자가 부스에 들어가 투표합니다.
    voting_booths.enter_booth(voter)

# 마지막 투표자의 도착 후 남은 투표자들을 처리합니다.
while voting_booths.is_some_booth_occupied():
    voter, departure_time = voting_booths.exit_next_booth()
    # 투표자의 출발을 처리해야 한다면 여기에서 처리합니다.

이 코드는 단순한 설명을 위한 것이며 실제로 작동하는 코드를 얻으려면 VotingBooths 클래스의 메소드들이 올바르게 구현되어 있어야 하고, Voter 클래스도 수정된 로직에 맞게 설정되어야 합니다.

1년 전 ∙ 1 ∙ 답글 달기 ∙ 공유 ∙ 신고 ∙ 차단

뎁스_2599

@피토니 감사합니다! 큰 도움 되었습니다ㅜㅜ

1년 전 ∙ 1 ∙ 답글 달기 ∙ 공유 ∙ 신고 ∙ 차단