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 | 7d9baf94bdd80986235683a4505169de | train_003.jsonl | 1566743700 | Cengiz recently learned Fibonacci numbers and now he is studying different algorithms to find them. After getting bored of reading them, he came with his own new type of numbers that he named XORinacci numbers. He defined them as follows: $$$f(0) = a$$$; $$$f(1) = b$$$; $$$f(n) = f(n-1) \oplus f(n-2)$$$ when $$$n &... | 256 megabytes | import java.util.Scanner;
public class solution{
public static void main(String[] args){
Scanner s = new Scanner(System.in);
int t = s.nextInt();
while(t-->0){
int a = s.nextInt();
int b = s.nextInt();
int n = s.nextInt();
int rem = n%3;
... | Java | ["3\n3 4 2\n4 5 0\n325 265 1231232"] | 1 second | ["7\n4\n76"] | NoteIn the first example, $$$f(2) = f(0) \oplus f(1) = 3 \oplus 4 = 7$$$. | Java 8 | standard input | [
"math"
] | 64a375c7c49591c676dbdb039c93d218 | The input contains one or more independent test cases. The first line of input contains a single integer $$$T$$$ ($$$1 \le T \le 10^3$$$), the number of test cases. Each of the $$$T$$$ following lines contains three space-separated integers $$$a$$$, $$$b$$$, and $$$n$$$ ($$$0 \le a, b, n \le 10^9$$$) respectively. | 900 | For each test case, output $$$f(n)$$$. | standard output | |
PASSED | 67c2787874a65141ec74f8b2d85a4839 | train_003.jsonl | 1566743700 | Cengiz recently learned Fibonacci numbers and now he is studying different algorithms to find them. After getting bored of reading them, he came with his own new type of numbers that he named XORinacci numbers. He defined them as follows: $$$f(0) = a$$$; $$$f(1) = b$$$; $$$f(n) = f(n-1) \oplus f(n-2)$$$ when $$$n &... | 256 megabytes | import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Scanner;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*
* @author Tanzim Ibn Patowary
*/
public class Main {
public static void main(String[] args) {
I... | Java | ["3\n3 4 2\n4 5 0\n325 265 1231232"] | 1 second | ["7\n4\n76"] | NoteIn the first example, $$$f(2) = f(0) \oplus f(1) = 3 \oplus 4 = 7$$$. | Java 8 | standard input | [
"math"
] | 64a375c7c49591c676dbdb039c93d218 | The input contains one or more independent test cases. The first line of input contains a single integer $$$T$$$ ($$$1 \le T \le 10^3$$$), the number of test cases. Each of the $$$T$$$ following lines contains three space-separated integers $$$a$$$, $$$b$$$, and $$$n$$$ ($$$0 \le a, b, n \le 10^9$$$) respectively. | 900 | For each test case, output $$$f(n)$$$. | standard output | |
PASSED | 3903a9c9f76c429c702ed297ee7e6550 | train_003.jsonl | 1566743700 | Cengiz recently learned Fibonacci numbers and now he is studying different algorithms to find them. After getting bored of reading them, he came with his own new type of numbers that he named XORinacci numbers. He defined them as follows: $$$f(0) = a$$$; $$$f(1) = b$$$; $$$f(n) = f(n-1) \oplus f(n-2)$$$ when $$$n &... | 256 megabytes | import java.io.*;
import java.util.StringTokenizer;
public class Main {
public static void main(String[] args) throws IOException {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
PrintWriter out = new Prin... | Java | ["3\n3 4 2\n4 5 0\n325 265 1231232"] | 1 second | ["7\n4\n76"] | NoteIn the first example, $$$f(2) = f(0) \oplus f(1) = 3 \oplus 4 = 7$$$. | Java 8 | standard input | [
"math"
] | 64a375c7c49591c676dbdb039c93d218 | The input contains one or more independent test cases. The first line of input contains a single integer $$$T$$$ ($$$1 \le T \le 10^3$$$), the number of test cases. Each of the $$$T$$$ following lines contains three space-separated integers $$$a$$$, $$$b$$$, and $$$n$$$ ($$$0 \le a, b, n \le 10^9$$$) respectively. | 900 | For each test case, output $$$f(n)$$$. | standard output | |
PASSED | 245a66f9cfb0b8ffe82e1fb93c379916 | train_003.jsonl | 1566743700 | Cengiz recently learned Fibonacci numbers and now he is studying different algorithms to find them. After getting bored of reading them, he came with his own new type of numbers that he named XORinacci numbers. He defined them as follows: $$$f(0) = a$$$; $$$f(1) = b$$$; $$$f(n) = f(n-1) \oplus f(n-2)$$$ when $$$n &... | 256 megabytes | import java.util.Scanner;
/**
* @author dzimiks
* Date: 25-08-2019 at 15:58
*/
public class TaskA {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int t = in.nextInt();
while (t-- > 0) {
int a = in.nextInt();
int b = in.nextInt();
int n = in.nextInt();
if (n == 0... | Java | ["3\n3 4 2\n4 5 0\n325 265 1231232"] | 1 second | ["7\n4\n76"] | NoteIn the first example, $$$f(2) = f(0) \oplus f(1) = 3 \oplus 4 = 7$$$. | Java 8 | standard input | [
"math"
] | 64a375c7c49591c676dbdb039c93d218 | The input contains one or more independent test cases. The first line of input contains a single integer $$$T$$$ ($$$1 \le T \le 10^3$$$), the number of test cases. Each of the $$$T$$$ following lines contains three space-separated integers $$$a$$$, $$$b$$$, and $$$n$$$ ($$$0 \le a, b, n \le 10^9$$$) respectively. | 900 | For each test case, output $$$f(n)$$$. | standard output | |
PASSED | 49160f60bc1918666f4488c02610b771 | train_003.jsonl | 1566743700 | Cengiz recently learned Fibonacci numbers and now he is studying different algorithms to find them. After getting bored of reading them, he came with his own new type of numbers that he named XORinacci numbers. He defined them as follows: $$$f(0) = a$$$; $$$f(1) = b$$$; $$$f(n) = f(n-1) \oplus f(n-2)$$$ when $$$n &... | 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();
for (int i = 0; i < T; i++) {
int a = sc.nextInt();
int b = sc.nextInt();
int n = sc.nextInt();
... | Java | ["3\n3 4 2\n4 5 0\n325 265 1231232"] | 1 second | ["7\n4\n76"] | NoteIn the first example, $$$f(2) = f(0) \oplus f(1) = 3 \oplus 4 = 7$$$. | Java 8 | standard input | [
"math"
] | 64a375c7c49591c676dbdb039c93d218 | The input contains one or more independent test cases. The first line of input contains a single integer $$$T$$$ ($$$1 \le T \le 10^3$$$), the number of test cases. Each of the $$$T$$$ following lines contains three space-separated integers $$$a$$$, $$$b$$$, and $$$n$$$ ($$$0 \le a, b, n \le 10^9$$$) respectively. | 900 | For each test case, output $$$f(n)$$$. | standard output | |
PASSED | 082953f6c71fbbd1150180d208a0a3d5 | train_003.jsonl | 1566743700 | Cengiz recently learned Fibonacci numbers and now he is studying different algorithms to find them. After getting bored of reading them, he came with his own new type of numbers that he named XORinacci numbers. He defined them as follows: $$$f(0) = a$$$; $$$f(1) = b$$$; $$$f(n) = f(n-1) \oplus f(n-2)$$$ when $$$n &... | 256 megabytes | import java.util.*;
public class simpleDP{
public static void main(String str[]){
int t;
Scanner s= new Scanner(System.in);
t = s.nextInt();
for(int i=0;i<t;i++){
int a = s.nextInt();
int b = s.nextInt();
int n = s.nextInt();
int arr[] =new int[3];
arr[0] = a;
arr[1] = b;
arr[2] = a^b;
... | Java | ["3\n3 4 2\n4 5 0\n325 265 1231232"] | 1 second | ["7\n4\n76"] | NoteIn the first example, $$$f(2) = f(0) \oplus f(1) = 3 \oplus 4 = 7$$$. | Java 8 | standard input | [
"math"
] | 64a375c7c49591c676dbdb039c93d218 | The input contains one or more independent test cases. The first line of input contains a single integer $$$T$$$ ($$$1 \le T \le 10^3$$$), the number of test cases. Each of the $$$T$$$ following lines contains three space-separated integers $$$a$$$, $$$b$$$, and $$$n$$$ ($$$0 \le a, b, n \le 10^9$$$) respectively. | 900 | For each test case, output $$$f(n)$$$. | standard output | |
PASSED | 4a03425663d55422862c545bfc0c73da | train_003.jsonl | 1566743700 | Cengiz recently learned Fibonacci numbers and now he is studying different algorithms to find them. After getting bored of reading them, he came with his own new type of numbers that he named XORinacci numbers. He defined them as follows: $$$f(0) = a$$$; $$$f(1) = b$$$; $$$f(n) = f(n-1) \oplus f(n-2)$$$ when $$$n &... | 256 megabytes | import java.util.Scanner;
public class XORinacci {
public static void main(String[] args) {
Scanner xScanner = new Scanner(System.in);
int iNumTestCases = xScanner.nextInt();
for(int i = 0; i < iNumTestCases; i++) {
int a = xScanner.nextInt();
int b = xScanner.nextInt();
int n = xScan... | Java | ["3\n3 4 2\n4 5 0\n325 265 1231232"] | 1 second | ["7\n4\n76"] | NoteIn the first example, $$$f(2) = f(0) \oplus f(1) = 3 \oplus 4 = 7$$$. | Java 8 | standard input | [
"math"
] | 64a375c7c49591c676dbdb039c93d218 | The input contains one or more independent test cases. The first line of input contains a single integer $$$T$$$ ($$$1 \le T \le 10^3$$$), the number of test cases. Each of the $$$T$$$ following lines contains three space-separated integers $$$a$$$, $$$b$$$, and $$$n$$$ ($$$0 \le a, b, n \le 10^9$$$) respectively. | 900 | For each test case, output $$$f(n)$$$. | standard output | |
PASSED | 740c3d1feccad135abcd7e5f70550cad | train_003.jsonl | 1566743700 | Cengiz recently learned Fibonacci numbers and now he is studying different algorithms to find them. After getting bored of reading them, he came with his own new type of numbers that he named XORinacci numbers. He defined them as follows: $$$f(0) = a$$$; $$$f(1) = b$$$; $$$f(n) = f(n-1) \oplus f(n-2)$$$ when $$$n &... | 256 megabytes |
import java.io.*;
import java.math.BigInteger;
import java.util.*;
public class Dynamic_programming
{
public static void main(String args[])throws IOException
{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in)) ;
int t=Integer.parseInt(br.readLine());
while(t-->0)
{
... | Java | ["3\n3 4 2\n4 5 0\n325 265 1231232"] | 1 second | ["7\n4\n76"] | NoteIn the first example, $$$f(2) = f(0) \oplus f(1) = 3 \oplus 4 = 7$$$. | Java 8 | standard input | [
"math"
] | 64a375c7c49591c676dbdb039c93d218 | The input contains one or more independent test cases. The first line of input contains a single integer $$$T$$$ ($$$1 \le T \le 10^3$$$), the number of test cases. Each of the $$$T$$$ following lines contains three space-separated integers $$$a$$$, $$$b$$$, and $$$n$$$ ($$$0 \le a, b, n \le 10^9$$$) respectively. | 900 | For each test case, output $$$f(n)$$$. | standard output | |
PASSED | 6912a4bd76c08d52e632b0f6a6ee6034 | train_003.jsonl | 1566743700 | Cengiz recently learned Fibonacci numbers and now he is studying different algorithms to find them. After getting bored of reading them, he came with his own new type of numbers that he named XORinacci numbers. He defined them as follows: $$$f(0) = a$$$; $$$f(1) = b$$$; $$$f(n) = f(n-1) \oplus f(n-2)$$$ when $$$n &... | 256 megabytes | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int num_Of_Elements = input.nextInt();
for (int i = 0; i < num_Of_Elements; i++) {
int arr[] = new int[3];
for (int j = 0; j < 3; j++){
... | Java | ["3\n3 4 2\n4 5 0\n325 265 1231232"] | 1 second | ["7\n4\n76"] | NoteIn the first example, $$$f(2) = f(0) \oplus f(1) = 3 \oplus 4 = 7$$$. | Java 8 | standard input | [
"math"
] | 64a375c7c49591c676dbdb039c93d218 | The input contains one or more independent test cases. The first line of input contains a single integer $$$T$$$ ($$$1 \le T \le 10^3$$$), the number of test cases. Each of the $$$T$$$ following lines contains three space-separated integers $$$a$$$, $$$b$$$, and $$$n$$$ ($$$0 \le a, b, n \le 10^9$$$) respectively. | 900 | For each test case, output $$$f(n)$$$. | standard output | |
PASSED | 3d56ae4826b7a3ad654655e2fc92440f | train_003.jsonl | 1566743700 | Cengiz recently learned Fibonacci numbers and now he is studying different algorithms to find them. After getting bored of reading them, he came with his own new type of numbers that he named XORinacci numbers. He defined them as follows: $$$f(0) = a$$$; $$$f(1) = b$$$; $$$f(n) = f(n-1) \oplus f(n-2)$$$ when $$$n &... | 256 megabytes | import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.InputMismatchException;
public class Main {
InputStream is;
PrintWriter out;
String INPUT = "";
void solve()
{
int t=ni();
while(t--... | Java | ["3\n3 4 2\n4 5 0\n325 265 1231232"] | 1 second | ["7\n4\n76"] | NoteIn the first example, $$$f(2) = f(0) \oplus f(1) = 3 \oplus 4 = 7$$$. | Java 8 | standard input | [
"math"
] | 64a375c7c49591c676dbdb039c93d218 | The input contains one or more independent test cases. The first line of input contains a single integer $$$T$$$ ($$$1 \le T \le 10^3$$$), the number of test cases. Each of the $$$T$$$ following lines contains three space-separated integers $$$a$$$, $$$b$$$, and $$$n$$$ ($$$0 \le a, b, n \le 10^9$$$) respectively. | 900 | For each test case, output $$$f(n)$$$. | standard output | |
PASSED | ebd43710125be6a09131d1634520037f | train_003.jsonl | 1566743700 | Cengiz recently learned Fibonacci numbers and now he is studying different algorithms to find them. After getting bored of reading them, he came with his own new type of numbers that he named XORinacci numbers. He defined them as follows: $$$f(0) = a$$$; $$$f(1) = b$$$; $$$f(n) = f(n-1) \oplus f(n-2)$$$ when $$$n &... | 256 megabytes | import java.util.Scanner;
public class Main {
public static void main (String... args) {
Scanner s = new Scanner (System.in);
int t = s.nextInt();
for (; t > 0; t--) {
int a = s.nextInt();
int b = s.nextInt();
int n = (s.nextInt())%3;
int[] m = {a, b, a ^ b};
System.out.println(m[n]);
}
... | Java | ["3\n3 4 2\n4 5 0\n325 265 1231232"] | 1 second | ["7\n4\n76"] | NoteIn the first example, $$$f(2) = f(0) \oplus f(1) = 3 \oplus 4 = 7$$$. | Java 8 | standard input | [
"math"
] | 64a375c7c49591c676dbdb039c93d218 | The input contains one or more independent test cases. The first line of input contains a single integer $$$T$$$ ($$$1 \le T \le 10^3$$$), the number of test cases. Each of the $$$T$$$ following lines contains three space-separated integers $$$a$$$, $$$b$$$, and $$$n$$$ ($$$0 \le a, b, n \le 10^9$$$) respectively. | 900 | For each test case, output $$$f(n)$$$. | standard output | |
PASSED | c154557419645b3c4bbc79a029ac3a1d | train_003.jsonl | 1380641400 | You've got a robot, its task is destroying bombs on a square plane. Specifically, the square plane contains n bombs, the i-th bomb is at point with coordinates (xi, yi). We know that no two bombs are at the same point and that no bomb is at point with coordinates (0, 0). Initially, the robot is at point with coordinate... | 256 megabytes | import java.util.*;
import java.io.*;
import java.math.*;
public class a{
public static void main( String [] args) throws IOException{
FastScanner sc=new FastScanner();
int n=sc.nextInt();
List<int[]> point=new ArrayList<>();
long ttl=0;
for(int i=0;i<n;i++){
int [] a=sc.nextIntArray(2);
point.add(a... | Java | ["2\n1 1\n-1 -1", "3\n5 0\n0 5\n1 0"] | 2 seconds | ["12\n1 1 R\n1 1 U\n2\n1 1 L\n1 1 D\n3\n1 1 L\n1 1 D\n2\n1 1 R\n1 1 U\n3", "12\n1 1 R\n2\n1 1 L\n3\n1 5 R\n2\n1 5 L\n3\n1 5 U\n2\n1 5 D\n3"] | null | Java 8 | standard input | [
"implementation",
"sortings",
"greedy"
] | a7c1b9845ab0569e0175853db9ed5c32 | The first line contains a single integer n (1 ≤ n ≤ 105) — the number of bombs on the coordinate plane. Next n lines contain two integers each. The i-th line contains numbers (xi, yi) ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th bomb. It is guaranteed that no two bombs are located at the same point and no bomb... | 1,600 | In a single line print a single integer k — the minimum number of operations needed to destroy all bombs. On the next lines print the descriptions of these k operations. If there are multiple sequences, you can print any of them. It is guaranteed that there is the solution where k ≤ 106. | standard output | |
PASSED | 467fa5d15205e499d610fc03ec6b821a | train_003.jsonl | 1380641400 | You've got a robot, its task is destroying bombs on a square plane. Specifically, the square plane contains n bombs, the i-th bomb is at point with coordinates (xi, yi). We know that no two bombs are at the same point and that no bomb is at point with coordinates (0, 0). Initially, the robot is at point with coordinate... | 256 megabytes | // TO LOVE IS TO KNOW WHAT'S YOUR WORTH. //
// Author :- Saurabh//
//BIT MESRA, RANCHI//
import java.io.*;
import java.util.*;
import static java.lang.Math.*;
public class bombs {
static void Bolo_Jai_Mata_Di() {
n = ni();
tsc();
Comparator<two> c = new Comparator<two>() {
@Ov... | Java | ["2\n1 1\n-1 -1", "3\n5 0\n0 5\n1 0"] | 2 seconds | ["12\n1 1 R\n1 1 U\n2\n1 1 L\n1 1 D\n3\n1 1 L\n1 1 D\n2\n1 1 R\n1 1 U\n3", "12\n1 1 R\n2\n1 1 L\n3\n1 5 R\n2\n1 5 L\n3\n1 5 U\n2\n1 5 D\n3"] | null | Java 8 | standard input | [
"implementation",
"sortings",
"greedy"
] | a7c1b9845ab0569e0175853db9ed5c32 | The first line contains a single integer n (1 ≤ n ≤ 105) — the number of bombs on the coordinate plane. Next n lines contain two integers each. The i-th line contains numbers (xi, yi) ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th bomb. It is guaranteed that no two bombs are located at the same point and no bomb... | 1,600 | In a single line print a single integer k — the minimum number of operations needed to destroy all bombs. On the next lines print the descriptions of these k operations. If there are multiple sequences, you can print any of them. It is guaranteed that there is the solution where k ≤ 106. | standard output | |
PASSED | b8471de545dc2aaeef8e733c308aac0f | train_003.jsonl | 1380641400 | You've got a robot, its task is destroying bombs on a square plane. Specifically, the square plane contains n bombs, the i-th bomb is at point with coordinates (xi, yi). We know that no two bombs are at the same point and that no bomb is at point with coordinates (0, 0). Initially, the robot is at point with coordinate... | 256 megabytes | import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;
public class Main {
public static void main(String[] args) throws IOExc... | Java | ["2\n1 1\n-1 -1", "3\n5 0\n0 5\n1 0"] | 2 seconds | ["12\n1 1 R\n1 1 U\n2\n1 1 L\n1 1 D\n3\n1 1 L\n1 1 D\n2\n1 1 R\n1 1 U\n3", "12\n1 1 R\n2\n1 1 L\n3\n1 5 R\n2\n1 5 L\n3\n1 5 U\n2\n1 5 D\n3"] | null | Java 8 | standard input | [
"implementation",
"sortings",
"greedy"
] | a7c1b9845ab0569e0175853db9ed5c32 | The first line contains a single integer n (1 ≤ n ≤ 105) — the number of bombs on the coordinate plane. Next n lines contain two integers each. The i-th line contains numbers (xi, yi) ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th bomb. It is guaranteed that no two bombs are located at the same point and no bomb... | 1,600 | In a single line print a single integer k — the minimum number of operations needed to destroy all bombs. On the next lines print the descriptions of these k operations. If there are multiple sequences, you can print any of them. It is guaranteed that there is the solution where k ≤ 106. | standard output | |
PASSED | d798f57378b7bf3d07daa4e78ffee556 | train_003.jsonl | 1380641400 | You've got a robot, its task is destroying bombs on a square plane. Specifically, the square plane contains n bombs, the i-th bomb is at point with coordinates (xi, yi). We know that no two bombs are at the same point and that no bomb is at point with coordinates (0, 0). Initially, the robot is at point with coordinate... | 256 megabytes | import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Scanner;
public class Main{
public static void main(String[] args)
{
Scanner s=new Scanner(System.in);
int n=s.nextInt();
ArrayList<pair> list=new ArrayList<>();
ArrayList<pair> l... | Java | ["2\n1 1\n-1 -1", "3\n5 0\n0 5\n1 0"] | 2 seconds | ["12\n1 1 R\n1 1 U\n2\n1 1 L\n1 1 D\n3\n1 1 L\n1 1 D\n2\n1 1 R\n1 1 U\n3", "12\n1 1 R\n2\n1 1 L\n3\n1 5 R\n2\n1 5 L\n3\n1 5 U\n2\n1 5 D\n3"] | null | Java 8 | standard input | [
"implementation",
"sortings",
"greedy"
] | a7c1b9845ab0569e0175853db9ed5c32 | The first line contains a single integer n (1 ≤ n ≤ 105) — the number of bombs on the coordinate plane. Next n lines contain two integers each. The i-th line contains numbers (xi, yi) ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th bomb. It is guaranteed that no two bombs are located at the same point and no bomb... | 1,600 | In a single line print a single integer k — the minimum number of operations needed to destroy all bombs. On the next lines print the descriptions of these k operations. If there are multiple sequences, you can print any of them. It is guaranteed that there is the solution where k ≤ 106. | standard output | |
PASSED | 8253529f418b0eacd6da87b875e33ee4 | train_003.jsonl | 1380641400 | You've got a robot, its task is destroying bombs on a square plane. Specifically, the square plane contains n bombs, the i-th bomb is at point with coordinates (xi, yi). We know that no two bombs are at the same point and that no bomb is at point with coordinates (0, 0). Initially, the robot is at point with coordinate... | 256 megabytes | import java.io.*;
import java.util.*;
public class CF350C {
static class B {
int x, y;
B(int x, int y) {
this.x = x;
this.y = y;
}
}
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamRe... | Java | ["2\n1 1\n-1 -1", "3\n5 0\n0 5\n1 0"] | 2 seconds | ["12\n1 1 R\n1 1 U\n2\n1 1 L\n1 1 D\n3\n1 1 L\n1 1 D\n2\n1 1 R\n1 1 U\n3", "12\n1 1 R\n2\n1 1 L\n3\n1 5 R\n2\n1 5 L\n3\n1 5 U\n2\n1 5 D\n3"] | null | Java 8 | standard input | [
"implementation",
"sortings",
"greedy"
] | a7c1b9845ab0569e0175853db9ed5c32 | The first line contains a single integer n (1 ≤ n ≤ 105) — the number of bombs on the coordinate plane. Next n lines contain two integers each. The i-th line contains numbers (xi, yi) ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th bomb. It is guaranteed that no two bombs are located at the same point and no bomb... | 1,600 | In a single line print a single integer k — the minimum number of operations needed to destroy all bombs. On the next lines print the descriptions of these k operations. If there are multiple sequences, you can print any of them. It is guaranteed that there is the solution where k ≤ 106. | standard output | |
PASSED | c4dcbc4fd609d4a59b29fc47c812e9b6 | train_003.jsonl | 1380641400 | You've got a robot, its task is destroying bombs on a square plane. Specifically, the square plane contains n bombs, the i-th bomb is at point with coordinates (xi, yi). We know that no two bombs are at the same point and that no bomb is at point with coordinates (0, 0). Initially, the robot is at point with coordinate... | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.Buffer;
import java.util.*;
public class Watermelon{
public static void main(String[] args) throws IOException {
Scanner sc = new Scanner(System.in);
int n=sc.nextInt();
int[][] info=... | Java | ["2\n1 1\n-1 -1", "3\n5 0\n0 5\n1 0"] | 2 seconds | ["12\n1 1 R\n1 1 U\n2\n1 1 L\n1 1 D\n3\n1 1 L\n1 1 D\n2\n1 1 R\n1 1 U\n3", "12\n1 1 R\n2\n1 1 L\n3\n1 5 R\n2\n1 5 L\n3\n1 5 U\n2\n1 5 D\n3"] | null | Java 8 | standard input | [
"implementation",
"sortings",
"greedy"
] | a7c1b9845ab0569e0175853db9ed5c32 | The first line contains a single integer n (1 ≤ n ≤ 105) — the number of bombs on the coordinate plane. Next n lines contain two integers each. The i-th line contains numbers (xi, yi) ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th bomb. It is guaranteed that no two bombs are located at the same point and no bomb... | 1,600 | In a single line print a single integer k — the minimum number of operations needed to destroy all bombs. On the next lines print the descriptions of these k operations. If there are multiple sequences, you can print any of them. It is guaranteed that there is the solution where k ≤ 106. | standard output | |
PASSED | f4d92f16591775f61f681e9439b64e86 | train_003.jsonl | 1380641400 | You've got a robot, its task is destroying bombs on a square plane. Specifically, the square plane contains n bombs, the i-th bomb is at point with coordinates (xi, yi). We know that no two bombs are at the same point and that no bomb is at point with coordinates (0, 0). Initially, the robot is at point with coordinate... | 256 megabytes |
import java.io.*;
import java.util.*;
public class Cf350C {
static class Pair implements Comparator<Pair>{
int a,b;
Pair(){}
Pair(int a, int b){
this.a = a;
this.b = b;
}
@Override
public int compare(Pair p, Pair q) {
if(Math.abs(... | Java | ["2\n1 1\n-1 -1", "3\n5 0\n0 5\n1 0"] | 2 seconds | ["12\n1 1 R\n1 1 U\n2\n1 1 L\n1 1 D\n3\n1 1 L\n1 1 D\n2\n1 1 R\n1 1 U\n3", "12\n1 1 R\n2\n1 1 L\n3\n1 5 R\n2\n1 5 L\n3\n1 5 U\n2\n1 5 D\n3"] | null | Java 8 | standard input | [
"implementation",
"sortings",
"greedy"
] | a7c1b9845ab0569e0175853db9ed5c32 | The first line contains a single integer n (1 ≤ n ≤ 105) — the number of bombs on the coordinate plane. Next n lines contain two integers each. The i-th line contains numbers (xi, yi) ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th bomb. It is guaranteed that no two bombs are located at the same point and no bomb... | 1,600 | In a single line print a single integer k — the minimum number of operations needed to destroy all bombs. On the next lines print the descriptions of these k operations. If there are multiple sequences, you can print any of them. It is guaranteed that there is the solution where k ≤ 106. | standard output | |
PASSED | 74f7c74bb2f94be49b2aa08769a961f7 | train_003.jsonl | 1380641400 | You've got a robot, its task is destroying bombs on a square plane. Specifically, the square plane contains n bombs, the i-th bomb is at point with coordinates (xi, yi). We know that no two bombs are at the same point and that no bomb is at point with coordinates (0, 0). Initially, the robot is at point with coordinate... | 256 megabytes |
import java.io.*;
import java.util.ArrayList;
import java.util.Collections;
public class C {
static StreamTokenizer st;
static PrintWriter out;
static ArrayList<Point> lst;
public static void main(String[] args) throws IOException {
st = new StreamTokenizer(new BufferedReader(new InputStream... | Java | ["2\n1 1\n-1 -1", "3\n5 0\n0 5\n1 0"] | 2 seconds | ["12\n1 1 R\n1 1 U\n2\n1 1 L\n1 1 D\n3\n1 1 L\n1 1 D\n2\n1 1 R\n1 1 U\n3", "12\n1 1 R\n2\n1 1 L\n3\n1 5 R\n2\n1 5 L\n3\n1 5 U\n2\n1 5 D\n3"] | null | Java 8 | standard input | [
"implementation",
"sortings",
"greedy"
] | a7c1b9845ab0569e0175853db9ed5c32 | The first line contains a single integer n (1 ≤ n ≤ 105) — the number of bombs on the coordinate plane. Next n lines contain two integers each. The i-th line contains numbers (xi, yi) ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th bomb. It is guaranteed that no two bombs are located at the same point and no bomb... | 1,600 | In a single line print a single integer k — the minimum number of operations needed to destroy all bombs. On the next lines print the descriptions of these k operations. If there are multiple sequences, you can print any of them. It is guaranteed that there is the solution where k ≤ 106. | standard output | |
PASSED | c05ffd85162140fb8631b2b288207ebc | train_003.jsonl | 1380641400 | You've got a robot, its task is destroying bombs on a square plane. Specifically, the square plane contains n bombs, the i-th bomb is at point with coordinates (xi, yi). We know that no two bombs are at the same point and that no bomb is at point with coordinates (0, 0). Initially, the robot is at point with coordinate... | 256 megabytes | import java.io.*;
import java.util.*;
public class C {
public static void main(String[] args) throws NumberFormatException, IOException {
BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
PrintWriter out = new PrintWriter(System.out);
Scanner sc = new Scanner(System.in);
input.init(Syst... | Java | ["2\n1 1\n-1 -1", "3\n5 0\n0 5\n1 0"] | 2 seconds | ["12\n1 1 R\n1 1 U\n2\n1 1 L\n1 1 D\n3\n1 1 L\n1 1 D\n2\n1 1 R\n1 1 U\n3", "12\n1 1 R\n2\n1 1 L\n3\n1 5 R\n2\n1 5 L\n3\n1 5 U\n2\n1 5 D\n3"] | null | Java 8 | standard input | [
"implementation",
"sortings",
"greedy"
] | a7c1b9845ab0569e0175853db9ed5c32 | The first line contains a single integer n (1 ≤ n ≤ 105) — the number of bombs on the coordinate plane. Next n lines contain two integers each. The i-th line contains numbers (xi, yi) ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th bomb. It is guaranteed that no two bombs are located at the same point and no bomb... | 1,600 | In a single line print a single integer k — the minimum number of operations needed to destroy all bombs. On the next lines print the descriptions of these k operations. If there are multiple sequences, you can print any of them. It is guaranteed that there is the solution where k ≤ 106. | standard output | |
PASSED | 460353a4d5712df0a5368a4c250526cd | train_003.jsonl | 1380641400 | You've got a robot, its task is destroying bombs on a square plane. Specifically, the square plane contains n bombs, the i-th bomb is at point with coordinates (xi, yi). We know that no two bombs are at the same point and that no bomb is at point with coordinates (0, 0). Initially, the robot is at point with coordinate... | 256 megabytes | import java.util.*;
import java.io.*;
public class C{
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
PrintWriter pw = new PrintWriter(System.out);
int n = scan.nextInt();
Pair arr[] = new Pair[n];
for(int i = 0;i < n;i++)
arr[i] = new Pair(scan.nextInt(),scan.nextInt());
... | Java | ["2\n1 1\n-1 -1", "3\n5 0\n0 5\n1 0"] | 2 seconds | ["12\n1 1 R\n1 1 U\n2\n1 1 L\n1 1 D\n3\n1 1 L\n1 1 D\n2\n1 1 R\n1 1 U\n3", "12\n1 1 R\n2\n1 1 L\n3\n1 5 R\n2\n1 5 L\n3\n1 5 U\n2\n1 5 D\n3"] | null | Java 8 | standard input | [
"implementation",
"sortings",
"greedy"
] | a7c1b9845ab0569e0175853db9ed5c32 | The first line contains a single integer n (1 ≤ n ≤ 105) — the number of bombs on the coordinate plane. Next n lines contain two integers each. The i-th line contains numbers (xi, yi) ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th bomb. It is guaranteed that no two bombs are located at the same point and no bomb... | 1,600 | In a single line print a single integer k — the minimum number of operations needed to destroy all bombs. On the next lines print the descriptions of these k operations. If there are multiple sequences, you can print any of them. It is guaranteed that there is the solution where k ≤ 106. | standard output | |
PASSED | 6f2a96407e6b7b987fb3895c84b495c1 | train_003.jsonl | 1380641400 | You've got a robot, its task is destroying bombs on a square plane. Specifically, the square plane contains n bombs, the i-th bomb is at point with coordinates (xi, yi). We know that no two bombs are at the same point and that no bomb is at point with coordinates (0, 0). Initially, the robot is at point with coordinate... | 256 megabytes | import java.io.*;
import java.util.*;
import java.math.BigInteger;
/*
* This file was created by ayush in attempt to solve the problem problems
*/
public class main {
public void solve(Point[] points, PrintWriter out) {
Arrays.sort(points);
String ans="";
int operations = 4 * points.length;
for (int i = 0;... | Java | ["2\n1 1\n-1 -1", "3\n5 0\n0 5\n1 0"] | 2 seconds | ["12\n1 1 R\n1 1 U\n2\n1 1 L\n1 1 D\n3\n1 1 L\n1 1 D\n2\n1 1 R\n1 1 U\n3", "12\n1 1 R\n2\n1 1 L\n3\n1 5 R\n2\n1 5 L\n3\n1 5 U\n2\n1 5 D\n3"] | null | Java 8 | standard input | [
"implementation",
"sortings",
"greedy"
] | a7c1b9845ab0569e0175853db9ed5c32 | The first line contains a single integer n (1 ≤ n ≤ 105) — the number of bombs on the coordinate plane. Next n lines contain two integers each. The i-th line contains numbers (xi, yi) ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th bomb. It is guaranteed that no two bombs are located at the same point and no bomb... | 1,600 | In a single line print a single integer k — the minimum number of operations needed to destroy all bombs. On the next lines print the descriptions of these k operations. If there are multiple sequences, you can print any of them. It is guaranteed that there is the solution where k ≤ 106. | standard output | |
PASSED | 38e845f7b2187312a86706291271178e | train_003.jsonl | 1380641400 | You've got a robot, its task is destroying bombs on a square plane. Specifically, the square plane contains n bombs, the i-th bomb is at point with coordinates (xi, yi). We know that no two bombs are at the same point and that no bomb is at point with coordinates (0, 0). Initially, the robot is at point with coordinate... | 256 megabytes | import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.Arrays;
import java.util.StringTokenizer;
public class C {
static class Point implements Comparable {
public long x, y;
public Poi... | Java | ["2\n1 1\n-1 -1", "3\n5 0\n0 5\n1 0"] | 2 seconds | ["12\n1 1 R\n1 1 U\n2\n1 1 L\n1 1 D\n3\n1 1 L\n1 1 D\n2\n1 1 R\n1 1 U\n3", "12\n1 1 R\n2\n1 1 L\n3\n1 5 R\n2\n1 5 L\n3\n1 5 U\n2\n1 5 D\n3"] | null | Java 8 | standard input | [
"implementation",
"sortings",
"greedy"
] | a7c1b9845ab0569e0175853db9ed5c32 | The first line contains a single integer n (1 ≤ n ≤ 105) — the number of bombs on the coordinate plane. Next n lines contain two integers each. The i-th line contains numbers (xi, yi) ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th bomb. It is guaranteed that no two bombs are located at the same point and no bomb... | 1,600 | In a single line print a single integer k — the minimum number of operations needed to destroy all bombs. On the next lines print the descriptions of these k operations. If there are multiple sequences, you can print any of them. It is guaranteed that there is the solution where k ≤ 106. | standard output | |
PASSED | d0c87692865070af2c4e903ea2eefb24 | train_003.jsonl | 1380641400 | You've got a robot, its task is destroying bombs on a square plane. Specifically, the square plane contains n bombs, the i-th bomb is at point with coordinates (xi, yi). We know that no two bombs are at the same point and that no bomb is at point with coordinates (0, 0). Initially, the robot is at point with coordinate... | 256 megabytes | import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.ObjectInputStream.GetField;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.In... | Java | ["2\n1 1\n-1 -1", "3\n5 0\n0 5\n1 0"] | 2 seconds | ["12\n1 1 R\n1 1 U\n2\n1 1 L\n1 1 D\n3\n1 1 L\n1 1 D\n2\n1 1 R\n1 1 U\n3", "12\n1 1 R\n2\n1 1 L\n3\n1 5 R\n2\n1 5 L\n3\n1 5 U\n2\n1 5 D\n3"] | null | Java 8 | standard input | [
"implementation",
"sortings",
"greedy"
] | a7c1b9845ab0569e0175853db9ed5c32 | The first line contains a single integer n (1 ≤ n ≤ 105) — the number of bombs on the coordinate plane. Next n lines contain two integers each. The i-th line contains numbers (xi, yi) ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th bomb. It is guaranteed that no two bombs are located at the same point and no bomb... | 1,600 | In a single line print a single integer k — the minimum number of operations needed to destroy all bombs. On the next lines print the descriptions of these k operations. If there are multiple sequences, you can print any of them. It is guaranteed that there is the solution where k ≤ 106. | standard output | |
PASSED | 56652ca8ab6ce9343b1afa4831e55937 | train_003.jsonl | 1380641400 | You've got a robot, its task is destroying bombs on a square plane. Specifically, the square plane contains n bombs, the i-th bomb is at point with coordinates (xi, yi). We know that no two bombs are at the same point and that no bomb is at point with coordinates (0, 0). Initially, the robot is at point with coordinate... | 256 megabytes | import java.io.*;
import java.math.*;
import java.util.*;
public class Main {
static final long MOD = 1000000007L;
static final int INF = 50000000;
public static void main(String[] args) {
FastScanner sc = new FastScanner();
PrintWriter pw = new PrintWriter(System.out);
int N = sc.ni();
int[][] nums = n... | Java | ["2\n1 1\n-1 -1", "3\n5 0\n0 5\n1 0"] | 2 seconds | ["12\n1 1 R\n1 1 U\n2\n1 1 L\n1 1 D\n3\n1 1 L\n1 1 D\n2\n1 1 R\n1 1 U\n3", "12\n1 1 R\n2\n1 1 L\n3\n1 5 R\n2\n1 5 L\n3\n1 5 U\n2\n1 5 D\n3"] | null | Java 8 | standard input | [
"implementation",
"sortings",
"greedy"
] | a7c1b9845ab0569e0175853db9ed5c32 | The first line contains a single integer n (1 ≤ n ≤ 105) — the number of bombs on the coordinate plane. Next n lines contain two integers each. The i-th line contains numbers (xi, yi) ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th bomb. It is guaranteed that no two bombs are located at the same point and no bomb... | 1,600 | In a single line print a single integer k — the minimum number of operations needed to destroy all bombs. On the next lines print the descriptions of these k operations. If there are multiple sequences, you can print any of them. It is guaranteed that there is the solution where k ≤ 106. | standard output | |
PASSED | 444013f6538b5cecf98242cd08fb7bd0 | train_003.jsonl | 1380641400 | You've got a robot, its task is destroying bombs on a square plane. Specifically, the square plane contains n bombs, the i-th bomb is at point with coordinates (xi, yi). We know that no two bombs are at the same point and that no bomb is at point with coordinates (0, 0). Initially, the robot is at point with coordinate... | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Comparator;
import java.util.PriorityQueue;
public class Main1 {
static class Point{
int x;
int y;
int dist;
}
static class IntCompare implements Comparator<Point>... | Java | ["2\n1 1\n-1 -1", "3\n5 0\n0 5\n1 0"] | 2 seconds | ["12\n1 1 R\n1 1 U\n2\n1 1 L\n1 1 D\n3\n1 1 L\n1 1 D\n2\n1 1 R\n1 1 U\n3", "12\n1 1 R\n2\n1 1 L\n3\n1 5 R\n2\n1 5 L\n3\n1 5 U\n2\n1 5 D\n3"] | null | Java 8 | standard input | [
"implementation",
"sortings",
"greedy"
] | a7c1b9845ab0569e0175853db9ed5c32 | The first line contains a single integer n (1 ≤ n ≤ 105) — the number of bombs on the coordinate plane. Next n lines contain two integers each. The i-th line contains numbers (xi, yi) ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th bomb. It is guaranteed that no two bombs are located at the same point and no bomb... | 1,600 | In a single line print a single integer k — the minimum number of operations needed to destroy all bombs. On the next lines print the descriptions of these k operations. If there are multiple sequences, you can print any of them. It is guaranteed that there is the solution where k ≤ 106. | standard output | |
PASSED | 5e864a28ba2b88bae0cf3e8893ab572c | train_003.jsonl | 1380641400 | You've got a robot, its task is destroying bombs on a square plane. Specifically, the square plane contains n bombs, the i-th bomb is at point with coordinates (xi, yi). We know that no two bombs are at the same point and that no bomb is at point with coordinates (0, 0). Initially, the robot is at point with coordinate... | 256 megabytes | import java.io.*;
import java.util.List;
import java.util.ArrayList;
import java.util.Collections;
public class c {
public static void main(String[] args) throws IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter out = new BufferedWriter(new OutputStreamWr... | Java | ["2\n1 1\n-1 -1", "3\n5 0\n0 5\n1 0"] | 2 seconds | ["12\n1 1 R\n1 1 U\n2\n1 1 L\n1 1 D\n3\n1 1 L\n1 1 D\n2\n1 1 R\n1 1 U\n3", "12\n1 1 R\n2\n1 1 L\n3\n1 5 R\n2\n1 5 L\n3\n1 5 U\n2\n1 5 D\n3"] | null | Java 8 | standard input | [
"implementation",
"sortings",
"greedy"
] | a7c1b9845ab0569e0175853db9ed5c32 | The first line contains a single integer n (1 ≤ n ≤ 105) — the number of bombs on the coordinate plane. Next n lines contain two integers each. The i-th line contains numbers (xi, yi) ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th bomb. It is guaranteed that no two bombs are located at the same point and no bomb... | 1,600 | In a single line print a single integer k — the minimum number of operations needed to destroy all bombs. On the next lines print the descriptions of these k operations. If there are multiple sequences, you can print any of them. It is guaranteed that there is the solution where k ≤ 106. | standard output | |
PASSED | e1e0ab48b83569b0c9d3c49bcd55eabc | train_003.jsonl | 1380641400 | You've got a robot, its task is destroying bombs on a square plane. Specifically, the square plane contains n bombs, the i-th bomb is at point with coordinates (xi, yi). We know that no two bombs are at the same point and that no bomb is at point with coordinates (0, 0). Initially, the robot is at point with coordinate... | 256 megabytes | import java.io.*;
import java.util.ArrayList;
import java.util.Collections;
public class c {
public static void main(String[] args) throws IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.o... | Java | ["2\n1 1\n-1 -1", "3\n5 0\n0 5\n1 0"] | 2 seconds | ["12\n1 1 R\n1 1 U\n2\n1 1 L\n1 1 D\n3\n1 1 L\n1 1 D\n2\n1 1 R\n1 1 U\n3", "12\n1 1 R\n2\n1 1 L\n3\n1 5 R\n2\n1 5 L\n3\n1 5 U\n2\n1 5 D\n3"] | null | Java 8 | standard input | [
"implementation",
"sortings",
"greedy"
] | a7c1b9845ab0569e0175853db9ed5c32 | The first line contains a single integer n (1 ≤ n ≤ 105) — the number of bombs on the coordinate plane. Next n lines contain two integers each. The i-th line contains numbers (xi, yi) ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th bomb. It is guaranteed that no two bombs are located at the same point and no bomb... | 1,600 | In a single line print a single integer k — the minimum number of operations needed to destroy all bombs. On the next lines print the descriptions of these k operations. If there are multiple sequences, you can print any of them. It is guaranteed that there is the solution where k ≤ 106. | standard output | |
PASSED | 2d0c28dc61d37fb815b033bff34bbec2 | train_003.jsonl | 1380641400 | You've got a robot, its task is destroying bombs on a square plane. Specifically, the square plane contains n bombs, the i-th bomb is at point with coordinates (xi, yi). We know that no two bombs are at the same point and that no bomb is at point with coordinates (0, 0). Initially, the robot is at point with coordinate... | 256 megabytes | import java.io.IOException;
import java.util.Arrays;
import java.io.UnsupportedEncodingException;
import java.util.InputMismatchException;
import java.util.Comparator;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.io.InputStream;
/**
* Built using CHelper plug-in
... | Java | ["2\n1 1\n-1 -1", "3\n5 0\n0 5\n1 0"] | 2 seconds | ["12\n1 1 R\n1 1 U\n2\n1 1 L\n1 1 D\n3\n1 1 L\n1 1 D\n2\n1 1 R\n1 1 U\n3", "12\n1 1 R\n2\n1 1 L\n3\n1 5 R\n2\n1 5 L\n3\n1 5 U\n2\n1 5 D\n3"] | null | Java 8 | standard input | [
"implementation",
"sortings",
"greedy"
] | a7c1b9845ab0569e0175853db9ed5c32 | The first line contains a single integer n (1 ≤ n ≤ 105) — the number of bombs on the coordinate plane. Next n lines contain two integers each. The i-th line contains numbers (xi, yi) ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th bomb. It is guaranteed that no two bombs are located at the same point and no bomb... | 1,600 | In a single line print a single integer k — the minimum number of operations needed to destroy all bombs. On the next lines print the descriptions of these k operations. If there are multiple sequences, you can print any of them. It is guaranteed that there is the solution where k ≤ 106. | standard output | |
PASSED | fabc4465ed59fc6f920bef59f2e30908 | train_003.jsonl | 1380641400 | You've got a robot, its task is destroying bombs on a square plane. Specifically, the square plane contains n bombs, the i-th bomb is at point with coordinates (xi, yi). We know that no two bombs are at the same point and that no bomb is at point with coordinates (0, 0). Initially, the robot is at point with coordinate... | 256 megabytes | import java.util.*;
import java.lang.*;
import java.io.*;
public class CF350C
{ //***************************************** VARIABLE DECLERATION SECTION ********************************************************************;
long x,y;
double z;
//**************************************... | Java | ["2\n1 1\n-1 -1", "3\n5 0\n0 5\n1 0"] | 2 seconds | ["12\n1 1 R\n1 1 U\n2\n1 1 L\n1 1 D\n3\n1 1 L\n1 1 D\n2\n1 1 R\n1 1 U\n3", "12\n1 1 R\n2\n1 1 L\n3\n1 5 R\n2\n1 5 L\n3\n1 5 U\n2\n1 5 D\n3"] | null | Java 8 | standard input | [
"implementation",
"sortings",
"greedy"
] | a7c1b9845ab0569e0175853db9ed5c32 | The first line contains a single integer n (1 ≤ n ≤ 105) — the number of bombs on the coordinate plane. Next n lines contain two integers each. The i-th line contains numbers (xi, yi) ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th bomb. It is guaranteed that no two bombs are located at the same point and no bomb... | 1,600 | In a single line print a single integer k — the minimum number of operations needed to destroy all bombs. On the next lines print the descriptions of these k operations. If there are multiple sequences, you can print any of them. It is guaranteed that there is the solution where k ≤ 106. | standard output | |
PASSED | d1f92ef3f7095ad03892738a81a937c2 | train_003.jsonl | 1380641400 | You've got a robot, its task is destroying bombs on a square plane. Specifically, the square plane contains n bombs, the i-th bomb is at point with coordinates (xi, yi). We know that no two bombs are at the same point and that no bomb is at point with coordinates (0, 0). Initially, the robot is at point with coordinate... | 256 megabytes | import java.util.*;
import java.lang.*;
import java.io.*;
public class CF350C
{ //***************************************** VARIABLE DECLERATION SECTION ********************************************************************;
long x,y;
double z;
//**************************************... | Java | ["2\n1 1\n-1 -1", "3\n5 0\n0 5\n1 0"] | 2 seconds | ["12\n1 1 R\n1 1 U\n2\n1 1 L\n1 1 D\n3\n1 1 L\n1 1 D\n2\n1 1 R\n1 1 U\n3", "12\n1 1 R\n2\n1 1 L\n3\n1 5 R\n2\n1 5 L\n3\n1 5 U\n2\n1 5 D\n3"] | null | Java 8 | standard input | [
"implementation",
"sortings",
"greedy"
] | a7c1b9845ab0569e0175853db9ed5c32 | The first line contains a single integer n (1 ≤ n ≤ 105) — the number of bombs on the coordinate plane. Next n lines contain two integers each. The i-th line contains numbers (xi, yi) ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th bomb. It is guaranteed that no two bombs are located at the same point and no bomb... | 1,600 | In a single line print a single integer k — the minimum number of operations needed to destroy all bombs. On the next lines print the descriptions of these k operations. If there are multiple sequences, you can print any of them. It is guaranteed that there is the solution where k ≤ 106. | standard output | |
PASSED | 78b4040f3f1fe5d55c4446d8e213bb94 | train_003.jsonl | 1380641400 | You've got a robot, its task is destroying bombs on a square plane. Specifically, the square plane contains n bombs, the i-th bomb is at point with coordinates (xi, yi). We know that no two bombs are at the same point and that no bomb is at point with coordinates (0, 0). Initially, the robot is at point with coordinate... | 256 megabytes | import java.util.*;import java.io.*;import java.math.*;
public class Main
{
static class Node{
int x;
int y;
Node(int x,int y){
this.x=x;
this.y=y;
}
}
public static class CustomSort implements Comparator<Node>{
public int compare(Node a,Node ... | Java | ["2\n1 1\n-1 -1", "3\n5 0\n0 5\n1 0"] | 2 seconds | ["12\n1 1 R\n1 1 U\n2\n1 1 L\n1 1 D\n3\n1 1 L\n1 1 D\n2\n1 1 R\n1 1 U\n3", "12\n1 1 R\n2\n1 1 L\n3\n1 5 R\n2\n1 5 L\n3\n1 5 U\n2\n1 5 D\n3"] | null | Java 8 | standard input | [
"implementation",
"sortings",
"greedy"
] | a7c1b9845ab0569e0175853db9ed5c32 | The first line contains a single integer n (1 ≤ n ≤ 105) — the number of bombs on the coordinate plane. Next n lines contain two integers each. The i-th line contains numbers (xi, yi) ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th bomb. It is guaranteed that no two bombs are located at the same point and no bomb... | 1,600 | In a single line print a single integer k — the minimum number of operations needed to destroy all bombs. On the next lines print the descriptions of these k operations. If there are multiple sequences, you can print any of them. It is guaranteed that there is the solution where k ≤ 106. | standard output | |
PASSED | 0965d8b359949e28cdd2b15368b93adc | train_003.jsonl | 1380641400 | You've got a robot, its task is destroying bombs on a square plane. Specifically, the square plane contains n bombs, the i-th bomb is at point with coordinates (xi, yi). We know that no two bombs are at the same point and that no bomb is at point with coordinates (0, 0). Initially, the robot is at point with coordinate... | 256 megabytes | import java.io.*;
import java.util.*;
import java.math.*;
public class Hello {
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 | ["2\n1 1\n-1 -1", "3\n5 0\n0 5\n1 0"] | 2 seconds | ["12\n1 1 R\n1 1 U\n2\n1 1 L\n1 1 D\n3\n1 1 L\n1 1 D\n2\n1 1 R\n1 1 U\n3", "12\n1 1 R\n2\n1 1 L\n3\n1 5 R\n2\n1 5 L\n3\n1 5 U\n2\n1 5 D\n3"] | null | Java 8 | standard input | [
"implementation",
"sortings",
"greedy"
] | a7c1b9845ab0569e0175853db9ed5c32 | The first line contains a single integer n (1 ≤ n ≤ 105) — the number of bombs on the coordinate plane. Next n lines contain two integers each. The i-th line contains numbers (xi, yi) ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th bomb. It is guaranteed that no two bombs are located at the same point and no bomb... | 1,600 | In a single line print a single integer k — the minimum number of operations needed to destroy all bombs. On the next lines print the descriptions of these k operations. If there are multiple sequences, you can print any of them. It is guaranteed that there is the solution where k ≤ 106. | standard output | |
PASSED | aba9c66ce53fee54e6335457bb7cf2b9 | train_003.jsonl | 1380641400 | You've got a robot, its task is destroying bombs on a square plane. Specifically, the square plane contains n bombs, the i-th bomb is at point with coordinates (xi, yi). We know that no two bombs are at the same point and that no bomb is at point with coordinates (0, 0). Initially, the robot is at point with coordinate... | 256 megabytes | import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.Comparator;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution i... | Java | ["2\n1 1\n-1 -1", "3\n5 0\n0 5\n1 0"] | 2 seconds | ["12\n1 1 R\n1 1 U\n2\n1 1 L\n1 1 D\n3\n1 1 L\n1 1 D\n2\n1 1 R\n1 1 U\n3", "12\n1 1 R\n2\n1 1 L\n3\n1 5 R\n2\n1 5 L\n3\n1 5 U\n2\n1 5 D\n3"] | null | Java 8 | standard input | [
"implementation",
"sortings",
"greedy"
] | a7c1b9845ab0569e0175853db9ed5c32 | The first line contains a single integer n (1 ≤ n ≤ 105) — the number of bombs on the coordinate plane. Next n lines contain two integers each. The i-th line contains numbers (xi, yi) ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th bomb. It is guaranteed that no two bombs are located at the same point and no bomb... | 1,600 | In a single line print a single integer k — the minimum number of operations needed to destroy all bombs. On the next lines print the descriptions of these k operations. If there are multiple sequences, you can print any of them. It is guaranteed that there is the solution where k ≤ 106. | standard output | |
PASSED | 1238b94ad8e69fc97ebdc4fbe4a497be | train_003.jsonl | 1380641400 | You've got a robot, its task is destroying bombs on a square plane. Specifically, the square plane contains n bombs, the i-th bomb is at point with coordinates (xi, yi). We know that no two bombs are at the same point and that no bomb is at point with coordinates (0, 0). Initially, the robot is at point with coordinate... | 256 megabytes |
import java.awt.*;
import java.io.*;
import java.util.*;
public class Main {
static Main.MyScanner sc = new Main.MyScanner();
static PrintWriter out = new PrintWriter(System.out);
// static PrintStream out = System.out;
public static void main(String[] args) {
... | Java | ["2\n1 1\n-1 -1", "3\n5 0\n0 5\n1 0"] | 2 seconds | ["12\n1 1 R\n1 1 U\n2\n1 1 L\n1 1 D\n3\n1 1 L\n1 1 D\n2\n1 1 R\n1 1 U\n3", "12\n1 1 R\n2\n1 1 L\n3\n1 5 R\n2\n1 5 L\n3\n1 5 U\n2\n1 5 D\n3"] | null | Java 8 | standard input | [
"implementation",
"sortings",
"greedy"
] | a7c1b9845ab0569e0175853db9ed5c32 | The first line contains a single integer n (1 ≤ n ≤ 105) — the number of bombs on the coordinate plane. Next n lines contain two integers each. The i-th line contains numbers (xi, yi) ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th bomb. It is guaranteed that no two bombs are located at the same point and no bomb... | 1,600 | In a single line print a single integer k — the minimum number of operations needed to destroy all bombs. On the next lines print the descriptions of these k operations. If there are multiple sequences, you can print any of them. It is guaranteed that there is the solution where k ≤ 106. | standard output | |
PASSED | c5afccf6d2903ea13c8b7071b7f44d54 | train_003.jsonl | 1380641400 | You've got a robot, its task is destroying bombs on a square plane. Specifically, the square plane contains n bombs, the i-th bomb is at point with coordinates (xi, yi). We know that no two bombs are at the same point and that no bomb is at point with coordinates (0, 0). Initially, the robot is at point with coordinate... | 256 megabytes | /*
Keep solving problems.
*/
import java.util.*;
import java.io.*;
public class CFA {
BufferedReader br;
PrintWriter out;
StringTokenizer st;
boolean eof;
final long MOD = 1000L * 1000L * 1000L * 2 + 7;
int[] dx = {-1, 1, 0, 0};
int[] dy = {0, 0, -1, 1};
class Node implements Compara... | Java | ["2\n1 1\n-1 -1", "3\n5 0\n0 5\n1 0"] | 2 seconds | ["12\n1 1 R\n1 1 U\n2\n1 1 L\n1 1 D\n3\n1 1 L\n1 1 D\n2\n1 1 R\n1 1 U\n3", "12\n1 1 R\n2\n1 1 L\n3\n1 5 R\n2\n1 5 L\n3\n1 5 U\n2\n1 5 D\n3"] | null | Java 8 | standard input | [
"implementation",
"sortings",
"greedy"
] | a7c1b9845ab0569e0175853db9ed5c32 | The first line contains a single integer n (1 ≤ n ≤ 105) — the number of bombs on the coordinate plane. Next n lines contain two integers each. The i-th line contains numbers (xi, yi) ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th bomb. It is guaranteed that no two bombs are located at the same point and no bomb... | 1,600 | In a single line print a single integer k — the minimum number of operations needed to destroy all bombs. On the next lines print the descriptions of these k operations. If there are multiple sequences, you can print any of them. It is guaranteed that there is the solution where k ≤ 106. | standard output | |
PASSED | 4ff4e661d23f72b0f4892f5226864010 | train_003.jsonl | 1380641400 | You've got a robot, its task is destroying bombs on a square plane. Specifically, the square plane contains n bombs, the i-th bomb is at point with coordinates (xi, yi). We know that no two bombs are at the same point and that no bomb is at point with coordinates (0, 0). Initially, the robot is at point with coordinate... | 256 megabytes | import java.util.*;
import java.io.*;
public class Main {
class pair{
int x;
int y;
}
class sort implements Comparator<pair>{
public int compare(pair a, pair b) {
if(Math.abs(a.y)==Math.abs(b.y)) {
return Math.abs(a.x) - Math.abs(b.x);
}
else {
return Math.abs(a.y) - Math.abs(b.y);
}
... | Java | ["2\n1 1\n-1 -1", "3\n5 0\n0 5\n1 0"] | 2 seconds | ["12\n1 1 R\n1 1 U\n2\n1 1 L\n1 1 D\n3\n1 1 L\n1 1 D\n2\n1 1 R\n1 1 U\n3", "12\n1 1 R\n2\n1 1 L\n3\n1 5 R\n2\n1 5 L\n3\n1 5 U\n2\n1 5 D\n3"] | null | Java 8 | standard input | [
"implementation",
"sortings",
"greedy"
] | a7c1b9845ab0569e0175853db9ed5c32 | The first line contains a single integer n (1 ≤ n ≤ 105) — the number of bombs on the coordinate plane. Next n lines contain two integers each. The i-th line contains numbers (xi, yi) ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th bomb. It is guaranteed that no two bombs are located at the same point and no bomb... | 1,600 | In a single line print a single integer k — the minimum number of operations needed to destroy all bombs. On the next lines print the descriptions of these k operations. If there are multiple sequences, you can print any of them. It is guaranteed that there is the solution where k ≤ 106. | standard output | |
PASSED | 3a915e133c4388fdeab611c07e588b61 | train_003.jsonl | 1380641400 | You've got a robot, its task is destroying bombs on a square plane. Specifically, the square plane contains n bombs, the i-th bomb is at point with coordinates (xi, yi). We know that no two bombs are at the same point and that no bomb is at point with coordinates (0, 0). Initially, the robot is at point with coordinate... | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.PriorityQueue;
import java.util.StringTokenizer;
public class Bombs {
static StringBuilder sb = new StringBuilder();
public static void destroy(int x,int y)
{
if (x==0)
{
if (y>0)
{
sb.append(... | Java | ["2\n1 1\n-1 -1", "3\n5 0\n0 5\n1 0"] | 2 seconds | ["12\n1 1 R\n1 1 U\n2\n1 1 L\n1 1 D\n3\n1 1 L\n1 1 D\n2\n1 1 R\n1 1 U\n3", "12\n1 1 R\n2\n1 1 L\n3\n1 5 R\n2\n1 5 L\n3\n1 5 U\n2\n1 5 D\n3"] | null | Java 8 | standard input | [
"implementation",
"sortings",
"greedy"
] | a7c1b9845ab0569e0175853db9ed5c32 | The first line contains a single integer n (1 ≤ n ≤ 105) — the number of bombs on the coordinate plane. Next n lines contain two integers each. The i-th line contains numbers (xi, yi) ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th bomb. It is guaranteed that no two bombs are located at the same point and no bomb... | 1,600 | In a single line print a single integer k — the minimum number of operations needed to destroy all bombs. On the next lines print the descriptions of these k operations. If there are multiple sequences, you can print any of them. It is guaranteed that there is the solution where k ≤ 106. | standard output | |
PASSED | 7964bc5aaf203ed219b52ccad11f8f34 | train_003.jsonl | 1380641400 | You've got a robot, its task is destroying bombs on a square plane. Specifically, the square plane contains n bombs, the i-th bomb is at point with coordinates (xi, yi). We know that no two bombs are at the same point and that no bomb is at point with coordinates (0, 0). Initially, the robot is at point with coordinate... | 256 megabytes | import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;
public class Bombs {
static StringBuilder sb;
static int total;
public static v... | Java | ["2\n1 1\n-1 -1", "3\n5 0\n0 5\n1 0"] | 2 seconds | ["12\n1 1 R\n1 1 U\n2\n1 1 L\n1 1 D\n3\n1 1 L\n1 1 D\n2\n1 1 R\n1 1 U\n3", "12\n1 1 R\n2\n1 1 L\n3\n1 5 R\n2\n1 5 L\n3\n1 5 U\n2\n1 5 D\n3"] | null | Java 8 | standard input | [
"implementation",
"sortings",
"greedy"
] | a7c1b9845ab0569e0175853db9ed5c32 | The first line contains a single integer n (1 ≤ n ≤ 105) — the number of bombs on the coordinate plane. Next n lines contain two integers each. The i-th line contains numbers (xi, yi) ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th bomb. It is guaranteed that no two bombs are located at the same point and no bomb... | 1,600 | In a single line print a single integer k — the minimum number of operations needed to destroy all bombs. On the next lines print the descriptions of these k operations. If there are multiple sequences, you can print any of them. It is guaranteed that there is the solution where k ≤ 106. | standard output | |
PASSED | 16640e61bdc65841dc276f42623cbd74 | train_003.jsonl | 1380641400 | You've got a robot, its task is destroying bombs on a square plane. Specifically, the square plane contains n bombs, the i-th bomb is at point with coordinates (xi, yi). We know that no two bombs are at the same point and that no bomb is at point with coordinates (0, 0). Initially, the robot is at point with coordinate... | 256 megabytes | //package c203;
import java.util.Arrays;
import java.util.Scanner;
public class q3
{
static ver[] v;
public static void main(String args[]) throws Exception
{
//System.setProperty("java.util.Arrays.useLegacyMergeSort", "true");
Scanner s=new Scanner(System.in);
int n=s.nextInt();
... | Java | ["2\n1 1\n-1 -1", "3\n5 0\n0 5\n1 0"] | 2 seconds | ["12\n1 1 R\n1 1 U\n2\n1 1 L\n1 1 D\n3\n1 1 L\n1 1 D\n2\n1 1 R\n1 1 U\n3", "12\n1 1 R\n2\n1 1 L\n3\n1 5 R\n2\n1 5 L\n3\n1 5 U\n2\n1 5 D\n3"] | null | Java 8 | standard input | [
"implementation",
"sortings",
"greedy"
] | a7c1b9845ab0569e0175853db9ed5c32 | The first line contains a single integer n (1 ≤ n ≤ 105) — the number of bombs on the coordinate plane. Next n lines contain two integers each. The i-th line contains numbers (xi, yi) ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th bomb. It is guaranteed that no two bombs are located at the same point and no bomb... | 1,600 | In a single line print a single integer k — the minimum number of operations needed to destroy all bombs. On the next lines print the descriptions of these k operations. If there are multiple sequences, you can print any of them. It is guaranteed that there is the solution where k ≤ 106. | standard output | |
PASSED | b50c783cd28b0acb9fbba79dad3f2082 | train_003.jsonl | 1380641400 | You've got a robot, its task is destroying bombs on a square plane. Specifically, the square plane contains n bombs, the i-th bomb is at point with coordinates (xi, yi). We know that no two bombs are at the same point and that no bomb is at point with coordinates (0, 0). Initially, the robot is at point with coordinate... | 256 megabytes | import java.util.*;
import java.io.*;
import java.math.*;
import java.util.HashMap;
public class main
{
static class Reader
{
private InputStream mIs;private byte[] buf = new byte[1024];private int curChar,numChars;public Reader() { this(System.in); }public Reader(InputStream is) { mIs = is;}
... | Java | ["2\n1 1\n-1 -1", "3\n5 0\n0 5\n1 0"] | 2 seconds | ["12\n1 1 R\n1 1 U\n2\n1 1 L\n1 1 D\n3\n1 1 L\n1 1 D\n2\n1 1 R\n1 1 U\n3", "12\n1 1 R\n2\n1 1 L\n3\n1 5 R\n2\n1 5 L\n3\n1 5 U\n2\n1 5 D\n3"] | null | Java 8 | standard input | [
"implementation",
"sortings",
"greedy"
] | a7c1b9845ab0569e0175853db9ed5c32 | The first line contains a single integer n (1 ≤ n ≤ 105) — the number of bombs on the coordinate plane. Next n lines contain two integers each. The i-th line contains numbers (xi, yi) ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th bomb. It is guaranteed that no two bombs are located at the same point and no bomb... | 1,600 | In a single line print a single integer k — the minimum number of operations needed to destroy all bombs. On the next lines print the descriptions of these k operations. If there are multiple sequences, you can print any of them. It is guaranteed that there is the solution where k ≤ 106. | standard output | |
PASSED | b1d7e701e4b0243f3614a2adcf6daa82 | train_003.jsonl | 1479632700 | Theater stage is a rectangular field of size n × m. The director gave you the stage's plan which actors will follow. For each cell it is stated in the plan if there would be an actor in this cell or not.You are to place a spotlight on the stage in some good position. The spotlight will project light in one of the four ... | 256 megabytes | //package leto;
import java.io.*;
import java.util.StringTokenizer;
public class rofl {
FastScanner in;
PrintWriter out;
public static void main(String[] arg) {
new rofl().run();
}
public void solve() throws IOException {
// Scanner scan = new Scanner(System.in);
int n = in.nextInt();
int m = in.nextInt(... | Java | ["2 4\n0 1 0 0\n1 0 1 0", "4 4\n0 0 0 0\n1 0 0 1\n0 1 1 0\n0 1 0 0"] | 1 second | ["9", "20"] | NoteIn the first example the following positions are good: the (1, 1) cell and right direction; the (1, 1) cell and down direction; the (1, 3) cell and left direction; the (1, 3) cell and down direction; the (1, 4) cell and left direction; the (2, 2) cell and left direction; the (2, 2) cell and up direction; th... | Java 8 | standard input | [
"dp",
"implementation"
] | c3a7d82f6c3cf8678a1c7c521e0a5f51 | The first line contains two positive integers n and m (1 ≤ n, m ≤ 1000) — the number of rows and the number of columns in the plan. The next n lines contain m integers, 0 or 1 each — the description of the plan. Integer 1, means there will be an actor in the corresponding cell, while 0 means the cell will remain empty.... | 1,200 | Print one integer — the number of good positions for placing the spotlight. | standard output | |
PASSED | 2ba508df1a6005c34afb909fdbd87dde | train_003.jsonl | 1479632700 | Theater stage is a rectangular field of size n × m. The director gave you the stage's plan which actors will follow. For each cell it is stated in the plan if there would be an actor in this cell or not.You are to place a spotlight on the stage in some good position. The spotlight will project light in one of the four ... | 256 megabytes | // Author @ BlackRise :) //
// Birla Institute of Technology, Mesra//
import java.io.*;
import java.util.*;
public class spotLights {
static void Blackrise() { //The name Blackrise is my pen name... you can change the name according to your wish
int n = ni(... | Java | ["2 4\n0 1 0 0\n1 0 1 0", "4 4\n0 0 0 0\n1 0 0 1\n0 1 1 0\n0 1 0 0"] | 1 second | ["9", "20"] | NoteIn the first example the following positions are good: the (1, 1) cell and right direction; the (1, 1) cell and down direction; the (1, 3) cell and left direction; the (1, 3) cell and down direction; the (1, 4) cell and left direction; the (2, 2) cell and left direction; the (2, 2) cell and up direction; th... | Java 8 | standard input | [
"dp",
"implementation"
] | c3a7d82f6c3cf8678a1c7c521e0a5f51 | The first line contains two positive integers n and m (1 ≤ n, m ≤ 1000) — the number of rows and the number of columns in the plan. The next n lines contain m integers, 0 or 1 each — the description of the plan. Integer 1, means there will be an actor in the corresponding cell, while 0 means the cell will remain empty.... | 1,200 | Print one integer — the number of good positions for placing the spotlight. | standard output | |
PASSED | cad523f3ffc817190ba22c0eef7b5d63 | train_003.jsonl | 1479632700 | Theater stage is a rectangular field of size n × m. The director gave you the stage's plan which actors will follow. For each cell it is stated in the plan if there would be an actor in this cell or not.You are to place a spotlight on the stage in some good position. The spotlight will project light in one of the four ... | 256 megabytes | import java.io.*;
import java.util.*;
public class Main {
public static void main (String[] args) throws Exception {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String st[] = br.readLine().split(" ");
int n=Integer.parseInt(st[0]);
int m=Integer.parseInt(st[1]);
int i... | Java | ["2 4\n0 1 0 0\n1 0 1 0", "4 4\n0 0 0 0\n1 0 0 1\n0 1 1 0\n0 1 0 0"] | 1 second | ["9", "20"] | NoteIn the first example the following positions are good: the (1, 1) cell and right direction; the (1, 1) cell and down direction; the (1, 3) cell and left direction; the (1, 3) cell and down direction; the (1, 4) cell and left direction; the (2, 2) cell and left direction; the (2, 2) cell and up direction; th... | Java 8 | standard input | [
"dp",
"implementation"
] | c3a7d82f6c3cf8678a1c7c521e0a5f51 | The first line contains two positive integers n and m (1 ≤ n, m ≤ 1000) — the number of rows and the number of columns in the plan. The next n lines contain m integers, 0 or 1 each — the description of the plan. Integer 1, means there will be an actor in the corresponding cell, while 0 means the cell will remain empty.... | 1,200 | Print one integer — the number of good positions for placing the spotlight. | standard output | |
PASSED | 627a185c3d61da9d28e38a04ef949194 | train_003.jsonl | 1479632700 | Theater stage is a rectangular field of size n × m. The director gave you the stage's plan which actors will follow. For each cell it is stated in the plan if there would be an actor in this cell or not.You are to place a spotlight on the stage in some good position. The spotlight will project light in one of the four ... | 256 megabytes | import java.io.*;
import java.lang.reflect.Array;
import java.util.*;
import java.lang.*;
import static java.lang.Math.*;
public class Main implements Runnable {
public static void main(String[] args) {
new Thread(null, new Main(), "Check2", 1 << 28).start();// to increse stack size in java
}
void ... | Java | ["2 4\n0 1 0 0\n1 0 1 0", "4 4\n0 0 0 0\n1 0 0 1\n0 1 1 0\n0 1 0 0"] | 1 second | ["9", "20"] | NoteIn the first example the following positions are good: the (1, 1) cell and right direction; the (1, 1) cell and down direction; the (1, 3) cell and left direction; the (1, 3) cell and down direction; the (1, 4) cell and left direction; the (2, 2) cell and left direction; the (2, 2) cell and up direction; th... | Java 8 | standard input | [
"dp",
"implementation"
] | c3a7d82f6c3cf8678a1c7c521e0a5f51 | The first line contains two positive integers n and m (1 ≤ n, m ≤ 1000) — the number of rows and the number of columns in the plan. The next n lines contain m integers, 0 or 1 each — the description of the plan. Integer 1, means there will be an actor in the corresponding cell, while 0 means the cell will remain empty.... | 1,200 | Print one integer — the number of good positions for placing the spotlight. | standard output | |
PASSED | a13086b66bc771119fd4e1f82e9036c2 | train_003.jsonl | 1479632700 | Theater stage is a rectangular field of size n × m. The director gave you the stage's plan which actors will follow. For each cell it is stated in the plan if there would be an actor in this cell or not.You are to place a spotlight on the stage in some good position. The spotlight will project light in one of the four ... | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class B729 {
public static void main(String[] args) throws IOException {
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
StringTokeniz... | Java | ["2 4\n0 1 0 0\n1 0 1 0", "4 4\n0 0 0 0\n1 0 0 1\n0 1 1 0\n0 1 0 0"] | 1 second | ["9", "20"] | NoteIn the first example the following positions are good: the (1, 1) cell and right direction; the (1, 1) cell and down direction; the (1, 3) cell and left direction; the (1, 3) cell and down direction; the (1, 4) cell and left direction; the (2, 2) cell and left direction; the (2, 2) cell and up direction; th... | Java 8 | standard input | [
"dp",
"implementation"
] | c3a7d82f6c3cf8678a1c7c521e0a5f51 | The first line contains two positive integers n and m (1 ≤ n, m ≤ 1000) — the number of rows and the number of columns in the plan. The next n lines contain m integers, 0 or 1 each — the description of the plan. Integer 1, means there will be an actor in the corresponding cell, while 0 means the cell will remain empty.... | 1,200 | Print one integer — the number of good positions for placing the spotlight. | standard output | |
PASSED | 477482984067aabfe50755e30dace9d7 | train_003.jsonl | 1479632700 | Theater stage is a rectangular field of size n × m. The director gave you the stage's plan which actors will follow. For each cell it is stated in the plan if there would be an actor in this cell or not.You are to place a spotlight on the stage in some good position. The spotlight will project light in one of the four ... | 256 megabytes | import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;
public class C304_546SoldiersCards {
public... | Java | ["2 4\n0 1 0 0\n1 0 1 0", "4 4\n0 0 0 0\n1 0 0 1\n0 1 1 0\n0 1 0 0"] | 1 second | ["9", "20"] | NoteIn the first example the following positions are good: the (1, 1) cell and right direction; the (1, 1) cell and down direction; the (1, 3) cell and left direction; the (1, 3) cell and down direction; the (1, 4) cell and left direction; the (2, 2) cell and left direction; the (2, 2) cell and up direction; th... | Java 8 | standard input | [
"dp",
"implementation"
] | c3a7d82f6c3cf8678a1c7c521e0a5f51 | The first line contains two positive integers n and m (1 ≤ n, m ≤ 1000) — the number of rows and the number of columns in the plan. The next n lines contain m integers, 0 or 1 each — the description of the plan. Integer 1, means there will be an actor in the corresponding cell, while 0 means the cell will remain empty.... | 1,200 | Print one integer — the number of good positions for placing the spotlight. | standard output | |
PASSED | 02f78e43c4285890ed722e73798a09ff | train_003.jsonl | 1479632700 | Theater stage is a rectangular field of size n × m. The director gave you the stage's plan which actors will follow. For each cell it is stated in the plan if there would be an actor in this cell or not.You are to place a spotlight on the stage in some good position. The spotlight will project light in one of the four ... | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.*;
import static java.lang.Math.abs;
public class B {
public static void main(String[] args) {
MyScanner in = new MyScanner();
... | Java | ["2 4\n0 1 0 0\n1 0 1 0", "4 4\n0 0 0 0\n1 0 0 1\n0 1 1 0\n0 1 0 0"] | 1 second | ["9", "20"] | NoteIn the first example the following positions are good: the (1, 1) cell and right direction; the (1, 1) cell and down direction; the (1, 3) cell and left direction; the (1, 3) cell and down direction; the (1, 4) cell and left direction; the (2, 2) cell and left direction; the (2, 2) cell and up direction; th... | Java 8 | standard input | [
"dp",
"implementation"
] | c3a7d82f6c3cf8678a1c7c521e0a5f51 | The first line contains two positive integers n and m (1 ≤ n, m ≤ 1000) — the number of rows and the number of columns in the plan. The next n lines contain m integers, 0 or 1 each — the description of the plan. Integer 1, means there will be an actor in the corresponding cell, while 0 means the cell will remain empty.... | 1,200 | Print one integer — the number of good positions for placing the spotlight. | standard output | |
PASSED | 37a17a1ce4587bee89aa3addfbc2a1ca | train_003.jsonl | 1479632700 | Theater stage is a rectangular field of size n × m. The director gave you the stage's plan which actors will follow. For each cell it is stated in the plan if there would be an actor in this cell or not.You are to place a spotlight on the stage in some good position. The spotlight will project light in one of the four ... | 256 megabytes | //package com.pb.codeforces.practice;
import java.util.Scanner;
public class CF729B {
public static int processUp(int[][] mat) {
int cnt = 0;
int n = mat.length; int m = mat[0].length;
for(int i=0; i<m; i++) {
boolean set = false;
for(int j=n-1; j>=0; j--) {
if(mat[j][i] == 1) set = true;
else ... | Java | ["2 4\n0 1 0 0\n1 0 1 0", "4 4\n0 0 0 0\n1 0 0 1\n0 1 1 0\n0 1 0 0"] | 1 second | ["9", "20"] | NoteIn the first example the following positions are good: the (1, 1) cell and right direction; the (1, 1) cell and down direction; the (1, 3) cell and left direction; the (1, 3) cell and down direction; the (1, 4) cell and left direction; the (2, 2) cell and left direction; the (2, 2) cell and up direction; th... | Java 8 | standard input | [
"dp",
"implementation"
] | c3a7d82f6c3cf8678a1c7c521e0a5f51 | The first line contains two positive integers n and m (1 ≤ n, m ≤ 1000) — the number of rows and the number of columns in the plan. The next n lines contain m integers, 0 or 1 each — the description of the plan. Integer 1, means there will be an actor in the corresponding cell, while 0 means the cell will remain empty.... | 1,200 | Print one integer — the number of good positions for placing the spotlight. | standard output | |
PASSED | cef56f98d9a90a78d3d6b8c3cd3587e8 | train_003.jsonl | 1479632700 | Theater stage is a rectangular field of size n × m. The director gave you the stage's plan which actors will follow. For each cell it is stated in the plan if there would be an actor in this cell or not.You are to place a spotlight on the stage in some good position. The spotlight will project light in one of the four ... | 256 megabytes |
import java.io.*;
import java.util.*;
public class NoB {
public class car {
int c, v;
}
public void solve() throws IOException {
int n = nextInt();
int m = nextInt();
int numF = 0;
int numL = 0;
int ans = 0;
int count1 = 0;
boolean ch = f... | Java | ["2 4\n0 1 0 0\n1 0 1 0", "4 4\n0 0 0 0\n1 0 0 1\n0 1 1 0\n0 1 0 0"] | 1 second | ["9", "20"] | NoteIn the first example the following positions are good: the (1, 1) cell and right direction; the (1, 1) cell and down direction; the (1, 3) cell and left direction; the (1, 3) cell and down direction; the (1, 4) cell and left direction; the (2, 2) cell and left direction; the (2, 2) cell and up direction; th... | Java 8 | standard input | [
"dp",
"implementation"
] | c3a7d82f6c3cf8678a1c7c521e0a5f51 | The first line contains two positive integers n and m (1 ≤ n, m ≤ 1000) — the number of rows and the number of columns in the plan. The next n lines contain m integers, 0 or 1 each — the description of the plan. Integer 1, means there will be an actor in the corresponding cell, while 0 means the cell will remain empty.... | 1,200 | Print one integer — the number of good positions for placing the spotlight. | standard output | |
PASSED | 0151ea26a59656aed7554d033e414224 | train_003.jsonl | 1479632700 | Theater stage is a rectangular field of size n × m. The director gave you the stage's plan which actors will follow. For each cell it is stated in the plan if there would be an actor in this cell or not.You are to place a spotlight on the stage in some good position. The spotlight will project light in one of the four ... | 256 megabytes |
import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) throws IOException {
FastScanner sc=new FastScanner(System.in);
int n=sc.nextInt();
int m=sc.nextInt();
int c=0;
int a[][]=new int[n][m];
for (int i = 0; i < n; i++) {
... | Java | ["2 4\n0 1 0 0\n1 0 1 0", "4 4\n0 0 0 0\n1 0 0 1\n0 1 1 0\n0 1 0 0"] | 1 second | ["9", "20"] | NoteIn the first example the following positions are good: the (1, 1) cell and right direction; the (1, 1) cell and down direction; the (1, 3) cell and left direction; the (1, 3) cell and down direction; the (1, 4) cell and left direction; the (2, 2) cell and left direction; the (2, 2) cell and up direction; th... | Java 8 | standard input | [
"dp",
"implementation"
] | c3a7d82f6c3cf8678a1c7c521e0a5f51 | The first line contains two positive integers n and m (1 ≤ n, m ≤ 1000) — the number of rows and the number of columns in the plan. The next n lines contain m integers, 0 or 1 each — the description of the plan. Integer 1, means there will be an actor in the corresponding cell, while 0 means the cell will remain empty.... | 1,200 | Print one integer — the number of good positions for placing the spotlight. | standard output | |
PASSED | 844472bb0d857d21310700b74003c621 | train_003.jsonl | 1479632700 | Theater stage is a rectangular field of size n × m. The director gave you the stage's plan which actors will follow. For each cell it is stated in the plan if there would be an actor in this cell or not.You are to place a spotlight on the stage in some good position. The spotlight will project light in one of the four ... | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class Main
{
public static void main(String args[])
{
try
{
Scanner sc = new Scanner(System.in);
int n = ... | Java | ["2 4\n0 1 0 0\n1 0 1 0", "4 4\n0 0 0 0\n1 0 0 1\n0 1 1 0\n0 1 0 0"] | 1 second | ["9", "20"] | NoteIn the first example the following positions are good: the (1, 1) cell and right direction; the (1, 1) cell and down direction; the (1, 3) cell and left direction; the (1, 3) cell and down direction; the (1, 4) cell and left direction; the (2, 2) cell and left direction; the (2, 2) cell and up direction; th... | Java 8 | standard input | [
"dp",
"implementation"
] | c3a7d82f6c3cf8678a1c7c521e0a5f51 | The first line contains two positive integers n and m (1 ≤ n, m ≤ 1000) — the number of rows and the number of columns in the plan. The next n lines contain m integers, 0 or 1 each — the description of the plan. Integer 1, means there will be an actor in the corresponding cell, while 0 means the cell will remain empty.... | 1,200 | Print one integer — the number of good positions for placing the spotlight. | standard output | |
PASSED | fde6d5f5d761c5b4febb9349db5577c0 | train_003.jsonl | 1479632700 | Theater stage is a rectangular field of size n × m. The director gave you the stage's plan which actors will follow. For each cell it is stated in the plan if there would be an actor in this cell or not.You are to place a spotlight on the stage in some good position. The spotlight will project light in one of the four ... | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class Main
{
public static void main(String args[])
{
try
{
Scanner sc = new Scanner(System.in);
int n = ... | Java | ["2 4\n0 1 0 0\n1 0 1 0", "4 4\n0 0 0 0\n1 0 0 1\n0 1 1 0\n0 1 0 0"] | 1 second | ["9", "20"] | NoteIn the first example the following positions are good: the (1, 1) cell and right direction; the (1, 1) cell and down direction; the (1, 3) cell and left direction; the (1, 3) cell and down direction; the (1, 4) cell and left direction; the (2, 2) cell and left direction; the (2, 2) cell and up direction; th... | Java 8 | standard input | [
"dp",
"implementation"
] | c3a7d82f6c3cf8678a1c7c521e0a5f51 | The first line contains two positive integers n and m (1 ≤ n, m ≤ 1000) — the number of rows and the number of columns in the plan. The next n lines contain m integers, 0 or 1 each — the description of the plan. Integer 1, means there will be an actor in the corresponding cell, while 0 means the cell will remain empty.... | 1,200 | Print one integer — the number of good positions for placing the spotlight. | standard output | |
PASSED | dce0dec99c6c3ca6614da142e9a198fd | train_003.jsonl | 1479632700 | Theater stage is a rectangular field of size n × m. The director gave you the stage's plan which actors will follow. For each cell it is stated in the plan if there would be an actor in this cell or not.You are to place a spotlight on the stage in some good position. The spotlight will project light in one of the four ... | 256 megabytes | /**
* Created by ankeet on 1/3/17.
*/
import java.io.*;
import java.util.*;
public class B729 {
static FastReader in = null;
static PrintWriter out = null;
public static void solve()
{
int n = in.nextInt();
int m = in.nextInt();
boolean[][] mat = new boolean[n][m];
... | Java | ["2 4\n0 1 0 0\n1 0 1 0", "4 4\n0 0 0 0\n1 0 0 1\n0 1 1 0\n0 1 0 0"] | 1 second | ["9", "20"] | NoteIn the first example the following positions are good: the (1, 1) cell and right direction; the (1, 1) cell and down direction; the (1, 3) cell and left direction; the (1, 3) cell and down direction; the (1, 4) cell and left direction; the (2, 2) cell and left direction; the (2, 2) cell and up direction; th... | Java 8 | standard input | [
"dp",
"implementation"
] | c3a7d82f6c3cf8678a1c7c521e0a5f51 | The first line contains two positive integers n and m (1 ≤ n, m ≤ 1000) — the number of rows and the number of columns in the plan. The next n lines contain m integers, 0 or 1 each — the description of the plan. Integer 1, means there will be an actor in the corresponding cell, while 0 means the cell will remain empty.... | 1,200 | Print one integer — the number of good positions for placing the spotlight. | standard output | |
PASSED | fcc39ef10a3ed19465f2eaa86484583f | train_003.jsonl | 1479632700 | Theater stage is a rectangular field of size n × m. The director gave you the stage's plan which actors will follow. For each cell it is stated in the plan if there would be an actor in this cell or not.You are to place a spotlight on the stage in some good position. The spotlight will project light in one of the four ... | 256 megabytes | import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) throws IOException {
Parser in = new Parser(System.in);
//Scanner in = new Scanner(new File("input.txt"));
//PrintWriter out = new PrintWriter(new File("output.txt"));
PrintWriter out = ... | Java | ["2 4\n0 1 0 0\n1 0 1 0", "4 4\n0 0 0 0\n1 0 0 1\n0 1 1 0\n0 1 0 0"] | 1 second | ["9", "20"] | NoteIn the first example the following positions are good: the (1, 1) cell and right direction; the (1, 1) cell and down direction; the (1, 3) cell and left direction; the (1, 3) cell and down direction; the (1, 4) cell and left direction; the (2, 2) cell and left direction; the (2, 2) cell and up direction; th... | Java 8 | standard input | [
"dp",
"implementation"
] | c3a7d82f6c3cf8678a1c7c521e0a5f51 | The first line contains two positive integers n and m (1 ≤ n, m ≤ 1000) — the number of rows and the number of columns in the plan. The next n lines contain m integers, 0 or 1 each — the description of the plan. Integer 1, means there will be an actor in the corresponding cell, while 0 means the cell will remain empty.... | 1,200 | Print one integer — the number of good positions for placing the spotlight. | standard output | |
PASSED | 755a40dd95dc4a86abc284c9c02a1db5 | train_003.jsonl | 1479632700 | Theater stage is a rectangular field of size n × m. The director gave you the stage's plan which actors will follow. For each cell it is stated in the plan if there would be an actor in this cell or not.You are to place a spotlight on the stage in some good position. The spotlight will project light in one of the four ... | 256 megabytes | import java.util.*;
import java.io.*;
public class cf {
private static final Scanner sc = new Scanner(System.in);
private static final PrintWriter pw = new PrintWriter(System.out);
private static StringBuffer ans = new StringBuffer();
public static void main(String args[]) throws Exception {
int n = sc.nextInt... | Java | ["2 4\n0 1 0 0\n1 0 1 0", "4 4\n0 0 0 0\n1 0 0 1\n0 1 1 0\n0 1 0 0"] | 1 second | ["9", "20"] | NoteIn the first example the following positions are good: the (1, 1) cell and right direction; the (1, 1) cell and down direction; the (1, 3) cell and left direction; the (1, 3) cell and down direction; the (1, 4) cell and left direction; the (2, 2) cell and left direction; the (2, 2) cell and up direction; th... | Java 8 | standard input | [
"dp",
"implementation"
] | c3a7d82f6c3cf8678a1c7c521e0a5f51 | The first line contains two positive integers n and m (1 ≤ n, m ≤ 1000) — the number of rows and the number of columns in the plan. The next n lines contain m integers, 0 or 1 each — the description of the plan. Integer 1, means there will be an actor in the corresponding cell, while 0 means the cell will remain empty.... | 1,200 | Print one integer — the number of good positions for placing the spotlight. | standard output | |
PASSED | 34c56b230ae274da79de01e6fa62572d | train_003.jsonl | 1479632700 | Theater stage is a rectangular field of size n × m. The director gave you the stage's plan which actors will follow. For each cell it is stated in the plan if there would be an actor in this cell or not.You are to place a spotlight on the stage in some good position. The spotlight will project light in one of the four ... | 256 megabytes | import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual soluti... | Java | ["2 4\n0 1 0 0\n1 0 1 0", "4 4\n0 0 0 0\n1 0 0 1\n0 1 1 0\n0 1 0 0"] | 1 second | ["9", "20"] | NoteIn the first example the following positions are good: the (1, 1) cell and right direction; the (1, 1) cell and down direction; the (1, 3) cell and left direction; the (1, 3) cell and down direction; the (1, 4) cell and left direction; the (2, 2) cell and left direction; the (2, 2) cell and up direction; th... | Java 8 | standard input | [
"dp",
"implementation"
] | c3a7d82f6c3cf8678a1c7c521e0a5f51 | The first line contains two positive integers n and m (1 ≤ n, m ≤ 1000) — the number of rows and the number of columns in the plan. The next n lines contain m integers, 0 or 1 each — the description of the plan. Integer 1, means there will be an actor in the corresponding cell, while 0 means the cell will remain empty.... | 1,200 | Print one integer — the number of good positions for placing the spotlight. | standard output | |
PASSED | 342eedd8ec49dbe923b832ff3504e6f7 | train_003.jsonl | 1479632700 | Theater stage is a rectangular field of size n × m. The director gave you the stage's plan which actors will follow. For each cell it is stated in the plan if there would be an actor in this cell or not.You are to place a spotlight on the stage in some good position. The spotlight will project light in one of the four ... | 256 megabytes | import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*
* @author kanak893
*/
public class M... | Java | ["2 4\n0 1 0 0\n1 0 1 0", "4 4\n0 0 0 0\n1 0 0 1\n0 1 1 0\n0 1 0 0"] | 1 second | ["9", "20"] | NoteIn the first example the following positions are good: the (1, 1) cell and right direction; the (1, 1) cell and down direction; the (1, 3) cell and left direction; the (1, 3) cell and down direction; the (1, 4) cell and left direction; the (2, 2) cell and left direction; the (2, 2) cell and up direction; th... | Java 8 | standard input | [
"dp",
"implementation"
] | c3a7d82f6c3cf8678a1c7c521e0a5f51 | The first line contains two positive integers n and m (1 ≤ n, m ≤ 1000) — the number of rows and the number of columns in the plan. The next n lines contain m integers, 0 or 1 each — the description of the plan. Integer 1, means there will be an actor in the corresponding cell, while 0 means the cell will remain empty.... | 1,200 | Print one integer — the number of good positions for placing the spotlight. | standard output | |
PASSED | f1eaf111915bb67abf15d9f4f84b6652 | train_003.jsonl | 1479632700 | Theater stage is a rectangular field of size n × m. The director gave you the stage's plan which actors will follow. For each cell it is stated in the plan if there would be an actor in this cell or not.You are to place a spotlight on the stage in some good position. The spotlight will project light in one of the four ... | 256 megabytes | import static java.lang.Boolean.*;
import static java.lang.Integer.*;
import static java.lang.Long.*;
import static java.lang.Float.*;
import static java.lang.Double.*;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.util.StringTokenizer;
import java.io.PrintWriter;
import java.io.IOExcept... | Java | ["2 4\n0 1 0 0\n1 0 1 0", "4 4\n0 0 0 0\n1 0 0 1\n0 1 1 0\n0 1 0 0"] | 1 second | ["9", "20"] | NoteIn the first example the following positions are good: the (1, 1) cell and right direction; the (1, 1) cell and down direction; the (1, 3) cell and left direction; the (1, 3) cell and down direction; the (1, 4) cell and left direction; the (2, 2) cell and left direction; the (2, 2) cell and up direction; th... | Java 8 | standard input | [
"dp",
"implementation"
] | c3a7d82f6c3cf8678a1c7c521e0a5f51 | The first line contains two positive integers n and m (1 ≤ n, m ≤ 1000) — the number of rows and the number of columns in the plan. The next n lines contain m integers, 0 or 1 each — the description of the plan. Integer 1, means there will be an actor in the corresponding cell, while 0 means the cell will remain empty.... | 1,200 | Print one integer — the number of good positions for placing the spotlight. | standard output | |
PASSED | c7665c4a09a223f754a3bfd592648870 | train_003.jsonl | 1479632700 | Theater stage is a rectangular field of size n × m. The director gave you the stage's plan which actors will follow. For each cell it is stated in the plan if there would be an actor in this cell or not.You are to place a spotlight on the stage in some good position. The spotlight will project light in one of the four ... | 256 megabytes | import static java.lang.Boolean.*;
import static java.lang.Byte.*;
import static java.lang.Integer.*;
import static java.lang.Long.*;
import static java.lang.Float.*;
import static java.lang.Double.*;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.util.StringTokenizer;
import java.io.Prin... | Java | ["2 4\n0 1 0 0\n1 0 1 0", "4 4\n0 0 0 0\n1 0 0 1\n0 1 1 0\n0 1 0 0"] | 1 second | ["9", "20"] | NoteIn the first example the following positions are good: the (1, 1) cell and right direction; the (1, 1) cell and down direction; the (1, 3) cell and left direction; the (1, 3) cell and down direction; the (1, 4) cell and left direction; the (2, 2) cell and left direction; the (2, 2) cell and up direction; th... | Java 8 | standard input | [
"dp",
"implementation"
] | c3a7d82f6c3cf8678a1c7c521e0a5f51 | The first line contains two positive integers n and m (1 ≤ n, m ≤ 1000) — the number of rows and the number of columns in the plan. The next n lines contain m integers, 0 or 1 each — the description of the plan. Integer 1, means there will be an actor in the corresponding cell, while 0 means the cell will remain empty.... | 1,200 | Print one integer — the number of good positions for placing the spotlight. | standard output | |
PASSED | 7384f36b43295556bfc0697ca4a200b2 | train_003.jsonl | 1479632700 | Theater stage is a rectangular field of size n × m. The director gave you the stage's plan which actors will follow. For each cell it is stated in the plan if there would be an actor in this cell or not.You are to place a spotlight on the stage in some good position. The spotlight will project light in one of the four ... | 256 megabytes | import static java.lang.Boolean.*;
import static java.lang.Integer.*;
import static java.lang.Long.*;
import static java.lang.Float.*;
import static java.lang.Double.*;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.util.StringTokenizer;
import java.io.PrintWriter;
import java.io.IOExcept... | Java | ["2 4\n0 1 0 0\n1 0 1 0", "4 4\n0 0 0 0\n1 0 0 1\n0 1 1 0\n0 1 0 0"] | 1 second | ["9", "20"] | NoteIn the first example the following positions are good: the (1, 1) cell and right direction; the (1, 1) cell and down direction; the (1, 3) cell and left direction; the (1, 3) cell and down direction; the (1, 4) cell and left direction; the (2, 2) cell and left direction; the (2, 2) cell and up direction; th... | Java 8 | standard input | [
"dp",
"implementation"
] | c3a7d82f6c3cf8678a1c7c521e0a5f51 | The first line contains two positive integers n and m (1 ≤ n, m ≤ 1000) — the number of rows and the number of columns in the plan. The next n lines contain m integers, 0 or 1 each — the description of the plan. Integer 1, means there will be an actor in the corresponding cell, while 0 means the cell will remain empty.... | 1,200 | Print one integer — the number of good positions for placing the spotlight. | standard output | |
PASSED | b87e72df83f7a6cad3a439226fe02aa2 | train_003.jsonl | 1479632700 | Theater stage is a rectangular field of size n × m. The director gave you the stage's plan which actors will follow. For each cell it is stated in the plan if there would be an actor in this cell or not.You are to place a spotlight on the stage in some good position. The spotlight will project light in one of the four ... | 256 megabytes | import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.OutputStreamWriter;
import java.io.BufferedWriter;
/**
* Created by yash on 04/06/17.
*/
public class Spotlights {
public static void main(String[] args) throws IOException {
... | Java | ["2 4\n0 1 0 0\n1 0 1 0", "4 4\n0 0 0 0\n1 0 0 1\n0 1 1 0\n0 1 0 0"] | 1 second | ["9", "20"] | NoteIn the first example the following positions are good: the (1, 1) cell and right direction; the (1, 1) cell and down direction; the (1, 3) cell and left direction; the (1, 3) cell and down direction; the (1, 4) cell and left direction; the (2, 2) cell and left direction; the (2, 2) cell and up direction; th... | Java 8 | standard input | [
"dp",
"implementation"
] | c3a7d82f6c3cf8678a1c7c521e0a5f51 | The first line contains two positive integers n and m (1 ≤ n, m ≤ 1000) — the number of rows and the number of columns in the plan. The next n lines contain m integers, 0 or 1 each — the description of the plan. Integer 1, means there will be an actor in the corresponding cell, while 0 means the cell will remain empty.... | 1,200 | Print one integer — the number of good positions for placing the spotlight. | standard output | |
PASSED | 6b9458e8068c12c40cc307c74d01d709 | train_003.jsonl | 1479632700 | Theater stage is a rectangular field of size n × m. The director gave you the stage's plan which actors will follow. For each cell it is stated in the plan if there would be an actor in this cell or not.You are to place a spotlight on the stage in some good position. The spotlight will project light in one of the four ... | 256 megabytes | import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.OutputStreamWriter;
import java.io.BufferedWriter;
/**
* Created by yash on 04/06/17.
*/
public class Spotlights {
public static void main(String[] args) throws IOException {
... | Java | ["2 4\n0 1 0 0\n1 0 1 0", "4 4\n0 0 0 0\n1 0 0 1\n0 1 1 0\n0 1 0 0"] | 1 second | ["9", "20"] | NoteIn the first example the following positions are good: the (1, 1) cell and right direction; the (1, 1) cell and down direction; the (1, 3) cell and left direction; the (1, 3) cell and down direction; the (1, 4) cell and left direction; the (2, 2) cell and left direction; the (2, 2) cell and up direction; th... | Java 8 | standard input | [
"dp",
"implementation"
] | c3a7d82f6c3cf8678a1c7c521e0a5f51 | The first line contains two positive integers n and m (1 ≤ n, m ≤ 1000) — the number of rows and the number of columns in the plan. The next n lines contain m integers, 0 or 1 each — the description of the plan. Integer 1, means there will be an actor in the corresponding cell, while 0 means the cell will remain empty.... | 1,200 | Print one integer — the number of good positions for placing the spotlight. | standard output | |
PASSED | c32e9499d8a2600e0d618f2f6d59c37c | train_003.jsonl | 1479632700 | Theater stage is a rectangular field of size n × m. The director gave you the stage's plan which actors will follow. For each cell it is stated in the plan if there would be an actor in this cell or not.You are to place a spotlight on the stage in some good position. The spotlight will project light in one of the four ... | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
public class SpotLoght {
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
//Scanner input = new... | Java | ["2 4\n0 1 0 0\n1 0 1 0", "4 4\n0 0 0 0\n1 0 0 1\n0 1 1 0\n0 1 0 0"] | 1 second | ["9", "20"] | NoteIn the first example the following positions are good: the (1, 1) cell and right direction; the (1, 1) cell and down direction; the (1, 3) cell and left direction; the (1, 3) cell and down direction; the (1, 4) cell and left direction; the (2, 2) cell and left direction; the (2, 2) cell and up direction; th... | Java 8 | standard input | [
"dp",
"implementation"
] | c3a7d82f6c3cf8678a1c7c521e0a5f51 | The first line contains two positive integers n and m (1 ≤ n, m ≤ 1000) — the number of rows and the number of columns in the plan. The next n lines contain m integers, 0 or 1 each — the description of the plan. Integer 1, means there will be an actor in the corresponding cell, while 0 means the cell will remain empty.... | 1,200 | Print one integer — the number of good positions for placing the spotlight. | standard output | |
PASSED | d5075ccd2312602cfa7520f95fd1534a | train_003.jsonl | 1479632700 | Theater stage is a rectangular field of size n × m. The director gave you the stage's plan which actors will follow. For each cell it is stated in the plan if there would be an actor in this cell or not.You are to place a spotlight on the stage in some good position. The spotlight will project light in one of the four ... | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
public class WorkFile {
public static void main(String[] args) throws IOException {
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
String[] firstli... | Java | ["2 4\n0 1 0 0\n1 0 1 0", "4 4\n0 0 0 0\n1 0 0 1\n0 1 1 0\n0 1 0 0"] | 1 second | ["9", "20"] | NoteIn the first example the following positions are good: the (1, 1) cell and right direction; the (1, 1) cell and down direction; the (1, 3) cell and left direction; the (1, 3) cell and down direction; the (1, 4) cell and left direction; the (2, 2) cell and left direction; the (2, 2) cell and up direction; th... | Java 8 | standard input | [
"dp",
"implementation"
] | c3a7d82f6c3cf8678a1c7c521e0a5f51 | The first line contains two positive integers n and m (1 ≤ n, m ≤ 1000) — the number of rows and the number of columns in the plan. The next n lines contain m integers, 0 or 1 each — the description of the plan. Integer 1, means there will be an actor in the corresponding cell, while 0 means the cell will remain empty.... | 1,200 | Print one integer — the number of good positions for placing the spotlight. | standard output | |
PASSED | 75b306537f232c058c9ec0536925a11f | train_003.jsonl | 1479632700 | Theater stage is a rectangular field of size n × m. The director gave you the stage's plan which actors will follow. For each cell it is stated in the plan if there would be an actor in this cell or not.You are to place a spotlight on the stage in some good position. The spotlight will project light in one of the four ... | 256 megabytes | import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;
public class Actors {
public static BufferedReader sc... | Java | ["2 4\n0 1 0 0\n1 0 1 0", "4 4\n0 0 0 0\n1 0 0 1\n0 1 1 0\n0 1 0 0"] | 1 second | ["9", "20"] | NoteIn the first example the following positions are good: the (1, 1) cell and right direction; the (1, 1) cell and down direction; the (1, 3) cell and left direction; the (1, 3) cell and down direction; the (1, 4) cell and left direction; the (2, 2) cell and left direction; the (2, 2) cell and up direction; th... | Java 8 | standard input | [
"dp",
"implementation"
] | c3a7d82f6c3cf8678a1c7c521e0a5f51 | The first line contains two positive integers n and m (1 ≤ n, m ≤ 1000) — the number of rows and the number of columns in the plan. The next n lines contain m integers, 0 or 1 each — the description of the plan. Integer 1, means there will be an actor in the corresponding cell, while 0 means the cell will remain empty.... | 1,200 | Print one integer — the number of good positions for placing the spotlight. | standard output | |
PASSED | d225ebfa6c2517bba00e38fce13c6a81 | train_003.jsonl | 1479632700 | Theater stage is a rectangular field of size n × m. The director gave you the stage's plan which actors will follow. For each cell it is stated in the plan if there would be an actor in this cell or not.You are to place a spotlight on the stage in some good position. The spotlight will project light in one of the four ... | 256 megabytes | import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Writer;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.*;
import java.io.*;
im... | Java | ["2 4\n0 1 0 0\n1 0 1 0", "4 4\n0 0 0 0\n1 0 0 1\n0 1 1 0\n0 1 0 0"] | 1 second | ["9", "20"] | NoteIn the first example the following positions are good: the (1, 1) cell and right direction; the (1, 1) cell and down direction; the (1, 3) cell and left direction; the (1, 3) cell and down direction; the (1, 4) cell and left direction; the (2, 2) cell and left direction; the (2, 2) cell and up direction; th... | Java 8 | standard input | [
"dp",
"implementation"
] | c3a7d82f6c3cf8678a1c7c521e0a5f51 | The first line contains two positive integers n and m (1 ≤ n, m ≤ 1000) — the number of rows and the number of columns in the plan. The next n lines contain m integers, 0 or 1 each — the description of the plan. Integer 1, means there will be an actor in the corresponding cell, while 0 means the cell will remain empty.... | 1,200 | Print one integer — the number of good positions for placing the spotlight. | standard output | |
PASSED | 6deb58ad5c36b3ff97a0c76cf9b8c7b1 | train_003.jsonl | 1479632700 | Theater stage is a rectangular field of size n × m. The director gave you the stage's plan which actors will follow. For each cell it is stated in the plan if there would be an actor in this cell or not.You are to place a spotlight on the stage in some good position. The spotlight will project light in one of the four ... | 256 megabytes | import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class TaskB {
public static Reader in;
public void run() throws IOException {
in = new Reader();
solve();
}
public static void solve() throws IOException{
int n = in.nextInt();
int m = in.n... | Java | ["2 4\n0 1 0 0\n1 0 1 0", "4 4\n0 0 0 0\n1 0 0 1\n0 1 1 0\n0 1 0 0"] | 1 second | ["9", "20"] | NoteIn the first example the following positions are good: the (1, 1) cell and right direction; the (1, 1) cell and down direction; the (1, 3) cell and left direction; the (1, 3) cell and down direction; the (1, 4) cell and left direction; the (2, 2) cell and left direction; the (2, 2) cell and up direction; th... | Java 8 | standard input | [
"dp",
"implementation"
] | c3a7d82f6c3cf8678a1c7c521e0a5f51 | The first line contains two positive integers n and m (1 ≤ n, m ≤ 1000) — the number of rows and the number of columns in the plan. The next n lines contain m integers, 0 or 1 each — the description of the plan. Integer 1, means there will be an actor in the corresponding cell, while 0 means the cell will remain empty.... | 1,200 | Print one integer — the number of good positions for placing the spotlight. | standard output | |
PASSED | 81bac904fabd8fa0d8093c52198eac41 | train_003.jsonl | 1479632700 | Theater stage is a rectangular field of size n × m. The director gave you the stage's plan which actors will follow. For each cell it is stated in the plan if there would be an actor in this cell or not.You are to place a spotlight on the stage in some good position. The spotlight will project light in one of the four ... | 256 megabytes | import java.io.*;
import java.util.*;
public class Main
{
static BufferedReader br;
static StringTokenizer st;
static PrintWriter pr = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
public static class AL<T> extends ArrayList<T> {};
public static class HM<T,Integer> ... | Java | ["2 4\n0 1 0 0\n1 0 1 0", "4 4\n0 0 0 0\n1 0 0 1\n0 1 1 0\n0 1 0 0"] | 1 second | ["9", "20"] | NoteIn the first example the following positions are good: the (1, 1) cell and right direction; the (1, 1) cell and down direction; the (1, 3) cell and left direction; the (1, 3) cell and down direction; the (1, 4) cell and left direction; the (2, 2) cell and left direction; the (2, 2) cell and up direction; th... | Java 8 | standard input | [
"dp",
"implementation"
] | c3a7d82f6c3cf8678a1c7c521e0a5f51 | The first line contains two positive integers n and m (1 ≤ n, m ≤ 1000) — the number of rows and the number of columns in the plan. The next n lines contain m integers, 0 or 1 each — the description of the plan. Integer 1, means there will be an actor in the corresponding cell, while 0 means the cell will remain empty.... | 1,200 | Print one integer — the number of good positions for placing the spotlight. | standard output | |
PASSED | d49eb6a3b3b29434cf2af4771f89df8d | train_003.jsonl | 1479632700 | Theater stage is a rectangular field of size n × m. The director gave you the stage's plan which actors will follow. For each cell it is stated in the plan if there would be an actor in this cell or not.You are to place a spotlight on the stage in some good position. The spotlight will project light in one of the four ... | 256 megabytes | import java.io.*;
import java.util.*;
public class actors
{
public static void main(String args[])throws IOException
{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
String s[]=br.readLine().split(" ");
int n=Integer.parseInt(s[0]);
int m=Integer.parseInt... | Java | ["2 4\n0 1 0 0\n1 0 1 0", "4 4\n0 0 0 0\n1 0 0 1\n0 1 1 0\n0 1 0 0"] | 1 second | ["9", "20"] | NoteIn the first example the following positions are good: the (1, 1) cell and right direction; the (1, 1) cell and down direction; the (1, 3) cell and left direction; the (1, 3) cell and down direction; the (1, 4) cell and left direction; the (2, 2) cell and left direction; the (2, 2) cell and up direction; th... | Java 8 | standard input | [
"dp",
"implementation"
] | c3a7d82f6c3cf8678a1c7c521e0a5f51 | The first line contains two positive integers n and m (1 ≤ n, m ≤ 1000) — the number of rows and the number of columns in the plan. The next n lines contain m integers, 0 or 1 each — the description of the plan. Integer 1, means there will be an actor in the corresponding cell, while 0 means the cell will remain empty.... | 1,200 | Print one integer — the number of good positions for placing the spotlight. | standard output | |
PASSED | 7f5259f2548eb1ebbde3081d4025d38a | train_003.jsonl | 1479632700 | Theater stage is a rectangular field of size n × m. The director gave you the stage's plan which actors will follow. For each cell it is stated in the plan if there would be an actor in this cell or not.You are to place a spotlight on the stage in some good position. The spotlight will project light in one of the four ... | 256 megabytes | import java.util.*;
import java.io.*;
import java.math.*;
public class Main {
public static long mod= (long) (1e9 +7);
public static void main(String args[])
{
InputReader s= new InputReader(System.in);
OutputStream outputStream= System.out;
PrintWriter out= new PrintWriter(outputStream);
int n= s.nextInt();... | Java | ["2 4\n0 1 0 0\n1 0 1 0", "4 4\n0 0 0 0\n1 0 0 1\n0 1 1 0\n0 1 0 0"] | 1 second | ["9", "20"] | NoteIn the first example the following positions are good: the (1, 1) cell and right direction; the (1, 1) cell and down direction; the (1, 3) cell and left direction; the (1, 3) cell and down direction; the (1, 4) cell and left direction; the (2, 2) cell and left direction; the (2, 2) cell and up direction; th... | Java 8 | standard input | [
"dp",
"implementation"
] | c3a7d82f6c3cf8678a1c7c521e0a5f51 | The first line contains two positive integers n and m (1 ≤ n, m ≤ 1000) — the number of rows and the number of columns in the plan. The next n lines contain m integers, 0 or 1 each — the description of the plan. Integer 1, means there will be an actor in the corresponding cell, while 0 means the cell will remain empty.... | 1,200 | Print one integer — the number of good positions for placing the spotlight. | standard output | |
PASSED | fd14870df3eca0600d72077792dd8c35 | train_003.jsonl | 1479632700 | Theater stage is a rectangular field of size n × m. The director gave you the stage's plan which actors will follow. For each cell it is stated in the plan if there would be an actor in this cell or not.You are to place a spotlight on the stage in some good position. The spotlight will project light in one of the four ... | 256 megabytes | import java.awt.Point;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.uti... | Java | ["2 4\n0 1 0 0\n1 0 1 0", "4 4\n0 0 0 0\n1 0 0 1\n0 1 1 0\n0 1 0 0"] | 1 second | ["9", "20"] | NoteIn the first example the following positions are good: the (1, 1) cell and right direction; the (1, 1) cell and down direction; the (1, 3) cell and left direction; the (1, 3) cell and down direction; the (1, 4) cell and left direction; the (2, 2) cell and left direction; the (2, 2) cell and up direction; th... | Java 8 | standard input | [
"dp",
"implementation"
] | c3a7d82f6c3cf8678a1c7c521e0a5f51 | The first line contains two positive integers n and m (1 ≤ n, m ≤ 1000) — the number of rows and the number of columns in the plan. The next n lines contain m integers, 0 or 1 each — the description of the plan. Integer 1, means there will be an actor in the corresponding cell, while 0 means the cell will remain empty.... | 1,200 | Print one integer — the number of good positions for placing the spotlight. | standard output | |
PASSED | 2d3c0a1fc931f23e27b4d4c54b6c49b9 | train_003.jsonl | 1479632700 | Theater stage is a rectangular field of size n × m. The director gave you the stage's plan which actors will follow. For each cell it is stated in the plan if there would be an actor in this cell or not.You are to place a spotlight on the stage in some good position. The spotlight will project light in one of the four ... | 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 {
String ZERO = "0";
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
String[] line = in.readLine().split(" ... | Java | ["2 4\n0 1 0 0\n1 0 1 0", "4 4\n0 0 0 0\n1 0 0 1\n0 1 1 0\n0 1 0 0"] | 1 second | ["9", "20"] | NoteIn the first example the following positions are good: the (1, 1) cell and right direction; the (1, 1) cell and down direction; the (1, 3) cell and left direction; the (1, 3) cell and down direction; the (1, 4) cell and left direction; the (2, 2) cell and left direction; the (2, 2) cell and up direction; th... | Java 8 | standard input | [
"dp",
"implementation"
] | c3a7d82f6c3cf8678a1c7c521e0a5f51 | The first line contains two positive integers n and m (1 ≤ n, m ≤ 1000) — the number of rows and the number of columns in the plan. The next n lines contain m integers, 0 or 1 each — the description of the plan. Integer 1, means there will be an actor in the corresponding cell, while 0 means the cell will remain empty.... | 1,200 | Print one integer — the number of good positions for placing the spotlight. | standard output | |
PASSED | 22eaee72933e011ad3a1bce5c0c3626d | train_003.jsonl | 1479632700 | Theater stage is a rectangular field of size n × m. The director gave you the stage's plan which actors will follow. For each cell it is stated in the plan if there would be an actor in this cell or not.You are to place a spotlight on the stage in some good position. The spotlight will project light in one of the four ... | 256 megabytes |
/*
HARSH KHATRI
DA-IICT
*/
import java.io.*;
import java.util.*;
import java.lang.*;
import java.util.Scanner;
import java.util.Arrays;
public class CF729B {
public static void main(String[] args) {
FasterScanner in = new FasterScanner();
int n = in.nextI... | Java | ["2 4\n0 1 0 0\n1 0 1 0", "4 4\n0 0 0 0\n1 0 0 1\n0 1 1 0\n0 1 0 0"] | 1 second | ["9", "20"] | NoteIn the first example the following positions are good: the (1, 1) cell and right direction; the (1, 1) cell and down direction; the (1, 3) cell and left direction; the (1, 3) cell and down direction; the (1, 4) cell and left direction; the (2, 2) cell and left direction; the (2, 2) cell and up direction; th... | Java 8 | standard input | [
"dp",
"implementation"
] | c3a7d82f6c3cf8678a1c7c521e0a5f51 | The first line contains two positive integers n and m (1 ≤ n, m ≤ 1000) — the number of rows and the number of columns in the plan. The next n lines contain m integers, 0 or 1 each — the description of the plan. Integer 1, means there will be an actor in the corresponding cell, while 0 means the cell will remain empty.... | 1,200 | Print one integer — the number of good positions for placing the spotlight. | standard output | |
PASSED | 8e53072a99907036903f7fc38cade332 | train_003.jsonl | 1479632700 | Theater stage is a rectangular field of size n × m. The director gave you the stage's plan which actors will follow. For each cell it is stated in the plan if there would be an actor in this cell or not.You are to place a spotlight on the stage in some good position. The spotlight will project light in one of the four ... | 256 megabytes |
import java.util.Scanner;
public class Spotlights {
public static void main(String[] args) {
try (Scanner s = new Scanner(System.in)) {
int height = s.nextInt();
int width = s.nextInt();
s.nextLine();
// Store each stage cell and a boolean value representing if an actor occupies
// that cell.
b... | Java | ["2 4\n0 1 0 0\n1 0 1 0", "4 4\n0 0 0 0\n1 0 0 1\n0 1 1 0\n0 1 0 0"] | 1 second | ["9", "20"] | NoteIn the first example the following positions are good: the (1, 1) cell and right direction; the (1, 1) cell and down direction; the (1, 3) cell and left direction; the (1, 3) cell and down direction; the (1, 4) cell and left direction; the (2, 2) cell and left direction; the (2, 2) cell and up direction; th... | Java 8 | standard input | [
"dp",
"implementation"
] | c3a7d82f6c3cf8678a1c7c521e0a5f51 | The first line contains two positive integers n and m (1 ≤ n, m ≤ 1000) — the number of rows and the number of columns in the plan. The next n lines contain m integers, 0 or 1 each — the description of the plan. Integer 1, means there will be an actor in the corresponding cell, while 0 means the cell will remain empty.... | 1,200 | Print one integer — the number of good positions for placing the spotlight. | standard output | |
PASSED | b22512ef75be85d723372968d6cd8be3 | train_003.jsonl | 1479632700 | Theater stage is a rectangular field of size n × m. The director gave you the stage's plan which actors will follow. For each cell it is stated in the plan if there would be an actor in this cell or not.You are to place a spotlight on the stage in some good position. The spotlight will project light in one of the four ... | 256 megabytes | import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class spotlight {
static Scanner w = new Scanner(System.in);
public static void main(String[] args) throws NumberFormatExceptio... | Java | ["2 4\n0 1 0 0\n1 0 1 0", "4 4\n0 0 0 0\n1 0 0 1\n0 1 1 0\n0 1 0 0"] | 1 second | ["9", "20"] | NoteIn the first example the following positions are good: the (1, 1) cell and right direction; the (1, 1) cell and down direction; the (1, 3) cell and left direction; the (1, 3) cell and down direction; the (1, 4) cell and left direction; the (2, 2) cell and left direction; the (2, 2) cell and up direction; th... | Java 8 | standard input | [
"dp",
"implementation"
] | c3a7d82f6c3cf8678a1c7c521e0a5f51 | The first line contains two positive integers n and m (1 ≤ n, m ≤ 1000) — the number of rows and the number of columns in the plan. The next n lines contain m integers, 0 or 1 each — the description of the plan. Integer 1, means there will be an actor in the corresponding cell, while 0 means the cell will remain empty.... | 1,200 | Print one integer — the number of good positions for placing the spotlight. | standard output | |
PASSED | 164fd67a5fdfa08b62f5bf8c9b3c0a57 | train_003.jsonl | 1479632700 | Theater stage is a rectangular field of size n × m. The director gave you the stage's plan which actors will follow. For each cell it is stated in the plan if there would be an actor in this cell or not.You are to place a spotlight on the stage in some good position. The spotlight will project light in one of the four ... | 256 megabytes | import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class Spotlights {
public static void main(String[] args) throws NumberFormatException, IOException {
Scanner sc = new Scann... | Java | ["2 4\n0 1 0 0\n1 0 1 0", "4 4\n0 0 0 0\n1 0 0 1\n0 1 1 0\n0 1 0 0"] | 1 second | ["9", "20"] | NoteIn the first example the following positions are good: the (1, 1) cell and right direction; the (1, 1) cell and down direction; the (1, 3) cell and left direction; the (1, 3) cell and down direction; the (1, 4) cell and left direction; the (2, 2) cell and left direction; the (2, 2) cell and up direction; th... | Java 8 | standard input | [
"dp",
"implementation"
] | c3a7d82f6c3cf8678a1c7c521e0a5f51 | The first line contains two positive integers n and m (1 ≤ n, m ≤ 1000) — the number of rows and the number of columns in the plan. The next n lines contain m integers, 0 or 1 each — the description of the plan. Integer 1, means there will be an actor in the corresponding cell, while 0 means the cell will remain empty.... | 1,200 | Print one integer — the number of good positions for placing the spotlight. | standard output | |
PASSED | 744b6390ac15062623dc06a54dcc4b2f | train_003.jsonl | 1479632700 | Theater stage is a rectangular field of size n × m. The director gave you the stage's plan which actors will follow. For each cell it is stated in the plan if there would be an actor in this cell or not.You are to place a spotlight on the stage in some good position. The spotlight will project light in one of the four ... | 256 megabytes |
import java.lang.*;
import java.util.*;
import java.io.*;
public class pblm2 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
int[][] mat = new int[n+1][m+1];
for(int i=0;i<n;i++)
{
int sum=0;
for(int j=0;j<m;j++)
{... | Java | ["2 4\n0 1 0 0\n1 0 1 0", "4 4\n0 0 0 0\n1 0 0 1\n0 1 1 0\n0 1 0 0"] | 1 second | ["9", "20"] | NoteIn the first example the following positions are good: the (1, 1) cell and right direction; the (1, 1) cell and down direction; the (1, 3) cell and left direction; the (1, 3) cell and down direction; the (1, 4) cell and left direction; the (2, 2) cell and left direction; the (2, 2) cell and up direction; th... | Java 8 | standard input | [
"dp",
"implementation"
] | c3a7d82f6c3cf8678a1c7c521e0a5f51 | The first line contains two positive integers n and m (1 ≤ n, m ≤ 1000) — the number of rows and the number of columns in the plan. The next n lines contain m integers, 0 or 1 each — the description of the plan. Integer 1, means there will be an actor in the corresponding cell, while 0 means the cell will remain empty.... | 1,200 | Print one integer — the number of good positions for placing the spotlight. | standard output | |
PASSED | 89b6f616243593bb82dc5b35b4002524 | train_003.jsonl | 1479632700 | Theater stage is a rectangular field of size n × m. The director gave you the stage's plan which actors will follow. For each cell it is stated in the plan if there would be an actor in this cell or not.You are to place a spotlight on the stage in some good position. The spotlight will project light in one of the four ... | 256 megabytes | import java.io.*;
import java.util.Arrays;
import java.util.Scanner;
import java.util.StringTokenizer;
public class cfs380B2 {
public static void main(String[] args) {
FastScanner sc = new FastScanner();
int N = sc.nextInt();
int M = sc.nextInt();
boolean[][] actors = new boolean[N][M];
int[][] row = new i... | Java | ["2 4\n0 1 0 0\n1 0 1 0", "4 4\n0 0 0 0\n1 0 0 1\n0 1 1 0\n0 1 0 0"] | 1 second | ["9", "20"] | NoteIn the first example the following positions are good: the (1, 1) cell and right direction; the (1, 1) cell and down direction; the (1, 3) cell and left direction; the (1, 3) cell and down direction; the (1, 4) cell and left direction; the (2, 2) cell and left direction; the (2, 2) cell and up direction; th... | Java 8 | standard input | [
"dp",
"implementation"
] | c3a7d82f6c3cf8678a1c7c521e0a5f51 | The first line contains two positive integers n and m (1 ≤ n, m ≤ 1000) — the number of rows and the number of columns in the plan. The next n lines contain m integers, 0 or 1 each — the description of the plan. Integer 1, means there will be an actor in the corresponding cell, while 0 means the cell will remain empty.... | 1,200 | Print one integer — the number of good positions for placing the spotlight. | standard output | |
PASSED | 288032d9a9d18a028d26f638e1085797 | train_003.jsonl | 1479632700 | Theater stage is a rectangular field of size n × m. The director gave you the stage's plan which actors will follow. For each cell it is stated in the plan if there would be an actor in this cell or not.You are to place a spotlight on the stage in some good position. The spotlight will project light in one of the four ... | 256 megabytes | import java.io.*;
import java.util.NoSuchElementException;
public class Main_729B {
private static Scanner sc;
private static Printer pr;
private static void solve() {
int n = sc.nextInt();
int m = sc.nextInt();
int[][] s = new int[n][];
for (int i = 0; i < n; i++) {
s[i] = sc.nextIntArray(m);
}
... | Java | ["2 4\n0 1 0 0\n1 0 1 0", "4 4\n0 0 0 0\n1 0 0 1\n0 1 1 0\n0 1 0 0"] | 1 second | ["9", "20"] | NoteIn the first example the following positions are good: the (1, 1) cell and right direction; the (1, 1) cell and down direction; the (1, 3) cell and left direction; the (1, 3) cell and down direction; the (1, 4) cell and left direction; the (2, 2) cell and left direction; the (2, 2) cell and up direction; th... | Java 8 | standard input | [
"dp",
"implementation"
] | c3a7d82f6c3cf8678a1c7c521e0a5f51 | The first line contains two positive integers n and m (1 ≤ n, m ≤ 1000) — the number of rows and the number of columns in the plan. The next n lines contain m integers, 0 or 1 each — the description of the plan. Integer 1, means there will be an actor in the corresponding cell, while 0 means the cell will remain empty.... | 1,200 | Print one integer — the number of good positions for placing the spotlight. | standard output | |
PASSED | bbea291e16cca225dc36ec3ddfc8abf6 | train_003.jsonl | 1593610500 | A mad scientist Dr.Jubal has made a competitive programming task. Try to solve it!You are given integers $$$n,k$$$. Construct a grid $$$A$$$ with size $$$n \times n$$$ consisting of integers $$$0$$$ and $$$1$$$. The very important condition should be satisfied: the sum of all elements in the grid is exactly $$$k$$$. In... | 256 megabytes | // _________________________RATHOD_____________________________________________________________
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;
import java.math.BigInteger;
import java.util.*;
public class ... | Java | ["4\n2 2\n3 8\n1 0\n4 16"] | 1 second | ["0\n10\n01\n2\n111\n111\n101\n0\n0\n0\n1111\n1111\n1111\n1111"] | NoteIn the first test case, the sum of all elements in the grid is equal to $$$2$$$, so the condition is satisfied. $$$R_1 = 1, R_2 = 1$$$ and $$$C_1 = 1, C_2 = 1$$$. Then, $$$f(A) = (1-1)^2 + (1-1)^2 = 0$$$, which is the minimum possible value of $$$f(A)$$$.In the second test case, the sum of all elements in the grid ... | Java 8 | standard input | [
"constructive algorithms",
"implementation",
"greedy"
] | 0f18382d450be90edf1fd1a3770b232b | The input consists of multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 100$$$) — the number of test cases. Next $$$t$$$ lines contain descriptions of test cases. For each test case the only line contains two integers $$$n$$$, $$$k$$$ $$$(1 \le n \le 300, 0 \le k \le n^2)$$$. It is g... | 1,600 | For each test case, firstly print the minimum possible value of $$$f(A)$$$ among all tables, for which the condition is satisfied. After that, print $$$n$$$ lines contain $$$n$$$ characters each. The $$$j$$$-th character in the $$$i$$$-th line should be equal to $$$A_{i,j}$$$. If there are multiple answers you can prin... | standard output | |
PASSED | 7c29beb477ce68bb7c31df8a02c63153 | train_003.jsonl | 1593610500 | A mad scientist Dr.Jubal has made a competitive programming task. Try to solve it!You are given integers $$$n,k$$$. Construct a grid $$$A$$$ with size $$$n \times n$$$ consisting of integers $$$0$$$ and $$$1$$$. The very important condition should be satisfied: the sum of all elements in the grid is exactly $$$k$$$. In... | 256 megabytes | /***
* ██████╗=====███████╗====███████╗====██████╗=
* ██╔══██╗====██╔════╝====██╔════╝====██╔══██╗
* ██║==██║====█████╗======█████╗======██████╔╝
* ██║==██║====██╔══╝======██╔══╝======██╔═══╝=
* ██████╔╝====███████╗====███████╗====██║=====
* ╚═════╝=====╚══════╝====╚══════╝====╚═╝=====
* ===... | Java | ["4\n2 2\n3 8\n1 0\n4 16"] | 1 second | ["0\n10\n01\n2\n111\n111\n101\n0\n0\n0\n1111\n1111\n1111\n1111"] | NoteIn the first test case, the sum of all elements in the grid is equal to $$$2$$$, so the condition is satisfied. $$$R_1 = 1, R_2 = 1$$$ and $$$C_1 = 1, C_2 = 1$$$. Then, $$$f(A) = (1-1)^2 + (1-1)^2 = 0$$$, which is the minimum possible value of $$$f(A)$$$.In the second test case, the sum of all elements in the grid ... | Java 8 | standard input | [
"constructive algorithms",
"implementation",
"greedy"
] | 0f18382d450be90edf1fd1a3770b232b | The input consists of multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 100$$$) — the number of test cases. Next $$$t$$$ lines contain descriptions of test cases. For each test case the only line contains two integers $$$n$$$, $$$k$$$ $$$(1 \le n \le 300, 0 \le k \le n^2)$$$. It is g... | 1,600 | For each test case, firstly print the minimum possible value of $$$f(A)$$$ among all tables, for which the condition is satisfied. After that, print $$$n$$$ lines contain $$$n$$$ characters each. The $$$j$$$-th character in the $$$i$$$-th line should be equal to $$$A_{i,j}$$$. If there are multiple answers you can prin... | standard output | |
PASSED | fdedbd9b98908d2e660e5ef113938144 | train_003.jsonl | 1593610500 | A mad scientist Dr.Jubal has made a competitive programming task. Try to solve it!You are given integers $$$n,k$$$. Construct a grid $$$A$$$ with size $$$n \times n$$$ consisting of integers $$$0$$$ and $$$1$$$. The very important condition should be satisfied: the sum of all elements in the grid is exactly $$$k$$$. In... | 256 megabytes | import java.util.*;
public class HelloWorld{
public static void main(String []args){
Scanner in=new Scanner(System.in);
int t=in.nextInt();
while(t-->0)
{
int n=in.nextInt();
int k=in.nextInt();
if(n==1)
{
System.out.p... | Java | ["4\n2 2\n3 8\n1 0\n4 16"] | 1 second | ["0\n10\n01\n2\n111\n111\n101\n0\n0\n0\n1111\n1111\n1111\n1111"] | NoteIn the first test case, the sum of all elements in the grid is equal to $$$2$$$, so the condition is satisfied. $$$R_1 = 1, R_2 = 1$$$ and $$$C_1 = 1, C_2 = 1$$$. Then, $$$f(A) = (1-1)^2 + (1-1)^2 = 0$$$, which is the minimum possible value of $$$f(A)$$$.In the second test case, the sum of all elements in the grid ... | Java 8 | standard input | [
"constructive algorithms",
"implementation",
"greedy"
] | 0f18382d450be90edf1fd1a3770b232b | The input consists of multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 100$$$) — the number of test cases. Next $$$t$$$ lines contain descriptions of test cases. For each test case the only line contains two integers $$$n$$$, $$$k$$$ $$$(1 \le n \le 300, 0 \le k \le n^2)$$$. It is g... | 1,600 | For each test case, firstly print the minimum possible value of $$$f(A)$$$ among all tables, for which the condition is satisfied. After that, print $$$n$$$ lines contain $$$n$$$ characters each. The $$$j$$$-th character in the $$$i$$$-th line should be equal to $$$A_{i,j}$$$. If there are multiple answers you can prin... | standard output | |
PASSED | 2a69419693e85aec638b12b5f9ae38b0 | train_003.jsonl | 1593610500 | A mad scientist Dr.Jubal has made a competitive programming task. Try to solve it!You are given integers $$$n,k$$$. Construct a grid $$$A$$$ with size $$$n \times n$$$ consisting of integers $$$0$$$ and $$$1$$$. The very important condition should be satisfied: the sum of all elements in the grid is exactly $$$k$$$. In... | 256 megabytes | import java.util.Scanner;
public class Solution {
public static void mainA(String[] args) {
final Scanner in = new Scanner(System.in);
final int T = in.nextInt();
for (int t = 0; t < T; t += 1) {
final int n = in.nextInt();
int answer;
if ((n & 1) ==... | Java | ["4\n2 2\n3 8\n1 0\n4 16"] | 1 second | ["0\n10\n01\n2\n111\n111\n101\n0\n0\n0\n1111\n1111\n1111\n1111"] | NoteIn the first test case, the sum of all elements in the grid is equal to $$$2$$$, so the condition is satisfied. $$$R_1 = 1, R_2 = 1$$$ and $$$C_1 = 1, C_2 = 1$$$. Then, $$$f(A) = (1-1)^2 + (1-1)^2 = 0$$$, which is the minimum possible value of $$$f(A)$$$.In the second test case, the sum of all elements in the grid ... | Java 8 | standard input | [
"constructive algorithms",
"implementation",
"greedy"
] | 0f18382d450be90edf1fd1a3770b232b | The input consists of multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 100$$$) — the number of test cases. Next $$$t$$$ lines contain descriptions of test cases. For each test case the only line contains two integers $$$n$$$, $$$k$$$ $$$(1 \le n \le 300, 0 \le k \le n^2)$$$. It is g... | 1,600 | For each test case, firstly print the minimum possible value of $$$f(A)$$$ among all tables, for which the condition is satisfied. After that, print $$$n$$$ lines contain $$$n$$$ characters each. The $$$j$$$-th character in the $$$i$$$-th line should be equal to $$$A_{i,j}$$$. If there are multiple answers you can prin... | standard output | |
PASSED | baffc0ff1da31f679514e6c0bc21cbf7 | train_003.jsonl | 1593610500 | A mad scientist Dr.Jubal has made a competitive programming task. Try to solve it!You are given integers $$$n,k$$$. Construct a grid $$$A$$$ with size $$$n \times n$$$ consisting of integers $$$0$$$ and $$$1$$$. The very important condition should be satisfied: the sum of all elements in the grid is exactly $$$k$$$. In... | 256 megabytes |
/*
⣿⣿⣿⣿⣿⣿⡷⣯⢿⣿⣷⣻⢯⣿⡽⣻⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣇⠸⣿⣿⣆⠹⣿⣿⢾⣟⣯⣿⣿⣿⣿⣿⣿⣽⣻⣿⣿⣿⣿⣿⣿⣿
⣿⣿⣿⣿⣿⣿⣻⣽⡿⣿⣎⠙⣿⣞⣷⡌⢻⣟⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⣿⣿⣿⣿⣿⣿⡄⠹⣿⣿⡆⠻⣿⣟⣯⡿⣽⡿⣿⣿⣿⣿⣽⡷⣯⣿⣿⣿⣿⣿⣿
⣿⣿⣿⣿⣿⣿⣟⣷⣿⣿⣿⡀⠹⣟⣾⣟⣆⠹⣯⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⢠⡘⣿⣿⡄⠉⢿⣿⣽⡷⣿⣻⣿⣿⣿⣿⡝⣷⣯⢿⣿⣿⣿⣿
⣿⣿⣿⣿⣿⣿⣯⢿⣾⢿⣿⡄⢄⠘⢿⣞⡿⣧⡈⢷⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⢸⣧⠘⣿⣷⠈⣦⠙⢿⣽⣷⣻⣽⣿⣿⣿⣿⣌⢿⣯⢿⣿⣿⣿
⣿⣿⣿⣿⣿⣿⣟⣯⣿⢿⣿⡆⢸⡷⡈⢻⡽⣷⡷⡄⠻⣽⣿⣿⡿⣿⣿⣿⣿⣿⣿⣷⣿⣿⣿⣿⣏⢰⣯⢷⠈⣿⡆⢹⢷⡌⠻⡾⢋⣱⣯⣿⣿⣿⣿⡆⢻⡿⣿⣿⣿
⣿⣿⣿⣿⣿⣿... | Java | ["4\n2 2\n3 8\n1 0\n4 16"] | 1 second | ["0\n10\n01\n2\n111\n111\n101\n0\n0\n0\n1111\n1111\n1111\n1111"] | NoteIn the first test case, the sum of all elements in the grid is equal to $$$2$$$, so the condition is satisfied. $$$R_1 = 1, R_2 = 1$$$ and $$$C_1 = 1, C_2 = 1$$$. Then, $$$f(A) = (1-1)^2 + (1-1)^2 = 0$$$, which is the minimum possible value of $$$f(A)$$$.In the second test case, the sum of all elements in the grid ... | Java 8 | standard input | [
"constructive algorithms",
"implementation",
"greedy"
] | 0f18382d450be90edf1fd1a3770b232b | The input consists of multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 100$$$) — the number of test cases. Next $$$t$$$ lines contain descriptions of test cases. For each test case the only line contains two integers $$$n$$$, $$$k$$$ $$$(1 \le n \le 300, 0 \le k \le n^2)$$$. It is g... | 1,600 | For each test case, firstly print the minimum possible value of $$$f(A)$$$ among all tables, for which the condition is satisfied. After that, print $$$n$$$ lines contain $$$n$$$ characters each. The $$$j$$$-th character in the $$$i$$$-th line should be equal to $$$A_{i,j}$$$. If there are multiple answers you can prin... | standard output | |
PASSED | 14ae8ed770959161fc7f6b89d195b951 | train_003.jsonl | 1593610500 | A mad scientist Dr.Jubal has made a competitive programming task. Try to solve it!You are given integers $$$n,k$$$. Construct a grid $$$A$$$ with size $$$n \times n$$$ consisting of integers $$$0$$$ and $$$1$$$. The very important condition should be satisfied: the sum of all elements in the grid is exactly $$$k$$$. In... | 256 megabytes | import java.util.*;
import java.lang.*;
import java.io.*;
public class GFG
{
public static void main (String[] args) throws Exception
{
FastScanner sc = new FastScanner(System.in);
PrintWriter out = new PrintWriter(System.out);
int t =sc.nextInt();
while(t-->0){
i... | Java | ["4\n2 2\n3 8\n1 0\n4 16"] | 1 second | ["0\n10\n01\n2\n111\n111\n101\n0\n0\n0\n1111\n1111\n1111\n1111"] | NoteIn the first test case, the sum of all elements in the grid is equal to $$$2$$$, so the condition is satisfied. $$$R_1 = 1, R_2 = 1$$$ and $$$C_1 = 1, C_2 = 1$$$. Then, $$$f(A) = (1-1)^2 + (1-1)^2 = 0$$$, which is the minimum possible value of $$$f(A)$$$.In the second test case, the sum of all elements in the grid ... | Java 8 | standard input | [
"constructive algorithms",
"implementation",
"greedy"
] | 0f18382d450be90edf1fd1a3770b232b | The input consists of multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 100$$$) — the number of test cases. Next $$$t$$$ lines contain descriptions of test cases. For each test case the only line contains two integers $$$n$$$, $$$k$$$ $$$(1 \le n \le 300, 0 \le k \le n^2)$$$. It is g... | 1,600 | For each test case, firstly print the minimum possible value of $$$f(A)$$$ among all tables, for which the condition is satisfied. After that, print $$$n$$$ lines contain $$$n$$$ characters each. The $$$j$$$-th character in the $$$i$$$-th line should be equal to $$$A_{i,j}$$$. If there are multiple answers you can prin... | standard output | |
PASSED | 2e858a2b05b45b897db0ea285ceea32c | train_003.jsonl | 1593610500 | A mad scientist Dr.Jubal has made a competitive programming task. Try to solve it!You are given integers $$$n,k$$$. Construct a grid $$$A$$$ with size $$$n \times n$$$ consisting of integers $$$0$$$ and $$$1$$$. The very important condition should be satisfied: the sum of all elements in the grid is exactly $$$k$$$. In... | 256 megabytes |
import java.io.PrintWriter;
import java.util.Scanner;
/**
* @author hypnos
* @date 2020/11/19
*/
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
PrintWriter writer = new PrintWriter(System.out);
int t = sc.nextInt();
while (t-->... | Java | ["4\n2 2\n3 8\n1 0\n4 16"] | 1 second | ["0\n10\n01\n2\n111\n111\n101\n0\n0\n0\n1111\n1111\n1111\n1111"] | NoteIn the first test case, the sum of all elements in the grid is equal to $$$2$$$, so the condition is satisfied. $$$R_1 = 1, R_2 = 1$$$ and $$$C_1 = 1, C_2 = 1$$$. Then, $$$f(A) = (1-1)^2 + (1-1)^2 = 0$$$, which is the minimum possible value of $$$f(A)$$$.In the second test case, the sum of all elements in the grid ... | Java 8 | standard input | [
"constructive algorithms",
"implementation",
"greedy"
] | 0f18382d450be90edf1fd1a3770b232b | The input consists of multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 100$$$) — the number of test cases. Next $$$t$$$ lines contain descriptions of test cases. For each test case the only line contains two integers $$$n$$$, $$$k$$$ $$$(1 \le n \le 300, 0 \le k \le n^2)$$$. It is g... | 1,600 | For each test case, firstly print the minimum possible value of $$$f(A)$$$ among all tables, for which the condition is satisfied. After that, print $$$n$$$ lines contain $$$n$$$ characters each. The $$$j$$$-th character in the $$$i$$$-th line should be equal to $$$A_{i,j}$$$. If there are multiple answers you can prin... | standard output | |
PASSED | f5621a2956133766a0f68a9d33dbae3d | train_003.jsonl | 1593610500 | A mad scientist Dr.Jubal has made a competitive programming task. Try to solve it!You are given integers $$$n,k$$$. Construct a grid $$$A$$$ with size $$$n \times n$$$ consisting of integers $$$0$$$ and $$$1$$$. The very important condition should be satisfied: the sum of all elements in the grid is exactly $$$k$$$. In... | 256 megabytes | import java.util.Scanner;
public class D {
static Scanner in = new Scanner(System.in);
static int n, m;
static int[][] a;
public static void main(String[] args) {
int t = in.nextInt();
while (t-- > 0) {
n = in.nextInt();
m = in.nextInt();
if (m % n == 0) {
System.out.println(0... | Java | ["4\n2 2\n3 8\n1 0\n4 16"] | 1 second | ["0\n10\n01\n2\n111\n111\n101\n0\n0\n0\n1111\n1111\n1111\n1111"] | NoteIn the first test case, the sum of all elements in the grid is equal to $$$2$$$, so the condition is satisfied. $$$R_1 = 1, R_2 = 1$$$ and $$$C_1 = 1, C_2 = 1$$$. Then, $$$f(A) = (1-1)^2 + (1-1)^2 = 0$$$, which is the minimum possible value of $$$f(A)$$$.In the second test case, the sum of all elements in the grid ... | Java 8 | standard input | [
"constructive algorithms",
"implementation",
"greedy"
] | 0f18382d450be90edf1fd1a3770b232b | The input consists of multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 100$$$) — the number of test cases. Next $$$t$$$ lines contain descriptions of test cases. For each test case the only line contains two integers $$$n$$$, $$$k$$$ $$$(1 \le n \le 300, 0 \le k \le n^2)$$$. It is g... | 1,600 | For each test case, firstly print the minimum possible value of $$$f(A)$$$ among all tables, for which the condition is satisfied. After that, print $$$n$$$ lines contain $$$n$$$ characters each. The $$$j$$$-th character in the $$$i$$$-th line should be equal to $$$A_{i,j}$$$. If there are multiple answers you can prin... | standard output | |
PASSED | e724e4256a5aa28fc03bbd42d1abdf37 | train_003.jsonl | 1593610500 | A mad scientist Dr.Jubal has made a competitive programming task. Try to solve it!You are given integers $$$n,k$$$. Construct a grid $$$A$$$ with size $$$n \times n$$$ consisting of integers $$$0$$$ and $$$1$$$. The very important condition should be satisfied: the sum of all elements in the grid is exactly $$$k$$$. In... | 256 megabytes | import java.io.*;
import java.util.*;
import static java.lang.Math.*;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*/
public class AA {
public static void main(String[] args) throws IOException {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
... | Java | ["4\n2 2\n3 8\n1 0\n4 16"] | 1 second | ["0\n10\n01\n2\n111\n111\n101\n0\n0\n0\n1111\n1111\n1111\n1111"] | NoteIn the first test case, the sum of all elements in the grid is equal to $$$2$$$, so the condition is satisfied. $$$R_1 = 1, R_2 = 1$$$ and $$$C_1 = 1, C_2 = 1$$$. Then, $$$f(A) = (1-1)^2 + (1-1)^2 = 0$$$, which is the minimum possible value of $$$f(A)$$$.In the second test case, the sum of all elements in the grid ... | Java 8 | standard input | [
"constructive algorithms",
"implementation",
"greedy"
] | 0f18382d450be90edf1fd1a3770b232b | The input consists of multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 100$$$) — the number of test cases. Next $$$t$$$ lines contain descriptions of test cases. For each test case the only line contains two integers $$$n$$$, $$$k$$$ $$$(1 \le n \le 300, 0 \le k \le n^2)$$$. It is g... | 1,600 | For each test case, firstly print the minimum possible value of $$$f(A)$$$ among all tables, for which the condition is satisfied. After that, print $$$n$$$ lines contain $$$n$$$ characters each. The $$$j$$$-th character in the $$$i$$$-th line should be equal to $$$A_{i,j}$$$. If there are multiple answers you can prin... | standard output | |
PASSED | b7b6dd8039d68bc77ea241cbc37bd238 | train_003.jsonl | 1593610500 | A mad scientist Dr.Jubal has made a competitive programming task. Try to solve it!You are given integers $$$n,k$$$. Construct a grid $$$A$$$ with size $$$n \times n$$$ consisting of integers $$$0$$$ and $$$1$$$. The very important condition should be satisfied: the sum of all elements in the grid is exactly $$$k$$$. In... | 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 Main
{
public static void main (String[] args) throws java.lang.Exception
{
BufferedReader bf = new BufferedReader(new ... | Java | ["4\n2 2\n3 8\n1 0\n4 16"] | 1 second | ["0\n10\n01\n2\n111\n111\n101\n0\n0\n0\n1111\n1111\n1111\n1111"] | NoteIn the first test case, the sum of all elements in the grid is equal to $$$2$$$, so the condition is satisfied. $$$R_1 = 1, R_2 = 1$$$ and $$$C_1 = 1, C_2 = 1$$$. Then, $$$f(A) = (1-1)^2 + (1-1)^2 = 0$$$, which is the minimum possible value of $$$f(A)$$$.In the second test case, the sum of all elements in the grid ... | Java 8 | standard input | [
"constructive algorithms",
"implementation",
"greedy"
] | 0f18382d450be90edf1fd1a3770b232b | The input consists of multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 100$$$) — the number of test cases. Next $$$t$$$ lines contain descriptions of test cases. For each test case the only line contains two integers $$$n$$$, $$$k$$$ $$$(1 \le n \le 300, 0 \le k \le n^2)$$$. It is g... | 1,600 | For each test case, firstly print the minimum possible value of $$$f(A)$$$ among all tables, for which the condition is satisfied. After that, print $$$n$$$ lines contain $$$n$$$ characters each. The $$$j$$$-th character in the $$$i$$$-th line should be equal to $$$A_{i,j}$$$. If there are multiple answers you can prin... | standard output | |
PASSED | 99a596ee5221f25724cbbae8a8f8479e | train_003.jsonl | 1593610500 | A mad scientist Dr.Jubal has made a competitive programming task. Try to solve it!You are given integers $$$n,k$$$. Construct a grid $$$A$$$ with size $$$n \times n$$$ consisting of integers $$$0$$$ and $$$1$$$. The very important condition should be satisfied: the sum of all elements in the grid is exactly $$$k$$$. In... | 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 Main
{
public static void main (String[] args) throws java.lang.Exception
{
BufferedReader bf = new BufferedReader(new ... | Java | ["4\n2 2\n3 8\n1 0\n4 16"] | 1 second | ["0\n10\n01\n2\n111\n111\n101\n0\n0\n0\n1111\n1111\n1111\n1111"] | NoteIn the first test case, the sum of all elements in the grid is equal to $$$2$$$, so the condition is satisfied. $$$R_1 = 1, R_2 = 1$$$ and $$$C_1 = 1, C_2 = 1$$$. Then, $$$f(A) = (1-1)^2 + (1-1)^2 = 0$$$, which is the minimum possible value of $$$f(A)$$$.In the second test case, the sum of all elements in the grid ... | Java 8 | standard input | [
"constructive algorithms",
"implementation",
"greedy"
] | 0f18382d450be90edf1fd1a3770b232b | The input consists of multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 100$$$) — the number of test cases. Next $$$t$$$ lines contain descriptions of test cases. For each test case the only line contains two integers $$$n$$$, $$$k$$$ $$$(1 \le n \le 300, 0 \le k \le n^2)$$$. It is g... | 1,600 | For each test case, firstly print the minimum possible value of $$$f(A)$$$ among all tables, for which the condition is satisfied. After that, print $$$n$$$ lines contain $$$n$$$ characters each. The $$$j$$$-th character in the $$$i$$$-th line should be equal to $$$A_{i,j}$$$. If there are multiple answers you can prin... | standard output | |
PASSED | eafc526339fd29cc1f846e6365982e78 | train_003.jsonl | 1593610500 | A mad scientist Dr.Jubal has made a competitive programming task. Try to solve it!You are given integers $$$n,k$$$. Construct a grid $$$A$$$ with size $$$n \times n$$$ consisting of integers $$$0$$$ and $$$1$$$. The very important condition should be satisfied: the sum of all elements in the grid is exactly $$$k$$$. In... | 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 Main
{
public static void main (String[] args) throws java.lang.Exception
{
BufferedReader bf = new BufferedReader(new ... | Java | ["4\n2 2\n3 8\n1 0\n4 16"] | 1 second | ["0\n10\n01\n2\n111\n111\n101\n0\n0\n0\n1111\n1111\n1111\n1111"] | NoteIn the first test case, the sum of all elements in the grid is equal to $$$2$$$, so the condition is satisfied. $$$R_1 = 1, R_2 = 1$$$ and $$$C_1 = 1, C_2 = 1$$$. Then, $$$f(A) = (1-1)^2 + (1-1)^2 = 0$$$, which is the minimum possible value of $$$f(A)$$$.In the second test case, the sum of all elements in the grid ... | Java 8 | standard input | [
"constructive algorithms",
"implementation",
"greedy"
] | 0f18382d450be90edf1fd1a3770b232b | The input consists of multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 100$$$) — the number of test cases. Next $$$t$$$ lines contain descriptions of test cases. For each test case the only line contains two integers $$$n$$$, $$$k$$$ $$$(1 \le n \le 300, 0 \le k \le n^2)$$$. It is g... | 1,600 | For each test case, firstly print the minimum possible value of $$$f(A)$$$ among all tables, for which the condition is satisfied. After that, print $$$n$$$ lines contain $$$n$$$ characters each. The $$$j$$$-th character in the $$$i$$$-th line should be equal to $$$A_{i,j}$$$. If there are multiple answers you can prin... | standard output | |
PASSED | 76d280064fd2f3032cb97b632f6071e7 | train_003.jsonl | 1593610500 | A mad scientist Dr.Jubal has made a competitive programming task. Try to solve it!You are given integers $$$n,k$$$. Construct a grid $$$A$$$ with size $$$n \times n$$$ consisting of integers $$$0$$$ and $$$1$$$. The very important condition should be satisfied: the sum of all elements in the grid is exactly $$$k$$$. In... | 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 Main
{
public static void main (String[] args) throws java.lang.Exception
{
// your code goes here
FastScanner sc=new ... | Java | ["4\n2 2\n3 8\n1 0\n4 16"] | 1 second | ["0\n10\n01\n2\n111\n111\n101\n0\n0\n0\n1111\n1111\n1111\n1111"] | NoteIn the first test case, the sum of all elements in the grid is equal to $$$2$$$, so the condition is satisfied. $$$R_1 = 1, R_2 = 1$$$ and $$$C_1 = 1, C_2 = 1$$$. Then, $$$f(A) = (1-1)^2 + (1-1)^2 = 0$$$, which is the minimum possible value of $$$f(A)$$$.In the second test case, the sum of all elements in the grid ... | Java 8 | standard input | [
"constructive algorithms",
"implementation",
"greedy"
] | 0f18382d450be90edf1fd1a3770b232b | The input consists of multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 100$$$) — the number of test cases. Next $$$t$$$ lines contain descriptions of test cases. For each test case the only line contains two integers $$$n$$$, $$$k$$$ $$$(1 \le n \le 300, 0 \le k \le n^2)$$$. It is g... | 1,600 | For each test case, firstly print the minimum possible value of $$$f(A)$$$ among all tables, for which the condition is satisfied. After that, print $$$n$$$ lines contain $$$n$$$ characters each. The $$$j$$$-th character in the $$$i$$$-th line should be equal to $$$A_{i,j}$$$. If there are multiple answers you can prin... | standard output | |
PASSED | 9bc3d3c24bbf814c8f5ec6a2a36b3642 | train_003.jsonl | 1593610500 | A mad scientist Dr.Jubal has made a competitive programming task. Try to solve it!You are given integers $$$n,k$$$. Construct a grid $$$A$$$ with size $$$n \times n$$$ consisting of integers $$$0$$$ and $$$1$$$. The very important condition should be satisfied: the sum of all elements in the grid is exactly $$$k$$$. In... | 256 megabytes | import java.util.*;
public class grid
{
public static void main(final String args[]) {
final Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
int n, k;
double num1, num2;
/*
* 1 3 6
*/
while (t > 0) {
--t;
n = sc.nex... | Java | ["4\n2 2\n3 8\n1 0\n4 16"] | 1 second | ["0\n10\n01\n2\n111\n111\n101\n0\n0\n0\n1111\n1111\n1111\n1111"] | NoteIn the first test case, the sum of all elements in the grid is equal to $$$2$$$, so the condition is satisfied. $$$R_1 = 1, R_2 = 1$$$ and $$$C_1 = 1, C_2 = 1$$$. Then, $$$f(A) = (1-1)^2 + (1-1)^2 = 0$$$, which is the minimum possible value of $$$f(A)$$$.In the second test case, the sum of all elements in the grid ... | Java 8 | standard input | [
"constructive algorithms",
"implementation",
"greedy"
] | 0f18382d450be90edf1fd1a3770b232b | The input consists of multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 100$$$) — the number of test cases. Next $$$t$$$ lines contain descriptions of test cases. For each test case the only line contains two integers $$$n$$$, $$$k$$$ $$$(1 \le n \le 300, 0 \le k \le n^2)$$$. It is g... | 1,600 | For each test case, firstly print the minimum possible value of $$$f(A)$$$ among all tables, for which the condition is satisfied. After that, print $$$n$$$ lines contain $$$n$$$ characters each. The $$$j$$$-th character in the $$$i$$$-th line should be equal to $$$A_{i,j}$$$. If there are multiple answers you can prin... | standard output | |
PASSED | ee9865daa75b54bb9fb5b344f0b951cc | train_003.jsonl | 1593610500 | A mad scientist Dr.Jubal has made a competitive programming task. Try to solve it!You are given integers $$$n,k$$$. Construct a grid $$$A$$$ with size $$$n \times n$$$ consisting of integers $$$0$$$ and $$$1$$$. The very important condition should be satisfied: the sum of all elements in the grid is exactly $$$k$$$. In... | 256 megabytes | import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.StringTokenizer;
public class Juwon {
static int N, K, arr[][];
public static void main(String args0[]) throws IOException {
BufferedReade... | Java | ["4\n2 2\n3 8\n1 0\n4 16"] | 1 second | ["0\n10\n01\n2\n111\n111\n101\n0\n0\n0\n1111\n1111\n1111\n1111"] | NoteIn the first test case, the sum of all elements in the grid is equal to $$$2$$$, so the condition is satisfied. $$$R_1 = 1, R_2 = 1$$$ and $$$C_1 = 1, C_2 = 1$$$. Then, $$$f(A) = (1-1)^2 + (1-1)^2 = 0$$$, which is the minimum possible value of $$$f(A)$$$.In the second test case, the sum of all elements in the grid ... | Java 8 | standard input | [
"constructive algorithms",
"implementation",
"greedy"
] | 0f18382d450be90edf1fd1a3770b232b | The input consists of multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 100$$$) — the number of test cases. Next $$$t$$$ lines contain descriptions of test cases. For each test case the only line contains two integers $$$n$$$, $$$k$$$ $$$(1 \le n \le 300, 0 \le k \le n^2)$$$. It is g... | 1,600 | For each test case, firstly print the minimum possible value of $$$f(A)$$$ among all tables, for which the condition is satisfied. After that, print $$$n$$$ lines contain $$$n$$$ characters each. The $$$j$$$-th character in the $$$i$$$-th line should be equal to $$$A_{i,j}$$$. If there are multiple answers you can prin... | standard output | |
PASSED | 831dc46c5640f4b708956e52197a2958 | train_003.jsonl | 1593610500 | A mad scientist Dr.Jubal has made a competitive programming task. Try to solve it!You are given integers $$$n,k$$$. Construct a grid $$$A$$$ with size $$$n \times n$$$ consisting of integers $$$0$$$ and $$$1$$$. The very important condition should be satisfied: the sum of all elements in the grid is exactly $$$k$$$. In... | 256 megabytes | import java.io.*;
import java.util.*;
public class D
{
static Scanner scan = new Scanner(System.in);
public static void solve() throws Exception
{
//BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
//StringTokenizer tk = new StringTokenizer(in.readLine());
int n = scan.nextInt();
... | Java | ["4\n2 2\n3 8\n1 0\n4 16"] | 1 second | ["0\n10\n01\n2\n111\n111\n101\n0\n0\n0\n1111\n1111\n1111\n1111"] | NoteIn the first test case, the sum of all elements in the grid is equal to $$$2$$$, so the condition is satisfied. $$$R_1 = 1, R_2 = 1$$$ and $$$C_1 = 1, C_2 = 1$$$. Then, $$$f(A) = (1-1)^2 + (1-1)^2 = 0$$$, which is the minimum possible value of $$$f(A)$$$.In the second test case, the sum of all elements in the grid ... | Java 8 | standard input | [
"constructive algorithms",
"implementation",
"greedy"
] | 0f18382d450be90edf1fd1a3770b232b | The input consists of multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 100$$$) — the number of test cases. Next $$$t$$$ lines contain descriptions of test cases. For each test case the only line contains two integers $$$n$$$, $$$k$$$ $$$(1 \le n \le 300, 0 \le k \le n^2)$$$. It is g... | 1,600 | For each test case, firstly print the minimum possible value of $$$f(A)$$$ among all tables, for which the condition is satisfied. After that, print $$$n$$$ lines contain $$$n$$$ characters each. The $$$j$$$-th character in the $$$i$$$-th line should be equal to $$$A_{i,j}$$$. If there are multiple answers you can prin... | standard output | |
PASSED | 0cf36fdda7173ea4542a09c2d6a93791 | train_003.jsonl | 1593610500 | A mad scientist Dr.Jubal has made a competitive programming task. Try to solve it!You are given integers $$$n,k$$$. Construct a grid $$$A$$$ with size $$$n \times n$$$ consisting of integers $$$0$$$ and $$$1$$$. The very important condition should be satisfied: the sum of all elements in the grid is exactly $$$k$$$. In... | 256 megabytes | import java.util.*;
import java.io.*;
import java.math.*;
public class D654{
public static void main(String args[]){
FastReader sc = new FastReader();
StringBuilder sb=new StringBuilder();
int t,i,n,j,k;
t=sc.nextInt();
while(t-->0){
n=sc.nextInt();
k=sc.nextInt();
if... | Java | ["4\n2 2\n3 8\n1 0\n4 16"] | 1 second | ["0\n10\n01\n2\n111\n111\n101\n0\n0\n0\n1111\n1111\n1111\n1111"] | NoteIn the first test case, the sum of all elements in the grid is equal to $$$2$$$, so the condition is satisfied. $$$R_1 = 1, R_2 = 1$$$ and $$$C_1 = 1, C_2 = 1$$$. Then, $$$f(A) = (1-1)^2 + (1-1)^2 = 0$$$, which is the minimum possible value of $$$f(A)$$$.In the second test case, the sum of all elements in the grid ... | Java 8 | standard input | [
"constructive algorithms",
"implementation",
"greedy"
] | 0f18382d450be90edf1fd1a3770b232b | The input consists of multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 100$$$) — the number of test cases. Next $$$t$$$ lines contain descriptions of test cases. For each test case the only line contains two integers $$$n$$$, $$$k$$$ $$$(1 \le n \le 300, 0 \le k \le n^2)$$$. It is g... | 1,600 | For each test case, firstly print the minimum possible value of $$$f(A)$$$ among all tables, for which the condition is satisfied. After that, print $$$n$$$ lines contain $$$n$$$ characters each. The $$$j$$$-th character in the $$$i$$$-th line should be equal to $$$A_{i,j}$$$. If there are multiple answers you can prin... | standard output | |
PASSED | 646f07089f6816404d6bc977241b08c6 | train_003.jsonl | 1593610500 | A mad scientist Dr.Jubal has made a competitive programming task. Try to solve it!You are given integers $$$n,k$$$. Construct a grid $$$A$$$ with size $$$n \times n$$$ consisting of integers $$$0$$$ and $$$1$$$. The very important condition should be satisfied: the sum of all elements in the grid is exactly $$$k$$$. In... | 256 megabytes |
import java.io.*;
import java.util.*;
import java.lang.*;
public class GridzeroOne{
public static class FastReader {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
private SpaceCharFilter filter;
public Fa... | Java | ["4\n2 2\n3 8\n1 0\n4 16"] | 1 second | ["0\n10\n01\n2\n111\n111\n101\n0\n0\n0\n1111\n1111\n1111\n1111"] | NoteIn the first test case, the sum of all elements in the grid is equal to $$$2$$$, so the condition is satisfied. $$$R_1 = 1, R_2 = 1$$$ and $$$C_1 = 1, C_2 = 1$$$. Then, $$$f(A) = (1-1)^2 + (1-1)^2 = 0$$$, which is the minimum possible value of $$$f(A)$$$.In the second test case, the sum of all elements in the grid ... | Java 8 | standard input | [
"constructive algorithms",
"implementation",
"greedy"
] | 0f18382d450be90edf1fd1a3770b232b | The input consists of multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 100$$$) — the number of test cases. Next $$$t$$$ lines contain descriptions of test cases. For each test case the only line contains two integers $$$n$$$, $$$k$$$ $$$(1 \le n \le 300, 0 \le k \le n^2)$$$. It is g... | 1,600 | For each test case, firstly print the minimum possible value of $$$f(A)$$$ among all tables, for which the condition is satisfied. After that, print $$$n$$$ lines contain $$$n$$$ characters each. The $$$j$$$-th character in the $$$i$$$-th line should be equal to $$$A_{i,j}$$$. If there are multiple answers you can prin... | standard output | |
PASSED | c16d8e8cbf0bf7ef2c462443c19e62fd | train_003.jsonl | 1593610500 | A mad scientist Dr.Jubal has made a competitive programming task. Try to solve it!You are given integers $$$n,k$$$. Construct a grid $$$A$$$ with size $$$n \times n$$$ consisting of integers $$$0$$$ and $$$1$$$. The very important condition should be satisfied: the sum of all elements in the grid is exactly $$$k$$$. In... | 256 megabytes | import java.io.*;
import java.util.*;
import java.util.concurrent.TimeUnit;
public class d654 implements Runnable{
public static void main(String[] args) {
try{
new Thread(null, new d654(), "process", 1<<26).start();
}
catch(Exception e){
System.out.println(e);
... | Java | ["4\n2 2\n3 8\n1 0\n4 16"] | 1 second | ["0\n10\n01\n2\n111\n111\n101\n0\n0\n0\n1111\n1111\n1111\n1111"] | NoteIn the first test case, the sum of all elements in the grid is equal to $$$2$$$, so the condition is satisfied. $$$R_1 = 1, R_2 = 1$$$ and $$$C_1 = 1, C_2 = 1$$$. Then, $$$f(A) = (1-1)^2 + (1-1)^2 = 0$$$, which is the minimum possible value of $$$f(A)$$$.In the second test case, the sum of all elements in the grid ... | Java 8 | standard input | [
"constructive algorithms",
"implementation",
"greedy"
] | 0f18382d450be90edf1fd1a3770b232b | The input consists of multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 100$$$) — the number of test cases. Next $$$t$$$ lines contain descriptions of test cases. For each test case the only line contains two integers $$$n$$$, $$$k$$$ $$$(1 \le n \le 300, 0 \le k \le n^2)$$$. It is g... | 1,600 | For each test case, firstly print the minimum possible value of $$$f(A)$$$ among all tables, for which the condition is satisfied. After that, print $$$n$$$ lines contain $$$n$$$ characters each. The $$$j$$$-th character in the $$$i$$$-th line should be equal to $$$A_{i,j}$$$. If there are multiple answers you can prin... | standard output | |
PASSED | 0a5a9d04039b0daff6de5abe90fb9551 | train_003.jsonl | 1593610500 | A mad scientist Dr.Jubal has made a competitive programming task. Try to solve it!You are given integers $$$n,k$$$. Construct a grid $$$A$$$ with size $$$n \times n$$$ consisting of integers $$$0$$$ and $$$1$$$. The very important condition should be satisfied: the sum of all elements in the grid is exactly $$$k$$$. In... | 256 megabytes | import java.io.*;
import java.util.*;
public class Grid00100 {
/*static int Bs(int sum[], int n, int i) {
int low = 0, mid , high = 2*(n-1);
while(low<=high) {
mid = (low+high)/2;
if(sum[mid]==i&&mid%2==0) {
resLow = mid;return -1;
}
else if(sum[mid]<i)
low = mid+1;
else
high = mid-1... | Java | ["4\n2 2\n3 8\n1 0\n4 16"] | 1 second | ["0\n10\n01\n2\n111\n111\n101\n0\n0\n0\n1111\n1111\n1111\n1111"] | NoteIn the first test case, the sum of all elements in the grid is equal to $$$2$$$, so the condition is satisfied. $$$R_1 = 1, R_2 = 1$$$ and $$$C_1 = 1, C_2 = 1$$$. Then, $$$f(A) = (1-1)^2 + (1-1)^2 = 0$$$, which is the minimum possible value of $$$f(A)$$$.In the second test case, the sum of all elements in the grid ... | Java 8 | standard input | [
"constructive algorithms",
"implementation",
"greedy"
] | 0f18382d450be90edf1fd1a3770b232b | The input consists of multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 100$$$) — the number of test cases. Next $$$t$$$ lines contain descriptions of test cases. For each test case the only line contains two integers $$$n$$$, $$$k$$$ $$$(1 \le n \le 300, 0 \le k \le n^2)$$$. It is g... | 1,600 | For each test case, firstly print the minimum possible value of $$$f(A)$$$ among all tables, for which the condition is satisfied. After that, print $$$n$$$ lines contain $$$n$$$ characters each. The $$$j$$$-th character in the $$$i$$$-th line should be equal to $$$A_{i,j}$$$. If there are multiple answers you can prin... | standard output |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.