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 | bea2eb2f62c10ec1e745bd4d3f716cb0 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes |
import java.util.Scanner;
public class LogChopping {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n =sc.nextInt();
while (n-- > 0) {
int t = sc.nextInt();
int total = 0;
for (int i = 0 ; i < t ;i++)
total+=sc.nextInt();
System.out.println(... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 8 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 1ae544e4143ccec7020a02e843f249c4 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.*;
public class May10
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
String who[] = new String[t];
for(int i = 0; i<t; i++)
{
int n = sc.nextInt();
int a[] = new int[n];
... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 8 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | c481cba77d2982c1acdba8192ffeec8d | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.*;
public class HelloWorld{
public static void main(String []args){
Scanner in =new Scanner(System.in);
int t =in.nextInt();
while(t-->0){
int n =in.nextInt();
int sum=0;
for(int i=0; i<n; i++){
sum+=in.nextInt();
}
sum-=n;
... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 8 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 8cbb75f6ba43fd9d34038b3096fe7e21 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes |
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
for (int tc = 0; tc < t; ++tc) {
int n = sc.nextInt();
int[] a = new int[n];
for (int i = 0; i < ... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 8 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 9a9c2711f646ab21f612ec5a2daa68e8 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.text.DecimalFormat;
import java.util.*;
public class Codeforces {
static long mod= Long.MAX_VALUE;
public static void main(String[] args) throws Exception {
PrintWrite... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 8 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 2a305986b30569ae226d23f718ff14e9 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.io.*;
import java.util.*;
/**
* Made by egor https://github.com/chermehdi/egor.
*
* @author Azuz
*
*/
public class Main {
void solve(InputReader in, PrintWriter out) {
int t = in.nextInt();
while (t-->0) {
int n = in.nextInt();
int s = 0;
for (int i = 0; i... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 8 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 8286bd8496e425e50ed23ca6c87fee31 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.*;
public class Solution
{
public static void main(String args[])
{
Scanner sc=new Scanner(System.in);
int t=sc.nextInt();
while(--t>-1)
{
int n=sc.nextInt();
int sum=0;
for(int i=0;i<n;i++) sum+=sc.nextInt()-1;
... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 8 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | deef758b2d6a876faca7a03e6e6de95c | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.util.*;
public class P1672A {
public static void main(String[] args) throws Exception {
new P1672A().run();
}
void run() throws Exception {
Scanner scanner = new Scanner(getInputStream());
in... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 8 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 54b7d989afc3aa65786c97e91d167290 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | // package faltu;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
import java.util.Map.Entry;
public class Main {
public static int upperBound(long[] arr, long m, int l, int r) {
while(l<=r) {
int mid=(l+r)/2;
if(arr[mi... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 8 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 7a78a5ba5f2677f0a36a55484e23e62b | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.*;
public class App{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
while(n > 0){
int sum = 0;
int len = sc.nextInt();
while(len > 0){
sum += sc.nextInt() - 1;
... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 8 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | e18d9e8a2b10e1d015c3084b8b48a21c | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.Scanner;
public class Solution{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
int rows=Integer.parseInt(sc.nextLine());
while(rows>0){
int n=Integer.parseInt(sc.nextLine()),sum=-n;
String[] nums=sc.nextLine().split(... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 8 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 020cf3af13da5350b3ae5d481851fee8 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class Codeforces {
static int M = 1_000_000_007;
static int INF = 2_000_000_000;
static int N = (int) 2e5 + 1;
static long[] factorial;
static boolean[] isPrime = new ... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 8 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 1d9700881ca9caff8ca78d891c916354 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 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 Solution
{
public static void main (String[] args) throws java.lang.Exception
{
// your code goes here
... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 8 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 3f7dcfa3e6ed950db75951305e32b50c | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.Scanner;
public class CF_1672A {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
while (t-- > 0) {
int n = sc.nextInt();
int total = 0;
for (int i = 0; i < n; i++) {
tota... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 8 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 93ce15c4ad77305fb4f2f5b66fde3865 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.*;
import java.io.*;
public class codeforces1672A {
public static void main(String[] args) throws Exception {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int numCases = Integer.parseInt(br.readLine());
for (int rep = 0; rep<numCases;rep+... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 8 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 131209e3251ab6b149f82743f8d09cb9 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.*;
public class HelloWorld {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int t=sc.nextInt();
for(int i=0;i<t;i++){
int l=0;
int n = sc.nextInt();
int array[] = new int[n];
for(int j=0;... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 8 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | eb4d0a28db866640c07e0bf86c0afbc9 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.io.*;
import java.util.*;
public class A_Log_Chopping {
public static void main(String[] args) {
MyScanner sc = new MyScanner();
out = new PrintWriter(new BufferedOutputStream(System.out));
int t = sc.nextInt();
while (t-- > 0) {
int n = sc.nextInt(), a[] = sc.readArray(n);
long su... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 8 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | a98b72fcc199472cfdc980758d026c5b | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.*;
import java.io.*;
import java.lang.Math;
public class cp{
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br = new BufferedReader(
new InputStreamReader(System.in));
}
... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 8 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 0e2aab2abc2e1836d9629c7088ad8d9e | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.*;
public class A{
static Scanner sc;
public static void solve(){
int n=sc.nextInt();
int sum=0;
for(int i=0;i<n;i++){
sum+=sc.nextInt();
}
sum-=n;
if(sum%2!=0) System.out.println("errorgorn");
else System.out.println("maomao90");
}
public static void main(Stri... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 8 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 7834b25d070dd0a0458dfa1d8153a72e | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.*;
public class code {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
long t = sc.nextLong();
while (t-- > 0) {
int n=sc.nextInt();
int[] a= new int[n];
for (int i=0;i<n;i++){
a... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 8 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 5713b0e8e09d4f3826781679d494f1d2 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.Scanner;
public class logchopping {
public static void main(String args[]){
Scanner sc=new Scanner(System.in);
int t=sc.nextInt();
for(int i=0;i<t;i++){
int n=sc.nextInt();
int a[]=new int[n];
for(int j=0;j<n;j++){
a[j]=sc.nextInt();
... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 8 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | e78649dc6d8b5eb6cbd5f3aaa12ba2c8 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.*;
import java.io.*;
public class A {
public static void main(String[] args) {
FastReader fr = new FastReader();
int tc = fr.nextInt();
while(tc-- != 0) {
int n=fr.nextInt();
int[] a = fr.readArray(n);
long totalMoves=0;
... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 8 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | a56e8519f4bc3d3f0629d338a6c5dc32 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes |
/*
!!!!Hello World,Prakhar here!!!!
codechef handle prakhar_3011
codeforces handle prakhar_30
trying to get good at CP
PEACE OUT.........
*/
/*
2 4
1 1 2 2
1 1 1 1
*/
import java.io.*;
import java.util.*;
public class log {
public static void main(String[] args) {
FastScan... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 8 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 5f163c94b04c779c633cf23e4bb7cfe3 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.io.*;
import java.util.*;
public class A {
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
br = new BufferedReader(new
InputStreamReader(System.in));
}
String next() {
... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 8 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | b1c39df6fafcb50d70f7609462832434 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;
public class A {
static final FastReader sc = new FastReader();
static final PrintWriter out = new PrintWriter(System.out, tru... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 30c4068d204b10a67e25292abcaf5db5 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class logchopping {
static String chop(int[] arr) {
int res = 0;
for (int num : arr) {
res += num - 1;
}
return res % 2 == 0 ? "maomao90" : "errorgorn";
}
public sta... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 575d6efa789a77da5d0e5932866d4bb3 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes |
import java.io.*;
import java.util.*;
public class example {
static class FastReader
{
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br = new BufferedReader(new
InputStreamReader(System.in));
}
String next()
{
while (st == null || !st.hasMoreElements())
{
try
{
st = new StringTokenize... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | f528311b002e292a75822c5e286ee908 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.*;
import java.io.*;
public class LogChopping{
public static int count=0;
public static void main(String args[])
{
Scanner sc=new Scanner(System.in);
int t=sc.nextInt();
while(t-->0)
{
int n=sc.nextInt();
int arr[]=new int[n... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | ae2d66a7b3660b5035da3a5369e0e01e | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes |
import java.util.Scanner;
public class A {
public static void main(String[] args) {
Scanner scn = new Scanner(System.in);
int t = scn.nextInt();
while(t-->0)
{
int n = scn.nextInt();
int countOptions = 0;
for(int i = 0 ; i<n ; i+... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 166cc60e5422f5c90e315c84106cf7b8 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.*;
public class CodeForce2
{
public static void main(String args[])
{
Scanner s = new Scanner(System.in);
int t = s.nextInt();
while(t-->0)
{ int pos=-1;
int n = s.nextInt();
int[] arr = new int[n+1];
... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 4948253730a4facbeb615cd7aee0a6d9 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) throws IOException {
Scanner scanner = new Scanner(System.in);
int t = scanner.nextInt();
while (t-- > 0) {
int n = scanner.nextInt(), turn = 0, cnt[] = new int[51];
... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | dea3f7220e48a22e3be0842f5b7fc495 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.*;
public class Main {
static Scanner sc = new Scanner (System.in);
public static void main(String[] args) {
int test = sc.nextInt();
for ( int t=0; t<test; t++){
int a = sc.nextInt();
long[] arr = new long[a];
long sum=0;
... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 7f1e0d0564de23ba7e822395b754c008 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | // package codeForces;
import java.util.*;
public class LogChopping {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
while(t-->0) {
int n = sc.nextInt();
int a [] = new int [n];
int sum =0;
for(in... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 4be7e190e1db418eec9a4387889ccc9f | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes |
import java.util.Scanner;
public class p1 {
public static void main(String[] args) {
Scanner scan=new Scanner(System.in);
int t=scan.nextInt();
// int[] arr=new int[n+1];
int w;
int c=0;
while(t--!=0) {
int n=scan.nextInt();
while(n--!=0) {
... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 2232ff706023073dd30b8158fe9882fc | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | // 1672A
import java.util.*;
public class LogChopping {
public static void main (String[] args) {
Scanner in = new Scanner(System.in);
int t = in.nextInt();
for (int i = 0; i < t; i++) {
int n = in.nextInt();
int cuts = 0;
for (int j = 0; j < n; j++) {
cuts += in.nextInt() - 1;
... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | e0cddd0dc2809b61180a9b67c98e25da | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.*;
import java.io.*;
public class Main {
static long mod = 1000000007;
static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
public static void main(String[] args) throws IOException {
FastReader sc = new FastReader();
int t = sc.nextInt();
while( t-- ... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 131ea7145475c50c8651d38d55dc36d5 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.io.*;
import java.lang.*;
import java.util.*;
import java.util.Collection;
import static java.lang.Math.*;
/*
author id: shubhanshu_jha
This is being used for the FastIO operations...
*/
public class Main implements Runnable {
public void run() {
InputReader input = new InputReader(... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 5f9667a7b2f175d578fa4df68fe043f0 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.Scanner;
public final class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int T = sc.nextInt();
for (int i = 0; i < T; i++) {
int N = sc.nextInt();
int sum = 0;
for (int j = 0; j <... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 4d3082aaca55cedd02973b4decee64c2 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | 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 Testclass
{
public static void main (String[] args) throws java.lang.Exception
{
// your code goes here
int t,n;
Scanner sc=new Scanne... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | e0d6c8680d445739a977dbda863dfda3 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.io.IOException;
import java.util.Scanner;
public class Solution {
public static void main(String[] args) throws IOException {
try {
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
for (int i = 0; i < a; i++) {
boolean d = t... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 54d0b0788fab407839cc9a59681c630c | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.*;
import java.io.*;
import java.lang.Math;
public class Log_Chopping {
public static void main(String[] args) throws Exception{
Scanner in = new Scanner(System.in);
int t = in.nextInt();
while(t-- > 0){
int n = in.nextInt();
int cpt = 0;
for(int i = 0; i < n... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | cd6cbbabc6fcca04c6da08b8b9a4ed0d | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.*;
import java.io.*;
public class Solution{
static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
static BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
static StringTokenizer st;
public static void main(String[] YDSV) throws IOEx... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 9badb43770a92256b79dd56cf8af4131 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes |
import java.io.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
import java.util.StringTokenizer;
public class contest1 {
public static class MyScanner {
BufferedReader br;
StringTokenizer st;
public MyScanner() {
br = new Buf... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | fae7294cae55f1da7f4fc4d4f65fbbfb | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.Scanner;
public class logChopping {
public static void main(String[] args) {
Scanner sn=new Scanner(System.in);
int t=sn.nextInt();
while(t-->0){
int n=sn.nextInt();
int arr[]=new int[n];
for(int i=0;i<n;i++)
arr[i]=sn.n... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 51b5eb7e3ab8c1c2163c76501403a423 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.*;
public class Main {
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
// System.out.println(sc.nextByte());
logchop(sc);
}
private static void logchop(Scanner scanner){
int testcase=scanner.nextInt();
for(int i=0;... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 8ebed50425e55bdf35896c54ca16693f | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual soluti... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | da1b2894df3601d9462fdf4dd21ca080 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | /* package CodeForces; // don't place package name! */
// algo_messiah23 , NIT RKL ...
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.*;
import static java.lang.System.*;
import java.util.stream.IntStream;
import java.util.Map.Entry;
/* Name of the class has to be "Main" only if the... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | ee86210a4f5f654d5f2647cf3472b095 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.lang.*;
// import java.math.*;
import java.io.*;
import java.util.*;
public class Main{
public static int mod=(int)(1e9) + 7;
public static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
public static PrintWriter ot=new PrintWriter(System.out);
public static int[] ... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | abd587d9485056b190ef3dc7124d4b5b | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.security.cert.X509CRL;
import java.util.*;
import java.lang.*;
import java.util.stream.Collector;
import java.util.stream.Co... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | f400a35419407f7ce7daf3fdea1c6127 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.Scanner;
public class Solution {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int t = in.nextInt();
while (t-- > 0) {
int n = in.nextInt();
int sum = 0;
for (int i = 0; i < n; ++i) {
sum += in.nextInt()-1;
}
System.out.pri... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 8655bc1d73dc5e8a964ddf1bf1256231 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.*;
public class A {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int testCases = sc.nextInt();
for (int t = 0; t < testCases; t++) {
int n = sc.nextInt(), total = 0;
for (int i = 0; i < n; i++) {
total += sc.nextInt() - 1;
}
System.out... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | bcd7dd64010ca4a45e4211c2b692293b | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.Scanner;
import java.util.Arrays;
import java.util.Collections;
// import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.ArrayList;
import java.util.Set;
import java.util.Stack;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.strea... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 7bd5150465ba72ee69f7ea6ed45e99a9 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.*;
public class a111 {
public static void main(String []args) {
Scanner s=new Scanner(System.in);
int t=s.nextInt();
while(t-->0) {
int n=s.nextInt();
int res=0;
while(n-->0) {
int a=s.nextInt();
if(a>1)
res+=a-1;
}
if(res%2==0)
System.out.printl... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | ca7831e7de9cd86999eca68bac8ab4f2 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.io.BufferedInputStream;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(new BufferedInputStream(System.in));
int t = sc.nextInt();
while (t-- > 0) {
int n = sc.nextInt();
int a[] = n... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 755b7927b8e1fab1df0a09d79a943dcc | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.io.*;
import java.lang.*;
import java.util.*;
public class ComdeFormces {
public static int cc2;
public static pair pr;
public static long sum;
public static void main(String[] args) throws Exception{
// TODO Auto-generated method stub
// Reader.init(System.in);
FastReader sc=new FastRea... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 5d0c1c12b325760270ddecd07a8303ce | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | // package global_20;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class A{
public static void main(String[] args){
FastReader sc = new FastReader();
int t=sc.nextInt();
while(t-->0){
int n=sc.nextInt();
int a[]=sc.fast... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 19c739c84c2ef17ea3802242ea890a43 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes |
import java.lang.reflect.Array;
import java.math.*;
import java.util.*;
import java.io.*;
public class Main {
public static int getHash(ArrayList<Integer> arr, int i){
int sm = 7 * -1;
if (i - 2 > 0){
sm*= arr.get(i - 2);
}
if (i + 1 < arr.size()){
... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 02aa7c3af2750a58f3ac1b1085be4d67 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.io.*;
import java.util.*;
public class Codeforces extends PrintWriter {
Codeforces() { super(System.out); }
Scanner sc = new Scanner(System.in);
public static void main(String[] $) {
Codeforces o = new Codeforces(); o.main(); o.flush();
o.close();
}
void main() {
int t = sc.... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | d5a5790b72aa8ebbe5973238ebebb68b | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes |
import java.util.*;
public class Program {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int testCases = scanner.nextInt();
while(testCases-->0) {
int numBr = scanner.nextInt();
int sum =0;
for(int i =numBr;i>0;i--) {
sum= sum+scanner.nextIn... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | abef15dcfa965323341018978a9029a5 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes |
import java.util.*;
public class Regional_round20 {
public static void main(String[] args) {
Scanner Abhi = new Scanner(System.in); // Abhishek Das Codechef 1*//
int t = Abhi.nextInt(); // long/ int
while(t-->0){
int n = Abhi.nextInt(); // long/int
PriorityQueue<Integer> q = new PriorityQueue<... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 2053be3c393d62a4743934e66bc47505 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.*;
public class Answer3 {
public static void main(String [] args) {
Scanner sc = new Scanner(System.in);
int x = sc.nextInt();
for (int j = 0; j < x; j++) {
int n = sc.nextInt();
int[] ar = new int[n];
for (int i = 0; i < n; i++) {... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 0f8d9d8d0923e5e5427a81c9119cba65 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.io.*;
import java.util.*;
public class template {
static class QuickReader
{
BufferedReader in;
StringTokenizer token;
public QuickReader(InputStream ins)
{
in=new BufferedReader(new InputStreamReader(ins));
token=new StringTokeni... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | e54463aa8a7e1113f08f6e6b1eaf650a | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.*;
import java.io.*;
public class Main {
static FastReader in=new FastReader();
static final Random random=new Random();
static long mod=1000000007L;
static HashMap<String,Integer>map=new HashMap<>();
public static void main(String args[]) throws IOException {
int... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 93129a98c07dfb6509dfec6dcd794b3e | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.io.*;
import java.util.*;
/**
*
* @author eslam
*/
public class IceCave {
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
br = new BufferedReader(new InputStreamReader(System.in));
}
Stri... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 85db6229704ec872a0a795251d4a5f91 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.io.BufferedReader;
import java.math.BigInteger;
import java.util.*;
import static java.lang.System.out;
import static java.lang.System.setProperty;
public class Round_780_Div_3 {
static Scanner str = new Scanner(System.in);
static ArrayList<Integer> list;
final int mod = 1000000007;
... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 65a4b5dfda1986c91af7d9856ed9d915 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.*;
public class A_Log_Chopping{
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, c=0;
for(int i=0; i<n;i++){
a= sc.nextI... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 74eab72ac8afbe635b9626fa97667cef | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.*;
import java.lang.*;
import java.math.*;
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
for(int i = 0; i < n; i++)
{
int loop = scan.nextInt();
int count = 0;
f... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 40b8c0330f126a2b6dd9d9d56b9b1daf | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.io.*;
import java.util.*;
public class Q1672A {
static int mod = (int) (1e9 + 7);
static void solve() {
int n=i();
long ans=0;
for(int i=0;i<n;i++){
long val=l();
ans+=val-1;
}
//System.out.println(ans);
if(ans%2==0){
System... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | fb29efc6a3924853dd2b990eb5360cce | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes |
import java.util.*;
public class ChoppingLogs {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
for (int i = 0; i < n; i++) {
int logs = in.nextInt();
int moves = 0;
for (int j = 0; j < logs... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 91208f1cd64017138108c30dc4511459 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;
public class LogChopping {
public static void main(String[] args) throws NumberFormatException, IOException {
BufferedReader br = new BufferedReader(new ... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 2cfbec529ee09def56a2f086fd0b24d6 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;
public class LogChopping {
public static void main(String[] args) throws NumberFormatException, IOException {
BufferedReader br = new BufferedReader(new ... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | cd6194286a20072d7a3f572238ee1d2e | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.*;
public class Main{
public static void main(String args[]) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
for(int i=0;i<n;i++){
int m = sc.nextInt();
int count = 0;
for(int j=0;j<m;j++){
count+=sc.nextInt()-1;
}
... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 5451224ae2e6e4ec87d17438d7fba933 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.*;
public class Main{
public static void main(String args[]) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
for(int i=0;i<n;i++){
int m = sc.nextInt();
int count = 0;
for(int j=0;j<m;j++){
count+=sc.nextInt()-1;
}
... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 0b8e3a86d87d710eea7fbf5c35d940c8 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.*;
public class A_Log_Chopping{
public static void main(String[] args){
Scanner sc = new Scanner(System.in) ;
int t = sc.nextInt();
while(t-- >0){
int c=0;
int n =sc.nextInt();
for(int i=0; i<n; i++){
... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | e5249e8a932b5306fa003f291319fc64 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.*;
import java.io.*;
public class Main {
// when can't think of anything -->>
// 1. In sorting questions try to think about all possibilities like starting from start, end, middle.
// 2. Two pointers, brute force.
// 3. In graph query questions try to solve it reversely or try to proc... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 4d8b5bbd99373e044301a9c2f4876760 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.*;
public class Codeforces {
static Scanner scan = new Scanner(System.in);
static boolean[] was = new boolean[100000000];
public static void main(String... args) {
int t = scan.nextInt();
while ( t-- > 0 ) {
solve();
}
}
public s... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 89d338cf0c0ac69550f892d7c5361a2b | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.*;
public class InfiniteReplacement {
public static boolean isWinner(int[] logs) {
int sum = 0;
for(int i=0;i<logs.length;i++)
sum += logs[i];
sum -= logs.length;
return sum%2 == 1;
}
public static void main(String[] args) {
... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 6c784d461221e2e7f7f2a524694b3fc4 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.*;
public class P1672A_LogChopping {
public static void main(String[] args){
//System.out.println("top");
Scanner in = new Scanner(System.in);
int numTests = Integer.parseInt(in.nextLine());
//System.out.println("numTests = " + numTests);
for... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 71ceb47bbbff8a3ecb6c69d6b948cdae | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.*;
public class Main
{
public static void main(String args[])
{
long t;int n,i,s=0;
Scanner x=new Scanner(System.in);
t=x.nextLong();
while(t>0)
{
t--;
n=x.nextInt();
int[] a=new int[n];
for(i=0;i<n;i++)
{
a[i]=x.nextInt();
s+=a[i];
}
s=s-n;
if(s%2==1)
System.out.p... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | e8a949fe4df127ba90533edde793cf54 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
import java.lang.*;
public class Solution{
static long mod=(long)1e9+7;
static int mod1=998244353;
static int[] cost=new int[(int)1005];
static FastScanner sc = new FastScanner();
// static Strin... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 53b8033c3b4f188d93b8713466141a2d | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes |
import java.io.*;
import java.util.*;
public class Script {
static boolean flag = false;
// Driver code
public static void main(String[] args) throws Exception
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(br.readLine());
... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 4fc51b10dc7d129f29c168caa8a7d40e | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;
public class Solution {
public static void main(String[] args) throws Exception {
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
long T = Integer.parseInt(reader.r... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | abe2a95d3780cf04619703266f2afce4 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.Scanner;
public class LogChopping{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
for(int j=0;j<t;j++){
int n = sc.nextInt();
int sum = 0;
for(int i=0;i<n;i++){
... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 5df734df7b393a7e18ade924ca9e5a0a | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 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(), ans = 0, arr[] = new int[n];
for(int i=0;i<n;i++) arr[i] = sc.nextInt();
for(int x : arr) if(x % 2 == 0) ans++... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 72bc7c283b3e2a1698dab7e30c64f80b | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class A_Log_Chopping{
static void solve(int n, int[] arr) {
int sum=0;
for (int i : arr) {
sum+=i-1;
}
if(sum%2==0)
{
... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | fd413a31ee2ee82efde35efbcb889e5d | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class A_Log_Chopping{
static void solve(int n, int[] arr) {
int sum=0;
for (int i : arr) {
sum+=i-1;
}
if(sum%2==0)
{
... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 1a3ec5a23133a1197a0f6d78a7ac7918 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class schnipschnap {
static class FastScanner {
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st=new StringTokeni... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | ce9d8194405a73a63581b1c868380bcf | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.Scanner;
public class A {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int t = s.nextInt();
for(int c = 0; c < t; c++){
int len = s.nextInt();
int k=0;
for (int i = 0; i < len; i++) {
... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | eebd2630473d68c416aeecb621a9e356 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int test = sc.nextInt();
String ans = "";
while(test-->0){
int n = sc.nextInt();
int[] A = new int[n];
for(int i=0; i<n; i++)
A[i] = sc.nextInt();
int sum = ... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 187e0671723649bc5985ddec46e0234b | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.io.*;
import java.util.*;
import java.math.BigInteger;
public class Main
{
InputStream is;
PrintWriter out = new PrintWriter(System.out); ;
String INPUT = "";
void run() throws Exception
{
is = System.in;
solve();
out.flush();
o... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 326195d4210dc756752ddfc1b1461297 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.Scanner;
public class ProblemA {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
while (t-- > 0) {
int size = sc.nextInt();
int[] logs = new int[size];
... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 9fcb50249c4c5b370dce0509c0d13cb5 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes |
import java.util.Arrays;
import java.util.Scanner;
public class ProblemA {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
while (t-- > 0) {
int size = sc.nextInt();
int[] logs = new int[size];
... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 92a422d78e35b8ac863ffa404319c591 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.*;
public class HelloWorld{
public static void main(String []args){
Scanner sc=new Scanner(System.in);
int t=sc.nextInt();
while(t-->0){
int n=sc.nextInt();
int count=0;
int[]arr=new int[n];
for(int i=... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 7dc16dfc823af689f5c5da24617238db | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 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){
t--;
int n=sc.nextInt();
int []arr= new int[n];
for (int i = 0; i < arr.length; i+... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | cca4335cee54f0025f42ee54d86b08d7 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 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 t=Integer.parseInt(br.readLine());
... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 2c0c38aabac95a4aece2083042fd9e79 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 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();
ArrayList<Integer> a = new ArrayList<Integer>();
for(int i=0; i<n; ++i) {
a.add(sc.nextInt());
}
for(i... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 1aaa770546c0f3fe9f8b8c9cbe8f8037 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.*;
public class PC {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
sc.nextLine();
for (int z = 0; z < t; z++) {
int n = sc.nextInt();
int sum = 0; char w = ' ';
... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | fe7b43353f55109b6526d92cd830007c | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.*;
import java.lang.*;
import java.io.*;
public class solution
{
public static void main (String[] args) throws java.lang.Exception
{
Scanner sc = new Scanner(System.in) ;
int w = sc.nextInt() ;
while(w>0){
int n = sc.nextInt() ;
int[] arr = new int[n] ;
for(int... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 08b92df68502a0e4f2d4d20db278ca35 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.*;
public class codeforce {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
while (a-->0){
int len = sc.nextInt();
int arr[] = n... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output | |
PASSED | 848af5c584d1ab998ff1329456a5d044 | train_108.jsonl | 1650722700 | There are $$$n$$$ logs, the $$$i$$$-th log has a length of $$$a_i$$$ meters. Since chopping logs is tiring work, errorgorn and maomao90 have decided to play a game.errorgorn and maomao90 will take turns chopping the logs with errorgorn chopping first. On his turn, the player will pick a log and chop it into $$$2$$$ pie... | 256 megabytes | import java.util.Scanner;
public class Log_Chopping
{
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[n];
int steps = 0;... | Java | ["2\n\n4\n\n2 4 2 1\n\n1\n\n1"] | 1 second | ["errorgorn\nmaomao90"] | NoteIn the first test case, errorgorn will be the winner. An optimal move is to chop the log of length $$$4$$$ into $$$2$$$ logs of length $$$2$$$. After this there will only be $$$4$$$ logs of length $$$2$$$ and $$$1$$$ log of length $$$1$$$.After this, the only move any player can do is to chop any log of length $$$2... | Java 11 | standard input | [
"games",
"implementation",
"math"
] | fc75935b149cf9f4f2ddb9e2ac01d1c2 | Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 50$$$) — the number of logs. The second line of... | 800 | For each test case, print "errorgorn" if errorgorn wins or "maomao90" if maomao90 wins. (Output without quotes). | standard output |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.