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 | 58b57e1f23e68298c8d008daf5e865eb | train_002.jsonl | 1590935700 | This is an interactive problem.Ayush devised a new scheme to set the password of his lock. The lock has $$$k$$$ slots where each slot can hold integers from $$$1$$$ to $$$n$$$. The password $$$P$$$ is a sequence of $$$k$$$ integers each in the range $$$[1, n]$$$, $$$i$$$-th element of which goes into the $$$i$$$-th slo... | 256 megabytes | import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int N=s.nextInt();
for(int i=0;i<N;i++){
System.out.println(help(s));
s.nextLine();
String ans=s.nextLine();
}
}
static bo... | Java | ["1\n4 2\n2 1 3\n2 2 4\n\n1\n\n2\n\n3\n\n4\n\nCorrect"] | 2 seconds | ["? 1 1\n\n? 1 2\n\n? 1 3\n\n? 1 4\n\n! 4 3"] | NoteThe array $$$A$$$ in the example is $$$[1, 2, 3, 4]$$$. The length of the password is $$$2$$$. The first element of the password is the maximum of $$$A[2]$$$, $$$A[4]$$$ (since the first subset contains indices $$$1$$$ and $$$3$$$, we take maximum over remaining indices). The second element of the password is the m... | Java 11 | standard input | [
"math",
"binary search",
"implementation",
"interactive"
] | b0bce8524eb69b695edc1394ff86b913 | The first line of the input contains a single integer $$$t$$$ $$$(1 \leq t \leq 10)$$$ — the number of test cases. The description of the test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$k$$$ $$$(2 \leq n \leq 1000, 1 \leq k \leq n)$$$ — the size of the array and the number of s... | 2,100 | null | standard output | |
PASSED | b47c9a2d9b5398811685e6d4272b5cfb | train_002.jsonl | 1590935700 | This is an interactive problem.Ayush devised a new scheme to set the password of his lock. The lock has $$$k$$$ slots where each slot can hold integers from $$$1$$$ to $$$n$$$. The password $$$P$$$ is a sequence of $$$k$$$ integers each in the range $$$[1, n]$$$, $$$i$$$-th element of which goes into the $$$i$$$-th slo... | 256 megabytes | /**
*
* @author tstulemeijer
*/
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Li... | Java | ["1\n4 2\n2 1 3\n2 2 4\n\n1\n\n2\n\n3\n\n4\n\nCorrect"] | 2 seconds | ["? 1 1\n\n? 1 2\n\n? 1 3\n\n? 1 4\n\n! 4 3"] | NoteThe array $$$A$$$ in the example is $$$[1, 2, 3, 4]$$$. The length of the password is $$$2$$$. The first element of the password is the maximum of $$$A[2]$$$, $$$A[4]$$$ (since the first subset contains indices $$$1$$$ and $$$3$$$, we take maximum over remaining indices). The second element of the password is the m... | Java 11 | standard input | [
"math",
"binary search",
"implementation",
"interactive"
] | b0bce8524eb69b695edc1394ff86b913 | The first line of the input contains a single integer $$$t$$$ $$$(1 \leq t \leq 10)$$$ — the number of test cases. The description of the test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$k$$$ $$$(2 \leq n \leq 1000, 1 \leq k \leq n)$$$ — the size of the array and the number of s... | 2,100 | null | standard output | |
PASSED | 0fdabd2968457ac7afc38b7c30b3b0c2 | train_002.jsonl | 1590935700 | This is an interactive problem.Ayush devised a new scheme to set the password of his lock. The lock has $$$k$$$ slots where each slot can hold integers from $$$1$$$ to $$$n$$$. The password $$$P$$$ is a sequence of $$$k$$$ integers each in the range $$$[1, n]$$$, $$$i$$$-th element of which goes into the $$$i$$$-th slo... | 256 megabytes | import java.math.*;
import java.io.*;
import java.util.*;
import java.awt.*;
public class Main implements Runnable {
@Override
public void run() {
try {
new Solver().solve();
System.exit(0);
} catch (Exception | Error e) {
e.printStackTrace();
Sys... | Java | ["1\n4 2\n2 1 3\n2 2 4\n\n1\n\n2\n\n3\n\n4\n\nCorrect"] | 2 seconds | ["? 1 1\n\n? 1 2\n\n? 1 3\n\n? 1 4\n\n! 4 3"] | NoteThe array $$$A$$$ in the example is $$$[1, 2, 3, 4]$$$. The length of the password is $$$2$$$. The first element of the password is the maximum of $$$A[2]$$$, $$$A[4]$$$ (since the first subset contains indices $$$1$$$ and $$$3$$$, we take maximum over remaining indices). The second element of the password is the m... | Java 11 | standard input | [
"math",
"binary search",
"implementation",
"interactive"
] | b0bce8524eb69b695edc1394ff86b913 | The first line of the input contains a single integer $$$t$$$ $$$(1 \leq t \leq 10)$$$ — the number of test cases. The description of the test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$k$$$ $$$(2 \leq n \leq 1000, 1 \leq k \leq n)$$$ — the size of the array and the number of s... | 2,100 | null | standard output | |
PASSED | 4c9433c07bad98d142bcab6ffe4dde61 | train_002.jsonl | 1590935700 | This is an interactive problem.Ayush devised a new scheme to set the password of his lock. The lock has $$$k$$$ slots where each slot can hold integers from $$$1$$$ to $$$n$$$. The password $$$P$$$ is a sequence of $$$k$$$ integers each in the range $$$[1, n]$$$, $$$i$$$-th element of which goes into the $$$i$$$-th slo... | 256 megabytes | import java.math.*;
import java.io.*;
import java.util.*;
import java.awt.*;
public class Main implements Runnable {
@Override
public void run() {
try {
new Solver().solve();
System.exit(0);
} catch (Exception | Error e) {
e.printStackTrace();
Sys... | Java | ["1\n4 2\n2 1 3\n2 2 4\n\n1\n\n2\n\n3\n\n4\n\nCorrect"] | 2 seconds | ["? 1 1\n\n? 1 2\n\n? 1 3\n\n? 1 4\n\n! 4 3"] | NoteThe array $$$A$$$ in the example is $$$[1, 2, 3, 4]$$$. The length of the password is $$$2$$$. The first element of the password is the maximum of $$$A[2]$$$, $$$A[4]$$$ (since the first subset contains indices $$$1$$$ and $$$3$$$, we take maximum over remaining indices). The second element of the password is the m... | Java 11 | standard input | [
"math",
"binary search",
"implementation",
"interactive"
] | b0bce8524eb69b695edc1394ff86b913 | The first line of the input contains a single integer $$$t$$$ $$$(1 \leq t \leq 10)$$$ — the number of test cases. The description of the test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$k$$$ $$$(2 \leq n \leq 1000, 1 \leq k \leq n)$$$ — the size of the array and the number of s... | 2,100 | null | standard output | |
PASSED | 860e8fac8841423f14bc17bcf4955a60 | train_002.jsonl | 1590935700 | This is an interactive problem.Ayush devised a new scheme to set the password of his lock. The lock has $$$k$$$ slots where each slot can hold integers from $$$1$$$ to $$$n$$$. The password $$$P$$$ is a sequence of $$$k$$$ integers each in the range $$$[1, n]$$$, $$$i$$$-th element of which goes into the $$$i$$$-th slo... | 256 megabytes | import java.io.*;
import java.util.*;
public class CF1363D extends PrintWriter {
CF1363D() { super(System.out, true); }
Scanner sc = new Scanner(System.in);
public static void main(String[] $) {
CF1363D o = new CF1363D(); o.main(); o.flush();
}
int[] cc;
int[][] ii;
int query(int l, int r) {
int c = 0;
f... | Java | ["1\n4 2\n2 1 3\n2 2 4\n\n1\n\n2\n\n3\n\n4\n\nCorrect"] | 2 seconds | ["? 1 1\n\n? 1 2\n\n? 1 3\n\n? 1 4\n\n! 4 3"] | NoteThe array $$$A$$$ in the example is $$$[1, 2, 3, 4]$$$. The length of the password is $$$2$$$. The first element of the password is the maximum of $$$A[2]$$$, $$$A[4]$$$ (since the first subset contains indices $$$1$$$ and $$$3$$$, we take maximum over remaining indices). The second element of the password is the m... | Java 11 | standard input | [
"math",
"binary search",
"implementation",
"interactive"
] | b0bce8524eb69b695edc1394ff86b913 | The first line of the input contains a single integer $$$t$$$ $$$(1 \leq t \leq 10)$$$ — the number of test cases. The description of the test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$k$$$ $$$(2 \leq n \leq 1000, 1 \leq k \leq n)$$$ — the size of the array and the number of s... | 2,100 | null | standard output | |
PASSED | 44644c004d27c28f1e2edb20eb1c83a1 | train_002.jsonl | 1590935700 | This is an interactive problem.Ayush devised a new scheme to set the password of his lock. The lock has $$$k$$$ slots where each slot can hold integers from $$$1$$$ to $$$n$$$. The password $$$P$$$ is a sequence of $$$k$$$ integers each in the range $$$[1, n]$$$, $$$i$$$-th element of which goes into the $$$i$$$-th slo... | 256 megabytes | import java.io.*;
import java.math.*;
import java.security.*;
import java.text.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.function.*;
import java.util.regex.*;
import java.util.stream.*;
import static java.util.stream.Collectors.joining;
import static java.util.stream.Collectors.toList;
publ... | Java | ["1\n4 2\n2 1 3\n2 2 4\n\n1\n\n2\n\n3\n\n4\n\nCorrect"] | 2 seconds | ["? 1 1\n\n? 1 2\n\n? 1 3\n\n? 1 4\n\n! 4 3"] | NoteThe array $$$A$$$ in the example is $$$[1, 2, 3, 4]$$$. The length of the password is $$$2$$$. The first element of the password is the maximum of $$$A[2]$$$, $$$A[4]$$$ (since the first subset contains indices $$$1$$$ and $$$3$$$, we take maximum over remaining indices). The second element of the password is the m... | Java 11 | standard input | [
"math",
"binary search",
"implementation",
"interactive"
] | b0bce8524eb69b695edc1394ff86b913 | The first line of the input contains a single integer $$$t$$$ $$$(1 \leq t \leq 10)$$$ — the number of test cases. The description of the test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$k$$$ $$$(2 \leq n \leq 1000, 1 \leq k \leq n)$$$ — the size of the array and the number of s... | 2,100 | null | standard output | |
PASSED | fdfd3f83856579bd498152a67fa40dd0 | train_002.jsonl | 1590935700 | This is an interactive problem.Ayush devised a new scheme to set the password of his lock. The lock has $$$k$$$ slots where each slot can hold integers from $$$1$$$ to $$$n$$$. The password $$$P$$$ is a sequence of $$$k$$$ integers each in the range $$$[1, n]$$$, $$$i$$$-th element of which goes into the $$$i$$$-th slo... | 256 megabytes | import java.io.*;
import java.util.*;
public class Main{
static void print(int[]arr) {
pw.print("? "+arr.length);
for(int i:arr)pw.print(" "+i);
pw.println();
pw.flush();
}
static void print(LinkedList<Integer>arr) {
pw.print("? "+arr.size());
for(int i:arr)pw.print(" "+i);
pw.println();
pw.flush();... | Java | ["1\n4 2\n2 1 3\n2 2 4\n\n1\n\n2\n\n3\n\n4\n\nCorrect"] | 2 seconds | ["? 1 1\n\n? 1 2\n\n? 1 3\n\n? 1 4\n\n! 4 3"] | NoteThe array $$$A$$$ in the example is $$$[1, 2, 3, 4]$$$. The length of the password is $$$2$$$. The first element of the password is the maximum of $$$A[2]$$$, $$$A[4]$$$ (since the first subset contains indices $$$1$$$ and $$$3$$$, we take maximum over remaining indices). The second element of the password is the m... | Java 11 | standard input | [
"math",
"binary search",
"implementation",
"interactive"
] | b0bce8524eb69b695edc1394ff86b913 | The first line of the input contains a single integer $$$t$$$ $$$(1 \leq t \leq 10)$$$ — the number of test cases. The description of the test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$k$$$ $$$(2 \leq n \leq 1000, 1 \leq k \leq n)$$$ — the size of the array and the number of s... | 2,100 | null | standard output | |
PASSED | 88dde7c20b3f03bad8c25be6d8de9ecc | train_002.jsonl | 1590935700 | This is an interactive problem.Ayush devised a new scheme to set the password of his lock. The lock has $$$k$$$ slots where each slot can hold integers from $$$1$$$ to $$$n$$$. The password $$$P$$$ is a sequence of $$$k$$$ integers each in the range $$$[1, n]$$$, $$$i$$$-th element of which goes into the $$$i$$$-th slo... | 256 megabytes | import java.io.IOException;
import java.io.InputStream;
import java.util.*;
public class Main {
static int max;
static FastReader in;
static boolean ispresent(int l,int r)throws IOException{
StringBuilder sb=new StringBuilder();
sb.append("? ");
sb.append(r-l+1).append(" ");
... | Java | ["1\n4 2\n2 1 3\n2 2 4\n\n1\n\n2\n\n3\n\n4\n\nCorrect"] | 2 seconds | ["? 1 1\n\n? 1 2\n\n? 1 3\n\n? 1 4\n\n! 4 3"] | NoteThe array $$$A$$$ in the example is $$$[1, 2, 3, 4]$$$. The length of the password is $$$2$$$. The first element of the password is the maximum of $$$A[2]$$$, $$$A[4]$$$ (since the first subset contains indices $$$1$$$ and $$$3$$$, we take maximum over remaining indices). The second element of the password is the m... | Java 11 | standard input | [
"math",
"binary search",
"implementation",
"interactive"
] | b0bce8524eb69b695edc1394ff86b913 | The first line of the input contains a single integer $$$t$$$ $$$(1 \leq t \leq 10)$$$ — the number of test cases. The description of the test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$k$$$ $$$(2 \leq n \leq 1000, 1 \leq k \leq n)$$$ — the size of the array and the number of s... | 2,100 | null | standard output | |
PASSED | 75aeb99fb3d3d2ba3b493fea4909c993 | train_002.jsonl | 1590935700 | This is an interactive problem.Ayush devised a new scheme to set the password of his lock. The lock has $$$k$$$ slots where each slot can hold integers from $$$1$$$ to $$$n$$$. The password $$$P$$$ is a sequence of $$$k$$$ integers each in the range $$$[1, n]$$$, $$$i$$$-th element of which goes into the $$$i$$$-th slo... | 256 megabytes |
/**
* @author egaeus
* @mail sebegaeusprogram@gmail.com
* @veredict Not sended
* @url <https://codeforces.com/problemset/problem/>
* @category ?
* @date 2/06/2020
**/
import java.io.*;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import static java.lang.Integer.*;... | Java | ["1\n4 2\n2 1 3\n2 2 4\n\n1\n\n2\n\n3\n\n4\n\nCorrect"] | 2 seconds | ["? 1 1\n\n? 1 2\n\n? 1 3\n\n? 1 4\n\n! 4 3"] | NoteThe array $$$A$$$ in the example is $$$[1, 2, 3, 4]$$$. The length of the password is $$$2$$$. The first element of the password is the maximum of $$$A[2]$$$, $$$A[4]$$$ (since the first subset contains indices $$$1$$$ and $$$3$$$, we take maximum over remaining indices). The second element of the password is the m... | Java 11 | standard input | [
"math",
"binary search",
"implementation",
"interactive"
] | b0bce8524eb69b695edc1394ff86b913 | The first line of the input contains a single integer $$$t$$$ $$$(1 \leq t \leq 10)$$$ — the number of test cases. The description of the test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$k$$$ $$$(2 \leq n \leq 1000, 1 \leq k \leq n)$$$ — the size of the array and the number of s... | 2,100 | null | standard output | |
PASSED | a792ffc96a961c6f17faaff04609a696 | train_002.jsonl | 1590935700 | This is an interactive problem.Ayush devised a new scheme to set the password of his lock. The lock has $$$k$$$ slots where each slot can hold integers from $$$1$$$ to $$$n$$$. The password $$$P$$$ is a sequence of $$$k$$$ integers each in the range $$$[1, n]$$$, $$$i$$$-th element of which goes into the $$$i$$$-th slo... | 256 megabytes | import java.io.*;
import java.util.*;
public class F {
static Scanner sc = new Scanner();
static int[] a;
static int query(ArrayList<Integer> indices) throws IOException {
StringBuilder sb = new StringBuilder("? ");
sb.append(indices.size());
for (int idx : indices)
sb.append(" " + idx);
System.out.pri... | Java | ["1\n4 2\n2 1 3\n2 2 4\n\n1\n\n2\n\n3\n\n4\n\nCorrect"] | 2 seconds | ["? 1 1\n\n? 1 2\n\n? 1 3\n\n? 1 4\n\n! 4 3"] | NoteThe array $$$A$$$ in the example is $$$[1, 2, 3, 4]$$$. The length of the password is $$$2$$$. The first element of the password is the maximum of $$$A[2]$$$, $$$A[4]$$$ (since the first subset contains indices $$$1$$$ and $$$3$$$, we take maximum over remaining indices). The second element of the password is the m... | Java 11 | standard input | [
"math",
"binary search",
"implementation",
"interactive"
] | b0bce8524eb69b695edc1394ff86b913 | The first line of the input contains a single integer $$$t$$$ $$$(1 \leq t \leq 10)$$$ — the number of test cases. The description of the test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$k$$$ $$$(2 \leq n \leq 1000, 1 \leq k \leq n)$$$ — the size of the array and the number of s... | 2,100 | null | standard output | |
PASSED | b8406356ca60d94841aa0bd0de1ee5bd | train_002.jsonl | 1590935700 | This is an interactive problem.Ayush devised a new scheme to set the password of his lock. The lock has $$$k$$$ slots where each slot can hold integers from $$$1$$$ to $$$n$$$. The password $$$P$$$ is a sequence of $$$k$$$ integers each in the range $$$[1, n]$$$, $$$i$$$-th element of which goes into the $$$i$$$-th slo... | 256 megabytes | import javax.swing.plaf.synth.SynthEditorPaneUI;
import java.io.*;
import java.util.*;
public class Contest1 {
public static void main(String[] args) throws Exception {
Scanner sc = new Scanner(System.in);
PrintWriter pw = new PrintWriter(System.out);
int t = sc.nextInt();
while (t... | Java | ["1\n4 2\n2 1 3\n2 2 4\n\n1\n\n2\n\n3\n\n4\n\nCorrect"] | 2 seconds | ["? 1 1\n\n? 1 2\n\n? 1 3\n\n? 1 4\n\n! 4 3"] | NoteThe array $$$A$$$ in the example is $$$[1, 2, 3, 4]$$$. The length of the password is $$$2$$$. The first element of the password is the maximum of $$$A[2]$$$, $$$A[4]$$$ (since the first subset contains indices $$$1$$$ and $$$3$$$, we take maximum over remaining indices). The second element of the password is the m... | Java 11 | standard input | [
"math",
"binary search",
"implementation",
"interactive"
] | b0bce8524eb69b695edc1394ff86b913 | The first line of the input contains a single integer $$$t$$$ $$$(1 \leq t \leq 10)$$$ — the number of test cases. The description of the test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$k$$$ $$$(2 \leq n \leq 1000, 1 \leq k \leq n)$$$ — the size of the array and the number of s... | 2,100 | null | standard output | |
PASSED | 3e74719a1ecc02293bd69f4be8393a9c | train_002.jsonl | 1590935700 | This is an interactive problem.Ayush devised a new scheme to set the password of his lock. The lock has $$$k$$$ slots where each slot can hold integers from $$$1$$$ to $$$n$$$. The password $$$P$$$ is a sequence of $$$k$$$ integers each in the range $$$[1, n]$$$, $$$i$$$-th element of which goes into the $$$i$$$-th slo... | 256 megabytes | import java.io.*;
import java.util.*;
import java.math.*;
public class D {
static final boolean RUN_TIMING = false;
static PushbackReader in = new PushbackReader(new BufferedReader(new InputStreamReader(System.in)), 1024);
static PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(S... | Java | ["1\n4 2\n2 1 3\n2 2 4\n\n1\n\n2\n\n3\n\n4\n\nCorrect"] | 2 seconds | ["? 1 1\n\n? 1 2\n\n? 1 3\n\n? 1 4\n\n! 4 3"] | NoteThe array $$$A$$$ in the example is $$$[1, 2, 3, 4]$$$. The length of the password is $$$2$$$. The first element of the password is the maximum of $$$A[2]$$$, $$$A[4]$$$ (since the first subset contains indices $$$1$$$ and $$$3$$$, we take maximum over remaining indices). The second element of the password is the m... | Java 11 | standard input | [
"math",
"binary search",
"implementation",
"interactive"
] | b0bce8524eb69b695edc1394ff86b913 | The first line of the input contains a single integer $$$t$$$ $$$(1 \leq t \leq 10)$$$ — the number of test cases. The description of the test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$k$$$ $$$(2 \leq n \leq 1000, 1 \leq k \leq n)$$$ — the size of the array and the number of s... | 2,100 | null | standard output | |
PASSED | 1e3f9c19ee7700aa08f0ab723d7ebfea | train_002.jsonl | 1590935700 | This is an interactive problem.Ayush devised a new scheme to set the password of his lock. The lock has $$$k$$$ slots where each slot can hold integers from $$$1$$$ to $$$n$$$. The password $$$P$$$ is a sequence of $$$k$$$ integers each in the range $$$[1, n]$$$, $$$i$$$-th element of which goes into the $$$i$$$-th slo... | 256 megabytes | import java.io.*;
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
public class cf1363d {
public static void main(String[] args) throws IOException {
int t = ri();
next: while(t --> 0) {
int n = rni(), k = ni(), s[][] = new int[k][];
fo... | Java | ["1\n4 2\n2 1 3\n2 2 4\n\n1\n\n2\n\n3\n\n4\n\nCorrect"] | 2 seconds | ["? 1 1\n\n? 1 2\n\n? 1 3\n\n? 1 4\n\n! 4 3"] | NoteThe array $$$A$$$ in the example is $$$[1, 2, 3, 4]$$$. The length of the password is $$$2$$$. The first element of the password is the maximum of $$$A[2]$$$, $$$A[4]$$$ (since the first subset contains indices $$$1$$$ and $$$3$$$, we take maximum over remaining indices). The second element of the password is the m... | Java 11 | standard input | [
"math",
"binary search",
"implementation",
"interactive"
] | b0bce8524eb69b695edc1394ff86b913 | The first line of the input contains a single integer $$$t$$$ $$$(1 \leq t \leq 10)$$$ — the number of test cases. The description of the test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$k$$$ $$$(2 \leq n \leq 1000, 1 \leq k \leq n)$$$ — the size of the array and the number of s... | 2,100 | null | standard output | |
PASSED | 50f448d8775f0aa3925346090396d56d | train_002.jsonl | 1590935700 | This is an interactive problem.Ayush devised a new scheme to set the password of his lock. The lock has $$$k$$$ slots where each slot can hold integers from $$$1$$$ to $$$n$$$. The password $$$P$$$ is a sequence of $$$k$$$ integers each in the range $$$[1, n]$$$, $$$i$$$-th element of which goes into the $$$i$$$-th slo... | 256 megabytes | import java.util.*;
import java.io.*;
import java.math.*;
public class Main {
static PrintWriter out = new PrintWriter(System.out);
static Reader in = new Reader();
public static void main(String[] args) throws IOException {
Main solver = new Main();
solver.solve();
out.flush();
... | Java | ["1\n4 2\n2 1 3\n2 2 4\n\n1\n\n2\n\n3\n\n4\n\nCorrect"] | 2 seconds | ["? 1 1\n\n? 1 2\n\n? 1 3\n\n? 1 4\n\n! 4 3"] | NoteThe array $$$A$$$ in the example is $$$[1, 2, 3, 4]$$$. The length of the password is $$$2$$$. The first element of the password is the maximum of $$$A[2]$$$, $$$A[4]$$$ (since the first subset contains indices $$$1$$$ and $$$3$$$, we take maximum over remaining indices). The second element of the password is the m... | Java 11 | standard input | [
"math",
"binary search",
"implementation",
"interactive"
] | b0bce8524eb69b695edc1394ff86b913 | The first line of the input contains a single integer $$$t$$$ $$$(1 \leq t \leq 10)$$$ — the number of test cases. The description of the test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$k$$$ $$$(2 \leq n \leq 1000, 1 \leq k \leq n)$$$ — the size of the array and the number of s... | 2,100 | null | standard output | |
PASSED | 6f5ce4689f0683941eb606a0cde0cb4e | train_002.jsonl | 1590935700 | This is an interactive problem.Ayush devised a new scheme to set the password of his lock. The lock has $$$k$$$ slots where each slot can hold integers from $$$1$$$ to $$$n$$$. The password $$$P$$$ is a sequence of $$$k$$$ integers each in the range $$$[1, n]$$$, $$$i$$$-th element of which goes into the $$$i$$$-th slo... | 256 megabytes | //package cf646;
import java.io.*;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
// What's the smallest input?
// Check * for int/long overflow.
// Check / for accidental rounding.
// Are you using doubles? Can you avoid it?
// Never compare after taking mod.
// Mod the f... | Java | ["1\n4 2\n2 1 3\n2 2 4\n\n1\n\n2\n\n3\n\n4\n\nCorrect"] | 2 seconds | ["? 1 1\n\n? 1 2\n\n? 1 3\n\n? 1 4\n\n! 4 3"] | NoteThe array $$$A$$$ in the example is $$$[1, 2, 3, 4]$$$. The length of the password is $$$2$$$. The first element of the password is the maximum of $$$A[2]$$$, $$$A[4]$$$ (since the first subset contains indices $$$1$$$ and $$$3$$$, we take maximum over remaining indices). The second element of the password is the m... | Java 11 | standard input | [
"math",
"binary search",
"implementation",
"interactive"
] | b0bce8524eb69b695edc1394ff86b913 | The first line of the input contains a single integer $$$t$$$ $$$(1 \leq t \leq 10)$$$ — the number of test cases. The description of the test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$k$$$ $$$(2 \leq n \leq 1000, 1 \leq k \leq n)$$$ — the size of the array and the number of s... | 2,100 | null | standard output | |
PASSED | c7bb12b0b19f5fd7bff1e89cddb73a4b | train_002.jsonl | 1590935700 | This is an interactive problem.Ayush devised a new scheme to set the password of his lock. The lock has $$$k$$$ slots where each slot can hold integers from $$$1$$$ to $$$n$$$. The password $$$P$$$ is a sequence of $$$k$$$ integers each in the range $$$[1, n]$$$, $$$i$$$-th element of which goes into the $$$i$$$-th slo... | 256 megabytes | //package round_646;
import java.util.*;
import java.io.*;
public class Problem_D {
static class Input {
BufferedReader br;
StringTokenizer st;
public Input(Reader r) throws IOException {
br = new BufferedReader(r);
st = new StringTokenizer(br.readLine());
}
public String nextLine() throws IOExceptio... | Java | ["1\n4 2\n2 1 3\n2 2 4\n\n1\n\n2\n\n3\n\n4\n\nCorrect"] | 2 seconds | ["? 1 1\n\n? 1 2\n\n? 1 3\n\n? 1 4\n\n! 4 3"] | NoteThe array $$$A$$$ in the example is $$$[1, 2, 3, 4]$$$. The length of the password is $$$2$$$. The first element of the password is the maximum of $$$A[2]$$$, $$$A[4]$$$ (since the first subset contains indices $$$1$$$ and $$$3$$$, we take maximum over remaining indices). The second element of the password is the m... | Java 11 | standard input | [
"math",
"binary search",
"implementation",
"interactive"
] | b0bce8524eb69b695edc1394ff86b913 | The first line of the input contains a single integer $$$t$$$ $$$(1 \leq t \leq 10)$$$ — the number of test cases. The description of the test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$k$$$ $$$(2 \leq n \leq 1000, 1 \leq k \leq n)$$$ — the size of the array and the number of s... | 2,100 | null | standard output | |
PASSED | 0e33166305844f84f1584714472b96a3 | train_002.jsonl | 1590935700 | This is an interactive problem.Ayush devised a new scheme to set the password of his lock. The lock has $$$k$$$ slots where each slot can hold integers from $$$1$$$ to $$$n$$$. The password $$$P$$$ is a sequence of $$$k$$$ integers each in the range $$$[1, n]$$$, $$$i$$$-th element of which goes into the $$$i$$$-th slo... | 256 megabytes | import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;
import java.util.*;
public class Main {
public static void main(String[] args) {... | Java | ["1\n4 2\n2 1 3\n2 2 4\n\n1\n\n2\n\n3\n\n4\n\nCorrect"] | 2 seconds | ["? 1 1\n\n? 1 2\n\n? 1 3\n\n? 1 4\n\n! 4 3"] | NoteThe array $$$A$$$ in the example is $$$[1, 2, 3, 4]$$$. The length of the password is $$$2$$$. The first element of the password is the maximum of $$$A[2]$$$, $$$A[4]$$$ (since the first subset contains indices $$$1$$$ and $$$3$$$, we take maximum over remaining indices). The second element of the password is the m... | Java 11 | standard input | [
"math",
"binary search",
"implementation",
"interactive"
] | b0bce8524eb69b695edc1394ff86b913 | The first line of the input contains a single integer $$$t$$$ $$$(1 \leq t \leq 10)$$$ — the number of test cases. The description of the test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$k$$$ $$$(2 \leq n \leq 1000, 1 \leq k \leq n)$$$ — the size of the array and the number of s... | 2,100 | null | standard output | |
PASSED | d2cd7f381c4f7ad58f2895973e4597b7 | train_002.jsonl | 1590935700 | This is an interactive problem.Ayush devised a new scheme to set the password of his lock. The lock has $$$k$$$ slots where each slot can hold integers from $$$1$$$ to $$$n$$$. The password $$$P$$$ is a sequence of $$$k$$$ integers each in the range $$$[1, n]$$$, $$$i$$$-th element of which goes into the $$$i$$$-th slo... | 256 megabytes | import java.util.*;
import java.io.*;
public class D646 {
public static void main(String [] args)
{
MyScanner sc = new MyScanner();
PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
int t = sc.nextInt();
while (t-- > 0) {
int n = sc.nextInt(); i... | Java | ["1\n4 2\n2 1 3\n2 2 4\n\n1\n\n2\n\n3\n\n4\n\nCorrect"] | 2 seconds | ["? 1 1\n\n? 1 2\n\n? 1 3\n\n? 1 4\n\n! 4 3"] | NoteThe array $$$A$$$ in the example is $$$[1, 2, 3, 4]$$$. The length of the password is $$$2$$$. The first element of the password is the maximum of $$$A[2]$$$, $$$A[4]$$$ (since the first subset contains indices $$$1$$$ and $$$3$$$, we take maximum over remaining indices). The second element of the password is the m... | Java 11 | standard input | [
"math",
"binary search",
"implementation",
"interactive"
] | b0bce8524eb69b695edc1394ff86b913 | The first line of the input contains a single integer $$$t$$$ $$$(1 \leq t \leq 10)$$$ — the number of test cases. The description of the test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$k$$$ $$$(2 \leq n \leq 1000, 1 \leq k \leq n)$$$ — the size of the array and the number of s... | 2,100 | null | standard output | |
PASSED | 56c26d2ded0d4864b528cb54f5ef93ae | train_003.jsonl | 1390231800 | Iahub likes chess very much. He even invented a new chess piece named Coder. A Coder can move (and attack) one square horizontally or vertically. More precisely, if the Coder is located at position (x, y), he can move to (or attack) positions (x + 1, y), (x–1, y), (x, y + 1) and (x, y–1).Iahub wants to know how many Co... | 256 megabytes | import java.util.*;
public class Coder {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int maxcoders = 0;
if (n % 2 == 0)
maxcoders = ((n * n) / 2);
else
maxcoders = ((n * n) + 1) / 2;
Sy... | Java | ["2"] | 1 second | ["2\nC.\n.C"] | null | Java 7 | standard input | [
"implementation"
] | 1aede54b41d6fad3e74f24a6592198eb | The first line contains an integer n (1 ≤ n ≤ 1000). | 800 | On the first line print an integer, the maximum number of Coders that can be placed on the chessboard. On each of the next n lines print n characters, describing the configuration of the Coders. For an empty cell print an '.', and for a Coder print a 'C'. If there are multiple correct answers, you can print any. | standard output | |
PASSED | ea1b20425277696765e24fa25ae87c4f | train_003.jsonl | 1390231800 | Iahub likes chess very much. He even invented a new chess piece named Coder. A Coder can move (and attack) one square horizontally or vertically. More precisely, if the Coder is located at position (x, y), he can move to (or attack) positions (x + 1, y), (x–1, y), (x, y + 1) and (x, y–1).Iahub wants to know how many Co... | 256 megabytes |
import java.awt.Point;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections... | Java | ["2"] | 1 second | ["2\nC.\n.C"] | null | Java 7 | standard input | [
"implementation"
] | 1aede54b41d6fad3e74f24a6592198eb | The first line contains an integer n (1 ≤ n ≤ 1000). | 800 | On the first line print an integer, the maximum number of Coders that can be placed on the chessboard. On each of the next n lines print n characters, describing the configuration of the Coders. For an empty cell print an '.', and for a Coder print a 'C'. If there are multiple correct answers, you can print any. | standard output | |
PASSED | 876f97bac9b38caeb458a4192990436e | train_003.jsonl | 1390231800 | Iahub likes chess very much. He even invented a new chess piece named Coder. A Coder can move (and attack) one square horizontally or vertically. More precisely, if the Coder is located at position (x, y), he can move to (or attack) positions (x + 1, y), (x–1, y), (x, y + 1) and (x, y–1).Iahub wants to know how many Co... | 256 megabytes | /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
//package coder;
/**
*
* @author samsung
*/
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamR... | Java | ["2"] | 1 second | ["2\nC.\n.C"] | null | Java 7 | standard input | [
"implementation"
] | 1aede54b41d6fad3e74f24a6592198eb | The first line contains an integer n (1 ≤ n ≤ 1000). | 800 | On the first line print an integer, the maximum number of Coders that can be placed on the chessboard. On each of the next n lines print n characters, describing the configuration of the Coders. For an empty cell print an '.', and for a Coder print a 'C'. If there are multiple correct answers, you can print any. | standard output | |
PASSED | 25c9b1ca5a1e1775da185e54c602b880 | train_003.jsonl | 1390231800 | Iahub likes chess very much. He even invented a new chess piece named Coder. A Coder can move (and attack) one square horizontally or vertically. More precisely, if the Coder is located at position (x, y), he can move to (or attack) positions (x + 1, y), (x–1, y), (x, y + 1) and (x, y–1).Iahub wants to know how many Co... | 256 megabytes | /*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
/**
*
* @author Prasham
*/
import java.io.* ;
public class NewClass {
public static void main(String []args) throws IOExc... | Java | ["2"] | 1 second | ["2\nC.\n.C"] | null | Java 7 | standard input | [
"implementation"
] | 1aede54b41d6fad3e74f24a6592198eb | The first line contains an integer n (1 ≤ n ≤ 1000). | 800 | On the first line print an integer, the maximum number of Coders that can be placed on the chessboard. On each of the next n lines print n characters, describing the configuration of the Coders. For an empty cell print an '.', and for a Coder print a 'C'. If there are multiple correct answers, you can print any. | standard output | |
PASSED | 0a754e4f0a5cb33b659eecdb06a87ecc | train_003.jsonl | 1390231800 | Iahub likes chess very much. He even invented a new chess piece named Coder. A Coder can move (and attack) one square horizontally or vertically. More precisely, if the Coder is located at position (x, y), he can move to (or attack) positions (x + 1, y), (x–1, y), (x, y + 1) and (x, y–1).Iahub wants to know how many Co... | 256 megabytes | import java.util.Scanner;
public class Main {
public static void main(String args[]){
Scanner scan=new Scanner(System.in);
int matriz=scan.nextInt();
int resu=0;
if(matriz%2==0)
resu=(matriz*matriz)/2;
else
resu=((matriz*matriz)/2)+1;
System.out.println(resu);
String st1=ne... | Java | ["2"] | 1 second | ["2\nC.\n.C"] | null | Java 7 | standard input | [
"implementation"
] | 1aede54b41d6fad3e74f24a6592198eb | The first line contains an integer n (1 ≤ n ≤ 1000). | 800 | On the first line print an integer, the maximum number of Coders that can be placed on the chessboard. On each of the next n lines print n characters, describing the configuration of the Coders. For an empty cell print an '.', and for a Coder print a 'C'. If there are multiple correct answers, you can print any. | standard output | |
PASSED | 2c2b0394f4e1a04d930c1d110874011c | train_003.jsonl | 1390231800 | Iahub likes chess very much. He even invented a new chess piece named Coder. A Coder can move (and attack) one square horizontally or vertically. More precisely, if the Coder is located at position (x, y), he can move to (or attack) positions (x + 1, y), (x–1, y), (x, y + 1) and (x, y–1).Iahub wants to know how many Co... | 256 megabytes | import java.util.Scanner;
public class chees {
public static void main(String[] args) {
Scanner in =new Scanner(System.in);
String ss="";
int x=in.nextInt(); int c=x*x;
if(c%2==0)
c=c/2;
else
c=(c/2)+1;
for(int i=0;ss.length()<=x;i++){
ss+="C.";
}
System.out.println(c);
int i=0;
boolean b=true;
while(++i<=x)
{
if... | Java | ["2"] | 1 second | ["2\nC.\n.C"] | null | Java 7 | standard input | [
"implementation"
] | 1aede54b41d6fad3e74f24a6592198eb | The first line contains an integer n (1 ≤ n ≤ 1000). | 800 | On the first line print an integer, the maximum number of Coders that can be placed on the chessboard. On each of the next n lines print n characters, describing the configuration of the Coders. For an empty cell print an '.', and for a Coder print a 'C'. If there are multiple correct answers, you can print any. | standard output | |
PASSED | e850e75c2087c76e8785ad4bb9a7d365 | train_003.jsonl | 1390231800 | Iahub likes chess very much. He even invented a new chess piece named Coder. A Coder can move (and attack) one square horizontally or vertically. More precisely, if the Coder is located at position (x, y), he can move to (or attack) positions (x + 1, y), (x–1, y), (x, y + 1) and (x, y–1).Iahub wants to know how many Co... | 256 megabytes | import java.io.PrintWriter;
import java.util.Scanner;
public class Coder {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
PrintWriter out = new PrintWriter(System.out);
int n = in.nextInt();
out.println((n*n+1)/2);
for(int i = 0;i<n;i++){
... | Java | ["2"] | 1 second | ["2\nC.\n.C"] | null | Java 7 | standard input | [
"implementation"
] | 1aede54b41d6fad3e74f24a6592198eb | The first line contains an integer n (1 ≤ n ≤ 1000). | 800 | On the first line print an integer, the maximum number of Coders that can be placed on the chessboard. On each of the next n lines print n characters, describing the configuration of the Coders. For an empty cell print an '.', and for a Coder print a 'C'. If there are multiple correct answers, you can print any. | standard output | |
PASSED | 67d1844a8d9ff1f0ec2fd173a7574cf7 | train_003.jsonl | 1390231800 | Iahub likes chess very much. He even invented a new chess piece named Coder. A Coder can move (and attack) one square horizontally or vertically. More precisely, if the Coder is located at position (x, y), he can move to (or attack) positions (x + 1, y), (x–1, y), (x, y + 1) and (x, y–1).Iahub wants to know how many Co... | 256 megabytes | import java.io.PrintWriter;
import java.util.Scanner;
public class Coder {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
PrintWriter out = new PrintWriter(System.out);
int n = in.nextInt();
out.println((n*n+1)/2);
for(int i = 0;i<n;i++){
... | Java | ["2"] | 1 second | ["2\nC.\n.C"] | null | Java 7 | standard input | [
"implementation"
] | 1aede54b41d6fad3e74f24a6592198eb | The first line contains an integer n (1 ≤ n ≤ 1000). | 800 | On the first line print an integer, the maximum number of Coders that can be placed on the chessboard. On each of the next n lines print n characters, describing the configuration of the Coders. For an empty cell print an '.', and for a Coder print a 'C'. If there are multiple correct answers, you can print any. | standard output | |
PASSED | cf1172a3dea319c016623f8d583d1b18 | train_003.jsonl | 1390231800 | Iahub likes chess very much. He even invented a new chess piece named Coder. A Coder can move (and attack) one square horizontally or vertically. More precisely, if the Coder is located at position (x, y), he can move to (or attack) positions (x + 1, y), (x–1, y), (x, y + 1) and (x, y–1).Iahub wants to know how many Co... | 256 megabytes | import java.util.Scanner;
/**
*
* @author Annie
*/
public class Coder {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
Scanner s = new Scanner(System.in);
int n = s.nextInt();
S... | Java | ["2"] | 1 second | ["2\nC.\n.C"] | null | Java 7 | standard input | [
"implementation"
] | 1aede54b41d6fad3e74f24a6592198eb | The first line contains an integer n (1 ≤ n ≤ 1000). | 800 | On the first line print an integer, the maximum number of Coders that can be placed on the chessboard. On each of the next n lines print n characters, describing the configuration of the Coders. For an empty cell print an '.', and for a Coder print a 'C'. If there are multiple correct answers, you can print any. | standard output | |
PASSED | ec11d5ce9fc6fbe550055383267ede0f | train_003.jsonl | 1390231800 | Iahub likes chess very much. He even invented a new chess piece named Coder. A Coder can move (and attack) one square horizontally or vertically. More precisely, if the Coder is located at position (x, y), he can move to (or attack) positions (x + 1, y), (x–1, y), (x, y + 1) and (x, y–1).Iahub wants to know how many Co... | 256 megabytes | import java.util.Scanner;
import java.io.PrintWriter;
import java.lang.*;
public class Main
{
public static final PrintWriter out=new PrintWriter(System.out);
public static void display(int a)
{ if(a%2==0){
int k=0;
for(int i=1;i<=a;i++){
for(int j=1;j<=a;j++){
++k;
if(k... | Java | ["2"] | 1 second | ["2\nC.\n.C"] | null | Java 7 | standard input | [
"implementation"
] | 1aede54b41d6fad3e74f24a6592198eb | The first line contains an integer n (1 ≤ n ≤ 1000). | 800 | On the first line print an integer, the maximum number of Coders that can be placed on the chessboard. On each of the next n lines print n characters, describing the configuration of the Coders. For an empty cell print an '.', and for a Coder print a 'C'. If there are multiple correct answers, you can print any. | standard output | |
PASSED | 2a23d60ec461e3139c30aa90ed97aa4a | train_003.jsonl | 1390231800 | Iahub likes chess very much. He even invented a new chess piece named Coder. A Coder can move (and attack) one square horizontally or vertically. More precisely, if the Coder is located at position (x, y), he can move to (or attack) positions (x + 1, y), (x–1, y), (x, y + 1) and (x, y–1).Iahub wants to know how many Co... | 256 megabytes |
import java.util.*;
public class Main {
public static void main (String[] args){
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
char[][] b= new char[n][n];
for(int i=0;i<n;i++)
Arrays.fill(b[i],'.');
/*for(int i=0;i<n;i++)
for(int j=0;j<n;j++){
if(i>0 && i<n-1 &... | Java | ["2"] | 1 second | ["2\nC.\n.C"] | null | Java 7 | standard input | [
"implementation"
] | 1aede54b41d6fad3e74f24a6592198eb | The first line contains an integer n (1 ≤ n ≤ 1000). | 800 | On the first line print an integer, the maximum number of Coders that can be placed on the chessboard. On each of the next n lines print n characters, describing the configuration of the Coders. For an empty cell print an '.', and for a Coder print a 'C'. If there are multiple correct answers, you can print any. | standard output | |
PASSED | 9e4206222e53c08405552726ceef0958 | train_003.jsonl | 1390231800 | Iahub likes chess very much. He even invented a new chess piece named Coder. A Coder can move (and attack) one square horizontally or vertically. More precisely, if the Coder is located at position (x, y), he can move to (or attack) positions (x + 1, y), (x–1, y), (x, y + 1) and (x, y–1).Iahub wants to know how many Co... | 256 megabytes | import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt(), count = 0;
char[][] values = new char[n + 2][n + 2];
for (int i = 0; i < n + 2; i... | Java | ["2"] | 1 second | ["2\nC.\n.C"] | null | Java 7 | standard input | [
"implementation"
] | 1aede54b41d6fad3e74f24a6592198eb | The first line contains an integer n (1 ≤ n ≤ 1000). | 800 | On the first line print an integer, the maximum number of Coders that can be placed on the chessboard. On each of the next n lines print n characters, describing the configuration of the Coders. For an empty cell print an '.', and for a Coder print a 'C'. If there are multiple correct answers, you can print any. | standard output | |
PASSED | 56ba9b37249b2d7e32fca98619d680a7 | train_003.jsonl | 1390231800 | Iahub likes chess very much. He even invented a new chess piece named Coder. A Coder can move (and attack) one square horizontally or vertically. More precisely, if the Coder is located at position (x, y), he can move to (or attack) positions (x + 1, y), (x–1, y), (x, y + 1) and (x, y–1).Iahub wants to know how many Co... | 256 megabytes |
import java.util.Scanner;
public class tr {
public static void main (String args []){
Scanner s = new Scanner(System.in);
int n = s.nextInt();
if(n%2==0){
System.out.println((n/2)*n);
}else{
System.out.println(Math.round(Math.ceil(1.0*n/2)*Math.ceil(1.0*n/2)+(n/2)... | Java | ["2"] | 1 second | ["2\nC.\n.C"] | null | Java 7 | standard input | [
"implementation"
] | 1aede54b41d6fad3e74f24a6592198eb | The first line contains an integer n (1 ≤ n ≤ 1000). | 800 | On the first line print an integer, the maximum number of Coders that can be placed on the chessboard. On each of the next n lines print n characters, describing the configuration of the Coders. For an empty cell print an '.', and for a Coder print a 'C'. If there are multiple correct answers, you can print any. | standard output | |
PASSED | 8ec29ecad062879e36fde5f0807f470f | train_003.jsonl | 1390231800 | Iahub likes chess very much. He even invented a new chess piece named Coder. A Coder can move (and attack) one square horizontally or vertically. More precisely, if the Coder is located at position (x, y), he can move to (or attack) positions (x + 1, y), (x–1, y), (x, y + 1) and (x, y–1).Iahub wants to know how many Co... | 256 megabytes |
import java.io.*;
import java.util.*;
/**
*
* @coder Altynbek Nurgaziyev
*/
public class A {
void solution() throws Exception {
int n = in.nextInt();
if (n * n % 2 == 0) {
out.println(n * n / 2);
} else {
out.p... | Java | ["2"] | 1 second | ["2\nC.\n.C"] | null | Java 7 | standard input | [
"implementation"
] | 1aede54b41d6fad3e74f24a6592198eb | The first line contains an integer n (1 ≤ n ≤ 1000). | 800 | On the first line print an integer, the maximum number of Coders that can be placed on the chessboard. On each of the next n lines print n characters, describing the configuration of the Coders. For an empty cell print an '.', and for a Coder print a 'C'. If there are multiple correct answers, you can print any. | standard output | |
PASSED | 061db2132b6c97b0e4e79a1ac4a3fa7e | train_003.jsonl | 1390231800 | Iahub likes chess very much. He even invented a new chess piece named Coder. A Coder can move (and attack) one square horizontally or vertically. More precisely, if the Coder is located at position (x, y), he can move to (or attack) positions (x + 1, y), (x–1, y), (x, y + 1) and (x, y–1).Iahub wants to know how many Co... | 256 megabytes | import java.util.Scanner;
public class A225 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int n = input.nextInt();
int firstRow, secondRow;
if (n % 2 != 0) {
firstRow = n / 2 + 1;
} else {
firstRow = n / 2;
}
secondRow = n / 2;
int sum = (n / 2) * (firstRow... | Java | ["2"] | 1 second | ["2\nC.\n.C"] | null | Java 7 | standard input | [
"implementation"
] | 1aede54b41d6fad3e74f24a6592198eb | The first line contains an integer n (1 ≤ n ≤ 1000). | 800 | On the first line print an integer, the maximum number of Coders that can be placed on the chessboard. On each of the next n lines print n characters, describing the configuration of the Coders. For an empty cell print an '.', and for a Coder print a 'C'. If there are multiple correct answers, you can print any. | standard output | |
PASSED | 638b30066724e03807089b2ad94c4133 | train_003.jsonl | 1390231800 | Iahub likes chess very much. He even invented a new chess piece named Coder. A Coder can move (and attack) one square horizontally or vertically. More precisely, if the Coder is located at position (x, y), he can move to (or attack) positions (x + 1, y), (x–1, y), (x, y + 1) and (x, y–1).Iahub wants to know how many Co... | 256 megabytes |
/* IMPORTANT: Multiple classes and nested static classes are supported */
/*
* uncomment this if you want to read input.
import java.io.BufferedReader;
import java.io.InputStreamReader;
*/
import java.math.BigInteger;
import java.util.*;
public class Astone {
public static void main(String args[] ) throws Excep... | Java | ["2"] | 1 second | ["2\nC.\n.C"] | null | Java 7 | standard input | [
"implementation"
] | 1aede54b41d6fad3e74f24a6592198eb | The first line contains an integer n (1 ≤ n ≤ 1000). | 800 | On the first line print an integer, the maximum number of Coders that can be placed on the chessboard. On each of the next n lines print n characters, describing the configuration of the Coders. For an empty cell print an '.', and for a Coder print a 'C'. If there are multiple correct answers, you can print any. | standard output | |
PASSED | 138903a9f92b613b7019d1964120c417 | train_003.jsonl | 1390231800 | Iahub likes chess very much. He even invented a new chess piece named Coder. A Coder can move (and attack) one square horizontally or vertically. More precisely, if the Coder is located at position (x, y), he can move to (or attack) positions (x + 1, y), (x–1, y), (x, y + 1) and (x, y–1).Iahub wants to know how many Co... | 256 megabytes | //package TestOnly.Div2A_225.Code1;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;
public class Main
{
FastScanner in;
PrintWriter out;
public void solve() throws IOException
{
int n = in.nextInt();
ou... | Java | ["2"] | 1 second | ["2\nC.\n.C"] | null | Java 7 | standard input | [
"implementation"
] | 1aede54b41d6fad3e74f24a6592198eb | The first line contains an integer n (1 ≤ n ≤ 1000). | 800 | On the first line print an integer, the maximum number of Coders that can be placed on the chessboard. On each of the next n lines print n characters, describing the configuration of the Coders. For an empty cell print an '.', and for a Coder print a 'C'. If there are multiple correct answers, you can print any. | standard output | |
PASSED | ff665b330e3df6047a658295c9233280 | train_003.jsonl | 1390231800 | Iahub likes chess very much. He even invented a new chess piece named Coder. A Coder can move (and attack) one square horizontally or vertically. More precisely, if the Coder is located at position (x, y), he can move to (or attack) positions (x + 1, y), (x–1, y), (x, y + 1) and (x, y–1).Iahub wants to know how many Co... | 256 megabytes | //package Codeforces.Div2A_225;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;
/*
* some cheeky quote
*/
public class Main
{
FastScanner in;
PrintWriter out;
public void solve() throws IOExcepti... | Java | ["2"] | 1 second | ["2\nC.\n.C"] | null | Java 7 | standard input | [
"implementation"
] | 1aede54b41d6fad3e74f24a6592198eb | The first line contains an integer n (1 ≤ n ≤ 1000). | 800 | On the first line print an integer, the maximum number of Coders that can be placed on the chessboard. On each of the next n lines print n characters, describing the configuration of the Coders. For an empty cell print an '.', and for a Coder print a 'C'. If there are multiple correct answers, you can print any. | standard output | |
PASSED | 1dc5b78c0cdcd020aca86da0e943b221 | train_003.jsonl | 1390231800 | Iahub likes chess very much. He even invented a new chess piece named Coder. A Coder can move (and attack) one square horizontally or vertically. More precisely, if the Coder is located at position (x, y), he can move to (or attack) positions (x + 1, y), (x–1, y), (x, y + 1) and (x, y–1).Iahub wants to know how many Co... | 256 megabytes |
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int n = Integer.parseInt(br.readLine());
i... | Java | ["2"] | 1 second | ["2\nC.\n.C"] | null | Java 7 | standard input | [
"implementation"
] | 1aede54b41d6fad3e74f24a6592198eb | The first line contains an integer n (1 ≤ n ≤ 1000). | 800 | On the first line print an integer, the maximum number of Coders that can be placed on the chessboard. On each of the next n lines print n characters, describing the configuration of the Coders. For an empty cell print an '.', and for a Coder print a 'C'. If there are multiple correct answers, you can print any. | standard output | |
PASSED | 2c3d774242a71bdf2d4231c4e68c11ab | train_003.jsonl | 1390231800 | Iahub likes chess very much. He even invented a new chess piece named Coder. A Coder can move (and attack) one square horizontally or vertically. More precisely, if the Coder is located at position (x, y), he can move to (or attack) positions (x + 1, y), (x–1, y), (x, y + 1) and (x, y–1).Iahub wants to know how many Co... | 256 megabytes | import java.io.*;
public class Coder {
public static void main(String[] args) throws IOException {
BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
int n = Integer.parseInt(f.readLine());
System.out.println((n*n+1)/2);
String str = "";
for (int i = 0;... | Java | ["2"] | 1 second | ["2\nC.\n.C"] | null | Java 7 | standard input | [
"implementation"
] | 1aede54b41d6fad3e74f24a6592198eb | The first line contains an integer n (1 ≤ n ≤ 1000). | 800 | On the first line print an integer, the maximum number of Coders that can be placed on the chessboard. On each of the next n lines print n characters, describing the configuration of the Coders. For an empty cell print an '.', and for a Coder print a 'C'. If there are multiple correct answers, you can print any. | standard output | |
PASSED | adb233e8e5873cb56d8e6b41a8d0b1e0 | train_003.jsonl | 1390231800 | Iahub likes chess very much. He even invented a new chess piece named Coder. A Coder can move (and attack) one square horizontally or vertically. More precisely, if the Coder is located at position (x, y), he can move to (or attack) positions (x + 1, y), (x–1, y), (x, y + 1) and (x, y–1).Iahub wants to know how many Co... | 256 megabytes | import java.io.*;
import java.util.*;
public class Main {
static BufferedReader f;
static StringTokenizer st;
public static void main (String [] args) throws Exception {
// Use BufferedReader rather than RandomAccessFile; it's much faster
f = new BufferedReader(new java.io.InputStr... | Java | ["2"] | 1 second | ["2\nC.\n.C"] | null | Java 7 | standard input | [
"implementation"
] | 1aede54b41d6fad3e74f24a6592198eb | The first line contains an integer n (1 ≤ n ≤ 1000). | 800 | On the first line print an integer, the maximum number of Coders that can be placed on the chessboard. On each of the next n lines print n characters, describing the configuration of the Coders. For an empty cell print an '.', and for a Coder print a 'C'. If there are multiple correct answers, you can print any. | standard output | |
PASSED | 6aff56e5bd8b96119f307c5114fee583 | train_003.jsonl | 1390231800 | Iahub likes chess very much. He even invented a new chess piece named Coder. A Coder can move (and attack) one square horizontally or vertically. More precisely, if the Coder is located at position (x, y), he can move to (or attack) positions (x + 1, y), (x–1, y), (x, y + 1) and (x, y–1).Iahub wants to know how many Co... | 256 megabytes | import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.math.BigInteger;
import java.util.Scanner;
import javax.swing.table.DefaultTableModel;
public class Test
{
static void print(int[] a)
{
for(int i=0;i<a.length;i++) S... | Java | ["2"] | 1 second | ["2\nC.\n.C"] | null | Java 7 | standard input | [
"implementation"
] | 1aede54b41d6fad3e74f24a6592198eb | The first line contains an integer n (1 ≤ n ≤ 1000). | 800 | On the first line print an integer, the maximum number of Coders that can be placed on the chessboard. On each of the next n lines print n characters, describing the configuration of the Coders. For an empty cell print an '.', and for a Coder print a 'C'. If there are multiple correct answers, you can print any. | standard output | |
PASSED | 5a44274e297a944017bad55ff57b10ad | train_003.jsonl | 1390231800 | Iahub likes chess very much. He even invented a new chess piece named Coder. A Coder can move (and attack) one square horizontally or vertically. More precisely, if the Coder is located at position (x, y), he can move to (or attack) positions (x + 1, y), (x–1, y), (x, y + 1) and (x, y–1).Iahub wants to know how many Co... | 256 megabytes | import java.io.*;
import java.math.*;
import java.util.*;
public class Main {
InputReader input;
PrintWriter output;
void run(){
output = new PrintWriter(new OutputStreamWriter(System.out));
input = new InputReader(System.in);
solve();
output.flush();
}
public st... | Java | ["2"] | 1 second | ["2\nC.\n.C"] | null | Java 7 | standard input | [
"implementation"
] | 1aede54b41d6fad3e74f24a6592198eb | The first line contains an integer n (1 ≤ n ≤ 1000). | 800 | On the first line print an integer, the maximum number of Coders that can be placed on the chessboard. On each of the next n lines print n characters, describing the configuration of the Coders. For an empty cell print an '.', and for a Coder print a 'C'. If there are multiple correct answers, you can print any. | standard output | |
PASSED | e9dd7d674e6c224916b523aad3d479fd | train_003.jsonl | 1390231800 | Iahub likes chess very much. He even invented a new chess piece named Coder. A Coder can move (and attack) one square horizontally or vertically. More precisely, if the Coder is located at position (x, y), he can move to (or attack) positions (x + 1, y), (x–1, y), (x, y + 1) and (x, y–1).Iahub wants to know how many Co... | 256 megabytes | import java.util.Scanner;
public class Problem384 {
/**
* @param args
*/
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int countEven = 0;
int countOdd = 0;
StringBuilder sbEven = new StringBuilder("");
... | Java | ["2"] | 1 second | ["2\nC.\n.C"] | null | Java 7 | standard input | [
"implementation"
] | 1aede54b41d6fad3e74f24a6592198eb | The first line contains an integer n (1 ≤ n ≤ 1000). | 800 | On the first line print an integer, the maximum number of Coders that can be placed on the chessboard. On each of the next n lines print n characters, describing the configuration of the Coders. For an empty cell print an '.', and for a Coder print a 'C'. If there are multiple correct answers, you can print any. | standard output | |
PASSED | 65adfc5e96843d582b3cf6efdcd14af4 | train_003.jsonl | 1390231800 | Iahub likes chess very much. He even invented a new chess piece named Coder. A Coder can move (and attack) one square horizontally or vertically. More precisely, if the Coder is located at position (x, y), he can move to (or attack) positions (x + 1, y), (x–1, y), (x, y + 1) and (x, y–1).Iahub wants to know how many Co... | 256 megabytes |
import java.util.Scanner;
public class Main
{
public static void main(String[]args)
{
int n,i,j;
String fila1;
String fila2;
Scanner s=new Scanner(System.in);
n=s.nextInt();
fila1=new String("");;
fila2=new String("");
if(n%2==0)
System.out.println((n*n)/2);
else
System.out.println((... | Java | ["2"] | 1 second | ["2\nC.\n.C"] | null | Java 7 | standard input | [
"implementation"
] | 1aede54b41d6fad3e74f24a6592198eb | The first line contains an integer n (1 ≤ n ≤ 1000). | 800 | On the first line print an integer, the maximum number of Coders that can be placed on the chessboard. On each of the next n lines print n characters, describing the configuration of the Coders. For an empty cell print an '.', and for a Coder print a 'C'. If there are multiple correct answers, you can print any. | standard output | |
PASSED | b36bf7ffb3020dedc756c707062c7256 | train_003.jsonl | 1390231800 | Iahub likes chess very much. He even invented a new chess piece named Coder. A Coder can move (and attack) one square horizontally or vertically. More precisely, if the Coder is located at position (x, y), he can move to (or attack) positions (x + 1, y), (x–1, y), (x, y + 1) and (x, y–1).Iahub wants to know how many Co... | 256 megabytes | import java.util.Scanner;
public class Main {
public static void main(String... args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
System.out.println((n*n+1)/2);
for (int i=0; i<n; i++){
for (int j=0; j<n; j++){
System.out.print((i+j)%2==0?"C":".");
}
System.out.println();
}
}
} | Java | ["2"] | 1 second | ["2\nC.\n.C"] | null | Java 7 | standard input | [
"implementation"
] | 1aede54b41d6fad3e74f24a6592198eb | The first line contains an integer n (1 ≤ n ≤ 1000). | 800 | On the first line print an integer, the maximum number of Coders that can be placed on the chessboard. On each of the next n lines print n characters, describing the configuration of the Coders. For an empty cell print an '.', and for a Coder print a 'C'. If there are multiple correct answers, you can print any. | standard output | |
PASSED | 13bb39b2a43fcaec14f04ee9beae1950 | train_003.jsonl | 1390231800 | Iahub likes chess very much. He even invented a new chess piece named Coder. A Coder can move (and attack) one square horizontally or vertically. More precisely, if the Coder is located at position (x, y), he can move to (or attack) positions (x + 1, y), (x–1, y), (x, y + 1) and (x, y–1).Iahub wants to know how many Co... | 256 megabytes | import java.util.Scanner;
public class Main {
public static void main(String... args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
System.out.println((n*n+1)/2);
for (int i=0; i<n; i++){
for (int j=0; j<n; j++){
System.out.print((i+j)%2==0?"C":".");
}
System.out.println();
}
}
} | Java | ["2"] | 1 second | ["2\nC.\n.C"] | null | Java 7 | standard input | [
"implementation"
] | 1aede54b41d6fad3e74f24a6592198eb | The first line contains an integer n (1 ≤ n ≤ 1000). | 800 | On the first line print an integer, the maximum number of Coders that can be placed on the chessboard. On each of the next n lines print n characters, describing the configuration of the Coders. For an empty cell print an '.', and for a Coder print a 'C'. If there are multiple correct answers, you can print any. | standard output | |
PASSED | 38b0919bda01d157da27948c6fec249d | train_003.jsonl | 1390231800 | Iahub likes chess very much. He even invented a new chess piece named Coder. A Coder can move (and attack) one square horizontally or vertically. More precisely, if the Coder is located at position (x, y), he can move to (or attack) positions (x + 1, y), (x–1, y), (x, y + 1) and (x, y–1).Iahub wants to know how many Co... | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class A {
public static void main(String[] args) throws IOException {
BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
int n = Integer.parseInt(bf.readLine());
if(n%2==0){
System.... | Java | ["2"] | 1 second | ["2\nC.\n.C"] | null | Java 7 | standard input | [
"implementation"
] | 1aede54b41d6fad3e74f24a6592198eb | The first line contains an integer n (1 ≤ n ≤ 1000). | 800 | On the first line print an integer, the maximum number of Coders that can be placed on the chessboard. On each of the next n lines print n characters, describing the configuration of the Coders. For an empty cell print an '.', and for a Coder print a 'C'. If there are multiple correct answers, you can print any. | standard output | |
PASSED | 46f7765b28ed571609daee767c8250fe | train_003.jsonl | 1390231800 | Iahub likes chess very much. He even invented a new chess piece named Coder. A Coder can move (and attack) one square horizontally or vertically. More precisely, if the Coder is located at position (x, y), he can move to (or attack) positions (x + 1, y), (x–1, y), (x, y + 1) and (x, y–1).Iahub wants to know how many Co... | 256 megabytes | import java.util.Scanner;
public class A384 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
System.out.println((n / 2) * (n / 2) + (n / 2 + (n % 2)) * (n / 2 + (n % 2)));
String [] st = new String[2];
for(int i = 1; i <= 2; i++){
Str... | Java | ["2"] | 1 second | ["2\nC.\n.C"] | null | Java 7 | standard input | [
"implementation"
] | 1aede54b41d6fad3e74f24a6592198eb | The first line contains an integer n (1 ≤ n ≤ 1000). | 800 | On the first line print an integer, the maximum number of Coders that can be placed on the chessboard. On each of the next n lines print n characters, describing the configuration of the Coders. For an empty cell print an '.', and for a Coder print a 'C'. If there are multiple correct answers, you can print any. | standard output | |
PASSED | 5e207dcef9329300e91969811ac7f301 | train_003.jsonl | 1390231800 | Iahub likes chess very much. He even invented a new chess piece named Coder. A Coder can move (and attack) one square horizontally or vertically. More precisely, if the Coder is located at position (x, y), he can move to (or attack) positions (x + 1, y), (x–1, y), (x, y + 1) and (x, y–1).Iahub wants to know how many Co... | 256 megabytes | /**
*
* @author Faruk
*/
import java.util.Arrays;
import java.util.Scanner;
import java.util.HashSet;
import java.util.HashMap;
import java.util.ArrayList;
public class tmp {
public static void main(String [] args){
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
... | Java | ["2"] | 1 second | ["2\nC.\n.C"] | null | Java 7 | standard input | [
"implementation"
] | 1aede54b41d6fad3e74f24a6592198eb | The first line contains an integer n (1 ≤ n ≤ 1000). | 800 | On the first line print an integer, the maximum number of Coders that can be placed on the chessboard. On each of the next n lines print n characters, describing the configuration of the Coders. For an empty cell print an '.', and for a Coder print a 'C'. If there are multiple correct answers, you can print any. | standard output | |
PASSED | 32e066d8ad60b3b0fb315afc5e5d7c94 | train_003.jsonl | 1390231800 | Iahub likes chess very much. He even invented a new chess piece named Coder. A Coder can move (and attack) one square horizontally or vertically. More precisely, if the Coder is located at position (x, y), he can move to (or attack) positions (x + 1, y), (x–1, y), (x, y + 1) and (x, y–1).Iahub wants to know how many Co... | 256 megabytes | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
if (n%2 == 0) {
System.out.println(n*n/2);
for (int i=0; i<n; i++) {
for (int j=0; j<n; j++) {
... | Java | ["2"] | 1 second | ["2\nC.\n.C"] | null | Java 7 | standard input | [
"implementation"
] | 1aede54b41d6fad3e74f24a6592198eb | The first line contains an integer n (1 ≤ n ≤ 1000). | 800 | On the first line print an integer, the maximum number of Coders that can be placed on the chessboard. On each of the next n lines print n characters, describing the configuration of the Coders. For an empty cell print an '.', and for a Coder print a 'C'. If there are multiple correct answers, you can print any. | standard output | |
PASSED | f47ed526fa272b4f39940c03a12dbc68 | train_003.jsonl | 1390231800 | Iahub likes chess very much. He even invented a new chess piece named Coder. A Coder can move (and attack) one square horizontally or vertically. More precisely, if the Coder is located at position (x, y), he can move to (or attack) positions (x + 1, y), (x–1, y), (x, y + 1) and (x, y–1).Iahub wants to know how many Co... | 256 megabytes |
import com.sun.org.apache.xerces.internal.impl.xs.identity.Selector;
import java.io.PrintStream;
import java.util.Arrays;
import java.util.PriorityQueue;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main {
public static void main(String[] args) {
... | Java | ["2"] | 1 second | ["2\nC.\n.C"] | null | Java 7 | standard input | [
"implementation"
] | 1aede54b41d6fad3e74f24a6592198eb | The first line contains an integer n (1 ≤ n ≤ 1000). | 800 | On the first line print an integer, the maximum number of Coders that can be placed on the chessboard. On each of the next n lines print n characters, describing the configuration of the Coders. For an empty cell print an '.', and for a Coder print a 'C'. If there are multiple correct answers, you can print any. | standard output | |
PASSED | bcb18479867cbafbe0d7e2606b24a751 | train_003.jsonl | 1390231800 | Iahub likes chess very much. He even invented a new chess piece named Coder. A Coder can move (and attack) one square horizontally or vertically. More precisely, if the Coder is located at position (x, y), he can move to (or attack) positions (x + 1, y), (x–1, y), (x, y + 1) and (x, y–1).Iahub wants to know how many Co... | 256 megabytes | import java.util.Scanner;
public class Main{
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner key = new Scanner(System.in);
int n = key.nextInt();
if (n % 2 == 0) {
System.out.println(n / 2 * n);
} else {
System.out.println((n / 2) * (n / 2) + (n / 2 + 1) * (n / 2... | Java | ["2"] | 1 second | ["2\nC.\n.C"] | null | Java 7 | standard input | [
"implementation"
] | 1aede54b41d6fad3e74f24a6592198eb | The first line contains an integer n (1 ≤ n ≤ 1000). | 800 | On the first line print an integer, the maximum number of Coders that can be placed on the chessboard. On each of the next n lines print n characters, describing the configuration of the Coders. For an empty cell print an '.', and for a Coder print a 'C'. If there are multiple correct answers, you can print any. | standard output | |
PASSED | 7308451964a9008d9075cfca28cb1e9d | train_003.jsonl | 1390231800 | Iahub likes chess very much. He even invented a new chess piece named Coder. A Coder can move (and attack) one square horizontally or vertically. More precisely, if the Coder is located at position (x, y), he can move to (or attack) positions (x + 1, y), (x–1, y), (x, y + 1) and (x, y–1).Iahub wants to know how many Co... | 256 megabytes | import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import j... | Java | ["2"] | 1 second | ["2\nC.\n.C"] | null | Java 7 | standard input | [
"implementation"
] | 1aede54b41d6fad3e74f24a6592198eb | The first line contains an integer n (1 ≤ n ≤ 1000). | 800 | On the first line print an integer, the maximum number of Coders that can be placed on the chessboard. On each of the next n lines print n characters, describing the configuration of the Coders. For an empty cell print an '.', and for a Coder print a 'C'. If there are multiple correct answers, you can print any. | standard output | |
PASSED | 1c64243a289555eebe0db0bdfe48d829 | train_003.jsonl | 1390231800 | Iahub likes chess very much. He even invented a new chess piece named Coder. A Coder can move (and attack) one square horizontally or vertically. More precisely, if the Coder is located at position (x, y), he can move to (or attack) positions (x + 1, y), (x–1, y), (x, y + 1) and (x, y–1).Iahub wants to know how many Co... | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import org.xml.sax.InputSource;
public class Main {
public static void main(String[] args) throws NumberFormatException,
IOException {
BufferedReader reader = new Buffered... | Java | ["2"] | 1 second | ["2\nC.\n.C"] | null | Java 7 | standard input | [
"implementation"
] | 1aede54b41d6fad3e74f24a6592198eb | The first line contains an integer n (1 ≤ n ≤ 1000). | 800 | On the first line print an integer, the maximum number of Coders that can be placed on the chessboard. On each of the next n lines print n characters, describing the configuration of the Coders. For an empty cell print an '.', and for a Coder print a 'C'. If there are multiple correct answers, you can print any. | standard output | |
PASSED | 9df2c1c905c094d10262f45b743085b7 | train_003.jsonl | 1594996500 | A permutation of length $$$n$$$ is a sequence of integers from $$$1$$$ to $$$n$$$ of length $$$n$$$ containing each number exactly once. For example, $$$[1]$$$, $$$[4, 3, 5, 1, 2]$$$, $$$[3, 2, 1]$$$ are permutations, and $$$[1, 1]$$$, $$$[0, 1]$$$, $$$[2, 2, 1, 4]$$$ are not.There was a permutation $$$p[1 \dots n]$$$.... | 256 megabytes | import java.util.HashMap;
import java.util.Scanner;
public class ques2
{
static void removeDups(int[] arr, int n)
{
HashMap<Integer,
Boolean> mp = new HashMap<>();
for (int i = 0; i < n; ++i)
{
if (mp.get(arr[i]) == null)
System.out.print(arr[i] + " ");
mp.put(arr[i], t... | Java | ["5\n2\n1 1 2 2\n4\n1 3 1 4 3 4 2 2\n5\n1 2 1 2 3 4 3 5 4 5\n3\n1 2 3 1 2 3\n4\n2 3 2 4 1 3 4 1"] | 1 second | ["1 2 \n1 3 4 2 \n1 2 3 4 5 \n1 2 3 \n2 3 4 1"] | null | Java 8 | standard input | [
"greedy"
] | aaf91874cf5aa0fa302ffed2ccecdc76 | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 400$$$) — the number of test cases. Then $$$t$$$ test cases follow. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 50$$$) — the length of permutation. The second line of the test case contains $$$2n$$$ integers $$$a_1... | 800 | For each test case, print the answer: $$$n$$$ integers $$$p_1, p_2, \dots, p_n$$$ ($$$1 \le p_i \le n$$$), representing the initial permutation. It is guaranteed that the answer exists and is unique. | standard output | |
PASSED | e9fd3739905eb3b5fe043366a311581b | train_003.jsonl | 1594996500 | A permutation of length $$$n$$$ is a sequence of integers from $$$1$$$ to $$$n$$$ of length $$$n$$$ containing each number exactly once. For example, $$$[1]$$$, $$$[4, 3, 5, 1, 2]$$$, $$$[3, 2, 1]$$$ are permutations, and $$$[1, 1]$$$, $$$[0, 1]$$$, $$$[2, 2, 1, 4]$$$ are not.There was a permutation $$$p[1 \dots n]$$$.... | 256 megabytes | import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int o = sc.nextInt();
while(o-->0) {
int[] x=new int[sc.nextInt()+1];
String tttt = sc.nextLine();
String[] s = sc.nextLine().split(" ");
for(int i=0;i<s.length;i++) {
int t = Integ... | Java | ["5\n2\n1 1 2 2\n4\n1 3 1 4 3 4 2 2\n5\n1 2 1 2 3 4 3 5 4 5\n3\n1 2 3 1 2 3\n4\n2 3 2 4 1 3 4 1"] | 1 second | ["1 2 \n1 3 4 2 \n1 2 3 4 5 \n1 2 3 \n2 3 4 1"] | null | Java 8 | standard input | [
"greedy"
] | aaf91874cf5aa0fa302ffed2ccecdc76 | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 400$$$) — the number of test cases. Then $$$t$$$ test cases follow. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 50$$$) — the length of permutation. The second line of the test case contains $$$2n$$$ integers $$$a_1... | 800 | For each test case, print the answer: $$$n$$$ integers $$$p_1, p_2, \dots, p_n$$$ ($$$1 \le p_i \le n$$$), representing the initial permutation. It is guaranteed that the answer exists and is unique. | standard output | |
PASSED | 792637a4fd353fe9b73db9dd1628646a | train_003.jsonl | 1594996500 | A permutation of length $$$n$$$ is a sequence of integers from $$$1$$$ to $$$n$$$ of length $$$n$$$ containing each number exactly once. For example, $$$[1]$$$, $$$[4, 3, 5, 1, 2]$$$, $$$[3, 2, 1]$$$ are permutations, and $$$[1, 1]$$$, $$$[0, 1]$$$, $$$[2, 2, 1, 4]$$$ are not.There was a permutation $$$p[1 \dots n]$$$.... | 256 megabytes | import java.util.*;
public class MyClass {
public static void main(String args[]) {
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
while(t-->0)
{
int n = sc.nextInt();
int[] a = new int[2*n];
for(int i=0;i<2*n;i++)
{
a[i]... | Java | ["5\n2\n1 1 2 2\n4\n1 3 1 4 3 4 2 2\n5\n1 2 1 2 3 4 3 5 4 5\n3\n1 2 3 1 2 3\n4\n2 3 2 4 1 3 4 1"] | 1 second | ["1 2 \n1 3 4 2 \n1 2 3 4 5 \n1 2 3 \n2 3 4 1"] | null | Java 8 | standard input | [
"greedy"
] | aaf91874cf5aa0fa302ffed2ccecdc76 | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 400$$$) — the number of test cases. Then $$$t$$$ test cases follow. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 50$$$) — the length of permutation. The second line of the test case contains $$$2n$$$ integers $$$a_1... | 800 | For each test case, print the answer: $$$n$$$ integers $$$p_1, p_2, \dots, p_n$$$ ($$$1 \le p_i \le n$$$), representing the initial permutation. It is guaranteed that the answer exists and is unique. | standard output | |
PASSED | e2a82b4baf189f7ae2b8551c28e85fae | train_003.jsonl | 1594996500 | A permutation of length $$$n$$$ is a sequence of integers from $$$1$$$ to $$$n$$$ of length $$$n$$$ containing each number exactly once. For example, $$$[1]$$$, $$$[4, 3, 5, 1, 2]$$$, $$$[3, 2, 1]$$$ are permutations, and $$$[1, 1]$$$, $$$[0, 1]$$$, $$$[2, 2, 1, 4]$$$ are not.There was a permutation $$$p[1 \dots n]$$$.... | 256 megabytes | import java.util.ArrayList;
import java.util.Scanner;
//import java.util.Arrays;
public class Algorithms {
static Scanner sc = new Scanner(System.in);
static ArrayList<Integer> k=new ArrayList<>();
public static void main(String[] args) {
int t=sc.nextInt();
int n;
int p;... | Java | ["5\n2\n1 1 2 2\n4\n1 3 1 4 3 4 2 2\n5\n1 2 1 2 3 4 3 5 4 5\n3\n1 2 3 1 2 3\n4\n2 3 2 4 1 3 4 1"] | 1 second | ["1 2 \n1 3 4 2 \n1 2 3 4 5 \n1 2 3 \n2 3 4 1"] | null | Java 8 | standard input | [
"greedy"
] | aaf91874cf5aa0fa302ffed2ccecdc76 | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 400$$$) — the number of test cases. Then $$$t$$$ test cases follow. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 50$$$) — the length of permutation. The second line of the test case contains $$$2n$$$ integers $$$a_1... | 800 | For each test case, print the answer: $$$n$$$ integers $$$p_1, p_2, \dots, p_n$$$ ($$$1 \le p_i \le n$$$), representing the initial permutation. It is guaranteed that the answer exists and is unique. | standard output | |
PASSED | 3a1059a4b0e3be7b5be90ea7dd4e358e | train_003.jsonl | 1594996500 | A permutation of length $$$n$$$ is a sequence of integers from $$$1$$$ to $$$n$$$ of length $$$n$$$ containing each number exactly once. For example, $$$[1]$$$, $$$[4, 3, 5, 1, 2]$$$, $$$[3, 2, 1]$$$ are permutations, and $$$[1, 1]$$$, $$$[0, 1]$$$, $$$[2, 2, 1, 4]$$$ are not.There was a permutation $$$p[1 \dots n]$$$.... | 256 megabytes | import java.util.ArrayList;
import java.util.Scanner;
//import java.util.Arrays;
public class Algorithms {
static Scanner sc = new Scanner(System.in);
static ArrayList<Integer> k=new ArrayList<>();
public static void main(String[] args) {
int t=sc.nextInt();
int n;
int p;... | Java | ["5\n2\n1 1 2 2\n4\n1 3 1 4 3 4 2 2\n5\n1 2 1 2 3 4 3 5 4 5\n3\n1 2 3 1 2 3\n4\n2 3 2 4 1 3 4 1"] | 1 second | ["1 2 \n1 3 4 2 \n1 2 3 4 5 \n1 2 3 \n2 3 4 1"] | null | Java 8 | standard input | [
"greedy"
] | aaf91874cf5aa0fa302ffed2ccecdc76 | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 400$$$) — the number of test cases. Then $$$t$$$ test cases follow. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 50$$$) — the length of permutation. The second line of the test case contains $$$2n$$$ integers $$$a_1... | 800 | For each test case, print the answer: $$$n$$$ integers $$$p_1, p_2, \dots, p_n$$$ ($$$1 \le p_i \le n$$$), representing the initial permutation. It is guaranteed that the answer exists and is unique. | standard output | |
PASSED | 1c5ea7a6c8a5d4b6a96fe4477c5f519f | train_003.jsonl | 1594996500 | A permutation of length $$$n$$$ is a sequence of integers from $$$1$$$ to $$$n$$$ of length $$$n$$$ containing each number exactly once. For example, $$$[1]$$$, $$$[4, 3, 5, 1, 2]$$$, $$$[3, 2, 1]$$$ are permutations, and $$$[1, 1]$$$, $$$[0, 1]$$$, $$$[2, 2, 1, 4]$$$ are not.There was a permutation $$$p[1 \dots n]$$$.... | 256 megabytes | import java.io.*;
import java.util.*;
public class MyClass
{
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)
{
int n=Integer.pars... | Java | ["5\n2\n1 1 2 2\n4\n1 3 1 4 3 4 2 2\n5\n1 2 1 2 3 4 3 5 4 5\n3\n1 2 3 1 2 3\n4\n2 3 2 4 1 3 4 1"] | 1 second | ["1 2 \n1 3 4 2 \n1 2 3 4 5 \n1 2 3 \n2 3 4 1"] | null | Java 8 | standard input | [
"greedy"
] | aaf91874cf5aa0fa302ffed2ccecdc76 | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 400$$$) — the number of test cases. Then $$$t$$$ test cases follow. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 50$$$) — the length of permutation. The second line of the test case contains $$$2n$$$ integers $$$a_1... | 800 | For each test case, print the answer: $$$n$$$ integers $$$p_1, p_2, \dots, p_n$$$ ($$$1 \le p_i \le n$$$), representing the initial permutation. It is guaranteed that the answer exists and is unique. | standard output | |
PASSED | 93a0a083b7fc6152deaa91450011ce99 | train_003.jsonl | 1594996500 | A permutation of length $$$n$$$ is a sequence of integers from $$$1$$$ to $$$n$$$ of length $$$n$$$ containing each number exactly once. For example, $$$[1]$$$, $$$[4, 3, 5, 1, 2]$$$, $$$[3, 2, 1]$$$ are permutations, and $$$[1, 1]$$$, $$$[0, 1]$$$, $$$[2, 2, 1, 4]$$$ are not.There was a permutation $$$p[1 \dots n]$$$.... | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;
public class Q1{
static StringTokenizer st;
static InputStreamReader ir;
static BufferedReader br;
public static... | Java | ["5\n2\n1 1 2 2\n4\n1 3 1 4 3 4 2 2\n5\n1 2 1 2 3 4 3 5 4 5\n3\n1 2 3 1 2 3\n4\n2 3 2 4 1 3 4 1"] | 1 second | ["1 2 \n1 3 4 2 \n1 2 3 4 5 \n1 2 3 \n2 3 4 1"] | null | Java 8 | standard input | [
"greedy"
] | aaf91874cf5aa0fa302ffed2ccecdc76 | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 400$$$) — the number of test cases. Then $$$t$$$ test cases follow. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 50$$$) — the length of permutation. The second line of the test case contains $$$2n$$$ integers $$$a_1... | 800 | For each test case, print the answer: $$$n$$$ integers $$$p_1, p_2, \dots, p_n$$$ ($$$1 \le p_i \le n$$$), representing the initial permutation. It is guaranteed that the answer exists and is unique. | standard output | |
PASSED | 8014701e62f19c3a9cedccd9a76deecf | train_003.jsonl | 1594996500 | A permutation of length $$$n$$$ is a sequence of integers from $$$1$$$ to $$$n$$$ of length $$$n$$$ containing each number exactly once. For example, $$$[1]$$$, $$$[4, 3, 5, 1, 2]$$$, $$$[3, 2, 1]$$$ are permutations, and $$$[1, 1]$$$, $$$[0, 1]$$$, $$$[2, 2, 1, 4]$$$ are not.There was a permutation $$$p[1 \dots n]$$$.... | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;
public class Q2{
static StringTokenizer st;
static InputStreamReader ir;
static BufferedReader br;
public static... | Java | ["5\n2\n1 1 2 2\n4\n1 3 1 4 3 4 2 2\n5\n1 2 1 2 3 4 3 5 4 5\n3\n1 2 3 1 2 3\n4\n2 3 2 4 1 3 4 1"] | 1 second | ["1 2 \n1 3 4 2 \n1 2 3 4 5 \n1 2 3 \n2 3 4 1"] | null | Java 8 | standard input | [
"greedy"
] | aaf91874cf5aa0fa302ffed2ccecdc76 | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 400$$$) — the number of test cases. Then $$$t$$$ test cases follow. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 50$$$) — the length of permutation. The second line of the test case contains $$$2n$$$ integers $$$a_1... | 800 | For each test case, print the answer: $$$n$$$ integers $$$p_1, p_2, \dots, p_n$$$ ($$$1 \le p_i \le n$$$), representing the initial permutation. It is guaranteed that the answer exists and is unique. | standard output | |
PASSED | 9b37d2df23175f04e6d647b1df61d63a | train_003.jsonl | 1594996500 | A permutation of length $$$n$$$ is a sequence of integers from $$$1$$$ to $$$n$$$ of length $$$n$$$ containing each number exactly once. For example, $$$[1]$$$, $$$[4, 3, 5, 1, 2]$$$, $$$[3, 2, 1]$$$ are permutations, and $$$[1, 1]$$$, $$$[0, 1]$$$, $$$[2, 2, 1, 4]$$$ are not.There was a permutation $$$p[1 \dots n]$$$.... | 256 megabytes | import java.util.ArrayList;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
public class Codeforce {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int numberOfTestCase = scanner.nextInt();
while (numberOfTestCase > 0){
... | Java | ["5\n2\n1 1 2 2\n4\n1 3 1 4 3 4 2 2\n5\n1 2 1 2 3 4 3 5 4 5\n3\n1 2 3 1 2 3\n4\n2 3 2 4 1 3 4 1"] | 1 second | ["1 2 \n1 3 4 2 \n1 2 3 4 5 \n1 2 3 \n2 3 4 1"] | null | Java 8 | standard input | [
"greedy"
] | aaf91874cf5aa0fa302ffed2ccecdc76 | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 400$$$) — the number of test cases. Then $$$t$$$ test cases follow. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 50$$$) — the length of permutation. The second line of the test case contains $$$2n$$$ integers $$$a_1... | 800 | For each test case, print the answer: $$$n$$$ integers $$$p_1, p_2, \dots, p_n$$$ ($$$1 \le p_i \le n$$$), representing the initial permutation. It is guaranteed that the answer exists and is unique. | standard output | |
PASSED | 31dca4856d9578fbfcaa81e2c6d3f4d2 | train_003.jsonl | 1594996500 | A permutation of length $$$n$$$ is a sequence of integers from $$$1$$$ to $$$n$$$ of length $$$n$$$ containing each number exactly once. For example, $$$[1]$$$, $$$[4, 3, 5, 1, 2]$$$, $$$[3, 2, 1]$$$ are permutations, and $$$[1, 1]$$$, $$$[0, 1]$$$, $$$[2, 2, 1, 4]$$$ are not.There was a permutation $$$p[1 \dots n]$$$.... | 256 megabytes | import java.util.*;
public class Main
{
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int t=sc.nextInt();
while(t>0)
{
int n=sc.nextInt();
Set<Integer> set=new LinkedHashSet<>();
for(int i=0;i<2*n;i++)
{
set.add(sc.nextI... | Java | ["5\n2\n1 1 2 2\n4\n1 3 1 4 3 4 2 2\n5\n1 2 1 2 3 4 3 5 4 5\n3\n1 2 3 1 2 3\n4\n2 3 2 4 1 3 4 1"] | 1 second | ["1 2 \n1 3 4 2 \n1 2 3 4 5 \n1 2 3 \n2 3 4 1"] | null | Java 8 | standard input | [
"greedy"
] | aaf91874cf5aa0fa302ffed2ccecdc76 | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 400$$$) — the number of test cases. Then $$$t$$$ test cases follow. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 50$$$) — the length of permutation. The second line of the test case contains $$$2n$$$ integers $$$a_1... | 800 | For each test case, print the answer: $$$n$$$ integers $$$p_1, p_2, \dots, p_n$$$ ($$$1 \le p_i \le n$$$), representing the initial permutation. It is guaranteed that the answer exists and is unique. | standard output | |
PASSED | b2b8ed7ad79cb8dd221ab8abe7c425a5 | train_003.jsonl | 1594996500 | A permutation of length $$$n$$$ is a sequence of integers from $$$1$$$ to $$$n$$$ of length $$$n$$$ containing each number exactly once. For example, $$$[1]$$$, $$$[4, 3, 5, 1, 2]$$$, $$$[3, 2, 1]$$$ are permutations, and $$$[1, 1]$$$, $$$[0, 1]$$$, $$$[2, 2, 1, 4]$$$ are not.There was a permutation $$$p[1 \dots n]$$$.... | 256 megabytes | import java.util.*;
public class Main
{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
while(t-->0)
{
int n = sc.nextInt();
int[] a = new int[2*n];
for(int i=0;i<2*n;i++)
a[i] = sc.nextInt();
HashSet<Intege... | Java | ["5\n2\n1 1 2 2\n4\n1 3 1 4 3 4 2 2\n5\n1 2 1 2 3 4 3 5 4 5\n3\n1 2 3 1 2 3\n4\n2 3 2 4 1 3 4 1"] | 1 second | ["1 2 \n1 3 4 2 \n1 2 3 4 5 \n1 2 3 \n2 3 4 1"] | null | Java 8 | standard input | [
"greedy"
] | aaf91874cf5aa0fa302ffed2ccecdc76 | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 400$$$) — the number of test cases. Then $$$t$$$ test cases follow. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 50$$$) — the length of permutation. The second line of the test case contains $$$2n$$$ integers $$$a_1... | 800 | For each test case, print the answer: $$$n$$$ integers $$$p_1, p_2, \dots, p_n$$$ ($$$1 \le p_i \le n$$$), representing the initial permutation. It is guaranteed that the answer exists and is unique. | standard output | |
PASSED | 696cd2e1a66c1a73bd587cc61f1ace17 | train_003.jsonl | 1594996500 | A permutation of length $$$n$$$ is a sequence of integers from $$$1$$$ to $$$n$$$ of length $$$n$$$ containing each number exactly once. For example, $$$[1]$$$, $$$[4, 3, 5, 1, 2]$$$, $$$[3, 2, 1]$$$ are permutations, and $$$[1, 1]$$$, $$$[0, 1]$$$, $$$[2, 2, 1, 4]$$$ are not.There was a permutation $$$p[1 \dots n]$$$.... | 256 megabytes | import java.util.*;
public class RestorethePermutationbyMerger {
public static void main(String args[])
{
Scanner sc=new Scanner(System.in);
int t=sc.nextInt();
for(int k=1;k<=t;k++)
{
int n=sc.nextInt();
int a[]=new int[2*n];
for(int i=0;i<2*n;i++)
a[i]=sc.nextInt();
LinkedHashSet<Integer> se... | Java | ["5\n2\n1 1 2 2\n4\n1 3 1 4 3 4 2 2\n5\n1 2 1 2 3 4 3 5 4 5\n3\n1 2 3 1 2 3\n4\n2 3 2 4 1 3 4 1"] | 1 second | ["1 2 \n1 3 4 2 \n1 2 3 4 5 \n1 2 3 \n2 3 4 1"] | null | Java 8 | standard input | [
"greedy"
] | aaf91874cf5aa0fa302ffed2ccecdc76 | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 400$$$) — the number of test cases. Then $$$t$$$ test cases follow. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 50$$$) — the length of permutation. The second line of the test case contains $$$2n$$$ integers $$$a_1... | 800 | For each test case, print the answer: $$$n$$$ integers $$$p_1, p_2, \dots, p_n$$$ ($$$1 \le p_i \le n$$$), representing the initial permutation. It is guaranteed that the answer exists and is unique. | standard output | |
PASSED | 3c5b5d5e5e91536fe5a671eb2ebd5bd6 | train_003.jsonl | 1594996500 | A permutation of length $$$n$$$ is a sequence of integers from $$$1$$$ to $$$n$$$ of length $$$n$$$ containing each number exactly once. For example, $$$[1]$$$, $$$[4, 3, 5, 1, 2]$$$, $$$[3, 2, 1]$$$ are permutations, and $$$[1, 1]$$$, $$$[0, 1]$$$, $$$[2, 2, 1, 4]$$$ are not.There was a permutation $$$p[1 \dots n]$$$.... | 256 megabytes | import java.util.*;
import java.io.*;
import java.math.*;
public class Solution
{
public static void main(String args[])
{
Scanner s=new Scanner(System.in);
int t=s.nextInt();
while(t-->0)
{
int n=s.nextInt();
int arr[]=new int[2*n];
for(int ... | Java | ["5\n2\n1 1 2 2\n4\n1 3 1 4 3 4 2 2\n5\n1 2 1 2 3 4 3 5 4 5\n3\n1 2 3 1 2 3\n4\n2 3 2 4 1 3 4 1"] | 1 second | ["1 2 \n1 3 4 2 \n1 2 3 4 5 \n1 2 3 \n2 3 4 1"] | null | Java 8 | standard input | [
"greedy"
] | aaf91874cf5aa0fa302ffed2ccecdc76 | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 400$$$) — the number of test cases. Then $$$t$$$ test cases follow. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 50$$$) — the length of permutation. The second line of the test case contains $$$2n$$$ integers $$$a_1... | 800 | For each test case, print the answer: $$$n$$$ integers $$$p_1, p_2, \dots, p_n$$$ ($$$1 \le p_i \le n$$$), representing the initial permutation. It is guaranteed that the answer exists and is unique. | standard output | |
PASSED | 0888924dda98fcfe1cb6367df4eec7c1 | train_003.jsonl | 1594996500 | A permutation of length $$$n$$$ is a sequence of integers from $$$1$$$ to $$$n$$$ of length $$$n$$$ containing each number exactly once. For example, $$$[1]$$$, $$$[4, 3, 5, 1, 2]$$$, $$$[3, 2, 1]$$$ are permutations, and $$$[1, 1]$$$, $$$[0, 1]$$$, $$$[2, 2, 1, 4]$$$ are not.There was a permutation $$$p[1 \dots n]$$$.... | 256 megabytes | import java.util.*;
public class cfperm{
public static void main(String[]args)
{
Scanner scn=new Scanner(System.in);
int tc=scn.nextInt();
for(int i9=0;i9<tc;i9++)
{
int n=scn.nextInt();
int[]inp=new int[2*n];
for(int i=0;i<2*... | Java | ["5\n2\n1 1 2 2\n4\n1 3 1 4 3 4 2 2\n5\n1 2 1 2 3 4 3 5 4 5\n3\n1 2 3 1 2 3\n4\n2 3 2 4 1 3 4 1"] | 1 second | ["1 2 \n1 3 4 2 \n1 2 3 4 5 \n1 2 3 \n2 3 4 1"] | null | Java 8 | standard input | [
"greedy"
] | aaf91874cf5aa0fa302ffed2ccecdc76 | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 400$$$) — the number of test cases. Then $$$t$$$ test cases follow. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 50$$$) — the length of permutation. The second line of the test case contains $$$2n$$$ integers $$$a_1... | 800 | For each test case, print the answer: $$$n$$$ integers $$$p_1, p_2, \dots, p_n$$$ ($$$1 \le p_i \le n$$$), representing the initial permutation. It is guaranteed that the answer exists and is unique. | standard output | |
PASSED | 5fd42bc32a71224849226428083f79e7 | train_003.jsonl | 1594996500 | A permutation of length $$$n$$$ is a sequence of integers from $$$1$$$ to $$$n$$$ of length $$$n$$$ containing each number exactly once. For example, $$$[1]$$$, $$$[4, 3, 5, 1, 2]$$$, $$$[3, 2, 1]$$$ are permutations, and $$$[1, 1]$$$, $$$[0, 1]$$$, $$$[2, 2, 1, 4]$$$ are not.There was a permutation $$$p[1 \dots n]$$$.... | 256 megabytes | import java.util.*;
/**
*
* @author Aaryan
*/
public class Test {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int tc = input.nextInt();
while(tc-->0){
HashMap<Integer,Integer> map = new HashMap<>();
int n = input.nextInt();
... | Java | ["5\n2\n1 1 2 2\n4\n1 3 1 4 3 4 2 2\n5\n1 2 1 2 3 4 3 5 4 5\n3\n1 2 3 1 2 3\n4\n2 3 2 4 1 3 4 1"] | 1 second | ["1 2 \n1 3 4 2 \n1 2 3 4 5 \n1 2 3 \n2 3 4 1"] | null | Java 8 | standard input | [
"greedy"
] | aaf91874cf5aa0fa302ffed2ccecdc76 | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 400$$$) — the number of test cases. Then $$$t$$$ test cases follow. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 50$$$) — the length of permutation. The second line of the test case contains $$$2n$$$ integers $$$a_1... | 800 | For each test case, print the answer: $$$n$$$ integers $$$p_1, p_2, \dots, p_n$$$ ($$$1 \le p_i \le n$$$), representing the initial permutation. It is guaranteed that the answer exists and is unique. | standard output | |
PASSED | 6c17cc8610178442543a1c0c08ffbe09 | train_003.jsonl | 1594996500 | A permutation of length $$$n$$$ is a sequence of integers from $$$1$$$ to $$$n$$$ of length $$$n$$$ containing each number exactly once. For example, $$$[1]$$$, $$$[4, 3, 5, 1, 2]$$$, $$$[3, 2, 1]$$$ are permutations, and $$$[1, 1]$$$, $$$[0, 1]$$$, $$$[2, 2, 1, 4]$$$ are not.There was a permutation $$$p[1 \dots n]$$$.... | 256 megabytes | import java.util.*;
/**
*
* @author Aaryan
*/
public class Test {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int tc = input.nextInt();
while(tc-->0){
int n = input.nextInt();
int a [] = new int[2*n];
int k [] = n... | Java | ["5\n2\n1 1 2 2\n4\n1 3 1 4 3 4 2 2\n5\n1 2 1 2 3 4 3 5 4 5\n3\n1 2 3 1 2 3\n4\n2 3 2 4 1 3 4 1"] | 1 second | ["1 2 \n1 3 4 2 \n1 2 3 4 5 \n1 2 3 \n2 3 4 1"] | null | Java 8 | standard input | [
"greedy"
] | aaf91874cf5aa0fa302ffed2ccecdc76 | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 400$$$) — the number of test cases. Then $$$t$$$ test cases follow. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 50$$$) — the length of permutation. The second line of the test case contains $$$2n$$$ integers $$$a_1... | 800 | For each test case, print the answer: $$$n$$$ integers $$$p_1, p_2, \dots, p_n$$$ ($$$1 \le p_i \le n$$$), representing the initial permutation. It is guaranteed that the answer exists and is unique. | standard output | |
PASSED | 2b1cf78bcdd96f219f9f9135c25c0160 | train_003.jsonl | 1594996500 | A permutation of length $$$n$$$ is a sequence of integers from $$$1$$$ to $$$n$$$ of length $$$n$$$ containing each number exactly once. For example, $$$[1]$$$, $$$[4, 3, 5, 1, 2]$$$, $$$[3, 2, 1]$$$ are permutations, and $$$[1, 1]$$$, $$$[0, 1]$$$, $$$[2, 2, 1, 4]$$$ are not.There was a permutation $$$p[1 \dots n]$$$.... | 256 megabytes | import java.util.*;
import java.util.ArrayList;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner (System.in);
int t,n,m;
t = sc.nextInt();
while(t-->0){
n = sc.nextInt();
ArrayList<Integer> s = new ArrayList<Integer>();
n*=2;
while(n-->0) {
... | Java | ["5\n2\n1 1 2 2\n4\n1 3 1 4 3 4 2 2\n5\n1 2 1 2 3 4 3 5 4 5\n3\n1 2 3 1 2 3\n4\n2 3 2 4 1 3 4 1"] | 1 second | ["1 2 \n1 3 4 2 \n1 2 3 4 5 \n1 2 3 \n2 3 4 1"] | null | Java 8 | standard input | [
"greedy"
] | aaf91874cf5aa0fa302ffed2ccecdc76 | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 400$$$) — the number of test cases. Then $$$t$$$ test cases follow. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 50$$$) — the length of permutation. The second line of the test case contains $$$2n$$$ integers $$$a_1... | 800 | For each test case, print the answer: $$$n$$$ integers $$$p_1, p_2, \dots, p_n$$$ ($$$1 \le p_i \le n$$$), representing the initial permutation. It is guaranteed that the answer exists and is unique. | standard output | |
PASSED | 761811eb8abef31cc54694e3932c0150 | train_003.jsonl | 1594996500 | A permutation of length $$$n$$$ is a sequence of integers from $$$1$$$ to $$$n$$$ of length $$$n$$$ containing each number exactly once. For example, $$$[1]$$$, $$$[4, 3, 5, 1, 2]$$$, $$$[3, 2, 1]$$$ are permutations, and $$$[1, 1]$$$, $$$[0, 1]$$$, $$$[2, 2, 1, 4]$$$ are not.There was a permutation $$$p[1 \dots n]$$$.... | 256 megabytes | import java.util.*;
import java.io.*;
public class Test{
public static void main(String[] args){
Scanner scn =new Scanner(System.in);
int t = scn.nextInt();
for(int i=0;i<t;i++){
int n = scn.nextInt();
int arr[] = new int[2*n];
for(int j=0; j<2*n; j++){
... | Java | ["5\n2\n1 1 2 2\n4\n1 3 1 4 3 4 2 2\n5\n1 2 1 2 3 4 3 5 4 5\n3\n1 2 3 1 2 3\n4\n2 3 2 4 1 3 4 1"] | 1 second | ["1 2 \n1 3 4 2 \n1 2 3 4 5 \n1 2 3 \n2 3 4 1"] | null | Java 8 | standard input | [
"greedy"
] | aaf91874cf5aa0fa302ffed2ccecdc76 | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 400$$$) — the number of test cases. Then $$$t$$$ test cases follow. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 50$$$) — the length of permutation. The second line of the test case contains $$$2n$$$ integers $$$a_1... | 800 | For each test case, print the answer: $$$n$$$ integers $$$p_1, p_2, \dots, p_n$$$ ($$$1 \le p_i \le n$$$), representing the initial permutation. It is guaranteed that the answer exists and is unique. | standard output | |
PASSED | 95002b983694f837de4c44f9eb3b5010 | train_003.jsonl | 1594996500 | A permutation of length $$$n$$$ is a sequence of integers from $$$1$$$ to $$$n$$$ of length $$$n$$$ containing each number exactly once. For example, $$$[1]$$$, $$$[4, 3, 5, 1, 2]$$$, $$$[3, 2, 1]$$$ are permutations, and $$$[1, 1]$$$, $$$[0, 1]$$$, $$$[2, 2, 1, 4]$$$ are not.There was a permutation $$$p[1 \dots n]$$$.... | 256 megabytes | import java.util.*;
public class B656 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int t=sc.nextInt();
while(t-->0) {
int n=sc.nextInt();
Set<Integer> h= new LinkedHashSet<Integer>();
for(int i=0;i<2*n;i++) {
h.add(sc.nextInt());
}
Iterator<Integer> i =h.itera... | Java | ["5\n2\n1 1 2 2\n4\n1 3 1 4 3 4 2 2\n5\n1 2 1 2 3 4 3 5 4 5\n3\n1 2 3 1 2 3\n4\n2 3 2 4 1 3 4 1"] | 1 second | ["1 2 \n1 3 4 2 \n1 2 3 4 5 \n1 2 3 \n2 3 4 1"] | null | Java 8 | standard input | [
"greedy"
] | aaf91874cf5aa0fa302ffed2ccecdc76 | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 400$$$) — the number of test cases. Then $$$t$$$ test cases follow. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 50$$$) — the length of permutation. The second line of the test case contains $$$2n$$$ integers $$$a_1... | 800 | For each test case, print the answer: $$$n$$$ integers $$$p_1, p_2, \dots, p_n$$$ ($$$1 \le p_i \le n$$$), representing the initial permutation. It is guaranteed that the answer exists and is unique. | standard output | |
PASSED | 46f04211dca2790f88ef77e59f6c08ea | train_003.jsonl | 1594996500 | A permutation of length $$$n$$$ is a sequence of integers from $$$1$$$ to $$$n$$$ of length $$$n$$$ containing each number exactly once. For example, $$$[1]$$$, $$$[4, 3, 5, 1, 2]$$$, $$$[3, 2, 1]$$$ are permutations, and $$$[1, 1]$$$, $$$[0, 1]$$$, $$$[2, 2, 1, 4]$$$ are not.There was a permutation $$$p[1 \dots n]$$$.... | 256 megabytes | import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int t = in.nextInt();
while (t-- > 0) {
int n = in.nextInt();
Set<Integer> set = new LinkedHashSet<>();
... | Java | ["5\n2\n1 1 2 2\n4\n1 3 1 4 3 4 2 2\n5\n1 2 1 2 3 4 3 5 4 5\n3\n1 2 3 1 2 3\n4\n2 3 2 4 1 3 4 1"] | 1 second | ["1 2 \n1 3 4 2 \n1 2 3 4 5 \n1 2 3 \n2 3 4 1"] | null | Java 8 | standard input | [
"greedy"
] | aaf91874cf5aa0fa302ffed2ccecdc76 | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 400$$$) — the number of test cases. Then $$$t$$$ test cases follow. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 50$$$) — the length of permutation. The second line of the test case contains $$$2n$$$ integers $$$a_1... | 800 | For each test case, print the answer: $$$n$$$ integers $$$p_1, p_2, \dots, p_n$$$ ($$$1 \le p_i \le n$$$), representing the initial permutation. It is guaranteed that the answer exists and is unique. | standard output | |
PASSED | 3e2fda38e721b48679bb0e94b4f8a82d | train_003.jsonl | 1594996500 | A permutation of length $$$n$$$ is a sequence of integers from $$$1$$$ to $$$n$$$ of length $$$n$$$ containing each number exactly once. For example, $$$[1]$$$, $$$[4, 3, 5, 1, 2]$$$, $$$[3, 2, 1]$$$ are permutations, and $$$[1, 1]$$$, $$$[0, 1]$$$, $$$[2, 2, 1, 4]$$$ are not.There was a permutation $$$p[1 \dots n]$$$.... | 256 megabytes | import java.util.HashSet;
import java.util.Scanner;
public class ProblemB {
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
int t=sc.nextInt();
while(t-->0){
int n=sc.nextInt();
HashSet<Integer> set=new HashSet<>();
int[] res=ne... | Java | ["5\n2\n1 1 2 2\n4\n1 3 1 4 3 4 2 2\n5\n1 2 1 2 3 4 3 5 4 5\n3\n1 2 3 1 2 3\n4\n2 3 2 4 1 3 4 1"] | 1 second | ["1 2 \n1 3 4 2 \n1 2 3 4 5 \n1 2 3 \n2 3 4 1"] | null | Java 8 | standard input | [
"greedy"
] | aaf91874cf5aa0fa302ffed2ccecdc76 | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 400$$$) — the number of test cases. Then $$$t$$$ test cases follow. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 50$$$) — the length of permutation. The second line of the test case contains $$$2n$$$ integers $$$a_1... | 800 | For each test case, print the answer: $$$n$$$ integers $$$p_1, p_2, \dots, p_n$$$ ($$$1 \le p_i \le n$$$), representing the initial permutation. It is guaranteed that the answer exists and is unique. | standard output | |
PASSED | 88eca8938b57510273aa6f1baba5ded7 | train_003.jsonl | 1594996500 | A permutation of length $$$n$$$ is a sequence of integers from $$$1$$$ to $$$n$$$ of length $$$n$$$ containing each number exactly once. For example, $$$[1]$$$, $$$[4, 3, 5, 1, 2]$$$, $$$[3, 2, 1]$$$ are permutations, and $$$[1, 1]$$$, $$$[0, 1]$$$, $$$[2, 2, 1, 4]$$$ are not.There was a permutation $$$p[1 \dots n]$$$.... | 256 megabytes | import java.util.*;
public class Main {
public static void main(String args[]) {
Scanner s = new Scanner(System.in);
int t = s.nextInt();
while(t-- != 0){
int n = s.nextInt();
HashSet<Integer> set = new HashSet<>();
for(int i = 0; i < 2 * n; i++){
... | Java | ["5\n2\n1 1 2 2\n4\n1 3 1 4 3 4 2 2\n5\n1 2 1 2 3 4 3 5 4 5\n3\n1 2 3 1 2 3\n4\n2 3 2 4 1 3 4 1"] | 1 second | ["1 2 \n1 3 4 2 \n1 2 3 4 5 \n1 2 3 \n2 3 4 1"] | null | Java 8 | standard input | [
"greedy"
] | aaf91874cf5aa0fa302ffed2ccecdc76 | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 400$$$) — the number of test cases. Then $$$t$$$ test cases follow. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 50$$$) — the length of permutation. The second line of the test case contains $$$2n$$$ integers $$$a_1... | 800 | For each test case, print the answer: $$$n$$$ integers $$$p_1, p_2, \dots, p_n$$$ ($$$1 \le p_i \le n$$$), representing the initial permutation. It is guaranteed that the answer exists and is unique. | standard output | |
PASSED | d95ae16f797753c31aeaf92c9aa03cbb | train_003.jsonl | 1594996500 | A permutation of length $$$n$$$ is a sequence of integers from $$$1$$$ to $$$n$$$ of length $$$n$$$ containing each number exactly once. For example, $$$[1]$$$, $$$[4, 3, 5, 1, 2]$$$, $$$[3, 2, 1]$$$ are permutations, and $$$[1, 1]$$$, $$$[0, 1]$$$, $$$[2, 2, 1, 4]$$$ are not.There was a permutation $$$p[1 \dots n]$$$.... | 256 megabytes | import java.io.*;
import java.util.*;
public class Mohammad {
public static void Mohammad_AboHasan() throws IOException {
FastReader fr = new FastReader();
int t = fr.nextInt();
while(t-->0){
int n = fr.nextInt();
Set<Integer> set = new HashSet<>();
Array... | Java | ["5\n2\n1 1 2 2\n4\n1 3 1 4 3 4 2 2\n5\n1 2 1 2 3 4 3 5 4 5\n3\n1 2 3 1 2 3\n4\n2 3 2 4 1 3 4 1"] | 1 second | ["1 2 \n1 3 4 2 \n1 2 3 4 5 \n1 2 3 \n2 3 4 1"] | null | Java 8 | standard input | [
"greedy"
] | aaf91874cf5aa0fa302ffed2ccecdc76 | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 400$$$) — the number of test cases. Then $$$t$$$ test cases follow. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 50$$$) — the length of permutation. The second line of the test case contains $$$2n$$$ integers $$$a_1... | 800 | For each test case, print the answer: $$$n$$$ integers $$$p_1, p_2, \dots, p_n$$$ ($$$1 \le p_i \le n$$$), representing the initial permutation. It is guaranteed that the answer exists and is unique. | standard output | |
PASSED | aa0c7c0f822bb0d22bc3c28bdb21f6d2 | train_003.jsonl | 1594996500 | A permutation of length $$$n$$$ is a sequence of integers from $$$1$$$ to $$$n$$$ of length $$$n$$$ containing each number exactly once. For example, $$$[1]$$$, $$$[4, 3, 5, 1, 2]$$$, $$$[3, 2, 1]$$$ are permutations, and $$$[1, 1]$$$, $$$[0, 1]$$$, $$$[2, 2, 1, 4]$$$ are not.There was a permutation $$$p[1 \dots n]$$$.... | 256 megabytes | import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
public class RestorePermutation {
public static BufferedReader br;
public static void main(String[] args) {
br = new BufferedReader(new InputStreamReader(System.in));
int test = ... | Java | ["5\n2\n1 1 2 2\n4\n1 3 1 4 3 4 2 2\n5\n1 2 1 2 3 4 3 5 4 5\n3\n1 2 3 1 2 3\n4\n2 3 2 4 1 3 4 1"] | 1 second | ["1 2 \n1 3 4 2 \n1 2 3 4 5 \n1 2 3 \n2 3 4 1"] | null | Java 8 | standard input | [
"greedy"
] | aaf91874cf5aa0fa302ffed2ccecdc76 | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 400$$$) — the number of test cases. Then $$$t$$$ test cases follow. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 50$$$) — the length of permutation. The second line of the test case contains $$$2n$$$ integers $$$a_1... | 800 | For each test case, print the answer: $$$n$$$ integers $$$p_1, p_2, \dots, p_n$$$ ($$$1 \le p_i \le n$$$), representing the initial permutation. It is guaranteed that the answer exists and is unique. | standard output | |
PASSED | 91ee969a059ec20c4baf3e67ca22ff08 | train_003.jsonl | 1594996500 | A permutation of length $$$n$$$ is a sequence of integers from $$$1$$$ to $$$n$$$ of length $$$n$$$ containing each number exactly once. For example, $$$[1]$$$, $$$[4, 3, 5, 1, 2]$$$, $$$[3, 2, 1]$$$ are permutations, and $$$[1, 1]$$$, $$$[0, 1]$$$, $$$[2, 2, 1, 4]$$$ are not.There was a permutation $$$p[1 \dots n]$$$.... | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public final class RestoreThePermutationByMerger {
private static final FastReader fr = new FastReader();
public static void main(String[] args) {
int t = fr.nextInt();
... | Java | ["5\n2\n1 1 2 2\n4\n1 3 1 4 3 4 2 2\n5\n1 2 1 2 3 4 3 5 4 5\n3\n1 2 3 1 2 3\n4\n2 3 2 4 1 3 4 1"] | 1 second | ["1 2 \n1 3 4 2 \n1 2 3 4 5 \n1 2 3 \n2 3 4 1"] | null | Java 8 | standard input | [
"greedy"
] | aaf91874cf5aa0fa302ffed2ccecdc76 | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 400$$$) — the number of test cases. Then $$$t$$$ test cases follow. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 50$$$) — the length of permutation. The second line of the test case contains $$$2n$$$ integers $$$a_1... | 800 | For each test case, print the answer: $$$n$$$ integers $$$p_1, p_2, \dots, p_n$$$ ($$$1 \le p_i \le n$$$), representing the initial permutation. It is guaranteed that the answer exists and is unique. | standard output | |
PASSED | 87484bc5426d6ac83953cf38115bb2ea | train_003.jsonl | 1594996500 | A permutation of length $$$n$$$ is a sequence of integers from $$$1$$$ to $$$n$$$ of length $$$n$$$ containing each number exactly once. For example, $$$[1]$$$, $$$[4, 3, 5, 1, 2]$$$, $$$[3, 2, 1]$$$ are permutations, and $$$[1, 1]$$$, $$$[0, 1]$$$, $$$[2, 2, 1, 4]$$$ are not.There was a permutation $$$p[1 \dots n]$$$.... | 256 megabytes | import java.io.*;
import java.util.*;
public class B {
private final FastReader fr = new FastReader();
public static void main(String[] args) {
new B().solve();
}
private void solve() {
int t = fr.nextInt();
while (t-- > 0) {
int n = fr.nextInt();
int[... | Java | ["5\n2\n1 1 2 2\n4\n1 3 1 4 3 4 2 2\n5\n1 2 1 2 3 4 3 5 4 5\n3\n1 2 3 1 2 3\n4\n2 3 2 4 1 3 4 1"] | 1 second | ["1 2 \n1 3 4 2 \n1 2 3 4 5 \n1 2 3 \n2 3 4 1"] | null | Java 8 | standard input | [
"greedy"
] | aaf91874cf5aa0fa302ffed2ccecdc76 | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 400$$$) — the number of test cases. Then $$$t$$$ test cases follow. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 50$$$) — the length of permutation. The second line of the test case contains $$$2n$$$ integers $$$a_1... | 800 | For each test case, print the answer: $$$n$$$ integers $$$p_1, p_2, \dots, p_n$$$ ($$$1 \le p_i \le n$$$), representing the initial permutation. It is guaranteed that the answer exists and is unique. | standard output | |
PASSED | e0941c1f7d9b3058fb708b619b577832 | train_003.jsonl | 1594996500 | A permutation of length $$$n$$$ is a sequence of integers from $$$1$$$ to $$$n$$$ of length $$$n$$$ containing each number exactly once. For example, $$$[1]$$$, $$$[4, 3, 5, 1, 2]$$$, $$$[3, 2, 1]$$$ are permutations, and $$$[1, 1]$$$, $$$[0, 1]$$$, $$$[2, 2, 1, 4]$$$ are not.There was a permutation $$$p[1 \dots n]$$$.... | 256 megabytes | import java.util.ArrayList;
import java.util.Scanner;
import static java.util.Collections.sort;
public class Codeforces {
public static void main(String[] args) {
try {
Scanner sc = new Scanner(System.in);
ArrayList<Integer> a = new ArrayList<>();
int t = sc.nextInt();... | Java | ["5\n2\n1 1 2 2\n4\n1 3 1 4 3 4 2 2\n5\n1 2 1 2 3 4 3 5 4 5\n3\n1 2 3 1 2 3\n4\n2 3 2 4 1 3 4 1"] | 1 second | ["1 2 \n1 3 4 2 \n1 2 3 4 5 \n1 2 3 \n2 3 4 1"] | null | Java 8 | standard input | [
"greedy"
] | aaf91874cf5aa0fa302ffed2ccecdc76 | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 400$$$) — the number of test cases. Then $$$t$$$ test cases follow. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 50$$$) — the length of permutation. The second line of the test case contains $$$2n$$$ integers $$$a_1... | 800 | For each test case, print the answer: $$$n$$$ integers $$$p_1, p_2, \dots, p_n$$$ ($$$1 \le p_i \le n$$$), representing the initial permutation. It is guaranteed that the answer exists and is unique. | standard output | |
PASSED | 8e8236cf5382ef5001b39f3b946be65f | train_003.jsonl | 1594996500 | A permutation of length $$$n$$$ is a sequence of integers from $$$1$$$ to $$$n$$$ of length $$$n$$$ containing each number exactly once. For example, $$$[1]$$$, $$$[4, 3, 5, 1, 2]$$$, $$$[3, 2, 1]$$$ are permutations, and $$$[1, 1]$$$, $$$[0, 1]$$$, $$$[2, 2, 1, 4]$$$ are not.There was a permutation $$$p[1 \dots n]$$$.... | 256 megabytes | import java.util.*;
import java.lang.*;
public class RP{
public static void main(String[] agrs)
{
Scanner sc=new Scanner(System.in);
int t=sc.nextInt();
ArrayList<Integer> a=new ArrayList<Integer>();
for(int j=0;j<t;j++)
{
int n=sc.nextInt();
int[] a1= new int[2*n];
int c=0;
HashMap<Integer,Inte... | Java | ["5\n2\n1 1 2 2\n4\n1 3 1 4 3 4 2 2\n5\n1 2 1 2 3 4 3 5 4 5\n3\n1 2 3 1 2 3\n4\n2 3 2 4 1 3 4 1"] | 1 second | ["1 2 \n1 3 4 2 \n1 2 3 4 5 \n1 2 3 \n2 3 4 1"] | null | Java 8 | standard input | [
"greedy"
] | aaf91874cf5aa0fa302ffed2ccecdc76 | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 400$$$) — the number of test cases. Then $$$t$$$ test cases follow. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 50$$$) — the length of permutation. The second line of the test case contains $$$2n$$$ integers $$$a_1... | 800 | For each test case, print the answer: $$$n$$$ integers $$$p_1, p_2, \dots, p_n$$$ ($$$1 \le p_i \le n$$$), representing the initial permutation. It is guaranteed that the answer exists and is unique. | standard output | |
PASSED | 0b5755758c2e4f218f92017b4a73bc11 | train_003.jsonl | 1594996500 | A permutation of length $$$n$$$ is a sequence of integers from $$$1$$$ to $$$n$$$ of length $$$n$$$ containing each number exactly once. For example, $$$[1]$$$, $$$[4, 3, 5, 1, 2]$$$, $$$[3, 2, 1]$$$ are permutations, and $$$[1, 1]$$$, $$$[0, 1]$$$, $$$[2, 2, 1, 4]$$$ are not.There was a permutation $$$p[1 \dots n]$$$.... | 256 megabytes | import java.io.*;
import java.util.*;
public class test
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
String n = sc.nextLine();
for (int i = 0; i<Integer.parseInt(n); i++) {
String j = sc.nextLine();
String[] dat... | Java | ["5\n2\n1 1 2 2\n4\n1 3 1 4 3 4 2 2\n5\n1 2 1 2 3 4 3 5 4 5\n3\n1 2 3 1 2 3\n4\n2 3 2 4 1 3 4 1"] | 1 second | ["1 2 \n1 3 4 2 \n1 2 3 4 5 \n1 2 3 \n2 3 4 1"] | null | Java 8 | standard input | [
"greedy"
] | aaf91874cf5aa0fa302ffed2ccecdc76 | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 400$$$) — the number of test cases. Then $$$t$$$ test cases follow. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 50$$$) — the length of permutation. The second line of the test case contains $$$2n$$$ integers $$$a_1... | 800 | For each test case, print the answer: $$$n$$$ integers $$$p_1, p_2, \dots, p_n$$$ ($$$1 \le p_i \le n$$$), representing the initial permutation. It is guaranteed that the answer exists and is unique. | standard output | |
PASSED | 326f44b95570462db0ae020f072850ff | train_003.jsonl | 1594996500 | A permutation of length $$$n$$$ is a sequence of integers from $$$1$$$ to $$$n$$$ of length $$$n$$$ containing each number exactly once. For example, $$$[1]$$$, $$$[4, 3, 5, 1, 2]$$$, $$$[3, 2, 1]$$$ are permutations, and $$$[1, 1]$$$, $$$[0, 1]$$$, $$$[2, 2, 1, 4]$$$ are not.There was a permutation $$$p[1 \dots n]$$$.... | 256 megabytes | import java.util.*;
public class Solution
{
public static void fun()
{
Scanner s=new Scanner(System.in);
}
public static void main(String[] args)
{
Scanner s=new Scanner(System.in);
int t=s.nextInt();
for(int i=0;i<t;i++)
{
int n=s... | Java | ["5\n2\n1 1 2 2\n4\n1 3 1 4 3 4 2 2\n5\n1 2 1 2 3 4 3 5 4 5\n3\n1 2 3 1 2 3\n4\n2 3 2 4 1 3 4 1"] | 1 second | ["1 2 \n1 3 4 2 \n1 2 3 4 5 \n1 2 3 \n2 3 4 1"] | null | Java 8 | standard input | [
"greedy"
] | aaf91874cf5aa0fa302ffed2ccecdc76 | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 400$$$) — the number of test cases. Then $$$t$$$ test cases follow. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 50$$$) — the length of permutation. The second line of the test case contains $$$2n$$$ integers $$$a_1... | 800 | For each test case, print the answer: $$$n$$$ integers $$$p_1, p_2, \dots, p_n$$$ ($$$1 \le p_i \le n$$$), representing the initial permutation. It is guaranteed that the answer exists and is unique. | standard output | |
PASSED | e6f4c434d9d8b46912254690b2aa5574 | train_003.jsonl | 1594996500 | A permutation of length $$$n$$$ is a sequence of integers from $$$1$$$ to $$$n$$$ of length $$$n$$$ containing each number exactly once. For example, $$$[1]$$$, $$$[4, 3, 5, 1, 2]$$$, $$$[3, 2, 1]$$$ are permutations, and $$$[1, 1]$$$, $$$[0, 1]$$$, $$$[2, 2, 1, 4]$$$ are not.There was a permutation $$$p[1 \dots n]$$$.... | 256 megabytes | import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
int tt=in.nextInt();
for(int t=0;t<tt;t++){
int n=in.nextInt();
int[] merge=new int[n];
ArrayList<Integer> l=new ArrayList<>();
for(int i=0... | Java | ["5\n2\n1 1 2 2\n4\n1 3 1 4 3 4 2 2\n5\n1 2 1 2 3 4 3 5 4 5\n3\n1 2 3 1 2 3\n4\n2 3 2 4 1 3 4 1"] | 1 second | ["1 2 \n1 3 4 2 \n1 2 3 4 5 \n1 2 3 \n2 3 4 1"] | null | Java 8 | standard input | [
"greedy"
] | aaf91874cf5aa0fa302ffed2ccecdc76 | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 400$$$) — the number of test cases. Then $$$t$$$ test cases follow. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 50$$$) — the length of permutation. The second line of the test case contains $$$2n$$$ integers $$$a_1... | 800 | For each test case, print the answer: $$$n$$$ integers $$$p_1, p_2, \dots, p_n$$$ ($$$1 \le p_i \le n$$$), representing the initial permutation. It is guaranteed that the answer exists and is unique. | standard output | |
PASSED | 6e91c91d69afba944b70b6f17e311efc | train_003.jsonl | 1594996500 | A permutation of length $$$n$$$ is a sequence of integers from $$$1$$$ to $$$n$$$ of length $$$n$$$ containing each number exactly once. For example, $$$[1]$$$, $$$[4, 3, 5, 1, 2]$$$, $$$[3, 2, 1]$$$ are permutations, and $$$[1, 1]$$$, $$$[0, 1]$$$, $$$[2, 2, 1, 4]$$$ are not.There was a permutation $$$p[1 \dots n]$$$.... | 256 megabytes | import java.util.Scanner;
import java.util.Set;
import java.util.HashSet;
/**
*
* @author lkoed
*/
public class Main {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int cases = sc.nextInt();
... | Java | ["5\n2\n1 1 2 2\n4\n1 3 1 4 3 4 2 2\n5\n1 2 1 2 3 4 3 5 4 5\n3\n1 2 3 1 2 3\n4\n2 3 2 4 1 3 4 1"] | 1 second | ["1 2 \n1 3 4 2 \n1 2 3 4 5 \n1 2 3 \n2 3 4 1"] | null | Java 8 | standard input | [
"greedy"
] | aaf91874cf5aa0fa302ffed2ccecdc76 | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 400$$$) — the number of test cases. Then $$$t$$$ test cases follow. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 50$$$) — the length of permutation. The second line of the test case contains $$$2n$$$ integers $$$a_1... | 800 | For each test case, print the answer: $$$n$$$ integers $$$p_1, p_2, \dots, p_n$$$ ($$$1 \le p_i \le n$$$), representing the initial permutation. It is guaranteed that the answer exists and is unique. | standard output | |
PASSED | 7189b8f55da81e45f60a9f2d2cbd4bc1 | train_003.jsonl | 1594996500 | A permutation of length $$$n$$$ is a sequence of integers from $$$1$$$ to $$$n$$$ of length $$$n$$$ containing each number exactly once. For example, $$$[1]$$$, $$$[4, 3, 5, 1, 2]$$$, $$$[3, 2, 1]$$$ are permutations, and $$$[1, 1]$$$, $$$[0, 1]$$$, $$$[2, 2, 1, 4]$$$ are not.There was a permutation $$$p[1 \dots n]$$$.... | 256 megabytes | import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.nio.Buffer;
import java.util.*;
public class ssss {
public static void main(String[] args){
try {
PrintWriter out=new PrintWriter(System.out,true);
B... | Java | ["5\n2\n1 1 2 2\n4\n1 3 1 4 3 4 2 2\n5\n1 2 1 2 3 4 3 5 4 5\n3\n1 2 3 1 2 3\n4\n2 3 2 4 1 3 4 1"] | 1 second | ["1 2 \n1 3 4 2 \n1 2 3 4 5 \n1 2 3 \n2 3 4 1"] | null | Java 8 | standard input | [
"greedy"
] | aaf91874cf5aa0fa302ffed2ccecdc76 | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 400$$$) — the number of test cases. Then $$$t$$$ test cases follow. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 50$$$) — the length of permutation. The second line of the test case contains $$$2n$$$ integers $$$a_1... | 800 | For each test case, print the answer: $$$n$$$ integers $$$p_1, p_2, \dots, p_n$$$ ($$$1 \le p_i \le n$$$), representing the initial permutation. It is guaranteed that the answer exists and is unique. | standard output | |
PASSED | 19f6edd0478e5d1753845b2a96c62d1a | train_003.jsonl | 1594996500 | A permutation of length $$$n$$$ is a sequence of integers from $$$1$$$ to $$$n$$$ of length $$$n$$$ containing each number exactly once. For example, $$$[1]$$$, $$$[4, 3, 5, 1, 2]$$$, $$$[3, 2, 1]$$$ are permutations, and $$$[1, 1]$$$, $$$[0, 1]$$$, $$$[2, 2, 1, 4]$$$ are not.There was a permutation $$$p[1 \dots n]$$$.... | 256 megabytes | import java.util.*;
public class Main
{
public static void main(String[] args) {
Scanner s=new Scanner(System.in);
int t=s.nextInt();
while(t-->0)
{
int n=s.nextInt();
int arr[]=new int[2*n];
for(int i=0;i<arr.length;i++)
{
arr[i]=s.nextInt();
... | Java | ["5\n2\n1 1 2 2\n4\n1 3 1 4 3 4 2 2\n5\n1 2 1 2 3 4 3 5 4 5\n3\n1 2 3 1 2 3\n4\n2 3 2 4 1 3 4 1"] | 1 second | ["1 2 \n1 3 4 2 \n1 2 3 4 5 \n1 2 3 \n2 3 4 1"] | null | Java 8 | standard input | [
"greedy"
] | aaf91874cf5aa0fa302ffed2ccecdc76 | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 400$$$) — the number of test cases. Then $$$t$$$ test cases follow. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 50$$$) — the length of permutation. The second line of the test case contains $$$2n$$$ integers $$$a_1... | 800 | For each test case, print the answer: $$$n$$$ integers $$$p_1, p_2, \dots, p_n$$$ ($$$1 \le p_i \le n$$$), representing the initial permutation. It is guaranteed that the answer exists and is unique. | standard output | |
PASSED | 92c1bea49d9615d70d48472e7993b2c8 | train_003.jsonl | 1594996500 | A permutation of length $$$n$$$ is a sequence of integers from $$$1$$$ to $$$n$$$ of length $$$n$$$ containing each number exactly once. For example, $$$[1]$$$, $$$[4, 3, 5, 1, 2]$$$, $$$[3, 2, 1]$$$ are permutations, and $$$[1, 1]$$$, $$$[0, 1]$$$, $$$[2, 2, 1, 4]$$$ are not.There was a permutation $$$p[1 \dots n]$$$.... | 256 megabytes | import java.util.*;
public class Main{
public static void main(String[] args){
int t;
Scanner s=new Scanner(System.in);
t=s.nextInt();
while(t!=0){
int n=s.nextInt();
int arr[]=new int[2*n];
for(int i=0;i<2*n;i++)
{
arr[... | Java | ["5\n2\n1 1 2 2\n4\n1 3 1 4 3 4 2 2\n5\n1 2 1 2 3 4 3 5 4 5\n3\n1 2 3 1 2 3\n4\n2 3 2 4 1 3 4 1"] | 1 second | ["1 2 \n1 3 4 2 \n1 2 3 4 5 \n1 2 3 \n2 3 4 1"] | null | Java 8 | standard input | [
"greedy"
] | aaf91874cf5aa0fa302ffed2ccecdc76 | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 400$$$) — the number of test cases. Then $$$t$$$ test cases follow. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 50$$$) — the length of permutation. The second line of the test case contains $$$2n$$$ integers $$$a_1... | 800 | For each test case, print the answer: $$$n$$$ integers $$$p_1, p_2, \dots, p_n$$$ ($$$1 \le p_i \le n$$$), representing the initial permutation. It is guaranteed that the answer exists and is unique. | standard output | |
PASSED | 3f3aa0890d5ed1fa756dc94c8cf34eb6 | train_003.jsonl | 1594996500 | A permutation of length $$$n$$$ is a sequence of integers from $$$1$$$ to $$$n$$$ of length $$$n$$$ containing each number exactly once. For example, $$$[1]$$$, $$$[4, 3, 5, 1, 2]$$$, $$$[3, 2, 1]$$$ are permutations, and $$$[1, 1]$$$, $$$[0, 1]$$$, $$$[2, 2, 1, 4]$$$ are not.There was a permutation $$$p[1 \dots n]$$$.... | 256 megabytes | import java.io.*;
import java.util.*;
public class fhjskf {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
PrintWriter pw = new PrintWriter(System.out);
Random gen = new Random();
int test = sc.nextInt();
while(test-- > 0)
{
... | Java | ["5\n2\n1 1 2 2\n4\n1 3 1 4 3 4 2 2\n5\n1 2 1 2 3 4 3 5 4 5\n3\n1 2 3 1 2 3\n4\n2 3 2 4 1 3 4 1"] | 1 second | ["1 2 \n1 3 4 2 \n1 2 3 4 5 \n1 2 3 \n2 3 4 1"] | null | Java 8 | standard input | [
"greedy"
] | aaf91874cf5aa0fa302ffed2ccecdc76 | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 400$$$) — the number of test cases. Then $$$t$$$ test cases follow. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 50$$$) — the length of permutation. The second line of the test case contains $$$2n$$$ integers $$$a_1... | 800 | For each test case, print the answer: $$$n$$$ integers $$$p_1, p_2, \dots, p_n$$$ ($$$1 \le p_i \le n$$$), representing the initial permutation. It is guaranteed that the answer exists and is unique. | standard output | |
PASSED | 5de537566056b83f921c0e5a4a4f4b14 | train_003.jsonl | 1594996500 | A permutation of length $$$n$$$ is a sequence of integers from $$$1$$$ to $$$n$$$ of length $$$n$$$ containing each number exactly once. For example, $$$[1]$$$, $$$[4, 3, 5, 1, 2]$$$, $$$[3, 2, 1]$$$ are permutations, and $$$[1, 1]$$$, $$$[0, 1]$$$, $$$[2, 2, 1, 4]$$$ are not.There was a permutation $$$p[1 \dots n]$$$.... | 256 megabytes | import java.util.*;
import java.io.*;
import java.*;
public class Main
{
public static void main(String[] args) {
Scanner in = new Scanner (System.in);
int t = in.nextInt();
for (int p=0; p<t; p++)
{
int n= in.nextInt();
//ArrayList<Integer> arr = new ArrayList<Integer>();
LinkedHashMap<Integer... | Java | ["5\n2\n1 1 2 2\n4\n1 3 1 4 3 4 2 2\n5\n1 2 1 2 3 4 3 5 4 5\n3\n1 2 3 1 2 3\n4\n2 3 2 4 1 3 4 1"] | 1 second | ["1 2 \n1 3 4 2 \n1 2 3 4 5 \n1 2 3 \n2 3 4 1"] | null | Java 8 | standard input | [
"greedy"
] | aaf91874cf5aa0fa302ffed2ccecdc76 | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 400$$$) — the number of test cases. Then $$$t$$$ test cases follow. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 50$$$) — the length of permutation. The second line of the test case contains $$$2n$$$ integers $$$a_1... | 800 | For each test case, print the answer: $$$n$$$ integers $$$p_1, p_2, \dots, p_n$$$ ($$$1 \le p_i \le n$$$), representing the initial permutation. It is guaranteed that the answer exists and is unique. | standard output | |
PASSED | c5f085100345f3b221cb5f1c5d2213ba | train_003.jsonl | 1593873900 | You are given a grid with $$$n$$$ rows and $$$m$$$ columns, where each cell has a non-negative integer written on it. We say the grid is good if for each cell the following condition holds: if it has a number $$$k > 0$$$ written on it, then exactly $$$k$$$ of its neighboring cells have a number greater than $$$0$$$ ... | 256 megabytes | import java.io.*;
import java.math.*;
import java.text.*;
import java.util.*;
public class test
{
public static void main(String args[])
{Scanner in=new Scanner(System.in);
test ob=new test();
int tc,i,r,j,k,l,n,c,p=0,o,m;
tc=in.nextInt();
for(i=0;i<tc;i++)
{
r=in... | Java | ["5\n3 4\n0 0 0 0\n0 1 0 0\n0 0 0 0\n2 2\n3 0\n0 0\n2 2\n0 0\n0 0\n2 3\n0 0 0\n0 4 0\n4 4\n0 0 0 0\n0 2 0 1\n0 0 0 0\n0 0 0 0"] | 1 second | ["YES\n0 0 0 0\n0 1 1 0\n0 0 0 0\nNO\nYES\n0 0\n0 0\nNO\nYES\n0 1 0 0\n1 4 2 1\n0 2 0 0\n1 3 1 0"] | NoteIn the first test case, we can obtain the resulting grid by increasing the number in row $$$2$$$, column $$$3$$$ once. Both of the cells that contain $$$1$$$ have exactly one neighbor that is greater than zero, so the grid is good. Many other solutions exist, such as the grid $$$$$$0\;1\;0\;0$$$$$$ $$$$$$0\;2\;1\;0... | Java 11 | standard input | [
"constructive algorithms",
"greedy"
] | 8afcdfaabba66fb9cefc5b6ceabac0d0 | The input consists of multiple test cases. The first line contains an integer $$$t$$$ ($$$1 \le t \le 5000$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$m$$$ ($$$2 \le n, m \le 300$$$) — the number of rows and columns, ... | 1,200 | If it is impossible to obtain a good grid, print a single line containing "NO". Otherwise, print a single line containing "YES", followed by $$$n$$$ lines each containing $$$m$$$ integers, which describe the final state of the grid. This final grid should be obtainable from the initial one by applying some operations (... | standard output | |
PASSED | 645de078d856679eb0a351343b846b3b | train_003.jsonl | 1593873900 | You are given a grid with $$$n$$$ rows and $$$m$$$ columns, where each cell has a non-negative integer written on it. We say the grid is good if for each cell the following condition holds: if it has a number $$$k > 0$$$ written on it, then exactly $$$k$$$ of its neighboring cells have a number greater than $$$0$$$ ... | 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
{
Scanner sc=new Scanner(System.in);
int t=s... | Java | ["5\n3 4\n0 0 0 0\n0 1 0 0\n0 0 0 0\n2 2\n3 0\n0 0\n2 2\n0 0\n0 0\n2 3\n0 0 0\n0 4 0\n4 4\n0 0 0 0\n0 2 0 1\n0 0 0 0\n0 0 0 0"] | 1 second | ["YES\n0 0 0 0\n0 1 1 0\n0 0 0 0\nNO\nYES\n0 0\n0 0\nNO\nYES\n0 1 0 0\n1 4 2 1\n0 2 0 0\n1 3 1 0"] | NoteIn the first test case, we can obtain the resulting grid by increasing the number in row $$$2$$$, column $$$3$$$ once. Both of the cells that contain $$$1$$$ have exactly one neighbor that is greater than zero, so the grid is good. Many other solutions exist, such as the grid $$$$$$0\;1\;0\;0$$$$$$ $$$$$$0\;2\;1\;0... | Java 11 | standard input | [
"constructive algorithms",
"greedy"
] | 8afcdfaabba66fb9cefc5b6ceabac0d0 | The input consists of multiple test cases. The first line contains an integer $$$t$$$ ($$$1 \le t \le 5000$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$m$$$ ($$$2 \le n, m \le 300$$$) — the number of rows and columns, ... | 1,200 | If it is impossible to obtain a good grid, print a single line containing "NO". Otherwise, print a single line containing "YES", followed by $$$n$$$ lines each containing $$$m$$$ integers, which describe the final state of the grid. This final grid should be obtainable from the initial one by applying some operations (... | standard output | |
PASSED | 49ce073444c12fe87c6b89b3ac3dcb4a | train_003.jsonl | 1593873900 | You are given a grid with $$$n$$$ rows and $$$m$$$ columns, where each cell has a non-negative integer written on it. We say the grid is good if for each cell the following condition holds: if it has a number $$$k > 0$$$ written on it, then exactly $$$k$$$ of its neighboring cells have a number greater than $$$0$$$ ... | 256 megabytes | import java.io.*;
import java.util.Arrays;
import java.util.StringTokenizer;
public class B {
static int[][] Z = new int[400][400];
private static void solve() throws Exception {
int n = R.nextInt();
int m = R.nextInt();
boolean ans = true;
for (int i = 0 ; i < n ; i ++ ) {
... | Java | ["5\n3 4\n0 0 0 0\n0 1 0 0\n0 0 0 0\n2 2\n3 0\n0 0\n2 2\n0 0\n0 0\n2 3\n0 0 0\n0 4 0\n4 4\n0 0 0 0\n0 2 0 1\n0 0 0 0\n0 0 0 0"] | 1 second | ["YES\n0 0 0 0\n0 1 1 0\n0 0 0 0\nNO\nYES\n0 0\n0 0\nNO\nYES\n0 1 0 0\n1 4 2 1\n0 2 0 0\n1 3 1 0"] | NoteIn the first test case, we can obtain the resulting grid by increasing the number in row $$$2$$$, column $$$3$$$ once. Both of the cells that contain $$$1$$$ have exactly one neighbor that is greater than zero, so the grid is good. Many other solutions exist, such as the grid $$$$$$0\;1\;0\;0$$$$$$ $$$$$$0\;2\;1\;0... | Java 11 | standard input | [
"constructive algorithms",
"greedy"
] | 8afcdfaabba66fb9cefc5b6ceabac0d0 | The input consists of multiple test cases. The first line contains an integer $$$t$$$ ($$$1 \le t \le 5000$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$m$$$ ($$$2 \le n, m \le 300$$$) — the number of rows and columns, ... | 1,200 | If it is impossible to obtain a good grid, print a single line containing "NO". Otherwise, print a single line containing "YES", followed by $$$n$$$ lines each containing $$$m$$$ integers, which describe the final state of the grid. This final grid should be obtainable from the initial one by applying some operations (... | standard output | |
PASSED | 8b1c41bab668072b46d9a51c5f14ebbb | train_003.jsonl | 1593873900 | You are given a grid with $$$n$$$ rows and $$$m$$$ columns, where each cell has a non-negative integer written on it. We say the grid is good if for each cell the following condition holds: if it has a number $$$k > 0$$$ written on it, then exactly $$$k$$$ of its neighboring cells have a number greater than $$$0$$$ ... | 256 megabytes | // Main Code at the Bottom
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigInteger;
public class Main {
//Fast IO class
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
boolean env=System.getProperty("ONLINE_JUD... | Java | ["5\n3 4\n0 0 0 0\n0 1 0 0\n0 0 0 0\n2 2\n3 0\n0 0\n2 2\n0 0\n0 0\n2 3\n0 0 0\n0 4 0\n4 4\n0 0 0 0\n0 2 0 1\n0 0 0 0\n0 0 0 0"] | 1 second | ["YES\n0 0 0 0\n0 1 1 0\n0 0 0 0\nNO\nYES\n0 0\n0 0\nNO\nYES\n0 1 0 0\n1 4 2 1\n0 2 0 0\n1 3 1 0"] | NoteIn the first test case, we can obtain the resulting grid by increasing the number in row $$$2$$$, column $$$3$$$ once. Both of the cells that contain $$$1$$$ have exactly one neighbor that is greater than zero, so the grid is good. Many other solutions exist, such as the grid $$$$$$0\;1\;0\;0$$$$$$ $$$$$$0\;2\;1\;0... | Java 11 | standard input | [
"constructive algorithms",
"greedy"
] | 8afcdfaabba66fb9cefc5b6ceabac0d0 | The input consists of multiple test cases. The first line contains an integer $$$t$$$ ($$$1 \le t \le 5000$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$m$$$ ($$$2 \le n, m \le 300$$$) — the number of rows and columns, ... | 1,200 | If it is impossible to obtain a good grid, print a single line containing "NO". Otherwise, print a single line containing "YES", followed by $$$n$$$ lines each containing $$$m$$$ integers, which describe the final state of the grid. This final grid should be obtainable from the initial one by applying some operations (... | standard output | |
PASSED | 2b44e3eb99c068b542bc3acc3915bd69 | train_003.jsonl | 1593873900 | You are given a grid with $$$n$$$ rows and $$$m$$$ columns, where each cell has a non-negative integer written on it. We say the grid is good if for each cell the following condition holds: if it has a number $$$k > 0$$$ written on it, then exactly $$$k$$$ of its neighboring cells have a number greater than $$$0$$$ ... | 256 megabytes |
import java.io.*;
import java.util.*;
public class Main {
public static FastReader scan = new FastReader();
public static void main(String[] args) {
int t = scan.nextInt();
while(t--> 0) {
int n = scan.nextInt();
int m = scan.nextInt();
long a[][] = new long[n][m];
boolean ans = true;
... | Java | ["5\n3 4\n0 0 0 0\n0 1 0 0\n0 0 0 0\n2 2\n3 0\n0 0\n2 2\n0 0\n0 0\n2 3\n0 0 0\n0 4 0\n4 4\n0 0 0 0\n0 2 0 1\n0 0 0 0\n0 0 0 0"] | 1 second | ["YES\n0 0 0 0\n0 1 1 0\n0 0 0 0\nNO\nYES\n0 0\n0 0\nNO\nYES\n0 1 0 0\n1 4 2 1\n0 2 0 0\n1 3 1 0"] | NoteIn the first test case, we can obtain the resulting grid by increasing the number in row $$$2$$$, column $$$3$$$ once. Both of the cells that contain $$$1$$$ have exactly one neighbor that is greater than zero, so the grid is good. Many other solutions exist, such as the grid $$$$$$0\;1\;0\;0$$$$$$ $$$$$$0\;2\;1\;0... | Java 11 | standard input | [
"constructive algorithms",
"greedy"
] | 8afcdfaabba66fb9cefc5b6ceabac0d0 | The input consists of multiple test cases. The first line contains an integer $$$t$$$ ($$$1 \le t \le 5000$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$m$$$ ($$$2 \le n, m \le 300$$$) — the number of rows and columns, ... | 1,200 | If it is impossible to obtain a good grid, print a single line containing "NO". Otherwise, print a single line containing "YES", followed by $$$n$$$ lines each containing $$$m$$$ integers, which describe the final state of the grid. This final grid should be obtainable from the initial one by applying some operations (... | standard output | |
PASSED | e48c419fa9b7e0ce29ab14329ea21a76 | train_003.jsonl | 1593873900 | You are given a grid with $$$n$$$ rows and $$$m$$$ columns, where each cell has a non-negative integer written on it. We say the grid is good if for each cell the following condition holds: if it has a number $$$k > 0$$$ written on it, then exactly $$$k$$$ of its neighboring cells have a number greater than $$$0$$$ ... | 256 megabytes | import java.util.Scanner;
public class NeighborGrid {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int Case = sc.nextInt();
for (int i=0;i<Case;i++){
Solve(sc);
}
}
private static void Solve(Scanner sc) {
int n = sc.nextIn... | Java | ["5\n3 4\n0 0 0 0\n0 1 0 0\n0 0 0 0\n2 2\n3 0\n0 0\n2 2\n0 0\n0 0\n2 3\n0 0 0\n0 4 0\n4 4\n0 0 0 0\n0 2 0 1\n0 0 0 0\n0 0 0 0"] | 1 second | ["YES\n0 0 0 0\n0 1 1 0\n0 0 0 0\nNO\nYES\n0 0\n0 0\nNO\nYES\n0 1 0 0\n1 4 2 1\n0 2 0 0\n1 3 1 0"] | NoteIn the first test case, we can obtain the resulting grid by increasing the number in row $$$2$$$, column $$$3$$$ once. Both of the cells that contain $$$1$$$ have exactly one neighbor that is greater than zero, so the grid is good. Many other solutions exist, such as the grid $$$$$$0\;1\;0\;0$$$$$$ $$$$$$0\;2\;1\;0... | Java 11 | standard input | [
"constructive algorithms",
"greedy"
] | 8afcdfaabba66fb9cefc5b6ceabac0d0 | The input consists of multiple test cases. The first line contains an integer $$$t$$$ ($$$1 \le t \le 5000$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$m$$$ ($$$2 \le n, m \le 300$$$) — the number of rows and columns, ... | 1,200 | If it is impossible to obtain a good grid, print a single line containing "NO". Otherwise, print a single line containing "YES", followed by $$$n$$$ lines each containing $$$m$$$ integers, which describe the final state of the grid. This final grid should be obtainable from the initial one by applying some operations (... | standard output | |
PASSED | a149febf2ad27bc6c087c0d3713b42bf | train_003.jsonl | 1593873900 | You are given a grid with $$$n$$$ rows and $$$m$$$ columns, where each cell has a non-negative integer written on it. We say the grid is good if for each cell the following condition holds: if it has a number $$$k > 0$$$ written on it, then exactly $$$k$$$ of its neighboring cells have a number greater than $$$0$$$ ... | 256 megabytes | // package com.prashant;
import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) throws IOException {
// write your code here
PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
Reader sc = new Reader();
int t = sc.nextI... | Java | ["5\n3 4\n0 0 0 0\n0 1 0 0\n0 0 0 0\n2 2\n3 0\n0 0\n2 2\n0 0\n0 0\n2 3\n0 0 0\n0 4 0\n4 4\n0 0 0 0\n0 2 0 1\n0 0 0 0\n0 0 0 0"] | 1 second | ["YES\n0 0 0 0\n0 1 1 0\n0 0 0 0\nNO\nYES\n0 0\n0 0\nNO\nYES\n0 1 0 0\n1 4 2 1\n0 2 0 0\n1 3 1 0"] | NoteIn the first test case, we can obtain the resulting grid by increasing the number in row $$$2$$$, column $$$3$$$ once. Both of the cells that contain $$$1$$$ have exactly one neighbor that is greater than zero, so the grid is good. Many other solutions exist, such as the grid $$$$$$0\;1\;0\;0$$$$$$ $$$$$$0\;2\;1\;0... | Java 11 | standard input | [
"constructive algorithms",
"greedy"
] | 8afcdfaabba66fb9cefc5b6ceabac0d0 | The input consists of multiple test cases. The first line contains an integer $$$t$$$ ($$$1 \le t \le 5000$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$m$$$ ($$$2 \le n, m \le 300$$$) — the number of rows and columns, ... | 1,200 | If it is impossible to obtain a good grid, print a single line containing "NO". Otherwise, print a single line containing "YES", followed by $$$n$$$ lines each containing $$$m$$$ integers, which describe the final state of the grid. This final grid should be obtainable from the initial one by applying some operations (... | standard output | |
PASSED | 35c86da3f91f434d105331e9798b21ce | train_003.jsonl | 1593873900 | You are given a grid with $$$n$$$ rows and $$$m$$$ columns, where each cell has a non-negative integer written on it. We say the grid is good if for each cell the following condition holds: if it has a number $$$k > 0$$$ written on it, then exactly $$$k$$$ of its neighboring cells have a number greater than $$$0$$$ ... | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class Learning {
public static void main(String[] args) throws Exception {
FastInput in = new FastInput();
int t = in.nextInt();
StringBuilder st = new Strin... | Java | ["5\n3 4\n0 0 0 0\n0 1 0 0\n0 0 0 0\n2 2\n3 0\n0 0\n2 2\n0 0\n0 0\n2 3\n0 0 0\n0 4 0\n4 4\n0 0 0 0\n0 2 0 1\n0 0 0 0\n0 0 0 0"] | 1 second | ["YES\n0 0 0 0\n0 1 1 0\n0 0 0 0\nNO\nYES\n0 0\n0 0\nNO\nYES\n0 1 0 0\n1 4 2 1\n0 2 0 0\n1 3 1 0"] | NoteIn the first test case, we can obtain the resulting grid by increasing the number in row $$$2$$$, column $$$3$$$ once. Both of the cells that contain $$$1$$$ have exactly one neighbor that is greater than zero, so the grid is good. Many other solutions exist, such as the grid $$$$$$0\;1\;0\;0$$$$$$ $$$$$$0\;2\;1\;0... | Java 11 | standard input | [
"constructive algorithms",
"greedy"
] | 8afcdfaabba66fb9cefc5b6ceabac0d0 | The input consists of multiple test cases. The first line contains an integer $$$t$$$ ($$$1 \le t \le 5000$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$m$$$ ($$$2 \le n, m \le 300$$$) — the number of rows and columns, ... | 1,200 | If it is impossible to obtain a good grid, print a single line containing "NO". Otherwise, print a single line containing "YES", followed by $$$n$$$ lines each containing $$$m$$$ integers, which describe the final state of the grid. This final grid should be obtainable from the initial one by applying some operations (... | standard output | |
PASSED | 7fc95cfe2f757d5e2cf4124f43d7a7eb | train_003.jsonl | 1593873900 | You are given a grid with $$$n$$$ rows and $$$m$$$ columns, where each cell has a non-negative integer written on it. We say the grid is good if for each cell the following condition holds: if it has a number $$$k > 0$$$ written on it, then exactly $$$k$$$ of its neighboring cells have a number greater than $$$0$$$ ... | 256 megabytes | /* package codechef; // don't place package name! */
import java.util.*;
import java.lang.*;
import java.io.*;
/* Name of the class has to be "Main" only if the class is public. */
public class Codechef
{
static int n,m;
public static void main (String[] args) throws java.lang.Exception
{
// your code goes he... | Java | ["5\n3 4\n0 0 0 0\n0 1 0 0\n0 0 0 0\n2 2\n3 0\n0 0\n2 2\n0 0\n0 0\n2 3\n0 0 0\n0 4 0\n4 4\n0 0 0 0\n0 2 0 1\n0 0 0 0\n0 0 0 0"] | 1 second | ["YES\n0 0 0 0\n0 1 1 0\n0 0 0 0\nNO\nYES\n0 0\n0 0\nNO\nYES\n0 1 0 0\n1 4 2 1\n0 2 0 0\n1 3 1 0"] | NoteIn the first test case, we can obtain the resulting grid by increasing the number in row $$$2$$$, column $$$3$$$ once. Both of the cells that contain $$$1$$$ have exactly one neighbor that is greater than zero, so the grid is good. Many other solutions exist, such as the grid $$$$$$0\;1\;0\;0$$$$$$ $$$$$$0\;2\;1\;0... | Java 11 | standard input | [
"constructive algorithms",
"greedy"
] | 8afcdfaabba66fb9cefc5b6ceabac0d0 | The input consists of multiple test cases. The first line contains an integer $$$t$$$ ($$$1 \le t \le 5000$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$m$$$ ($$$2 \le n, m \le 300$$$) — the number of rows and columns, ... | 1,200 | If it is impossible to obtain a good grid, print a single line containing "NO". Otherwise, print a single line containing "YES", followed by $$$n$$$ lines each containing $$$m$$$ integers, which describe the final state of the grid. This final grid should be obtainable from the initial one by applying some operations (... | standard output | |
PASSED | 43f845ef1c946de4cad6946d9a3bc250 | train_003.jsonl | 1593873900 | You are given a grid with $$$n$$$ rows and $$$m$$$ columns, where each cell has a non-negative integer written on it. We say the grid is good if for each cell the following condition holds: if it has a number $$$k > 0$$$ written on it, then exactly $$$k$$$ of its neighboring cells have a number greater than $$$0$$$ ... | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;
public class Task2 {
public static void main(String[] args) throws IOException {
new Task2().solve();
... | Java | ["5\n3 4\n0 0 0 0\n0 1 0 0\n0 0 0 0\n2 2\n3 0\n0 0\n2 2\n0 0\n0 0\n2 3\n0 0 0\n0 4 0\n4 4\n0 0 0 0\n0 2 0 1\n0 0 0 0\n0 0 0 0"] | 1 second | ["YES\n0 0 0 0\n0 1 1 0\n0 0 0 0\nNO\nYES\n0 0\n0 0\nNO\nYES\n0 1 0 0\n1 4 2 1\n0 2 0 0\n1 3 1 0"] | NoteIn the first test case, we can obtain the resulting grid by increasing the number in row $$$2$$$, column $$$3$$$ once. Both of the cells that contain $$$1$$$ have exactly one neighbor that is greater than zero, so the grid is good. Many other solutions exist, such as the grid $$$$$$0\;1\;0\;0$$$$$$ $$$$$$0\;2\;1\;0... | Java 11 | standard input | [
"constructive algorithms",
"greedy"
] | 8afcdfaabba66fb9cefc5b6ceabac0d0 | The input consists of multiple test cases. The first line contains an integer $$$t$$$ ($$$1 \le t \le 5000$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$m$$$ ($$$2 \le n, m \le 300$$$) — the number of rows and columns, ... | 1,200 | If it is impossible to obtain a good grid, print a single line containing "NO". Otherwise, print a single line containing "YES", followed by $$$n$$$ lines each containing $$$m$$$ integers, which describe the final state of the grid. This final grid should be obtainable from the initial one by applying some operations (... | standard output |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.