exec_outcome stringclasses 1
value | code_uid stringlengths 32 32 | file_name stringclasses 111
values | prob_desc_created_at stringlengths 10 10 | prob_desc_description stringlengths 63 3.8k | prob_desc_memory_limit stringclasses 18
values | source_code stringlengths 117 65.5k | lang_cluster stringclasses 1
value | prob_desc_sample_inputs stringlengths 2 802 | prob_desc_time_limit stringclasses 27
values | prob_desc_sample_outputs stringlengths 2 796 | prob_desc_notes stringlengths 4 3k ⌀ | lang stringclasses 5
values | prob_desc_input_from stringclasses 3
values | tags listlengths 0 11 | src_uid stringlengths 32 32 | prob_desc_input_spec stringlengths 28 2.37k ⌀ | difficulty int64 -1 3.5k ⌀ | prob_desc_output_spec stringlengths 17 1.47k ⌀ | prob_desc_output_to stringclasses 3
values | hidden_unit_tests stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
PASSED | 003f37dcf1fbc84b2f9e30680f3177bf | train_109.jsonl | 1613658900 | The only difference between the easy and the hard version is the limit to the number of queries.This is an interactive problem.There is an array $$$a$$$ of $$$n$$$ different numbers. In one query you can ask the position of the second maximum element in a subsegment $$$a[l..r]$$$. Find the position of the maximum eleme... | 256 megabytes | // practice with kaiboy
import java.io.*;
import java.util.*;
public class CF1486C2 extends PrintWriter {
CF1486C2() { super(System.out, true); }
Scanner sc = new Scanner(System.in);
public static void main(String[] $) {
CF1486C2 o = new CF1486C2(); o.main(); o.flush();
}
int query(int l, int r) {
println("?... | Java | ["5\n\n3\n\n4"] | 1 second | ["? 1 5\n\n? 4 5\n\n! 1"] | NoteIn the sample suppose $$$a$$$ is $$$[5, 1, 4, 2, 3]$$$. So after asking the $$$[1..5]$$$ subsegment $$$4$$$ is second to max value, and it's position is $$$3$$$. After asking the $$$[4..5]$$$ subsegment $$$2$$$ is second to max value and it's position in the whole array is $$$4$$$.Note that there are other arrays $... | Java 11 | standard input | [
"binary search",
"interactive"
] | eb660c470760117dfd0b95acc10eee3b | The first line contains a single integer $$$n$$$ $$$(2 \leq n \leq 10^5)$$$ — the number of elements in the array. | 1,900 | null | standard output | |
PASSED | 436cf6667588af895779e5d40999d459 | train_109.jsonl | 1613658900 | The only difference between the easy and the hard version is the limit to the number of queries.This is an interactive problem.There is an array $$$a$$$ of $$$n$$$ different numbers. In one query you can ask the position of the second maximum element in a subsegment $$$a[l..r]$$$. Find the position of the maximum eleme... | 256 megabytes |
import java.util.*;
import java.util.concurrent.CompletableFuture;
import javax.swing.text.Segment;
import java.io.*;
import java.math.*;
import java.sql.Array;
public class Main {
static class Reader{
BufferedReader br;
StringTokenizer st;
public Reader() {
br = new Buffe... | Java | ["5\n\n3\n\n4"] | 1 second | ["? 1 5\n\n? 4 5\n\n! 1"] | NoteIn the sample suppose $$$a$$$ is $$$[5, 1, 4, 2, 3]$$$. So after asking the $$$[1..5]$$$ subsegment $$$4$$$ is second to max value, and it's position is $$$3$$$. After asking the $$$[4..5]$$$ subsegment $$$2$$$ is second to max value and it's position in the whole array is $$$4$$$.Note that there are other arrays $... | Java 11 | standard input | [
"binary search",
"interactive"
] | eb660c470760117dfd0b95acc10eee3b | The first line contains a single integer $$$n$$$ $$$(2 \leq n \leq 10^5)$$$ — the number of elements in the array. | 1,900 | null | standard output | |
PASSED | 2f9af0a844afeed42060dc32a698b7e1 | train_109.jsonl | 1613658900 | The only difference between the easy and the hard version is the limit to the number of queries.This is an interactive problem.There is an array $$$a$$$ of $$$n$$$ different numbers. In one query you can ask the position of the second maximum element in a subsegment $$$a[l..r]$$$. Find the position of the maximum eleme... | 256 megabytes | import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.io.PrintWriter;
public class guess {
public static void main(String[] args) {
FastScanner in = new FastScanner();
PrintWriter out = new PrintWriter(System.out);
int n = in.nextInt();
int sec = ask(in... | Java | ["5\n\n3\n\n4"] | 1 second | ["? 1 5\n\n? 4 5\n\n! 1"] | NoteIn the sample suppose $$$a$$$ is $$$[5, 1, 4, 2, 3]$$$. So after asking the $$$[1..5]$$$ subsegment $$$4$$$ is second to max value, and it's position is $$$3$$$. After asking the $$$[4..5]$$$ subsegment $$$2$$$ is second to max value and it's position in the whole array is $$$4$$$.Note that there are other arrays $... | Java 11 | standard input | [
"binary search",
"interactive"
] | eb660c470760117dfd0b95acc10eee3b | The first line contains a single integer $$$n$$$ $$$(2 \leq n \leq 10^5)$$$ — the number of elements in the array. | 1,900 | null | standard output | |
PASSED | fe9b0035d0a4f8fb8f5fafe8b461dae8 | train_109.jsonl | 1613658900 | The only difference between the easy and the hard version is the limit to the number of queries.This is an interactive problem.There is an array $$$a$$$ of $$$n$$$ different numbers. In one query you can ask the position of the second maximum element in a subsegment $$$a[l..r]$$$. Find the position of the maximum eleme... | 256 megabytes |
import java.io.*;
import java.math.*;
import java.util.*;
// @author : Dinosparton
public class test {
static class Pair{
long x;
long y;
Pair(long x,long y){
this.x = x;
this.y = y;
}
}
static class Sort implements Comparator... | Java | ["5\n\n3\n\n4"] | 1 second | ["? 1 5\n\n? 4 5\n\n! 1"] | NoteIn the sample suppose $$$a$$$ is $$$[5, 1, 4, 2, 3]$$$. So after asking the $$$[1..5]$$$ subsegment $$$4$$$ is second to max value, and it's position is $$$3$$$. After asking the $$$[4..5]$$$ subsegment $$$2$$$ is second to max value and it's position in the whole array is $$$4$$$.Note that there are other arrays $... | Java 11 | standard input | [
"binary search",
"interactive"
] | eb660c470760117dfd0b95acc10eee3b | The first line contains a single integer $$$n$$$ $$$(2 \leq n \leq 10^5)$$$ — the number of elements in the array. | 1,900 | null | standard output | |
PASSED | 445b6ec3634099ada264402e59883d0b | train_109.jsonl | 1613658900 | The only difference between the easy and the hard version is the limit to the number of queries.This is an interactive problem.There is an array $$$a$$$ of $$$n$$$ different numbers. In one query you can ask the position of the second maximum element in a subsegment $$$a[l..r]$$$. Find the position of the maximum eleme... | 256 megabytes |
import java.util.*;
import java.io.*;
public class Main {
static BufferedReader rd = new BufferedReader(new InputStreamReader(System.in));
static BufferedWriter wr = new BufferedWriter(new OutputStreamWriter(System.out));
static StringTokenizer tok;
public static void main(String[] args) throws Exception {
... | Java | ["5\n\n3\n\n4"] | 1 second | ["? 1 5\n\n? 4 5\n\n! 1"] | NoteIn the sample suppose $$$a$$$ is $$$[5, 1, 4, 2, 3]$$$. So after asking the $$$[1..5]$$$ subsegment $$$4$$$ is second to max value, and it's position is $$$3$$$. After asking the $$$[4..5]$$$ subsegment $$$2$$$ is second to max value and it's position in the whole array is $$$4$$$.Note that there are other arrays $... | Java 11 | standard input | [
"binary search",
"interactive"
] | eb660c470760117dfd0b95acc10eee3b | The first line contains a single integer $$$n$$$ $$$(2 \leq n \leq 10^5)$$$ — the number of elements in the array. | 1,900 | null | standard output | |
PASSED | 8e26ef5c358cede61a8ca072157c895a | train_109.jsonl | 1613658900 | The only difference between the easy and the hard version is the limit to the number of queries.This is an interactive problem.There is an array $$$a$$$ of $$$n$$$ different numbers. In one query you can ask the position of the second maximum element in a subsegment $$$a[l..r]$$$. Find the position of the maximum eleme... | 256 megabytes |
//@author->.....future_me......//
//..............Learning.........//
/*Compete against yourself*/
import java.util.*;
import java.io.*;
import java.lang.*;
import java.math.BigInteger;
public class C {
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Code Starts <<<<<<<<<<<<<<<<<<<<<<<<<<<<< //
static... | Java | ["5\n\n3\n\n4"] | 1 second | ["? 1 5\n\n? 4 5\n\n! 1"] | NoteIn the sample suppose $$$a$$$ is $$$[5, 1, 4, 2, 3]$$$. So after asking the $$$[1..5]$$$ subsegment $$$4$$$ is second to max value, and it's position is $$$3$$$. After asking the $$$[4..5]$$$ subsegment $$$2$$$ is second to max value and it's position in the whole array is $$$4$$$.Note that there are other arrays $... | Java 11 | standard input | [
"binary search",
"interactive"
] | eb660c470760117dfd0b95acc10eee3b | The first line contains a single integer $$$n$$$ $$$(2 \leq n \leq 10^5)$$$ — the number of elements in the array. | 1,900 | null | standard output | |
PASSED | 2d0aa960a84fd1d15fd8f856e356204b | train_109.jsonl | 1613658900 | The only difference between the easy and the hard version is the limit to the number of queries.This is an interactive problem.There is an array $$$a$$$ of $$$n$$$ different numbers. In one query you can ask the position of the second maximum element in a subsegment $$$a[l..r]$$$. Find the position of the maximum eleme... | 256 megabytes | import java.util.*;
import java.lang.*;
import java.io.*;
import java.awt.*;
public class Main
{
static Scanner scn = new Scanner(System.in) ;
public static int query(int l , int r)
{
System.out.println("? " + l +" " + r ) ;
int q = scn.nextInt() ;
return q ;... | Java | ["5\n\n3\n\n4"] | 1 second | ["? 1 5\n\n? 4 5\n\n! 1"] | NoteIn the sample suppose $$$a$$$ is $$$[5, 1, 4, 2, 3]$$$. So after asking the $$$[1..5]$$$ subsegment $$$4$$$ is second to max value, and it's position is $$$3$$$. After asking the $$$[4..5]$$$ subsegment $$$2$$$ is second to max value and it's position in the whole array is $$$4$$$.Note that there are other arrays $... | Java 11 | standard input | [
"binary search",
"interactive"
] | eb660c470760117dfd0b95acc10eee3b | The first line contains a single integer $$$n$$$ $$$(2 \leq n \leq 10^5)$$$ — the number of elements in the array. | 1,900 | null | standard output | |
PASSED | 51e8a8fc341f3165298075b46a77a4c1 | train_109.jsonl | 1613658900 | The only difference between the easy and the hard version is the limit to the number of queries.This is an interactive problem.There is an array $$$a$$$ of $$$n$$$ different numbers. In one query you can ask the position of the second maximum element in a subsegment $$$a[l..r]$$$. Find the position of the maximum eleme... | 256 megabytes | import java.io.*;
import java.util.*;
public class Main {
private static final boolean N_CASE = false;
private int query(int l, int r) {
out.println(String.format("? %d %d", l, r));
out.flush();
return sc.nextInt();
}
private void answer(int value) {
out... | Java | ["5\n\n3\n\n4"] | 1 second | ["? 1 5\n\n? 4 5\n\n! 1"] | NoteIn the sample suppose $$$a$$$ is $$$[5, 1, 4, 2, 3]$$$. So after asking the $$$[1..5]$$$ subsegment $$$4$$$ is second to max value, and it's position is $$$3$$$. After asking the $$$[4..5]$$$ subsegment $$$2$$$ is second to max value and it's position in the whole array is $$$4$$$.Note that there are other arrays $... | Java 11 | standard input | [
"binary search",
"interactive"
] | eb660c470760117dfd0b95acc10eee3b | The first line contains a single integer $$$n$$$ $$$(2 \leq n \leq 10^5)$$$ — the number of elements in the array. | 1,900 | null | standard output | |
PASSED | 354d0fcc6e8d2ee0e90ecf82772678be | train_109.jsonl | 1613658900 | The only difference between the easy and the hard version is the limit to the number of queries.This is an interactive problem.There is an array $$$a$$$ of $$$n$$$ different numbers. In one query you can ask the position of the second maximum element in a subsegment $$$a[l..r]$$$. Find the position of the maximum eleme... | 256 megabytes | import java.util.*;
public class Cf {
public static void main(String [] args){
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();int a=1;int b=n;
System.out.println("? "+a+" "+b );
System.out.flush();
int t=sc.nextInt();
int q=0;
if(t==1){}
else{
System.out... | Java | ["5\n\n3\n\n4"] | 1 second | ["? 1 5\n\n? 4 5\n\n! 1"] | NoteIn the sample suppose $$$a$$$ is $$$[5, 1, 4, 2, 3]$$$. So after asking the $$$[1..5]$$$ subsegment $$$4$$$ is second to max value, and it's position is $$$3$$$. After asking the $$$[4..5]$$$ subsegment $$$2$$$ is second to max value and it's position in the whole array is $$$4$$$.Note that there are other arrays $... | Java 11 | standard input | [
"binary search",
"interactive"
] | eb660c470760117dfd0b95acc10eee3b | The first line contains a single integer $$$n$$$ $$$(2 \leq n \leq 10^5)$$$ — the number of elements in the array. | 1,900 | null | standard output | |
PASSED | a2b5f2f81e1c41f6e037f13c1bdf9c64 | train_109.jsonl | 1613658900 | The only difference between the easy and the hard version is the limit to the number of queries.This is an interactive problem.There is an array $$$a$$$ of $$$n$$$ different numbers. In one query you can ask the position of the second maximum element in a subsegment $$$a[l..r]$$$. Find the position of the maximum eleme... | 256 megabytes | import java.util.*;
public class cf703 {
public static Scanner sc = new Scanner(System.in);
public static int problemA(int n, int arr[]){
long tillNow=0;
for(int i=0; i<n; i++){
tillNow+=arr[i];
if(tillNow<i) return 0;
tillNow-=i;
}
... | Java | ["5\n\n3\n\n4"] | 1 second | ["? 1 5\n\n? 4 5\n\n! 1"] | NoteIn the sample suppose $$$a$$$ is $$$[5, 1, 4, 2, 3]$$$. So after asking the $$$[1..5]$$$ subsegment $$$4$$$ is second to max value, and it's position is $$$3$$$. After asking the $$$[4..5]$$$ subsegment $$$2$$$ is second to max value and it's position in the whole array is $$$4$$$.Note that there are other arrays $... | Java 11 | standard input | [
"binary search",
"interactive"
] | eb660c470760117dfd0b95acc10eee3b | The first line contains a single integer $$$n$$$ $$$(2 \leq n \leq 10^5)$$$ — the number of elements in the array. | 1,900 | null | standard output | |
PASSED | 8c59a772abf077d842b872584cd1d897 | train_109.jsonl | 1613658900 | The only difference between the easy and the hard version is the limit to the number of queries.This is an interactive problem.There is an array $$$a$$$ of $$$n$$$ different numbers. In one query you can ask the position of the second maximum element in a subsegment $$$a[l..r]$$$. Find the position of the maximum eleme... | 256 megabytes |
import java.util.*;
import java.lang.*;
import java.io.*;
public class feb20 {
// *** ++
// +=-==+ +++=-
// +-:---==+ *+=----=
// +-:---... | Java | ["5\n\n3\n\n4"] | 1 second | ["? 1 5\n\n? 4 5\n\n! 1"] | NoteIn the sample suppose $$$a$$$ is $$$[5, 1, 4, 2, 3]$$$. So after asking the $$$[1..5]$$$ subsegment $$$4$$$ is second to max value, and it's position is $$$3$$$. After asking the $$$[4..5]$$$ subsegment $$$2$$$ is second to max value and it's position in the whole array is $$$4$$$.Note that there are other arrays $... | Java 11 | standard input | [
"binary search",
"interactive"
] | eb660c470760117dfd0b95acc10eee3b | The first line contains a single integer $$$n$$$ $$$(2 \leq n \leq 10^5)$$$ — the number of elements in the array. | 1,900 | null | standard output | |
PASSED | c20ac575d82774c77bfc2322b922e58e | train_109.jsonl | 1613658900 | The only difference between the easy and the hard version is the limit to the number of queries.This is an interactive problem.There is an array $$$a$$$ of $$$n$$$ different numbers. In one query you can ask the position of the second maximum element in a subsegment $$$a[l..r]$$$. Find the position of the maximum eleme... | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import static java.lang.System.in;
import static java.lang.System.out;
public class Main {
public static void main(String[] args){
FastReader fr=new FastReader();
... | Java | ["5\n\n3\n\n4"] | 1 second | ["? 1 5\n\n? 4 5\n\n! 1"] | NoteIn the sample suppose $$$a$$$ is $$$[5, 1, 4, 2, 3]$$$. So after asking the $$$[1..5]$$$ subsegment $$$4$$$ is second to max value, and it's position is $$$3$$$. After asking the $$$[4..5]$$$ subsegment $$$2$$$ is second to max value and it's position in the whole array is $$$4$$$.Note that there are other arrays $... | Java 11 | standard input | [
"binary search",
"interactive"
] | eb660c470760117dfd0b95acc10eee3b | The first line contains a single integer $$$n$$$ $$$(2 \leq n \leq 10^5)$$$ — the number of elements in the array. | 1,900 | null | standard output | |
PASSED | d4c78a2f2f9b915dd936e953902fa136 | train_109.jsonl | 1613658900 | The only difference between the easy and the hard version is the limit to the number of queries.This is an interactive problem.There is an array $$$a$$$ of $$$n$$$ different numbers. In one query you can ask the position of the second maximum element in a subsegment $$$a[l..r]$$$. Find the position of the maximum eleme... | 256 megabytes |
import java.io.*;
import java.util.Arrays;
public class codeforces {
static int ask(int l,int r)throws IOException {
if(l==r) {
return -1;
}
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int out1;
System.out.println("? "+l+" "+r);
System.out... | Java | ["5\n\n3\n\n4"] | 1 second | ["? 1 5\n\n? 4 5\n\n! 1"] | NoteIn the sample suppose $$$a$$$ is $$$[5, 1, 4, 2, 3]$$$. So after asking the $$$[1..5]$$$ subsegment $$$4$$$ is second to max value, and it's position is $$$3$$$. After asking the $$$[4..5]$$$ subsegment $$$2$$$ is second to max value and it's position in the whole array is $$$4$$$.Note that there are other arrays $... | Java 11 | standard input | [
"binary search",
"interactive"
] | eb660c470760117dfd0b95acc10eee3b | The first line contains a single integer $$$n$$$ $$$(2 \leq n \leq 10^5)$$$ — the number of elements in the array. | 1,900 | null | standard output | |
PASSED | af324e16436937c4de84bb54f56392bd | train_109.jsonl | 1613658900 | The only difference between the easy and the hard version is the limit to the number of queries.This is an interactive problem.There is an array $$$a$$$ of $$$n$$$ different numbers. In one query you can ask the position of the second maximum element in a subsegment $$$a[l..r]$$$. Find the position of the maximum eleme... | 256 megabytes | import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashM... | Java | ["5\n\n3\n\n4"] | 1 second | ["? 1 5\n\n? 4 5\n\n! 1"] | NoteIn the sample suppose $$$a$$$ is $$$[5, 1, 4, 2, 3]$$$. So after asking the $$$[1..5]$$$ subsegment $$$4$$$ is second to max value, and it's position is $$$3$$$. After asking the $$$[4..5]$$$ subsegment $$$2$$$ is second to max value and it's position in the whole array is $$$4$$$.Note that there are other arrays $... | Java 11 | standard input | [
"binary search",
"interactive"
] | eb660c470760117dfd0b95acc10eee3b | The first line contains a single integer $$$n$$$ $$$(2 \leq n \leq 10^5)$$$ — the number of elements in the array. | 1,900 | null | standard output | |
PASSED | 4b978f5cc80fdca8d2aaff76b9a09637 | train_109.jsonl | 1613658900 | The only difference between the easy and the hard version is the limit to the number of queries.This is an interactive problem.There is an array $$$a$$$ of $$$n$$$ different numbers. In one query you can ask the position of the second maximum element in a subsegment $$$a[l..r]$$$. Find the position of the maximum eleme... | 256 megabytes | //Implemented By Aman Kotiyal Date:-19-Feb-2021 Time:-1:07:15 am
import java.io.*;
import java.util.*;
public class ques1
{
public static void main(String[] args)throws Exception{ new ques1().run();}
long mod=1000000000+7;
void solve() throws Exception
{
int n=ni();
int l=1,r=n;
out.println(... | Java | ["5\n\n3\n\n4"] | 1 second | ["? 1 5\n\n? 4 5\n\n! 1"] | NoteIn the sample suppose $$$a$$$ is $$$[5, 1, 4, 2, 3]$$$. So after asking the $$$[1..5]$$$ subsegment $$$4$$$ is second to max value, and it's position is $$$3$$$. After asking the $$$[4..5]$$$ subsegment $$$2$$$ is second to max value and it's position in the whole array is $$$4$$$.Note that there are other arrays $... | Java 11 | standard input | [
"binary search",
"interactive"
] | eb660c470760117dfd0b95acc10eee3b | The first line contains a single integer $$$n$$$ $$$(2 \leq n \leq 10^5)$$$ — the number of elements in the array. | 1,900 | null | standard output | |
PASSED | eaa2854c13abc0c68a7f823e1d0859a0 | train_109.jsonl | 1613658900 | The only difference between the easy and the hard version is the limit to the number of queries.This is an interactive problem.There is an array $$$a$$$ of $$$n$$$ different numbers. In one query you can ask the position of the second maximum element in a subsegment $$$a[l..r]$$$. Find the position of the maximum eleme... | 256 megabytes |
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.StringTokenizer;
public class GuessingTheGreatest {
static class FastScanner
{
BufferedReader br;
StringTokenizer st;
public FastScanner()
{
... | Java | ["5\n\n3\n\n4"] | 1 second | ["? 1 5\n\n? 4 5\n\n! 1"] | NoteIn the sample suppose $$$a$$$ is $$$[5, 1, 4, 2, 3]$$$. So after asking the $$$[1..5]$$$ subsegment $$$4$$$ is second to max value, and it's position is $$$3$$$. After asking the $$$[4..5]$$$ subsegment $$$2$$$ is second to max value and it's position in the whole array is $$$4$$$.Note that there are other arrays $... | Java 11 | standard input | [
"binary search",
"interactive"
] | eb660c470760117dfd0b95acc10eee3b | The first line contains a single integer $$$n$$$ $$$(2 \leq n \leq 10^5)$$$ — the number of elements in the array. | 1,900 | null | standard output | |
PASSED | aef1d6dd3953bf470195e19c8b684006 | train_109.jsonl | 1613658900 | The only difference between the easy and the hard version is the limit to the number of queries.This is an interactive problem.There is an array $$$a$$$ of $$$n$$$ different numbers. In one query you can ask the position of the second maximum element in a subsegment $$$a[l..r]$$$. Find the position of the maximum eleme... | 256 megabytes | /* package codechef; // don't place package name! */
import java.util.*;
import java.lang.*;
import java.io.*;
/* Name of the class has to be "Main" only if the class is public. */
public class Main
{
static Scanner sc=new Scanner(System.in);
static int ask(int l,int r) {
if(l==r)
r... | Java | ["5\n\n3\n\n4"] | 1 second | ["? 1 5\n\n? 4 5\n\n! 1"] | NoteIn the sample suppose $$$a$$$ is $$$[5, 1, 4, 2, 3]$$$. So after asking the $$$[1..5]$$$ subsegment $$$4$$$ is second to max value, and it's position is $$$3$$$. After asking the $$$[4..5]$$$ subsegment $$$2$$$ is second to max value and it's position in the whole array is $$$4$$$.Note that there are other arrays $... | Java 11 | standard input | [
"binary search",
"interactive"
] | eb660c470760117dfd0b95acc10eee3b | The first line contains a single integer $$$n$$$ $$$(2 \leq n \leq 10^5)$$$ — the number of elements in the array. | 1,900 | null | standard output | |
PASSED | a24809b02b6d19a296dd16b21d854f13 | train_109.jsonl | 1613658900 | The only difference between the easy and the hard version is the limit to the number of queries.This is an interactive problem.There is an array $$$a$$$ of $$$n$$$ different numbers. In one query you can ask the position of the second maximum element in a subsegment $$$a[l..r]$$$. Find the position of the maximum eleme... | 256 megabytes | //package credit;
import java.io.*;
import java.util.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class Main{
static boolean v[];
static int ans[];
int size[];
static int count=0;
static int... | Java | ["5\n\n3\n\n4"] | 1 second | ["? 1 5\n\n? 4 5\n\n! 1"] | NoteIn the sample suppose $$$a$$$ is $$$[5, 1, 4, 2, 3]$$$. So after asking the $$$[1..5]$$$ subsegment $$$4$$$ is second to max value, and it's position is $$$3$$$. After asking the $$$[4..5]$$$ subsegment $$$2$$$ is second to max value and it's position in the whole array is $$$4$$$.Note that there are other arrays $... | Java 11 | standard input | [
"binary search",
"interactive"
] | eb660c470760117dfd0b95acc10eee3b | The first line contains a single integer $$$n$$$ $$$(2 \leq n \leq 10^5)$$$ — the number of elements in the array. | 1,900 | null | standard output | |
PASSED | eb97d2700669ed84b10fdf8f32871d5a | train_109.jsonl | 1613658900 | The only difference between the easy and the hard version is the limit to the number of queries.This is an interactive problem.There is an array $$$a$$$ of $$$n$$$ different numbers. In one query you can ask the position of the second maximum element in a subsegment $$$a[l..r]$$$. Find the position of the maximum eleme... | 256 megabytes | import java.io.*;
import java.util.StringTokenizer;
import static java.lang.System.out;
public class C2_GuessingTheGreatest_HardVersion {
private static final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
private static StringTokenizer st;
private static int readInt() throws I... | Java | ["5\n\n3\n\n4"] | 1 second | ["? 1 5\n\n? 4 5\n\n! 1"] | NoteIn the sample suppose $$$a$$$ is $$$[5, 1, 4, 2, 3]$$$. So after asking the $$$[1..5]$$$ subsegment $$$4$$$ is second to max value, and it's position is $$$3$$$. After asking the $$$[4..5]$$$ subsegment $$$2$$$ is second to max value and it's position in the whole array is $$$4$$$.Note that there are other arrays $... | Java 11 | standard input | [
"binary search",
"interactive"
] | eb660c470760117dfd0b95acc10eee3b | The first line contains a single integer $$$n$$$ $$$(2 \leq n \leq 10^5)$$$ — the number of elements in the array. | 1,900 | null | standard output | |
PASSED | 12a54cce13b31a13ed959e44cb624388 | train_109.jsonl | 1613658900 | The only difference between the easy and the hard version is the limit to the number of queries.This is an interactive problem.There is an array $$$a$$$ of $$$n$$$ different numbers. In one query you can ask the position of the second maximum element in a subsegment $$$a[l..r]$$$. Find the position of the maximum eleme... | 256 megabytes | import java.util.*;
import java.io.*;
public class Main {
static class Scan {
private byte[] buf=new byte[1024];
private int index;
private InputStream in;
private int total;
public Scan()
{
in=System.in;
}
public int scan()thro... | Java | ["5\n\n3\n\n4"] | 1 second | ["? 1 5\n\n? 4 5\n\n! 1"] | NoteIn the sample suppose $$$a$$$ is $$$[5, 1, 4, 2, 3]$$$. So after asking the $$$[1..5]$$$ subsegment $$$4$$$ is second to max value, and it's position is $$$3$$$. After asking the $$$[4..5]$$$ subsegment $$$2$$$ is second to max value and it's position in the whole array is $$$4$$$.Note that there are other arrays $... | Java 11 | standard input | [
"binary search",
"interactive"
] | eb660c470760117dfd0b95acc10eee3b | The first line contains a single integer $$$n$$$ $$$(2 \leq n \leq 10^5)$$$ — the number of elements in the array. | 1,900 | null | standard output | |
PASSED | fe77c6dc08ca0e540629493fd8d4d719 | train_109.jsonl | 1613658900 | The only difference between the easy and the hard version is the limit to the number of queries.This is an interactive problem.There is an array $$$a$$$ of $$$n$$$ different numbers. In one query you can ask the position of the second maximum element in a subsegment $$$a[l..r]$$$. Find the position of the maximum eleme... | 256 megabytes | import java.util.*;
import java.io.*;
public class C {
private static PrintWriter out;
private static FS sc;
private static class FS {
StringTokenizer st;
BufferedReader br;
public FS() {
br = new BufferedReader(new InputStreamReader(System.in));
}
public String next() {
... | Java | ["5\n\n3\n\n4"] | 1 second | ["? 1 5\n\n? 4 5\n\n! 1"] | NoteIn the sample suppose $$$a$$$ is $$$[5, 1, 4, 2, 3]$$$. So after asking the $$$[1..5]$$$ subsegment $$$4$$$ is second to max value, and it's position is $$$3$$$. After asking the $$$[4..5]$$$ subsegment $$$2$$$ is second to max value and it's position in the whole array is $$$4$$$.Note that there are other arrays $... | Java 11 | standard input | [
"binary search",
"interactive"
] | eb660c470760117dfd0b95acc10eee3b | The first line contains a single integer $$$n$$$ $$$(2 \leq n \leq 10^5)$$$ — the number of elements in the array. | 1,900 | null | standard output | |
PASSED | aed714ae854f172d06c204b7fb6d81c3 | train_109.jsonl | 1613658900 | The only difference between the easy and the hard version is the limit to the number of queries.This is an interactive problem.There is an array $$$a$$$ of $$$n$$$ different numbers. In one query you can ask the position of the second maximum element in a subsegment $$$a[l..r]$$$. Find the position of the maximum eleme... | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.StringTokenizer;
public class problemC {
static class Solution {
HashMap<Point, Integer> m... | Java | ["5\n\n3\n\n4"] | 1 second | ["? 1 5\n\n? 4 5\n\n! 1"] | NoteIn the sample suppose $$$a$$$ is $$$[5, 1, 4, 2, 3]$$$. So after asking the $$$[1..5]$$$ subsegment $$$4$$$ is second to max value, and it's position is $$$3$$$. After asking the $$$[4..5]$$$ subsegment $$$2$$$ is second to max value and it's position in the whole array is $$$4$$$.Note that there are other arrays $... | Java 11 | standard input | [
"binary search",
"interactive"
] | eb660c470760117dfd0b95acc10eee3b | The first line contains a single integer $$$n$$$ $$$(2 \leq n \leq 10^5)$$$ — the number of elements in the array. | 1,900 | null | standard output | |
PASSED | b655dae2464cfb1ddd1404bfe9177e2d | train_109.jsonl | 1613658900 | The only difference between the easy and the hard version is the limit to the number of queries.This is an interactive problem.There is an array $$$a$$$ of $$$n$$$ different numbers. In one query you can ask the position of the second maximum element in a subsegment $$$a[l..r]$$$. Find the position of the maximum eleme... | 256 megabytes | import java.io.*;
import java.util.*;
import java.lang.*;
public class C {
public static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
static long MOD = (long) (1e9 + 7);
//static int MOD = 998244353;
static long MOD2 = MOD * MOD;
static FastReader sc = new FastReader();
... | Java | ["5\n\n3\n\n4"] | 1 second | ["? 1 5\n\n? 4 5\n\n! 1"] | NoteIn the sample suppose $$$a$$$ is $$$[5, 1, 4, 2, 3]$$$. So after asking the $$$[1..5]$$$ subsegment $$$4$$$ is second to max value, and it's position is $$$3$$$. After asking the $$$[4..5]$$$ subsegment $$$2$$$ is second to max value and it's position in the whole array is $$$4$$$.Note that there are other arrays $... | Java 11 | standard input | [
"binary search",
"interactive"
] | eb660c470760117dfd0b95acc10eee3b | The first line contains a single integer $$$n$$$ $$$(2 \leq n \leq 10^5)$$$ — the number of elements in the array. | 1,900 | null | standard output | |
PASSED | 2fe90f39f7369288c4fdbba97d16630d | train_109.jsonl | 1613658900 | The only difference between the easy and the hard version is the limit to the number of queries.This is an interactive problem.There is an array $$$a$$$ of $$$n$$$ different numbers. In one query you can ask the position of the second maximum element in a subsegment $$$a[l..r]$$$. Find the position of the maximum eleme... | 256 megabytes | import java.util.*;
import java.io.*;
public class _1486_C2 {
public static void main(String[] args) throws IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
int n = Integer.parseInt(in.readLine());
int sec = query(1, n, in);
int lbound = sec + 1;
int rbound = ... | Java | ["5\n\n3\n\n4"] | 1 second | ["? 1 5\n\n? 4 5\n\n! 1"] | NoteIn the sample suppose $$$a$$$ is $$$[5, 1, 4, 2, 3]$$$. So after asking the $$$[1..5]$$$ subsegment $$$4$$$ is second to max value, and it's position is $$$3$$$. After asking the $$$[4..5]$$$ subsegment $$$2$$$ is second to max value and it's position in the whole array is $$$4$$$.Note that there are other arrays $... | Java 11 | standard input | [
"binary search",
"interactive"
] | eb660c470760117dfd0b95acc10eee3b | The first line contains a single integer $$$n$$$ $$$(2 \leq n \leq 10^5)$$$ — the number of elements in the array. | 1,900 | null | standard output | |
PASSED | 523ff66af306e2fec3590b73e08ed7f7 | train_109.jsonl | 1613658900 | The only difference between the easy and the hard version is the limit to the number of queries.This is an interactive problem.There is an array $$$a$$$ of $$$n$$$ different numbers. In one query you can ask the position of the second maximum element in a subsegment $$$a[l..r]$$$. Find the position of the maximum eleme... | 256 megabytes | import java.util.*;
import java.io.*;
public class Main2 {
static class FastReader
{
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br = new BufferedReader(new
InputStreamReader(System.in));
}
... | Java | ["5\n\n3\n\n4"] | 1 second | ["? 1 5\n\n? 4 5\n\n! 1"] | NoteIn the sample suppose $$$a$$$ is $$$[5, 1, 4, 2, 3]$$$. So after asking the $$$[1..5]$$$ subsegment $$$4$$$ is second to max value, and it's position is $$$3$$$. After asking the $$$[4..5]$$$ subsegment $$$2$$$ is second to max value and it's position in the whole array is $$$4$$$.Note that there are other arrays $... | Java 11 | standard input | [
"binary search",
"interactive"
] | eb660c470760117dfd0b95acc10eee3b | The first line contains a single integer $$$n$$$ $$$(2 \leq n \leq 10^5)$$$ — the number of elements in the array. | 1,900 | null | standard output | |
PASSED | 1de958aa6383710d05502884886f7686 | train_109.jsonl | 1613658900 | The only difference between the easy and the hard version is the limit to the number of queries.This is an interactive problem.There is an array $$$a$$$ of $$$n$$$ different numbers. In one query you can ask the position of the second maximum element in a subsegment $$$a[l..r]$$$. Find the position of the maximum eleme... | 256 megabytes | import java.io.*;
import java.util.*;
public class Codeforces
{
static BufferedReader bu=new BufferedReader(new InputStreamReader(System.in));
public static void main(String args[])throws Exception
{
StringBuilder sb=new StringBuilder();
int n=Integer.parseInt(bu.readLine());
... | Java | ["5\n\n3\n\n4"] | 1 second | ["? 1 5\n\n? 4 5\n\n! 1"] | NoteIn the sample suppose $$$a$$$ is $$$[5, 1, 4, 2, 3]$$$. So after asking the $$$[1..5]$$$ subsegment $$$4$$$ is second to max value, and it's position is $$$3$$$. After asking the $$$[4..5]$$$ subsegment $$$2$$$ is second to max value and it's position in the whole array is $$$4$$$.Note that there are other arrays $... | Java 11 | standard input | [
"binary search",
"interactive"
] | eb660c470760117dfd0b95acc10eee3b | The first line contains a single integer $$$n$$$ $$$(2 \leq n \leq 10^5)$$$ — the number of elements in the array. | 1,900 | null | standard output | |
PASSED | 72bc21a7290b5ea38629e595bdea13e4 | train_109.jsonl | 1613658900 | The only difference between the easy and the hard version is the limit to the number of queries.This is an interactive problem.There is an array $$$a$$$ of $$$n$$$ different numbers. In one query you can ask the position of the second maximum element in a subsegment $$$a[l..r]$$$. Find the position of the maximum eleme... | 256 megabytes | 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.Random;
import java.util.StringTok... | Java | ["5\n\n3\n\n4"] | 1 second | ["? 1 5\n\n? 4 5\n\n! 1"] | NoteIn the sample suppose $$$a$$$ is $$$[5, 1, 4, 2, 3]$$$. So after asking the $$$[1..5]$$$ subsegment $$$4$$$ is second to max value, and it's position is $$$3$$$. After asking the $$$[4..5]$$$ subsegment $$$2$$$ is second to max value and it's position in the whole array is $$$4$$$.Note that there are other arrays $... | Java 11 | standard input | [
"binary search",
"interactive"
] | eb660c470760117dfd0b95acc10eee3b | The first line contains a single integer $$$n$$$ $$$(2 \leq n \leq 10^5)$$$ — the number of elements in the array. | 1,900 | null | standard output | |
PASSED | 8a4debcb62d6ce7a652101a5cd5f90eb | train_109.jsonl | 1613658900 | The only difference between the easy and the hard version is the limit to the number of queries.This is an interactive problem.There is an array $$$a$$$ of $$$n$$$ different numbers. In one query you can ask the position of the second maximum element in a subsegment $$$a[l..r]$$$. Find the position of the maximum eleme... | 256 megabytes |
import java.io.*;
import java.util.*;
public class TestClass {
public static class FastWriter {
private static final int BUF_SIZE = 1 << 13;
private final byte[] buf = new byte[BUF_SIZE];
private final OutputStream out;
private int ptr = 0;
private FastWri... | Java | ["5\n\n3\n\n4"] | 1 second | ["? 1 5\n\n? 4 5\n\n! 1"] | NoteIn the sample suppose $$$a$$$ is $$$[5, 1, 4, 2, 3]$$$. So after asking the $$$[1..5]$$$ subsegment $$$4$$$ is second to max value, and it's position is $$$3$$$. After asking the $$$[4..5]$$$ subsegment $$$2$$$ is second to max value and it's position in the whole array is $$$4$$$.Note that there are other arrays $... | Java 11 | standard input | [
"binary search",
"interactive"
] | eb660c470760117dfd0b95acc10eee3b | The first line contains a single integer $$$n$$$ $$$(2 \leq n \leq 10^5)$$$ — the number of elements in the array. | 1,900 | null | standard output | |
PASSED | 8599550cf7d5b990a4683091b6002dcb | train_109.jsonl | 1613658900 | The only difference between the easy and the hard version is the limit to the number of queries.This is an interactive problem.There is an array $$$a$$$ of $$$n$$$ different numbers. In one query you can ask the position of the second maximum element in a subsegment $$$a[l..r]$$$. Find the position of the maximum eleme... | 256 megabytes | import java.util.*;
import java.io.*;
public class _703 {
static MyScanner sc;
public static void main(String[] args) {
sc = new MyScanner();
PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
int t = 1;
while (t-- > 0) {
int n = sc.ne... | Java | ["5\n\n3\n\n4"] | 1 second | ["? 1 5\n\n? 4 5\n\n! 1"] | NoteIn the sample suppose $$$a$$$ is $$$[5, 1, 4, 2, 3]$$$. So after asking the $$$[1..5]$$$ subsegment $$$4$$$ is second to max value, and it's position is $$$3$$$. After asking the $$$[4..5]$$$ subsegment $$$2$$$ is second to max value and it's position in the whole array is $$$4$$$.Note that there are other arrays $... | Java 11 | standard input | [
"binary search",
"interactive"
] | eb660c470760117dfd0b95acc10eee3b | The first line contains a single integer $$$n$$$ $$$(2 \leq n \leq 10^5)$$$ — the number of elements in the array. | 1,900 | null | standard output | |
PASSED | 7952c6e4cf0cdeb2b139b3d506063c6f | train_109.jsonl | 1613658900 | The only difference between the easy and the hard version is the limit to the number of queries.This is an interactive problem.There is an array $$$a$$$ of $$$n$$$ different numbers. In one query you can ask the position of the second maximum element in a subsegment $$$a[l..r]$$$. Find the position of the maximum eleme... | 256 megabytes | //package round703;
import java.io.*;
import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.Queue;
public class C3 {
InputStream is;
FastWriter out;
String INPUT = "";
// Random gen = new Random(99999);
//
// public static int[] shuffle(int ... | Java | ["5\n\n3\n\n4"] | 1 second | ["? 1 5\n\n? 4 5\n\n! 1"] | NoteIn the sample suppose $$$a$$$ is $$$[5, 1, 4, 2, 3]$$$. So after asking the $$$[1..5]$$$ subsegment $$$4$$$ is second to max value, and it's position is $$$3$$$. After asking the $$$[4..5]$$$ subsegment $$$2$$$ is second to max value and it's position in the whole array is $$$4$$$.Note that there are other arrays $... | Java 11 | standard input | [
"binary search",
"interactive"
] | eb660c470760117dfd0b95acc10eee3b | The first line contains a single integer $$$n$$$ $$$(2 \leq n \leq 10^5)$$$ — the number of elements in the array. | 1,900 | null | standard output | |
PASSED | 531884c5c46b98a4d5802f0a45f28c03 | train_109.jsonl | 1613658900 | The only difference between the easy and the hard version is the limit to the number of queries.This is an interactive problem.There is an array $$$a$$$ of $$$n$$$ different numbers. In one query you can ask the position of the second maximum element in a subsegment $$$a[l..r]$$$. Find the position of the maximum eleme... | 256 megabytes | import java.io.*;
import java.text.*;
import java.util.*;
import java.util.function.*;
/**
* Provide prove of correctness before implementation. Implementation can cost a lot of time.
* Anti test that prove that it's wrong.
* <p>
* Do not confuse i j k g indexes, upTo and length. Do extra methods!!! Write... | Java | ["5\n\n3\n\n4"] | 1 second | ["? 1 5\n\n? 4 5\n\n! 1"] | NoteIn the sample suppose $$$a$$$ is $$$[5, 1, 4, 2, 3]$$$. So after asking the $$$[1..5]$$$ subsegment $$$4$$$ is second to max value, and it's position is $$$3$$$. After asking the $$$[4..5]$$$ subsegment $$$2$$$ is second to max value and it's position in the whole array is $$$4$$$.Note that there are other arrays $... | Java 17 | standard input | [
"binary search",
"interactive"
] | eb660c470760117dfd0b95acc10eee3b | The first line contains a single integer $$$n$$$ $$$(2 \leq n \leq 10^5)$$$ — the number of elements in the array. | 1,900 | null | standard output | |
PASSED | fc26fe014937400329f842068f00de2f | train_109.jsonl | 1613658900 | The only difference between the easy and the hard version is the limit to the number of queries.This is an interactive problem.There is an array $$$a$$$ of $$$n$$$ different numbers. In one query you can ask the position of the second maximum element in a subsegment $$$a[l..r]$$$. Find the position of the maximum eleme... | 256 megabytes |
import java.util.*;
import java.io.*;
public class GuessingTheGreatest_Hard {
public static void main(String[] args) throws IOException {
Soumit sc = new Soumit();
int n = sc.nextInt();
System.out.println("? 1 "+n);
System.out.flush();
int smax_ind = sc.ne... | Java | ["5\n\n3\n\n4"] | 1 second | ["? 1 5\n\n? 4 5\n\n! 1"] | NoteIn the sample suppose $$$a$$$ is $$$[5, 1, 4, 2, 3]$$$. So after asking the $$$[1..5]$$$ subsegment $$$4$$$ is second to max value, and it's position is $$$3$$$. After asking the $$$[4..5]$$$ subsegment $$$2$$$ is second to max value and it's position in the whole array is $$$4$$$.Note that there are other arrays $... | Java 17 | standard input | [
"binary search",
"interactive"
] | eb660c470760117dfd0b95acc10eee3b | The first line contains a single integer $$$n$$$ $$$(2 \leq n \leq 10^5)$$$ — the number of elements in the array. | 1,900 | null | standard output | |
PASSED | a1d75aa294c45ea70fdd7c04b9e2ba8d | train_109.jsonl | 1613658900 | The only difference between the easy and the hard version is the limit to the number of queries.This is an interactive problem.There is an array $$$a$$$ of $$$n$$$ different numbers. In one query you can ask the position of the second maximum element in a subsegment $$$a[l..r]$$$. Find the position of the maximum eleme... | 256 megabytes | import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.IOException;
import java.io.InputStream;
/**
* Built using CHelper plug-... | Java | ["5\n\n3\n\n4"] | 1 second | ["? 1 5\n\n? 4 5\n\n! 1"] | NoteIn the sample suppose $$$a$$$ is $$$[5, 1, 4, 2, 3]$$$. So after asking the $$$[1..5]$$$ subsegment $$$4$$$ is second to max value, and it's position is $$$3$$$. After asking the $$$[4..5]$$$ subsegment $$$2$$$ is second to max value and it's position in the whole array is $$$4$$$.Note that there are other arrays $... | Java 17 | standard input | [
"binary search",
"interactive"
] | eb660c470760117dfd0b95acc10eee3b | The first line contains a single integer $$$n$$$ $$$(2 \leq n \leq 10^5)$$$ — the number of elements in the array. | 1,900 | null | standard output | |
PASSED | ae9ff591d0fb5557ed0c72806ba11f42 | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes |
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;
public class A implements Runnable {
public static void main(String args[]) throws Exception {
new Thread(null, new A(), "A", 1 << 27).start();
}
void merge1(i... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | 66bd4e558b5daa485dfebfad79c429ce | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes |
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;
public class A implements Runnable {
public static void main(String args[]) throws Exception {
new Thread(null, new A(), "A", 1 << 27).start();
}
void merge1(int... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | fa4fdb57b971943341c616ee53b7f1af | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes |
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;
public class A implements Runnable {
public static void main(String args[]) throws Exception {
new Thread(null, new A(), "A", 1 << 27).start();
}
void merge1(int... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | f974abf4d2b2cc0189cf5c186b2c17e4 | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.util.*;
public class Solution
{
public static void main(String args[])
{
Scanner sc=new Scanner(System.in);
int t=sc.nextInt();
while(--t>=0)
{
int k=0;
int i=0;
long m=0;
int n=sc.nex... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | a0454c6bf5770d944f3f2c920414978b | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes |
/*Author Adityaraj*/
import java.io.*;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.*;
public class Template {
// initialize variable
public static void main(String[] args) throws IOException {
long start = System.nanoTime();
// Initialize the reader
FastScanner sc... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | f5999a2860e9aae93c3d179cc8eaf63b | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes |
import java.util.Arrays;
import java.util.Scanner;
public class Solution {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int t = in.nextInt();
for (int i = 0; i < t; i++) {
solve(in);
}
}
private static void so... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | dc6719784dd475cc8af4f5f835f40e7d | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.util.*;
public class Program {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int x = scan.nextInt();
for (int i = 0; i < x; i++) {
int y = scan.nextInt();
int[] arr = new int[y];
for (int j = 0;... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | 909a66459d239bac41d3b95ecbcd0d3c | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes |
import java.util.*;
public class Program {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int x = scan.nextInt();
for (int i = 0; i < x; i++) {
int y = scan.nextInt();
int[] arr = new int[y];
for (int ... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | 0778ea44cc0f68a11023fa20389241a6 | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.util.*;
public class Program {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
//p sure this will owrk this time, im j double chekcing
int x = scan.nextInt();
for (int i = 0; i < x; i++) {
int y = scan.nextInt();
... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | ebd0cfbf6f813bb3c58c5b9d5825d8d3 | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.util.*;
public class shift
{
public static void main(String args[])
{
Scanner in=new Scanner(System.in);
long n,i,t,f;
int j;
long a[]=new long[100];
t=in.nextLong();
for(i=0;i<t;i++)
{
n=in.nextLong();
a[0]... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | be2fe698b9ed4d4623deab5961c4542e | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.util.*;
public class shift
{
public static void main(String args[])
{
Scanner in=new Scanner(System.in);
long n,i,t,f;
int j;
long a[]=new long[100];
t=in.nextLong();
for(i=0;i<t;i++)
{
n=in.nextLong();
for(... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | cb641b89f7c9f1f445061262c4840f9f | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class ShiftingStacks { //1486A
public static void main(String[] args) throws NumberFormatException, IOException {
BufferedReader br = new BufferedReader(new InputStr... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | 6e5b5910206a6b520b530cfe1320cfc0 | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | //package letsgo.c703;
//import DataStructures.Linkedlist;
import java.util.Arrays;
import java.util.Scanner;
public class p1 {
public static boolean func ( Long [] arr ) {
Long Sum[] = new Long[arr.length];
Sum[0]=arr[0];
for (int i = 1; i < arr.length; i++) {
... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | b25007fec317e4f8550fcdb633b08be9 | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.util.*;
public class ShiftingStacks
{
public static void main(String[] args)
{
Scanner input = new Scanner(System.in);
int n = input.nextInt();
int num = 0;
long sumNum = 0;
long sumT;
for(int j = 0; j < n; j++)
{
num = input.nextInt();
sumNum = 0;
sumT = 0;
boolean check = tru... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | 6702e13818d8f9c83498633c3baa5830 | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.util.*;
import java.io.*;
public class UVa {
static class FastIO {
InputStream dis;
byte[] buffer = new byte[1 << 17];
int pointer = 0;
public FastIO(String fileName) throws Exception {
dis = new FileInputStream(fileName);
}
public FastIO... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | 2d1ae5dc276a6e6946f388a232653549 | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | 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.math.BigInteger;
import java.util.*;
import java.util.stream.Collectors;
public class coding {
static class FastR... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | 9ce34e88bef88fafbaa27d59c5a8a2b6 | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.util.Scanner;
public class Round703 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int T = scanner.nextInt();
while (T!=0) {
int n = scanner.nextInt();
long cur_sum = 0, need = 0;
boolean ok = tru... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | c6f71a49db4668be40fca60993e0ac80 | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) throws IOException {
long t = nextLong();
for (int i = 0; i < t; i++) {
int n = nextInt();
long sum =0;
long need = 0;
long[]a =new long[n];
... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | 5e7e8f84dae85c63071880dd6b3d6c8a | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.util.Scanner;
public class ShiftingStacks {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
for (int j = 0; j < n; j++) {
int length = scanner.nextInt();
long temp1=0;
long... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | 78668fb6fce54384aa3fee493ad8ca7c | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.util.Scanner;
public class ShiftingStacks {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
for (int j = 0; j < n; j++) {
int length = scanner.nextInt();
long temp1=0;
long... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | 417a5c980aa68aa8b546bd881aa03cec | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.util.*;
public class Test2 {
static Scanner sc;
public static void main(String args[]) {
sc = new Scanner(System.in);
int t = sc.nextInt();
while (t-- > 0) {
solve();
}
}
public static void solve() {
int n = sc.nextInt();
long sum = 0, minsum = 0;
int[] arr = new in... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | b5754ca3c31bd9188a279eda5b43721f | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.util.*;
public class Test {
static Scanner sc;
public static void main(String args[]) {
sc = new Scanner(System.in);
int t = sc.nextInt();
while (t-- > 0) {
solve();
}
}
public static void solve() {
int n = sc.nextInt();
long sum = 0, minsum = 0;
int[] arr = new int... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | 7e82d0fa275090d9da8f737146174854 | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.util.*;
public class Result {
public static int t, n;
public static long[] a;
public static void main (String[] args) {
Scanner sc = new Scanner(System.in);
t = sc.nextInt();
while (t-- > 0) {
n = sc.nextInt();
a = new long[n];
for (int i = 0; i < n; ++i)
a[i] = sc.nextLo... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | 00b39abefcf1b59e2474abc1c3b27389 | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes |
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main
{
public static void main (String[] args) throws java.lang.Exception
{
FastReader sc =new FastReader();
int t=sc.nextInt();
while(t-->0)
{
int n=sc.nextInt();
long arr[]... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | 50913be173764222f741464277c9beea | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.util.Scanner;
public class cf {
public static void main(String args[]) {
Scanner scan = new Scanner(System.in);
long t, s = 0, a;
int n;
boolean ans;
t = scan.nextLong();
for (int i=0; i<t; i++) {
n = scan.nextInt();
s = 0;
... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | 89c96046e31e031b713fa681cf469a85 | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes |
import java.util.Arrays;
import java.util.Scanner;
public class Cf{
static Scanner scan=new Scanner(System.in);
public static void main(String[] args) {
int t=1;
t=scan.nextInt();
while(t-->0){
solve();
}
}
static void solve(){
int ... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | 2cedcb3e2fac8027c8962e200f20dd1a | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes |
import java.util.Arrays;
import java.util.Scanner;
public class Cf{
static Scanner scan=new Scanner(System.in);
public static void main(String[] args) {
int t=1;
t=scan.nextInt();
while(t-->0){
solve();
}
}
static void solve(){
int ... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | 9c024a75f2f4ca195f51ed4b9900eb86 | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes |
import java.io.*;
public class codeforces {
public static void main(String[] args)throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int t=Integer.parseInt(br.readLine());
while(t--!=0) {
int n=Integer.parseInt(br.readLine());
... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | 68b0d5bae66256f5ee0faa485703dd67 | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes |
import java.io.*;
public class codeforces {
public static void main(String[] args)throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int t=Integer.parseInt(br.readLine());
while(t--!=0) {
int n=Integer.parseInt(br.readLine());
... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | cca3d416892c96b4e0a41afb9c0395a0 | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.io.*;
import java.util.*;
public class Main {
static long TIME_START, TIME_END;
public static class Task {
public void solve(Scanner sc, PrintWriter pw) throws IOException {
int testCase = sc.nextInt();
Outer: while(testCase-- > 0) {
int n = sc.nextInt(... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | 35d2749936dacfa436ef4f4e8dfb00d0 | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.util.*;
public class A {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
StringBuilder sb = new StringBuilder();
int testCases = sc.nextInt();
for (int t = 0; t < testCases; t++) {
int n = sc.nextInt();
... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | d432c80ec0d3100635571d5808773979 | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.util.*;
public class A {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
StringBuilder sb = new StringBuilder();
int testCases = sc.nextInt();
for (int t = 0; t < testCases; t++) {
long n = sc.nextInt();
... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | 47b03de26c63d901740859a1198184f6 | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.util.*;
import java.io.*;
public class Main {
static InputReader scn = new InputReader(System.in);
static OutputWriter out = new OutputWriter(System.out);
public static void main(String[] args) {
// Running Number Of TestCases (t)
int t = scn.nextInt();
while(t-- > 0)
solve();
out... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | 5017c763567cd7dbd7c26e2aa9819e3e | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.io.*;
import java.math.*;
import java.util.*;
// author : Multi-Thread
public class A {
static int mod = (int) 1e9 + 7;
static int MAX = Integer.MAX_VALUE;
static int MIN = Integer.MIN_VALUE;
public static void main(String[] args) {
int test = fs.nextInt();
// int test = 1;
for... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | da5e53a3fa94d1e48acd71b0957dd444 | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.util.*;
public class shift{
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int t=sc.nextInt();
while(t-->0){
int n=sc.nextInt();
long s=0;
int p=0;
int ar[]=new int[n];
for(int i=0;i<n;i++){
ar[i]=sc.nextInt();
s+=ar[i];
if(s<(i+1)*... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | 45b0cd429a8053693c6aefb76cd53a93 | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.util.*;
import java.io.*;
public class Solution {
static int mod = 1000000007;
public static void main(String[] args) {
FastScanner fs = new FastScanner();
int t = fs.nextInt();
outer: while (t-- > 0) {
int n = fs.nextInt();
int arr[] = fs.readArray(n);
long sum[] = new long... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | a542ad2a547b9251828effe7cb387a12 | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | //<———My cp————
import java.util.*;
import java.io.*;
public class A_Shifting_Stacks{
public static void main(String[] args) throws Exception{
FastReader fr = new FastReader(System.in);
int t = fr.nextInt();
while(t-->0){
int l = fr.nextInt();
int[] data = ... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | 8a8e0b3d509ea2e0cbb67787e12e9fbd | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.io.*;
public class ShiftingStacks
{
public static void main(String args[]) throws IOException
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int t = Integer.parseInt(br.readLine());
for(int k = 0; k < t; k++)
{
int n = Integer.parseInt(br.readLine());
long arr[] ... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | b9c37f70eabe7b9ba23655e25225f131 | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes |
import java.util.*;
import java.lang.*;
import java.io.*;
/* Name of the class has to be "Main" only if the class is public. */
public class d2
{
static ArrayList<ArrayList<Integer>> graph;
static boolean[] visited;
static int[] distance;
public static void main (String[] args) throws java.lang.Excepti... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | ed1f65fa2622694437e32bc32f3944a7 | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.util.*;
public class test {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int tests= sc.nextInt();
for(int i=0;i<tests;i++){
int height=sc.nextInt();
long sum=0;
int flag=1;
long arr[]=... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | 5ea784fb7b69f09848009f4df12f5269 | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.util.*;
public class sol {
static Scanner scr=new Scanner(System.in);
public static void main(String[] args) {
// TODO Auto-generated method stub
int t=scr.nextInt();
// prime=new boolean[50000+1];
// Arrays.fill(prime, false);
// fill();
int count=1;
while(t-->0) {
solve(count... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | 5eb8b650f5eda2c0ae22cdfc9a619687 | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes |
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class Main {
static class DisjointUnionSets {
int[] rank, parent;
int n;
// Constructor
public DisjointUnionSets(int n)
{
ran... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | c155883e2acfd7a713fb40c93ae65756 | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.io.IOException;
import java.io.InputStreamReader;
import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;
import java.io.BufferedReader;
import java.util.StringTokenizer;
import java.io.*;
import java.util.*;
public class A {
public static ... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | 670bbf87f189b24a0c1da89fadfa7e03 | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.io.IOException;
import java.io.InputStreamReader;
import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;
import java.io.BufferedReader;
import java.util.StringTokenizer;
import java.io.*;
import java.util.*;
public class A {
public static... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | 8d7907c1189c703c1759e82e84565525 | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.io.*;
import java.util.*;
public class Day1_1_ShiftingStacks {
public static void main(String[] args) {
InputReader reader = new InputReader(System.in);
int n = reader.nextInt();
StringBuilder outBuffer = new StringBuilder();
while (n-- > 0) {
int length = reader.nextInt();
int[]... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | 63ba071904ff97256937405bdc245576 | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.io.*;
import java.util.*;
public class Stack {
public static void main(String[] args) {
int tc;
Scanner in = new Scanner(System.in);
tc = in.nextInt();
for (int t = 0; t < tc; t++) {
int n;
n = in.nextInt();
// int[] arr =... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | 1e5273a08023a02454dc9a6cf3fa0f2e | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;
import java.lang.*;
public class Rhombus{
static int mod = 1000000007;
static InputReader in = new InputReader(System.in);
static PrintWriter pw = new PrintWriter(System.out);
public static void main(St... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | 1ca770ceb33a73fa306490818acba0a4 | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args)throws IOException
{
BufferedReader bufferedReader = new BufferedReader(new InputStreamReade... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | d275c6ef1f2b4e01765d9bedc456b122 | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.util.*;
public final class file{
public static void main(String args[]){
Scanner scan = new Scanner(System.in);
int n=scan.nextInt();
for(int i=0;i<n;i++){
int z=scan.nextInt();
long a[] = new long[z];
long sum=0;
for(int... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | 0eaa1a05d19d22e7a1e04f62c47c3cb6 | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.io.*;
import java.util.*;
public class Template {
public static void main(String[] args) {
FastScanner sc = new FastScanner();
int yo = sc.nextInt();
PrintWriter out = new PrintWriter(System.out);
outer: while (yo-- > 0) {
int n = sc.nextInt();
long[] a = new long[n];
for(int... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | fd4482bad3517f2357e16f88044ae182 | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;
public class A {
void solve() throws IOException {
int t = nextInt();
for (int i = 0; i < t; ++i) {
/*
4 1 4
... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | 9bfc5b5ee4e3bad20e8cbbe9198ee909 | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.util.Scanner;
public class c700A {
static int ans= Integer.MIN_VALUE ;
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
int t = sc.nextInt();
while((t--)!=0) {
int n = sc.nextInt();
long arr[] = new long[n];
bool... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | da8671e13fd18e5a0eff87efe42a9004 | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.util.*;
import java.io.*;
//My life seems to be a joke. But, one day I will conquer.
public class B{
public static void main(String[] args)
{
FastScanner fs = new FastScanner();
PrintWriter out = new PrintWriter(System.out);
int t = fs.nextInt();
a:for(int tt=0;tt<t;tt++)
{
int n =... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | d893f906ff32c8678dbe22f2cf31dab3 | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.io.*;
import java.util.*;
import java.math.*;
public class Solution{
public static void main(String[] args) {
TaskA solver = new TaskA();
int t = in.nextInt();
for (int i = 1; i <= t ; i++) {
solver.solve(i, in, out);
}
// solver.solve(1, in... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | 094a8f3e1a45b7b3624993cf9f4d6b2d | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.io.BufferedReader;
import java.math.BigInteger;
import java.util.*;
import static java.lang.System.out;
public class Round_780_Div_3 {
static Scanner str = new Scanner(System.in);
static ArrayList<Integer> list;
final int mod = 1000000007;
public static void main(String[] args) {
... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | 59b3c60a12fc51343b5f9203dc1b90f5 | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.util.stream.IntStream;
import java.util.Arrays;
import java.util.*;
public class Program {
public static void main(String[] args) throws IOEx... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | c2306225ebb710a0eb5f8dda0b705ccb | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes |
import java.util.Scanner;
public class ShiftingStacks {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int t = in.nextInt();
while (t-- > 0) {
int n = in.nextInt();
long[] a = new long[n];
String ans = "YES";
long count = 0;
for (int i = 0; ... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | 8297fda88180c869574721534ad5920c | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.util.*;
public class class42 {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
int t=input.nextInt();
while(t-->0) {
int n=input.nextInt();
long a[]=new long[n];
long count=0,x=0,temp=0;
for(int i=0;i<n;i++) {
a[i]=input.nextLong();
}
f... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | 806593cf5cce3687889edfd7bf4198cb | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.util.*;
public class A_AB_Balance{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
int t=sc.nextInt();
while(t-->0){
int n=sc.nextInt();
long[] arr=new long[n];
int count=0;
long sum=0;
... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | 917876bfe675756d4e01ccf7decdd3d8 | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | //package currentContest;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
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.Random;
... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | 4a6db81c7918c6490ae64a3a5fc183f7 | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.util.*;
import java.io.*;
public class Main {
static long mod = 1000000007;
static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
public static void main(String[] args) throws IOException {
FastReader sc = new FastReader();
int t = sc.nextInt();
while( t-- >... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | 2d8b609a166b3d796a510ec25fd5bc17 | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.StringTokenizer;
/*
* @author : Imtiaz Adar
* Stream : Koshto
*/
public class Shifting_Stacks {
public... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | b19c6b7b3f811edb084e803dcce1e614 | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.util.*;
public class Round7032 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
for(int i = 0; i < t; i++) {
int n = sc.nextInt();
long arr[] = new long[n];
for(int j = 0; j < n; j++) {
arr[j] = sc.nextLong();}
for(int j =... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | c5d55cf8b66710b36e45509beb4a4e42 | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | //package codeforces;
import java.util.*;
public class solution {
public static void main(String args[]){
Scanner s=new Scanner(System.in);
int t=s.nextInt();
for(int tt=0;tt<t;tt++){
int n=s.nextInt();
long sum=0,sum1=0;
boolean ans=true;
for(int i=0;i<n;i++) {
int x=s.nextInt(... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | 988d5e41c5507b01d58a18fa48b2fa2f | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.Vector;
public class codeforce {
static Scanner sc = new Scanner(System.in);
static Vector<Integer> ve = new Vector<Integer>();
static List<Integer> list = new ArrayList<Integer>();
public static void main(String... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | 0b6d079f23835c6fc574c9f45b16b828 | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class ShiftingStacks {
public static void main(String[] args) {
FastReader sc = new FastReader();
int t=sc.nextInt();
while(t-->0)
{
int n = sc.nextInt();
... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output | |
PASSED | 4f797486df74a56c1ce928318dc68d1c | train_109.jsonl | 1613658900 | You have $$$n$$$ stacks of blocks. The $$$i$$$-th stack contains $$$h_i$$$ blocks and it's height is the number of blocks in it. In one move you can take a block from the $$$i$$$-th stack (if there is at least one block) and put it to the $$$i + 1$$$-th stack. Can you make the sequence of heights strictly increasing?No... | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
public class ShiftingStacks {
public static void main(String[] args) throws IOException {
ShiftingStacks solver = new ShiftingStacks();
BufferedReader in = new BufferedReader(new Inp... | Java | ["6\n2\n1 2\n2\n1 0\n3\n4 4 4\n2\n0 0\n3\n0 1 0\n4\n1000000000 1000000000 1000000000 1000000000"] | 1 second | ["YES\nYES\nYES\nNO\nNO\nYES"] | NoteIn the first test case there is no need to make any moves, the sequence of heights is already increasing.In the second test case we need to move one block from the first stack to the second. Then the heights become $$$0$$$ $$$1$$$.In the third test case we could move one block from the first stack to the second and... | Java 11 | standard input | [
"greedy",
"implementation"
] | 7a8c4ba98a77097faff625b94889b365 | First line contains a single integer $$$t$$$ $$$(1 \leq t \leq 10^4)$$$ — the number of test cases. The first line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$. The second line of each test case contains $$$n$$$ integers $$$h_i$$$ $$$(0 \leq h_i \leq 10^9)$$$ — starting heights of the s... | 900 | For each test case output YES if you can make the sequence of heights strictly increasing and NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer). | standard output |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.