message stringlengths 2 28.7k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 21 109k | cluster float64 7 7 | __index_level_0__ int64 42 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
Panic is rising in the committee for doggo standardization — the puppies of the new brood have been born multi-colored! In total there are 26 possible colors of puppies in the nature and they are denoted by letters from 'a' to 'z' inclusive.
The committee rules strictly prohibit even the smallest diversity between doggos and hence all the puppies should be of the same color. Thus Slava, the committee employee, has been assigned the task to recolor some puppies into other colors in order to eliminate the difference and make all the puppies have one common color.
Unfortunately, due to bureaucratic reasons and restricted budget, there's only one operation Slava can perform: he can choose a color x such that there are currently at least two puppies of color x and recolor all puppies of the color x into some arbitrary color y. Luckily, this operation can be applied multiple times (including zero).
For example, if the number of puppies is 7 and their colors are represented as the string "abababc", then in one operation Slava can get the results "zbzbzbc", "bbbbbbc", "aaaaaac", "acacacc" and others. However, if the current color sequence is "abababc", then he can't choose x='c' right now, because currently only one puppy has the color 'c'.
Help Slava and the committee determine whether it is possible to standardize all the puppies, i.e. after Slava's operations all the puppies should have the same color.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^5) — the number of puppies.
The second line contains a string s of length n consisting of lowercase Latin letters, where the i-th symbol denotes the i-th puppy's color.
Output
If it's possible to recolor all puppies into one color, print "Yes".
Otherwise print "No".
Output the answer without quotation signs.
Examples
Input
6
aabddc
Output
Yes
Input
3
abc
Output
No
Input
3
jjj
Output
Yes
Note
In the first example Slava can perform the following steps:
1. take all puppies of color 'a' (a total of two) and recolor them into 'b';
2. take all puppies of color 'd' (a total of two) and recolor them into 'c';
3. take all puppies of color 'b' (three puppies for now) and recolor them into 'c'.
In the second example it's impossible to recolor any of the puppies.
In the third example all the puppies' colors are the same; thus there's no need to recolor anything. | instruction | 0 | 92,620 | 7 | 185,240 |
Tags: implementation, sortings
Correct Solution:
```
T=int(input())
text=input()
L=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
for i in range(T):
L[ord(text[i])-ord('a')]+=1
check=True
for item in L:
if item>=2:
check=False
break
if T==1:
print('Yes')
elif check:
print('No')
else:
print('Yes')
``` | output | 1 | 92,620 | 7 | 185,241 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Panic is rising in the committee for doggo standardization — the puppies of the new brood have been born multi-colored! In total there are 26 possible colors of puppies in the nature and they are denoted by letters from 'a' to 'z' inclusive.
The committee rules strictly prohibit even the smallest diversity between doggos and hence all the puppies should be of the same color. Thus Slava, the committee employee, has been assigned the task to recolor some puppies into other colors in order to eliminate the difference and make all the puppies have one common color.
Unfortunately, due to bureaucratic reasons and restricted budget, there's only one operation Slava can perform: he can choose a color x such that there are currently at least two puppies of color x and recolor all puppies of the color x into some arbitrary color y. Luckily, this operation can be applied multiple times (including zero).
For example, if the number of puppies is 7 and their colors are represented as the string "abababc", then in one operation Slava can get the results "zbzbzbc", "bbbbbbc", "aaaaaac", "acacacc" and others. However, if the current color sequence is "abababc", then he can't choose x='c' right now, because currently only one puppy has the color 'c'.
Help Slava and the committee determine whether it is possible to standardize all the puppies, i.e. after Slava's operations all the puppies should have the same color.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^5) — the number of puppies.
The second line contains a string s of length n consisting of lowercase Latin letters, where the i-th symbol denotes the i-th puppy's color.
Output
If it's possible to recolor all puppies into one color, print "Yes".
Otherwise print "No".
Output the answer without quotation signs.
Examples
Input
6
aabddc
Output
Yes
Input
3
abc
Output
No
Input
3
jjj
Output
Yes
Note
In the first example Slava can perform the following steps:
1. take all puppies of color 'a' (a total of two) and recolor them into 'b';
2. take all puppies of color 'd' (a total of two) and recolor them into 'c';
3. take all puppies of color 'b' (three puppies for now) and recolor them into 'c'.
In the second example it's impossible to recolor any of the puppies.
In the third example all the puppies' colors are the same; thus there's no need to recolor anything.
Submitted Solution:
```
n = int(input())
s = input()
if len(s) == 1:
print("Yes")
exit()
m = {}
for i in s:
if i in m:
print("Yes")
exit()
else:
m[i] = 1
print("No")
``` | instruction | 0 | 92,621 | 7 | 185,242 |
Yes | output | 1 | 92,621 | 7 | 185,243 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Panic is rising in the committee for doggo standardization — the puppies of the new brood have been born multi-colored! In total there are 26 possible colors of puppies in the nature and they are denoted by letters from 'a' to 'z' inclusive.
The committee rules strictly prohibit even the smallest diversity between doggos and hence all the puppies should be of the same color. Thus Slava, the committee employee, has been assigned the task to recolor some puppies into other colors in order to eliminate the difference and make all the puppies have one common color.
Unfortunately, due to bureaucratic reasons and restricted budget, there's only one operation Slava can perform: he can choose a color x such that there are currently at least two puppies of color x and recolor all puppies of the color x into some arbitrary color y. Luckily, this operation can be applied multiple times (including zero).
For example, if the number of puppies is 7 and their colors are represented as the string "abababc", then in one operation Slava can get the results "zbzbzbc", "bbbbbbc", "aaaaaac", "acacacc" and others. However, if the current color sequence is "abababc", then he can't choose x='c' right now, because currently only one puppy has the color 'c'.
Help Slava and the committee determine whether it is possible to standardize all the puppies, i.e. after Slava's operations all the puppies should have the same color.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^5) — the number of puppies.
The second line contains a string s of length n consisting of lowercase Latin letters, where the i-th symbol denotes the i-th puppy's color.
Output
If it's possible to recolor all puppies into one color, print "Yes".
Otherwise print "No".
Output the answer without quotation signs.
Examples
Input
6
aabddc
Output
Yes
Input
3
abc
Output
No
Input
3
jjj
Output
Yes
Note
In the first example Slava can perform the following steps:
1. take all puppies of color 'a' (a total of two) and recolor them into 'b';
2. take all puppies of color 'd' (a total of two) and recolor them into 'c';
3. take all puppies of color 'b' (three puppies for now) and recolor them into 'c'.
In the second example it's impossible to recolor any of the puppies.
In the third example all the puppies' colors are the same; thus there's no need to recolor anything.
Submitted Solution:
```
#codeforces_1025A_live
gi = lambda: list(map(int,input().split()))
n = gi()[0]
s = input()
if n > 26 or n==1:
print("Yes")
exit();
if len(set(list(s))) == n:
print("No")
else:
print("Yes")
``` | instruction | 0 | 92,622 | 7 | 185,244 |
Yes | output | 1 | 92,622 | 7 | 185,245 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Panic is rising in the committee for doggo standardization — the puppies of the new brood have been born multi-colored! In total there are 26 possible colors of puppies in the nature and they are denoted by letters from 'a' to 'z' inclusive.
The committee rules strictly prohibit even the smallest diversity between doggos and hence all the puppies should be of the same color. Thus Slava, the committee employee, has been assigned the task to recolor some puppies into other colors in order to eliminate the difference and make all the puppies have one common color.
Unfortunately, due to bureaucratic reasons and restricted budget, there's only one operation Slava can perform: he can choose a color x such that there are currently at least two puppies of color x and recolor all puppies of the color x into some arbitrary color y. Luckily, this operation can be applied multiple times (including zero).
For example, if the number of puppies is 7 and their colors are represented as the string "abababc", then in one operation Slava can get the results "zbzbzbc", "bbbbbbc", "aaaaaac", "acacacc" and others. However, if the current color sequence is "abababc", then he can't choose x='c' right now, because currently only one puppy has the color 'c'.
Help Slava and the committee determine whether it is possible to standardize all the puppies, i.e. after Slava's operations all the puppies should have the same color.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^5) — the number of puppies.
The second line contains a string s of length n consisting of lowercase Latin letters, where the i-th symbol denotes the i-th puppy's color.
Output
If it's possible to recolor all puppies into one color, print "Yes".
Otherwise print "No".
Output the answer without quotation signs.
Examples
Input
6
aabddc
Output
Yes
Input
3
abc
Output
No
Input
3
jjj
Output
Yes
Note
In the first example Slava can perform the following steps:
1. take all puppies of color 'a' (a total of two) and recolor them into 'b';
2. take all puppies of color 'd' (a total of two) and recolor them into 'c';
3. take all puppies of color 'b' (three puppies for now) and recolor them into 'c'.
In the second example it's impossible to recolor any of the puppies.
In the third example all the puppies' colors are the same; thus there's no need to recolor anything.
Submitted Solution:
```
n = int(input())
s = list(input())
g = set(s)
print("Yes" if len(g) != n or n == 1 else "No")
``` | instruction | 0 | 92,623 | 7 | 185,246 |
Yes | output | 1 | 92,623 | 7 | 185,247 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Panic is rising in the committee for doggo standardization — the puppies of the new brood have been born multi-colored! In total there are 26 possible colors of puppies in the nature and they are denoted by letters from 'a' to 'z' inclusive.
The committee rules strictly prohibit even the smallest diversity between doggos and hence all the puppies should be of the same color. Thus Slava, the committee employee, has been assigned the task to recolor some puppies into other colors in order to eliminate the difference and make all the puppies have one common color.
Unfortunately, due to bureaucratic reasons and restricted budget, there's only one operation Slava can perform: he can choose a color x such that there are currently at least two puppies of color x and recolor all puppies of the color x into some arbitrary color y. Luckily, this operation can be applied multiple times (including zero).
For example, if the number of puppies is 7 and their colors are represented as the string "abababc", then in one operation Slava can get the results "zbzbzbc", "bbbbbbc", "aaaaaac", "acacacc" and others. However, if the current color sequence is "abababc", then he can't choose x='c' right now, because currently only one puppy has the color 'c'.
Help Slava and the committee determine whether it is possible to standardize all the puppies, i.e. after Slava's operations all the puppies should have the same color.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^5) — the number of puppies.
The second line contains a string s of length n consisting of lowercase Latin letters, where the i-th symbol denotes the i-th puppy's color.
Output
If it's possible to recolor all puppies into one color, print "Yes".
Otherwise print "No".
Output the answer without quotation signs.
Examples
Input
6
aabddc
Output
Yes
Input
3
abc
Output
No
Input
3
jjj
Output
Yes
Note
In the first example Slava can perform the following steps:
1. take all puppies of color 'a' (a total of two) and recolor them into 'b';
2. take all puppies of color 'd' (a total of two) and recolor them into 'c';
3. take all puppies of color 'b' (three puppies for now) and recolor them into 'c'.
In the second example it's impossible to recolor any of the puppies.
In the third example all the puppies' colors are the same; thus there's no need to recolor anything.
Submitted Solution:
```
n = int(input())
s = input()
a = 0
if len(s) == 1:
print('Yes')
else:
boolean = False
for i in set(s):
if s.count(i) != 1:
boolean = True
break
if boolean:
print('Yes')
else:
print('No')
``` | instruction | 0 | 92,624 | 7 | 185,248 |
Yes | output | 1 | 92,624 | 7 | 185,249 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Panic is rising in the committee for doggo standardization — the puppies of the new brood have been born multi-colored! In total there are 26 possible colors of puppies in the nature and they are denoted by letters from 'a' to 'z' inclusive.
The committee rules strictly prohibit even the smallest diversity between doggos and hence all the puppies should be of the same color. Thus Slava, the committee employee, has been assigned the task to recolor some puppies into other colors in order to eliminate the difference and make all the puppies have one common color.
Unfortunately, due to bureaucratic reasons and restricted budget, there's only one operation Slava can perform: he can choose a color x such that there are currently at least two puppies of color x and recolor all puppies of the color x into some arbitrary color y. Luckily, this operation can be applied multiple times (including zero).
For example, if the number of puppies is 7 and their colors are represented as the string "abababc", then in one operation Slava can get the results "zbzbzbc", "bbbbbbc", "aaaaaac", "acacacc" and others. However, if the current color sequence is "abababc", then he can't choose x='c' right now, because currently only one puppy has the color 'c'.
Help Slava and the committee determine whether it is possible to standardize all the puppies, i.e. after Slava's operations all the puppies should have the same color.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^5) — the number of puppies.
The second line contains a string s of length n consisting of lowercase Latin letters, where the i-th symbol denotes the i-th puppy's color.
Output
If it's possible to recolor all puppies into one color, print "Yes".
Otherwise print "No".
Output the answer without quotation signs.
Examples
Input
6
aabddc
Output
Yes
Input
3
abc
Output
No
Input
3
jjj
Output
Yes
Note
In the first example Slava can perform the following steps:
1. take all puppies of color 'a' (a total of two) and recolor them into 'b';
2. take all puppies of color 'd' (a total of two) and recolor them into 'c';
3. take all puppies of color 'b' (three puppies for now) and recolor them into 'c'.
In the second example it's impossible to recolor any of the puppies.
In the third example all the puppies' colors are the same; thus there's no need to recolor anything.
Submitted Solution:
```
x=int(input())
str=input()
t=0
d={ i : [0] for i in "abcdefhijklmnopqrstuvwxyz"}
for i in d :
#print(i)
d[i]=str.count(i)
if d[i]>1 :
t=1
break
if (1==t) :
print("YES")
else :
print("NO")
``` | instruction | 0 | 92,625 | 7 | 185,250 |
No | output | 1 | 92,625 | 7 | 185,251 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Panic is rising in the committee for doggo standardization — the puppies of the new brood have been born multi-colored! In total there are 26 possible colors of puppies in the nature and they are denoted by letters from 'a' to 'z' inclusive.
The committee rules strictly prohibit even the smallest diversity between doggos and hence all the puppies should be of the same color. Thus Slava, the committee employee, has been assigned the task to recolor some puppies into other colors in order to eliminate the difference and make all the puppies have one common color.
Unfortunately, due to bureaucratic reasons and restricted budget, there's only one operation Slava can perform: he can choose a color x such that there are currently at least two puppies of color x and recolor all puppies of the color x into some arbitrary color y. Luckily, this operation can be applied multiple times (including zero).
For example, if the number of puppies is 7 and their colors are represented as the string "abababc", then in one operation Slava can get the results "zbzbzbc", "bbbbbbc", "aaaaaac", "acacacc" and others. However, if the current color sequence is "abababc", then he can't choose x='c' right now, because currently only one puppy has the color 'c'.
Help Slava and the committee determine whether it is possible to standardize all the puppies, i.e. after Slava's operations all the puppies should have the same color.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^5) — the number of puppies.
The second line contains a string s of length n consisting of lowercase Latin letters, where the i-th symbol denotes the i-th puppy's color.
Output
If it's possible to recolor all puppies into one color, print "Yes".
Otherwise print "No".
Output the answer without quotation signs.
Examples
Input
6
aabddc
Output
Yes
Input
3
abc
Output
No
Input
3
jjj
Output
Yes
Note
In the first example Slava can perform the following steps:
1. take all puppies of color 'a' (a total of two) and recolor them into 'b';
2. take all puppies of color 'd' (a total of two) and recolor them into 'c';
3. take all puppies of color 'b' (three puppies for now) and recolor them into 'c'.
In the second example it's impossible to recolor any of the puppies.
In the third example all the puppies' colors are the same; thus there's no need to recolor anything.
Submitted Solution:
```
if __name__ == "__main__":
num_of_puppies = int(input().strip())
colors = input().strip().lower()
puppies = [0] * 26 # 26 : is the English letters.
for i in colors:
puppies[ord(i) - ord('a')] += 1
standard = False
for i in puppies:
if i >= 2:
standard = True
break
if standard:
print("YES")
else:
print("NO")
``` | instruction | 0 | 92,626 | 7 | 185,252 |
No | output | 1 | 92,626 | 7 | 185,253 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Panic is rising in the committee for doggo standardization — the puppies of the new brood have been born multi-colored! In total there are 26 possible colors of puppies in the nature and they are denoted by letters from 'a' to 'z' inclusive.
The committee rules strictly prohibit even the smallest diversity between doggos and hence all the puppies should be of the same color. Thus Slava, the committee employee, has been assigned the task to recolor some puppies into other colors in order to eliminate the difference and make all the puppies have one common color.
Unfortunately, due to bureaucratic reasons and restricted budget, there's only one operation Slava can perform: he can choose a color x such that there are currently at least two puppies of color x and recolor all puppies of the color x into some arbitrary color y. Luckily, this operation can be applied multiple times (including zero).
For example, if the number of puppies is 7 and their colors are represented as the string "abababc", then in one operation Slava can get the results "zbzbzbc", "bbbbbbc", "aaaaaac", "acacacc" and others. However, if the current color sequence is "abababc", then he can't choose x='c' right now, because currently only one puppy has the color 'c'.
Help Slava and the committee determine whether it is possible to standardize all the puppies, i.e. after Slava's operations all the puppies should have the same color.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^5) — the number of puppies.
The second line contains a string s of length n consisting of lowercase Latin letters, where the i-th symbol denotes the i-th puppy's color.
Output
If it's possible to recolor all puppies into one color, print "Yes".
Otherwise print "No".
Output the answer without quotation signs.
Examples
Input
6
aabddc
Output
Yes
Input
3
abc
Output
No
Input
3
jjj
Output
Yes
Note
In the first example Slava can perform the following steps:
1. take all puppies of color 'a' (a total of two) and recolor them into 'b';
2. take all puppies of color 'd' (a total of two) and recolor them into 'c';
3. take all puppies of color 'b' (three puppies for now) and recolor them into 'c'.
In the second example it's impossible to recolor any of the puppies.
In the third example all the puppies' colors are the same; thus there's no need to recolor anything.
Submitted Solution:
```
def find_pair(string, len_string):
for index in range(0, len_string - 1):
char = string[index]
for chars in string[index + 1:]:
if char == chars:
return "Yes"
return "No"
numberPuppies = int(input())
string = input()
print(find_pair(string, numberPuppies))
``` | instruction | 0 | 92,627 | 7 | 185,254 |
No | output | 1 | 92,627 | 7 | 185,255 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Panic is rising in the committee for doggo standardization — the puppies of the new brood have been born multi-colored! In total there are 26 possible colors of puppies in the nature and they are denoted by letters from 'a' to 'z' inclusive.
The committee rules strictly prohibit even the smallest diversity between doggos and hence all the puppies should be of the same color. Thus Slava, the committee employee, has been assigned the task to recolor some puppies into other colors in order to eliminate the difference and make all the puppies have one common color.
Unfortunately, due to bureaucratic reasons and restricted budget, there's only one operation Slava can perform: he can choose a color x such that there are currently at least two puppies of color x and recolor all puppies of the color x into some arbitrary color y. Luckily, this operation can be applied multiple times (including zero).
For example, if the number of puppies is 7 and their colors are represented as the string "abababc", then in one operation Slava can get the results "zbzbzbc", "bbbbbbc", "aaaaaac", "acacacc" and others. However, if the current color sequence is "abababc", then he can't choose x='c' right now, because currently only one puppy has the color 'c'.
Help Slava and the committee determine whether it is possible to standardize all the puppies, i.e. after Slava's operations all the puppies should have the same color.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^5) — the number of puppies.
The second line contains a string s of length n consisting of lowercase Latin letters, where the i-th symbol denotes the i-th puppy's color.
Output
If it's possible to recolor all puppies into one color, print "Yes".
Otherwise print "No".
Output the answer without quotation signs.
Examples
Input
6
aabddc
Output
Yes
Input
3
abc
Output
No
Input
3
jjj
Output
Yes
Note
In the first example Slava can perform the following steps:
1. take all puppies of color 'a' (a total of two) and recolor them into 'b';
2. take all puppies of color 'd' (a total of two) and recolor them into 'c';
3. take all puppies of color 'b' (three puppies for now) and recolor them into 'c'.
In the second example it's impossible to recolor any of the puppies.
In the third example all the puppies' colors are the same; thus there's no need to recolor anything.
Submitted Solution:
```
import collections
n = int(input())
s = input()
d = collections.Counter()
for i in s:
d[i]+=1
if (max(d.values()) >= 2):
print ("YES")
else:
print ("NO")
``` | instruction | 0 | 92,628 | 7 | 185,256 |
No | output | 1 | 92,628 | 7 | 185,257 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ivan is a novice painter. He has n dyes of different colors. He also knows exactly m pairs of colors which harmonize with each other.
Ivan also enjoy playing chess. He has 5000 rooks. He wants to take k rooks, paint each of them in one of n colors and then place this k rooks on a chessboard of size 10^{9} × 10^{9}.
Let's call the set of rooks on the board connected if from any rook we can get to any other rook in this set moving only through cells with rooks from this set. Assume that rooks can jump over other rooks, in other words a rook can go to any cell which shares vertical and to any cell which shares horizontal.
Ivan wants his arrangement of rooks to have following properties:
* For any color there is a rook of this color on a board;
* For any color the set of rooks of this color is connected;
* For any two different colors a b union of set of rooks of color a and set of rooks of color b is connected if and only if this two colors harmonize with each other.
Please help Ivan find such an arrangement.
Input
The first line of input contains 2 integers n, m (1 ≤ n ≤ 100, 0 ≤ m ≤ min(1000, (n(n-1))/(2))) — number of colors and number of pairs of colors which harmonize with each other.
In next m lines pairs of colors which harmonize with each other are listed. Colors are numbered from 1 to n. It is guaranteed that no pair occurs twice in this list.
Output
Print n blocks, i-th of them describes rooks of i-th color.
In the first line of block print one number a_{i} (1 ≤ a_{i} ≤ 5000) — number of rooks of color i. In each of next a_{i} lines print two integers x and y (1 ≤ x, y ≤ 10^{9}) — coordinates of the next rook.
All rooks must be on different cells.
Total number of rooks must not exceed 5000.
It is guaranteed that the solution exists.
Examples
Input
3 2
1 2
2 3
Output
2
3 4
1 4
4
1 2
2 2
2 4
5 4
1
5 1
Input
3 3
1 2
2 3
3 1
Output
1
1 1
1
1 2
1
1 3
Input
3 1
1 3
Output
1
1 1
1
2 2
1
3 1
Note
Rooks arrangements for all three examples (red is color 1, green is color 2 and blue is color 3).
<image>
<image>
<image> | instruction | 0 | 92,629 | 7 | 185,258 |
Tags: constructive algorithms, graphs
Correct Solution:
```
n,m=map(int,input().split())
arr=[]
for i in range(m):
x,y=map(int,input().split())
arr.append([x,y])
dict1={}
k=1
for i in range(m):
a=arr[i][0]
b=arr[i][1]
try:
dict1[a].append((k,a))
except:
dict1[a]=[(k,a)]
try:
dict1[b].append((k,b))
except:
KeyError
dict1[b]=[(k,b)]
k+=1
#print(dict1)
for i in range(1,n+1):
try:
z=len(dict1[i])
except:
KeyError
dict1[i]=[(k,i)]
k+=1
for i in range(1,n+1):
print(len(dict1[i]))
for j in dict1[i]:
print(j[0],j[1])
``` | output | 1 | 92,629 | 7 | 185,259 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ivan is a novice painter. He has n dyes of different colors. He also knows exactly m pairs of colors which harmonize with each other.
Ivan also enjoy playing chess. He has 5000 rooks. He wants to take k rooks, paint each of them in one of n colors and then place this k rooks on a chessboard of size 10^{9} × 10^{9}.
Let's call the set of rooks on the board connected if from any rook we can get to any other rook in this set moving only through cells with rooks from this set. Assume that rooks can jump over other rooks, in other words a rook can go to any cell which shares vertical and to any cell which shares horizontal.
Ivan wants his arrangement of rooks to have following properties:
* For any color there is a rook of this color on a board;
* For any color the set of rooks of this color is connected;
* For any two different colors a b union of set of rooks of color a and set of rooks of color b is connected if and only if this two colors harmonize with each other.
Please help Ivan find such an arrangement.
Input
The first line of input contains 2 integers n, m (1 ≤ n ≤ 100, 0 ≤ m ≤ min(1000, (n(n-1))/(2))) — number of colors and number of pairs of colors which harmonize with each other.
In next m lines pairs of colors which harmonize with each other are listed. Colors are numbered from 1 to n. It is guaranteed that no pair occurs twice in this list.
Output
Print n blocks, i-th of them describes rooks of i-th color.
In the first line of block print one number a_{i} (1 ≤ a_{i} ≤ 5000) — number of rooks of color i. In each of next a_{i} lines print two integers x and y (1 ≤ x, y ≤ 10^{9}) — coordinates of the next rook.
All rooks must be on different cells.
Total number of rooks must not exceed 5000.
It is guaranteed that the solution exists.
Examples
Input
3 2
1 2
2 3
Output
2
3 4
1 4
4
1 2
2 2
2 4
5 4
1
5 1
Input
3 3
1 2
2 3
3 1
Output
1
1 1
1
1 2
1
1 3
Input
3 1
1 3
Output
1
1 1
1
2 2
1
3 1
Note
Rooks arrangements for all three examples (red is color 1, green is color 2 and blue is color 3).
<image>
<image>
<image> | instruction | 0 | 92,630 | 7 | 185,260 |
Tags: constructive algorithms, graphs
Correct Solution:
```
if __name__ == '__main__':
n, m = map(int, input().split())
edges = [[] for _ in range(n)]
for edge_id, i in enumerate(range(m)):
a, b = map(int, input().split())
edges[a-1].append((b-1, edge_id))
edges[b-1].append((a-1, edge_id))
cnt = 0
ans = [[] for _ in range(n)]
for i in range(n):
for j, (node, edge_id) in enumerate(edges[i]):
cnt += 1
ans[i].append((cnt, i + 1))
ans[i].append((cnt, n + 1 + edge_id))
if len(edges[i]) == 0:
cnt += 1
ans[i].append((cnt, i + 1))
print('\n'.join('%d\n' % len(color) + '\n'.join('%d %d' % (x, y) for (x, y) in color) for color in ans))
``` | output | 1 | 92,630 | 7 | 185,261 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ivan is a novice painter. He has n dyes of different colors. He also knows exactly m pairs of colors which harmonize with each other.
Ivan also enjoy playing chess. He has 5000 rooks. He wants to take k rooks, paint each of them in one of n colors and then place this k rooks on a chessboard of size 10^{9} × 10^{9}.
Let's call the set of rooks on the board connected if from any rook we can get to any other rook in this set moving only through cells with rooks from this set. Assume that rooks can jump over other rooks, in other words a rook can go to any cell which shares vertical and to any cell which shares horizontal.
Ivan wants his arrangement of rooks to have following properties:
* For any color there is a rook of this color on a board;
* For any color the set of rooks of this color is connected;
* For any two different colors a b union of set of rooks of color a and set of rooks of color b is connected if and only if this two colors harmonize with each other.
Please help Ivan find such an arrangement.
Input
The first line of input contains 2 integers n, m (1 ≤ n ≤ 100, 0 ≤ m ≤ min(1000, (n(n-1))/(2))) — number of colors and number of pairs of colors which harmonize with each other.
In next m lines pairs of colors which harmonize with each other are listed. Colors are numbered from 1 to n. It is guaranteed that no pair occurs twice in this list.
Output
Print n blocks, i-th of them describes rooks of i-th color.
In the first line of block print one number a_{i} (1 ≤ a_{i} ≤ 5000) — number of rooks of color i. In each of next a_{i} lines print two integers x and y (1 ≤ x, y ≤ 10^{9}) — coordinates of the next rook.
All rooks must be on different cells.
Total number of rooks must not exceed 5000.
It is guaranteed that the solution exists.
Examples
Input
3 2
1 2
2 3
Output
2
3 4
1 4
4
1 2
2 2
2 4
5 4
1
5 1
Input
3 3
1 2
2 3
3 1
Output
1
1 1
1
1 2
1
1 3
Input
3 1
1 3
Output
1
1 1
1
2 2
1
3 1
Note
Rooks arrangements for all three examples (red is color 1, green is color 2 and blue is color 3).
<image>
<image>
<image> | instruction | 0 | 92,631 | 7 | 185,262 |
Tags: constructive algorithms, graphs
Correct Solution:
```
n,m = map(int, input().split())
d = {}
for i in range(1,n+1):
d[i] = set()
for i in range(m):
x,y = map(int, input().split())
d[x].add(x*n+y)
d[y].add(x*n+y)
for i in range(1,n+1):
print(len(d[i])+1)
print(i,i)
for k in d[i]:
print(i,k)
``` | output | 1 | 92,631 | 7 | 185,263 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ivan is a novice painter. He has n dyes of different colors. He also knows exactly m pairs of colors which harmonize with each other.
Ivan also enjoy playing chess. He has 5000 rooks. He wants to take k rooks, paint each of them in one of n colors and then place this k rooks on a chessboard of size 10^{9} × 10^{9}.
Let's call the set of rooks on the board connected if from any rook we can get to any other rook in this set moving only through cells with rooks from this set. Assume that rooks can jump over other rooks, in other words a rook can go to any cell which shares vertical and to any cell which shares horizontal.
Ivan wants his arrangement of rooks to have following properties:
* For any color there is a rook of this color on a board;
* For any color the set of rooks of this color is connected;
* For any two different colors a b union of set of rooks of color a and set of rooks of color b is connected if and only if this two colors harmonize with each other.
Please help Ivan find such an arrangement.
Input
The first line of input contains 2 integers n, m (1 ≤ n ≤ 100, 0 ≤ m ≤ min(1000, (n(n-1))/(2))) — number of colors and number of pairs of colors which harmonize with each other.
In next m lines pairs of colors which harmonize with each other are listed. Colors are numbered from 1 to n. It is guaranteed that no pair occurs twice in this list.
Output
Print n blocks, i-th of them describes rooks of i-th color.
In the first line of block print one number a_{i} (1 ≤ a_{i} ≤ 5000) — number of rooks of color i. In each of next a_{i} lines print two integers x and y (1 ≤ x, y ≤ 10^{9}) — coordinates of the next rook.
All rooks must be on different cells.
Total number of rooks must not exceed 5000.
It is guaranteed that the solution exists.
Examples
Input
3 2
1 2
2 3
Output
2
3 4
1 4
4
1 2
2 2
2 4
5 4
1
5 1
Input
3 3
1 2
2 3
3 1
Output
1
1 1
1
1 2
1
1 3
Input
3 1
1 3
Output
1
1 1
1
2 2
1
3 1
Note
Rooks arrangements for all three examples (red is color 1, green is color 2 and blue is color 3).
<image>
<image>
<image> | instruction | 0 | 92,632 | 7 | 185,264 |
Tags: constructive algorithms, graphs
Correct Solution:
```
from collections import defaultdict
def compute(n, col_pairs):
pos = defaultdict(list)
for i in range(1, n+1):
pos[i].append((i, i))
for i, (u, v) in enumerate(col_pairs, 1):
pos[u].append((u, n + i))
pos[v].append((v, n + i))
for i in range(1, n+1):
print(len(pos[i]))
for p1, p2 in pos[i]:
print(p1, p2)
def run():
# n = number of colors [1,100]
# m = number of color pairs that harmonize with each other [0, min(1000, n*(n+1)/2)]
n, m = [int(c) for c in input().split()]
col_pairs = []
for _ in range(m):
col1, col2 = [int(c) for c in input().split()]
col_pairs.append((col1, col2))
compute(n, col_pairs)
if __name__ == '__main__':
run()
``` | output | 1 | 92,632 | 7 | 185,265 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ivan is a novice painter. He has n dyes of different colors. He also knows exactly m pairs of colors which harmonize with each other.
Ivan also enjoy playing chess. He has 5000 rooks. He wants to take k rooks, paint each of them in one of n colors and then place this k rooks on a chessboard of size 10^{9} × 10^{9}.
Let's call the set of rooks on the board connected if from any rook we can get to any other rook in this set moving only through cells with rooks from this set. Assume that rooks can jump over other rooks, in other words a rook can go to any cell which shares vertical and to any cell which shares horizontal.
Ivan wants his arrangement of rooks to have following properties:
* For any color there is a rook of this color on a board;
* For any color the set of rooks of this color is connected;
* For any two different colors a b union of set of rooks of color a and set of rooks of color b is connected if and only if this two colors harmonize with each other.
Please help Ivan find such an arrangement.
Input
The first line of input contains 2 integers n, m (1 ≤ n ≤ 100, 0 ≤ m ≤ min(1000, (n(n-1))/(2))) — number of colors and number of pairs of colors which harmonize with each other.
In next m lines pairs of colors which harmonize with each other are listed. Colors are numbered from 1 to n. It is guaranteed that no pair occurs twice in this list.
Output
Print n blocks, i-th of them describes rooks of i-th color.
In the first line of block print one number a_{i} (1 ≤ a_{i} ≤ 5000) — number of rooks of color i. In each of next a_{i} lines print two integers x and y (1 ≤ x, y ≤ 10^{9}) — coordinates of the next rook.
All rooks must be on different cells.
Total number of rooks must not exceed 5000.
It is guaranteed that the solution exists.
Examples
Input
3 2
1 2
2 3
Output
2
3 4
1 4
4
1 2
2 2
2 4
5 4
1
5 1
Input
3 3
1 2
2 3
3 1
Output
1
1 1
1
1 2
1
1 3
Input
3 1
1 3
Output
1
1 1
1
2 2
1
3 1
Note
Rooks arrangements for all three examples (red is color 1, green is color 2 and blue is color 3).
<image>
<image>
<image> | instruction | 0 | 92,633 | 7 | 185,266 |
Tags: constructive algorithms, graphs
Correct Solution:
```
n,m=[int(x) for x in input().split()]
ms=[]
con=[set()for i in range(n)]
loc=[0]*n
for i in range(m):
a,b=[int(x) for x in input().split()]
a-=1
b-=1
con[a].add(b)
con[b].add(a)
ms.append((a,b))
ans=[[]for i in range(n)]
if len(con[0])==0:
con[0].add(n+10)
l=len(con[0])
ans[0]=[i for i in range(l)]
for i in range(1,n):
loc[i]=l
if len(con[i])==0:
con[i].add(n+10)
for s in con[i]:
if s<i:
ans[i].append(loc[s])
loc[s]+=1
else:
ans[i].append(l)
l+=1
for i in range(n):
print(len(ans[i]))
for s in ans[i]:
print(i+1,s+1)
``` | output | 1 | 92,633 | 7 | 185,267 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ivan is a novice painter. He has n dyes of different colors. He also knows exactly m pairs of colors which harmonize with each other.
Ivan also enjoy playing chess. He has 5000 rooks. He wants to take k rooks, paint each of them in one of n colors and then place this k rooks on a chessboard of size 10^{9} × 10^{9}.
Let's call the set of rooks on the board connected if from any rook we can get to any other rook in this set moving only through cells with rooks from this set. Assume that rooks can jump over other rooks, in other words a rook can go to any cell which shares vertical and to any cell which shares horizontal.
Ivan wants his arrangement of rooks to have following properties:
* For any color there is a rook of this color on a board;
* For any color the set of rooks of this color is connected;
* For any two different colors a b union of set of rooks of color a and set of rooks of color b is connected if and only if this two colors harmonize with each other.
Please help Ivan find such an arrangement.
Input
The first line of input contains 2 integers n, m (1 ≤ n ≤ 100, 0 ≤ m ≤ min(1000, (n(n-1))/(2))) — number of colors and number of pairs of colors which harmonize with each other.
In next m lines pairs of colors which harmonize with each other are listed. Colors are numbered from 1 to n. It is guaranteed that no pair occurs twice in this list.
Output
Print n blocks, i-th of them describes rooks of i-th color.
In the first line of block print one number a_{i} (1 ≤ a_{i} ≤ 5000) — number of rooks of color i. In each of next a_{i} lines print two integers x and y (1 ≤ x, y ≤ 10^{9}) — coordinates of the next rook.
All rooks must be on different cells.
Total number of rooks must not exceed 5000.
It is guaranteed that the solution exists.
Examples
Input
3 2
1 2
2 3
Output
2
3 4
1 4
4
1 2
2 2
2 4
5 4
1
5 1
Input
3 3
1 2
2 3
3 1
Output
1
1 1
1
1 2
1
1 3
Input
3 1
1 3
Output
1
1 1
1
2 2
1
3 1
Note
Rooks arrangements for all three examples (red is color 1, green is color 2 and blue is color 3).
<image>
<image>
<image> | instruction | 0 | 92,634 | 7 | 185,268 |
Tags: constructive algorithms, graphs
Correct Solution:
```
# -*- coding:utf-8 -*-
"""
created by shuangquan.huang at 11/3/18
"""
N, M = map(int, input().split())
ans = [(0, 0)] + [[(i+1, i+10000)] for i in range(N)]
y = 9999
for mi in range(M):
u, v = map(int, input().split())
ans[u].append((u, y))
ans[v].append((v, y))
y -= 1
outs = []
for i in range(1, N+1):
outs.append(str(len(ans[i])))
for x, y in ans[i]:
outs.append('{} {}'.format(x, y))
print('\n'.join(outs))
``` | output | 1 | 92,634 | 7 | 185,269 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ivan is a novice painter. He has n dyes of different colors. He also knows exactly m pairs of colors which harmonize with each other.
Ivan also enjoy playing chess. He has 5000 rooks. He wants to take k rooks, paint each of them in one of n colors and then place this k rooks on a chessboard of size 10^{9} × 10^{9}.
Let's call the set of rooks on the board connected if from any rook we can get to any other rook in this set moving only through cells with rooks from this set. Assume that rooks can jump over other rooks, in other words a rook can go to any cell which shares vertical and to any cell which shares horizontal.
Ivan wants his arrangement of rooks to have following properties:
* For any color there is a rook of this color on a board;
* For any color the set of rooks of this color is connected;
* For any two different colors a b union of set of rooks of color a and set of rooks of color b is connected if and only if this two colors harmonize with each other.
Please help Ivan find such an arrangement.
Input
The first line of input contains 2 integers n, m (1 ≤ n ≤ 100, 0 ≤ m ≤ min(1000, (n(n-1))/(2))) — number of colors and number of pairs of colors which harmonize with each other.
In next m lines pairs of colors which harmonize with each other are listed. Colors are numbered from 1 to n. It is guaranteed that no pair occurs twice in this list.
Output
Print n blocks, i-th of them describes rooks of i-th color.
In the first line of block print one number a_{i} (1 ≤ a_{i} ≤ 5000) — number of rooks of color i. In each of next a_{i} lines print two integers x and y (1 ≤ x, y ≤ 10^{9}) — coordinates of the next rook.
All rooks must be on different cells.
Total number of rooks must not exceed 5000.
It is guaranteed that the solution exists.
Examples
Input
3 2
1 2
2 3
Output
2
3 4
1 4
4
1 2
2 2
2 4
5 4
1
5 1
Input
3 3
1 2
2 3
3 1
Output
1
1 1
1
1 2
1
1 3
Input
3 1
1 3
Output
1
1 1
1
2 2
1
3 1
Note
Rooks arrangements for all three examples (red is color 1, green is color 2 and blue is color 3).
<image>
<image>
<image> | instruction | 0 | 92,635 | 7 | 185,270 |
Tags: constructive algorithms, graphs
Correct Solution:
```
# Author: Divesh Uttamchandani
# Institution: BITS Pilani
n,m = list(map(int,input().strip().split()))
graph = [set({}) for i in range(n+1)]
for i in range(m):
a,b = list(map(int,input().strip().split()))
graph[min(a,b)].add((max(a,b)))
points = [(set({})) for i in range(n+1)]
points_start = [-1 for i in range(n+2)]
s=1
for j in range(1, n+1):
i=graph[j]
points_start[j]=s
s+=len(i)+1
points_start[-1]=s
for i in range(1,n+1):
for d in range(points_start[i+1]-points_start[i]):
points[i].add((points_start[i]+d, i))
#print(points)
for coord, edges in enumerate(graph):
if(coord!=0):
for i,edge in enumerate(edges):
#coord, edge is and edge
points[edge].add((points_start[coord]+i, edge))
for coord, p in enumerate(points):
if(coord!=0):
print(len(p))
for j in p:
print(j[0], j[1])
# <> with <3 using Termicoder:
# https://termicoder.github.io
``` | output | 1 | 92,635 | 7 | 185,271 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ivan is a novice painter. He has n dyes of different colors. He also knows exactly m pairs of colors which harmonize with each other.
Ivan also enjoy playing chess. He has 5000 rooks. He wants to take k rooks, paint each of them in one of n colors and then place this k rooks on a chessboard of size 10^{9} × 10^{9}.
Let's call the set of rooks on the board connected if from any rook we can get to any other rook in this set moving only through cells with rooks from this set. Assume that rooks can jump over other rooks, in other words a rook can go to any cell which shares vertical and to any cell which shares horizontal.
Ivan wants his arrangement of rooks to have following properties:
* For any color there is a rook of this color on a board;
* For any color the set of rooks of this color is connected;
* For any two different colors a b union of set of rooks of color a and set of rooks of color b is connected if and only if this two colors harmonize with each other.
Please help Ivan find such an arrangement.
Input
The first line of input contains 2 integers n, m (1 ≤ n ≤ 100, 0 ≤ m ≤ min(1000, (n(n-1))/(2))) — number of colors and number of pairs of colors which harmonize with each other.
In next m lines pairs of colors which harmonize with each other are listed. Colors are numbered from 1 to n. It is guaranteed that no pair occurs twice in this list.
Output
Print n blocks, i-th of them describes rooks of i-th color.
In the first line of block print one number a_{i} (1 ≤ a_{i} ≤ 5000) — number of rooks of color i. In each of next a_{i} lines print two integers x and y (1 ≤ x, y ≤ 10^{9}) — coordinates of the next rook.
All rooks must be on different cells.
Total number of rooks must not exceed 5000.
It is guaranteed that the solution exists.
Examples
Input
3 2
1 2
2 3
Output
2
3 4
1 4
4
1 2
2 2
2 4
5 4
1
5 1
Input
3 3
1 2
2 3
3 1
Output
1
1 1
1
1 2
1
1 3
Input
3 1
1 3
Output
1
1 1
1
2 2
1
3 1
Note
Rooks arrangements for all three examples (red is color 1, green is color 2 and blue is color 3).
<image>
<image>
<image> | instruction | 0 | 92,636 | 7 | 185,272 |
Tags: constructive algorithms, graphs
Correct Solution:
```
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sat Aug 1 12:14:13 2020
@author: shailesh
"""
n,m = [int(i) for i in input().split()]
harmonies = []
for i in range(m):
harmonies.append([int(i) for i in input().split()])
#stage 1: diagonal
rooks_by_colour = [[] for i in range(n+1)]
for i in range(1,n+1):
rooks_by_colour[i].append((i,i))
next_row = n+1
for harmony in harmonies:
colour1,colour2 = harmony
rooks_by_colour[colour1].append((next_row,colour1))
rooks_by_colour[colour2].append((next_row,colour2))
next_row+=1
for i in range(1,n+1):
print(len(rooks_by_colour[i]))
for i in rooks_by_colour[i]:
print(i[0],i[1])
``` | output | 1 | 92,636 | 7 | 185,273 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ivan is a novice painter. He has n dyes of different colors. He also knows exactly m pairs of colors which harmonize with each other.
Ivan also enjoy playing chess. He has 5000 rooks. He wants to take k rooks, paint each of them in one of n colors and then place this k rooks on a chessboard of size 10^{9} × 10^{9}.
Let's call the set of rooks on the board connected if from any rook we can get to any other rook in this set moving only through cells with rooks from this set. Assume that rooks can jump over other rooks, in other words a rook can go to any cell which shares vertical and to any cell which shares horizontal.
Ivan wants his arrangement of rooks to have following properties:
* For any color there is a rook of this color on a board;
* For any color the set of rooks of this color is connected;
* For any two different colors a b union of set of rooks of color a and set of rooks of color b is connected if and only if this two colors harmonize with each other.
Please help Ivan find such an arrangement.
Input
The first line of input contains 2 integers n, m (1 ≤ n ≤ 100, 0 ≤ m ≤ min(1000, (n(n-1))/(2))) — number of colors and number of pairs of colors which harmonize with each other.
In next m lines pairs of colors which harmonize with each other are listed. Colors are numbered from 1 to n. It is guaranteed that no pair occurs twice in this list.
Output
Print n blocks, i-th of them describes rooks of i-th color.
In the first line of block print one number a_{i} (1 ≤ a_{i} ≤ 5000) — number of rooks of color i. In each of next a_{i} lines print two integers x and y (1 ≤ x, y ≤ 10^{9}) — coordinates of the next rook.
All rooks must be on different cells.
Total number of rooks must not exceed 5000.
It is guaranteed that the solution exists.
Examples
Input
3 2
1 2
2 3
Output
2
3 4
1 4
4
1 2
2 2
2 4
5 4
1
5 1
Input
3 3
1 2
2 3
3 1
Output
1
1 1
1
1 2
1
1 3
Input
3 1
1 3
Output
1
1 1
1
2 2
1
3 1
Note
Rooks arrangements for all three examples (red is color 1, green is color 2 and blue is color 3).
<image>
<image>
<image>
Submitted Solution:
```
n, m = map(int, input().split())
res = [[(i+1, 5001+i)] for i in range(n)]
for i in range(m):
a, b = map(int, input().split())
res[a-1].append((a, i+1))
res[b-1].append((b, i+1))
for i in range(n):
print(len(res[i]))
for p in res[i]:
print(*p)
``` | instruction | 0 | 92,637 | 7 | 185,274 |
Yes | output | 1 | 92,637 | 7 | 185,275 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ivan is a novice painter. He has n dyes of different colors. He also knows exactly m pairs of colors which harmonize with each other.
Ivan also enjoy playing chess. He has 5000 rooks. He wants to take k rooks, paint each of them in one of n colors and then place this k rooks on a chessboard of size 10^{9} × 10^{9}.
Let's call the set of rooks on the board connected if from any rook we can get to any other rook in this set moving only through cells with rooks from this set. Assume that rooks can jump over other rooks, in other words a rook can go to any cell which shares vertical and to any cell which shares horizontal.
Ivan wants his arrangement of rooks to have following properties:
* For any color there is a rook of this color on a board;
* For any color the set of rooks of this color is connected;
* For any two different colors a b union of set of rooks of color a and set of rooks of color b is connected if and only if this two colors harmonize with each other.
Please help Ivan find such an arrangement.
Input
The first line of input contains 2 integers n, m (1 ≤ n ≤ 100, 0 ≤ m ≤ min(1000, (n(n-1))/(2))) — number of colors and number of pairs of colors which harmonize with each other.
In next m lines pairs of colors which harmonize with each other are listed. Colors are numbered from 1 to n. It is guaranteed that no pair occurs twice in this list.
Output
Print n blocks, i-th of them describes rooks of i-th color.
In the first line of block print one number a_{i} (1 ≤ a_{i} ≤ 5000) — number of rooks of color i. In each of next a_{i} lines print two integers x and y (1 ≤ x, y ≤ 10^{9}) — coordinates of the next rook.
All rooks must be on different cells.
Total number of rooks must not exceed 5000.
It is guaranteed that the solution exists.
Examples
Input
3 2
1 2
2 3
Output
2
3 4
1 4
4
1 2
2 2
2 4
5 4
1
5 1
Input
3 3
1 2
2 3
3 1
Output
1
1 1
1
1 2
1
1 3
Input
3 1
1 3
Output
1
1 1
1
2 2
1
3 1
Note
Rooks arrangements for all three examples (red is color 1, green is color 2 and blue is color 3).
<image>
<image>
<image>
Submitted Solution:
```
n, m = map(int, input().split())
clr = [[] for i in range(n)]
for i in range(m):
a, b = sorted(map(int, input().split()))
a -= 1
b -= 1
clr[a].append(b)
ys = [-1 for i in range(n)]
result = [[] for i in range(n)]
global y, x
x = 1
y = 1
def visit(cur):
global y, x
y += 1
result[cur].append((x, y,))
x += 1
ys[cur] = y
for adj in clr[cur]:
if ys[adj] == -1:
visit(adj)
result[cur].append((x, ys[cur],))
result[adj].append((x, ys[adj],))
x += 1
for i in range(n):
if ys[i] == -1:
visit(i)
for i in range(n):
print(len(result[i]))
for j in result[i]:
print(*j)
``` | instruction | 0 | 92,638 | 7 | 185,276 |
Yes | output | 1 | 92,638 | 7 | 185,277 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ivan is a novice painter. He has n dyes of different colors. He also knows exactly m pairs of colors which harmonize with each other.
Ivan also enjoy playing chess. He has 5000 rooks. He wants to take k rooks, paint each of them in one of n colors and then place this k rooks on a chessboard of size 10^{9} × 10^{9}.
Let's call the set of rooks on the board connected if from any rook we can get to any other rook in this set moving only through cells with rooks from this set. Assume that rooks can jump over other rooks, in other words a rook can go to any cell which shares vertical and to any cell which shares horizontal.
Ivan wants his arrangement of rooks to have following properties:
* For any color there is a rook of this color on a board;
* For any color the set of rooks of this color is connected;
* For any two different colors a b union of set of rooks of color a and set of rooks of color b is connected if and only if this two colors harmonize with each other.
Please help Ivan find such an arrangement.
Input
The first line of input contains 2 integers n, m (1 ≤ n ≤ 100, 0 ≤ m ≤ min(1000, (n(n-1))/(2))) — number of colors and number of pairs of colors which harmonize with each other.
In next m lines pairs of colors which harmonize with each other are listed. Colors are numbered from 1 to n. It is guaranteed that no pair occurs twice in this list.
Output
Print n blocks, i-th of them describes rooks of i-th color.
In the first line of block print one number a_{i} (1 ≤ a_{i} ≤ 5000) — number of rooks of color i. In each of next a_{i} lines print two integers x and y (1 ≤ x, y ≤ 10^{9}) — coordinates of the next rook.
All rooks must be on different cells.
Total number of rooks must not exceed 5000.
It is guaranteed that the solution exists.
Examples
Input
3 2
1 2
2 3
Output
2
3 4
1 4
4
1 2
2 2
2 4
5 4
1
5 1
Input
3 3
1 2
2 3
3 1
Output
1
1 1
1
1 2
1
1 3
Input
3 1
1 3
Output
1
1 1
1
2 2
1
3 1
Note
Rooks arrangements for all three examples (red is color 1, green is color 2 and blue is color 3).
<image>
<image>
<image>
Submitted Solution:
```
# -*- coding:utf-8 -*-
"""
created by shuangquan.huang at 11/3/18
"""
N, M = map(int, input().split())
ans = [(0, 0)] + [[(i+1, i+10000)] for i in range(N)]
y = 9999
for mi in range(M):
u, v = map(int, input().split())
ans[u].append((u, y))
ans[v].append((v, y))
y -= 1
for i in range(1, N+1):
print(len(ans[i]))
for x, y in ans[i]:
print('{} {}'.format(x, y))
``` | instruction | 0 | 92,639 | 7 | 185,278 |
Yes | output | 1 | 92,639 | 7 | 185,279 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ivan is a novice painter. He has n dyes of different colors. He also knows exactly m pairs of colors which harmonize with each other.
Ivan also enjoy playing chess. He has 5000 rooks. He wants to take k rooks, paint each of them in one of n colors and then place this k rooks on a chessboard of size 10^{9} × 10^{9}.
Let's call the set of rooks on the board connected if from any rook we can get to any other rook in this set moving only through cells with rooks from this set. Assume that rooks can jump over other rooks, in other words a rook can go to any cell which shares vertical and to any cell which shares horizontal.
Ivan wants his arrangement of rooks to have following properties:
* For any color there is a rook of this color on a board;
* For any color the set of rooks of this color is connected;
* For any two different colors a b union of set of rooks of color a and set of rooks of color b is connected if and only if this two colors harmonize with each other.
Please help Ivan find such an arrangement.
Input
The first line of input contains 2 integers n, m (1 ≤ n ≤ 100, 0 ≤ m ≤ min(1000, (n(n-1))/(2))) — number of colors and number of pairs of colors which harmonize with each other.
In next m lines pairs of colors which harmonize with each other are listed. Colors are numbered from 1 to n. It is guaranteed that no pair occurs twice in this list.
Output
Print n blocks, i-th of them describes rooks of i-th color.
In the first line of block print one number a_{i} (1 ≤ a_{i} ≤ 5000) — number of rooks of color i. In each of next a_{i} lines print two integers x and y (1 ≤ x, y ≤ 10^{9}) — coordinates of the next rook.
All rooks must be on different cells.
Total number of rooks must not exceed 5000.
It is guaranteed that the solution exists.
Examples
Input
3 2
1 2
2 3
Output
2
3 4
1 4
4
1 2
2 2
2 4
5 4
1
5 1
Input
3 3
1 2
2 3
3 1
Output
1
1 1
1
1 2
1
1 3
Input
3 1
1 3
Output
1
1 1
1
2 2
1
3 1
Note
Rooks arrangements for all three examples (red is color 1, green is color 2 and blue is color 3).
<image>
<image>
<image>
Submitted Solution:
```
# use this as the main template for python problems
from collections import Counter
if __name__ == "__main__":
# single variables
n, m = [int(val) for val in input().split()]
harmony = [set([]) for i in range(n)]
for i in range(m):
# get the pair, divide larger and smaller
a, b = [int(val) for val in input().split()]
a -= 1
b -= 1
harmony[a].add(b)
harmony[b].add(a)
pos = [[] for i in range(n)]
# each color gets a unique column
# all intra harmony will be within a column
# all inter harmony will be within rows
v = 1
vertical_positions = {}
for i in range(n):
s = harmony[i]
count = len(s)
vertical_positions[i] = set([])
if(count == 0):
vertical_positions[i].add(v)
pos[i].append((i+1, v))
v += 1
else:
for color in s:
if(color < i):
val = vertical_positions[color].pop()
pos[i].append((i+1, val))
else:
vertical_positions[i].add(v)
pos[i].append((i+1, v))
v += 1
for i in pos:
print(len(i))
for j in i:
print(j[0], j[1])
``` | instruction | 0 | 92,640 | 7 | 185,280 |
Yes | output | 1 | 92,640 | 7 | 185,281 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ivan is a novice painter. He has n dyes of different colors. He also knows exactly m pairs of colors which harmonize with each other.
Ivan also enjoy playing chess. He has 5000 rooks. He wants to take k rooks, paint each of them in one of n colors and then place this k rooks on a chessboard of size 10^{9} × 10^{9}.
Let's call the set of rooks on the board connected if from any rook we can get to any other rook in this set moving only through cells with rooks from this set. Assume that rooks can jump over other rooks, in other words a rook can go to any cell which shares vertical and to any cell which shares horizontal.
Ivan wants his arrangement of rooks to have following properties:
* For any color there is a rook of this color on a board;
* For any color the set of rooks of this color is connected;
* For any two different colors a b union of set of rooks of color a and set of rooks of color b is connected if and only if this two colors harmonize with each other.
Please help Ivan find such an arrangement.
Input
The first line of input contains 2 integers n, m (1 ≤ n ≤ 100, 0 ≤ m ≤ min(1000, (n(n-1))/(2))) — number of colors and number of pairs of colors which harmonize with each other.
In next m lines pairs of colors which harmonize with each other are listed. Colors are numbered from 1 to n. It is guaranteed that no pair occurs twice in this list.
Output
Print n blocks, i-th of them describes rooks of i-th color.
In the first line of block print one number a_{i} (1 ≤ a_{i} ≤ 5000) — number of rooks of color i. In each of next a_{i} lines print two integers x and y (1 ≤ x, y ≤ 10^{9}) — coordinates of the next rook.
All rooks must be on different cells.
Total number of rooks must not exceed 5000.
It is guaranteed that the solution exists.
Examples
Input
3 2
1 2
2 3
Output
2
3 4
1 4
4
1 2
2 2
2 4
5 4
1
5 1
Input
3 3
1 2
2 3
3 1
Output
1
1 1
1
1 2
1
1 3
Input
3 1
1 3
Output
1
1 1
1
2 2
1
3 1
Note
Rooks arrangements for all three examples (red is color 1, green is color 2 and blue is color 3).
<image>
<image>
<image>
Submitted Solution:
```
n, m = map(int, input().split())
j = 0
lis = [[] for i in range(n)]
for i in range(m):
a, b = map(int, input().split())
lis[a - 1].append(b)
lis[b - 1].append(a)
for pos in range(n):
print(len(lis[pos]))
for i in lis[pos]:
print(str(pos + 1), str(i))
``` | instruction | 0 | 92,641 | 7 | 185,282 |
No | output | 1 | 92,641 | 7 | 185,283 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ivan is a novice painter. He has n dyes of different colors. He also knows exactly m pairs of colors which harmonize with each other.
Ivan also enjoy playing chess. He has 5000 rooks. He wants to take k rooks, paint each of them in one of n colors and then place this k rooks on a chessboard of size 10^{9} × 10^{9}.
Let's call the set of rooks on the board connected if from any rook we can get to any other rook in this set moving only through cells with rooks from this set. Assume that rooks can jump over other rooks, in other words a rook can go to any cell which shares vertical and to any cell which shares horizontal.
Ivan wants his arrangement of rooks to have following properties:
* For any color there is a rook of this color on a board;
* For any color the set of rooks of this color is connected;
* For any two different colors a b union of set of rooks of color a and set of rooks of color b is connected if and only if this two colors harmonize with each other.
Please help Ivan find such an arrangement.
Input
The first line of input contains 2 integers n, m (1 ≤ n ≤ 100, 0 ≤ m ≤ min(1000, (n(n-1))/(2))) — number of colors and number of pairs of colors which harmonize with each other.
In next m lines pairs of colors which harmonize with each other are listed. Colors are numbered from 1 to n. It is guaranteed that no pair occurs twice in this list.
Output
Print n blocks, i-th of them describes rooks of i-th color.
In the first line of block print one number a_{i} (1 ≤ a_{i} ≤ 5000) — number of rooks of color i. In each of next a_{i} lines print two integers x and y (1 ≤ x, y ≤ 10^{9}) — coordinates of the next rook.
All rooks must be on different cells.
Total number of rooks must not exceed 5000.
It is guaranteed that the solution exists.
Examples
Input
3 2
1 2
2 3
Output
2
3 4
1 4
4
1 2
2 2
2 4
5 4
1
5 1
Input
3 3
1 2
2 3
3 1
Output
1
1 1
1
1 2
1
1 3
Input
3 1
1 3
Output
1
1 1
1
2 2
1
3 1
Note
Rooks arrangements for all three examples (red is color 1, green is color 2 and blue is color 3).
<image>
<image>
<image>
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline()
# ------------------------------
def RL(): return map(int, sys.stdin.readline().split())
def RLL(): return list(map(int, sys.stdin.readline().split()))
def N(): return int(input())
def print_list(l):
print(' '.join(map(str,l)))
# sys.setrecursionlimit(300000)
# from heapq import *
# from collections import deque as dq
# from math import ceil,floor,sqrt,pow
# import bisect as bs
# from collections import Counter
# from collections import defaultdict as dc
n,m = RL()
dic = [[i] for i in range(n+1)]
for _ in range(m):
a,b = RL()
dic[a].append(b)
for i in range(1,n+1):
print(len(dic[i]))
for j in dic[i]:
print(i,j)
``` | instruction | 0 | 92,642 | 7 | 185,284 |
No | output | 1 | 92,642 | 7 | 185,285 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ivan is a novice painter. He has n dyes of different colors. He also knows exactly m pairs of colors which harmonize with each other.
Ivan also enjoy playing chess. He has 5000 rooks. He wants to take k rooks, paint each of them in one of n colors and then place this k rooks on a chessboard of size 10^{9} × 10^{9}.
Let's call the set of rooks on the board connected if from any rook we can get to any other rook in this set moving only through cells with rooks from this set. Assume that rooks can jump over other rooks, in other words a rook can go to any cell which shares vertical and to any cell which shares horizontal.
Ivan wants his arrangement of rooks to have following properties:
* For any color there is a rook of this color on a board;
* For any color the set of rooks of this color is connected;
* For any two different colors a b union of set of rooks of color a and set of rooks of color b is connected if and only if this two colors harmonize with each other.
Please help Ivan find such an arrangement.
Input
The first line of input contains 2 integers n, m (1 ≤ n ≤ 100, 0 ≤ m ≤ min(1000, (n(n-1))/(2))) — number of colors and number of pairs of colors which harmonize with each other.
In next m lines pairs of colors which harmonize with each other are listed. Colors are numbered from 1 to n. It is guaranteed that no pair occurs twice in this list.
Output
Print n blocks, i-th of them describes rooks of i-th color.
In the first line of block print one number a_{i} (1 ≤ a_{i} ≤ 5000) — number of rooks of color i. In each of next a_{i} lines print two integers x and y (1 ≤ x, y ≤ 10^{9}) — coordinates of the next rook.
All rooks must be on different cells.
Total number of rooks must not exceed 5000.
It is guaranteed that the solution exists.
Examples
Input
3 2
1 2
2 3
Output
2
3 4
1 4
4
1 2
2 2
2 4
5 4
1
5 1
Input
3 3
1 2
2 3
3 1
Output
1
1 1
1
1 2
1
1 3
Input
3 1
1 3
Output
1
1 1
1
2 2
1
3 1
Note
Rooks arrangements for all three examples (red is color 1, green is color 2 and blue is color 3).
<image>
<image>
<image>
Submitted Solution:
```
n, m = map(int, input().split())
a = []
for i in range(n):
a.append([i * n, i * n])
for i in range(m):
x, y = map(int, input().split())
x -= 1
y -= 1
if x > y:
x, y = y, x
a[x].append([x*n, x * n + y])
a[y].append([y*n, x * n + y])
for i in range(n):
print(len(a[i]))
for j in a:
print(j[0]+1, j[1] + 1)
``` | instruction | 0 | 92,643 | 7 | 185,286 |
No | output | 1 | 92,643 | 7 | 185,287 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ivan is a novice painter. He has n dyes of different colors. He also knows exactly m pairs of colors which harmonize with each other.
Ivan also enjoy playing chess. He has 5000 rooks. He wants to take k rooks, paint each of them in one of n colors and then place this k rooks on a chessboard of size 10^{9} × 10^{9}.
Let's call the set of rooks on the board connected if from any rook we can get to any other rook in this set moving only through cells with rooks from this set. Assume that rooks can jump over other rooks, in other words a rook can go to any cell which shares vertical and to any cell which shares horizontal.
Ivan wants his arrangement of rooks to have following properties:
* For any color there is a rook of this color on a board;
* For any color the set of rooks of this color is connected;
* For any two different colors a b union of set of rooks of color a and set of rooks of color b is connected if and only if this two colors harmonize with each other.
Please help Ivan find such an arrangement.
Input
The first line of input contains 2 integers n, m (1 ≤ n ≤ 100, 0 ≤ m ≤ min(1000, (n(n-1))/(2))) — number of colors and number of pairs of colors which harmonize with each other.
In next m lines pairs of colors which harmonize with each other are listed. Colors are numbered from 1 to n. It is guaranteed that no pair occurs twice in this list.
Output
Print n blocks, i-th of them describes rooks of i-th color.
In the first line of block print one number a_{i} (1 ≤ a_{i} ≤ 5000) — number of rooks of color i. In each of next a_{i} lines print two integers x and y (1 ≤ x, y ≤ 10^{9}) — coordinates of the next rook.
All rooks must be on different cells.
Total number of rooks must not exceed 5000.
It is guaranteed that the solution exists.
Examples
Input
3 2
1 2
2 3
Output
2
3 4
1 4
4
1 2
2 2
2 4
5 4
1
5 1
Input
3 3
1 2
2 3
3 1
Output
1
1 1
1
1 2
1
1 3
Input
3 1
1 3
Output
1
1 1
1
2 2
1
3 1
Note
Rooks arrangements for all three examples (red is color 1, green is color 2 and blue is color 3).
<image>
<image>
<image>
Submitted Solution:
```
#import sys
#sys.stdin = open("123.data")
n, m = map(int, input().split())
g = [[(i, i)] for i in range(n)]
k = n
for i in range(m):
a1, b1 = map(int, input().split())
g[a1 - 1].append((b1 - 1, k))
g[b1 - 1].append((a1 - 1, k))
#print(k, 11111111)
k += 1
#print(g)
for i in range(n):
print(len(g[i]))
for x in g[i]:
print(x[0] + 1, x[1] + 1)
``` | instruction | 0 | 92,644 | 7 | 185,288 |
No | output | 1 | 92,644 | 7 | 185,289 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently biologists came to a fascinating conclusion about how to find a chameleon mood. Consider chameleon body to be a rectangular table n × m, each cell of which may be green or blue and may change between these two colors. We will denote as (x, y) (1 ≤ x ≤ n, 1 ≤ y ≤ m) the cell in row x and column y.
Let us define a chameleon good mood certificate to be four cells which are corners of some subrectangle of the table, such that colors in opposite cells among these four are similar, and at the same time not all of the four cell colors are similar. Formally, it is a group of four cells (x_1, y_1), (x_1, y_2), (x_2, y_1), (x_2, y_2) for some 1 ≤ x_1 < x_2 ≤ n, 1 ≤ y_1 < y_2 ≤ m, that colors of (x_1, y_1) and (x_2, y_2) coincide and colors of (x_1, y_2) and (x_2, y_1) coincide, but not all of the four cells share the same color. It was found that whenever such four cells are present, chameleon is in good mood, and vice versa: if there are no such four cells, chameleon is in bad mood.
You are asked to help scientists write a program determining the mood of chameleon. Let us consider that initially all cells of chameleon are green. After that chameleon coloring may change several times. On one change, colors of contiguous segment of some table row are replaced with the opposite. Formally, each color change is defined by three integers a, l, r (1 ≤ a ≤ n, 1 ≤ l ≤ r ≤ m). On such change colors of all cells (a, b) such that l ≤ b ≤ r are replaced with the opposite.
Write a program that reports mood of the chameleon after each change. Additionally, if the chameleon mood is good, program should find out any four numbers x_1, y_1, x_2, y_2 such that four cells (x_1, y_1), (x_1, y_2), (x_2, y_1), (x_2, y_2) are the good mood certificate.
Input
The first line of input contains three integers n, m, q (1 ≤ n, m ≤ 2000, 1 ≤ q ≤ 500 000), the sizes of the table and the number of changes respectively.
Each of the following q lines contains 3 integers a_i, l_i, r_i (1 ≤ a_i ≤ n, 1 ≤ l_i ≤ r_i ≤ m), describing i-th coloring change.
Output
Print q lines. In the i-th line report the chameleon mood after first i color changes for all 1 ≤ i ≤ q.
If chameleon is in bad mood, print the only integer -1.
Otherwise, print four integers x_1, y_1, x_2, y_2 (1 ≤ x_1 < x_2 ≤ n, 1 ≤ y_1 < y_2 ≤ m) such that four cells (x_1, y_1), (x_1, y_2), (x_2, y_1), (x_2, y_2) are the good mood certificate. If there are several ways to choose such four integers, print any valid one.
Examples
Input
2 2 6
1 1 1
2 2 2
2 1 1
1 2 2
2 2 2
1 1 1
Output
-1
1 1 2 2
-1
-1
-1
1 1 2 2
Input
4 3 9
2 2 3
4 1 2
2 1 3
3 2 2
3 1 3
1 2 2
4 2 3
1 1 3
3 1 3
Output
-1
2 1 4 3
-1
2 1 3 2
3 2 4 3
1 1 2 2
1 1 2 2
-1
2 1 3 2
Submitted Solution:
```
x,y,q=input().split()
x=int(x)
y=int(y)
q=int(q)
m=1
lis=[[0,0]]
while(m<=x):
a=[0]
n=1
while(n<=y):
a.append(0)
n+=1
lis.append(a)
m+=1
def change(a1,b1):
if(lis[a1][b1]==0):
lis[a1][b1]=1
else:
lis[a1][b1]=0
print(lis)
while(q>0):
d,e,f=input().split()
d=int(d)
e=int(e)
f=int(f)
z=e
while(z<f+1):
change(d,z)
z+=1
print(lis)
x1=1
key=0
while(x1<x):
y1=1
while(y1<y):
x2=x1+1
while(x2<=x):
y2=y1+1
while(y2<=y):
if(lis[x1][y1]==lis[x2][y2] and lis[x1][y2]==lis[x2][y1] and lis[x1][y1]!=lis[x1][y2]):
if(key==0):
print(str(x1)+" "+str(y1)+" "+str(x2)+" "+str(y2))
key=1
break
y2+=1
x2+=1
y1+=1
x1+=1
if(key==0):
print("-1")
q-=1
print(lis)
``` | instruction | 0 | 92,693 | 7 | 185,386 |
No | output | 1 | 92,693 | 7 | 185,387 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nicholas, a painter is going to paint several new canvases. Nicholas is sure that the canvases will turn out so great that each one will need framing and being hung on the wall. Frames are what Nicholas decided to begin with.
Nicholas has n sticks whose lengths equal a1, a2, ... an. Nicholas does not want to break the sticks or glue them together. To make a h × w-sized frame, he needs two sticks whose lengths equal h and two sticks whose lengths equal w. Specifically, to make a square frame (when h = w), he needs four sticks of the same length.
Now Nicholas wants to make from the sticks that he has as many frames as possible; to be able to paint as many canvases as possible to fill the frames. Help him in this uneasy task. Note that it is not necessary to use all the sticks Nicholas has.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the number of sticks. The second line contains n space-separated integers. The i-th integer equals the length of the i-th stick ai (1 ≤ ai ≤ 100).
Output
Print the single number — the maximum number of frames Nicholas can make for his future canvases.
Examples
Input
5
2 4 3 2 3
Output
1
Input
13
2 2 4 4 4 4 6 6 6 7 7 9 9
Output
3
Input
4
3 3 3 5
Output
0 | instruction | 0 | 92,726 | 7 | 185,452 |
Tags: implementation
Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
d = {}
for i in a:
s = d.get(i, 0)
if s == 0:
d[i] = 1
else:
d[i] = d[i] + 1
c = 0
for i in d.keys():
c += d[i] // 2
print(c // 2)
``` | output | 1 | 92,726 | 7 | 185,453 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nicholas, a painter is going to paint several new canvases. Nicholas is sure that the canvases will turn out so great that each one will need framing and being hung on the wall. Frames are what Nicholas decided to begin with.
Nicholas has n sticks whose lengths equal a1, a2, ... an. Nicholas does not want to break the sticks or glue them together. To make a h × w-sized frame, he needs two sticks whose lengths equal h and two sticks whose lengths equal w. Specifically, to make a square frame (when h = w), he needs four sticks of the same length.
Now Nicholas wants to make from the sticks that he has as many frames as possible; to be able to paint as many canvases as possible to fill the frames. Help him in this uneasy task. Note that it is not necessary to use all the sticks Nicholas has.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the number of sticks. The second line contains n space-separated integers. The i-th integer equals the length of the i-th stick ai (1 ≤ ai ≤ 100).
Output
Print the single number — the maximum number of frames Nicholas can make for his future canvases.
Examples
Input
5
2 4 3 2 3
Output
1
Input
13
2 2 4 4 4 4 6 6 6 7 7 9 9
Output
3
Input
4
3 3 3 5
Output
0 | instruction | 0 | 92,727 | 7 | 185,454 |
Tags: implementation
Correct Solution:
```
n=int(input())
arr=list(map(int,input().split()))
s=set(arr)
rem=0
c=0
for x in s:
if(arr.count(x)>=4):
c=c+(arr.count(x)//4)
rem=rem+((arr.count(x)%4)//2)
else:
rem=rem+(arr.count(x)//2)
c=c+(rem//2)
print(c)
``` | output | 1 | 92,727 | 7 | 185,455 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nicholas, a painter is going to paint several new canvases. Nicholas is sure that the canvases will turn out so great that each one will need framing and being hung on the wall. Frames are what Nicholas decided to begin with.
Nicholas has n sticks whose lengths equal a1, a2, ... an. Nicholas does not want to break the sticks or glue them together. To make a h × w-sized frame, he needs two sticks whose lengths equal h and two sticks whose lengths equal w. Specifically, to make a square frame (when h = w), he needs four sticks of the same length.
Now Nicholas wants to make from the sticks that he has as many frames as possible; to be able to paint as many canvases as possible to fill the frames. Help him in this uneasy task. Note that it is not necessary to use all the sticks Nicholas has.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the number of sticks. The second line contains n space-separated integers. The i-th integer equals the length of the i-th stick ai (1 ≤ ai ≤ 100).
Output
Print the single number — the maximum number of frames Nicholas can make for his future canvases.
Examples
Input
5
2 4 3 2 3
Output
1
Input
13
2 2 4 4 4 4 6 6 6 7 7 9 9
Output
3
Input
4
3 3 3 5
Output
0 | instruction | 0 | 92,728 | 7 | 185,456 |
Tags: implementation
Correct Solution:
```
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from copy import copy
n=int(input())
f={}
d=0
p=[]
deleted=[]
def refresh():
global p,d
if len(p)==2:
d+=1
f[p[0]]=0
f[p[1]]=0
p=[]
for x in input().split():
try:
f[x]+=1
except:
f[x]=1
for x in f.keys():
if f[x]>=4:
j=copy(f[x])
f[x]=j%4
d+=j//4
if f[x]>=2:
p.append(x)
refresh()
print(d)
``` | output | 1 | 92,728 | 7 | 185,457 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nicholas, a painter is going to paint several new canvases. Nicholas is sure that the canvases will turn out so great that each one will need framing and being hung on the wall. Frames are what Nicholas decided to begin with.
Nicholas has n sticks whose lengths equal a1, a2, ... an. Nicholas does not want to break the sticks or glue them together. To make a h × w-sized frame, he needs two sticks whose lengths equal h and two sticks whose lengths equal w. Specifically, to make a square frame (when h = w), he needs four sticks of the same length.
Now Nicholas wants to make from the sticks that he has as many frames as possible; to be able to paint as many canvases as possible to fill the frames. Help him in this uneasy task. Note that it is not necessary to use all the sticks Nicholas has.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the number of sticks. The second line contains n space-separated integers. The i-th integer equals the length of the i-th stick ai (1 ≤ ai ≤ 100).
Output
Print the single number — the maximum number of frames Nicholas can make for his future canvases.
Examples
Input
5
2 4 3 2 3
Output
1
Input
13
2 2 4 4 4 4 6 6 6 7 7 9 9
Output
3
Input
4
3 3 3 5
Output
0 | instruction | 0 | 92,729 | 7 | 185,458 |
Tags: implementation
Correct Solution:
```
n = int(input())
a = [0] * 110
sticks = list(map(int, input().split()))
for i in range(len(sticks)):
a[sticks[i]] += 1
counter = 0
for i in range(len(a)):
counter += a[i] // 2
print(counter // 2)
``` | output | 1 | 92,729 | 7 | 185,459 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nicholas, a painter is going to paint several new canvases. Nicholas is sure that the canvases will turn out so great that each one will need framing and being hung on the wall. Frames are what Nicholas decided to begin with.
Nicholas has n sticks whose lengths equal a1, a2, ... an. Nicholas does not want to break the sticks or glue them together. To make a h × w-sized frame, he needs two sticks whose lengths equal h and two sticks whose lengths equal w. Specifically, to make a square frame (when h = w), he needs four sticks of the same length.
Now Nicholas wants to make from the sticks that he has as many frames as possible; to be able to paint as many canvases as possible to fill the frames. Help him in this uneasy task. Note that it is not necessary to use all the sticks Nicholas has.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the number of sticks. The second line contains n space-separated integers. The i-th integer equals the length of the i-th stick ai (1 ≤ ai ≤ 100).
Output
Print the single number — the maximum number of frames Nicholas can make for his future canvases.
Examples
Input
5
2 4 3 2 3
Output
1
Input
13
2 2 4 4 4 4 6 6 6 7 7 9 9
Output
3
Input
4
3 3 3 5
Output
0 | instruction | 0 | 92,730 | 7 | 185,460 |
Tags: implementation
Correct Solution:
```
def arr_inp():
return [int(x) for x in input().split()]
from collections import *
n, a = int(input()), arr_inp()
c = Counter(a)
# print(c)
print(int(sum(list(map(lambda x:x//2, c.values())))//2))
``` | output | 1 | 92,730 | 7 | 185,461 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nicholas, a painter is going to paint several new canvases. Nicholas is sure that the canvases will turn out so great that each one will need framing and being hung on the wall. Frames are what Nicholas decided to begin with.
Nicholas has n sticks whose lengths equal a1, a2, ... an. Nicholas does not want to break the sticks or glue them together. To make a h × w-sized frame, he needs two sticks whose lengths equal h and two sticks whose lengths equal w. Specifically, to make a square frame (when h = w), he needs four sticks of the same length.
Now Nicholas wants to make from the sticks that he has as many frames as possible; to be able to paint as many canvases as possible to fill the frames. Help him in this uneasy task. Note that it is not necessary to use all the sticks Nicholas has.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the number of sticks. The second line contains n space-separated integers. The i-th integer equals the length of the i-th stick ai (1 ≤ ai ≤ 100).
Output
Print the single number — the maximum number of frames Nicholas can make for his future canvases.
Examples
Input
5
2 4 3 2 3
Output
1
Input
13
2 2 4 4 4 4 6 6 6 7 7 9 9
Output
3
Input
4
3 3 3 5
Output
0 | instruction | 0 | 92,731 | 7 | 185,462 |
Tags: implementation
Correct Solution:
```
n = int(input())
l = list(map(int, input().split()))
s = set(l)
c = []
for i in s:
t = l.count(i)
if t%2==0:
c.append(t)
else:
c.append(t-1)
s = sum(c)
print(s//4)
``` | output | 1 | 92,731 | 7 | 185,463 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nicholas, a painter is going to paint several new canvases. Nicholas is sure that the canvases will turn out so great that each one will need framing and being hung on the wall. Frames are what Nicholas decided to begin with.
Nicholas has n sticks whose lengths equal a1, a2, ... an. Nicholas does not want to break the sticks or glue them together. To make a h × w-sized frame, he needs two sticks whose lengths equal h and two sticks whose lengths equal w. Specifically, to make a square frame (when h = w), he needs four sticks of the same length.
Now Nicholas wants to make from the sticks that he has as many frames as possible; to be able to paint as many canvases as possible to fill the frames. Help him in this uneasy task. Note that it is not necessary to use all the sticks Nicholas has.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the number of sticks. The second line contains n space-separated integers. The i-th integer equals the length of the i-th stick ai (1 ≤ ai ≤ 100).
Output
Print the single number — the maximum number of frames Nicholas can make for his future canvases.
Examples
Input
5
2 4 3 2 3
Output
1
Input
13
2 2 4 4 4 4 6 6 6 7 7 9 9
Output
3
Input
4
3 3 3 5
Output
0 | instruction | 0 | 92,732 | 7 | 185,464 |
Tags: implementation
Correct Solution:
```
"""
Oh, Grantors of Dark Disgrace,
Do Not Wake Me Again.
"""
from collections import Counter
ii = lambda: int(input())
mi = lambda: map(int, input().split())
li = lambda: list(mi())
si = lambda: input()
n = ii()
l = li()
cc = Counter(l)
e = [(i-i%2) for i in cc.values()]
print(sum(e)//4)
``` | output | 1 | 92,732 | 7 | 185,465 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nicholas, a painter is going to paint several new canvases. Nicholas is sure that the canvases will turn out so great that each one will need framing and being hung on the wall. Frames are what Nicholas decided to begin with.
Nicholas has n sticks whose lengths equal a1, a2, ... an. Nicholas does not want to break the sticks or glue them together. To make a h × w-sized frame, he needs two sticks whose lengths equal h and two sticks whose lengths equal w. Specifically, to make a square frame (when h = w), he needs four sticks of the same length.
Now Nicholas wants to make from the sticks that he has as many frames as possible; to be able to paint as many canvases as possible to fill the frames. Help him in this uneasy task. Note that it is not necessary to use all the sticks Nicholas has.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the number of sticks. The second line contains n space-separated integers. The i-th integer equals the length of the i-th stick ai (1 ≤ ai ≤ 100).
Output
Print the single number — the maximum number of frames Nicholas can make for his future canvases.
Examples
Input
5
2 4 3 2 3
Output
1
Input
13
2 2 4 4 4 4 6 6 6 7 7 9 9
Output
3
Input
4
3 3 3 5
Output
0 | instruction | 0 | 92,733 | 7 | 185,466 |
Tags: implementation
Correct Solution:
```
from collections import defaultdict
n=int(input())
c=list(map(int,input().split()))
d=defaultdict(int)
for i in range(len(c)):
d[c[i]]+=1
count=0
for val in d.values():
count+=val//2
if count%2==0:
print(count//2)
else:
print((count-1)//2)
``` | output | 1 | 92,733 | 7 | 185,467 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nicholas, a painter is going to paint several new canvases. Nicholas is sure that the canvases will turn out so great that each one will need framing and being hung on the wall. Frames are what Nicholas decided to begin with.
Nicholas has n sticks whose lengths equal a1, a2, ... an. Nicholas does not want to break the sticks or glue them together. To make a h × w-sized frame, he needs two sticks whose lengths equal h and two sticks whose lengths equal w. Specifically, to make a square frame (when h = w), he needs four sticks of the same length.
Now Nicholas wants to make from the sticks that he has as many frames as possible; to be able to paint as many canvases as possible to fill the frames. Help him in this uneasy task. Note that it is not necessary to use all the sticks Nicholas has.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the number of sticks. The second line contains n space-separated integers. The i-th integer equals the length of the i-th stick ai (1 ≤ ai ≤ 100).
Output
Print the single number — the maximum number of frames Nicholas can make for his future canvases.
Examples
Input
5
2 4 3 2 3
Output
1
Input
13
2 2 4 4 4 4 6 6 6 7 7 9 9
Output
3
Input
4
3 3 3 5
Output
0
Submitted Solution:
```
d={}
for x in map(int,[*open(0)][1].split()):
d[x]=d.get(x,0)+1
r=0
for x in d.values():r+=x//2
print(r//2)
``` | instruction | 0 | 92,734 | 7 | 185,468 |
Yes | output | 1 | 92,734 | 7 | 185,469 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nicholas, a painter is going to paint several new canvases. Nicholas is sure that the canvases will turn out so great that each one will need framing and being hung on the wall. Frames are what Nicholas decided to begin with.
Nicholas has n sticks whose lengths equal a1, a2, ... an. Nicholas does not want to break the sticks or glue them together. To make a h × w-sized frame, he needs two sticks whose lengths equal h and two sticks whose lengths equal w. Specifically, to make a square frame (when h = w), he needs four sticks of the same length.
Now Nicholas wants to make from the sticks that he has as many frames as possible; to be able to paint as many canvases as possible to fill the frames. Help him in this uneasy task. Note that it is not necessary to use all the sticks Nicholas has.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the number of sticks. The second line contains n space-separated integers. The i-th integer equals the length of the i-th stick ai (1 ≤ ai ≤ 100).
Output
Print the single number — the maximum number of frames Nicholas can make for his future canvases.
Examples
Input
5
2 4 3 2 3
Output
1
Input
13
2 2 4 4 4 4 6 6 6 7 7 9 9
Output
3
Input
4
3 3 3 5
Output
0
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
from collections import defaultdict
from math import ceil,floor,sqrt,log2,gcd
from heapq import heappush,heappop
from bisect import bisect_left,bisect
import sys
abc='abcdefghijklmnopqrstuvwxyz'
ABC="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
n=int(input())
arr=list(map(int,input().split()))
d=defaultdict(int)
for i in arr:
d[i]+=1
ans=0
for i in d:
ans+=d[i]//2
print(ans//2)
``` | instruction | 0 | 92,735 | 7 | 185,470 |
Yes | output | 1 | 92,735 | 7 | 185,471 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nicholas, a painter is going to paint several new canvases. Nicholas is sure that the canvases will turn out so great that each one will need framing and being hung on the wall. Frames are what Nicholas decided to begin with.
Nicholas has n sticks whose lengths equal a1, a2, ... an. Nicholas does not want to break the sticks or glue them together. To make a h × w-sized frame, he needs two sticks whose lengths equal h and two sticks whose lengths equal w. Specifically, to make a square frame (when h = w), he needs four sticks of the same length.
Now Nicholas wants to make from the sticks that he has as many frames as possible; to be able to paint as many canvases as possible to fill the frames. Help him in this uneasy task. Note that it is not necessary to use all the sticks Nicholas has.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the number of sticks. The second line contains n space-separated integers. The i-th integer equals the length of the i-th stick ai (1 ≤ ai ≤ 100).
Output
Print the single number — the maximum number of frames Nicholas can make for his future canvases.
Examples
Input
5
2 4 3 2 3
Output
1
Input
13
2 2 4 4 4 4 6 6 6 7 7 9 9
Output
3
Input
4
3 3 3 5
Output
0
Submitted Solution:
```
if __name__ == '__main__':
Y = lambda: list(map(int, input().split()))
N = lambda: int(input())
n = N()
a = Y()
d = dict()
for i in range(n):
d[a[i]] = d.get(a[i], 0) + 1
for v in d.keys():
d[v] = d[v]//2
print(sum(d.values())//2)
``` | instruction | 0 | 92,736 | 7 | 185,472 |
Yes | output | 1 | 92,736 | 7 | 185,473 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nicholas, a painter is going to paint several new canvases. Nicholas is sure that the canvases will turn out so great that each one will need framing and being hung on the wall. Frames are what Nicholas decided to begin with.
Nicholas has n sticks whose lengths equal a1, a2, ... an. Nicholas does not want to break the sticks or glue them together. To make a h × w-sized frame, he needs two sticks whose lengths equal h and two sticks whose lengths equal w. Specifically, to make a square frame (when h = w), he needs four sticks of the same length.
Now Nicholas wants to make from the sticks that he has as many frames as possible; to be able to paint as many canvases as possible to fill the frames. Help him in this uneasy task. Note that it is not necessary to use all the sticks Nicholas has.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the number of sticks. The second line contains n space-separated integers. The i-th integer equals the length of the i-th stick ai (1 ≤ ai ≤ 100).
Output
Print the single number — the maximum number of frames Nicholas can make for his future canvases.
Examples
Input
5
2 4 3 2 3
Output
1
Input
13
2 2 4 4 4 4 6 6 6 7 7 9 9
Output
3
Input
4
3 3 3 5
Output
0
Submitted Solution:
```
import sys
f = sys.stdin
#f = open("input.txt", "r")
n = int(f.readline().strip())
a = [int(i) for i in f.readline().strip().split()]
a.sort()
k = list(set(a))
counts = []
for i in k:
counts.append(a.count(i))
counts.sort(reverse=True)
cnt = 0
i = 0
while i < len(counts):
if counts[i] >= 4:
cnt += counts[i]//4
counts[i] -= (counts[i]//4)*4
i += 1
while 0 in counts:
counts.remove(0)
counts.sort(reverse=True)
i = 0
while i < len(counts)-1:
if counts[i] >= 2 and counts[i+1] >= 2:
cnt += min(counts[i], counts[i+1])//2
i += 2
else:
i += 1
print(cnt)
``` | instruction | 0 | 92,737 | 7 | 185,474 |
Yes | output | 1 | 92,737 | 7 | 185,475 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nicholas, a painter is going to paint several new canvases. Nicholas is sure that the canvases will turn out so great that each one will need framing and being hung on the wall. Frames are what Nicholas decided to begin with.
Nicholas has n sticks whose lengths equal a1, a2, ... an. Nicholas does not want to break the sticks or glue them together. To make a h × w-sized frame, he needs two sticks whose lengths equal h and two sticks whose lengths equal w. Specifically, to make a square frame (when h = w), he needs four sticks of the same length.
Now Nicholas wants to make from the sticks that he has as many frames as possible; to be able to paint as many canvases as possible to fill the frames. Help him in this uneasy task. Note that it is not necessary to use all the sticks Nicholas has.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the number of sticks. The second line contains n space-separated integers. The i-th integer equals the length of the i-th stick ai (1 ≤ ai ≤ 100).
Output
Print the single number — the maximum number of frames Nicholas can make for his future canvases.
Examples
Input
5
2 4 3 2 3
Output
1
Input
13
2 2 4 4 4 4 6 6 6 7 7 9 9
Output
3
Input
4
3 3 3 5
Output
0
Submitted Solution:
```
z,w,m=input,int,sorted
n=w(z())
l1=list(map(int,input().split()))
l2=set(l1)
l={}
for i in l2:
l[i]=0
for i in l1:
l[i]+=1
l=sorted(l.values())
l=l[::-1]
c=0
ans=0
for i in l:
ans+=(i+c)//4
c=i%4
if c>=2:
c=c//2
else:
c=0
print(ans)
``` | instruction | 0 | 92,738 | 7 | 185,476 |
No | output | 1 | 92,738 | 7 | 185,477 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nicholas, a painter is going to paint several new canvases. Nicholas is sure that the canvases will turn out so great that each one will need framing and being hung on the wall. Frames are what Nicholas decided to begin with.
Nicholas has n sticks whose lengths equal a1, a2, ... an. Nicholas does not want to break the sticks or glue them together. To make a h × w-sized frame, he needs two sticks whose lengths equal h and two sticks whose lengths equal w. Specifically, to make a square frame (when h = w), he needs four sticks of the same length.
Now Nicholas wants to make from the sticks that he has as many frames as possible; to be able to paint as many canvases as possible to fill the frames. Help him in this uneasy task. Note that it is not necessary to use all the sticks Nicholas has.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the number of sticks. The second line contains n space-separated integers. The i-th integer equals the length of the i-th stick ai (1 ≤ ai ≤ 100).
Output
Print the single number — the maximum number of frames Nicholas can make for his future canvases.
Examples
Input
5
2 4 3 2 3
Output
1
Input
13
2 2 4 4 4 4 6 6 6 7 7 9 9
Output
3
Input
4
3 3 3 5
Output
0
Submitted Solution:
```
n = int(input())
l = list(map(int , input().split()))
i = 0
arr=[]
while i<len(l):
x = l.count(l[i])
if x>=4:
arr.append(1)
arr.append(1)
l.remove(l[i])
l.remove(l[i])
l.remove(l[i])
l.remove(l[i])
i = i-1
elif x>=2:
arr.append(1)
l.remove(l[i])
l.remove(l[i])
i = i-1
i = i + 1
ans = len(arr)//2
print(ans)
``` | instruction | 0 | 92,739 | 7 | 185,478 |
No | output | 1 | 92,739 | 7 | 185,479 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nicholas, a painter is going to paint several new canvases. Nicholas is sure that the canvases will turn out so great that each one will need framing and being hung on the wall. Frames are what Nicholas decided to begin with.
Nicholas has n sticks whose lengths equal a1, a2, ... an. Nicholas does not want to break the sticks or glue them together. To make a h × w-sized frame, he needs two sticks whose lengths equal h and two sticks whose lengths equal w. Specifically, to make a square frame (when h = w), he needs four sticks of the same length.
Now Nicholas wants to make from the sticks that he has as many frames as possible; to be able to paint as many canvases as possible to fill the frames. Help him in this uneasy task. Note that it is not necessary to use all the sticks Nicholas has.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the number of sticks. The second line contains n space-separated integers. The i-th integer equals the length of the i-th stick ai (1 ≤ ai ≤ 100).
Output
Print the single number — the maximum number of frames Nicholas can make for his future canvases.
Examples
Input
5
2 4 3 2 3
Output
1
Input
13
2 2 4 4 4 4 6 6 6 7 7 9 9
Output
3
Input
4
3 3 3 5
Output
0
Submitted Solution:
```
n=int(input())
a=list(map(int,input().split()))
freq={}
for x in a:
if x in freq:
freq[x]+=1
else:
freq[x]=1
count=0
for x in freq:
if freq[x]>1:
count+=freq[x]
print(count//4)
``` | instruction | 0 | 92,740 | 7 | 185,480 |
No | output | 1 | 92,740 | 7 | 185,481 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nicholas, a painter is going to paint several new canvases. Nicholas is sure that the canvases will turn out so great that each one will need framing and being hung on the wall. Frames are what Nicholas decided to begin with.
Nicholas has n sticks whose lengths equal a1, a2, ... an. Nicholas does not want to break the sticks or glue them together. To make a h × w-sized frame, he needs two sticks whose lengths equal h and two sticks whose lengths equal w. Specifically, to make a square frame (when h = w), he needs four sticks of the same length.
Now Nicholas wants to make from the sticks that he has as many frames as possible; to be able to paint as many canvases as possible to fill the frames. Help him in this uneasy task. Note that it is not necessary to use all the sticks Nicholas has.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the number of sticks. The second line contains n space-separated integers. The i-th integer equals the length of the i-th stick ai (1 ≤ ai ≤ 100).
Output
Print the single number — the maximum number of frames Nicholas can make for his future canvases.
Examples
Input
5
2 4 3 2 3
Output
1
Input
13
2 2 4 4 4 4 6 6 6 7 7 9 9
Output
3
Input
4
3 3 3 5
Output
0
Submitted Solution:
```
n = int(input())
l = list(input().split())
d = {}
for gar in l:
if gar in d:
d[gar] = d[gar] + 1
else:
d[gar] = 1
pari = 0
for gar in d:
pari = pari + d[gar] // 2
print(pari // 2)
``` | instruction | 0 | 92,741 | 7 | 185,482 |
No | output | 1 | 92,741 | 7 | 185,483 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Easter Rabbit laid n eggs in a circle and is about to paint them.
Each egg should be painted one color out of 7: red, orange, yellow, green, blue, indigo or violet. Also, the following conditions should be satisfied:
* Each of the seven colors should be used to paint at least one egg.
* Any four eggs lying sequentially should be painted different colors.
Help the Easter Rabbit paint the eggs in the required manner. We know that it is always possible.
Input
The only line contains an integer n — the amount of eggs (7 ≤ n ≤ 100).
Output
Print one line consisting of n characters. The i-th character should describe the color of the i-th egg in the order they lie in the circle. The colors should be represented as follows: "R" stands for red, "O" stands for orange, "Y" stands for yellow, "G" stands for green, "B" stands for blue, "I" stands for indigo, "V" stands for violet.
If there are several answers, print any of them.
Examples
Input
8
Output
ROYGRBIV
Input
13
Output
ROYGBIVGBIVYG
Note
The way the eggs will be painted in the first sample is shown on the picture:
<image> | instruction | 0 | 94,058 | 7 | 188,116 |
Tags: constructive algorithms, implementation
Correct Solution:
```
#------------------------template--------------------------#
import os
import sys
from math import *
from collections import *
# from fractions import *
# from heapq import*
from bisect import *
from io import BytesIO, IOBase
def vsInput():
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
ALPHA='abcdefghijklmnopqrstuvwxyz'
M=10**9+7
EPS=1e-6
def Ceil(a,b): return a//b+int(a%b>0)
def value():return tuple(map(int,input().split()))
def array():return [int(i) for i in input().split()]
def Int():return int(input())
def Str():return input()
def arrayS():return [i for i in input().split()]
#-------------------------code---------------------------#
# vsInput()
n=Int()
color="ROYGBIV"
ans=list(color[:3])
color=color[3:]
for i in range(n-3):
ans.append(color[i%4])
print(*ans,sep="")
``` | output | 1 | 94,058 | 7 | 188,117 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Easter Rabbit laid n eggs in a circle and is about to paint them.
Each egg should be painted one color out of 7: red, orange, yellow, green, blue, indigo or violet. Also, the following conditions should be satisfied:
* Each of the seven colors should be used to paint at least one egg.
* Any four eggs lying sequentially should be painted different colors.
Help the Easter Rabbit paint the eggs in the required manner. We know that it is always possible.
Input
The only line contains an integer n — the amount of eggs (7 ≤ n ≤ 100).
Output
Print one line consisting of n characters. The i-th character should describe the color of the i-th egg in the order they lie in the circle. The colors should be represented as follows: "R" stands for red, "O" stands for orange, "Y" stands for yellow, "G" stands for green, "B" stands for blue, "I" stands for indigo, "V" stands for violet.
If there are several answers, print any of them.
Examples
Input
8
Output
ROYGRBIV
Input
13
Output
ROYGBIVGBIVYG
Note
The way the eggs will be painted in the first sample is shown on the picture:
<image> | instruction | 0 | 94,059 | 7 | 188,118 |
Tags: constructive algorithms, implementation
Correct Solution:
```
n = int(input())
s = "ROYGBIV"
a, b = divmod(n, len(s))
res = s * a
start = 3 if b <= 4 else 0
res += s[start:start+b]
print(res)
``` | output | 1 | 94,059 | 7 | 188,119 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Easter Rabbit laid n eggs in a circle and is about to paint them.
Each egg should be painted one color out of 7: red, orange, yellow, green, blue, indigo or violet. Also, the following conditions should be satisfied:
* Each of the seven colors should be used to paint at least one egg.
* Any four eggs lying sequentially should be painted different colors.
Help the Easter Rabbit paint the eggs in the required manner. We know that it is always possible.
Input
The only line contains an integer n — the amount of eggs (7 ≤ n ≤ 100).
Output
Print one line consisting of n characters. The i-th character should describe the color of the i-th egg in the order they lie in the circle. The colors should be represented as follows: "R" stands for red, "O" stands for orange, "Y" stands for yellow, "G" stands for green, "B" stands for blue, "I" stands for indigo, "V" stands for violet.
If there are several answers, print any of them.
Examples
Input
8
Output
ROYGRBIV
Input
13
Output
ROYGBIVGBIVYG
Note
The way the eggs will be painted in the first sample is shown on the picture:
<image> | instruction | 0 | 94,060 | 7 | 188,120 |
Tags: constructive algorithms, implementation
Correct Solution:
```
from sys import stdin, stdout
n = int(stdin.readline()) - 7
ans = 'ROYGBIV'
while n:
ans += ans[-4]
n -= 1
stdout.write(ans)
``` | output | 1 | 94,060 | 7 | 188,121 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Easter Rabbit laid n eggs in a circle and is about to paint them.
Each egg should be painted one color out of 7: red, orange, yellow, green, blue, indigo or violet. Also, the following conditions should be satisfied:
* Each of the seven colors should be used to paint at least one egg.
* Any four eggs lying sequentially should be painted different colors.
Help the Easter Rabbit paint the eggs in the required manner. We know that it is always possible.
Input
The only line contains an integer n — the amount of eggs (7 ≤ n ≤ 100).
Output
Print one line consisting of n characters. The i-th character should describe the color of the i-th egg in the order they lie in the circle. The colors should be represented as follows: "R" stands for red, "O" stands for orange, "Y" stands for yellow, "G" stands for green, "B" stands for blue, "I" stands for indigo, "V" stands for violet.
If there are several answers, print any of them.
Examples
Input
8
Output
ROYGRBIV
Input
13
Output
ROYGBIVGBIVYG
Note
The way the eggs will be painted in the first sample is shown on the picture:
<image> | instruction | 0 | 94,061 | 7 | 188,122 |
Tags: constructive algorithms, implementation
Correct Solution:
```
if __name__ == '__main__':
num = int(input().strip())
f_count = num // 7
rem = num % 7
chain = ['ROYGBIV','G','GB','YGB','ROYG','ROYGB','ROYGBI']
if(rem == 0):
print(chain[0] * f_count)
else:
print(chain[0] * f_count + chain[rem])
``` | output | 1 | 94,061 | 7 | 188,123 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Easter Rabbit laid n eggs in a circle and is about to paint them.
Each egg should be painted one color out of 7: red, orange, yellow, green, blue, indigo or violet. Also, the following conditions should be satisfied:
* Each of the seven colors should be used to paint at least one egg.
* Any four eggs lying sequentially should be painted different colors.
Help the Easter Rabbit paint the eggs in the required manner. We know that it is always possible.
Input
The only line contains an integer n — the amount of eggs (7 ≤ n ≤ 100).
Output
Print one line consisting of n characters. The i-th character should describe the color of the i-th egg in the order they lie in the circle. The colors should be represented as follows: "R" stands for red, "O" stands for orange, "Y" stands for yellow, "G" stands for green, "B" stands for blue, "I" stands for indigo, "V" stands for violet.
If there are several answers, print any of them.
Examples
Input
8
Output
ROYGRBIV
Input
13
Output
ROYGBIVGBIVYG
Note
The way the eggs will be painted in the first sample is shown on the picture:
<image> | instruction | 0 | 94,062 | 7 | 188,124 |
Tags: constructive algorithms, implementation
Correct Solution:
```
hat = int(input())
lst = ['R', 'O', 'Y', 'G', 'B', 'I', 'V']
new = ""
if hat == 7:
print("".join(lst))
elif hat == 8:
print("ROYGRBIV")
elif hat == 9:
print("ROYGROBIV")
elif hat == 10:
print("ROYGROYBIV")
else:
new += "".join(lst) * int(hat / 7)
x = 3
for i in range(hat % 7):
if x > 6:
x = 3
new += lst[x]
x += 1
print(new)
``` | output | 1 | 94,062 | 7 | 188,125 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Easter Rabbit laid n eggs in a circle and is about to paint them.
Each egg should be painted one color out of 7: red, orange, yellow, green, blue, indigo or violet. Also, the following conditions should be satisfied:
* Each of the seven colors should be used to paint at least one egg.
* Any four eggs lying sequentially should be painted different colors.
Help the Easter Rabbit paint the eggs in the required manner. We know that it is always possible.
Input
The only line contains an integer n — the amount of eggs (7 ≤ n ≤ 100).
Output
Print one line consisting of n characters. The i-th character should describe the color of the i-th egg in the order they lie in the circle. The colors should be represented as follows: "R" stands for red, "O" stands for orange, "Y" stands for yellow, "G" stands for green, "B" stands for blue, "I" stands for indigo, "V" stands for violet.
If there are several answers, print any of them.
Examples
Input
8
Output
ROYGRBIV
Input
13
Output
ROYGBIVGBIVYG
Note
The way the eggs will be painted in the first sample is shown on the picture:
<image> | instruction | 0 | 94,063 | 7 | 188,126 |
Tags: constructive algorithms, implementation
Correct Solution:
```
n = int(input())
output = []
colors = ["R","O","Y","G","B","I","V"]
temp = 4
for x in range(n):
if x < 7:
output.append(colors[x])
else:
for i in colors:
if i not in output[temp:temp+4]:
if i not in output[0:3]:
output.append(i)
temp +=1
break
print("".join(output))
``` | output | 1 | 94,063 | 7 | 188,127 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Easter Rabbit laid n eggs in a circle and is about to paint them.
Each egg should be painted one color out of 7: red, orange, yellow, green, blue, indigo or violet. Also, the following conditions should be satisfied:
* Each of the seven colors should be used to paint at least one egg.
* Any four eggs lying sequentially should be painted different colors.
Help the Easter Rabbit paint the eggs in the required manner. We know that it is always possible.
Input
The only line contains an integer n — the amount of eggs (7 ≤ n ≤ 100).
Output
Print one line consisting of n characters. The i-th character should describe the color of the i-th egg in the order they lie in the circle. The colors should be represented as follows: "R" stands for red, "O" stands for orange, "Y" stands for yellow, "G" stands for green, "B" stands for blue, "I" stands for indigo, "V" stands for violet.
If there are several answers, print any of them.
Examples
Input
8
Output
ROYGRBIV
Input
13
Output
ROYGBIVGBIVYG
Note
The way the eggs will be painted in the first sample is shown on the picture:
<image> | instruction | 0 | 94,064 | 7 | 188,128 |
Tags: constructive algorithms, implementation
Correct Solution:
```
n = int(input())
colors = "VIBGYOR"
ans = colors + (n-7)//4 * colors[3:] + colors[3:(3+(n-7)%4)]
print(ans)
``` | output | 1 | 94,064 | 7 | 188,129 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Easter Rabbit laid n eggs in a circle and is about to paint them.
Each egg should be painted one color out of 7: red, orange, yellow, green, blue, indigo or violet. Also, the following conditions should be satisfied:
* Each of the seven colors should be used to paint at least one egg.
* Any four eggs lying sequentially should be painted different colors.
Help the Easter Rabbit paint the eggs in the required manner. We know that it is always possible.
Input
The only line contains an integer n — the amount of eggs (7 ≤ n ≤ 100).
Output
Print one line consisting of n characters. The i-th character should describe the color of the i-th egg in the order they lie in the circle. The colors should be represented as follows: "R" stands for red, "O" stands for orange, "Y" stands for yellow, "G" stands for green, "B" stands for blue, "I" stands for indigo, "V" stands for violet.
If there are several answers, print any of them.
Examples
Input
8
Output
ROYGRBIV
Input
13
Output
ROYGBIVGBIVYG
Note
The way the eggs will be painted in the first sample is shown on the picture:
<image> | instruction | 0 | 94,065 | 7 | 188,130 |
Tags: constructive algorithms, implementation
Correct Solution:
```
x=int(input())
n=x-7
s="ROYG"
l=['R','O','Y','G']
i=0
while(n!=0):
s+=l[i]
i+=1
if i>3:
i=0
n-=1
s+='BIV'
print(s)
``` | output | 1 | 94,065 | 7 | 188,131 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.