id int64 0 4.52k | code stringlengths 142 31.2k | answer stringclasses 7
values | prompt stringlengths 1.64k 32.6k | test_prompt stringlengths 1.7k 32.7k | token_length int64 373 7.8k | __index_level_0__ int64 0 4.5k |
|---|---|---|---|---|---|---|
3,254 | import java.io.*;
public class Main {
private StreamTokenizer in;
private PrintWriter out;
public static void main(String[] args) throws IOException {
//long time = System.currentTimeMillis();
new Main().run();
//time = System.currentTimeMillis() - time;
//System.out.pri... | O(1) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 528 | 3,248 |
274 | import java.util.*;
import java.io.*;
public class A
{
public static void main(String ar[]) throws Exception
{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
String s1[]=br.readLine().split(" ");
int n=Integer.parseInt(s1[0]);
int m=In... | O(nlog(n)) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 569 | 274 |
3,688 | import java.io.*;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.util.*;
import static java.lang.Math.*;
public class Main {
final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;
BufferedReader in;
Pr... | O(n^3) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 3,844 | 3,680 |
3,117 | import java.io.InputStreamReader;
import java.util.Scanner;
import java.io.IOException;
public class kresz {
public static double a;
public static double v;
public static double l;
public static double d;
public static double w;
public static double gyorsulut (double v1, double v2) { //v1 -> v2 mennyi utat te... | O(1) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 962 | 3,111 |
3,767 | import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOExcept... | O(n^3) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 1,793 | 3,759 |
917 | import java.io.BufferedReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.io.ObjectInputStream.GetField;
import java.security.KeyStore.Entry;
import java.util.ArrayList;
import ... | O(log(n)) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 1,184 | 916 |
2,007 | import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.io.OutputStreamWriter;
import java.util.NoSuchElementException;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Iterator;
import ja... | O(nlog(n)) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 4,406 | 2,003 |
4,214 | import java.util.Scanner;
public class Fishes {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int n = s.nextInt();
double[][] p = new double[n][n];
double[] dp = new double[1 << 18];
for (int i = 0; i < n; i++) {
for (int j = 0; j ... | non-polynomial | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 692 | 4,203 |
2,737 | import java.io.*;
import java.util.*;
public class LCMChallenge {
public static void main(String[] args) throws IOException {
BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
long n = Long.parseLong(f.readLine());
if (n == 1 || n == 2)
System.out.println(... | O(1) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 559 | 2,731 |
1,364 |
import java.io.*;
import java.math.*;
import static java.lang.Math.*;
import java.security.SecureRandom;
import static java.util.Arrays.*;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import sun.misc.Regexp;
import java.awt.geom.*;
import sun.net.www.content.text.plain;
public c... | O(log(n)) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 1,213 | 1,362 |
446 |
import java.io.*;
import java.util.*;
import java.lang.*;
import static java.lang.Math.*;
// _ h _ r _ t r _
// _ t _ t _ s t _
public class TaskA implements Runnable {
long m = (int)1e9+7;
PrintWriter w;
InputReader c;
final int MAXN = (int)1e6 + 100;
public void run() {
c = new Input... | O(n) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 2,383 | 445 |
2,268 | import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
/*
public class _909C {
}
*/
public class _909C {
int mod = (int) 1e9 + 7;
public void solve() throws FileNotFoundEx... | O(n^2) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 972 | 2,263 |
1,851 | import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Iterator;
import java.util.ListIterator;
import java.util.Collection;
import java.util.AbstractList;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.Deq... | O(nlog(n)) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 6,442 | 1,847 |
268 | import java.util.*;
import java.io.*;
public class SonyaExhibition {
static BufferedReader br;
static StringTokenizer tokenizer;
public static void main(String[] args) throws Exception {
br = new BufferedReader(new InputStreamReader(System.in));
int n = nextInt();
int[] arr = {0,1};
for(int i = 0; i < n; i... | O(n) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 501 | 268 |
3,851 | import java.io.*;
import java.util.*;
public class Codeforces
{
public static void main(String args[])throws Exception
{
BufferedReader bu=new BufferedReader(new InputStreamReader(System.in));
StringBuilder sb=new StringBuilder();
int t=Integer.parseInt(bu.readLine());
while(t--... | O(n^3) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 558 | 3,841 |
1,760 | //package round15;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
public class A {
static StreamTokenizer in =
new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
static int nextInt(... | O(nlog(n)) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 743 | 1,756 |
1,990 | //package round113;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Comparator;
public class A {
InputStream is;
PrintWriter out;
String INPUT = "";
void solve()
{
int n = ni(), k = ni();
int[]... | O(nlog(n)) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 1,362 | 1,986 |
1,377 | import java.util.Scanner;
public class b {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
long n = sc.nextLong() - 1, k = sc.nextLong() - 1;
int a = 0;
if ((k + 1) * k / 2 < n) {
System.out.println(-1);
return;
}
... | O(log(n)) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 624 | 1,375 |
282 | import java.util.HashSet;
import java.util.Scanner;
public class Solution {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
HashSet<Integer> set = new HashSet<>();
for(int i = 0; i<n; i++){
int a = sc.nextInt();
... | O(n) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 423 | 282 |
1,936 | import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Scanner;
public class nA {
Scanner in;
PrintWriter out;
void solve() {
int n = in.nextInt();
int a[] = new int[n];
int sum = 0;
for (int i = 0; i < n; i++) {
a[i] = in.nextInt();
... | O(nlog(n)) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 555 | 1,932 |
2,464 | import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
public class Main {
private static class Interval implements Comparable<Interval> {
public int start , end;
public Interval(int start , int end) {
this.st... | O(n^2) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 955 | 2,459 |
3,434 | import java.util.Scanner;
public class A {
public static void main(String[] args) {
new A().run();
}
private void run() {
Scanner sc = new Scanner(System.in);
String s = sc.next();
sc.close();
int res = 0;
for (int i = 0; i < s.length(); i++)
for (int j = i + 1; j <= s.length(); j++) {
Stri... | O(n^3) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 527 | 3,428 |
4,487 | import java.io.*;
import java.math.BigInteger;
import java.util.*;
public class E implements Runnable {
public static void main (String[] args) {new Thread(null, new E(), "_cf", 1 << 28).start();}
int n, m;
char[] str;
int[][] occs, cost;
int[] dp;
public void run() {
FastScanner fs = new FastScanner();
P... | non-polynomial | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 1,483 | 4,476 |
4,138 | 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 LookingForOrder {
static int[] x, y;
static int[] dp;
static int n;
static int dist(int i, int j) {
return ((x[i] - x[... | non-polynomial | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 1,125 | 4,127 |
69 | import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;
public class D {
private void solve() {
br = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(System.out);
int n = nextInt(), m = nextI... | O(n^2) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 704 | 69 |
3,204 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
public class CF {
public static void main(String[] args) throws IOException {
InputStream inpu... | O(1) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 662 | 3,198 |
4,063 | import java.util.*;
import java.io.*;
public class Main{
BufferedReader in;
StringTokenizer str = null;
PrintWriter out;
private String next() throws Exception{
if (str == null || !str.hasMoreElements())
str = new StringTokenizer(in.readLine());
return str.nextToken();
}
... | non-polynomial | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 1,215 | 4,052 |
873 |
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.HashSet;
import java.util.Set;
import java.util.StringTokenizer;
public class B {
static BufferedReader in;
static StringTokenizer st;
... | O(n) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 665 | 872 |
3,208 |
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;
public class e {
public static class FastReader {
BufferedReader br;
StringTokenizer st;
//it reads the data about the specified point and divide the data about it... | O(1) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 903 | 3,202 |
2,957 | //package CF;
// Div One
import java.util.*;
public class CFA_200 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
long x = sc.nextLong();
long y = sc.nextLong();
System.out.println(Wilf_tree(x, y));
sc.close();
}
static long Wilf_tree(long a,long b)
{
if(a==0|... | O(1) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 475 | 2,951 |
879 | import java.io.*;
import java.math.BigInteger;
import java.util.*;
public class Main {
static final double eps = 1e-8;
public static void main(String[] args) throws IOException {
try {
... | O(n) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 999 | 878 |
325 | import java.io.*;
import java.util.*;
import java.math.*;
public class Main {
Scanner in;
PrintWriter out;
StreamTokenizer ST;
BufferedReader br;
int nextInt() throws IOException {
ST.nextToken();
return (int) ST.nval;
}
double nextDouble() throws IOException {
ST.nextToken();
return ST.nval;
}
Str... | O(n) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 677 | 325 |
570 | //package global14;
import java.util.Scanner;
public class B {
public static void main(String[] args){
Scanner in = new Scanner(System.in);
int t = in.nextInt();
while(t > 0){
t --;
int n = in.nextInt();
if(n % 2 != 0){
System.out.prin... | O(n) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 552 | 569 |
623 | //package round495;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.HashSet;
import java.util.InputMismatchException;
import java.util.Set;
public class A {
InputStream is;
PrintWriter out;
String INPU... | O(n) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 1,348 | 622 |
3,312 | import java.util.*;
import java.io.*;
import java.text.*;
import java.math.*;
import static java.lang.Integer.*;
import static java.lang.Double.*;
import java.lang.Math.*;
public class two_squares {
public static void main(String[] args) throws Exception {
new two_squares().run();
}
public void run() throws Exc... | O(1) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 2,358 | 3,306 |
4,133 | import java.io.IOException;
import java.io.OutputStreamWriter;
import java.util.Arrays;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.util.Comparator;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.NoSuchElementException;
import java.io.Writer;
import jav... | non-polynomial | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 1,698 | 4,122 |
1,872 | import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.FilterInputStream;
import java.io.BufferedInputStream;
import java.math.BigInteger;
import java.util.HashMap;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution... | O(nlog(n)) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 1,094 | 1,868 |
2,097 | import java.io.*;
import java.util.*;
public class A {
final String filename = new String("A").toLowerCase();
void solve() throws Exception {
int n = nextInt();
int[] a = new int[n];
int m = -1;
for (int i = 0; i < n; i++) {
a[i] = nextInt();
if (m == -1 || a[i] > a[m]) {
m = i;
}
}
if (a[... | O(nlog(n)) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 692 | 2,093 |
169 | import java.util.*;
public class A
{
public static void main(String args[])
{
Scanner sc=new Scanner(System.in);
long n=sc.nextLong();
if(n==0)
System.out.println(0);
else if(n%2==1)
System.out.println((n+1)/2);
else
System.out.println(n+1);
}
... | O(1) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 432 | 169 |
3,948 | import java.util.*;
import java.io.*;
public class E {
void solve(BufferedReader in) throws Exception {
int[] xx = toInts(in.readLine());
int n = xx[0];
double k = xx[1];
int[][] board = new int[n][n];
for(int i = 0; i<n; i++) board[i] = toInts(in.readLine());
int fst... | non-polynomial | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 981 | 3,937 |
3,439 | import static java.lang.Math.*;
import static java.util.Arrays.*;
import java.io.*;
import java.util.*;
public class Main {
static boolean LOCAL = false;//System.getSecurityManager() == null;
Scanner sc = new Scanner(System.in);
void run() {
char[] cs = sc.nextLine().toCharArray();
int... | O(n^3) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 807 | 3,433 |
2,513 | import java.util.HashMap;
import java.util.Scanner;
public class Main{
int[] ints;
int[] prefix;
public static void main(String[] args)
{
new Main().run();
}
public void run()
{
Scanner file = new Scanner(System.in);
int N = file.nextInt();
ints = new int[N];
for(int i = 0;i<N;i++)
ints[i] = ... | O(n^2) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 808 | 2,507 |
2,484 | /*
Keep solving problems.
*/
import java.util.*;
import java.io.*;
public class CFA {
BufferedReader br;
PrintWriter out;
StringTokenizer st;
boolean eof;
private static final long MOD = 1000L * 1000L * 1000L + 7;
private static final int[] dx = {0, -1, 0, 1};
private static final int[] dy... | O(n^2) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 1,400 | 2,479 |
3,576 | import java.io.*;
import java.util.*;
public class Main implements Runnable {
public void _main() throws IOException {
int height = nextInt();
int width = nextInt();
int k = nextInt();
int[] r = new int[k];
int[] c = new int[k];
for (int i = 0; i < k; i++) {
r[i] = nextInt() - 1;
c[i] = nextInt()... | O(n^3) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 779 | 3,568 |
2,195 | import java.util.*;
import java.io.*;
public class C
{
static long time = System.currentTimeMillis();
public static void main(String[] args) throws IOException
{
//FastReader infile = new FastReader("test.txt");
FastReader infile = new FastReader(System.in);
int N = infile.nextInt();
in... | O(n^2) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 887 | 2,191 |
703 | import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main {
public static void main(String[] args) {
Scanner scn = new Scanner(System.in);
int t = scn.nextInt();
while(t-- >0){
String str = scn.next();
Pattern p = Pattern.compile("R[0-9]+C[0-9]+");
... | O(n) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 686 | 702 |
155 | import java.util.Scanner;
public class MargariteBestPresent_1080B {
private static int f(int x) {
return (x%2==0)?x/2:(x-1)/2-x;
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n,r,l;
n = sc.nextInt();
while(n-->0) {
l = sc.nextInt();
r = sc.nextInt();
Syst... | O(1) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 472 | 155 |
2,759 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////// SOLUTION ///////////////////////////////... | O(1) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 540 | 2,753 |
3,546 | // upsolve with rainboy
import java.io.*;
import java.util.*;
public class CF1187G extends PrintWriter {
CF1187G() { super(System.out); }
static class Scanner {
Scanner(InputStream in) { this.in = in; } InputStream in;
int k, l; byte[] bb = new byte[1 << 15];
byte getc() {
if (k >= l) {
k = 0;
try {... | O(n^3) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 2,008 | 3,539 |
930 | import java.io.*;
import java.math.BigInteger;
import java.util.*;
public class Main {
static int inf = (int) 1e9;
public static void main(String[] args) throws IOException {
br = new BufferedReader(new InputStreamReader(System.in));
pw = new PrintWriter(System.out);
int n = nextInt();
... | O(log(n)) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 614 | 929 |
3,225 |
import java.util.Scanner;
/**
* Feb 18, 2016 | 4:00:49 PM
* <pre>
* <u>Description</u>
*
* </pre>
*
* @author Essiennta Emmanuel (colourfulemmanuel@gmail.com)
*/
public class ProblemA{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
sc.next();
Syst... | O(1) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 457 | 3,219 |
1,242 | import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.InputMismatchException;
/**
* Created by hama_du on 15/09/10.
*/
public class A {
private static final long MOD = 1000000009;
public static void main(String[] args) {
InputRe... | O(log(n)) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 1,575 | 1,241 |
2,479 | import java.io.PrintWriter;
import java.util.*;
public class Main{
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
PrintWriter out=new PrintWriter(System.out);
int n=sc.nextInt();
int a[]=new int[n];
for (int i = 0; i <n ; i++) {
a[i]... | O(n^2) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 806 | 2,474 |
2,098 |
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.util.Arrays;
import java.util.StringTokenizer;
import java.util.logging.Level;
import java.util.logging.Logger;
public class ProblemA {
private final BufferedReader in;
private... | O(nlog(n)) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 801 | 2,094 |
4,077 | import java.util.Arrays;
import java.util.Scanner;
/**
* @author vstepanov on 3/29/2017.
*/
public class Main {
public static void main(String[] args) {
try(Scanner in = new Scanner(System.in)) {
int bx = in.nextInt();
int by = in.nextInt();
int n = in.nextInt();
... | non-polynomial | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 1,055 | 4,066 |
2,504 |
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.InputMismatchException;
import java.util.List;
public class Q6 {
public static void main(String[] args)... | O(n^2) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 1,872 | 2,498 |
3,680 | import java.util.*;
import java.io.*;
public class C {
private static int[] dx = {1, -1, 0, 0};
private static int[] dy = {0, 0, -1, 1};
public static void main(String[] args) throws Exception{
Thread t = new Thread(null, null, "~", Runtime.getRuntime().maxMemory()){
@Override
public void run(){
try {... | O(n^3) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 894 | 3,672 |
3,907 | import java.util.*;
public class CompressionAndExpansion {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int T = in.nextInt();
for (int t = 0; t < T; t++) {
int N = in.nextInt();
List<Integer> list = new ArrayList<>();
for (... | O(n^3) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 548 | 3,897 |
2,363 | import java.io.BufferedReader;
import java.io.Closeable;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Scanner;
import java.util.StringTokenizer;
pub... | O(n^2) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 1,075 | 2,358 |
1,844 | import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] wide = new int[n], sta = new int[n];
HashMap<Integer, Integer> hm = new HashMap<Integer, Integer>();
for (int i = 0; i < n; i++)... | O(nlog(n)) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 2,080 | 1,840 |
989 | import java.io.*;
import java.math.*;
import java.text.*;
import java.util.*;
import java.util.regex.*;
public class Main {
public static void main(String[] args) throws IOException {
InputStreamReader r = new InputStreamReader(System.in);
BufferedReader f = new BufferedReader(r);
Sc... | O(log(n)) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 487 | 988 |
223 | import java.util.*;
import java.io.*;
import java.lang.*;
import java.math.*;
public class B {
public static void main(String[] args) throws Exception {
BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
PrintWriter out = new PrintWriter(new Out... | O(n) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 757 | 223 |
317 | import java.io.*;
import java.util.*;
public class Main {
static InputReader in = new InputReader(System.in);
static PrintWriter out = new PrintWriter(System.out);
static long oo = 1000000000000L;
public static void main(String[] args) throws IOException {
int n = in.nextInt();
int q = in.nextInt()... | O(n) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 2,133 | 317 |
4,312 | import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class B{
public static void main(String[] args) throws Exception{
new B().run();
}
double ans = 0;
int n, candy, A, half;
void run() throws Exception{
Scanner sc = new Scanner(System.in);
//Buffer... | non-polynomial | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 1,028 | 4,301 |
2,456 | //package com.example.programming;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
public class Test {
static class Pair {
int f,s;
public Pair(int x, int ... | O(n^2) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 752 | 2,451 |
1,274 | import java.io.*;
import java.util.*;
import java.math.*;
import java.lang.*;
import static java.lang.Math.*;
public class Main implements Runnable {
static class InputReader {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numCha... | O(log(n)) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 1,545 | 1,272 |
2,491 | /*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
//package Round547;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Array... | O(n^2) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 1,993 | 2,486 |
2,083 | import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.AbstractList;
import java.io.Writer;
import java.util.List;
import java.io.IOException;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.math.BigInteger;
import java.io.InputStream;
/**
* Built using CHelper plug-in... | O(nlog(n)) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 1,222 | 2,079 |
4,145 | import java.util.*;
import java.io.*;
public class Main {
static final int MAXN = 24;
int[] x = new int[MAXN];
int[] y = new int[MAXN];
int[][] dist = new int[MAXN][MAXN];
int[] single = new int[MAXN];
int sqr(int x) { return x * x; }
void run(int nT) {
int xs = cin.n... | non-polynomial | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 1,196 | 4,134 |
2,506 | import javax.print.attribute.standard.PrinterMessageFromOperator;
import java.io.*;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.*;
public class Main {
public static void main(String[] args) throws Exception {
new Main().run();}
// int[] h,ne,to,wt;
// int ct = 0;
// ... | O(n^2) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 6,345 | 2,500 |
2,720 | import java.io.*;
import java.util.*;
public class Lcm
{
public static void main(String args[])throws Exception
{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
PrintWriter pw=new PrintWriter(System.out);
long n=Long.parseLong(br.readLine());
if(n<=2)
pw.println(n);
else
{
if(n%6==0)
{
pw.p... | O(1) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 464 | 2,714 |
4,180 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;
public class A {
static double[][] a;
static int N;
static double[] memo;
static double dp(int alive)
... | non-polynomial | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 989 | 4,169 |
1,073 | import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Scanner;
public class Main {
static ArrayList<BigInteger> bs = new ArrayList<>();
static void getBs(int n, BigInteger k) {
BigInteger four = BigInteger.valueOf(4);
BigInteger tmp4 = BigInteger.valueOf(1);
BigInt... | O(log(n)) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 778 | 1,072 |
257 | 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... | O(n^2) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 830 | 257 |
848 | import java.util.*;
import java.util.regex.*;
import java.text.*;
import java.math.*;
public class Main
{
Scanner cin;
int []prime;
int top;
void work()
{
cin=new Scanner(System.in);
int n=cin.nextInt();
int k=cin.nextInt();
top=0;
prime=new int[2000];
... | O(n) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 603 | 847 |
1,104 | import java.io.*;
import java.util.*;
public class B {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
Task solver = new Task();
solver.solv... | O(log(n)) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 845 | 1,103 |
62 |
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;
public class e {
public static class FastReader {
BufferedReader br;
StringTokenizer st;
//it reads the data about the specified point and divide the data about it... | O(1) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 900 | 62 |
1,084 | 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.util.ArrayList;
import java.io.InputStream;
/**
* Built using CHel... | O(log(n)) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 1,198 | 1,083 |
596 | import javafx.collections.transformation.SortedList;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Array;
import java.util.*;
public class Main {
public static void main(String[] args) throws IOException {
Scan scan = new Scan();
int n = scan.scanInt();
... | O(n) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 1,370 | 595 |
2,608 | import java.util.*;
import java.io.*;
import java.text.*;
import java.math.*;
import static java.lang.Integer.*;
import static java.lang.Double.*;
import java.lang.Math.*;
public class A {
public static void main(String[] args) throws Exception {
new A().run();
}
public void run() throws Exception {
FastIO fi... | O(n^2) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 1,113 | 2,602 |
41 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
public class D909 {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
char[] line = br.readLin... | O(n) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 788 | 41 |
24 | import java.util.*;
public class Main {
static int n=5;
static int[] arr=new int[5];
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n=sc.nextInt();
int arr[]=new int[n];
for (int i=0;i<n;i++)
{
arr[i]=sc.nextInt();
... | O(n) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 547 | 24 |
857 | import java.util.*;
import java.io.*;
public class A{
public static void main(String args[]){
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int ans = 0;
for(int i = 1; i <= n; i++){
ans += ((i*2) <= n) ? i : n-i+1;
... | O(n) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 420 | 856 |
2,344 | import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.util.NoSuchElementException;
public class Main {
static PrintWriter out;
static InputReader ir;
static void solve() {
int n=ir.nextInt();
int[] a=ir.nextIntArray(n);
int m... | O(n^2) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 1,657 | 2,339 |
1,930 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
public class con111_A {
public static void main( final String[] args ) throws IOException {
final BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) );
fina... | O(nlog(n)) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 601 | 1,926 |
4,211 | import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
public class Main {
public static void main(String[] args) throws Exception {
StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
... | non-polynomial | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 728 | 4,200 |
3,347 | import java.util.Scanner;
public class Prob023A
{
public static void main( String[] Args )
{
Scanner scan = new Scanner( System.in );
String s = scan.next();
all: for ( int x = s.length() - 1; x >= 0; x-- )
for ( int y = 0; x + y <= s.length(); y++ )
{
... | O(n^3) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 488 | 3,341 |
2,435 | import java.util.*;
public class vas2 {
public static void main( String[] args ) {
Scanner in = new Scanner( System.in );
int n = in.nextInt();
String st = in.next();
int[] a = new int[n];
for ( int i = 0; i < n; i++ )
a[i] = st.charAt( i ) - 48;
boolean c = false;
for ( int i = 1; !c && i < n; i++ ) {... | O(n^2) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 553 | 2,430 |
1,485 | import java.util.*;
import java.io.*;
import java.math.*;
import java.awt.geom.*;
import static java.lang.Math.*;
public class Solution implements Runnable {
boolean hasBit(long n, int pos) {
return (n & (1L << pos)) != 0;
}
public void solve() throws Exception {
long l = sc.next... | O(log(n)) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 772 | 1,483 |
1,119 | import java.util.*;
public class ehab4 {
public static void main( String[] args ) {
Scanner in = new Scanner( System.in );
int a = 0, b = 0;
System.out.println( "? 0 0 " );
System.out.flush();
int c = in.nextInt();
for ( int i = 29; i >= 0; i-- ) {
System.out.println( "? " + ( a + ( 1 << i ) ) + ... | O(log(n)) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 626 | 1,118 |
413 | import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;
public class Main2 {
static List<List<Integer>> getLayers(int[] numbers, int a, int b) {
boolean[] used = new boolean[numbers.length];
HashSet<Integer> hs ... | O(n) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 1,426 | 412 |
3,349 | /**
* MxNINJA 04:06:52 ص 14/01/2014
*/
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class Main {
public static void main(String[] args) throws Exception {
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
StringBuilder line = new StringBuild... | O(n^3) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 500 | 3,343 |
919 |
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 solu... | O(log(n)) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 673 | 918 |
411 |
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
public class TwoSets<V> {
private static int n;
private static int a;
private static int b;
private static List<Node<Integer>> nodes = new Linke... | O(n) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 1,722 | 410 |
3,509 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.PriorityQueue;
imp... | O(n^3) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 1,657 | 3,503 |
137 | /**
* BaZ :D
*/
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class Main
{
static Reader scan;
static PrintWriter pw;
static int n,k,left[],right[],arr[];
static long MOD = 1000000007,count[],dp[];
public static void main(String[] args) {
new Thread(null,null... | O(n) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 2,119 | 137 |
1,794 | import java.util.Arrays;
import java.util.InputMismatchException;
import java.io.*;
/**
* Generated by Contest helper plug-in
* Actual solution is at the bottom
*/
public class Main {
public static void main(String[] args) {
InputReader in = new StreamInputReader(System.in);
PrintWriter out = ne... | O(nlog(n)) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 1,128 | 1,790 |
1,290 | import java.util.*;
import java.io.*;
import java.lang.*;
import java.math.*;
public class C {
public static void main(String[] args) throws Exception {
BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
// Scanner scan = new Scanner(System.in);
PrintWriter out = new P... | O(log(n)) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 721 | 1,288 |
2,256 | import java.util.Scanner;
public class maestro{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
long mod = (long)Math.pow(10,9)+7;
long[][] arr = new long[N][N];
arr[0][0]=1;
for (int i=1;i<N;i++){
char c ... | O(n^2) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 554 | 2,251 |
2,678 |
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
public class A {
public static void main(String[] args) throws IOException {
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
int n = Integer.parseInt... | O(n^2) | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | Evaluate the code based on the given task, code, and evaluation rubric. Provide a fair and detailed assessment following the rubric.
The XML tags are defined as follows:
- <TASK>: Describes what the responses are supposed to accomplish.
- <CODE>: The code provided to be evaluated.
- <EVALUATION_RUBRIC>: Evaluation rubr... | 556 | 2,672 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.