message stringlengths 2 20.1k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 1.95k 109k | cluster float64 17 17 | __index_level_0__ int64 3.91k 217k |
|---|---|---|---|---|---|
Provide a correct Python 3 solution for this coding contest problem.
In the speed skating badge test, grades are awarded when the time specified for two distances is exceeded. For example, to reach Class A, 500 M requires less than 40.0 seconds and 1000 M requires less than 1 minute and 23 seconds.
Create a program that takes the time recorded in the speed skating competitions (500 M and 1000 M) as input and outputs what grade it corresponds to in the speed skating badge test. The table below shows the default badge test times for the 500 M and 1000 M. If it is less than class E, output NA.
| 500 M | 1000 M
--- | --- | ---
AAA class | 35 seconds 50 | 1 minute 11 seconds 00
AA class | 37 seconds 50 | 1 minute 17 seconds 00
Class A | 40 seconds 00 | 1 minute 23 seconds 00
Class B | 43 seconds 00 | 1 minute 29 seconds 00
Class C | 50 seconds 00 | 1 minute 45 seconds 00
Class D | 55 seconds 00 | 1 minute 56 seconds 00
Class E | 1 minute 10 seconds 00 | 2 minutes 28 seconds 00
Input
Given multiple datasets. For each dataset, real numbers t1, t2 (8.0 ≤ t1, t2 ≤ 360.0) representing 500 M time and 1000 M time, respectively, are given, separated by blanks. t1 and t2 are given in seconds as real numbers, including up to two digits after the decimal point.
The number of datasets does not exceed 100.
Output
For each data set, output the judgment result AAA ~ E or NA on one line.
Example
Input
40.0 70.0
72.5 140.51
Output
B
NA | instruction | 0 | 72,411 | 17 | 144,822 |
"Correct Solution:
```
def judge(t1, t2):
if t1 < 35.5 and t2 < 71:
print("AAA")
elif t1 < 37.5 and t2 < 77:
print("AA")
elif t1 < 40 and t2 < 83:
print("A")
elif t1 < 43 and t2 < 89:
print("B")
elif t1 < 50 and t2 < 105:
print("C")
elif t1 < 55 and t2 < 116:
print("D")
elif t1 < 70 and t2 < 148:
print ("E")
else:
print("NA")
while True:
try:
t1, t2 = map(float, input().split())
judge(t1, t2)
except EOFError:
break
``` | output | 1 | 72,411 | 17 | 144,823 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the speed skating badge test, grades are awarded when the time specified for two distances is exceeded. For example, to reach Class A, 500 M requires less than 40.0 seconds and 1000 M requires less than 1 minute and 23 seconds.
Create a program that takes the time recorded in the speed skating competitions (500 M and 1000 M) as input and outputs what grade it corresponds to in the speed skating badge test. The table below shows the default badge test times for the 500 M and 1000 M. If it is less than class E, output NA.
| 500 M | 1000 M
--- | --- | ---
AAA class | 35 seconds 50 | 1 minute 11 seconds 00
AA class | 37 seconds 50 | 1 minute 17 seconds 00
Class A | 40 seconds 00 | 1 minute 23 seconds 00
Class B | 43 seconds 00 | 1 minute 29 seconds 00
Class C | 50 seconds 00 | 1 minute 45 seconds 00
Class D | 55 seconds 00 | 1 minute 56 seconds 00
Class E | 1 minute 10 seconds 00 | 2 minutes 28 seconds 00
Input
Given multiple datasets. For each dataset, real numbers t1, t2 (8.0 ≤ t1, t2 ≤ 360.0) representing 500 M time and 1000 M time, respectively, are given, separated by blanks. t1 and t2 are given in seconds as real numbers, including up to two digits after the decimal point.
The number of datasets does not exceed 100.
Output
For each data set, output the judgment result AAA ~ E or NA on one line.
Example
Input
40.0 70.0
72.5 140.51
Output
B
NA
Submitted Solution:
```
import sys
judgeTable = {0: "AAA", 1: "AA", 2: "A",
3: "B", 4: "C", 5: "D", 6: "E", 7: "NA"}
def Judge500(time):
if time < 35.5:
return 0
elif time < 37.5:
return 1
elif time < 40.0:
return 2
elif time < 43.0:
return 3
elif time < 50.0:
return 4
elif time < 55.0:
return 5
elif time < 70.0:
return 6
else:
return 7
def Judge1000(time):
if time < 71.0:
return 0
elif time < 77.0:
return 1
elif time < 83.0:
return 2
elif time < 89.0:
return 3
elif time < 105.0:
return 4
elif time < 116.0:
return 5
elif time < 148.0:
return 6
else:
return 7
for line in sys.stdin:
line = line[:-1]
time1, time2 = [float(item) for item in line.split(" ")]
rank1, rank2 = Judge500(time1), Judge1000(time2)
result = judgeTable[max(rank1, rank2)]
print(result)
``` | instruction | 0 | 72,412 | 17 | 144,824 |
Yes | output | 1 | 72,412 | 17 | 144,825 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the speed skating badge test, grades are awarded when the time specified for two distances is exceeded. For example, to reach Class A, 500 M requires less than 40.0 seconds and 1000 M requires less than 1 minute and 23 seconds.
Create a program that takes the time recorded in the speed skating competitions (500 M and 1000 M) as input and outputs what grade it corresponds to in the speed skating badge test. The table below shows the default badge test times for the 500 M and 1000 M. If it is less than class E, output NA.
| 500 M | 1000 M
--- | --- | ---
AAA class | 35 seconds 50 | 1 minute 11 seconds 00
AA class | 37 seconds 50 | 1 minute 17 seconds 00
Class A | 40 seconds 00 | 1 minute 23 seconds 00
Class B | 43 seconds 00 | 1 minute 29 seconds 00
Class C | 50 seconds 00 | 1 minute 45 seconds 00
Class D | 55 seconds 00 | 1 minute 56 seconds 00
Class E | 1 minute 10 seconds 00 | 2 minutes 28 seconds 00
Input
Given multiple datasets. For each dataset, real numbers t1, t2 (8.0 ≤ t1, t2 ≤ 360.0) representing 500 M time and 1000 M time, respectively, are given, separated by blanks. t1 and t2 are given in seconds as real numbers, including up to two digits after the decimal point.
The number of datasets does not exceed 100.
Output
For each data set, output the judgment result AAA ~ E or NA on one line.
Example
Input
40.0 70.0
72.5 140.51
Output
B
NA
Submitted Solution:
```
while True:
try: n = input().split()
except: break
m5, m10 = map(float, n)
if m5 < 35.50 and m10 < 71.0:
print('AAA')
elif m5 < 37.50 and m10 < 77.0:
print('AA')
elif m5 < 40.0 and m10 < 83.0:
print('A')
elif m5 < 43.0 and m10 < 89.0:
print('B')
elif m5 < 50.0 and m10 < 105.0:
print('C')
elif m5 < 55.0 and m10 < 116.0:
print('D')
elif m5 < 70.0 and m10 < 148.0:
print('E')
else:
print('NA')
``` | instruction | 0 | 72,413 | 17 | 144,826 |
Yes | output | 1 | 72,413 | 17 | 144,827 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the speed skating badge test, grades are awarded when the time specified for two distances is exceeded. For example, to reach Class A, 500 M requires less than 40.0 seconds and 1000 M requires less than 1 minute and 23 seconds.
Create a program that takes the time recorded in the speed skating competitions (500 M and 1000 M) as input and outputs what grade it corresponds to in the speed skating badge test. The table below shows the default badge test times for the 500 M and 1000 M. If it is less than class E, output NA.
| 500 M | 1000 M
--- | --- | ---
AAA class | 35 seconds 50 | 1 minute 11 seconds 00
AA class | 37 seconds 50 | 1 minute 17 seconds 00
Class A | 40 seconds 00 | 1 minute 23 seconds 00
Class B | 43 seconds 00 | 1 minute 29 seconds 00
Class C | 50 seconds 00 | 1 minute 45 seconds 00
Class D | 55 seconds 00 | 1 minute 56 seconds 00
Class E | 1 minute 10 seconds 00 | 2 minutes 28 seconds 00
Input
Given multiple datasets. For each dataset, real numbers t1, t2 (8.0 ≤ t1, t2 ≤ 360.0) representing 500 M time and 1000 M time, respectively, are given, separated by blanks. t1 and t2 are given in seconds as real numbers, including up to two digits after the decimal point.
The number of datasets does not exceed 100.
Output
For each data set, output the judgment result AAA ~ E or NA on one line.
Example
Input
40.0 70.0
72.5 140.51
Output
B
NA
Submitted Solution:
```
import bisect
while 1:
try:
n,m=map(float,input().split())
m500=[35.5,37.5,40,43,50,55,70]
m1000=[71,77,83,89,105,116,148]
r1=bisect.bisect_left(m500,n+0.001)
r2=bisect.bisect_left(m1000,m+0.001)
rank=["AAA","AA","A","B","C","D","E","NA"]
print(rank[max(r1,r2)])
except:break
``` | instruction | 0 | 72,414 | 17 | 144,828 |
Yes | output | 1 | 72,414 | 17 | 144,829 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the speed skating badge test, grades are awarded when the time specified for two distances is exceeded. For example, to reach Class A, 500 M requires less than 40.0 seconds and 1000 M requires less than 1 minute and 23 seconds.
Create a program that takes the time recorded in the speed skating competitions (500 M and 1000 M) as input and outputs what grade it corresponds to in the speed skating badge test. The table below shows the default badge test times for the 500 M and 1000 M. If it is less than class E, output NA.
| 500 M | 1000 M
--- | --- | ---
AAA class | 35 seconds 50 | 1 minute 11 seconds 00
AA class | 37 seconds 50 | 1 minute 17 seconds 00
Class A | 40 seconds 00 | 1 minute 23 seconds 00
Class B | 43 seconds 00 | 1 minute 29 seconds 00
Class C | 50 seconds 00 | 1 minute 45 seconds 00
Class D | 55 seconds 00 | 1 minute 56 seconds 00
Class E | 1 minute 10 seconds 00 | 2 minutes 28 seconds 00
Input
Given multiple datasets. For each dataset, real numbers t1, t2 (8.0 ≤ t1, t2 ≤ 360.0) representing 500 M time and 1000 M time, respectively, are given, separated by blanks. t1 and t2 are given in seconds as real numbers, including up to two digits after the decimal point.
The number of datasets does not exceed 100.
Output
For each data set, output the judgment result AAA ~ E or NA on one line.
Example
Input
40.0 70.0
72.5 140.51
Output
B
NA
Submitted Solution:
```
import sys
for line in sys.stdin.readlines():
t1,t2 = list(map(float, line.split()))
if t1 < 35.5 and t2 < 71.0: print("AAA")
elif t1 < 37.5 and t2 < 77.0: print("AA")
elif t1 < 40.0 and t2 < 83.0: print("A")
elif t1 < 43.0 and t2 < 89.0: print("B")
elif t1 < 50.0 and t2 < 105.0: print("C")
elif t1 < 55.0 and t2 < 116.0: print("D")
elif t1 < 70.0 and t2 < 148.0: print("E")
else: print("NA")
``` | instruction | 0 | 72,415 | 17 | 144,830 |
Yes | output | 1 | 72,415 | 17 | 144,831 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the speed skating badge test, grades are awarded when the time specified for two distances is exceeded. For example, to reach Class A, 500 M requires less than 40.0 seconds and 1000 M requires less than 1 minute and 23 seconds.
Create a program that takes the time recorded in the speed skating competitions (500 M and 1000 M) as input and outputs what grade it corresponds to in the speed skating badge test. The table below shows the default badge test times for the 500 M and 1000 M. If it is less than class E, output NA.
| 500 M | 1000 M
--- | --- | ---
AAA class | 35 seconds 50 | 1 minute 11 seconds 00
AA class | 37 seconds 50 | 1 minute 17 seconds 00
Class A | 40 seconds 00 | 1 minute 23 seconds 00
Class B | 43 seconds 00 | 1 minute 29 seconds 00
Class C | 50 seconds 00 | 1 minute 45 seconds 00
Class D | 55 seconds 00 | 1 minute 56 seconds 00
Class E | 1 minute 10 seconds 00 | 2 minutes 28 seconds 00
Input
Given multiple datasets. For each dataset, real numbers t1, t2 (8.0 ≤ t1, t2 ≤ 360.0) representing 500 M time and 1000 M time, respectively, are given, separated by blanks. t1 and t2 are given in seconds as real numbers, including up to two digits after the decimal point.
The number of datasets does not exceed 100.
Output
For each data set, output the judgment result AAA ~ E or NA on one line.
Example
Input
40.0 70.0
72.5 140.51
Output
B
NA
Submitted Solution:
```
# Aizu Problem 00123: Speed Skating Badge Test
#
import sys, math, os, copy
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input.txt", "rt")
grades = ["AAA", "AA", "A", "B", "C", "D", "E", "NA"]
limits = [[35, 71], [37, 77], [40, 83], [43, 89], [50, 105],
[55, 116], [70, 148], [99999999, 999999999]]
for line in sys.stdin:
t1, t2 = [float(_) for _ in line.split()]
for k in range(8):
if t1 < limits[k][0] and t2 < limits[k][1]:
print(grades[k])
break
``` | instruction | 0 | 72,416 | 17 | 144,832 |
No | output | 1 | 72,416 | 17 | 144,833 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the speed skating badge test, grades are awarded when the time specified for two distances is exceeded. For example, to reach Class A, 500 M requires less than 40.0 seconds and 1000 M requires less than 1 minute and 23 seconds.
Create a program that takes the time recorded in the speed skating competitions (500 M and 1000 M) as input and outputs what grade it corresponds to in the speed skating badge test. The table below shows the default badge test times for the 500 M and 1000 M. If it is less than class E, output NA.
| 500 M | 1000 M
--- | --- | ---
AAA class | 35 seconds 50 | 1 minute 11 seconds 00
AA class | 37 seconds 50 | 1 minute 17 seconds 00
Class A | 40 seconds 00 | 1 minute 23 seconds 00
Class B | 43 seconds 00 | 1 minute 29 seconds 00
Class C | 50 seconds 00 | 1 minute 45 seconds 00
Class D | 55 seconds 00 | 1 minute 56 seconds 00
Class E | 1 minute 10 seconds 00 | 2 minutes 28 seconds 00
Input
Given multiple datasets. For each dataset, real numbers t1, t2 (8.0 ≤ t1, t2 ≤ 360.0) representing 500 M time and 1000 M time, respectively, are given, separated by blanks. t1 and t2 are given in seconds as real numbers, including up to two digits after the decimal point.
The number of datasets does not exceed 100.
Output
For each data set, output the judgment result AAA ~ E or NA on one line.
Example
Input
40.0 70.0
72.5 140.51
Output
B
NA
Submitted Solution:
```
while True:
try:
t1,t2=map(float,input().split())
if t1<35.5 and t2<71:
print("AAA")
elif t1<37.5 and t2<77:
print("AA")
elif t1<40 and t2<83:
print("A")
elif t1<43 and t2<89:
print("B")
elif t1<50 and t2<105:
print("C")
elif t1<55 and t2<116:
print("D")
elif t1<70 and t2<148:
print("e")
else:
print("NA")
except:break
``` | instruction | 0 | 72,417 | 17 | 144,834 |
No | output | 1 | 72,417 | 17 | 144,835 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the speed skating badge test, grades are awarded when the time specified for two distances is exceeded. For example, to reach Class A, 500 M requires less than 40.0 seconds and 1000 M requires less than 1 minute and 23 seconds.
Create a program that takes the time recorded in the speed skating competitions (500 M and 1000 M) as input and outputs what grade it corresponds to in the speed skating badge test. The table below shows the default badge test times for the 500 M and 1000 M. If it is less than class E, output NA.
| 500 M | 1000 M
--- | --- | ---
AAA class | 35 seconds 50 | 1 minute 11 seconds 00
AA class | 37 seconds 50 | 1 minute 17 seconds 00
Class A | 40 seconds 00 | 1 minute 23 seconds 00
Class B | 43 seconds 00 | 1 minute 29 seconds 00
Class C | 50 seconds 00 | 1 minute 45 seconds 00
Class D | 55 seconds 00 | 1 minute 56 seconds 00
Class E | 1 minute 10 seconds 00 | 2 minutes 28 seconds 00
Input
Given multiple datasets. For each dataset, real numbers t1, t2 (8.0 ≤ t1, t2 ≤ 360.0) representing 500 M time and 1000 M time, respectively, are given, separated by blanks. t1 and t2 are given in seconds as real numbers, including up to two digits after the decimal point.
The number of datasets does not exceed 100.
Output
For each data set, output the judgment result AAA ~ E or NA on one line.
Example
Input
40.0 70.0
72.5 140.51
Output
B
NA
Submitted Solution:
```
while True:
try:
t1,t2=map(float,input().split())
except:break
if t1<35.5 and t2<71:
print("AAA")
elif t1<37.5 and t2<77:
print("AA")
elif t1<40 and t2<83:
print("A")
elif t1<43 and t2<89:
print("B")
elif t1<50 and t2<105:
print("C")
elif t1<55 and t2<116:
print("D")
elif t1<70 and t2<148:
print("e")
else:
print("NA")
``` | instruction | 0 | 72,418 | 17 | 144,836 |
No | output | 1 | 72,418 | 17 | 144,837 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the speed skating badge test, grades are awarded when the time specified for two distances is exceeded. For example, to reach Class A, 500 M requires less than 40.0 seconds and 1000 M requires less than 1 minute and 23 seconds.
Create a program that takes the time recorded in the speed skating competitions (500 M and 1000 M) as input and outputs what grade it corresponds to in the speed skating badge test. The table below shows the default badge test times for the 500 M and 1000 M. If it is less than class E, output NA.
| 500 M | 1000 M
--- | --- | ---
AAA class | 35 seconds 50 | 1 minute 11 seconds 00
AA class | 37 seconds 50 | 1 minute 17 seconds 00
Class A | 40 seconds 00 | 1 minute 23 seconds 00
Class B | 43 seconds 00 | 1 minute 29 seconds 00
Class C | 50 seconds 00 | 1 minute 45 seconds 00
Class D | 55 seconds 00 | 1 minute 56 seconds 00
Class E | 1 minute 10 seconds 00 | 2 minutes 28 seconds 00
Input
Given multiple datasets. For each dataset, real numbers t1, t2 (8.0 ≤ t1, t2 ≤ 360.0) representing 500 M time and 1000 M time, respectively, are given, separated by blanks. t1 and t2 are given in seconds as real numbers, including up to two digits after the decimal point.
The number of datasets does not exceed 100.
Output
For each data set, output the judgment result AAA ~ E or NA on one line.
Example
Input
40.0 70.0
72.5 140.51
Output
B
NA
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0123
"""
import sys
def solve(r500, r1000):
criteria = [(35.0, 71.0, 'AAA'), (37.0, 77.0, 'AA'), (40.0, 83.0, 'A'), (43.0, 89.0, 'B'),
(50.0, 105.0, 'C'), (55.0, 116.0, 'D'), (70.0, 148.0, 'E')]
rank = None
for c500, c1000, r in criteria:
if r500 < c500 and r1000 < c1000:
rank = r
break
if rank == None:
rank = 'NA'
return rank
def main(args):
for line in sys.stdin:
r500, r1000 = [float(x) for x in line.strip().split()]
result = solve(r500, r1000)
print(result)
if __name__ == '__main__':
main(sys.argv[1:])
``` | instruction | 0 | 72,419 | 17 | 144,838 |
No | output | 1 | 72,419 | 17 | 144,839 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
BCPC stands for Byteforces Collegiate Programming Contest, and is the most famous competition in Byteforces.
BCPC is a team competition. Each team is composed by a coach and three contestants. Blenda is the coach of the Bit State University(BSU), and she is very strict selecting the members of her team.
<image>
In BSU there are n students numbered from 1 to n. Since all BSU students are infinitely smart, the only important parameters for Blenda are their reading and writing speed. After a careful measuring, Blenda have found that the i-th student have a reading speed equal to ri (words per minute), and a writing speed of wi (symbols per minute). Since BSU students are very smart, the measured speeds are sometimes very big and Blenda have decided to subtract some constant value c from all the values of reading speed and some value d from all the values of writing speed. Therefore she considers ri' = ri - c and wi' = wi - d.
The student i is said to overwhelm the student j if and only if ri'·wj' > rj'·wi'. Blenda doesn’t like fights in teams, so she thinks that a team consisting of three distinct students i, j and k is good if i overwhelms j, j overwhelms k, and k overwhelms i. Yes, the relation of overwhelming is not transitive as it often happens in real life.
Since Blenda is busy preparing a training camp in Codeforces, you are given a task to calculate the number of different good teams in BSU. Two teams are considered to be different if there is at least one student that is present in one team but is not present in the other. In other words, two teams are different if the sets of students that form these teams are different.
Input
In the first line of the input three integers n, c and d (3 ≤ n ≤ 345678, 1 ≤ c, d ≤ 109) are written. They denote the number of students Blenda can use to form teams, the value subtracted from all reading speeds and the value subtracted from all writing speeds respectively.
Each of the next n lines contains two integers ri and wi (0 < ri, wi ≤ 109, |ri - c| + |wi - d| > 0). There are no two students, such that both their reading and writing speeds coincide, i.e. for every i ≠ j condition |ri - rj| + |wi - wj| > 0 holds.
Output
Print the number of different teams in BSU, that are good according to Blenda's definition.
Examples
Input
5 2 2
1 1
4 1
2 3
3 2
3 4
Output
4
Input
7 6 6
3 2
1 7
5 7
3 7
6 4
8 9
8 5
Output
11
Note
In the first sample the following teams are good: (i = 1, j = 2, k = 3), (i = 2, j = 5, k = 1), (i = 1, j = 4, k = 3), (i = 5, j = 1, k = 4).
Note, that for example the team (i = 3, j = 1, k = 2) is also good, but is considered to be the same as the team (i = 1, j = 2, k = 3).
Submitted Solution:
```
import math
import collections
n, c, d = map(int, input().split(" "))
def arctan(rise, run):
if run == 0:
if rise > 0:
return (math.pi)/2
elif rise < 0:
return 3*(math.pi)/2
else:
pass
if run > 0:
theta = math.atan(rise/run)
if theta>=0:
return theta
else:
return (2*math.pi+theta)
if run < 0:
theta = math.atan(rise/run)
return math.pi + theta
angles=[]
for i in range (n):
a, b = map(int, input().split(" "))
angles += [arctan(b-d, a-c)]
angles.sort()
obt = 0
a=collections.deque()
for angle in angles:
a.append(angle-2*math.pi)
for angle in angles:
a.append(angle)
while a[-1] - a[0] >= math.pi:
a.popleft()
obt += (len(a)-1)*(len(a)-2)//2
deg = 0
A=collections.deque()
for angle in angles:
A.append(angle)
while A[-1] - A[0] > math.pi:
A.popleft()
if A[0] + math.pi == A[-1]:
b=1
c=1
while A[-c]==A[-1]:
c+=1
c-=2
while A[b]==A[0]:
b+=1
deg += ((b+c)*(b+c-1)//2 - (c-1)*(c)//2)
l = len(angles)
total = l*(l-1)*(l-2)//6
print(total-obt-deg)
"""Pslopes = []
Nslopes = []
for i in range (n):
a, b = map(int, input().split(" "))
if (b-d)>=0:
if (b-d)==0:
if (a-c)>0:
Pslopes += [10000000000]
if (a-c)<0:
Nslopes += [10000000000]
if (a-c)==0:
pass
else:
Pslopes += [(a-c)/(b-d)]
else:
Nslopes += [(a-c)/(b-d)]
Pslopes.sort()
Nslopes.sort()
p = len(Pslopes)
n = len(Nslopes)
print(Pslopes, Nslopes, n)
teams = 0
#iterate over each slope, find the number of slopes between that slope and its
#negative one way, multiple that by the number of slopes the other way.
#Be careful with +- infinity. Divide by 3 at the end for over counting.
#too slow though? 10^11? no, go on counting using what info you previously know.
#noooooooo wrong algorithm
Nindex = 0
for i in range (p):
side1 = p-1-i
while Nindex < n and Nslopes[Nindex] < Pslopes[i]:
Nindex += 1
side1 += Nindex
side2 = i + n - Nindex
if (Nindex != n) and (Nslopes[Nindex] == Pslopes[i]):
side2-=1
teams += side1 * side2
print(teams)
Pindex = 0
for i in range (n):
side1 = n-1-i
while Pindex < p and Pslopes[Pindex] < Nslopes[i]:
Pindex += 1
side1 += Pindex
side2 = i + p - Pindex
if Nslopes[i] == Pslopes[Pindex]:
side2 -= 1
teams += side1 * side2
print (teams, teams//3)"""
``` | instruction | 0 | 72,912 | 17 | 145,824 |
No | output | 1 | 72,912 | 17 | 145,825 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
BCPC stands for Byteforces Collegiate Programming Contest, and is the most famous competition in Byteforces.
BCPC is a team competition. Each team is composed by a coach and three contestants. Blenda is the coach of the Bit State University(BSU), and she is very strict selecting the members of her team.
<image>
In BSU there are n students numbered from 1 to n. Since all BSU students are infinitely smart, the only important parameters for Blenda are their reading and writing speed. After a careful measuring, Blenda have found that the i-th student have a reading speed equal to ri (words per minute), and a writing speed of wi (symbols per minute). Since BSU students are very smart, the measured speeds are sometimes very big and Blenda have decided to subtract some constant value c from all the values of reading speed and some value d from all the values of writing speed. Therefore she considers ri' = ri - c and wi' = wi - d.
The student i is said to overwhelm the student j if and only if ri'·wj' > rj'·wi'. Blenda doesn’t like fights in teams, so she thinks that a team consisting of three distinct students i, j and k is good if i overwhelms j, j overwhelms k, and k overwhelms i. Yes, the relation of overwhelming is not transitive as it often happens in real life.
Since Blenda is busy preparing a training camp in Codeforces, you are given a task to calculate the number of different good teams in BSU. Two teams are considered to be different if there is at least one student that is present in one team but is not present in the other. In other words, two teams are different if the sets of students that form these teams are different.
Input
In the first line of the input three integers n, c and d (3 ≤ n ≤ 345678, 1 ≤ c, d ≤ 109) are written. They denote the number of students Blenda can use to form teams, the value subtracted from all reading speeds and the value subtracted from all writing speeds respectively.
Each of the next n lines contains two integers ri and wi (0 < ri, wi ≤ 109, |ri - c| + |wi - d| > 0). There are no two students, such that both their reading and writing speeds coincide, i.e. for every i ≠ j condition |ri - rj| + |wi - wj| > 0 holds.
Output
Print the number of different teams in BSU, that are good according to Blenda's definition.
Examples
Input
5 2 2
1 1
4 1
2 3
3 2
3 4
Output
4
Input
7 6 6
3 2
1 7
5 7
3 7
6 4
8 9
8 5
Output
11
Note
In the first sample the following teams are good: (i = 1, j = 2, k = 3), (i = 2, j = 5, k = 1), (i = 1, j = 4, k = 3), (i = 5, j = 1, k = 4).
Note, that for example the team (i = 3, j = 1, k = 2) is also good, but is considered to be the same as the team (i = 1, j = 2, k = 3).
Submitted Solution:
```
import math
import collections
n, c, d = map(int, input().split(" "))
def arctan(rise, run):
if run == 0:
if rise > 0:
return (math.pi)/2
elif rise < 0:
return 3*(math.pi)/2
else:
pass
if run > 0:
theta = math.atan(rise/run)
if theta>=0:
return theta
else:
return (2*math.pi+theta)
if run < 0:
theta = math.atan(rise/run)
return math.pi + theta
angles=[]
for i in range (n):
a, b = map(int, input().split(" "))
angles += [arctan(b-d, a-c)]
angles.sort()
obt = 0
a=collections.deque()
for angle in angles:
a.append(angle-2*math.pi)
for angle in angles:
a.append(angle)
while a[-1] - a[0] > math.pi:
a.popleft()
obt += (len(a)-1)*(len(a)-2)//2
l = len(angles)
total = l*(l-1)*(l-2)//6
print(total-obt)
"""Pslopes = []
Nslopes = []
for i in range (n):
a, b = map(int, input().split(" "))
if (b-d)>=0:
if (b-d)==0:
if (a-c)>0:
Pslopes += [10000000000]
if (a-c)<0:
Nslopes += [10000000000]
if (a-c)==0:
pass
else:
Pslopes += [(a-c)/(b-d)]
else:
Nslopes += [(a-c)/(b-d)]
Pslopes.sort()
Nslopes.sort()
p = len(Pslopes)
n = len(Nslopes)
print(Pslopes, Nslopes, n)
teams = 0
#iterate over each slope, find the number of slopes between that slope and its
#negative one way, multiple that by the number of slopes the other way.
#Be careful with +- infinity. Divide by 3 at the end for over counting.
#too slow though? 10^11? no, go on counting using what info you previously know.
#noooooooo wrong algorithm
Nindex = 0
for i in range (p):
side1 = p-1-i
while Nindex < n and Nslopes[Nindex] < Pslopes[i]:
Nindex += 1
side1 += Nindex
side2 = i + n - Nindex
if (Nindex != n) and (Nslopes[Nindex] == Pslopes[i]):
side2-=1
teams += side1 * side2
print(teams)
Pindex = 0
for i in range (n):
side1 = n-1-i
while Pindex < p and Pslopes[Pindex] < Nslopes[i]:
Pindex += 1
side1 += Pindex
side2 = i + p - Pindex
if Nslopes[i] == Pslopes[Pindex]:
side2 -= 1
teams += side1 * side2
print (teams, teams//3)"""
``` | instruction | 0 | 72,913 | 17 | 145,826 |
No | output | 1 | 72,913 | 17 | 145,827 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
BCPC stands for Byteforces Collegiate Programming Contest, and is the most famous competition in Byteforces.
BCPC is a team competition. Each team is composed by a coach and three contestants. Blenda is the coach of the Bit State University(BSU), and she is very strict selecting the members of her team.
<image>
In BSU there are n students numbered from 1 to n. Since all BSU students are infinitely smart, the only important parameters for Blenda are their reading and writing speed. After a careful measuring, Blenda have found that the i-th student have a reading speed equal to ri (words per minute), and a writing speed of wi (symbols per minute). Since BSU students are very smart, the measured speeds are sometimes very big and Blenda have decided to subtract some constant value c from all the values of reading speed and some value d from all the values of writing speed. Therefore she considers ri' = ri - c and wi' = wi - d.
The student i is said to overwhelm the student j if and only if ri'·wj' > rj'·wi'. Blenda doesn’t like fights in teams, so she thinks that a team consisting of three distinct students i, j and k is good if i overwhelms j, j overwhelms k, and k overwhelms i. Yes, the relation of overwhelming is not transitive as it often happens in real life.
Since Blenda is busy preparing a training camp in Codeforces, you are given a task to calculate the number of different good teams in BSU. Two teams are considered to be different if there is at least one student that is present in one team but is not present in the other. In other words, two teams are different if the sets of students that form these teams are different.
Input
In the first line of the input three integers n, c and d (3 ≤ n ≤ 345678, 1 ≤ c, d ≤ 109) are written. They denote the number of students Blenda can use to form teams, the value subtracted from all reading speeds and the value subtracted from all writing speeds respectively.
Each of the next n lines contains two integers ri and wi (0 < ri, wi ≤ 109, |ri - c| + |wi - d| > 0). There are no two students, such that both their reading and writing speeds coincide, i.e. for every i ≠ j condition |ri - rj| + |wi - wj| > 0 holds.
Output
Print the number of different teams in BSU, that are good according to Blenda's definition.
Examples
Input
5 2 2
1 1
4 1
2 3
3 2
3 4
Output
4
Input
7 6 6
3 2
1 7
5 7
3 7
6 4
8 9
8 5
Output
11
Note
In the first sample the following teams are good: (i = 1, j = 2, k = 3), (i = 2, j = 5, k = 1), (i = 1, j = 4, k = 3), (i = 5, j = 1, k = 4).
Note, that for example the team (i = 3, j = 1, k = 2) is also good, but is considered to be the same as the team (i = 1, j = 2, k = 3).
Submitted Solution:
```
import math
import collections
n, c, d = map(int, input().split(" "))
def arctan(rise, run):
if run == 0:
if rise > 0:
return (math.pi)/2
elif rise < 0:
return 3*(math.pi)/2
else:
pass
if run > 0:
theta = math.atan(rise/run)
if theta>=0:
return theta
else:
return (2*math.pi+theta)
if run < 0:
theta = math.atan(rise/run)
return math.pi + theta
angles=[]
for i in range (n):
a, b = map(int, input().split(" "))
angles += [arctan(b-d, a-c)]
angles.sort()
obt = 0
a=collections.deque()
for angle in angles:
a.append(angle-2*math.pi)
for angle in angles:
a.append(angle)
while a[-1] - a[0] > math.pi:
a.popleft()
obt += (len(a)-1)*(len(a)-2)//2
deg = 0
A=collections.deque()
for angle in angles:
A.append(angle)
while A[-1] - A[0] > math.pi:
A.popleft()
if A[0] + math.pi == A[-1]:
b=1
c=1
while A[-c]==A[-1]:
c+=1
c-=2
while A[b]==A[0]:
b+=1
deg += ((b+c)*(b+c-1)//2 - (c-1)*(c)//2)
l = len(angles)
total = l*(l-1)*(l-2)//6
print(total-obt+deg)
"""Pslopes = []
Nslopes = []
for i in range (n):
a, b = map(int, input().split(" "))
if (b-d)>=0:
if (b-d)==0:
if (a-c)>0:
Pslopes += [10000000000]
if (a-c)<0:
Nslopes += [10000000000]
if (a-c)==0:
pass
else:
Pslopes += [(a-c)/(b-d)]
else:
Nslopes += [(a-c)/(b-d)]
Pslopes.sort()
Nslopes.sort()
p = len(Pslopes)
n = len(Nslopes)
print(Pslopes, Nslopes, n)
teams = 0
#iterate over each slope, find the number of slopes between that slope and its
#negative one way, multiple that by the number of slopes the other way.
#Be careful with +- infinity. Divide by 3 at the end for over counting.
#too slow though? 10^11? no, go on counting using what info you previously know.
#noooooooo wrong algorithm
Nindex = 0
for i in range (p):
side1 = p-1-i
while Nindex < n and Nslopes[Nindex] < Pslopes[i]:
Nindex += 1
side1 += Nindex
side2 = i + n - Nindex
if (Nindex != n) and (Nslopes[Nindex] == Pslopes[i]):
side2-=1
teams += side1 * side2
print(teams)
Pindex = 0
for i in range (n):
side1 = n-1-i
while Pindex < p and Pslopes[Pindex] < Nslopes[i]:
Pindex += 1
side1 += Pindex
side2 = i + p - Pindex
if Nslopes[i] == Pslopes[Pindex]:
side2 -= 1
teams += side1 * side2
print (teams, teams//3)"""
``` | instruction | 0 | 72,914 | 17 | 145,828 |
No | output | 1 | 72,914 | 17 | 145,829 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
BCPC stands for Byteforces Collegiate Programming Contest, and is the most famous competition in Byteforces.
BCPC is a team competition. Each team is composed by a coach and three contestants. Blenda is the coach of the Bit State University(BSU), and she is very strict selecting the members of her team.
<image>
In BSU there are n students numbered from 1 to n. Since all BSU students are infinitely smart, the only important parameters for Blenda are their reading and writing speed. After a careful measuring, Blenda have found that the i-th student have a reading speed equal to ri (words per minute), and a writing speed of wi (symbols per minute). Since BSU students are very smart, the measured speeds are sometimes very big and Blenda have decided to subtract some constant value c from all the values of reading speed and some value d from all the values of writing speed. Therefore she considers ri' = ri - c and wi' = wi - d.
The student i is said to overwhelm the student j if and only if ri'·wj' > rj'·wi'. Blenda doesn’t like fights in teams, so she thinks that a team consisting of three distinct students i, j and k is good if i overwhelms j, j overwhelms k, and k overwhelms i. Yes, the relation of overwhelming is not transitive as it often happens in real life.
Since Blenda is busy preparing a training camp in Codeforces, you are given a task to calculate the number of different good teams in BSU. Two teams are considered to be different if there is at least one student that is present in one team but is not present in the other. In other words, two teams are different if the sets of students that form these teams are different.
Input
In the first line of the input three integers n, c and d (3 ≤ n ≤ 345678, 1 ≤ c, d ≤ 109) are written. They denote the number of students Blenda can use to form teams, the value subtracted from all reading speeds and the value subtracted from all writing speeds respectively.
Each of the next n lines contains two integers ri and wi (0 < ri, wi ≤ 109, |ri - c| + |wi - d| > 0). There are no two students, such that both their reading and writing speeds coincide, i.e. for every i ≠ j condition |ri - rj| + |wi - wj| > 0 holds.
Output
Print the number of different teams in BSU, that are good according to Blenda's definition.
Examples
Input
5 2 2
1 1
4 1
2 3
3 2
3 4
Output
4
Input
7 6 6
3 2
1 7
5 7
3 7
6 4
8 9
8 5
Output
11
Note
In the first sample the following teams are good: (i = 1, j = 2, k = 3), (i = 2, j = 5, k = 1), (i = 1, j = 4, k = 3), (i = 5, j = 1, k = 4).
Note, that for example the team (i = 3, j = 1, k = 2) is also good, but is considered to be the same as the team (i = 1, j = 2, k = 3).
Submitted Solution:
```
from fractions import*
n, c, d = map(int, input().split())
p_wn0 = []
p_w0p = 0
p_w0n = 0
for i in range(n):
r, w = tuple(map(int, input().split()))
r -= c
w -= d
if w != 0:
p_wn0.append((r,w))
elif r > 0:
p_w0p += 1
else:
p_w0n += 1
p_wn0.sort(key = lambda x: Fraction(x[0],x[1]))
ppopm = 0
pmopp = 0
ans = 0
oppo = []
for i in range(len(p_wn0)):
op = 0
for j in range(i):
if p_wn0[j][1] * p_wn0[i][1] < 0:
op += 1
ans += oppo[j]
if p_wn0[i][1] < 0:
ppopm += 1
else:
pmopp += 1
oppo.append(op)
ans += p_w0p * ppopm + p_w0n * pmopp
print(ans)
``` | instruction | 0 | 72,915 | 17 | 145,830 |
No | output | 1 | 72,915 | 17 | 145,831 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alex, Bob and Carl will soon participate in a team chess tournament. Since they are all in the same team, they have decided to practise really hard before the tournament. But it's a bit difficult for them because chess is a game for two players, not three.
So they play with each other according to following rules:
* Alex and Bob play the first game, and Carl is spectating;
* When the game ends, the one who lost the game becomes the spectator in the next game, and the one who was spectating plays against the winner.
Alex, Bob and Carl play in such a way that there are no draws.
Today they have played n games, and for each of these games they remember who was the winner. They decided to make up a log of games describing who won each game. But now they doubt if the information in the log is correct, and they want to know if the situation described in the log they made up was possible (that is, no game is won by someone who is spectating if Alex, Bob and Carl play according to the rules). Help them to check it!
Input
The first line contains one integer n (1 ≤ n ≤ 100) — the number of games Alex, Bob and Carl played.
Then n lines follow, describing the game log. i-th line contains one integer ai (1 ≤ ai ≤ 3) which is equal to 1 if Alex won i-th game, to 2 if Bob won i-th game and 3 if Carl won i-th game.
Output
Print YES if the situation described in the log was possible. Otherwise print NO.
Examples
Input
3
1
1
2
Output
YES
Input
2
1
2
Output
NO
Note
In the first example the possible situation is:
1. Alex wins, Carl starts playing instead of Bob;
2. Alex wins, Bob replaces Carl;
3. Bob wins.
The situation in the second example is impossible because Bob loses the first game, so he cannot win the second one. | instruction | 0 | 73,031 | 17 | 146,062 |
Tags: implementation
Correct Solution:
```
n=int(input())
op=3
for i in range(0,n):
wi=int(input())
if wi==op:
print('NO')
break
op=6-op-wi
else:
print('YES')
``` | output | 1 | 73,031 | 17 | 146,063 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alex, Bob and Carl will soon participate in a team chess tournament. Since they are all in the same team, they have decided to practise really hard before the tournament. But it's a bit difficult for them because chess is a game for two players, not three.
So they play with each other according to following rules:
* Alex and Bob play the first game, and Carl is spectating;
* When the game ends, the one who lost the game becomes the spectator in the next game, and the one who was spectating plays against the winner.
Alex, Bob and Carl play in such a way that there are no draws.
Today they have played n games, and for each of these games they remember who was the winner. They decided to make up a log of games describing who won each game. But now they doubt if the information in the log is correct, and they want to know if the situation described in the log they made up was possible (that is, no game is won by someone who is spectating if Alex, Bob and Carl play according to the rules). Help them to check it!
Input
The first line contains one integer n (1 ≤ n ≤ 100) — the number of games Alex, Bob and Carl played.
Then n lines follow, describing the game log. i-th line contains one integer ai (1 ≤ ai ≤ 3) which is equal to 1 if Alex won i-th game, to 2 if Bob won i-th game and 3 if Carl won i-th game.
Output
Print YES if the situation described in the log was possible. Otherwise print NO.
Examples
Input
3
1
1
2
Output
YES
Input
2
1
2
Output
NO
Note
In the first example the possible situation is:
1. Alex wins, Carl starts playing instead of Bob;
2. Alex wins, Bob replaces Carl;
3. Bob wins.
The situation in the second example is impossible because Bob loses the first game, so he cannot win the second one. | instruction | 0 | 73,032 | 17 | 146,064 |
Tags: implementation
Correct Solution:
```
n = int(input())
spec = 3
all = [1,2,3]
for i in range(n):
num = int(input())
if num == spec:
print("NO")
exit(0)
else:
all.remove(spec)
all.remove(num)
spec = all[0]
all = [1,2,3]
print("YES")
``` | output | 1 | 73,032 | 17 | 146,065 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alex, Bob and Carl will soon participate in a team chess tournament. Since they are all in the same team, they have decided to practise really hard before the tournament. But it's a bit difficult for them because chess is a game for two players, not three.
So they play with each other according to following rules:
* Alex and Bob play the first game, and Carl is spectating;
* When the game ends, the one who lost the game becomes the spectator in the next game, and the one who was spectating plays against the winner.
Alex, Bob and Carl play in such a way that there are no draws.
Today they have played n games, and for each of these games they remember who was the winner. They decided to make up a log of games describing who won each game. But now they doubt if the information in the log is correct, and they want to know if the situation described in the log they made up was possible (that is, no game is won by someone who is spectating if Alex, Bob and Carl play according to the rules). Help them to check it!
Input
The first line contains one integer n (1 ≤ n ≤ 100) — the number of games Alex, Bob and Carl played.
Then n lines follow, describing the game log. i-th line contains one integer ai (1 ≤ ai ≤ 3) which is equal to 1 if Alex won i-th game, to 2 if Bob won i-th game and 3 if Carl won i-th game.
Output
Print YES if the situation described in the log was possible. Otherwise print NO.
Examples
Input
3
1
1
2
Output
YES
Input
2
1
2
Output
NO
Note
In the first example the possible situation is:
1. Alex wins, Carl starts playing instead of Bob;
2. Alex wins, Bob replaces Carl;
3. Bob wins.
The situation in the second example is impossible because Bob loses the first game, so he cannot win the second one. | instruction | 0 | 73,033 | 17 | 146,066 |
Tags: implementation
Correct Solution:
```
n = int(input())
players = ['A','B','C']
state = ['A','B']
k = True
for i in range(n):
a = int(input())
if (players[a-1] in state):
for o in players:
if (o not in state):
break
ind = (state.index(players[a-1]) + 1) % 2
state[ind] = o
else:
print('NO')
k = False
break
if k:
print("YES")
``` | output | 1 | 73,033 | 17 | 146,067 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alex, Bob and Carl will soon participate in a team chess tournament. Since they are all in the same team, they have decided to practise really hard before the tournament. But it's a bit difficult for them because chess is a game for two players, not three.
So they play with each other according to following rules:
* Alex and Bob play the first game, and Carl is spectating;
* When the game ends, the one who lost the game becomes the spectator in the next game, and the one who was spectating plays against the winner.
Alex, Bob and Carl play in such a way that there are no draws.
Today they have played n games, and for each of these games they remember who was the winner. They decided to make up a log of games describing who won each game. But now they doubt if the information in the log is correct, and they want to know if the situation described in the log they made up was possible (that is, no game is won by someone who is spectating if Alex, Bob and Carl play according to the rules). Help them to check it!
Input
The first line contains one integer n (1 ≤ n ≤ 100) — the number of games Alex, Bob and Carl played.
Then n lines follow, describing the game log. i-th line contains one integer ai (1 ≤ ai ≤ 3) which is equal to 1 if Alex won i-th game, to 2 if Bob won i-th game and 3 if Carl won i-th game.
Output
Print YES if the situation described in the log was possible. Otherwise print NO.
Examples
Input
3
1
1
2
Output
YES
Input
2
1
2
Output
NO
Note
In the first example the possible situation is:
1. Alex wins, Carl starts playing instead of Bob;
2. Alex wins, Bob replaces Carl;
3. Bob wins.
The situation in the second example is impossible because Bob loses the first game, so he cannot win the second one. | instruction | 0 | 73,034 | 17 | 146,068 |
Tags: implementation
Correct Solution:
```
n = int(input())
a = [int(input()) for i in range(n)]
p1, p2, p3 = 1, 2, 3
for i in a:
if p1 != i and p2 != i:
print('NO')
exit(0)
elif p1 != i:
p1, p3 = p3, p1
else:
p2, p3 = p3, p2
print('YES')
``` | output | 1 | 73,034 | 17 | 146,069 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alex, Bob and Carl will soon participate in a team chess tournament. Since they are all in the same team, they have decided to practise really hard before the tournament. But it's a bit difficult for them because chess is a game for two players, not three.
So they play with each other according to following rules:
* Alex and Bob play the first game, and Carl is spectating;
* When the game ends, the one who lost the game becomes the spectator in the next game, and the one who was spectating plays against the winner.
Alex, Bob and Carl play in such a way that there are no draws.
Today they have played n games, and for each of these games they remember who was the winner. They decided to make up a log of games describing who won each game. But now they doubt if the information in the log is correct, and they want to know if the situation described in the log they made up was possible (that is, no game is won by someone who is spectating if Alex, Bob and Carl play according to the rules). Help them to check it!
Input
The first line contains one integer n (1 ≤ n ≤ 100) — the number of games Alex, Bob and Carl played.
Then n lines follow, describing the game log. i-th line contains one integer ai (1 ≤ ai ≤ 3) which is equal to 1 if Alex won i-th game, to 2 if Bob won i-th game and 3 if Carl won i-th game.
Output
Print YES if the situation described in the log was possible. Otherwise print NO.
Examples
Input
3
1
1
2
Output
YES
Input
2
1
2
Output
NO
Note
In the first example the possible situation is:
1. Alex wins, Carl starts playing instead of Bob;
2. Alex wins, Bob replaces Carl;
3. Bob wins.
The situation in the second example is impossible because Bob loses the first game, so he cannot win the second one. | instruction | 0 | 73,035 | 17 | 146,070 |
Tags: implementation
Correct Solution:
```
n=int(input())
c=[]
players=[1,1,0]
score=[0,0,0]
k=1
for i in range(n):
a=int(input())
c.append(a)
for j in range(n):
for u in range(3):
if players[u]==0 and u!=c[j]-1:
score[u]=1
if players[u]==1 and u!=c[j]-1:
score[u]=-1
for y in range(3):
players[y]+=score[y]
score=[0,0,0]
if players[c[j]-1]==0:
k-=100
if k>0:
print("YES")
else:
print("NO")
``` | output | 1 | 73,035 | 17 | 146,071 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alex, Bob and Carl will soon participate in a team chess tournament. Since they are all in the same team, they have decided to practise really hard before the tournament. But it's a bit difficult for them because chess is a game for two players, not three.
So they play with each other according to following rules:
* Alex and Bob play the first game, and Carl is spectating;
* When the game ends, the one who lost the game becomes the spectator in the next game, and the one who was spectating plays against the winner.
Alex, Bob and Carl play in such a way that there are no draws.
Today they have played n games, and for each of these games they remember who was the winner. They decided to make up a log of games describing who won each game. But now they doubt if the information in the log is correct, and they want to know if the situation described in the log they made up was possible (that is, no game is won by someone who is spectating if Alex, Bob and Carl play according to the rules). Help them to check it!
Input
The first line contains one integer n (1 ≤ n ≤ 100) — the number of games Alex, Bob and Carl played.
Then n lines follow, describing the game log. i-th line contains one integer ai (1 ≤ ai ≤ 3) which is equal to 1 if Alex won i-th game, to 2 if Bob won i-th game and 3 if Carl won i-th game.
Output
Print YES if the situation described in the log was possible. Otherwise print NO.
Examples
Input
3
1
1
2
Output
YES
Input
2
1
2
Output
NO
Note
In the first example the possible situation is:
1. Alex wins, Carl starts playing instead of Bob;
2. Alex wins, Bob replaces Carl;
3. Bob wins.
The situation in the second example is impossible because Bob loses the first game, so he cannot win the second one. | instruction | 0 | 73,036 | 17 | 146,072 |
Tags: implementation
Correct Solution:
```
class Solution(object):
def __init__(self):
self.solve()
def next(self, type=int):
temp = list(map(type, input().split()))
return temp if len(temp) > 1 else temp[0]
def solve(self):
players = [1, 2, 3]
for _ in range(self.next()):
winner = self.next()
if winner == players[0]:
players.append(players.pop(1))
elif winner == players[1]:
players.append(players.pop(0))
else:
print('NO')
break
else:
print('YES')
Solution()
``` | output | 1 | 73,036 | 17 | 146,073 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alex, Bob and Carl will soon participate in a team chess tournament. Since they are all in the same team, they have decided to practise really hard before the tournament. But it's a bit difficult for them because chess is a game for two players, not three.
So they play with each other according to following rules:
* Alex and Bob play the first game, and Carl is spectating;
* When the game ends, the one who lost the game becomes the spectator in the next game, and the one who was spectating plays against the winner.
Alex, Bob and Carl play in such a way that there are no draws.
Today they have played n games, and for each of these games they remember who was the winner. They decided to make up a log of games describing who won each game. But now they doubt if the information in the log is correct, and they want to know if the situation described in the log they made up was possible (that is, no game is won by someone who is spectating if Alex, Bob and Carl play according to the rules). Help them to check it!
Input
The first line contains one integer n (1 ≤ n ≤ 100) — the number of games Alex, Bob and Carl played.
Then n lines follow, describing the game log. i-th line contains one integer ai (1 ≤ ai ≤ 3) which is equal to 1 if Alex won i-th game, to 2 if Bob won i-th game and 3 if Carl won i-th game.
Output
Print YES if the situation described in the log was possible. Otherwise print NO.
Examples
Input
3
1
1
2
Output
YES
Input
2
1
2
Output
NO
Note
In the first example the possible situation is:
1. Alex wins, Carl starts playing instead of Bob;
2. Alex wins, Bob replaces Carl;
3. Bob wins.
The situation in the second example is impossible because Bob loses the first game, so he cannot win the second one. | instruction | 0 | 73,037 | 17 | 146,074 |
Tags: implementation
Correct Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 998244353
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)
def JA(a, sep): return sep.join(map(str, a))
def JAA(a, s, t): return s.join(t.join(map(str, b)) for b in a)
def main():
n = I()
a = [I() for _ in range(n)]
t = [1,2]
for c in a:
if c not in t:
return 'NO'
t = [c, 6 - sum(t)]
return 'YES'
print(main())
``` | output | 1 | 73,037 | 17 | 146,075 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alex, Bob and Carl will soon participate in a team chess tournament. Since they are all in the same team, they have decided to practise really hard before the tournament. But it's a bit difficult for them because chess is a game for two players, not three.
So they play with each other according to following rules:
* Alex and Bob play the first game, and Carl is spectating;
* When the game ends, the one who lost the game becomes the spectator in the next game, and the one who was spectating plays against the winner.
Alex, Bob and Carl play in such a way that there are no draws.
Today they have played n games, and for each of these games they remember who was the winner. They decided to make up a log of games describing who won each game. But now they doubt if the information in the log is correct, and they want to know if the situation described in the log they made up was possible (that is, no game is won by someone who is spectating if Alex, Bob and Carl play according to the rules). Help them to check it!
Input
The first line contains one integer n (1 ≤ n ≤ 100) — the number of games Alex, Bob and Carl played.
Then n lines follow, describing the game log. i-th line contains one integer ai (1 ≤ ai ≤ 3) which is equal to 1 if Alex won i-th game, to 2 if Bob won i-th game and 3 if Carl won i-th game.
Output
Print YES if the situation described in the log was possible. Otherwise print NO.
Examples
Input
3
1
1
2
Output
YES
Input
2
1
2
Output
NO
Note
In the first example the possible situation is:
1. Alex wins, Carl starts playing instead of Bob;
2. Alex wins, Bob replaces Carl;
3. Bob wins.
The situation in the second example is impossible because Bob loses the first game, so he cannot win the second one. | instruction | 0 | 73,038 | 17 | 146,076 |
Tags: implementation
Correct Solution:
```
n=int(input())
c=0
spec=3
for i in range(n):
a=int(input())
if a==spec:
c=1
spec=6-spec-a
if c==0:
print('YES')
else:
print('NO')
``` | output | 1 | 73,038 | 17 | 146,077 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alex, Bob and Carl will soon participate in a team chess tournament. Since they are all in the same team, they have decided to practise really hard before the tournament. But it's a bit difficult for them because chess is a game for two players, not three.
So they play with each other according to following rules:
* Alex and Bob play the first game, and Carl is spectating;
* When the game ends, the one who lost the game becomes the spectator in the next game, and the one who was spectating plays against the winner.
Alex, Bob and Carl play in such a way that there are no draws.
Today they have played n games, and for each of these games they remember who was the winner. They decided to make up a log of games describing who won each game. But now they doubt if the information in the log is correct, and they want to know if the situation described in the log they made up was possible (that is, no game is won by someone who is spectating if Alex, Bob and Carl play according to the rules). Help them to check it!
Input
The first line contains one integer n (1 ≤ n ≤ 100) — the number of games Alex, Bob and Carl played.
Then n lines follow, describing the game log. i-th line contains one integer ai (1 ≤ ai ≤ 3) which is equal to 1 if Alex won i-th game, to 2 if Bob won i-th game and 3 if Carl won i-th game.
Output
Print YES if the situation described in the log was possible. Otherwise print NO.
Examples
Input
3
1
1
2
Output
YES
Input
2
1
2
Output
NO
Note
In the first example the possible situation is:
1. Alex wins, Carl starts playing instead of Bob;
2. Alex wins, Bob replaces Carl;
3. Bob wins.
The situation in the second example is impossible because Bob loses the first game, so he cannot win the second one.
Submitted Solution:
```
n=int(input())
l=[]
for i in range(n):
l.append(int(input()))
def f(l):
a=[1,2]
for i in l:
if i not in a:
return "NO"
b=[1,2,3]
for x in a:
b.remove(x)
a=[i,b[0]]
return "YES"
print(f(l))
``` | instruction | 0 | 73,039 | 17 | 146,078 |
Yes | output | 1 | 73,039 | 17 | 146,079 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alex, Bob and Carl will soon participate in a team chess tournament. Since they are all in the same team, they have decided to practise really hard before the tournament. But it's a bit difficult for them because chess is a game for two players, not three.
So they play with each other according to following rules:
* Alex and Bob play the first game, and Carl is spectating;
* When the game ends, the one who lost the game becomes the spectator in the next game, and the one who was spectating plays against the winner.
Alex, Bob and Carl play in such a way that there are no draws.
Today they have played n games, and for each of these games they remember who was the winner. They decided to make up a log of games describing who won each game. But now they doubt if the information in the log is correct, and they want to know if the situation described in the log they made up was possible (that is, no game is won by someone who is spectating if Alex, Bob and Carl play according to the rules). Help them to check it!
Input
The first line contains one integer n (1 ≤ n ≤ 100) — the number of games Alex, Bob and Carl played.
Then n lines follow, describing the game log. i-th line contains one integer ai (1 ≤ ai ≤ 3) which is equal to 1 if Alex won i-th game, to 2 if Bob won i-th game and 3 if Carl won i-th game.
Output
Print YES if the situation described in the log was possible. Otherwise print NO.
Examples
Input
3
1
1
2
Output
YES
Input
2
1
2
Output
NO
Note
In the first example the possible situation is:
1. Alex wins, Carl starts playing instead of Bob;
2. Alex wins, Bob replaces Carl;
3. Bob wins.
The situation in the second example is impossible because Bob loses the first game, so he cannot win the second one.
Submitted Solution:
```
n = int(input())
T = set([1,2])
p = 0
for i in range(n):
a = int(input())
if a in T:
p = p + 1
else:
print("NO")
break
for i in range(1,4):
if i not in T:
m = i
break
for k in T:
if k != a:
T.remove(k)
T.add(m)
break
if p == n:
print("YES")
else:
pass
``` | instruction | 0 | 73,040 | 17 | 146,080 |
Yes | output | 1 | 73,040 | 17 | 146,081 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alex, Bob and Carl will soon participate in a team chess tournament. Since they are all in the same team, they have decided to practise really hard before the tournament. But it's a bit difficult for them because chess is a game for two players, not three.
So they play with each other according to following rules:
* Alex and Bob play the first game, and Carl is spectating;
* When the game ends, the one who lost the game becomes the spectator in the next game, and the one who was spectating plays against the winner.
Alex, Bob and Carl play in such a way that there are no draws.
Today they have played n games, and for each of these games they remember who was the winner. They decided to make up a log of games describing who won each game. But now they doubt if the information in the log is correct, and they want to know if the situation described in the log they made up was possible (that is, no game is won by someone who is spectating if Alex, Bob and Carl play according to the rules). Help them to check it!
Input
The first line contains one integer n (1 ≤ n ≤ 100) — the number of games Alex, Bob and Carl played.
Then n lines follow, describing the game log. i-th line contains one integer ai (1 ≤ ai ≤ 3) which is equal to 1 if Alex won i-th game, to 2 if Bob won i-th game and 3 if Carl won i-th game.
Output
Print YES if the situation described in the log was possible. Otherwise print NO.
Examples
Input
3
1
1
2
Output
YES
Input
2
1
2
Output
NO
Note
In the first example the possible situation is:
1. Alex wins, Carl starts playing instead of Bob;
2. Alex wins, Bob replaces Carl;
3. Bob wins.
The situation in the second example is impossible because Bob loses the first game, so he cannot win the second one.
Submitted Solution:
```
#chess for 3, edu 33 A
def ni():
s=input()
while len(s)==0:
s=input()
try:
return int(s)
except:
return 0
def nia():
s=input()
while len(s)==0:
s=input()
s=s.split()
iVal=[];
for i in range (len(s)):
iVal.append(int(s[i]))
return iVal
def solve():
games=ni()
winner=[None]*games
for i in range (games):
winner[i]=ni()
last=winner[0]
if last==3: #first game winner must be 1 or 2
return False
loser=3-last
spect=3
for i in range(1, games):
if winner[i]==last: #same winner, swap spect and loser
temp=loser
loser=spect
spect=temp
else:
if winner[i]==loser: #new winner cannot be last loser
return False
else:
spect=loser
loser=last
last=winner[i]
return True
if solve():
print("YES")
else:
print("NO")
``` | instruction | 0 | 73,041 | 17 | 146,082 |
Yes | output | 1 | 73,041 | 17 | 146,083 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alex, Bob and Carl will soon participate in a team chess tournament. Since they are all in the same team, they have decided to practise really hard before the tournament. But it's a bit difficult for them because chess is a game for two players, not three.
So they play with each other according to following rules:
* Alex and Bob play the first game, and Carl is spectating;
* When the game ends, the one who lost the game becomes the spectator in the next game, and the one who was spectating plays against the winner.
Alex, Bob and Carl play in such a way that there are no draws.
Today they have played n games, and for each of these games they remember who was the winner. They decided to make up a log of games describing who won each game. But now they doubt if the information in the log is correct, and they want to know if the situation described in the log they made up was possible (that is, no game is won by someone who is spectating if Alex, Bob and Carl play according to the rules). Help them to check it!
Input
The first line contains one integer n (1 ≤ n ≤ 100) — the number of games Alex, Bob and Carl played.
Then n lines follow, describing the game log. i-th line contains one integer ai (1 ≤ ai ≤ 3) which is equal to 1 if Alex won i-th game, to 2 if Bob won i-th game and 3 if Carl won i-th game.
Output
Print YES if the situation described in the log was possible. Otherwise print NO.
Examples
Input
3
1
1
2
Output
YES
Input
2
1
2
Output
NO
Note
In the first example the possible situation is:
1. Alex wins, Carl starts playing instead of Bob;
2. Alex wins, Bob replaces Carl;
3. Bob wins.
The situation in the second example is impossible because Bob loses the first game, so he cannot win the second one.
Submitted Solution:
```
n = int(input())
numList = []
answer = 0
for i in range(0, n):
item = int(input())
numList.append(item)
player1 = "Aleksei"
player2 = "Boris"
nextPlayer = "Vasilii"
playerList = [player1, player2, nextPlayer]
for i in range(0, n):
if numList[i] == 1:
if player1 == "Aleksei":
(player2, nextPlayer) = (nextPlayer, player2)
elif player2 == "Aleksei":
(player1, nextPlayer) = (nextPlayer, player1)
else:
answer = "NO"
break
elif numList[i] == 2:
if player1 == "Boris":
(player2, nextPlayer) = (nextPlayer, player2)
elif player2 == "Boris":
(player1, nextPlayer) = (nextPlayer, player1)
else:
answer = "NO"
break
elif numList[i] == 3:
if player1 == "Vasilii":
(player2, nextPlayer) = (nextPlayer, player2)
elif player2 == "Vasilii":
(player1, nextPlayer) = (nextPlayer, player1)
else:
answer = "NO"
break
if answer != "NO":
print("YES")
else:
print("NO")
``` | instruction | 0 | 73,042 | 17 | 146,084 |
Yes | output | 1 | 73,042 | 17 | 146,085 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alex, Bob and Carl will soon participate in a team chess tournament. Since they are all in the same team, they have decided to practise really hard before the tournament. But it's a bit difficult for them because chess is a game for two players, not three.
So they play with each other according to following rules:
* Alex and Bob play the first game, and Carl is spectating;
* When the game ends, the one who lost the game becomes the spectator in the next game, and the one who was spectating plays against the winner.
Alex, Bob and Carl play in such a way that there are no draws.
Today they have played n games, and for each of these games they remember who was the winner. They decided to make up a log of games describing who won each game. But now they doubt if the information in the log is correct, and they want to know if the situation described in the log they made up was possible (that is, no game is won by someone who is spectating if Alex, Bob and Carl play according to the rules). Help them to check it!
Input
The first line contains one integer n (1 ≤ n ≤ 100) — the number of games Alex, Bob and Carl played.
Then n lines follow, describing the game log. i-th line contains one integer ai (1 ≤ ai ≤ 3) which is equal to 1 if Alex won i-th game, to 2 if Bob won i-th game and 3 if Carl won i-th game.
Output
Print YES if the situation described in the log was possible. Otherwise print NO.
Examples
Input
3
1
1
2
Output
YES
Input
2
1
2
Output
NO
Note
In the first example the possible situation is:
1. Alex wins, Carl starts playing instead of Bob;
2. Alex wins, Bob replaces Carl;
3. Bob wins.
The situation in the second example is impossible because Bob loses the first game, so he cannot win the second one.
Submitted Solution:
```
n = int(input())
f = 1
s = 2
new = 3
for i in range(n):
a = int(input())
if f == a:
new, s = s, new
elif s == a:
new, s = s, new
else:
print("NO")
exit()
print("YES")
``` | instruction | 0 | 73,043 | 17 | 146,086 |
No | output | 1 | 73,043 | 17 | 146,087 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alex, Bob and Carl will soon participate in a team chess tournament. Since they are all in the same team, they have decided to practise really hard before the tournament. But it's a bit difficult for them because chess is a game for two players, not three.
So they play with each other according to following rules:
* Alex and Bob play the first game, and Carl is spectating;
* When the game ends, the one who lost the game becomes the spectator in the next game, and the one who was spectating plays against the winner.
Alex, Bob and Carl play in such a way that there are no draws.
Today they have played n games, and for each of these games they remember who was the winner. They decided to make up a log of games describing who won each game. But now they doubt if the information in the log is correct, and they want to know if the situation described in the log they made up was possible (that is, no game is won by someone who is spectating if Alex, Bob and Carl play according to the rules). Help them to check it!
Input
The first line contains one integer n (1 ≤ n ≤ 100) — the number of games Alex, Bob and Carl played.
Then n lines follow, describing the game log. i-th line contains one integer ai (1 ≤ ai ≤ 3) which is equal to 1 if Alex won i-th game, to 2 if Bob won i-th game and 3 if Carl won i-th game.
Output
Print YES if the situation described in the log was possible. Otherwise print NO.
Examples
Input
3
1
1
2
Output
YES
Input
2
1
2
Output
NO
Note
In the first example the possible situation is:
1. Alex wins, Carl starts playing instead of Bob;
2. Alex wins, Bob replaces Carl;
3. Bob wins.
The situation in the second example is impossible because Bob loses the first game, so he cannot win the second one.
Submitted Solution:
```
x=input()
z=[]
for i in range(int(x)):
z.append(input())
def recur(lista):
flag=True
if len(lista)>1:
if lista[0]=="1" and lista[1]=="2":
flag=False
return flag
elif lista[0]=="2"and lista[1]=="1":
flag=False
return flag
elif lista[0]=="1" and lista[1]=="1":
recur(lista[2:])
elif lista[0]=="2" and lista[1]=="2":
recur(lista[2:])
else:
return flag
res=recur(z)
if res==True or res==None :
print("YES")
else:
print("NO")
``` | instruction | 0 | 73,044 | 17 | 146,088 |
No | output | 1 | 73,044 | 17 | 146,089 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alex, Bob and Carl will soon participate in a team chess tournament. Since they are all in the same team, they have decided to practise really hard before the tournament. But it's a bit difficult for them because chess is a game for two players, not three.
So they play with each other according to following rules:
* Alex and Bob play the first game, and Carl is spectating;
* When the game ends, the one who lost the game becomes the spectator in the next game, and the one who was spectating plays against the winner.
Alex, Bob and Carl play in such a way that there are no draws.
Today they have played n games, and for each of these games they remember who was the winner. They decided to make up a log of games describing who won each game. But now they doubt if the information in the log is correct, and they want to know if the situation described in the log they made up was possible (that is, no game is won by someone who is spectating if Alex, Bob and Carl play according to the rules). Help them to check it!
Input
The first line contains one integer n (1 ≤ n ≤ 100) — the number of games Alex, Bob and Carl played.
Then n lines follow, describing the game log. i-th line contains one integer ai (1 ≤ ai ≤ 3) which is equal to 1 if Alex won i-th game, to 2 if Bob won i-th game and 3 if Carl won i-th game.
Output
Print YES if the situation described in the log was possible. Otherwise print NO.
Examples
Input
3
1
1
2
Output
YES
Input
2
1
2
Output
NO
Note
In the first example the possible situation is:
1. Alex wins, Carl starts playing instead of Bob;
2. Alex wins, Bob replaces Carl;
3. Bob wins.
The situation in the second example is impossible because Bob loses the first game, so he cannot win the second one.
Submitted Solution:
```
n = int(input())
lst = list()
for i in range(n):
lst.append(int(input()))
win = lst[0]
lose = 3 - win
for i in range(1,n):
if lst[i] == lose:
print("NO")
exit()
else:
if lst[i] != lst[i -1]:
lose = lst[i -1]
print("YES")
``` | instruction | 0 | 73,045 | 17 | 146,090 |
No | output | 1 | 73,045 | 17 | 146,091 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alex, Bob and Carl will soon participate in a team chess tournament. Since they are all in the same team, they have decided to practise really hard before the tournament. But it's a bit difficult for them because chess is a game for two players, not three.
So they play with each other according to following rules:
* Alex and Bob play the first game, and Carl is spectating;
* When the game ends, the one who lost the game becomes the spectator in the next game, and the one who was spectating plays against the winner.
Alex, Bob and Carl play in such a way that there are no draws.
Today they have played n games, and for each of these games they remember who was the winner. They decided to make up a log of games describing who won each game. But now they doubt if the information in the log is correct, and they want to know if the situation described in the log they made up was possible (that is, no game is won by someone who is spectating if Alex, Bob and Carl play according to the rules). Help them to check it!
Input
The first line contains one integer n (1 ≤ n ≤ 100) — the number of games Alex, Bob and Carl played.
Then n lines follow, describing the game log. i-th line contains one integer ai (1 ≤ ai ≤ 3) which is equal to 1 if Alex won i-th game, to 2 if Bob won i-th game and 3 if Carl won i-th game.
Output
Print YES if the situation described in the log was possible. Otherwise print NO.
Examples
Input
3
1
1
2
Output
YES
Input
2
1
2
Output
NO
Note
In the first example the possible situation is:
1. Alex wins, Carl starts playing instead of Bob;
2. Alex wins, Bob replaces Carl;
3. Bob wins.
The situation in the second example is impossible because Bob loses the first game, so he cannot win the second one.
Submitted Solution:
```
n = int(input())
l = n
player = ["Alex", "Bob", "Carl"]
current = ["Alex", "Bob"]
count = 0
i = 0
while n:
a = int(input())
if a == 1 and 'Alex'in current:
if 'Carl' in current:
current[1] = 'Bob'
else:
current[1] = 'Carl'
current[0] = 'Alex'
print(current)
elif a == 2 and 'Bob' in current:
if 'Alex' in current:
current[1] = 'Carl'
else:
current[1] = 'Alex'
current[0] = 'Bob'
count += 1
elif a == 3 and 'Carl' in current:
if 'Bob' in current:
current[1] = 'Alex'
else:
current[1] = 'Bob'
current[0] = 'Carl'
count += 1
n -= 1
print("YES" if count == l else "NO")
``` | instruction | 0 | 73,046 | 17 | 146,092 |
No | output | 1 | 73,046 | 17 | 146,093 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The final round of Bayan Programming Contest will be held in Tehran, and the participants will be carried around with a yellow bus. The bus has 34 passenger seats: 4 seats in the last row and 3 seats in remaining rows.
<image>
The event coordinator has a list of k participants who should be picked up at the airport. When a participant gets on the bus, he will sit in the last row with an empty seat. If there is more than one empty seat in that row, he will take the leftmost one.
In order to keep track of the people who are on the bus, the event coordinator needs a figure showing which seats are going to be taken by k participants. Your task is to draw the figure representing occupied seats.
Input
The only line of input contains integer k, (0 ≤ k ≤ 34), denoting the number of participants.
Output
Print the figure of a bus with k passengers as described in sample tests. Character '#' denotes an empty seat, while 'O' denotes a taken seat. 'D' is the bus driver and other characters in the output are for the purpose of beautifying the figure. Strictly follow the sample test cases output format. Print exactly six lines. Do not output extra space or other characters.
Examples
Input
9
Output
+------------------------+
|O.O.O.#.#.#.#.#.#.#.#.|D|)
|O.O.O.#.#.#.#.#.#.#.#.|.|
|O.......................|
|O.O.#.#.#.#.#.#.#.#.#.|.|)
+------------------------+
Input
20
Output
+------------------------+
|O.O.O.O.O.O.O.#.#.#.#.|D|)
|O.O.O.O.O.O.#.#.#.#.#.|.|
|O.......................|
|O.O.O.O.O.O.#.#.#.#.#.|.|)
+------------------------+ | instruction | 0 | 73,674 | 17 | 147,348 |
Tags: implementation
Correct Solution:
```
k = int(input())
s = [list('+------------------------+'),
list('|#.#.#.#.#.#.#.#.#.#.#.|D|)'),
list('|#.#.#.#.#.#.#.#.#.#.#.|.|'),
list('|#.......................|'),
list('|#.#.#.#.#.#.#.#.#.#.#.|.|)'),
list('+------------------------+')]
row = 1
c = 1
for i in range(k):
s[c][row] = 'O'
c += 1
if row > 1 and c == 3:
c += 1
if c == 5:
c = 1
row += 2
for i in range(6):
print(''.join([ss for ss in s[i]]))
``` | output | 1 | 73,674 | 17 | 147,349 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The final round of Bayan Programming Contest will be held in Tehran, and the participants will be carried around with a yellow bus. The bus has 34 passenger seats: 4 seats in the last row and 3 seats in remaining rows.
<image>
The event coordinator has a list of k participants who should be picked up at the airport. When a participant gets on the bus, he will sit in the last row with an empty seat. If there is more than one empty seat in that row, he will take the leftmost one.
In order to keep track of the people who are on the bus, the event coordinator needs a figure showing which seats are going to be taken by k participants. Your task is to draw the figure representing occupied seats.
Input
The only line of input contains integer k, (0 ≤ k ≤ 34), denoting the number of participants.
Output
Print the figure of a bus with k passengers as described in sample tests. Character '#' denotes an empty seat, while 'O' denotes a taken seat. 'D' is the bus driver and other characters in the output are for the purpose of beautifying the figure. Strictly follow the sample test cases output format. Print exactly six lines. Do not output extra space or other characters.
Examples
Input
9
Output
+------------------------+
|O.O.O.#.#.#.#.#.#.#.#.|D|)
|O.O.O.#.#.#.#.#.#.#.#.|.|
|O.......................|
|O.O.#.#.#.#.#.#.#.#.#.|.|)
+------------------------+
Input
20
Output
+------------------------+
|O.O.O.O.O.O.O.#.#.#.#.|D|)
|O.O.O.O.O.O.#.#.#.#.#.|.|
|O.......................|
|O.O.O.O.O.O.#.#.#.#.#.|.|)
+------------------------+ | instruction | 0 | 73,675 | 17 | 147,350 |
Tags: implementation
Correct Solution:
```
n = int(input())
s = ['+------------------------+',
'|#.#.#.#.#.#.#.#.#.#.#.|D|)',
'|#.#.#.#.#.#.#.#.#.#.#.|.|',
'|#.......................|',
'|#.#.#.#.#.#.#.#.#.#.#.|.|)',
'+------------------------+']
for i in range(22):
for j in range(5):
if n and s[j][i] == '#':
n -= 1
s[j] = s[j][:i] + 'O' + s[j][i + 1:]
print('\n'.join(s))
``` | output | 1 | 73,675 | 17 | 147,351 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The final round of Bayan Programming Contest will be held in Tehran, and the participants will be carried around with a yellow bus. The bus has 34 passenger seats: 4 seats in the last row and 3 seats in remaining rows.
<image>
The event coordinator has a list of k participants who should be picked up at the airport. When a participant gets on the bus, he will sit in the last row with an empty seat. If there is more than one empty seat in that row, he will take the leftmost one.
In order to keep track of the people who are on the bus, the event coordinator needs a figure showing which seats are going to be taken by k participants. Your task is to draw the figure representing occupied seats.
Input
The only line of input contains integer k, (0 ≤ k ≤ 34), denoting the number of participants.
Output
Print the figure of a bus with k passengers as described in sample tests. Character '#' denotes an empty seat, while 'O' denotes a taken seat. 'D' is the bus driver and other characters in the output are for the purpose of beautifying the figure. Strictly follow the sample test cases output format. Print exactly six lines. Do not output extra space or other characters.
Examples
Input
9
Output
+------------------------+
|O.O.O.#.#.#.#.#.#.#.#.|D|)
|O.O.O.#.#.#.#.#.#.#.#.|.|
|O.......................|
|O.O.#.#.#.#.#.#.#.#.#.|.|)
+------------------------+
Input
20
Output
+------------------------+
|O.O.O.O.O.O.O.#.#.#.#.|D|)
|O.O.O.O.O.O.#.#.#.#.#.|.|
|O.......................|
|O.O.O.O.O.O.#.#.#.#.#.|.|)
+------------------------+ | instruction | 0 | 73,676 | 17 | 147,352 |
Tags: implementation
Correct Solution:
```
v='''+------------------------+
|#.#.#.#.#.#.#.#.#.#.#.|D|)
|#.#.#.#.#.#.#.#.#.#.#.|.|
|#.......................|
|#.#.#.#.#.#.#.#.#.#.#.|.|)
+------------------------+'''.split()
def sr(n):
"""string replace"""
w=4
a,b=n//w,n%w
vn=w*[a]
for c in range(b):
vn[c]+=1
for c in range(1,w+1):
v[c]=v[c].replace('#','O',vn[c-1])
n=int(input())
if n>5:
n+=n//3-1
sr(n)
for c in v:
print(c)
``` | output | 1 | 73,676 | 17 | 147,353 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The final round of Bayan Programming Contest will be held in Tehran, and the participants will be carried around with a yellow bus. The bus has 34 passenger seats: 4 seats in the last row and 3 seats in remaining rows.
<image>
The event coordinator has a list of k participants who should be picked up at the airport. When a participant gets on the bus, he will sit in the last row with an empty seat. If there is more than one empty seat in that row, he will take the leftmost one.
In order to keep track of the people who are on the bus, the event coordinator needs a figure showing which seats are going to be taken by k participants. Your task is to draw the figure representing occupied seats.
Input
The only line of input contains integer k, (0 ≤ k ≤ 34), denoting the number of participants.
Output
Print the figure of a bus with k passengers as described in sample tests. Character '#' denotes an empty seat, while 'O' denotes a taken seat. 'D' is the bus driver and other characters in the output are for the purpose of beautifying the figure. Strictly follow the sample test cases output format. Print exactly six lines. Do not output extra space or other characters.
Examples
Input
9
Output
+------------------------+
|O.O.O.#.#.#.#.#.#.#.#.|D|)
|O.O.O.#.#.#.#.#.#.#.#.|.|
|O.......................|
|O.O.#.#.#.#.#.#.#.#.#.|.|)
+------------------------+
Input
20
Output
+------------------------+
|O.O.O.O.O.O.O.#.#.#.#.|D|)
|O.O.O.O.O.O.#.#.#.#.#.|.|
|O.......................|
|O.O.O.O.O.O.#.#.#.#.#.|.|)
+------------------------+ | instruction | 0 | 73,677 | 17 | 147,354 |
Tags: implementation
Correct Solution:
```
import sys
def main():
while 1:
try:
line = sys.stdin.readline()
solve(line)
break
except KeyboardInterrupt:
break
pas = ['#','#','#','#','#','#','#','#','#','#',
'#','#','#','#','#','#','#','#','#','#',
'#','#','#','#','#','#','#','#','#','#',
'#','#','#','#']
def solve(line):
for x in range(0,int(line)):
pas[x] = 'O'
print ('+------------------------+')
print ('|{}.{}.{}.{}.{}.{}.{}.{}.{}.{}.{}.|D|)' .format(pas[0],pas[4],pas[7],pas[10],pas[13],pas[16],pas[19],pas[22],pas[25],pas[28],pas[31]))
print ('|{}.{}.{}.{}.{}.{}.{}.{}.{}.{}.{}.|.|' .format(pas[1],pas[5],pas[8],pas[11],pas[14],pas[17],pas[20],pas[23],pas[26],pas[29],pas[32]))
print ('|{}.......................|' .format(pas[2]))
print ('|{}.{}.{}.{}.{}.{}.{}.{}.{}.{}.{}.|.|)' .format(pas[3],pas[6],pas[9],pas[12],pas[15],pas[18],pas[21],pas[24],pas[27],pas[30],pas[33]))
print ('+------------------------+')
if __name__ == "__main__":
main()
# 1502214954884
``` | output | 1 | 73,677 | 17 | 147,355 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The final round of Bayan Programming Contest will be held in Tehran, and the participants will be carried around with a yellow bus. The bus has 34 passenger seats: 4 seats in the last row and 3 seats in remaining rows.
<image>
The event coordinator has a list of k participants who should be picked up at the airport. When a participant gets on the bus, he will sit in the last row with an empty seat. If there is more than one empty seat in that row, he will take the leftmost one.
In order to keep track of the people who are on the bus, the event coordinator needs a figure showing which seats are going to be taken by k participants. Your task is to draw the figure representing occupied seats.
Input
The only line of input contains integer k, (0 ≤ k ≤ 34), denoting the number of participants.
Output
Print the figure of a bus with k passengers as described in sample tests. Character '#' denotes an empty seat, while 'O' denotes a taken seat. 'D' is the bus driver and other characters in the output are for the purpose of beautifying the figure. Strictly follow the sample test cases output format. Print exactly six lines. Do not output extra space or other characters.
Examples
Input
9
Output
+------------------------+
|O.O.O.#.#.#.#.#.#.#.#.|D|)
|O.O.O.#.#.#.#.#.#.#.#.|.|
|O.......................|
|O.O.#.#.#.#.#.#.#.#.#.|.|)
+------------------------+
Input
20
Output
+------------------------+
|O.O.O.O.O.O.O.#.#.#.#.|D|)
|O.O.O.O.O.O.#.#.#.#.#.|.|
|O.......................|
|O.O.O.O.O.O.#.#.#.#.#.|.|)
+------------------------+ | instruction | 0 | 73,678 | 17 | 147,356 |
Tags: implementation
Correct Solution:
```
# 9
# +------------------------+
# |O.O.O.#.#.#.#.#.#.#.#.|D|)
# |O.O.O.#.#.#.#.#.#.#.#.|.|
# |O.......................|
# |O.O.#.#.#.#.#.#.#.#.#.|.|)
# +------------------------+
# +------------------------+
# |O.O.O.#.#.#.#.#.#.#.#.|D|)
# |O.O.O.#.#.#.#.#.#.#.#.|.|
# |O.......................|
# |O.O.#.#.#.#.#.#.#.#.#.|.|)
# +------------------------+
# 20
# +------------------------+
# |O.O.O.O.O.O.O.#.#.#.#.|D|)
# |O.O.O.O.O.O.#.#.#.#.#.|.|
# |O.......................|
# |O.O.O.O.O.O.#.#.#.#.#.|.|)
# +------------------------+
# +------------------------+
# |O.O.O.O.O.O.O.#.#.#.#.|D|)
# |O.O.O.O.O.O.#.#.#.#.#.|.|
# |O.......................|
# |O.O.O.O.O.O.#.#.#.#.#.|.|)
# +------------------------+
def sol(A):
print('+------------------------+')
for i in range(4):
for j in range(11):
if j == 0:
if A[i][j] == 1:
A[i][j] = '|O'
else:
A[i][j] = '|#'
else:
if i == 2:
A[i][j] = '.'
else:
if A[i][j] == 1:
A[i][j] = '.O'
else:
A[i][j] = '.#'
if i == 0:
A[i].append('.|D|)')
elif i == 2:
for _ in range(13):
A[i].append('.')
A[i].append('|')
elif i==3:
A[i].append('.|.|)')
else:
A[i].append('.|.|')
for row in A:
print(''.join(row))
print('+------------------------+')
if __name__ == '__main__':
k = int(input())
j = 0
A = [[None for y in range(11)] for x in range(4)]
if k == 0:
sol(A)
# print(k)
# print(A)
while k>0:
# print('1')
while k>0 and j<11:
# print('2')
i=0
if j == 0:
while k>0 and i<4:
# print('3')
A[i][j] = 1
i+=1
k-=1
if k == 0:
sol(A)
else:
while k>0 and i<4:
# print('4')
if i == 2:
i+=1
continue
else:
A[i][j] = 1
i+=1
k-=1
if k==0:
sol(A)
j+=1
``` | output | 1 | 73,678 | 17 | 147,357 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The final round of Bayan Programming Contest will be held in Tehran, and the participants will be carried around with a yellow bus. The bus has 34 passenger seats: 4 seats in the last row and 3 seats in remaining rows.
<image>
The event coordinator has a list of k participants who should be picked up at the airport. When a participant gets on the bus, he will sit in the last row with an empty seat. If there is more than one empty seat in that row, he will take the leftmost one.
In order to keep track of the people who are on the bus, the event coordinator needs a figure showing which seats are going to be taken by k participants. Your task is to draw the figure representing occupied seats.
Input
The only line of input contains integer k, (0 ≤ k ≤ 34), denoting the number of participants.
Output
Print the figure of a bus with k passengers as described in sample tests. Character '#' denotes an empty seat, while 'O' denotes a taken seat. 'D' is the bus driver and other characters in the output are for the purpose of beautifying the figure. Strictly follow the sample test cases output format. Print exactly six lines. Do not output extra space or other characters.
Examples
Input
9
Output
+------------------------+
|O.O.O.#.#.#.#.#.#.#.#.|D|)
|O.O.O.#.#.#.#.#.#.#.#.|.|
|O.......................|
|O.O.#.#.#.#.#.#.#.#.#.|.|)
+------------------------+
Input
20
Output
+------------------------+
|O.O.O.O.O.O.O.#.#.#.#.|D|)
|O.O.O.O.O.O.#.#.#.#.#.|.|
|O.......................|
|O.O.O.O.O.O.#.#.#.#.#.|.|)
+------------------------+ | instruction | 0 | 73,679 | 17 | 147,358 |
Tags: implementation
Correct Solution:
```
'''
Created on Oct 5, 2014
@author: Ismael
'''
def printBus(lastRow,otherRows):
s = "+------------------------+\n"
for i in range(4):
s += "|"+lastRow[i]+"."
for j in range(10):
if(i == 2):
s += ".."
elif(i == 3):
s += otherRows[j][i-1]+"."
else:
s += otherRows[j][i]+"."
if(i == 0):
s += "|D|)"
elif(i == 1):
s += "|.|"
elif(i == 2):
s += "..|"
else:
s += "|.|)"
s += "\n"
s += "+------------------------+"
print(s)
def solve(n):
lastRow = []
otherRows = [[]]
while(n>0):
if(len(lastRow)<4):
lastRow.append('O')
else:
if(len(otherRows[-1])<3):
otherRows[-1].append('O')
else:
otherRows.append(['O'])
n -= 1
otherRows += [[] for _ in range(10-len(otherRows))]
lastRow += (4-len(lastRow))*['#']
for row in otherRows:
row += (3-len(row))*['#']
printBus(lastRow,otherRows)
n = int(input())
solve(n)
``` | output | 1 | 73,679 | 17 | 147,359 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The final round of Bayan Programming Contest will be held in Tehran, and the participants will be carried around with a yellow bus. The bus has 34 passenger seats: 4 seats in the last row and 3 seats in remaining rows.
<image>
The event coordinator has a list of k participants who should be picked up at the airport. When a participant gets on the bus, he will sit in the last row with an empty seat. If there is more than one empty seat in that row, he will take the leftmost one.
In order to keep track of the people who are on the bus, the event coordinator needs a figure showing which seats are going to be taken by k participants. Your task is to draw the figure representing occupied seats.
Input
The only line of input contains integer k, (0 ≤ k ≤ 34), denoting the number of participants.
Output
Print the figure of a bus with k passengers as described in sample tests. Character '#' denotes an empty seat, while 'O' denotes a taken seat. 'D' is the bus driver and other characters in the output are for the purpose of beautifying the figure. Strictly follow the sample test cases output format. Print exactly six lines. Do not output extra space or other characters.
Examples
Input
9
Output
+------------------------+
|O.O.O.#.#.#.#.#.#.#.#.|D|)
|O.O.O.#.#.#.#.#.#.#.#.|.|
|O.......................|
|O.O.#.#.#.#.#.#.#.#.#.|.|)
+------------------------+
Input
20
Output
+------------------------+
|O.O.O.O.O.O.O.#.#.#.#.|D|)
|O.O.O.O.O.O.#.#.#.#.#.|.|
|O.......................|
|O.O.O.O.O.O.#.#.#.#.#.|.|)
+------------------------+ | instruction | 0 | 73,680 | 17 | 147,360 |
Tags: implementation
Correct Solution:
```
def proximoHashtag(v):
for i in range(1,22,2):
for j in range(0,4):
if(j==2 and i>1):
continue
if(v[j][i] == '#'):
v[j] = v[j][:i] + 'O' + v[j][i+1:]
return
n = int(input())
print("+------------------------+")
a = "|#.#.#.#.#.#.#.#.#.#.#.|D|)"
b = "|#.#.#.#.#.#.#.#.#.#.#.|.|"
c = "|#.......................|"
d = "|#.#.#.#.#.#.#.#.#.#.#.|.|)"
v = [a,b,c,d]
for i in range(0,n):
proximoHashtag(v)
for i in range(0,4):
print(v[i])
print("+------------------------+")
``` | output | 1 | 73,680 | 17 | 147,361 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The final round of Bayan Programming Contest will be held in Tehran, and the participants will be carried around with a yellow bus. The bus has 34 passenger seats: 4 seats in the last row and 3 seats in remaining rows.
<image>
The event coordinator has a list of k participants who should be picked up at the airport. When a participant gets on the bus, he will sit in the last row with an empty seat. If there is more than one empty seat in that row, he will take the leftmost one.
In order to keep track of the people who are on the bus, the event coordinator needs a figure showing which seats are going to be taken by k participants. Your task is to draw the figure representing occupied seats.
Input
The only line of input contains integer k, (0 ≤ k ≤ 34), denoting the number of participants.
Output
Print the figure of a bus with k passengers as described in sample tests. Character '#' denotes an empty seat, while 'O' denotes a taken seat. 'D' is the bus driver and other characters in the output are for the purpose of beautifying the figure. Strictly follow the sample test cases output format. Print exactly six lines. Do not output extra space or other characters.
Examples
Input
9
Output
+------------------------+
|O.O.O.#.#.#.#.#.#.#.#.|D|)
|O.O.O.#.#.#.#.#.#.#.#.|.|
|O.......................|
|O.O.#.#.#.#.#.#.#.#.#.|.|)
+------------------------+
Input
20
Output
+------------------------+
|O.O.O.O.O.O.O.#.#.#.#.|D|)
|O.O.O.O.O.O.#.#.#.#.#.|.|
|O.......................|
|O.O.O.O.O.O.#.#.#.#.#.|.|)
+------------------------+ | instruction | 0 | 73,681 | 17 | 147,362 |
Tags: implementation
Correct Solution:
```
__author__ = 'hamed1soleimani'
lines = list()
lines.append('+------------------------+')
lines.append('|#.#.#.#.#.#.#.#.#.#.#.|D|)')
lines.append('|#.#.#.#.#.#.#.#.#.#.#.|.|')
lines.append('|#.......................|')
lines.append('|#.#.#.#.#.#.#.#.#.#.#.|.|)')
lines.append('+------------------------+')
n = int(input())
while True:
if n == 0:
break
idx = list()
for m in range(1, 5):
idx.append(lines[m].find('#'))
while True:
if idx.count(-1) > 0:
idx.remove(-1)
else:
break
x = min(idx)
if lines[1].find('#') == x:
lines[1] = lines[1].replace('#', 'O', 1)
n -= 1
elif lines[2].find('#') == x:
lines[2] = lines[2].replace('#', 'O', 1)
n -= 1
elif lines[3].find('#') == x:
lines[3] = lines[3].replace('#', 'O', 1)
n -= 1
elif lines[4].find('#') == x:
lines[4] = lines[4].replace('#', 'O', 1)
n -= 1
for ss in lines:
print(ss)
``` | output | 1 | 73,681 | 17 | 147,363 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The final round of Bayan Programming Contest will be held in Tehran, and the participants will be carried around with a yellow bus. The bus has 34 passenger seats: 4 seats in the last row and 3 seats in remaining rows.
<image>
The event coordinator has a list of k participants who should be picked up at the airport. When a participant gets on the bus, he will sit in the last row with an empty seat. If there is more than one empty seat in that row, he will take the leftmost one.
In order to keep track of the people who are on the bus, the event coordinator needs a figure showing which seats are going to be taken by k participants. Your task is to draw the figure representing occupied seats.
Input
The only line of input contains integer k, (0 ≤ k ≤ 34), denoting the number of participants.
Output
Print the figure of a bus with k passengers as described in sample tests. Character '#' denotes an empty seat, while 'O' denotes a taken seat. 'D' is the bus driver and other characters in the output are for the purpose of beautifying the figure. Strictly follow the sample test cases output format. Print exactly six lines. Do not output extra space or other characters.
Examples
Input
9
Output
+------------------------+
|O.O.O.#.#.#.#.#.#.#.#.|D|)
|O.O.O.#.#.#.#.#.#.#.#.|.|
|O.......................|
|O.O.#.#.#.#.#.#.#.#.#.|.|)
+------------------------+
Input
20
Output
+------------------------+
|O.O.O.O.O.O.O.#.#.#.#.|D|)
|O.O.O.O.O.O.#.#.#.#.#.|.|
|O.......................|
|O.O.O.O.O.O.#.#.#.#.#.|.|)
+------------------------+
Submitted Solution:
```
from sys import stdin
def imprime(a):
for i in range(0,len(a)):
print(a[i],end='')
def main():
bus=[['+','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','+',''],['|','#','.','#','.','#','.','#','.','#','.','#','.','#','.','#','.','#','.','#','.','#','.','|','D','|',')'],['|','#','.','#','.','#','.','#','.','#','.','#','.','#','.','#','.','#','.','#','.','#','.','|','.','|',''],['|','#','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','|',''],['|','#','.','#','.','#','.','#','.','#','.','#','.','#','.','#','.','#','.','#','.','#','.','|','.','|',')'],['+','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','+','']]
a=int(input())
cont=0
for i in range(27):
for j in range(6):
if bus[j][i]=='#':
bus[j][i]='O'
cont+=1
if cont==a:
break
for i in range(len(bus)):
imprime(bus[i])
print()
main()
``` | instruction | 0 | 73,682 | 17 | 147,364 |
Yes | output | 1 | 73,682 | 17 | 147,365 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The final round of Bayan Programming Contest will be held in Tehran, and the participants will be carried around with a yellow bus. The bus has 34 passenger seats: 4 seats in the last row and 3 seats in remaining rows.
<image>
The event coordinator has a list of k participants who should be picked up at the airport. When a participant gets on the bus, he will sit in the last row with an empty seat. If there is more than one empty seat in that row, he will take the leftmost one.
In order to keep track of the people who are on the bus, the event coordinator needs a figure showing which seats are going to be taken by k participants. Your task is to draw the figure representing occupied seats.
Input
The only line of input contains integer k, (0 ≤ k ≤ 34), denoting the number of participants.
Output
Print the figure of a bus with k passengers as described in sample tests. Character '#' denotes an empty seat, while 'O' denotes a taken seat. 'D' is the bus driver and other characters in the output are for the purpose of beautifying the figure. Strictly follow the sample test cases output format. Print exactly six lines. Do not output extra space or other characters.
Examples
Input
9
Output
+------------------------+
|O.O.O.#.#.#.#.#.#.#.#.|D|)
|O.O.O.#.#.#.#.#.#.#.#.|.|
|O.......................|
|O.O.#.#.#.#.#.#.#.#.#.|.|)
+------------------------+
Input
20
Output
+------------------------+
|O.O.O.O.O.O.O.#.#.#.#.|D|)
|O.O.O.O.O.O.#.#.#.#.#.|.|
|O.......................|
|O.O.O.O.O.O.#.#.#.#.#.|.|)
+------------------------+
Submitted Solution:
```
from collections import Counter
from functools import lru_cache, wraps
from math import gcd
from string import ascii_lowercase
from sys import stderr, stdin, stdout
import time
INF = 10 ** 18 + 3
EPS = 1e-10
# Decorators
def print_to_file(function, file=stderr):
def wrapped(*args, **kwargs):
res = function(*args, **kwargs)
print(res, file=file)
file.flush()
return res
return wrapped
def time_it(function, output=stderr):
def wrapped(*args, **kwargs):
start = time.time()
res = function(*args, **kwargs)
elapsed_time = time.time() - start
print('Function "%s" took %f ms' % (function.__name__, elapsed_time * 1000),
file=output)
return res
return wrapped
@time_it
def main():
k = int(input())
text = "+" + "|" * 4 + "+\n"
text += "-" + "O" * min(4, k) + "#" * (4 - min(4, k)) + "-\n"
text += "-" + "." * 4 + "-\n"
k -= min(4, k)
for _ in range(10):
row = "O" * min(3, k) + "#" * (3 - min(3, k))
row = row[:2] + "." + row[2:]
text += "-" + row + "-\n"
text += "-" + "." * 4 + "-\n"
k -= min(3, k)
text += "-||.|-\n"
text += "-D...-\n"
text += "+" + "|" * 4 + "+"
# print()
text = ["".join(el) for el in zip(*text.split("\n"))]
text[1] += ")"
text[4] += ")"
for line in text:
print(line)
# Auxiliary functions
@print_to_file
def range_of_len(start, length, step=1):
return range(start, start + length * step, step)
# IO reassignment
def set_input(file):
global input
input = lambda: file.readline().strip()
def set_output(file):
global print
l_print = print
def print(*args, **kwargs):
kwargs["file"] = kwargs.get("file", file)
return l_print(*args, **kwargs)
if __name__ == '__main__':
# set_input(open("fin", "r"))
# set_output(open("sum.out", "w"))
main()
``` | instruction | 0 | 73,683 | 17 | 147,366 |
Yes | output | 1 | 73,683 | 17 | 147,367 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The final round of Bayan Programming Contest will be held in Tehran, and the participants will be carried around with a yellow bus. The bus has 34 passenger seats: 4 seats in the last row and 3 seats in remaining rows.
<image>
The event coordinator has a list of k participants who should be picked up at the airport. When a participant gets on the bus, he will sit in the last row with an empty seat. If there is more than one empty seat in that row, he will take the leftmost one.
In order to keep track of the people who are on the bus, the event coordinator needs a figure showing which seats are going to be taken by k participants. Your task is to draw the figure representing occupied seats.
Input
The only line of input contains integer k, (0 ≤ k ≤ 34), denoting the number of participants.
Output
Print the figure of a bus with k passengers as described in sample tests. Character '#' denotes an empty seat, while 'O' denotes a taken seat. 'D' is the bus driver and other characters in the output are for the purpose of beautifying the figure. Strictly follow the sample test cases output format. Print exactly six lines. Do not output extra space or other characters.
Examples
Input
9
Output
+------------------------+
|O.O.O.#.#.#.#.#.#.#.#.|D|)
|O.O.O.#.#.#.#.#.#.#.#.|.|
|O.......................|
|O.O.#.#.#.#.#.#.#.#.#.|.|)
+------------------------+
Input
20
Output
+------------------------+
|O.O.O.O.O.O.O.#.#.#.#.|D|)
|O.O.O.O.O.O.#.#.#.#.#.|.|
|O.......................|
|O.O.O.O.O.O.#.#.#.#.#.|.|)
+------------------------+
Submitted Solution:
```
k = int(input())
bus = []
bus.append([])
bus.append([])
bus.append([])
bus.append([])
row = 0
for i in range(k):
bus[row].append("O")
row = (row + 1) % len(bus)
if (i > 4 and row == 2):
row += 1
if len(bus[2]) == 0:
bus[2].append("#")
for i in range(11 - len(bus[0])):
bus[0].append("#")
for i in range(11 - len(bus[1])):
bus[1].append("#")
for i in range(11 - len(bus[2])):
bus[2].append(".")
for i in range(11 - len(bus[3])):
bus[3].append("#")
print("+------------------------+")
print("|" + ".".join(bus[0]) + ".|D|)")
print("|" + ".".join(bus[1]) + ".|.|")
print("|" + ".".join(bus[2]) + "...|")
print("|" + ".".join(bus[3]) + ".|.|)")
print("+------------------------+")
``` | instruction | 0 | 73,684 | 17 | 147,368 |
Yes | output | 1 | 73,684 | 17 | 147,369 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The final round of Bayan Programming Contest will be held in Tehran, and the participants will be carried around with a yellow bus. The bus has 34 passenger seats: 4 seats in the last row and 3 seats in remaining rows.
<image>
The event coordinator has a list of k participants who should be picked up at the airport. When a participant gets on the bus, he will sit in the last row with an empty seat. If there is more than one empty seat in that row, he will take the leftmost one.
In order to keep track of the people who are on the bus, the event coordinator needs a figure showing which seats are going to be taken by k participants. Your task is to draw the figure representing occupied seats.
Input
The only line of input contains integer k, (0 ≤ k ≤ 34), denoting the number of participants.
Output
Print the figure of a bus with k passengers as described in sample tests. Character '#' denotes an empty seat, while 'O' denotes a taken seat. 'D' is the bus driver and other characters in the output are for the purpose of beautifying the figure. Strictly follow the sample test cases output format. Print exactly six lines. Do not output extra space or other characters.
Examples
Input
9
Output
+------------------------+
|O.O.O.#.#.#.#.#.#.#.#.|D|)
|O.O.O.#.#.#.#.#.#.#.#.|.|
|O.......................|
|O.O.#.#.#.#.#.#.#.#.#.|.|)
+------------------------+
Input
20
Output
+------------------------+
|O.O.O.O.O.O.O.#.#.#.#.|D|)
|O.O.O.O.O.O.#.#.#.#.#.|.|
|O.......................|
|O.O.O.O.O.O.#.#.#.#.#.|.|)
+------------------------+
Submitted Solution:
```
import math
k = 11
p = int(input())
print('+------------------------+')
print('|',end='')
if p > 4:
t = 1 + math.ceil((p-4)/3)
print(t*'O.',end='')
print((k-t)*'#.',end='')
elif p == 0:
print(k*'#.', end='')
else:
print('O.' + (k-1)*'#.', end='')
print('|D|)')
print('|',end='')
if p > 4:
t = 1 + (p-4)//3
if (p-4) % 3 == 2: t += 1
print(t*'O.',end='')
print((k-t)*'#.',end='')
elif p < 2:
print(k*'#.', end='')
else:
print('O.' + (k-1)*'#.', end='')
print('|.|')
print('|',end='')
if p < 3:
print('#.......................|')
else:
print('O.......................|')
print('|',end='')
if p > 4:
t = 1 + (p-4)//3
print(t*'O.',end='')
print((k-t)*'#.',end='')
elif p < 4:
print(k*'#.', end='')
else:
print('O.' + (k-1)*'#.', end='')
print('|.|)')
print('+------------------------+')
# 1505499034082
``` | instruction | 0 | 73,685 | 17 | 147,370 |
Yes | output | 1 | 73,685 | 17 | 147,371 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The final round of Bayan Programming Contest will be held in Tehran, and the participants will be carried around with a yellow bus. The bus has 34 passenger seats: 4 seats in the last row and 3 seats in remaining rows.
<image>
The event coordinator has a list of k participants who should be picked up at the airport. When a participant gets on the bus, he will sit in the last row with an empty seat. If there is more than one empty seat in that row, he will take the leftmost one.
In order to keep track of the people who are on the bus, the event coordinator needs a figure showing which seats are going to be taken by k participants. Your task is to draw the figure representing occupied seats.
Input
The only line of input contains integer k, (0 ≤ k ≤ 34), denoting the number of participants.
Output
Print the figure of a bus with k passengers as described in sample tests. Character '#' denotes an empty seat, while 'O' denotes a taken seat. 'D' is the bus driver and other characters in the output are for the purpose of beautifying the figure. Strictly follow the sample test cases output format. Print exactly six lines. Do not output extra space or other characters.
Examples
Input
9
Output
+------------------------+
|O.O.O.#.#.#.#.#.#.#.#.|D|)
|O.O.O.#.#.#.#.#.#.#.#.|.|
|O.......................|
|O.O.#.#.#.#.#.#.#.#.#.|.|)
+------------------------+
Input
20
Output
+------------------------+
|O.O.O.O.O.O.O.#.#.#.#.|D|)
|O.O.O.O.O.O.#.#.#.#.#.|.|
|O.......................|
|O.O.O.O.O.O.#.#.#.#.#.|.|)
+------------------------+
Submitted Solution:
```
x=int(input())
y= x-4
fila=[]
if(y>=0):
fila.append(1+y//3)
fila.append(1+y//3)
fila.append(1+y//3)
if(y%3==2):
fila[1]+=1
if(y%3>=1):
fila[0]+=1
else:
if(x>=1):
fila.append(1)
else:
fila.append(0)
fila.append(x//2)
fila.append(0)
if(x>=2):
k="O."
else:
k="#."
print("+------------------------+")
print("|"+("O."*fila[0])+("#."*(11-fila[0]))+"|D|)")
print("|"+("O."*fila[1])+("#."*(11-fila[1]))+"|.|)")
print("|"+k+"......................|")
print("|"+("O."*fila[2])+("#."*(11-fila[2]))+"|.|)")
print("+------------------------+")
``` | instruction | 0 | 73,686 | 17 | 147,372 |
No | output | 1 | 73,686 | 17 | 147,373 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The final round of Bayan Programming Contest will be held in Tehran, and the participants will be carried around with a yellow bus. The bus has 34 passenger seats: 4 seats in the last row and 3 seats in remaining rows.
<image>
The event coordinator has a list of k participants who should be picked up at the airport. When a participant gets on the bus, he will sit in the last row with an empty seat. If there is more than one empty seat in that row, he will take the leftmost one.
In order to keep track of the people who are on the bus, the event coordinator needs a figure showing which seats are going to be taken by k participants. Your task is to draw the figure representing occupied seats.
Input
The only line of input contains integer k, (0 ≤ k ≤ 34), denoting the number of participants.
Output
Print the figure of a bus with k passengers as described in sample tests. Character '#' denotes an empty seat, while 'O' denotes a taken seat. 'D' is the bus driver and other characters in the output are for the purpose of beautifying the figure. Strictly follow the sample test cases output format. Print exactly six lines. Do not output extra space or other characters.
Examples
Input
9
Output
+------------------------+
|O.O.O.#.#.#.#.#.#.#.#.|D|)
|O.O.O.#.#.#.#.#.#.#.#.|.|
|O.......................|
|O.O.#.#.#.#.#.#.#.#.#.|.|)
+------------------------+
Input
20
Output
+------------------------+
|O.O.O.O.O.O.O.#.#.#.#.|D|)
|O.O.O.O.O.O.#.#.#.#.#.|.|
|O.......................|
|O.O.O.O.O.O.#.#.#.#.#.|.|)
+------------------------+
Submitted Solution:
```
x=int(input())
y= x-4
fila=[]
if(y>=0):
fila.append(1+y//3)
fila.append(1+y//3)
fila.append(1+y//3)
if(y%3==2):
fila[1]+=1
if(y%3>=1):
fila[0]+=1
else:
if(x>=1):
fila.append(1)
else:
fila.append(0)
fila.append(x//2)
fila.append(0)
if(x>=2):
k="O."
else:
k="#."
print("+------------------------+")
print("|"+("O."*fila[0])+("#."*(11-fila[0]))+"|D|)")
print("|"+("O."*fila[1])+("#."*(11-fila[1]))+"|.|)")
print("|"+k+".......................|")
print("|"+("O."*fila[2])+("#."*(11-fila[2]))+"|.|)")
print("+------------------------+")
``` | instruction | 0 | 73,687 | 17 | 147,374 |
No | output | 1 | 73,687 | 17 | 147,375 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The final round of Bayan Programming Contest will be held in Tehran, and the participants will be carried around with a yellow bus. The bus has 34 passenger seats: 4 seats in the last row and 3 seats in remaining rows.
<image>
The event coordinator has a list of k participants who should be picked up at the airport. When a participant gets on the bus, he will sit in the last row with an empty seat. If there is more than one empty seat in that row, he will take the leftmost one.
In order to keep track of the people who are on the bus, the event coordinator needs a figure showing which seats are going to be taken by k participants. Your task is to draw the figure representing occupied seats.
Input
The only line of input contains integer k, (0 ≤ k ≤ 34), denoting the number of participants.
Output
Print the figure of a bus with k passengers as described in sample tests. Character '#' denotes an empty seat, while 'O' denotes a taken seat. 'D' is the bus driver and other characters in the output are for the purpose of beautifying the figure. Strictly follow the sample test cases output format. Print exactly six lines. Do not output extra space or other characters.
Examples
Input
9
Output
+------------------------+
|O.O.O.#.#.#.#.#.#.#.#.|D|)
|O.O.O.#.#.#.#.#.#.#.#.|.|
|O.......................|
|O.O.#.#.#.#.#.#.#.#.#.|.|)
+------------------------+
Input
20
Output
+------------------------+
|O.O.O.O.O.O.O.#.#.#.#.|D|)
|O.O.O.O.O.O.#.#.#.#.#.|.|
|O.......................|
|O.O.O.O.O.O.#.#.#.#.#.|.|)
+------------------------+
Submitted Solution:
```
k = int(input())
values = [['#' for i in range(11)] for i in range(3)]
for i in range(k - 1):
values[i % 3][i // 3] = 'O'
print('+------------------------+')
print('|' + '.'.join(values[0]) + '.|D|)')
print('|' + '.'.join(values[1]) + '.|.|')
print('|' + ('O' if k > 2 else '#') + '.......................|')
print('|' + '.'.join(values[2]) + '.|.|)')
print('+------------------------+')
``` | instruction | 0 | 73,688 | 17 | 147,376 |
No | output | 1 | 73,688 | 17 | 147,377 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The final round of Bayan Programming Contest will be held in Tehran, and the participants will be carried around with a yellow bus. The bus has 34 passenger seats: 4 seats in the last row and 3 seats in remaining rows.
<image>
The event coordinator has a list of k participants who should be picked up at the airport. When a participant gets on the bus, he will sit in the last row with an empty seat. If there is more than one empty seat in that row, he will take the leftmost one.
In order to keep track of the people who are on the bus, the event coordinator needs a figure showing which seats are going to be taken by k participants. Your task is to draw the figure representing occupied seats.
Input
The only line of input contains integer k, (0 ≤ k ≤ 34), denoting the number of participants.
Output
Print the figure of a bus with k passengers as described in sample tests. Character '#' denotes an empty seat, while 'O' denotes a taken seat. 'D' is the bus driver and other characters in the output are for the purpose of beautifying the figure. Strictly follow the sample test cases output format. Print exactly six lines. Do not output extra space or other characters.
Examples
Input
9
Output
+------------------------+
|O.O.O.#.#.#.#.#.#.#.#.|D|)
|O.O.O.#.#.#.#.#.#.#.#.|.|
|O.......................|
|O.O.#.#.#.#.#.#.#.#.#.|.|)
+------------------------+
Input
20
Output
+------------------------+
|O.O.O.O.O.O.O.#.#.#.#.|D|)
|O.O.O.O.O.O.#.#.#.#.#.|.|
|O.......................|
|O.O.O.O.O.O.#.#.#.#.#.|.|)
+------------------------+
Submitted Solution:
```
n=int(input())
a='+'+'-'*24+'+'
print(a)
b='|'
if n>=1:b=b+'0.'
else:b=b+'#.'
for i in range(1,11):
if 3*i+2>n:b+='#.'
else:b+='0.'
b+='|D|)'
print(b)
b='|'
if n>=2:b=b+'0.'
else:b=b+'#.'
for i in range(1,11):
if 3*i+3>n:b+='#.'
else:b+='0.'
b+='|.|'
print(b)
b='|'
if n>=3:b=b+'0.'
else:b=b+'#.'
b=b+'.'*22
b+='|'
print(b)
b='|'
if n>=4:b=b+'0.'
else:b=b+'#.'
for i in range(1,11):
if 3*i+4>n:b+='#.'
else:b+='0.'
b+='|.|)'
print(b)
print(a)
``` | instruction | 0 | 73,689 | 17 | 147,378 |
No | output | 1 | 73,689 | 17 | 147,379 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Anton likes to play chess, and so does his friend Danik.
Once they have played n games in a row. For each game it's known who was the winner — Anton or Danik. None of the games ended with a tie.
Now Anton wonders, who won more games, he or Danik? Help him determine this.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of games played.
The second line contains a string s, consisting of n uppercase English letters 'A' and 'D' — the outcome of each of the games. The i-th character of the string is equal to 'A' if the Anton won the i-th game and 'D' if Danik won the i-th game.
Output
If Anton won more games than Danik, print "Anton" (without quotes) in the only line of the output.
If Danik won more games than Anton, print "Danik" (without quotes) in the only line of the output.
If Anton and Danik won the same number of games, print "Friendship" (without quotes).
Examples
Input
6
ADAAAA
Output
Anton
Input
7
DDDAADA
Output
Danik
Input
6
DADADA
Output
Friendship
Note
In the first sample, Anton won 6 games, while Danik — only 1. Hence, the answer is "Anton".
In the second sample, Anton won 3 games and Danik won 4 games, so the answer is "Danik".
In the third sample, both Anton and Danik won 3 games and the answer is "Friendship". | instruction | 0 | 73,792 | 17 | 147,584 |
Tags: implementation, strings
Correct Solution:
```
input()
d = {'A':0, 'D':0}
for c in input():
d[c] += 1
if d['A'] > d['D']:
print('Anton')
elif d['A'] < d['D']:
print('Danik')
else:
print('Friendship')
``` | output | 1 | 73,792 | 17 | 147,585 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Anton likes to play chess, and so does his friend Danik.
Once they have played n games in a row. For each game it's known who was the winner — Anton or Danik. None of the games ended with a tie.
Now Anton wonders, who won more games, he or Danik? Help him determine this.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of games played.
The second line contains a string s, consisting of n uppercase English letters 'A' and 'D' — the outcome of each of the games. The i-th character of the string is equal to 'A' if the Anton won the i-th game and 'D' if Danik won the i-th game.
Output
If Anton won more games than Danik, print "Anton" (without quotes) in the only line of the output.
If Danik won more games than Anton, print "Danik" (without quotes) in the only line of the output.
If Anton and Danik won the same number of games, print "Friendship" (without quotes).
Examples
Input
6
ADAAAA
Output
Anton
Input
7
DDDAADA
Output
Danik
Input
6
DADADA
Output
Friendship
Note
In the first sample, Anton won 6 games, while Danik — only 1. Hence, the answer is "Anton".
In the second sample, Anton won 3 games and Danik won 4 games, so the answer is "Danik".
In the third sample, both Anton and Danik won 3 games and the answer is "Friendship". | instruction | 0 | 73,793 | 17 | 147,586 |
Tags: implementation, strings
Correct Solution:
```
a=int(input())
b=str(input())
c=b.count('A')
d=b.count('D')
if c>d:
print('Anton')
elif c==d:
print('Friendship')
else:
print('Danik')
``` | output | 1 | 73,793 | 17 | 147,587 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Anton likes to play chess, and so does his friend Danik.
Once they have played n games in a row. For each game it's known who was the winner — Anton or Danik. None of the games ended with a tie.
Now Anton wonders, who won more games, he or Danik? Help him determine this.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of games played.
The second line contains a string s, consisting of n uppercase English letters 'A' and 'D' — the outcome of each of the games. The i-th character of the string is equal to 'A' if the Anton won the i-th game and 'D' if Danik won the i-th game.
Output
If Anton won more games than Danik, print "Anton" (without quotes) in the only line of the output.
If Danik won more games than Anton, print "Danik" (without quotes) in the only line of the output.
If Anton and Danik won the same number of games, print "Friendship" (without quotes).
Examples
Input
6
ADAAAA
Output
Anton
Input
7
DDDAADA
Output
Danik
Input
6
DADADA
Output
Friendship
Note
In the first sample, Anton won 6 games, while Danik — only 1. Hence, the answer is "Anton".
In the second sample, Anton won 3 games and Danik won 4 games, so the answer is "Danik".
In the third sample, both Anton and Danik won 3 games and the answer is "Friendship". | instruction | 0 | 73,794 | 17 | 147,588 |
Tags: implementation, strings
Correct Solution:
```
n=int(input())
s=input()
l=len(s)
a=s.count('A')
d=l-a
if(a>d):
print("Anton")
elif(a<d):
print("Danik")
else:
print("Friendship")
``` | output | 1 | 73,794 | 17 | 147,589 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Anton likes to play chess, and so does his friend Danik.
Once they have played n games in a row. For each game it's known who was the winner — Anton or Danik. None of the games ended with a tie.
Now Anton wonders, who won more games, he or Danik? Help him determine this.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of games played.
The second line contains a string s, consisting of n uppercase English letters 'A' and 'D' — the outcome of each of the games. The i-th character of the string is equal to 'A' if the Anton won the i-th game and 'D' if Danik won the i-th game.
Output
If Anton won more games than Danik, print "Anton" (without quotes) in the only line of the output.
If Danik won more games than Anton, print "Danik" (without quotes) in the only line of the output.
If Anton and Danik won the same number of games, print "Friendship" (without quotes).
Examples
Input
6
ADAAAA
Output
Anton
Input
7
DDDAADA
Output
Danik
Input
6
DADADA
Output
Friendship
Note
In the first sample, Anton won 6 games, while Danik — only 1. Hence, the answer is "Anton".
In the second sample, Anton won 3 games and Danik won 4 games, so the answer is "Danik".
In the third sample, both Anton and Danik won 3 games and the answer is "Friendship". | instruction | 0 | 73,795 | 17 | 147,590 |
Tags: implementation, strings
Correct Solution:
```
a = int(input())
b = list(input())
c = 0
d = 0
for i in range(a):
if b[i] == 'A':
c += 1
if b[i] == 'D':
d += 1
if d > c:
print("Danik")
elif d == c:
print("Friendship")
else:
print("Anton")
``` | output | 1 | 73,795 | 17 | 147,591 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Anton likes to play chess, and so does his friend Danik.
Once they have played n games in a row. For each game it's known who was the winner — Anton or Danik. None of the games ended with a tie.
Now Anton wonders, who won more games, he or Danik? Help him determine this.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of games played.
The second line contains a string s, consisting of n uppercase English letters 'A' and 'D' — the outcome of each of the games. The i-th character of the string is equal to 'A' if the Anton won the i-th game and 'D' if Danik won the i-th game.
Output
If Anton won more games than Danik, print "Anton" (without quotes) in the only line of the output.
If Danik won more games than Anton, print "Danik" (without quotes) in the only line of the output.
If Anton and Danik won the same number of games, print "Friendship" (without quotes).
Examples
Input
6
ADAAAA
Output
Anton
Input
7
DDDAADA
Output
Danik
Input
6
DADADA
Output
Friendship
Note
In the first sample, Anton won 6 games, while Danik — only 1. Hence, the answer is "Anton".
In the second sample, Anton won 3 games and Danik won 4 games, so the answer is "Danik".
In the third sample, both Anton and Danik won 3 games and the answer is "Friendship". | instruction | 0 | 73,796 | 17 | 147,592 |
Tags: implementation, strings
Correct Solution:
```
n = int(input())
a = input()
anton_wins, danik_wins = 0, 0
for i in range(n):
if a[i] == 'A':
anton_wins += 1
else:
danik_wins += 1
if anton_wins == danik_wins:
print('Friendship')
elif anton_wins > danik_wins:
print('Anton')
else:
print('Danik')
``` | output | 1 | 73,796 | 17 | 147,593 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.