exec_outcome
stringclasses 1
value | code_uid
stringlengths 32
32
| file_name
stringclasses 111
values | prob_desc_created_at
stringlengths 10
10
| prob_desc_description
stringlengths 63
3.8k
| prob_desc_memory_limit
stringclasses 18
values | source_code
stringlengths 117
65.5k
| lang_cluster
stringclasses 1
value | prob_desc_sample_inputs
stringlengths 2
802
| prob_desc_time_limit
stringclasses 27
values | prob_desc_sample_outputs
stringlengths 2
796
| prob_desc_notes
stringlengths 4
3k
⌀ | lang
stringclasses 5
values | prob_desc_input_from
stringclasses 3
values | tags
sequencelengths 0
11
| src_uid
stringlengths 32
32
| prob_desc_input_spec
stringlengths 28
2.37k
⌀ | difficulty
int64 -1
3.5k
⌀ | prob_desc_output_spec
stringlengths 17
1.47k
⌀ | prob_desc_output_to
stringclasses 3
values | hidden_unit_tests
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
PASSED | 995070557f5415187bca99c4a6215a0d | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.*;
import java.io.*;
public class lab_1 {
public static void main(String[] args) throws IOException
{ Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
for(int i = 0 ;i< t;i++)
{
int x = sc.nextInt();
int y = sc.nextInt();
int x2 = x;
int y2 = y;
boolean flag = false;
int counter = 0;
double euc = Math.sqrt(Math.pow(0 - x, 2) + Math.pow(0 - y, 2));
if(0 == x && 0 == y)
{
counter = 0;
}
else if(euc % 1 == 0)
{
counter = 1;
}
else
{
for(int a = 0; a<=x;a++)
{
for(int b = 0; b<=y ;b++)
{
euc = Math.sqrt(Math.pow(a- x2, 2) + Math.pow(b- y2, 2));
if(euc % 1 ==0)
{
x2 = a;
y2 = b;
a = 0;
b= 0;
counter++;
}
double euc2 = Math.sqrt(Math.pow(0- x2, 2) + Math.pow(0- y2, 2));
if(euc2 % 1 == 0)
{ counter++;
flag = true;
break;
}
}
if(flag == true)
{
break;
}
}
}
System.out.println(counter);
}
}
static class Scanner {
StringTokenizer st;
BufferedReader br;
public Scanner(InputStream s) {
br = new BufferedReader(new InputStreamReader(s));
}
public String next() throws IOException {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
public int nextInt() throws IOException {
return Integer.parseInt(next());
}
public long nextLong() throws IOException {
return Long.parseLong(next());
}
public String nextLine() throws IOException {
return br.readLine();
}
public double nextDouble() throws IOException {
String x = next();
StringBuilder sb = new StringBuilder("0");
double res = 0, f = 1;
boolean dec = false, neg = false;
int start = 0;
if (x.charAt(0) == '-') {
neg = true;
start++;
}
for (int i = start; i < x.length(); i++)
if (x.charAt(i) == '.') {
res = Long.parseLong(sb.toString());
sb = new StringBuilder("0");
dec = true;
} else {
sb.append(x.charAt(i));
if (dec)
f *= 10;
}
res += Long.parseLong(sb.toString()) / f;
return res * (neg ? -1 : 1);
}
public boolean ready() throws IOException {
return br.ready();
}
public int[] readArr(int n) throws IOException {
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = Integer.parseInt(next());
}
return arr;
}
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 2faee42095b2baa74d98d1c89a28612f | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main{
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String[]data;
int t, x, y;
t = Integer.valueOf(br.readLine());
while((t--)!=0){
data = br.readLine().split(" ");
x = Integer.parseInt(data[0]);
y = Integer.parseInt(data[1]);
if(x==0 && y == 0){
System.out.println(0);;
}else{
int hip = (int)Math.sqrt(x*x + y*y);
System.out.println(hip * hip != x*x + y*y ? 2 : 1);
}
}
}
private static int solve(int x0, int y0, int x, int y) {
if(x0 == x && y0 == y){
return 0;
}
for(int i = y; i >= y0 ; --i){
for(int j = x ; j >= x0 ; --j){
int sqrHip =(i-y0)*(i-y0) + (j - x0)*(j-x0) ;
int hip = (int)Math.sqrt( sqrHip);
if( hip*hip == sqrHip){
int sub = solve(j, i, x, y);
if(sub >= 0){
return sub + 1;
}
}
}
}
return Integer.MIN_VALUE;
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 01678bc724095a1eb45434fa7ba32644 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main{
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String[]data;
int t, x, y;
t = Integer.valueOf(br.readLine());
while((t--)!=0){
data = br.readLine().split(" ");
x = Integer.parseInt(data[0]);
y = Integer.parseInt(data[1]);
System.out.println(solve(0,0, x, y));
}
}
private static int solve(int x0, int y0, int x, int y) {
if(x0 == x && y0 == y){
return 0;
}
for(int i = y; i >= y0 ; --i){
for(int j = x ; j >= x0 ; --j){
int sqrHip =(i-y0)*(i-y0) + (j - x0)*(j-x0) ;
int hip = (int)Math.sqrt( sqrHip);
if( hip*hip == sqrHip){
int sub = solve(j, i, x, y);
if(sub >= 0){
return sub + 1;
}
}
}
}
return Integer.MIN_VALUE;
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 0b6373e1dcfb2d2f510801857c243e58 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes |
import java.util.*;
import java.io.*;
import java.lang.*;
public class quetion1template {
static class FastWriter {
private final BufferedWriter bw;
public FastWriter() {
this.bw = new BufferedWriter(new OutputStreamWriter(System.out));
}
public void print(Object object) throws IOException {
bw.append("" + object);
}
public void println(Object object) throws IOException {
print(object);
bw.append("\n");
}
public void close() throws IOException {
bw.close();
}
}
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine().trim();
} catch (Exception e) {
e.printStackTrace();
}
return str;
}
}
public static void main(String[] args) {
try {
FastReader sc = new FastReader();
FastWriter out = new FastWriter();
int testCases = sc.nextInt();
while (testCases-- > 0) {
int x=sc.nextInt();
int y=sc.nextInt();
int ans=0;
if(x==0 && y==0) {
ans=0;
}
else if(isPerfect(x,y)) {
ans=1;
}
else {
ans=2;
}
out.println(ans);
}
out.close();
} catch (Exception e) {
return;
}
}
private static boolean isPerfect(int x, int y) {
// TODO Auto-generated method stub
int real=x*x+y*y;
int a=(int)Math.sqrt(x*x+y*y);
return a*a==real;
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | d446e2af5a028bf005e356fdc74788a1 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.Scanner;
public class Contest1657 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int test = sc.nextInt();
for (int t = 0; t < test; t++){
int x = sc.nextInt();
int y = sc.nextInt();
if (x == 0 && y == 0){
System.out.println(0);
}
else {
System.out.println(check(x, y));
}
}
}
static int check(int x, int y){
int z = x*x + y*y;
for(int n = 0; n*n <= x*x + y*y; n++){
if (n*n == z){
return 1;
}
}
return 2;
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | caa42f357eda549d8c50dc1b5ccb9a72 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class test {
static class FastScanner {
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st=new StringTokenizer("");
String next() {
while (!st.hasMoreTokens())
try {
st=new StringTokenizer(br.readLine());
} catch (IOException e) {}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
}
public static void main(String[] args)
{
FastScanner t=new FastScanner();
int line=t.nextInt();
while(line>0)
{
int x=t.nextInt();
int y=t.nextInt();
double ans=Math.sqrt(Math.pow(x-0,2)+Math.pow(y-0,2));
if(x==0 && y==0)
System.out.println(0);
else if (ans==(int)ans)
System.out.println(1);
else
System.out.println(2);
line--;
}
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 9a57f96abc0069ae9fd428b90874be09 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.io.*;
import java.util.StringTokenizer;
public class P1657A_B {
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader(InputStream is) {
br = new BufferedReader(new InputStreamReader(is));
}
String nextToken() throws IOException {
while (st == null || !st.hasMoreElements()) {
st = new StringTokenizer(br.readLine());
}
return st.nextToken();
}
int nextInt() throws IOException {
return Integer.parseInt(nextToken());
}
long nextLong() throws IOException {
return Long.parseLong(nextToken());
}
double nextDouble() throws IOException {
return Double.parseDouble(nextToken());
}
String nextLine() throws IOException {
return br.readLine();
}
}
public static void main(String[] args) throws IOException {
PrintWriter writer = new PrintWriter(System.out);
testableMain(new FastReader(System.in), writer);
writer.flush();
}
static void testableMain(InputStream is, OutputStream os) throws IOException {
PrintWriter writer = new PrintWriter(os);
testableMain(new FastReader(is), writer);
writer.flush();
}
static void testableMain(FastReader reader, PrintWriter writer) throws IOException {
int numCases = reader.nextInt();
for(int i = 0; i < numCases; i++) {
int a = reader.nextInt();
int b = reader.nextInt();
int answer = solve(a, b);
writer.println(answer);
}
}
static int solve(int a, int b) {
int d2 = a * a + b * b;
if (d2 == 0) {
return 0;
}
int sq = 1;
int i = 0;
do {
sq = i * i;
if (sq == d2) {
return 1;
}
i += 1;
} while(sq < d2);
return 2;
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 763e6406f2053fec5f3ebf23d991a4cc | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.io.*;
import java.util.*;
public class P1657A {
static class TestCase {
int x;
int y;
TestCase(int x, int y) {
this.x = x;
this.y = y;
}
}
private List<String> stdInputRaw = new ArrayList<>(10000); // Input as-is.
private int currentLineNumber = 0;
private List<String> stdOutput = new ArrayList<>(10000);
private TestCase testCase;
private int testCaseNumber;
boolean getNextTestCase() {
if (testCase == null) {
testCaseNumber = Integer.parseInt(getNextLine());
}
if (testCaseNumber == 0) {
return false;
}
testCaseNumber--;
int[] input = new int[2];
InputParsers.readWholeNumbers(getNextLine(), input);
testCase = new TestCase(input[0], input[1]);
return true;
}
void processTestCase() {
int x = testCase.x;
int y = testCase.y;
if (x == 0 && y == 0) {
addToOutput("0\n");
return;
}
int d = x * x + y * y;
int sq = (int) Math.sqrt(d);
if (d == sq * sq) {
addToOutput("1\n");
return;
}
addToOutput("2\n");
}
void solveAll() {
while(getNextTestCase()) {
processTestCase();
}
}
void testableMain(InputStream is, OutputStream os) {
readInput(is);
solveAll();
writeOutput(os);
}
public static void main(String[] args) {
new P1657A().testableMain(System.in, System.out);
}
String getNextLine() {
return cleanupLine(getNextLineRaw());
}
String getNextLineRaw() {
String nextLine = "";
if (currentLineNumber < stdInputRaw.size()) {
nextLine = stdInputRaw.get(currentLineNumber++);
}
return nextLine;
}
void addToOutput(String s) {
stdOutput.add(s);
}
void readInput(InputStream is) {
BufferedReader stdin = new BufferedReader(new InputStreamReader(is));
try {
while (stdin.ready()) {
String line = stdin.readLine();
stdInputRaw.add(line);
}
} catch(IOException e) {
// nothing we can do...
}
}
private String cleanupLine(String s) {
if (s.isEmpty()) {
return s;
}
boolean shouldCleanup = false;
int l = s.length();
if (s.charAt(0) == ' ' || s.charAt(l - 1) == ' ') {
shouldCleanup = true;
}
if (!shouldCleanup) {
// check for double space
for(int i = 1; i < l; i++) {
if (s.charAt(i) == ' ' && s.charAt(i - 1) == ' ') {
shouldCleanup = true;
break;
}
}
}
if (!shouldCleanup) {
return s;
}
StringBuilder sb = new StringBuilder(l);
boolean previousSpace = true;
for(int i = 0; i < l; i++) {
if (s.charAt(i) != ' ') {
sb.append(s.charAt(i));
previousSpace = false;
} else {
if (!previousSpace) {
sb.append(' ');
previousSpace = true;
}
}
}
return sb.toString();
}
void writeOutput(OutputStream os) {
BufferedWriter stdout = new BufferedWriter(new OutputStreamWriter(os));
try {
for (String o : stdOutput) {
stdout.write(o);
}
stdout.flush();
stdout.close();
} catch(IOException e) {
// nothing we can do
}
}
static class InputParsers {
// Note: this could handle "raw" inputs with extra spaces.
static void readWholeNumbers(String line, int[] output) {
int outputPosition = 0;
boolean previousSpace = true;
int value = 0;
for (byte b : line.getBytes()) {
if (b == ' ' && !previousSpace) {
output[outputPosition++] = value;
value = 0;
previousSpace = true;
}
if (b != ' ') {
if (!(b <= '9' && b >= '0')) {
throw new IllegalStateException("non-digit found for int reads");
}
previousSpace = false;
value = value * 10 + (b - '0');
}
}
if (outputPosition == output.length - 1) {
output[outputPosition++] = value;
return;
}
if (outputPosition != output.length) {
throw new IllegalStateException("Not enough values read");
}
if (value != 0) {
throw new IllegalStateException("Extra argument found");
}
}
// Note: this could handle "raw" inputs with extra spaces.
static void readWholeNumbers(String line, long[] output) {
int outputPosition = 0;
boolean previousSpace = true;
long value = 0;
for (byte b : line.getBytes()) {
if (b == ' ' && !previousSpace) {
output[outputPosition++] = value;
value = 0;
previousSpace = true;
}
if (b != ' ') {
if (!(b <= '9' && b >= '0')) {
throw new IllegalStateException("non-digit found for int reads");
}
previousSpace = false;
value = value * 10 + (b - '0');
}
}
if (outputPosition == output.length - 1) {
output[outputPosition++] = value;
return;
}
if (outputPosition != output.length) {
throw new IllegalStateException("Not enough values read");
}
if (value != 0) {
throw new IllegalStateException("Extra argument found");
}
}
static void readIntNumbers(String line, int[] output) {
int outputPosition = 0;
boolean previousSpace = true;
int value = 0;
boolean negative = false;
for (byte b : line.getBytes()) {
if (b == ' ' && !previousSpace) {
if (negative) {
value = -value;
negative = false;
}
output[outputPosition++] = value;
value = 0;
previousSpace = true;
}
if (b != ' ') {
if (b != '-' && !(b <= '9' && b >= '0')) {
throw new IllegalStateException("non-digit found for int reads");
}
if (b == '-') {
negative = true;
} else {
previousSpace = false;
value = value * 10 + (b - '0');
}
}
}
if (outputPosition == output.length - 1) {
if (negative) {
value = -value;
negative = false;
}
output[outputPosition++] = value;
return;
}
if (outputPosition != output.length) {
throw new IllegalStateException("Not enough values read");
}
if (value != 0) {
throw new IllegalStateException("Extra argument found");
}
}
public static int countWords(String line) {
boolean prevSpace = true;
int count = 0;
for(int i = 0; i < line.length(); i++) {
if (line.charAt(i) == ' ') {
if (!prevSpace) {
prevSpace = true;
count += 1;
}
} else {
prevSpace = false;
}
}
if (!prevSpace) {
count += 1;
}
return count;
}
public static ArrayList<String> parseWords(String line) {
ArrayList<String> words = new ArrayList<>();
int start = 0;
while(start < line.length() && line.charAt(start) == ' ') {
start++;
}
while(start < line.length()) {
int end = line.indexOf(' ', start);
if (end == -1) {
end = line.length();
}
words.add(line.substring(start, end));
start = end + 1;
while(start < line.length() && line.charAt(start) == ' ') {
start++;
}
}
return words;
}
}
static class Toolkit {
static int[] getPrimeList(int upperValue) {
boolean[] isPrime = new boolean[upperValue + 1];
Arrays.fill(isPrime, true);
isPrime[0] = isPrime[1] = false;
int p = 2;
while(p * p < isPrime.length) {
if (isPrime[p]) {
int m = p * p;
while(m < isPrime.length) {
isPrime[m] = false;
m += p;
}
}
p++;
}
int numPrimes = 0;
for (int i = 2; i < isPrime.length; i++) {
if (isPrime[i]) {
numPrimes++;
}
}
int[] primes = new int[numPrimes];
int primeIndex = 0;
for (int i = 2; i < isPrime.length; i++) {
if (isPrime[i]) {
primes[primeIndex++] = i;
}
}
return primes;
}
public static <T> void swap(ArrayList<T> encryptedWords, int i, int j) {
T value = encryptedWords.get(i);
encryptedWords.set(i, encryptedWords.get(j));
encryptedWords.set(j, value);
}
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | f283d7ba3e1f99002143b44bc7420182 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.Scanner;
import java.util.*;
public class Test {
public static void main(String args[])
{
Scanner scan=new Scanner(System.in);
int numberOfIterations=scan.nextInt();
int result=0;
for(int i=numberOfIterations;i>0;i--)
{
int x=scan.nextInt();
int y=scan.nextInt();
if(x==0 && y==0)
result=0;
else if(Math.sqrt(x*x+y*y)==(int)Math.sqrt(x*x+y*y))
result=1;
else
result=2;
System.out.println(result);
}
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 7536b4cb326ad7ffe558fe0a62a46452 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.Scanner;
public class codeforces4 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int t=sc.nextInt();
for (int i = 0; i < t; i++) {
int x=sc.nextInt();
int y=sc.nextInt();
int z;
z=x*x+y*y;
if(x==0 && y==0 ){
System.out.println(0); }
else{
if(checkPerfectSquare(z)){
System.out.println(1);
}
else{
System.out.println(2);
}}}}
static boolean checkPerfectSquare(double number)
{
//calculating the square root of the given number
double sqrt=Math.sqrt(number);
//finds the floor value of the square root and comparing it with zero
return ((sqrt - Math.floor(sqrt)) == 0);
} }
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | bdf44af54d8531191a5894320acb0c78 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.*;
import java.lang.Math;
public class test {
public static void main(String[] args) {
Scanner inputul = new Scanner(System.in);
int n = inputul.nextInt();
int x,y,res=0;
for (int i = 0; i < n; i++) {
x = inputul.nextInt();
y = inputul.nextInt();
if (x ==0 && y ==0)res=0;
else if (Math.sqrt(x*x+y*y)==(int)Math.sqrt(x*x+y*y)){
res = 1;
}
else res=2;
System.out.println(res);
}
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 41a7fb1712646674cea82c5e3017f970 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.io.*;
//import java.util.*;
public class IntegerMoves {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int t = Integer.valueOf(br.readLine());//
int[][] distances = new int[60][60];
preprocess(distances);
while(t-->0){
String[] str = br.readLine().split("\\s+");
int x = Integer.valueOf(str[0]);
int y = Integer.valueOf(str[1]);
if(x==0 && y==0)System.out.println(0);
else if(distances[x][y]==1 || x==0 || y==0){
System.out.println(1);
}else {
System.out.println(2);
}
}
}
public static void preprocess(int[][] distances){
int m = 2;
int a=0,b=0,c=0;
/*
a = m*m - n*n;
b = 2*m*n;
c = m*m + n*n
*/
while(c<71){
for(int n=1; n<m; n++){
a = m*m - n*n;
b = 2*m*n;
c = m*m + n*n;
if(c>= 71) break;
int g = a>b?a:b;
for(int i=1;g*i<51;i++){
int ia = i*a, ib = i*b;
//System.out.println(ia+" "+ib);
distances[ia][ib] = distances[ib][ia] = 1;
}
}
m++;
}
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | becc052a51bae15f73c9a0bcc36bfe19 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.Scanner;
public class IntegerMoves {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int arr = scanner.nextInt();
while (arr > 0) {
int x = scanner.nextInt();
int y = scanner.nextInt();
double s = Math.sqrt(x * x + y * y);
if(x == 0 && y == 0 ){
System.out.println(0);
} else if((int) s * s == x * x + y * y) {
System.out.println(1);
}else {
System.out.println(2);
}
arr--;
}
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 64f9f37af86f6ce53d65113a10453c32 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.*;
public class code {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
long t = sc.nextLong();
while (t-- > 0) {
long x=sc.nextLong();
long y= sc.nextLong();
long res=(x*x)+(y*y);
int ans=2;
long i=0;
while(i*i<res) i++;
if(i*i==res) ans=1;
if(x==0 && y==0) ans=0;
System.out.println(ans);
}
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | f033a1c4a186c02bdf18457f3bd69c60 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.io.*;
import java.util.*;
public class Main {
static PrintWriter pw;
public static int gcd(int a, int b) {
return b == 0 ? a : gcd(b, a % b);
}
public static int lcm(int a, int b) {
return a * b / gcd(a, b);
}
public static long fac(long i) {
long res=1;
while(i>0) {
res=res*i--;
}
return res;
}
public static long combination (long x,long y) {
return 1l*(fac(x)/(fac(x-y)*fac(y)));
}
public static long permutation (long x,long y) {
return combination(x, y) * fac(y);
}
public static long sum(Long[]arr,long item) {
long res=0;
for (int i = 0; i < arr.length; i++) {
res+=arr[i] ;
}
res-=item;
return res;
}
public static void main(String[] args) throws IOException, InterruptedException {
Scanner sc = new Scanner(System.in);
pw = new PrintWriter(System.out);
int t=sc.nextInt();
while(t-->0) {
int x=sc.nextInt();
int y=sc.nextInt();
int res =x*x+y*y;
if(x==0&&y==0)
System.out.println("0");
else if(Math.sqrt(res)==(int)Math.sqrt(res))
System.out.println("1");
else {
System.out.println("2");
}
}
pw.flush();
}
static class Pair {
long x;
long y;
public Pair(long x, long y) {
this.x = x;
this.y = y;
}
public String toString() {
return x + " " + y;
}
}
static class Scanner {
StringTokenizer st;
BufferedReader br;
public Scanner(InputStream s) {
br = new BufferedReader(new InputStreamReader(s));
}
public String next() throws IOException {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
public int nextInt() throws IOException {
return Integer.parseInt(next());
}
public long nextLong() throws IOException {
return Long.parseLong(next());
}
public String nextLine() throws IOException {
return br.readLine();
}
public double nextDouble() throws IOException {
String x = next();
StringBuilder sb = new StringBuilder("0");
double res = 0, f = 1;
boolean dec = false, neg = false;
int start = 0;
if (x.charAt(0) == '-') {
neg = true;
start++;
}
for (int i = start; i < x.length(); i++)
if (x.charAt(i) == '.') {
res = Long.parseLong(sb.toString());
sb = new StringBuilder("0");
dec = true;
} else {
sb.append(x.charAt(i));
if (dec)
f *= 10;
}
res += Long.parseLong(sb.toString()) / f;
return res * (neg ? -1 : 1);
}
public int[] nextIntArray(int n) throws IOException {
int[] array = new int[n];
for (int i = 0; i < n; i++) {
array[i] = nextInt();
}
return array;
}
public Integer[] nextIntegerArray(int n) throws IOException {
Integer[] array = new Integer[n];
for (int i = 0; i < n; i++) {
array[i] = nextInt();
}
return array;
}
public long[] nextlongArray(int n) throws IOException {
long[] array = new long[n];
for (int i = 0; i < n; i++) {
array[i] = nextLong();
}
return array;
}
public Long[] nextLongArray(int n) throws IOException {
Long[] array = new Long[n];
for (int i = 0; i < n; i++) {
array[i] = nextLong();
}
return array;
}
public char[] nextCharArray(int n) throws IOException {
char[] array = new char[n];
String string = next();
for (int i = 0; i < n; i++) {
array[i] = string.charAt(i);
}
return array;
}
public boolean ready() throws IOException {
return br.ready();
}
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | a758a8c5364d90449bde9f3cad77d8fb | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes |
import java.util.Scanner;
public class A_Integer_Moves {
private static final Scanner in = new Scanner(System.in);
private static int x, y, testCases;
private static void solve() {
if (x == 0 && y == 0) {
System.out.println(0);
return;
}
double dis = distance(x, y);
int dis1 = (int) distance(x, y);
if (dis == (double) dis1) {
System.out.println(1);
} else {
System.out.println(2);
}
}
public static void main(String[] args) {
testCases = in.nextInt();
for (int t = 0; t < testCases; ++t) {
x = in.nextInt();
y = in.nextInt();
solve();
}
}
private static double distance(int x, int y) {
return Math.sqrt(Math.pow(y, 2) + Math.pow(x, 2));
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 9606ae5ff93efe7931aad31b4f5c64c5 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.Scanner;
public class A_Integer_Moves {
static Scanner in = new Scanner(System.in);
static int x, y, testCases;
static StringBuilder ans = new StringBuilder();
static double distance() {
return Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
}
static void solve() {
double d = distance();
int e = (int)distance();
if(x == 0 && y == 0 ) {
//System.out.println(0);
ans.append(0).append("\n");
} else if(d == (double)e ) {
//System.out.println(1);
ans.append(1).append("\n");
} else {
//System.out.println(2);
ans.append(2).append("\n");
}
}
public static void main(String [] priya) {
testCases = in.nextInt();
for(int t = 0; t < testCases; ++t) {
x = in.nextInt();
y = in.nextInt();
solve();
}
System.out.print(ans.toString());
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | c9cf14f5768b4c8e1225e4f7334aa67b | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.*;
import java.io.*;
public class A1657 {
public static void main(String[] args) throws IOException {
//BufferedReader r = new BufferedReader(new FileReader("test.in"));
BufferedReader r = new BufferedReader(new InputStreamReader(System.in));
int T = Integer.parseInt(r.readLine());
for(int i = 0; i < T; i++) {
StringTokenizer st = new StringTokenizer(r.readLine());
int a = Integer.parseInt(st.nextToken()); int b=Integer.parseInt(st.nextToken());
double distance = Math.sqrt((Math.pow(a,2)+Math.pow(b,2)));
if(a==0&&b==0) {
System.out.println(0);
} else if(distance == (int)distance) {
System.out.println(1);
} else {
System.out.println(2);
}
}
r.close();
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | a72906f5f729873426dd8108975cc0ff | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.*;
public class question {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
while(t-->0) {
int x = sc.nextInt();
int y = sc.nextInt();
if(x==0 && y==0)
System.out.println(0);
else {
double ans = Math.sqrt( x*x + y*y );
if( ans == (int)ans )
System.out.println(1);
else
System.out.println(2);
}
}
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 22af16771d61e49d83dc032b9d9caa7d | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.io.*;
import java.util.*;
import java.math.*;
public class Main{
static class in{
static BufferedReader re = new BufferedReader(new InputStreamReader(System.in));
static StreamTokenizer st = new StreamTokenizer(re);
public static int nextInt()throws IOException{
st.nextToken();
return (int)st.nval;
}
public static double nextDouble()throws IOException{
st.nextToken();
return st.nval;
}
public static String nextLine()throws IOException{
return re.readLine();
}
}
static PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
static int t,x,y,ans;
static int[][] mapp = new int[100][100];
public static void main(String[] args)throws IOException {
Scanner sc = new Scanner(System.in);
t = in.nextInt();
while(t-->0){
x = in.nextInt();
y = in.nextInt();
double tnum = (x)*(x)+(y)*(y);
if(x==0&&y==0){
System.out.println(0);
}
else if(Math.sqrt(tnum)-(int)Math.sqrt(tnum)==0){
System.out.println(1);
}
else{
System.out.println(2);
}
// for(int i = 0;i <= x;++i){
// for(int k = 0;k <= y;++k){
// mapp[i][k] = 0;
// }
// }
// Queue<node> q = new LinkedList<>();
// if(x==0&&y==0){
// System.out.println(0);
// }
// else{
// q.add(new node(0,0));
// while(!q.isEmpty()){
// node n = q.poll();
// int dx = n.x,dy = n.y;
// for(int i = dx;i <= x;++i){
// for(int k = dy;k <= y;++k){
// double tnum = (dx-i)*(dx-i)+(dy-k)*(dy-k);
// if(i!=dx && k!=dy && Math.sqrt(tnum)-(int)Math.sqrt(tnum)==0){
// if(mapp[i][k]>0){
// mapp[i][k] = Math.min(mapp[dx][dy]+1, mapp[i][k]);
// }
// else{
// mapp[i][k] = mapp[dx][dy]+1;
// }
// q.add(new node(i,k));
// }
// }
// }
// if(mapp[x][y]!=0){
// System.out.println(mapp[x][y]);
// break;
// }
// }
// }
// for(int i = 0;i <= x;++i){
// for(int k = 0;k <= y;++k){
// System.out.print(mapp[i][k]+" ");
// }
// System.out.println();
// }
}
sc.close();
out.flush();
}
}
class node{
int x,y;
node(int a,int b){
x = a;
y = b;
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | f47055319ad6c750fa0d8d93d50f7c6c | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | //package codeforces.educational125;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.LinkedList;
import java.util.Queue;
public class IntegerMoves {
private static final int MAX = 51;
public static void main(String[] args) throws IOException {
new IntegerMoves().run();
}
public void run() throws IOException {
InputStream inputStream = getInputStream();
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
PrintWriter writer = new PrintWriter(new BufferedOutputStream(System.out));
IntegerMoves integerMoves = new IntegerMoves();
String[] tokens;
tokens = bufferedReader.readLine().split(" ");
int t = Integer.parseInt(tokens[0]);
while (t > 0) {
tokens = bufferedReader.readLine().split(" ");
int x = Integer.parseInt(tokens[0]);
int y = Integer.parseInt(tokens[1]);
writer.println(integerMoves.moves(x, y));
t--;
}
writer.close();
inputStream.close();
}
Position[][] positions = new Position[MAX][MAX];
static class Position {
int x;
int y;
int d;
Position(int x, int y, int d) {
this.x = x;
this.y = y;
this.d = d;
}
}
public IntegerMoves() {
boolean[] square = new boolean[2*MAX*MAX];
for (int x = 0; x*x < 2*MAX*MAX; x++) {
square[x*x] = true;
}
positions[0][0] = new Position(0, 0, 0);
Queue<Position> queue = new LinkedList<>();
queue.add(positions[0][0]);
while (!queue.isEmpty()) {
Position head = queue.poll();
for (int x = 0; x < MAX; x++) {
for (int y = 0; y < MAX; y++) {
if (positions[x][y] == null && square[(x - head.x)*(x - head.x) + (y - head.y)*(y - head.y)]) {
positions[x][y] = new Position(x, y, head.d+1);
queue.add(positions[x][y]);
}
}
}
}
}
public int moves(int x, int y) {
return positions[x][y].d;
}
private InputStream getInputStream() throws IOException {
if (System.getProperty("ONLINE_JUDGE") != null) {
return System.in;
}
return new FileInputStream("IntegerMoves");
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 453b67e38b6f1d493750568275647823 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.Scanner;
public class template
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
for (int i = 1; i <= n; i++) {
int x = sc.nextInt();
int y = sc.nextInt();
System.out.println(buildNum(x, y));
}
}
private static int buildNum(int x, int y) {
if (x == 0 && y == 0) return 0;
double hyp = Math.sqrt(x*x + y*y);
if ((hyp % 1) == 0) return 1;
return 2;
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | bb354a4e613fdad06ba92ddf2570c76b | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.*;
import java.io.*;
import java.math.*;
public class Main {
static class FastScanner {
BufferedReader br;
StringTokenizer st;
public FastScanner() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try
{
st = new StringTokenizer(br.readLine());
}
catch (IOException e)
{
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try
{
str = br.readLine();
}
catch (IOException e)
{
e.printStackTrace();
}
return str;
}
}
public static void main(String[] args) throws Exception {
FastScanner sc=new FastScanner();
int t=sc.nextInt();
while(t-->0){
int x=sc.nextInt();
int y=sc.nextInt();
if(x==0 && y==0) System.out.println("0");
else{
double d = Math.pow(x, 2) + Math.pow(y, 2);
double sq = Math.sqrt(d);
if (sq == (int) sq) System.out.println("1");
else System.out.println("2");
}
}
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 422aa02279df7001bf05108782812b5d | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | /*#####################################################
################ >>>> Diaa12360 <<<< ##################
################ Just Nothing ##################
############ If You Need it, Fight For IT; ############
####################.-. 1 5 9 2 .-.####################
######################################################*/
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Stack;
import java.util.StringTokenizer;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
StringBuilder out = new StringBuilder();
StringTokenizer tk;
int t = ints(in.readLine());
while(t-- > 0){
tk = new StringTokenizer(in.readLine());
int x = ints(tk.nextToken()), y = ints(tk.nextToken());
int ans;
double sol = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
if(x == 0 && y == 0)
ans = 0;
else if(sol-(int)sol == 0)
ans = 1;
else
ans = 2;
out.append(ans).append('\n');
}
System.out.println(out);
}
static int ints(String s){return Integer.parseInt(s);}
static int ll(String s) {return Integer.parseInt(s);}
static int[] readArray(String s, int n){
StringTokenizer tk = new StringTokenizer(s);
int []arr = new int[n];
for (int i = 0; i < n; i++)
arr[i] = ints(tk.nextToken());
return arr;
}
static int[] readArray(String s){
StringTokenizer tk = new StringTokenizer(s);
int []arr = new int[tk.countTokens()];
for (int i = 0; i < arr.length; i++)
arr[i] = ints(tk.nextToken());
return arr;
}
}
//e. (x1−x2)2+(y1−y2)2−−−−−−−−−−−−−−−−−−√ | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | aa375aaf375abf0e1ae0c649c3f6608d | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.io.*;
import java.util.*;
public class A_Integer_Moves {
public static void main(String[] args) {
MyScanner sc = new MyScanner();
out = new PrintWriter(new BufferedOutputStream(System.out));
int t = sc.nextInt();
while (t-- > 0) {
int x = sc.nextInt(), y = sc.nextInt();
if (x == 0 && y == 0)
out.println(0);
else if (Math.sqrt(((0 - x) * (0 - x)) + ((0 - y) * (0 - y))) == (int) Math
.sqrt(((0 - x) * (0 - x)) + ((0 - y) * (0 - y))))
out.println(1);
else
out.println(2);
}
out.close();
}
public static PrintWriter out;
public static long mod = (long) 1e9 + 7;
public static class MyScanner {
BufferedReader br;
StringTokenizer st;
public MyScanner() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
int[] readArray(int n) {
int a[] = new int[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
long[] readLongArray(int n) {
long a[] = new long[n];
for (int i = 0; i < n; i++)
a[i] = nextLong();
return a;
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
static void SieveOfEratosthenes(int n, boolean prime[]) {
prime[0] = false;
prime[1] = false;
for (int p = 2; p * p <= n; p++) {
if (prime[p] == true)
for (int i = p * p; i <= n; i += p)
prime[i] = false;
}
}
static void dfs(int root, boolean[] vis, int[] value, ArrayList[] gr, int prev) {
vis[root] = true;
value[root] = 3 - prev;
prev = 3 - prev;
for (int i = 0; i < gr[root].size(); i++) {
int next = (int) gr[root].get(i);
if (!vis[next])
dfs(next, vis, value, gr, prev);
}
}
static boolean isPrime(int n) {
for (int i = 2; i * i <= n; i++)
if (n % i == 0)
return false;
return true;
}
static int abs(int a) {
return a > 0 ? a : -a;
}
static int max(int a, int b) {
return a > b ? a : b;
}
static int min(int a, int b) {
return a < b ? a : b;
}
static long pow(long n, long m) {
if (m == 0)
return 1;
long temp = pow(n, m / 2);
long res = ((temp * temp) % mod);
if (m % 2 == 0)
return res;
return (res * n) % mod;
}
static long modular_add(long a, long b) {
return ((a % mod) + (b % mod)) % mod;
}
static long modular_sub(long a, long b) {
return ((a % mod) - (b % mod) + mod) % mod;
}
static long modular_mult(long a, long b) {
return ((a % mod) * (b % mod)) % mod;
}
static long lcm(int a, int b) {
return (a / gcd(a, b)) * b;
}
static long gcd(long a, long b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
static class Pair {
int u, v;
Pair(int u, int v) {
this.u = u;
this.v = v;
}
static void sort(Pair[] coll) {
List<Pair> al = new ArrayList<>(Arrays.asList(coll));
Collections.sort(al, new Comparator<Pair>() {
public int compare(Pair p1, Pair p2) {
return p1.u - p2.u;
}
});
for (int i = 0; i < al.size(); i++) {
coll[i] = al.get(i);
}
}
}
static void sort(int[] a) {
ArrayList<Integer> list = new ArrayList<>();
for (int i : a)
list.add(i);
Collections.sort(list);
for (int i = 0; i < a.length; i++)
a[i] = list.get(i);
}
static void sort(long a[]) {
ArrayList<Long> list = new ArrayList<>();
for (long i : a)
list.add(i);
Collections.sort(list);
for (int i = 0; i < a.length; i++)
a[i] = list.get(i);
}
static int[] array(int n, int value) {
int a[] = new int[n];
for (int i = 0; i < n; i++)
a[i] = value;
return a;
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 6c17d509dc7fb20b9b4e9f8c9417d35e | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.Scanner;
import java.util.StringTokenizer;
public class IntegerMoves {
public static double distance(int x1, int x2, int y1, int y2) {
return(Math.sqrt(Math.pow(x1-x2, 2) + Math.pow(y1-y2, 2)));
}
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
StringTokenizer st;
int t = Integer.parseInt(scan.nextLine());
int[] operations = new int[t];
//double[] temp = new double[t];
int x, y;
boolean ok, maxQuad;
for(int i = 0; i < t; i++) {
ok = false;
st = new StringTokenizer(scan.nextLine());
x = Integer.parseInt(st.nextToken());
y = Integer.parseInt(st.nextToken());
//int tempX, tempY;
//temp[i] = distance(x, 0, y, 0);
if(x != 0 && y != 0)
{while(!ok) {
//System.out.println("dentro al while");
maxQuad = false;
for(int j = x; j >= 0 && !maxQuad; j--) {
//System.out.println("dentro al forX");
for(int k = y; k >= 0 && !maxQuad; k--) {
//System.out.println("dentro al forY");
if(distance(j, 0, k, 0) % 1 == 0) {
//System.out.println("fatta operazione " + (operations[i]+1));
operations[i]++;
maxQuad = true;
x -= j;
y -= k;
}
}
}
//System.out.println("ci arrivo mai quii");
//System.out.println(x + " " + y);
if(x == 0 && y == 0)
ok = true;
}
}else if((x == 0 || y == 0) && !(x == 0 && y == 0))
operations[i]++;
//System.out.println("esco dall'ok HWIL");
}
for(int i = 0; i < t; i++) {
System.out.println(operations[i]);
}
/*
int a = scan.nextInt();
int b = scan.nextInt();
System.out.println(distance(a, 0, b, 0) % 1 == 0 ? "yes" : "no");
*/
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | af5ac0b12a277399e3a8a0e41cac178a | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | // #samoJako
import java.util.Arrays;
import java.util.Scanner;
public class A_Integer_Moves {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
for(int i = 0; i < n; i++) {
Integer x=sc.nextInt();
Integer y=sc.nextInt();
System.out.println(solve(x,y));
}
sc.close();
}
static Integer solve(Integer x, Integer y) {
if(x==0 && y==0) return 0;
if(check(x,y,0,0)== true) return 1;
else return 2;
}
static boolean check(Integer x, Integer y, Integer x2, Integer y2){
Double korijen = Math.sqrt( square(x2-x)+square(y2-y));
if( korijen == korijen.intValue() )
return true;
else return false;
}
static long square(int x) {
return (long) x * x;
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | de4a0dcb5c2a4ee879dd2b0519214d56 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | // #samoJako
import java.util.Arrays;
import java.util.Scanner;
public class A_Integer_Moves {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
for(int i = 0; i < n; i++) {
Integer x=sc.nextInt();
Integer y=sc.nextInt();
System.out.println(solve(x,y));
}
sc.close();
}
static Integer solve(Integer x, Integer y) {
Integer veci = Integer.max(x,y);
Integer manji = Integer.min(x,y);
Integer pocetakX = 0;
Integer pocetakY = 0;
if(x==0 && y==0) return 0;
if(check(x,y,0,0)== true) return 1;
else return 2;
}
static boolean check(Integer x, Integer y, Integer x2, Integer y2){
Double korijen = Math.sqrt( square(x2-x)+square(y2-y));
if( korijen == korijen.intValue() )
return true;
else return false;
}
static long square(int x) {
return (long) x * x;
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | b65461a3587c560103c5c3005ac8f491 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.*;
public class Solution {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
while(t-- > 0) {
long x = sc.nextInt();
long y = sc.nextInt();
long temp = (long)Math.sqrt(x*x + y*y);
if(x == 0 && y == 0) System.out.println(0);
else if (temp*temp == (x*x + y*y)) {
System.out.println(1);
} else {
System.out.println(2);
}
}
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 0129d5ce3994a67f172ec0941b06a64c | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.*;
public class Main
{
public static void main(String[] args) {
Scanner sc= new Scanner(System.in);
int t = sc.nextInt();
while(t--!=0){
int a= sc.nextInt();
int b = sc.nextInt();
if(a==0 && b==0){
System.out.println("0");
}
else{
double fin= (double) Math.sqrt(Math.pow(a,2)+ Math.pow(b,2));
if(Math.ceil(fin)==Math.floor(fin)){
System.out.println("1");
}
else{
System.out.println("2");
}
}
}
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 66cd23a1da3c002edb741d39610355e6 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;
public class Main {
static int t;
static int n;
static int[] a;
static String s;
static FastReader fr = new FastReader();
static PrintWriter out = new PrintWriter(System.out);
static long mod = 998244353l;
public static Edge[] edges;
public static int cnt;
public static int[] fir;
public static long[] dis;
public static boolean[] vis;
static class Edge {
int u, v, next;
boolean cut;
int used;
int num;
long fz, fm;
}
public static void dijInit(int edgeSize, int nodeSize) {
cnt = 0;
edges = new Edge[edgeSize + 10];
fir = new int[edgeSize + 10];
dis = new long[nodeSize + 10];
vis = new boolean[nodeSize + 10];
Arrays.fill(fir, -1);
}
public static long gcd(long a, long b) {
return b == 0 ? a : gcd(b, a % b);
}
//构建邻接表，u代表起点，v代表终点，w代表之间路径
static void addEdge(int u, int v, long fz, long fm) {
edges[cnt] = new Edge();
edges[cnt].u = u;
edges[cnt].v = v;
edges[cnt].fz = fz;
edges[cnt].fm = fm;
edges[cnt].next = fir[u];
edges[cnt].used = 0;
fir[u] = cnt++;
}
static long x, y, q;
//扩展欧几里德
static void ExEuclid(long a, long b) {
if (b == 0) {
x = 1;
y = 0;
q = a;
return;
}
ExEuclid(b, a % b);
long tmp = x;
x = y;
y = tmp - y * (a / b);
}
//乘法逆元
static long inv(long num) {
ExEuclid(num, mod);
return (x + mod) % mod;
}
static int[][] dp = new int[51][51];
static void init() {
Set<Integer> z = new HashSet<>();
for (int i = 0; i < 100; i++) {
z.add(i * i);
}
for (int i = 0; i <= 50; i ++) Arrays.fill(dp[i], 0x3f3f3f3f);
dp[0][0] = 0;
for (int i = 0; i <= 50; i ++) {
for (int j = 0; j <= 50; j ++) {
for (int k = 0; k <= i; k ++) {
for (int h = 0; h <= j; h ++) {
int t = (i - k) * (i - k) + (j - h) * (j - h);
if (t == 0) continue;
if (z.contains(t)) {
dp[i][j] = Math.min(dp[i][j], dp[k][h] + 1);
}
}
}
}
}
}
public static void main(String[] args) {
init();
int t = fr.nextInt();
while ((t --) > 0) {
int x = fr.nextInt();
int y = fr.nextInt();
System.out.println(dp[x][y]);
}
return;
}
static class FastReader {
private BufferedReader bfr;
private StringTokenizer st;
public FastReader() {
bfr = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
if (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(bfr.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
char nextChar() {
return next().toCharArray()[0];
}
String nextString() {
return next();
}
int[] nextIntArray(int n) {
int[] arr = new int[n];
for (int i = 0; i < n; i++)
arr[i] = nextInt();
return arr;
}
double[] nextDoubleArray(int n) {
double[] arr = new double[n];
for (int i = 0; i < arr.length; i++)
arr[i] = nextDouble();
return arr;
}
long[] nextLongArray(int n) {
long[] arr = new long[n];
for (int i = 0; i < n; i++)
arr[i] = nextLong();
return arr;
}
int[][] nextIntGrid(int n, int m) {
int[][] grid = new int[n][m];
for (int i = 0; i < n; i++) {
char[] line = fr.next().toCharArray();
for (int j = 0; j < m; j++)
grid[i][j] = line[j] - 48;
}
return grid;
}
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 62d945fea71a6b0bfdeace1e74242e1b | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.awt.image.ImageProducer;
import java.util.*;
public class Solution {
static boolean prime[] = new boolean[1000001];
static Set<Long> cubes=new HashSet<>();
static
{
long N = 1000000000000L;
//
//
// for(int i=1;i*i<=n;i++)
// {
// long x=i*i;
// set.add(x);
// }
for (long i = 1; i * i * i <= N; i++) {
cubes.add(i * i * i);
}
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int t=sc.nextInt();
while(t-->0) {
long a=sc.nextLong();
long b=sc.nextLong();
double cs=(a*a)+(b*b);
if(cs==0)
{
System.out.println(0);
}
else if(checkPerfectSquare(cs))
{
System.out.println(1);
}
else
{
System.out.println(2);
}
}
}
// public static int[] reverse(int arr[],int start,int end)
// {
// for(int i=start;i<=end;i++)
// {
// int temp=arr[i];
// arr[i]=arr[i+1];
// arr[i+1]=temp;
// }
// return arr;
// }
static boolean checkPerfectSquare(double number)
{
//calculating the square root of the given number
double sqrt=Math.sqrt(number);
//finds the floor value of the square root and comparing it with zero
return ((sqrt - Math.floor(sqrt)) == 0);
}
static void sieveOfEratosthenes(int n)
{
for(int i=0;i<=n;i++)
prime[i] = true;
for(int p = 2; p*p <=n; p++)
{
if(prime[p] == true)
{
for(int i = p*p; i <= n; i += p)
prime[i] = false;
}
}
// Print all prime numbers
// for(int i = 2; i <= n; i++)
// {
// if(prime[i] == true)
// System.out.print(i + " ");
// }
}
public static boolean isPrime(int n)
{
for(int i=2;i*i<=n;i++)
{
if(n%i==0)
return false;
}
return true;
}
public static int gcd(int a,int b)
{
if(b==0)
return a;
return gcd(b,a%b);
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 952a64effa469a54726fb515ddda7739 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | /*
I am dead inside
Do you like NCT, sKz, BTS?
5 4 3 2 1 Moonwalk
Imma knock it down like domino
Is this what you want? Is this what you want?
Let's ttalkbocky about that
*/
import static java.lang.Math.*;
import java.util.*;
import java.io.*;
import java.math.*;
public class x1657A
{
static final int INF = Integer.MAX_VALUE/2;
public static void main(String omkar[]) throws Exception
{
boolean[] square = new boolean[1<<18];
for(int v=1; v*v < 1<<18; v++)
square[v*v] = true;
BufferedReader infile = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(infile.readLine());
int T = Integer.parseInt(st.nextToken());
StringBuilder sb = new StringBuilder();
while(T-->0)
{
st = new StringTokenizer(infile.readLine());
int X = Integer.parseInt(st.nextToken());
int Y = Integer.parseInt(st.nextToken());
if(X+Y == 0)
sb.append("0\n");
else if(square[X*X+Y*Y])
sb.append("1\n");
else
sb.append("2\n");
}
System.out.print(sb);
}
public static int[] readArr(int N, BufferedReader infile, StringTokenizer st) throws Exception
{
int[] arr = new int[N];
st = new StringTokenizer(infile.readLine());
for(int i=0; i < N; i++)
arr[i] = Integer.parseInt(st.nextToken());
return arr;
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | d40ab4512617672842a24ceca4ae2212 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.*;
import java.io.*;
public class tr0 {
static PrintWriter out;
static StringBuilder sb;
static long mod = (long) 998244353;
static long inf = (long) 1e16;
static int n, l, k;
static ArrayList<Integer>[][] ad, ad1;
static int[][] remove, add;
static int[][] memo;
static long[] inv, f, ncr[];
static HashMap<Integer, Integer> hm;
static int[] pre, suf, Smax[], Smin[];
static int idmax, idmin;
static ArrayList<Integer> av;
static HashMap<Integer, Integer> mm;
static boolean[] msks;
static int[] lazy[], lazyCount;
static int[] c, w;
public static void main(String[] args) throws Exception {
Scanner sc = new Scanner(System.in);
out = new PrintWriter(System.out);
int t = sc.nextInt();
// int[][] dp = new int[51][51];
// ad = new ArrayList[51][51];
// for (int i = 0; i < ad.length; i++)
// for (int j = 0; j < ad.length; j++)
// ad[i][j] = new ArrayList<>();
// for (int i = 0; i <= 50; i++) {
// for (int j = 0; j <= 50; j++) {
// for (int ii = 0; ii <= 50; ii++) {
// for (int jj = 0; jj <= 50; jj++) {
// if (ii == i && jj == j)
// continue;
// int o = (i - ii) * (i - ii) + (j - jj) * (j - jj);
// int o2 = (int) Math.sqrt(o);
// if (o2 * o2 == o) {
// System.out.println(Math.abs(i - ii) + " " + Math.abs(j - jj));
// }
// }
// }
// }
// }
while (t-- > 0) {
int x = sc.nextInt();
int y = sc.nextInt();
if (x == 0 && y == 0)
out.println(0);
else {
int o = x * x + y * y;
int o2 = (int) Math.sqrt(o);
if (o2 * o2 == o) {
out.println(1);
} else
out.println(2);
}
}
out.flush();
}
static class Scanner {
StringTokenizer st;
BufferedReader br;
public Scanner(InputStream system) {
br = new BufferedReader(new InputStreamReader(system));
}
public Scanner(String file) throws Exception {
br = new BufferedReader(new FileReader(file));
}
public String next() throws IOException {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
public String nextLine() throws IOException {
return br.readLine();
}
public int nextInt() throws IOException {
return Integer.parseInt(next());
}
public double nextDouble() throws IOException {
return Double.parseDouble(next());
}
public char nextChar() throws IOException {
return next().charAt(0);
}
public Long nextLong() throws IOException {
return Long.parseLong(next());
}
public int[] nextArrInt(int n) throws IOException {
int[] a = new int[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
public long[] nextArrLong(int n) throws IOException {
long[] a = new long[n];
for (int i = 0; i < n; i++)
a[i] = nextLong();
return a;
}
public int[] nextArrIntSorted(int n) throws IOException {
int[] a = new int[n];
Integer[] a1 = new Integer[n];
for (int i = 0; i < n; i++)
a1[i] = nextInt();
Arrays.sort(a1);
for (int i = 0; i < n; i++)
a[i] = a1[i].intValue();
return a;
}
public long[] nextArrLongSorted(int n) throws IOException {
long[] a = new long[n];
Long[] a1 = new Long[n];
for (int i = 0; i < n; i++)
a1[i] = nextLong();
Arrays.sort(a1);
for (int i = 0; i < n; i++)
a[i] = a1[i].longValue();
return a;
}
public boolean ready() throws IOException {
return br.ready();
}
public void waitForInput() throws InterruptedException {
Thread.sleep(3000);
}
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | a270d8273551c2bbbcb033cb8001d512 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.*;
public class Solution {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int t = s.nextInt();
while (t-- > 0) {
int x = s.nextInt();
int y = s.nextInt();
if (x == 0 && y == 0) {
System.out.println("0");
continue;
}
double r = Math.sqrt(x * x + y * y);
if (r == (int) r) {
System.out.println("1");
} else {
System.out.println("2");
}
}
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | dada4ab5793d97b39ad288fbe2955b49 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.*;
public class main{
public static void main(String args[])
{
Scanner s=new Scanner(System.in);
int t=s.nextInt();
for(int g=0;g<t;g++)
{
int x=s.nextInt();
int y=s.nextInt();
if(x==0&&y==0)
{
System.out.println(0);
continue;
}
int a= x*x +y*y;
double d=Math.sqrt(a);
if(Math.floor(d)==d)
System.out.println(1);
else System.out.println(2);
}
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 1405f87923747147ea64a2b8607604ab | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.Scanner;
public class Main {
private static final int MAX_SQ = 50001;
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int testCases = in.nextInt();
boolean sq[] = new boolean[MAX_SQ];
for (int s = 1; s * s < MAX_SQ; ++s) {
sq[s * s] = true;
}
for (int currTestCase = 1; currTestCase <= testCases; ++currTestCase) {
int x = in.nextInt();
int y = in.nextInt();
if (x == 0 && y == 0) {
System.out.println(0);
} else if (x == 0 || y == 0) {
System.out.println(1);
} else if (sq[x * x + y * y]) {
System.out.println(1);
} else {
System.out.println(2);
}
}
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 087c080978b2c98fa57da9a613b056a3 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.Scanner;
public class A {
static Scanner sc = new Scanner(System.in);
private static void solve() {
int x = sc.nextInt();
int y = sc.nextInt();
if( x == 0 && y == 0 ) {
System.out.println("0");
return;
}
int val = (int) Math.sqrt(x * x + y * y);
if (val * val == (x * x + y * y)) {
System.out.println("1");
return;
}
System.out.println("2");
}
public static void main(String[] args) {
int t = sc.nextInt();
for (int k = 0; k < t; k++) {
solve();
}
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | f927f68b626af8dc446fc0da1701d81e | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.io.*;
import java.util.*;
public class A {
static int t,n,arr[],x,y;
static StringBuilder sb;
static BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
static StreamTokenizer in=new StreamTokenizer(bf);
static PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out));
public static void main(String[] args) throws IOException{
in.nextToken();t=(int)in.nval;
while(t-->0) solve();
out.flush();
}
static void solve() throws IOException {
in.nextToken();x=(int)in.nval;
in.nextToken();y=(int)in.nval;
if(x==0&&y==0){
out.println(0);
return;
}
out.println((int)Math.sqrt(x*x+y*y)==Math.sqrt(x*x+y*y)?1:2);
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 17ba2dd20a549861bd7e5dc17964e157 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.io.*;
import java.util.*;
public class Main
{
public static void main(String[] args) throws IOException {
IO io = new IO();
int t = io.nextInt();
while (t-- > 0) {
int x = io.nextInt(), y = io.nextInt();
if (x == 0 && y == 0) io.println(0);
else {
int dist = x * x + y * y;
boolean can = false;
for (int i = 1; i <= 1000; ++i) if (i * i == dist) can = true;
if (can) io.println(1);
else io.println(2);
}
}
io.flush();
io.close();
}
static class IO extends PrintWriter {
BufferedReader br;
StringTokenizer st;
// standard input
public IO() { this(System.in, System.out); }
public IO(InputStream i, OutputStream o) {
super(o);
br = new BufferedReader(new InputStreamReader(i));
}
public IO(String problemName) throws IOException {
super(problemName + ".out");
br = new BufferedReader(new FileReader(problemName + ".in"));
}
public String next() throws IOException {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
public String nextLine() throws IOException {
return br.readLine();
}
public int nextInt() throws IOException {
return Integer.parseInt(next());
}
public long nextLong() throws IOException {
return Long.parseLong(next());
}
public double nextDouble() throws IOException {
return Double.parseDouble(next());
}
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | dd4853c2829175acc4a8db54fbe6405a | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class Main {
public static void swap (int [] arr , int i , int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
public static void main(String[] args) throws IOException {
OutputStreamWriter osr = new OutputStreamWriter(System.out);
PrintWriter o = new PrintWriter(osr);
FastReader fr = new FastReader();
int t = fr.nextInt();
while (t-- != 0)
{
int x = fr.nextInt() , y = fr.nextInt();
if(x == 0 && y == 0)
o.println(0);
else {
double a = pow(x, 2) + pow(y, 2);
if(sqrt(a) == (int)sqrt(a))
o.println(1);
else
o.println(2);
}
}
o.close();
}
}
class FastReader {
// Attributes :
BufferedReader br;
StringTokenizer st;
// Constructor :
public FastReader() {
InputStreamReader isr = new InputStreamReader(System.in);
br = new BufferedReader(isr);
}
// Operations :
// #01 :
public String next() throws IOException {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
// #02 :
public String nextLine() throws IOException {
return br.readLine();
}
// #03 :
public int nextInt() throws IOException {
return Integer.parseInt(next());
}
// #04 :
public long nextLong() throws IOException {
return Long.parseLong(next());
}
// #05 :
public double nextDouble() throws IOException {
return Double.parseDouble(next());
}
// #06 :
public int [] intArray (int size) throws IOException{
int [] arr = new int[size];
for (int i = 0 ; i < size; i++)
arr[i] = nextInt();
return arr;
}
// #07 :
public char [] charArray() throws IOException {
return nextLine().toCharArray();
}
}
class Pair {
int x;
int y;
public Pair(int x, int y) {
this.x = x;
this.y = y;
}
static class Compare implements Comparator<Pair> {
@Override
public int compare(Pair o1, Pair o2) {
return (o1.y - o2.y);
}
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 1c4badcd63c8749ee5b65c6c01dce65f | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.Scanner;
public class test310 {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int t=in.nextInt();
for(int j=0;j<t;j++) {
int x=in.nextInt();
int y=in.nextInt();
if(x==0 && y==0) {
System.out.println(0);
}
else {
int z=(int)Math.sqrt(x*x+y*y);
if(z*z==x*x+y*y) {
System.out.println(1);
}
else {
System.out.println(2);
}
}
}
in.close();
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 48214ce8a24cb0ea01a111efd726db28 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | /*
...|/G\/E\/O\/R\/G\/E\|...
*/
import java.io.*;
import java.util.StringTokenizer;
import static java.lang.Double.parseDouble;
import static java.lang.Integer.parseInt;
import static java.lang.Long.parseLong;
public class Main {
static BufferedWriter of = null;
static {
try {
of = new BufferedWriter(new FileWriter(new File("filee.txt")));
} catch (IOException e) {
e.printStackTrace();
}
}
private static BufferedWriter ifile = null;
static {
try {
ifile = new BufferedWriter(new FileWriter(String.valueOf(System.in)));
} catch (IOException e) {
e.printStackTrace();
}
}
private static final BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
private static final Fast in = new Fast();
public static void main(String[] args) throws IOException {
int n = in.nextInt();
while(n>0)
{
int m1 = in.nextInt();
int m2 = in.nextInt();
if (m1==0 && m2==0)
System.out.println("0");
else if (Math.sqrt((m1*m1)+(m2*m2))-(int)Math.sqrt((m1*m1)+(m2*m2))==0)
System.out.println("1");
else
System.out.println("2");
n--;
}
}
public static class Fast {
BufferedReader br;
StringTokenizer st;
public Fast() {
br = new BufferedReader(new InputStreamReader(System.in));
}
public Fast(FileReader f) {
br = new BufferedReader(f);
}
public String next() throws IOException {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
public int nextInt() throws IOException {
return parseInt(next());
}
public long nextLong() throws IOException {
return parseLong(next());
}
public double nextDouble() throws IOException {
return parseDouble(next());
}
public float nextFloat() throws IOException {
return Float.parseFloat(next());
}
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 4ada6f159892e731bd4754e9f012d32b | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) {
new Thread(null, () -> new Main().run(), "1", 1 << 23).start();
}
private void run() {
FastReader scan = new FastReader();
PrintWriter out = new PrintWriter(System.out);
Solution solve = new Solution();
int t = scan.nextInt();
// int t = 1;
for (int qq = 0; qq < t; qq++) {
solve.solve(scan, out);
//out.println();
}
out.close();
}
}
class Solution {
/*
* think and coding
*/ double EPS = 0.000_0001;
public void solve(FastReader scan, PrintWriter out) {
int x = scan.nextInt(), y = scan.nextInt();
if (x == 0 && y == x) {
out.println(0);
} else {
int t = x * x + y * y;
int tt = (int) Math.sqrt(t);
if (tt * tt == t) {
out.println(1);
} else out.println(2);
}
}
static class Pair implements Comparable<Pair> {
int a, b;
public Pair(int a, int b) {
this.a = a;
this.b = b;
}
public Pair(Pair p) {
this.a = p.a;
this.b = p.b;
}
@Override
public int compareTo(Pair p) {
return Integer.compare(a, p.a);
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Pair pair = (Pair) o;
return a == pair.a && b == pair.b;
}
@Override
public int hashCode() {
return Objects.hash(a, b);
}
@Override
public String toString() {
return "Pair{" + "a=" + a + ", b=" + b + '}';
}
}
}
class FastReader {
private final BufferedReader br;
private StringTokenizer st;
public FastReader() {
br = new BufferedReader(new InputStreamReader(System.in));
}
public FastReader(String s) throws FileNotFoundException {
br = new BufferedReader(new FileReader(new File(s)));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 91a9e3dc7a84d9c31aed434e7a6f196b | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
int x , y;
while (t > 0) {
x = Integer.parseInt(sc.next());
y = Integer.parseInt(sc.next());
sc.nextLine();
if (x == 0 && y == 0) {
System.out.println(0);
} else {
int a = (int)Math.sqrt(x * x + y * y);
if (a * a == x * x + y * y) {
System.out.println(1);
} else {
System.out.println(2);
}
}
t -= 1;
}
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | b21fc9b9b2d40e6d6270acc09fc14e9d | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.Scanner;
public class vc {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
for (int i = 0; i < t; i++) {
double x = sc.nextDouble();
double y = sc.nextDouble();
if (x == 0.0 && y == 0.0) System.out.println(0);
else System.out.println((Math.sqrt(x * x + y * y) % 1.0 == 0) ? 1 : 2);
}
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | bc2adb0992f8d2544d46ffa7cab33116 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.*;
public class Main
{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
while (t-- > 0)
{
int x = sc.nextInt();
int y = sc.nextInt();
if ( x == 0 && y== 0)
{
System.out.println(0);
}
else if ((double)Math.sqrt(x*x+y*y) == (int)Math.sqrt(x*x+y*y))
{
System.out.println(1);
}
else if ((double)Math.sqrt(x*x+y*y) != (int)Math.sqrt(x*x+y*y))
{
System.out.println(2);
}
}
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 2e171cd6bdf8c0781d589a0abd7df098 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class AMinSteps {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in, StandardCharsets.UTF_8.name());
String s1 = sc.nextLine();
Integer count = Integer.parseInt(s1);
List<String> inputs = new ArrayList();
for(int i=0; i<count; i++){
inputs.add(sc.nextLine());
}
for(int j=0; j<count; j++){
String s2 = inputs.get(j);
int x = Integer.parseInt(s2.split(" ")[0]);
int y = Integer.parseInt(s2.split(" ")[1]);
if(x==0 && y==0){
System.out.println(0);
continue;
}
if(Double.valueOf(Math.sqrt(x*x+y*y)).intValue() * Double.valueOf(Math.sqrt(x*x+y*y)).intValue() == x*x + y*y){
System.out.println(1);
}else {
System.out.println(2);
}
}
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | dbcf1d829aa1cbb60790e1c3449d19c5 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.Scanner;
public class ProblemA {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int t = in.nextInt();
int[][] point = new int[t][2];
for (int i = 0; i < t; i++) {
point[i][0] = in.nextInt();
point[i][1] = in.nextInt();
}
for (int i = 0; i < t; i++) {
int x = point[i][0];
int y = point[i][1];
if (x == 0 && y == 0) {
System.out.println(0);
} else if (Math.round(Math.sqrt(x * x + y * y)) == Math.sqrt(x * x + y * y)) {
System.out.println(1);
} else {
System.out.println(2);
}
}
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 49623ee18176fbbee0010e2187f2f38f | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes |
import java.io.*;
import java.util.*;
public final class Main {
//int 2e9 - long 9e18
static PrintWriter out = new PrintWriter(System.out);
static FastReader in = new FastReader();
static Pair[] moves = new Pair[]{new Pair(-1, 0), new Pair(0, 1), new Pair(1, 0), new Pair(0, -1)};
static int mod = (int) (1e9 + 7);
static int mod2 = 998244353;
public static void main(String[] args) {
int tt = i();
while (tt-- > 0) {
solve();
}
out.flush();
}
public static void solve() {
int x = i();
int y = i();
if (x == 0 && y == 0) {
out.println(0);
} else {
int z = x * x + y * y;
int sq = (int) Math.sqrt(z);
if (sq * sq == z) {
out.println(1);
} else {
out.println(2);
}
}
}
// (10,5) = 2 ,(11,5) = 3
static long upperDiv(long a, long b) {
return (a / b) + ((a % b == 0) ? 0 : 1);
}
static long sum(int[] a) {
long sum = 0;
for (int x : a) {
sum += x;
}
return sum;
}
static int[] preint(int[] a) {
int[] pre = new int[a.length + 1];
pre[0] = 0;
for (int i = 0; i < a.length; i++) {
pre[i + 1] = pre[i] + a[i];
}
return pre;
}
static long[] pre(int[] a) {
long[] pre = new long[a.length + 1];
pre[0] = 0;
for (int i = 0; i < a.length; i++) {
pre[i + 1] = pre[i] + a[i];
}
return pre;
}
static long[] post(int[] a) {
long[] post = new long[a.length + 1];
post[0] = 0;
for (int i = 0; i < a.length; i++) {
post[i + 1] = post[i] + a[a.length - 1 - i];
}
return post;
}
static long[] pre(long[] a) {
long[] pre = new long[a.length + 1];
pre[0] = 0;
for (int i = 0; i < a.length; i++) {
pre[i + 1] = pre[i] + a[i];
}
return pre;
}
static void print(char A[]) {
for (char c : A) {
out.print(c);
}
out.println();
}
static void print(boolean A[]) {
for (boolean c : A) {
out.print(c + " ");
}
out.println();
}
static void print(int A[]) {
for (int c : A) {
out.print(c + " ");
}
out.println();
}
static void print(long A[]) {
for (long i : A) {
out.print(i + " ");
}
out.println();
}
static void print(List<Integer> A) {
for (int a : A) {
out.print(a + " ");
}
}
static int i() {
return in.nextInt();
}
static long l() {
return in.nextLong();
}
static double d() {
return in.nextDouble();
}
static String s() {
return in.nextLine();
}
static String c() {
return in.next();
}
static int[][] inputWithIdx(int N) {
int A[][] = new int[N][2];
for (int i = 0; i < N; i++) {
A[i] = new int[]{i, in.nextInt()};
}
return A;
}
static int[] input(int N) {
int A[] = new int[N];
for (int i = 0; i < N; i++) {
A[i] = in.nextInt();
}
return A;
}
static long[] inputLong(int N) {
long A[] = new long[N];
for (int i = 0; i < A.length; i++) {
A[i] = in.nextLong();
}
return A;
}
static int GCD(int a, int b) {
if (b == 0) {
return a;
} else {
return GCD(b, a % b);
}
}
static long GCD(long a, long b) {
if (b == 0) {
return a;
} else {
return GCD(b, a % b);
}
}
static long LCM(int a, int b) {
return (long) a / GCD(a, b) * b;
}
static long LCM(long a, long b) {
return a / GCD(a, b) * b;
}
// find highest i which satisfy a[i]<=x
static int lowerbound(int[] a, int x) {
int l = 0;
int r = a.length - 1;
while (l < r) {
int m = (l + r + 1) / 2;
if (a[m] <= x) {
l = m;
} else {
r = m - 1;
}
}
return l;
}
static void shuffle(int[] arr) {
for (int i = 0; i < arr.length; i++) {
int rand = (int) (Math.random() * arr.length);
int temp = arr[rand];
arr[rand] = arr[i];
arr[i] = temp;
}
}
static void shuffleAndSort(int[] arr) {
for (int i = 0; i < arr.length; i++) {
int rand = (int) (Math.random() * arr.length);
int temp = arr[rand];
arr[rand] = arr[i];
arr[i] = temp;
}
Arrays.sort(arr);
}
static void shuffleAndSort(int[][] arr, Comparator<? super int[]> comparator) {
for (int i = 0; i < arr.length; i++) {
int rand = (int) (Math.random() * arr.length);
int[] temp = arr[rand];
arr[rand] = arr[i];
arr[i] = temp;
}
Arrays.sort(arr, comparator);
}
static void shuffleAndSort(long[] arr) {
for (int i = 0; i < arr.length; i++) {
int rand = (int) (Math.random() * arr.length);
long temp = arr[rand];
arr[rand] = arr[i];
arr[i] = temp;
}
Arrays.sort(arr);
}
static boolean isPerfectSquare(double number) {
double sqrt = Math.sqrt(number);
return ((sqrt - Math.floor(sqrt)) == 0);
}
static void swap(int A[], int a, int b) {
int t = A[a];
A[a] = A[b];
A[b] = t;
}
static void swap(char A[], int a, int b) {
char t = A[a];
A[a] = A[b];
A[b] = t;
}
static long pow(long a, long b, int mod) {
long pow = 1;
long x = a;
while (b != 0) {
if ((b & 1) != 0) {
pow = (pow * x) % mod;
}
x = (x * x) % mod;
b /= 2;
}
return pow;
}
static long pow(long a, long b) {
long pow = 1;
long x = a;
while (b != 0) {
if ((b & 1) != 0) {
pow *= x;
}
x = x * x;
b /= 2;
}
return pow;
}
static long modInverse(long x, int mod) {
return pow(x, mod - 2, mod);
}
static boolean isPrime(long N) {
if (N <= 1) {
return false;
}
if (N <= 3) {
return true;
}
if (N % 2 == 0 || N % 3 == 0) {
return false;
}
for (int i = 5; i * i <= N; i = i + 6) {
if (N % i == 0 || N % (i + 2) == 0) {
return false;
}
}
return true;
}
public static String reverse(String str) {
if (str == null) {
return null;
}
return new StringBuilder(str).reverse().toString();
}
public static void reverse(int[] arr) {
for (int i = 0; i < arr.length / 2; i++) {
int tmp = arr[i];
arr[arr.length - 1 - i] = tmp;
arr[i] = arr[arr.length - 1 - i];
}
}
public static String repeat(char ch, int repeat) {
if (repeat <= 0) {
return "";
}
final char[] buf = new char[repeat];
for (int i = repeat - 1; i >= 0; i--) {
buf[i] = ch;
}
return new String(buf);
}
public static int[] manacher(String s) {
char[] chars = s.toCharArray();
int n = s.length();
int[] d1 = new int[n];
for (int i = 0, l = 0, r = -1; i < n; i++) {
int k = (i > r) ? 1 : Math.min(d1[l + r - i], r - i + 1);
while (0 <= i - k && i + k < n && chars[i - k] == chars[i + k]) {
k++;
}
d1[i] = k--;
if (i + k > r) {
l = i - k;
r = i + k;
}
}
return d1;
}
public static int[] kmp(String s) {
int n = s.length();
int[] res = new int[n];
for (int i = 1; i < n; ++i) {
int j = res[i - 1];
while (j > 0 && s.charAt(i) != s.charAt(j)) {
j = res[j - 1];
}
if (s.charAt(i) == s.charAt(j)) {
++j;
}
res[i] = j;
}
return res;
}
}
class Pair {
int i;
int j;
Pair(int i, int j) {
this.i = i;
this.j = j;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
Pair pair = (Pair) o;
return i == pair.i && j == pair.j;
}
@Override
public int hashCode() {
return Objects.hash(i, j);
}
}
class ThreePair {
int i;
int j;
int k;
ThreePair(int i, int j, int k) {
this.i = i;
this.j = j;
this.k = k;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
ThreePair pair = (ThreePair) o;
return i == pair.i && j == pair.j && k == pair.k;
}
@Override
public int hashCode() {
return Objects.hash(i, j);
}
}
class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
class Node {
int val;
public Node(int val) {
this.val = val;
}
}
class ST {
int n;
Node[] st;
ST(int n) {
this.n = n;
st = new Node[4 * Integer.highestOneBit(n)];
}
void build(Node[] nodes) {
build(0, 0, n - 1, nodes);
}
private void build(int id, int l, int r, Node[] nodes) {
if (l == r) {
st[id] = nodes[l];
return;
}
int mid = (l + r) >> 1;
build((id << 1) + 1, l, mid, nodes);
build((id << 1) + 2, mid + 1, r, nodes);
st[id] = comb(st[(id << 1) + 1], st[(id << 1) + 2]);
}
void update(int i, Node node) {
update(0, 0, n - 1, i, node);
}
private void update(int id, int l, int r, int i, Node node) {
if (i < l || r < i) {
return;
}
if (l == r) {
st[id] = node;
return;
}
int mid = (l + r) >> 1;
update((id << 1) + 1, l, mid, i, node);
update((id << 1) + 2, mid + 1, r, i, node);
st[id] = comb(st[(id << 1) + 1], st[(id << 1) + 2]);
}
Node get(int x, int y) {
return get(0, 0, n - 1, x, y);
}
private Node get(int id, int l, int r, int x, int y) {
if (x > r || y < l) {
return new Node(0);
}
if (x <= l && r <= y) {
return st[id];
}
int mid = (l + r) >> 1;
return comb(get((id << 1) + 1, l, mid, x, y), get((id << 1) + 2, mid + 1, r, x, y));
}
Node comb(Node a, Node b) {
if (a == null) {
return b;
}
if (b == null) {
return a;
}
return new Node(GCD(a.val, b.val));
}
static int GCD(int a, int b) {
if (b == 0) {
return a;
} else {
return GCD(b, a % b);
}
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 74b2c50a8728ec68f87af24369f5aae4 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.*;
import java.io.*;
public class MyCpClass{
public static void main(String []args) throws IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringBuilder sb = new StringBuilder();
int T = Integer.parseInt(br.readLine().trim());
while(T-- > 0){
String []ip = br.readLine().trim().split(" ");
int x = Integer.parseInt(ip[0]);
int y = Integer.parseInt(ip[1]);
int ans = 2, i = 1;
int n = x*x + y*y;
while(i*i <= n){
if(i*i == n) ans = 1;
i++;
}
if(x==0 && y==0) ans = 0;
sb.append(ans + "\n");
}
System.out.println(sb);
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 691ce32295a15bc0db68e136b681f519 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes |
import java.util.*;
import java.io.*;
public class A {
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
public static void swap(long[] a, int i, int j) {
long temp = a[i];
a[i] = a[j];
a[j] = temp;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
FastReader t = new FastReader();
PrintWriter o = new PrintWriter(System.out);
int test = t.nextInt();
while (test-- > 0) {
long m = t.nextLong();
long n = t.nextLong();
long max = Integer.MIN_VALUE, min = Integer.MAX_VALUE;
// int n = t.nextInt();
// long[] a = new long[n];
// for (int i = 0; i < n; ++i) {
// a[i] = t.nextLong();
// }
double d = Math.sqrt(m*m+n*n);
int ans = 0;
if (m == 0 && n == 0)
{
}
else if (d%1 == 0.00)
ans = 1;
else
ans = 2;
o.println(ans);
}
o.flush();
o.close();
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | f728a80ea482410d5d15a4fc9f5dfa65 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.*;
public class IntegerMoves
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
while(t-->0)
{
int x = sc.nextInt();
int y = sc.nextInt();
double z = Math.sqrt(x*x+y*y);
System.out.println(z==0?"0":z==(int)z?"1":"2");
}
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 718488224cd4d0616ef4b4ba9bcc090d | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.*;
public class IntegerMoves {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc=new Scanner(System.in);
int t=sc.nextInt();
while(t-->0) {
int x=sc.nextInt();
int y=sc.nextInt();
int temp=x*x+y*y;
if(x==0&&y==0)
System.out.println(0);
else if(Math.sqrt(temp)==(int)Math.sqrt(temp))
System.out.println(1);
else
System.out.println(2);
}
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 7498c7cd028303f9aa727af4b9cc62ca | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.*;
import java.io.*;
public class IntegerMoves {
public static void main(String[] args) throws IOException {
Scanner scan = new Scanner (System.in);
int n = scan.nextInt();
for(int i=0;i<n;i++) {
int x = scan.nextInt();
int y = scan.nextInt();
int currx = 0;
int curry = 0;
int counter = 0;
if(x==0 && y==0) {
System.out.println(counter);
} else {
for(int j=x;j>=currx;j--) {
for(int k=y;k>=curry;k--) {
double sqrt = Math.sqrt((j-currx)*(j-currx)+(k-curry)*(k-curry));
if(sqrt==(int)sqrt) {
counter++;
currx = j;
curry = k;
j=x;
k=y+1;
if(x==currx &&y==curry) {
break;
}
}
}
if(x==currx &&y==curry) {
break;
}
}
System.out.println(counter);
}
}
}
static class Scanner {
StringTokenizer st;
BufferedReader br;
public Scanner(InputStream s) {
br = new BufferedReader(new InputStreamReader(s));
}
public String next() throws IOException {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
public int nextInt() throws IOException {
return Integer.parseInt(next());
}
public long nextLong() throws IOException {
return Long.parseLong(next());
}
public String nextLine() throws IOException {
return br.readLine();
}
public double nextDouble() throws IOException {
String x = next();
StringBuilder sb = new StringBuilder("0");
double res = 0, f = 1;
boolean dec = false, neg = false;
int start = 0;
if (x.charAt(0) == '-') {
neg = true;
start++;
}
for (int i = start; i < x.length(); i++)
if (x.charAt(i) == '.') {
res = Long.parseLong(sb.toString());
sb = new StringBuilder("0");
dec = true;
} else {
sb.append(x.charAt(i));
if (dec)
f *= 10;
}
res += Long.parseLong(sb.toString()) / f;
return res * (neg ? -1 : 1);
}
public boolean ready() throws IOException {
return br.ready();
}
public int[] readArr(int n) throws IOException {
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = Integer.parseInt(next());
}
return arr;
}
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 7d1958cfd898311fdfe3fd833db2151e | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes |
import java.io.*;
import java.util.*;
public class Main {
static Reader rd = new Reader();
public static void main(String[] args) {
int tt = rd.nextInt();
while (tt-- > 0) {
new Solution().solve();
}
}
static class Solution {
// int N = 51;
void solve() {
int x = rd.nextInt(), y = rd.nextInt();
// int[][] step = new int[N][N];
if (x == 0 && y == 0) {
System.out.println(0);
return;
}
long d = Math.round(Math.sqrt(x * x + y * y));
if (d * d == x * x + y * y) {
System.out.println(1);
return;
}
System.out.println(2);
}
}
static class Reader {
private BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
private StringTokenizer tokenizer = new StringTokenizer("");
private String innerNextLine() {
try {
return reader.readLine();
} catch (IOException ex) {
throw new RuntimeException(ex);
}
}
public boolean hasNext() {
while (!tokenizer.hasMoreTokens()) {
String nextLine = innerNextLine();
if (nextLine == null) {
return false;
}
tokenizer = new StringTokenizer(nextLine);
}
return true;
}
public String nextLine() {
tokenizer = new StringTokenizer("");
return innerNextLine();
}
public String next() {
hasNext();
return tokenizer.nextToken();
}
public int nextInt() {
return Integer.valueOf(next());
}
public long nextLong() {
return Long.valueOf(next());
}
public double nextDouble() {
return Double.valueOf(next());
}
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 6cf43d7a4e8ae552f011dd0424ebc6bb | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes |
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class Main
{
public static void main(String args[]) throws java.lang.Exception
{
FastScanner input = new FastScanner();
int tc = input.nextInt();
work:
while (tc-- > 0) {
double x = input.nextDouble();
double y = input.nextDouble();
double dis = Math.sqrt(x*x+y*y);
long one = (long) dis;
long two = (long) Math.ceil(dis);
if(one==two&&one==0L)
{
System.out.println("0");
}
else if(one==two)
{
System.out.println(1);
}
else
{
System.out.println(2);
}
}
}
static class FastScanner
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer("");
String next()
{
while (!st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt()
{
return Integer.parseInt(next());
}
long nextLong()
{
return Long.parseLong(next());
}
double nextDouble()
{
return Double.parseDouble(next());
}
String nextLine() throws IOException
{
return br.readLine();
}
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 7c896315903e772fdabc0b807cb59cbd | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.*;
import java.lang.Math;
import java.util.StringTokenizer;
public class nine {
public static void main(String[] args){
int a, b, t;
String str;
FastReader in = new FastReader();
t = in.nextInt();
while(t-- > 0){
int x1 = 0;
int y1 = 0;
int x2 = in.nextInt();
int y2 = in.nextInt();
double distance = Math.sqrt(Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2));
if(x2 == x1 && y2 == y1){
System.out.println(0);
continue;
}
if(distance % 1 == 0){
System.out.println(1);
}else{
System.out.println(2);
}
}
}
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br = new BufferedReader(new InputStreamReader(System.in));
}
String next()
{
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
}
catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() { return Integer.parseInt(next()); }
long nextLong() { return Long.parseLong(next()); }
double nextDouble()
{
return Double.parseDouble(next());
}
String nextLine()
{
String str = "";
try {
if(st.hasMoreTokens()){
str = st.nextToken("\n");
}
else{
str = br.readLine();
}
}
catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 6b6bcf1fab2ecf3f6c9ae095036bdc14 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.Scanner;
public class A1657 {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int T = in.nextInt();
for (int t=0; t<T; t++) {
int X = in.nextInt();
int Y = in.nextInt();
int answer;
double dist = Math.sqrt(X*X + Y*Y);
if (dist == 0) {
answer = 0;
} else {
answer = (dist == (int) dist) ? 1 : 2;
}
System.out.println(answer);
}
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | ca7eb757f86bb9a14bd2e1b34774ae95 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.io.*;
import java.util.*;
public class _1657a {
FastScanner scn;
PrintWriter w;
PrintStream fs;
int MOD = 1000000007;
int MAX = 200005;
long mul(long x, long y) {long res = x * y; return (res >= MOD ? res % MOD : res);}
long power(long x, long y) {if (y < 0) return 1; long res = 1; x %= MOD; while (y!=0) {if ((y & 1)==1)res = mul(res, x); y >>= 1; x = mul(x, x);} return res;}
void ruffleSort(int[] a) {int n=a.length;Random r=new Random();for (int i=0; i<a.length; i++) {int oi=r.nextInt(n), temp=a[i];a[i]=a[oi];a[oi]=temp;}Arrays.sort(a);}
void reverseSort(int[] arr){List<Integer> list = new ArrayList<>();for (int i=0; i<arr.length; i++){list.add(arr[i]);}Collections.sort(list, Collections.reverseOrder());for (int i = 0; i < arr.length; i++){arr[i] = list.get(i);}}
boolean LOCAL;
void debug(Object... o){if(LOCAL)System.err.println(Arrays.deepToString(o));}
//SPEED IS NOT THE CRITERIA, CODE SHOULD BE A NO BRAINER, CMP KILLS, MOCIM
boolean checkPerfectSquare(double number)
{
//calculating the square root of the given number
double sqrt=Math.sqrt(number);
//finds the floor value of the square root and comparing it with zero
return ((sqrt - Math.floor(sqrt)) == 0);
}
void solve(){
int t =scn.nextInt();
while(t-->0)
{
int x = scn.nextInt();
int y = scn.nextInt();
if(x==0&&y==0){
w.println(0);
continue;
}
double xx =x,yy=y;
double ans = (xx*xx)+(yy*yy);
if(checkPerfectSquare(ans)){
w.println(1);
}else{
w.println(2);
}
}
}
void run() {
try {
long ct = System.currentTimeMillis();
scn = new FastScanner(new File("input.txt"));
w = new PrintWriter(new File("output.txt"));
fs=new PrintStream("error.txt");
System.setErr(fs);
LOCAL=true;
solve();
w.close();
System.err.println(System.currentTimeMillis() - ct);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
void runIO() {
scn = new FastScanner(System.in);
w = new PrintWriter(System.out);
LOCAL=false;
solve();
w.close();
}
class FastScanner {
BufferedReader br;
StringTokenizer st;
public FastScanner(File f) {
try {
br = new BufferedReader(new FileReader(f));
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
public FastScanner(InputStream f) {
br = new BufferedReader(new InputStreamReader(f));
}
String next() {
while (st == null || !st.hasMoreTokens()) {
String s = null;
try {
s = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
if (s == null)
return null;
st = new StringTokenizer(s);
}
return st.nextToken();
}
boolean hasMoreTokens() {
while (st == null || !st.hasMoreTokens()) {
String s = null;
try {
s = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
if (s == null)
return false;
st = new StringTokenizer(s);
}
return true;
}
int nextInt() {
return Integer.parseInt(next());
}
int[] nextIntArray(int n) {
int a[] = new int[n];
for (int i = 0; i < n; i++) {
a[i] = nextInt();
}
return a;
}
long[] nextLongArray(int n) {
long a[] = new long[n];
for (int i = 0; i < n; i++) {
a[i] = nextLong();
}
return a;
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
}
int lowerBound(int[] arr, int x){int n = arr.length, si = 0, ei = n - 1;while(si <= ei){int mid = si + (ei - si)/2;if(arr[mid] == x){if(mid-1 >= 0 && arr[mid-1] == arr[mid]){ei = mid-1;}else{return mid;}}else if(arr[mid] > x){ei = mid - 1; }else{si = mid+1;}}return si; }
int upperBound(int[] arr, int x){int n = arr.length, si = 0, ei = n - 1;while(si <= ei){int mid = si + (ei - si)/2;if(arr[mid] == x){if(mid+1 < n && arr[mid+1] == arr[mid]){si = mid+1;}else{return mid + 1;}}else if(arr[mid] > x){ei = mid - 1; }else{si = mid+1;}}return si; }
int upperBound(ArrayList<Integer> list, int x){int n = list.size(), si = 0, ei = n - 1;while(si <= ei){int mid = si + (ei - si)/2;if(list.get(mid) == x){if(mid+1 < n && list.get(mid+1) == list.get(mid)){si = mid+1;}else{return mid + 1;}}else if(list.get(mid) > x){ei = mid - 1; }else{si = mid+1;}}return si; }
void swap(int[] arr, int i, int j){int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}
long nextPowerOf2(long v){if (v == 0) return 1;v--;v |= v >> 1;v |= v >> 2;v |= v >> 4;v |= v >> 8;v |= v >> 16;v |= v >> 32;v++;return v;}
int gcd(int a, int b) {if(a == 0){return b;}return gcd(b%a, a);} // TC- O(logmax(a,b))
boolean nextPermutation(int[] arr) {if(arr == null || arr.length <= 1){return false;}int last = arr.length-2;while(last >= 0){if(arr[last] < arr[last+1]){break;}last--;}if (last < 0){return false;}if(last >= 0){int nextGreater = arr.length-1;for(int i=arr.length-1; i>last; i--){if(arr[i] > arr[last]){nextGreater = i;break;}}swap(arr, last, nextGreater);}int i = last + 1, j = arr.length - 1;while(i < j){swap(arr, i++, j--);}return true;}
public static void main(String[] args) {
new _1657a().runIO();
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 9443a4a00e927f0bb21aa0876bc019d1 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.*;
import java.io.*;
public class Solution {
public static void main(String[] args) throws IOException {
Scanner in = new Scanner(System.in);
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringBuffer out = new StringBuffer();
int T = in.nextInt();
OUTER:
while (T-->0) {
int x = in.nextInt();
int y = in.nextInt();
int ans = -1;
if(x==0 && y==0) {
ans = 0;
} else {
double dist = Math.sqrt(x*x+y*y);
if(dist == (int)dist) {
ans = 1;
} else {
ans = 2;
}
}
out.append(ans+"\n");
}
System.out.print(out);
}
private static long gcd(long a, long b) {
if (a==0)
return b;
return gcd(b%a, a);
}
private static int toInt(String s) {
return Integer.parseInt(s);
}
private static long toLong(String s) {
return Long.parseLong(s);
}
private static void print(String s) {
System.out.print(s);
}
private static void println(String s) {
System.out.println(s);
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | c78afa9510aabe6b016c16a99953fe12 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes |
import javax.swing.*;
import java.lang.reflect.Array;
import java.text.DecimalFormat;
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.*;
import java.util.stream.Stream;
// Please name your class Main
public class Main {
static FastScanner fs=new FastScanner();
static class FastScanner {
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st=new StringTokenizer("");
public String next() {
while (!st.hasMoreElements())
try {
st=new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
return st.nextToken();
}
int Int() {
return Integer.parseInt(next());
}
long Long() {
return Long.parseLong(next());
}
String Str(){
return next();
}
}
public static void main (String[] args) throws java.lang.Exception {
PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
//reading /writing file
//Scanner in=new Scanner(System.in);
//Scanner in=new Scanner(new File("input.txt"));
//PrintWriter pr=new PrintWriter("output.txt")
int T=1;
for(int t=0;t<T;t++){
Solution sol1=new Solution(out,fs);
sol1.solution(T,t);
}
out.flush();
}
public static int[] Arr(int n){
int A[]=new int[n];
for(int i=0;i<n;i++)A[i]=Int();
return A;
}
public static int Int(){
return fs.Int();
}
public static long Long(){
return fs.Long();
}
public static String Str(){
return fs.Str();
}
}
class Solution {
PrintWriter out;
int INF = Integer.MAX_VALUE;
int NINF = Integer.MIN_VALUE;
int MOD = 998244353;
int mod = 1000000007;
Main.FastScanner fs;
public Solution(PrintWriter out, Main.FastScanner fs) {
this.out = out;
this.fs = fs;
}
public void add(Map<Integer, Integer> f, int key) {
Integer cnt = f.get(key);
if(cnt == null) {
f.put(key, 1);
} else {
f.put(key, cnt + 1);
}
}
public void del(Map<Integer, Integer> f, int key) {
Integer cnt = f.get(key);
if(cnt == 1) {
f.remove(key);
} else {
f.put(key, cnt - 1);
}
}
public void msg(String s) {
System.out.println(s);
}
public void solution(int all, int testcase) {
int t = fs.Int();
while(t > 0) {
t--;
int x = fs.Int();int y = fs.Int();
if(x == 0 && y == 0) {
out.println(0);
} else {
int sum = x * x + y * y;
int sq = (int)(Math.sqrt(sum));
if(sq * sq == sum) {
out.println(1);
} else {
out.println(2);
}
}
}
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 982d941ae483e3a5fd2b804940ed8186 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.*;
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
TaskA solver = new TaskA();
// int a = 1;
int t;
t = in.nextInt();
//t = 1;
while (t > 0) {
// out.print("Case #"+(a++)+": ");
solver.call(in,out);
t--;
}
out.close();
}
static class TaskA {
public void call(InputReader in, PrintWriter out) {
long x, y;
x = in.nextLong();
y = in.nextLong();
if(x==0 && y==0){
out.println(0);
return;
}
long a = x*x + y*y;
long b = (long) Math.pow(a,0.5);
if(b*b == a){
out.println(1);
}
else{
out.println(2);
}
}
}
static int gcd(int a, int b )
{
if (a == 0)
return b;
return gcd(b % a, a);
}
static int lcm(int a, int b)
{
return (a / gcd(a, b)) * b;
}
static class answer implements Comparable<answer>{
int a;
long b, c;
public answer(int a, long b, int c) {
this.a = a;
this.b = b;
this.c = c;
}
public answer(int a, long b) {
this.a = a;
this.b = b;
}
@Override
public int compareTo(answer o) {
if(this.a == o.a){
return Long.compare(this.b, o.b);
}
return Integer.compare(this.a, o.a);
}
}
static class answer1 implements Comparable<answer1>{
int a, b, c;
public answer1(int a, int b, int c) {
this.a = a;
this.b = b;
this.c = c;
}
public answer1(int a, int b) {
this.a = a;
this.b = b;
}
@Override
public int compareTo(answer1 o) {
if(this.b == o.b){
return Integer.compare(this.a, o.a);
}
return Integer.compare(this.b, o.b);
}
}
static long gcd(long a, long b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
static void sort(long[] a) {
ArrayList<Long> l = new ArrayList<>();
for (Long i:a) l.add(i);
Collections.sort(l);
for (int i=0; i<a.length; i++) a[i]=l.get(i);
}
static final Random random=new Random();
static void shuffleSort(int[] a) {
int n = a.length;
for (int i=0; i<n; i++) {
int oi= random.nextInt(n), temp=a[oi];
a[oi]=a[i]; a[i]=temp;
}
Arrays.sort(a);
}
static class InputReader {
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream), 32768);
tokenizer = null;
}
public String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong(){
return Long.parseLong(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | aa0a9458ddee32ae73ab793f846ae271 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | // package faltu;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
import java.util.Map.Entry;
public class Main {
public static int upperBound(long[] arr, long m, int l, int r) {
while(l<=r) {
int mid=(l+r)/2;
if(arr[mid]<=m) l=mid+1;
else r=mid-1;
}
return l;
}
public static int lowerBound(long[] a, long m, int l, int r) {
while(l<=r) {
int mid=(l+r)/2;
if(a[mid]<m) l=mid+1;
else r=mid-1;
}
return l;
}
public static long getClosest(long val1, long val2,long target)
{
if (target - val1 >= val2 - target)
return val2;
else
return val1;
}
static void ruffleSort(long[] a) {
int n=a.length;
Random r=new Random();
for (int i=0; i<a.length; i++) {
long oi=r.nextInt(n), temp=a[i];
a[i]=a[(int)oi];
a[(int)oi]=temp;
}
Arrays.sort(a);
}
static void ruffleSort(int[] a){
int n=a.length;
Random r=new Random();
for (int i=0; i<a.length; i++) {
int oi=r.nextInt(n), temp=a[i];
a[i]=a[oi];
a[oi]=temp;
}
Arrays.sort(a);
}
int ceilIndex(int input[], int T[], int end, int s){
int start = 0;
int middle;
int len = end;
while(start <= end){
middle = (start + end)/2;
if(middle < len && input[T[middle]] < s && s <= input[T[middle+1]]){
return middle+1;
}else if(input[T[middle]] < s){
start = middle+1;
}else{
end = middle-1;
}
}
return -1;
}
public static int findIndex(long arr[], long t)
{
if (arr == null) {
return -1;
}
int len = arr.length;
int i = 0;
while (i < len) {
if (arr[i] == t) {
return i;
}
else {
i = i + 1;
}
}
return -1;
}
static long gcd(long a, long b)
{
if (a == 0)
return b;
return gcd(b % a, a);
}
static int gcd(int a, int b)
{
if (a == 0)
return b;
return gcd(b % a, a);
}
static long lcm(long a,long b)
{
return (a / gcd(a, b)) * b;
}
public static int[] swap(int a[], int left, int right)
{
int temp = a[left];
a[left] = a[right];
a[right] = temp;
return a;
}
public static void swap(long x,long max1)
{
long temp=x;
x=max1;
max1=temp;
}
public static int[] reverse(int a[], int left, int right)
{
// Reverse the sub-array
while (left < right) {
int temp = a[left];
a[left++] = a[right];
a[right--] = temp;
}
return a;
}
static int lowerLimitBinarySearch(ArrayList<Integer> A,int B) {
int n =A.size();
int first = 0,second = n;
while(first <second) {
int mid = first + (second-first)/2;
if(A.get(mid) > B) {
second = mid;
}else {
first = mid+1;
}
}
if(first < n && A.get(first) < B) {
first++;
}
return first; //1 index
}
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br = new BufferedReader(
new InputStreamReader(System.in));
}
String next()
{
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
}
catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() { return Integer.parseInt(next()); }
long nextLong() { return Long.parseLong(next()); }
double nextDouble()
{
return Double.parseDouble(next());
}
String nextLine()
{
String str = "";
try {
str = br.readLine();
}
catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
// *******----segement tree implement---*****
// -------------START--------------------------
void buildTree (int[] arr,int[] tree,int start,int end,int treeNode)
{
if(start==end)
{
tree[treeNode]=arr[start];
return;
}
buildTree(arr,tree,start,end,2*treeNode);
buildTree(arr,tree,start,end,2*treeNode+1);
tree[treeNode]=tree[treeNode*2]+tree[2*treeNode+1];
}
void updateTree(int[] arr,int[] tree,int start,int end,int treeNode,int idx,int value)
{
if(start==end)
{
arr[idx]=value;
tree[treeNode]=value;
return;
}
int mid=(start+end)/2;
if(idx>mid)
{
updateTree(arr,tree,mid+1,end,2*treeNode+1,idx,value);
}
else
{
updateTree(arr,tree,start,mid,2*treeNode,idx,value);
}
tree[treeNode]=tree[2*treeNode]+tree[2*treeNode+1];
}
// disjoint set implementation --start
static void makeSet(int n)
{
parent=new int[n];
rank=new int[n];
for(int i=0;i<n;i++)
{
parent[i]=i;
rank[i]=0;
}
}
static void union(int u,int v)
{
u=findpar(u);
v=findpar(v);
if(rank[u]<rank[v])parent[u]=v;
else if(rank[v]<rank[u])parent[v]=u;
else
{
parent[v]=u;
rank[u]++;
}
}
private static int findpar(int node)
{
if(node==parent[node])return node;
return parent[node]=findpar(parent[node]);
}
static int parent[];
static int rank[];
// *************end
static void presumbit(int[][]prebitsum) {
for(int i=1;i<=200000;i++) {
int z=i;
int j=0;
while(z>0) {
if((z&1)==1) {
prebitsum[i][j]+=(prebitsum[i-1][j]+1);
}else {
prebitsum[i][j]=prebitsum[i-1][j];
}
z=z>>1;
j++;
}
}
}
public static int[] sort(int[] arr) {
ArrayList<Integer> al = new ArrayList<>();
for(int i=0;i<arr.length;i++) al.add(arr[i]);
Collections.sort(al);
for(int i=0;i<arr.length;i++) arr[i]=al.get(i);
return arr;
}
static ArrayList<String>powof2s;
static void powof2S() {
long i=1;
while(i<(long)2e18) {
powof2s.add(String.valueOf(i));
i*=2;
}
}
static boolean coprime(int a, long l){
return (gcd(a, l) == 1);
}
static Long MOD=(long) (1e9+7);
static int prebitsum[][];
static ArrayList<Integer>arr;
static boolean[] vis;
static ArrayList<ArrayList<Integer>>adj;
public static void main(String[] args) throws IOException
{
// sieve();
// prebitsum=new int[200001][18];
// presumbit(prebitsum);
// powof2S();
FastReader s = new FastReader();
long tt = s.nextLong();
while(tt-->0) {
int x=s.nextInt();
int y=s.nextInt();
if(x==0&&y==0)System.out.println(0);
else {
double dis=Math.sqrt((x*x)+(y*y));
int temp1=(int) Math.ceil(dis);
int temp2=(int) Math.floor(dis);
if(temp1!=temp2)System.out.println(2);
else System.out.println(1);
}
}
}
static void DFSUtil(int v, boolean[] visited)
{
visited[v] = true;
Iterator<Integer> it = adj.get(v).iterator();
while (it.hasNext()) {
int n = it.next();
if (!visited[n])
DFSUtil(n, visited);
}
}
static long DFS(int n)
{
boolean[] visited = new boolean[n+1];
long cnt=0;
for (int i = 1; i <= n; i++) {
if (!visited[i]) {
DFSUtil(i, visited);
cnt++;
}
}
return cnt;
}
public static String revStr(String str){
String input = str;
StringBuilder input1 = new StringBuilder();
input1.append(input);
input1.reverse();
return input1.toString();
}
public static String sortString(String inputString){
char tempArray[] = inputString.toCharArray();
Arrays.sort(tempArray);
return new String(tempArray);
}
static long myPow(long n, long i){
if(i==0) return 1;
if(i%2==0) return (myPow(n,i/2)%MOD * myPow(n,i/2)%MOD)%MOD;
return (n%MOD* myPow(n,i-i)%MOD)%MOD;
}
static void palindromeSubStrs(String str) {
HashSet<String>set=new HashSet<>();
char[]a =str.toCharArray();
int n=str.length();
int[][]dp=new int[n][n];
for(int g=0;g<n;g++){
for(int i=0,j=g;j<n;j++,i++){
if(!set.contains(str.substring(i,i+1))&&g==0) {
dp[i][j]=1;
set.add(str.substring(i,i+1));
}
else {
if(!set.contains(str.substring(i,j+1))&&isPalindrome(str,i,j)) {
dp[i][j]=1;
set.add(str.substring(i,j+1));
}
}
}
}
int ans=0;
for(int i=0;i<n;i++) {
for(int j=0;j<n;j++) {
System.out.print(dp[i][j]+" ");
if(dp[i][j]==1)ans++;
}
System.out.println();
}
System.out.println(ans);
}
static boolean isPalindrome(String str,int i,int j)
{
while (i < j) {
if (str.charAt(i) != str.charAt(j))
return false;
i++;
j--;
}
return true;
}
static boolean sign(long num) {
return num>0;
}
static boolean isSquare(long x){
if(x==1)return true;
long y=(long) Math.sqrt(x);
return y*y==x;
}
static long power1(long a,long b) {
if(b == 0){
return 1;
}
long ans = power(a,b/2);
ans *= ans;
if(b % 2!=0){
ans *= a;
}
return ans;
}
static void swap(StringBuilder sb,int l,int r)
{
char temp = sb.charAt(l);
sb.setCharAt(l,sb.charAt(r));
sb.setCharAt(r,temp);
}
// function to reverse the string between index l and r
static void reverse(StringBuilder sb,int l,int r)
{
while(l < r)
{
swap(sb,l,r);
l++;
r--;
}
}
// function to search a character lying between index l and r
// which is closest greater (just greater) than val
// and return it's index
static int binarySearch(StringBuilder sb,int l,int r,char val)
{
int index = -1;
while (l <= r)
{
int mid = (l+r)/2;
if (sb.charAt(mid) <= val)
{
r = mid - 1;
}
else
{
l = mid + 1;
if (index == -1 || sb.charAt(index) >= sb.charAt(mid))
index = mid;
}
}
return index;
}
// this function generates next permutation (if there exists any such permutation) from the given string
// and returns True
// Else returns false
static boolean nextPermutation(StringBuilder sb)
{
int len = sb.length();
int i = len-2;
while (i >= 0 && sb.charAt(i) >= sb.charAt(i+1))
i--;
if (i < 0)
return false;
else
{
int index = binarySearch(sb,i+1,len-1,sb.charAt(i));
swap(sb,i,index);
reverse(sb,i+1,len-1);
return true;
}
}
private static int lps(int m ,int n,String s1,String s2,int[][]mat)
{
for(int i=1;i<=m;i++)
{
for(int j=1;j<=n;j++)
{
if(s1.charAt(i-1)==s2.charAt(j-1))mat[i][j]=1+mat[i-1][j-1];
else mat[i][j]=Math.max(mat[i-1][j],mat[i][j-1]);
}
}
return mat[m][n];
}
static int lcs(String X, String Y, int m, int n)
{
int[][] L = new int[m+1][n+1];
// Following steps build L[m+1][n+1] in bottom up fashion. Note
// that L[i][j] contains length of LCS of X[0..i-1] and Y[0..j-1]
for (int i=0; i<=m; i++)
{
for (int j=0; j<=n; j++)
{
if (i == 0 || j == 0)
L[i][j] = 0;
else if (X.charAt(i-1) == Y.charAt(j-1))
L[i][j] = L[i-1][j-1] + 1;
else
L[i][j] = Math.max(L[i-1][j], L[i][j-1]);
}
}
return L[m][n];
// Following code is used to print LCS
// int index = L[m][n];
// int temp = index;
//
// // Create a character array to store the lcs string
// char[] lcs = new char[index+1];
// lcs[index] = '\u0000'; // Set the terminating character
//
// // Start from the right-most-bottom-most corner and
// // one by one store characters in lcs[]
// int i = m;
// int j = n;
// while (i > 0 && j > 0)
// {
// // If current character in X[] and Y are same, then
// // current character is part of LCS
// if (X.charAt(i-1) == Y.charAt(j-1))
// {
// // Put current character in result
// lcs[index-1] = X.charAt(i-1);
//
// // reduce values of i, j and index
// i--;
// j--;
// index--;
// }
//
// // If not same, then find the larger of two and
// // go in the direction of larger value
// else if (L[i-1][j] > L[i][j-1])
// i--;
// else
// j--;
// }
// return String.valueOf(lcs);
// Print the lcs
// System.out.print("LCS of "+X+" and "+Y+" is ");
// for(int k=0;k<=temp;k++)
// System.out.print(lcs[k]);
}
static long lis(long[] aa2, int n)
{
long lis[] = new long[n];
int i, j;
long max = 0;
for (i = 0; i < n; i++)
lis[i] = 1;
for (i = 1; i < n; i++)
for (j = 0; j < i; j++)
if (aa2[i] >= aa2[j] && lis[i] <= lis[j] + 1)
lis[i] = lis[j] + 1;
for (i = 0; i < n; i++)
if (max < lis[i])
max = lis[i];
return max;
}
static boolean isPalindrome(String str)
{
int i = 0, j = str.length() - 1;
while (i < j) {
if (str.charAt(i) != str.charAt(j))
return false;
i++;
j--;
}
return true;
}
static boolean issafe(int i, int j, int r,int c, char ch)
{
if (i < 0 || j < 0 || i >= r || j >= c|| ch!= '1')return false;
else return true;
}
static long power(long a, long b)
{
a %=MOD;
long out = 1;
while (b > 0) {
if((b&1)!=0)out = out * a % MOD;
a = a * a % MOD;
b >>= 1;
a*=a;
}
return out;
}
static long[] sieve;
public static void sieve()
{
int nnn=(int) 1e6+1;
long nn=(int) 1e6;
sieve=new long[(int) nnn];
int[] freq=new int[(int) nnn];
sieve[0]=0;
sieve[1]=1;
for(int i=2;i<=nn;i++)
{
sieve[i]=1;
freq[i]=1;
}
for(int i=2;i*i<=nn;i++)
{
if(sieve[i]==1)
{
for(int j=i*i;j<=nn;j+=i)
{
if(sieve[j]==1)
{
sieve[j]=0;
}
}
}
}
}
}
class decrease implements Comparator<Long> {
// Used for sorting in ascending order of
// roll number
public int compare(long a, long b)
{
return (int) (b - a);
}
@Override
public int compare(Long o1, Long o2) {
// TODO Auto-generated method stub
return (int) (o2-o1);
}
}
class pair{
long x;
long y;
long c;
char ch;
public pair(long x,long y) {
this.x=x;
this.y=y;
}
public pair(long x,char ch) {
this.x=x;
this.ch=ch;
}
public pair(long x,long y,long c)
{
this.x=x;
this.y=y;
this.c=c;
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 537d47c9e45c00520b2790e7553342fb | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.Scanner;
import java.io.IOException;
import java.util.Scanner;
import java.util.concurrent.CopyOnWriteArraySet;
public class int_mov {
static boolean isInteger(double N)
{
// Convert float value
// of N to integer
int X = (int)N;
double temp2 = N - X;
// If N is not equivalent
// to any integer
if (temp2 > 0)
{
return false;
}
return true;
}
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int a= sc.nextInt();
for(int i=0;i<a ;i++) {
int c = sc.nextInt();
int b = sc.nextInt();
double x=(Math.pow(c, 2) + Math.pow(b, 2)) ;
// System.out.println(x);
double R = Math.sqrt(x);
// System.out.println(R);
if(c==0 && b==0){
System.out.println("0");
}
else if (isInteger(R))
{
System.out.println("1");
}
else
{
System.out.println("2");
}
}
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 4eeda3fc3855521abd87325a0d78621c | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes |
import java.util.Scanner;
public class IntegerMoves {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int t=sc.nextInt();
while (t-->0){
int x=sc.nextInt();
int y=sc.nextInt();
if(x==0 && y==0){
System.out.println(0);
}
else if (Math.sqrt(x*x+y*y)==(int)Math.sqrt(x*x+y*y)){
System.out.println(1);
}
else {
System.out.println(2);
}
}
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 8b67eceb78755b6fcd4776a84d555805 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes |
import java.util.Scanner;
public class codevita {
public static int solve(int x,int y) {
if(x==0 && y==0) {
return 0;
}
int a=(x*x)+(y*y);
double b=Math.sqrt(a);
if(Math.floor(b)==b) {
return 1;
}else {
return 2;
}
}
public static void main(String[] args) {
Scanner s= new Scanner(System.in);
int t=s.nextInt();
while(t-->0) {
int x= s.nextInt();
int y= s.nextInt();
int a=solve(x,y);
System.out.println(a);
}
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 6a0694af8588d83e5f908b5ba9eb753b | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int T = in.nextInt();
while(T-- > 0) {
int x = in.nextInt();
int y = in.nextInt();
double dis = Math.sqrt(x*x + y*y);
int d = (int)Math.sqrt(x*x + y*y);
if(dis == 0) {
System.out.println(0);
} else if(dis == d) {
System.out.println(1);
} else {
System.out.println(2);
}
}
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 311f0c0a494c86a49547ab36f4e0c403 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | /* package codechef; // don't place package name! */
import java.util.*;
import java.lang.*;
import java.io.*;
/* Name of the class has to be "Main" only if the class is public. */
public class Codechef
{
public static void main (String[] args) throws java.lang.Exception
{
// your code goes here
try {
Scanner sc=new Scanner(System.in);
int t=sc.nextInt();
while(t-->0)
{
int x=sc.nextInt();
int y=sc.nextInt();
if(x==0 && y==0){
System.out.println(0);
continue;
}
int root= (int)Math.sqrt(x*x + y*y);
int temp=x*x + y*y;
root*=root;
if(root==temp)
{
System.out.println(1);
continue;
}
System.out.println(2);
}
} catch(Exception e) {
}
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 9cf0427c3f9afc26308bb5c98789eeb0 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.Scanner;
public class IntegerMoves{
public static double distance(int x1, int y1, int x2, int y2){
double dist = Math.sqrt((x2 - x1)*(x2 - x1) + (y2 - y1)*(y2 - y1));
return dist;
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int x1 = 0;
int y1 = 0;
for(int i = 0; i < n; i++){
int x2 = sc.nextInt();
int y2 = sc.nextInt();
if(x2 == 0 && y2 == 0) System.out.println("0");
else{
double dist = distance(x1, y1, x2, y2);
int d = (int)dist;
if(d == dist){
System.out.println("1");
}else{
System.out.println("2");
}
}
}
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | a5981d9f2db56161a45ba811ce1a67f8 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.*;
import java.util.stream.IntStream;
import java.io.*;
public class Solution{
public static void main(String args[]){
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
while(t--!=0){
int x = sc.nextInt();
int y = sc.nextInt();
if(x==0 && y==0){
System.out.println("0");
continue;
}
int z = x*x+y*y;
boolean b = false;
if(z>=0){
int sr = (int)Math.sqrt(z);
if(sr*sr == z){
b = true;
}
}
if(b){
System.out.println("1");
}
else{
System.out.println("2");
}
}
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | bc3faed12bcc0e9d829b05a2809ddd83 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.io.*;
import java.util.*;
public class A_Integer_Moves
{
public static void main(String[] args) {
MyScanner s = new MyScanner();
int t = s.nextInt();
for(int f = 0;f<t;f++)
{
int x = s.nextInt();
int y = s.nextInt();
if(x==0 && y==0)
{
System.out.println(0);
continue;
}
double a = Math.sqrt(x*x + y*y);
if(a==Math.ceil(a))
{
System.out.println(1);
}else
{
System.out.println(2);
}
}
}
}
class MyScanner {
BufferedReader br; StringTokenizer st;
public MyScanner() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine(){
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 8 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | c251ffa4fd996c1eb0b8a58d1d9f36a8 | train_110.jsonl | 1647960300 | You are given four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$. You should build a sequence $$$a_0, a_1, a_2, \dots, a_n$$$ where $$$a_0 = 0$$$ and for each $$$i \ge 1$$$ you can choose: either $$$a_i = a_{i - 1} + x$$$ or $$$a_i = a_{i - 1} - y$$$. Your goal is to build such a sequence $$$a$$$ that $$$a_i \le B$$$ for all $$$i$$$ and $$$\sum\limits_{i=0}^{n}{a_i}$$$ is maximum possible. | 256 megabytes | import java.util.*;
public class XY_sequence
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
int t=sc.nextInt();
for(int i=0;i<t;i++)
{
long n,b,x,y,sum;
n=sc.nextLong();
b=sc.nextLong();
x=sc.nextLong();
y=sc.nextLong();
sum=0;
long a=0;
for(int j=0;j<n;j++)
{
if(a+x<=b)
{
a=a+x;
}
else
{
a=a-y;
}
sum=sum+a;
}
System.out.println(sum);
}
}
} | Java | ["3\n5 100 1 30\n7 1000000000 1000000000 1000000000\n4 1 7 3"] | 2 seconds | ["15\n4000000000\n-10"] | NoteIn the first test case, the optimal sequence $$$a$$$ is $$$[0, 1, 2, 3, 4, 5]$$$.In the second test case, the optimal sequence $$$a$$$ is $$$[0, 10^9, 0, 10^9, 0, 10^9, 0, 10^9]$$$.In the third test case, the optimal sequence $$$a$$$ is $$$[0, -3, -6, 1, -2]$$$. | Java 11 | standard input | [
"greedy"
] | 2c921093abf2c5963f5f0e96cd430456 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. Next $$$t$$$ cases follow. The first and only line of each test case contains four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$ ($$$1 \le n \le 2 \cdot 10^5$$$; $$$1 \le B, x, y \le 10^9$$$). It's guaranteed that the total sum of $$$n$$$ doesn't exceed $$$2 \cdot 10^5$$$. | 800 | For each test case, print one integer — the maximum possible $$$\sum\limits_{i=0}^{n}{a_i}$$$. | standard output | |
PASSED | 794e41a9c674749ebaf4c5ff2e1d2bee | train_110.jsonl | 1647960300 | You are given four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$. You should build a sequence $$$a_0, a_1, a_2, \dots, a_n$$$ where $$$a_0 = 0$$$ and for each $$$i \ge 1$$$ you can choose: either $$$a_i = a_{i - 1} + x$$$ or $$$a_i = a_{i - 1} - y$$$. Your goal is to build such a sequence $$$a$$$ that $$$a_i \le B$$$ for all $$$i$$$ and $$$\sum\limits_{i=0}^{n}{a_i}$$$ is maximum possible. | 256 megabytes | import java.util.*;
public class Solution {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int t=sc.nextInt();
sc.nextLine();
for(int i=0;i<t;i++){
long n=sc.nextInt();
long b=sc.nextInt();
long x=sc.nextInt();
long y=sc.nextInt();
long prev=0;
long count=0;
for(int j=0;j<=n;j++){
count+=prev;
if(prev+x<=b)
prev=prev+x;
else
prev=prev-y;
}
System.out.println(count);
}
}
} | Java | ["3\n5 100 1 30\n7 1000000000 1000000000 1000000000\n4 1 7 3"] | 2 seconds | ["15\n4000000000\n-10"] | NoteIn the first test case, the optimal sequence $$$a$$$ is $$$[0, 1, 2, 3, 4, 5]$$$.In the second test case, the optimal sequence $$$a$$$ is $$$[0, 10^9, 0, 10^9, 0, 10^9, 0, 10^9]$$$.In the third test case, the optimal sequence $$$a$$$ is $$$[0, -3, -6, 1, -2]$$$. | Java 11 | standard input | [
"greedy"
] | 2c921093abf2c5963f5f0e96cd430456 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. Next $$$t$$$ cases follow. The first and only line of each test case contains four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$ ($$$1 \le n \le 2 \cdot 10^5$$$; $$$1 \le B, x, y \le 10^9$$$). It's guaranteed that the total sum of $$$n$$$ doesn't exceed $$$2 \cdot 10^5$$$. | 800 | For each test case, print one integer — the maximum possible $$$\sum\limits_{i=0}^{n}{a_i}$$$. | standard output | |
PASSED | 9f71b6f8252b0bfc12eb139ed5f4af06 | train_110.jsonl | 1647960300 | You are given four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$. You should build a sequence $$$a_0, a_1, a_2, \dots, a_n$$$ where $$$a_0 = 0$$$ and for each $$$i \ge 1$$$ you can choose: either $$$a_i = a_{i - 1} + x$$$ or $$$a_i = a_{i - 1} - y$$$. Your goal is to build such a sequence $$$a$$$ that $$$a_i \le B$$$ for all $$$i$$$ and $$$\sum\limits_{i=0}^{n}{a_i}$$$ is maximum possible. | 256 megabytes | import java.util.*;
public class Round_124_Div2 {
public static void main(String[] args) {
Scanner str = new Scanner(System.in);
int t = str.nextInt();
for (int i = 0; i < t; i++) {
int n = str.nextInt();
int b = str.nextInt();
int x = str.nextInt();
int y = str.nextInt();
long sum = 0;
int arr[] = new int[n + 1];
arr[0] = 0;
for (int j = 1; j <= n; j++) {
if(Math.max(arr[j-1] + x, arr[j-1] - y) <= b){
arr[j] = Math.max(arr[j-1] + x, arr[j-1] - y);
} else{
arr[j] = Math.min(arr[j-1] + x, arr[j-1] - y);
}
sum += arr[j];
}
System.out.println(sum);
}
}
} | Java | ["3\n5 100 1 30\n7 1000000000 1000000000 1000000000\n4 1 7 3"] | 2 seconds | ["15\n4000000000\n-10"] | NoteIn the first test case, the optimal sequence $$$a$$$ is $$$[0, 1, 2, 3, 4, 5]$$$.In the second test case, the optimal sequence $$$a$$$ is $$$[0, 10^9, 0, 10^9, 0, 10^9, 0, 10^9]$$$.In the third test case, the optimal sequence $$$a$$$ is $$$[0, -3, -6, 1, -2]$$$. | Java 11 | standard input | [
"greedy"
] | 2c921093abf2c5963f5f0e96cd430456 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. Next $$$t$$$ cases follow. The first and only line of each test case contains four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$ ($$$1 \le n \le 2 \cdot 10^5$$$; $$$1 \le B, x, y \le 10^9$$$). It's guaranteed that the total sum of $$$n$$$ doesn't exceed $$$2 \cdot 10^5$$$. | 800 | For each test case, print one integer — the maximum possible $$$\sum\limits_{i=0}^{n}{a_i}$$$. | standard output | |
PASSED | 26199ce3ecdc1c6b724fb98cae5f9e28 | train_110.jsonl | 1647960300 | You are given four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$. You should build a sequence $$$a_0, a_1, a_2, \dots, a_n$$$ where $$$a_0 = 0$$$ and for each $$$i \ge 1$$$ you can choose: either $$$a_i = a_{i - 1} + x$$$ or $$$a_i = a_{i - 1} - y$$$. Your goal is to build such a sequence $$$a$$$ that $$$a_i \le B$$$ for all $$$i$$$ and $$$\sum\limits_{i=0}^{n}{a_i}$$$ is maximum possible. | 256 megabytes | import java.util.*;
public class Main{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
int t=sc.nextInt();
while(t-->0)
{
int n=sc.nextInt();
int b=sc.nextInt();
int x=sc.nextInt();
int y=sc.nextInt();
long sum=0,str=0;
while(n>0)
{
if(str+x<=b)
{
str+=x;
sum+=str;
}
else
{
str-=y;
sum+=str;
}
n--;
// System.out.println(sum);
}
System.out.println(sum);
}
}} | Java | ["3\n5 100 1 30\n7 1000000000 1000000000 1000000000\n4 1 7 3"] | 2 seconds | ["15\n4000000000\n-10"] | NoteIn the first test case, the optimal sequence $$$a$$$ is $$$[0, 1, 2, 3, 4, 5]$$$.In the second test case, the optimal sequence $$$a$$$ is $$$[0, 10^9, 0, 10^9, 0, 10^9, 0, 10^9]$$$.In the third test case, the optimal sequence $$$a$$$ is $$$[0, -3, -6, 1, -2]$$$. | Java 11 | standard input | [
"greedy"
] | 2c921093abf2c5963f5f0e96cd430456 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. Next $$$t$$$ cases follow. The first and only line of each test case contains four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$ ($$$1 \le n \le 2 \cdot 10^5$$$; $$$1 \le B, x, y \le 10^9$$$). It's guaranteed that the total sum of $$$n$$$ doesn't exceed $$$2 \cdot 10^5$$$. | 800 | For each test case, print one integer — the maximum possible $$$\sum\limits_{i=0}^{n}{a_i}$$$. | standard output | |
PASSED | 3044e863c47dbf4053571873b62cd7bf | train_110.jsonl | 1647960300 | You are given four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$. You should build a sequence $$$a_0, a_1, a_2, \dots, a_n$$$ where $$$a_0 = 0$$$ and for each $$$i \ge 1$$$ you can choose: either $$$a_i = a_{i - 1} + x$$$ or $$$a_i = a_{i - 1} - y$$$. Your goal is to build such a sequence $$$a$$$ that $$$a_i \le B$$$ for all $$$i$$$ and $$$\sum\limits_{i=0}^{n}{a_i}$$$ is maximum possible. | 256 megabytes | import java.util.*;
public class Main {
public static void main(String[] args) {
// System.out.println(" afddfadf");
Scanner scn = new Scanner(System.in);
int t = scn.nextInt();
while(t-->0) {
// System.out.println();
int n = scn.nextInt();
long b = scn.nextLong();
long x = scn.nextLong();
long y = scn.nextLong();
long a = 0;
long sum = 0;
for(int i=1;i<=n;i++) {
if(a+x<=b) {
a = a+x;
}else {
a = a-y;
}
sum+=a;
}
System.out.println(sum);
}
}
}
| Java | ["3\n5 100 1 30\n7 1000000000 1000000000 1000000000\n4 1 7 3"] | 2 seconds | ["15\n4000000000\n-10"] | NoteIn the first test case, the optimal sequence $$$a$$$ is $$$[0, 1, 2, 3, 4, 5]$$$.In the second test case, the optimal sequence $$$a$$$ is $$$[0, 10^9, 0, 10^9, 0, 10^9, 0, 10^9]$$$.In the third test case, the optimal sequence $$$a$$$ is $$$[0, -3, -6, 1, -2]$$$. | Java 11 | standard input | [
"greedy"
] | 2c921093abf2c5963f5f0e96cd430456 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. Next $$$t$$$ cases follow. The first and only line of each test case contains four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$ ($$$1 \le n \le 2 \cdot 10^5$$$; $$$1 \le B, x, y \le 10^9$$$). It's guaranteed that the total sum of $$$n$$$ doesn't exceed $$$2 \cdot 10^5$$$. | 800 | For each test case, print one integer — the maximum possible $$$\sum\limits_{i=0}^{n}{a_i}$$$. | standard output | |
PASSED | 7b75f83e6d0ac015ee70b47092534eac | train_110.jsonl | 1647960300 | You are given four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$. You should build a sequence $$$a_0, a_1, a_2, \dots, a_n$$$ where $$$a_0 = 0$$$ and for each $$$i \ge 1$$$ you can choose: either $$$a_i = a_{i - 1} + x$$$ or $$$a_i = a_{i - 1} - y$$$. Your goal is to build such a sequence $$$a$$$ that $$$a_i \le B$$$ for all $$$i$$$ and $$$\sum\limits_{i=0}^{n}{a_i}$$$ is maximum possible. | 256 megabytes | import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.*;
public class Main{
public static void main(String[] args)throws Exception {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int testCases = Integer.parseInt(br.readLine());
StringBuilder result = new StringBuilder();
StringTokenizer str;
for(int testCase = 1; testCase <= testCases; testCase++){
str = new StringTokenizer(br.readLine());
int n = Integer.parseInt(str.nextToken());
long B = Long.parseLong(str.nextToken());
long x = Long.parseLong(str.nextToken());
long y = Long.parseLong(str.nextToken());
long sum = 0, num = 0;
while(n > 0){
if(n > 0 && ((num + x) <= B)){
num += x;
n--;
sum += num;
}else{
num -= y;
n--;
sum += num;
}
}
result.append(sum + "\n");
}
System.out.println(result);
}
} | Java | ["3\n5 100 1 30\n7 1000000000 1000000000 1000000000\n4 1 7 3"] | 2 seconds | ["15\n4000000000\n-10"] | NoteIn the first test case, the optimal sequence $$$a$$$ is $$$[0, 1, 2, 3, 4, 5]$$$.In the second test case, the optimal sequence $$$a$$$ is $$$[0, 10^9, 0, 10^9, 0, 10^9, 0, 10^9]$$$.In the third test case, the optimal sequence $$$a$$$ is $$$[0, -3, -6, 1, -2]$$$. | Java 11 | standard input | [
"greedy"
] | 2c921093abf2c5963f5f0e96cd430456 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. Next $$$t$$$ cases follow. The first and only line of each test case contains four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$ ($$$1 \le n \le 2 \cdot 10^5$$$; $$$1 \le B, x, y \le 10^9$$$). It's guaranteed that the total sum of $$$n$$$ doesn't exceed $$$2 \cdot 10^5$$$. | 800 | For each test case, print one integer — the maximum possible $$$\sum\limits_{i=0}^{n}{a_i}$$$. | standard output | |
PASSED | fba4c84ff9120113c3110cc6dc7f5b40 | train_110.jsonl | 1647960300 | You are given four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$. You should build a sequence $$$a_0, a_1, a_2, \dots, a_n$$$ where $$$a_0 = 0$$$ and for each $$$i \ge 1$$$ you can choose: either $$$a_i = a_{i - 1} + x$$$ or $$$a_i = a_{i - 1} - y$$$. Your goal is to build such a sequence $$$a$$$ that $$$a_i \le B$$$ for all $$$i$$$ and $$$\sum\limits_{i=0}^{n}{a_i}$$$ is maximum possible. | 256 megabytes | import java.util.*;
// Compiler version JDK 11.0.2
public class Dcoder
{
public static void main(String args[])
{
Scanner s=new Scanner(System.in);
int t=s.nextInt();
while(t-->0)
{
int n=s.nextInt();
int B=s.nextInt();
int x=s.nextInt();
int y=s.nextInt();
long ans=0;
int a=0;
while(n-->0)
{
if(a+x<=B)
a+=x;
else
a-=y;
ans+=a;
}
System.out.println(ans);
}
s.close();
}
}
| Java | ["3\n5 100 1 30\n7 1000000000 1000000000 1000000000\n4 1 7 3"] | 2 seconds | ["15\n4000000000\n-10"] | NoteIn the first test case, the optimal sequence $$$a$$$ is $$$[0, 1, 2, 3, 4, 5]$$$.In the second test case, the optimal sequence $$$a$$$ is $$$[0, 10^9, 0, 10^9, 0, 10^9, 0, 10^9]$$$.In the third test case, the optimal sequence $$$a$$$ is $$$[0, -3, -6, 1, -2]$$$. | Java 11 | standard input | [
"greedy"
] | 2c921093abf2c5963f5f0e96cd430456 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. Next $$$t$$$ cases follow. The first and only line of each test case contains four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$ ($$$1 \le n \le 2 \cdot 10^5$$$; $$$1 \le B, x, y \le 10^9$$$). It's guaranteed that the total sum of $$$n$$$ doesn't exceed $$$2 \cdot 10^5$$$. | 800 | For each test case, print one integer — the maximum possible $$$\sum\limits_{i=0}^{n}{a_i}$$$. | standard output | |
PASSED | 5eb01d74c65cc32bbd9452dfa7ee68b4 | train_110.jsonl | 1647960300 | You are given four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$. You should build a sequence $$$a_0, a_1, a_2, \dots, a_n$$$ where $$$a_0 = 0$$$ and for each $$$i \ge 1$$$ you can choose: either $$$a_i = a_{i - 1} + x$$$ or $$$a_i = a_{i - 1} - y$$$. Your goal is to build such a sequence $$$a$$$ that $$$a_i \le B$$$ for all $$$i$$$ and $$$\sum\limits_{i=0}^{n}{a_i}$$$ is maximum possible. | 256 megabytes | import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int tc = sc.nextInt();
while (tc-- > 0) {
int n = sc.nextInt();
int B = sc.nextInt();
int x = sc.nextInt();
int y = sc.nextInt();
int[] arr = new int[n + 1];
arr[0] = 0;
for (int i = 1; i < arr.length; i++) {
if (arr[i - 1] + x > B) {
arr[i] = arr[i - 1] - y;
} else if (arr[i - 1] - y > B) {
arr[i] = arr[i - 1] + x;
} else {
arr[i] = Math.max(arr[i - 1] + x, arr[i - 1] - y);
}
}
// System.out.println(Arrays.toString(arr));
long ans = 0;
for (int i = 1; i < arr.length; i++) {
ans += arr[i];
}
System.out.println(ans);
}
}
}
| Java | ["3\n5 100 1 30\n7 1000000000 1000000000 1000000000\n4 1 7 3"] | 2 seconds | ["15\n4000000000\n-10"] | NoteIn the first test case, the optimal sequence $$$a$$$ is $$$[0, 1, 2, 3, 4, 5]$$$.In the second test case, the optimal sequence $$$a$$$ is $$$[0, 10^9, 0, 10^9, 0, 10^9, 0, 10^9]$$$.In the third test case, the optimal sequence $$$a$$$ is $$$[0, -3, -6, 1, -2]$$$. | Java 11 | standard input | [
"greedy"
] | 2c921093abf2c5963f5f0e96cd430456 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. Next $$$t$$$ cases follow. The first and only line of each test case contains four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$ ($$$1 \le n \le 2 \cdot 10^5$$$; $$$1 \le B, x, y \le 10^9$$$). It's guaranteed that the total sum of $$$n$$$ doesn't exceed $$$2 \cdot 10^5$$$. | 800 | For each test case, print one integer — the maximum possible $$$\sum\limits_{i=0}^{n}{a_i}$$$. | standard output | |
PASSED | 12707e7735fc9101bef1deba29baf541 | train_110.jsonl | 1647960300 | You are given four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$. You should build a sequence $$$a_0, a_1, a_2, \dots, a_n$$$ where $$$a_0 = 0$$$ and for each $$$i \ge 1$$$ you can choose: either $$$a_i = a_{i - 1} + x$$$ or $$$a_i = a_{i - 1} - y$$$. Your goal is to build such a sequence $$$a$$$ that $$$a_i \le B$$$ for all $$$i$$$ and $$$\sum\limits_{i=0}^{n}{a_i}$$$ is maximum possible. | 256 megabytes | import java .util.Scanner;
public class Experts {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
int t=input.nextInt();
while(t!=0){
long sum=0;
long num=0;
long n=input.nextInt();
long b=input.nextInt();
long x=input.nextInt();
long y=input.nextInt();
for(int i=0;i<n;i++){
if(num+x<=b)
num+=x;
else{
num-=y;
}
sum+=num;
}
System.out.println(sum);
t--;
}
}
} | Java | ["3\n5 100 1 30\n7 1000000000 1000000000 1000000000\n4 1 7 3"] | 2 seconds | ["15\n4000000000\n-10"] | NoteIn the first test case, the optimal sequence $$$a$$$ is $$$[0, 1, 2, 3, 4, 5]$$$.In the second test case, the optimal sequence $$$a$$$ is $$$[0, 10^9, 0, 10^9, 0, 10^9, 0, 10^9]$$$.In the third test case, the optimal sequence $$$a$$$ is $$$[0, -3, -6, 1, -2]$$$. | Java 11 | standard input | [
"greedy"
] | 2c921093abf2c5963f5f0e96cd430456 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. Next $$$t$$$ cases follow. The first and only line of each test case contains four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$ ($$$1 \le n \le 2 \cdot 10^5$$$; $$$1 \le B, x, y \le 10^9$$$). It's guaranteed that the total sum of $$$n$$$ doesn't exceed $$$2 \cdot 10^5$$$. | 800 | For each test case, print one integer — the maximum possible $$$\sum\limits_{i=0}^{n}{a_i}$$$. | standard output | |
PASSED | 5d8e987dc3243bc9441785e45933dff4 | train_110.jsonl | 1647960300 | You are given four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$. You should build a sequence $$$a_0, a_1, a_2, \dots, a_n$$$ where $$$a_0 = 0$$$ and for each $$$i \ge 1$$$ you can choose: either $$$a_i = a_{i - 1} + x$$$ or $$$a_i = a_{i - 1} - y$$$. Your goal is to build such a sequence $$$a$$$ that $$$a_i \le B$$$ for all $$$i$$$ and $$$\sum\limits_{i=0}^{n}{a_i}$$$ is maximum possible. | 256 megabytes | import java.util.Scanner;
public class XYSequence {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int t = scanner.nextInt();
for (int i = 0; i < t; i++) {
long n = scanner.nextLong(), b = scanner.nextLong(), x = scanner.nextLong(), y = scanner.nextLong();
long sum = 0;
long max = 0;
for (int j = 0; j < n; j++) {
long min = Long.min(max + x, max - y);
max = Long.max(max + x, max - y);
sum += max <= b ? max : min;
max = max <= b ? max : min;
}
System.out.println(sum);
}
}
} | Java | ["3\n5 100 1 30\n7 1000000000 1000000000 1000000000\n4 1 7 3"] | 2 seconds | ["15\n4000000000\n-10"] | NoteIn the first test case, the optimal sequence $$$a$$$ is $$$[0, 1, 2, 3, 4, 5]$$$.In the second test case, the optimal sequence $$$a$$$ is $$$[0, 10^9, 0, 10^9, 0, 10^9, 0, 10^9]$$$.In the third test case, the optimal sequence $$$a$$$ is $$$[0, -3, -6, 1, -2]$$$. | Java 11 | standard input | [
"greedy"
] | 2c921093abf2c5963f5f0e96cd430456 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. Next $$$t$$$ cases follow. The first and only line of each test case contains four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$ ($$$1 \le n \le 2 \cdot 10^5$$$; $$$1 \le B, x, y \le 10^9$$$). It's guaranteed that the total sum of $$$n$$$ doesn't exceed $$$2 \cdot 10^5$$$. | 800 | For each test case, print one integer — the maximum possible $$$\sum\limits_{i=0}^{n}{a_i}$$$. | standard output | |
PASSED | caba5b82bedab0a3da303f23c27bf8f9 | train_110.jsonl | 1647960300 | You are given four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$. You should build a sequence $$$a_0, a_1, a_2, \dots, a_n$$$ where $$$a_0 = 0$$$ and for each $$$i \ge 1$$$ you can choose: either $$$a_i = a_{i - 1} + x$$$ or $$$a_i = a_{i - 1} - y$$$. Your goal is to build such a sequence $$$a$$$ that $$$a_i \le B$$$ for all $$$i$$$ and $$$\sum\limits_{i=0}^{n}{a_i}$$$ is maximum possible. | 256 megabytes | import java.util.Scanner;
public class XYSequence {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
int t=scanner.nextInt();
for (int i = 0; i < t; i++) {
int n=scanner.nextInt();
int b=scanner.nextInt();
int x=scanner.nextInt();
int y=scanner.nextInt();
long sum=0;int s=0;
for (int i1 = 0; i1 < n; i1++) {
if (s+x<=b) {s+=x;sum+=s;}
else {s-=y;sum+=s;}
}
System.out.println(sum);
}
}
}
| Java | ["3\n5 100 1 30\n7 1000000000 1000000000 1000000000\n4 1 7 3"] | 2 seconds | ["15\n4000000000\n-10"] | NoteIn the first test case, the optimal sequence $$$a$$$ is $$$[0, 1, 2, 3, 4, 5]$$$.In the second test case, the optimal sequence $$$a$$$ is $$$[0, 10^9, 0, 10^9, 0, 10^9, 0, 10^9]$$$.In the third test case, the optimal sequence $$$a$$$ is $$$[0, -3, -6, 1, -2]$$$. | Java 11 | standard input | [
"greedy"
] | 2c921093abf2c5963f5f0e96cd430456 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. Next $$$t$$$ cases follow. The first and only line of each test case contains four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$ ($$$1 \le n \le 2 \cdot 10^5$$$; $$$1 \le B, x, y \le 10^9$$$). It's guaranteed that the total sum of $$$n$$$ doesn't exceed $$$2 \cdot 10^5$$$. | 800 | For each test case, print one integer — the maximum possible $$$\sum\limits_{i=0}^{n}{a_i}$$$. | standard output | |
PASSED | e5ef1fae925fda46e497a162a51727c4 | train_110.jsonl | 1647960300 | You are given four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$. You should build a sequence $$$a_0, a_1, a_2, \dots, a_n$$$ where $$$a_0 = 0$$$ and for each $$$i \ge 1$$$ you can choose: either $$$a_i = a_{i - 1} + x$$$ or $$$a_i = a_{i - 1} - y$$$. Your goal is to build such a sequence $$$a$$$ that $$$a_i \le B$$$ for all $$$i$$$ and $$$\sum\limits_{i=0}^{n}{a_i}$$$ is maximum possible. | 256 megabytes | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
while (t > 0) {
int n = sc.nextInt();
int B = sc.nextInt();
int x = sc.nextInt();
int y = sc.nextInt();
long ans = 0, curr = 0;
for (int i = 1; i <= n; ++i) {
if (curr + x <= B) {
curr = curr + x;
} else {
curr = curr - y;
}
ans += curr;
}
System.out.println(ans);
t--;
}
sc.close();
}
} | Java | ["3\n5 100 1 30\n7 1000000000 1000000000 1000000000\n4 1 7 3"] | 2 seconds | ["15\n4000000000\n-10"] | NoteIn the first test case, the optimal sequence $$$a$$$ is $$$[0, 1, 2, 3, 4, 5]$$$.In the second test case, the optimal sequence $$$a$$$ is $$$[0, 10^9, 0, 10^9, 0, 10^9, 0, 10^9]$$$.In the third test case, the optimal sequence $$$a$$$ is $$$[0, -3, -6, 1, -2]$$$. | Java 11 | standard input | [
"greedy"
] | 2c921093abf2c5963f5f0e96cd430456 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. Next $$$t$$$ cases follow. The first and only line of each test case contains four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$ ($$$1 \le n \le 2 \cdot 10^5$$$; $$$1 \le B, x, y \le 10^9$$$). It's guaranteed that the total sum of $$$n$$$ doesn't exceed $$$2 \cdot 10^5$$$. | 800 | For each test case, print one integer — the maximum possible $$$\sum\limits_{i=0}^{n}{a_i}$$$. | standard output | |
PASSED | 95ccc25c315e084267a66d43d12d323e | train_110.jsonl | 1647960300 | You are given four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$. You should build a sequence $$$a_0, a_1, a_2, \dots, a_n$$$ where $$$a_0 = 0$$$ and for each $$$i \ge 1$$$ you can choose: either $$$a_i = a_{i - 1} + x$$$ or $$$a_i = a_{i - 1} - y$$$. Your goal is to build such a sequence $$$a$$$ that $$$a_i \le B$$$ for all $$$i$$$ and $$$\sum\limits_{i=0}^{n}{a_i}$$$ is maximum possible. | 256 megabytes | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
while (t > 0) {
int n = sc.nextInt();
int B = sc.nextInt();
int x = sc.nextInt();
int y = sc.nextInt();
long ans = 0, ansX, ansY;
long arr[] = new long[n + 1];
arr[0] = 0;
for (int i = 1; i <= n; ++i) {
ansX = arr[i - 1] + x;
if (ansX <= B) {
arr[i] = ansX;
ans += arr[i];
} else {
ansY = arr[i - 1] - y;
arr[i] = ansY;
ans += arr[i];
}
}
System.out.println(ans);
t--;
}
sc.close();
}
} | Java | ["3\n5 100 1 30\n7 1000000000 1000000000 1000000000\n4 1 7 3"] | 2 seconds | ["15\n4000000000\n-10"] | NoteIn the first test case, the optimal sequence $$$a$$$ is $$$[0, 1, 2, 3, 4, 5]$$$.In the second test case, the optimal sequence $$$a$$$ is $$$[0, 10^9, 0, 10^9, 0, 10^9, 0, 10^9]$$$.In the third test case, the optimal sequence $$$a$$$ is $$$[0, -3, -6, 1, -2]$$$. | Java 11 | standard input | [
"greedy"
] | 2c921093abf2c5963f5f0e96cd430456 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. Next $$$t$$$ cases follow. The first and only line of each test case contains four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$ ($$$1 \le n \le 2 \cdot 10^5$$$; $$$1 \le B, x, y \le 10^9$$$). It's guaranteed that the total sum of $$$n$$$ doesn't exceed $$$2 \cdot 10^5$$$. | 800 | For each test case, print one integer — the maximum possible $$$\sum\limits_{i=0}^{n}{a_i}$$$. | standard output | |
PASSED | 8684780ea077988e0228998e76663119 | train_110.jsonl | 1647960300 | You are given four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$. You should build a sequence $$$a_0, a_1, a_2, \dots, a_n$$$ where $$$a_0 = 0$$$ and for each $$$i \ge 1$$$ you can choose: either $$$a_i = a_{i - 1} + x$$$ or $$$a_i = a_{i - 1} - y$$$. Your goal is to build such a sequence $$$a$$$ that $$$a_i \le B$$$ for all $$$i$$$ and $$$\sum\limits_{i=0}^{n}{a_i}$$$ is maximum possible. | 256 megabytes | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
while (t > 0) {
int n = sc.nextInt();
int B = sc.nextInt();
int x = sc.nextInt();
int y = sc.nextInt();
long ansX, ansY;
long arr[] = new long[n + 1];
arr[0] = 0;
for (int i = 1; i <= n; ++i) {
ansX = arr[i - 1] + x;
if (ansX <= B) {
arr[i] = ansX;
} else {
ansY = arr[i - 1] - y;
arr[i] = ansY;
}
}
long ans = 0;
for (int i = 0; i <= n; i++) {
ans += arr[i];
}
System.out.println(ans);
t--;
}
sc.close();
}
} | Java | ["3\n5 100 1 30\n7 1000000000 1000000000 1000000000\n4 1 7 3"] | 2 seconds | ["15\n4000000000\n-10"] | NoteIn the first test case, the optimal sequence $$$a$$$ is $$$[0, 1, 2, 3, 4, 5]$$$.In the second test case, the optimal sequence $$$a$$$ is $$$[0, 10^9, 0, 10^9, 0, 10^9, 0, 10^9]$$$.In the third test case, the optimal sequence $$$a$$$ is $$$[0, -3, -6, 1, -2]$$$. | Java 11 | standard input | [
"greedy"
] | 2c921093abf2c5963f5f0e96cd430456 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. Next $$$t$$$ cases follow. The first and only line of each test case contains four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$ ($$$1 \le n \le 2 \cdot 10^5$$$; $$$1 \le B, x, y \le 10^9$$$). It's guaranteed that the total sum of $$$n$$$ doesn't exceed $$$2 \cdot 10^5$$$. | 800 | For each test case, print one integer — the maximum possible $$$\sum\limits_{i=0}^{n}{a_i}$$$. | standard output | |
PASSED | 665d63683928c113b43779a876d2e83e | train_110.jsonl | 1647960300 | You are given four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$. You should build a sequence $$$a_0, a_1, a_2, \dots, a_n$$$ where $$$a_0 = 0$$$ and for each $$$i \ge 1$$$ you can choose: either $$$a_i = a_{i - 1} + x$$$ or $$$a_i = a_{i - 1} - y$$$. Your goal is to build such a sequence $$$a$$$ that $$$a_i \le B$$$ for all $$$i$$$ and $$$\sum\limits_{i=0}^{n}{a_i}$$$ is maximum possible. | 256 megabytes | /******************************************************************************
Welcome to GDB Online.
GDB online is an online compiler and debugger tool for C, C++, Python, Java, PHP, Ruby, Perl,
C#, VB, Swift, Pascal, Fortran, Haskell, Objective-C, Assembly, HTML, CSS, JS, SQLite, Prolog.
Code, Compile, Run and Debug online from anywhere in world.
*******************************************************************************/
import java.util.*;
public class Main
{
private static boolean elcheckx(int prev,int x, int B)
{
int next;
next=prev+x;
if(next<=B)
{
return true;
}
return false;
}
private static boolean elchecky(int prev,int y, int B)
{
int nexty;
nexty=prev-y;
if(nexty<=B)
{
return true;
}
return false;
}
public static void main(String[] args) {
int n,B,x,y,t;
Scanner in=new Scanner(System.in);
t=in.nextInt();
for(int j=0;j<t;j++)
{
n=in.nextInt()+1;
B=in.nextInt();
x=in.nextInt();
y=in.nextInt();
int seq[]= new int[n];
seq[0]=0;
//code starts anywhere
for(int i=1;i<n;i++)
{
int nx;
nx=seq[i-1]+x;
int ny;
ny=seq[i-1]-y;
if(elcheckx(seq[i-1],x,B) && elchecky(seq[i-1],y,B))
{
if(nx>ny)
seq[i]=nx;
else
seq[i]=ny;
}
else if(elcheckx(seq[i-1],x,B))
{
seq[i]=nx;
}
else if(elchecky(seq[i-1],y,B))
{
seq[i]=ny;
}
}
long sum=0;
for(int i=0;i<n;i++){
sum+=seq[i];
}
System.out.println(sum);
}
}
}
| Java | ["3\n5 100 1 30\n7 1000000000 1000000000 1000000000\n4 1 7 3"] | 2 seconds | ["15\n4000000000\n-10"] | NoteIn the first test case, the optimal sequence $$$a$$$ is $$$[0, 1, 2, 3, 4, 5]$$$.In the second test case, the optimal sequence $$$a$$$ is $$$[0, 10^9, 0, 10^9, 0, 10^9, 0, 10^9]$$$.In the third test case, the optimal sequence $$$a$$$ is $$$[0, -3, -6, 1, -2]$$$. | Java 11 | standard input | [
"greedy"
] | 2c921093abf2c5963f5f0e96cd430456 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. Next $$$t$$$ cases follow. The first and only line of each test case contains four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$ ($$$1 \le n \le 2 \cdot 10^5$$$; $$$1 \le B, x, y \le 10^9$$$). It's guaranteed that the total sum of $$$n$$$ doesn't exceed $$$2 \cdot 10^5$$$. | 800 | For each test case, print one integer — the maximum possible $$$\sum\limits_{i=0}^{n}{a_i}$$$. | standard output | |
PASSED | e33f2bf6723c78b46ee3c7786209cbf2 | train_110.jsonl | 1647960300 | You are given four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$. You should build a sequence $$$a_0, a_1, a_2, \dots, a_n$$$ where $$$a_0 = 0$$$ and for each $$$i \ge 1$$$ you can choose: either $$$a_i = a_{i - 1} + x$$$ or $$$a_i = a_{i - 1} - y$$$. Your goal is to build such a sequence $$$a$$$ that $$$a_i \le B$$$ for all $$$i$$$ and $$$\sum\limits_{i=0}^{n}{a_i}$$$ is maximum possible. | 256 megabytes | import java.util.*;
import java.io.*;
import java.lang.*;
public class Main
{
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int number_of_inputs = scan.nextInt();
List<Long> final_list = new ArrayList<Long>();
for (int i=0;i<number_of_inputs;i++) {
int n = scan.nextInt();
int B = scan.nextInt();
int x = scan.nextInt();
int y = scan.nextInt();
int sum = 0;
List<Integer> new_list = new ArrayList<>();
for (int j=0;j<n;j++) {
int summation = sum+x;
int difference = sum-y;
if ((B-summation < B-difference) && (summation <= B)) {
sum = summation;
new_list.add(sum);
}
else {
sum = difference;
new_list.add(sum);
}
}
long final_sum = 0;
for (int item:new_list) final_sum += item;
final_list.add(final_sum);
}
for (long item:final_list)System.out.println(item);
}
}
| Java | ["3\n5 100 1 30\n7 1000000000 1000000000 1000000000\n4 1 7 3"] | 2 seconds | ["15\n4000000000\n-10"] | NoteIn the first test case, the optimal sequence $$$a$$$ is $$$[0, 1, 2, 3, 4, 5]$$$.In the second test case, the optimal sequence $$$a$$$ is $$$[0, 10^9, 0, 10^9, 0, 10^9, 0, 10^9]$$$.In the third test case, the optimal sequence $$$a$$$ is $$$[0, -3, -6, 1, -2]$$$. | Java 11 | standard input | [
"greedy"
] | 2c921093abf2c5963f5f0e96cd430456 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. Next $$$t$$$ cases follow. The first and only line of each test case contains four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$ ($$$1 \le n \le 2 \cdot 10^5$$$; $$$1 \le B, x, y \le 10^9$$$). It's guaranteed that the total sum of $$$n$$$ doesn't exceed $$$2 \cdot 10^5$$$. | 800 | For each test case, print one integer — the maximum possible $$$\sum\limits_{i=0}^{n}{a_i}$$$. | standard output | |
PASSED | 29cfb542cc8ce1547aa966ecde87b4a9 | train_110.jsonl | 1647960300 | You are given four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$. You should build a sequence $$$a_0, a_1, a_2, \dots, a_n$$$ where $$$a_0 = 0$$$ and for each $$$i \ge 1$$$ you can choose: either $$$a_i = a_{i - 1} + x$$$ or $$$a_i = a_{i - 1} - y$$$. Your goal is to build such a sequence $$$a$$$ that $$$a_i \le B$$$ for all $$$i$$$ and $$$\sum\limits_{i=0}^{n}{a_i}$$$ is maximum possible. | 256 megabytes |
import java.util.*;
import java.math.*;
import java.io.*;
public class Solution {
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
public static void inmatrix(int [][]a, int n, int m)
{
for (int i = 0; i < n; i++) {
String s = sc.next();
for (int j = 0; j < m; j++) {
a[i][j] = s.charAt(j) - '0';
}
}
}
public static void main(String[] args) throws IOException {
sc = new FastReader();
out = new PrintWriter(System.out);
// primes();
// ________________________________
StringBuilder output = new StringBuilder();
int test = sc.nextInt();
// int test = 1;
int t = test;
while (test-- > 0) {
int n = sc.nextInt();
long B = sc.nextLong();
long x = sc.nextLong();
long y = sc.nextLong();
solver(n,B,x,y);
}
out.flush();
}
public static void solver( int n, long B,long x, long y) {
long ans [] = new long[n+1];
for(int i =1;i<=n;i++)
{
long pos = ans[i-1]+x;
if(pos<=B)
{
ans[i] = pos;
}
else
ans[i] =ans[i-1]-y;
}
long sum =0;
for(long i :ans)
sum+=i;
System.out.println(sum);
}
static void sort(int a[]) { // int -> long
ArrayList<Integer> arr = new ArrayList<>(); // Integer -> Long
for (int i = 0; i < a.length; i++)
arr.add(a[i]);
Collections.sort(arr);
for (int i = 0; i < a.length; i++)
a[i] = arr.get(i);
}
static class Pair implements Comparable<Pair> {
long val;
int idx;
Pair(long val, int idx) {
this.val = val;
this.idx = idx;
}
public int compareTo(Pair o) {
if(o.val >this.val)
return 1;
else if(o.val==this.val)
return 0;
else
return -1;
}
}
public static void leftRotate(int a[], int n, int k) {
k = k % n;
reverseArray(a, 0, k - 1);
reverseArray(a, k, n - 1);
reverseArray(a, 0, n - 1);
}
private static long gcd(long a, long b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
private static void inarr(long a[]) {
for (int i = 0; i < a.length; i++) {
a[i] = sc.nextLong();
}
}
private static long pow(long x, long y) {
if (y == 0)
return 1;
long temp = pow(x, y / 2);
if (y % 2 == 1) {
return x * temp * temp;
} else {
return temp * temp;
}
}
static long powM(long a, long b) {
if (b == 0)
return 1;
long res = pow(a, b / 2);
res = (res % mod * res % mod) % 1_000_000_007;
if (b % 2 == 1) {
res = (res % mod * a % mod) % 1_000_000_007;
}
return res % mod;
}
static int log(long n) {
int res = 0;
while (n > 0) {
res++;
n /= 2;
}
return res;
}
static int mod = (int) 1e9 + 7;
static PrintWriter out;
static FastReader sc;
static class Edge {
int u, v;
Edge(int u, int v) {
this.u = u;
this.v = v;
}
}
// static class Pair implements Comparable <Pair>{
// int l, r;
//
// Pair(int l, int r)
// {
// this.l = l;
// this.r = r;
//
// }
// public int compareTo(Pair o)
// {
//
// return this.l-o.l;
// }
// }
static long[] dp;
public static int setbitcnt(long n) {
int nb = 0;
while (n != 0) {
long rmsb = n & (-n);
n = n - rmsb;
nb++;
}
return nb;
}
public static long log2(long N) {
// calculate log2 N indirectly
// using log() method
long result = (long) (Math.log(N) / Math.log(2));
return result;
}
static long highestPowerof2(long x) {
// check for the set bits
x |= x >> 1;
x |= x >> 2;
x |= x >> 4;
x |= x >> 8;
x |= x >> 16;
// Then we remove all but the top bit by xor'ing the
// string of 1's with that string of 1's shifted one to
// the left, and we end up with just the one top bit
// followed by 0's.
return x ^ (x >> 1);
}
public static void rotate(int[] arr, int s, int n) {
int x = arr[n], i;
for (i = n; i > s; i--)
arr[i] = arr[i - 1];
arr[s] = x;
// for(int j=s;j<=n;j++)
// System.out.print(arr[j]+" ");
// System.out.println();
}
static int lower_bound(int[] a, long x) {
int i = 0;
int j = a.length - 1;
// if(arr[i] > key)return -1;
if (a[j] < x)
return a.length;
while (i < j) {
int mid = (i + j) / 2;
if (a[mid] == x) {
j = mid;
}
else if (a[mid] < x) {
i = mid + 1;
} else
j = mid - 1;
}
return i;
}
int upper_bound(int[] arr, int key) {
int i = 0;
int j = arr.length - 1;
if (arr[j] <= key)
return j + 1;
while (i < j) {
int mid = (i + j) / 2;
if (arr[mid] <= key) {
i = mid + 1;
} else
j = mid;
}
return i;
}
static void reverseArray(int arr[], int start, int end) {
while (start < end) {
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
start++;
end--;
}
}
} | Java | ["3\n5 100 1 30\n7 1000000000 1000000000 1000000000\n4 1 7 3"] | 2 seconds | ["15\n4000000000\n-10"] | NoteIn the first test case, the optimal sequence $$$a$$$ is $$$[0, 1, 2, 3, 4, 5]$$$.In the second test case, the optimal sequence $$$a$$$ is $$$[0, 10^9, 0, 10^9, 0, 10^9, 0, 10^9]$$$.In the third test case, the optimal sequence $$$a$$$ is $$$[0, -3, -6, 1, -2]$$$. | Java 11 | standard input | [
"greedy"
] | 2c921093abf2c5963f5f0e96cd430456 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. Next $$$t$$$ cases follow. The first and only line of each test case contains four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$ ($$$1 \le n \le 2 \cdot 10^5$$$; $$$1 \le B, x, y \le 10^9$$$). It's guaranteed that the total sum of $$$n$$$ doesn't exceed $$$2 \cdot 10^5$$$. | 800 | For each test case, print one integer — the maximum possible $$$\sum\limits_{i=0}^{n}{a_i}$$$. | standard output | |
PASSED | e452cc53198c8bfe0b596cd7a4e8454b | train_110.jsonl | 1647960300 | You are given four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$. You should build a sequence $$$a_0, a_1, a_2, \dots, a_n$$$ where $$$a_0 = 0$$$ and for each $$$i \ge 1$$$ you can choose: either $$$a_i = a_{i - 1} + x$$$ or $$$a_i = a_{i - 1} - y$$$. Your goal is to build such a sequence $$$a$$$ that $$$a_i \le B$$$ for all $$$i$$$ and $$$\sum\limits_{i=0}^{n}{a_i}$$$ is maximum possible. | 256 megabytes |
import java.util.Scanner;
//https://codeforces.com/contest/1657/problem/B
public class XYSeq {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
long testcases = input.nextLong();
long n = 0;
long B = 0;
long x = 0;
long y = 0;
for (long i = 0; i < testcases; i++) {
n = input.nextLong();
B = input.nextLong();
x = input.nextLong();
y = input.nextLong();
long ans = helper(n, B, x, y, 0);
System.out.println(ans);
}
}
public static long helper(long n, long B, long x, long y, long a) {
if (n == 0) {
return a;
}
if (a + x <= B) {
return helper(n - 1, B, x, y, a + x) + a;
}
return helper(n - 1, B, x, y, a - y) + a;
}
} | Java | ["3\n5 100 1 30\n7 1000000000 1000000000 1000000000\n4 1 7 3"] | 2 seconds | ["15\n4000000000\n-10"] | NoteIn the first test case, the optimal sequence $$$a$$$ is $$$[0, 1, 2, 3, 4, 5]$$$.In the second test case, the optimal sequence $$$a$$$ is $$$[0, 10^9, 0, 10^9, 0, 10^9, 0, 10^9]$$$.In the third test case, the optimal sequence $$$a$$$ is $$$[0, -3, -6, 1, -2]$$$. | Java 11 | standard input | [
"greedy"
] | 2c921093abf2c5963f5f0e96cd430456 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. Next $$$t$$$ cases follow. The first and only line of each test case contains four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$ ($$$1 \le n \le 2 \cdot 10^5$$$; $$$1 \le B, x, y \le 10^9$$$). It's guaranteed that the total sum of $$$n$$$ doesn't exceed $$$2 \cdot 10^5$$$. | 800 | For each test case, print one integer — the maximum possible $$$\sum\limits_{i=0}^{n}{a_i}$$$. | standard output | |
PASSED | 4cd083c9786f6e7188e5e25294e1dd6c | train_110.jsonl | 1647960300 | You are given four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$. You should build a sequence $$$a_0, a_1, a_2, \dots, a_n$$$ where $$$a_0 = 0$$$ and for each $$$i \ge 1$$$ you can choose: either $$$a_i = a_{i - 1} + x$$$ or $$$a_i = a_{i - 1} - y$$$. Your goal is to build such a sequence $$$a$$$ that $$$a_i \le B$$$ for all $$$i$$$ and $$$\sum\limits_{i=0}^{n}{a_i}$$$ is maximum possible. | 256 megabytes | import java.io.*;
import java.util.*;
public class JavaApplication {
static BufferedReader in;
static StringTokenizer st;
String getLine() throws IOException {
return in.readLine();
}
String getToken() throws IOException {
if (st == null || !st.hasMoreTokens())
st = new StringTokenizer(getLine());
return st.nextToken();
}
int getInt() throws IOException {
return Integer.parseInt(getToken());
}
long getLong() throws IOException {
return Long.parseLong(getToken());
}
public void Solve() throws IOException {
int t = getInt();
while (t-- > 0) {
int n = getInt();
int B = getInt();
int x = getInt();
int y = getInt();
List<Long> a = new ArrayList<Long>();
a.add(0l);
int i = 1;
long sum = 0;
while (i <= n) {
int pos = a.size() - 1;
long temp = a.get(pos) + x;
while (i <= n && temp <= B) {
a.add(temp);
i++;
pos = a.size() - 1;
temp = a.get(pos) + x;
}
pos = a.size() - 1;
temp = a.get(pos) - y;
if (i <= n) {
a.add(temp);
i++;
}
}
for (Long num : a) {
sum += num;
}
System.out.println(sum);
}
}
public static void main(String[] args) throws java.lang.Exception {
in = new BufferedReader(new InputStreamReader(System.in));
new JavaApplication().Solve();
return;
}
} | Java | ["3\n5 100 1 30\n7 1000000000 1000000000 1000000000\n4 1 7 3"] | 2 seconds | ["15\n4000000000\n-10"] | NoteIn the first test case, the optimal sequence $$$a$$$ is $$$[0, 1, 2, 3, 4, 5]$$$.In the second test case, the optimal sequence $$$a$$$ is $$$[0, 10^9, 0, 10^9, 0, 10^9, 0, 10^9]$$$.In the third test case, the optimal sequence $$$a$$$ is $$$[0, -3, -6, 1, -2]$$$. | Java 11 | standard input | [
"greedy"
] | 2c921093abf2c5963f5f0e96cd430456 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. Next $$$t$$$ cases follow. The first and only line of each test case contains four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$ ($$$1 \le n \le 2 \cdot 10^5$$$; $$$1 \le B, x, y \le 10^9$$$). It's guaranteed that the total sum of $$$n$$$ doesn't exceed $$$2 \cdot 10^5$$$. | 800 | For each test case, print one integer — the maximum possible $$$\sum\limits_{i=0}^{n}{a_i}$$$. | standard output | |
PASSED | 4597fe3b6bad9952129693f05fa50d8d | train_110.jsonl | 1647960300 | You are given four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$. You should build a sequence $$$a_0, a_1, a_2, \dots, a_n$$$ where $$$a_0 = 0$$$ and for each $$$i \ge 1$$$ you can choose: either $$$a_i = a_{i - 1} + x$$$ or $$$a_i = a_{i - 1} - y$$$. Your goal is to build such a sequence $$$a$$$ that $$$a_i \le B$$$ for all $$$i$$$ and $$$\sum\limits_{i=0}^{n}{a_i}$$$ is maximum possible. | 256 megabytes | import java.util.Scanner;
public class solut {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
while (t-->0){
int n = sc.nextInt();
int b = sc.nextInt();
int x = sc.nextInt();
int y = sc.nextInt();
int[] arr = new int[n+1];
arr[0] = 0;
int ans = 0;
long sum = 0;
for(int i = 1; i<n+1; i++){
if((ans+x)<=b){
arr[i] = ans+x;
ans+=x;
}
else{
arr[i] = ans-y;
ans-=y;
}
}
for(int j = 0; j<n+1; j++){
sum+=arr[j];
}
//System.out.println(Arrays.toString(arr));
System.out.println(sum);
}
}
}
| Java | ["3\n5 100 1 30\n7 1000000000 1000000000 1000000000\n4 1 7 3"] | 2 seconds | ["15\n4000000000\n-10"] | NoteIn the first test case, the optimal sequence $$$a$$$ is $$$[0, 1, 2, 3, 4, 5]$$$.In the second test case, the optimal sequence $$$a$$$ is $$$[0, 10^9, 0, 10^9, 0, 10^9, 0, 10^9]$$$.In the third test case, the optimal sequence $$$a$$$ is $$$[0, -3, -6, 1, -2]$$$. | Java 11 | standard input | [
"greedy"
] | 2c921093abf2c5963f5f0e96cd430456 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. Next $$$t$$$ cases follow. The first and only line of each test case contains four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$ ($$$1 \le n \le 2 \cdot 10^5$$$; $$$1 \le B, x, y \le 10^9$$$). It's guaranteed that the total sum of $$$n$$$ doesn't exceed $$$2 \cdot 10^5$$$. | 800 | For each test case, print one integer — the maximum possible $$$\sum\limits_{i=0}^{n}{a_i}$$$. | standard output | |
PASSED | 6301602a1cc59be3e0a9849005788662 | train_110.jsonl | 1647960300 | You are given four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$. You should build a sequence $$$a_0, a_1, a_2, \dots, a_n$$$ where $$$a_0 = 0$$$ and for each $$$i \ge 1$$$ you can choose: either $$$a_i = a_{i - 1} + x$$$ or $$$a_i = a_{i - 1} - y$$$. Your goal is to build such a sequence $$$a$$$ that $$$a_i \le B$$$ for all $$$i$$$ and $$$\sum\limits_{i=0}^{n}{a_i}$$$ is maximum possible. | 256 megabytes |
import java.util.*;
public class Main {
// Driver Code
public static void main(String args[])
{
Scanner sc= new Scanner(System.in);
int j=sc.nextInt();
long n,b,x,y;
long a=0,d;
long sum=0;
for (int i=0; i<j;i++) {
n = sc.nextLong();
b = sc.nextLong();
x = sc.nextLong();
y = sc.nextLong();
//System.out.println(n +" "+" "+b+ " "+x+" "+y);
for (int k = 0; k < n; k++) {
if ((a + x) <= b) {
a = a + x;
} else {
a = a - y;
}
//System.out.println(a);
sum = sum + a;
}
System.out.println(sum);
sum=0;
a=0;
}
}
} | Java | ["3\n5 100 1 30\n7 1000000000 1000000000 1000000000\n4 1 7 3"] | 2 seconds | ["15\n4000000000\n-10"] | NoteIn the first test case, the optimal sequence $$$a$$$ is $$$[0, 1, 2, 3, 4, 5]$$$.In the second test case, the optimal sequence $$$a$$$ is $$$[0, 10^9, 0, 10^9, 0, 10^9, 0, 10^9]$$$.In the third test case, the optimal sequence $$$a$$$ is $$$[0, -3, -6, 1, -2]$$$. | Java 11 | standard input | [
"greedy"
] | 2c921093abf2c5963f5f0e96cd430456 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. Next $$$t$$$ cases follow. The first and only line of each test case contains four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$ ($$$1 \le n \le 2 \cdot 10^5$$$; $$$1 \le B, x, y \le 10^9$$$). It's guaranteed that the total sum of $$$n$$$ doesn't exceed $$$2 \cdot 10^5$$$. | 800 | For each test case, print one integer — the maximum possible $$$\sum\limits_{i=0}^{n}{a_i}$$$. | standard output | |
PASSED | 8f3293784053203f19414da07a2d34b2 | train_110.jsonl | 1647960300 | You are given four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$. You should build a sequence $$$a_0, a_1, a_2, \dots, a_n$$$ where $$$a_0 = 0$$$ and for each $$$i \ge 1$$$ you can choose: either $$$a_i = a_{i - 1} + x$$$ or $$$a_i = a_{i - 1} - y$$$. Your goal is to build such a sequence $$$a$$$ that $$$a_i \le B$$$ for all $$$i$$$ and $$$\sum\limits_{i=0}^{n}{a_i}$$$ is maximum possible. | 256 megabytes | import java.util.*;
public class B{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int T =sc.nextInt();
while(T-->0){
int n = sc.nextInt();
int B = sc.nextInt();
int x = sc.nextInt();
int y = sc.nextInt();
int a[] = new int[n+1];
long sum = 0;
a[0]=0;
for(int i=1;i<=n;i++){
if(a[i-1]+x<=B)
a[i]=a[i-1]+x;
else
a[i]=a[i-1]-y;
}
for(int i=0;i<=n;i++)
sum+=a[i];
System.out.println(sum);
}
}
} | Java | ["3\n5 100 1 30\n7 1000000000 1000000000 1000000000\n4 1 7 3"] | 2 seconds | ["15\n4000000000\n-10"] | NoteIn the first test case, the optimal sequence $$$a$$$ is $$$[0, 1, 2, 3, 4, 5]$$$.In the second test case, the optimal sequence $$$a$$$ is $$$[0, 10^9, 0, 10^9, 0, 10^9, 0, 10^9]$$$.In the third test case, the optimal sequence $$$a$$$ is $$$[0, -3, -6, 1, -2]$$$. | Java 11 | standard input | [
"greedy"
] | 2c921093abf2c5963f5f0e96cd430456 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. Next $$$t$$$ cases follow. The first and only line of each test case contains four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$ ($$$1 \le n \le 2 \cdot 10^5$$$; $$$1 \le B, x, y \le 10^9$$$). It's guaranteed that the total sum of $$$n$$$ doesn't exceed $$$2 \cdot 10^5$$$. | 800 | For each test case, print one integer — the maximum possible $$$\sum\limits_{i=0}^{n}{a_i}$$$. | standard output | |
PASSED | d78136ab97bb5c125a1fdd82f24b3f68 | train_110.jsonl | 1647960300 | You are given four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$. You should build a sequence $$$a_0, a_1, a_2, \dots, a_n$$$ where $$$a_0 = 0$$$ and for each $$$i \ge 1$$$ you can choose: either $$$a_i = a_{i - 1} + x$$$ or $$$a_i = a_{i - 1} - y$$$. Your goal is to build such a sequence $$$a$$$ that $$$a_i \le B$$$ for all $$$i$$$ and $$$\sum\limits_{i=0}^{n}{a_i}$$$ is maximum possible. | 256 megabytes |
import java.util.*;
public class Play {
public static void main(String[] args) throws Exception {
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
while (t -- > 0) {
int n = sc.nextInt(); long b = sc.nextLong(), x = sc.nextLong(), y = sc.nextLong();
long ans = 0, prev = 0;
for (int i=1; i<=n; i++) {
long add = prev + x, minus = prev - y;
if (add <= b && minus <= b) {
prev = Math.max(add, minus);
}
else if (add < b) {
prev = add;
}
else {
prev = minus;
}
// System.out.println("add: "+add + " minus " + minus + " prev " + prev);
ans += prev;
}
System.out.println(ans);
}
}
}
| Java | ["3\n5 100 1 30\n7 1000000000 1000000000 1000000000\n4 1 7 3"] | 2 seconds | ["15\n4000000000\n-10"] | NoteIn the first test case, the optimal sequence $$$a$$$ is $$$[0, 1, 2, 3, 4, 5]$$$.In the second test case, the optimal sequence $$$a$$$ is $$$[0, 10^9, 0, 10^9, 0, 10^9, 0, 10^9]$$$.In the third test case, the optimal sequence $$$a$$$ is $$$[0, -3, -6, 1, -2]$$$. | Java 11 | standard input | [
"greedy"
] | 2c921093abf2c5963f5f0e96cd430456 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. Next $$$t$$$ cases follow. The first and only line of each test case contains four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$ ($$$1 \le n \le 2 \cdot 10^5$$$; $$$1 \le B, x, y \le 10^9$$$). It's guaranteed that the total sum of $$$n$$$ doesn't exceed $$$2 \cdot 10^5$$$. | 800 | For each test case, print one integer — the maximum possible $$$\sum\limits_{i=0}^{n}{a_i}$$$. | standard output | |
PASSED | 87e7e48394ade5eed6a442fd049d683a | train_110.jsonl | 1647960300 | You are given four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$. You should build a sequence $$$a_0, a_1, a_2, \dots, a_n$$$ where $$$a_0 = 0$$$ and for each $$$i \ge 1$$$ you can choose: either $$$a_i = a_{i - 1} + x$$$ or $$$a_i = a_{i - 1} - y$$$. Your goal is to build such a sequence $$$a$$$ that $$$a_i \le B$$$ for all $$$i$$$ and $$$\sum\limits_{i=0}^{n}{a_i}$$$ is maximum possible. | 256 megabytes | import java.util.Scanner;
public class Solution {
public static void main(String[] args) {
try (Scanner sc = new Scanner(System.in)) {
int t = sc.nextInt();
while(t > 0) {
int n = sc.nextInt();
long B = sc.nextLong();
long x = sc.nextLong();
long y = sc.nextLong();
long start = 0;
long sum = 0;
int c = 1;
while(c <= n) {
if(start + x <= B) {
sum += start + x;
start = start + x;
}
else {
sum += start - y;
start = start - y;
}
c++;
}
System.out.println(sum);
t = t - 1;
}
}
}
}
| Java | ["3\n5 100 1 30\n7 1000000000 1000000000 1000000000\n4 1 7 3"] | 2 seconds | ["15\n4000000000\n-10"] | NoteIn the first test case, the optimal sequence $$$a$$$ is $$$[0, 1, 2, 3, 4, 5]$$$.In the second test case, the optimal sequence $$$a$$$ is $$$[0, 10^9, 0, 10^9, 0, 10^9, 0, 10^9]$$$.In the third test case, the optimal sequence $$$a$$$ is $$$[0, -3, -6, 1, -2]$$$. | Java 11 | standard input | [
"greedy"
] | 2c921093abf2c5963f5f0e96cd430456 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. Next $$$t$$$ cases follow. The first and only line of each test case contains four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$ ($$$1 \le n \le 2 \cdot 10^5$$$; $$$1 \le B, x, y \le 10^9$$$). It's guaranteed that the total sum of $$$n$$$ doesn't exceed $$$2 \cdot 10^5$$$. | 800 | For each test case, print one integer — the maximum possible $$$\sum\limits_{i=0}^{n}{a_i}$$$. | standard output | |
PASSED | 0ff412c2bfad0dd4115e078777c840f8 | train_110.jsonl | 1647960300 | You are given four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$. You should build a sequence $$$a_0, a_1, a_2, \dots, a_n$$$ where $$$a_0 = 0$$$ and for each $$$i \ge 1$$$ you can choose: either $$$a_i = a_{i - 1} + x$$$ or $$$a_i = a_{i - 1} - y$$$. Your goal is to build such a sequence $$$a$$$ that $$$a_i \le B$$$ for all $$$i$$$ and $$$\sum\limits_{i=0}^{n}{a_i}$$$ is maximum possible. | 256 megabytes | import java.util.Scanner; // Import the Scanner class
import java.util.ArrayList; // import the ArrayList class
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int n = input.nextInt();
long [][] arr = new long[n][4];
for(int i = 0 ; i < n; i ++) {
for(int j = 0; j < arr[0].length; j++) {
long a = input.nextLong();
arr[i][j] = a;
}
}
for(int i = 0 ; i < arr.length; i ++) {
long x = retNum(arr[i]);
System.out.println(x);
}
}
public static long retNum(long[] arr) {
long sum = 0;
long newNum = 0;
long counter = 0;
while(counter < arr[0]) {
long temp;
temp = newNum;
temp += arr[2];
if(temp > arr[1]) {
newNum -= arr[3];
}
else {
newNum += arr[2];
}
sum += newNum;
counter ++;
}
return sum;
}
} | Java | ["3\n5 100 1 30\n7 1000000000 1000000000 1000000000\n4 1 7 3"] | 2 seconds | ["15\n4000000000\n-10"] | NoteIn the first test case, the optimal sequence $$$a$$$ is $$$[0, 1, 2, 3, 4, 5]$$$.In the second test case, the optimal sequence $$$a$$$ is $$$[0, 10^9, 0, 10^9, 0, 10^9, 0, 10^9]$$$.In the third test case, the optimal sequence $$$a$$$ is $$$[0, -3, -6, 1, -2]$$$. | Java 11 | standard input | [
"greedy"
] | 2c921093abf2c5963f5f0e96cd430456 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. Next $$$t$$$ cases follow. The first and only line of each test case contains four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$ ($$$1 \le n \le 2 \cdot 10^5$$$; $$$1 \le B, x, y \le 10^9$$$). It's guaranteed that the total sum of $$$n$$$ doesn't exceed $$$2 \cdot 10^5$$$. | 800 | For each test case, print one integer — the maximum possible $$$\sum\limits_{i=0}^{n}{a_i}$$$. | standard output | |
PASSED | 65351a148cce030a307fc0c5155579db | train_110.jsonl | 1647960300 | You are given four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$. You should build a sequence $$$a_0, a_1, a_2, \dots, a_n$$$ where $$$a_0 = 0$$$ and for each $$$i \ge 1$$$ you can choose: either $$$a_i = a_{i - 1} + x$$$ or $$$a_i = a_{i - 1} - y$$$. Your goal is to build such a sequence $$$a$$$ that $$$a_i \le B$$$ for all $$$i$$$ and $$$\sum\limits_{i=0}^{n}{a_i}$$$ is maximum possible. | 256 megabytes | import java.util.Scanner;
public class Main {
public static void main(String argc[]){
Scanner sc =new Scanner(System.in);
int t=sc.nextInt();
while(t-->0){
long n=sc.nextInt(),B=sc.nextInt(),x=sc.nextInt(),y= sc.nextInt();
long sum=0,cur=0;
for(int i=1;i<=n;i++){
if(cur+x<=B){
cur+=x;
}
else {
cur-=y;
}
sum+=cur;
}
System.out.println(sum);
}
}
}
| Java | ["3\n5 100 1 30\n7 1000000000 1000000000 1000000000\n4 1 7 3"] | 2 seconds | ["15\n4000000000\n-10"] | NoteIn the first test case, the optimal sequence $$$a$$$ is $$$[0, 1, 2, 3, 4, 5]$$$.In the second test case, the optimal sequence $$$a$$$ is $$$[0, 10^9, 0, 10^9, 0, 10^9, 0, 10^9]$$$.In the third test case, the optimal sequence $$$a$$$ is $$$[0, -3, -6, 1, -2]$$$. | Java 11 | standard input | [
"greedy"
] | 2c921093abf2c5963f5f0e96cd430456 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. Next $$$t$$$ cases follow. The first and only line of each test case contains four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$ ($$$1 \le n \le 2 \cdot 10^5$$$; $$$1 \le B, x, y \le 10^9$$$). It's guaranteed that the total sum of $$$n$$$ doesn't exceed $$$2 \cdot 10^5$$$. | 800 | For each test case, print one integer — the maximum possible $$$\sum\limits_{i=0}^{n}{a_i}$$$. | standard output | |
PASSED | ee43ad914ed3e7bd4d516a4f0711102a | train_110.jsonl | 1647960300 | You are given four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$. You should build a sequence $$$a_0, a_1, a_2, \dots, a_n$$$ where $$$a_0 = 0$$$ and for each $$$i \ge 1$$$ you can choose: either $$$a_i = a_{i - 1} + x$$$ or $$$a_i = a_{i - 1} - y$$$. Your goal is to build such a sequence $$$a$$$ that $$$a_i \le B$$$ for all $$$i$$$ and $$$\sum\limits_{i=0}^{n}{a_i}$$$ is maximum possible. | 256 megabytes |
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class CFER1215B {
public static void main(String[] args) throws java.io.IOException{
InputReader in = new InputReader();
int t = in.readInt();
for(; t>0; t--) {
long[] a = in.readLongArray(4);
long n = a[0];
long b = a[1];
long x = a[2];
long y = a[3];
long p = 0;
long sum = 0;
for(int i=0; i<n; i++) {
if(p+x <= b) {
// System.out.print(p + " ");
sum += p+x;
p = p+x;
}
else {
// System.out.print(p + " ");
sum += p-y;
p = p-y;
}
}
// System.out.println(p + " ");
System.out.println(sum);
}
}
public static class InputReader {
static BufferedReader br;
static StringTokenizer st;
InputReader() {
br = new BufferedReader(new InputStreamReader(System.in));
}
public String read() throws IOException {
return br.readLine().trim();
}
public int readInt() throws IOException {
return Integer.parseInt(br.readLine().trim());
}
public long readLong() throws IOException {
return Long.parseLong(br.readLine().trim());
}
public int[] readArray(int len) throws IOException {
int[] a = new int[len];
st = new StringTokenizer(br.readLine().trim());
int pos = 0;
for(;st.hasMoreTokens();) {
a[pos++] = Integer.parseInt(st.nextToken());
}
return a;
}
public long[] readLongArray(int len) throws IOException {
long[] a = new long[len];
st = new StringTokenizer(br.readLine().trim());
int pos = 0;
for(;st.hasMoreTokens();) {
a[pos++] = Long.parseLong(st.nextToken());
}
return a;
}
}
}
| Java | ["3\n5 100 1 30\n7 1000000000 1000000000 1000000000\n4 1 7 3"] | 2 seconds | ["15\n4000000000\n-10"] | NoteIn the first test case, the optimal sequence $$$a$$$ is $$$[0, 1, 2, 3, 4, 5]$$$.In the second test case, the optimal sequence $$$a$$$ is $$$[0, 10^9, 0, 10^9, 0, 10^9, 0, 10^9]$$$.In the third test case, the optimal sequence $$$a$$$ is $$$[0, -3, -6, 1, -2]$$$. | Java 11 | standard input | [
"greedy"
] | 2c921093abf2c5963f5f0e96cd430456 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. Next $$$t$$$ cases follow. The first and only line of each test case contains four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$ ($$$1 \le n \le 2 \cdot 10^5$$$; $$$1 \le B, x, y \le 10^9$$$). It's guaranteed that the total sum of $$$n$$$ doesn't exceed $$$2 \cdot 10^5$$$. | 800 | For each test case, print one integer — the maximum possible $$$\sum\limits_{i=0}^{n}{a_i}$$$. | standard output | |
PASSED | aa6f8f8ce8a221f857036b27c656e1d7 | train_110.jsonl | 1647960300 | You are given four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$. You should build a sequence $$$a_0, a_1, a_2, \dots, a_n$$$ where $$$a_0 = 0$$$ and for each $$$i \ge 1$$$ you can choose: either $$$a_i = a_{i - 1} + x$$$ or $$$a_i = a_{i - 1} - y$$$. Your goal is to build such a sequence $$$a$$$ that $$$a_i \le B$$$ for all $$$i$$$ and $$$\sum\limits_{i=0}^{n}{a_i}$$$ is maximum possible. | 256 megabytes |
import java.util.Scanner;
public class name {
public static void main(String[] args) {
// write your code here
Scanner in = new Scanner(System.in);
int cases = in.nextInt();
for(int i =0; i<cases; i++){
long total = 0;
int rounds = in.nextInt();
int max = in.nextInt();
int cur=0;
int x = in.nextInt();
int y = in.nextInt();
for(int j =0; j<rounds; j++){
if(cur+x<= max){
total+= cur+x;
cur=cur+x;
}
else{
total+=(cur-y);
cur=cur-y;
}
}
System.out.println(total);
}
}
}
| Java | ["3\n5 100 1 30\n7 1000000000 1000000000 1000000000\n4 1 7 3"] | 2 seconds | ["15\n4000000000\n-10"] | NoteIn the first test case, the optimal sequence $$$a$$$ is $$$[0, 1, 2, 3, 4, 5]$$$.In the second test case, the optimal sequence $$$a$$$ is $$$[0, 10^9, 0, 10^9, 0, 10^9, 0, 10^9]$$$.In the third test case, the optimal sequence $$$a$$$ is $$$[0, -3, -6, 1, -2]$$$. | Java 11 | standard input | [
"greedy"
] | 2c921093abf2c5963f5f0e96cd430456 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. Next $$$t$$$ cases follow. The first and only line of each test case contains four integers $$$n$$$, $$$B$$$, $$$x$$$ and $$$y$$$ ($$$1 \le n \le 2 \cdot 10^5$$$; $$$1 \le B, x, y \le 10^9$$$). It's guaranteed that the total sum of $$$n$$$ doesn't exceed $$$2 \cdot 10^5$$$. | 800 | For each test case, print one integer — the maximum possible $$$\sum\limits_{i=0}^{n}{a_i}$$$. | standard output |
Subsets and Splits