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
sequencelengths 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 | f0dcafabc7b022df29e7d427ee048b0b | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes | //import java.io.IOException;
import java.io.*;
import java.util.*;
public class BracketSequenceDeletion {
static InputReader inputReader=new InputReader(System.in);
static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
static List<LinkedHashSet<Integer>>answer=new ArrayList<>();
static void solve() throws IOException
{
int n=inputReader.nextInt();
String str=inputReader.readString();
StringBuffer stringBuffer=new StringBuffer();
int a=0;
int b=0;
int ind=0;
char prev='#';
while (ind<n)
{
int curr=ind;
char c=str.charAt(curr);
int next=ind+1;
if (next==n)
{
break;
}
if (c=='(')
{
a++;
}
else
{
while (next<n&& str.charAt(next)!=')')
{
next++;
}
if (next==n)
{
break;
}
a++;
}
b+=(next-ind+1);
ind=next;
ind++;
}
out.println(a+" "+(n-b));
}
static PrintWriter out=new PrintWriter((System.out));
static void SortDec(long arr[])
{
List<Long>list=new ArrayList<>();
for(long ele:arr) {
list.add(ele);
}
Collections.sort(list,Collections.reverseOrder());
for (int i=0;i<list.size();i++)
{
arr[i]=list.get(i);
}
}
static void Sort(long arr[])
{
List<Long>list=new ArrayList<>();
for(long ele:arr) {
list.add(ele);
}
Collections.sort(list);
for (int i=0;i<list.size();i++)
{
arr[i]=list.get(i);
}
}
public static void main(String args[])throws IOException
{
int t=inputReader.nextInt();
while (t-->0) {
solve();
}
long s = System.currentTimeMillis();
// out.println(System.currentTimeMillis()-s+"ms");
out.close();
}
static class InputReader {
private InputStream stream;
private byte[] buf = new byte[8192];
private int curChar, snumChars;
private SpaceCharFilter filter;
public InputReader(InputStream stream) {
this.stream = stream;
}
public int snext() {
if (snumChars == -1)
throw new InputMismatchException();
if (curChar >= snumChars) {
curChar = 0;
try {
snumChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (snumChars <= 0)
return -1;
}
return buf[curChar++];
}
public int nextInt() {
int c = snext();
while (isSpaceChar(c))
c = snext();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = snext();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = snext();
} while (!isSpaceChar(c));
return res * sgn;
}
public long nextLong() {
int c = snext();
while (isSpaceChar(c))
c = snext();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = snext();
}
long res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = snext();
} while (!isSpaceChar(c));
return res * sgn;
}
public int[] nextIntArray(int n) {
int a[] = new int[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
public String readString() {
int c = snext();
while (isSpaceChar(c))
c = snext();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = snext();
} while (!isSpaceChar(c));
return res.toString();
}
public boolean isSpaceChar(int c) {
if (filter != null)
return filter.isSpaceChar(c);
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
}
}
| Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | 5261bbfc4dd0f911bdc574d01b9d60fb | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes | import java.math.*;
import java.util.* ;
import java.io.* ;
@SuppressWarnings("unused")
//Scanner s = new Scanner(new File("input.txt"));
//s.close();
//PrintWriter writer = new PrintWriter("output.txt");
//writer.close();
public class cf
{
static long gcd(long a, long b){if (b == 0) {return a;}return gcd(b, a % b);}
public static void main(String[] args)throws Exception
{
FastReader in = new FastReader() ;
// FastIO in = new FastIO(System.in) ;
StringBuilder op = new StringBuilder() ;
int T = in.nextInt() ;
// int T=1 ;
for(int tt=0 ; tt<T ; tt++){
int n = in.nextInt() ;
String st = in.nextLine() ;
// (( , )) , () , )()
int rem=0 , oper=0 ;
for(int i=0 ; i<n-1 ; i++) {
String two = st.substring(i,i+2) ;
if(two.equals("((") || two.equals("))") || two.equals("()")) {
rem+=2 ;
i++ ;
oper++ ;
}
//)((((((((()
else if(two.equals(")(")) {
int mark=i ;
i++ ;
while(i<n && st.charAt(i)!=')') {
i++ ;
}
if(i<n && st.charAt(i)==')'){
rem+=i-mark+1 ;
oper++ ;
}
}
}
op.append(oper+" "+(n-rem)).append("\n") ;
}
System.out.println(op.toString()) ;
}
static class pair implements Comparable<pair> {
int first, second;
pair(int first, int second) {
this.first = first;
this.second = second;
}
@Override
public int compareTo(pair other) {
return this.first - other.first;
}
}
static void sort(int[] a) {
ArrayList<Integer> l=new ArrayList<>();
for (int i:a) l.add(i);
Collections.sort(l);
for (int i=0; i<a.length; i++) a[i]=l.get(i);
}
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br = new BufferedReader(
new InputStreamReader(System.in));
}
String next()
{
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
}
catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() { return Integer.parseInt(next()); }
long nextLong() { return Long.parseLong(next()); }
double nextDouble(){ return Double.parseDouble(next()); };
String nextLine()
{
String str = "";
try {
str = br.readLine();
}
catch (IOException e) {
e.printStackTrace();
}
return str;
}
int[] readArray(int n) {
int[] a=new int[n];
for (int i=0; i<n; i++) a[i]=nextInt();
return a;
}
}
} | Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | a093b8d315dbeb97a90fb1b08d41152a | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.*;
public class CF1{
public static void main(String[] args) {
FastScanner sc=new FastScanner();
int T=sc.nextInt();
// int T=1;
for (int tt=1; tt<=T; tt++){
int n =sc.nextInt();
String s = sc.next();
int operations=0;
int removed=0;
for (int i=0; i<n; i++){
if (i!=n-1 && (s.charAt(i)=='(' || s.charAt(i)==s.charAt(i+1))) {operations++; removed+=2; i++;}
else {
int rem=1;
i++;
while (i<n && s.charAt(i)!=')'){
rem++;
i++;
}
if (i==n) break;
else {operations++; removed+=rem+1;}
}
}
System.out.println(operations+" "+ (n-removed));
}
}
static long factorial (int x){
if (x==0) return 1;
long ans =x;
for (int i=x-1; i>=1; i--){
ans*=i;
ans%=mod;
}
return ans;
}
static long mod =998244353L;
static long power2 (long a, long b){
long res=1;
while (b>0){
if ((b&1)== 1){
res= (res * a % mod)%mod;
}
a=(a%mod * a%mod)%mod;
b=b>>1;
}
return res;
}
static boolean sieveOfEratosthenes(int n)
{
boolean prime[] = new boolean[n+1];
for(int i=0;i<=n;i++)
prime[i] = true;
for(int p = 2; p*p <=n; p++)
{
if(prime[p] == true)
{
for(int i = p*p; i <= n; i += p)
prime[i] = false;
}
}
return prime[n];
}
static void sort(int[] a) {
ArrayList<Integer> l=new ArrayList<>();
for (int i:a) l.add(i);
Collections.sort(l);
for (int i=0; i<a.length; i++) a[i]=l.get(i);
}
static void sortLong(long[] a) {
ArrayList<Long> l=new ArrayList<>();
for (long i:a) l.add(i);
Collections.sort(l);
for (int i=0; i<a.length; i++) a[i]=l.get(i);
}
static long gcd (long n, long m){
if (m==0) return n;
else return gcd(m, n%m);
}
static class Pair implements Comparable<Pair>{
int x,y;
private static final int hashMultiplier = BigInteger.valueOf(new Random().nextInt(1000) + 100).nextProbablePrime().intValue();
public Pair(int x, int y){
this.x = x;
this.y = y;
}
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Pair pii = (Pair) o;
if (x != pii.x) return false;
return y == pii.y;
}
public int hashCode() {
return hashMultiplier * x + y;
}
public int compareTo(Pair o){
return this.x-o.x;
}
// this.x-o.x is ascending
}
static class FastScanner {
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st=new StringTokenizer("");
String next() {
while (!st.hasMoreTokens())
try {
st=new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
int[] readArray(int n) {
int[] a=new int[n];
for (int i=0; i<n; i++) a[i]=nextInt();
return a;
}
long nextLong() {
return Long.parseLong(next());
}
}
} | Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | 1208a5509d916d8a180ef7683d4ed322 | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes | import java.util.Comparator;
import java.util.Objects;
import java.util.Scanner;
import java.util.Stack;
public class Main {
static void solve() {
Scanner scan = new Scanner(System.in);
int t = scan.nextInt();
for (int i = 0; i < t; i++) {
int n = scan.nextInt();
String s = scan.next();
solveCase(n, s);
}
}
static void solveCase(int n, String s) {
int cnt = 0;
int removed = 0;
// boolean[][] pals = getPals(s);
Stack<Character> stack = new Stack<>();
int start = 0;
int curr = 0;
while(curr < n) {
char ch = s.charAt(curr);
if(curr - start >= 1 && isPal(s, start, curr)) {
cnt++;
removed += (curr - start + 1);
start = curr + 1;
stack.clear();
} else if(ch == ')') {
if(!stack.isEmpty()) {
stack.pop();
boolean match = stack.size() == 0;
if(match) {
cnt++;
removed += (curr - start + 1);
start = curr + 1;
}
}
} else {
stack.push(ch);
}
curr++;
}
System.out.printf("%d %d\n", cnt, s.length() - removed);
}
static boolean isPal(String s, int beg, int end) {
while(beg <= end) {
if(s.charAt(beg) != s.charAt(end)) {
return false;
}
beg++; end--;
}
return true;
}
// static boolean[][] getPals(String s) {
// int cnt = 1;
// boolean[][] pals = new boolean[s.length()][s.length()];
// int i = 0;
// while(cnt <= s.length()) {
// i = 0;
// while(i + cnt <= s.length()) {
// int end = i + cnt - 1;
// if(i == end || (end - i == 1 && s.charAt(end) == s.charAt(i)) || (s.charAt(end) == s.charAt(i) && pals[i+1][end-1])) {
// pals[i][end] = true;
// }
// i++;
// }
// cnt++;
// }
// return pals;
// }
public static void main(String[] args) {
// System.out.println(isSquare(16));
solve();
}
static class Node {
int val;
Node right;
Node left;
public Node(int val, Node right, Node left) {
this.val = val;
this.right = right;
this.left = left;
}
}
////////////////
static class Pair {
int row;
int col;
public Pair(int row, int col) {
this.row = row;
this.col = col;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Pair pair = (Pair) o;
return row == pair.row && col == pair.col;
}
@Override
public int hashCode() {
return Objects.hash(row, col);
}
}
static class MyComparator implements Comparator<Integer> {
@Override
public int compare(Integer o1, Integer o2) {
return o1 - o2;
}
}
}
| Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | 930bc5a7ab483b035d7e361a0c20e568 | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes | import java.util.*;
import java.util.stream.LongStream;
import java.io.*;
import java.math.BigInteger;
public class Template{
public static void main(String[] args) {
FastReader fr = new FastReader();
PrintWriter out = new PrintWriter(System.out);
Scanner sc= new Scanner (System.in);
//Code From Here----
int t =fr.nextInt();
StringBuilder answer = new StringBuilder();
while (t-->0) {
int n = fr.nextInt();
char[] s = fr.nextLine().toCharArray();
int index = 0;
int ans =0;
while (index<n) {
if (s[index]=='(') {
if(index<n-1){
ans++;
index+=2;
}
else break;
}
else
{
int temp=index;
index++;
while (index<n && s[index]!=')') {
index++;
}
if(index==n){
index=temp;
break;
}
ans++;
index++;
}
}
answer.append(ans+" "+(n-index>0?n-index:index-n)+"\n");
}
out.println(answer);
out.flush();
sc.close();
}
private static boolean Calculate(int sum, Map<Integer, Integer> freq,boolean value) {
if(sum==0)
return true;
if (freq.containsKey(sum) && freq.get(sum)>=1) {
freq.put(sum,freq.get(sum)-1);
return true;
}
else if (sum==1){
value=false;
return false;
}
return Calculate(sum/2, freq,value) && Calculate((sum+1)/2, freq,value);
}
public static BigInteger Factorial(BigInteger number){
if(number.compareTo(BigInteger.ONE)!=1)
{
return BigInteger.ONE;
}
return number.multiply(Factorial(number.subtract(BigInteger.ONE)));
}
private static boolean isPrime(int count) {
if(count%2 == 0) return false;
if(count%3 ==0) return false;
for (int i = 6; i*i <= count ; i+=6) {
if(count%(i-1) == 0 || count%(i+1)==0)
{
return false;
}
}
return true;
}
static ArrayList<Integer> sieveOfEratosthenes(int n)
{
// Create a boolean array
// "prime[0..n]" and
// initialize all entries
// it as true. A value in
// prime[i] will finally be
// false if i is Not a
// prime, else true.
boolean prime[] = new boolean[n + 1];
for (int i = 0; i <= n; i++)
prime[i] = true;
for (int p = 2; p * p <= n; p++)
{
// If prime[p] is not changed, then it is a
// prime
if (prime[p] == true)
{
// Update all multiples of p
for (int i = p * p; i <= n; i += p)
prime[i] = false;
}
}
ArrayList <Integer> list = new ArrayList<>();
// Print all prime numbers
for (int i = 2; i <= n; i++)
{
if (prime[i] == true)
list.add(i);
}
return list;
}
//This RadixSort() is for long method
public static long[] radixSort(long[] f){ return radixSort(f, f.length); }
public static long[] radixSort(long[] f, int n)
{
long[] to = new long[n];
{
int[] b = new int[65537];
for(int i = 0;i < n;i++)b[1+(int)(f[i]&0xffff)]++;
for(int i = 1;i <= 65536;i++)b[i]+=b[i-1];
for(int i = 0;i < n;i++)to[b[(int)(f[i]&0xffff)]++] = f[i];
long[] d = f; f = to;to = d;
}
{
int[] b = new int[65537];
for(int i = 0;i < n;i++)b[1+(int)(f[i]>>>16&0xffff)]++;
for(int i = 1;i <= 65536;i++)b[i]+=b[i-1];
for(int i = 0;i < n;i++)to[b[(int)(f[i]>>>16&0xffff)]++] = f[i];
long[] d = f; f = to;to = d;
}
{
int[] b = new int[65537];
for(int i = 0;i < n;i++)b[1+(int)(f[i]>>>32&0xffff)]++;
for(int i = 1;i <= 65536;i++)b[i]+=b[i-1];
for(int i = 0;i < n;i++)to[b[(int)(f[i]>>>32&0xffff)]++] = f[i];
long[] d = f; f = to;to = d;
}
{
int[] b = new int[65537];
for(int i = 0;i < n;i++)b[1+(int)(f[i]>>>48&0xffff)]++;
for(int i = 1;i <= 65536;i++)b[i]+=b[i-1];
for(int i = 0;i < n;i++)to[b[(int)(f[i]>>>48&0xffff)]++] = f[i];
long[] d = f; f = to; to = d;
}
return f;
}
public static int[] radixSort2(int[] a)
{
int n = a.length;
int[] c0 = new int[0x101];
int[] c1 = new int[0x101];
int[] c2 = new int[0x101];
int[] c3 = new int[0x101];
for(int v : a) {
c0[(v&0xff)+1]++;
c1[(v>>>8&0xff)+1]++;
c2[(v>>>16&0xff)+1]++;
c3[(v>>>24^0x80)+1]++;
}
for(int i = 0;i < 0xff;i++) {
c0[i+1] += c0[i];
c1[i+1] += c1[i];
c2[i+1] += c2[i];
c3[i+1] += c3[i];
}
int[] t = new int[n];
for(int v : a)t[c0[v&0xff]++] = v;
for(int v : t)a[c1[v>>>8&0xff]++] = v;
for(int v : a)t[c2[v>>>16&0xff]++] = v;
for(int v : t)a[c3[v>>>24^0x80]++] = v;
return a;
}
static int lowerBound(long a[], long x) { // x is the target value or key
int l = -1, r = a.length;
while (l + 1 < r) {
int m = (l + r) >>> 1;
if (a[m] >= x) r = m;
else l = m;
}
return r;
}
static int upperBound(long a[], long x) {// x is the key or target value
int l = -1, r = a.length;
while (l + 1 < r) {
int m = (l + r) >>> 1L;
if (a[m] <= x) l = m;
else r = m;
}
return l + 1;
}
static int upperBound(long[] arr, int start, int end, long k) {
int N = end;
while (start < end) {
int mid = start + (end - start) / 2;
if (k >= arr[mid]) {
start = mid + 1;
} else {
end = mid;
}
}
if (start < N && arr[start] <= k) {
start++;
}
return start;
}
static long lowerBound(long[] arr, int start, int end, long k) {
int N = end;
while (start < end) {
int mid = start + (end - start) / 2;
if (k <= arr[mid]) {
end = mid;
} else {
start = mid + 1;
}
}
if (start < N && arr[start] < k) {
start++;
}
return start;
}
// H.C.F.
// For Fast Factorial
public static long factorialStreams( long n )
{
return LongStream.rangeClosed( 1, n )
.reduce(1, ( long a, long b ) -> a * b);
}
// Binary Exponentiation
public static long FastExp(long base, long exp) {
long ans=1;
long mod=998244353;
while (exp>0) {
if (exp%2==1) ans*=base;
exp/=2;
base*=base;
base%=mod;
ans%=mod;
}
return ans;
}
// H.C.F.
public static int gcd(int a, int b)
{
if (a == 0)
return b;
return gcd(b%a, a);
}
// H.C.F. by Binary Method(Eucladian Algorithm)
private static int gcdBinary(int x, int y)
{
int shift;
/* GCD(0, y) == y; GCD(x, 0) == x, GCD(0, 0) == 0 */
if (x == 0)
return y;
if (y == 0)
return x;
int gcdX = Math.abs(x);
int gcdY = Math.abs(y);
if (gcdX == 1 || gcdY == 1)
return 1;
/* Let shift := lg K, where K is the greatest power of 2 dividing both x and y. */
for (shift = 0; ((gcdX | gcdY) & 1) == 0; ++shift)
{
gcdX >>= 1;
gcdY >>= 1;
}
while ((gcdX & 1) == 0)
gcdX >>= 1;
/* From here on, gcdX is always odd. */
do
{
/* Remove all factors of 2 in gcdY -- they are not common */
/* Note: gcdY is not zero, so while will terminate */
while ((gcdY & 1) == 0)
/* Loop X */
gcdY >>= 1;
/*
* Now gcdX and gcdY are both odd. Swap if necessary so gcdX <= gcdY,
* then set gcdY = gcdY - gcdX (which is even). For bignums, the
* swapping is just pointer movement, and the subtraction
* can be done in-place.
*/
if (gcdX > gcdY)
{
final int t = gcdY;
gcdY = gcdX;
gcdX = t;
} // Swap gcdX and gcdY.
gcdY = gcdY - gcdX; // Here gcdY >= gcdX.
}while (gcdY != 0);
/* Restore common factors of 2 */
return gcdX << shift;
}
// Check For Palindrome
public static boolean isPalindrome(String s)
{
return s.equals( new StringBuilder(s).reverse().toString());
}
// For Fast Input ----
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br = new BufferedReader(
new InputStreamReader(System.in));
}
String next()
{
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
}
catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() { return Integer.parseInt(next()); }
long nextLong() { return Long.parseLong(next()); }
int[] readArray(int []arr) {
for (int i = 0; i < arr.length; i++) {
arr[i]=nextInt();
}
return arr;
}
long[] readArray(long []arr) {
for (int i = 0; i < arr.length; i++) {
arr[i]=nextLong();
}
return arr;
}
double nextDouble()
{
return Double.parseDouble(next());
}
String nextLine()
{
String str = "";
try {
str = br.readLine();
}
catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
} | Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | b39e9700b8e1ae5a70f5c2a1be5cd5b7 | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes | import static java.lang.Math.*;
import java.util.*;
import java.io.*;
import java.math.*;
public class x1657C
{
public static void main(String omkar[]) throws Exception
{
BufferedReader infile = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(infile.readLine());
int T = Integer.parseInt(st.nextToken());
StringBuilder sb = new StringBuilder();
while(T-->0)
{
st = new StringTokenizer(infile.readLine());
int N = Integer.parseInt(st.nextToken());
char[] arr = infile.readLine().trim().toCharArray();
int res = 0;
int remain = -1;
int curr = 0;
while(curr < N-1)
{
if(arr[curr] == ')' && arr[curr+1] == '(')
{
int dex = curr+1;
while(dex < N)
{
if(arr[dex] == ')')
break;
dex++;
}
if(dex == N)
break;
res++;
curr = dex+1;
}
else
{
res++;
curr+=2;
}
}
if(remain == -1)
remain = N-curr;
sb.append(res).append(" ").append(remain);
sb.append("\n");
}
System.out.print(sb);
}
public static int[] readArr(int N, BufferedReader infile, StringTokenizer st) throws Exception
{
int[] arr = new int[N];
st = new StringTokenizer(infile.readLine());
for(int i=0; i < N; i++)
arr[i] = Integer.parseInt(st.nextToken());
return arr;
}
} | Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | fb2b06bf915badcde312321520b7cf0c | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes | import java.io.*;
public class Contest {
public static void main(String[] args) throws IOException {
// Reader reader = new Reader("c.in");
Reader reader = new Reader();
int t = reader.nextInt();
for (int ti = 0; ti < t; ti++) {
int n = reader.nextInt();
String s = reader.nextString();
int p = 0;
int oper = 0;
while (p + 2 <= n) {
if (s.charAt(p) == '(') {
p+=2;
oper++;
} else {
int oldp = p;
p++;
while (p < n && s.charAt(p) == '(') {
p+=1;
}
if (p == n) {
p = oldp;
break;
}
oper++;
p++;
}
}
System.out.println(oper + " " + (n-p));
}
}
public static class Reader {
final private int BUFFER_SIZE = 500_010;
private DataInputStream din;
private byte[] buffer;
private int bufferPointer, bytesRead;
public Reader(String fileName) throws FileNotFoundException {
din = new DataInputStream(new FileInputStream(fileName));
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public Reader() {
din = new DataInputStream(System.in);
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public String nextString() throws IOException {
byte[] buf = new byte[BUFFER_SIZE]; // line length
int cnt = 0, c;
while ((c = read()) != -1) {
if (c == '\n' || c == '\r') {
if (cnt != 0) {
break;
}
else {
continue;
}
}
buf[cnt++] = (byte)c;
}
return new String(buf, 0, cnt);
}
public int nextInt() throws IOException {
int ret = 0;
byte c = read();
while (c <= ' ') {
c = read();
}
boolean neg = (c == '-');
if (neg) {
c = read();
}
do
{
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (neg) {
return -ret;
}
return ret;
}
private void fillBuffer() throws IOException {
bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
if (bytesRead == -1) {
buffer[0] = -1;
}
}
private byte read() throws IOException {
if (bufferPointer == bytesRead) {
fillBuffer();
}
return buffer[bufferPointer++];
}
public void close() throws IOException {
if (din == null) {
return;
}
din.close();
}
}
} | Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | d7c352fe7a95ca49b30e8010022a7dd9 | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Stack;
public class BracketSequenceDeletion {
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());
String str=br.readLine();
int op=0;
int i=0;
int j=1;
while(i<n && j<n){
if(str.charAt(i)==')' && str.charAt(j)=='(') j++;
else{
op++;
i=j+1;
j=i+1;
}
}
System.out.println(op+" "+(n-i));
}
}
} | Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | 3433b294ac304cf3d75a564a0a650333 | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayDeque;
import java.util.Deque;
public class BracketsSeqDeletions {
static boolean isPalindrome(String word, int l, int r) {
while (l < r) {
if (word.charAt(l) != word.charAt(r)) return false;
l++;
r--;
}
return true;
}
static boolean isValid(String word, int l, int r) {
Deque<Character> deq = new ArrayDeque<>();
while (l <= r) {
if (word.charAt(l) == ')' && deq.isEmpty()) return false;
else if (word.charAt(l) == ')') deq.pop();
else deq.push('(');
l++;
}
return deq.isEmpty();
}
static int[] operations(String s) {
int ops = 0;
int l = 0;
int r = l + 1;
int last = 0;
while (r < s.length()) {
if (isPalindrome(s, l, r) || isValid(s, l, r)) {
ops++;
last = r;
l = r + 1;
r = l + 1;
} else r++;
}
if (last == 0) return new int[]{ops, s.length()};
return new int[]{ops, s.length() - 1 == last ? 0 : s.length() - 1 - last};
}
public static void main(String[] args) throws IOException {
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
int t = Integer.parseInt(reader.readLine());
for (int i = 0; i < t; i++) {
String x = reader.readLine();
String s = reader.readLine();
int[] ans = operations(s);
System.out.println(ans[0] + " " + ans[1]);
}
}
} | Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | 954878ee2d49bc1f35a6a05adc55ef34 | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes | import java.util.*;
public class program1 {
public static void main (String[] args) throws java.lang.Exception
{
// your code goes here
Scanner s=new Scanner(System.in);
int t=s.nextInt();
while(t-->0)
{
int n=s.nextInt();
String str=s.next();
char ch[]=str.toCharArray();
int ans=0;
Stack<Character> st=new Stack<>();
int i = 0;
int c = 0;
st.push(ch[i]);
while (i < n - 1) {
if (ch[i] == ch[i + 1]) {
st.push(ch[i]);
c++;
i += 2;
continue;
}
if (ch[i] == '(' && ch[i + 1] == ')') {
c++;
i += 2;
if(st.isEmpty())
st.peek();
continue;
}
int ind = -1;
for (int k = i + 1; k < n; k++) {
if (ch[k] == ')') {
c++;
ind = k;
st.push(ch[k]);
if(st.isEmpty())
st.pop();
break;
}
}
if (ind == -1) break;
i = ind + 1;
}
int len = 0;
if (i < n) {
len = n - i;
}
System.out.println(c+" "+len);
}
}
} | Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | faf45694179b9a21aa5c8312ed005002 | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes | import java.util.LinkedList;
import java.util.Random;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int T=sc.nextInt();
while(T-->0) {
int n=sc.nextInt();
char[] str=sc.next().toCharArray();
LinkedList<Integer> list=new LinkedList<>();
int[] pre=new int[n];
for(int i=0;i<n;i++) {
if(i>0)
pre[i]=pre[i-1];
if(str[i]=='(')
pre[i]++;
}
int ans=n,cnt=0;
int index=0;
for(int i=0;i<n;i++) {
if(str[i]=='(')
list.addLast(0);
else {
if(!list.isEmpty() && list.getLast()==0)
list.removeLast();
else
list.addLast(1);
}
if(list.isEmpty() && i>index) {
ans-=i-index+1;
index=i+1;
cnt++;
continue;
}
if(index==i)
continue;
if(index>0) {
if((i-index+1)%2==0) {
int t=(i+index)/2;
if(pre[t]-pre[index-1]==pre[i]-pre[t]) {
if(check(str,index,i)) {
ans-=i-index+1;
index=i+1;
cnt++;
list.clear();
continue;
}
}
}
else {
int t=(i+index)/2;
if(pre[t-1]-pre[index-1]==pre[i]-pre[t]) {
if(check(str,index,i)) {
ans-=i-index+1;
index=i+1;
cnt++;
list.clear();
continue;
}
}
}
}
else {
if((i-index+1)%2==0) {
int t=(i+index)/2;
if(pre[t]==pre[i]-pre[t]) {
if(check(str,index,i)) {
ans-=i-index+1;
index=i+1;
cnt++;
list.clear();
continue;
}
}
}
else {
int t=(i+index)/2;
if(pre[t-1]==pre[i]-pre[t]) {
if(check(str,index,i)) {
ans-=i-index+1;
index=i+1;
cnt++;
list.clear();
continue;
}
}
}
}
}
System.out.println(cnt+" "+ans);
}
sc.close();
}
private static boolean check(char[] str,int from,int to) {
for(int i=from,j=to;i<j;i++,j--) {
if(str[i]!=str[j])
return false;
}
return true;
}
private static char[] generate(int n) {
char[] str=new char[n];
for(int i=0;i<n;i++) {
if(new Random().nextInt(2)%2!=0)
str[i]='(';
else
str[i]=')';
}
return str;
}
}
| Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | d4066195464af992baa00688ffce755d | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;
public class Main {
static int t;
static int n;
static int[] a;
static String s;
static FastReader fr = new FastReader();
static PrintWriter out = new PrintWriter(System.out);
static long mod = 998244353l;
public static Edge[] edges;
public static int cnt;
public static int[] fir;
public static long[] dis;
public static boolean[] vis;
static class Edge {
int u, v, next;
boolean cut;
int used;
int num;
long fz, fm;
}
public static void dijInit(int edgeSize, int nodeSize) {
cnt = 0;
edges = new Edge[edgeSize + 10];
fir = new int[edgeSize + 10];
dis = new long[nodeSize + 10];
vis = new boolean[nodeSize + 10];
Arrays.fill(fir, -1);
}
public static long gcd(long a, long b) {
return b == 0 ? a : gcd(b, a % b);
}
//构建邻接表，u代表起点，v代表终点，w代表之间路径
static void addEdge(int u, int v, long fz, long fm) {
edges[cnt] = new Edge();
edges[cnt].u = u;
edges[cnt].v = v;
edges[cnt].fz = fz;
edges[cnt].fm = fm;
edges[cnt].next = fir[u];
edges[cnt].used = 0;
fir[u] = cnt++;
}
static long x, y, q;
//扩展欧几里德
static void ExEuclid(long a, long b) {
if (b == 0) {
x = 1;
y = 0;
q = a;
return;
}
ExEuclid(b, a % b);
long tmp = x;
x = y;
y = tmp - y * (a / b);
}
//乘法逆元
static long inv(long num) {
ExEuclid(num, mod);
return (x + mod) % mod;
}
static int[][] dp = new int[51][51];
static void init() {
Set<Integer> z = new HashSet<>();
for (int i = 0; i < 100; i++) {
z.add(i * i);
}
for (int i = 0; i <= 50; i ++) Arrays.fill(dp[i], 0x3f3f3f3f);
dp[0][0] = 0;
for (int i = 0; i <= 50; i ++) {
for (int j = 0; j <= 50; j ++) {
for (int k = 0; k <= i; k ++) {
for (int h = 0; h <= j; h ++) {
int t = (i - k) * (i - k) + (j - h) * (j - h);
if (t == 0) continue;
if (z.contains(t)) {
dp[i][j] = Math.min(dp[i][j], dp[k][h] + 1);
}
}
}
}
}
}
public static void main(String[] args) {
init();
int t = fr.nextInt();
while ((t --) > 0) {
int n = fr.nextInt();
String s = fr.nextString();
char[] cs = s.toCharArray();
int cnt = 0;
int sum = 0;
boolean flag = false;
int tmp = 0;
for (int i = 1; i < cs.length; ) {
if (!flag) {
if (cs[i] == cs[i - 1]) {
cnt ++;
sum += 2;
i += 2;
continue;
} else if (cs[i] == ')' && cs[i - 1] == '(') {
cnt ++;
sum += 2;
i += 2;
continue;
} else {
flag = true;
i +=1;
tmp = 2;
}
} else {
if (cs[i] == ')') {
cnt ++;
tmp ++;
sum += tmp;
tmp = 0;
flag = false;
i ++;
} else {
tmp ++;
}
i ++;
}
}
System.out.println(cnt + " " + (s.length() - sum));
}
return;
}
static class FastReader {
private BufferedReader bfr;
private StringTokenizer st;
public FastReader() {
bfr = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
if (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(bfr.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
char nextChar() {
return next().toCharArray()[0];
}
String nextString() {
return next();
}
int[] nextIntArray(int n) {
int[] arr = new int[n];
for (int i = 0; i < n; i++)
arr[i] = nextInt();
return arr;
}
double[] nextDoubleArray(int n) {
double[] arr = new double[n];
for (int i = 0; i < arr.length; i++)
arr[i] = nextDouble();
return arr;
}
long[] nextLongArray(int n) {
long[] arr = new long[n];
for (int i = 0; i < n; i++)
arr[i] = nextLong();
return arr;
}
int[][] nextIntGrid(int n, int m) {
int[][] grid = new int[n][m];
for (int i = 0; i < n; i++) {
char[] line = fr.next().toCharArray();
for (int j = 0; j < m; j++)
grid[i][j] = line[j] - 48;
}
return grid;
}
}
}
| Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | 404b4b3ddd765f9c0a2a66b7396cb443 | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes | import java.util.*;
import java.io.*;
public class C {
public static void main(String[] args) throws Exception {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
PrintWriter pw = new PrintWriter(System.out);
StringTokenizer st;
int t = Integer.parseInt(br.readLine());
while (t --> 0) {
int n = Integer.parseInt(br.readLine());
int[] a = new int[n];
String s = br.readLine();
for (int i = 0; i < n; i++) a[i] = s.charAt(i) == '(' ? 1 : -1;
int ops = 0;
int l = 0;
int sum = 0;
int prefix = 0;
int reversePrefix = 0;
int last = -1;
int p1 = 0;
while (p1 < n - 1) {
if (!s.substring(p1, p1 + 2).equals(")(")) {
ops++;
p1 = p1 + 2;
last = p1 - 1;
} else {
while (p1 < n - 1) {
p1++;
if (s.charAt(p1) == ')') {
last = p1;
ops++;
p1++;
break;
}
}
}
}
pw.println(ops + " " + (n - last - 1));
}
pw.close();
}
}
| Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | 62071ac99f49577f2ae3a1a24090c6fb | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes | import java.util.*;
import java.io.*;
import java.lang.*;
import java.math.*;
public class Main {
public static class MyScanner {
BufferedReader br;
StringTokenizer st;
public MyScanner() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
int[] readArray(int n) {
int[] ar = new int[n];
for (int i = 0; i < n; i++)
ar[i] = nextInt();
return ar;
}
long[] readArray2(int n) {
long[] ar = new long[n];
for (int i = 0; i < n; i++)
ar[i] = nextLong();
return ar;
}
}
static class DSU {
int[] parent;
int[] rank;
int[] sz;
public DSU(int N) {
parent = new int[N];
for (int i = 0; i < N; ++i)
parent[i] = i;
rank = new int[N];
sz = new int[N];
Arrays.fill(sz, 1);
}
public int find(int x) {
if (parent[x] != x) parent[x] = find(parent[x]);
return parent[x];
}
public void union(int x, int y) {
int xr = find(x), yr = find(y);
if (xr == yr) return;
if (rank[xr] < rank[yr]) {
int tmp = yr;
yr = xr;
xr = tmp;
}
if (rank[xr] == rank[yr])
rank[xr]++;
parent[yr] = xr;
sz[xr] += sz[yr];
}
public int size(int x) {
return sz[find(x)];
}
public int top() {
return size(sz.length - 1) - 1;
}
}
static class Pair{
int sum;
int product;
public Pair(){
sum=0;product=1;
}
public String toString(){
return (sum)+"-"+product;
}
}
static class Query{
int a,b,c,d;
public Query(int a,int b,int c,int d){
this.a=a+1;this.b=b+1;this.c=c+1;this.d=d+1;
}
}
static class People{
int x,y,d;
public People(int x,int y){
this.x=x;this.y=y;
d=0;
}
public int getX(){
return x;
}
}
static class SegmentTree {
int[] segmentTree;
public SegmentTree(int n) {
segmentTree=new int[4*n];
segmentTree[0]=0;
buildSegmentTree(0,n-1,1);
}
private void buildSegmentTree(int start,int end,int treeIndex)
{
if(start==end)
{
segmentTree[treeIndex]=0;
return;
}
int mid=(start+end)/2;
buildSegmentTree(start,mid,2*treeIndex);
buildSegmentTree(mid+1,end,2*treeIndex+1);
segmentTree[treeIndex]=segmentTree[2*treeIndex]+segmentTree[2*treeIndex+1];
}
private void updateSegmentTree(int start,int end,int treeIndex,
int index,int val)
{
if(start==end)
{
segmentTree[treeIndex]=val;
return;
}
int mid=(start+end)/2;
if(index<=mid)
updateSegmentTree(start,mid,2*treeIndex,index,val);
else
updateSegmentTree(mid+1,end,2*treeIndex+1,index,val);
segmentTree[treeIndex]=segmentTree[2*treeIndex]+segmentTree[2*treeIndex+1];
}
private int findSumRangeSegmentTree(int start,int end,int treeIndex,
int left,int right)
{
if(start>=left&&end<=right)
return segmentTree[treeIndex];
if(start>right||end<left)
return 0;
if(start==end)
return 0;
int mid=(start+end)/2;
return findSumRangeSegmentTree(start,mid,2*treeIndex,left,right)+
findSumRangeSegmentTree(mid+1,end,2*treeIndex+1,left,right);
}
}
private static MyScanner sc;
private static SegmentTree st;
public static void main(String[] args) {
sc=new MyScanner();
int T=sc.nextInt();
for(int i=0;i<T;i++){
solve(i+1);
}
// solve(0);
}
private static void solve(int test) {
int n=sc.nextInt();
String s=sc.next();
int i=0,c=0;
while(i<n-1){
String pre=""+s.charAt(i)+s.charAt(i+1);
if("()".equals(pre)||"((".equals(pre)||"))".equals(pre)){
c++;
i+=2;
}else{
int j=i;
while(++j<n&&s.charAt(j)!=')');
if(j==n)
break;
c++;
i=j+1;
}
}
System.out.println(c+" "+((n-i)<0?0:n-i));
}
} | Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | e591e1d78e9f477b9ed0569ff745826e | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes | import java.util.*;
import java.io.*;
// import java.lang.*;
// import java.math.*;
public class Main {
static FastReader sc=new FastReader();
static PrintWriter out=new PrintWriter(System.out);
static long mod=1000000007;
// static long mod=998244353;
static int MAX=Integer.MAX_VALUE;
static int MIN=Integer.MIN_VALUE;
static long MAXL=Long.MAX_VALUE;
static long MINL=Long.MIN_VALUE;
static ArrayList<Integer> graph[];
// static ArrayList<ArrayList<Integer>> graph;
static long fact[];
static int seg[];
static int dp[][];
// static long dp[][];
public static void main (String[] args) throws java.lang.Exception
{
// code goes here
int t=I();
outer:while(t-->0)
{
int n=I();
char c[]=S().toCharArray();
int ans=0;
int i;
for(i=0;i<n-1;)
{
if(c[i]=='('){
ans++;
i+=2;
}else{
int j=i+1;
while(j<n && c[j]=='(')j++;
if(j<n){
ans++;
i=j+1;
}else{
break;
}
}
}
out.println(ans+" "+(n-i));
}
out.close();
}
public static class pair
{
int a;
int b;
public pair(int aa,int bb)
{
a=aa;
b=bb;
}
}
public static class myComp implements Comparator<pair>
{
//sort in ascending order.
public int compare(pair p1,pair p2)
{
if(p1.a==p2.a)
return 0;
else if(p1.a<p2.a)
return -1;
else
return 1;
}
// sort in descending order.
// public int compare(pair p1,pair p2)
// {
// if(p1.a==p2.a)
// return 0;
// else if(p1.a<p2.a)
// return 1;
// else
// return -1;
// }
}
public static void DFS(int s,boolean visited[])
{
visited[s]=true;
for(int i:graph[s]){
if(!visited[i]){
DFS(i,visited);
}
}
}
public static void setGraph(int n,int m)
{
graph=new ArrayList[n+1];
for(int i=0;i<=n;i++){
graph[i]=new ArrayList<>();
}
for(int i=0;i<m;i++){
int u=I(),v=I();
graph[u].add(v);
graph[v].add(u);
}
}
//LOWER_BOUND and UPPER_BOUND functions
//It returns answer according to zero based indexing.
public static int lower_bound(long arr[],long X,int start, int end) //start=0,end=n-1
{
if(start>end)return -1;
if(arr[arr.length-1]<X)return end;
if(arr[0]>X)return -1;
int left=start,right=end;
while(left<right){
int mid=(left+right)/2;
// if(arr[mid]==X){ //Returns last index of lower bound value.
// if(mid<end && arr[mid+1]==X){
// left=mid+1;
// }else{
// return mid;
// }
// }
if(arr[mid]==X){ //Returns first index of lower bound value.
if(mid>start && arr[mid-1]==X){
right=mid-1;
}else{
return mid;
}
}
else if(arr[mid]>X){
if(mid>start && arr[mid-1]<X){
return mid-1;
}else{
right=mid-1;
}
}else{
if(mid<end && arr[mid+1]>X){
return mid;
}else{
left=mid+1;
}
}
}
return left;
}
//It returns answer according to zero based indexing.
public static int upper_bound(long arr[],long X,int start,int end) //start=0,end=n-1
{
if(arr[0]>=X)return start;
if(arr[arr.length-1]<X)return -1;
int left=start,right=end;
while(left<right){
int mid=(left+right)/2;
if(arr[mid]==X){ //returns first index of upper bound value.
if(mid>start && arr[mid-1]==X){
right=mid-1;
}else{
return mid;
}
}
// if(arr[mid]==X){ //returns last index of upper bound value.
// if(mid<end && arr[mid+1]==X){
// left=mid+1;
// }else{
// return mid;
// }
// }
else if(arr[mid]>X){
if(mid>start && arr[mid-1]<X){
return mid;
}else{
right=mid-1;
}
}else{
if(mid<end && arr[mid+1]>X){
return mid+1;
}else{
left=mid+1;
}
}
}
return left;
}
//END
//Segment Tree Code
public static void buildTree(int a[],int si,int ss,int se)
{
if(ss==se){
// seg[si]=ss;
if(a[ss]%2==0){
seg[si]=1;
}else{
seg[si]=0;
}
return;
}
int mid=(ss+se)/2;
buildTree(a,2*si+1,ss,mid);
buildTree(a,2*si+2,mid+1,se);
// seg[si]=max(seg[2*si+1],seg[2*si+2]);
seg[si]=(seg[2*si+1]&seg[2*si+2]);
}
public static void merge(ArrayList<Integer> f,ArrayList<Integer> a,ArrayList<Integer> b)
{
int i=0,j=0;
while(i<a.size() && j<b.size()){
if(a.get(i)<=b.get(j)){
f.add(a.get(i));
i++;
}else{
f.add(b.get(j));
j++;
}
}
while(i<a.size()){
f.add(a.get(i));
i++;
}
while(j<b.size()){
f.add(b.get(j));
j++;
}
}
public static void update(int si,int ss,int se,int pos,int val)
{
if(ss==se){
seg[si]=(int)add(seg[si],val);
return;
}
int mid=(ss+se)/2;
if(pos<=mid){
update(2*si+1,ss,mid,pos,val);
}else{
update(2*si+2,mid+1,se,pos,val);
}
seg[si]=(int)add(seg[2*si+1],seg[2*si+2]);
}
public static int query(int a[],int si,int ss,int se,int qs,int qe)
{
if(qs>se || qe<ss)return -1;
if(ss>=qs && se<=qe)return seg[si];
int mid=(ss+se)/2;
// return max(query(2*si+1,ss,mid,qs,qe),query(2*si+2,mid+1,se,qs,qe));
int p1=query(a,2*si+1,ss,mid,qs,qe);
int p2=query(a,2*si+2,mid+1,se,qs,qe);
if(p1==-1 && p2==-1)return -1;
else if(p1==-1)return p2;
else if(p2==-1)return p1;
else return (p1&p2);
}
//Segment Tree Code end
//Prefix Function of KMP Algorithm
public static int[] KMP(char c[],int n)
{
int pi[]=new int[n];
for(int i=1;i<n;i++){
int j=pi[i-1];
while(j>0 && c[i]!=c[j]){
j=pi[j-1];
}
if(c[i]==c[j])j++;
pi[i]=j;
}
return pi;
}
public static long kadane(long a[],int n) //largest sum subarray
{
long max_sum=Long.MIN_VALUE,max_end=0;
for(int i=0;i<n;i++){
max_end+=a[i];
if(max_sum<max_end){max_sum=max_end;}
if(max_end<0){max_end=0;}
}
return max_sum;
}
public static long nPr(int n,int r)
{
long ans=divide(fact(n),fact(n-r),mod);
return ans;
}
public static long nCr(int n,int r)
{
long ans=divide(fact[n],mul(fact[n-r],fact[r]),mod);
return ans;
}
public static boolean isSorted(int a[])
{
int n=a.length;
for(int i=0;i<n-1;i++){
if(a[i]>a[i+1])return false;
}
return true;
}
public static boolean isSorted(long a[])
{
int n=a.length;
for(int i=0;i<n-1;i++){
if(a[i]>a[i+1])return false;
}
return true;
}
public static int computeXOR(int n) //compute XOR of all numbers between 1 to n.
{
if (n % 4 == 0)
return n;
if (n % 4 == 1)
return 1;
if (n % 4 == 2)
return n + 1;
return 0;
}
public static int np2(int x)
{
x--;
x |= x >> 1;
x |= x >> 2;
x |= x >> 4;
x |= x >> 8;
x |= x >> 16;
x++;
return x;
}
public static int hp2(int x)
{
x |= x >> 1;
x |= x >> 2;
x |= x >> 4;
x |= x >> 8;
x |= x >> 16;
return x ^ (x >> 1);
}
public static long hp2(long x)
{
x |= x >> 1;
x |= x >> 2;
x |= x >> 4;
x |= x >> 8;
x |= x >> 16;
return x ^ (x >> 1);
}
public static ArrayList<Integer> primeSieve(int n)
{
ArrayList<Integer> arr=new ArrayList<>();
boolean prime[] = new boolean[n + 1];
for (int i = 0; i <= n; i++)
prime[i] = true;
for (int p = 2; p * p <= n; p++)
{
if (prime[p] == true)
{
for (int i = p * p; i <= n; i += p)
prime[i] = false;
}
}
for (int i = 2; i <= n; i++)
{
if (prime[i] == true)
arr.add(i);
}
return arr;
}
// Fenwick / BinaryIndexed Tree USE IT - FenwickTree ft1=new FenwickTree(n);
public static class FenwickTree
{
int farr[];
int n;
public FenwickTree(int c)
{
n=c+1;
farr=new int[n];
}
// public void update_range(int l,int r,long p)
// {
// update(l,p);
// update(r+1,(-1)*p);
// }
public void update(int x,int p)
{
for(;x<n;x+=x&(-x))
{
farr[x]+=p;
}
}
public int get(int x)
{
int ans=0;
for(;x>0;x-=x&(-x))
{
ans=ans+farr[x];
}
return ans;
}
}
//Disjoint Set Union
public static class DSU
{
int par[],rank[];
public DSU(int c)
{
par=new int[c+1];
rank=new int[c+1];
for(int i=0;i<=c;i++)
{
par[i]=i;
rank[i]=0;
}
}
public int find(int a)
{
if(a==par[a])
return a;
return par[a]=find(par[a]);
}
public void union(int a,int b)
{
int a_rep=find(a),b_rep=find(b);
if(a_rep==b_rep)
return;
if(rank[a_rep]<rank[b_rep])
par[a_rep]=b_rep;
else if(rank[a_rep]>rank[b_rep])
par[b_rep]=a_rep;
else
{
par[b_rep]=a_rep;
rank[a_rep]++;
}
}
}
public static HashMap<Integer,Integer> primeFact(int a)
{
// HashSet<Long> arr=new HashSet<>();
HashMap<Integer,Integer> hm=new HashMap<>();
int p=0;
while(a%2==0){
// arr.add(2L);
p++;
a=a/2;
}
hm.put(2,hm.getOrDefault(2,0)+p);
for(int i=3;i*i<=a;i+=2){
p=0;
while(a%i==0){
// arr.add(i);
p++;
a=a/i;
}
hm.put(i,hm.getOrDefault(i,0)+p);
}
if(a>2){
// arr.add(a);
hm.put(a,hm.getOrDefault(a,0)+1);
}
// return arr;
return hm;
}
public static boolean isInteger(double N)
{
int X = (int)N;
double temp2 = N - X;
if (temp2 > 0)
{
return false;
}
return true;
}
public static boolean isPalindrome(String s)
{
int n=s.length();
for(int i=0;i<=n/2;i++){
if(s.charAt(i)!=s.charAt(n-i-1)){
return false;
}
}
return true;
}
public static int gcd(int a,int b)
{
if(b==0)
return a;
else
return gcd(b,a%b);
}
public static long gcd(long a,long b)
{
if(b==0)
return a;
else
return gcd(b,a%b);
}
public static long fact(long n)
{
long fact=1;
for(long i=2;i<=n;i++){
fact=((fact%mod)*(i%mod))%mod;
}
return fact;
}
public static long fact(int n)
{
long fact=1;
for(int i=2;i<=n;i++){
fact=((fact%mod)*(i%mod))%mod;
}
return fact;
}
public static boolean isPrime(int n)
{
if (n <= 1)
return false;
if (n <= 3)
return true;
if (n % 2 == 0 || n % 3 == 0)
return false;
double sq=Math.sqrt(n);
for (int i = 5; i <= sq; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0)
return false;
return true;
}
public static boolean isPrime(long n)
{
if (n <= 1)
return false;
if (n <= 3)
return true;
if (n % 2 == 0 || n % 3 == 0)
return false;
double sq=Math.sqrt(n);
for (int i = 5; i <= sq; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0)
return false;
return true;
}
public static void printArray(long a[])
{
for(int i=0;i<a.length;i++){
out.print(a[i]+" ");
}
out.println();
}
public static void printArray(int a[])
{
for(int i=0;i<a.length;i++){
out.print(a[i]+" ");
}
out.println();
}
public static void printArray(char a[])
{
for(int i=0;i<a.length;i++){
out.print(a[i]);
}
out.println();
}
public static void printArray(String a[])
{
for(int i=0;i<a.length;i++){
out.print(a[i]+" ");
}
out.println();
}
public static void printArray(boolean a[])
{
for(int i=0;i<a.length;i++){
out.print(a[i]+" ");
}
out.println();
}
public static void printArray(pair a[])
{
for(pair p:a){
out.println(p.a+"->"+p.b);
}
}
public static void printArray(int a[][])
{
for(int i=0;i<a.length;i++){
for(int j=0;j<a[i].length;j++){
out.print(a[i][j]+" ");
}out.println();
}
}
public static void printArray(long a[][])
{
for(int i=0;i<a.length;i++){
for(int j=0;j<a[i].length;j++){
out.print(a[i][j]+" ");
}out.println();
}
}
public static void printArray(char a[][])
{
for(int i=0;i<a.length;i++){
for(int j=0;j<a[i].length;j++){
out.print(a[i][j]+" ");
}out.println();
}
}
public static void printArray(ArrayList<?> arr)
{
for(int i=0;i<arr.size();i++){
out.print(arr.get(i)+" ");
}
out.println();
}
public static void printMapI(HashMap<?,?> hm){
for(Map.Entry<?,?> e:hm.entrySet()){
out.println(e.getKey()+"->"+e.getValue());
}out.println();
}
public static void printMap(HashMap<Long,ArrayList<Integer>> hm){
for(Map.Entry<Long,ArrayList<Integer>> e:hm.entrySet()){
out.print(e.getKey()+"->");
ArrayList<Integer> arr=e.getValue();
for(int i=0;i<arr.size();i++){
out.print(arr.get(i)+" ");
}out.println();
}
}
//Modular Arithmetic
public static long add(long a,long b)
{
a+=b;
if(a>=mod)a-=mod;
return a;
}
public static long sub(long a,long b)
{
a-=b;
if(a<0)a+=mod;
return a;
}
public static long mul(long a,long b)
{
return ((a%mod)*(b%mod))%mod;
}
public static long divide(long a,long b,long m)
{
a=mul(a,modInverse(b,m));
return a;
}
public static long modInverse(long a,long m)
{
int x=0,y=0;
own p=new own(x,y);
long g=gcdExt(a,m,p);
if(g!=1){
out.println("inverse does not exists");
return -1;
}else{
long res=((p.a%m)+m)%m;
return res;
}
}
public static long gcdExt(long a,long b,own p)
{
if(b==0){
p.a=1;
p.b=0;
return a;
}
int x1=0,y1=0;
own p1=new own(x1,y1);
long gcd=gcdExt(b,a%b,p1);
p.b=p1.a - (a/b) * p1.b;
p.a=p1.b;
return gcd;
}
public static long pwr(long m,long n)
{
long res=1;
if(m==0)
return 0;
while(n>0)
{
if((n&1)!=0)
{
res=(res*m);
}
n=n>>1;
m=(m*m);
}
return res;
}
public static long modpwr(long m,long n)
{
long res=1;
m=m%mod;
if(m==0)
return 0;
while(n>0)
{
if((n&1)!=0)
{
res=(res*m)%mod;
}
n=n>>1;
m=(m*m)%mod;
}
return res;
}
public static class own
{
long a;
long b;
public own(long val,long index)
{
a=val;
b=index;
}
}
//Modular Airthmetic
public static void sort(int[] A)
{
int n = A.length;
Random rnd = new Random();
for(int i=0; i<n; ++i)
{
int tmp = A[i];
int randomPos = i + rnd.nextInt(n-i);
A[i] = A[randomPos];
A[randomPos] = tmp;
}
Arrays.sort(A);
}
public static void sort(char[] A)
{
int n = A.length;
Random rnd = new Random();
for(int i=0; i<n; ++i)
{
char tmp = A[i];
int randomPos = i + rnd.nextInt(n-i);
A[i] = A[randomPos];
A[randomPos] = tmp;
}
Arrays.sort(A);
}
public static void sort(long[] A)
{
int n = A.length;
Random rnd = new Random();
for(int i=0; i<n; ++i)
{
long tmp = A[i];
int randomPos = i + rnd.nextInt(n-i);
A[i] = A[randomPos];
A[randomPos] = tmp;
}
Arrays.sort(A);
}
//max & min
public static int max(int a,int b){return Math.max(a,b);}
public static int min(int a,int b){return Math.min(a,b);}
public static int max(int a,int b,int c){return Math.max(a,Math.max(b,c));}
public static int min(int a,int b,int c){return Math.min(a,Math.min(b,c));}
public static long max(long a,long b){return Math.max(a,b);}
public static long min(long a,long b){return Math.min(a,b);}
public static long max(long a,long b,long c){return Math.max(a,Math.max(b,c));}
public static long min(long a,long b,long c){return Math.min(a,Math.min(b,c));}
public static int maxinA(int a[]){int n=a.length;int mx=a[0];for(int i=1;i<n;i++){mx=max(mx,a[i]);}return mx;}
public static long maxinA(long a[]){int n=a.length;long mx=a[0];for(int i=1;i<n;i++){mx=max(mx,a[i]);}return mx;}
public static int mininA(int a[]){int n=a.length;int mn=a[0];for(int i=1;i<n;i++){mn=min(mn,a[i]);}return mn;}
public static long mininA(long a[]){int n=a.length;long mn=a[0];for(int i=1;i<n;i++){mn=min(mn,a[i]);}return mn;}
public static long suminA(int a[]){int n=a.length;long sum=0;for(int i=0;i<n;i++){sum+=a[i];}return sum;}
public static long suminA(long a[]){int n=a.length;long sum=0;for(int i=0;i<n;i++){sum+=a[i];}return sum;}
//end
public static int[] I(int n){int a[]=new int[n];for(int i=0;i<n;i++){a[i]=I();}return a;}
public static long[] IL(int n){long a[]=new long[n];for(int i=0;i<n;i++){a[i]=L();}return a;}
public static long[] prefix(int a[]){int n=a.length;long pre[]=new long[n];pre[0]=a[0];for(int i=1;i<n;i++){pre[i]=pre[i-1]+a[i];}return pre;}
public static long[] prefix(long a[]){int n=a.length;long pre[]=new long[n];pre[0]=a[0];for(int i=1;i<n;i++){pre[i]=pre[i-1]+a[i];}return pre;}
public static int I(){return sc.I();}
public static long L(){return sc.L();}
public static String S(){return sc.S();}
public static double D(){return sc.D();}
}
class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader(){
br = new BufferedReader(new InputStreamReader(System.in));
}
String next(){
while (st == null || !st.hasMoreElements()){
try {
st = new StringTokenizer(br.readLine());
}
catch (IOException e){
e.printStackTrace();
}
}
return st.nextToken();
}
int I(){ return Integer.parseInt(next());}
long L(){ return Long.parseLong(next());}
double D(){return Double.parseDouble(next());}
String S(){
String str = "";
try {
str = br.readLine();
}
catch (IOException e){
e.printStackTrace();
}
return str;
}
}
| Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | b2430e42ad4fc12e2b708810663bd9be | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes | import java.util.*;
import java.io.*;
// cd C:\Users\Lenovo\Desktop\New
//ArrayList<Integer> a=new ArrayList<>();
//List<Integer> lis=new ArrayList<>();
//StringBuilder ans = new StringBuilder();
//HashMap<Integer,Integer> map=new HashMap<>();
public class cf {
static FastReader in=new FastReader();
static final Random random=new Random();
static int mod=1000000007;
//static long dp[]=new long[200002];
static int dp[][];
static int d;
static int res;
public static void main(String args[]) throws IOException {
FastReader sc=new FastReader();
//Scanner s=new Scanner(System.in);
int tt=sc.nextInt();
//int tt=1;
while(tt-->0){
int n=sc.nextInt();
String s=sc.next();
int ans=0;
int len=0;
boolean check=true;
for(int i=0;i<n;i++){
if(s.charAt(i)=='(' && check){
for(int j=i+1;j<n;j++){
if(s.charAt(j)==')'){
ans++;
len=j;
i=j;
break;
}
else{
ans++;
len=j;
i=j;
break;
}
}
}
else if(s.charAt(i)==')' && check){
for(int j=i+1;j<n;j++){
if(s.charAt(j)==')'){
ans++;
len=j;
i=j;
break;
}
if(j==n-1){
check=false;
}
}
}
}
if(len==0){
System.out.println(ans+" "+(n));
}
else{
System.out.println(ans+" "+(n-len-1));
}
}
}
static boolean prime(int n){
for(int i=2;i<=Math.sqrt(n);i++){
if(n%i==0){
return false;
}
}
return true;
}
static void factorial(int n){
long ret = 1;
while(n > 0){
ret = ret * n % mod;
n--;
}
System.out.println(ret);
}
static long find_min(int a,int arr[]){
long ans=Integer.MAX_VALUE;
for(int i=0;i<arr.length;i++){
if(Math.abs(a-arr[i])<ans){
ans=Math.abs(a-arr[i]);
}
}
return ans;
}
static long find(ArrayList<Long> arr,long n){
int l=0;
int r=arr.size();
while(l+1<r){
int mid=(l+r)/2;
if(arr.get(mid)<n){
l=mid;
}
else{
r=mid;
}
}
return arr.get(l);
}
static void factorial(long []fact){
for(int i=2;i<14;i++){
fact[i]=1l*(i+1)*fact[i-1];
}
}
static void rotate(int ans[]){
int last=ans[0];
for(int i=0;i<ans.length-1;i++){
ans[i]=ans[i+1];
}
ans[ans.length-1]=last;
}
static int reduce(int n){
while(n>1){
if(n%2==1){
n--;
n=n/2;
}
else{
if(n%4==0){
n=n/4;
}
else{
break;
}
}
}
return n;
}
static long count(long n,int p,HashSet<Long> set){
if(n<Math.pow(2,p)){
set.add(n);
return count(2*n+1,p,set)+count(4*n,p,set)+1;
}
return 0;
}
static int countprimefactors(int n){
int ans=0;
int z=(int)Math.sqrt(n);
for(int i=2;i<=z;i++){
while(n%i==0){
ans++;
n=n/i;
}
}
if(n>1){
ans++;
}
return ans;
}
/*static int count(int arr[],int idx,long sum,int []dp){
if(idx>=arr.length){
return 0;
}
if(dp[idx]!=-1){
return dp[idx];
}
if(arr[idx]<0){
return dp[idx]=Math.max(1+count(arr,idx+1,sum+arr[idx],dp),count(arr,idx+1,sum,dp));
}
else{
return dp[idx]=1+count(arr,idx+1,sum+arr[idx],dp);
}
}*/
static String reverse(String s){
String ans="";
for(int i=s.length()-1;i>=0;i--){
ans+=s.charAt(i);
}
return ans;
}
static int find_max(int []check,int y){
int max=0;
for(int i=y;i>=0;i--){
if(check[i]!=0){
max=i;
break;
}
}
return max;
}
static int msb(int x){
int ans=0;
while(x!=0){
x=x/2;
ans++;
}
return ans;
}
static void ruffleSort(int[] a) {
int n=a.length;
for (int i=0; i<n; i++) {
int oi=random.nextInt(n), temp=a[oi];
a[oi]=a[i]; a[i]=temp;
}
Arrays.sort(a);
}
static int gcd(int a,int b)
{
if(b==0)
{
return a;
}
return gcd(b,a%b);
}
/* static boolean checkprime(int n1)
{
if(n1%2==0||n1%3==0)
return false;
else
{
for(int i=5;i*i<=n1;i+=6)
{
if(n1%i==0||n1%(i+2)==0)
return false;
}
return true;
}
}
*/
/* Iterator<Map.Entry<Integer, Integer>> iterator = map.entrySet().iterator();
while(iterator.hasNext()){
Map.Entry<Integer, Integer> entry = iterator.next();
int value = entry.getValue();
if(value==1){
iterator.remove();
}
else{
entry.setValue(value-1);
}
}
*/
static class Pair implements Comparable
{
int a,b;
public String toString()
{
return a+" " + b;
}
public Pair(int x , int y)
{
a=x;b=y;
}
@Override
public int compareTo(Object o) {
Pair p = (Pair)o;
if((Math.abs(a)+Math.abs(b))!=(Math.abs(p.a)+Math.abs(p.b))){
return ((Math.abs(a)+Math.abs(b))-(Math.abs(p.a)+Math.abs(p.b)));
}
else{
return a-p.a;
}
/*if(p.a!=a){
return a-p.a;//in
}
else{
return b-p.b;//
}*/
}
}
/* public static boolean checkAP(List<Integer> lis){
for(int i=1;i<lis.size()-1;i++){
if(2*lis.get(i)!=lis.get(i-1)+lis.get(i+1)){
return false;
}
}
return true;
}
public static int minBS(int[]arr,int val){
int l=-1;
int r=arr.length;
while(r>l+1){
int mid=(l+r)/2;
if(arr[mid]>=val){
r=mid;
}
else{
l=mid;
}
}
return r;
}
public static int maxBS(int[]arr,int val){
int l=-1;
int r=arr.length;
while(r>l+1){
int mid=(l+r)/2;
if(arr[mid]<=val){
l=mid;
}
else{
r=mid;
}
}
return l;
}
static int lcm(int a, int b)
{
return (a / gcd(a, b)) * b;
}*/
static class FastReader
{
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br = new BufferedReader(new
InputStreamReader(System.in));
}
String next()
{
while (st == null || !st.hasMoreElements())
{
try
{
st = new StringTokenizer(br.readLine());
}
catch (IOException e)
{
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt()
{
return Integer.parseInt(next());
}
long nextLong()
{
return Long.parseLong(next());
}
double nextDouble()
{
return Double.parseDouble(next());
}
String nextLine()
{
String str = "";
try
{
str = br.readLine();
}
catch (IOException e)
{
e.printStackTrace();
}
return str;
}
}
} | Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | 169170cf73e0ac0ab55b0885a8438729 | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
public class test {
public static void main(String[] args) throws NumberFormatException, IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
PrintWriter pw = new PrintWriter(System.out);
int t = Integer.parseInt(br.readLine());
while (t-- > 0) {
int n = Integer.parseInt(br.readLine());
String s = br.readLine();
pw.println(solve(s, n));
}
pw.flush();
pw.close();
br.close();
}
public static String solve(String s, int n) {
int count = 0;
int l = 0;
int r = 1;
while (r < n) {
if (s.charAt(l) == '(' && s.charAt(r) == ')') {
l = r + 1;
r = r + 2;
count++;
} else {
if (s.charAt(l) == s.charAt(r)) {
StringBuilder st = new StringBuilder(s.substring(l, r + 1));
if (st.toString().equals(st.reverse().toString())) {
l = r + 1;
r = r + 2;
count++;
} else {
r++;
}
} else {
r++;
}
}
}
r = Math.min(r, n);
l = Math.min(l, n);
return count + " " + (r - l);
}
} | Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | 44f2bed28c4c35cd621c356da6c1e5ac | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes |
import java.util.*;
import java.io.*;
import java.io.*;
import java.util.*;
import java.math.*;
import static java.lang.Math.sqrt;
import static java.lang.Math.floor;
public class run_code {
static class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode() {}
TreeNode(int val) { this.val = val; }
TreeNode(int val, TreeNode left, TreeNode right) {
this.val = val;
this.left = left;
this.right = right;
}
public static int max(int []nums, int s, int e) {
int max = Integer.MIN_VALUE;
for(int i = s; i <= e; i++) {
max = Math.max(max, nums[i]);
}
return max;
}
static int depth(TreeNode root) {
if(root == null)return 0;
int a = 1+ depth(root.left);
int b = 1+ depth(root.right);
return Math.max(a,b);
}
static HashSet<Integer>set = new HashSet<>();
static void deepestLeaves(TreeNode root, int cur_depth, int depth) {
if(root == null)return;
if(cur_depth == depth)set.add(root.val);
deepestLeaves(root.left,cur_depth+1,depth);
deepestLeaves(root.right,cur_depth+1,depth);
}
public static void print(TreeNode root) {
if(root == null)return;
System.out.print(root.val+" ");
System.out.println("er");
print(root.left);
print(root.right);
}
public static HashSet<Integer>original(TreeNode root){
int d = depth(root);
deepestLeaves(root,0,d);
return set;
}
static HashSet<Integer>set1 = new HashSet<>();
static void leaves(TreeNode root) {
if(root == null)return;
if(root.left == null && root.right == null)set1.add(root.val);
leaves(root.left);
leaves(root.right);
}
public static boolean check(HashSet<Integer>s, HashSet<Integer>s1) {
if(s.size() != s1.size())return false;
for(int a : s) {
if(!s1.contains(a))return false;
}
return true;
}
static TreeNode subTree;
public static void smallest_subTree(TreeNode root) {
if(root == null)return;
smallest_subTree(root.left);
smallest_subTree(root.right);
set1 = new HashSet<>();
leaves(root);
boolean smallest = check(set,set1);
if(smallest) {
subTree = root;
return;
}
}
public static TreeNode answer(TreeNode root) {
smallest_subTree(root);
return subTree;
}
}
static class Key<K1, K2>
{
public K1 key1;
public K2 key2;
public Key(K1 key1, K2 key2)
{
this.key1 = key1;
this.key2 = key2;
}
@Override
public boolean equals(Object o)
{
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
Key key = (Key) o;
if (key1 != null ? !key1.equals(key.key1) : key.key1 != null) {
return false;
}
if (key2 != null ? !key2.equals(key.key2) : key.key2 != null) {
return false;
}
return true;
}
@Override
public int hashCode()
{
int result = key1 != null ? key1.hashCode() : 0;
result = 31 * result + (key2 != null ? key2.hashCode() : 0);
return result;
}
@Override
public String toString() {
return "[" + key1 + ", " + key2 + "]";
}
}
public static int sumOfDigits (long n) {
int sum = 0;
while(n > 0) {
sum += n%10;
n /= 10;
}
return sum;
}
public static void swap(int []ar, int i, int j) {
for(int k= j; k >= i; k--) {
int temp = ar[k];
ar[k] = ar[k+1];
ar[k+1] = temp;
}
}
public static int findOr(int[]bits){
int or=0;
for(int i=0;i<32;i++){
or=or<<1;
if(bits[i]>0)
or=or+1;
}
return or;
}
public static boolean[] getSieve(int n) {
boolean[] isPrime = new boolean[n+1];
for (int i = 2; i <= n; i++) isPrime[i] = true;
for (int i = 2; i*i <= n; i++) if (isPrime[i])
for (int j = i; i*j <= n; j++) isPrime[i*j] = false;
return isPrime;
}
public static long gcd(long a, long b)
{
if (a == 0)
return b;
return gcd(b%a, a);
}
static long nextPrime(long n) {
boolean found = false;
long prime = n;
while(!found) {
prime++;
if(isPrime(prime))
found = true;
}
return prime;
}
// method to return LCM of two numbers
static long lcm(long a, long b)
{
return (a / gcd(a, b)) * b;
}
static boolean isPrime(long n) {
if(n <= 1)return false;
if(n <= 3)return true;
if(n%2 == 0 || n%3 == 0)return false;
for(int i = 5; i*i <= n; i+= 6) {
if(n%i == 0 || n%(i+2) == 0)
return false;
}
return true;
}
static int countGreater(int arr[], int n, int k){
int l = 0;
int r = n - 1;
// Stores the index of the left most element
// from the array which is greater than k
int leftGreater = n;
// Finds number of elements greater than k
while (l <= r) {
int m = l + (r - l) / 2;
// If mid element is greater than
// k update leftGreater and r
if (arr[m] > k) {
leftGreater = m;
r = m - 1;
}
// If mid element is less than
// or equal to k update l
else
l = m + 1;
}
// Return the count of elements greater than k
return (n - leftGreater);
}
static ArrayList<Integer>printDivisors(int n){
ArrayList<Integer>list = new ArrayList<>();
for (int i=1; i<=Math.sqrt(n); i++)
{
if (n%i==0)
{
// If divisors are equal, print only one
if (n/i == i)
list.add(i);
else // Otherwise print both
list.add(i);
list.add(n/i);
}
}
return list;
}
static void leftRotate(int l, int r,int arr[], int d)
{
for (int i = 0; i < d; i++)
leftRotatebyOne(l,r,arr);
}
static void leftRotatebyOne(int l, int r,int arr[])
{
int i, temp;
temp = arr[l];
for (i = l; i < r; i++)
arr[i] = arr[i + 1];
arr[r] = temp;
}
static class pairInPq<F extends Comparable<F>, S extends Comparable<S>>
implements Comparable<pairInPq<F, S>> {
private F first;
private S second;
public pairInPq(F first, S second){
this.first = first;
this.second = second;
}
public F getFirst(){return first;}
public S getSecond(){return second;}
// All the code you already have is fine
@Override
public int compareTo(pairInPq<F, S> o) {
int retVal = getFirst().compareTo(o.getFirst());
if (retVal != 0) {
return retVal;
}
return getSecond().compareTo(o.getSecond());
}
}
static long modInverse(long a, long m)
{
long m0 = m;
long y = 0, x = 1;
if (m == 1)
return 0;
while (a > 1) {
// q is quotient
long q = a / m;
long t = m;
// m is remainder now, process
// same as Euclid's algo
m = a % m;
a = t;
t = y;
// Update x and y
y = x - q * y;
x = t;
}
// Make x positive
if (x < 0)
x += m0;
return x;
}
static long power(long x, long y, long p)
{
long res = 1; // Initialize result
x = x % p; // Update x if it is more than or
// equal to p
if (x == 0)
return 0; // In case x is divisible by p;
while (y > 0)
{
// If y is odd, multiply x with result
if ((y & 1) != 0)
res = (res * x) % p;
// y must be even now
y = y >> 1; // y = y/2
x = (x * x) % p;
}
return res;
}
static TreeNode buildTree(TreeNode root,int []ar, int l, int r){
if(l > r)return null;
int len = l+r;
if(len%2 != 0)len++;
int mid = (len)/2;
int v = ar[mid];
TreeNode temp = new TreeNode(v);
root = temp;
root.left = buildTree(root.left,ar,l,mid-1);
root.right = buildTree(root.right,ar,mid+1,r);
return root;
}
public static int getClosest(int val1, int val2, int target) {
if (target - val1 >= val2 - target)
return val2;
else
return val1;
}
public static int findClosest(int start, int end, int arr[], int target)
{
int n = arr.length;
// Corner cases
if (target <= arr[start])
return arr[start];
if (target >= arr[end])
return arr[end];
// Doing binary search
int i = start, j = end+1, mid = 0;
while (i < j) {
mid = (i + j) / 2;
if (arr[mid] == target)
return arr[mid];
/* If target is less than array element,
then search in left */
if (target < arr[mid]) {
// If target is greater than previous
// to mid, return closest of two
if (mid > 0 && target > arr[mid - 1])
return getClosest(arr[mid - 1],
arr[mid], target);
/* Repeat for left half */
j = mid;
}
// If target is greater than mid
else {
if (mid < n-1 && target < arr[mid + 1])
return getClosest(arr[mid],
arr[mid + 1], target);
i = mid + 1; // update i
}
}
// Only single element left after search
return arr[mid];
}
static int LIS(int arr[], int n)
{
int lis[] = new int[n];
int i, j, max = 0;
/* Initialize LIS values for all indexes */
for (i = 0; i < n; i++)
lis[i] = 1;
/* Compute optimized LIS values in
bottom up manner */
for (i = 1; i < n; i++)
for (j = 0; j < i; j++)
if (arr[i] >= arr[j] && lis[i] < lis[j] + 1)
lis[i] = lis[j] + 1;
/* Pick maximum of all LIS values */
for (i = 0; i < n; i++)
if (max < lis[i])
max = lis[i];
return max;
}
static void permuteString(String s , String answer)
{
if (s.length() == 0)
{
System.out.print(answer + " ");
return;
}
for(int i = 0 ;i < s.length(); i++)
{
char ch = s.charAt(i);
String left_substr = s.substring(0, i);
String right_substr = s.substring(i + 1);
String rest = left_substr + right_substr;
permuteString(rest, answer + ch);
}
}
static boolean isPowerOfTwo(long n)
{
if(n==0)
return false;
return (int)(Math.ceil((Math.log(n) / Math.log(2)))) ==
(int)(Math.floor(((Math.log(n) / Math.log(2)))));
}
static class Pair {
int x;
int y;
// Constructor
public Pair(int x, int y)
{
this.x = x;
this.y = y;
}
}
static class Sorting implements Comparator<Pair>{
public int compare(Pair p1, Pair p2){
if(p1.x==p2.x){
return p1.y-p2.y;
}
return p1.x - p2.x;
}
}
static class Compare1{
static void compare(Pair arr[], int n)
{
// Comparator to sort the pair according to second element
Arrays.sort(arr, new Comparator<Pair>() {
@Override public int compare(Pair p1, Pair p2)
{
return p1.x - p2.x;
}
});
}
}
static int min;
static int max;
static LinkedList<Integer>[]adj;
static int n;
static void insertlist(int n) {
for(int i = 0; i <= n; i++) {
adj[i] = new LinkedList<>();
}
}
static int []ar;
static boolean []vis;
static HashMap<Key,Integer>map;
static ArrayList<Integer>list;
static int dfs(int parent, int child,LinkedList<Integer>[]adj) {
list.add(parent);
for(int a : adj[parent]) {
if(vis[a] == false) {
vis[a] = true;
return 1+dfs(a,parent,adj);
}
}
return 0;
}
static StringTokenizer st;
static BufferedReader ob;
static int [] readarrayInt( int n)throws IOException {
st = new StringTokenizer(ob.readLine());
int []ar = new int[n];
for(int i = 0; i < n; i++) {
ar[i] = Integer.parseInt(st.nextToken());
}
return ar;
}
static long [] readarrayLong( int n)throws IOException {
st = new StringTokenizer(ob.readLine());
long []ar = new long[n];
for(int i = 0; i < n; i++) {
ar[i] = Long.parseLong(st.nextToken());
}
return ar;
}
static int readInt()throws IOException {
return Integer.parseInt(ob.readLine());
}
static long readLong()throws IOException {
return Long.parseLong(ob.readLine());
}
static int nextTokenInt() {
return Integer.parseInt(st.nextToken());
}
static long nextTokenLong() {
return Long.parseLong(st.nextToken());
}
static int root(int u) {
if(ar[u] == -1)return -1;
if(u == ar[u]) {
return u;
}
return root(ar[u]);
}
static Pair []pairar;
static void addEdges(int m)throws IOException {
for(int i = 0; i < m; i++) {
st = new StringTokenizer(ob.readLine());
int u = nextTokenInt();
int v = nextTokenInt();
pairar[i] = new Pair(u,v);
adj[u].add(v);
adj[v].add(u);
}
}
static int numberOfDiv(long num) {
int c = 0;
for(int i = 1; i <= Math.sqrt(num ); i++) {
if(num%i == 0) {
long d = num/i;
if( d == i)c++; else c += 2;
}
}
return c;
}
static long ans;
static int count;
static boolean []computed;
static void NoOfWays(int n) {
if(n == 0 ) {
count++;
}
if(n <= 0)return;
for(int i = 1; i <= n; i++) {
if(n+i <= n)
NoOfWays(n-i);
}
}
static boolean binarylistsearch( List<Integer>list, int l, int r, int s, int e) {
if(s > e)return false;
int mid = (s+e)/2;
if(list.get(mid) >= l && list.get(mid) < r) {
return true;
}else if(list.get(mid) > r) {
return binarylistsearch(list,l,r,s,mid-1);
}else if(list.get(mid) < l) {
return binarylistsearch(list,l,r,mid+1,e);
}
return false;
}
static int [][] readmatrix(int r, int c)throws IOException{
int [][]mat = new int[r][c];
for(int i = 0; i < r; i++) {
st = new StringTokenizer(ob.readLine());
for(int j = 0; j < c; j++) {
mat[i][j] = nextTokenInt();
}
}
return mat;
}
static HashSet<Integer>set1;
static boolean possible;
static int c = 0;
static void isbeautiful(HashSet<Integer>s,int num, List<Integer>good, int i, int x, int count) {
if(c == 2) {
possible = true;
return;
}
if(num >x || i == good.size())return;
if(num > x)return;
if(i >= good.size())return;
for(int j = i; j < good.size(); j++) {
if(!map.containsKey(new Key(num,good.get(j))) &&
!map.containsKey(new Key(good.get(j),num))){
if(s.contains(num) && s.contains(good.get(j)))
map.put(new Key (num,good.get(j)),1);
isbeautiful(s,num*good.get(j),good,i,x,count);
}
}
}
static long sum;
static long mod;
static void recur(HashSet<Integer>set,HashMap<Integer,HashSet<Integer>>map, int n, int j) {
if(j > n)return;
int v = 0;
for(int a : set) {
if(map.get(j).contains(a)) {
v++;
}
}
long d = map.get(j).size()-v;
sum = (sum*d)%mod;
HashSet<Integer> temp = map.get(j);
for(int num : temp) {
if(!set.contains(num)) {
set.add(num);
recur(set,map,n,j+1);
set.remove(num);
}
}
}
static int key1;
static int key2;
static HashSet<Integer>set;
public static TreeNode lowestCommonAncestor(TreeNode root) {
if(root == null)return null;
TreeNode left = lowestCommonAncestor(root.left);
TreeNode right =lowestCommonAncestor(root.right);
if(left == null && right != null) {
System.out.println(right.val);
return right;
}else if(right == null && left != null) {
System.out.println(left.val);
return left;
}else if(left == null && right == null) {
return null;
}else {
System.out.println(root.val);
return root;
}
}
static int res;
static boolean poss = false;
public static void recur1 (char []ar, int i) {
if(i >= ar.length) {
boolean isPalindrome = false;
for(int k = 0; k < ar.length; k++) {
for(int j = 0; j < ar.length; j++) {
if(j-k+1 >= 5) {
int x = k;
int y = j;
while(x < y && ar[x] == ar[y]) {
x++;
y--;
}
if(x == y || x > y) {
isPalindrome = true;
}
}
}
}
if(!isPalindrome) {
poss = true;
}
}
if(i < ar.length && ar[i] == '?' ) {
ar[i] = '0';
recur1(ar,i+1);
ar[i] = '?';
}
if(i < ar.length && ar[i] == '?') {
ar[i] = '1';
recur1(ar,i+1);
ar[i] = '?';
}
if(i < ar.length && ar[i] != '?') {
recur1(ar,i+1);
}
}
static int []theArray;
static int [] dfs(int parent, int child) {
for(int i : adj[child]) {
if(vis[i] && i != parent) {
int []ar = {i,parent};
System.out.println(i+" "+child);
theArray = ar;
}
if(!vis[i] && i != parent) {
vis[i] = true;
return dfs(child,i);
}
}
return new int[2];
}
static int rotate(int []ar, int element, int i) {
int count = 0;
while(ar[i] != element) {
int last = ar[i];
count++;
int prev = ar[1];
for(int j = 2; j <= i; j++) {
int temp = ar[j];
ar[j] = prev;
prev = temp;
}
ar[1] = prev;
}
return count;
}
public static void main(String args[])throws IOException {
ob = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
int t = Integer.parseInt(ob.readLine());
while(t --> 0){
int n = Integer.parseInt(ob.readLine());
String s = ob.readLine();
Queue<Integer>que = new LinkedList<>();
for(int i = 0; i < s.length(); i++) {
if(s.charAt(i) == '(') {
que.add(1);
}else {
que.add(0);
}
}
int op = 0;
int rem = -1;
while(que.size() > 1) {
int size = que.size();
int a = que.poll();
int b = que.poll();
if(a == 0 && b == 0) {
op++;
}else if(a == 1 && b == 0) {
op++;
}else if(a == 1 && b == 1) {
op++;
}else {
while(que.size() > 0 && que.peek() == 1) {
que.poll();
}
if(que.size() == 0) {
rem = size;
break;
}else
que.poll();
op++;
}
}
if(rem == -1) {
System.out.println(op+" "+que.size());
}else {
System.out.println(op+" "+rem);
}
}
}
}
| Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | 446a7f8b3e7bdd9388b47b27340ae35d | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes | //package Codeforces;
import java.io.*;
import java.util.*;
public class C {
public static void main (String[] Z) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringBuilder op = new StringBuilder();
StringTokenizer stz;
int T = Integer.parseInt(br.readLine());
while(T-- > 0) {
int n = Integer.parseInt(br.readLine());
char[] s = br.readLine().toCharArray();
String str = String.valueOf(s);
int ops = 0;
int done = 0;
for (int i = 0 ; i < n - 1; ) {
if(s[i] == s[i+1]) {
++ops;
done += 2;
i += 2;
}
else {
if (s[i] == '(' && s[i+1] == ')') {
++ops;
done += 2;
i += 2;
} else {
int next = str.indexOf(')', i+1);
if (next == -1) {
break;
} else {
++ops;
done += (next - i + 1);
i = next + 1;
}
}
}
}
op.append(ops + " ");
op.append(n - done);
op.append("\n");
}
System.out.println(op);
// END OF CODE
}
}
| Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | 0e29886ef4d4e3fc583aa3f5ae44a6a5 | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes | import java.util.*;
import java.io.*;
public class Main {
static long startTime = System.currentTimeMillis();
// for global initializations and methods starts here
// global initialisations and methods end here
static void run() {
boolean tc = true;
//AdityaFastIO r = new AdityaFastIO();
FastReader r = new FastReader();
try (OutputStream out = new BufferedOutputStream(System.out)) {
//long startTime = System.currentTimeMillis();
int testcases = tc ? r.ni() : 1;
int tcCounter = 1;
// Hold Here Sparky------------------->>>
// Solution Starts Here
start:
while (testcases-- > 0) {
int n = r.ni();
char[] s = r.word().toCharArray();
int i = 0;
int j = 0;
int res = 0;
boolean ff = false;
do {
if (i >= n) break;
if (ff) {
if (s[i] != ')') {
} else {
res++;
ff = false;
j = i + 1;
}
} else {
if (s[i] != '(' || i + 1 >= n) {
ff = true;
} else {
res++;
i++;
j = i + 1;
}
}
i++;
} while (true);
out.write((res + " ").getBytes());
out.write((n - j + " ").getBytes());
out.write(("\n").getBytes());
}
// Solution Ends Here
} catch (IOException e) {
e.printStackTrace();
}
}
static class AdityaFastIO {
final private int BUFFER_SIZE = 1 << 16;
private final DataInputStream din;
private final byte[] buffer;
private int bufferPointer, bytesRead;
public BufferedReader br;
public StringTokenizer st;
public AdityaFastIO() {
br = new BufferedReader(new InputStreamReader(System.in));
din = new DataInputStream(System.in);
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public AdityaFastIO(String file_name) throws IOException {
din = new DataInputStream(new FileInputStream(file_name));
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public String word() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
public String line() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
public String readLine() throws IOException {
byte[] buf = new byte[100000001]; // line length
int cnt = 0, c;
while ((c = read()) != -1) {
if (c == '\n') break;
buf[cnt++] = (byte) c;
}
return new String(buf, 0, cnt);
}
public int ni() throws IOException {
int ret = 0;
byte c = read();
while (c <= ' ') c = read();
boolean neg = (c == '-');
if (neg) c = read();
do {
ret = ret * 10 + c - '0';
}
while ((c = read()) >= '0' && c <= '9');
if (neg) return -ret;
return ret;
}
public long nl() throws IOException {
long ret = 0;
byte c = read();
while (c <= ' ') c = read();
boolean neg = (c == '-');
if (neg) c = read();
do {
ret = ret * 10 + c - '0';
}
while ((c = read()) >= '0' && c <= '9');
if (neg) return -ret;
return ret;
}
public double nd() throws IOException {
double ret = 0, div = 1;
byte c = read();
while (c <= ' ') c = read();
boolean neg = (c == '-');
if (neg) c = read();
do {
ret = ret * 10 + c - '0';
}
while ((c = read()) >= '0' && c <= '9');
if (c == '.') while ((c = read()) >= '0' && c <= '9') ret += (c - '0') / (div *= 10);
if (neg) return -ret;
return ret;
}
private void fillBuffer() throws IOException {
bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
if (bytesRead == -1) buffer[0] = -1;
}
private byte read() throws IOException {
if (bufferPointer == bytesRead) fillBuffer();
return buffer[bufferPointer++];
}
public void close() throws IOException {
if (din == null) return;
din.close();
}
}
public static void main(String[] args) throws Exception {
run();
}
static int[] readIntArr(int n, AdityaFastIO r) throws IOException {
int[] arr = new int[n];
for (int i = 0; i < n; i++) arr[i] = r.ni();
return arr;
}
static long[] readLongArr(int n, AdityaFastIO r) throws IOException {
long[] arr = new long[n];
for (int i = 0; i < n; i++) arr[i] = r.nl();
return arr;
}
static List<Integer> readIntList(int n, AdityaFastIO r) throws IOException {
List<Integer> al = new ArrayList<>();
for (int i = 0; i < n; i++) al.add(r.ni());
return al;
}
static List<Long> readLongList(int n, AdityaFastIO r) throws IOException {
List<Long> al = new ArrayList<>();
for (int i = 0; i < n; i++) al.add(r.nl());
return al;
}
static long mod = 998244353;
static long modInv(long base, long e) {
long result = 1;
base %= mod;
while (e > 0) {
if ((e & 1) > 0) result = result * base % mod;
base = base * base % mod;
e >>= 1;
}
return result;
}
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String word() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
String line() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
int ni() {
return Integer.parseInt(word());
}
long nl() {
return Long.parseLong(word());
}
double nd() {
return Double.parseDouble(word());
}
}
static int MOD = (int) (1e9 + 7);
static long powerLL(long x, long n) {
long result = 1;
while (n > 0) {
if (n % 2 == 1) result = result * x % MOD;
n = n / 2;
x = x * x % MOD;
}
return result;
}
static long powerStrings(int i1, int i2) {
String sa = String.valueOf(i1);
String sb = String.valueOf(i2);
long a = 0, b = 0;
for (int i = 0; i < sa.length(); i++) a = (a * 10 + (sa.charAt(i) - '0')) % MOD;
for (int i = 0; i < sb.length(); i++) b = (b * 10 + (sb.charAt(i) - '0')) % (MOD - 1);
return powerLL(a, b);
}
static long gcd(long a, long b) {
if (a == 0) return b;
else return gcd(b % a, a);
}
static long lcm(long a, long b) {
return (a * b) / gcd(a, b);
}
static long lower_bound(int[] arr, int x) {
int l = -1, r = arr.length;
while (l + 1 < r) {
int m = (l + r) >>> 1;
if (arr[m] >= x) r = m;
else l = m;
}
return r;
}
static int upper_bound(int[] arr, int x) {
int l = -1, r = arr.length;
while (l + 1 < r) {
int m = (l + r) >>> 1;
if (arr[m] <= x) l = m;
else r = m;
}
return l + 1;
}
static void addEdge(ArrayList<ArrayList<Integer>> graph, int edge1, int edge2) {
graph.get(edge1).add(edge2);
graph.get(edge2).add(edge1);
}
public static class Pair implements Comparable<Pair> {
int first;
int second;
public Pair(int first, int second) {
this.first = first;
this.second = second;
}
public String toString() {
return "(" + first + "," + second + ")";
}
public int compareTo(Pair o) {
// TODO Auto-generated method stub
if (this.first != o.first)
return (int) (this.first - o.first);
else return (int) (this.second - o.second);
}
}
public static class PairC<X, Y> implements Comparable<PairC> {
X first;
Y second;
public PairC(X first, Y second) {
this.first = first;
this.second = second;
}
public String toString() {
return "(" + first + "," + second + ")";
}
public int compareTo(PairC o) {
// TODO Auto-generated method stub
return o.compareTo((PairC) first);
}
}
static boolean isCollectionsSorted(List<Long> list) {
if (list.size() == 0 || list.size() == 1) return true;
for (int i = 1; i < list.size(); i++) if (list.get(i) <= list.get(i - 1)) return false;
return true;
}
static boolean isCollectionsSortedReverseOrder(List<Long> list) {
if (list.size() == 0 || list.size() == 1) return true;
for (int i = 1; i < list.size(); i++) if (list.get(i) >= list.get(i - 1)) return false;
return true;
}
} | Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | 0b3c3988a0ba5ce6b8795a383aa11e5f | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes |
import java.io.*;
import java.util.*;
import java.lang.*;
import static java.lang.Math.*;
public class Codeforces {
static int MAX = Integer.MAX_VALUE,MIN = Integer.MIN_VALUE;
static long MAXL = Long.MAX_VALUE,MINL = Long.MIN_VALUE,MOD = (int)1e9+7;
static void solve() {
int n = fs.nInt();
String str = fs.next();
char[]s = str.toCharArray();
int ind = 0,operation = 0;
while (ind < n-1 ){
if( s[ind] == '('){
operation++;
ind += 2;
}else{
int j = ind+1;
boolean flag = false;
while ( j < n ){
if(s[j] == s[ind]){
if(isPermutation(str.substring(ind,min(j+1,n)))){
operation++;
ind = j+1;
flag = true;
break;
}
}
j++;
}
if(!flag){
break;
}
}
}
int charleft = n - ind;
out.println(operation+" "+charleft);
}
static boolean isPermutation(String s){
int len = s.length();
for(int i=0;i<len/2;i++){
if(s.charAt(i)!=s.charAt(len-i-1))
return false;
}
return true;
}
static class Triplet<T,U,V>{
T a;
U b;
V c;
Triplet(T a,U b,V c){
this.a = a;
this.b = b;
this.c = c;
}
}
static class Pair<A, B>{
A fst;
B snd;
Pair(A fst,B snd){
this.fst = fst;
this.snd = snd;
}
}
static boolean multipleTestCase = true;static FastScanner fs;static PrintWriter out;
public static void main(String[]args){
try{
out = new PrintWriter(System.out);
fs = new FastScanner();
int tc = multipleTestCase?fs.nInt():1;
while (tc-->0)solve();
out.flush();
out.close();
}catch (Exception e){
e.printStackTrace();
}
}
static class FastScanner extends PrintWriter {
private InputStream stream;
private byte[] buf = new byte[1<<16];
private int curChar, numChars;
public FastScanner() { this(System.in,System.out); }
public FastScanner(InputStream i, OutputStream o) {
super(o);
stream = i;
}
// file input
public FastScanner(String i, String o) throws IOException {
super(new FileWriter(o));
stream = new FileInputStream(i);
}
// throws InputMismatchException() if previously detected end of file
private int nextByte() {
if (numChars == -1) throw new InputMismatchException();
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars == -1) return -1; // end of file
}
return buf[curChar++];
}
// to read in entire lines, replace c <= ' '
// with a function that checks whether c is a line break
public String next() {
int c; do { c = nextByte(); } while (c <= ' ');
StringBuilder res = new StringBuilder();
do { res.appendCodePoint(c); c = nextByte(); } while (c > ' ');
return res.toString();
}
public int nInt() { // nextLong() would be implemented similarly
int c; do { c = nextByte(); } while (c <= ' ');
int sgn = 1; if (c == '-') { sgn = -1; c = nextByte(); }
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res = 10*res+c-'0';
c = nextByte();
} while (c > ' ');
return res * sgn;
}
public long nLong(){return Long.parseLong(next());}
public double nextDouble() { return Double.parseDouble(next()); }
}
public static void sort(int[] arr){
ArrayList<Integer> ls = new ArrayList<>();
for(int x: arr)
ls.add(x);
Collections.sort(ls);
for(int i=0; i < arr.length; i++)
arr[i] = ls.get(i);
}
public static void sortR(int[] arr){
ArrayList<Integer> ls = new ArrayList<>();
for(int x: arr)
ls.add(x);
Collections.sort(ls,Collections.reverseOrder());
for(int i=0; i < arr.length; i++)
arr[i] = ls.get(i);
}
public static void sort(long[] arr){
ArrayList<Long> ls = new ArrayList<>();
for(long x: arr)
ls.add(x);
Collections.sort(ls);
for(int i=0; i < arr.length; i++)
arr[i] = ls.get(i);
}
public static void sortR(long[] arr){
ArrayList<Long> ls = new ArrayList<>();
for(long x: arr)
ls.add(x);
Collections.sort(ls,Collections.reverseOrder());
for(int i=0; i < arr.length; i++)
arr[i] = ls.get(i);
}
} | Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | 583ff77839bc4aff6a1462b0849eb2b4 | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes | import java.util.*;
import java.io.*;
import java.math.*;
public class Main {
static long INF = 2000000000000000010l;
public static void main(String[] args) throws IOException {
int t = cin.nextInt();
while (t-- > 0) {
// csh();
solve();
out.flush();
}
out.close();
}
public static void solve() {
int n = cin.nextInt();
char[]c=cin.next().toCharArray();
int as=0,k=-1;
boolean f=false;
for(int i=0;i<n;i++){
if(c[i]=='('){
if(!f&&i!=n-1){
as++;
i++;
k=i;
}
}else{
if(!f){
f=true;
}else{
as++;
k=i;
f=false;
}
}
}
out.println(as+" "+(n-1-k));
}
public static boolean isF(String str) {
//
if (str == null || str.length() == 0) return true;
char[] chars = str.toCharArray();
Stack<Character> stack = new Stack<>();
for (int i=0; i<chars.length; i++) {
if (chars[i] == '(') {
stack.push(')');
} else if (chars[i] == '{') {
stack.push('}');
} else if (chars[i] == '[') {
stack.push(']');
} else if(stack.isEmpty() || chars[i] != stack.pop()) {
return false;
}
}
return stack.isEmpty();
}
public static int isH(String str, int n) {
int s, w;
int j = 0;
char c1, c2;
s = str.length() - n;
w = n - 1;
c1 = str.charAt(s);
c2 = str.charAt(w);
if (c1 == c2 || s == w)
j = 1;
if (s != w && s < w && j == 1)
isH(str, n - 1);
return j;
}
static boolean f(int n, int m) {
double a = Math.sqrt(n * n + m * m);
return a == (int) a;
}
static class Node {
int x, y, k;
Node() {
}
public Node(int x, int y, int k) {
this.x = x;
this.y = y;
this.k = k;
}
}
static void csh() {
}
static long cnm(int a, int b) {
long sum = 1;
int i = a, j = 1;
while (j <= b) {
sum = sum * i / j;
i--;
j++;
}
return sum;
}
static int gcd(int a, int b) {
return b == 0 ? a : gcd(b, a % b);
}
static int lcm(int a, int b) {
return (a * b) / gcd(a, b);
}
static void gbSort(int[] a, int l, int r) {
if (l < r) {
int m = (l + r) >> 1;
gbSort(a, l, m);
gbSort(a, m + 1, r);
int[] t = new int[r - l + 1];
int idx = 0, i = l, j = m + 1;
while (i <= m && j <= r)
if (a[i] <= a[j])
t[idx++] = a[i++];
else
t[idx++] = a[j++];
while (i <= m)
t[idx++] = a[i++];
while (j <= r)
t[idx++] = a[j++];
for (int z = 0; z < t.length; z++)
a[l + z] = t[z];
}
}
static FastScanner cin = new FastScanner(System.in);
static PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
static class FastScanner {
BufferedReader br;
StringTokenizer st;
public FastScanner(InputStream in) {
br = new BufferedReader(new InputStreamReader(in), 16384);
eat("");
}
public void eat(String s) {
st = new StringTokenizer(s);
}
public String nextLine() {
try {
return br.readLine();
} catch (IOException e) {
return null;
}
}
public boolean hasNext() {
while (!st.hasMoreTokens()) {
String s = nextLine();
if (s == null)
return false;
eat(s);
}
return true;
}
public String next() {
hasNext();
return st.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
public Double nextDouble() {
return Double.parseDouble(next());
}
public BigInteger nextBigInteger() {
return new BigInteger(next());
}
public BigDecimal nextBigDecimal() {
return new BigDecimal(next());
}
}
}
| Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | 30b6a9eba2b792ac47054c0dcf5c6cda | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes | import java.io.*;
import java.lang.reflect.Array;
import java.util.*;
public class tr1 {
static PrintWriter out;
static StringBuilder sb;
static long mod = 998244353;
static Boolean[] memo;
static int n, m, id, c;
static ArrayList<int[]>[] ad;
static HashMap<Integer, Integer>[] going;
static long inf = Long.MAX_VALUE;
static char[][] g;
static boolean[][] vis;
static int[] ans, arr[], per;
static int h, w;
static HashMap<Integer, int[]> hmC, hmG;
public static void main(String[] args) throws Exception {
Scanner sc = new Scanner(System.in);
out = new PrintWriter(System.out);
int t = sc.nextInt();
while (t-- > 0) {
sc.nextInt();
String ss = sc.nextLine();
char[] seq = ss.toCharArray();
int idx = 0;
int moves = 0;
Stack<Character> s = new Stack<>();
int p = 0;
boolean g = true;
int n = seq.length;
Manacher k = new Manacher(ss);
for (int i = 0; i < n; i++) {
if (seq[i] == '(') {
p++;
s.push('(');
} else {
p--;
if (!s.isEmpty() && s.peek() == '(')
s.pop();
else
g = false;
}
if (p == 0 && s.isEmpty() && g) {
moves++;
idx = i + 1;
continue;
}
boolean bal = k.get(idx, i);
if (bal) {
g = true;
s = new Stack<>();
idx = i + 1;
p = 0;
moves++;
}
}
out.println(moves + " " + (n - idx));
}
out.flush();
}
public static class Manacher {
private int[] p; // p[i] = length of longest palindromic substring of t, centered at i
private String s; // original string
private char[] t; // transformed string
public Manacher(String s) {
this.s = s;
preprocess();
p = new int[t.length];
int center = 0, right = 0;
for (int i = 1; i < t.length - 1; i++) {
int mirror = 2 * center - i;
if (right > i)
p[i] = Math.min(right - i, p[mirror]);
// attempt to expand palindrome centered at i
while (t[i + (1 + p[i])] == t[i - (1 + p[i])])
p[i]++;
// if palindrome centered at i expands past right,
// adjust center based on expanded palindrome.
if (i + p[i] > right) {
center = i;
right = i + p[i];
}
}
// System.out.println(Arrays.toString(p) + " " + Arrays.toString(t) + " " + s);
}
boolean get(int i, int j) {
int len = j - i + 1;
if (len == 1)
return false;
if (len % 2 == 0) {
int ii = (i + 1) * 2;
int jj = (j + 1) * 2;
if (p[(ii + jj) / 2] >= len)
return true;
} else {
int ii = (i + 1) * 2;
int jj = (j + 1) * 2;
if (p[(ii + jj) / 2] >= len)
return true;
}
return false;
}
// Transform s into t.
// For example, if s = "abba", then t = "$#a#b#b#a#@"
// the # are interleaved to avoid even/odd-length palindromes uniformly
// $ and @ are prepended and appended to each end to avoid bounds checking
private void preprocess() {
t = new char[s.length() * 2 + 3];
t[0] = '$';
t[s.length() * 2 + 2] = '@';
for (int i = 0; i < s.length(); i++) {
t[2 * i + 1] = '#';
t[2 * i + 2] = s.charAt(i);
}
t[s.length() * 2 + 1] = '#';
}
}
static class Scanner {
StringTokenizer st;
BufferedReader br;
public Scanner(InputStream system) {
br = new BufferedReader(new InputStreamReader(system));
}
public Scanner(String file) throws Exception {
br = new BufferedReader(new FileReader(file));
}
public String next() throws IOException {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
public String nextLine() throws IOException {
return br.readLine();
}
public int nextInt() throws IOException {
return Integer.parseInt(next());
}
public double nextDouble() throws IOException {
return Double.parseDouble(next());
}
public char nextChar() throws IOException {
return next().charAt(0);
}
public Long nextLong() throws IOException {
return Long.parseLong(next());
}
public int[] nextArrInt(int n) throws IOException {
int[] a = new int[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
public long[] nextArrLong(int n) throws IOException {
long[] a = new long[n];
for (int i = 0; i < n; i++)
a[i] = nextLong();
return a;
}
public int[] nextArrIntSorted(int n) throws IOException {
int[] a = new int[n];
Integer[] a1 = new Integer[n];
for (int i = 0; i < n; i++)
a1[i] = nextInt();
Arrays.sort(a1);
for (int i = 0; i < n; i++)
a[i] = a1[i].intValue();
return a;
}
public long[] nextArrLongSorted(int n) throws IOException {
long[] a = new long[n];
Long[] a1 = new Long[n];
for (int i = 0; i < n; i++)
a1[i] = nextLong();
Arrays.sort(a1);
for (int i = 0; i < n; i++)
a[i] = a1[i].longValue();
return a;
}
public boolean ready() throws IOException {
return br.ready();
}
public void waitForInput() throws InterruptedException {
Thread.sleep(3000);
}
}
} | Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | b7035a54bad4181195987aa92969d278 | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes | import java.io.*;
import java.math.*;
import java.util.*;
/*
* Author: Atuer
*/
public class Main
{
// ==== Solve Code ====//
static int INF = 2000000010;
public static void csh()
{
}
public static void main(String[] args) throws IOException
{
// csh();
int t = in.nextInt();
while (t-- > 0)
{
solve();
out.flush();
}
out.close();
}
public static void solve()
{
int n = in.nextInt();
char[] a = in.next().toCharArray();
int cnt = 0;
int last = -1;
boolean preyou = false;
for (int i = 0; i < n; i++)
{
if (a[i] == '(')
{
if (!preyou && i != n - 1)
{
cnt++;
i++;
last = i;
}
} else
{
if (!preyou)
{
preyou = true;
} else
{
cnt++;
last = i;
preyou = false;
}
}
//out.println(i + " " + preyou + " " + cnt + " " + (n - last));
}
out.println(cnt + " " + (n-1-last));
}
public static class Node
{
int x, y, k;
public Node(int x, int y, int k)
{
this.x = x;
this.y = y;
this.k = k;
}
}
// ==== Solve Code ====//
// ==== Template ==== //
public static long cnm(int a, int b)
{
long sum = 1;
int i = a, j = 1;
while (j <= b)
{
sum = sum * i / j;
i--;
j++;
}
return sum;
}
public static int gcd(int a, int b)
{
return b == 0 ? a : gcd(b, a % b);
}
public static int lcm(int a, int b)
{
return (a * b) / gcd(a, b);
}
public static void gbSort(int[] a, int l, int r)
{
if (l < r)
{
int m = (l + r) >> 1;
gbSort(a, l, m);
gbSort(a, m + 1, r);
int[] t = new int[r - l + 1];
int idx = 0, i = l, j = m + 1;
while (i <= m && j <= r)
if (a[i] <= a[j])
t[idx++] = a[i++];
else
t[idx++] = a[j++];
while (i <= m)
t[idx++] = a[i++];
while (j <= r)
t[idx++] = a[j++];
for (int z = 0; z < t.length; z++)
a[l + z] = t[z];
}
}
// ==== Template ==== //
// ==== IO ==== //
static InputStream inputStream = System.in;
static InputReader in = new InputReader(inputStream);
static PrintWriter out = new PrintWriter(System.out);
static class InputReader
{
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(InputStream stream)
{
reader = new BufferedReader(new InputStreamReader(stream), 32768);
tokenizer = null;
}
public String next()
{
while (tokenizer == null || !tokenizer.hasMoreTokens())
{
try
{
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e)
{
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
boolean hasNext()
{
while (tokenizer == null || !tokenizer.hasMoreTokens())
{
try
{
tokenizer = new StringTokenizer(reader.readLine());
} catch (Exception e)
{
return false;
// TODO: handle exception
}
}
return true;
}
public String nextLine()
{
String str = null;
try
{
str = reader.readLine();
} catch (IOException e)
{
e.printStackTrace();
}
return str;
}
public int nextInt()
{
return Integer.parseInt(next());
}
public long nextLong()
{
return Long.parseLong(next());
}
public Double nextDouble()
{
return Double.parseDouble(next());
}
public BigInteger nextBigInteger()
{
return new BigInteger(next());
}
public BigDecimal nextBigDecimal()
{
return new BigDecimal(next());
}
}
// ==== IO ==== //
} | Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | 71ac51c03f89ce32573b3da1f207e6c8 | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes | import java.io.*;
import java.util.*;
public class gotoJapan {
public static void main(String[] args) throws java.lang.Exception {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
Solution solver = new Solution();
boolean isTest = true;
int tC = isTest ? Integer.parseInt(in.next()) : 1;
for (int i = 1; i <= tC; i++)
solver.solve(in, out, i);
out.close();
}
/* ............................................................. */
static class Solution {
InputReader in;
PrintWriter out;
public void solve(InputReader in, PrintWriter out, int test) {
this.in = in;
this.out = out;
int n=ni();
char x[]=n();
int cnt=0;
int i=0;
int ans=0;
while(i<n) {
boolean flag=false;
if(x[i]=='(') {
int j=i+1;
while(j<n) {
if(x[j]=='('||x[j]==')') {
cnt++;
flag=true;
break;
}
else j++;
}
i=j+1;
if(flag)ans=j+1;
}
else {
int j=i+1;
while(j<n) {
if(x[j]==')') {
cnt++;
flag=true;
break;
}
else j++;
}
i=j+1;
if(flag)ans=j+1;
}
}
pn(cnt+" "+(n-ans));
}
class Pair {
int x;
int y;
long w;
Pair(int x, int y, long w) {
this.x = x;
this.y = y;
this.w = w;
}
}
char[] n() {
return in.next().toCharArray();
}
int ni() {
return in.nextInt();
}
long nl() {
return in.nextLong();
}
long[] nal(int n) {
long a[] = new long[n];
for (int i = 0; i < n; i++)
a[i] = nl();
return a;
}
void pn(long zx) {
out.println(zx);
}
void pn(String sz) {
out.println(sz);
}
void pn(double dx) {
out.println(dx);
}
void pn(long ar[]) {
for (int i = 0; i < ar.length; i++)
out.print(ar[i] + " ");
out.println();
}
void pn(String ar[]) {
for (int i = 0; i < ar.length; i++)
out.println(ar[i]);
}
}
/* ......................Just Input............................. */
static class InputReader {
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream), 32768);
tokenizer = null;
}
public String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
}
/* ......................Just Input............................. */
} | Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | 6468fc983f93c494b92914b3ec6c22d5 | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes | import java.util.*;
import java.io.*;
public class Omar {
static Scanner sc;
static PrintWriter pw;
public static void main(String[] args) throws IOException, InterruptedException {
sc = new Scanner(System.in);
pw = new PrintWriter(System.out);
int t = sc.nextInt();
while (t-- > 0) {
int n = sc.nextInt();
char[] arr = sc.next().toCharArray();
int remove = 0;
int cnt1 = 0, cnt2 = 0;
int c = 0;
int ans2 = 0;
boolean first = arr[0] == ')' ? false : true;
boolean active=false;
for (int i = 0; i < n; i++) {
if (arr[i] == '(') {
c++;
active=true;
cnt1++;
} else {
if (c > 0)
c--;
cnt2++;
}
if ((c == 0 && active)|| (first && cnt1 > 1) || (!first && cnt2 > 1)) {
remove += cnt1 + cnt2;
cnt1 = cnt2 = c = 0;
ans2++;
active=false;
if (i < n - 1) {
first = arr[i+1] == ')' ? false : true;
}
}
}
pw.println(ans2 + " " + (n - remove));
}
pw.flush();
}
static class pair {
// long x,y;
int x, y;
public pair(int x, int y) {
this.x = x;
this.y = y;
}
public String toString() {
return x + " " + y;
}
public boolean equals(Object o) {
if (o instanceof pair) {
pair p = (pair) o;
return p.x == x && p.y == y;
}
return false;
}
public int hashCode() {
return new Long(x).hashCode() * 31 + new Long(y).hashCode();
}
}
static class Scanner {
StringTokenizer st;
BufferedReader br;
public Scanner(InputStream s) {
br = new BufferedReader(new InputStreamReader(s));
}
public Scanner(FileReader r) {
br = new BufferedReader(r);
}
public String readAllLines(BufferedReader reader) throws IOException {
StringBuilder content = new StringBuilder();
String line;
while ((line = reader.readLine()) != null) {
content.append(line);
content.append(System.lineSeparator());
}
return content.toString();
}
public String next() throws IOException {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
public int nextInt() throws IOException {
return Integer.parseInt(next());
}
public long nextLong() throws IOException {
return Long.parseLong(next());
}
public String nextLine() throws IOException {
return br.readLine();
}
public double nextDouble() throws IOException {
String x = next();
StringBuilder sb = new StringBuilder("0");
double res = 0, f = 1;
boolean dec = false, neg = false;
int start = 0;
if (x.charAt(0) == '-') {
neg = true;
start++;
}
for (int i = start; i < x.length(); i++)
if (x.charAt(i) == '.') {
res = Long.parseLong(sb.toString());
sb = new StringBuilder("0");
dec = true;
} else {
sb.append(x.charAt(i));
if (dec)
f *= 10;
}
res += Long.parseLong(sb.toString()) / f;
return res * (neg ? -1 : 1);
}
public long[] nextlongArray(int n) throws IOException {
long[] a = new long[n];
for (int i = 0; i < n; i++)
a[i] = nextLong();
return a;
}
public Long[] nextLongArray(int n) throws IOException {
Long[] a = new Long[n];
for (int i = 0; i < n; i++)
a[i] = nextLong();
return a;
}
public int[] nextIntArray(int n) throws IOException {
int[] a = new int[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
public Integer[] nextIntegerArray(int n) throws IOException {
Integer[] a = new Integer[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
public boolean ready() throws IOException {
return br.ready();
}
}
}
| Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | 42179f4a3a2365761da5c15870302873 | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes |
import java.io.*;
import java.util.*;
public class Solution {
static long cr[][]=new long[1001][1001];
//static double EPS = 1e-7;
static long mod=998244353;
static long val=0;
static boolean flag=true;
public static void main(String[] args)
{
FScanner sc = new FScanner();
//Arrays.fill(prime, true);
//sieve();
//ncr();
int t=sc.nextInt();
StringBuilder sb = new StringBuilder();
int cnt=1;
while(t-->0)
{
int n=sc.nextInt();
String s=sc.next();
char c[]=s.toCharArray();
long v=0;int start=0,count=0;
for(int i=0;i<n;i++)
{
if(c[i]=='(')
v++;
else
v--;
if(v==0)
{
count++;
start=i+1;
}
else if(palindrome(c,start,i))
{
count++;
start=i+1;
v=0;
}
if(v<0)
{
v=Integer.MAX_VALUE;
}
}
sb.append(count+" ");
sb.append(n-start);
sb.append("\n");
}
System.out.println(sb.toString());
}
public static boolean palindrome(char c[],int i,int j)
{ if(i==j)
return false;
while(i<j)
{
if(c[i]!=c[j])
return false;
i++;j--;
}
return true;
}
public static boolean check(char c[],int i,int j,int dp[][])
{ int k=i;
while(i<=j-4)
{
if(palin(c,i,i+4) )
return true;
i++;
}
i=k;
while(i<=j-5)
{
if(palin(c,i,i+5) )
return true;
i++;
}
return false;
}
public static boolean palin(char c[],int i,int j)
{
while(i<j)
{
if(c[i]!=c[j])
return false;
i++;j--;
}
return true;
}
public static long powerLL(long x, long n)
{
long result = 1;
while (n > 0)
{
if (n % 2 == 1)
{
result = result * x % mod;
}
n = n / 2;
x = x * x % mod;
}
return result;
}
public static long gcd(long a,long b)
{
return b==0 ? a:gcd(b,a%b);
}
/* public static void sieve()
{ prime[0]=prime[1]=false;
int n=1000000;
for(int p = 2; p*p <=n; p++)
{
if(prime[p] == true)
{
for(int i = p*p; i <= n; i += p)
prime[i] = false;
}
}
*/
public static void ncr()
{
cr[0][0]=1;
for(int i=1;i<=1000;i++)
{
cr[i][0]=1;
for(int j=1;j<i;j++)
{
cr[i][j]=(cr[i-1][j-1]+cr[i-1][j])%mod;
}
cr[i][i]=1;
}
}
}
class pair
//implements Comparable<pair>
{
long a;long b;
pair(long a,long b)
{
this.b=b;
this.a=a;
}
}
class FScanner {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer sb = new StringTokenizer("");
String next(){
while(!sb.hasMoreTokens()){
try{
sb = new StringTokenizer(br.readLine());
} catch(IOException e){ }
}
return sb.nextToken();
}
String nextLine(){
try{ return br.readLine(); }
catch(IOException e) { } return "";
}
int nextInt(){
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
int[] readArray(int n) {
int a[] = new int[n];
for(int i=0;i<n;i++) a[i] = nextInt();
return a;
}
float nextFloat(){
return Float.parseFloat(next());
}
double nextDouble(){
return Double.parseDouble(next());
}
}
| Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | 756d653bdfb11eaf813ad327f7915d9f | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes | import java.io.*;
import java.util.*;
public class BracketSequenceDeletion {
private static final int START_TEST_CASE = 1;
public static void solveCase(FastIO io, int testCase) {
final int N = io.nextInt();
final char[] S = io.nextLine().toCharArray();
int idx = 0;
int moves = 0;
while (idx + 1 < N) {
if (S[idx] == '(') {
idx += 2;
++moves;
} else {
int next = findNextCloseParen(S, idx + 1);
if (next < 0) {
break;
}
idx = next + 1;
++moves;
}
}
io.println(moves, N - idx);
}
private static int findNextCloseParen(char[] S, int start) {
for (int i = start; i < S.length; ++i) {
if (S[i] == ')') {
return i;
}
}
return -1;
}
public static void solve(FastIO io) {
final int T = io.nextInt();
for (int t = 0; t < T; ++t) {
solveCase(io, START_TEST_CASE + t);
}
}
public static class FastIO {
private InputStream reader;
private PrintWriter writer;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
public FastIO(InputStream r, OutputStream w) {
reader = r;
writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(w)));
}
public int read() {
if (numChars == -1)
throw new InputMismatchException();
if (curChar >= numChars) {
curChar = 0;
try {
numChars = reader.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0)
return -1;
}
return buf[curChar++];
}
public String nextLine() {
int c = read();
while (isSpaceChar(c))
c = read();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isEndOfLine(c));
return res.toString();
}
public String nextString() {
int c = read();
while (isSpaceChar(c))
c = read();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
public long nextLong() {
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
long res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public int nextInt() {
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
// TODO: read this byte-by-byte like the other read functions.
public double nextDouble() {
return Double.parseDouble(nextString());
}
public int[] nextIntArray(int n) {
return nextIntArray(n, 0);
}
public int[] nextIntArray(int n, int off) {
int[] arr = new int[n + off];
for (int i = 0; i < n; i++) {
arr[i + off] = nextInt();
}
return arr;
}
public long[] nextLongArray(int n) {
return nextLongArray(n, 0);
}
public long[] nextLongArray(int n, int off) {
long[] arr = new long[n + off];
for (int i = 0; i < n; i++) {
arr[i + off] = nextLong();
}
return arr;
}
private boolean isSpaceChar(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
private boolean isEndOfLine(int c) {
return c == '\n' || c == '\r' || c == -1;
}
public void print(Object... objects) {
for (int i = 0; i < objects.length; i++) {
if (i != 0) {
writer.print(' ');
}
writer.print(objects[i]);
}
}
public void println(Object... objects) {
print(objects);
writer.println();
}
public void printArray(int[] arr) {
for (int i = 0; i < arr.length; i++) {
if (i != 0) {
writer.print(' ');
}
writer.print(arr[i]);
}
}
public void printArray(long[] arr) {
for (int i = 0; i < arr.length; i++) {
if (i != 0) {
writer.print(' ');
}
writer.print(arr[i]);
}
}
public void printlnArray(int[] arr) {
printArray(arr);
writer.println();
}
public void printlnArray(long[] arr) {
printArray(arr);
writer.println();
}
public void printf(String format, Object... args) {
print(String.format(format, args));
}
public void flush() {
writer.flush();
}
}
public static void main(String[] args) {
FastIO io = new FastIO(System.in, System.out);
solve(io);
io.flush();
}
} | Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | 19cd662c394b8242ee1e49f79d1b650b | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes | import java.io.*;
import java.nio.Buffer;
import java.util.*;
public class Main2 {
public static void main(String[] args) throws IOException {
Scanner sc = new Scanner(System.in);
int testCases = sc.nextInt();
while (testCases -- > 0)
{
int n = sc.nextInt();
String input = sc.next();
long operations = 0;
long lastIndex = 0;
for(int i = 0; i < input.length(); i++)
{
if(input.charAt(i) == '(' && i != input.length() - 1)
{
operations++;
i++;
lastIndex = i + 1;
}
else if(input.charAt(i) == ')')
{
i++;
while (i < input.length() && input.charAt(i) == '(')
{
i++;
}
if(i != input.length())
{
operations++;
lastIndex = i + 1;
}
}
}
System.out.println(operations + " " + (n - lastIndex));
}
}
}
| Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | 7f9da6e8c44d520d5be1bbf5df535fb2 | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes | import java.util.*;
import java.io.*;
public class MyCpClass{
public static void main(String []args) throws IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringBuilder sb = new StringBuilder();
int T = Integer.parseInt(br.readLine().trim());
while(T-- > 0){
int n = Integer.parseInt(br.readLine().trim());
String ip = br.readLine().trim();
char []str = ip.toCharArray();
int s=0, e=s+1, c=0;
while(e < n){
if(e-s==1 && (str[s]==str[e] || (str[s]=='(' && str[e]==')'))){
e += 2;
s += 2;
c++;
}
else if(e-s == 1)
e++;
else if(str[e] == ')'){
s = e+1;
e += 2;
c++;
}
else
e++;
}
int r = (s<n) ? e-s : 0;
sb.append(c + " " + r + "\n");
}
System.out.println(sb);
}
} | Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | bb59db2b8b6b7ca538d258cf58e99653 | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes | import java.util.*;
import java.io.*;
public class Main {
static PrintStream out = new PrintStream(System.out);
static LinkedList<LinkedList<Integer>> adj;
static boolean[] vis;
//static ArrayList<ArrayList<Integer>> lists;
public static void main(String[] args){
FastScanner sc = new FastScanner();
int t = sc.nextInt();
while(t-->0){
int n = sc.nextInt();
char[] arr = sc.next().toCharArray();
boolean ok = true;
int i = 0;
ArrayList<Pair> pairs = new ArrayList();
boolean[] taken = new boolean[n];
boolean cont = true;
while(i + 1 < n){
char curr = arr[i];
if(curr == '('){
Pair p = new Pair(i, i+1);
pairs.add(p);
i += 2;
continue;
}
char next = arr[i+1];
if(next == ')'){
Pair p = new Pair(i, i+1);
pairs.add(p);
i += 2;
continue;
}
int j = i + 1;
boolean found = false;
while(j + 1 < n){
if(arr[j] == '(' && arr[j+1] == ')'){
found = true;
cont = isPal(arr, i, j + 1);
if(cont){
Pair p = new Pair(i, j+1);
pairs.add(p);
i = j + 2;
}
break;
}
j++;
}
if(!cont || !found) break;
}
for(Pair p : pairs){
int begin = p.a;
int end = p.b;
for(int k = begin; k <= end; k++)
taken[k] = true;
}
int notTakenCnt = 0;
for(int k = 0; k < n; k++){
if(!taken[k]) notTakenCnt++;
}
out.println(pairs.size() + " " + notTakenCnt);
}
}
public static boolean isPal(char[] arr, int l, int r){
if(r - l <= 1) return false;
while(l <= r){
if(arr[l] != arr[r]) return false;
l++; r--;
}
return true;
}
public static void dfs(int v){
if(vis[v]) return;
vis[v] = true;
LinkedList<Integer> neighbors = adj.get(v);
Iterator<Integer> it = neighbors.iterator();
while(it.hasNext()){
int node = it.next();
if(!vis[node]){
dfs(node);
}
}
}
public static void mergeSort(int[] inputArray){
int n = inputArray.length;
// if input array is empty or contains only one element (meaning already sorted)
if(n < 2){
return;
}
// split input array
int mid = n / 2;
int[] leftHalf = new int[mid];
int[] rightHalf = new int[n - mid];
for(int i = 0; i < mid; i++){
leftHalf[i] = inputArray[i];
}
for(int i = mid; i < n; i++){
rightHalf[i - mid] = inputArray[i];
}
// merge sort both halves
mergeSort(leftHalf);
mergeSort(rightHalf);
// merge halves back into one array
merge(inputArray, leftHalf, rightHalf);
}
public static void merge(int[] inputArray, int[] leftArray, int[] rightArray){
int leftSize = leftArray.length;
int rightSize = rightArray.length;
int i = 0, j = 0, k = 0;
// get smaller element between two arrays
while(i < leftSize && j < rightSize){
if(leftArray[i] <= rightArray[j]){
inputArray[k] = leftArray[i++];
}
else{
for(int x = i ; x < leftSize; x++){
//out.print(leftArray[x] + " " + rightArray[j]);
int u = leftArray[x];
int v = rightArray[j];
adj.get(u).add(v);
adj.get(v).add(u);
}
inputArray[k] = rightArray[j++];
}
k++;
}
// check left for leftovers
while(i < leftSize){
inputArray[k++] = leftArray[i++];
}
// check right for leftovers
while(j < rightSize){
inputArray[k++] = rightArray[j++];
}
}
public static void addUndirectedEdge(int u, int v){
adj.get(u).add(v);
adj.get(v).add(u);
}
}
// custom I/O
class FastScanner {
BufferedReader br;
StringTokenizer st;
public FastScanner()
{
br = new BufferedReader(new
InputStreamReader(System.in));
}
String next()
{
while (st == null || !st.hasMoreElements())
{
try
{
st = new StringTokenizer(br.readLine());
}
catch (IOException e)
{
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt()
{
return Integer.parseInt(next());
}
long nextLong()
{
return Long.parseLong(next());
}
double nextDouble()
{
return Double.parseDouble(next());
}
String nextLine()
{
String str = "";
try
{
str = br.readLine();
}
catch (IOException e)
{
e.printStackTrace();
}
return str;
}
int[] nextIntArray(int length) {
int[] arr = new int[length];
for (int i = 0; i < length; i++)
arr[i] = nextInt();
return arr;
}
}
class Pair implements Comparable<Pair>{
int a;
int b;
public Pair(int a, int b){
this.a = a;
this.b = b;
}
@Override
public int compareTo(Pair p) {
return this.a - p.a;
}
} | Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | 24c7efef635ab3104a3a124f4a441621 | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main{
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String[]data;
int t, n;
char[]s;
t = Integer.valueOf(br.readLine());
while( (t--) != 0){
n = Integer.valueOf(br.readLine());
s = br.readLine().toCharArray();
char[]revS = new char[n];
for(int i = 0 ; i < n ; ++i){
revS[i] = s[n - i - 1];
}
Hashing s1 = new Hashing(new String(s));
Hashing s2 = new Hashing(new String(revS));
int i = 0;
int left = 0, right = 0;
int c = 0, r;
for(int j = 0 ; j < n ; ++j){
if(s[j] == '('){
left++;
}else{
if(left >0){
left --;
} else{
right ++;
}
}
if(j - i <= 0){
continue;
}
if(s1.hash(i, j+1) == s2.hash(n - (j +1), n - i)){
i = j + 1;
left = 0;
right = 0;
c++;
continue;
}
if(left == 0 && right == 0){
i = j + 1;
left = 0;
right = 0;
c++;
}
}
System.out.println(c + " " + (n - i));
}
}
static long p[] = {257, 359};
static long mod[] = {1000000007, 1000000009};
static long X = 1000000010;
static class Hashing {
long[][] h, pot;
int n;
public Hashing(String _s) {
char[] s = _s.toCharArray();
n = s.length;
h = new long[2][n + 1];
pot = new long[2][n + 1];
for (int i = 0; i < 2; ++i) {
pot[i][0] = 1;
}
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < 2; ++j) {
h[j][i] = (h[j][i-1] * p[j] + s[i-1]) % mod[j];
pot[j][i] = (pot[j][i-1] * p[j]) % mod[j];
}
}
}
//Hash del substring en el rango [i, j)
long hash(int i, int j) {
long a = (h[0][j] - (h[0][i] * pot[0][j-i] % mod[0]) + mod[0]) % mod[0];
long b = (h[1][j] - (h[1][i] * pot[1][j-i] % mod[1]) + mod[1]) % mod[1];
return a*X + b;
}
}
} | Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | a74378fcfc2b1d1e7a73fba5be87578e | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes | //package codeforces.educational125;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
public class BracketSequenceDeletion {
public static void main(String[] args) throws IOException {
new BracketSequenceDeletion().run();
}
public void run() throws IOException {
InputStream inputStream = getInputStream();
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
PrintWriter writer = new PrintWriter(new BufferedOutputStream(System.out));
String[] tokens;
tokens = bufferedReader.readLine().split(" ");
int t = Integer.parseInt(tokens[0]);
while (t > 0) {
tokens = bufferedReader.readLine().split(" ");
int n = Integer.parseInt(tokens[0]);
tokens = bufferedReader.readLine().split(" ");
String brackets = tokens[0];
BracketSequenceDeletion bracketSequenceDeletion = new BracketSequenceDeletion(brackets);
writer.println(bracketSequenceDeletion.c + " " + bracketSequenceDeletion.r);
t--;
}
writer.close();
inputStream.close();
}
public BracketSequenceDeletion() {}
int c, r;
public BracketSequenceDeletion(String brackets) {
int i = 0;
int n = brackets.length();
while (i < n) {
if (i == n-1) {
r = 1;
i++;
} else {
if (brackets.charAt(i) == '(') {
// if next bracket is (, it's a palindrome of size 2
// if next bracket is ), it's a regular string of size 2
c++;
i += 2;
} else {
// current bracket is )
// next match is a palindrome ) (* )
int i0 = i;
i++;
while (i < n && brackets.charAt(i) == '(') {
i++;
}
if (i < n) {
// current bracket is )
c++;
i++;
} else {
r = n-i0;
}
}
}
}
}
private InputStream getInputStream() throws IOException {
if (System.getProperty("ONLINE_JUDGE") != null) {
return System.in;
}
return new FileInputStream("BracketSequenceDeletion");
}
}
| Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | 95e17c455429e46bdc5355abd84bc1a4 | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes |
import java.io.*;
import java.util.*;
public class Main {
static Reader rd = new Reader();
public static void main(String[] args) {
int tt = rd.nextInt();
while (tt-- > 0) {
new Solution().solve();
}
}
static class Solution {
long P1 = 1337;
long MD = (long) 1e9 + 7;
void solve() {
int n = rd.nextInt();
char[] s = rd.next().toCharArray();
// matched: 0101
// palindrome: 0010100
int start = 0, c = 0;
while (true) {
boolean bad = false, ok = false;
int open = 0;
long hash1 = 0, hash2 = 0;
for (int i = start; i < n; i++) {
if (s[i] == '(') {
open++;
hash2 *= P1;
hash2 %= MD;
} else {
open--;
if (open < 0) {
bad = true;
}
hash1 += qpow(P1, i - start, MD);
hash2 *= P1;
hash2 %= MD;
hash2 += 1;
}
// System.out.printf("bad=%b open=%d start=%d i=%d hash1=%d hash2=%d\n", bad, open, start, i, hash1, hash2);
if ((!bad && open == 0) || (i - start + 1 >= 2 && hash1 == hash2)) { // check(s[start, i]) is good
start = i + 1;
c++;
ok = true;
break;
}
}
if (ok) continue;
break;
}
System.out.printf("%d %d\n", c, n - start);
}
long qpow(long a, long b, long p) {
if (b == 0) return 1;
if (b == 1) return a % p;
long res = qpow(a, b >> 1, p);
res *= res;
res %= p;
if (b % 2 == 1) {
res *= a;
}
return res % p;
}
}
static class Reader {
private BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
private StringTokenizer tokenizer = new StringTokenizer("");
private String innerNextLine() {
try {
return reader.readLine();
} catch (IOException ex) {
throw new RuntimeException(ex);
}
}
public boolean hasNext() {
while (!tokenizer.hasMoreTokens()) {
String nextLine = innerNextLine();
if (nextLine == null) {
return false;
}
tokenizer = new StringTokenizer(nextLine);
}
return true;
}
public String nextLine() {
tokenizer = new StringTokenizer("");
return innerNextLine();
}
public String next() {
hasNext();
return tokenizer.nextToken();
}
public int nextInt() {
return Integer.valueOf(next());
}
public long nextLong() {
return Long.valueOf(next());
}
public double nextDouble() {
return Double.valueOf(next());
}
}
}
| Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | 7299e5af403bb4ab6d216efe8432fbb4 | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes | import java.io.*;
import java.util.*;
public class CodeForces {
/*-------------------------------------------EDITING CODE STARTS HERE-------------------------------------------*/
public static void solve(int tCase) throws IOException {
int n = sc.nextInt();
char[] str = sc.next().toCharArray();
int cnt = 0;
int i=0;
for(;i<n;){
if(i+1<n && (str[i]==str[i+1] || str[i]=='(')){
cnt ++;
i+=2;
}else {
int j = i+1;
boolean ok = false;
for(;j<n;j++){
if(str[j]==')'){
i = j+1;
cnt++;
ok = true;
break;
}
}
if(!ok)break;
}
}
out.println(cnt+" "+(n-i));
}
public static void main(String[] args) throws IOException {
openIO();
int testCase = 1;
testCase = sc.nextInt();
for (int i = 1; i <= testCase; i++) solve(i);
closeIO();
}
/*-------------------------------------------EDITING CODE ENDS HERE-------------------------------------------*/
/*--------------------------------------HELPER FUNCTIONS STARTS HERE-----------------------------------------*/
// public static int mod = (int) 1e9 + 7;
public static int mod = 998244353;
public static int inf_int = (int) 2e9+10;
public static long inf_long = (long) 2e18;
public static void _sort(int[] arr, boolean isAscending) {
int n = arr.length;
List<Integer> list = new ArrayList<>();
for (int ele : arr) list.add(ele);
Collections.sort(list);
if (!isAscending) Collections.reverse(list);
for (int i = 0; i < n; i++) arr[i] = list.get(i);
}
public static void _sort(long[] arr, boolean isAscending) {
int n = arr.length;
List<Long> list = new ArrayList<>();
for (long ele : arr) list.add(ele);
Collections.sort(list);
if (!isAscending) Collections.reverse(list);
for (int i = 0; i < n; i++) arr[i] = list.get(i);
}
// time : O(1), space : O(1)
public static int _digitCount(long num,int base){
// this will give the # of digits needed for a number num in format : base
return (int)(1 + Math.log(num)/Math.log(base));
}
// time : O(n), space: O(n)
public static long _fact(int n){
// simple factorial calculator
long ans = 1;
for(int i=2;i<=n;i++)
ans = ans * i % mod;
return ans;
}
// time for pre-computation of factorial and inverse-factorial table : O(nlog(mod))
public static long[] factorial , inverseFact;
public static void _ncr_precompute(int n){
factorial = new long[n+1];
inverseFact = new long[n+1];
factorial[0] = inverseFact[0] = 1;
for (int i = 1; i <=n; i++) {
factorial[i] = (factorial[i - 1] * i) % mod;
inverseFact[i] = _modExpo(factorial[i], mod - 2);
}
}
// time of factorial calculation after pre-computation is O(1)
public static int _ncr(int n,int r){
if(r > n)return 0;
return (int)(factorial[n] * inverseFact[r] % mod * inverseFact[n - r] % mod);
}
public static int _npr(int n,int r){
if(r > n)return 0;
return (int)(factorial[n] * inverseFact[n - r] % mod);
}
// euclidean algorithm time O(max (loga ,logb))
public static long _gcd(long a, long b) {
while (a>0){
long x = a;
a = b % a;
b = x;
}
return b;
// if (a == 0)
// return b;
// return _gcd(b % a, a);
}
// lcm(a,b) * gcd(a,b) = a * b
public static long _lcm(long a, long b) {
return (a / _gcd(a, b)) * b;
}
// binary exponentiation time O(logn)
public static long _modExpo(long x, long n) {
long ans = 1;
while (n > 0) {
if ((n & 1) == 1) {
ans *= x;
ans %= mod;
n--;
} else {
x *= x;
x %= mod;
n >>= 1;
}
}
return ans;
}
// function to find a/b under modulo mod. time : O(logn)
public static long _modInv(long a,long b){
return (a * _modExpo(b,mod-2)) % mod;
}
//sieve or first divisor time : O(mx * log ( log (mx) ) )
public static int[] _seive(int mx){
int[] firstDivisor = new int[mx+1];
for(int i=0;i<=mx;i++)firstDivisor[i] = i;
for(int i=2;i*i<=mx;i++)
if(firstDivisor[i] == i)
for(int j = i*i;j<=mx;j+=i)
if(firstDivisor[j]==j)firstDivisor[j] = i;
return firstDivisor;
}
// check if x is a prime # of not. time : O( n ^ 1/2 )
private static boolean _isPrime(long x){
for(long i=2;i*i<=x;i++)
if(x%i==0)return false;
return true;
}
static class Pair<K, V>{
K ff;
V ss;
public Pair(K ff, V ss) {
this.ff = ff;
this.ss = ss;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || this.getClass() != o.getClass()) return false;
Pair<?, ?> pair = (Pair<?, ?>) o;
return ff.equals(pair.ff) && ss.equals(pair.ss);
}
@Override
public int hashCode() {
return Objects.hash(ff, ss);
}
@Override
public String toString(){
return ff.toString()+" "+ss.toString();
}
}
/*--------------------------------------HELPER FUNCTIONS ENDS HERE-----------------------------------------*/
/*-------------------------------------------FAST INPUT STARTS HERE---------------------------------------------*/
static FastestReader sc;
static PrintWriter out;
private static void openIO() throws IOException {
sc = new FastestReader();
out = new PrintWriter(System.out);
}
public static void closeIO() throws IOException {
out.flush();
out.close();
sc.close();
}
private static final class FastestReader {
private static final int BUFFER_SIZE = 1 << 16;
private final DataInputStream din;
private final byte[] buffer;
private int bufferPointer, bytesRead;
public FastestReader() {
din = new DataInputStream(System.in);
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public FastestReader(String file_name) throws IOException {
din = new DataInputStream(new FileInputStream(file_name));
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
private static boolean isSpaceChar(int c) {
return !(c >= 33 && c <= 126);
}
private int skip() throws IOException {
int b;
//noinspection StatementWithEmptyBody
while ((b = read()) != -1 && isSpaceChar(b)) {}
return b;
}
public String next() throws IOException {
int b = skip();
final StringBuilder sb = new StringBuilder();
while (!isSpaceChar(b)) { // when nextLine, (isSpaceChar(b) && b != ' ')
sb.appendCodePoint(b);
b = read();
}
return sb.toString();
}
public int nextInt() throws IOException {
int ret = 0;
byte c = read();
while (c <= ' ') c = read();
final boolean neg = c == '-';
if (neg) c = read();
do {
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
return neg?-ret:ret;
}
public long nextLong() throws IOException {
long ret = 0;
byte c = read();
while (c <= ' ') c = read();
final boolean neg = c == '-';
if (neg) c = read();
do {
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
return neg?-ret:ret;
}
public double nextDouble() throws IOException {
double ret = 0, div = 1;
byte c = read();
while (c <= ' ') c = read();
final boolean neg = c == '-';
if (neg) c = read();
do {
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (c == '.')
while ((c = read()) >= '0' && c <= '9')
ret += (c - '0') / (div *= 10);
return neg?-ret:ret;
}
public String nextLine() throws IOException {
final byte[] buf = new byte[(1<<10)]; // line length
int cnt = 0, c;
while ((c = read()) != -1) {
if (c == '\n') {
break;
}
buf[cnt++] = (byte) c;
}
return new String(buf, 0, cnt);
}
private void fillBuffer() throws IOException {
bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
if (bytesRead == -1) buffer[0] = -1;
}
private byte read() throws IOException {
if (bufferPointer == bytesRead) fillBuffer();
return buffer[bufferPointer++];
}
public void close() throws IOException {
din.close();
}
}
/*---------------------------------------------FAST INPUT ENDS HERE ---------------------------------------------*/
}
/** Some points to keep in mind :
* 1. don't use Arrays.sort(primitive data type array)
* 2. try to make the parameters of a recursive function as less as possible,
* more use static variables.
*
**/ | Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | 908b1aa8f5ffece077b85a5bbf6292fe | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes | //package codeforces;
import java .util.*;
public class squarebracketdeletion {
public static void main(String [] args)
{
Scanner in=new Scanner (System.in);
int t=in.nextInt();
while(t>0)
{ //System.out.println(t);
int n1=in.nextInt();
in.nextLine();
String s1=in.nextLine();
int o=0,c=0;
int i=0,j=0;
for( i=0;i<n1;)
{
if(s1.charAt(i)=='(')
{
if(i==n1-1)
{
i++;
c++;
}
else
{
i+=2;
o++;
}
}
else
{ int f=0;
for(j=i+1;j<n1;j++)
{
if(s1.charAt(j)==')')
{
o++;
f++;
i=j+1;
break;
}
}
if(f==0)
{
c=n1-i;
break;
}
}
}
System.out.println(o+" "+c);
t--;
}
}
}
| Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | a179d5363b0ff77cb5128221e6512a0a | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes | import java.io.*;
import java.util.*;
public class _1657c {
FastScanner scn;
PrintWriter w;
PrintStream fs;
int MOD = 1000000007;
int MAX = 200005;
long mul(long x, long y) {long res = x * y; return (res >= MOD ? res % MOD : res);}
long power(long x, long y) {if (y < 0) return 1; long res = 1; x %= MOD; while (y!=0) {if ((y & 1)==1)res = mul(res, x); y >>= 1; x = mul(x, x);} return res;}
void ruffleSort(int[] a) {int n=a.length;Random r=new Random();for (int i=0; i<a.length; i++) {int oi=r.nextInt(n), temp=a[i];a[i]=a[oi];a[oi]=temp;}Arrays.sort(a);}
void reverseSort(int[] arr){List<Integer> list = new ArrayList<>();for (int i=0; i<arr.length; i++){list.add(arr[i]);}Collections.sort(list, Collections.reverseOrder());for (int i = 0; i < arr.length; i++){arr[i] = list.get(i);}}
boolean LOCAL;
void debug(Object... o){if(LOCAL)System.err.println(Arrays.deepToString(o));}
//SPEED IS NOT THE CRITERIA, CODE SHOULD BE A NO BRAINER, CMP KILLS, MOCIM
void solve(){
int t=scn.nextInt();
while(t-->0)
{
int n=scn.nextInt();
String str = scn.next();
long del = 0,op = 0;
long delst = 0;
boolean inpro = false;
for(int i=0;i<n;i++){
char ch1 = str.charAt(i);
if(ch1=='('&&!inpro&&i!=n-1){
del+=2;
op++;
i++;
}else if(ch1==')'){
if(!inpro){
delst = i;
inpro=true;
}else{
del += (i-delst+1);
debug(del);
op++;
inpro = false;
}
}
}
w.println(op+" "+(n-del));
}
}
void run() {
try {
long ct = System.currentTimeMillis();
scn = new FastScanner(new File("input.txt"));
w = new PrintWriter(new File("output.txt"));
fs=new PrintStream("error.txt");
System.setErr(fs);
LOCAL=true;
solve();
w.close();
System.err.println(System.currentTimeMillis() - ct);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
void runIO() {
scn = new FastScanner(System.in);
w = new PrintWriter(System.out);
LOCAL=false;
solve();
w.close();
}
class FastScanner {
BufferedReader br;
StringTokenizer st;
public FastScanner(File f) {
try {
br = new BufferedReader(new FileReader(f));
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
public FastScanner(InputStream f) {
br = new BufferedReader(new InputStreamReader(f));
}
String next() {
while (st == null || !st.hasMoreTokens()) {
String s = null;
try {
s = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
if (s == null)
return null;
st = new StringTokenizer(s);
}
return st.nextToken();
}
boolean hasMoreTokens() {
while (st == null || !st.hasMoreTokens()) {
String s = null;
try {
s = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
if (s == null)
return false;
st = new StringTokenizer(s);
}
return true;
}
int nextInt() {
return Integer.parseInt(next());
}
int[] nextIntArray(int n) {
int a[] = new int[n];
for (int i = 0; i < n; i++) {
a[i] = nextInt();
}
return a;
}
long[] nextLongArray(int n) {
long a[] = new long[n];
for (int i = 0; i < n; i++) {
a[i] = nextLong();
}
return a;
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
}
int lowerBound(int[] arr, int x){int n = arr.length, si = 0, ei = n - 1;while(si <= ei){int mid = si + (ei - si)/2;if(arr[mid] == x){if(mid-1 >= 0 && arr[mid-1] == arr[mid]){ei = mid-1;}else{return mid;}}else if(arr[mid] > x){ei = mid - 1; }else{si = mid+1;}}return si; }
int upperBound(int[] arr, int x){int n = arr.length, si = 0, ei = n - 1;while(si <= ei){int mid = si + (ei - si)/2;if(arr[mid] == x){if(mid+1 < n && arr[mid+1] == arr[mid]){si = mid+1;}else{return mid + 1;}}else if(arr[mid] > x){ei = mid - 1; }else{si = mid+1;}}return si; }
int upperBound(ArrayList<Integer> list, int x){int n = list.size(), si = 0, ei = n - 1;while(si <= ei){int mid = si + (ei - si)/2;if(list.get(mid) == x){if(mid+1 < n && list.get(mid+1) == list.get(mid)){si = mid+1;}else{return mid + 1;}}else if(list.get(mid) > x){ei = mid - 1; }else{si = mid+1;}}return si; }
void swap(int[] arr, int i, int j){int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}
long nextPowerOf2(long v){if (v == 0) return 1;v--;v |= v >> 1;v |= v >> 2;v |= v >> 4;v |= v >> 8;v |= v >> 16;v |= v >> 32;v++;return v;}
int gcd(int a, int b) {if(a == 0){return b;}return gcd(b%a, a);} // TC- O(logmax(a,b))
boolean nextPermutation(int[] arr) {if(arr == null || arr.length <= 1){return false;}int last = arr.length-2;while(last >= 0){if(arr[last] < arr[last+1]){break;}last--;}if (last < 0){return false;}if(last >= 0){int nextGreater = arr.length-1;for(int i=arr.length-1; i>last; i--){if(arr[i] > arr[last]){nextGreater = i;break;}}swap(arr, last, nextGreater);}int i = last + 1, j = arr.length - 1;while(i < j){swap(arr, i++, j--);}return true;}
public static void main(String[] args) {
new _1657c().runIO();
}
}
| Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | 4f10a4fb24a50d9be1b98baa4bff60ad | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes | // package faltu;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
import java.util.Map.Entry;
public class Main {
public static int upperBound(long[] arr, long m, int l, int r) {
while(l<=r) {
int mid=(l+r)/2;
if(arr[mid]<=m) l=mid+1;
else r=mid-1;
}
return l;
}
public static int lowerBound(long[] a, long m, int l, int r) {
while(l<=r) {
int mid=(l+r)/2;
if(a[mid]<m) l=mid+1;
else r=mid-1;
}
return l;
}
public static long getClosest(long val1, long val2,long target)
{
if (target - val1 >= val2 - target)
return val2;
else
return val1;
}
static void ruffleSort(long[] a) {
int n=a.length;
Random r=new Random();
for (int i=0; i<a.length; i++) {
long oi=r.nextInt(n), temp=a[i];
a[i]=a[(int)oi];
a[(int)oi]=temp;
}
Arrays.sort(a);
}
static void ruffleSort(int[] a){
int n=a.length;
Random r=new Random();
for (int i=0; i<a.length; i++) {
int oi=r.nextInt(n), temp=a[i];
a[i]=a[oi];
a[oi]=temp;
}
Arrays.sort(a);
}
int ceilIndex(int input[], int T[], int end, int s){
int start = 0;
int middle;
int len = end;
while(start <= end){
middle = (start + end)/2;
if(middle < len && input[T[middle]] < s && s <= input[T[middle+1]]){
return middle+1;
}else if(input[T[middle]] < s){
start = middle+1;
}else{
end = middle-1;
}
}
return -1;
}
public static int findIndex(long arr[], long t)
{
if (arr == null) {
return -1;
}
int len = arr.length;
int i = 0;
while (i < len) {
if (arr[i] == t) {
return i;
}
else {
i = i + 1;
}
}
return -1;
}
static long gcd(long a, long b)
{
if (a == 0)
return b;
return gcd(b % a, a);
}
static int gcd(int a, int b)
{
if (a == 0)
return b;
return gcd(b % a, a);
}
static long lcm(long a,long b)
{
return (a / gcd(a, b)) * b;
}
public static int[] swap(int a[], int left, int right)
{
int temp = a[left];
a[left] = a[right];
a[right] = temp;
return a;
}
public static void swap(long x,long max1)
{
long temp=x;
x=max1;
max1=temp;
}
public static int[] reverse(int a[], int left, int right)
{
// Reverse the sub-array
while (left < right) {
int temp = a[left];
a[left++] = a[right];
a[right--] = temp;
}
return a;
}
static int lowerLimitBinarySearch(ArrayList<Integer> A,int B) {
int n =A.size();
int first = 0,second = n;
while(first <second) {
int mid = first + (second-first)/2;
if(A.get(mid) > B) {
second = mid;
}else {
first = mid+1;
}
}
if(first < n && A.get(first) < B) {
first++;
}
return first; //1 index
}
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br = new BufferedReader(
new InputStreamReader(System.in));
}
String next()
{
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
}
catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() { return Integer.parseInt(next()); }
long nextLong() { return Long.parseLong(next()); }
double nextDouble()
{
return Double.parseDouble(next());
}
String nextLine()
{
String str = "";
try {
str = br.readLine();
}
catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
// *******----segement tree implement---*****
// -------------START--------------------------
void buildTree (int[] arr,int[] tree,int start,int end,int treeNode)
{
if(start==end)
{
tree[treeNode]=arr[start];
return;
}
buildTree(arr,tree,start,end,2*treeNode);
buildTree(arr,tree,start,end,2*treeNode+1);
tree[treeNode]=tree[treeNode*2]+tree[2*treeNode+1];
}
void updateTree(int[] arr,int[] tree,int start,int end,int treeNode,int idx,int value)
{
if(start==end)
{
arr[idx]=value;
tree[treeNode]=value;
return;
}
int mid=(start+end)/2;
if(idx>mid)
{
updateTree(arr,tree,mid+1,end,2*treeNode+1,idx,value);
}
else
{
updateTree(arr,tree,start,mid,2*treeNode,idx,value);
}
tree[treeNode]=tree[2*treeNode]+tree[2*treeNode+1];
}
// disjoint set implementation --start
static void makeSet(int n)
{
parent=new int[n];
rank=new int[n];
for(int i=0;i<n;i++)
{
parent[i]=i;
rank[i]=0;
}
}
static void union(int u,int v)
{
u=findpar(u);
v=findpar(v);
if(rank[u]<rank[v])parent[u]=v;
else if(rank[v]<rank[u])parent[v]=u;
else
{
parent[v]=u;
rank[u]++;
}
}
private static int findpar(int node)
{
if(node==parent[node])return node;
return parent[node]=findpar(parent[node]);
}
static int parent[];
static int rank[];
// *************end
static void presumbit(int[][]prebitsum) {
for(int i=1;i<=200000;i++) {
int z=i;
int j=0;
while(z>0) {
if((z&1)==1) {
prebitsum[i][j]+=(prebitsum[i-1][j]+1);
}else {
prebitsum[i][j]=prebitsum[i-1][j];
}
z=z>>1;
j++;
}
}
}
public static int[] sort(int[] arr) {
ArrayList<Integer> al = new ArrayList<>();
for(int i=0;i<arr.length;i++) al.add(arr[i]);
Collections.sort(al);
for(int i=0;i<arr.length;i++) arr[i]=al.get(i);
return arr;
}
static ArrayList<String>powof2s;
static void powof2S() {
long i=1;
while(i<(long)2e18) {
powof2s.add(String.valueOf(i));
i*=2;
}
}
static boolean coprime(int a, long l){
return (gcd(a, l) == 1);
}
static Long MOD=(long) (1e9+7);
static int prebitsum[][];
static ArrayList<Integer>arr;
static boolean[] vis;
static ArrayList<ArrayList<Integer>>adj;
public static void main(String[] args) throws IOException
{
// sieve();
// prebitsum=new int[200001][18];
// presumbit(prebitsum);
// powof2S();
FastReader s = new FastReader();
long tt = s.nextLong();
while(tt-->0) {
int n=s.nextInt();
char[]ch=s.next().toCharArray();
int ans=0, i=0;
while(i<n) {
if(ch[i]==')') {
int j=i+1;
while(j<n&&ch[j]!=')') {
j++;
}
if(j<n&&ch[j]==')')i=j+1;
else break;
}
else {
if(i+1<n)i+=2;
else break;
}
ans++;
}
System.out.println(ans+" "+(n-i));
}
}
static boolean pal(char[]ch,int i,int j) {
while(i<j) {
if(ch[i]==ch[j]) {
i++;j--;
}
else return false;
}
return true;
}
static void DFSUtil(int v, boolean[] visited)
{
visited[v] = true;
Iterator<Integer> it = adj.get(v).iterator();
while (it.hasNext()) {
int n = it.next();
if (!visited[n])
DFSUtil(n, visited);
}
}
static long DFS(int n)
{
boolean[] visited = new boolean[n+1];
long cnt=0;
for (int i = 1; i <= n; i++) {
if (!visited[i]) {
DFSUtil(i, visited);
cnt++;
}
}
return cnt;
}
public static String revStr(String str){
String input = str;
StringBuilder input1 = new StringBuilder();
input1.append(input);
input1.reverse();
return input1.toString();
}
public static String sortString(String inputString){
char tempArray[] = inputString.toCharArray();
Arrays.sort(tempArray);
return new String(tempArray);
}
static long myPow(long n, long i){
if(i==0) return 1;
if(i%2==0) return (myPow(n,i/2)%MOD * myPow(n,i/2)%MOD)%MOD;
return (n%MOD* myPow(n,i-i)%MOD)%MOD;
}
static void palindromeSubStrs(String str) {
HashSet<String>set=new HashSet<>();
char[]a =str.toCharArray();
int n=str.length();
int[][]dp=new int[n][n];
for(int g=0;g<n;g++){
for(int i=0,j=g;j<n;j++,i++){
if(!set.contains(str.substring(i,i+1))&&g==0) {
dp[i][j]=1;
set.add(str.substring(i,i+1));
}
else {
if(!set.contains(str.substring(i,j+1))&&isPalindrome(str,i,j)) {
dp[i][j]=1;
set.add(str.substring(i,j+1));
}
}
}
}
int ans=0;
for(int i=0;i<n;i++) {
for(int j=0;j<n;j++) {
System.out.print(dp[i][j]+" ");
if(dp[i][j]==1)ans++;
}
System.out.println();
}
System.out.println(ans);
}
static boolean isPalindrome(String str,int i,int j)
{
while (i < j) {
if (str.charAt(i) != str.charAt(j))
return false;
i++;
j--;
}
return true;
}
static boolean sign(long num) {
return num>0;
}
static boolean isSquare(long x){
if(x==1)return true;
long y=(long) Math.sqrt(x);
return y*y==x;
}
static long power1(long a,long b) {
if(b == 0){
return 1;
}
long ans = power(a,b/2);
ans *= ans;
if(b % 2!=0){
ans *= a;
}
return ans;
}
static void swap(StringBuilder sb,int l,int r)
{
char temp = sb.charAt(l);
sb.setCharAt(l,sb.charAt(r));
sb.setCharAt(r,temp);
}
// function to reverse the string between index l and r
static void reverse(StringBuilder sb,int l,int r)
{
while(l < r)
{
swap(sb,l,r);
l++;
r--;
}
}
// function to search a character lying between index l and r
// which is closest greater (just greater) than val
// and return it's index
static int binarySearch(StringBuilder sb,int l,int r,char val)
{
int index = -1;
while (l <= r)
{
int mid = (l+r)/2;
if (sb.charAt(mid) <= val)
{
r = mid - 1;
}
else
{
l = mid + 1;
if (index == -1 || sb.charAt(index) >= sb.charAt(mid))
index = mid;
}
}
return index;
}
// this function generates next permutation (if there exists any such permutation) from the given string
// and returns True
// Else returns false
static boolean nextPermutation(StringBuilder sb)
{
int len = sb.length();
int i = len-2;
while (i >= 0 && sb.charAt(i) >= sb.charAt(i+1))
i--;
if (i < 0)
return false;
else
{
int index = binarySearch(sb,i+1,len-1,sb.charAt(i));
swap(sb,i,index);
reverse(sb,i+1,len-1);
return true;
}
}
private static int lps(int m ,int n,String s1,String s2,int[][]mat)
{
for(int i=1;i<=m;i++)
{
for(int j=1;j<=n;j++)
{
if(s1.charAt(i-1)==s2.charAt(j-1))mat[i][j]=1+mat[i-1][j-1];
else mat[i][j]=Math.max(mat[i-1][j],mat[i][j-1]);
}
}
return mat[m][n];
}
static int lcs(String X, String Y, int m, int n)
{
int[][] L = new int[m+1][n+1];
// Following steps build L[m+1][n+1] in bottom up fashion. Note
// that L[i][j] contains length of LCS of X[0..i-1] and Y[0..j-1]
for (int i=0; i<=m; i++)
{
for (int j=0; j<=n; j++)
{
if (i == 0 || j == 0)
L[i][j] = 0;
else if (X.charAt(i-1) == Y.charAt(j-1))
L[i][j] = L[i-1][j-1] + 1;
else
L[i][j] = Math.max(L[i-1][j], L[i][j-1]);
}
}
return L[m][n];
// Following code is used to print LCS
// int index = L[m][n];
// int temp = index;
//
// // Create a character array to store the lcs string
// char[] lcs = new char[index+1];
// lcs[index] = '\u0000'; // Set the terminating character
//
// // Start from the right-most-bottom-most corner and
// // one by one store characters in lcs[]
// int i = m;
// int j = n;
// while (i > 0 && j > 0)
// {
// // If current character in X[] and Y are same, then
// // current character is part of LCS
// if (X.charAt(i-1) == Y.charAt(j-1))
// {
// // Put current character in result
// lcs[index-1] = X.charAt(i-1);
//
// // reduce values of i, j and index
// i--;
// j--;
// index--;
// }
//
// // If not same, then find the larger of two and
// // go in the direction of larger value
// else if (L[i-1][j] > L[i][j-1])
// i--;
// else
// j--;
// }
// return String.valueOf(lcs);
// Print the lcs
// System.out.print("LCS of "+X+" and "+Y+" is ");
// for(int k=0;k<=temp;k++)
// System.out.print(lcs[k]);
}
static long lis(long[] aa2, int n)
{
long lis[] = new long[n];
int i, j;
long max = 0;
for (i = 0; i < n; i++)
lis[i] = 1;
for (i = 1; i < n; i++)
for (j = 0; j < i; j++)
if (aa2[i] >= aa2[j] && lis[i] <= lis[j] + 1)
lis[i] = lis[j] + 1;
for (i = 0; i < n; i++)
if (max < lis[i])
max = lis[i];
return max;
}
static boolean isPalindrome(String str)
{
int i = 0, j = str.length() - 1;
while (i < j) {
if (str.charAt(i) != str.charAt(j))
return false;
i++;
j--;
}
return true;
}
static boolean issafe(int i, int j, int r,int c, char ch)
{
if (i < 0 || j < 0 || i >= r || j >= c|| ch!= '1')return false;
else return true;
}
static long power(long a, long b)
{
a %=MOD;
long out = 1;
while (b > 0) {
if((b&1)!=0)out = out * a % MOD;
a = a * a % MOD;
b >>= 1;
a*=a;
}
return out;
}
static long[] sieve;
public static void sieve()
{
int nnn=(int) 1e6+1;
long nn=(int) 1e6;
sieve=new long[(int) nnn];
int[] freq=new int[(int) nnn];
sieve[0]=0;
sieve[1]=1;
for(int i=2;i<=nn;i++)
{
sieve[i]=1;
freq[i]=1;
}
for(int i=2;i*i<=nn;i++)
{
if(sieve[i]==1)
{
for(int j=i*i;j<=nn;j+=i)
{
if(sieve[j]==1)
{
sieve[j]=0;
}
}
}
}
}
}
class decrease implements Comparator<Long> {
// Used for sorting in ascending order of
// roll number
public int compare(long a, long b)
{
return (int) (b - a);
}
@Override
public int compare(Long o1, Long o2) {
// TODO Auto-generated method stub
return (int) (o2-o1);
}
}
class pair{
long x;
long y;
long c;
char ch;
public pair(long x,long y) {
this.x=x;
this.y=y;
}
public pair(long x,char ch) {
this.x=x;
this.ch=ch;
}
public pair(long x,long y,long c)
{
this.x=x;
this.y=y;
this.c=c;
}
} | Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | 6e08a7c2613086616a3682cecedea36e | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes | import java.io.BufferedReader;
import java.io.InputStreamReader;
public class HelloWorld{
public static void main(String[] args) throws java.io.IOException {
BufferedReader scan = new BufferedReader(new InputStreamReader(System.in));
int t = Integer.parseInt(scan.readLine());
while(t-- > 0) {
int n = Integer.parseInt(scan.readLine());
char[] s = scan.readLine().toCharArray();
int i=0, ops=0;
while(i < n) {
if(s[i] == '(') {
if(i+1 < n) i += 2;
else break;
}
else {
int j=i+1;
while(j < n && s[j] == '(') j++;
if(j < n && s[j] == ')') i = j+1;
else break;
}
ops++;
}
System.out.println(ops + " " + (n-i));
}
}
} | Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | 06fb33dc968865e9a29672690ba1f6b6 | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes |
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.Stack;
import java.util.*;
public class BracketSequenceDeletion {
static class Pair
{
int f;int s; //
Pair(){}
Pair(int f,int s){ this.f=f;this.s=s;}
}
static class Fast {
BufferedReader br;
StringTokenizer st;
public Fast() {
br = new BufferedReader(
new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
int[] readArray(int n) {
int a[] = new int[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
long[] readArray1(int n) {
long a[] = new long[n];
for (int i = 0; i < n; i++)
a[i] = nextLong();
return a;
}
String nextLine() {
String str = "";
try {
str = br.readLine().trim();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
/* static long noOfDivisor(long a)
{
long count=0;
long t=a;
for(long i=1;i<=(int)Math.sqrt(a);i++)
{
if(a%i==0)
count+=2;
}
if(a==((long)Math.sqrt(a)*(long)Math.sqrt(a)))
{
count--;
}
return count;
}*/
static boolean isPrime(long a) {
for (long i = 2; i <= (long) Math.sqrt(a); i++) {
if (a % i == 0)
return false;
}
return true;
}
static void primeFact(int n) {
int temp = n;
HashMap<Integer, Integer> h = new HashMap<>();
for (int i = 2; i * i <= n; i++) {
if (temp % i == 0) {
int c = 0;
while (temp % i == 0) {
c++;
temp /= i;
}
h.put(i, c);
}
}
if (temp != 1)
h.put(temp, 1);
}
static void reverseArray(int a[]) {
int n = a.length;
for (int i = 0; i < n / 2; i++) {
a[i] = a[i] ^ a[n - i - 1];
a[n - i - 1] = a[i] ^ a[n - i - 1];
a[i] = a[i] ^ a[n - i - 1];
}
}
static void f(int sx, int sy, int n, int m, int i, int j) {
System.out.println(((sx + i - 2) % n + 1) + " " + ((sy - 2 + j) % m + 1));
}
static void solve(int a, int b, int x, int y, int n) {
if (n <= a - x) {
a = a - n;
System.out.println(a * b);
// continue outer;
} else {
a = x;
n = n - (a - x);
if (n <= b - y) {
b = b - n;
System.out.println(a * b);
// continue outer;
} else {
b = y;
System.out.println(a * b);
// continue outer;
}
}
}
static boolean pal(String s)
{
String s1="";
for(int i=0;i<s.length()/2;i++)
{
if(s.charAt(i)!=s.charAt(s.length()-1-i))
return false;
}
return true;
}
static int rec(int idx,int x,int y)
{
if(idx==x)
return 0;
if(y>20)
return 0;
int l=Integer.MAX_VALUE;int r=Integer.MAX_VALUE;
l=1+rec(idx-1,x,y+1);
if(idx<x)
r=1+rec(idx+y,x,y+1);
return l<r?l:r;
}
static boolean regular(String s)
{
Stack<Character> st=new Stack<>();
st.push(s.charAt(0));
int i=1;int f=0;
while(i<s.length())
{
char s2=s.charAt(i++);
if(s2=='(') st.push(s2);
else
{
if(st.size()==0)
{
f=1;break;
}
else st.pop();
}
}
if(f==1) return false;
if(st.size()>0) return false;
return true;
}
public static void main(String args[]) throws IOException {
Fast sc = new Fast();
PrintWriter out = new PrintWriter(System.out);
int t1 = sc.nextInt();
outer:
while (t1-- > 0) {
int n=sc.nextInt();String s1=sc.nextLine();
char s[]=s1.toCharArray();
int i=0;int count=0;int c1=0;int x=0,y=0;
while(i<s1.length())
{
if(c1!=0)
{
if(s[i]==')')
{
c1++;
count+=c1;
c1=0;
i++;y++;
}
else
{
i++;c1++;
}
}
else if(c1==0&&s[i]=='('&&i!=s.length-1)
{
count+=2;
i+=2;x++;
}
else if(c1==0&&s[i]==')')
{
i++;
c1++;
}
else if(i==s.length-1)
i++;
}
out.println(x+y+" "+(n-count));
}
out.close();
}
}
| Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | 5f98dad3dbbbb55cf0baa599216bc592 | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes | import java.util.*;
import javax.management.Query;
import java.io.*;
public class practice {
// static int n,k;
//// static String t,s;
// static long[]memo;
// static int n;
static String s;
static HashMap<Long,Integer>hm;
public static void main(String[] args) throws Exception {
Scanner sc=new Scanner(System.in);
int t=sc.nextInt();
while (t-->0) {
int n=sc.nextInt();
String s=sc.next();
Stack<String>stack=new Stack<>();
StringBuilder sb=new StringBuilder();StringBuilder s2=new StringBuilder();
int c=0;
int r=0;
int cur=0;
boolean f=false,f2=false;
for (int i = 0; i <n ; i++) {
if(f&&!f2) {
c++;
r=i+1;
f=false;
// pw.println(11111);
}else if(!f2&&s.charAt(i)=='(')
f=true;
else if(s.charAt(i)==')'){
if(f2){
r=i+1;
f2=false;
c++;
// pw.println("kk"+i);
}else{
f2=true;
}
}
}
pw.println(c+" "+(n-r));
}
pw.close();
}
static LinkedList getfact(int n){
LinkedList<Integer>ll=new LinkedList<>();
LinkedList<Integer>ll2=new LinkedList<>();
for (int i = 1; i <= Math.sqrt(n); i++) {
if(n%i==0) {
ll.add(i);
if(i!=n/i)
ll2.addLast(n/i);
}
}
while (!ll2.isEmpty()){
ll.add(ll2.removeLast());
}
return ll;
}
static void rev(int n){
String s1=s.substring(0,n);
s=s.substring(n);
for (int i = 0; i <n ; i++) {
s=s1.charAt(i)+s;
}
}
static class SegmentTree { // 1-based DS, OOP
int N; //the number of elements in the array as a power of 2 (i.e. after padding)
long[] array, sTree;
Long[]lazy;
SegmentTree(long[] in)
{
array = in; N = in.length - 1;
sTree = new long[N<<1]; //no. of nodes = 2*N - 1, we add one to cross out index zero
lazy = new Long[N<<1];
build(1,1,N);
}
void build(int node, int b, int e) // O(n)
{
if(b == e)
sTree[node] = array[b];
else
{
int mid = b + e >> 1;
build(node<<1,b,mid);
build(node<<1|1,mid+1,e);
sTree[node] = sTree[node<<1]+sTree[node<<1|1];
}
}
void update_point(int index, int val) // O(log n)
{
index += N - 1;
sTree[index] += val;
while(index>1)
{
index >>= 1;
sTree[index] = sTree[index<<1] + sTree[index<<1|1];
}
}
void update_range(int i, int j, int val) // O(log n)
{
update_range(1,1,N,i,j,val);
}
void update_range(int node, int b, int e, int i, int j, int val)
{
if(i > e || j < b)
return;
if(b >= i && e <= j)
{
sTree[node] = (e-b+1)*val;
lazy[node] = val*1l;
}
else
{
int mid = b + e >> 1;
propagate(node, b, mid, e);
update_range(node<<1,b,mid,i,j,val);
update_range(node<<1|1,mid+1,e,i,j,val);
sTree[node] = sTree[node<<1] + sTree[node<<1|1];
}
}
void propagate(int node, int b, int mid, int e)
{
if(lazy[node]!=null) {
lazy[node << 1] = lazy[node];
lazy[node << 1 | 1] = lazy[node];
sTree[node << 1] = (mid - b + 1) * lazy[node];
sTree[node << 1 | 1] = (e - mid) * lazy[node];
}
lazy[node] = null;
}
long query(int i, int j)
{
return query(1,1,N,i,j);
}
long query(int node, int b, int e, int i, int j) // O(log n)
{
if(i>e || j <b)
return 0;
if(b>= i && e <= j)
return sTree[node];
int mid = b + e >> 1;
propagate(node, b, mid, e);
long q1 = query(node<<1,b,mid,i,j);
long q2 = query(node<<1|1,mid+1,e,i,j);
return q1 + q2;
}
}
// public static long dp(int idx) {
// if (idx >= n)
// return Long.MAX_VALUE/2;
// return Math.min(dp(idx+1),memo[idx]+dp(idx+k));
// }
// if(num==k)
// return dp(0,idx+1);
// if(memo[num][idx]!=-1)
// return memo[num][idx];
// long ret=0;
// if(num==0) {
// if(s.charAt(idx)=='a')
// ret= dp(1,idx+1);
// else if(s.charAt(idx)=='?') {
// ret=Math.max(1+dp(1,idx+1),dp(0,idx+1) );
// }
// }
// else {
// if(num%2==0) {
// if(s.charAt(idx)=='a')
// ret=dp(num+1,idx+1);
// else if(s.charAt(idx)=='?')
// ret=Math.max(1+dp(num+1,idx+1),dp(0,idx+1));
// }
// else {
// if(s.charAt(idx)=='b')
// ret=dp(num+1,idx+1);
// else if(s.charAt(idx)=='?')
// ret=Math.max(1+dp(num+1,idx+1),dp(0,idx+1));
// }
// }
// }
static void putorrem(long x){
if(hm.getOrDefault(x,0)==1){
hm.remove(x);
}
else
hm.put(x,hm.getOrDefault(x,0)-1);
}
public static int max4(int a,int b, int c,int d) {
int [] s= {a,b,c,d};
Arrays.sort(s);
return s[3];
}
public static double logbase2(int k) {
return( (Math.log(k)+0.0)/Math.log(2));
}
static class Scanner {
StringTokenizer st;
BufferedReader br;
public Scanner(InputStream s) {
br = new BufferedReader(new InputStreamReader(s));
}
public Scanner(FileReader r) {
br = new BufferedReader(r);
}
public String next() throws IOException {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
public int nextInt() throws IOException {
return Integer.parseInt(next());
}
public long nextLong() throws IOException {
return Long.parseLong(next());
}
public String nextLine() throws IOException {
return br.readLine();
}
public double nextDouble() throws IOException {
String x = next();
StringBuilder sb = new StringBuilder("0");
double res = 0, f = 1;
boolean dec = false, neg = false;
int start = 0;
if (x.charAt(0) == '-') {
neg = true;
start++;
}
for (int i = start; i < x.length(); i++)
if (x.charAt(i) == '.') {
res = Long.parseLong(sb.toString());
sb = new StringBuilder("0");
dec = true;
} else {
sb.append(x.charAt(i));
if (dec)
f *= 10;
}
res += Long.parseLong(sb.toString()) / f;
return res * (neg ? -1 : 1);
}
public long[] nextlongArray(int n) throws IOException {
long[] a = new long[n];
for (int i = 0; i < n; i++)
a[i] = nextLong();
return a;
}
public Long[] nextLongArray(int n) throws IOException {
Long[] a = new Long[n];
for (int i = 0; i < n; i++)
a[i] = nextLong();
return a;
}
public int[] nextIntArray(int n) throws IOException {
int[] a = new int[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
public Integer[] nextIntegerArray(int n) throws IOException {
Integer[] a = new Integer[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
public boolean ready() throws IOException {
return br.ready();
}
}
static class pair implements Comparable<pair> {
long x;
long y;
public pair(long x, long y) {
this.x = x;
this.y = y;
}
public String toString() {
return x + " " + y;
}
public boolean equals(Object o) {
if (o instanceof pair) {
pair p = (pair) o;
return p.x == x && p.y == y;
}
return false;
}
public int hashCode() {
return new Long(x).hashCode() * 31 + new Long(y).hashCode();
}
public int compareTo(pair other) {
if (this.x == other.x) {
return Long.compare(this.y, other.y);
}
return Long.compare(this.x, other.x);
}
}
static class tuble implements Comparable<tuble> {
int x;
int y;
int z;
public tuble(int x, int y, int z) {
this.x = x;
this.y = y;
this.z = z;
}
public String toString() {
return x + " " + y + " " + z;
}
public int compareTo(tuble other) {
if (this.x == other.x) {
if (this.y == other.y) {
return this.z - other.z;
}
return this.y - other.y;
} else {
return this.x - other.x;
}
}
}
static long mod = 1000000007;
static Random rn = new Random();
static Scanner sc = new Scanner(System.in);
static PrintWriter pw = new PrintWriter(System.out);
} | Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | ffbe7a712fd2d90d4aafcb0c08681762 | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes |
// Online IDE - Code Editor, Compiler, Interpreter
import java.util.*;
import java.util.Collections;
public class C_125
{
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();
sc.nextLine();
String s=sc.nextLine();
int l = 0;
int cnt = 0;
while (l + 1 < n) {
if (s.charAt(l) == '(' || (s.charAt(l) == ')' && s.charAt(l+1) == ')')) {
l += 2;
}else {
int r = l + 1;
while (r < n && s.charAt(r) != ')') {
++r;
}
if (r == n) {
break;
}
l = r + 1;
}
++cnt;
}
System.out.println(cnt+" "+(n-l));
}
}
}
| Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | 7f3834689a8850ab8fc801570f5c4afe | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes |
import java.util.*;
import java.util.stream.Collectors;
import java.io.*;
import java.math.*;
public class ER125_C{
public static FastScanner sc;
public static PrintWriter pw;
public static StringBuilder sb;
public static int MOD= 1000000007;
public static class FastScanner {
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st=new StringTokenizer("");
String next() {
while (!st.hasMoreTokens())
try {
st=new StringTokenizer(br.readLine());
} catch (IOException e) {}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
}
public static void printList(List<Long> al) {
System.out.println(al.stream().map(it -> it.toString()).collect(Collectors.joining(" ")));
}
public static void printList(Deque<Long> al) {
System.out.println(al.stream().map(it -> it.toString()).collect(Collectors.joining(" ")));
}
public static void printArr(long[] arr) {
System.out.println(Arrays.toString(arr).trim().replace("[", "").replace("]","").replace(","," "));
}
public static long gcd(long a, long b) {
if(b==0) return a;
return gcd(b,a%b);
}
public static long lcm(long a, long b) {
return((a*b)/gcd(a,b));
}
public static void decreasingOrder(ArrayList<Long> al) {
Comparator<Long> c = Collections.reverseOrder();
Collections.sort(al,c);
}
public static boolean[] sieveOfEratosthenes(int n) {
boolean isPrime[] = new boolean[n+1];
Arrays.fill(isPrime, true);
isPrime[0]=false;
isPrime[1]=false;
for(int i=2;i*i<n;i++) {
for(int j=2*i;j<n;j+=i) {
isPrime[j]=false;
}
}
return isPrime;
}
public static long nCr(long N, long R) {
double result=1;
for(int i=1;i<=R;i++) result=((result*(N-R+i))/i);
return (long) result;
}
public static long fastPow(long a, long b, int n) {
long result=1;
while(b>0) {
if((b&1)==1)
result=(result*a %n)%n;
a=(a%n * a%n)%n;
b>>=1;
}
return result;
}
public static int BinarySearch(long[] arr, long key) {
int low=0;
int high=arr.length-1;
while(low<=high) {
int mid=(low+high)/2;
if(arr[mid]==key)
return mid;
else if(arr[mid]>key)
high=mid-1;
else
low=mid+1;
}
return low; //High=low-1
}
public static void solve(int t) {
int n=sc.nextInt();
String s=sc.next();
Stack<Integer> st = new Stack<>();
int indexT=n-1;
int count=0;
int i=0;
int rem=0;
while(i+1<n) {
if(s.charAt(i)=='(' && s.charAt(i+1)=='(') {
i+=2;
count++;
}
else if(s.charAt(i)==')' && s.charAt(i+1)==')') {
i+=2;
count++;
}
else if(s.charAt(i)=='(' && s.charAt(i+1)==')') {
i+=2;
count++;
}
else {
int temp=i+1;
int temp2=i;
while(temp<n && s.charAt(temp)=='(') temp++;
if(temp==n) {
break;
}
else {
i=temp+1;
count++;
}
}
}
System.out.println(count+" "+ (n-i));
}
public static void main(String[] args) {
sc = new FastScanner();
pw = new PrintWriter(new OutputStreamWriter(System.out));
sb= new StringBuilder("");
int t=sc.nextInt();
for(int i=1;i<=t;i++) solve(i);
System.out.println(sb);
}
}
| Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | b1c8df3e368b66e14bd9de3744708a8e | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes | import java.io.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.StringTokenizer;
import java.util.logging.Logger;
/**
* Accomplished using the EduTools plugin by JetBrains https://plugins.jetbrains.com/plugin/10081-edutools
*
* To modify the template, go to Preferences -> Editor -> File and Code Templates -> Other
*/
public class Main {
static class InputReader {
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream), 32768);
tokenizer = null;
}
public String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
}
public static class Pair<K extends Comparable<K>,V extends Comparable<V>> implements Comparable<Pair<K,V>> {
private K p1;
private V p2;
public Pair(K p1, V p2) {
this.p1 = p1;
this.p2 = p2;
}
public K getP1() {
return p1;
}
public void setP1(K p1) {
this.p1 = p1;
}
public V getP2() {
return p2;
}
public void setP2(V p2) {
this.p2 = p2;
}
@Override
public int compareTo(Pair<K, V> o) {
if(p1.compareTo(o.getP1()) == 0) {
return p2.compareTo(o.getP2());
}
return p1.compareTo(o.getP1());
}
}
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
Long t = in.nextLong();
while(t-- > 0) {
int n = in.nextInt();
String s = in.next();
int op = 0;
int len = 0;
for(int i = 0;i < n-1;i++) {
if(s.charAt(i) != s.charAt(i + 1) && s.charAt(i) == '(') {
op++;
i++;
len += 2;
} else {
int j = i+1;
for(;j < n;j++) {
if(s.charAt(j) == s.charAt(i)) {
len += (j - i + 1);
op++;
i = j;
break;
}
}
if(j == n) {
i = n;
}
}
}
int tmp = (n - len);
out.write(op + " " + tmp + "\n");
}
out.close();
}
} | Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | 41d56865f05b935e7d82e978071ae5a0 | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes | // Working program with FastReader
import java.io.*;
import java.util.*;
//
public class Example {
static BufferedWriter bw;
static {
bw = new BufferedWriter(new OutputStreamWriter(System.out));
}
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
br = new BufferedReader(
new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
public static void print(String a) throws IOException {
bw.write(a);
}
public static void printSp(String a) throws IOException {
bw.write(a + " ");
}
public static void println(String a) throws IOException {
bw.write(a + "\n");
}
static int min = Integer.MAX_VALUE;
static boolean tt = true;
static int mod = (int) (1e9 + 7);
static long minDIff = Long.MAX_VALUE;
public static void main(String[] args) throws IOException {
FastReader sc = new FastReader();
// BufferedWriter print = new BufferedWriter(new OutputStreamWriter(System.out));
int t=sc.nextInt();
while(t>0){
t--;
int n=sc.nextInt();
String s=sc.next();
int i=0;
int ans=0;
int len=0;
while (i<s.length()-1){
String ss=s.substring(i,i+2);
if(ss.equals("((")){
i=i+2;
ans++;
}else if(ss.equals("))")){
i+=2;
ans++;
}else if(ss.equals("()")){
i+=2;
ans++;
}else{
int j=i;
i=i+2;
boolean tt=false;
while (i<s.length()){
if(s.charAt(i)==')'){
tt=true;
break;
}
i++;
}
if(tt){
ans++;
i++;
}else{
len=n-j;
break;
}
}
}
if(len==0){
len=n-i;
}
System.out.println(ans+" "+len);
}
}
private static int gcd1(int a, int b) {
if(b==0){
return a;
}
return gcd1(b,a%b);
}
private static int solve2(int i, int[] ar, int[] crosses,Map<String,Integer> map) {
if(i==(ar.length)){
return 0;
}
crosses[i]++;
String key=getKey(i,crosses);
if(map.containsKey(key)){
crosses[i]++;
return map.get(key);
}
if(crosses[i]%2!=0){
int p=ar[i];
int a1= ( 1+ solve2(p,ar,crosses,map))%(mod);
map.put(key,a1);
return a1;
}else{
int a2=(1+solve2(i+1,ar,crosses,map))%(mod);
map.put(key,a2);
return a2;
}
}
private static String getKey(int i, int[] crosses) {
StringBuilder key= new StringBuilder();
key.append(i).append("&");
for(int a:crosses){
key.append(a);
}
return key.toString();
}
private static long solve4(int a1, int a2, int b1, int b2, int b3, int b4) {
long ans1=Math.abs(a1-b1);
ans1+=Math.abs(Math.min(Math.abs(a2-b3),Math.abs(a2-b4)));
long ans2=Math.abs(a1-b2);
ans2+=Math.abs(Math.min(Math.abs(a2-b3),Math.abs(a2-b4)));
ans1=Math.min(ans1,ans2);
return ans1;
}
private static long solve1(List<Integer> list1, List<Integer> list2) {
Set<Integer> set= new HashSet<>();
long ans=0;
for(int a:list1){
int ind1=upper(a,list2);
int ind2=lower(a,list2);
long min1=Long.MAX_VALUE;
long min2=Long.MAX_VALUE;
if(ind1!=-1){
min1=list2.get(ind1)-a;
}
if(ind2!=-1){
min2=a-list2.get(ind2);
}
if(min1<min2){
set.add(ind1);
ans+=min1;
}else{
set.add(ind2);
ans+=min2;
}
}
// System.out.println(set+" "+ans);
for(int i=0;i<list1.size();i++){
if(set.add(i)){
int a=list2.get(i);
int ind1=upper(a,list1);
int ind2=lower(a,list1);
long min1=Long.MAX_VALUE;
long min2=Long.MAX_VALUE;
if(ind1!=-1){
min1=list1.get(ind1)-a;
}
if(ind2!=-1){
min2=a-list1.get(ind2);
}
//set.add(ind1);
// set.add(min2);
ans += Math.min(min1, min2);
}
}
return ans;
}
private static int serach(int[] ar, int i) {
for(int i1=0;i1<ar.length;i1++){
if(ar[i1]==i){
return i1;
}
}
return 0;
}
private static int upper(int a, List<Integer> list2) {
int i=0;
int j=list2.size()-1;
int ans=-1;
while (i<=j){
int mid=i+(j-i)/2;
if(list2.get(mid)>=a){
ans=mid;
j=mid-1;
}else{
i=mid+1;
}
}
return ans;
}
private static int lower(int a, List<Integer> list2) {
int i=0;
int j=list2.size()-1;
int ans=-1;
while (i<=j){
int mid=i+(j-i)/2;
if(list2.get(mid)<=a){
ans=mid;
i=mid+1;
}else{
j=mid-1;
}
}
return ans;
}
private static void dfs(List<List<Integer>> list, int i, List<Integer> list1, int[] vis) {
vis[i]=1;
list1.add(i);
for(int child:list.get(i)){
if(vis[child]==0){
dfs(list,child,list1,vis);
}
}
}
public static void permuteHelper(int[] arr, int index) {
if (index >= arr.length - 1) { //If we are at the last element - nothing left to permute
//System.out.println(Arrays.toString(arr));
//Print the array
int ans=0;
for(int i=1;i<arr.length;i++){
ans=ans^(Math.abs(arr[i-1]-arr[i]));
}
if(ans==0&& tt){
tt=false;
for(int a:arr){
System.out.print(a+" ");
}
System.out.println();
}
}
for (int i = index; i < arr.length; i++) { //For each index in the sub array arr[index...end]
//Swap the elements at indices index and i
int t = arr[index];
arr[index] = arr[i];
arr[i] = t;
//Recurse on the sub array arr[index+1...end]
permuteHelper(arr, index + 1);
//Swap the elements back
t = arr[index];
arr[index] = arr[i];
arr[i] = t;
}
}
private static void premutate(char[] cc, int i, int i1,Set<String> set,List<String> list) {
if(i==i1){
if(set.add(String.valueOf(cc))){
list.add(String.valueOf(cc));
}
}else{
for(int i2=i;i2<=i1;i2++){
swap(cc,i,i2);
premutate(cc,i+1,i1,set,list);
swap(cc,i,i2);
}
}
}
public static void isolve(long curr,long sum,int[]ar,int i){
if(i==ar.length){
minDIff=Math.min(minDIff,Math.abs(2*curr-sum));
return;
}
minDIff=Math.min(minDIff,Math.abs(2*curr-sum));
isolve(curr,sum,ar,i+1);
isolve(curr+ar[i],sum,ar,i+1);
}
private static void solve(int s, int d, int h, int n) {
if(n==1){
System.out.println(s+" "+d);
}else{
solve(s,h,d,n-1);
System.out.println(s+" "+d);
solve(h,d,s,n-1);
}
}
private static long power(long b, long c,long mod) {
long ans=1;
while (c>0){
if(c%2==0){
c=c/2;
b=((b*b)%mod);
}else{
c--;
ans=((ans*b)%mod);
}
}
return ans;
}
private static void swap(char[] ar, int i, int i1) {
char temp = ar[i];
ar[i] = ar[i1];
ar[i1] = temp;
}
private static void reverse(int[] ar, int i, int j) {
while (i < j) {
int temp = ar[i];
ar[i] = ar[j];
ar[j] = temp;
i++;
j--;
}
}
private static boolean isPalindrome(String s) {
int i = 0;
int j = s.length() - 1;
while (i <= j) {
if (s.charAt(i) == s.charAt(j)) {
return false;
}
i++;
j--;
}
return true;
}
public static Stack<Integer> reverseTheGroups(Stack<Integer> s, int n, int k) {
// Write your code here.
Deque<Integer> qu= new LinkedList<>();
while(s.size()>=k){
Stack<Integer> temp= new Stack<>();
int tempnum=k;
while(tempnum!=0){
tempnum--;
temp.push(s.pop());
}
while(temp.size()>0){
qu.addLast(temp.pop());
}
}
while(s.size()>0){
qu.add(s.pop());
}
Stack<Integer> st= new Stack<>();
while(qu.size()>0){
st.push(qu.pollLast());
}
return st;
}
}
class Pair{
int a;
int b;
public Pair(int a,int b){
this.a=a;
this.b=b;
}
}
| Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 8 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | 43b50c4c619eb1cbf90e0aefe607e4d0 | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.*;
import static java.lang.Math.*;
import static java.lang.System.*;
import static java.util.Arrays.*;
import static java.util.stream.IntStream.iterate;
public class Template {
private static final FastScanner scanner = new FastScanner();
private static void solve() {
int n = i(), size = n, count = 0;
var a = s().toCharArray();
for (int i = 0; i<n; i++) {
if (a[i] == '(') {
if (i == n-1) break;
size-=2;
count++;
i++;
} else {
boolean bad = true;
for (int j = i+1; j<n; j++) {
if (a[j] == ')') {
size-=(j-i+1);
i = j;
bad = false;
count++;
break;
}
}
if (bad) {
out.println(count+" "+size);
return;
}
}
}
out.println(count+" "+size);
}
public static void main(String[] args) {
int t = i();
while (t-->0) {
solve();
}
}
private static long fac(int n) {
long res = 1;
for (int i = 2; i<=n; i++) {
res*=i;
}
return res;
}
private static BigInteger factorial(int n) {
BigInteger res = BigInteger.valueOf(1);
for (int i = 2; i <= n; i++){
res = res.multiply(BigInteger.valueOf(i));
}
return res;
}
private static long l() {
return scanner.nextLong();
}
private static int i() {
return scanner.nextInt();
}
private static String s() {
return scanner.next();
}
private static void yes() {
out.println("YES");
}
private static void no() {
out.println("NO");
}
private static int toInt(char c) {
return Integer.parseInt(c+"");
}
private static void printArray(long[] a) {
StringBuilder builder = new StringBuilder();
for (long i : a)
builder.append(i).append(' ');
out.println(builder);
}
private static void printArray(int[] a) {
StringBuilder builder = new StringBuilder();
for (int i : a)
builder.append(i).append(' ');
out.println(builder);
}
private static void swap(int[] a, int i, int j) {
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}
private static int binPow(int a, int n) {
if (n == 0)
return 1;
if (n % 2 == 1)
return binPow(a, n-1) * a;
else {
int b = binPow(a, n/2);
return b * b;
}
}
private static boolean isPrime(long n) {
return iterate(2, i -> (long) i * i <= n, i -> i + 1).noneMatch(i -> n % i == 0);
}
private static int gcd(int a, int b) {
return b == 0 ? a : gcd(b, a % b);
}
private static void stableSort(int[] a) {
List<Integer> list = stream(a).boxed().sorted().toList();
setAll(a, list::get);
}
private static int getKthMax(int[] a, int low, int high, int k) {
int pivot = low;
for (int j = low; j < high; j++) {
if (a[j] <= a[high]) {
swap(a, pivot++, j);
}
}
swap(a, pivot, high);
int count = high - pivot + 1;
if (count == k) return a[pivot];
if (count > k) return getKthMax(a, pivot + 1, high, k);
return getKthMax(a, low, pivot - 1, k - count);
}
static class FastScanner {
BufferedReader br = new BufferedReader(new InputStreamReader(in));
StringTokenizer st = new StringTokenizer("");
String next() {
while (!st.hasMoreTokens())
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
int[] readArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++) a[i] = nextInt();
return a;
}
long[] readLong(int n) {
long[] a = new long[n];
for (int i = 0; i<n; i++) a[i] = nextInt();
return a;
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
}
static class SegmentTreeRMXQ {
static int getMid(int s, int e) {
return s + (e - s) / 2;
}
static int MaxUtil(int[] st, int ss, int se, int l, int r, int node) {
if (l <= ss && r >= se)
return st[node];
if (se < l || ss > r)
return -1;
int mid = getMid(ss, se);
return max(
MaxUtil(st, ss, mid, l, r,
2 * node + 1),
MaxUtil(st, mid + 1, se, l, r,
2 * node + 2));
}
static void updateValue(int[] arr, int[] st, int ss, int se, int index, int value, int node) {
if (index < ss || index > se) {
System.out.println("Invalid Input");
return;
}
if (ss == se) {
arr[index] = value;
st[node] = value;
} else {
int mid = getMid(ss, se);
if (index <= mid)
updateValue(arr, st, ss, mid,
index, value,
2 * node + 1);
else
updateValue(arr, st, mid + 1, se, index,
value, 2 * node + 2);
st[node] = max(st[2 * node + 1],
st[2 * node + 2]);
}
}
static int getMax(int[] st, int n, int l, int r) {
if (l < 0 || r > n - 1 || l > r) {
System.out.print("Invalid Input\n");
return -1;
}
return MaxUtil(st, 0, n - 1, l, r, 0);
}
static int constructSTUtil(int[] arr, int ss, int se, int[] st, int si) {
if (ss == se) {
st[si] = arr[ss];
return arr[ss];
}
int mid = getMid(ss, se);
st[si] = max(
constructSTUtil(arr, ss, mid,
st, si * 2 + 1),
constructSTUtil(arr, mid + 1,
se, st,
si * 2 + 2));
return st[si];
}
static int[] constructST(int[] arr, int n) {
int x = (int)Math.ceil(Math.log(n) / Math.log(2));
int max_size = 2 * (int)Math.pow(2, x) - 1;
int[] st = new int[max_size];
constructSTUtil(arr, 0, n - 1, st, 0);
return st;
}
}
static class SegmentTreeRMNQ {
int[] st;
int minVal(int x, int y) {
return min(x, y);
}
int getMid(int s, int e) {
return s + (e - s) / 2;
}
int RMQUtil(int ss, int se, int qs, int qe, int index) {
if (qs <= ss && qe >= se)
return st[index];
if (se < qs || ss > qe)
return Integer.MAX_VALUE;
int mid = getMid(ss, se);
return minVal(RMQUtil(ss, mid, qs, qe, 2 * index + 1),
RMQUtil(mid + 1, se, qs, qe, 2 * index + 2));
}
int RMQ(int n, int qs, int qe) {
if (qs < 0 || qe > n - 1 || qs > qe) {
System.out.println("Invalid Input");
return -1;
}
return RMQUtil(0, n - 1, qs, qe, 0);
}
int constructSTUtil(int[] arr, int ss, int se, int si) {
if (ss == se) {
st[si] = arr[ss];
return arr[ss];
}
int mid = getMid(ss, se);
st[si] = minVal(constructSTUtil(arr, ss, mid, si * 2 + 1),
constructSTUtil(arr, mid + 1, se, si * 2 + 2));
return st[si];
}
void constructST(int[] arr, int n) {
int x = (int) (Math.ceil(Math.log(n) / Math.log(2)));
int max_size = 2 * (int) Math.pow(2, x) - 1;
st = new int[max_size]; // allocate memory
constructSTUtil(arr, 0, n - 1, 0);
}
}
static class SegmentTreeRSQ
{
int[] st; // The array that stores segment tree nodes
/* Constructor to construct segment tree from given array. This
constructor allocates memory for segment tree and calls
constructSTUtil() to fill the allocated memory */
SegmentTreeRSQ(int[] arr, int n)
{
// Allocate memory for segment tree
//Height of segment tree
int x = (int) (Math.ceil(Math.log(n) / Math.log(2)));
//Maximum size of segment tree
int max_size = 2 * (int) Math.pow(2, x) - 1;
st = new int[max_size]; // Memory allocation
constructSTUtil(arr, 0, n - 1, 0);
}
// A utility function to get the middle index from corner indexes.
int getMid(int s, int e) {
return s + (e - s) / 2;
}
/* A recursive function to get the sum of values in given range
of the array. The following are parameters for this function.
st --> Pointer to segment tree
si --> Index of current node in the segment tree. Initially
0 is passed as root is always at index 0
ss & se --> Starting and ending indexes of the segment represented
by current node, i.e., st[si]
qs & qe --> Starting and ending indexes of query range */
int getSumUtil(int ss, int se, int qs, int qe, int si)
{
// If segment of this node is a part of given range, then return
// the sum of the segment
if (qs <= ss && qe >= se)
return st[si];
// If segment of this node is outside the given range
if (se < qs || ss > qe)
return 0;
// If a part of this segment overlaps with the given range
int mid = getMid(ss, se);
return getSumUtil(ss, mid, qs, qe, 2 * si + 1) +
getSumUtil(mid + 1, se, qs, qe, 2 * si + 2);
}
/* A recursive function to update the nodes which have the given
index in their range. The following are parameters
st, si, ss and se are same as getSumUtil()
i --> index of the element to be updated. This index is in
input array.
diff --> Value to be added to all nodes which have I in range */
void updateValueUtil(int ss, int se, int i, int diff, int si)
{
// Base Case: If the input index lies outside the range of
// this segment
if (i < ss || i > se)
return;
// If the input index is in range of this node, then update the
// value of the node and its children
st[si] = st[si] + diff;
if (se != ss) {
int mid = getMid(ss, se);
updateValueUtil(ss, mid, i, diff, 2 * si + 1);
updateValueUtil(mid + 1, se, i, diff, 2 * si + 2);
}
}
// The function to update a value in input array and segment tree.
// It uses updateValueUtil() to update the value in segment tree
void updateValue(int arr[], int n, int i, int new_val)
{
// Check for erroneous input index
if (i < 0 || i > n - 1) {
System.out.println("Invalid Input");
return;
}
// Get the difference between new value and old value
int diff = new_val - arr[i];
// Update the value in array
arr[i] = new_val;
// Update the values of nodes in segment tree
updateValueUtil(0, n - 1, i, diff, 0);
}
// Return sum of elements in range from index qs (query start) to
// qe (query end). It mainly uses getSumUtil()
int getSum(int n, int qs, int qe)
{
// Check for erroneous input values
if (qs < 0 || qe > n - 1 || qs > qe) {
System.out.println("Invalid Input");
return -1;
}
return getSumUtil(0, n - 1, qs, qe, 0);
}
// A recursive function that constructs Segment Tree for array[ss..se].
// si is index of current node in segment tree st
int constructSTUtil(int arr[], int ss, int se, int si)
{
// If there is one element in array, store it in current node of
// segment tree and return
if (ss == se) {
st[si] = arr[ss];
return arr[ss];
}
// If there are more than one elements, then recur for left and
// right subtrees and store the sum of values in this node
int mid = getMid(ss, se);
st[si] = constructSTUtil(arr, ss, mid, si * 2 + 1) +
constructSTUtil(arr, mid + 1, se, si * 2 + 2);
return st[si];
}
}
} | Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 17 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | fc6f88337ea47b06b0153c4ac7f5b56c | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes |
import java.util.*;
public class Test1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
while(t-->0) {
int n = sc.nextInt();
String s = sc.next();
int op = 0, left = n, ind = 0;
while(ind < n-1) {
char ch1 = s.charAt(ind);
if(ch1 == '(') {
op++;
ind += 2;
continue;
}
int j = ind+1;
while(j < n && s.charAt(j) != ch1) j++;
if(j == n) break;
op++;
ind = j+1;
}
left = n-ind;
System.out.println(op+" "+left);
}
// ####################
}
// ####################
}
| Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 17 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | 49e6e6fb5f9ac0376551471b247e8213 | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes | import java.util.*;
public class sol {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int test = sc.nextInt();
while(test-->0){
int n = sc.nextInt();
sc.nextLine();
String s=sc.next();
char[] ch=s.toCharArray();
int i=0,j=1,cnt=0;
while(j<n) {
if(ch[i]=='(') {
cnt++;
i=j+1;
j+=2;
}else {
while(ch[j]!=')'&&j<n) {
j++;
if(j==n) {
break;
}
}
if(j<n) {
cnt++;
i=j+1;
j+=2;
}
}
}
System.out.println(cnt+" "+(n-i));
}
}
} | Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 17 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | 0be4098c201f5667567c432f9b394ad3 | train_110.jsonl | 1647960300 | You are given a bracket sequence consisting of $$$n$$$ characters '(' and/or )'. You perform several operations with it.During one operation, you choose the shortest prefix of this string (some amount of first characters of the string) that is good and remove it from the string.The prefix is considered good if one of the following two conditions is satisfied: this prefix is a regular bracket sequence; this prefix is a palindrome of length at least two. A bracket sequence is called regular if it is possible to obtain a correct arithmetic expression by inserting characters '+' and '1' into this sequence. For example, sequences (())(), () and (()(())) are regular, while )(, (() and (()))( are not.The bracket sequence is called palindrome if it reads the same back and forth. For example, the bracket sequences )), (( and )(() are palindromes, while bracket sequences (), )( and ))( are not palindromes.You stop performing the operations when it's not possible to find a good prefix. Your task is to find the number of operations you will perform on the given string and the number of remaining characters in the string.You have to answer $$$t$$$ independent test cases. | 256 megabytes | import java.util.*;
public class MergeSort {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int test = sc.nextInt();
while(test-->0){
int n = sc.nextInt();
sc.nextLine();
String s=sc.next();
char[] ch=s.toCharArray();
int i=0,j=1,cnt=0;
while(j<n) {
if(ch[i]=='(') {
cnt++;
i=j+1;
j+=2;
}else {
while(ch[j]!=')'&&j<n) {
j++;
if(j==n) {
break;
}
}
if(j<n) {
cnt++;
i=j+1;
j+=2;
}
}
}
System.out.println(cnt+" "+(n-i));
}
}
} | Java | ["5\n2\n()\n3\n())\n4\n((((\n5\n)((()\n6\n)((()("] | 2 seconds | ["1 0\n1 1\n2 0\n1 0\n1 1"] | null | Java 17 | standard input | [
"greedy",
"implementation"
] | af3f3329e249c0a4fa14476626e9c97c | The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The next $$$2t$$$ lines describe test cases. The first line of the test case contains one integer $$$n$$$ ($$$1 \le n \le 5 \cdot 10^5$$$) — the length of the bracket sequence. The second line of the test case contains $$$n$$$ characters '(' and/or ')' — the bracket sequence itself. It is guaranteed that the sum of $$$n$$$ over all test cases do not exceed $$$5 \cdot 10^5$$$ ($$$\sum n \le 5 \cdot 10^5$$$). | 1,200 | For each test case, print two integers $$$c$$$ and $$$r$$$ — the number of operations you will perform on the given bracket sequence and the number of characters that remain in the string after performing all operations. | standard output | |
PASSED | 1e4d586576db028c354bba5182d8c51d | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;
import java.lang.*;
public class Main{
public static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
public static FastReader in = new FastReader();
public static int mod = 1000000007;
public static void main(String[] args) {
try {
int tc = in();
int t=1;
while(t<=tc){
int x = in();
int y = in();
double ans = Math.sqrt(Math.pow(x,2)+Math.pow(y,2));
if(x==0 && y==0){
out.println(0);
}else if(Math.floor(ans) == ans){
out.println(1);
}else{
out.println(2);
}
t++;
}
out.flush();
out.close();
} catch (Exception e) {
e.printStackTrace();
return;
}
}
static void sort(int[] arr){
ArrayList<Integer> ls = new ArrayList<Integer>();
for(int x: arr)ls.add(x);
Collections.sort(ls);
for(int i=0; i < arr.length; i++)arr[i] = ls.get(i);
}
static void sort(long[] arr){
ArrayList<Long> ls = new ArrayList<Long>();
for(long x: arr)ls.add(x);
Collections.sort(ls);
for(int i=0; i < arr.length; i++)arr[i] = ls.get(i);
}
static double pow(double a,long b){
long ans = b;
double res =1;
if(b<0){
ans = -1*b;
}
while(ans>0){
if((ans&1)==1){
res = (res*a);
ans = ans -1;
}else{
a = (a*a);
ans = ans>>1;
}
}
if(b<0){
res = 1/res;
}
return res;
}
static long pow(long a,long b){
long ans = b;
long res =1;
if(b<0){ans = -1*b;}
while(ans>0){
if((ans&1)==1){
res = (res*a);
ans = ans -1;
}else{
a = (a*a)%mod;
ans = ans>>1;
}
}
if(b<0){res = 1/res;}
return res;
}
static int highestPowerOf2(int x){
x |= x >> 1;
x |= x >> 2;
x |= x >> 4;
x |= x >> 8;
x |= x >> 16;
return x ^ (x >> 1);
}
static boolean isPrime(int a){
if (a == 1) return false;
if (a == 2 || a == 3) return true;
if (a%2==0 || a%3==0) return false;
for (int i=5;i*i<=a;i+=6){
if (a%i==0 || a%(i+2)==0) return false;
}
return true;
}
static ArrayList<Integer> getAllPrime(int n){
ArrayList<Integer> ans = new ArrayList<Integer>();
if(n <= 1) return ans;
boolean[] arr = new boolean[n+1];
Arrays.fill(arr,true);
for (int i=2;i*i<=n;i++){
if (arr[i]){
for (int j=i*i;j<=n;j+=i){
arr[j] = false;
}
}
}
for (int i=2;i<=n;i++){
if (arr[i]){
ans.add(i);
}
}
return ans;
}
static long totient(long n){
long result = n;
for (int p = 2; p*p <= n; ++p)
if (n % p == 0)
{
while(n%p == 0)
n /= p;
result -= result/p;
}
if (n > 1)
result -= result/n;
return result;
}
static ArrayList<Integer> allDivisor(int n){
int i=0;
ArrayList<Integer> a = new ArrayList<Integer>();
for (i=1;i*i<=n;i++){
if (n%i==0){
a.add(i);
}
}
for (;i>=1;i--){
if (n%i==0){
a.add(n/i);
}
}
return a;
}
static void primeFactors(int a){
if (a<=1) return;
while (a%2==0) {System.out.printf(2+" "); a=a/2;}
while (a%3==0) {System.out.printf(3+" "); a=a/3;}
for (int i=5;i*i<=a;i+=6){
while (a%i==0){
System.out.printf(i+" ");
a = a/i;
}
while (a%(i+2)==0){
System.out.printf((i+2)+" ");
a = a / (i+2);
}
}
if (a>3){
System.out.printf(a+" ");
}
System.out.println();
}
static int egcd(int a, int b,int x,int y){
if(b == 0){
x = 1;
y = 0;
return a;
}
int x1=1,y1=1;
int ans = egcd(b, a%b,x1,y1);
x = y1;
y = x1 - (a/b)*y1;
System.out.println(x+" "+y);
return ans;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////Lazy work/////////////////////////////////////////////////
static long fib(long n) { // Fn = ( [(1 + sqrt(5))/2] ^ n - [(1 - sqrt(5))/2] ^ n )/ sqrt(5) (binet's formular for fib)
return (long) Math.round((Math.pow((1 + Math.sqrt(5)) / 2, n) - Math.pow((1 - Math.sqrt(5)) / 2, n)) / Math.sqrt(5));
}
static int in(){ return in.nextInt();}
static long inl(){ return in.nextLong();}
static String ins(){ return in.next();}
static double ind() { return Double.parseDouble(in.next());}
static long log2(long N){return (long)(Math.log(N) / Math.log(2));}
static int binaryToInt(String s){return Integer.parseInt(s,2);}
static String toBinaryString(int s){return Integer.toBinaryString(s);}
static int lcm(int a,int b){return a*b/gcd(a,b);}
static int gcd(int a, int b){ if (a==0) return b; return gcd(b%a,a);}
static int bit(long n){return (n==0)?0:(1+bit(n&(n-1)));}
static int cfz(int f){int x = 0;for (int i=5;i<=f;i=i*5)x += f/i;return x;}
static void fill(int[] a){ for(int i=0;i<a.length;i++) a[i] = in.nextInt(); }
static void fill(long[] a){ for(int i=0;i<a.length;i++) a[i] = in.nextLong(); }
static void fill(String[] a){ for(int i=0;i<a.length;i++) a[i] = in.next(); }
static void fill(ArrayList<ArrayList<Integer>> a){for (int i=0;i<a.size()-1;i++){int u = in();int v = in();addEdge(a,u,v);}}
static void addEdge(ArrayList<ArrayList<Integer>> a,int u,int v){a.get(u).add(v);a.get(v).add(u);}
static void fill(int[][] m){for (int i=0;i<m.length;i++){for(int j=0;j<m[i].length;j++){m[i][j] = in();}}}
static void swap(char[] c,int i,int j){ char t = c[i]; c[i] = c[j]; c[j] = t;}
static void swap(int[] c,int i,int j){int t = c[i]; c[i] = c[j]; c[j] = t;}
static void swap(long[] c,int i,int j){long t = c[i]; c[i] = c[j]; c[j] = t;}
static void p(int[] a){ for(int i=0;i<a.length;i++) out.printf(a[i]+" "); out.println(); }
static void p(int[][] a){ for(int i=0;i<a.length;i++){for(int j=0;j<a[i].length;j++)out.printf(a[i][j]+" ");out.println();}}
static void p(long[] a){for(int i=0;i<a.length;i++) out.printf(a[i]+" "); out.println();}
static void p(char[] a){for(int i=0;i<a.length;i++) out.printf(a[i]+" "); out.println();}
static void p(String s){for(int i=0;i<s.length();i++) out.printf(s.charAt(i)+" "); out.println();}
static void p(ArrayList<Integer> a){a.forEach(e -> out.printf(e+" "));out.println();}
static void p(LinkedList<Integer> a){a.forEach(e -> out.printf(e+" "));out.println();}
static void p(HashSet<Integer> a){a.forEach(e -> out.printf(e+" "));out.println();}
static void p(HashMap<Integer,Integer> a){for(Map.Entry<Integer, Integer> mp : a.entrySet())out.println(mp.getKey()+" "+mp.getValue());}
static void reverse(int[] a,int i,int j){while(i<j){int t = a[i];a[i] = a[j];a[j]= t;i++;j--;}}
static String reverse(String s,int i,int j){char[] a = s.toCharArray();while(i<j){char t = a[i];a[i] = a[j];a[j]= t;i++;j--;}return String.valueOf(a);}
static boolean isok(int i,int j,int n,int m){return i >=0 && j>= 0 && i<n && j<m;}
static pair[] alldir(){ return new pair[]{new pair(0,1),new pair(1,0),new pair(0,-1),new pair(-1,0),
new pair(-1,1),new pair(-1,-1),new pair(1,-1),new pair(1,1)};}
static pair[] sides(){ return new pair[]{new pair(0,1),new pair(1,0),new pair(0,-1),new pair(-1,0)};}
static pair[] corners(){ return new pair[]{new pair(-1,1),new pair(-1,-1),new pair(1,-1),new pair(1,1)};}
static int[] dijkstra(ArrayList<ArrayList<ArrayList<Integer>>> g, int source) {
int n = g.size();
int[] dist = new int[n];
Arrays.fill(dist, Integer.MAX_VALUE);
dist[source] = 0;
int[] prev = new int[n];
Arrays.fill(prev, -1);
prev[source] = source;
PriorityQueue<ArrayList<Integer>> pq = new PriorityQueue<>(new Comparator<ArrayList<Integer>>() {
public int compare(ArrayList<Integer> x, ArrayList<Integer> y) {
if(x.get(1) == y.get(1)) return Integer.compare(x.get(0), y.get(0));
return Integer.compare(x.get(1),y.get(1));
}
});
ArrayList<Integer> x = new ArrayList<Integer>();
x.add(source);
x.add(0);
pq.add(x);
while(!pq.isEmpty()) {
ArrayList<Integer> u = pq.poll();
for(ArrayList<Integer> adj : g.get(u.get(0))) {
if(dist[adj.get(0)] > dist[u.get(0)]+adj.get(1)) {
prev[adj.get(0)] = u.get(0);
dist[adj.get(0)] = dist[u.get(0)]+adj.get(1);
ArrayList<Integer> y = new ArrayList<Integer>();
y.add(adj.get(0));
y.add(dist[adj.get(0)]);
pq.add(y);
}
}
}
return dist;
}
static class Triplet implements Comparable<Triplet> {
long x;
long y;
long z;
public Triplet(long x,long y,long z){
this.x = x;
this.y = y;
this.z = z;
}
public String toString() {
return "(" + x + "," + y + "," + z + ")";
}
public int compareTo(Triplet a){
long dif = this.z - a.z;
if (dif > 0) return 1;
if (dif < 0) return -1;
return 0;
}
}
static class Pair implements Comparable<Pair> {
long k;long v;
public Pair(long k, long v) {this.k = k;this.v = v;}
public String toString() {return "(" + k + "," + v + ")";}
public int compareTo(Pair a){
long dif = this.v - a.v;
if (dif > 0) return 1;
if (dif < 0) return -1;
return 0;
}
}
static class pair implements Comparable<pair> {
int k;int v;
public pair(int k, int v) {this.k = k;this.v = v;}
public String toString() {return "(" + k + "," + v + ")";}
public int compareTo(pair a){return this.v-a.v; }
}
static class ncr
{
public int mod = 1000000007;
public long[] fact = new long[mod+1];
public long[] ifact = new long[mod+1];
public int nCr(long n, long r)
{
preFactFermat();
long ans = 1;
// while(n>0 && r>0){
// int a=(int) (n%mod),b= (int)(r%mod);
// n = n/mod;r=r/mod;
// if(a<b){
// return 0;
// }else{
// ans = (ans* (fact[a]*((ifact[b]*ifact[a-b])%mod)%mod))%mod;
// }
// }
ans = lucas(n,r,ans);
return (int)ans;
}
public long lucas(long n,long r,long ans){
if(r==0)return 1;
long ni=n%mod,ri=r%mod;
return (lucas(n/mod,r/mod,ans)*(fermat(ni,ri,ans)%mod))%mod;
}
public long fermat(long n,long r,long ans){
if(n<r){
return 0;
}
ans = (ans* (fact[(int)n]*((ifact[(int)r]*ifact[(int)(n-r)])%mod)%mod))%mod;
return ans;
}
public void preFactFermat(){
fact[1] = 1;
fact[0] = 1;
ifact[0] = expo(1,mod-2);
ifact[1] = expo(1,mod-2);
for(int i=2;i<=mod;i++){
fact[i] = (i*(fact[i-1]%mod))%mod;
ifact[i] = expo(fact[i],mod-2);
}
}
public long expo(long a,long b){
long ans = b;
long res =1;
if(b<0){
ans = -1*b;
}
while(ans>0){
if((ans&1)==1){
res = (res*a)%mod;
}
a = (a*a)%mod;
ans = ans>>1;
}
if(b<0){
res = 1/res;
}
return res;
}
}
static class ft{
int[] ft;
public void print(){
for (int i=0;i<ft.length;i++){
System.out.printf(ft[i]+" ");
}
}
public ft(int[] a){
ft = new int[a.length+1];
for (int i=0;i<a.length;i++){
this.update(i,a[i]);
}
}
public int getSum(int i){
int sum = 0;
while(i>0){
sum += ft[i];
i = i - (i & (-i));
}
return sum;
}
public void update(int i,int d){
i = i +1;
while(i<ft.length){
ft[i] += d;
i = i + (i &(-i));
}
}
}
static class st{
int[] st;
public st(int[] a){
st = new int[a.length*4];
construct(a,0,a.length-1,0);
}
void print(){
for(int i=0;i<st.length;i++){
System.out.printf(st[i]+" ");
}
System.out.println();
}
int construct(int[] a,int ss,int se,int si){
if(ss==se){
st[si] = a[ss];
return a[ss];
}
int mid = (ss+se)/2;
st[si] = construct(a,ss,mid,2*si+1) + construct(a,mid+1,se,2*si+2);
return st[si];
}
int getSum(int qs,int qe,int ss,int se,int si){
if(qe<ss || qs>se){
return 0;
}
if(ss>=qs && se <= qe){
return st[si];
}
int mid = (ss+se)/2;
return getSum(qs,qe,ss,mid,2*si+1) + getSum(qs,qe,mid+1,se,2*si+2);
}
void update(int ss,int se,int si,int i,int diff){
if(ss > i || i> se){
return;
}
this.st[si] += diff;
if(ss< se){
int mid = (ss+se)/2;
update(ss,mid,2*si+1,i,diff);
update(mid+1,se,2*si+2,i,diff);
}
}
}
static class uf {
int count = 0;
int[] parent, rank;
public uf(int n) {
count = n;
parent = new int[n];
rank = new int[n];
for (int i = 0; i < n; i++) {
parent[i] = i;
}
}
public boolean isConnected(int a, int b){return find(a) == find(b);}
public int ct() {return count;}
public int size() {return parent.length;}
public int find(int n) {
while (n != parent[n]) {
parent[n] = parent[parent[n]];
n = parent[n];
}
return n;
}
public void union(int a, int b) {
int rep_a = find(a);
int rep_b = find(b);
if (rep_a == rep_b) return;
if (rank[rep_b] > rank[rep_a]) {
parent[rep_a] = rep_b;
}else {
parent[rep_b] = rep_a;
if (rank[rep_a] == rank[rep_b]) {rank[rep_a]++;}
}
count--;
}
}
static class trie{
trie[] child;
boolean isEnd;
int count;
public trie(){
child = new trie[26];
isEnd = false;
}
public void add(String s){
trie cur = this;
for(int i=0;i<s.length();i++){
int c = s.charAt(i) - 'a';
if(cur.child[c]==null){cur.child[c] = new trie();}
cur = cur.child[c];
}
count++;
cur.isEnd=true;
}
public boolean contains(String s){
trie cur = this;
for(int i=0;i<s.length();i++){
int c = s.charAt(i) - 'a';
if(cur.child[c]==null){return false;}
cur = cur.child[c];
}
return cur.isEnd;
}
public boolean containsPrefix(String s){
trie cur = this;
for(int i=0;i<s.length();i++){
int c = s.charAt(i) - 'a';
if(cur.child[c]==null){return false;}
cur = cur.child[c];
}
return true;
}
public trie delete(String key,int i){
trie root = this;
if (root==null){return null;}
if (i==key.length()){
root.isEnd = false;
if (root.isEmpty()){root = null;}
return root;
}
int c = key.charAt(i)-'a';
root.child[c]= delete(key,i+1);
if (root.isEmpty() && root.isEnd==false){ root = null; }
return root;
}
public trie remove(String s){return delete(s,0);}
public boolean isEmpty(){return count==0;}
public int size(){ return count;}
}
static class FastReader{
BufferedReader br;
StringTokenizer st;
public FastReader(){
br=new BufferedReader(new InputStreamReader(System.in));
}
String next(){
while(st==null || !st.hasMoreTokens()){
try {
st=new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt(){
return Integer.parseInt(next());
}
long nextLong(){
return Long.parseLong(next());
}
double nextDouble(){
return Double.parseDouble(next());
}
String nextLine(){
String str="";
try {
str=br.readLine().trim();
} catch (Exception e) {
e.printStackTrace();
}
return str;
}
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 0e0f538d4df27cfd1bb1d319e30cd5a9 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.*;
import java.lang.*;
import java.math.*;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
while(t-->0){
int x = sc.nextInt();
int y = sc.nextInt();
boolean ans = checkPerfectSquare(Math.pow(x,2)+Math.pow(y,2));
// out.println(ans);
if(x==0 && y==0){
System.out.println(0);
}else if(ans){
System.out.println(1);
}else{
System.out.println(2);
}
}
}
static boolean checkPerfectSquare(double number)
{
//calculating the square root of the given number
double sqrt=Math.sqrt(number);
//finds the floor value of the square root and comparing it with zero
return ((sqrt - Math.floor(sqrt)) == 0);
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 47c066d4c488b177c5986426389953bf | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes |
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class Main {
static class MyScanner {
BufferedReader br;
StringTokenizer st;
public MyScanner() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine(){
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
static class TreeMultiSet<T> implements Iterable<T>
{
private final TreeMap<T,Integer> map;
private int size;
public TreeMultiSet(){map=new TreeMap<>(); size=0;}
public TreeMultiSet(boolean reverse)
{
if(reverse) map=new TreeMap<>(Collections.reverseOrder());
else map=new TreeMap<>(); size=0;
}
public void clear(){map.clear(); size=0;}
public int size(){return size;}
public int setSize(){return map.size();}
public boolean contains(T a){return map.containsKey(a);}
public boolean isEmpty(){return size==0;}
public Integer get(T a){return map.getOrDefault(a,0);}
public void add(T a, int count)
{
int cur=get(a);map.put(a,cur+count); size+=count;
if(cur+count==0) map.remove(a);
}
public void addOne(T a){add(a,1);}
public void remove(T a, int count){add(a,Math.max(-get(a),-count));}
public void removeOne(T a){remove(a,1);}
public void removeAll(T a){remove(a,Integer.MAX_VALUE-10);}
public T ceiling(T a){return map.ceilingKey(a);}
public T floor(T a){return map.floorKey(a);}
public T first(){return map.firstKey();}
public T last(){return map.lastKey();}
public T higher(T a){return map.higherKey(a);}
public T lower(T a){return map.lowerKey(a);}
public T pollFirst(){T a=first(); removeOne(a); return a;}
public T pollLast(){T a=last(); removeOne(a); return a;}
public Iterator<T> iterator()
{
return new Iterator<>()
{
private final Iterator<T> iter = map.keySet().iterator();
private int count = 0; private T curElement;
public boolean hasNext(){return iter.hasNext()||count>0;}
public T next()
{
if(count==0)
{
curElement=iter.next();
count=get(curElement);
}
count--; return curElement;
}
};
}
}
static long abs(long x){
if(x<0) x*=-1;
return x;
}
static int sqrt(int x) {
double t = Math.sqrt((double) x);
return (int)t;
}
static boolean checkPalindorm(String x) {
for(int i=0;i<x.length();i++) {
if(x.charAt(i) != x.charAt(x.length() -1 - i)) {
return false;
}
}
return true;
}
public static void main(String[] args) {
MyScanner scanner = new MyScanner();
int t = scanner.nextInt();
while(t-- != 0){
int tar1 = scanner.nextInt();
int tar2 = scanner.nextInt();
if (tar1 == 0 && tar2 == 0)
System.out.println("0");
else {
int x = tar1 * tar1 + tar2 * tar2;
int y = sqrt(x);
if ( y*y == x) {
System.out.println("1");
}else {
System.out.println("2");
}
}
}
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | edce35efcef844d95a961b04e5a7c284 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.*;
import java.io.*;
public class Main{
public static void main(String args[])throws IOException{
// int dp[][]=new int[51][51];
// for(int i=0;i<=50;i++){
// for(int j=0;j<=50;j++){
// if(i==0&&j==0){
// dp[i][j]=0;
// continue;
// }
// int d=(i*i)+(j*j);
// double dist=Math.sqrt(d);
// if(d==(dist*dist)){
// dp[i][j]=1;
// }else{
// int min=50;
// for(int x=0;x<=i;x++){
// for(int y=0;y<=j;y++){
// if(x==i&&y==j)continue;
// int xd=i-x;
// int yd=j-x;
// int dd=(xd*xd)+(yd*yd);
// double distd=Math.sqrt(dd);
// if(dd==(distd*distd)){
// min=Math.min(min,dp[x][y]);
// }
// }
// }
// dp[i][j]=min+1;
// }
// }
// }
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
int t=Integer.parseInt(br.readLine());
while(t-->0){
String inp[]=br.readLine().split(" ");
int x=Integer.parseInt(inp[0]);
int y=Integer.parseInt(inp[1]);
int d=(x*x)+(y*y);
double sqrt=Math.sqrt(d);
int s=(int)sqrt;
if(x==0&&y==0){
System.out.println("0");
}else if(s==sqrt){
System.out.println("1");
}else{
System.out.println("2");
}
// System.out.println(dp[x][y]);
}
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 7e7b4fd5d784349060dd0a7260c95bdd | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 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 Main
{
public static void main (String[] args) throws java.lang.Exception
{
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
while(t-->0){
int x1 = sc.nextInt();
int y1 = sc.nextInt();
if(x1==0&&y1==0){
System.out.println(0);
continue;
}
int t1 = (x1)*(x1);
int t2 = (y1)*(y1);
double t3 = Math.sqrt((double)t1+t2);
if(t3==(int)t3){
System.out.println(1);
}
else System.out.println(2);
}
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | b6e52adae6bf674c65a7734e6ef03bb8 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | // package com.company;
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
for (int i = 0; i < num; i++) {
int x = sc.nextInt();
int y = sc.nextInt();
double xsquare = x*x+y*y;
double underroo = Math.sqrt(xsquare);
long underroot=(long)underroo;
// System.out.println(underroot);
if (x==0&&y==0){
System.out.println(0);
}
else if (underroot*underroot ==xsquare){
System.out.println(1);
}
else {
System.out.println(2);
}
}
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 54291a6f168f7ff69c7e6b7d55ec3150 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | /* package codechef; // don't place package name! */
import java.util.*;
import java.lang.*;
import java.io.*;
/* Name of the class has to be "Main" only if the class is public. */
public class Codechef
{
public static void main (String[] args) throws java.lang.Exception
{
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
while(t -->0){
int x = sc.nextInt();
int y = sc.nextInt();
if((x==0) && (y==0)){
System.out.println(0);
}
else{
int g1 =x*x;
int g2 =y*y;
int a =g1+g2;
int sqrtd = (int)Math.sqrt(a);
if (sqrtd*sqrtd ==a){
System.out.println(1);
}
else{
System.out.println(2);
}
}
}
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | ec68eefcfab7d817add1a4890240713d | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.Scanner;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.lang.Integer;
import java.lang.Math;
// import org.apache.commons.lang.ArrayUtils;
public class codeforces_java {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
while (n-- >0)
{
double x = in.nextDouble();
double y = in.nextDouble();
x = Math.sqrt(x*x+y*y);
if (x==0) System.out.println(0);
else if (x==(int)x) System.out.println(1);
else System.out.println(2);
}
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 2bc2aece2851e5886bd43a6ba5e2ec45 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | //package cf;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
public class integer_move {
static int map[][]=new int[51][51];
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
for(int i=0;i<=50;++i)
for(int j=0;j<=50;++j) {
int c=(int)Math.sqrt((double)(i*i+j*j));
if(c*c==i*i+j*j) {
map[i][j]=1;
//System.out.println(i+" "+j);
};
}
while(n>0) {
--n;
int x=sc.nextInt(),y=sc.nextInt();
if(x==0&&y==0)System.out.println(0);
else if(map[x][y]==1)System.out.println(1);
else System.out.println(2);
}
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | c1ab70ea5ba0f9a3b0189352618dea12 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.*;
public class A{
static Scanner sc = new Scanner(System.in);
public static void main(String[] args){
int t =sc.nextInt();
while(t-->0)
solve();
}
public static void solve(){
int x = sc.nextInt();
int y = sc.nextInt();
double dis = Math.sqrt(Math.pow(x,2)+Math.pow(y,2));
if(x==0&&y==0)
System.out.println(0);
else if(dis==Math.floor(dis))
System.out.println(1);
else
System.out.println(2);
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 016d362c02aacba15ea7189428bc8634 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.*;
public class Main{
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int noOfTestCases = scan.nextInt();
for(int i = 0; i < noOfTestCases; i++){
int x1 = scan.nextInt();
int y1 = scan.nextInt();
neededMoves(x1, y1);
}
}
public static void neededMoves(int x1, int y1){
if(x1 == 0 && y1 == 0){
System.out.println(0);
} else if(isASquare(x1 * x1 + y1 * y1)){
System.out.println(1);
} else{
System.out.println(2);
}
}
public static boolean isASquare(int num){
for (int i = 0; i <= num; i++){
if (i * i == num) {
return true;
}
}
return false;
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | b7be571eaafaa8eccb55dcf6887d0517 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.*;
public class Main{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
int t=sc.nextInt();
while(t-->0)
{
int a=sc.nextInt();
int b=sc.nextInt();
if(a==0&&b==0)
{ System.out.println(0);
continue;}
if(a==0||b==0)
{ System.out.println(1);
continue;}
int tmp=(a)*(a)+(b)*(b);
int d=(int)Math.sqrt(tmp);
if(d*d==tmp)
{ System.out.println(1);
continue;}
System.out.println(2);
}
}} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 8ad516fd88f9d6ff884a38946a61a6d3 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes |
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.HashSet;
import java.util.Random;
import java.util.StringTokenizer;
import javax.lang.model.util.ElementScanner6;
public class IntegerValues {
static long power(long pow, long pow2, long mod)
{
long res = 1; // Initialize result
pow = pow % mod; // Update x if it is more than or
// equal to p
if (pow == 0)
return 0; // In case x is divisible by p;
while (pow2 > 0)
{
// If y is odd, multiply x with result
if ((pow2 & 1) != 0)
res = (res * pow) % mod;
// y must be even now
pow2 = pow2 >> 1; // y = y/2
pow = (pow * pow) % mod;
}
return res;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
StringBuilder st = new StringBuilder();
FastReader sc = new FastReader();
int t=sc.nextInt();
while (t-- != 0) {
int x=sc.nextInt();
int y=sc.nextInt();
int count=0;
boolean dp[][]=new boolean[51][51];
dp[0][0]=true;
boolean flag=false;
if(x==0&&y==0)
{
st.append(0+"\n");
}
else if(checkSquare(x, y))
{
st.append(1+"\n");
}
else {
//0,0 to x,0 and x,0 to x,y there are maximum of 2 moves
st.append(2+"\n");
}
}
System.out.println(st);
}
static boolean checkSquare(int a,int b)
{
int square=(a*a+b*b);
int sqt=(int)(Math.sqrt(square));
if(sqt*sqt==square)
{
return true;
}
return false;
}
static int minCount(int count,int x,int y,boolean dp[][])
{
if(x<0||y<0)
{
return Integer.MIN_VALUE;
}
if(dp[x][y])
{
return 1+count;
}
if(x==0&&y==0)
{
return count;
}
int ans=Integer.MIN_VALUE;
for(int i=1;i<=50;i++)
{
for(int j=1;j<=50;j++)
{
if(checkSquare(i, j))
{
if(checkSquare(x-i, y-j))
{
return 1+count;
}
else{
ans=minCount(count+1, x-i, y-j,dp);
// if(ans!=Integer.MIN_VALUE)
// {
// return ans;
// }
}
// if(checkSquare(x, y))
// {
// st.append(count+"\n");
// flag=true;
// break;
// }
// else{
// count--;
// x=x+i;
// y=y+j;
// }
}
}
}
return ans;
}
static FastReader sc = new FastReader();
public static void solvegraph() {
int n = sc.nextInt();
int edge[][] = new int[n - 1][2];
for (int i = 0; i < n - 1; i++) {
edge[i][0] = sc.nextInt() - 1;
edge[i][1] = sc.nextInt() - 1;
}
ArrayList<ArrayList<Integer>> ad = new ArrayList<>();
for (int i = 0; i < n; i++) {
ad.add(new ArrayList<Integer>());
}
for (int i = 0; i < n - 1; i++) {
ad.get(edge[i][0]).add(edge[i][1]);
ad.get(edge[i][1]).add(edge[i][0]);
}
int parent[] = new int[n];
Arrays.fill(parent, -1);
parent[0] = n;
ArrayDeque<Integer> queue = new ArrayDeque<>();
queue.add(0);
int child[] = new int[n];
Arrays.fill(child, 0);
ArrayList<Integer> lv = new ArrayList<Integer>();
while (!queue.isEmpty()) {
int toget = queue.getFirst();
queue.removeFirst();
child[toget] = ad.get(toget).size() - 1;
for (int i = 0; i < ad.get(toget).size(); i++) {
if (parent[ad.get(toget).get(i)] == -1) {
parent[ad.get(toget).get(i)] = toget;
queue.addLast(ad.get(toget).get(i));
}
}
lv.add(toget);
}
child[0]++;
}
static void sort(int[] A) {
int n = A.length;
Random rnd = new Random();
for (int i = 0; i < n; ++i) {
int tmp = A[i];
int randomPos = i + rnd.nextInt(n - i);
A[i] = A[randomPos];
A[randomPos] = tmp;
}
Arrays.sort(A);
}
static void sort(long[] A) {
int n = A.length;
Random rnd = new Random();
for (int i = 0; i < n; ++i) {
long tmp = A[i];
int randomPos = i + rnd.nextInt(n - i);
A[i] = A[randomPos];
A[randomPos] = tmp;
}
Arrays.sort(A);
}
static String sort(String s) {
Character ch[] = new Character[s.length()];
for (int i = 0; i < s.length(); i++) {
ch[i] = s.charAt(i);
}
Arrays.sort(ch);
StringBuffer st = new StringBuffer("");
for (int i = 0; i < s.length(); i++) {
st.append(ch[i]);
}
return st.toString();
}
public static long gcd(long a, long b) {
if (a == 0) {
return b;
}
return gcd(b % a, a);
}
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 626d4bb4df88ae846cbc5f9e536eb4f5 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes |
import java.io.*;
import java.lang.*;
import java.util.*;
public class solut {
public static void main (String[] args){
int t=sc.nextInt();
while(t--!=0) {
int x=sc.nextInt();int y=sc.nextInt();
if(x==0&&y==0) {
out.println(0);
}else {
double sq=(Math.pow(x, 2)+Math.pow(y, 2));
if(Math.ceil((double)Math.sqrt(sq)) ==
Math.floor((double)Math.sqrt(sq))) {
out.println(1);
}else {
out.println(2);
}
}
}
////////////////////////////////////////////////////////////////////
out.flush();out.close();
}//*END OF MAIN METHOD*
static final Random random = new Random();
static void sort(int arr[]) {
int n = arr.length;
for(int i = 0; i < n; i++) {
int j = random.nextInt(n),temp = arr[j];
arr[j] = arr[i];
arr[i] = temp;
}
Arrays.sort(arr);
}
static class FastScanner {
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st=new StringTokenizer("");
String next() {
while (!st.hasMoreTokens())
try {
st=new StringTokenizer(br.readLine());
} catch (IOException e) {e.printStackTrace();
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long[] readArrayL(int n) {
long a[]=new long[n];
for(int i=0;i<n;i++) a[i]=nextLong();
return a;
}
int[] readArray(int n) {
int[] a=new int[n];
for (int i=0; i<n; i++) a[i]=nextInt();
return a;
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
}
static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));//PRINTLN METHOD
static FastScanner sc = new FastScanner();//FASTSCANNER OBJECT
}//*END OF MAIN CLASS*
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 0a6116c48ec637012fabc6bb1c783494 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.*;
public class solut {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int t=sc.nextInt();
while(t--!=0) {
int x=sc.nextInt();int y=sc.nextInt();
if(x==0&&y==0) {
System.out.println(0);
}else {
double sq=(Math.pow(x, 2)+Math.pow(y, 2));
if(Math.ceil((double)Math.sqrt(sq)) ==
Math.floor((double)Math.sqrt(sq))) {
System.out.println(1);
}else {
System.out.println(2);
}
}
}
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | f022327181017bf8b35a733a0e8dbcca | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.*;
public class solut {
static Scanner sc=new Scanner(System.in);
public static void main(String[] args) {
int t=sc.nextInt();
while(t--!=0) {
int x=sc.nextInt();int y=sc.nextInt();
if(x==0&&y==0) {
System.out.println(0);
}else {
double sq=(Math.pow(x, 2)+Math.pow(y, 2));
if(Math.ceil((double)Math.sqrt(sq)) ==
Math.floor((double)Math.sqrt(sq))) {
System.out.println(1);
}else {
System.out.println(2);
}
}
}
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 0b1ae2fba01070e8ecdc310e38fb7a58 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.Scanner;
public class IntegerMoves {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
int t;
try {
t = sc.nextInt();
}catch(Exception e) {
t=0;
}
while(t-- > 0) {
int x2;
try {
x2 = sc.nextInt();
}catch(Exception e) {
break;
}
int y2;
try {
y2 = sc.nextInt();
}catch(Exception e) {
break;
}
int x1=0;
int y1=0;
boolean flag = true;
int count = 0;
while(flag) {
if(x2==0 && y2==0) {
break;
}
double first = Math.pow((x1-x2), 2);
double second = Math.pow((y1-y2), 2);
double ans = Math.pow(first+second, 0.5);
if(ans == (int)ans) {
count++;
flag = false;
}else {
count+=2;
flag = false;
}
}
System.out.println(count);
}
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 94be937c2fb6fa02c077fde54636d0a9 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.*;
import java.lang.*;
public class demo{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
while(t-->0)
{
int x = sc.nextInt();
int y = sc.nextInt();
if(x==0 && y==0)
System.out.println("0");
else if(Math.sqrt(x*x+y*y)%1==0)
System.out.println("1");
else
System.out.println("2");
}
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | bc49cc3f15bb9c5d591ae25503fc841b | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.Deque;
import java.util.Queue;
public class A {
static final Reader in = new Reader();
static final PrintWriter out = new PrintWriter(System.out);
static final int maxX = 50, maxY = 50, INF = Integer.MAX_VALUE / 2;
static int[][] distMap = new int[maxX + 1][maxY + 1];
static {
for (int[] row : distMap) {
Arrays.fill(row, INF);
}
Deque<int[]> q = new ArrayDeque<>();
q.add(new int[]{0, 0, 0});
distMap[0][0] = 0;
while (!q.isEmpty()) {
int[] cur = q.remove();
for (int i = cur[0]; i <= maxX; i++) {
for (int j = cur[1]; j <= maxY; j++) {
if (distMap[i][j] == INF && distIsInt(cur[0], cur[1], i, j)) {
distMap[i][j] = cur[2] + 1;
q.add(new int[]{i, j, cur[2] + 1});
}
}
}
}
}
static boolean distIsInt(int x1, int y1, int x2, int y2) {
int dist = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
int squared = (int) Math.sqrt(dist);
return Math.pow(squared, 2) == dist;
}
public static void main(String[] args) {
int t = in.nextInt();
for (int tc = 1; tc <= t; tc++) {
solve();
out.println();
}
out.close();
}
static void solve() {
int x = in.nextInt(), y = in.nextInt();
out.print(distMap[x][y]);
}
static class Reader {
private final int BUFFER_SIZE = 1 << 16;
private final DataInputStream din;
private final byte[] buffer;
private int bufferPointer, bytesRead;
Reader() {
din = new DataInputStream(System.in);
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
Reader(InputStream in) {
try {
din = new DataInputStream(in);
} catch (Exception e) {
throw new RuntimeException();
}
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
String next() {
int c;
while ((c = read()) != -1 && (c == ' ' || c == '\n' || c == '\r')) ;
StringBuilder s = new StringBuilder();
while (c != -1) {
if (c == ' ' || c == '\n' || c == '\r')
break;
s.append((char) c);
c = read();
}
return s.toString();
}
String nextLine() {
int c;
while ((c = read()) != -1 && (c == ' ' || c == '\n' || c == '\r')) ;
StringBuilder s = new StringBuilder();
while (c != -1) {
if (c == '\n' || c == '\r')
break;
s.append((char) c);
c = read();
}
return s.toString();
}
int nextInt() {
int ret = 0;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do
ret = ret * 10 + c - '0';
while ((c = read()) >= '0' && c <= '9');
if (neg)
return -ret;
return ret;
}
int[] nextInts(int n) {
int[] ar = new int[n];
for (int i = 0; i < n; ++i)
ar[i] = nextInt();
return ar;
}
long nextLong() {
long ret = 0;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do
ret = ret * 10 + c - '0';
while ((c = read()) >= '0' && c <= '9');
if (neg)
return -ret;
return ret;
}
long[] nextLongs(int n) {
long[] ar = new long[n];
for (int i = 0; i < n; ++i)
ar[i] = nextLong();
return ar;
}
double nextDouble() {
double ret = 0, div = 1;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do
ret = ret * 10 + c - '0';
while ((c = read()) >= '0' && c <= '9');
if (c == '.')
while ((c = read()) >= '0' && c <= '9')
ret += (c - '0') / (div *= 10);
if (neg)
return -ret;
return ret;
}
void fillBuffer() throws IOException {
bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
if (bytesRead == -1)
buffer[0] = -1;
}
byte read() {
try {
if (bufferPointer == bytesRead)
fillBuffer();
return buffer[bufferPointer++];
} catch (IOException e) {
throw new RuntimeException();
}
}
void close() throws IOException {
din.close();
}
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | f7bf1c14570b3d8605f50f6c18495ac9 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.*;
public class Main
{
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int t=sc.nextInt();
while(t>0)
{
int x=sc.nextInt();
int y=sc.nextInt();
if(x==0&&y==0)
{
System.out.println(0);
}
else{
int a=x*x;
int b=y*y;
int l=(int)Math.sqrt(a+b);
if((l*l)==a+b)
{
System.out.println(1);
}
else{
System.out.println(2);
}
}
t--;
}
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | d086f9a134eb2f12e6c97227009ff34d | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.*;
public class Main
{
public static boolean check_sqrt(int x,int y)
{
double sq = Math.sqrt( (x*x)+(y*y) );
return ((sq - Math.floor(sq)) == 0);
}
public static void main(String[] args)
{
int q;
Scanner sc = new Scanner(System.in);
q = sc.nextInt();
while(q--!=0)
{
int x,y;
x = sc.nextInt();
y = sc.nextInt();
if(x==0 && y==0)
{
System.out.println(0);
}
else
{
if (check_sqrt(x,y))
{
System.out.println(1);
}
else
{
System.out.println(2);
}
}
}
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 068f847b43b484c4453436d687bf16c6 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.*;
public class IntegerMoves{
public static int getMinSquare(int x, int y, int d){
int r = 0;
while (r * r < d) ++r;
int ans = 2;
if (r * r == d) ans = 1;
if (x == 0 && y == 0) ans = 0;
return ans;
}
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int tests = sc.nextInt();
for(int test = 0; test < tests; test++){
int x = sc.nextInt();
int y = sc.nextInt();
int dis = ((x*x) + (y*y));
System.out.println(getMinSquare(x, y, dis));
}
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 839fc712ad327e8e6907a55534224a95 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.*;
import javax.swing.plaf.synth.SynthDesktopIconUI;
import java.lang.*;
import java.io.*;
public class Main
{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
for(int i=0;i<n;i++){
int a = sc.nextInt();
int b = sc.nextInt();
int x = a*a;
int y = b*b;
int v = x+y;
// System.out.println(y);
// System.out.println(perfectsquare(v));
if(x==0 && y==0){
System.out.println("0");
}
else if(perfectsquare(v)){
System.out.println("1");
}
else{
System.out.println("2");
}
}
}
public static String remVowel(String str)
{
return str.replaceAll("[aeiouAEIOU]", "");
}
public static String Ssort(String s) {
char tempArray[] = s.toCharArray();
Arrays.sort(tempArray);
return new String(tempArray);
}
public static int smallest(int x, int y,int z ) {
return Math.min(Math.min(x, y), z);
}
public static int largest(int x,int y, int z) {
return Math.max(Math.max(x, y), z);
}
public static int average(int x,int y,int z) {
return(x+y+z)/3;
}
public static int sumdigit(long x) {
int result = 0;
while(x>0){
result+=x%10;
x/=10;
}
return result;
}
public static String isPowerOfTwo(long n)
{
if (n == 0)
return ("Yes");
while (n != 1)
{
if (n % 2 != 0)
return ("Yes");
n = n / 2;
}
return ("No");
}
public static char[] swap(String s)
{
char ch[] = s.toCharArray();
char temp = ch[0];
ch[0] = ch[s.length()-1];
ch[s.length()-1] = temp;
return ch;
}
public static boolean perfectsquare(int x)
{
if (x >= 0) {
int sr = (int)Math.sqrt(x);
return ((sr * sr) == x);
}
return false;
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | cd8acd7b0256a2f60a30fabfdb5afef5 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.Scanner;
import java.util.ArrayList;
public class Main
{
static Scanner scanner = new Scanner(System.in);
public static void main(String[] args) throws Exception
{
int distance[][] = bfs();
int tc = scanner.nextInt();
while (tc > 0)
{
int x = scanner.nextInt();
int y = scanner.nextInt();
System.out.println(distance[x][y]);
tc --;
}
}
static int[][] bfs()
{
int maxX = 50, maxY = 50;
int inf = 10000;
int[][] dist = new int[maxX+1][maxY+1];
for (int i=0; i<=maxX; i++)
for (int j=0; j<=maxY; j++)
dist[i][j] = inf;
dist[0][0] = 0;
ArrayList<Integer[]> bfsQueue = new ArrayList<>();
Integer[] start = {0, 0};
bfsQueue.add(start);
while (!bfsQueue.isEmpty())
{
Integer[] currPoint = bfsQueue.get(bfsQueue.size()-1);
bfsQueue.remove(bfsQueue.size()-1);
for (int i=0; i<=maxX; i++)
{
for (int j=0; j<=maxY; j++)
{
int distX = currPoint[0] - i;
int distY = currPoint[1] - j;
int sqroot = (int)Math.round(Math.sqrt(distX*distX + distY*distY));
if (sqroot * sqroot == distX*distX + distY*distY)
{
if (dist[i][j] > dist[currPoint[0]][currPoint[1]] + 1)
{
dist[i][j] = dist[currPoint[0]][currPoint[1]] + 1;
Integer[] thisPoint = {i, j};
bfsQueue.add(thisPoint);
}
}
}
}
}
return dist;
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | aa112497a43e616f9380cbfef55da6f4 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.*;
public class intergermoves
{
public static void main (String[]args)
{
Scanner x= new Scanner(System.in);
int t=x.nextInt();
while(t-->0)
{
int X=x.nextInt();
int y=x.nextInt();
double d=Math.sqrt((X*X)+(y*y));
if(X==0&&y==0)
System.out.println("0");
else if(d==Math.floor(d))
System.out.println("1");
else
System.out.println("2");
}
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 60d123a338e916d88b15b2c067430fc9 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.Scanner;
import java.util.*;
public class integerMoves{
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int times = input.nextInt();
for (int k = 0; k < times; k++) {
int a=input.nextInt();
int b=input.nextInt();
if(a == 0 && b == 0) {
System.out.println('0');
}else{
int x = a*a;
int y = b*b;
double t = Math.sqrt(x+y);
int ans = (int)t;
if(ans*ans == x + y) {
System.out.println('1');
}else{
System.out.println('2');
}
}
}
input.close();
} }
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 3e809415283a9a96c4b60d670587bb0a | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.*;
import java.io.*;
public class Solution {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int t = Integer.parseInt(br.readLine());
BufferedWriter output = new BufferedWriter(new OutputStreamWriter(System.out));
StringTokenizer st;
while (t-- > 0) {
// int n = Integer.parseInt(br.readLine());
st = new StringTokenizer(br.readLine());
int x = Integer.parseInt(st.nextToken());
int y = Integer.parseInt(st.nextToken());
if(x == 0 && y == 0)
{output.write("0\n");
continue;}
double temp = x*x + y*y;
double sqrt1 = Math.sqrt(temp);
double sqrt = Math.ceil(sqrt1);
if(sqrt1 == sqrt)
output.write("1\n");
else
output.write("2\n");
}
output.flush();
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 0e47b40f481341e02846b83f8c7cf536 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.*;
public class IntegerMoves {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
while(t-- >0) {
int x = sc.nextInt();
int y = sc.nextInt();
double ans = Math.sqrt(x*x + y*y);
if(x==0 && y==0){
System.out.println(0);
continue;
}
if(ans%1 ==0){
System.out.println(1);
}
else{
System.out.println(2);
}
}
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 9cc5e48c13860e2a1059da766cdb8c58 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.io.*;
import java.util.*;
/**
* 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 more informative names to simulation
* <p>
* Will program ever exceed limit?
* Try all approaches with prove of correctness if task is not obvious.
* If you are given formula/rule: Try to play with it.
* Analytic solution/Hardcoded solution/Constructive/Greedy/DP/Math/Brute force/Symmetric data
* Number theory
* Game theory (optimal play) that consider local and global strategy.
*/
public class A {
class Pair {
int x;
int y;
int deep;
public Pair(int x, int y) {
this.x = x;
this.y = y;
}
public Pair(int x, int y, int deep) {
this.x = x;
this.y = y;
this.deep = deep;
}
@Override
public String toString() {
return "Pair{" +
"x=" + x +
", y=" + y +
'}';
}
}
List<Pair> pairs = new ArrayList<>();
int[][] dir = {
{1, 1},
{1, -1},
{-1, 1},
{-1, -1},
};
private void precompute(){
for (int i = 1; i <= 50; i++) {
for (int j = 1; j <= 50; j++) {
if(ok(i, j)) {
pairs.add(new Pair(i, j));
}
}
}
}
private void solveOne() {
int x = nextInt();
int y = nextInt();
if(x == 0 && y == 0) {
System.out.println(0);
} else {
if(ok(x, y)) {
System.out.println(1);
} else {
System.out.println(2);
//bfs
// boolean[][] used = new boolean[100][100];
// LinkedList<Pair> queue = new LinkedList<>();
// queue.addLast(new Pair(0, 0, 0));
// used[0][0] = true;
// while (!queue.isEmpty()){
// Pair cur = queue.removeFirst();
// if(cur.x == x && cur.y == y) {
// System.out.println(cur.deep);
// return;
// }
// for (Pair p : pairs) {
// for(int[] d : dir){
// queue.add(new Pair(cur.x + d[0] * p.x, cur.y + d[1] * p.y, cur.deep + 1));
// }
// }
// }
}
}
}
boolean ok(int x , int y){
int x2 = x * x;
int y2 = y * y;
int sq = (int)Math.sqrt(x2 + y2);
return sq * sq == x2 + y2;
}
private void solve() {
//precompute();
int t = nextInt();
for (int tt = 0; tt < t; tt++) {
solveOne();
}
}
class AssertionRuntimeException extends RuntimeException {
AssertionRuntimeException(Object expected,
Object actual, Object... input) {
super("expected = " + expected + ",\n actual = " + actual + ",\n " + Arrays.deepToString(input));
}
}
private int nextInt() {
return System.in.readInt();
}
private long nextLong() {
return System.in.readLong();
}
private String nextString() {
return System.in.readString();
}
private int[] nextIntArr(int n) {
return System.in.readIntArray(n);
}
private long[] nextLongArr(int n) {
return System.in.readLongArray(n);
}
public static void main(String[] args) {
new A().run();
}
static class System {
private static FastInputStream in;
private static FastPrintStream out;
}
private void run() {
final boolean ONLINE_JUDGE = java.lang.System.getProperty("ONLINE_JUDGE") != null;
final boolean USE_IO = ONLINE_JUDGE;
if (USE_IO) {
System.in = new FastInputStream(java.lang.System.in);
System.out = new FastPrintStream(java.lang.System.out);
solve();
System.out.flush();
} else {
final String nameIn = "input.txt";
final String nameOut = "output.txt";
try {
System.in = new FastInputStream(new FileInputStream(nameIn));
System.out = new FastPrintStream(new PrintStream(nameOut));
solve();
System.out.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
}
private static class FastPrintStream {
private static final int BUF_SIZE = 8192;
private final byte[] buf = new byte[BUF_SIZE];
private final OutputStream out;
private int ptr = 0;
private FastPrintStream() {
this(java.lang.System.out);
}
public FastPrintStream(OutputStream os) {
this.out = os;
}
public FastPrintStream(String path) {
try {
this.out = new FileOutputStream(path);
} catch (FileNotFoundException e) {
throw new RuntimeException("FastWriter");
}
}
public FastPrintStream print(byte b) {
buf[ptr++] = b;
if (ptr == BUF_SIZE) innerflush();
return this;
}
public FastPrintStream print(char c) {
return print((byte) c);
}
public FastPrintStream print(char[] s) {
for (char c : s) {
buf[ptr++] = (byte) c;
if (ptr == BUF_SIZE) innerflush();
}
return this;
}
public FastPrintStream print(String s) {
s.chars().forEach(c -> {
buf[ptr++] = (byte) c;
if (ptr == BUF_SIZE) innerflush();
});
return this;
}
//can be optimized
public FastPrintStream print0(char[] s) {
if (ptr + s.length < BUF_SIZE) {
for (char c : s) {
buf[ptr++] = (byte) c;
}
} else {
for (char c : s) {
buf[ptr++] = (byte) c;
if (ptr == BUF_SIZE) innerflush();
}
}
return this;
}
//can be optimized
public FastPrintStream print0(String s) {
if (ptr + s.length() < BUF_SIZE) {
for (int i = 0; i < s.length(); i++) {
buf[ptr++] = (byte) s.charAt(i);
}
} else {
for (int i = 0; i < s.length(); i++) {
buf[ptr++] = (byte) s.charAt(i);
if (ptr == BUF_SIZE) innerflush();
}
}
return this;
}
private static int countDigits(int l) {
if (l >= 1000000000) return 10;
if (l >= 100000000) return 9;
if (l >= 10000000) return 8;
if (l >= 1000000) return 7;
if (l >= 100000) return 6;
if (l >= 10000) return 5;
if (l >= 1000) return 4;
if (l >= 100) return 3;
if (l >= 10) return 2;
return 1;
}
public FastPrintStream print(int x) {
if (x == Integer.MIN_VALUE) {
return print((long) x);
}
if (ptr + 12 >= BUF_SIZE) innerflush();
if (x < 0) {
print((byte) '-');
x = -x;
}
int d = countDigits(x);
for (int i = ptr + d - 1; i >= ptr; i--) {
buf[i] = (byte) ('0' + x % 10);
x /= 10;
}
ptr += d;
return this;
}
private static int countDigits(long l) {
if (l >= 1000000000000000000L) return 19;
if (l >= 100000000000000000L) return 18;
if (l >= 10000000000000000L) return 17;
if (l >= 1000000000000000L) return 16;
if (l >= 100000000000000L) return 15;
if (l >= 10000000000000L) return 14;
if (l >= 1000000000000L) return 13;
if (l >= 100000000000L) return 12;
if (l >= 10000000000L) return 11;
if (l >= 1000000000L) return 10;
if (l >= 100000000L) return 9;
if (l >= 10000000L) return 8;
if (l >= 1000000L) return 7;
if (l >= 100000L) return 6;
if (l >= 10000L) return 5;
if (l >= 1000L) return 4;
if (l >= 100L) return 3;
if (l >= 10L) return 2;
return 1;
}
public FastPrintStream print(long x) {
if (x == Long.MIN_VALUE) {
return print("" + x);
}
if (ptr + 21 >= BUF_SIZE) innerflush();
if (x < 0) {
print((byte) '-');
x = -x;
}
int d = countDigits(x);
for (int i = ptr + d - 1; i >= ptr; i--) {
buf[i] = (byte) ('0' + x % 10);
x /= 10;
}
ptr += d;
return this;
}
public FastPrintStream print(double x, int precision) {
if (x < 0) {
print('-');
x = -x;
}
x += Math.pow(10, -precision) / 2;
// if(x < 0){ x = 0; }
print((long) x).print(".");
x -= (long) x;
for (int i = 0; i < precision; i++) {
x *= 10;
print((char) ('0' + (int) x));
x -= (int) x;
}
return this;
}
public FastPrintStream println(int[] a, int from, int upTo, char separator) {
for (int i = from; i < upTo; i++) {
print(a[i]);
print(separator);
}
print('\n');
return this;
}
public FastPrintStream println(int[] a) {
return println(a, 0, a.length, ' ');
}
public FastPrintStream println(long[] a, int from, int upTo, char separator) {
for (int i = from; i < upTo; i++) {
print(a[i]);
print(separator);
}
print('\n');
return this;
}
public FastPrintStream println(long[] a) {
return println(a, 0, a.length, ' ');
}
public FastPrintStream println(char c) {
return print(c).println();
}
public FastPrintStream println(int x) {
return print(x).println();
}
public FastPrintStream println(long x) {
return print(x).println();
}
public FastPrintStream println(String x) {
return print(x).println();
}
public FastPrintStream println(double x, int precision) {
return print(x, precision).println();
}
public FastPrintStream println() {
return print((byte) '\n');
}
public FastPrintStream printf(String format, Object... args) {
return print(String.format(format, args));
}
private void innerflush() {
try {
out.write(buf, 0, ptr);
ptr = 0;
} catch (IOException e) {
throw new RuntimeException("innerflush");
}
}
public void flush() {
innerflush();
try {
out.flush();
} catch (IOException e) {
throw new RuntimeException("flush");
}
}
}
private static class FastInputStream {
private boolean finished = false;
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
private SpaceCharFilter filter;
public FastInputStream(InputStream stream) {
this.stream = stream;
}
public double[] readDoubleArray(int size) {
double[] array = new double[size];
for (int i = 0; i < size; i++) {
array[i] = readDouble();
}
return array;
}
public String[] readStringArray(int size) {
String[] array = new String[size];
for (int i = 0; i < size; i++) {
array[i] = readString();
}
return array;
}
public char[] readCharArray(int size) {
char[] array = new char[size];
for (int i = 0; i < size; i++) {
array[i] = readCharacter();
}
return array;
}
public char[][] readTable(int rowCount, int columnCount) {
char[][] table = new char[rowCount][];
for (int i = 0; i < rowCount; i++) {
table[i] = this.readCharArray(columnCount);
}
return table;
}
public int[][] readIntTable(int rowCount, int columnCount) {
int[][] table = new int[rowCount][];
for (int i = 0; i < rowCount; i++) {
table[i] = readIntArray(columnCount);
}
return table;
}
public double[][] readDoubleTable(int rowCount, int columnCount) {
double[][] table = new double[rowCount][];
for (int i = 0; i < rowCount; i++) {
table[i] = this.readDoubleArray(columnCount);
}
return table;
}
public long[][] readLongTable(int rowCount, int columnCount) {
long[][] table = new long[rowCount][];
for (int i = 0; i < rowCount; i++) {
table[i] = readLongArray(columnCount);
}
return table;
}
public String[][] readStringTable(int rowCount, int columnCount) {
String[][] table = new String[rowCount][];
for (int i = 0; i < rowCount; i++) {
table[i] = this.readStringArray(columnCount);
}
return table;
}
public String readText() {
StringBuilder result = new StringBuilder();
while (true) {
int character = read();
if (character == '\r') {
continue;
}
if (character == -1) {
break;
}
result.append((char) character);
}
return result.toString();
}
public void readStringArrays(String[]... arrays) {
for (int i = 0; i < arrays[0].length; i++) {
for (int j = 0; j < arrays.length; j++) {
arrays[j][i] = readString();
}
}
}
public long[] readLongArray(int size) {
long[] array = new long[size];
for (int i = 0; i < size; i++) {
array[i] = readLong();
}
return array;
}
public int[] readIntArray(int size) {
int[] array = new int[size];
for (int i = 0; i < size; i++) {
array[i] = readInt();
}
return array;
}
public int read() {
if (numChars == -1) {
throw new InputMismatchException();
}
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0) {
return -1;
}
}
return buf[curChar++];
}
public int peek() {
if (numChars == -1) {
return -1;
}
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
return -1;
}
if (numChars <= 0) {
return -1;
}
}
return buf[curChar];
}
public int peekNonWhitespace() {
while (isWhitespace(peek())) {
read();
}
return peek();
}
public int readInt() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
if (c < '0' || c > '9') {
throw new InputMismatchException();
}
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public long readLong() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
long res = 0;
do {
if (c < '0' || c > '9') {
throw new InputMismatchException();
}
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public String readString() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
StringBuilder res = new StringBuilder();
do {
if (Character.isValidCodePoint(c)) {
res.appendCodePoint(c);
}
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
public boolean isSpaceChar(int c) {
if (filter != null) {
return filter.isSpaceChar(c);
}
return isWhitespace(c);
}
public static boolean isWhitespace(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
private String readLine0() {
StringBuilder buf = new StringBuilder();
int c = read();
while (c != '\n' && c != -1) {
if (c != '\r') {
buf.appendCodePoint(c);
}
c = read();
}
return buf.toString();
}
public String readLine() {
String s = readLine0();
while (s.trim().length() == 0) {
s = readLine0();
}
return s;
}
public String readLine(boolean ignoreEmptyLines) {
if (ignoreEmptyLines) {
return readLine();
} else {
return readLine0();
}
}
public char readCharacter() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
return (char) c;
}
public double readDouble() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
double res = 0;
while (!isSpaceChar(c) && c != '.') {
if (c == 'e' || c == 'E') {
return res * Math.pow(10, readInt());
}
if (c < '0' || c > '9') {
throw new InputMismatchException();
}
res *= 10;
res += c - '0';
c = read();
}
if (c == '.') {
c = read();
double m = 1;
while (!isSpaceChar(c)) {
if (c == 'e' || c == 'E') {
return res * Math.pow(10, readInt());
}
if (c < '0' || c > '9') {
throw new InputMismatchException();
}
m /= 10;
res += (c - '0') * m;
c = read();
}
}
return res * sgn;
}
public boolean isExhausted() {
int value;
while (isSpaceChar(value = peek()) && value != -1) {
read();
}
return value == -1;
}
public String next() {
return readString();
}
public SpaceCharFilter getFilter() {
return filter;
}
public void setFilter(SpaceCharFilter filter) {
this.filter = filter;
}
public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | ae0bc767a1c623d4a1c568ed3afbc38b | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.io.*;
import java.util.*;
/**
* 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 more informative names to simulation
* <p>
* Will program ever exceed limit?
* Try all approaches with prove of correctness if task is not obvious.
* If you are given formula/rule: Try to play with it.
* Analytic solution/Hardcoded solution/Constructive/Greedy/DP/Math/Brute force/Symmetric data
* Number theory
* Game theory (optimal play) that consider local and global strategy.
*/
public class A {
class Pair {
int x;
int y;
int deep;
public Pair(int x, int y) {
this.x = x;
this.y = y;
}
public Pair(int x, int y, int deep) {
this.x = x;
this.y = y;
this.deep = deep;
}
@Override
public String toString() {
return "Pair{" +
"x=" + x +
", y=" + y +
'}';
}
}
List<Pair> pairs = new ArrayList<>();
int[][] dir = {
{1, 1},
{1, -1},
{-1, 1},
{-1, -1},
};
private void precompute(){
for (int i = 1; i <= 50; i++) {
for (int j = 1; j <= 50; j++) {
if(ok(i, j)) {
pairs.add(new Pair(i, j));
}
}
}
}
private void solveOne() {
int x = nextInt();
int y = nextInt();
if(x == 0 && y == 0) {
System.out.println(0);
} else {
if(ok(x, y)) {
System.out.println(1);
} else {
System.out.println(2);
//bfs
// boolean[][] used = new boolean[100][100];
// LinkedList<Pair> queue = new LinkedList<>();
// queue.addLast(new Pair(0, 0, 0));
// used[0][0] = true;
// while (!queue.isEmpty()){
// Pair cur = queue.removeFirst();
// if(cur.x == x && cur.y == y) {
// System.out.println(cur.deep);
// return;
// }
// for (Pair p : pairs) {
// for(int[] d : dir){
// queue.add(new Pair(cur.x + d[0] * p.x, cur.y + d[1] * p.y, cur.deep + 1));
// }
// }
// }
}
}
}
boolean ok(int x , int y){
int x2 = x * x;
int y2 = y * y;
int sq = (int)Math.sqrt(x2 + y2);
return sq * sq == x2 + y2;
}
private void solve() {
precompute();
int t = nextInt();
for (int tt = 0; tt < t; tt++) {
solveOne();
}
}
class AssertionRuntimeException extends RuntimeException {
AssertionRuntimeException(Object expected,
Object actual, Object... input) {
super("expected = " + expected + ",\n actual = " + actual + ",\n " + Arrays.deepToString(input));
}
}
private int nextInt() {
return System.in.readInt();
}
private long nextLong() {
return System.in.readLong();
}
private String nextString() {
return System.in.readString();
}
private int[] nextIntArr(int n) {
return System.in.readIntArray(n);
}
private long[] nextLongArr(int n) {
return System.in.readLongArray(n);
}
public static void main(String[] args) {
new A().run();
}
static class System {
private static FastInputStream in;
private static FastPrintStream out;
}
private void run() {
final boolean ONLINE_JUDGE = java.lang.System.getProperty("ONLINE_JUDGE") != null;
final boolean USE_IO = ONLINE_JUDGE;
if (USE_IO) {
System.in = new FastInputStream(java.lang.System.in);
System.out = new FastPrintStream(java.lang.System.out);
solve();
System.out.flush();
} else {
final String nameIn = "input.txt";
final String nameOut = "output.txt";
try {
System.in = new FastInputStream(new FileInputStream(nameIn));
System.out = new FastPrintStream(new PrintStream(nameOut));
solve();
System.out.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
}
private static class FastPrintStream {
private static final int BUF_SIZE = 8192;
private final byte[] buf = new byte[BUF_SIZE];
private final OutputStream out;
private int ptr = 0;
private FastPrintStream() {
this(java.lang.System.out);
}
public FastPrintStream(OutputStream os) {
this.out = os;
}
public FastPrintStream(String path) {
try {
this.out = new FileOutputStream(path);
} catch (FileNotFoundException e) {
throw new RuntimeException("FastWriter");
}
}
public FastPrintStream print(byte b) {
buf[ptr++] = b;
if (ptr == BUF_SIZE) innerflush();
return this;
}
public FastPrintStream print(char c) {
return print((byte) c);
}
public FastPrintStream print(char[] s) {
for (char c : s) {
buf[ptr++] = (byte) c;
if (ptr == BUF_SIZE) innerflush();
}
return this;
}
public FastPrintStream print(String s) {
s.chars().forEach(c -> {
buf[ptr++] = (byte) c;
if (ptr == BUF_SIZE) innerflush();
});
return this;
}
//can be optimized
public FastPrintStream print0(char[] s) {
if (ptr + s.length < BUF_SIZE) {
for (char c : s) {
buf[ptr++] = (byte) c;
}
} else {
for (char c : s) {
buf[ptr++] = (byte) c;
if (ptr == BUF_SIZE) innerflush();
}
}
return this;
}
//can be optimized
public FastPrintStream print0(String s) {
if (ptr + s.length() < BUF_SIZE) {
for (int i = 0; i < s.length(); i++) {
buf[ptr++] = (byte) s.charAt(i);
}
} else {
for (int i = 0; i < s.length(); i++) {
buf[ptr++] = (byte) s.charAt(i);
if (ptr == BUF_SIZE) innerflush();
}
}
return this;
}
private static int countDigits(int l) {
if (l >= 1000000000) return 10;
if (l >= 100000000) return 9;
if (l >= 10000000) return 8;
if (l >= 1000000) return 7;
if (l >= 100000) return 6;
if (l >= 10000) return 5;
if (l >= 1000) return 4;
if (l >= 100) return 3;
if (l >= 10) return 2;
return 1;
}
public FastPrintStream print(int x) {
if (x == Integer.MIN_VALUE) {
return print((long) x);
}
if (ptr + 12 >= BUF_SIZE) innerflush();
if (x < 0) {
print((byte) '-');
x = -x;
}
int d = countDigits(x);
for (int i = ptr + d - 1; i >= ptr; i--) {
buf[i] = (byte) ('0' + x % 10);
x /= 10;
}
ptr += d;
return this;
}
private static int countDigits(long l) {
if (l >= 1000000000000000000L) return 19;
if (l >= 100000000000000000L) return 18;
if (l >= 10000000000000000L) return 17;
if (l >= 1000000000000000L) return 16;
if (l >= 100000000000000L) return 15;
if (l >= 10000000000000L) return 14;
if (l >= 1000000000000L) return 13;
if (l >= 100000000000L) return 12;
if (l >= 10000000000L) return 11;
if (l >= 1000000000L) return 10;
if (l >= 100000000L) return 9;
if (l >= 10000000L) return 8;
if (l >= 1000000L) return 7;
if (l >= 100000L) return 6;
if (l >= 10000L) return 5;
if (l >= 1000L) return 4;
if (l >= 100L) return 3;
if (l >= 10L) return 2;
return 1;
}
public FastPrintStream print(long x) {
if (x == Long.MIN_VALUE) {
return print("" + x);
}
if (ptr + 21 >= BUF_SIZE) innerflush();
if (x < 0) {
print((byte) '-');
x = -x;
}
int d = countDigits(x);
for (int i = ptr + d - 1; i >= ptr; i--) {
buf[i] = (byte) ('0' + x % 10);
x /= 10;
}
ptr += d;
return this;
}
public FastPrintStream print(double x, int precision) {
if (x < 0) {
print('-');
x = -x;
}
x += Math.pow(10, -precision) / 2;
// if(x < 0){ x = 0; }
print((long) x).print(".");
x -= (long) x;
for (int i = 0; i < precision; i++) {
x *= 10;
print((char) ('0' + (int) x));
x -= (int) x;
}
return this;
}
public FastPrintStream println(int[] a, int from, int upTo, char separator) {
for (int i = from; i < upTo; i++) {
print(a[i]);
print(separator);
}
print('\n');
return this;
}
public FastPrintStream println(int[] a) {
return println(a, 0, a.length, ' ');
}
public FastPrintStream println(long[] a, int from, int upTo, char separator) {
for (int i = from; i < upTo; i++) {
print(a[i]);
print(separator);
}
print('\n');
return this;
}
public FastPrintStream println(long[] a) {
return println(a, 0, a.length, ' ');
}
public FastPrintStream println(char c) {
return print(c).println();
}
public FastPrintStream println(int x) {
return print(x).println();
}
public FastPrintStream println(long x) {
return print(x).println();
}
public FastPrintStream println(String x) {
return print(x).println();
}
public FastPrintStream println(double x, int precision) {
return print(x, precision).println();
}
public FastPrintStream println() {
return print((byte) '\n');
}
public FastPrintStream printf(String format, Object... args) {
return print(String.format(format, args));
}
private void innerflush() {
try {
out.write(buf, 0, ptr);
ptr = 0;
} catch (IOException e) {
throw new RuntimeException("innerflush");
}
}
public void flush() {
innerflush();
try {
out.flush();
} catch (IOException e) {
throw new RuntimeException("flush");
}
}
}
private static class FastInputStream {
private boolean finished = false;
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
private SpaceCharFilter filter;
public FastInputStream(InputStream stream) {
this.stream = stream;
}
public double[] readDoubleArray(int size) {
double[] array = new double[size];
for (int i = 0; i < size; i++) {
array[i] = readDouble();
}
return array;
}
public String[] readStringArray(int size) {
String[] array = new String[size];
for (int i = 0; i < size; i++) {
array[i] = readString();
}
return array;
}
public char[] readCharArray(int size) {
char[] array = new char[size];
for (int i = 0; i < size; i++) {
array[i] = readCharacter();
}
return array;
}
public char[][] readTable(int rowCount, int columnCount) {
char[][] table = new char[rowCount][];
for (int i = 0; i < rowCount; i++) {
table[i] = this.readCharArray(columnCount);
}
return table;
}
public int[][] readIntTable(int rowCount, int columnCount) {
int[][] table = new int[rowCount][];
for (int i = 0; i < rowCount; i++) {
table[i] = readIntArray(columnCount);
}
return table;
}
public double[][] readDoubleTable(int rowCount, int columnCount) {
double[][] table = new double[rowCount][];
for (int i = 0; i < rowCount; i++) {
table[i] = this.readDoubleArray(columnCount);
}
return table;
}
public long[][] readLongTable(int rowCount, int columnCount) {
long[][] table = new long[rowCount][];
for (int i = 0; i < rowCount; i++) {
table[i] = readLongArray(columnCount);
}
return table;
}
public String[][] readStringTable(int rowCount, int columnCount) {
String[][] table = new String[rowCount][];
for (int i = 0; i < rowCount; i++) {
table[i] = this.readStringArray(columnCount);
}
return table;
}
public String readText() {
StringBuilder result = new StringBuilder();
while (true) {
int character = read();
if (character == '\r') {
continue;
}
if (character == -1) {
break;
}
result.append((char) character);
}
return result.toString();
}
public void readStringArrays(String[]... arrays) {
for (int i = 0; i < arrays[0].length; i++) {
for (int j = 0; j < arrays.length; j++) {
arrays[j][i] = readString();
}
}
}
public long[] readLongArray(int size) {
long[] array = new long[size];
for (int i = 0; i < size; i++) {
array[i] = readLong();
}
return array;
}
public int[] readIntArray(int size) {
int[] array = new int[size];
for (int i = 0; i < size; i++) {
array[i] = readInt();
}
return array;
}
public int read() {
if (numChars == -1) {
throw new InputMismatchException();
}
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0) {
return -1;
}
}
return buf[curChar++];
}
public int peek() {
if (numChars == -1) {
return -1;
}
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
return -1;
}
if (numChars <= 0) {
return -1;
}
}
return buf[curChar];
}
public int peekNonWhitespace() {
while (isWhitespace(peek())) {
read();
}
return peek();
}
public int readInt() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
if (c < '0' || c > '9') {
throw new InputMismatchException();
}
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public long readLong() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
long res = 0;
do {
if (c < '0' || c > '9') {
throw new InputMismatchException();
}
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public String readString() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
StringBuilder res = new StringBuilder();
do {
if (Character.isValidCodePoint(c)) {
res.appendCodePoint(c);
}
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
public boolean isSpaceChar(int c) {
if (filter != null) {
return filter.isSpaceChar(c);
}
return isWhitespace(c);
}
public static boolean isWhitespace(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
private String readLine0() {
StringBuilder buf = new StringBuilder();
int c = read();
while (c != '\n' && c != -1) {
if (c != '\r') {
buf.appendCodePoint(c);
}
c = read();
}
return buf.toString();
}
public String readLine() {
String s = readLine0();
while (s.trim().length() == 0) {
s = readLine0();
}
return s;
}
public String readLine(boolean ignoreEmptyLines) {
if (ignoreEmptyLines) {
return readLine();
} else {
return readLine0();
}
}
public char readCharacter() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
return (char) c;
}
public double readDouble() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
double res = 0;
while (!isSpaceChar(c) && c != '.') {
if (c == 'e' || c == 'E') {
return res * Math.pow(10, readInt());
}
if (c < '0' || c > '9') {
throw new InputMismatchException();
}
res *= 10;
res += c - '0';
c = read();
}
if (c == '.') {
c = read();
double m = 1;
while (!isSpaceChar(c)) {
if (c == 'e' || c == 'E') {
return res * Math.pow(10, readInt());
}
if (c < '0' || c > '9') {
throw new InputMismatchException();
}
m /= 10;
res += (c - '0') * m;
c = read();
}
}
return res * sgn;
}
public boolean isExhausted() {
int value;
while (isSpaceChar(value = peek()) && value != -1) {
read();
}
return value == -1;
}
public String next() {
return readString();
}
public SpaceCharFilter getFilter() {
return filter;
}
public void setFilter(SpaceCharFilter filter) {
this.filter = filter;
}
public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | f4a9b772cb396bd9e30ec140b0ebc7aa | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes |
//package basicjava;
import java.util.Scanner;
import java.lang.*;
public class Biodata {
public static void main(String[] args)
{
int tc;
Scanner input=new Scanner(System.in);
tc=input.nextInt();
while(tc>0)
{
tc--;
int a,b;
a=input.nextInt();
b=input.nextInt();
if(a==0&&b==0)
System.out.println(0);
else
{
int z;
z=a*a+b*b;
if((int)Math.sqrt(z)*(int)Math.sqrt(z)==z)
System.out.println(1);
else
System.out.println(2);
}
}
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 569c2142aa2050443e560080b0469ad6 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.io.*;
import java.util.*;
public class Main {
static final int INF = Integer.MAX_VALUE;
static final int NINF = Integer.MIN_VALUE;
static final long LINF = Long.MAX_VALUE;
static final long LNINF = Long.MIN_VALUE;
static Reader reader;
static Writer writer;
static PrintWriter out;
static FastScanner fs;
static void solve() {
int x = fs.nextInt();
int y = fs.nextInt();
if (x==0 && y==0)out.print("0\n");
else if(x==0 || y==0 || isInteger(Math.sqrt(x*x + y*y)))out.print("1\n");
else out.print("2\n");
}
public static void main(String[] args) {
setReaderWriter();
fs = new FastScanner(reader);
testForTestcases();
// solve();
out.close();
}
static void setReaderWriter() {
reader = new InputStreamReader(System.in);
writer = new OutputStreamWriter(System.out);
out=new PrintWriter(writer);
}
static void testForTestcases() {
int T = fs.nextInt();
while (T-- > 0) {
solve();
}
}
static int getMax(int[] a) {
int m = NINF;
for(int i : a) m = Math.max(m, i);
return m;
}
static int getMin(int[] a) {
int m = INF;
for(int i : a) m = Math.min(m, i);
return m;
}
static int upperBound(int[] a, int l, int h, int val) {
int ans = h + 1;
while (l <= h) {
int mid = l + (h - l) / 2;
if (a[mid] > val) {
ans = mid;
h = mid - 1;
} else {
l = mid + 1;
}
}
return ans;
}
static boolean isInteger(double val) {
return !(val - (long)val > 0);
}
static void swap(int[] a , int i , int j) {
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}
static void swap(long[] a , int i , int j) {
long temp = a[i];
a[i] = a[j];
a[j] = temp;
}
static void swap(char[] a , int i , int j) {
char temp = a[i];
a[i] = a[j];
a[j] = temp;
}
static long GCD(long a,long b)
{
if(b==0)
{
return a;
}
else return GCD(b,a%b );
}
static int opposite(int n, int x) {
return (n-1)^x;
}
static Pair print(int a, int b) {
out.println(a+" "+b);
return new Pair(a, b);
}
static class Pair {
int a, b;
public Pair(int a, int b) {
this.a=a;
this.b=b;
}
}
static final Random random=new Random();
static final int mod=1_000_000_007;
static void ruffleSort(int[] a) {
int n=a.length;//shuffle, then sort
for (int i=0; i<n; i++) {
int oi=random.nextInt(n), temp=a[oi];
a[oi]=a[i]; a[i]=temp;
}
Arrays.sort(a);
}
static long add(long a, long b) {
return (a+b)%mod;
}
static long sub(long a, long b) {
return ((a-b)%mod+mod)%mod;
}
static long mul(long a, long b) {
return (a*b)%mod;
}
static long exp(long base, long exp) {
if (exp==0) return 1;
long half=exp(base, exp/2);
if (exp%2==0) return mul(half, half);
return mul(half, mul(half, base));
}
static long[] factorials=new long[2_000_001];
static long[] invFactorials=new long[2_000_001];
static void precompFacts() {
factorials[0]=invFactorials[0]=1;
for (int i=1; i<factorials.length; i++) factorials[i]=mul(factorials[i-1], i);
invFactorials[factorials.length-1]=exp(factorials[factorials.length-1], mod-2);
for (int i=invFactorials.length-2; i>=0; i--)
invFactorials[i]=mul(invFactorials[i+1], i+1);
}
static long nCk(int n, int k) {
return mul(factorials[n], mul(invFactorials[k], invFactorials[n-k]));
}
static void sort(int[] a) {
ArrayList<Integer> l=new ArrayList<>();
for (int i:a) l.add(i);
Collections.sort(l);
for (int i=0; i<a.length; i++) a[i]=l.get(i);
}
static class FastScanner {
BufferedReader br;
StringTokenizer st;
public FastScanner(Reader reader) {
br =new BufferedReader(reader);
st =new StringTokenizer("");
}
String next() {
while (!st.hasMoreTokens())
try {
st=new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
return st.nextToken();
}
String nextLine()
{
String str = "";
try {
str = br.readLine();
}
catch (IOException e) {
e.printStackTrace();
}
return str;
}
int nextInt() {
return Integer.parseInt(next());
}
int[] readArrayInt(int n) {
int[] a=new int[n];
for (int i=0; i<n; i++) a[i]=nextInt();
return a;
}
long[] readArrayLong(int n) {
long[] a=new long[n];
for (int i=0; i<n; i++) a[i]=nextLong();
return a;
}
long nextLong() {
return Long.parseLong(next());
}
char[] readCharArray() {
return next().toCharArray();
}
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 6a62a630ca989603179ac758b5ced4ab | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes |
import java.util.*;
public class IntegerMove {
public static void main(String[] args) {
Scanner s=new Scanner(System.in);
int t=s.nextInt();
for (int i=0;i<t;i++)
{
int x=s.nextInt();
int y=s.nextInt();
double first=Math.sqrt(x*x+y*y);
int second=(int) Math.sqrt(x*x+y*y);
if (first-second==0&&x!=0&&y!=0)
System.out.println(1);
if (x==0&&y==0)
System.out.println(0);
if ((x!=0&&y==0)||(x==0&&y!=0))
System.out.println(1);
else
if (first-second!=0&&x!=0&&y!=0)
System.out.println(2);
}
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 82e75019e5ef2b3f7221828d437db600 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.Scanner;
import java.lang.Math;
public class Main {
public static void main (String[] args) {
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
while (t-- > 0) {
int x = sc.nextInt(), y = sc.nextInt();
if (x == 0 && y == 0) {
System.out.println(0);
}
else {
int d = (int) Math.sqrt(x * x + y * y);
if (d * d == x * x + y * y) {
System.out.println(1);
}
else {
System.out.println(2);
}
}
}
sc.close();
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | be888ce3dcc8c64e6a9f97e3519e0038 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes |
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int t = in.nextInt();
while (t > 0) {
int x = in.nextInt();
int y = in.nextInt();
if (x == 0 && y == 0) {
System.out.println(0);
} else if (String.valueOf(Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2))).endsWith(".0")) {
System.out.println(1);
} else {
System.out.println(2);
}
t--;
}
}
public static int solve(int x, int y) {
int cnt = 0;
return cnt;
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 784af8265fd02881d471dee296455ac1 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes |
import java.io.*;
public class a1657A {
public static void main(String[] args) throws IOException {
BufferedReader bu = new BufferedReader(new InputStreamReader(System.in));
StringBuilder sb = new StringBuilder();
int t = Integer.parseInt(bu.readLine());
next: while(t-->0){
String s[] = bu.readLine().split(" ");
int x = Integer.parseInt(s[0]);
int y = Integer.parseInt(s[1]);
int d = x*x + y*y;
if(d==0){ System.out.println(0);
continue next;
}
int z = 0;
while(z*z<d)z++;
if(z*z==d) System.out.println(1);
else System.out.println(2);
}
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | e378c435ea10d8b695a195e3acfc8d28 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.io.*;
import java.util.*;
public class Rough {
public static void main(String[] args) throws Exception {
Scanner s = new Scanner(System.in);
PrintWriter pw = new PrintWriter(System.out);
int t = s.nextInt();
while (t-- > 0) {
int x = s.nextInt();
int y = s.nextInt();
int cnt =(x*x)+(y*y);
int cnt1=(int) Math.sqrt(cnt);
if(x==0&&y==0) pw.println(0);
else if(cnt1*cnt1==cnt)pw.println(1);
else {
pw.println(2);
}
//pw.println(cnt);
}
pw.close();
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 22b87bcec365fcc817bd1927eb7c0fef | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes |
import java.util.*;
public class A {
public static void main(String[] args) {
// Use the Scanner class
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
for (int ti = 0; ti < t; ti++) {
int x = sc.nextInt();
int y = sc.nextInt();
if (x == 0 && y == 0) {
System.out.println(0);
} else {
int distance = (int) Math.sqrt((0 - x) * (0 - x) + (0 - y) * (0 - y));
if (distance * distance == x * x + y * y) {
System.out.println(1);
} else {
System.out.println(2);
}
}
}
}
/*
* int n = sc.nextInt(); // read input as integer
* long k = sc.nextLong(); // read input as long
* double d = sc.nextDouble(); // read input as double
* String str = sc.next(); // read input as String
* String s = sc.nextLine(); // read whole line as String
*/
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 3cb760f576c486ec796f16ad3f6c8814 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.io.*;
import java.util.*;
public class CF {
public static void main(String[] args) throws IOException {
Scanner sc=new Scanner(System.in);
int T=sc.nextInt();
while(T-->0)
{
int x=sc.nextInt();
int y=sc.nextInt();
if(x==0 && y==0){
System.out.println(0);
continue;
}
double ed=Math.sqrt(Math.pow(x,2)+Math.pow(y,2));
if(ed==(int)ed)
{
System.out.println(1);
}
else
System.out.println(2);
}
sc.close();
}
}
// Aman and garden
// Medium
// There is a garden and Aman is the gardener and he wants to arrange trees in a row
// of length n such that every Kth plant is non-decreasing in height. For example the plant
// at position 1 should be smaller than or equal to the tree planted at position 1+K and plant
// at position 1+K should be smaller than or equal to 1+2*K and so on, this
// should be true for every position(for eg. 2 <= 2+K <= 2+2*K ...).
// Now Aman can change a plant at any position with a plant of any height in order to create
// the required arrangment. He wants to know minimum number of trees he will have to change to get the required arrangement.
// We"ll be given a plants array which represents the height of plants at every position
// and a number K and we need to output the minimum number of plants we will have to change to get the required arrangement.
// Example:
// plants = [5,3,4,1,6,5];
// K=2;
// here plants at index (0,2,4) and (1,3,5) should be non decreasing.
// plants[0]=5;
// plants[2]=4;
// plants[4]=6;
// We can change the plant at index 2 with a plant of height 5(one change).
// Similarly
// plants[1]=3;
// plants[3]=1;
// plants[5]=5;
// We can change the plant at index 3 with a plant of height 4(one change).
// So minimum 2 changes are required.
// Constraints
// 1<=plants.length<=100000
// 1<=plants[i],K<=plants.length
// Format
// Input
// First line contains an integer N representing length of the plant array.
// Next line contains N space separated integers representing height of trees.
// Last line contains an integer K
// Output
// Output the minimum number of changes required.
// Example
// Sample Input
// 6
// 5
// 3
// 4
// 1
// 6
// 5
// 2
// Sample Output
// 2
// Tokyo Drift
// Easy
// There is a racing competition which will be held in your city next weekend. There are N racers who are going to take part in the competition. Each racer is at a given distance from the finish line, which is given in an integer array.
// Due to some safety reasons, total sum of speeds with which racers can drive is restricted with a given limit. Since, cost of organizing such an event depends on how long the event will last, you need to find out the minimum time in which all racers will cross the finishing line, but sum of speeds of all racers should be less than or equal to the given limit.
// If it is impossible to complete the race for all racers within given limit, we have to return -1.
// Note: Speed is defined as Ceil (distance/time), where ceil represents smaller than or equal to. For example if distance is 20 km and time taken to travel is 3 hrs then speed equals ceil(20/3) i.e. 7 km/hr.
// Example: Let us take 4 Racers with Distances from finishing line as [15 km, 25 km, 5 km, 20 km], and the maximum sum of speeds allowed is 12 km/hr. The minimum time in which all racers will reach the finishing line will be 7 hours.
// Racer 1 will have 15 km / 7 hr = 3 km/hr speed
// Racer 2 will have 25 km / 7 hr = 4 km/hr speed
// Racer 3 will have 05 km / 7 hr = 1 km/hr speed
// Racer 4 will have 20 km / 7 hr = 3 km/hr speed
// Hence, the total sum of speeds will be (3 + 4 + 1 + 3) = 11 km/hr which is less than or equal to 12 km/hr.
// Constraints
// 1 <= N <= 100000
// 1 <= racers[i] <= 10000000
// 1 <= Limit <= 10000000
// Format
// Input
// First line contains an integer N representing length of array.
// Next line contains N space seprated integers representing distance from finishing line.
// Last line contains an integer representing limit of sum of speeds with which racers can drive
// Output
// A single line integer representing minimum time in which all racers will cross the finishing line, If not possible print -1
// Example
// Sample Input
// 4
// 15 25 5 20
// 12
// Sample Output
// 7
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 5f06eb1086e77005c7b067875fe848ed | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.io.*;
import java.util.*;
public class A_Integer_Moves {
public static void main(String[] quesgs) {
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
for(int i = 0; i<t; i++){
int x = sc.nextInt();
int y = sc.nextInt();
if(x==0 && y==0){
System.out.println(0);
}
else {
double squ = (x*x) + (y*y);
double root = Math.sqrt(squ);
int root2 = (int)root;
if(root==root2){
System.out.println(1);
}
else{
System.out.println(2);
}
}
}
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 1035576db1655e1c6febdcd3a0c41e73 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.Scanner;
public class Solution {
static Scanner scan = new Scanner(System.in);
public static void main(String[] args) {
var cas = scan.nextInt();
while (cas-->0){
var x = scan.nextInt();
var y = scan.nextInt();
boolean isFound = false;
int count=0;
while (x>0 || y>0){
for(int i=x;i>=0;i--){
for(int j=y;j>=0;j--){
if (isInteger(i, j)){
x-=i;
y-=j;
isFound = true;
count++;
break;
}
}
if (isFound) break;
}
}
System.out.println(count);
}
}
private static boolean isInteger(int i, int j) {
var cur = (int )Math.sqrt(i*i+j*j);
return cur * cur == i * i + j * j;
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 70e3af5e569d15459f47c2fc57ab2c14 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.*;
import java.lang.Math;
public class Main{
public static void main(String[] args){
Scanner sc= new Scanner(System.in);
int s=sc.nextInt();
// int x=0;
// int y=0;
for(int i=0;i<s;i++){
int x=sc.nextInt();
int y=sc.nextInt();
// float z=Math.pow(x)+Math.pow(y);
if(x==0&&y==0){
System.out.println("0");
// continue;
}
else if((Math.sqrt(Math.pow(x,2)+Math.pow(y,2)))%1==0){
System.out.println("1");
}
else
System.out.println("2");
}
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 1646c5516e1298d7ab080b9662aa61c0 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.*;
public class Main {
// Driver Code
public static void main(String args[])
{
Scanner sc= new Scanner(System.in);
int x,y;
double d;
int n=sc.nextInt();
for (int i=0; i<n;i++){
x=sc.nextInt();
y=sc.nextInt();
if(x==0 && y==0){
System.out.println(0);
continue;
}
d=Math.sqrt((Math.pow(x,2)+Math.pow(y,2)));
if(d%1==0){
System.out.println(1);
}else{
System.out.println(2);
}
}
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 83ea69b5d5b1d21146029b3f33fc88ed | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes |
import java.util.*;
import java.io.*;
public class Solution {
public static void main(String[] args) throws IOException {
StringBuilder sb = new StringBuilder();
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
int tt = Integer.parseInt(in.readLine());
while (tt-- > 0) {
String[] tokens = in.readLine().split("\\s+");
int x1 = Integer.parseInt(tokens[0]);
int y1 = Integer.parseInt(tokens[1]);
sb.append(solve(x1, y1)).append("\n");
}
System.out.print(sb);
}
private static int solve(int x1, int y1) {
if (x1 == 0 && y1 == 0) return 0;
if (isPerfectSquare(0, 0, x1, y1)) return 1;
return 2;
}
private static boolean isPerfectSquare(int x1, int y1, int x2, int y2) {
int dist = Math.abs(x1 - x2) * Math.abs(x1 - x2) + Math.abs(y1 - y2) * Math.abs(y1 - y2);
for (int i = 0; i <= 100; i++) {
if (i * i == dist) return true;
}
return false;
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 2a3358160fd6ad52c8ffe1922d63d50d | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.*;
public class Main {
public static void main(String[] args) throws Exception {
PrintWriter out = new PrintWriter(System.out);
InputReader in = new InputReader(System.in);
Task solver = new Task();
solver.solve(in, out);
out.flush();
out.close();
}
}
class Task {
static final long mod = 998244353;
public void solve(InputReader in, PrintWriter out) throws Exception {
int T = in.nextInt();
int x = 50, y = 50;
int[][] dp = new int[x + 1][y + 1];
for (int i = 0; i < x; i++) {
Arrays.fill(dp[i], Integer.MAX_VALUE);
}
dp[0][0] = 0;
for (int i = 0; i <= x; i++) {
for (int j = 0; j <= y; j++) {
for (int ii = 0; ii <= i; ii++) {
for (int jj = 0; jj <= j; jj++) {
int a = (i - ii) * (i - ii) + (j - jj) * (j - jj);
if (a == 0) continue;
int sa = (int)Math.sqrt(1.0 * a);
if (sa * sa == a) {
dp[i][j] = Math.min(dp[i][j], dp[ii][jj] + 1);
}
}
}
}
}
for (int i = 0; i < T; i++) {
solveOne(in, out, dp);
}
}
private void solveOne(InputReader in, PrintWriter out, int[][] dp) {
int x = in.nextInt();
int y = in.nextInt();
if (x == 0 && y == 0) {
out.println(0);
return;
}
int a = x * x + y * y;
int sa = (int) Math.sqrt(1.0 * a);
if (sa * sa == a) {
out.println(1);
} else {
out.println(2);
}
}
}
class InputReader {
private InputStream in;
private byte[] buffer = new byte[1024];
private int curbuf;
private int lenbuf;
public InputReader(InputStream in) {
this.in = in;
this.curbuf = this.lenbuf = 0;
}
public boolean hasNextByte() {
if (curbuf >= lenbuf) {
curbuf = 0;
try {
lenbuf = in.read(buffer);
} catch (IOException e) {
throw new InputMismatchException();
}
if (lenbuf <= 0)
return false;
}
return true;
}
private int readByte() {
if (hasNextByte())
return buffer[curbuf++];
else
return -1;
}
private boolean isSpaceChar(int c) {
return !(c >= 33 && c <= 126);
}
private void skip() {
while (hasNextByte() && isSpaceChar(buffer[curbuf]))
curbuf++;
}
public boolean hasNext() {
skip();
return hasNextByte();
}
public String next() {
if (!hasNext())
throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (!isSpaceChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public int nextInt() {
if (!hasNext())
throw new NoSuchElementException();
int c = readByte();
while (isSpaceChar(c))
c = readByte();
boolean minus = false;
if (c == '-') {
minus = true;
c = readByte();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res = res * 10 + c - '0';
c = readByte();
} while (!isSpaceChar(c));
return (minus) ? -res : res;
}
public long nextLong() {
if (!hasNext())
throw new NoSuchElementException();
int c = readByte();
while (isSpaceChar(c))
c = readByte();
boolean minus = false;
if (c == '-') {
minus = true;
c = readByte();
}
long res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res = res * 10 + c - '0';
c = readByte();
} while (!isSpaceChar(c));
return (minus) ? -res : res;
}
public double nextDouble() {
return Double.parseDouble(next());
}
public int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
public long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++)
a[i] = nextLong();
return a;
}
public char[][] nextCharMap(int n, int m) {
char[][] map = new char[n][m];
for (int i = 0; i < n; i++)
map[i] = next().toCharArray();
return map;
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 1039039083add57784e39b8430cf330d | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.*;
public class Play {
public static void main(String[] args) throws Exception {
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
while (t -- > 0) {
int x = sc.nextInt(), y = sc.nextInt();
if (x == 0 && y == 0) {
System.out.println(0);
continue;
}
double distance = Math.sqrt(x*x + y*y);
if (Math.floor(distance) == distance) {
System.out.println(1);
}
else {
System.out.println(2);
}
}
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 3e44e861d4abf15c014d2263835aefa5 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes |
/*
* akshaygupta26
*/
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Random;
import java.util.StringTokenizer;
public class A {
static long mod = (long) (1e9 + 7);
public static void main(String[] args) {
FastReader sc = new FastReader();
StringBuilder ans = new StringBuilder();
int test = sc.nextInt();
while (test-- > 0) {
int x = sc.nextInt();
int y = sc.nextInt();
if (x == 0 && y == 0) {
ans.append(0 + "\n");
} else if (solve(x, y)) {
ans.append(1 + "\n");
} else {
ans.append(2 + "\n");
}
}
System.out.print(ans);
}
static boolean solve(double x, double y) {
double res = (x * x) + (y * y);
double res2 = Math.pow((int) Math.sqrt(res), 2);
// System.out.println(res + " " + res2);
return res2 == res;
}
static long add(long a, long b) {
return (a + b) % mod;
}
static long mult(long a, long b) {
return (a * b) % mod;
}
static long _gcd(long a, long b) {
if (b == 0)
return a;
return _gcd(b, a % b);
}
static final Random random = new Random();
static void ruffleSort(int[] a) {
int n = a.length;// shuffle, then sort
for (int i = 0; i < n; i++) {
int oi = random.nextInt(n), temp = a[oi];
a[oi] = a[i];
a[i] = temp;
}
Arrays.sort(a);
}
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | ddc823c09ded4166b551f2fe01b86192 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | // package CF1657;
import java.util.Scanner;
/**
* User : ribhavpahuja
* Date : 22/03/22
* Time : 8:11 PM
*/
public class A {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int t = s.nextInt();
while(t-- > 0) {
int x = s.nextInt();
int y = s.nextInt();
if (x == 0 && y == 0) {
System.out.println(0);
} else {
double sqrt = Math.sqrt((x*x) + (y*y));
if (sqrt == (int)(sqrt)) {
System.out.println(1);
} else {
System.out.println(2);
}
}
}
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | bb01cf5d46a9014eb4b12a486ed1eff1 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.*;
public class Main
{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
int x,y,i;
double d;
for(i=0;i<t;i++){
x=sc.nextInt();
y=sc.nextInt();
d=Math.sqrt(x*x + y*y);
d=Math.round(d);
if(x==0 && y==0)
System.out.println(0);
else if(d*d == x*x + y*y)
System.out.println(1);
else
System.out.println(2);
}
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 41617b1ab506d850526c543c1a6ae478 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | //Utilities
import java.io.*;
import java.util.*;
public class a {
static int t;
static int x, y;
public static void main(String[] args) throws IOException {
t = in.iscan();
while (t-- > 0) {
x = in.iscan(); y = in.iscan();
if (x == 0 && y == 0) {
out.println(0);
}
else if (isPerfectSquare(x*x+y*y)) {
out.println(1);
}
else {
out.println(2);
}
}
out.close();
}
static boolean isPerfectSquare(int num) {
for (int i = 1; i * i <= num; i++) {
if (i * i == num) {
return true;
}
}
return false;
}
static INPUT in = new INPUT(System.in);
static PrintWriter out = new PrintWriter(System.out);
private static class INPUT {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar, numChars;
public INPUT (InputStream stream) {
this.stream = stream;
}
public INPUT (String file) throws IOException {
this.stream = new FileInputStream (file);
}
public int cscan () throws IOException {
if (curChar >= numChars) {
curChar = 0;
numChars = stream.read (buf);
}
if (numChars == -1)
return numChars;
return buf[curChar++];
}
public int iscan () throws IOException {
int c = cscan (), sgn = 1;
while (space (c))
c = cscan ();
if (c == '-') {
sgn = -1;
c = cscan ();
}
int res = 0;
do {
res = (res << 1) + (res << 3);
res += c - '0';
c = cscan ();
}
while (!space (c));
return res * sgn;
}
public String sscan () throws IOException {
int c = cscan ();
while (space (c))
c = cscan ();
StringBuilder res = new StringBuilder ();
do {
res.appendCodePoint (c);
c = cscan ();
}
while (!space (c));
return res.toString ();
}
public double dscan () throws IOException {
int c = cscan (), sgn = 1;
while (space (c))
c = cscan ();
if (c == '-') {
sgn = -1;
c = cscan ();
}
double res = 0;
while (!space (c) && c != '.') {
if (c == 'e' || c == 'E')
return res * UTILITIES.fast_pow (10, iscan ());
res *= 10;
res += c - '0';
c = cscan ();
}
if (c == '.') {
c = cscan ();
double m = 1;
while (!space (c)) {
if (c == 'e' || c == 'E')
return res * UTILITIES.fast_pow (10, iscan ());
m /= 10;
res += (c - '0') * m;
c = cscan ();
}
}
return res * sgn;
}
public long lscan () throws IOException {
int c = cscan (), sgn = 1;
while (space (c))
c = cscan ();
if (c == '-') {
sgn = -1;
c = cscan ();
}
long res = 0;
do {
res = (res << 1) + (res << 3);
res += c - '0';
c = cscan ();
}
while (!space (c));
return res * sgn;
}
public boolean space (int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
}
public static class UTILITIES {
static final double EPS = 10e-6;
public static void sort(int[] a, boolean increasing) {
ArrayList<Integer> arr = new ArrayList<Integer>();
int n = a.length;
for (int i = 0; i < n; i++) {
arr.add(a[i]);
}
Collections.sort(arr);
for (int i = 0; i < n; i++) {
if (increasing) {
a[i] = arr.get(i);
}
else {
a[i] = arr.get(n-1-i);
}
}
}
public static void sort(long[] a, boolean increasing) {
ArrayList<Long> arr = new ArrayList<Long>();
int n = a.length;
for (int i = 0; i < n; i++) {
arr.add(a[i]);
}
Collections.sort(arr);
for (int i = 0; i < n; i++) {
if (increasing) {
a[i] = arr.get(i);
}
else {
a[i] = arr.get(n-1-i);
}
}
}
public static void sort(double[] a, boolean increasing) {
ArrayList<Double> arr = new ArrayList<Double>();
int n = a.length;
for (int i = 0; i < n; i++) {
arr.add(a[i]);
}
Collections.sort(arr);
for (int i = 0; i < n; i++) {
if (increasing) {
a[i] = arr.get(i);
}
else {
a[i] = arr.get(n-1-i);
}
}
}
public static int lower_bound (int[] arr, int x) {
int low = 0, high = arr.length, mid = -1;
while (low < high) {
mid = (low + high) / 2;
if (arr[mid] >= x)
high = mid;
else
low = mid + 1;
}
return low;
}
public static int upper_bound (int[] arr, int x) {
int low = 0, high = arr.length, mid = -1;
while (low < high) {
mid = (low + high) / 2;
if (arr[mid] > x)
high = mid;
else
low = mid + 1;
}
return low;
}
public static void updateMap(HashMap<Integer, Integer> map, int key, int v) {
if (!map.containsKey(key)) {
map.put(key, v);
}
else {
map.put(key, map.get(key) + v);
}
if (map.get(key) == 0) {
map.remove(key);
}
}
public static long gcd (long a, long b) {
return b == 0 ? a : gcd (b, a % b);
}
public static long lcm (long a, long b) {
return a * b / gcd (a, b);
}
public static long fast_pow_mod (long b, long x, int mod) {
if (x == 0) return 1;
if (x == 1) return b;
if (x % 2 == 0) return fast_pow_mod (b * b % mod, x / 2, mod) % mod;
return b * fast_pow_mod (b * b % mod, x / 2, mod) % mod;
}
public static long fast_pow (long b, long x) {
if (x == 0) return 1;
if (x == 1) return b;
if (x % 2 == 0) return fast_pow (b * b, x / 2);
return b * fast_pow (b * b, x / 2);
}
public static long choose (long n, long k) {
k = Math.min (k, n - k);
long val = 1;
for (int i = 0; i < k; ++i)
val = val * (n - i) / (i + 1);
return val;
}
public static long permute (int n, int k) {
if (n < k) return 0;
long val = 1;
for (int i = 0; i < k; ++i)
val = (val * (n - i));
return val;
}
// start of permutation and lower/upper bound template
public static void nextPermutation(int[] nums) {
//find first decreasing digit
int mark = -1;
for (int i = nums.length - 1; i > 0; i--) {
if (nums[i] > nums[i - 1]) {
mark = i - 1;
break;
}
}
if (mark == -1) {
reverse(nums, 0, nums.length - 1);
return;
}
int idx = nums.length-1;
for (int i = nums.length-1; i >= mark+1; i--) {
if (nums[i] > nums[mark]) {
idx = i;
break;
}
}
swap(nums, mark, idx);
reverse(nums, mark + 1, nums.length - 1);
}
public static void swap(int[] nums, int i, int j) {
int t = nums[i];
nums[i] = nums[j];
nums[j] = t;
}
public static void reverse(int[] nums, int i, int j) {
while (i < j) {
swap(nums, i, j);
i++;
j--;
}
}
static int lower_bound (int[] arr, int hi, int cmp) {
int low = 0, high = hi, mid = -1;
while (low < high) {
mid = (low + high) / 2;
if (arr[mid] >= cmp) high = mid;
else low = mid + 1;
}
return low;
}
static int upper_bound (int[] arr, int hi, int cmp) {
int low = 0, high = hi, mid = -1;
while (low < high) {
mid = (low + high) / 2;
if (arr[mid] > cmp) high = mid;
else low = mid + 1;
}
return low;
}
// end of permutation and lower/upper bound template
}
} | Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output | |
PASSED | 2f2795dfe2fb43351c9ab3fe08f10a70 | train_110.jsonl | 1647960300 | There's a chip in the point $$$(0, 0)$$$ of the coordinate plane. In one operation, you can move the chip from some point $$$(x_1, y_1)$$$ to some point $$$(x_2, y_2)$$$ if the Euclidean distance between these two points is an integer (i.e. $$$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$$$ is integer).Your task is to determine the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | 256 megabytes | import java.util.*;
import java.io.*;
public class JavaApplication77 {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
Scanner read=new Scanner(System.in);
int t=read.nextInt();
while(t-->0)
{
int n=read.nextInt(),k=read.nextInt(),sum=(int)(Math.sqrt(n*n+k*k));
if(sum==0)System.out.println("0");
else if(sum==Math.sqrt(k*k+n*n))
System.out.println("1");
else System.out.println("2");
}
}
static boolean Sorted(int []ar)
{
for(int i=0;i<ar.length-1;i++)
if(ar[i]>ar[i+1])return false;
return true;
}
static int gcd(int a,int b)
{
int r;
while(a%b>0)
{
r=a%b;
a=b;
b=r;
}
return b;
}
}
| Java | ["3\n8 6\n0 0\n9 15"] | 2 seconds | ["1\n0\n2"] | NoteIn the first example, one operation $$$(0, 0) \rightarrow (8, 6)$$$ is enough. $$$\sqrt{(0-8)^2+(0-6)^2}=\sqrt{64+36}=\sqrt{100}=10$$$ is an integer.In the second example, the chip is already at the destination point.In the third example, the chip can be moved as follows: $$$(0, 0) \rightarrow (5, 12) \rightarrow (9, 15)$$$. $$$\sqrt{(0-5)^2+(0-12)^2}=\sqrt{25+144}=\sqrt{169}=13$$$ and $$$\sqrt{(5-9)^2+(12-15)^2}=\sqrt{16+9}=\sqrt{25}=5$$$ are integers. | Java 11 | standard input | [
"brute force",
"math"
] | fce6d690c2790951f7e04c622c3c2d44 | The first line contains a single integer $$$t$$$ ($$$1 \le t \le 3000$$$) — number of test cases. The single line of each test case contains two integers $$$x$$$ and $$$y$$$ ($$$0 \le x, y \le 50$$$) — the coordinates of the destination point. | 800 | For each test case, print one integer — the minimum number of operations required to move the chip from the point $$$(0, 0)$$$ to the point $$$(x, y)$$$. | standard output |
Subsets and Splits