message stringlengths 2 44.5k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 276 109k | cluster float64 23 23 | __index_level_0__ int64 552 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
Phoenix is playing with a new puzzle, which consists of n identical puzzle pieces. Each puzzle piece is a right isosceles triangle as shown below.
<image> A puzzle piece
The goal of the puzzle is to create a square using the n pieces. He is allowed to rotate and move the pieces around, but none of them can overlap and all n pieces must be used (of course, the square shouldn't contain any holes as well). Can he do it?
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The first line of each test case contains an integer n (1 ≤ n ≤ 10^9) — the number of puzzle pieces.
Output
For each test case, if Phoenix can create a square with the n puzzle pieces, print YES. Otherwise, print NO.
Example
Input
3
2
4
6
Output
YES
YES
NO
Note
For n=2, Phoenix can create a square like this:
<image>
For n=4, Phoenix can create a square like this:
<image>
For n=6, it is impossible for Phoenix to create a square. | instruction | 0 | 28,497 | 23 | 56,994 |
Tags: brute force, geometry, math, number theory
Correct Solution:
```
# template begins
#####################################
from io import BytesIO, IOBase
import sys
import math
import os
from collections import defaultdict
from math import ceil
from bisect import bisect_left, bisect_left
from time import perf_counter
# 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)
def input(): return sys.stdin.readline().rstrip("\r\n")
def mint(): return map(int, input().split())
def mfloat(): return map(float, input().split())
#####################################
# template ends
# Use the recursion snippet if heavy recursion is needed (depth>1000)
def sq(n):
return int(math.sqrt(n))**2==n
def solve():
n = int(input())
"""
you can make a small square with 2 or 4 blocks
"""
if n%4==0:
large = n//4
if sq(large):
print("YES")
return
if n%2==0:
small = n//2
if sq(small):
print("YES")
return
print("NO")
def main():
t = int(input())
# t = 1
for _ in range(t):
solve()
if __name__ == "__main__":
main()
``` | output | 1 | 28,497 | 23 | 56,995 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Phoenix is playing with a new puzzle, which consists of n identical puzzle pieces. Each puzzle piece is a right isosceles triangle as shown below.
<image> A puzzle piece
The goal of the puzzle is to create a square using the n pieces. He is allowed to rotate and move the pieces around, but none of them can overlap and all n pieces must be used (of course, the square shouldn't contain any holes as well). Can he do it?
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The first line of each test case contains an integer n (1 ≤ n ≤ 10^9) — the number of puzzle pieces.
Output
For each test case, if Phoenix can create a square with the n puzzle pieces, print YES. Otherwise, print NO.
Example
Input
3
2
4
6
Output
YES
YES
NO
Note
For n=2, Phoenix can create a square like this:
<image>
For n=4, Phoenix can create a square like this:
<image>
For n=6, it is impossible for Phoenix to create a square.
Submitted Solution:
```
import heapq
import math
tcs = int(input())
for tc in range(tcs):
N = int(input())
# N, M = list(map(int, input().split()))
res = False
if N >= 2:
if N == (N // 2) * 2:
if int(math.sqrt(N // 2)) * int(math.sqrt(N // 2)) == N // 2:
res = True
if N == (N // 4) * 4:
if int(math.sqrt(N // 4)) * int(math.sqrt(N // 4)) == N // 4:
res = True
if res:
print("YES")
else:
print("NO")
``` | instruction | 0 | 28,498 | 23 | 56,996 |
Yes | output | 1 | 28,498 | 23 | 56,997 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Phoenix is playing with a new puzzle, which consists of n identical puzzle pieces. Each puzzle piece is a right isosceles triangle as shown below.
<image> A puzzle piece
The goal of the puzzle is to create a square using the n pieces. He is allowed to rotate and move the pieces around, but none of them can overlap and all n pieces must be used (of course, the square shouldn't contain any holes as well). Can he do it?
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The first line of each test case contains an integer n (1 ≤ n ≤ 10^9) — the number of puzzle pieces.
Output
For each test case, if Phoenix can create a square with the n puzzle pieces, print YES. Otherwise, print NO.
Example
Input
3
2
4
6
Output
YES
YES
NO
Note
For n=2, Phoenix can create a square like this:
<image>
For n=4, Phoenix can create a square like this:
<image>
For n=6, it is impossible for Phoenix to create a square.
Submitted Solution:
```
def ps(n):
x=int(n**0.5)
if x*x==n:
return True
else:
return False
for _ in range(int(input())):
n=int(input())
if n%2==1:
print("NO")
else:
while(n%2==0):
n//=2
if ps(n):
print("YES")
else:
print("NO")
``` | instruction | 0 | 28,499 | 23 | 56,998 |
Yes | output | 1 | 28,499 | 23 | 56,999 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Phoenix is playing with a new puzzle, which consists of n identical puzzle pieces. Each puzzle piece is a right isosceles triangle as shown below.
<image> A puzzle piece
The goal of the puzzle is to create a square using the n pieces. He is allowed to rotate and move the pieces around, but none of them can overlap and all n pieces must be used (of course, the square shouldn't contain any holes as well). Can he do it?
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The first line of each test case contains an integer n (1 ≤ n ≤ 10^9) — the number of puzzle pieces.
Output
For each test case, if Phoenix can create a square with the n puzzle pieces, print YES. Otherwise, print NO.
Example
Input
3
2
4
6
Output
YES
YES
NO
Note
For n=2, Phoenix can create a square like this:
<image>
For n=4, Phoenix can create a square like this:
<image>
For n=6, it is impossible for Phoenix to create a square.
Submitted Solution:
```
import math
for i in range(int(input())):
t = int(input())
if t % 2 == 0 and int(math.sqrt(t // 2)) ** 2 == t // 2 or t % 4 == 0 and int(math.sqrt(t // 4)) ** 2 == t // 4:
print("YES")
else:
print("NO")
``` | instruction | 0 | 28,500 | 23 | 57,000 |
Yes | output | 1 | 28,500 | 23 | 57,001 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Phoenix is playing with a new puzzle, which consists of n identical puzzle pieces. Each puzzle piece is a right isosceles triangle as shown below.
<image> A puzzle piece
The goal of the puzzle is to create a square using the n pieces. He is allowed to rotate and move the pieces around, but none of them can overlap and all n pieces must be used (of course, the square shouldn't contain any holes as well). Can he do it?
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The first line of each test case contains an integer n (1 ≤ n ≤ 10^9) — the number of puzzle pieces.
Output
For each test case, if Phoenix can create a square with the n puzzle pieces, print YES. Otherwise, print NO.
Example
Input
3
2
4
6
Output
YES
YES
NO
Note
For n=2, Phoenix can create a square like this:
<image>
For n=4, Phoenix can create a square like this:
<image>
For n=6, it is impossible for Phoenix to create a square.
Submitted Solution:
```
from math import sqrt
for _ in range(int(input())):
n = int(input())
m = n
if n%2==1:
print("NO")
else:
ck=1
if (sqrt(n//2).is_integer()):
ck=0
if (sqrt(n/4).is_integer()):
ck=0
if ck==0:
print("YES")
else:
print("NO")
``` | instruction | 0 | 28,501 | 23 | 57,002 |
Yes | output | 1 | 28,501 | 23 | 57,003 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Phoenix is playing with a new puzzle, which consists of n identical puzzle pieces. Each puzzle piece is a right isosceles triangle as shown below.
<image> A puzzle piece
The goal of the puzzle is to create a square using the n pieces. He is allowed to rotate and move the pieces around, but none of them can overlap and all n pieces must be used (of course, the square shouldn't contain any holes as well). Can he do it?
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The first line of each test case contains an integer n (1 ≤ n ≤ 10^9) — the number of puzzle pieces.
Output
For each test case, if Phoenix can create a square with the n puzzle pieces, print YES. Otherwise, print NO.
Example
Input
3
2
4
6
Output
YES
YES
NO
Note
For n=2, Phoenix can create a square like this:
<image>
For n=4, Phoenix can create a square like this:
<image>
For n=6, it is impossible for Phoenix to create a square.
Submitted Solution:
```
if __name__ == "__main__":
T = int(input())
for i in range(T):
n = int(input())
if n == 1:
print("NO")
else:
binary = bin(n)[2:]
if binary.count('1') == 1 and binary[0] == '1':
print("YES")
else:
print("NO")
``` | instruction | 0 | 28,502 | 23 | 57,004 |
No | output | 1 | 28,502 | 23 | 57,005 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Phoenix is playing with a new puzzle, which consists of n identical puzzle pieces. Each puzzle piece is a right isosceles triangle as shown below.
<image> A puzzle piece
The goal of the puzzle is to create a square using the n pieces. He is allowed to rotate and move the pieces around, but none of them can overlap and all n pieces must be used (of course, the square shouldn't contain any holes as well). Can he do it?
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The first line of each test case contains an integer n (1 ≤ n ≤ 10^9) — the number of puzzle pieces.
Output
For each test case, if Phoenix can create a square with the n puzzle pieces, print YES. Otherwise, print NO.
Example
Input
3
2
4
6
Output
YES
YES
NO
Note
For n=2, Phoenix can create a square like this:
<image>
For n=4, Phoenix can create a square like this:
<image>
For n=6, it is impossible for Phoenix to create a square.
Submitted Solution:
```
lst = [1<<i for i in range(1,35)]
for t in range(int(input())):
n = int(input())
if n in lst:
print("YES")
else:
print("NO")
``` | instruction | 0 | 28,503 | 23 | 57,006 |
No | output | 1 | 28,503 | 23 | 57,007 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Phoenix is playing with a new puzzle, which consists of n identical puzzle pieces. Each puzzle piece is a right isosceles triangle as shown below.
<image> A puzzle piece
The goal of the puzzle is to create a square using the n pieces. He is allowed to rotate and move the pieces around, but none of them can overlap and all n pieces must be used (of course, the square shouldn't contain any holes as well). Can he do it?
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The first line of each test case contains an integer n (1 ≤ n ≤ 10^9) — the number of puzzle pieces.
Output
For each test case, if Phoenix can create a square with the n puzzle pieces, print YES. Otherwise, print NO.
Example
Input
3
2
4
6
Output
YES
YES
NO
Note
For n=2, Phoenix can create a square like this:
<image>
For n=4, Phoenix can create a square like this:
<image>
For n=6, it is impossible for Phoenix to create a square.
Submitted Solution:
```
t=int(input())
while(t>0):
t=t-1
x=int(input())
if (x&(x-1))==0:
print("YES")
else:
print("NO")
``` | instruction | 0 | 28,504 | 23 | 57,008 |
No | output | 1 | 28,504 | 23 | 57,009 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Phoenix is playing with a new puzzle, which consists of n identical puzzle pieces. Each puzzle piece is a right isosceles triangle as shown below.
<image> A puzzle piece
The goal of the puzzle is to create a square using the n pieces. He is allowed to rotate and move the pieces around, but none of them can overlap and all n pieces must be used (of course, the square shouldn't contain any holes as well). Can he do it?
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The first line of each test case contains an integer n (1 ≤ n ≤ 10^9) — the number of puzzle pieces.
Output
For each test case, if Phoenix can create a square with the n puzzle pieces, print YES. Otherwise, print NO.
Example
Input
3
2
4
6
Output
YES
YES
NO
Note
For n=2, Phoenix can create a square like this:
<image>
For n=4, Phoenix can create a square like this:
<image>
For n=6, it is impossible for Phoenix to create a square.
Submitted Solution:
```
def isPowerOfTwo(x):
return (x and (not(x & (x - 1))) )
for t in range(int(input())):
n = int(input())
if isPowerOfTwo(n):
print('YES')
else:
print('NO')
``` | instruction | 0 | 28,505 | 23 | 57,010 |
No | output | 1 | 28,505 | 23 | 57,011 |
Provide a correct Python 3 solution for this coding contest problem.
In Aizu prefecture, we decided to create a new town to increase the population. To that end, we decided to cultivate a new rectangular land and divide this land into squares of the same size. The cost of developing this land is proportional to the number of plots, but the prefecture wants to minimize this cost.
Create a program to find the minimum maintenance cost for all plots, given the east-west and north-south lengths of the newly cultivated land and the maintenance cost per plot.
Input
The input is given in the following format.
W H C
The input is one line, the length W (1 ≤ W ≤ 1000) in the east-west direction and the length H (1 ≤ H ≤ 1000) in the north-south direction of the newly cultivated land, and the maintenance cost per plot C (1 ≤ 1000). C ≤ 1000) is given as an integer.
Output
Output the minimum cost required to maintain the land in one line.
Examples
Input
10 20 5
Output
10
Input
27 6 1
Output
18 | instruction | 0 | 29,004 | 23 | 58,008 |
"Correct Solution:
```
import math#mathモジュールをインポートする
a,b,c = map(int,input().split())#標準入力
i = (math.gcd(a,b))#最大公約数
a *= b#開拓した面積を求める
i *= i#正方形の面接を求める
print(int(a / i * c))#正方形のに開拓費用をかけた数を出力する
``` | output | 1 | 29,004 | 23 | 58,009 |
Provide a correct Python 3 solution for this coding contest problem.
In Aizu prefecture, we decided to create a new town to increase the population. To that end, we decided to cultivate a new rectangular land and divide this land into squares of the same size. The cost of developing this land is proportional to the number of plots, but the prefecture wants to minimize this cost.
Create a program to find the minimum maintenance cost for all plots, given the east-west and north-south lengths of the newly cultivated land and the maintenance cost per plot.
Input
The input is given in the following format.
W H C
The input is one line, the length W (1 ≤ W ≤ 1000) in the east-west direction and the length H (1 ≤ H ≤ 1000) in the north-south direction of the newly cultivated land, and the maintenance cost per plot C (1 ≤ 1000). C ≤ 1000) is given as an integer.
Output
Output the minimum cost required to maintain the land in one line.
Examples
Input
10 20 5
Output
10
Input
27 6 1
Output
18 | instruction | 0 | 29,005 | 23 | 58,010 |
"Correct Solution:
```
import math
w,h,c=map(int,input().split())
g=math.gcd(w,h)
print(int((w/g)*(h/g)*c))
``` | output | 1 | 29,005 | 23 | 58,011 |
Provide a correct Python 3 solution for this coding contest problem.
In Aizu prefecture, we decided to create a new town to increase the population. To that end, we decided to cultivate a new rectangular land and divide this land into squares of the same size. The cost of developing this land is proportional to the number of plots, but the prefecture wants to minimize this cost.
Create a program to find the minimum maintenance cost for all plots, given the east-west and north-south lengths of the newly cultivated land and the maintenance cost per plot.
Input
The input is given in the following format.
W H C
The input is one line, the length W (1 ≤ W ≤ 1000) in the east-west direction and the length H (1 ≤ H ≤ 1000) in the north-south direction of the newly cultivated land, and the maintenance cost per plot C (1 ≤ 1000). C ≤ 1000) is given as an integer.
Output
Output the minimum cost required to maintain the land in one line.
Examples
Input
10 20 5
Output
10
Input
27 6 1
Output
18 | instruction | 0 | 29,006 | 23 | 58,012 |
"Correct Solution:
```
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
w, h, c = [int(num) for num in input().split()]
g = gcd(w, h)
print((w // g) * (h // g) * c)
``` | output | 1 | 29,006 | 23 | 58,013 |
Provide a correct Python 3 solution for this coding contest problem.
In Aizu prefecture, we decided to create a new town to increase the population. To that end, we decided to cultivate a new rectangular land and divide this land into squares of the same size. The cost of developing this land is proportional to the number of plots, but the prefecture wants to minimize this cost.
Create a program to find the minimum maintenance cost for all plots, given the east-west and north-south lengths of the newly cultivated land and the maintenance cost per plot.
Input
The input is given in the following format.
W H C
The input is one line, the length W (1 ≤ W ≤ 1000) in the east-west direction and the length H (1 ≤ H ≤ 1000) in the north-south direction of the newly cultivated land, and the maintenance cost per plot C (1 ≤ 1000). C ≤ 1000) is given as an integer.
Output
Output the minimum cost required to maintain the land in one line.
Examples
Input
10 20 5
Output
10
Input
27 6 1
Output
18 | instruction | 0 | 29,007 | 23 | 58,014 |
"Correct Solution:
```
import math
W,H,C = [int(i) for i in input().split()]
g = math.gcd(W,H)
print(int(((W/g) * (H/g))*C))
``` | output | 1 | 29,007 | 23 | 58,015 |
Provide a correct Python 3 solution for this coding contest problem.
In Aizu prefecture, we decided to create a new town to increase the population. To that end, we decided to cultivate a new rectangular land and divide this land into squares of the same size. The cost of developing this land is proportional to the number of plots, but the prefecture wants to minimize this cost.
Create a program to find the minimum maintenance cost for all plots, given the east-west and north-south lengths of the newly cultivated land and the maintenance cost per plot.
Input
The input is given in the following format.
W H C
The input is one line, the length W (1 ≤ W ≤ 1000) in the east-west direction and the length H (1 ≤ H ≤ 1000) in the north-south direction of the newly cultivated land, and the maintenance cost per plot C (1 ≤ 1000). C ≤ 1000) is given as an integer.
Output
Output the minimum cost required to maintain the land in one line.
Examples
Input
10 20 5
Output
10
Input
27 6 1
Output
18 | instruction | 0 | 29,008 | 23 | 58,016 |
"Correct Solution:
```
def g(a,b):
if b==0:
return a
return g(b,a%b)
def main():
w,h,c=map(int,input().split())
d=g(w,h)
print((w//d)*(h//d)*c)
main()
``` | output | 1 | 29,008 | 23 | 58,017 |
Provide a correct Python 3 solution for this coding contest problem.
In Aizu prefecture, we decided to create a new town to increase the population. To that end, we decided to cultivate a new rectangular land and divide this land into squares of the same size. The cost of developing this land is proportional to the number of plots, but the prefecture wants to minimize this cost.
Create a program to find the minimum maintenance cost for all plots, given the east-west and north-south lengths of the newly cultivated land and the maintenance cost per plot.
Input
The input is given in the following format.
W H C
The input is one line, the length W (1 ≤ W ≤ 1000) in the east-west direction and the length H (1 ≤ H ≤ 1000) in the north-south direction of the newly cultivated land, and the maintenance cost per plot C (1 ≤ 1000). C ≤ 1000) is given as an integer.
Output
Output the minimum cost required to maintain the land in one line.
Examples
Input
10 20 5
Output
10
Input
27 6 1
Output
18 | instruction | 0 | 29,009 | 23 | 58,018 |
"Correct Solution:
```
import math
w,h,c = [ int(s) for s in input().split() ]
gcd = math.gcd(w,h)
print((w//gcd)*(h//gcd)*c)
``` | output | 1 | 29,009 | 23 | 58,019 |
Provide a correct Python 3 solution for this coding contest problem.
In Aizu prefecture, we decided to create a new town to increase the population. To that end, we decided to cultivate a new rectangular land and divide this land into squares of the same size. The cost of developing this land is proportional to the number of plots, but the prefecture wants to minimize this cost.
Create a program to find the minimum maintenance cost for all plots, given the east-west and north-south lengths of the newly cultivated land and the maintenance cost per plot.
Input
The input is given in the following format.
W H C
The input is one line, the length W (1 ≤ W ≤ 1000) in the east-west direction and the length H (1 ≤ H ≤ 1000) in the north-south direction of the newly cultivated land, and the maintenance cost per plot C (1 ≤ 1000). C ≤ 1000) is given as an integer.
Output
Output the minimum cost required to maintain the land in one line.
Examples
Input
10 20 5
Output
10
Input
27 6 1
Output
18 | instruction | 0 | 29,010 | 23 | 58,020 |
"Correct Solution:
```
W,H,C=map(int,input().split())
mini=10**10
for x in range(1,min(H,W)+1,1):
if ( H % x ) or ( W % x ):
continue
mini=min(mini,(H//x)*(W//x)*C)
print(mini)
``` | output | 1 | 29,010 | 23 | 58,021 |
Provide a correct Python 3 solution for this coding contest problem.
In Aizu prefecture, we decided to create a new town to increase the population. To that end, we decided to cultivate a new rectangular land and divide this land into squares of the same size. The cost of developing this land is proportional to the number of plots, but the prefecture wants to minimize this cost.
Create a program to find the minimum maintenance cost for all plots, given the east-west and north-south lengths of the newly cultivated land and the maintenance cost per plot.
Input
The input is given in the following format.
W H C
The input is one line, the length W (1 ≤ W ≤ 1000) in the east-west direction and the length H (1 ≤ H ≤ 1000) in the north-south direction of the newly cultivated land, and the maintenance cost per plot C (1 ≤ 1000). C ≤ 1000) is given as an integer.
Output
Output the minimum cost required to maintain the land in one line.
Examples
Input
10 20 5
Output
10
Input
27 6 1
Output
18 | instruction | 0 | 29,011 | 23 | 58,022 |
"Correct Solution:
```
import math
W, H, C = map(int, input().split())
g = math.gcd(W, H)
print((W // g) * (H // g) * C)
``` | output | 1 | 29,011 | 23 | 58,023 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In Aizu prefecture, we decided to create a new town to increase the population. To that end, we decided to cultivate a new rectangular land and divide this land into squares of the same size. The cost of developing this land is proportional to the number of plots, but the prefecture wants to minimize this cost.
Create a program to find the minimum maintenance cost for all plots, given the east-west and north-south lengths of the newly cultivated land and the maintenance cost per plot.
Input
The input is given in the following format.
W H C
The input is one line, the length W (1 ≤ W ≤ 1000) in the east-west direction and the length H (1 ≤ H ≤ 1000) in the north-south direction of the newly cultivated land, and the maintenance cost per plot C (1 ≤ 1000). C ≤ 1000) is given as an integer.
Output
Output the minimum cost required to maintain the land in one line.
Examples
Input
10 20 5
Output
10
Input
27 6 1
Output
18
Submitted Solution:
```
import math
W,H,C=map(int,input().split())
sikaku=math.gcd(W,H)
print(C*(W*H)//(sikaku*sikaku))
``` | instruction | 0 | 29,012 | 23 | 58,024 |
Yes | output | 1 | 29,012 | 23 | 58,025 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In Aizu prefecture, we decided to create a new town to increase the population. To that end, we decided to cultivate a new rectangular land and divide this land into squares of the same size. The cost of developing this land is proportional to the number of plots, but the prefecture wants to minimize this cost.
Create a program to find the minimum maintenance cost for all plots, given the east-west and north-south lengths of the newly cultivated land and the maintenance cost per plot.
Input
The input is given in the following format.
W H C
The input is one line, the length W (1 ≤ W ≤ 1000) in the east-west direction and the length H (1 ≤ H ≤ 1000) in the north-south direction of the newly cultivated land, and the maintenance cost per plot C (1 ≤ 1000). C ≤ 1000) is given as an integer.
Output
Output the minimum cost required to maintain the land in one line.
Examples
Input
10 20 5
Output
10
Input
27 6 1
Output
18
Submitted Solution:
```
def sdk(a,b):
if a < b:
a,b = b,a
if a%b == 0:
return b
else:
return sdk(b, a%b)
w,h,c=map(int, input().split())
t = sdk(w,h)
print(w//t * h//t * c)
``` | instruction | 0 | 29,013 | 23 | 58,026 |
Yes | output | 1 | 29,013 | 23 | 58,027 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In Aizu prefecture, we decided to create a new town to increase the population. To that end, we decided to cultivate a new rectangular land and divide this land into squares of the same size. The cost of developing this land is proportional to the number of plots, but the prefecture wants to minimize this cost.
Create a program to find the minimum maintenance cost for all plots, given the east-west and north-south lengths of the newly cultivated land and the maintenance cost per plot.
Input
The input is given in the following format.
W H C
The input is one line, the length W (1 ≤ W ≤ 1000) in the east-west direction and the length H (1 ≤ H ≤ 1000) in the north-south direction of the newly cultivated land, and the maintenance cost per plot C (1 ≤ 1000). C ≤ 1000) is given as an integer.
Output
Output the minimum cost required to maintain the land in one line.
Examples
Input
10 20 5
Output
10
Input
27 6 1
Output
18
Submitted Solution:
```
from math import gcd
w, h, c = map(int, input().split())
print(w * h // gcd(w, h) // gcd(w, h) * c)
``` | instruction | 0 | 29,014 | 23 | 58,028 |
Yes | output | 1 | 29,014 | 23 | 58,029 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In Aizu prefecture, we decided to create a new town to increase the population. To that end, we decided to cultivate a new rectangular land and divide this land into squares of the same size. The cost of developing this land is proportional to the number of plots, but the prefecture wants to minimize this cost.
Create a program to find the minimum maintenance cost for all plots, given the east-west and north-south lengths of the newly cultivated land and the maintenance cost per plot.
Input
The input is given in the following format.
W H C
The input is one line, the length W (1 ≤ W ≤ 1000) in the east-west direction and the length H (1 ≤ H ≤ 1000) in the north-south direction of the newly cultivated land, and the maintenance cost per plot C (1 ≤ 1000). C ≤ 1000) is given as an integer.
Output
Output the minimum cost required to maintain the land in one line.
Examples
Input
10 20 5
Output
10
Input
27 6 1
Output
18
Submitted Solution:
```
import math
w, h, c = [int(i) for i in input().split()]
g = math.gcd(w, h)
print((w//g) * (h//g) * c)
``` | instruction | 0 | 29,015 | 23 | 58,030 |
Yes | output | 1 | 29,015 | 23 | 58,031 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In Aizu prefecture, we decided to create a new town to increase the population. To that end, we decided to cultivate a new rectangular land and divide this land into squares of the same size. The cost of developing this land is proportional to the number of plots, but the prefecture wants to minimize this cost.
Create a program to find the minimum maintenance cost for all plots, given the east-west and north-south lengths of the newly cultivated land and the maintenance cost per plot.
Input
The input is given in the following format.
W H C
The input is one line, the length W (1 ≤ W ≤ 1000) in the east-west direction and the length H (1 ≤ H ≤ 1000) in the north-south direction of the newly cultivated land, and the maintenance cost per plot C (1 ≤ 1000). C ≤ 1000) is given as an integer.
Output
Output the minimum cost required to maintain the land in one line.
Examples
Input
10 20 5
Output
10
Input
27 6 1
Output
18
Submitted Solution:
```
import fractions
A, B, C = [int(k) for k in raw_input().split(' ')]
print((A * B)/ (fractions.gcd(A, B) ** 2 ))
``` | instruction | 0 | 29,016 | 23 | 58,032 |
No | output | 1 | 29,016 | 23 | 58,033 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In Aizu prefecture, we decided to create a new town to increase the population. To that end, we decided to cultivate a new rectangular land and divide this land into squares of the same size. The cost of developing this land is proportional to the number of plots, but the prefecture wants to minimize this cost.
Create a program to find the minimum maintenance cost for all plots, given the east-west and north-south lengths of the newly cultivated land and the maintenance cost per plot.
Input
The input is given in the following format.
W H C
The input is one line, the length W (1 ≤ W ≤ 1000) in the east-west direction and the length H (1 ≤ H ≤ 1000) in the north-south direction of the newly cultivated land, and the maintenance cost per plot C (1 ≤ 1000). C ≤ 1000) is given as an integer.
Output
Output the minimum cost required to maintain the land in one line.
Examples
Input
10 20 5
Output
10
Input
27 6 1
Output
18
Submitted Solution:
```
import math
W,H,C = map(int,input().split(' '))
x = math.gcd(W,H)
print((W//x)*(H//x)*C)
``` | instruction | 0 | 29,017 | 23 | 58,034 |
No | output | 1 | 29,017 | 23 | 58,035 |
Provide a correct Python 3 solution for this coding contest problem.
Let’s try a dice puzzle. The rules of this puzzle are as follows.
1. Dice with six faces as shown in Figure 1 are used in the puzzle.
<image>
Figure 1: Faces of a die
2. With twenty seven such dice, a 3 × 3 × 3 cube is built as shown in Figure 2.
<image>
Figure 2: 3 × 3 × 3 cube
3. When building up a cube made of dice, the sum of the numbers marked on the faces of adjacent dice that are placed against each other must be seven (See Figure 3). For example, if one face of the pair is marked “2”, then the other face must be “5”.
<image>
Figure 3: A pair of faces placed against each other
4. The top and the front views of the cube are partially given, i.e. the numbers on faces of some of the dice on the top and on the front are given.
<image>
Figure 4: Top and front views of the cube
5. The goal of the puzzle is to find all the plausible dice arrangements that are consistent with the given top and front view information.
Your job is to write a program that solves this puzzle.
Input
The input consists of multiple datasets in the following format.
N
Dataset1
Dataset2
...
DatasetN
N is the number of the datasets.
The format of each dataset is as follows.
T11 T12 T13
T21 T22 T23
T31 T32 T33
F11 F12 F13
F21 F22 F23
F31 F32 F33
Tij and Fij (1 ≤ i ≤ 3, 1 ≤ j ≤ 3) are the faces of dice appearing on the top and front views, as shown in Figure 2, or a zero. A zero means that the face at the corresponding position is unknown.
Output
For each plausible arrangement of dice, compute the sum of the numbers marked on the nine faces appearing on the right side of the cube, that is, with the notation given in Figure 2, ∑3i=1∑3j=1Rij.
For each dataset, you should output the right view sums for all the plausible arrangements, in ascending order and without duplicates. Numbers should be separated by a single space.
When there are no plausible arrangements for a dataset, output a zero.
For example, suppose that the top and the front views are given as follows.
<image>
Figure 5: Example
There are four plausible right views as shown in Figure 6. The right view sums are 33, 36, 32, and 33, respectively. After rearranging them into ascending order and eliminating duplicates, the answer should be “32 33 36”.
<image>
Figure 6: Plausible right views
The output should be one line for each dataset. The output may have spaces at ends of lines.
Example
Input
4
1 1 1
1 1 1
1 1 1
2 2 2
2 2 2
2 2 2
4 3 3
5 2 2
4 3 3
6 1 1
6 1 1
6 1 0
1 0 0
0 2 0
0 0 0
5 1 2
5 1 2
0 0 0
2 0 0
0 3 0
0 0 0
0 0 0
0 0 0
3 0 1
Output
27
24
32 33 36
0 | instruction | 0 | 29,037 | 23 | 58,074 |
"Correct Solution:
```
import sys
readline = sys.stdin.readline
write = sys.stdout.write
D = [
(1, 5, 2, 3, 0, 4), # 'U'
(3, 1, 0, 5, 4, 2), # 'R'
(4, 0, 2, 3, 5, 1), # 'D'
(2, 1, 5, 0, 4, 3), # 'L'
]
p_dice = (0, 0, 0, 1, 1, 2, 2, 3)*3
def enumerate_dice(L0):
L = L0[:]
for k in p_dice:
yield L
L[:] = (L[e] for e in D[k])
L = [1, 2, 3, 4, 5, 6]
LS = []
for l in enumerate_dice(L):
LS.append(l[:])
def solve():
T = [list(map(int, readline().split())) for i in range(3)]
F = [list(map(int, readline().split())) for i in range(3)]
T0 = [[-1]*3 for i in range(3)]
F0 = [[-1]*3 for i in range(3)]
R0 = [[-1]*3 for i in range(3)]
res = set()
def dfs(i, s):
if i == 27:
res.add(s)
return
x = i % 3; y = (i // 3) % 3; z = (i // 9) % 3
t0 = T0[y][x]
f0 = F0[z][x]
r0 = R0[z][y]
for l in LS:
if t0 == -1:
e = T[y][x]
if e != 0 and e != l[0]:
continue
T0[y][x] = l[0]
else:
if l[0] != t0:
continue
if f0 == -1:
e = F[z][x]
if e != 0 and e != l[1]:
continue
F0[z][x] = l[1]
else:
if l[1] != f0:
continue
if r0 == -1:
R0[z][y] = l[2]
s0 = s + l[2]
else:
if l[2] != r0:
continue
s0 = s
dfs(i+1, s0)
if t0 == -1:
T0[y][x] = -1
if f0 == -1:
F0[z][x] = -1
if r0 == -1:
R0[z][y] = -1
dfs(0, 0)
if res:
ans = sorted(res)
write(" ".join(map(str, ans)))
write("\n")
else:
write("0\n")
N = int(readline())
for i in range(N):
solve()
``` | output | 1 | 29,037 | 23 | 58,075 |
Provide a correct Python 3 solution for this coding contest problem.
For a non-negative integer K, we define a fractal of level K as follows:
* A fractal of level 0 is a grid with just one white square.
* When K > 0, a fractal of level K is a 3^K \times 3^K grid. If we divide this grid into nine 3^{K-1} \times 3^{K-1} subgrids:
* The central subgrid consists of only black squares.
* Each of the other eight subgrids is a fractal of level K-1.
For example, a fractal of level 2 is as follows:
A fractal of level 2
In a fractal of level 30, let (r, c) denote the square at the r-th row from the top and the c-th column from the left.
You are given Q quadruples of integers (a_i, b_i, c_i, d_i). For each quadruple, find the distance from (a_i, b_i) to (c_i, d_i).
Here the distance from (a, b) to (c, d) is the minimum integer n that satisfies the following condition:
* There exists a sequence of white squares (x_0, y_0), \ldots, (x_n, y_n) satisfying the following conditions:
* (x_0, y_0) = (a, b)
* (x_n, y_n) = (c, d)
* For every i (0 \leq i \leq n-1), (x_i, y_i) and (x_{i+1}, y_{i+1}) share a side.
Constraints
* 1 \leq Q \leq 10000
* 1 \leq a_i, b_i, c_i, d_i \leq 3^{30}
* (a_i, b_i) \neq (c_i, d_i)
* (a_i, b_i) and (c_i, d_i) are white squares.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
Q
a_1 \ b_1 \ c_1 \ d_1
:
a_Q \ b_Q \ c_Q \ d_Q
Output
Print Q lines. The i-th line should contain the distance from (a_i, b_i) to (c_i, d_i).
Example
Input
2
4 2 7 4
9 9 1 9
Output
5
8 | instruction | 0 | 29,759 | 23 | 59,518 |
"Correct Solution:
```
def solve():
a, b, c, d = map(int, input().split())
a -= 1
b -= 1
c -= 1
d -= 1
if a > c:
a, b, c, d = c, d, a, b
for k in range(30, -1, -1):
def check(a, b, c, d):
if a // 3 ** k == c // 3 ** k and a // 3 ** k % 3 == 1 \
and (min(b, d) // 3 ** k % 3 == 0 and max(b, d) // 3 ** k % 3 == 2
or max(b, d) // 3 ** k - min(b, d) // 3 ** k >= 3):
print(min(a % 3 ** k + 1 + c % 3 ** k + 1 + abs(b - d),
3 ** k - a % 3 ** k + 3 ** k - c % 3 ** k + abs(b - d)))
return True
if check(a, b, c, d) or check(b, a, d, c):
return
print(abs(a - c) + abs(b - d))
q = int(input())
for _ in range(q):
solve()
``` | output | 1 | 29,759 | 23 | 59,519 |
Provide a correct Python 3 solution for this coding contest problem.
For a non-negative integer K, we define a fractal of level K as follows:
* A fractal of level 0 is a grid with just one white square.
* When K > 0, a fractal of level K is a 3^K \times 3^K grid. If we divide this grid into nine 3^{K-1} \times 3^{K-1} subgrids:
* The central subgrid consists of only black squares.
* Each of the other eight subgrids is a fractal of level K-1.
For example, a fractal of level 2 is as follows:
A fractal of level 2
In a fractal of level 30, let (r, c) denote the square at the r-th row from the top and the c-th column from the left.
You are given Q quadruples of integers (a_i, b_i, c_i, d_i). For each quadruple, find the distance from (a_i, b_i) to (c_i, d_i).
Here the distance from (a, b) to (c, d) is the minimum integer n that satisfies the following condition:
* There exists a sequence of white squares (x_0, y_0), \ldots, (x_n, y_n) satisfying the following conditions:
* (x_0, y_0) = (a, b)
* (x_n, y_n) = (c, d)
* For every i (0 \leq i \leq n-1), (x_i, y_i) and (x_{i+1}, y_{i+1}) share a side.
Constraints
* 1 \leq Q \leq 10000
* 1 \leq a_i, b_i, c_i, d_i \leq 3^{30}
* (a_i, b_i) \neq (c_i, d_i)
* (a_i, b_i) and (c_i, d_i) are white squares.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
Q
a_1 \ b_1 \ c_1 \ d_1
:
a_Q \ b_Q \ c_Q \ d_Q
Output
Print Q lines. The i-th line should contain the distance from (a_i, b_i) to (c_i, d_i).
Example
Input
2
4 2 7 4
9 9 1 9
Output
5
8 | instruction | 0 | 29,760 | 23 | 59,520 |
"Correct Solution:
```
q=abs;s=lambda t,i:0--t//3**i;m=lambda a,b,c,d:max([i for i in range(30)if s(a,i)==s(c,i)and s(a,i)%3==2and 1<q(s(b,i)-s(d,i))]+[-1])+1
for _ in[0]*int(input()):
a,b,c,d=map(int,input().split());h=m(a,b,c,d);w=m(b,a,d,c)
if h==w==0:print(q(b-d)+q(a-c));continue
if h<w:h,a,b,c,d=w,b,a,d,c
i=3**h//3;x=2*i+1;g=a-(a-1)%(3*i)-1;a-=g;c-=g;print(q(b-d)+min(q(i-a)+q(i-c),q(x-a)+q(x-c)))
``` | output | 1 | 29,760 | 23 | 59,521 |
Provide a correct Python 3 solution for this coding contest problem.
For a non-negative integer K, we define a fractal of level K as follows:
* A fractal of level 0 is a grid with just one white square.
* When K > 0, a fractal of level K is a 3^K \times 3^K grid. If we divide this grid into nine 3^{K-1} \times 3^{K-1} subgrids:
* The central subgrid consists of only black squares.
* Each of the other eight subgrids is a fractal of level K-1.
For example, a fractal of level 2 is as follows:
A fractal of level 2
In a fractal of level 30, let (r, c) denote the square at the r-th row from the top and the c-th column from the left.
You are given Q quadruples of integers (a_i, b_i, c_i, d_i). For each quadruple, find the distance from (a_i, b_i) to (c_i, d_i).
Here the distance from (a, b) to (c, d) is the minimum integer n that satisfies the following condition:
* There exists a sequence of white squares (x_0, y_0), \ldots, (x_n, y_n) satisfying the following conditions:
* (x_0, y_0) = (a, b)
* (x_n, y_n) = (c, d)
* For every i (0 \leq i \leq n-1), (x_i, y_i) and (x_{i+1}, y_{i+1}) share a side.
Constraints
* 1 \leq Q \leq 10000
* 1 \leq a_i, b_i, c_i, d_i \leq 3^{30}
* (a_i, b_i) \neq (c_i, d_i)
* (a_i, b_i) and (c_i, d_i) are white squares.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
Q
a_1 \ b_1 \ c_1 \ d_1
:
a_Q \ b_Q \ c_Q \ d_Q
Output
Print Q lines. The i-th line should contain the distance from (a_i, b_i) to (c_i, d_i).
Example
Input
2
4 2 7 4
9 9 1 9
Output
5
8 | instruction | 0 | 29,761 | 23 | 59,522 |
"Correct Solution:
```
Q=int(input())
Query=[tuple(map(int,input().split())) for i in range(Q)]
B=[(3,2)]
for i in range(2,31):
B.append((3**i,B[-1][1]+3**(i-1)))
for a,b,c,d in Query:
MINX=min(a,c)
MAXX=max(a,c)
MINY=min(b,d)
MAXY=max(b,d)
flag=0
for i in range(29,-1,-1):
r,q=B[i]
l=3**i
xcen=-(-(MINX-q)//r)*r+q
ycen=-(-(MINY-q)//r)*r+q
for xq in [xcen-r,xcen,xcen+r]:
for yq in [ycen-r,ycen,ycen+r]:
#print(xq,yq,MINX,MAXX,xq-l//2,xq+l//2,MINY,MAXY,yq-l//2,yq+l//2)
if (MINX<xq-l//2 and xq+l//2<MAXX) and (yq-l//2<=MINY and MAXY<=yq+l//2):
#print(xq,yq,l)
flag=1
break
if (xq-l//2<=MINX and MAXX<=xq+l//2) and (MINY<yq-l//2 and yq+l//2<MAXY):
#print(xq,yq,l)
flag=2
break
if flag!=0:
break
if flag!=0:
break
if flag==0:
print(MAXX-MINX+MAXY-MINY)
elif flag==1:
ANS=MAXX-MINX
y1=yq+l//2+1
y2=yq-l//2-1
ANS+=min(abs(y1-b)+abs(y1-d),abs(y2-b)+abs(y2-d))
print(ANS)
else:
ANS=MAXY-MINY
x1=xq+l//2+1
x2=xq-l//2-1
ANS+=min(abs(x1-a)+abs(x1-c),abs(x2-a)+abs(x2-c))
print(ANS)
``` | output | 1 | 29,761 | 23 | 59,523 |
Provide a correct Python 3 solution for this coding contest problem.
For a non-negative integer K, we define a fractal of level K as follows:
* A fractal of level 0 is a grid with just one white square.
* When K > 0, a fractal of level K is a 3^K \times 3^K grid. If we divide this grid into nine 3^{K-1} \times 3^{K-1} subgrids:
* The central subgrid consists of only black squares.
* Each of the other eight subgrids is a fractal of level K-1.
For example, a fractal of level 2 is as follows:
A fractal of level 2
In a fractal of level 30, let (r, c) denote the square at the r-th row from the top and the c-th column from the left.
You are given Q quadruples of integers (a_i, b_i, c_i, d_i). For each quadruple, find the distance from (a_i, b_i) to (c_i, d_i).
Here the distance from (a, b) to (c, d) is the minimum integer n that satisfies the following condition:
* There exists a sequence of white squares (x_0, y_0), \ldots, (x_n, y_n) satisfying the following conditions:
* (x_0, y_0) = (a, b)
* (x_n, y_n) = (c, d)
* For every i (0 \leq i \leq n-1), (x_i, y_i) and (x_{i+1}, y_{i+1}) share a side.
Constraints
* 1 \leq Q \leq 10000
* 1 \leq a_i, b_i, c_i, d_i \leq 3^{30}
* (a_i, b_i) \neq (c_i, d_i)
* (a_i, b_i) and (c_i, d_i) are white squares.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
Q
a_1 \ b_1 \ c_1 \ d_1
:
a_Q \ b_Q \ c_Q \ d_Q
Output
Print Q lines. The i-th line should contain the distance from (a_i, b_i) to (c_i, d_i).
Example
Input
2
4 2 7 4
9 9 1 9
Output
5
8 | instruction | 0 | 29,762 | 23 | 59,524 |
"Correct Solution:
```
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def solve(A,B,C,D,E=3**30):
# 大きさEの穴まで考慮
if not E:
return abs(A-C) + abs(B-D)
a = A//E
b = B//E
c = C//E
d = D//E
if a != c and b != d:
return abs(A-C) + abs(B-D)
if a == c and b == d:
return solve(A,B,C,D,E//3)
if b == d and a != c:
A,B = B,A
a,b = b,a
C,D = D,C
c,d = d,c
if a == c and b != d:
if a % 3 != 1:
return solve(A,B,C,D,E//3)
if abs(b-d) == 1:
return solve(A,B,C,D,E//3)
if B > D:
A,B,C,D = C,D,A,B
a,b,c,d = c,d,a,b
x1 = E * a - 1
y1 = E * (b+1) - 1
y2 = E * d
dist1 = abs(x1-A) + abs(y1-B) + abs(y1-y2) + abs(x1-C) + abs(y2-D)
x1 = E * (a+1)
y1 = E * (b+1) - 1
y2 = E * d
dist2 = abs(x1-A) + abs(y1-B) + abs(y1-y2) + abs(x1-C) + abs(y2-D)
return min(dist1, dist2)
solve(2,1,3,1)
N = int(readline())
m = map(int,read().split())
for A,B,C,D in zip(m,m,m,m):
print(solve(A-1,B-1,C-1,D-1,3**30))
``` | output | 1 | 29,762 | 23 | 59,525 |
Provide a correct Python 3 solution for this coding contest problem.
For a non-negative integer K, we define a fractal of level K as follows:
* A fractal of level 0 is a grid with just one white square.
* When K > 0, a fractal of level K is a 3^K \times 3^K grid. If we divide this grid into nine 3^{K-1} \times 3^{K-1} subgrids:
* The central subgrid consists of only black squares.
* Each of the other eight subgrids is a fractal of level K-1.
For example, a fractal of level 2 is as follows:
A fractal of level 2
In a fractal of level 30, let (r, c) denote the square at the r-th row from the top and the c-th column from the left.
You are given Q quadruples of integers (a_i, b_i, c_i, d_i). For each quadruple, find the distance from (a_i, b_i) to (c_i, d_i).
Here the distance from (a, b) to (c, d) is the minimum integer n that satisfies the following condition:
* There exists a sequence of white squares (x_0, y_0), \ldots, (x_n, y_n) satisfying the following conditions:
* (x_0, y_0) = (a, b)
* (x_n, y_n) = (c, d)
* For every i (0 \leq i \leq n-1), (x_i, y_i) and (x_{i+1}, y_{i+1}) share a side.
Constraints
* 1 \leq Q \leq 10000
* 1 \leq a_i, b_i, c_i, d_i \leq 3^{30}
* (a_i, b_i) \neq (c_i, d_i)
* (a_i, b_i) and (c_i, d_i) are white squares.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
Q
a_1 \ b_1 \ c_1 \ d_1
:
a_Q \ b_Q \ c_Q \ d_Q
Output
Print Q lines. The i-th line should contain the distance from (a_i, b_i) to (c_i, d_i).
Example
Input
2
4 2 7 4
9 9 1 9
Output
5
8 | instruction | 0 | 29,763 | 23 | 59,526 |
"Correct Solution:
```
def solve(A,B,C,D, level):
E = 3**level
if level == -1:
return int(abs(A-C) + abs(B-D))
a,b,c,d = A//E, B//E, C//E, D//E
if a != c and b != d:
return int(abs(A-C) + abs(B-D))
if a == c and b==d:
return solve(A,B,C,D,level-1)
if a != c and b==d:
A,B,C,D = B,A,D,C
a,b,c,d = b,a,d,c
if b != d and a == c:
if a%3 != 1:
return solve(A,B,C,D,level-1)
if abs(b-d) == 1:
return solve(A,B,C,D,level-1)
if B > D:
A, B, C, D = C, D, A, B
a, b, c, d = c, d, a, b
x = E * a -1
y1 = E * (b+1) -1
y2 = E * d
d = abs(x-A) + abs(y1-B) + abs(y1-y2) + abs(x-C) + abs(y2-D)
x = E *(a+1)
d2 = abs(x-A) + abs(y1-B) + abs(y1-y2) + abs(x-C) + abs(y2-D)
return min(d,d2)
N = int(input())
for i in range(N):
sg = [int(j.strip()) for j in input().split(' ')]
s,g = [sg[0]-1,sg[1]-1],[sg[2]-1,sg[3]-1]
A,B,C,D = s[0],s[1],g[0],g[1]
print(solve(A,B,C,D,30))
``` | output | 1 | 29,763 | 23 | 59,527 |
Provide a correct Python 3 solution for this coding contest problem.
For a non-negative integer K, we define a fractal of level K as follows:
* A fractal of level 0 is a grid with just one white square.
* When K > 0, a fractal of level K is a 3^K \times 3^K grid. If we divide this grid into nine 3^{K-1} \times 3^{K-1} subgrids:
* The central subgrid consists of only black squares.
* Each of the other eight subgrids is a fractal of level K-1.
For example, a fractal of level 2 is as follows:
A fractal of level 2
In a fractal of level 30, let (r, c) denote the square at the r-th row from the top and the c-th column from the left.
You are given Q quadruples of integers (a_i, b_i, c_i, d_i). For each quadruple, find the distance from (a_i, b_i) to (c_i, d_i).
Here the distance from (a, b) to (c, d) is the minimum integer n that satisfies the following condition:
* There exists a sequence of white squares (x_0, y_0), \ldots, (x_n, y_n) satisfying the following conditions:
* (x_0, y_0) = (a, b)
* (x_n, y_n) = (c, d)
* For every i (0 \leq i \leq n-1), (x_i, y_i) and (x_{i+1}, y_{i+1}) share a side.
Constraints
* 1 \leq Q \leq 10000
* 1 \leq a_i, b_i, c_i, d_i \leq 3^{30}
* (a_i, b_i) \neq (c_i, d_i)
* (a_i, b_i) and (c_i, d_i) are white squares.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
Q
a_1 \ b_1 \ c_1 \ d_1
:
a_Q \ b_Q \ c_Q \ d_Q
Output
Print Q lines. The i-th line should contain the distance from (a_i, b_i) to (c_i, d_i).
Example
Input
2
4 2 7 4
9 9 1 9
Output
5
8 | instruction | 0 | 29,764 | 23 | 59,528 |
"Correct Solution:
```
# PANA2020
q = int(input())
query = [tuple(map(int, input().split())) for _ in range(q)]
def man(a, b, c, d):
return abs(a - c) + abs(b - d)
def solve(a, b, c, d, i, carry):
if (a, b) == (c, d):
return carry
if i == 29:
if (a, c) == (1, 1) or (b, d) == (1, 1):
return 4 + carry
else:
return man(a,b,c,d) + carry
k = 3 ** (30 - 1 - i)
ga = a // k
gb = b // k
gc = c // k
gd = d // k
if (ga, gb) == (gc, gd):
a %= k
b %= k
c %= k
d %= k
return solve(a,b,c,d,i+1,carry)
if ga != gc and gb != gd:
return man(a,b,c,d) + carry
if gb == gd:
a,b,c,d = b,a,d,c
ga = a // k
gb = b // k
gc = c // k
gd = d // k
if ga == 1:
return carry + abs(b - d) + min(a+c - 2*(k-1), 4*k - a - c)
if b > d:
a,b,c,d = c,d,a,b
ga = a // k
gb = b // k
gc = c // k
gd = d // k
# ga == gc != 1 and gb < gd
a %= k
c %= k
kk = k // 3
gga = a // kk
ggb = b // kk
ggc = c // kk
ggd = d // kk
if ggd - ggb == 1:
if gga == ggc:
return solve(a % kk, b % kk, c % kk, d % kk + kk, i+1, carry)
else:
return man(a,b,c,d) + carry
else:
nb = b % kk
nd = d % kk + 2 * kk
carry += (d - b) - (nd - nb)
return solve(a,nb,c,nd,i+1,carry)
for a, b, c, d in query:
print(solve(a-1,b-1,c-1,d-1,0,0))
``` | output | 1 | 29,764 | 23 | 59,529 |
Provide a correct Python 3 solution for this coding contest problem.
For a non-negative integer K, we define a fractal of level K as follows:
* A fractal of level 0 is a grid with just one white square.
* When K > 0, a fractal of level K is a 3^K \times 3^K grid. If we divide this grid into nine 3^{K-1} \times 3^{K-1} subgrids:
* The central subgrid consists of only black squares.
* Each of the other eight subgrids is a fractal of level K-1.
For example, a fractal of level 2 is as follows:
A fractal of level 2
In a fractal of level 30, let (r, c) denote the square at the r-th row from the top and the c-th column from the left.
You are given Q quadruples of integers (a_i, b_i, c_i, d_i). For each quadruple, find the distance from (a_i, b_i) to (c_i, d_i).
Here the distance from (a, b) to (c, d) is the minimum integer n that satisfies the following condition:
* There exists a sequence of white squares (x_0, y_0), \ldots, (x_n, y_n) satisfying the following conditions:
* (x_0, y_0) = (a, b)
* (x_n, y_n) = (c, d)
* For every i (0 \leq i \leq n-1), (x_i, y_i) and (x_{i+1}, y_{i+1}) share a side.
Constraints
* 1 \leq Q \leq 10000
* 1 \leq a_i, b_i, c_i, d_i \leq 3^{30}
* (a_i, b_i) \neq (c_i, d_i)
* (a_i, b_i) and (c_i, d_i) are white squares.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
Q
a_1 \ b_1 \ c_1 \ d_1
:
a_Q \ b_Q \ c_Q \ d_Q
Output
Print Q lines. The i-th line should contain the distance from (a_i, b_i) to (c_i, d_i).
Example
Input
2
4 2 7 4
9 9 1 9
Output
5
8 | instruction | 0 | 29,765 | 23 | 59,530 |
"Correct Solution:
```
import sys
input=sys.stdin.readline
def dist(a,b,c,d,P3):
for p in P3:
da,ma=divmod(a,p)
dc,mc=divmod(c,p)
if da!=dc:
return abs(a-c)+abs(b-d)
if da!=1:
a,c=ma,mc
continue
db,mb=divmod(b,p)
dd,md=divmod(d,p)
if abs(db-dd)<2:
a,c=ma,mc
continue
return min(ma+mc+2,2*p-(ma+mc))+abs(b-d)
return abs(a-c)+abs(b-d)
def main():
q=int(input())
P3=[pow(3,i) for i in reversed(range(30))]
for _ in range(q):
a,b,c,d=map(lambda x: int(x)-1,input().split())
print(max(dist(a,b,c,d,P3),dist(b,a,d,c,P3)))
if __name__=='__main__':
main()
``` | output | 1 | 29,765 | 23 | 59,531 |
Provide a correct Python 3 solution for this coding contest problem.
For a non-negative integer K, we define a fractal of level K as follows:
* A fractal of level 0 is a grid with just one white square.
* When K > 0, a fractal of level K is a 3^K \times 3^K grid. If we divide this grid into nine 3^{K-1} \times 3^{K-1} subgrids:
* The central subgrid consists of only black squares.
* Each of the other eight subgrids is a fractal of level K-1.
For example, a fractal of level 2 is as follows:
A fractal of level 2
In a fractal of level 30, let (r, c) denote the square at the r-th row from the top and the c-th column from the left.
You are given Q quadruples of integers (a_i, b_i, c_i, d_i). For each quadruple, find the distance from (a_i, b_i) to (c_i, d_i).
Here the distance from (a, b) to (c, d) is the minimum integer n that satisfies the following condition:
* There exists a sequence of white squares (x_0, y_0), \ldots, (x_n, y_n) satisfying the following conditions:
* (x_0, y_0) = (a, b)
* (x_n, y_n) = (c, d)
* For every i (0 \leq i \leq n-1), (x_i, y_i) and (x_{i+1}, y_{i+1}) share a side.
Constraints
* 1 \leq Q \leq 10000
* 1 \leq a_i, b_i, c_i, d_i \leq 3^{30}
* (a_i, b_i) \neq (c_i, d_i)
* (a_i, b_i) and (c_i, d_i) are white squares.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
Q
a_1 \ b_1 \ c_1 \ d_1
:
a_Q \ b_Q \ c_Q \ d_Q
Output
Print Q lines. The i-th line should contain the distance from (a_i, b_i) to (c_i, d_i).
Example
Input
2
4 2 7 4
9 9 1 9
Output
5
8 | instruction | 0 | 29,766 | 23 | 59,532 |
"Correct Solution:
```
import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def MI1(): return map(int1, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]
def solve(ai,aj,bi,bj):
s=pow(3,30)
dist=abs(ai-bi)+abs(aj-bj)
while s>1:
s//=3
si,sj,ti,tj=ai//s,aj//s,bi//s,bj//s
if si!=ti:
return dist
if abs(sj-tj)>1 and si%3==1:
up=s*si-1
down=s*(si+1)
return min(min(ai,bi)-up,down-max(ai,bi))*2+dist
return dist
def main():
q=II()
for _ in range(q):
ai,aj,bi,bj=MI1()
if abs(ai-bi)>abs(aj-bj):ai,aj,bi,bj=aj,ai,bj,bi
print(solve(ai,aj,bi,bj))
main()
``` | output | 1 | 29,766 | 23 | 59,533 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For a non-negative integer K, we define a fractal of level K as follows:
* A fractal of level 0 is a grid with just one white square.
* When K > 0, a fractal of level K is a 3^K \times 3^K grid. If we divide this grid into nine 3^{K-1} \times 3^{K-1} subgrids:
* The central subgrid consists of only black squares.
* Each of the other eight subgrids is a fractal of level K-1.
For example, a fractal of level 2 is as follows:
A fractal of level 2
In a fractal of level 30, let (r, c) denote the square at the r-th row from the top and the c-th column from the left.
You are given Q quadruples of integers (a_i, b_i, c_i, d_i). For each quadruple, find the distance from (a_i, b_i) to (c_i, d_i).
Here the distance from (a, b) to (c, d) is the minimum integer n that satisfies the following condition:
* There exists a sequence of white squares (x_0, y_0), \ldots, (x_n, y_n) satisfying the following conditions:
* (x_0, y_0) = (a, b)
* (x_n, y_n) = (c, d)
* For every i (0 \leq i \leq n-1), (x_i, y_i) and (x_{i+1}, y_{i+1}) share a side.
Constraints
* 1 \leq Q \leq 10000
* 1 \leq a_i, b_i, c_i, d_i \leq 3^{30}
* (a_i, b_i) \neq (c_i, d_i)
* (a_i, b_i) and (c_i, d_i) are white squares.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
Q
a_1 \ b_1 \ c_1 \ d_1
:
a_Q \ b_Q \ c_Q \ d_Q
Output
Print Q lines. The i-th line should contain the distance from (a_i, b_i) to (c_i, d_i).
Example
Input
2
4 2 7 4
9 9 1 9
Output
5
8
Submitted Solution:
```
# coding: utf-8
import math
Q = int(input())
A = [list(map(int, input().split())) for _ in range(Q)]
def measure(A):
a,b,c,d = A
if abs(a-c) < abs(b-d):
s1, s2 = min([a,c]), max([a,c])
l1, l2 = min([b,d]), max([b,d])
else:
l1, l2 = min([a,c]), max([a,c])
s1, s2 = min([b,d]), max([b,d])
min_K = int(math.log(s2-s1+1, 3) + 1)
max_K = int(math.log(l2-l1+1, 3) + 1)
for k in list(range(min_K, max_K+1))[::-1]:
v = 3 ** k
_l = 3 ** (k-1) + 1
_h = (3 ** (k-1)) * 2
c1 = s1//v == s2//v
c2 = (s1 % v <= _h) & (_l <= s1 % v)
c3 = (s2 % v <= _h) & (_l <= s2 % v)
c4 = True
if (l1 // v) == (l2 // v):
if (l1 % v < _l) & (l2 % v > _h):
c4 = True
else:c4=False
if ((l1 // v) + 1) == (l2 // v):
if ((l2 % v < _l) & (l1 % v > _h)):
c4 = False
if c1 & c2 & c3 & c4:
val1 = (s1 % v - _l + 1) + (s2 % v - _l + 1) + (l2 - l1)
val2 = (_h - s1 % v + 1) + (_h - s2 % v + 1) + (l2 - l1)
print(min([val1, val2]))
return None
print(l2-l1+s2-s1)
if __name__ == '__main__':
for val in A:
measure(val)
``` | instruction | 0 | 29,767 | 23 | 59,534 |
Yes | output | 1 | 29,767 | 23 | 59,535 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For a non-negative integer K, we define a fractal of level K as follows:
* A fractal of level 0 is a grid with just one white square.
* When K > 0, a fractal of level K is a 3^K \times 3^K grid. If we divide this grid into nine 3^{K-1} \times 3^{K-1} subgrids:
* The central subgrid consists of only black squares.
* Each of the other eight subgrids is a fractal of level K-1.
For example, a fractal of level 2 is as follows:
A fractal of level 2
In a fractal of level 30, let (r, c) denote the square at the r-th row from the top and the c-th column from the left.
You are given Q quadruples of integers (a_i, b_i, c_i, d_i). For each quadruple, find the distance from (a_i, b_i) to (c_i, d_i).
Here the distance from (a, b) to (c, d) is the minimum integer n that satisfies the following condition:
* There exists a sequence of white squares (x_0, y_0), \ldots, (x_n, y_n) satisfying the following conditions:
* (x_0, y_0) = (a, b)
* (x_n, y_n) = (c, d)
* For every i (0 \leq i \leq n-1), (x_i, y_i) and (x_{i+1}, y_{i+1}) share a side.
Constraints
* 1 \leq Q \leq 10000
* 1 \leq a_i, b_i, c_i, d_i \leq 3^{30}
* (a_i, b_i) \neq (c_i, d_i)
* (a_i, b_i) and (c_i, d_i) are white squares.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
Q
a_1 \ b_1 \ c_1 \ d_1
:
a_Q \ b_Q \ c_Q \ d_Q
Output
Print Q lines. The i-th line should contain the distance from (a_i, b_i) to (c_i, d_i).
Example
Input
2
4 2 7 4
9 9 1 9
Output
5
8
Submitted Solution:
```
import sys
def grid(p, level):
c = 3 ** level
return ((p[0] % (3 * c)) // c, (p[1] % (3 * c)) // c)
def sub(p1, p2, level):
# print('sub',(p1, p2, level))
if level < 0:
return abs(p1[0] - p2[0]) + abs(p1[1] - p2[1])
g1, g2 = grid(p1, level), grid(p2, level)
assert 0 <= g1[0] < 3
assert 0 <= g1[1] < 3
assert 0 <= g2[0] < 3
assert 0 <= g2[1] < 3
if g1[0] != g2[0]:
return abs(p1[0] - p2[0]) + abs(p1[1] - p2[1])
if g1[0] == 1:
c = 3 ** level
y1, y2 = p1[1] // c, p2[1] //c
if abs(y1 - y2) < 2:
return sub(p1, p2, level - 1)
i1, i2 = p1[0] % c, p2[0] % c
xp = min(i1 + i2 + 2, 2 * c - i1 - i2)
return xp + abs(p1[1] - p2[1])
return sub(p1, p2, level - 1)
def solve(p1, p2, level):
g1, g2 = grid(p1, level), grid(p2, level)
if g1 == g2:
if level == 0:
return 0
return solve(p1, p2, level - 1)
if g1[0] == g2[0]:
return sub(p1, p2, level)
elif g1[1] == g2[1]:
return sub((p1[1], p1[0]), (p2[1], p2[0]), level)
else:
return abs(p1[0] - p2[0]) + abs(p1[1] - p2[1])
q = int(input())
for i in range(q):
a, b, c, d = [int(x) - 1 for x in input().split()]
print(solve((a, b), (c, d), 30))
``` | instruction | 0 | 29,768 | 23 | 59,536 |
Yes | output | 1 | 29,768 | 23 | 59,537 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For a non-negative integer K, we define a fractal of level K as follows:
* A fractal of level 0 is a grid with just one white square.
* When K > 0, a fractal of level K is a 3^K \times 3^K grid. If we divide this grid into nine 3^{K-1} \times 3^{K-1} subgrids:
* The central subgrid consists of only black squares.
* Each of the other eight subgrids is a fractal of level K-1.
For example, a fractal of level 2 is as follows:
A fractal of level 2
In a fractal of level 30, let (r, c) denote the square at the r-th row from the top and the c-th column from the left.
You are given Q quadruples of integers (a_i, b_i, c_i, d_i). For each quadruple, find the distance from (a_i, b_i) to (c_i, d_i).
Here the distance from (a, b) to (c, d) is the minimum integer n that satisfies the following condition:
* There exists a sequence of white squares (x_0, y_0), \ldots, (x_n, y_n) satisfying the following conditions:
* (x_0, y_0) = (a, b)
* (x_n, y_n) = (c, d)
* For every i (0 \leq i \leq n-1), (x_i, y_i) and (x_{i+1}, y_{i+1}) share a side.
Constraints
* 1 \leq Q \leq 10000
* 1 \leq a_i, b_i, c_i, d_i \leq 3^{30}
* (a_i, b_i) \neq (c_i, d_i)
* (a_i, b_i) and (c_i, d_i) are white squares.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
Q
a_1 \ b_1 \ c_1 \ d_1
:
a_Q \ b_Q \ c_Q \ d_Q
Output
Print Q lines. The i-th line should contain the distance from (a_i, b_i) to (c_i, d_i).
Example
Input
2
4 2 7 4
9 9 1 9
Output
5
8
Submitted Solution:
```
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
q = int(input())
def _sub(a):
v = []
for i in range(35):
a,val = divmod(a,3)
v.append(val)
return v
def sub(a,b,c,d):
va,vb,vc,vd = _sub(a), _sub(b), _sub(c), _sub(d)
ans = 0
m1 = True
m2 = True
for i in reversed(range(35)):
aa,bb,cc,dd = va[i],vb[i],vc[i],vd[i]
if aa==cc==1 and m1 and ((m2 and bb!=dd) or (not m2 and abs(b-d)>2*pow(3,i))):
# print(aa,bb,cc,dd,m1,m2,i)
ta = a % pow(3,i)
tc = c % pow(3,i)
ans = abs(b-d) + min(ta+tc+2, 2*pow(3,i)-(ta+tc))
break
elif bb==dd==1 and m2 and ((m1 and aa!=cc) or (not m1 and abs(a-c)>2*pow(3,i))):
# print(aa,bb,cc,dd,m1,m2,i)
tb = b % pow(3,i)
td = d % pow(3,i)
ans = abs(a-c) + min(tb+td+2, 2*pow(3,i)-(tb+td))
break
else:
if aa!=cc:
m1 = False
if bb!=dd:
m2 = False
else:
ans = abs(a-c) + abs(b-d)
return ans
ans = [None]*q
for i in range(q):
a,b,c,d = list(map(lambda x: int(x)-1, input().split()))
ans[i] = sub(a,b,c,d)
write("\n".join(map(str, ans)))
``` | instruction | 0 | 29,769 | 23 | 59,538 |
Yes | output | 1 | 29,769 | 23 | 59,539 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For a non-negative integer K, we define a fractal of level K as follows:
* A fractal of level 0 is a grid with just one white square.
* When K > 0, a fractal of level K is a 3^K \times 3^K grid. If we divide this grid into nine 3^{K-1} \times 3^{K-1} subgrids:
* The central subgrid consists of only black squares.
* Each of the other eight subgrids is a fractal of level K-1.
For example, a fractal of level 2 is as follows:
A fractal of level 2
In a fractal of level 30, let (r, c) denote the square at the r-th row from the top and the c-th column from the left.
You are given Q quadruples of integers (a_i, b_i, c_i, d_i). For each quadruple, find the distance from (a_i, b_i) to (c_i, d_i).
Here the distance from (a, b) to (c, d) is the minimum integer n that satisfies the following condition:
* There exists a sequence of white squares (x_0, y_0), \ldots, (x_n, y_n) satisfying the following conditions:
* (x_0, y_0) = (a, b)
* (x_n, y_n) = (c, d)
* For every i (0 \leq i \leq n-1), (x_i, y_i) and (x_{i+1}, y_{i+1}) share a side.
Constraints
* 1 \leq Q \leq 10000
* 1 \leq a_i, b_i, c_i, d_i \leq 3^{30}
* (a_i, b_i) \neq (c_i, d_i)
* (a_i, b_i) and (c_i, d_i) are white squares.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
Q
a_1 \ b_1 \ c_1 \ d_1
:
a_Q \ b_Q \ c_Q \ d_Q
Output
Print Q lines. The i-th line should contain the distance from (a_i, b_i) to (c_i, d_i).
Example
Input
2
4 2 7 4
9 9 1 9
Output
5
8
Submitted Solution:
```
import itertools
import os
import sys
if os.getenv("LOCAL"):
sys.stdin = open("_in.txt", "r")
sys.setrecursionlimit(10 ** 9)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7
# MOD = 998244353
def get_block(X1, Y1, X2, Y2):
# x1 から x2 の間にある、y方向の両端が y1 と y2 より大きいブロック
if X1 > X2:
X1, X2 = X2, X1
if Y1 > Y2:
Y1, Y2 = Y2, Y1
size = pow(3, 30)
for level in reversed(range(31)):
x1 = X1 // size
x2 = X2 // size
y1 = Y1 // size
y2 = Y2 // size
if y1 == y2 and y1 % 3 == y2 % 3 == 1:
# x1 と x2 の間に 1, 4, 7, ... があればそれ
if x2 - x1 >= 2:
while x1 % 3 != 1:
x1 += 1
return x1 * size, y1 * size, size
if x1 == x2 and x1 % 3 == x2 % 3 == 1:
if y2 - y1 >= 2:
while y1 % 3 != 1:
y1 += 1
return x1 * size, y1 * size, size
size //= 3
return None
def dist(x1, y1, x2, y2):
return abs(x1 - x2) + abs(y1 - y2)
def solve(X1, Y1, X2, Y2):
# 一番大きい障害物を知りたい
block = get_block(X1, Y1, X2, Y2)
ret = INF
if block:
x, y, size = block
for x, y in itertools.product((x - 1, x + size), (y - 1, y + size)):
ret = min(ret, dist(X1, Y1, x, y) + dist(X2, Y2, x, y))
else:
ret = min(ret, dist(X1, Y1, X2, Y2))
return ret
Q = int(sys.stdin.buffer.readline())
ABCD = [list(map(int, sys.stdin.buffer.readline().split())) for _ in range(Q)]
for a, b, c, d in ABCD:
a -= 1
b -= 1
c -= 1
d -= 1
ans = solve(a, b, c, d)
print(ans)
``` | instruction | 0 | 29,770 | 23 | 59,540 |
Yes | output | 1 | 29,770 | 23 | 59,541 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For a non-negative integer K, we define a fractal of level K as follows:
* A fractal of level 0 is a grid with just one white square.
* When K > 0, a fractal of level K is a 3^K \times 3^K grid. If we divide this grid into nine 3^{K-1} \times 3^{K-1} subgrids:
* The central subgrid consists of only black squares.
* Each of the other eight subgrids is a fractal of level K-1.
For example, a fractal of level 2 is as follows:
A fractal of level 2
In a fractal of level 30, let (r, c) denote the square at the r-th row from the top and the c-th column from the left.
You are given Q quadruples of integers (a_i, b_i, c_i, d_i). For each quadruple, find the distance from (a_i, b_i) to (c_i, d_i).
Here the distance from (a, b) to (c, d) is the minimum integer n that satisfies the following condition:
* There exists a sequence of white squares (x_0, y_0), \ldots, (x_n, y_n) satisfying the following conditions:
* (x_0, y_0) = (a, b)
* (x_n, y_n) = (c, d)
* For every i (0 \leq i \leq n-1), (x_i, y_i) and (x_{i+1}, y_{i+1}) share a side.
Constraints
* 1 \leq Q \leq 10000
* 1 \leq a_i, b_i, c_i, d_i \leq 3^{30}
* (a_i, b_i) \neq (c_i, d_i)
* (a_i, b_i) and (c_i, d_i) are white squares.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
Q
a_1 \ b_1 \ c_1 \ d_1
:
a_Q \ b_Q \ c_Q \ d_Q
Output
Print Q lines. The i-th line should contain the distance from (a_i, b_i) to (c_i, d_i).
Example
Input
2
4 2 7 4
9 9 1 9
Output
5
8
Submitted Solution:
```
def dist(a,b,c,d,n):
L=3**n
area1=(a//L)*3+b//L
if area1==2:
b=L*3-b-1
d=L*3-d-1
if area1==3:
a,b=b,a
c,d=d,c
if area1==5:
a,b=L*3-b-1,a
c,d=L*3-d-1,c
if area1 in [6,7]:
a=L*3-a-1
c=L*3-c-1
if area1==8:
a,b=L*3-a-1,L*3-b-1
c,d=L*3-c-1,L*3-d-1
area1=(a//L)*3+b//L
area2=(c//L)*3+d//L
if n==1:
if area1==1 and area2==7: return 4
else: return abs(a-c)+abs(b-d)
if area1>area2:
a,b,c,d=c,d,a,b
area1,area2=area2,area1
if area1==area2:
return dist(a%L,b%L,c%L,d%L,n-1)
elif area1==0:
if area2 in [5,7,8]:
return abs(a-c)+abs(b-d)
elif area2 in [3,6]:
return dist(b,a,d,c,n)
elif area2 in [1,2]:
L=3**(n-1)
a12=(a//L)*3+b//L
a22=(c//L)*3+(d-3*area2*L)//L
if a//L!=c//L:
return abs(a-c)+abs(b-d)
elif a//L==0:
p=(d//L)-(b//L)
if p==1: return dist(a,b-2*L,c,d-2*L,n-1)
else: dist(a,b%L,c,d-(p-2)*L,n-1)+(p-2)*L
elif a//L==1:
if area2==1 and a12==5 and a22==3:
return dist(a-L,b-2*L,c-L,d-2*L,n-1)
else:
return min(a+c-2*(L-1),4*L-a-c)+abs(b-d)
elif a//L==2: return dist(a-2*L,b,c-2*L,d,n)
else: return 0
elif area1==1:
if area2 in [3,5,6,8]:
return abs(a-c)+abs(b-d)
elif area2==2:
return dist(a,b-L,c,d-L,n)
elif area2==7:
return min(b+d-2*(L-1),(4*L)-b-d)+abs(a-c)
else: return 0
for i in range(int(input())):
a,b,c,d=map(int,input().split())
print(dist(a-1,b-1,c-1,d-1,29))
``` | instruction | 0 | 29,771 | 23 | 59,542 |
No | output | 1 | 29,771 | 23 | 59,543 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For a non-negative integer K, we define a fractal of level K as follows:
* A fractal of level 0 is a grid with just one white square.
* When K > 0, a fractal of level K is a 3^K \times 3^K grid. If we divide this grid into nine 3^{K-1} \times 3^{K-1} subgrids:
* The central subgrid consists of only black squares.
* Each of the other eight subgrids is a fractal of level K-1.
For example, a fractal of level 2 is as follows:
A fractal of level 2
In a fractal of level 30, let (r, c) denote the square at the r-th row from the top and the c-th column from the left.
You are given Q quadruples of integers (a_i, b_i, c_i, d_i). For each quadruple, find the distance from (a_i, b_i) to (c_i, d_i).
Here the distance from (a, b) to (c, d) is the minimum integer n that satisfies the following condition:
* There exists a sequence of white squares (x_0, y_0), \ldots, (x_n, y_n) satisfying the following conditions:
* (x_0, y_0) = (a, b)
* (x_n, y_n) = (c, d)
* For every i (0 \leq i \leq n-1), (x_i, y_i) and (x_{i+1}, y_{i+1}) share a side.
Constraints
* 1 \leq Q \leq 10000
* 1 \leq a_i, b_i, c_i, d_i \leq 3^{30}
* (a_i, b_i) \neq (c_i, d_i)
* (a_i, b_i) and (c_i, d_i) are white squares.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
Q
a_1 \ b_1 \ c_1 \ d_1
:
a_Q \ b_Q \ c_Q \ d_Q
Output
Print Q lines. The i-th line should contain the distance from (a_i, b_i) to (c_i, d_i).
Example
Input
2
4 2 7 4
9 9 1 9
Output
5
8
Submitted Solution:
```
q = int(input())
for _ in range(q):
a,b,c,d = map(int,input().split())
ans=abs(c-a)+abs(d-b)
for i in range(1,31):
am=a%(3**i)
bm=b%(3**i)
cm=c%(3**i)
dm=d%(3**i)
if 3**(i-1)<am<=2*3**(i-1) and 3**(i-1)<cm<=2*3**(i-1) and a//(3**i) == c//(3**i) and b//(3**(i-1)) != d//(3**(i-1)):
ans+=2
if 3**(i-1)<bm<=2*3**(i-1) and 3**(i-1)<dm<=2*3**(i-1) and b//(3**i) == d//(3**i) and a//(3**(i-1)) != c//(3**(i-1)) :
ans+=2
print(ans)
``` | instruction | 0 | 29,772 | 23 | 59,544 |
No | output | 1 | 29,772 | 23 | 59,545 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For a non-negative integer K, we define a fractal of level K as follows:
* A fractal of level 0 is a grid with just one white square.
* When K > 0, a fractal of level K is a 3^K \times 3^K grid. If we divide this grid into nine 3^{K-1} \times 3^{K-1} subgrids:
* The central subgrid consists of only black squares.
* Each of the other eight subgrids is a fractal of level K-1.
For example, a fractal of level 2 is as follows:
A fractal of level 2
In a fractal of level 30, let (r, c) denote the square at the r-th row from the top and the c-th column from the left.
You are given Q quadruples of integers (a_i, b_i, c_i, d_i). For each quadruple, find the distance from (a_i, b_i) to (c_i, d_i).
Here the distance from (a, b) to (c, d) is the minimum integer n that satisfies the following condition:
* There exists a sequence of white squares (x_0, y_0), \ldots, (x_n, y_n) satisfying the following conditions:
* (x_0, y_0) = (a, b)
* (x_n, y_n) = (c, d)
* For every i (0 \leq i \leq n-1), (x_i, y_i) and (x_{i+1}, y_{i+1}) share a side.
Constraints
* 1 \leq Q \leq 10000
* 1 \leq a_i, b_i, c_i, d_i \leq 3^{30}
* (a_i, b_i) \neq (c_i, d_i)
* (a_i, b_i) and (c_i, d_i) are white squares.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
Q
a_1 \ b_1 \ c_1 \ d_1
:
a_Q \ b_Q \ c_Q \ d_Q
Output
Print Q lines. The i-th line should contain the distance from (a_i, b_i) to (c_i, d_i).
Example
Input
2
4 2 7 4
9 9 1 9
Output
5
8
Submitted Solution:
```
import sys
def solve(a, b, c, d):
""" Lv.i の中央の■を、上下(a,c)に迂回する """
for i in range(3, 0, -1):
# ここに到達している時点で、Lv.i 盤面の同じ横ならびに位置することは保証されている
d3i = d3[i - 1]
da, ma = divmod(a, d3i)
dc, mc = divmod(c, d3i)
if da != dc:
return abs(a - c) + abs(b - d)
if da != 1:
a, c = ma, mc
continue
db, mb = divmod(b, d3i)
dd, md = divmod(d, d3i)
if (abs(db - dd) < 2):
a, c = ma, mc
continue
return min(ma + mc + 2, 2 * d3i - (ma + mc)) + abs(b - d)
return abs(a - c) + abs(b - d)
d3 = [pow(3, i) for i in range(31)] + [0]
q = int(input())
buf = []
for line in sys.stdin:
a, b, c, d = map(int, line.split())
a -= 1
b -= 1
c -= 1
d -= 1
ans = max(solve(a, b, c, d), solve(b, a, d, c))
buf.append(ans)
print('\n'.join(map(str, buf)))
``` | instruction | 0 | 29,773 | 23 | 59,546 |
No | output | 1 | 29,773 | 23 | 59,547 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For a non-negative integer K, we define a fractal of level K as follows:
* A fractal of level 0 is a grid with just one white square.
* When K > 0, a fractal of level K is a 3^K \times 3^K grid. If we divide this grid into nine 3^{K-1} \times 3^{K-1} subgrids:
* The central subgrid consists of only black squares.
* Each of the other eight subgrids is a fractal of level K-1.
For example, a fractal of level 2 is as follows:
A fractal of level 2
In a fractal of level 30, let (r, c) denote the square at the r-th row from the top and the c-th column from the left.
You are given Q quadruples of integers (a_i, b_i, c_i, d_i). For each quadruple, find the distance from (a_i, b_i) to (c_i, d_i).
Here the distance from (a, b) to (c, d) is the minimum integer n that satisfies the following condition:
* There exists a sequence of white squares (x_0, y_0), \ldots, (x_n, y_n) satisfying the following conditions:
* (x_0, y_0) = (a, b)
* (x_n, y_n) = (c, d)
* For every i (0 \leq i \leq n-1), (x_i, y_i) and (x_{i+1}, y_{i+1}) share a side.
Constraints
* 1 \leq Q \leq 10000
* 1 \leq a_i, b_i, c_i, d_i \leq 3^{30}
* (a_i, b_i) \neq (c_i, d_i)
* (a_i, b_i) and (c_i, d_i) are white squares.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
Q
a_1 \ b_1 \ c_1 \ d_1
:
a_Q \ b_Q \ c_Q \ d_Q
Output
Print Q lines. The i-th line should contain the distance from (a_i, b_i) to (c_i, d_i).
Example
Input
2
4 2 7 4
9 9 1 9
Output
5
8
Submitted Solution:
```
def manh(a, b, c, d):
return abs(a-c)+abs(b-d)
def dist(a, b, c, d):
for i in range(30):
if a // 3**(29-i) % 3 == 1 and c // 3**(29-i) % 3 == 1 and abs(b-d) > 3 ** (29-i):
return manh(a, b, c, d) + min(abs((a % 3**(30-i)) - (3**(29-i)-1)), abs((c % 3**(30-i)) - (3**(29-i)-1)), abs((a % 3**(30-i)) - (2*3**(29-i))), abs((c % 3**(30-i)) - (2*3**(29-i))))*2
elif b // 3**(29-i) % 3 == 1 and d // 3**(29-i) % 3 == 1 and abs(a-c) > 3 ** (29-i):
return manh(a, b, c, d) + min(abs((b % 3**(30-i)) - (3**(29-i)-1)), abs((d % 3**(30-i)) - (3**(29-i)-1)), abs((b % 3**(30-i)) - (2*3**(29-i))), abs((d % 3**(30-i)) - (2*3**(29-i))))*2
else:
return manh(a, b, c, d)
q = int(input())
a = [0]*q
b = [0]*q
c = [0]*q
d = [0]*q
for i in range(q):
a[i], b[i], c[i], d[i] = map(int, input().split())
for i in range(q):
print(dist(a[i]-1, b[i]-1, c[i]-1, d[i]-1))
``` | instruction | 0 | 29,774 | 23 | 59,548 |
No | output | 1 | 29,774 | 23 | 59,549 |
Provide a correct Python 3 solution for this coding contest problem.
Seen from above, there is a grid-like square shaped like Figure 1. The presence or absence of "walls" on each side of this grid is represented by a sequence of 0s and 1s. Create a program that stands at point A, puts your right hand on the wall, keeps walking in the direction of the arrow, and outputs the route to return to point A again.
<image>
---
Figure 1
---
Input
The input consists of 9 lines and is given in the following format, with 1 being the presence of a wall and 0 being the absence of a wall, as shown in Figure 2 below.
The first line is a character string that indicates the presence or absence of the top horizontal line wall as 0 and 1 from the left.
The second line is a character string that indicates the presence or absence of the vertical line wall below it with 0 and 1 from the left.
The third line is a character string that indicates the presence or absence of the wall of the second horizontal line from the top by 0 and 1 from the left.
...
The 9th line is a character string representing the presence or absence of the bottom horizontal line wall with 0 and 1 from the left.
<image>
---
Figure 2 (Thick line shows where the wall is) (corresponding numbers)
However, as shown by the thick line in Fig. 1, it is assumed that there is always a wall for one section to the right of point A. That is, the first character on the first line is always 1.
Output
"Advance one section to the left of the figure" is "L", "Advance one section to the right of the figure" is "R", "Advance one section to the top of the figure" is "U", "Figure" "Advance one block downward" is represented by "D", and "L", "R", "U", and "D" are output in the order of advance.
Example
Input
1111
00001
0110
01011
0010
01111
0010
01001
0111
Output
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL | instruction | 0 | 29,903 | 23 | 59,806 |
"Correct Solution:
```
def idx_to_wxy(x, y, idx):
return (2 * x + 1 + (idx % 2) * (2 - idx), 2 * y + 1 + (1 - idx % 2) * (1 - idx))
ws = [[0]*11 for _ in range(11)]
for i in range(1, 10):
if i % 2:
ws[i][2], ws[i][4], ws[i][6], ws[i][8] = map(int, list(input()))
else:
ws[i][1], ws[i][3], ws[i][5], ws[i][7], ws[i][9] = map(int, list(input()))
x = y = 0
ds = list('RDLU')
d = 'R'
while True:
print(d, end='')
idx = ds.index(d)
x += (idx % 2) * (2 - idx)
y += (1 - idx % 2) * (1 - idx)
if x == y == 0:
break
for i in range(-1, 3):
if ws[idx_to_wxy(x, y, (idx + i) % 4)[0]][idx_to_wxy(x, y, (idx + i) % 4)[1]]:
d = ds[(idx + i) % 4]
break
print('')
``` | output | 1 | 29,903 | 23 | 59,807 |
Provide a correct Python 3 solution for this coding contest problem.
Seen from above, there is a grid-like square shaped like Figure 1. The presence or absence of "walls" on each side of this grid is represented by a sequence of 0s and 1s. Create a program that stands at point A, puts your right hand on the wall, keeps walking in the direction of the arrow, and outputs the route to return to point A again.
<image>
---
Figure 1
---
Input
The input consists of 9 lines and is given in the following format, with 1 being the presence of a wall and 0 being the absence of a wall, as shown in Figure 2 below.
The first line is a character string that indicates the presence or absence of the top horizontal line wall as 0 and 1 from the left.
The second line is a character string that indicates the presence or absence of the vertical line wall below it with 0 and 1 from the left.
The third line is a character string that indicates the presence or absence of the wall of the second horizontal line from the top by 0 and 1 from the left.
...
The 9th line is a character string representing the presence or absence of the bottom horizontal line wall with 0 and 1 from the left.
<image>
---
Figure 2 (Thick line shows where the wall is) (corresponding numbers)
However, as shown by the thick line in Fig. 1, it is assumed that there is always a wall for one section to the right of point A. That is, the first character on the first line is always 1.
Output
"Advance one section to the left of the figure" is "L", "Advance one section to the right of the figure" is "R", "Advance one section to the top of the figure" is "U", "Figure" "Advance one block downward" is represented by "D", and "L", "R", "U", and "D" are output in the order of advance.
Example
Input
1111
00001
0110
01011
0010
01111
0010
01001
0111
Output
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL | instruction | 0 | 29,904 | 23 | 59,808 |
"Correct Solution:
```
def is_wall(x1,y1,x2,y2):
if x1<0 or 4<x1 or y1<0 or 4<y1 or x2<0 or 4<x2 or y2<0 or 4<y2:
return False
elif x1 == x2:
if y1>y2: y1,y2 = y2,y1
if y2-y1 != 1: return False
return (walls[y1*2+1][x1] == "1")
elif y1 == y2:
if x1>x2: x1,x2 = x2,x1
if x2-x1 != 1: return False
return (walls[y1*2][x1] == "1")
else: return False
def nextmove(x,y):
lastmove = moves[-1]
if lastmove == 3: lastmove = -1
if lastmove < -1: lastmove += 4
if is_wall(x,y,x+direction[lastmove+1][1],y+direction[lastmove+1][2]):
return lastmove+1,x+direction[lastmove+1][1],y+direction[lastmove+1][2]
if is_wall(x,y,x+direction[lastmove][1],y+direction[lastmove][2]):
return lastmove,x+direction[lastmove][1],y+direction[lastmove][2]
if is_wall(x,y,x+direction[lastmove-1][1],y+direction[lastmove-1][2]):
return lastmove-1,x+direction[lastmove-1][1],y+direction[lastmove-1][2]
if is_wall(x,y,x+direction[lastmove-2][1],y+direction[lastmove-2][2]):
return lastmove-2,x+direction[lastmove-2][1],y+direction[lastmove-2][2]
direction = [["R",1,0],["U",0,-1],["L",-1,0],["D",0,1]]
walls = []
moves = [0]
for _ in range(9):
walls.append(input())
lastx = 1
lasty = 0
print("R", end = "")
while True:
move,lastx,lasty = nextmove(lastx, lasty)
moves.append(move)
print(direction[move][0], end = "")
if lastx == 0 and lasty == 0: break
print()
``` | output | 1 | 29,904 | 23 | 59,809 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Seen from above, there is a grid-like square shaped like Figure 1. The presence or absence of "walls" on each side of this grid is represented by a sequence of 0s and 1s. Create a program that stands at point A, puts your right hand on the wall, keeps walking in the direction of the arrow, and outputs the route to return to point A again.
<image>
---
Figure 1
---
Input
The input consists of 9 lines and is given in the following format, with 1 being the presence of a wall and 0 being the absence of a wall, as shown in Figure 2 below.
The first line is a character string that indicates the presence or absence of the top horizontal line wall as 0 and 1 from the left.
The second line is a character string that indicates the presence or absence of the vertical line wall below it with 0 and 1 from the left.
The third line is a character string that indicates the presence or absence of the wall of the second horizontal line from the top by 0 and 1 from the left.
...
The 9th line is a character string representing the presence or absence of the bottom horizontal line wall with 0 and 1 from the left.
<image>
---
Figure 2 (Thick line shows where the wall is) (corresponding numbers)
However, as shown by the thick line in Fig. 1, it is assumed that there is always a wall for one section to the right of point A. That is, the first character on the first line is always 1.
Output
"Advance one section to the left of the figure" is "L", "Advance one section to the right of the figure" is "R", "Advance one section to the top of the figure" is "U", "Figure" "Advance one block downward" is represented by "D", and "L", "R", "U", and "D" are output in the order of advance.
Example
Input
1111
00001
0110
01011
0010
01111
0010
01001
0111
Output
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
Submitted Solution:
```
import sys
readline = sys.stdin.readline
write = sys.stdout.write
def solve():
N = 5
MP = [[[0]*4 for i in range(N)] for j in range(N)]
dd = ((-1, 0), (0, -1), (1, 0), (0, 1))
ds = "LURD"
for i in range(N):
s = readline().strip()
for j in range(N-1):
if s[j] == '1':
MP[i][j][2] = MP[i][j+1][0] = 1
if i < 4:
s = readline().strip()
for j in range(N):
if s[j] == '1':
MP[i][j][3] = MP[i+1][j][1] = 1
x = 1; y = 0; cd = 2
de = [3, 0, 1, 2]
ans = [2]
while not x == y == 0:
e = MP[y][x]
for d in de:
if e[cd + d - 4]:
cd = (cd + d) % 4
ans.append(cd)
dx, dy = dd[cd]
x += dx; y += dy
break
write("".join(map(ds.__getitem__, ans)))
write("\n")
solve()
``` | instruction | 0 | 29,907 | 23 | 59,814 |
Yes | output | 1 | 29,907 | 23 | 59,815 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Seen from above, there is a grid-like square shaped like Figure 1. The presence or absence of "walls" on each side of this grid is represented by a sequence of 0s and 1s. Create a program that stands at point A, puts your right hand on the wall, keeps walking in the direction of the arrow, and outputs the route to return to point A again.
<image>
---
Figure 1
---
Input
The input consists of 9 lines and is given in the following format, with 1 being the presence of a wall and 0 being the absence of a wall, as shown in Figure 2 below.
The first line is a character string that indicates the presence or absence of the top horizontal line wall as 0 and 1 from the left.
The second line is a character string that indicates the presence or absence of the vertical line wall below it with 0 and 1 from the left.
The third line is a character string that indicates the presence or absence of the wall of the second horizontal line from the top by 0 and 1 from the left.
...
The 9th line is a character string representing the presence or absence of the bottom horizontal line wall with 0 and 1 from the left.
<image>
---
Figure 2 (Thick line shows where the wall is) (corresponding numbers)
However, as shown by the thick line in Fig. 1, it is assumed that there is always a wall for one section to the right of point A. That is, the first character on the first line is always 1.
Output
"Advance one section to the left of the figure" is "L", "Advance one section to the right of the figure" is "R", "Advance one section to the top of the figure" is "U", "Figure" "Advance one block downward" is represented by "D", and "L", "R", "U", and "D" are output in the order of advance.
Example
Input
1111
00001
0110
01011
0010
01111
0010
01001
0111
Output
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
Submitted Solution:
```
import sys
f = sys.stdin
board = [[0 for i in range(11)] for j in range(11)]
for i, line in enumerate(f):
for j, c in enumerate(line.strip()):
board[i + 1][1 + (i + 1) % 2 + j * 2] = int(c)
step = {(-1, 0 ):'L',(0, -1 ):'U',(1, 0 ):'R',(0, 1):'D'}
start = pre_loc = 1 + 1j
loc = 3 + 1j
print('R',end='')
while loc != start:
for direct in [(pre_loc - loc) / 2 * 1j ** (i + 1) for i in range(4)]:
if board[int(loc.imag + direct.imag)][int(loc.real + direct.real)]:
pre_loc = loc
loc += direct * 2
print(step[(direct.real,direct.imag)],end='')
break
print()
``` | instruction | 0 | 29,908 | 23 | 59,816 |
Yes | output | 1 | 29,908 | 23 | 59,817 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Seen from above, there is a grid-like square shaped like Figure 1. The presence or absence of "walls" on each side of this grid is represented by a sequence of 0s and 1s. Create a program that stands at point A, puts your right hand on the wall, keeps walking in the direction of the arrow, and outputs the route to return to point A again.
<image>
---
Figure 1
---
Input
The input consists of 9 lines and is given in the following format, with 1 being the presence of a wall and 0 being the absence of a wall, as shown in Figure 2 below.
The first line is a character string that indicates the presence or absence of the top horizontal line wall as 0 and 1 from the left.
The second line is a character string that indicates the presence or absence of the vertical line wall below it with 0 and 1 from the left.
The third line is a character string that indicates the presence or absence of the wall of the second horizontal line from the top by 0 and 1 from the left.
...
The 9th line is a character string representing the presence or absence of the bottom horizontal line wall with 0 and 1 from the left.
<image>
---
Figure 2 (Thick line shows where the wall is) (corresponding numbers)
However, as shown by the thick line in Fig. 1, it is assumed that there is always a wall for one section to the right of point A. That is, the first character on the first line is always 1.
Output
"Advance one section to the left of the figure" is "L", "Advance one section to the right of the figure" is "R", "Advance one section to the top of the figure" is "U", "Figure" "Advance one block downward" is represented by "D", and "L", "R", "U", and "D" are output in the order of advance.
Example
Input
1111
00001
0110
01011
0010
01111
0010
01001
0111
Output
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
Submitted Solution:
```
k = [[1,2,4,8],[4,8,1,2],[8,1,2,4],[2,4,8,1]]
m = [[0]*5 for _ in range(5)]
for i in range(9):
a = input()
if i%2:
for j in range(5):
if a[j] == '1':
m[i//2][j] |= 4
m[i//2+1][j] |= 1
else:
for j in range(4):
if a[j] == '1':
m[i//2][j] |= 2
m[i//2][j+1] |= 8
y,x,direct = 0,0,0
ans = []
while True:
for i in range(4):
if m[y][x] & k[direct][i]:
d = k[direct][i]
if d == 1: y -= 1; direct = 2
elif d == 2: x += 1; direct = 0
elif d == 4: y += 1; direct = 3
else : x -= 1; direct = 1
ans.append(direct)
break
if not ( x or y ): break
print("".join("RLUD"[e] for e in ans))
``` | instruction | 0 | 29,909 | 23 | 59,818 |
Yes | output | 1 | 29,909 | 23 | 59,819 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Seen from above, there is a grid-like square shaped like Figure 1. The presence or absence of "walls" on each side of this grid is represented by a sequence of 0s and 1s. Create a program that stands at point A, puts your right hand on the wall, keeps walking in the direction of the arrow, and outputs the route to return to point A again.
<image>
---
Figure 1
---
Input
The input consists of 9 lines and is given in the following format, with 1 being the presence of a wall and 0 being the absence of a wall, as shown in Figure 2 below.
The first line is a character string that indicates the presence or absence of the top horizontal line wall as 0 and 1 from the left.
The second line is a character string that indicates the presence or absence of the vertical line wall below it with 0 and 1 from the left.
The third line is a character string that indicates the presence or absence of the wall of the second horizontal line from the top by 0 and 1 from the left.
...
The 9th line is a character string representing the presence or absence of the bottom horizontal line wall with 0 and 1 from the left.
<image>
---
Figure 2 (Thick line shows where the wall is) (corresponding numbers)
However, as shown by the thick line in Fig. 1, it is assumed that there is always a wall for one section to the right of point A. That is, the first character on the first line is always 1.
Output
"Advance one section to the left of the figure" is "L", "Advance one section to the right of the figure" is "R", "Advance one section to the top of the figure" is "U", "Figure" "Advance one block downward" is represented by "D", and "L", "R", "U", and "D" are output in the order of advance.
Example
Input
1111
00001
0110
01011
0010
01111
0010
01001
0111
Output
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
Submitted Solution:
```
import sys
point = [[[0 for i in range(4)] for j in range(5)] for k in range(5)]
raw = 0
for line in sys.stdin:
way = list(map(int, line.strip()))
if len(way) == 4:
for col in range(4):
if way[col] == 1:
point[raw][col][1] = point[raw][col + 1][3] = 1
elif len(way) == 5:
for col in range(5):
if way[col] == 1:
point[raw][col][2] = point[raw + 1][col][0] = 1
raw += 1
dict = {0:"U", 1:"R", 2:"D", 3:"L"}
cold = [0, 1, 0, -1]
rawd = [-1, 0, 1, 0]
raw = 0
col = 0
nowd = 1
ans = ""
while True:
for dirc in [(x - 1) % 4 for x in range(nowd, nowd + 4)]:
if point[raw][col][dirc] == 1:
ans += dict[dirc]
raw += rawd[dirc]
col += cold[dirc]
nowd = dirc
break
if raw == 0 and col == 0:
break
print(ans)
``` | instruction | 0 | 29,910 | 23 | 59,820 |
Yes | output | 1 | 29,910 | 23 | 59,821 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Seen from above, there is a grid-like square shaped like Figure 1. The presence or absence of "walls" on each side of this grid is represented by a sequence of 0s and 1s. Create a program that stands at point A, puts your right hand on the wall, keeps walking in the direction of the arrow, and outputs the route to return to point A again.
<image>
---
Figure 1
---
Input
The input consists of 9 lines and is given in the following format, with 1 being the presence of a wall and 0 being the absence of a wall, as shown in Figure 2 below.
The first line is a character string that indicates the presence or absence of the top horizontal line wall as 0 and 1 from the left.
The second line is a character string that indicates the presence or absence of the vertical line wall below it with 0 and 1 from the left.
The third line is a character string that indicates the presence or absence of the wall of the second horizontal line from the top by 0 and 1 from the left.
...
The 9th line is a character string representing the presence or absence of the bottom horizontal line wall with 0 and 1 from the left.
<image>
---
Figure 2 (Thick line shows where the wall is) (corresponding numbers)
However, as shown by the thick line in Fig. 1, it is assumed that there is always a wall for one section to the right of point A. That is, the first character on the first line is always 1.
Output
"Advance one section to the left of the figure" is "L", "Advance one section to the right of the figure" is "R", "Advance one section to the top of the figure" is "U", "Figure" "Advance one block downward" is represented by "D", and "L", "R", "U", and "D" are output in the order of advance.
Example
Input
1111
00001
0110
01011
0010
01111
0010
01001
0111
Output
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
Submitted Solution:
```
grid = []
for i in range(9):
grid += [input()]
position = [0, 0]
direction = 'R'
path = ''
while True:
print(direction)
if direction == 'R':
path += direction
position[1] += 1
if position[0] > 0 and grid[position[0] - 1][position[1]] == '1':
direction = 'U'
elif position[1] < 4 and grid[position[0]][position[1]] == '1':
direction = 'R'
elif position[0] < 8 and grid[position[0] + 1][position[1]] == '1':
direction = 'D'
else:
direction = 'L'
elif direction == 'L':
path += direction
position[1] -= 1
if position[0] < 8 and grid[position[0] + 1][position[1]] == '1':
direction = 'D'
elif position[1] > 0 and grid[position[0]][position[1] - 1] == '1':
direction = 'L'
elif position[0] > 0 and grid[position[0] - 1][position[1]] == '1':
direction = 'U'
else:
if position[0] == position[1] == 0:
break
direction = 'R'
elif direction == 'D':
path += direction
position[0] += 2
if position[1] < 4 and grid[position[0]][position[1]] == '1':
direction = 'R'
elif position[0] < 8 and grid[position[0] + 1][position[1]] == '1':
direction = 'D'
elif position[1] > 0 and grid[position[0]][position[1] - 1] == '1':
direction = 'L'
else:
direction = 'U'
else:
path += direction
position[0] -= 2
if position[1] > 0 and grid[position[0]][position[1] - 1] == '1':
print('hello')
direction = 'L'
elif position[0] > 0 and grid[position[0] - 1][position[1]] == '1':
direction = 'U'
elif position[1] < 4 and grid[position[0]][position[1]] == '1':
direction = 'R'
else:
direction = 'D'
print(path)
``` | instruction | 0 | 29,912 | 23 | 59,824 |
No | output | 1 | 29,912 | 23 | 59,825 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Seen from above, there is a grid-like square shaped like Figure 1. The presence or absence of "walls" on each side of this grid is represented by a sequence of 0s and 1s. Create a program that stands at point A, puts your right hand on the wall, keeps walking in the direction of the arrow, and outputs the route to return to point A again.
<image>
---
Figure 1
---
Input
The input consists of 9 lines and is given in the following format, with 1 being the presence of a wall and 0 being the absence of a wall, as shown in Figure 2 below.
The first line is a character string that indicates the presence or absence of the top horizontal line wall as 0 and 1 from the left.
The second line is a character string that indicates the presence or absence of the vertical line wall below it with 0 and 1 from the left.
The third line is a character string that indicates the presence or absence of the wall of the second horizontal line from the top by 0 and 1 from the left.
...
The 9th line is a character string representing the presence or absence of the bottom horizontal line wall with 0 and 1 from the left.
<image>
---
Figure 2 (Thick line shows where the wall is) (corresponding numbers)
However, as shown by the thick line in Fig. 1, it is assumed that there is always a wall for one section to the right of point A. That is, the first character on the first line is always 1.
Output
"Advance one section to the left of the figure" is "L", "Advance one section to the right of the figure" is "R", "Advance one section to the top of the figure" is "U", "Figure" "Advance one block downward" is represented by "D", and "L", "R", "U", and "D" are output in the order of advance.
Example
Input
1111
00001
0110
01011
0010
01111
0010
01001
0111
Output
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
Submitted Solution:
```
grid = []
for i in range(9):
grid += [input()]
position = [0, 0]
direction = 'R'
path = ''
while True:
if direction == 'R':
path += direction
position[1] += 1
if position[1] == 4 or grid[position[0]][position[1]] == '0':
if position[0] > 0 and grid[position[0] - 1][position[1]] == '1':
direction = 'U'
elif position[0] < 8 and grid[position[0] + 1][position[1]] == '1':
direction = 'D'
else:
direction = 'L'
elif direction == 'L':
path += direction
position[1] -= 1
if position[1] == 0 or grid[position[0]][position[1] - 1] == '0':
if position[0] < 8 and grid[position[0] + 1][position[1]] == '1':
direction = 'D'
elif position[0] > 0 and grid[position[0] - 1][position[1]] == '1':
direction = 'U'
else:
if position[0] == position[1] == 0:
break
direction = 'R'
elif direction == 'D':
path += direction
position[0] += 2
if position[0] == 8 or grid[position[0] + 1][position[1]] == '0':
if position[1] < 4 and grid[position[0]][position[1]] == '1':
direction = 'R'
elif position[1] > 0 and grid[position[0]][position[1] - 1] == '1':
direction = 'L'
else:
direction = 'U'
else:
path += direction
position[0] -= 2
if position[0] == 0 or grid[position[0] - 1][position[1]] == '0':
if position[1] > 0 and grid[position[0]][position[1] - 1] == '1':
direction = 'L'
elif position[1] < 4 and grid[position[0]][position[1]] == '1':
direction = 'R'
else:
direction = 'D'
print(path)
``` | instruction | 0 | 29,913 | 23 | 59,826 |
No | output | 1 | 29,913 | 23 | 59,827 |
Provide a correct Python 3 solution for this coding contest problem.
JOI is playing with a nail in the board. As shown in the figure below, JOI stabbed nails in the shape of an equilateral triangle with N sides. A nails are lined up in the ath line (1 ≤ a ≤ N) from the top. The bth nail (1 ≤ b ≤ a) from the left is represented by (a, b).
<image>
Figure 1: Arrangement of nails (when N = 5)
When an equilateral triangle with a nail as its apex is "each side is parallel to one of the sides of the entire equilateral triangle and has the same orientation as the entire equilateral triangle", this equilateral triangle is called a "good equilateral triangle". That is, a "good equilateral triangle" is an equilateral triangle whose vertices are three nails (a, b), (a + x, b), (a + x, b + x) (but a). , B, x satisfy 1 ≤ a <N, 1 ≤ b ≤ a, 1 ≤ x ≤ N --a)).
JOI decided to use a rubber band to surround the "good equilateral triangle."
<image>
Figure 2: An example of how to enclose a "good equilateral triangle" with a rubber band
input
Read the following data from standard input.
* The integers N and M are written on the first line, separated by blanks. N represents the number of nails lined up on one side of an equilateral triangle, and M represents the number of rubber bands that JOI has.
* The following M line shows information on how to enclose a "good equilateral triangle" with a rubber band. The integers Ai, Bi, Xi (1 ≤ Ai <N, 1 ≤ Bi ≤ Ai, 1 ≤ Xi ≤ N --Ai) are written on the first line (1 ≤ i ≤ M), separated by blanks. .. This means that the i-th rubber band surrounds a "good equilateral triangle" with three nails (Ai, Bi), (Ai + Xi, Bi), (Ai + Xi, Bi + Xi) as vertices. Represent.
output
Output the number of nails surrounded by one or more rubber bands to the standard output in one line.
Examples
Input
5 2
2 2 1
2 1 3
Output
12
Input
None
Output
None | instruction | 0 | 29,938 | 23 | 59,876 |
"Correct Solution:
```
N,M = map(int,input().split())
d = [ [0]*(N+2) for _ in range(N+2) ]
for i in range(M):
a,b,x = map(int,input().split())
a -= 1
b -= 1
d[a][b] += 1
d[a][b+1] -= 1
d[a+x+1][b] -= 1
d[a+x+2][b+1] += 1
d[a+x+1][b+x+2] += 1
d[a+x+2][b+x+2] -= 1
# for r in d: print(r)
# vertical
for i in range(N+2):
for j in range(1, N+2):
d[i][j] += d[i][j-1]
# print("=============vertical===============")
# for r in d: print(r)
# horizontal
for i in range(N+2):
for j in range(1, N+2):
d[j][i] += d[j-1][i]
# print("=============horizontal===============")
# for r in d: print(r)
# diagonal
for i in range(1, N+2):
for j in range(1, N+2):
d[i][j] += d[i-1][j-1]
# print("=============diagonal===============")
# for r in d: print(r)
res = 0
for i in range(N+2):
for j in range(N+2):
if d[i][j] != 0:
res += 1
print(res)
``` | output | 1 | 29,938 | 23 | 59,877 |
Provide a correct Python 3 solution for this coding contest problem.
JOI is playing with a nail in the board. As shown in the figure below, JOI stabbed nails in the shape of an equilateral triangle with N sides. A nails are lined up in the ath line (1 ≤ a ≤ N) from the top. The bth nail (1 ≤ b ≤ a) from the left is represented by (a, b).
<image>
Figure 1: Arrangement of nails (when N = 5)
When an equilateral triangle with a nail as its apex is "each side is parallel to one of the sides of the entire equilateral triangle and has the same orientation as the entire equilateral triangle", this equilateral triangle is called a "good equilateral triangle". That is, a "good equilateral triangle" is an equilateral triangle whose vertices are three nails (a, b), (a + x, b), (a + x, b + x) (but a). , B, x satisfy 1 ≤ a <N, 1 ≤ b ≤ a, 1 ≤ x ≤ N --a)).
JOI decided to use a rubber band to surround the "good equilateral triangle."
<image>
Figure 2: An example of how to enclose a "good equilateral triangle" with a rubber band
input
Read the following data from standard input.
* The integers N and M are written on the first line, separated by blanks. N represents the number of nails lined up on one side of an equilateral triangle, and M represents the number of rubber bands that JOI has.
* The following M line shows information on how to enclose a "good equilateral triangle" with a rubber band. The integers Ai, Bi, Xi (1 ≤ Ai <N, 1 ≤ Bi ≤ Ai, 1 ≤ Xi ≤ N --Ai) are written on the first line (1 ≤ i ≤ M), separated by blanks. .. This means that the i-th rubber band surrounds a "good equilateral triangle" with three nails (Ai, Bi), (Ai + Xi, Bi), (Ai + Xi, Bi + Xi) as vertices. Represent.
output
Output the number of nails surrounded by one or more rubber bands to the standard output in one line.
Examples
Input
5 2
2 2 1
2 1 3
Output
12
Input
None
Output
None | instruction | 0 | 29,939 | 23 | 59,878 |
"Correct Solution:
```
n,m = map(int,input().split())
t = [[0]*(n+2) for i in range(n+2)]
for i in range(m):
a,b,x = map(int,input().split())
a -= 1
b -= 1
t[a][b] += 1
t[a][b+1] -= 1
t[a+x+1][b] -= 1
t[a+x+1][b+x+2] += 1
t[a+x+2][b+1] += 1
t[a+x+2][b+x+2] -= 1
for i in range(n+2):
for j in range(1,n+2):
t[i][j] += t[i][j-1]
for i in range(n+2):
for j in range(1,n+2):
t[j][i] += t[j-1][i]
for i in range(1, n+2):
for j in range(1,n+2):
t[i][j] += t[i-1][j-1]
ans = 0
for i in range(n):
for j in range(i+1):
if t[i][j] != 0:
ans += 1
print(ans)
``` | output | 1 | 29,939 | 23 | 59,879 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.