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 listlengths 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 ... | 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;
boole... | 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 (... | 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 ... | 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;
... | 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 (... | 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 ... | 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;
... | 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 (... | 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 ... | 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 IOEx... | 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 (... | 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 ... | 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 &... | 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 (... | 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 ... | 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... | 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 (... | 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 ... | 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 IOEx... | 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 (... | 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 ... | 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.
privat... | 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 (... | 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 ... | 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==... | 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 (... | 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 ... | 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 ... | 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 (... | 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 ... | 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 = ... | 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 (... | 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 ... | 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];... | 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 (... | 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 ... | 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... | 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 (... | 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 ... | 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 ... | 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 (... | 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 ... | 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;
... | 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 (... | 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 ... | 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;
}
... | 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 (... | 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 ... | 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() {
... | 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 (... | 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 ... | 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.parseI... | 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 (... | 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 ... | 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 = Mat... | 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 (... | 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 ... | 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{
... | 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 (... | 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 ... | 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 cla... | 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 (... | 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 ... | 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();
... | 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 (... | 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 ... | 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() {
... | 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 (... | 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 ... | 256 megabytes | /*#####################################################
################ >>>> Diaa12360 <<<< ##################
################ Just Nothing ##################
############ If You Need it, Fight For IT; ############
####################.-. 1 5 9 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 (... | 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 ... | 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 ... | 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 (... | 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 ... | 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);
... | 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 (... | 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 ... | 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();
... | 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 (... | 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 ... | 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();
... | 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 (... | 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 ... | 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);
... | 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 (... | 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 ... | 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... | 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 (... | 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 ... | 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... | 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 (... | 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 ... | 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... | 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 (... | 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 ... | 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 ... | 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 (... | 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 ... | 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[] i... | 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 (... | 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 ... | 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) {
Sys... | 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 (... | 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 ... | 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);
... | 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 (... | 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 ... | 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)... | 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 (... | 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 ... | 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.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 (... | 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 ... | 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 BufferedOutput... | 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 (... | 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 ... | 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);
el... | 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 (... | 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 ... | 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 {
OutputStreamWrite... | 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 (... | 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 ... | 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)Ma... | 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 (... | 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 ... | 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 {
... | 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 (... | 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 ... | 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);
... | 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 (... | 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 ... | 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.nex... | 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 (... | 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 ... | 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);... | 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 (... | 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 ... | 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);
}... | 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 (... | 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 ... | 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 cou... | 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 (... | 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 ... | 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.nex... | 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 (... | 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 ... | 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... | 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 (... | 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 ... | 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().... | 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 (... | 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 ... | 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 {
... | 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 (... | 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 ... | 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);
... | 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 (... | 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 ... | 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.ou... | 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 (... | 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 ... | 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 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 (... | 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 ... | 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;
... | 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 (... | 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 ... | 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();
... | 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 (... | 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 ... | 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;
... | 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 (... | 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 ... | 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;
do... | 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 (... | 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 ... | 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 ... | 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 (... | 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 ... | 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 = ... | 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 (... | 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 ... | 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();
... | 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 (... | 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 ... | 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;
... | 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 (... | 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 ... | 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... | 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 (... | 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 ... | 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;... | 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 (... | 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 ... | 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){
Syst... | 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 (... | 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 ... | 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) {
Scan... | 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 (... | 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 ... | 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);
... | 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 (... | 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 ... | 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... | 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 (... | 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 ... | 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.i... | 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 (... | 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 ... | 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(... | 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 (... | 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 ... | 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==... | 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 (... | 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$... | 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=... | 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... | 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$... | 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 co... | 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... | 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$... | 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.nextIn... | 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... | 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$... | 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();
... | 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... | 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$... | 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(... | 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... | 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$... | 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 ... | 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... | 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$... | 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.nextIn... | 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... | 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$... | 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];
... | 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... | 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$... | 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();
... | 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... | 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$... | 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.nextLon... | 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... | 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$... | 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=sc... | 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... | 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$... | 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... | 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... | 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$... | 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... | 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... | 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$... | 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... | 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... | 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$... | 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 Debu... | 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... | 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$... | 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.ne... | 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... | 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$... | 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.hasMoreEl... | 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... | 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$... | 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 ... | 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... | 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$... | 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 StringTok... | 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... | 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$... | 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... | 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... | 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$... | 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.nex... | 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... | 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$... | 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... | 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... | 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$... | 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();... | 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... | 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$... | 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;... | 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... | 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$... | 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 = ... | 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... | 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$... | 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;
fo... | 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... | 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$... | 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--... | 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... | 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$... | 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 m... | 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... | 800 | For each test case, print one integer — the maximum possible $$$\sum\limits_{i=0}^{n}{a_i}$$$. | standard output |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.