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.
You are given a grid, consisting of 2 rows and n columns. Each cell of this grid should be colored either black or white.
Two cells are considered neighbours if they have a common border and share the same color. Two cells A and B belong to the same component if they are neighbours, or if there is a neighbour of A that belongs to the same component with B.
Let's call some bicoloring beautiful if it has exactly k components.
Count the number of beautiful bicolorings. The number can be big enough, so print the answer modulo 998244353.
Input
The only line contains two integers n and k (1 ≤ n ≤ 1000, 1 ≤ k ≤ 2n) — the number of columns in a grid and the number of components required.
Output
Print a single integer — the number of beautiful bicolorings modulo 998244353.
Examples
Input
3 4
Output
12
Input
4 1
Output
2
Input
1 2
Output
2
Note
One of possible bicolorings in sample 1:
<image> | instruction | 0 | 21 | 7 | 42 |
Tags: bitmasks, dp
Correct Solution:
```
n,k=map(int,input().split())
same=[0]*(k+1)
diff=[0]*(k+1)
same[1]=2
if k>1:
diff[2]=2
for i in range(n-1):
newsame=[0]*(k+1)
newdiff=[0]*(k+1)
for i in range(1,k+1):
newsame[i]=(same[i]+same[i-1]+2*diff[i])%998244353
for i in range(2,k+1):
newdiff[i]=(2*same[i-1]+diff[i]+diff[i-2])%998244353
same=newsame
diff=newdiff
print((same[-1]+diff[-1])%998244353)
``` | output | 1 | 21 | 7 | 43 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a grid, consisting of 2 rows and n columns. Each cell of this grid should be colored either black or white.
Two cells are considered neighbours if they have a common border and share the same color. Two cells A and B belong to the same component if they are neighbours, or if there is a neighbour of A that belongs to the same component with B.
Let's call some bicoloring beautiful if it has exactly k components.
Count the number of beautiful bicolorings. The number can be big enough, so print the answer modulo 998244353.
Input
The only line contains two integers n and k (1 ≤ n ≤ 1000, 1 ≤ k ≤ 2n) — the number of columns in a grid and the number of components required.
Output
Print a single integer — the number of beautiful bicolorings modulo 998244353.
Examples
Input
3 4
Output
12
Input
4 1
Output
2
Input
1 2
Output
2
Note
One of possible bicolorings in sample 1:
<image> | instruction | 0 | 22 | 7 | 44 |
Tags: bitmasks, dp
Correct Solution:
```
def main():
n, k = map(int, input().split(' '))
if(k > 2*n):
return(0)
if(k == 2*n or k==1):
return(2)
iguales = [0]*(k+1)
diferentes = [0]*(k+1)
iguales[1] = 2
diferentes[2] = 2
modulo = 998244353
for i in range(1, n):
auxigual, auxdiff = [0]*(k+1), [0]*(k+1)
for j in range(k):
auxigual[j+1] = (iguales[j+1] + iguales[j] + 2*diferentes[j+1]) % modulo
if(j >= 1):
auxdiff[j+1] = (diferentes[j+1] + diferentes[j-1] + 2*iguales[j]) % modulo
iguales = auxigual
diferentes = auxdiff
return((iguales[-1] + diferentes[-1]) % modulo)
print(main())
``` | output | 1 | 22 | 7 | 45 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a grid, consisting of 2 rows and n columns. Each cell of this grid should be colored either black or white.
Two cells are considered neighbours if they have a common border and share the same color. Two cells A and B belong to the same component if they are neighbours, or if there is a neighbour of A that belongs to the same component with B.
Let's call some bicoloring beautiful if it has exactly k components.
Count the number of beautiful bicolorings. The number can be big enough, so print the answer modulo 998244353.
Input
The only line contains two integers n and k (1 ≤ n ≤ 1000, 1 ≤ k ≤ 2n) — the number of columns in a grid and the number of components required.
Output
Print a single integer — the number of beautiful bicolorings modulo 998244353.
Examples
Input
3 4
Output
12
Input
4 1
Output
2
Input
1 2
Output
2
Note
One of possible bicolorings in sample 1:
<image> | instruction | 0 | 23 | 7 | 46 |
Tags: bitmasks, dp
Correct Solution:
```
import math,sys,bisect,heapq
from collections import defaultdict,Counter,deque
from itertools import groupby,accumulate
#sys.setrecursionlimit(200000000)
int1 = lambda x: int(x) - 1
input = iter(sys.stdin.buffer.read().decode().splitlines()).__next__
ilele = lambda: map(int,input().split())
alele = lambda: list(map(int, input().split()))
ilelec = lambda: map(int1,input().split())
alelec = lambda: list(map(int1, input().split()))
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
#MOD = 1000000000 + 7
def Y(c): print(["NO","YES"][c])
def y(c): print(["no","yes"][c])
def Yy(c): print(["No","Yes"][c])
MOD = 998244353
N,K = ilele()
if K == 1 or K == 2*N:
print(2)
exit(0)
dp = list3d(N+1,4,K+1,0)
dp[1][0][1] = 1
dp[1][3][1] = 1
dp[1][1][2] = 1
dp[1][2][2] = 1
for n in range(2,N+1):
for k in range(1,K+1):
dp[n][0][k] = ((dp[n-1][0][k]+dp[n-1][1][k])%MOD+(dp[n-1][2][k]+dp[n-1][3][k-1])%MOD)%MOD
dp[n][3][k] = ((dp[n-1][0][k-1]+dp[n-1][1][k])%MOD+(dp[n-1][2][k]+dp[n-1][3][k])%MOD)%MOD
if k > 1:
dp[n][1][k]=((dp[n-1][0][k-1]+dp[n-1][1][k])%MOD+(dp[n-1][2][k-2] +dp[n-1][3][k-1])%MOD)%MOD
dp[n][2][k]=((dp[n-1][0][k-1]+dp[n-1][1][k-2])%MOD+(dp[n-1][2][k]+dp[n-1][3][k-1])%MOD)%MOD
else:
dp[n][1][k]=((dp[n-1][0][k-1]+dp[n-1][1][k])%MOD+(dp[n-1][3][k-1])%MOD)%MOD
dp[n][2][k]=((dp[n-1][0][k-1])%MOD+(dp[n-1][2][k]+dp[n-1][3][k-1])%MOD)%MOD
print(((dp[N][0][K]+dp[N][1][K])%MOD+(dp[N][2][K]+dp[N][3][K])%MOD)%MOD)
``` | output | 1 | 23 | 7 | 47 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a grid, consisting of 2 rows and n columns. Each cell of this grid should be colored either black or white.
Two cells are considered neighbours if they have a common border and share the same color. Two cells A and B belong to the same component if they are neighbours, or if there is a neighbour of A that belongs to the same component with B.
Let's call some bicoloring beautiful if it has exactly k components.
Count the number of beautiful bicolorings. The number can be big enough, so print the answer modulo 998244353.
Input
The only line contains two integers n and k (1 ≤ n ≤ 1000, 1 ≤ k ≤ 2n) — the number of columns in a grid and the number of components required.
Output
Print a single integer — the number of beautiful bicolorings modulo 998244353.
Examples
Input
3 4
Output
12
Input
4 1
Output
2
Input
1 2
Output
2
Note
One of possible bicolorings in sample 1:
<image> | instruction | 0 | 24 | 7 | 48 |
Tags: bitmasks, dp
Correct Solution:
```
n,k = list(map(int,input().split()))
limit = 998244353
if k > 2*n:
print(0)
elif k == 1 or k == 2*n:
print(2)
else:
same = [0] * (k+1)
same[1] = 2
diff = [0] * (k+1)
diff[2] = 2
for i in range(2, n+1):
for j in range(min(k, 2*i), 1, -1):
same[j] = same[j] + 2*diff[j] + same[j-1]
same[j] %= limit
diff[j] = diff[j] + 2*same[j-1] + diff[j-2]
diff[j] %= limit
print((same[k] + diff[k]) % limit)
``` | output | 1 | 24 | 7 | 49 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a grid, consisting of 2 rows and n columns. Each cell of this grid should be colored either black or white.
Two cells are considered neighbours if they have a common border and share the same color. Two cells A and B belong to the same component if they are neighbours, or if there is a neighbour of A that belongs to the same component with B.
Let's call some bicoloring beautiful if it has exactly k components.
Count the number of beautiful bicolorings. The number can be big enough, so print the answer modulo 998244353.
Input
The only line contains two integers n and k (1 ≤ n ≤ 1000, 1 ≤ k ≤ 2n) — the number of columns in a grid and the number of components required.
Output
Print a single integer — the number of beautiful bicolorings modulo 998244353.
Examples
Input
3 4
Output
12
Input
4 1
Output
2
Input
1 2
Output
2
Note
One of possible bicolorings in sample 1:
<image> | instruction | 0 | 25 | 7 | 50 |
Tags: bitmasks, dp
Correct Solution:
```
import sys
input = sys.stdin.readline
import math
import copy
import collections
from collections import deque
import heapq
import itertools
from collections import defaultdict
from collections import Counter
n,k = map(int,input().split())
mod = 998244353
dp = [[[0 for z in range(2)] for j in range(k+1)] for i in range(n)]
# z= 0: bb, 1:bw, 2:wb, 3=ww
dp[0][1][0] = 1
if k>=2:
dp[0][2][1] = 1
for i in range(1,n):
for j in range(1,k+1):
dp[i][j][0] += dp[i-1][j-1][0]+dp[i-1][j][0]+2*dp[i-1][j][1]
dp[i][j][0]%=mod
if j-2>=0:
dp[i][j][1] += 2*dp[i-1][j-1][0]+dp[i-1][j][1]+dp[i-1][j-2][1]
else:
dp[i][j][1] += dp[i-1][j-1][0]+dp[i-1][j][1]+dp[i][j-1][0]
dp[i][j][1]%=mod
ans = 0
for z in range(2):
ans+=dp[n-1][k][z]
ans*=2
print(ans%mod)
# for row in dp:
# print(row)
``` | output | 1 | 25 | 7 | 51 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a grid, consisting of 2 rows and n columns. Each cell of this grid should be colored either black or white.
Two cells are considered neighbours if they have a common border and share the same color. Two cells A and B belong to the same component if they are neighbours, or if there is a neighbour of A that belongs to the same component with B.
Let's call some bicoloring beautiful if it has exactly k components.
Count the number of beautiful bicolorings. The number can be big enough, so print the answer modulo 998244353.
Input
The only line contains two integers n and k (1 ≤ n ≤ 1000, 1 ≤ k ≤ 2n) — the number of columns in a grid and the number of components required.
Output
Print a single integer — the number of beautiful bicolorings modulo 998244353.
Examples
Input
3 4
Output
12
Input
4 1
Output
2
Input
1 2
Output
2
Note
One of possible bicolorings in sample 1:
<image> | instruction | 0 | 26 | 7 | 52 |
Tags: bitmasks, dp
Correct Solution:
```
n,k = [int(x) for x in input().split()]
dp = [[[0 for _ in range(4)] for _ in range(k+2)] for _ in range(2)]
dp[1][2][0] = 1
dp[1][2][1] = 1
dp[1][1][2] = 1
dp[1][1][3] = 1
for n1 in range(1,n):
for k1 in range(1,k+1):
dp[0][k1][0] = dp[1][k1][0]
dp[0][k1][1] = dp[1][k1][1]
dp[0][k1][2] = dp[1][k1][2]
dp[0][k1][3] = dp[1][k1][3]
dp[1][k1][0] = (dp[0][k1][0] + (dp[0][k1-2][1] if k1-2>=0 else 0) + dp[0][k1-1][2] + dp[0][k1-1][3])% 998244353
dp[1][k1][1] = (dp[0][k1][1] + (dp[0][k1-2][0] if k1-2>=0 else 0) + dp[0][k1-1][2] + dp[0][k1-1][3])% 998244353
dp[1][k1][2] = (dp[0][k1][2] + (dp[0][k1][1]) + dp[0][k1][0] + dp[0][k1-1][3])% 998244353
dp[1][k1][3] = (dp[0][k1][3] + (dp[0][k1][1]) + dp[0][k1][0] + dp[0][k1-1][2])% 998244353
total = 0
#print(dp)
for i in range(4):
total += dp[1][k][i] % 998244353
#print(dp)
print(total% 998244353 )
``` | output | 1 | 26 | 7 | 53 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a grid, consisting of 2 rows and n columns. Each cell of this grid should be colored either black or white.
Two cells are considered neighbours if they have a common border and share the same color. Two cells A and B belong to the same component if they are neighbours, or if there is a neighbour of A that belongs to the same component with B.
Let's call some bicoloring beautiful if it has exactly k components.
Count the number of beautiful bicolorings. The number can be big enough, so print the answer modulo 998244353.
Input
The only line contains two integers n and k (1 ≤ n ≤ 1000, 1 ≤ k ≤ 2n) — the number of columns in a grid and the number of components required.
Output
Print a single integer — the number of beautiful bicolorings modulo 998244353.
Examples
Input
3 4
Output
12
Input
4 1
Output
2
Input
1 2
Output
2
Note
One of possible bicolorings in sample 1:
<image> | instruction | 0 | 27 | 7 | 54 |
Tags: bitmasks, dp
Correct 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().rstrip("\r\n")
# ------------------------------
from math import factorial
from collections import Counter, defaultdict
from heapq import heapify, heappop, heappush
def RL(): return map(int, sys.stdin.readline().rstrip().split())
def RLL(): return list(map(int, sys.stdin.readline().rstrip().split()))
def N(): return int(input())
def comb(n, m): return factorial(n) / (factorial(m) * factorial(n - m)) if n >= m else 0
def perm(n, m): return factorial(n) // (factorial(n - m)) if n >= m else 0
def mdis(x1, y1, x2, y2): return abs(x1 - x2) + abs(y1 - y2)
mod = 998244353
INF = float('inf')
# ------------------------------
def main():
n, k = RLL()
dp = [[0]*4 for _ in range(k+2)]
dp[1][0] = 1
dp[1][3] = 1
dp[2][1] = 1
dp[2][2] = 1
for i in range(2, n+1):
new = [[0]*4 for _ in range(k+2)]
for j in range(1, k+2):
for l in range(4):
new[j][l] += dp[j][l]
if l==0 or l==3:
new[j][l]+=dp[j-1][l^3]
new[j][l]+=(dp[j][1]+dp[j][2])
elif l==1 or l==2:
new[j][l]+=(dp[j-1][0]+dp[j-1][3])
if j-2>=0: new[j][l]+=dp[j-2][l^3]
new[j][l] = new[j][l]%mod
dp = new
print(sum(dp[k])%mod)
if __name__ == "__main__":
main()
``` | output | 1 | 27 | 7 | 55 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a grid, consisting of 2 rows and n columns. Each cell of this grid should be colored either black or white.
Two cells are considered neighbours if they have a common border and share the same color. Two cells A and B belong to the same component if they are neighbours, or if there is a neighbour of A that belongs to the same component with B.
Let's call some bicoloring beautiful if it has exactly k components.
Count the number of beautiful bicolorings. The number can be big enough, so print the answer modulo 998244353.
Input
The only line contains two integers n and k (1 ≤ n ≤ 1000, 1 ≤ k ≤ 2n) — the number of columns in a grid and the number of components required.
Output
Print a single integer — the number of beautiful bicolorings modulo 998244353.
Examples
Input
3 4
Output
12
Input
4 1
Output
2
Input
1 2
Output
2
Note
One of possible bicolorings in sample 1:
<image> | instruction | 0 | 28 | 7 | 56 |
Tags: bitmasks, dp
Correct Solution:
```
#Code by Sounak, IIESTS
#------------------------------warmup----------------------------
import os
import sys
import math
from io import BytesIO, IOBase
from fractions import Fraction
from collections import defaultdict
from itertools import permutations
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")
#-------------------game starts now-----------------------------------------------------
n,k=map(int,sys.stdin.readline().split())
mod=998244353
dp=[[0,0,0,0] for x in range(k+3)]
dp[1][0]=1
dp[1][1]=1
dp[2][2]=1
dp[2][3]=1
newdp=[[0,0,0,0] for x in range(k+3)]
for i in range(n-1):
for j in range(k+1):
newdp[j+1][1]+=dp[j][0]
newdp[j+1][3]+=dp[j][0]
newdp[j+1][2]+=dp[j][0]
newdp[j][0]+=dp[j][0]
newdp[j][1]+=dp[j][1]
newdp[j+1][3]+=dp[j][1]
newdp[j+1][2]+=dp[j][1]
newdp[j+1][0]+=dp[j][1]
newdp[j][1]+=dp[j][2]
newdp[j+2][3]+=dp[j][2]
newdp[j][2]+=dp[j][2]
newdp[j][0]+=dp[j][2]
newdp[j][1]+=dp[j][3]
newdp[j][3]+=dp[j][3]
newdp[j+2][2]+=dp[j][3]
newdp[j][0]+=dp[j][3]
for a in range(3):
for b in range(4):
newdp[a+j][b]%=mod
for a in range(k+3):
for b in range(4):
dp[a][b]=newdp[a][b]
newdp[a][b]=0
ans=sum(dp[k])
ans%=mod
print(ans)
``` | output | 1 | 28 | 7 | 57 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a grid, consisting of 2 rows and n columns. Each cell of this grid should be colored either black or white.
Two cells are considered neighbours if they have a common border and share the same color. Two cells A and B belong to the same component if they are neighbours, or if there is a neighbour of A that belongs to the same component with B.
Let's call some bicoloring beautiful if it has exactly k components.
Count the number of beautiful bicolorings. The number can be big enough, so print the answer modulo 998244353.
Input
The only line contains two integers n and k (1 ≤ n ≤ 1000, 1 ≤ k ≤ 2n) — the number of columns in a grid and the number of components required.
Output
Print a single integer — the number of beautiful bicolorings modulo 998244353.
Examples
Input
3 4
Output
12
Input
4 1
Output
2
Input
1 2
Output
2
Note
One of possible bicolorings in sample 1:
<image>
Submitted Solution:
```
n,k=map(int,input().split())
mod=998244353
dp=[[0,0,0,0] for _ in range(k+1)]
#dp[0][0]=dp[0][1]=dp[0][2]=dp[0][3]=
dp[1][0]=dp[1][3]=1
if k>1:
dp[2][2]=dp[2][1]=1
for x in range(1,n):
g=[[0,0,0,0] for _ in range(k+1)]
# 0 - bb
# 1 - bw
# 2 - wb
# 3 - ww
g[1][0]=g[1][3]=1
for i in range(2,k+1):
g[i][0]=(dp[i][0]+dp[i][1]+dp[i][2]+dp[i-1][3])%mod
g[i][1]=(dp[i-1][0]+dp[i][1]+dp[i-2][2]+dp[i-1][3])%mod
g[i][2]=(dp[i-1][0]+dp[i-2][1]+dp[i][2]+dp[i-1][3])%mod
g[i][3]=(dp[i-1][0]+dp[i][1]+dp[i][2]+dp[i][3])%mod
dp=g
print(sum(dp[-1])%mod)
``` | instruction | 0 | 29 | 7 | 58 |
Yes | output | 1 | 29 | 7 | 59 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a grid, consisting of 2 rows and n columns. Each cell of this grid should be colored either black or white.
Two cells are considered neighbours if they have a common border and share the same color. Two cells A and B belong to the same component if they are neighbours, or if there is a neighbour of A that belongs to the same component with B.
Let's call some bicoloring beautiful if it has exactly k components.
Count the number of beautiful bicolorings. The number can be big enough, so print the answer modulo 998244353.
Input
The only line contains two integers n and k (1 ≤ n ≤ 1000, 1 ≤ k ≤ 2n) — the number of columns in a grid and the number of components required.
Output
Print a single integer — the number of beautiful bicolorings modulo 998244353.
Examples
Input
3 4
Output
12
Input
4 1
Output
2
Input
1 2
Output
2
Note
One of possible bicolorings in sample 1:
<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().rstrip("\r\n")
# ------------------------------
from math import factorial
from collections import Counter, defaultdict
from heapq import heapify, heappop, heappush
def RL(): return map(int, sys.stdin.readline().rstrip().split())
def RLL(): return list(map(int, sys.stdin.readline().rstrip().split()))
def N(): return int(input())
def comb(n, m): return factorial(n) / (factorial(m) * factorial(n - m)) if n >= m else 0
def perm(n, m): return factorial(n) // (factorial(n - m)) if n >= m else 0
def mdis(x1, y1, x2, y2): return abs(x1 - x2) + abs(y1 - y2)
mod = 998244353
INF = float('inf')
# ------------------------------
def main():
n, k = RLL()
dp = [[0]*4 for _ in range(k+2)]
dp[1][0] = 1
dp[1][3] = 1
dp[2][1] = 1
dp[2][2] = 1
tag = 0
for i in range(2, n+1):
new = [[0]*4 for _ in range(k+2)]
for j in range(1, k+2):
for l in range(4):
tag+=1
new[j][l] = ((dp[j][l])%mod + (new[j][l])%mod)%mod
if l==0 or l==3:
new[j][l] = ((dp[j-1][l^3])%mod + (new[j][l])%mod)%mod
new[j][l] = (((dp[j][1])%mod+(dp[j][2])%mod) + (new[j][l])%mod)%mod
elif l==1 or l==2:
new[j][l] = (((dp[j-1][0])%mod+(dp[j-1][3])%mod) + (new[j][l])%mod)%mod
if j-2>=0: new[j][l] = ((dp[j-2][l^3])%mod + (new[j][l])%mod)%mod
dp = new
print(sum(dp[k])%mod)
if __name__ == "__main__":
main()
``` | instruction | 0 | 30 | 7 | 60 |
Yes | output | 1 | 30 | 7 | 61 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a grid, consisting of 2 rows and n columns. Each cell of this grid should be colored either black or white.
Two cells are considered neighbours if they have a common border and share the same color. Two cells A and B belong to the same component if they are neighbours, or if there is a neighbour of A that belongs to the same component with B.
Let's call some bicoloring beautiful if it has exactly k components.
Count the number of beautiful bicolorings. The number can be big enough, so print the answer modulo 998244353.
Input
The only line contains two integers n and k (1 ≤ n ≤ 1000, 1 ≤ k ≤ 2n) — the number of columns in a grid and the number of components required.
Output
Print a single integer — the number of beautiful bicolorings modulo 998244353.
Examples
Input
3 4
Output
12
Input
4 1
Output
2
Input
1 2
Output
2
Note
One of possible bicolorings in sample 1:
<image>
Submitted Solution:
```
n, k = map(int, input().split())
same = [0] * (k + 1)
diff = [0] * (k + 1)
mod = 998244353
same[1] = 2
if k > 1 : diff[2] = 2
for i in range (n - 1) :
newsame = [0] * (k + 1)
newdiff = [0] * (k + 1)
for i in range (1, k + 1) : newsame[i] = (same[i] + same[i - 1] + 2 * diff[i]) % mod
for i in range (2, k + 1) : newdiff[i] = (2 * same[i - 1] + diff[i] + diff[i - 2]) % mod
same = newsame ; diff = newdiff
print((same[-1] + diff[-1]) % mod)
``` | instruction | 0 | 31 | 7 | 62 |
Yes | output | 1 | 31 | 7 | 63 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a grid, consisting of 2 rows and n columns. Each cell of this grid should be colored either black or white.
Two cells are considered neighbours if they have a common border and share the same color. Two cells A and B belong to the same component if they are neighbours, or if there is a neighbour of A that belongs to the same component with B.
Let's call some bicoloring beautiful if it has exactly k components.
Count the number of beautiful bicolorings. The number can be big enough, so print the answer modulo 998244353.
Input
The only line contains two integers n and k (1 ≤ n ≤ 1000, 1 ≤ k ≤ 2n) — the number of columns in a grid and the number of components required.
Output
Print a single integer — the number of beautiful bicolorings modulo 998244353.
Examples
Input
3 4
Output
12
Input
4 1
Output
2
Input
1 2
Output
2
Note
One of possible bicolorings in sample 1:
<image>
Submitted Solution:
```
import sys
import math
from collections import defaultdict,deque
import heapq
n,k=map(int,sys.stdin.readline().split())
mod=998244353
dp=[[0,0,0,0] for x in range(k+3)]
dp[1][0]=1
dp[1][1]=1
dp[2][2]=1
dp[2][3]=1
newdp=[[0,0,0,0] for x in range(k+3)]
for i in range(n-1):
for j in range(k+1):
newdp[j+1][1]+=dp[j][0]
newdp[j+1][3]+=dp[j][0]
newdp[j+1][2]+=dp[j][0]
newdp[j][0]+=dp[j][0]
newdp[j][1]+=dp[j][1]
newdp[j+1][3]+=dp[j][1]
newdp[j+1][2]+=dp[j][1]
newdp[j+1][0]+=dp[j][1]
newdp[j][1]+=dp[j][2]
newdp[j+2][3]+=dp[j][2]
newdp[j][2]+=dp[j][2]
newdp[j][0]+=dp[j][2]
newdp[j][1]+=dp[j][3]
newdp[j][3]+=dp[j][3]
newdp[j+2][2]+=dp[j][3]
newdp[j][0]+=dp[j][3]
'''dp[i+1][j][0]+=dp[i][j][0]
dp[i+1][j][1]+=dp[i][j][1]
dp[i+1][j][2]+=dp[i][j][2]
dp[i+1][j][3]+=dp[i][j][3]
dp[i+1][j+1][0]+=dp[i][j][2]+dp[i][j][3]
dp[i+1][j+1][1]+=dp[i][j][2]+dp[i][j][3]
dp[i+1][j+1][2]+=dp[i][j][0]+dp[i][j][1]
dp[i+1][j+1][3]+=dp[i][j][0]+dp[i][j][1]
dp[i+1][j+2][2]+=dp[i][j][3]
dp[i+1][j+2][3]+=dp[i][j][2]'''
for a in range(3):
for b in range(4):
newdp[a+j][b]%=mod
for a in range(k+3):
for b in range(4):
dp[a][b]=newdp[a][b]
newdp[a][b]=0
#print(dp,'dp')
'''for i in range(n):
print(dp[i])'''
#ans=0
#print(dp,'dp')
ans=sum(dp[k])
ans%=mod
print(ans)
``` | instruction | 0 | 32 | 7 | 64 |
Yes | output | 1 | 32 | 7 | 65 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a grid, consisting of 2 rows and n columns. Each cell of this grid should be colored either black or white.
Two cells are considered neighbours if they have a common border and share the same color. Two cells A and B belong to the same component if they are neighbours, or if there is a neighbour of A that belongs to the same component with B.
Let's call some bicoloring beautiful if it has exactly k components.
Count the number of beautiful bicolorings. The number can be big enough, so print the answer modulo 998244353.
Input
The only line contains two integers n and k (1 ≤ n ≤ 1000, 1 ≤ k ≤ 2n) — the number of columns in a grid and the number of components required.
Output
Print a single integer — the number of beautiful bicolorings modulo 998244353.
Examples
Input
3 4
Output
12
Input
4 1
Output
2
Input
1 2
Output
2
Note
One of possible bicolorings in sample 1:
<image>
Submitted Solution:
```
#0 denotes white white
#1 denotes white black
#2 denotes black white
#3 denotes black black
pri=998244353
dp=[[[0 for i in range(2005)] for i in range(1005)] for i in range(2)]
n,k=map(int,input().split())
#dp[i][j][k] i denotes type j denotes index k denotes bycoloring
for i in range(1,n+1):
if(i==1):
dp[0][i][1]=2
dp[1][i][2]=2
continue;
for j in range(1,(2*i)+1):
dp[0][i][j]=dp[0][i-1][j]//2+((dp[0][i-1][j-1])//2)+(dp[1][i-1][j])
dp[0][i][j]*=2
dp[1][i][j]=dp[0][i-1][j-1]+(dp[1][i-1][j]//2)+(dp[1][i-1][j-2]//2)
dp[1][i][j]*=2
dp[0][i][j]%=pri
dp[1][i][j]%=pri
y=dp[0][n][k]+dp[1][n][k]
y%=pri
print(y)
``` | instruction | 0 | 33 | 7 | 66 |
No | output | 1 | 33 | 7 | 67 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a grid, consisting of 2 rows and n columns. Each cell of this grid should be colored either black or white.
Two cells are considered neighbours if they have a common border and share the same color. Two cells A and B belong to the same component if they are neighbours, or if there is a neighbour of A that belongs to the same component with B.
Let's call some bicoloring beautiful if it has exactly k components.
Count the number of beautiful bicolorings. The number can be big enough, so print the answer modulo 998244353.
Input
The only line contains two integers n and k (1 ≤ n ≤ 1000, 1 ≤ k ≤ 2n) — the number of columns in a grid and the number of components required.
Output
Print a single integer — the number of beautiful bicolorings modulo 998244353.
Examples
Input
3 4
Output
12
Input
4 1
Output
2
Input
1 2
Output
2
Note
One of possible bicolorings in sample 1:
<image>
Submitted Solution:
```
import math,sys,bisect,heapq
from collections import defaultdict,Counter,deque
from itertools import groupby,accumulate
#sys.setrecursionlimit(200000000)
int1 = lambda x: int(x) - 1
input = iter(sys.stdin.buffer.read().decode().splitlines()).__next__
ilele = lambda: map(int,input().split())
alele = lambda: list(map(int, input().split()))
ilelec = lambda: map(int1,input().split())
alelec = lambda: list(map(int1, input().split()))
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
#MOD = 1000000000 + 7
def Y(c): print(["NO","YES"][c])
def y(c): print(["no","yes"][c])
def Yy(c): print(["No","Yes"][c])
MOD = 998244353
N,K = ilele()
if K == 1 or K == 2*N:
print(2)
exit(0)
dp = list3d(N+1,4,K+1,0)
dp[1][0][1] = 1
dp[1][3][1] = 1
dp[1][1][2] = 1
dp[1][2][2] = 1
for n in range(2,N+1):
for k in range(1,K+1):
dp[n][0][k] = ((dp[n-1][0][k]+dp[n-1][1][k])%MOD+(dp[n-1][2][k]+dp[n-1][3][k-1])%MOD)%MOD
dp[n][3][k] = ((dp[n-1][0][k-1]+dp[n-1][1][k])%MOD+(dp[n-1][2][k]+dp[n-1][3][k])%MOD)%MOD
if k > 1:
dp[n][1][k]=((dp[n-1][0][k-1]+dp[n-1][1][k])%MOD+(dp[n-1][2][k-2] +dp[n-1][3][k-1])%MOD)%MOD
dp[n][2][k]=((dp[n-1][0][k-1]+dp[n-1][1][k-2])%MOD+(dp[n-1][2][k]+dp[n-1][3][k-1])%MOD)%MOD
else:
dp[n][1][k]=((dp[n-1][0][k-1])%MOD+(dp[n-1][2][k-2] +dp[n-1][3][k-1])%MOD)%MOD
dp[n][2][k]=((dp[n-1][0][k-1]+dp[n-1][1][k-2])%MOD+(dp[n-1][3][k-1])%MOD)%MOD
print(((dp[N][0][K]+dp[N][1][K])%MOD+(dp[N][2][K]+dp[N][3][K])%MOD)%MOD)
``` | instruction | 0 | 34 | 7 | 68 |
No | output | 1 | 34 | 7 | 69 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a grid, consisting of 2 rows and n columns. Each cell of this grid should be colored either black or white.
Two cells are considered neighbours if they have a common border and share the same color. Two cells A and B belong to the same component if they are neighbours, or if there is a neighbour of A that belongs to the same component with B.
Let's call some bicoloring beautiful if it has exactly k components.
Count the number of beautiful bicolorings. The number can be big enough, so print the answer modulo 998244353.
Input
The only line contains two integers n and k (1 ≤ n ≤ 1000, 1 ≤ k ≤ 2n) — the number of columns in a grid and the number of components required.
Output
Print a single integer — the number of beautiful bicolorings modulo 998244353.
Examples
Input
3 4
Output
12
Input
4 1
Output
2
Input
1 2
Output
2
Note
One of possible bicolorings in sample 1:
<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().rstrip("\r\n")
# ------------------------------
from math import factorial
from collections import Counter, defaultdict
from heapq import heapify, heappop, heappush
def RL(): return map(int, sys.stdin.readline().rstrip().split())
def RLL(): return list(map(int, sys.stdin.readline().rstrip().split()))
def N(): return int(input())
def comb(n, m): return factorial(n) / (factorial(m) * factorial(n - m)) if n >= m else 0
def perm(n, m): return factorial(n) // (factorial(n - m)) if n >= m else 0
def mdis(x1, y1, x2, y2): return abs(x1 - x2) + abs(y1 - y2)
mod = 998244353
INF = float('inf')
# ------------------------------
def main():
n, k = RLL()
dp = [[[0]*4 for _ in range(k+2)] for _ in range(n+1)]
dp[1][1][0] = 1
dp[1][1][3] = 1
dp[1][2][1] = 1
dp[1][2][2] = 1
for i in range(2, n+1):
for j in range(1, k+2):
for l in range(4):
dp[i][j][l] += dp[i - 1][j][l]
if (j-1>=0) and l==0 or l==3:
dp[i][j][l]+=dp[i-1][j-1][l^3]
dp[i][j][l]+=(dp[i-1][j-1][1]+dp[i-1][j-1][2])
else:
if j-1>=0: dp[i][j][l]+=(dp[i-1][j-1][0]+dp[i-1][j-1][3])
# if j-2>=0: dp[i][j][l]+=dp[i-1][j-2][l^3]
# for i in dp: print(i)
print(sum(dp[n][k])%mod)
if __name__ == "__main__":
main()
``` | instruction | 0 | 35 | 7 | 70 |
No | output | 1 | 35 | 7 | 71 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a grid, consisting of 2 rows and n columns. Each cell of this grid should be colored either black or white.
Two cells are considered neighbours if they have a common border and share the same color. Two cells A and B belong to the same component if they are neighbours, or if there is a neighbour of A that belongs to the same component with B.
Let's call some bicoloring beautiful if it has exactly k components.
Count the number of beautiful bicolorings. The number can be big enough, so print the answer modulo 998244353.
Input
The only line contains two integers n and k (1 ≤ n ≤ 1000, 1 ≤ k ≤ 2n) — the number of columns in a grid and the number of components required.
Output
Print a single integer — the number of beautiful bicolorings modulo 998244353.
Examples
Input
3 4
Output
12
Input
4 1
Output
2
Input
1 2
Output
2
Note
One of possible bicolorings in sample 1:
<image>
Submitted Solution:
```
a,b = map(int,input().split())
dp = [[0 for i in range(4*b)] for u in range(a)]
dp[0][0] = 1
if b != 1:
dp[0][5] = 1
dp[0][6] = 1
dp[0][3] = 1
we = 4*b
for i in range(0,a-1):
for u in range(0,we,4):
dp[i+1][u+1] += dp[i][u+1]
dp[i+1][u] += dp[i][u]
dp[i+1][u+2] += dp[i][u+2]
dp[i+1][u+3] += dp[i][u+3]
dp[i+1][u] += dp[i][u+1]
dp[i+1][u] += dp[i][u+2]
dp[i+1][u+3] += dp[i][u+1]
dp[i+1][u+3] += dp[i][u+2]
dp[i+1][u] %= 998244353
dp[i+1][u+3] %= 998244353
dp[i+1][u+2] %= 998244353
dp[i+1][u+1] %= 998244353
if u != we-8 and u != we-4:
dp[i+1][u+9] += dp[i][u+2]
dp[i+1][u+9] %= 998244353
dp[i+1][u+10] += dp[i][u+1]
dp[i+1][u+10] %= 998244353
if u != we-4:
dp[i+1][u+5] += dp[i][u]
dp[i+1][u+5] += dp[i][u+3]
dp[i+1][u+5] %= 998244353
dp[i+1][u+6] += dp[i][u+3]
dp[i+1][u+6] += dp[i][u]
dp[i+1][u+6] %= 998244353
dp[i+1][u+4] += dp[i][u+3]
dp[i+1][u+4] %= 998244353
dp[i+1][u+7] += dp[i][u]
dp[i+1][u+7] %= 998244353
print(sum(dp[-1][4*b-4::]) % 998244353)
``` | instruction | 0 | 36 | 7 | 72 |
No | output | 1 | 36 | 7 | 73 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bill likes to play with dominoes. He took an n × m board divided into equal square cells, and covered it with dominoes. Each domino covers two adjacent cells of the board either horizontally or vertically, and each cell is covered exactly once with a half of one domino (that is, there are no uncovered cells, and no two dominoes cover the same cell twice).
After that Bill decided to play with the covered board and share some photos of it on social media. First, he removes exactly one domino from the board, freeing two of the cells. Next, he moves dominoes around. A domino can only be moved along the line parallel to its longer side. A move in the chosen direction is possible if the next cell in this direction is currently free. Bill doesn't want to lose track of what the original tiling looks like, so he makes sure that at any point each domino shares at least one cell with its original position.
After removing a domino and making several (possibly, zero) moves Bill takes a photo of the board and posts it. However, with the amount of filters Bill is using, domino borders are not visible, so only the two free cells of the board can be identified. When the photo is posted, Bill reverts the board to its original state and starts the process again.
Bill wants to post as many photos as possible, but he will not post any photo twice. How many distinct photos can he take? Recall that photos are different if the pairs of free cells in the photos are different.
Input
The first line contains two positive integers n and m (nm ≤ 2 ⋅ 10^5) — height and width of the board respectively.
The next n lines describe the tiling of the board, row by row from top to bottom. Each of these lines contains m characters, describing the cells in the corresponding row left to right. Each character is one of U, D, L, or R, meaning that the cell is covered with a top, bottom, left, or right half of a domino respectively.
It is guaranteed that the described tiling is valid, that is, each half-domino has a counterpart in the relevant location. In particular, since tiling is possible, the number of cells in the board is even.
Output
Print a single integer — the number of distinct photos Bill can take.
Examples
Input
2 4
UUUU
DDDD
Output
4
Input
2 3
ULR
DLR
Output
6
Input
6 6
ULRUUU
DUUDDD
UDDLRU
DLRLRD
ULRULR
DLRDLR
Output
133
Note
In the first sample case, no moves are possible after removing any domino, thus there are four distinct photos.
In the second sample case, four photos are possible after removing the leftmost domino by independently moving/not moving the remaining two dominoes. Two more different photos are obtained by removing one of the dominoes on the right.
Submitted Solution:
```
print('hahah')
``` | instruction | 0 | 178 | 7 | 356 |
No | output | 1 | 178 | 7 | 357 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel has some flowers: r red flowers, g green flowers and b blue flowers. She wants to use these flowers to make several bouquets. There are 4 types of bouquets:
* To make a "red bouquet", it needs 3 red flowers.
* To make a "green bouquet", it needs 3 green flowers.
* To make a "blue bouquet", it needs 3 blue flowers.
* To make a "mixing bouquet", it needs 1 red, 1 green and 1 blue flower.
Help Fox Ciel to find the maximal number of bouquets she can make.
Input
The first line contains three integers r, g and b (0 ≤ r, g, b ≤ 109) — the number of red, green and blue flowers.
Output
Print the maximal number of bouquets Fox Ciel can make.
Examples
Input
3 6 9
Output
6
Input
4 4 4
Output
4
Input
0 0 0
Output
0
Note
In test case 1, we can make 1 red bouquet, 2 green bouquets and 3 blue bouquets.
In test case 2, we can make 1 red, 1 green, 1 blue and 1 mixing bouquet. | instruction | 0 | 302 | 7 | 604 |
Tags: combinatorics, math
Correct Solution:
```
a,b,c=map(int,input().split())
x=a//3+b//3+c//3+min(a%3,b%3,c%3)
y=min(a,b,c)
if ((a-y+1)%3==0 and ((b-y+1)%3==0) and c!=0)or ((a-y+1)%3==0 and (c-y+1)%3==0 and b!=0) or ((b-y+1)%3==0 and (c-y+1)%3==0 and a!=0):
a-=(y-1)
b-=(y-1)
c-=(y-1)
#print(a,b,c)
y+=(-1+(a//3+b//3+c//3))
else:
a-=y
b-=y
c-=y
y+=(a//3+b//3+c//3)
print(max(y,x))
#print(y)
``` | output | 1 | 302 | 7 | 605 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel has some flowers: r red flowers, g green flowers and b blue flowers. She wants to use these flowers to make several bouquets. There are 4 types of bouquets:
* To make a "red bouquet", it needs 3 red flowers.
* To make a "green bouquet", it needs 3 green flowers.
* To make a "blue bouquet", it needs 3 blue flowers.
* To make a "mixing bouquet", it needs 1 red, 1 green and 1 blue flower.
Help Fox Ciel to find the maximal number of bouquets she can make.
Input
The first line contains three integers r, g and b (0 ≤ r, g, b ≤ 109) — the number of red, green and blue flowers.
Output
Print the maximal number of bouquets Fox Ciel can make.
Examples
Input
3 6 9
Output
6
Input
4 4 4
Output
4
Input
0 0 0
Output
0
Note
In test case 1, we can make 1 red bouquet, 2 green bouquets and 3 blue bouquets.
In test case 2, we can make 1 red, 1 green, 1 blue and 1 mixing bouquet. | instruction | 0 | 303 | 7 | 606 |
Tags: combinatorics, math
Correct Solution:
```
def ciel_flowers(a,b,c):
red=a//3
green=b//3
blue=c//3
total=red+green+blue
remain=[a%3 , b%3 , c%3]
ideal=[0,2,2]
if sorted(remain)==ideal and 0 not in [a,b,c]:
print(total+1)
else:
print(total+min(remain))
a,b,c=list(map(int,input().split()))
ciel_flowers(a,b,c)
``` | output | 1 | 303 | 7 | 607 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel has some flowers: r red flowers, g green flowers and b blue flowers. She wants to use these flowers to make several bouquets. There are 4 types of bouquets:
* To make a "red bouquet", it needs 3 red flowers.
* To make a "green bouquet", it needs 3 green flowers.
* To make a "blue bouquet", it needs 3 blue flowers.
* To make a "mixing bouquet", it needs 1 red, 1 green and 1 blue flower.
Help Fox Ciel to find the maximal number of bouquets she can make.
Input
The first line contains three integers r, g and b (0 ≤ r, g, b ≤ 109) — the number of red, green and blue flowers.
Output
Print the maximal number of bouquets Fox Ciel can make.
Examples
Input
3 6 9
Output
6
Input
4 4 4
Output
4
Input
0 0 0
Output
0
Note
In test case 1, we can make 1 red bouquet, 2 green bouquets and 3 blue bouquets.
In test case 2, we can make 1 red, 1 green, 1 blue and 1 mixing bouquet. | instruction | 0 | 304 | 7 | 608 |
Tags: combinatorics, math
Correct Solution:
```
r,g,b = map(int,input().split())
print (max(i+(r-i)//3+(g-i)//3+(b-i)//3 for i in range(min(r+1,g+1,b+1,3))))
# Made By Mostafa_Khaled
``` | output | 1 | 304 | 7 | 609 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel has some flowers: r red flowers, g green flowers and b blue flowers. She wants to use these flowers to make several bouquets. There are 4 types of bouquets:
* To make a "red bouquet", it needs 3 red flowers.
* To make a "green bouquet", it needs 3 green flowers.
* To make a "blue bouquet", it needs 3 blue flowers.
* To make a "mixing bouquet", it needs 1 red, 1 green and 1 blue flower.
Help Fox Ciel to find the maximal number of bouquets she can make.
Input
The first line contains three integers r, g and b (0 ≤ r, g, b ≤ 109) — the number of red, green and blue flowers.
Output
Print the maximal number of bouquets Fox Ciel can make.
Examples
Input
3 6 9
Output
6
Input
4 4 4
Output
4
Input
0 0 0
Output
0
Note
In test case 1, we can make 1 red bouquet, 2 green bouquets and 3 blue bouquets.
In test case 2, we can make 1 red, 1 green, 1 blue and 1 mixing bouquet. | instruction | 0 | 305 | 7 | 610 |
Tags: combinatorics, math
Correct Solution:
```
r,g,b = map(int, input().split())
ans = r//3 + g//3 + b//3
y = (r-1)//3 + (g-1)//3 + (b-1)//3
if r > 0 and g > 0 and b > 0:
ans = max(ans, (r-1)//3 + (g-1)//3 + (b-1)//3 + 1)
if r > 1 and g > 1 and b > 1:
ans = max(ans, (r-2)//3 + (g-2)//3 + (b-2)//3 + 2)
print(ans)
``` | output | 1 | 305 | 7 | 611 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel has some flowers: r red flowers, g green flowers and b blue flowers. She wants to use these flowers to make several bouquets. There are 4 types of bouquets:
* To make a "red bouquet", it needs 3 red flowers.
* To make a "green bouquet", it needs 3 green flowers.
* To make a "blue bouquet", it needs 3 blue flowers.
* To make a "mixing bouquet", it needs 1 red, 1 green and 1 blue flower.
Help Fox Ciel to find the maximal number of bouquets she can make.
Input
The first line contains three integers r, g and b (0 ≤ r, g, b ≤ 109) — the number of red, green and blue flowers.
Output
Print the maximal number of bouquets Fox Ciel can make.
Examples
Input
3 6 9
Output
6
Input
4 4 4
Output
4
Input
0 0 0
Output
0
Note
In test case 1, we can make 1 red bouquet, 2 green bouquets and 3 blue bouquets.
In test case 2, we can make 1 red, 1 green, 1 blue and 1 mixing bouquet. | instruction | 0 | 306 | 7 | 612 |
Tags: combinatorics, math
Correct Solution:
```
r,g,b=map(int,input().split())
k=min(r,g,b)
t1=(r//3)+(g//3)+(b//3)+min(r%3,g%3,b%3)
t2=(r//3)+(g//3)
p=min(r%3,g%3,b)
t2=t2+p+(b-p)//3
t3=(r//3)+(b//3)
p=min(r%3,b%3,g)
t3=t3+p+(g-p)//3
t4=(b//3)+(g//3)
p=min(b%3,g%3,r)
t4=t4+p+(r-p)//3
t5=(r//3)
p=min(r%3,g,b)
t5=t5+p+(g-p)//3+(b-p)//3
t6=(g//3)
p=min(g%3,r,b)
t6=t6+p+(r-p)//3+(b-p)//3
t7=(b//3)
p=min(b%3,r,g)
t7=t7+p+(g-p)//3+(r-p)//3
t8=min(r,g,b)+(r-k)//3+(b-k)//3+(g-k)//3
print(max(t1,t2,t3,t4,t5,t6,t7,t8))
``` | output | 1 | 306 | 7 | 613 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel has some flowers: r red flowers, g green flowers and b blue flowers. She wants to use these flowers to make several bouquets. There are 4 types of bouquets:
* To make a "red bouquet", it needs 3 red flowers.
* To make a "green bouquet", it needs 3 green flowers.
* To make a "blue bouquet", it needs 3 blue flowers.
* To make a "mixing bouquet", it needs 1 red, 1 green and 1 blue flower.
Help Fox Ciel to find the maximal number of bouquets she can make.
Input
The first line contains three integers r, g and b (0 ≤ r, g, b ≤ 109) — the number of red, green and blue flowers.
Output
Print the maximal number of bouquets Fox Ciel can make.
Examples
Input
3 6 9
Output
6
Input
4 4 4
Output
4
Input
0 0 0
Output
0
Note
In test case 1, we can make 1 red bouquet, 2 green bouquets and 3 blue bouquets.
In test case 2, we can make 1 red, 1 green, 1 blue and 1 mixing bouquet. | instruction | 0 | 307 | 7 | 614 |
Tags: combinatorics, math
Correct Solution:
```
dados = input().split()
flowers = [int(dados[0]), int(dados[1]), int(dados[2])]
buques = 0
buques = flowers[0] // 3 + flowers[1] // 3 + flowers[2] // 3
if (flowers[0] and flowers[1] and flowers[2]) > 0:
buques = max(buques, 1+(flowers[0] - 1) // 3 + (flowers[1] - 1) // 3 + (flowers[2] - 1) // 3)
buques = max(buques, 2+(flowers[0] - 2) // 3 + (flowers[1] - 2) // 3 + (flowers[2] - 2) // 3)
print(buques)
``` | output | 1 | 307 | 7 | 615 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel has some flowers: r red flowers, g green flowers and b blue flowers. She wants to use these flowers to make several bouquets. There are 4 types of bouquets:
* To make a "red bouquet", it needs 3 red flowers.
* To make a "green bouquet", it needs 3 green flowers.
* To make a "blue bouquet", it needs 3 blue flowers.
* To make a "mixing bouquet", it needs 1 red, 1 green and 1 blue flower.
Help Fox Ciel to find the maximal number of bouquets she can make.
Input
The first line contains three integers r, g and b (0 ≤ r, g, b ≤ 109) — the number of red, green and blue flowers.
Output
Print the maximal number of bouquets Fox Ciel can make.
Examples
Input
3 6 9
Output
6
Input
4 4 4
Output
4
Input
0 0 0
Output
0
Note
In test case 1, we can make 1 red bouquet, 2 green bouquets and 3 blue bouquets.
In test case 2, we can make 1 red, 1 green, 1 blue and 1 mixing bouquet. | instruction | 0 | 308 | 7 | 616 |
Tags: combinatorics, math
Correct Solution:
```
def f(a, b, c):
return a // 3 + b // 3 + c // 3
a, b, c = sorted(map(int, input().split()))
print(max(f(a, b, c), f(a - 1, b - 1, c - 1) + 1 if a * b * c >= 1 else 0, f(a - 2, b - 2, c - 2) + 2 if a * b * c >= 8 else 0))
``` | output | 1 | 308 | 7 | 617 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel has some flowers: r red flowers, g green flowers and b blue flowers. She wants to use these flowers to make several bouquets. There are 4 types of bouquets:
* To make a "red bouquet", it needs 3 red flowers.
* To make a "green bouquet", it needs 3 green flowers.
* To make a "blue bouquet", it needs 3 blue flowers.
* To make a "mixing bouquet", it needs 1 red, 1 green and 1 blue flower.
Help Fox Ciel to find the maximal number of bouquets she can make.
Input
The first line contains three integers r, g and b (0 ≤ r, g, b ≤ 109) — the number of red, green and blue flowers.
Output
Print the maximal number of bouquets Fox Ciel can make.
Examples
Input
3 6 9
Output
6
Input
4 4 4
Output
4
Input
0 0 0
Output
0
Note
In test case 1, we can make 1 red bouquet, 2 green bouquets and 3 blue bouquets.
In test case 2, we can make 1 red, 1 green, 1 blue and 1 mixing bouquet. | instruction | 0 | 309 | 7 | 618 |
Tags: combinatorics, math
Correct Solution:
```
l=list(map(int,input().split()))
r,g,b=l[0],l[1],l[2]
c=0
if(r==0 or g==0 or b==0):
c=r//3+g//3+b//3
print(c)
else:
c+=r//3 + g//3+b//3
r%=3
g%=3
b%=3
c+=min(r,g,b)
if((r==0 and g==2 and b==2 ) or (r==2 and g==2 and b==0 ) or (r==2 and g==0 and b==2 ) ):
print(c+1)
else:
print(c)
``` | output | 1 | 309 | 7 | 619 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel has some flowers: r red flowers, g green flowers and b blue flowers. She wants to use these flowers to make several bouquets. There are 4 types of bouquets:
* To make a "red bouquet", it needs 3 red flowers.
* To make a "green bouquet", it needs 3 green flowers.
* To make a "blue bouquet", it needs 3 blue flowers.
* To make a "mixing bouquet", it needs 1 red, 1 green and 1 blue flower.
Help Fox Ciel to find the maximal number of bouquets she can make.
Input
The first line contains three integers r, g and b (0 ≤ r, g, b ≤ 109) — the number of red, green and blue flowers.
Output
Print the maximal number of bouquets Fox Ciel can make.
Examples
Input
3 6 9
Output
6
Input
4 4 4
Output
4
Input
0 0 0
Output
0
Note
In test case 1, we can make 1 red bouquet, 2 green bouquets and 3 blue bouquets.
In test case 2, we can make 1 red, 1 green, 1 blue and 1 mixing bouquet.
Submitted Solution:
```
a = [int(x) for x in input().split()]
res = a[0]//3+a[1]//3+a[2]//3
for i in a:
if i==0:
print(res)
exit(0)
a = [x-1 for x in a]
res = max(res, 1+a[0]//3+a[1]//3+a[2]//3)
a = [x-1 for x in a]
res = max(res, 2+a[0]//3+a[1]//3+a[2]//3)
print(res)
``` | instruction | 0 | 310 | 7 | 620 |
Yes | output | 1 | 310 | 7 | 621 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel has some flowers: r red flowers, g green flowers and b blue flowers. She wants to use these flowers to make several bouquets. There are 4 types of bouquets:
* To make a "red bouquet", it needs 3 red flowers.
* To make a "green bouquet", it needs 3 green flowers.
* To make a "blue bouquet", it needs 3 blue flowers.
* To make a "mixing bouquet", it needs 1 red, 1 green and 1 blue flower.
Help Fox Ciel to find the maximal number of bouquets she can make.
Input
The first line contains three integers r, g and b (0 ≤ r, g, b ≤ 109) — the number of red, green and blue flowers.
Output
Print the maximal number of bouquets Fox Ciel can make.
Examples
Input
3 6 9
Output
6
Input
4 4 4
Output
4
Input
0 0 0
Output
0
Note
In test case 1, we can make 1 red bouquet, 2 green bouquets and 3 blue bouquets.
In test case 2, we can make 1 red, 1 green, 1 blue and 1 mixing bouquet.
Submitted Solution:
```
s = input()
arr = s.split(" ")
r = int(arr[0])
g = int(arr[1])
b = int(arr[2])
ans = r//3 + g//3 + b//3
if r > 0 and g > 0 and b > 0:
temp = (r-1)//3 + (g-1)//3 + (b-1)//3 + 1
ans = max(ans,temp)
if r > 1 and g > 1 and b > 1:
temp = (r-2)//3 + (g-2)//3 + (b-2)//3 + 2
ans = max(ans,temp)
print(ans)
``` | instruction | 0 | 311 | 7 | 622 |
Yes | output | 1 | 311 | 7 | 623 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel has some flowers: r red flowers, g green flowers and b blue flowers. She wants to use these flowers to make several bouquets. There are 4 types of bouquets:
* To make a "red bouquet", it needs 3 red flowers.
* To make a "green bouquet", it needs 3 green flowers.
* To make a "blue bouquet", it needs 3 blue flowers.
* To make a "mixing bouquet", it needs 1 red, 1 green and 1 blue flower.
Help Fox Ciel to find the maximal number of bouquets she can make.
Input
The first line contains three integers r, g and b (0 ≤ r, g, b ≤ 109) — the number of red, green and blue flowers.
Output
Print the maximal number of bouquets Fox Ciel can make.
Examples
Input
3 6 9
Output
6
Input
4 4 4
Output
4
Input
0 0 0
Output
0
Note
In test case 1, we can make 1 red bouquet, 2 green bouquets and 3 blue bouquets.
In test case 2, we can make 1 red, 1 green, 1 blue and 1 mixing bouquet.
Submitted Solution:
```
*arr,=map(int, input().split())
mod, div = [int(i%3) for i in arr], [int(i/3) for i in arr]
a, b = sum(div) + min(mod), max(mod) + (sum(div)-(3-mod.count(max(mod))))
if(0 in arr): print(a)
else:
print(max(a,b))
``` | instruction | 0 | 312 | 7 | 624 |
Yes | output | 1 | 312 | 7 | 625 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel has some flowers: r red flowers, g green flowers and b blue flowers. She wants to use these flowers to make several bouquets. There are 4 types of bouquets:
* To make a "red bouquet", it needs 3 red flowers.
* To make a "green bouquet", it needs 3 green flowers.
* To make a "blue bouquet", it needs 3 blue flowers.
* To make a "mixing bouquet", it needs 1 red, 1 green and 1 blue flower.
Help Fox Ciel to find the maximal number of bouquets she can make.
Input
The first line contains three integers r, g and b (0 ≤ r, g, b ≤ 109) — the number of red, green and blue flowers.
Output
Print the maximal number of bouquets Fox Ciel can make.
Examples
Input
3 6 9
Output
6
Input
4 4 4
Output
4
Input
0 0 0
Output
0
Note
In test case 1, we can make 1 red bouquet, 2 green bouquets and 3 blue bouquets.
In test case 2, we can make 1 red, 1 green, 1 blue and 1 mixing bouquet.
Submitted Solution:
```
a, b, c = map(int, input().split())
l = min(a, min(b, c))
ans = 0
x = 0
n = l
while x <= min(n, 10):
l = l - x
ans = max(ans, l + (a-l)//3 + (b-l)//3 + (c-l)//3 )
x = x + 1
print(ans)
``` | instruction | 0 | 313 | 7 | 626 |
Yes | output | 1 | 313 | 7 | 627 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel has some flowers: r red flowers, g green flowers and b blue flowers. She wants to use these flowers to make several bouquets. There are 4 types of bouquets:
* To make a "red bouquet", it needs 3 red flowers.
* To make a "green bouquet", it needs 3 green flowers.
* To make a "blue bouquet", it needs 3 blue flowers.
* To make a "mixing bouquet", it needs 1 red, 1 green and 1 blue flower.
Help Fox Ciel to find the maximal number of bouquets she can make.
Input
The first line contains three integers r, g and b (0 ≤ r, g, b ≤ 109) — the number of red, green and blue flowers.
Output
Print the maximal number of bouquets Fox Ciel can make.
Examples
Input
3 6 9
Output
6
Input
4 4 4
Output
4
Input
0 0 0
Output
0
Note
In test case 1, we can make 1 red bouquet, 2 green bouquets and 3 blue bouquets.
In test case 2, we can make 1 red, 1 green, 1 blue and 1 mixing bouquet.
Submitted Solution:
```
def solve(r, g, b):
global cnt, threecnt
cnt = int(0)
threecnt = int(0)
def change(y):
global cnt, threecnt
if y % 3:
cnt += y // 3
y = y % 3
print(cnt, y)
elif y != 0:
cnt += y // 3 - 1
y = 3
threecnt += 1
return y
r = change(r)
g = change(g)
b = change(b)
if threecnt > 1:
cnt += threecnt
else:
cnt += max(threecnt, min(r, g, b))
print(cnt)
r, g, b = map(int, input().split())
solve(r, g, b)
``` | instruction | 0 | 314 | 7 | 628 |
No | output | 1 | 314 | 7 | 629 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel has some flowers: r red flowers, g green flowers and b blue flowers. She wants to use these flowers to make several bouquets. There are 4 types of bouquets:
* To make a "red bouquet", it needs 3 red flowers.
* To make a "green bouquet", it needs 3 green flowers.
* To make a "blue bouquet", it needs 3 blue flowers.
* To make a "mixing bouquet", it needs 1 red, 1 green and 1 blue flower.
Help Fox Ciel to find the maximal number of bouquets she can make.
Input
The first line contains three integers r, g and b (0 ≤ r, g, b ≤ 109) — the number of red, green and blue flowers.
Output
Print the maximal number of bouquets Fox Ciel can make.
Examples
Input
3 6 9
Output
6
Input
4 4 4
Output
4
Input
0 0 0
Output
0
Note
In test case 1, we can make 1 red bouquet, 2 green bouquets and 3 blue bouquets.
In test case 2, we can make 1 red, 1 green, 1 blue and 1 mixing bouquet.
Submitted Solution:
```
r, b, g = [int(i) for i in input().split()]
rems = min(r, b, g)
rems1 = min(r%3,b%3,g%3)
ans = ((r-rems)//3) + ((b-rems)//3) + ((g-rems)//3) + rems
ans1 = (r//3) + (b//3) + (g//3) + rems1
print(max(ans,ans1))
``` | instruction | 0 | 315 | 7 | 630 |
No | output | 1 | 315 | 7 | 631 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel has some flowers: r red flowers, g green flowers and b blue flowers. She wants to use these flowers to make several bouquets. There are 4 types of bouquets:
* To make a "red bouquet", it needs 3 red flowers.
* To make a "green bouquet", it needs 3 green flowers.
* To make a "blue bouquet", it needs 3 blue flowers.
* To make a "mixing bouquet", it needs 1 red, 1 green and 1 blue flower.
Help Fox Ciel to find the maximal number of bouquets she can make.
Input
The first line contains three integers r, g and b (0 ≤ r, g, b ≤ 109) — the number of red, green and blue flowers.
Output
Print the maximal number of bouquets Fox Ciel can make.
Examples
Input
3 6 9
Output
6
Input
4 4 4
Output
4
Input
0 0 0
Output
0
Note
In test case 1, we can make 1 red bouquet, 2 green bouquets and 3 blue bouquets.
In test case 2, we can make 1 red, 1 green, 1 blue and 1 mixing bouquet.
Submitted Solution:
```
r,g,b = [int(x) for x in input().split()]
def bouquets(r,g,b):
ans = 0
ans += int(r/3)
ans += int(g/3)
ans += int(b/3)
li = [r%3,g%3,b%3]
if 0 in li:
if sum(li)==4: # 0,2,2
return (ans+1)
else:
return ans
else:
if sum(li)==6: #2,2,2
return (ans+2)
else:
return (ans+1)
return ans
print(bouquets(r,g,b))
#print(bouquets(4,4,4))
``` | instruction | 0 | 316 | 7 | 632 |
No | output | 1 | 316 | 7 | 633 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel has some flowers: r red flowers, g green flowers and b blue flowers. She wants to use these flowers to make several bouquets. There are 4 types of bouquets:
* To make a "red bouquet", it needs 3 red flowers.
* To make a "green bouquet", it needs 3 green flowers.
* To make a "blue bouquet", it needs 3 blue flowers.
* To make a "mixing bouquet", it needs 1 red, 1 green and 1 blue flower.
Help Fox Ciel to find the maximal number of bouquets she can make.
Input
The first line contains three integers r, g and b (0 ≤ r, g, b ≤ 109) — the number of red, green and blue flowers.
Output
Print the maximal number of bouquets Fox Ciel can make.
Examples
Input
3 6 9
Output
6
Input
4 4 4
Output
4
Input
0 0 0
Output
0
Note
In test case 1, we can make 1 red bouquet, 2 green bouquets and 3 blue bouquets.
In test case 2, we can make 1 red, 1 green, 1 blue and 1 mixing bouquet.
Submitted Solution:
```
r, g, b = sorted(map(int, input().split()))
print((r // 3) * 3 + (g - r % 3 - (r // 3) * 3) // 3 + (b - r % 3 - (r // 3) * 3) // 3 + r % 3)
``` | instruction | 0 | 317 | 7 | 634 |
No | output | 1 | 317 | 7 | 635 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel starts to learn programming. The first task is drawing a fox! However, that turns out to be too hard for a beginner, so she decides to draw a snake instead.
A snake is a pattern on a n by m table. Denote c-th cell of r-th row as (r, c). The tail of the snake is located at (1, 1), then it's body extends to (1, m), then goes down 2 rows to (3, m), then goes left to (3, 1) and so on.
Your task is to draw this snake for Fox Ciel: the empty cells should be represented as dot characters ('.') and the snake cells should be filled with number signs ('#').
Consider sample tests in order to understand the snake pattern.
Input
The only line contains two integers: n and m (3 ≤ n, m ≤ 50).
n is an odd number.
Output
Output n lines. Each line should contain a string consisting of m characters. Do not output spaces.
Examples
Input
3 3
Output
###
..#
###
Input
3 4
Output
####
...#
####
Input
5 3
Output
###
..#
###
#..
###
Input
9 9
Output
#########
........#
#########
#........
#########
........#
#########
#........
######### | instruction | 0 | 380 | 7 | 760 |
Tags: implementation
Correct Solution:
```
n,m=map(int,input().split())
k=0
for i in range(n):
if i%2==0:
print("#"*m)
elif k==0:
print("."*(m-1)+"#")
k=1
else:
print("#"+"."*(m-1))
k=0
``` | output | 1 | 380 | 7 | 761 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel starts to learn programming. The first task is drawing a fox! However, that turns out to be too hard for a beginner, so she decides to draw a snake instead.
A snake is a pattern on a n by m table. Denote c-th cell of r-th row as (r, c). The tail of the snake is located at (1, 1), then it's body extends to (1, m), then goes down 2 rows to (3, m), then goes left to (3, 1) and so on.
Your task is to draw this snake for Fox Ciel: the empty cells should be represented as dot characters ('.') and the snake cells should be filled with number signs ('#').
Consider sample tests in order to understand the snake pattern.
Input
The only line contains two integers: n and m (3 ≤ n, m ≤ 50).
n is an odd number.
Output
Output n lines. Each line should contain a string consisting of m characters. Do not output spaces.
Examples
Input
3 3
Output
###
..#
###
Input
3 4
Output
####
...#
####
Input
5 3
Output
###
..#
###
#..
###
Input
9 9
Output
#########
........#
#########
#........
#########
........#
#########
#........
######### | instruction | 0 | 381 | 7 | 762 |
Tags: implementation
Correct Solution:
```
# -*- coding: utf-8 -*-
"""
Spyder Editor
This is a temporary script file.
"""
n, m = [int(x) for x in input().split()]
row = n
col = m
def snake(row = m):
print('#'*row)
def empty1(row = m):
row = row - 1
print('.'*row, end="")
print('#')
def empty2(row = m):
row = row - 1
print('#',end="")
print('.'*row)
count = 0
for i in range(row):
if i % 2 == 0:
snake()
elif i % 2 == 1 and count == 0:
empty1()
count = 1
elif i % 2 == 1 and count == 1 :
empty2()
count = 0
``` | output | 1 | 381 | 7 | 763 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel starts to learn programming. The first task is drawing a fox! However, that turns out to be too hard for a beginner, so she decides to draw a snake instead.
A snake is a pattern on a n by m table. Denote c-th cell of r-th row as (r, c). The tail of the snake is located at (1, 1), then it's body extends to (1, m), then goes down 2 rows to (3, m), then goes left to (3, 1) and so on.
Your task is to draw this snake for Fox Ciel: the empty cells should be represented as dot characters ('.') and the snake cells should be filled with number signs ('#').
Consider sample tests in order to understand the snake pattern.
Input
The only line contains two integers: n and m (3 ≤ n, m ≤ 50).
n is an odd number.
Output
Output n lines. Each line should contain a string consisting of m characters. Do not output spaces.
Examples
Input
3 3
Output
###
..#
###
Input
3 4
Output
####
...#
####
Input
5 3
Output
###
..#
###
#..
###
Input
9 9
Output
#########
........#
#########
#........
#########
........#
#########
#........
######### | instruction | 0 | 382 | 7 | 764 |
Tags: implementation
Correct Solution:
```
n, m = map(int, input().split())
for i in range(n):
for j in range(m):
if(i % 2 == 0):
if(j == m-1):
print('#')
else:
print('#', sep ='', end='')
else:
if((i//2)%2 == 0):
if(j == m-1):
print('#')
else:
print('.', sep='',end='')
else:
if(j == 0):
print('#', sep='',end='')
elif(j == m-1):
print('.')
else:
print('.', sep='',end='')
``` | output | 1 | 382 | 7 | 765 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel starts to learn programming. The first task is drawing a fox! However, that turns out to be too hard for a beginner, so she decides to draw a snake instead.
A snake is a pattern on a n by m table. Denote c-th cell of r-th row as (r, c). The tail of the snake is located at (1, 1), then it's body extends to (1, m), then goes down 2 rows to (3, m), then goes left to (3, 1) and so on.
Your task is to draw this snake for Fox Ciel: the empty cells should be represented as dot characters ('.') and the snake cells should be filled with number signs ('#').
Consider sample tests in order to understand the snake pattern.
Input
The only line contains two integers: n and m (3 ≤ n, m ≤ 50).
n is an odd number.
Output
Output n lines. Each line should contain a string consisting of m characters. Do not output spaces.
Examples
Input
3 3
Output
###
..#
###
Input
3 4
Output
####
...#
####
Input
5 3
Output
###
..#
###
#..
###
Input
9 9
Output
#########
........#
#########
#........
#########
........#
#########
#........
######### | instruction | 0 | 383 | 7 | 766 |
Tags: implementation
Correct Solution:
```
a,b =map(int,input().split())
co=0
for i in range(a):
if i%2==0:
for i in range(b):
print("#",end='')
print("")
else:
if co%2==0:
for i in range(b-1):
print(".",end='')
print("#")
co+=1
else:
print("#",end="")
for i in range(b-1):
print(".",end='')
print("")
co+=1
``` | output | 1 | 383 | 7 | 767 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel starts to learn programming. The first task is drawing a fox! However, that turns out to be too hard for a beginner, so she decides to draw a snake instead.
A snake is a pattern on a n by m table. Denote c-th cell of r-th row as (r, c). The tail of the snake is located at (1, 1), then it's body extends to (1, m), then goes down 2 rows to (3, m), then goes left to (3, 1) and so on.
Your task is to draw this snake for Fox Ciel: the empty cells should be represented as dot characters ('.') and the snake cells should be filled with number signs ('#').
Consider sample tests in order to understand the snake pattern.
Input
The only line contains two integers: n and m (3 ≤ n, m ≤ 50).
n is an odd number.
Output
Output n lines. Each line should contain a string consisting of m characters. Do not output spaces.
Examples
Input
3 3
Output
###
..#
###
Input
3 4
Output
####
...#
####
Input
5 3
Output
###
..#
###
#..
###
Input
9 9
Output
#########
........#
#########
#........
#########
........#
#########
#........
######### | instruction | 0 | 384 | 7 | 768 |
Tags: implementation
Correct Solution:
```
n,m=map(int,input().split())
for i in range(n):
if i%2==0:
print('#'*m)
elif (i-1)%4==0:
print('.'*(m-1)+'#')
elif (i+1)%4==0:
print('#'+'.'*(m-1))
``` | output | 1 | 384 | 7 | 769 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel starts to learn programming. The first task is drawing a fox! However, that turns out to be too hard for a beginner, so she decides to draw a snake instead.
A snake is a pattern on a n by m table. Denote c-th cell of r-th row as (r, c). The tail of the snake is located at (1, 1), then it's body extends to (1, m), then goes down 2 rows to (3, m), then goes left to (3, 1) and so on.
Your task is to draw this snake for Fox Ciel: the empty cells should be represented as dot characters ('.') and the snake cells should be filled with number signs ('#').
Consider sample tests in order to understand the snake pattern.
Input
The only line contains two integers: n and m (3 ≤ n, m ≤ 50).
n is an odd number.
Output
Output n lines. Each line should contain a string consisting of m characters. Do not output spaces.
Examples
Input
3 3
Output
###
..#
###
Input
3 4
Output
####
...#
####
Input
5 3
Output
###
..#
###
#..
###
Input
9 9
Output
#########
........#
#########
#........
#########
........#
#########
#........
######### | instruction | 0 | 385 | 7 | 770 |
Tags: implementation
Correct Solution:
```
n, m = [int(s) for s in input().split()]
e = 0
for x in range(1, n + 1):
if x % 2 != 0:
for _ in range(m):
print("#", end="")
print()
elif e % 2 == 0:
for _ in range(m - 1):
print(".", end="")
print("#")
e += 1
elif e % 2 != 0:
print("#", end="")
for _ in range(m - 1):
print(".", end="")
print()
e += 1
``` | output | 1 | 385 | 7 | 771 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel starts to learn programming. The first task is drawing a fox! However, that turns out to be too hard for a beginner, so she decides to draw a snake instead.
A snake is a pattern on a n by m table. Denote c-th cell of r-th row as (r, c). The tail of the snake is located at (1, 1), then it's body extends to (1, m), then goes down 2 rows to (3, m), then goes left to (3, 1) and so on.
Your task is to draw this snake for Fox Ciel: the empty cells should be represented as dot characters ('.') and the snake cells should be filled with number signs ('#').
Consider sample tests in order to understand the snake pattern.
Input
The only line contains two integers: n and m (3 ≤ n, m ≤ 50).
n is an odd number.
Output
Output n lines. Each line should contain a string consisting of m characters. Do not output spaces.
Examples
Input
3 3
Output
###
..#
###
Input
3 4
Output
####
...#
####
Input
5 3
Output
###
..#
###
#..
###
Input
9 9
Output
#########
........#
#########
#........
#########
........#
#########
#........
######### | instruction | 0 | 386 | 7 | 772 |
Tags: implementation
Correct Solution:
```
a=list(map(int,input().split()))
k=1
while k<=a[0]:
if k%4==1:
for i in range(a[1]):
print('#',end='')
k+=1
print('')
elif k%4==2:
for i in range(a[1]-1):
print('.',end='')
print('#')
k+=1
elif k%4==3:
for i in range(a[1]):
print('#',end='')
print('')
k+=1
elif k%4==0:
print('#',end='')
for i in range(a[1]-1):
print('.',end='')
print('')
k+=1
``` | output | 1 | 386 | 7 | 773 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel starts to learn programming. The first task is drawing a fox! However, that turns out to be too hard for a beginner, so she decides to draw a snake instead.
A snake is a pattern on a n by m table. Denote c-th cell of r-th row as (r, c). The tail of the snake is located at (1, 1), then it's body extends to (1, m), then goes down 2 rows to (3, m), then goes left to (3, 1) and so on.
Your task is to draw this snake for Fox Ciel: the empty cells should be represented as dot characters ('.') and the snake cells should be filled with number signs ('#').
Consider sample tests in order to understand the snake pattern.
Input
The only line contains two integers: n and m (3 ≤ n, m ≤ 50).
n is an odd number.
Output
Output n lines. Each line should contain a string consisting of m characters. Do not output spaces.
Examples
Input
3 3
Output
###
..#
###
Input
3 4
Output
####
...#
####
Input
5 3
Output
###
..#
###
#..
###
Input
9 9
Output
#########
........#
#########
#........
#########
........#
#########
#........
######### | instruction | 0 | 387 | 7 | 774 |
Tags: implementation
Correct Solution:
```
n,m=map(int,input().split())
snake="#"*m
nosnake="."*(m-1)+"#"
even=snake+"\n"+nosnake
odd=snake+"\n"+nosnake[::-1]
for i in range(n//2+1):
if(i+1>n//2):
print(snake)
else:
if(i%2==0):
print(even)
else:
print(odd)
``` | output | 1 | 387 | 7 | 775 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel starts to learn programming. The first task is drawing a fox! However, that turns out to be too hard for a beginner, so she decides to draw a snake instead.
A snake is a pattern on a n by m table. Denote c-th cell of r-th row as (r, c). The tail of the snake is located at (1, 1), then it's body extends to (1, m), then goes down 2 rows to (3, m), then goes left to (3, 1) and so on.
Your task is to draw this snake for Fox Ciel: the empty cells should be represented as dot characters ('.') and the snake cells should be filled with number signs ('#').
Consider sample tests in order to understand the snake pattern.
Input
The only line contains two integers: n and m (3 ≤ n, m ≤ 50).
n is an odd number.
Output
Output n lines. Each line should contain a string consisting of m characters. Do not output spaces.
Examples
Input
3 3
Output
###
..#
###
Input
3 4
Output
####
...#
####
Input
5 3
Output
###
..#
###
#..
###
Input
9 9
Output
#########
........#
#########
#........
#########
........#
#########
#........
#########
Submitted Solution:
```
def drawSnake(n,m):
hashBool = True
for row in range(n):
for col in range(m):
if row % 2 == 0:
print('#', end='')
else:
if hashBool:
hashSpace = m-1
else:
hashSpace = 0
if col == hashSpace:
print('#', end='')
else:
print('.', end='')
print()
if row % 2 == 1:
if hashBool == True:
hashBool = False
else:
hashBool = True
[n,m] = [int(x) for x in input().split()]
drawSnake(n,m)
``` | instruction | 0 | 388 | 7 | 776 |
Yes | output | 1 | 388 | 7 | 777 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel starts to learn programming. The first task is drawing a fox! However, that turns out to be too hard for a beginner, so she decides to draw a snake instead.
A snake is a pattern on a n by m table. Denote c-th cell of r-th row as (r, c). The tail of the snake is located at (1, 1), then it's body extends to (1, m), then goes down 2 rows to (3, m), then goes left to (3, 1) and so on.
Your task is to draw this snake for Fox Ciel: the empty cells should be represented as dot characters ('.') and the snake cells should be filled with number signs ('#').
Consider sample tests in order to understand the snake pattern.
Input
The only line contains two integers: n and m (3 ≤ n, m ≤ 50).
n is an odd number.
Output
Output n lines. Each line should contain a string consisting of m characters. Do not output spaces.
Examples
Input
3 3
Output
###
..#
###
Input
3 4
Output
####
...#
####
Input
5 3
Output
###
..#
###
#..
###
Input
9 9
Output
#########
........#
#########
#........
#########
........#
#########
#........
#########
Submitted Solution:
```
line,times=map(int,input().split())
headortail=0
for i in range(line):
if (i+1)%2 == 1 :
for e in range(times):
print("#",end='')
print()
else :
if headortail == 0 :
for l in range(times-1):
print(".",end='')
print("#")
headortail =1
else :
print("#",end='')
for l in range(times-1):
print(".",end='')
print()
headortail =0
``` | instruction | 0 | 389 | 7 | 778 |
Yes | output | 1 | 389 | 7 | 779 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel starts to learn programming. The first task is drawing a fox! However, that turns out to be too hard for a beginner, so she decides to draw a snake instead.
A snake is a pattern on a n by m table. Denote c-th cell of r-th row as (r, c). The tail of the snake is located at (1, 1), then it's body extends to (1, m), then goes down 2 rows to (3, m), then goes left to (3, 1) and so on.
Your task is to draw this snake for Fox Ciel: the empty cells should be represented as dot characters ('.') and the snake cells should be filled with number signs ('#').
Consider sample tests in order to understand the snake pattern.
Input
The only line contains two integers: n and m (3 ≤ n, m ≤ 50).
n is an odd number.
Output
Output n lines. Each line should contain a string consisting of m characters. Do not output spaces.
Examples
Input
3 3
Output
###
..#
###
Input
3 4
Output
####
...#
####
Input
5 3
Output
###
..#
###
#..
###
Input
9 9
Output
#########
........#
#########
#........
#########
........#
#########
#........
#########
Submitted Solution:
```
vector = [int(i) for i in str(input()).split()]
leftRight = 1
for i in range(vector[0]):
if i%2 ==0:
print("#"*vector[1])
else:
if leftRight ==1:
print("."*(vector[1]-1) + "#")
leftRight = 0
else:
print("#" + "."*(vector[1]-1))
leftRight = 1
``` | instruction | 0 | 390 | 7 | 780 |
Yes | output | 1 | 390 | 7 | 781 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel starts to learn programming. The first task is drawing a fox! However, that turns out to be too hard for a beginner, so she decides to draw a snake instead.
A snake is a pattern on a n by m table. Denote c-th cell of r-th row as (r, c). The tail of the snake is located at (1, 1), then it's body extends to (1, m), then goes down 2 rows to (3, m), then goes left to (3, 1) and so on.
Your task is to draw this snake for Fox Ciel: the empty cells should be represented as dot characters ('.') and the snake cells should be filled with number signs ('#').
Consider sample tests in order to understand the snake pattern.
Input
The only line contains two integers: n and m (3 ≤ n, m ≤ 50).
n is an odd number.
Output
Output n lines. Each line should contain a string consisting of m characters. Do not output spaces.
Examples
Input
3 3
Output
###
..#
###
Input
3 4
Output
####
...#
####
Input
5 3
Output
###
..#
###
#..
###
Input
9 9
Output
#########
........#
#########
#........
#########
........#
#########
#........
#########
Submitted Solution:
```
n, m = map(int, input().split())
flag = True
while n:
if n % 2 != 0:
print("#" * m)
elif flag:
print("#".rjust(m, "."))
flag = False
else:
print("#".ljust(m, "."))
flag = True
n -= 1
``` | instruction | 0 | 391 | 7 | 782 |
Yes | output | 1 | 391 | 7 | 783 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel starts to learn programming. The first task is drawing a fox! However, that turns out to be too hard for a beginner, so she decides to draw a snake instead.
A snake is a pattern on a n by m table. Denote c-th cell of r-th row as (r, c). The tail of the snake is located at (1, 1), then it's body extends to (1, m), then goes down 2 rows to (3, m), then goes left to (3, 1) and so on.
Your task is to draw this snake for Fox Ciel: the empty cells should be represented as dot characters ('.') and the snake cells should be filled with number signs ('#').
Consider sample tests in order to understand the snake pattern.
Input
The only line contains two integers: n and m (3 ≤ n, m ≤ 50).
n is an odd number.
Output
Output n lines. Each line should contain a string consisting of m characters. Do not output spaces.
Examples
Input
3 3
Output
###
..#
###
Input
3 4
Output
####
...#
####
Input
5 3
Output
###
..#
###
#..
###
Input
9 9
Output
#########
........#
#########
#........
#########
........#
#########
#........
#########
Submitted Solution:
```
r,c = list(map(int,input().split()))
temp = 0
for i in range(0,r):
for j in range(0,c):
if(i%2==0):
print("#",end="")
elif (temp==0):
if(j==(c-1)):
print("#",end="")
else:
print(".",end="")
temp=1
else:
if(j == 0):
print("#",end="")
else:
print(".",end="")
temp=0
print("\n")
``` | instruction | 0 | 392 | 7 | 784 |
No | output | 1 | 392 | 7 | 785 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel starts to learn programming. The first task is drawing a fox! However, that turns out to be too hard for a beginner, so she decides to draw a snake instead.
A snake is a pattern on a n by m table. Denote c-th cell of r-th row as (r, c). The tail of the snake is located at (1, 1), then it's body extends to (1, m), then goes down 2 rows to (3, m), then goes left to (3, 1) and so on.
Your task is to draw this snake for Fox Ciel: the empty cells should be represented as dot characters ('.') and the snake cells should be filled with number signs ('#').
Consider sample tests in order to understand the snake pattern.
Input
The only line contains two integers: n and m (3 ≤ n, m ≤ 50).
n is an odd number.
Output
Output n lines. Each line should contain a string consisting of m characters. Do not output spaces.
Examples
Input
3 3
Output
###
..#
###
Input
3 4
Output
####
...#
####
Input
5 3
Output
###
..#
###
#..
###
Input
9 9
Output
#########
........#
#########
#........
#########
........#
#########
#........
#########
Submitted Solution:
```
m, n = map(int, input().split())
for i in range(1, n+1):
if i % 4 == 0:
print('#', '.' * (m-1), sep='')
elif i % 2 == 0:
print('.' * (m-1), '#', sep='')
else:
print('#' * m, sep='')
``` | instruction | 0 | 393 | 7 | 786 |
No | output | 1 | 393 | 7 | 787 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel starts to learn programming. The first task is drawing a fox! However, that turns out to be too hard for a beginner, so she decides to draw a snake instead.
A snake is a pattern on a n by m table. Denote c-th cell of r-th row as (r, c). The tail of the snake is located at (1, 1), then it's body extends to (1, m), then goes down 2 rows to (3, m), then goes left to (3, 1) and so on.
Your task is to draw this snake for Fox Ciel: the empty cells should be represented as dot characters ('.') and the snake cells should be filled with number signs ('#').
Consider sample tests in order to understand the snake pattern.
Input
The only line contains two integers: n and m (3 ≤ n, m ≤ 50).
n is an odd number.
Output
Output n lines. Each line should contain a string consisting of m characters. Do not output spaces.
Examples
Input
3 3
Output
###
..#
###
Input
3 4
Output
####
...#
####
Input
5 3
Output
###
..#
###
#..
###
Input
9 9
Output
#########
........#
#########
#........
#########
........#
#########
#........
#########
Submitted Solution:
```
# import sys
# sys.stdin=open("input.in","r")
# sys.stdout=open("output.out","w")
l=list(map(int,input().split()))
n=l[0]
m=l[1]
count=0
for i in range(n):
if(i%2==0):
for j in range(m-1):
print("#",end=" ")
print("#")
else:
count+=1
if(count%2!=0):
for k in range(m-1):
print(".",end=" ")
print("#")
else:
print("#",end=" ")
for p in range(m-2):
print(".",end=" ")
print(".")
``` | instruction | 0 | 394 | 7 | 788 |
No | output | 1 | 394 | 7 | 789 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel starts to learn programming. The first task is drawing a fox! However, that turns out to be too hard for a beginner, so she decides to draw a snake instead.
A snake is a pattern on a n by m table. Denote c-th cell of r-th row as (r, c). The tail of the snake is located at (1, 1), then it's body extends to (1, m), then goes down 2 rows to (3, m), then goes left to (3, 1) and so on.
Your task is to draw this snake for Fox Ciel: the empty cells should be represented as dot characters ('.') and the snake cells should be filled with number signs ('#').
Consider sample tests in order to understand the snake pattern.
Input
The only line contains two integers: n and m (3 ≤ n, m ≤ 50).
n is an odd number.
Output
Output n lines. Each line should contain a string consisting of m characters. Do not output spaces.
Examples
Input
3 3
Output
###
..#
###
Input
3 4
Output
####
...#
####
Input
5 3
Output
###
..#
###
#..
###
Input
9 9
Output
#########
........#
#########
#........
#########
........#
#########
#........
#########
Submitted Solution:
```
r,c=map(int,input().strip().split())
for i in range(c):
print("#",end="")
print()
r-=1
for i in range(1,r+1,1):
if i%2==1:
if i%3==1:
for j in range(c):
if j==c-1:
print("#",end="")
else:
print(".",end="")
else:
for j in range(c):
if j!=0:
print(".",end="")
else:
print("#",end="")
elif i%2==0:
for j in range(c):
print("#",end="")
print()
``` | instruction | 0 | 395 | 7 | 790 |
No | output | 1 | 395 | 7 | 791 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Roy and Biv have a set of n points on the infinite number line.
Each point has one of 3 colors: red, green, or blue.
Roy and Biv would like to connect all the points with some edges. Edges can be drawn between any of the two of the given points. The cost of an edge is equal to the distance between the two points it connects.
They want to do this in such a way that they will both see that all the points are connected (either directly or indirectly).
However, there is a catch: Roy cannot see the color red and Biv cannot see the color blue.
Therefore, they have to choose the edges in such a way that if all the red points are removed, the remaining blue and green points are connected (and similarly, if all the blue points are removed, the remaining red and green points are connected).
Help them compute the minimum cost way to choose edges to satisfy the above constraints.
Input
The first line will contain an integer n (1 ≤ n ≤ 300 000), the number of points.
The next n lines will contain two tokens pi and ci (pi is an integer, 1 ≤ pi ≤ 109, ci is a uppercase English letter 'R', 'G' or 'B'), denoting the position of the i-th point and the color of the i-th point. 'R' means red, 'G' denotes green, and 'B' means blue. The positions will be in strictly increasing order.
Output
Print a single integer, the minimum cost way to solve the problem.
Examples
Input
4
1 G
5 R
10 B
15 G
Output
23
Input
4
1 G
2 R
3 B
10 G
Output
12
Note
In the first sample, it is optimal to draw edges between the points (1,2), (1,4), (3,4). These have costs 4, 14, 5, respectively.
Submitted Solution:
```
r = g = b = 0
R = G = B = 0
s = u = v = 0
f = lambda k: k if k else n
for i in range(int(input())):
q, c = input().split()
n = int(q)
if c in 'RG': r, R, u = f(r), n, max(u, n - R)
if c in 'BG': b, B, v = f(b), n, max(v, n - B)
if c == 'G':
if g: s -= max(u + v, n - G)
g, G, u, v = f(g), n, 0, 0
print(s + R - r + G - g + B - b)
``` | instruction | 0 | 516 | 7 | 1,032 |
Yes | output | 1 | 516 | 7 | 1,033 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.