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 | cf5d143a0f8414ccd4db984ce0f64424 | train_110.jsonl | 1618839300 | Baby Ehab has a piece of Cut and Stick with an array $$$a$$$ of length $$$n$$$ written on it. He plans to grab a pair of scissors and do the following to it: pick a range $$$(l, r)$$$ and cut out every element $$$a_l$$$, $$$a_{l + 1}$$$, ..., $$$a_r$$$ in this range; stick some of the elements together in the same order they were in the array; end up with multiple pieces, where every piece contains some of the elements and every element belongs to some piece. More formally, he partitions the sequence $$$a_l$$$, $$$a_{l + 1}$$$, ..., $$$a_r$$$ into subsequences. He thinks a partitioning is beautiful if for every piece (subsequence) it holds that, if it has length $$$x$$$, then no value occurs strictly more than $$$\lceil \frac{x}{2} \rceil$$$ times in it.He didn't pick a range yet, so he's wondering: for $$$q$$$ ranges $$$(l, r)$$$, what is the minimum number of pieces he needs to partition the elements $$$a_l$$$, $$$a_{l + 1}$$$, ..., $$$a_r$$$ into so that the partitioning is beautiful.A sequence $$$b$$$ is a subsequence of an array $$$a$$$ if $$$b$$$ can be obtained from $$$a$$$ by deleting some (possibly zero) elements. Note that it does not have to be contiguous. | 512 megabytes | import java.io.*;
import java.math.*;
import java.text.*;
import java.util.*;
public class Main {
static PrintWriter out;
static Reader in;
public static void main(String[] args) throws IOException {
input_output();
Main solver = new Main();
solver.solve();
out.close();
out.flush();
}
static int INF = (int)1e18;
static int MAXN = (int)5e5 + 5;
static int mod = (int)1e9+7;
static int q, t, n, m, k;
static double pi = Math.PI;
static int bl;
static int[] arr;
void solve() throws IOException {
n = in.nextInt();
q = in.nextInt();
bl = 300;
ans = 0;
arr = new int[n];
for (int i = 0; i <n; i++) arr[i] = in.nextInt();
List<Node> qrs = new ArrayList<>();
for (int i = 0; i < q; i++) {
int l = in.nextInt(),
r = in.nextInt();
qrs.add(new Node (l, r, i));
}
Collections.sort(qrs);
freq = new int[2*n+1];
cnt = new int[2*n+1];
int[] res = new int[q];
int l= 0, r = -1;
for (int i = 0; i < qrs.size(); i++) {
Node qr = qrs.get(i);
int L = qr.l-1,
R = qr.r-1;
while (R > r)
add(++r);
while (L > l)
rem(l++);
while (R < r)
rem(r--);
while (L < l)
add(--l);
int size = r-l+1;
if (size >= max*2-1) {
res[qr.idx] = 1;
} else {
size = (r-l+1-max)*2+1;
ans = 1+r-l+1-size;
res[qr.idx] = ans;
}
}
for (int i = 0; i < q; i++) out.println(res[i]);
}
static int ans, max = 0;
static int[] freq, cnt;
static void add(int i) {
freq[cnt[arr[i]]]--;
cnt[arr[i]]++;
freq[cnt[arr[i]]]++;
if (cnt[arr[i]] > max) {
max = cnt[arr[i]];
}
}
static void rem(int i) {
freq[cnt[arr[i]]]--;
cnt[arr[i]]--;
freq[cnt[arr[i]]]++;
if (max != 0 && freq[max] == 0) {
max--;
}
}
static class Node implements Comparable<Node> {
int l, r, idx;
Node (int l, int r, int idx) {
this.l = l;
this.r = r;
this.idx = idx;
}
public int compareTo(Node o) {
if (this.l/bl != o.l/bl) return this.l-o.l;
return this.r - o.r;
}
}
static class Reader {
private InputStream mIs;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
public Reader() {
this(System.in);
}
public Reader(InputStream is) {
mIs = is;
}
public int read() {
if (numChars == -1) {
throw new InputMismatchException();
}
if (curChar >= numChars) {
curChar = 0;
try {
numChars = mIs.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 next() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
double nextDouble() {
return Double.parseDouble(next());
}
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;
}
public boolean isSpaceChar(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public boolean isEndOfLine(int c) {
return c == '\n' || c == '\r' || c == -1;
}
}
static void input_output() throws IOException {
File f = new File("in.txt");
if (f.exists() && !f.isDirectory()) {
in = new Reader(new FileInputStream("in.txt"));
} else in = new Reader();
f = new File("out.txt");
if (f.exists() && !f.isDirectory()) {
out = new PrintWriter(new File("out.txt"));
} else out = new PrintWriter(System.out);
}
} | Java | ["6 2\n1 3 2 3 3 2\n1 6\n2 5"] | 3 seconds | ["1\n2"] | NoteIn the first query, you can just put the whole array in one subsequence, since its length is $$$6$$$, and no value occurs more than $$$3$$$ times in it.In the second query, the elements of the query range are $$$[3,2,3,3]$$$. You can't put them all in one subsequence, since its length is $$$4$$$, and $$$3$$$ occurs more than $$$2$$$ times. However, you can partition it into two subsequences: $$$[3]$$$ and $$$[2,3,3]$$$. | Java 11 | standard input | [
"binary search",
"data structures",
"greedy",
"implementation",
"sortings"
] | d6c228bc6e4c17894d9e723ff980844f | The first line contains two integers $$$n$$$ and $$$q$$$ ($$$1 \le n,q \le 3 \cdot 10^5$$$) — the length of the array $$$a$$$ and the number of queries. The second line contains $$$n$$$ integers $$$a_1$$$, $$$a_2$$$, ..., $$$a_{n}$$$ ($$$1 \le a_i \le n$$$) — the elements of the array $$$a$$$. Each of the next $$$q$$$ lines contains two integers $$$l$$$ and $$$r$$$ ($$$1 \le l \le r \le n$$$) — the range of this query. | 2,000 | For each query, print the minimum number of subsequences you need to partition this range into so that the partitioning is beautiful. We can prove such partitioning always exists. | standard output | |
PASSED | d46b58eb8df86413483661c8aca14e88 | train_110.jsonl | 1618839300 | Baby Ehab has a piece of Cut and Stick with an array $$$a$$$ of length $$$n$$$ written on it. He plans to grab a pair of scissors and do the following to it: pick a range $$$(l, r)$$$ and cut out every element $$$a_l$$$, $$$a_{l + 1}$$$, ..., $$$a_r$$$ in this range; stick some of the elements together in the same order they were in the array; end up with multiple pieces, where every piece contains some of the elements and every element belongs to some piece. More formally, he partitions the sequence $$$a_l$$$, $$$a_{l + 1}$$$, ..., $$$a_r$$$ into subsequences. He thinks a partitioning is beautiful if for every piece (subsequence) it holds that, if it has length $$$x$$$, then no value occurs strictly more than $$$\lceil \frac{x}{2} \rceil$$$ times in it.He didn't pick a range yet, so he's wondering: for $$$q$$$ ranges $$$(l, r)$$$, what is the minimum number of pieces he needs to partition the elements $$$a_l$$$, $$$a_{l + 1}$$$, ..., $$$a_r$$$ into so that the partitioning is beautiful.A sequence $$$b$$$ is a subsequence of an array $$$a$$$ if $$$b$$$ can be obtained from $$$a$$$ by deleting some (possibly zero) elements. Note that it does not have to be contiguous. | 512 megabytes | import java.io.*;
import java.math.*;
import java.text.*;
import java.util.*;
public class Main {
static PrintWriter out;
static Reader in;
public static void main(String[] args) throws IOException {
input_output();
Main solver = new Main();
solver.solve();
out.close();
out.flush();
}
static int INF = (int)1e18;
static int MAXN = (int)5e5 + 5;
static int mod = (int)1e9+7;
static int q, t, n, m, k;
static double pi = Math.PI;
static int bl;
static int[] arr;
void solve() throws IOException {
n = in.nextInt();
q = in.nextInt();
bl = 300;
ans = 0;
arr = new int[n];
for (int i = 0; i <n; i++) arr[i] = in.nextInt();
List<Node> qrs = new ArrayList<>();
for (int i = 0; i < q; i++) {
int l = in.nextInt(),
r = in.nextInt();
qrs.add(new Node (l, r, i));
}
Collections.sort(qrs);
freq = new int[2*n+1];
cnt = new int[2*n+1];
int[] res = new int[q];
int l= 0, r = -1;
for (int i = 0; i < qrs.size(); i++) {
Node qr = qrs.get(i);
int L = qr.l-1,
R = qr.r-1;
while (R > r)
add(++r);
while (L > l)
rem(l++);
while (R < r)
rem(r--);
while (L < l)
add(--l);
int size = r-l+1;
if (size >= max*2-1) {
res[qr.idx] = 1;
} else {
size = (r-l+1-max)*2+1;
ans = 1+r-l+1-size;
res[qr.idx] = ans;
}
}
StringBuilder ss = new StringBuilder("");
for (int i = 0; i < q; i++) {
ss.append(res[i]+"\n");
}
out.println(ss);
}
static int ans, max = 0;
static int[] freq, cnt;
static void add(int i) {
freq[cnt[arr[i]]]--;
cnt[arr[i]]++;
freq[cnt[arr[i]]]++;
if (cnt[arr[i]] > max) {
max = cnt[arr[i]];
}
}
static void rem(int i) {
freq[cnt[arr[i]]]--;
cnt[arr[i]]--;
freq[cnt[arr[i]]]++;
if (max != 0 && freq[max] == 0) {
max--;
}
}
static class Node implements Comparable<Node> {
int l, r, idx;
Node (int l, int r, int idx) {
this.l = l;
this.r = r;
this.idx = idx;
}
public int compareTo(Node o) {
if (this.l/bl != o.l/bl) return this.l-o.l;
return this.r - o.r;
}
}
static class Reader {
private InputStream mIs;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
public Reader() {
this(System.in);
}
public Reader(InputStream is) {
mIs = is;
}
public int read() {
if (numChars == -1) {
throw new InputMismatchException();
}
if (curChar >= numChars) {
curChar = 0;
try {
numChars = mIs.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 next() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
double nextDouble() {
return Double.parseDouble(next());
}
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;
}
public boolean isSpaceChar(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public boolean isEndOfLine(int c) {
return c == '\n' || c == '\r' || c == -1;
}
}
static void input_output() throws IOException {
File f = new File("in.txt");
if (f.exists() && !f.isDirectory()) {
in = new Reader(new FileInputStream("in.txt"));
} else in = new Reader();
f = new File("out.txt");
if (f.exists() && !f.isDirectory()) {
out = new PrintWriter(new File("out.txt"));
} else out = new PrintWriter(System.out);
}
} | Java | ["6 2\n1 3 2 3 3 2\n1 6\n2 5"] | 3 seconds | ["1\n2"] | NoteIn the first query, you can just put the whole array in one subsequence, since its length is $$$6$$$, and no value occurs more than $$$3$$$ times in it.In the second query, the elements of the query range are $$$[3,2,3,3]$$$. You can't put them all in one subsequence, since its length is $$$4$$$, and $$$3$$$ occurs more than $$$2$$$ times. However, you can partition it into two subsequences: $$$[3]$$$ and $$$[2,3,3]$$$. | Java 11 | standard input | [
"binary search",
"data structures",
"greedy",
"implementation",
"sortings"
] | d6c228bc6e4c17894d9e723ff980844f | The first line contains two integers $$$n$$$ and $$$q$$$ ($$$1 \le n,q \le 3 \cdot 10^5$$$) — the length of the array $$$a$$$ and the number of queries. The second line contains $$$n$$$ integers $$$a_1$$$, $$$a_2$$$, ..., $$$a_{n}$$$ ($$$1 \le a_i \le n$$$) — the elements of the array $$$a$$$. Each of the next $$$q$$$ lines contains two integers $$$l$$$ and $$$r$$$ ($$$1 \le l \le r \le n$$$) — the range of this query. | 2,000 | For each query, print the minimum number of subsequences you need to partition this range into so that the partitioning is beautiful. We can prove such partitioning always exists. | standard output | |
PASSED | 61536b03bb95d5f62d965bd1be7ef77e | train_110.jsonl | 1618839300 | Baby Ehab has a piece of Cut and Stick with an array $$$a$$$ of length $$$n$$$ written on it. He plans to grab a pair of scissors and do the following to it: pick a range $$$(l, r)$$$ and cut out every element $$$a_l$$$, $$$a_{l + 1}$$$, ..., $$$a_r$$$ in this range; stick some of the elements together in the same order they were in the array; end up with multiple pieces, where every piece contains some of the elements and every element belongs to some piece. More formally, he partitions the sequence $$$a_l$$$, $$$a_{l + 1}$$$, ..., $$$a_r$$$ into subsequences. He thinks a partitioning is beautiful if for every piece (subsequence) it holds that, if it has length $$$x$$$, then no value occurs strictly more than $$$\lceil \frac{x}{2} \rceil$$$ times in it.He didn't pick a range yet, so he's wondering: for $$$q$$$ ranges $$$(l, r)$$$, what is the minimum number of pieces he needs to partition the elements $$$a_l$$$, $$$a_{l + 1}$$$, ..., $$$a_r$$$ into so that the partitioning is beautiful.A sequence $$$b$$$ is a subsequence of an array $$$a$$$ if $$$b$$$ can be obtained from $$$a$$$ by deleting some (possibly zero) elements. Note that it does not have to be contiguous. | 512 megabytes | import java.io.*;
import java.util.*;
public class D {
public static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
public static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
public static void main(String[] args) throws IOException {
readInput();
out.close();
}
static int n;
static int ans(int l, int r, int cur) {
int ll = -1, rr = g[cur].length;
while (ll+1<rr) {
// Floor
int m = (ll+rr)>>1;
if (g[cur][m] > r) rr = m;
else ll = m;
}
int top = ll;
ll = -1;
rr = g[cur].length;
while (ll+1<rr) {
// Floor
int m = (ll+rr)>>1;
if (g[cur][m] < l) ll = m;
else rr = m;
}
int bot = rr;
return top - bot +1;
}
static int[][] g;
public static void readInput() throws IOException {
// br = new BufferedReader(new FileReader(".in"));
// out = new PrintWriter(new FileWriter(".out"));
StringTokenizer st = new StringTokenizer(br.readLine());
n = Integer.parseInt(st.nextToken());
int q = Integer.parseInt(st.nextToken());
int[] a = new int[n];
List<Integer>[] g1 = new List[n+1];
g = new int[n+1][];
for (int i = 0; i <= n; i++) g1[i] = new ArrayList<Integer>();
st = new StringTokenizer(br.readLine());
for (int i= 0; i < n; i++) {
a[i] = Integer.parseInt(st.nextToken());
g1[a[i]].add(i);
}
for (int i = 0; i <= n; i++) {
g[i] = new int[g1[i].size()];
for (int j = 0; j < g1[i].size(); j++) {
g[i][j] = g1[i].get(j);
}
}
double[] randoms = new double[40];
for (int i = 0; i < randoms.length; i++) randoms[i] = Math.random();
while(q-->0) {
int ans = 1;
st = new StringTokenizer(br.readLine());
int l = Integer.parseInt(st.nextToken())-1;
int r = Integer.parseInt(st.nextToken())-1;
int len = (r-l+1);
for (int tq = 0; tq < 25; tq++) {
int rand = (int)(Math.random()* len) + l;
int cur = a[rand];
int cnt = ans(l,r,cur);
//out.println(cnt + " " + (len+1)/2);
if (cnt > (len+1)/2) {
int freq = cnt;
int opp = len-cnt;
int sol = 1;
freq-=(opp+1);
opp = 0;
sol += freq;
ans = sol;
break;
}
}
out.println(ans);
}
}
} | Java | ["6 2\n1 3 2 3 3 2\n1 6\n2 5"] | 3 seconds | ["1\n2"] | NoteIn the first query, you can just put the whole array in one subsequence, since its length is $$$6$$$, and no value occurs more than $$$3$$$ times in it.In the second query, the elements of the query range are $$$[3,2,3,3]$$$. You can't put them all in one subsequence, since its length is $$$4$$$, and $$$3$$$ occurs more than $$$2$$$ times. However, you can partition it into two subsequences: $$$[3]$$$ and $$$[2,3,3]$$$. | Java 11 | standard input | [
"binary search",
"data structures",
"greedy",
"implementation",
"sortings"
] | d6c228bc6e4c17894d9e723ff980844f | The first line contains two integers $$$n$$$ and $$$q$$$ ($$$1 \le n,q \le 3 \cdot 10^5$$$) — the length of the array $$$a$$$ and the number of queries. The second line contains $$$n$$$ integers $$$a_1$$$, $$$a_2$$$, ..., $$$a_{n}$$$ ($$$1 \le a_i \le n$$$) — the elements of the array $$$a$$$. Each of the next $$$q$$$ lines contains two integers $$$l$$$ and $$$r$$$ ($$$1 \le l \le r \le n$$$) — the range of this query. | 2,000 | For each query, print the minimum number of subsequences you need to partition this range into so that the partitioning is beautiful. We can prove such partitioning always exists. | standard output | |
PASSED | 3a8d915c146f6ec60849aa2daf6fe396 | train_110.jsonl | 1618839300 | Baby Ehab has a piece of Cut and Stick with an array $$$a$$$ of length $$$n$$$ written on it. He plans to grab a pair of scissors and do the following to it: pick a range $$$(l, r)$$$ and cut out every element $$$a_l$$$, $$$a_{l + 1}$$$, ..., $$$a_r$$$ in this range; stick some of the elements together in the same order they were in the array; end up with multiple pieces, where every piece contains some of the elements and every element belongs to some piece. More formally, he partitions the sequence $$$a_l$$$, $$$a_{l + 1}$$$, ..., $$$a_r$$$ into subsequences. He thinks a partitioning is beautiful if for every piece (subsequence) it holds that, if it has length $$$x$$$, then no value occurs strictly more than $$$\lceil \frac{x}{2} \rceil$$$ times in it.He didn't pick a range yet, so he's wondering: for $$$q$$$ ranges $$$(l, r)$$$, what is the minimum number of pieces he needs to partition the elements $$$a_l$$$, $$$a_{l + 1}$$$, ..., $$$a_r$$$ into so that the partitioning is beautiful.A sequence $$$b$$$ is a subsequence of an array $$$a$$$ if $$$b$$$ can be obtained from $$$a$$$ by deleting some (possibly zero) elements. Note that it does not have to be contiguous. | 512 megabytes | import java.io.*;
import java.util.*;
public class D {
public static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
public static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
public static void main(String[] args) throws IOException {
readInput();
out.close();
}
static int n;
static int ans(int l, int r, int cur) {
int ll = -1, rr = g[cur].size();
while (ll+1<rr) {
// Floor
int m = (ll+rr)>>1;
if (g[cur].get(m) > r) rr = m;
else ll = m;
}
int top = ll;
ll = -1;
rr = g[cur].size();
while (ll+1<rr) {
// Floor
int m = (ll+rr)>>1;
if (g[cur].get(m) < l) ll = m;
else rr = m;
}
int bot = rr;
return top - bot +1;
}
static List<Integer>[] g;
public static void readInput() throws IOException {
// br = new BufferedReader(new FileReader(".in"));
// out = new PrintWriter(new FileWriter(".out"));
StringTokenizer st = new StringTokenizer(br.readLine());
n = Integer.parseInt(st.nextToken());
int q = Integer.parseInt(st.nextToken());
int[] a = new int[n];
g = new List[n+1];
for (int i = 0; i <= n; i++) g[i] = new ArrayList<Integer>();
st = new StringTokenizer(br.readLine());
for (int i= 0; i < n; i++) {
a[i] = Integer.parseInt(st.nextToken());
g[a[i]].add(i);
}
double[] randoms = new double[40];
for (int i = 0; i < randoms.length; i++) randoms[i] = Math.random();
while(q-->0) {
int ans = 1;
st = new StringTokenizer(br.readLine());
int l = Integer.parseInt(st.nextToken())-1;
int r = Integer.parseInt(st.nextToken())-1;
int len = (r-l+1);
for (int tq = 0; tq < 25; tq++) {
int rand = (int)(randoms[tq] * len) + l;
int cur = a[rand];
int cnt = ans(l,r,cur);
//out.println(cnt + " " + (len+1)/2);
if (cnt > (len+1)/2) {
int freq = cnt;
int opp = len-cnt;
int sol = 1;
freq-=(opp+1);
opp = 0;
sol += freq;
ans = sol;
break;
}
}
out.println(ans);
}
}
} | Java | ["6 2\n1 3 2 3 3 2\n1 6\n2 5"] | 3 seconds | ["1\n2"] | NoteIn the first query, you can just put the whole array in one subsequence, since its length is $$$6$$$, and no value occurs more than $$$3$$$ times in it.In the second query, the elements of the query range are $$$[3,2,3,3]$$$. You can't put them all in one subsequence, since its length is $$$4$$$, and $$$3$$$ occurs more than $$$2$$$ times. However, you can partition it into two subsequences: $$$[3]$$$ and $$$[2,3,3]$$$. | Java 11 | standard input | [
"binary search",
"data structures",
"greedy",
"implementation",
"sortings"
] | d6c228bc6e4c17894d9e723ff980844f | The first line contains two integers $$$n$$$ and $$$q$$$ ($$$1 \le n,q \le 3 \cdot 10^5$$$) — the length of the array $$$a$$$ and the number of queries. The second line contains $$$n$$$ integers $$$a_1$$$, $$$a_2$$$, ..., $$$a_{n}$$$ ($$$1 \le a_i \le n$$$) — the elements of the array $$$a$$$. Each of the next $$$q$$$ lines contains two integers $$$l$$$ and $$$r$$$ ($$$1 \le l \le r \le n$$$) — the range of this query. | 2,000 | For each query, print the minimum number of subsequences you need to partition this range into so that the partitioning is beautiful. We can prove such partitioning always exists. | standard output | |
PASSED | 351a427c1613f40f90638810a3b3be84 | train_110.jsonl | 1618839300 | Baby Ehab has a piece of Cut and Stick with an array $$$a$$$ of length $$$n$$$ written on it. He plans to grab a pair of scissors and do the following to it: pick a range $$$(l, r)$$$ and cut out every element $$$a_l$$$, $$$a_{l + 1}$$$, ..., $$$a_r$$$ in this range; stick some of the elements together in the same order they were in the array; end up with multiple pieces, where every piece contains some of the elements and every element belongs to some piece. More formally, he partitions the sequence $$$a_l$$$, $$$a_{l + 1}$$$, ..., $$$a_r$$$ into subsequences. He thinks a partitioning is beautiful if for every piece (subsequence) it holds that, if it has length $$$x$$$, then no value occurs strictly more than $$$\lceil \frac{x}{2} \rceil$$$ times in it.He didn't pick a range yet, so he's wondering: for $$$q$$$ ranges $$$(l, r)$$$, what is the minimum number of pieces he needs to partition the elements $$$a_l$$$, $$$a_{l + 1}$$$, ..., $$$a_r$$$ into so that the partitioning is beautiful.A sequence $$$b$$$ is a subsequence of an array $$$a$$$ if $$$b$$$ can be obtained from $$$a$$$ by deleting some (possibly zero) elements. Note that it does not have to be contiguous. | 512 megabytes | import java.util.*;
import java.io.*;
public class D {
static int seg_tree[];
static int a[];
static ArrayList<ArrayList<Integer>> al;
static int count(int start, int end, int val) {
return upperbound(al.get(val), end) - lowerbound(al.get(val), start) + 1;
}
static void build(int node, int start, int end) {
if (start == end)
seg_tree[node] = a[start];
else {
int mid = (start + end) >> 1;
build(2 * node, start, mid); // left node
build(2 * node + 1, mid + 1, end); // right node
if (count(start, end, seg_tree[2 * node]) > count(start, end, seg_tree[2 * node + 1]))
seg_tree[node] = seg_tree[2 * node];
else
seg_tree[node] = seg_tree[2 * node + 1];
}
}
static int query(int node, int start, int end, int l, int r) { // 1 1 n l r
if (end < l || start > r || r < l)
return 0;
if (l <= start && end <= r)
return count(l, r, seg_tree[node]);
int mid = (start + end) >> 1;
return Math.max(query(2 * node, start, mid, l, r), query(2 * node + 1, mid + 1, end, l, r));
}
public static void main(String[] args) throws Exception {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));
StringBuilder sb = new StringBuilder();
StringTokenizer st;
st = new StringTokenizer(br.readLine());
int n = Integer.parseInt(st.nextToken());
int q = Integer.parseInt(st.nextToken());
a = new int[n + 1];
al = new ArrayList<ArrayList<Integer>>(); // stores position
for (int i = 0; i <= n; i++)
al.add(new ArrayList<Integer>());
st = new StringTokenizer(br.readLine());
for (int i = 1; i <= n; i++) {
a[i] = Integer.parseInt(st.nextToken());
al.get(a[i]).add(i);
}
seg_tree = new int[4 * n + 2];
build(1, 1, n);
while (q-- > 0) {
st = new StringTokenizer(br.readLine());
int l = Integer.parseInt(st.nextToken());
int r = Integer.parseInt(st.nextToken());
int m = r - l + 1;
int ans = 2 * query(1, 1, n, l, r) - m;
ans = Math.max(1, ans);
sb.append(ans).append("\n");
}
pw.print(sb);
pw.flush();
pw.close();
}
static int lowerbound(ArrayList<Integer> arr, int target) {
int l = 0;
int r = arr.size() - 1;
int mid;
while (l < r) {
mid = (l + r) >> 1;
if (arr.get(mid) >= target)
r = mid;
else
l = mid + 1;
}
return l;
}
static int upperbound(ArrayList<Integer> arr, int target) {
int l = 0;
int r = arr.size() - 1;
int mid;
while (l < r) {
mid = (l + r + 1) >> 1;
if (arr.get(mid) > target)
r = mid - 1;
else
l = mid;
}
return l;
}
} | Java | ["6 2\n1 3 2 3 3 2\n1 6\n2 5"] | 3 seconds | ["1\n2"] | NoteIn the first query, you can just put the whole array in one subsequence, since its length is $$$6$$$, and no value occurs more than $$$3$$$ times in it.In the second query, the elements of the query range are $$$[3,2,3,3]$$$. You can't put them all in one subsequence, since its length is $$$4$$$, and $$$3$$$ occurs more than $$$2$$$ times. However, you can partition it into two subsequences: $$$[3]$$$ and $$$[2,3,3]$$$. | Java 11 | standard input | [
"binary search",
"data structures",
"greedy",
"implementation",
"sortings"
] | d6c228bc6e4c17894d9e723ff980844f | The first line contains two integers $$$n$$$ and $$$q$$$ ($$$1 \le n,q \le 3 \cdot 10^5$$$) — the length of the array $$$a$$$ and the number of queries. The second line contains $$$n$$$ integers $$$a_1$$$, $$$a_2$$$, ..., $$$a_{n}$$$ ($$$1 \le a_i \le n$$$) — the elements of the array $$$a$$$. Each of the next $$$q$$$ lines contains two integers $$$l$$$ and $$$r$$$ ($$$1 \le l \le r \le n$$$) — the range of this query. | 2,000 | For each query, print the minimum number of subsequences you need to partition this range into so that the partitioning is beautiful. We can prove such partitioning always exists. | standard output | |
PASSED | fc80250366c66d2209ed8c630a19e89c | train_110.jsonl | 1618839300 | Baby Ehab has a piece of Cut and Stick with an array $$$a$$$ of length $$$n$$$ written on it. He plans to grab a pair of scissors and do the following to it: pick a range $$$(l, r)$$$ and cut out every element $$$a_l$$$, $$$a_{l + 1}$$$, ..., $$$a_r$$$ in this range; stick some of the elements together in the same order they were in the array; end up with multiple pieces, where every piece contains some of the elements and every element belongs to some piece. More formally, he partitions the sequence $$$a_l$$$, $$$a_{l + 1}$$$, ..., $$$a_r$$$ into subsequences. He thinks a partitioning is beautiful if for every piece (subsequence) it holds that, if it has length $$$x$$$, then no value occurs strictly more than $$$\lceil \frac{x}{2} \rceil$$$ times in it.He didn't pick a range yet, so he's wondering: for $$$q$$$ ranges $$$(l, r)$$$, what is the minimum number of pieces he needs to partition the elements $$$a_l$$$, $$$a_{l + 1}$$$, ..., $$$a_r$$$ into so that the partitioning is beautiful.A sequence $$$b$$$ is a subsequence of an array $$$a$$$ if $$$b$$$ can be obtained from $$$a$$$ by deleting some (possibly zero) elements. Note that it does not have to be contiguous. | 512 megabytes | import java.util.*;
import java.io.*;
public class D {
static int seg_tree[];
static int a[];
static ArrayList<ArrayList<Integer>> al;
static int count(int start, int end, int val) {
return upperbound(al.get(val), end) - lowerbound(al.get(val), start) + 1;
}
static void build(int node, int start, int end) {
if (start == end)
seg_tree[node] = a[start];
else {
int mid = (start + end) >> 1;
build(2 * node, start, mid); // left node
build(2 * node + 1, mid + 1, end); // right node
if (count(start, end, seg_tree[2 * node]) > count(start, end, seg_tree[2 * node + 1]))
seg_tree[node] = seg_tree[2 * node];
else
seg_tree[node] = seg_tree[2 * node + 1];
}
}
static int query(int node, int start, int end, int l, int r) { // 1 1 n l r
if (end < l || start > r || r < l)
return 0;
if (l <= start && end <= r)
return count(l, r, seg_tree[node]);
int mid = (start + end) >> 1;
return Math.max(query(2 * node, start, mid, l, r), query(2 * node + 1, mid + 1, end, l, r));
}
public static void main(String[] args) throws Exception {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));
StringBuilder sb = new StringBuilder();
StringTokenizer st;
st = new StringTokenizer(br.readLine().trim());
int n = Integer.parseInt(st.nextToken());
int q = Integer.parseInt(st.nextToken());
a = new int[n + 1];
al = new ArrayList<ArrayList<Integer>>(); // stores position
for (int i = 0; i <= n; i++)
al.add(new ArrayList<Integer>());
st = new StringTokenizer(br.readLine());
for (int i = 1; i <= n; i++) {
a[i] = Integer.parseInt(st.nextToken());
al.get(a[i]).add(i);
}
seg_tree = new int[4 * n + 2];
build(1, 1, n);
while (q-- > 0) {
st = new StringTokenizer(br.readLine());
int l = Integer.parseInt(st.nextToken());
int r = Integer.parseInt(st.nextToken());
int m = r - l + 1;
int ans = 2 * query(1, 1, n, l, r) - m;
ans = Math.max(1, ans);
sb.append(ans).append("\n");
}
pw.print(sb);
pw.flush();
pw.close();
}
static int lowerbound(ArrayList<Integer> arr, int target) {
int l = 0;
int r = arr.size() - 1;
int mid;
while (l < r) {
mid = (l + r) >> 1;
if (arr.get(mid) >= target)
r = mid;
else
l = mid + 1;
}
return l;
}
static int upperbound(ArrayList<Integer> arr, int target) {
int l = 0;
int r = arr.size() - 1;
int mid;
while (l < r) {
mid = (l + r + 1) >> 1;
if (arr.get(mid) > target)
r = mid - 1;
else
l = mid;
}
return l;
}
} | Java | ["6 2\n1 3 2 3 3 2\n1 6\n2 5"] | 3 seconds | ["1\n2"] | NoteIn the first query, you can just put the whole array in one subsequence, since its length is $$$6$$$, and no value occurs more than $$$3$$$ times in it.In the second query, the elements of the query range are $$$[3,2,3,3]$$$. You can't put them all in one subsequence, since its length is $$$4$$$, and $$$3$$$ occurs more than $$$2$$$ times. However, you can partition it into two subsequences: $$$[3]$$$ and $$$[2,3,3]$$$. | Java 11 | standard input | [
"binary search",
"data structures",
"greedy",
"implementation",
"sortings"
] | d6c228bc6e4c17894d9e723ff980844f | The first line contains two integers $$$n$$$ and $$$q$$$ ($$$1 \le n,q \le 3 \cdot 10^5$$$) — the length of the array $$$a$$$ and the number of queries. The second line contains $$$n$$$ integers $$$a_1$$$, $$$a_2$$$, ..., $$$a_{n}$$$ ($$$1 \le a_i \le n$$$) — the elements of the array $$$a$$$. Each of the next $$$q$$$ lines contains two integers $$$l$$$ and $$$r$$$ ($$$1 \le l \le r \le n$$$) — the range of this query. | 2,000 | For each query, print the minimum number of subsequences you need to partition this range into so that the partitioning is beautiful. We can prove such partitioning always exists. | standard output | |
PASSED | fa5d00d65d1409743078ffb3789c9c59 | train_110.jsonl | 1618839300 | Baby Ehab has a piece of Cut and Stick with an array $$$a$$$ of length $$$n$$$ written on it. He plans to grab a pair of scissors and do the following to it: pick a range $$$(l, r)$$$ and cut out every element $$$a_l$$$, $$$a_{l + 1}$$$, ..., $$$a_r$$$ in this range; stick some of the elements together in the same order they were in the array; end up with multiple pieces, where every piece contains some of the elements and every element belongs to some piece. More formally, he partitions the sequence $$$a_l$$$, $$$a_{l + 1}$$$, ..., $$$a_r$$$ into subsequences. He thinks a partitioning is beautiful if for every piece (subsequence) it holds that, if it has length $$$x$$$, then no value occurs strictly more than $$$\lceil \frac{x}{2} \rceil$$$ times in it.He didn't pick a range yet, so he's wondering: for $$$q$$$ ranges $$$(l, r)$$$, what is the minimum number of pieces he needs to partition the elements $$$a_l$$$, $$$a_{l + 1}$$$, ..., $$$a_r$$$ into so that the partitioning is beautiful.A sequence $$$b$$$ is a subsequence of an array $$$a$$$ if $$$b$$$ can be obtained from $$$a$$$ by deleting some (possibly zero) elements. Note that it does not have to be contiguous. | 512 megabytes | import java.io.*;
import java.util.*;
public class Main {
void run() throws IOException {
int n = nextInt();
int q = nextInt();
ArrayList<Integer>[] a = new ArrayList[n];
for (int i = 0; i < n; i++) {
a[i] = new ArrayList<>();
}
int[] z = new int[n];
for (int i = 0; i < n; i++) {
z[i] = nextInt();
a[z[i] - 1].add(i);
}
while (q-- > 0) {
int l = nextInt() - 1;
int r = nextInt();
int mx = 0;
for (int i = 0; i < 20; i++) {
int idx = ((int) (Math.random() * 3 * 1000000)) % (r - l) + l;
int now = z[idx] - 1;
int ll = -1;
int rr = a[now].size();
while (ll + 1 < rr) {
int m = (ll + rr) >> 1;
if (a[now].get(m) < l) ll = m;
else rr = m;
}
int lll = 0;
int rrr = a[now].size();
while (lll + 1 < rrr) {
int m = (lll + rrr) >> 1;
if (a[now].get(m) < r) lll = m;
else rrr = m;
}
mx = Math.max(mx, lll - ll);
}
if ((r - l + 1) / 2 >= mx) out.println(1);
else if (mx == r - l) out.println(mx);
else out.println(mx * 2 - r + l);
}
}
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
PrintWriter out = new PrintWriter(System.out);
StringTokenizer in = new StringTokenizer("");
// pairs
class pil implements Comparable<pil> {
int first;
long second;
pil(int f, long s) {
this.first = f;
this.second = s;
}
public int compareTo(pil o) {
if (first != o.first) return Integer.compare(first, o.first);
return Long.compare(second, o.second);
}
}
class pii implements Comparable<pii> {
int fi;
int se;
pii(int f, int s) {
se = s;
fi = f;
}
public int compareTo(pii o) {
if (fi != o.fi) return Integer.compare(fi, o.fi);
return Integer.compare(se, o.se);
}
}
class vert {
int to;
int iter;
int idx;
int ed;
vert(int s, int f, int zz, int gg) {
to = s;
iter = f;
idx = zz;
ed = gg;
}
}
class pll implements Comparable<pll> {
long first;
long second;
pll(long f, long s) {
this.first = f;
this.second = s;
}
public int compareTo(pll o) {
if (first != o.first) return Long.compare(first, o.first);
return Long.compare(second, o.second);
}
}
class pli implements Comparable<pli> {
long first;
int second;
pli(long f, int s) {
this.first = f;
this.second = s;
}
public int compareTo(pli o) {
if (first != o.first) return Long.compare(first, o.first);
return Integer.compare(second, o.second);
}
}
boolean hasNext() throws IOException {
if (in.hasMoreTokens()) return true;
String s;
while ((s = br.readLine()) != null) {
in = new StringTokenizer(s);
if (in.hasMoreTokens()) return true;
}
return false;
}
String nextToken() throws IOException {
while (!in.hasMoreTokens()) {
in = new StringTokenizer(br.readLine());
}
return in.nextToken();
}
int nextInt() throws IOException {
return Integer.parseInt(nextToken());
}
double nextDouble() throws IOException {
return Double.parseDouble(nextToken());
}
long nextLong() throws IOException {
return Long.parseLong(nextToken());
}
public static void main(String[] args) throws IOException {
Main m = new Main();
m.run();
m.out.close();
}
} | Java | ["6 2\n1 3 2 3 3 2\n1 6\n2 5"] | 3 seconds | ["1\n2"] | NoteIn the first query, you can just put the whole array in one subsequence, since its length is $$$6$$$, and no value occurs more than $$$3$$$ times in it.In the second query, the elements of the query range are $$$[3,2,3,3]$$$. You can't put them all in one subsequence, since its length is $$$4$$$, and $$$3$$$ occurs more than $$$2$$$ times. However, you can partition it into two subsequences: $$$[3]$$$ and $$$[2,3,3]$$$. | Java 11 | standard input | [
"binary search",
"data structures",
"greedy",
"implementation",
"sortings"
] | d6c228bc6e4c17894d9e723ff980844f | The first line contains two integers $$$n$$$ and $$$q$$$ ($$$1 \le n,q \le 3 \cdot 10^5$$$) — the length of the array $$$a$$$ and the number of queries. The second line contains $$$n$$$ integers $$$a_1$$$, $$$a_2$$$, ..., $$$a_{n}$$$ ($$$1 \le a_i \le n$$$) — the elements of the array $$$a$$$. Each of the next $$$q$$$ lines contains two integers $$$l$$$ and $$$r$$$ ($$$1 \le l \le r \le n$$$) — the range of this query. | 2,000 | For each query, print the minimum number of subsequences you need to partition this range into so that the partitioning is beautiful. We can prove such partitioning always exists. | standard output | |
PASSED | 0e1d1197b3617a20f45b70ecfb4a979d | train_110.jsonl | 1618839300 | Baby Ehab has a piece of Cut and Stick with an array $$$a$$$ of length $$$n$$$ written on it. He plans to grab a pair of scissors and do the following to it: pick a range $$$(l, r)$$$ and cut out every element $$$a_l$$$, $$$a_{l + 1}$$$, ..., $$$a_r$$$ in this range; stick some of the elements together in the same order they were in the array; end up with multiple pieces, where every piece contains some of the elements and every element belongs to some piece. More formally, he partitions the sequence $$$a_l$$$, $$$a_{l + 1}$$$, ..., $$$a_r$$$ into subsequences. He thinks a partitioning is beautiful if for every piece (subsequence) it holds that, if it has length $$$x$$$, then no value occurs strictly more than $$$\lceil \frac{x}{2} \rceil$$$ times in it.He didn't pick a range yet, so he's wondering: for $$$q$$$ ranges $$$(l, r)$$$, what is the minimum number of pieces he needs to partition the elements $$$a_l$$$, $$$a_{l + 1}$$$, ..., $$$a_r$$$ into so that the partitioning is beautiful.A sequence $$$b$$$ is a subsequence of an array $$$a$$$ if $$$b$$$ can be obtained from $$$a$$$ by deleting some (possibly zero) elements. Note that it does not have to be contiguous. | 512 megabytes | import java.io.*;
import java.util.*;
public class cut_stick {
static int n;
static List<Integer>[] g;
public static void main(String[] args) throws Exception {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
StringTokenizer line = new StringTokenizer(in.readLine());
n = Integer.parseInt(line.nextToken());
int q = Integer.parseInt(line.nextToken());
int[] a = new int[n];
g = new List[n+1];
for (int i = 0; i <= n; i++) {
g[i] = new ArrayList<Integer>();
}
line = new StringTokenizer(in.readLine());
for (int i = 0; i < n; i++) {
a[i] = Integer.parseInt(line.nextToken());
g[a[i]].add(i);
}
double[] randoms = new double[40];
for (int i = 0; i < randoms.length; i++) {
randoms[i] = Math.random();
}
while(q-->0) {
int result = 1;
line = new StringTokenizer(in.readLine());
int l = Integer.parseInt(line.nextToken())-1;
int r = Integer.parseInt(line.nextToken())-1;
int len = (r - l + 1);
for (int tq = 0; tq < 25; tq++) {
int rand = (int)(randoms[tq] * len) + l;
int cur = a[rand];
int count = solve(l, r, cur);
if (count > (len + 1) / 2) {
int freq = count;
int opp = len-count;
int sol = 1;
freq -= (opp + 1);
opp = 0;
sol += freq;
result = sol;
break;
}
}
out.println(result);
}
out.close();
}
static int solve(int l, int r, int cur) {
int ll = -1;
int rr = g[cur].size();
while (ll + 1 < rr) {
int m = (ll+rr)>>1;
if (g[cur].get(m) > r) {
rr = m;
} else {
ll = m;
}
}
int top = ll;
ll = -1;
rr = g[cur].size();
while (ll + 1 < rr) {
int m = (ll+rr)>>1;
if (g[cur].get(m) < l) {
ll = m;
} else {
rr = m;
}
}
int bot = rr;
return top - bot +1;
}
}
| Java | ["6 2\n1 3 2 3 3 2\n1 6\n2 5"] | 3 seconds | ["1\n2"] | NoteIn the first query, you can just put the whole array in one subsequence, since its length is $$$6$$$, and no value occurs more than $$$3$$$ times in it.In the second query, the elements of the query range are $$$[3,2,3,3]$$$. You can't put them all in one subsequence, since its length is $$$4$$$, and $$$3$$$ occurs more than $$$2$$$ times. However, you can partition it into two subsequences: $$$[3]$$$ and $$$[2,3,3]$$$. | Java 11 | standard input | [
"binary search",
"data structures",
"greedy",
"implementation",
"sortings"
] | d6c228bc6e4c17894d9e723ff980844f | The first line contains two integers $$$n$$$ and $$$q$$$ ($$$1 \le n,q \le 3 \cdot 10^5$$$) — the length of the array $$$a$$$ and the number of queries. The second line contains $$$n$$$ integers $$$a_1$$$, $$$a_2$$$, ..., $$$a_{n}$$$ ($$$1 \le a_i \le n$$$) — the elements of the array $$$a$$$. Each of the next $$$q$$$ lines contains two integers $$$l$$$ and $$$r$$$ ($$$1 \le l \le r \le n$$$) — the range of this query. | 2,000 | For each query, print the minimum number of subsequences you need to partition this range into so that the partitioning is beautiful. We can prove such partitioning always exists. | standard output | |
PASSED | 88d1203c06f8bef8e71f744dfb5761bc | train_110.jsonl | 1618839300 | Baby Ehab has a piece of Cut and Stick with an array $$$a$$$ of length $$$n$$$ written on it. He plans to grab a pair of scissors and do the following to it: pick a range $$$(l, r)$$$ and cut out every element $$$a_l$$$, $$$a_{l + 1}$$$, ..., $$$a_r$$$ in this range; stick some of the elements together in the same order they were in the array; end up with multiple pieces, where every piece contains some of the elements and every element belongs to some piece. More formally, he partitions the sequence $$$a_l$$$, $$$a_{l + 1}$$$, ..., $$$a_r$$$ into subsequences. He thinks a partitioning is beautiful if for every piece (subsequence) it holds that, if it has length $$$x$$$, then no value occurs strictly more than $$$\lceil \frac{x}{2} \rceil$$$ times in it.He didn't pick a range yet, so he's wondering: for $$$q$$$ ranges $$$(l, r)$$$, what is the minimum number of pieces he needs to partition the elements $$$a_l$$$, $$$a_{l + 1}$$$, ..., $$$a_r$$$ into so that the partitioning is beautiful.A sequence $$$b$$$ is a subsequence of an array $$$a$$$ if $$$b$$$ can be obtained from $$$a$$$ by deleting some (possibly zero) elements. Note that it does not have to be contiguous. | 512 megabytes |
import java.util.*;
import java.io.*;
public class CutandStick {
// https://codeforces.com/contest/1514/problem/D
static int n, maxcount=0, numvals=0;
static int[] arr;
public static void main(String[] args) throws IOException, FileNotFoundException {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
//BufferedReader in = new BufferedReader(new FileReader("CutandStick"));
int t = 1;
while (t-- > 0) {
StringTokenizer st = new StringTokenizer(in.readLine());
n = Integer.parseInt(st.nextToken());
int q = Integer.parseInt(st.nextToken());
A[] queries =new A[q];
arr = new int[n];
st = new StringTokenizer(in.readLine());
for (int i=0; i<n; i++) {
arr[i] = Integer.parseInt(st.nextToken());
}
for (int i=0; i<q; i++) {
st = new StringTokenizer(in.readLine());
queries[i] = new A(Integer.parseInt(st.nextToken())-1, Integer.parseInt(st.nextToken())-1, i);
}
MO(queries, q, (int) (Math.sqrt(n) + 1));
}
}
public static void MO(A[] queries, int q, int len) {
Arrays.parallelSort(queries, new Comparator<A>() {
public int compare(A a, A b) {
if (a.left/len == b.left/len) {
return a.right - b.right;
}
else {
return a.left/len - b.left/len;
}
}
});
int[] answer = new int[q];
int ans = 0;
int[] count = new int[n+1];
int[] val = new int[n+1];
int left = 0;
int right = 0;
ans = add(arr[0], val, count);
for (int i=0; i<q; i++) {
// queries[i].print();
while (left > queries[i].left) {
left--;
ans = add(arr[left], val, count);
}
while (right < queries[i].right) {
right++;
ans = add(arr[right], val, count);
}
while (left < queries[i].left) {
ans = remove(arr[left], val, count);
left++;
}
while (right > queries[i].right) {
ans = remove(arr[right], val, count);
right--;
}
answer[queries[i].index]= ans;
}
StringBuilder sb = new StringBuilder();
for (int i=0; i<q; i++) {
sb.append(answer[i] + "\n");
}
System.out.print(sb);
}
public static int add(int index, int[] count, int[] vals) {
if (vals[index] > 0) {
count[vals[index]]--;
}
vals[index]++;
count[vals[index]]++;
maxcount = Math.max(maxcount, vals[index]);
numvals++;
int last = maxcount;
int rest = numvals - last;
if (last <= rest+1) {
return 1;
}
last -= rest;
return last;
}
public static int remove(int index, int[] count, int[] vals) {
if (vals[index] > 0) {
count[vals[index]]--;
if (vals[index] == maxcount && count[vals[index]] == 0) {
maxcount=0;
}
}
vals[index]--;
count[vals[index]]++;
maxcount = Math.max(maxcount, vals[index]);
numvals--;
int last = maxcount;
int rest = numvals - last;
if (last <= rest+1) {
return 1;
}
last -= rest;
return last;
}
static class A {
int left, right, index;
A (int a, int b, int c) {
left = a; right = b; index = c;
}
void print() {
System.out.println(left + " " + right);
}
}
} | Java | ["6 2\n1 3 2 3 3 2\n1 6\n2 5"] | 3 seconds | ["1\n2"] | NoteIn the first query, you can just put the whole array in one subsequence, since its length is $$$6$$$, and no value occurs more than $$$3$$$ times in it.In the second query, the elements of the query range are $$$[3,2,3,3]$$$. You can't put them all in one subsequence, since its length is $$$4$$$, and $$$3$$$ occurs more than $$$2$$$ times. However, you can partition it into two subsequences: $$$[3]$$$ and $$$[2,3,3]$$$. | Java 11 | standard input | [
"binary search",
"data structures",
"greedy",
"implementation",
"sortings"
] | d6c228bc6e4c17894d9e723ff980844f | The first line contains two integers $$$n$$$ and $$$q$$$ ($$$1 \le n,q \le 3 \cdot 10^5$$$) — the length of the array $$$a$$$ and the number of queries. The second line contains $$$n$$$ integers $$$a_1$$$, $$$a_2$$$, ..., $$$a_{n}$$$ ($$$1 \le a_i \le n$$$) — the elements of the array $$$a$$$. Each of the next $$$q$$$ lines contains two integers $$$l$$$ and $$$r$$$ ($$$1 \le l \le r \le n$$$) — the range of this query. | 2,000 | For each query, print the minimum number of subsequences you need to partition this range into so that the partitioning is beautiful. We can prove such partitioning always exists. | standard output | |
PASSED | 612bebf28802a28b82a0165505f97719 | train_110.jsonl | 1618839300 | Baby Ehab has a piece of Cut and Stick with an array $$$a$$$ of length $$$n$$$ written on it. He plans to grab a pair of scissors and do the following to it: pick a range $$$(l, r)$$$ and cut out every element $$$a_l$$$, $$$a_{l + 1}$$$, ..., $$$a_r$$$ in this range; stick some of the elements together in the same order they were in the array; end up with multiple pieces, where every piece contains some of the elements and every element belongs to some piece. More formally, he partitions the sequence $$$a_l$$$, $$$a_{l + 1}$$$, ..., $$$a_r$$$ into subsequences. He thinks a partitioning is beautiful if for every piece (subsequence) it holds that, if it has length $$$x$$$, then no value occurs strictly more than $$$\lceil \frac{x}{2} \rceil$$$ times in it.He didn't pick a range yet, so he's wondering: for $$$q$$$ ranges $$$(l, r)$$$, what is the minimum number of pieces he needs to partition the elements $$$a_l$$$, $$$a_{l + 1}$$$, ..., $$$a_r$$$ into so that the partitioning is beautiful.A sequence $$$b$$$ is a subsequence of an array $$$a$$$ if $$$b$$$ can be obtained from $$$a$$$ by deleting some (possibly zero) elements. Note that it does not have to be contiguous. | 512 megabytes | import java.io.*;
import java.util.*;
public class Codeforces {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
//int cases = Integer.parseInt(br.readLine());
//while(cases-- > 0) {
String[] str = br.readLine().split(" ");
int n = Integer.parseInt(str[0]);
int q = Integer.parseInt(str[1]);
int[] a = new int[n];
str = br.readLine().split(" ");
HashMap<Integer, ArrayList<Integer>> map = new HashMap<>();
for(int i=0; i<n; i++) {
a[i] = Integer.parseInt(str[i]);
if(!map.containsKey(a[i])) {
map.put(a[i], new ArrayList<Integer>());
}
map.get(a[i]).add(i);
}
double[] randoms = new double[40];
for(int i=0; i<40; i++) {
randoms[i] = Math.random();
}
StringBuffer buf = new StringBuffer();
while(q-- > 0) {
int ans = 1;
str = br.readLine().split(" ");
int l = Integer.parseInt(str[0]) - 1;
int r = Integer.parseInt(str[1]) - 1;
int m = r - l + 1;
for(int tq=0; tq<25; tq++) {
int rand = (int)(randoms[tq]*m) + l;
int cur = a[rand];
ArrayList<Integer> send = map.get(cur);
int f = upperbound(send, r) - lowerbound(send, l);
if(f > (m+1)/2) {
ans = 2*f - m;
break;
}
}
buf.append(ans+"\n");
}
System.out.print(buf);
//}
}
static int lowerbound(ArrayList<Integer> a, int i){
// Lowest index i such that a[i] is not less than target
int l = -1;
int r = a.size();
while(l+1<r){
int mid = (l+r)>>1;
if(a.get(mid)>=i)
r = mid;
else
l = mid;
}
return r;
}
static int upperbound(ArrayList<Integer> a, int i){
// Lowest index i such that a[i] is greater than target
int l = -1;
int r = a.size();
while(l+1<r){
int mid = (l+r)>>1;
if(a.get(mid)<=i)
l = mid;
else
r = mid;
}
return l+1;
}
} | Java | ["6 2\n1 3 2 3 3 2\n1 6\n2 5"] | 3 seconds | ["1\n2"] | NoteIn the first query, you can just put the whole array in one subsequence, since its length is $$$6$$$, and no value occurs more than $$$3$$$ times in it.In the second query, the elements of the query range are $$$[3,2,3,3]$$$. You can't put them all in one subsequence, since its length is $$$4$$$, and $$$3$$$ occurs more than $$$2$$$ times. However, you can partition it into two subsequences: $$$[3]$$$ and $$$[2,3,3]$$$. | Java 11 | standard input | [
"binary search",
"data structures",
"greedy",
"implementation",
"sortings"
] | d6c228bc6e4c17894d9e723ff980844f | The first line contains two integers $$$n$$$ and $$$q$$$ ($$$1 \le n,q \le 3 \cdot 10^5$$$) — the length of the array $$$a$$$ and the number of queries. The second line contains $$$n$$$ integers $$$a_1$$$, $$$a_2$$$, ..., $$$a_{n}$$$ ($$$1 \le a_i \le n$$$) — the elements of the array $$$a$$$. Each of the next $$$q$$$ lines contains two integers $$$l$$$ and $$$r$$$ ($$$1 \le l \le r \le n$$$) — the range of this query. | 2,000 | For each query, print the minimum number of subsequences you need to partition this range into so that the partitioning is beautiful. We can prove such partitioning always exists. | standard output | |
PASSED | 6f683de751b95b9e059ac1a0403f3773 | train_110.jsonl | 1618839300 | Baby Ehab has a piece of Cut and Stick with an array $$$a$$$ of length $$$n$$$ written on it. He plans to grab a pair of scissors and do the following to it: pick a range $$$(l, r)$$$ and cut out every element $$$a_l$$$, $$$a_{l + 1}$$$, ..., $$$a_r$$$ in this range; stick some of the elements together in the same order they were in the array; end up with multiple pieces, where every piece contains some of the elements and every element belongs to some piece. More formally, he partitions the sequence $$$a_l$$$, $$$a_{l + 1}$$$, ..., $$$a_r$$$ into subsequences. He thinks a partitioning is beautiful if for every piece (subsequence) it holds that, if it has length $$$x$$$, then no value occurs strictly more than $$$\lceil \frac{x}{2} \rceil$$$ times in it.He didn't pick a range yet, so he's wondering: for $$$q$$$ ranges $$$(l, r)$$$, what is the minimum number of pieces he needs to partition the elements $$$a_l$$$, $$$a_{l + 1}$$$, ..., $$$a_r$$$ into so that the partitioning is beautiful.A sequence $$$b$$$ is a subsequence of an array $$$a$$$ if $$$b$$$ can be obtained from $$$a$$$ by deleting some (possibly zero) elements. Note that it does not have to be contiguous. | 512 megabytes | import java.io.DataInputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.*;
public class Main {
private static int[] a;
private static Vector<Integer>[] indexSets;
private static void run() throws IOException {
int n = in.nextInt();
int q = in.nextInt();
a = new int[n + 1];
indexSets = new Vector[n + 1];
for (int i = 1; i <= n; i++) {
indexSets[i] = new Vector<>();
}
for (int i = 1; i <= n; i++) {
a[i] = in.nextInt();
Vector<Integer> now = indexSets[a[i]];
now.add(i);
}
int[] randoms = new int[40];
for (int i = 0; i < 40; i++) {
randoms[i] = ((int) (Math.random() * 3 * 1000000));
}
for (int i = 0; i < q; i++) {
int left = in.nextInt();
int right = in.nextInt();
int len = right - left + 1;
int ans = 1;
for (int t = 0; t < 25; t++) {
int test = randoms[t] % len + left;
ans = Math.max(ans, 2 * count(left, right, indexSets[a[test]]) - len);
if (ans != 1) break;
}
out.println(ans);
}
}
private static int count(int left, int right, Vector<Integer> arrayList) {
int left_pos = find(left, arrayList);
int right_pos = find(right, arrayList);
int size = arrayList.size();
while (left_pos < size && arrayList.get(left_pos) < left) left_pos++;
while (right_pos >= 0 && arrayList.get(right_pos) > right) right_pos--;
if (left_pos > right_pos) return 0;
return right_pos - left_pos + 1;
}
private static int find(int pos, Vector<Integer> arrayList) {
int left = 0;
int right = arrayList.size() - 1;
while (left < right) {
int mid = (left + right + 1) >> 1;
int mid_pos = arrayList.get(mid);
if (mid_pos > pos) {
right = mid - 1;
} else {
left = mid;
}
}
return right;
}
public static void main(String[] args) throws IOException {
in = new Reader();
out = new PrintWriter(new OutputStreamWriter(System.out));
// int t = in.nextInt();
// for (int i = 0; i < t; i++) {
// }
run();
out.flush();
in.close();
out.close();
}
private static int gcd(int a, int b) {
if (a == 0 || b == 0)
return 0;
while (b != 0) {
int tmp;
tmp = a % b;
a = b;
b = tmp;
}
return a;
}
static final long mod = 1000000007;
static long pow_mod(long a, long b) {
long result = 1;
while (b != 0) {
if ((b & 1) != 0) result = (result * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return result;
}
private static long multiplied_mod(long... longs) {
long ans = 1;
for (long now : longs) {
ans = (ans * now) % mod;
}
return ans;
}
@SuppressWarnings("FieldCanBeLocal")
private static Reader in;
private static PrintWriter out;
private static void print_array(int[] array) {
for (int now : array) {
out.print(now);
out.print(' ');
}
out.println();
}
private static void print_array(long[] array) {
for (long now : array) {
out.print(now);
out.print(' ');
}
out.println();
}
static class Reader {
private static 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;
}
public String readLine() throws IOException {
final byte[] buf = new byte[1024]; // 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 nextSign() throws IOException {
byte c = read();
while ('+' != c && '-' != c) {
c = read();
}
return '+' == c ? 0 : 1;
}
private static boolean isSpaceChar(int c) {
return !(c >= 33 && c <= 126);
}
public int skip() throws IOException {
int b;
// noinspection ALL
while ((b = read()) != -1 && isSpaceChar(b)) {
;
}
return b;
}
public char nc() throws IOException {
return (char) skip();
}
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');
if (neg) {
return -ret;
}
return 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');
if (neg) {
return -ret;
}
return 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);
}
}
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 {
din.close();
}
}
} | Java | ["6 2\n1 3 2 3 3 2\n1 6\n2 5"] | 3 seconds | ["1\n2"] | NoteIn the first query, you can just put the whole array in one subsequence, since its length is $$$6$$$, and no value occurs more than $$$3$$$ times in it.In the second query, the elements of the query range are $$$[3,2,3,3]$$$. You can't put them all in one subsequence, since its length is $$$4$$$, and $$$3$$$ occurs more than $$$2$$$ times. However, you can partition it into two subsequences: $$$[3]$$$ and $$$[2,3,3]$$$. | Java 11 | standard input | [
"binary search",
"data structures",
"greedy",
"implementation",
"sortings"
] | d6c228bc6e4c17894d9e723ff980844f | The first line contains two integers $$$n$$$ and $$$q$$$ ($$$1 \le n,q \le 3 \cdot 10^5$$$) — the length of the array $$$a$$$ and the number of queries. The second line contains $$$n$$$ integers $$$a_1$$$, $$$a_2$$$, ..., $$$a_{n}$$$ ($$$1 \le a_i \le n$$$) — the elements of the array $$$a$$$. Each of the next $$$q$$$ lines contains two integers $$$l$$$ and $$$r$$$ ($$$1 \le l \le r \le n$$$) — the range of this query. | 2,000 | For each query, print the minimum number of subsequences you need to partition this range into so that the partitioning is beautiful. We can prove such partitioning always exists. | standard output | |
PASSED | 7c562e66280091e10ebc36e78c262da5 | train_110.jsonl | 1618839300 | Baby Ehab has a piece of Cut and Stick with an array $$$a$$$ of length $$$n$$$ written on it. He plans to grab a pair of scissors and do the following to it: pick a range $$$(l, r)$$$ and cut out every element $$$a_l$$$, $$$a_{l + 1}$$$, ..., $$$a_r$$$ in this range; stick some of the elements together in the same order they were in the array; end up with multiple pieces, where every piece contains some of the elements and every element belongs to some piece. More formally, he partitions the sequence $$$a_l$$$, $$$a_{l + 1}$$$, ..., $$$a_r$$$ into subsequences. He thinks a partitioning is beautiful if for every piece (subsequence) it holds that, if it has length $$$x$$$, then no value occurs strictly more than $$$\lceil \frac{x}{2} \rceil$$$ times in it.He didn't pick a range yet, so he's wondering: for $$$q$$$ ranges $$$(l, r)$$$, what is the minimum number of pieces he needs to partition the elements $$$a_l$$$, $$$a_{l + 1}$$$, ..., $$$a_r$$$ into so that the partitioning is beautiful.A sequence $$$b$$$ is a subsequence of an array $$$a$$$ if $$$b$$$ can be obtained from $$$a$$$ by deleting some (possibly zero) elements. Note that it does not have to be contiguous. | 512 megabytes | import java.awt.*;
import java.io.*;
import java.sql.Array;
import java.util.*;
import java.util.List;
public class Main {
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;
}
}
static final int N=300005;
static final int mod=1000000007;
static FastReader r=new FastReader();
static PrintWriter pw = new PrintWriter(System.out);
static int []a=new int[N];
static final int BLOCK=400;
static int maxx=0;
static int []num=new int[N];
static int []occur=new int[N];
static int []ans;
public static class DataRange{
int l,r;
int id;
public DataRange(int l, int r, int id) {
this.l = l;
this.r = r;
this.id = id;
}
}
public static void add(int x){
int n=num[x];
if(n==maxx) ++maxx;
if(n>=0){
--occur[n];
++occur[n+1];
}
++num[x];
}
public static void del(int x){
int n=num[x];
if(n>0&&n==maxx&&occur[n]==1) --maxx;
if(n>0){
--occur[n];
++occur[n-1];
}
--num[x];
}
public static void main(String[] args) throws IOException {
int n=r.nextInt();
int q=r.nextInt();
ans=new int[q];
// List<DataRange> queries=new ArrayList<>();
DataRange[] queries=new DataRange[q];
for(int i=1;i<=n;++i) a[i]=r.nextInt();
for(int i=0;i<q;++i){
int left=r.nextInt();
int right=r.nextInt();
// queries.add(new DataRange(left,right,i));
queries[i]=new DataRange(left,right,i);
}
Arrays.parallelSort(queries, new Comparator<DataRange>() {
@Override
public int compare(DataRange o1, DataRange o2) {
if(o1.l/BLOCK!=o2.l/BLOCK){
if(o1.l/BLOCK<o2.l/BLOCK) return -1;
else if(o1.l/BLOCK==o2.l/BLOCK)return 0;
return 1;
}
if(o1.r<o2.r) return -1;
else if(o1.r==o2.r) return 0;
return 1;
}
});
// Collections.sort(queries, new Comparator<DataRange>() {
// @Override
// public int compare(DataRange o1, DataRange o2) {
// if(o1.l/BLOCK!=o2.l/BLOCK){
// if(o1.l/BLOCK<o2.l/BLOCK) return -1;
// else if(o1.l/BLOCK==o2.l/BLOCK)return 0;
// return 1;
// }
// if(o1.r<o2.r) return -1;
// else if(o1.r==o2.r) return 0;
// return 1;
// }
// });
int left=1,right=0;
for(int i=0;i<q;++i){
while(left<queries[i].l){
del(a[left]);
++left;
}
while(left>queries[i].l){
--left;
add(a[left]);
}
while(right<queries[i].r){
++right;
add(a[right]);
}
while(right>queries[i].r){
del(a[right]);
--right;
}
int len=queries[i].r-queries[i].l+1;
if(maxx<=len/2) ans[queries[i].id]=1;
else{
// System.out.println("id : "+queries.get(i).id);
// System.out.println("maxx : "+maxx);
int other=len-maxx;
int remain=maxx-other;
ans[queries[i].id]=remain;
}
}
StringBuilder stringBuilder=new StringBuilder();
for(int i=0;i<q;++i){
stringBuilder.append(ans[i]+"\n");
}
pw.print(stringBuilder);
pw.close();
}
} | Java | ["6 2\n1 3 2 3 3 2\n1 6\n2 5"] | 3 seconds | ["1\n2"] | NoteIn the first query, you can just put the whole array in one subsequence, since its length is $$$6$$$, and no value occurs more than $$$3$$$ times in it.In the second query, the elements of the query range are $$$[3,2,3,3]$$$. You can't put them all in one subsequence, since its length is $$$4$$$, and $$$3$$$ occurs more than $$$2$$$ times. However, you can partition it into two subsequences: $$$[3]$$$ and $$$[2,3,3]$$$. | Java 11 | standard input | [
"binary search",
"data structures",
"greedy",
"implementation",
"sortings"
] | d6c228bc6e4c17894d9e723ff980844f | The first line contains two integers $$$n$$$ and $$$q$$$ ($$$1 \le n,q \le 3 \cdot 10^5$$$) — the length of the array $$$a$$$ and the number of queries. The second line contains $$$n$$$ integers $$$a_1$$$, $$$a_2$$$, ..., $$$a_{n}$$$ ($$$1 \le a_i \le n$$$) — the elements of the array $$$a$$$. Each of the next $$$q$$$ lines contains two integers $$$l$$$ and $$$r$$$ ($$$1 \le l \le r \le n$$$) — the range of this query. | 2,000 | For each query, print the minimum number of subsequences you need to partition this range into so that the partitioning is beautiful. We can prove such partitioning always exists. | standard output | |
PASSED | d8a81e9ead86bdc243a1e8766c08256b | train_110.jsonl | 1618839300 | Baby Ehab has a piece of Cut and Stick with an array $$$a$$$ of length $$$n$$$ written on it. He plans to grab a pair of scissors and do the following to it: pick a range $$$(l, r)$$$ and cut out every element $$$a_l$$$, $$$a_{l + 1}$$$, ..., $$$a_r$$$ in this range; stick some of the elements together in the same order they were in the array; end up with multiple pieces, where every piece contains some of the elements and every element belongs to some piece. More formally, he partitions the sequence $$$a_l$$$, $$$a_{l + 1}$$$, ..., $$$a_r$$$ into subsequences. He thinks a partitioning is beautiful if for every piece (subsequence) it holds that, if it has length $$$x$$$, then no value occurs strictly more than $$$\lceil \frac{x}{2} \rceil$$$ times in it.He didn't pick a range yet, so he's wondering: for $$$q$$$ ranges $$$(l, r)$$$, what is the minimum number of pieces he needs to partition the elements $$$a_l$$$, $$$a_{l + 1}$$$, ..., $$$a_r$$$ into so that the partitioning is beautiful.A sequence $$$b$$$ is a subsequence of an array $$$a$$$ if $$$b$$$ can be obtained from $$$a$$$ by deleting some (possibly zero) elements. Note that it does not have to be contiguous. | 512 megabytes | import java.util.*;import java.io.*;import java.math.*;
public class Main
{
static int block;
static class Node
{
int l,r,ind;
Node(int l,int r,int ind)
{
this.l=l;
this.r=r;
this.ind=ind;
}
}
public static class CustomSort implements Comparator<Node>{
public int compare(Node a,Node b){
if(a.l/block!=b.l/block)
return a.l-b.l;
return (a.r-b.r);
}
}
public static void process()throws IOException
{
int n=ni();
int m=ni();
block=(int)Math.sqrt(n);
int[]freq=new int[n+1];
int[]counter=new int[n+1];
int[]A=nai(n);
Node[]q=new Node[m];
int[]ans=new int[m];
for(int i=0;i<m;i++)
q[i]=new Node(ni()-1,ni()-1,i);
Arrays.sort(q,new CustomSort());
// for(int i=0;i<m;i++)
// System.err.println(q[i].l+" "+q[i].r+" "+q[i].ind);
int curl = 1, curr = 0;
int t_ans = 0;
for(int i=0;i<m;i++){
int l = q[i].l;
int r = q[i].r;
while(curr < r){
++curr;
int val = A[curr];
int c = freq[val];
counter[c]--;
freq[val]++;
counter[freq[val]]++;
t_ans = Math.max(t_ans, freq[val]);
}
while(curl > l){
--curl;
int val = A[curl];
int c = freq[val];
counter[c]--;
freq[val]++;
counter[freq[val]]++;
t_ans = Math.max(t_ans, freq[val]);
}
while(curr > r){
int val = A[curr];
int c = freq[val];
counter[c]--;
freq[val]--;
counter[freq[val]]++;
while(counter[t_ans] == 0) t_ans--;
--curr;
}
while(curl < l){
int val = A[curl];
counter[freq[val]]--;
freq[val]--;
counter[freq[val]]++;
while(counter[t_ans] == 0) t_ans--;
++curl;
}
ans[q[i].ind] = Math.max(2*t_ans-(r-l+1),1);
}
for(int i=0;i<m;i++)
pn(ans[i]);
}
static AnotherReader sc;
static PrintWriter out;
public static void main(String[]args)throws IOException
{
boolean oj = System.getProperty("ONLINE_JUDGE") != null;
if(oj){sc=new AnotherReader();out=new PrintWriter(System.out);}
else{sc=new AnotherReader(100);out=new PrintWriter("output.txt");}
int t=1;
// t=ni();
while(t-->0) {process();}
out.flush();out.close();
}
static void pn(Object o){out.println(o);}
static void p(Object o){out.print(o);}
static void pni(Object o){out.println(o);out.flush();}
static int ni()throws IOException{return sc.nextInt();}
static long nl()throws IOException{return sc.nextLong();}
static double nd()throws IOException{return sc.nextDouble();}
static String nln()throws IOException{return sc.nextLine();}
static int[] nai(int N)throws IOException{int[]A=new int[N];for(int i=0;i!=N;i++){A[i]=ni();}return A;}
static long[] nal(int N)throws IOException{long[]A=new long[N];for(int i=0;i!=N;i++){A[i]=nl();}return A;}
static long gcd(long a, long b)throws IOException{return (b==0)?a:gcd(b,a%b);}
static int gcd(int a, int b)throws IOException{return (b==0)?a:gcd(b,a%b);}
static int bit(long n)throws IOException{return (n==0)?0:(1+bit(n&(n-1)));}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
static class AnotherReader{BufferedReader br; StringTokenizer st;
AnotherReader()throws FileNotFoundException{
br=new BufferedReader(new InputStreamReader(System.in));}
AnotherReader(int a)throws FileNotFoundException{
br = new BufferedReader(new FileReader("input.txt"));}
String next()throws IOException{
while (st == null || !st.hasMoreElements()) {try{
st = new StringTokenizer(br.readLine());}
catch (IOException e){ e.printStackTrace(); }}
return st.nextToken(); } int nextInt() throws IOException{
return Integer.parseInt(next());}
long nextLong() throws IOException
{return Long.parseLong(next());}
double nextDouble()throws IOException { return Double.parseDouble(next()); }
String nextLine() throws IOException{ String str = ""; try{
str = br.readLine();} catch (IOException e){
e.printStackTrace();} return str;}}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
} | Java | ["6 2\n1 3 2 3 3 2\n1 6\n2 5"] | 3 seconds | ["1\n2"] | NoteIn the first query, you can just put the whole array in one subsequence, since its length is $$$6$$$, and no value occurs more than $$$3$$$ times in it.In the second query, the elements of the query range are $$$[3,2,3,3]$$$. You can't put them all in one subsequence, since its length is $$$4$$$, and $$$3$$$ occurs more than $$$2$$$ times. However, you can partition it into two subsequences: $$$[3]$$$ and $$$[2,3,3]$$$. | Java 11 | standard input | [
"binary search",
"data structures",
"greedy",
"implementation",
"sortings"
] | d6c228bc6e4c17894d9e723ff980844f | The first line contains two integers $$$n$$$ and $$$q$$$ ($$$1 \le n,q \le 3 \cdot 10^5$$$) — the length of the array $$$a$$$ and the number of queries. The second line contains $$$n$$$ integers $$$a_1$$$, $$$a_2$$$, ..., $$$a_{n}$$$ ($$$1 \le a_i \le n$$$) — the elements of the array $$$a$$$. Each of the next $$$q$$$ lines contains two integers $$$l$$$ and $$$r$$$ ($$$1 \le l \le r \le n$$$) — the range of this query. | 2,000 | For each query, print the minimum number of subsequences you need to partition this range into so that the partitioning is beautiful. We can prove such partitioning always exists. | standard output | |
PASSED | 9add6d8b08aaa6890dbbd4a85b8a95ad | train_110.jsonl | 1618839300 | Baby Ehab has a piece of Cut and Stick with an array $$$a$$$ of length $$$n$$$ written on it. He plans to grab a pair of scissors and do the following to it: pick a range $$$(l, r)$$$ and cut out every element $$$a_l$$$, $$$a_{l + 1}$$$, ..., $$$a_r$$$ in this range; stick some of the elements together in the same order they were in the array; end up with multiple pieces, where every piece contains some of the elements and every element belongs to some piece. More formally, he partitions the sequence $$$a_l$$$, $$$a_{l + 1}$$$, ..., $$$a_r$$$ into subsequences. He thinks a partitioning is beautiful if for every piece (subsequence) it holds that, if it has length $$$x$$$, then no value occurs strictly more than $$$\lceil \frac{x}{2} \rceil$$$ times in it.He didn't pick a range yet, so he's wondering: for $$$q$$$ ranges $$$(l, r)$$$, what is the minimum number of pieces he needs to partition the elements $$$a_l$$$, $$$a_{l + 1}$$$, ..., $$$a_r$$$ into so that the partitioning is beautiful.A sequence $$$b$$$ is a subsequence of an array $$$a$$$ if $$$b$$$ can be obtained from $$$a$$$ by deleting some (possibly zero) elements. Note that it does not have to be contiguous. | 512 megabytes | //package round716;
import java.io.*;
import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.Queue;
public class D {
InputStream is;
FastWriter out;
String INPUT = "";
int[] ans;
void solve()
{
int n = ni(), Q = ni();
int[] a = na(n);
int[][] qs = new int[Q][];
for(int i = 0;i < Q;i++){
qs[i] = new int[]{ni()-1, ni()-1, i};
}
ans = new int[Q];
int[] from = a;
int[] to = new int[n];
for(int i = 0;i < n;i++)to[i] = i;
int[][] b = packD(n+1, from, to);
for(int[] row : b){
for(int j = 0, k = row.length-1;j < k;j++,k--){
int d = row[j]; row[j] = row[k]; row[k] = d;
}
}
dfs(0, n, qs, b, a);
for(int v : ans){
out.println(v);
}
}
void dfs(int l, int r, int[][] qs, int[][] b, int[] a)
{
if(qs.length == 0)return;
if(r-l <= 1){
for(int[] q : qs){
ans[q[2]] = 1;
}
return;
}
int h = l+r>>1;
int[] pre = new int[h-l];
{
int arg = -1;
int f = 0;
for(int i = h-1;i >= l;i--){
if(arg == a[i]){
f++;
}else if(f == 0){
arg = a[i];
f = 1;
}else{
f--;
}
pre[h-1-i] = arg;
}
}
int[] suf = new int[r-h];
{
int arg = -1;
int f = 0;
for(int i = h;i < r;i++){
if(arg == a[i]){
f++;
}else if(f == 0){
arg = a[i];
f = 1;
}else{
f--;
}
suf[i-h] = arg;
}
}
int[][] ls = new int[qs.length][];
int[][] rs = new int[qs.length][];
int lp = 0, rp = 0;
for(int[] q : qs){
if(q[0] <= h && h <= q[1]){
int F = 0;
if(q[0] <= h-1){
int tar = pre[h-1-q[0]];
F = Math.max(F, lowerBound(b[tar], q[1]+1) - lowerBound(b[tar], q[0]));
}
{
int tar = suf[q[1]-h];
F = Math.max(F, lowerBound(b[tar], q[1]+1) - lowerBound(b[tar], q[0]));
}
int len = q[1]-q[0]+1;
if(F > len-F+1){
ans[q[2]] = F-(len-F+1) + 1;
}else{
ans[q[2]] = 1;
}
}else if(q[0] > h){
rs[rp++] = q;
}else{
ls[lp++] = q;
}
}
dfs(l, h, Arrays.copyOf(ls, lp), b, a);
dfs(h, r, Arrays.copyOf(rs, rp), b, a);
}
public static int lowerBound(int[] a, int v){ return lowerBound(a, 0, a.length, v); }
public static int lowerBound(int[] a, int l, int r, int v)
{
if(l > r || l < 0 || r > a.length)throw new IllegalArgumentException();
int low = l-1, high = r;
while(high-low > 1){
int h = high+low>>>1;
if(a[h] >= v){
high = h;
}else{
low = h;
}
}
return high;
}
public static int[][] packD(int n, int[] from, int[] to) {
return packD(n, from, to, from.length);
}
public static int[][] packD(int n, int[] from, int[] to, int sup) {
int[][] g = new int[n][];
int[] p = new int[n];
for (int i = 0; i < sup; i++) p[from[i]]++;
for (int i = 0; i < n; i++) g[i] = new int[p[i]];
for (int i = 0; i < sup; i++) {
g[from[i]][--p[from[i]]] = to[i];
}
return g;
}
void run() throws Exception
{
is = oj ? System.in : new ByteArrayInputStream(INPUT.getBytes());
out = new FastWriter(System.out);
long s = System.currentTimeMillis();
solve();
out.flush();
tr(System.currentTimeMillis()-s+"ms");
}
public static void main(String[] args) throws Exception { new D().run(); }
private byte[] inbuf = new byte[1024];
public int lenbuf = 0, ptrbuf = 0;
private int readByte()
{
if(lenbuf == -1)throw new InputMismatchException();
if(ptrbuf >= lenbuf){
ptrbuf = 0;
try { lenbuf = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }
if(lenbuf <= 0)return -1;
}
return inbuf[ptrbuf++];
}
private boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
private int skip() { int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }
private double nd() { return Double.parseDouble(ns()); }
private char nc() { return (char)skip(); }
private String ns()
{
int b = skip();
StringBuilder sb = new StringBuilder();
while(!(isSpaceChar(b))){ // when nextLine, (isSpaceChar(b) && b != ' ')
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
private char[] ns(int n)
{
char[] buf = new char[n];
int b = skip(), p = 0;
while(p < n && !(isSpaceChar(b))){
buf[p++] = (char)b;
b = readByte();
}
return n == p ? buf : Arrays.copyOf(buf, p);
}
private int[] na(int n)
{
int[] a = new int[n];
for(int i = 0;i < n;i++)a[i] = ni();
return a;
}
private long[] nal(int n)
{
long[] a = new long[n];
for(int i = 0;i < n;i++)a[i] = nl();
return a;
}
private char[][] nm(int n, int m) {
char[][] map = new char[n][];
for(int i = 0;i < n;i++)map[i] = ns(m);
return map;
}
private int[][] nmi(int n, int m) {
int[][] map = new int[n][];
for(int i = 0;i < n;i++)map[i] = na(m);
return map;
}
private int ni() { return (int)nl(); }
private long nl()
{
long num = 0;
int b;
boolean minus = false;
while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
if(b == '-'){
minus = true;
b = readByte();
}
while(true){
if(b >= '0' && b <= '9'){
num = num * 10 + (b - '0');
}else{
return minus ? -num : num;
}
b = readByte();
}
}
public static class FastWriter
{
private static final int BUF_SIZE = 1<<13;
private final byte[] buf = new byte[BUF_SIZE];
private final OutputStream out;
private int ptr = 0;
private FastWriter(){out = null;}
public FastWriter(OutputStream os)
{
this.out = os;
}
public FastWriter(String path)
{
try {
this.out = new FileOutputStream(path);
} catch (FileNotFoundException e) {
throw new RuntimeException("FastWriter");
}
}
public FastWriter write(byte b)
{
buf[ptr++] = b;
if(ptr == BUF_SIZE)innerflush();
return this;
}
public FastWriter write(char c)
{
return write((byte)c);
}
public FastWriter write(char[] s)
{
for(char c : s){
buf[ptr++] = (byte)c;
if(ptr == BUF_SIZE)innerflush();
}
return this;
}
public FastWriter write(String s)
{
s.chars().forEach(c -> {
buf[ptr++] = (byte)c;
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 FastWriter write(int x)
{
if(x == Integer.MIN_VALUE){
return write((long)x);
}
if(ptr + 12 >= BUF_SIZE)innerflush();
if(x < 0){
write((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 FastWriter write(long x)
{
if(x == Long.MIN_VALUE){
return write("" + x);
}
if(ptr + 21 >= BUF_SIZE)innerflush();
if(x < 0){
write((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 FastWriter write(double x, int precision)
{
if(x < 0){
write('-');
x = -x;
}
x += Math.pow(10, -precision)/2;
// if(x < 0){ x = 0; }
write((long)x).write(".");
x -= (long)x;
for(int i = 0;i < precision;i++){
x *= 10;
write((char)('0'+(int)x));
x -= (int)x;
}
return this;
}
public FastWriter writeln(char c){
return write(c).writeln();
}
public FastWriter writeln(int x){
return write(x).writeln();
}
public FastWriter writeln(long x){
return write(x).writeln();
}
public FastWriter writeln(double x, int precision){
return write(x, precision).writeln();
}
public FastWriter write(int... xs)
{
boolean first = true;
for(int x : xs) {
if (!first) write(' ');
first = false;
write(x);
}
return this;
}
public FastWriter write(long... xs)
{
boolean first = true;
for(long x : xs) {
if (!first) write(' ');
first = false;
write(x);
}
return this;
}
public FastWriter writeln()
{
return write((byte)'\n');
}
public FastWriter writeln(int... xs)
{
return write(xs).writeln();
}
public FastWriter writeln(long... xs)
{
return write(xs).writeln();
}
public FastWriter writeln(char[] line)
{
return write(line).writeln();
}
public FastWriter writeln(char[]... map)
{
for(char[] line : map)write(line).writeln();
return this;
}
public FastWriter writeln(String s)
{
return write(s).writeln();
}
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");
}
}
public FastWriter print(byte b) { return write(b); }
public FastWriter print(char c) { return write(c); }
public FastWriter print(char[] s) { return write(s); }
public FastWriter print(String s) { return write(s); }
public FastWriter print(int x) { return write(x); }
public FastWriter print(long x) { return write(x); }
public FastWriter print(double x, int precision) { return write(x, precision); }
public FastWriter println(char c){ return writeln(c); }
public FastWriter println(int x){ return writeln(x); }
public FastWriter println(long x){ return writeln(x); }
public FastWriter println(double x, int precision){ return writeln(x, precision); }
public FastWriter print(int... xs) { return write(xs); }
public FastWriter print(long... xs) { return write(xs); }
public FastWriter println(int... xs) { return writeln(xs); }
public FastWriter println(long... xs) { return writeln(xs); }
public FastWriter println(char[] line) { return writeln(line); }
public FastWriter println(char[]... map) { return writeln(map); }
public FastWriter println(String s) { return writeln(s); }
public FastWriter println() { return writeln(); }
}
public void trnz(int... o)
{
for(int i = 0;i < o.length;i++)if(o[i] != 0)System.out.print(i+":"+o[i]+" ");
System.out.println();
}
// print ids which are 1
public void trt(long... o)
{
Queue<Integer> stands = new ArrayDeque<>();
for(int i = 0;i < o.length;i++){
for(long x = o[i];x != 0;x &= x-1)stands.add(i<<6|Long.numberOfTrailingZeros(x));
}
System.out.println(stands);
}
public void tf(boolean... r)
{
for(boolean x : r)System.out.print(x?'#':'.');
System.out.println();
}
public void tf(boolean[]... b)
{
for(boolean[] r : b) {
for(boolean x : r)System.out.print(x?'#':'.');
System.out.println();
}
System.out.println();
}
public void tf(long[]... b)
{
if(INPUT.length() != 0) {
for (long[] r : b) {
for (long x : r) {
for (int i = 0; i < 64; i++) {
System.out.print(x << ~i < 0 ? '#' : '.');
}
}
System.out.println();
}
System.out.println();
}
}
public void tf(long... b)
{
if(INPUT.length() != 0) {
for (long x : b) {
for (int i = 0; i < 64; i++) {
System.out.print(x << ~i < 0 ? '#' : '.');
}
}
System.out.println();
}
}
private boolean oj = System.getProperty("ONLINE_JUDGE") != null;
private void tr(Object... o) { if(!oj)System.out.println(Arrays.deepToString(o)); }
}
| Java | ["6 2\n1 3 2 3 3 2\n1 6\n2 5"] | 3 seconds | ["1\n2"] | NoteIn the first query, you can just put the whole array in one subsequence, since its length is $$$6$$$, and no value occurs more than $$$3$$$ times in it.In the second query, the elements of the query range are $$$[3,2,3,3]$$$. You can't put them all in one subsequence, since its length is $$$4$$$, and $$$3$$$ occurs more than $$$2$$$ times. However, you can partition it into two subsequences: $$$[3]$$$ and $$$[2,3,3]$$$. | Java 11 | standard input | [
"binary search",
"data structures",
"greedy",
"implementation",
"sortings"
] | d6c228bc6e4c17894d9e723ff980844f | The first line contains two integers $$$n$$$ and $$$q$$$ ($$$1 \le n,q \le 3 \cdot 10^5$$$) — the length of the array $$$a$$$ and the number of queries. The second line contains $$$n$$$ integers $$$a_1$$$, $$$a_2$$$, ..., $$$a_{n}$$$ ($$$1 \le a_i \le n$$$) — the elements of the array $$$a$$$. Each of the next $$$q$$$ lines contains two integers $$$l$$$ and $$$r$$$ ($$$1 \le l \le r \le n$$$) — the range of this query. | 2,000 | For each query, print the minimum number of subsequences you need to partition this range into so that the partitioning is beautiful. We can prove such partitioning always exists. | standard output | |
PASSED | 66a81e1956baf4a3a0146d7723c587b7 | train_110.jsonl | 1618839300 | This is an interactive problem.Baby Ehab loves crawling around his apartment. It has $$$n$$$ rooms numbered from $$$0$$$ to $$$n-1$$$. For every pair of rooms, $$$a$$$ and $$$b$$$, there's either a direct passage from room $$$a$$$ to room $$$b$$$, or from room $$$b$$$ to room $$$a$$$, but never both.Baby Ehab wants to go play with Baby Badawy. He wants to know if he could get to him. However, he doesn't know anything about his apartment except the number of rooms. He can ask the baby sitter two types of questions: is the passage between room $$$a$$$ and room $$$b$$$ directed from $$$a$$$ to $$$b$$$ or the other way around? does room $$$x$$$ have a passage towards any of the rooms $$$s_1$$$, $$$s_2$$$, ..., $$$s_k$$$? He can ask at most $$$9n$$$ queries of the first type and at most $$$2n$$$ queries of the second type.After asking some questions, he wants to know for every pair of rooms $$$a$$$ and $$$b$$$ whether there's a path from $$$a$$$ to $$$b$$$ or not. A path from $$$a$$$ to $$$b$$$ is a sequence of passages that starts from room $$$a$$$ and ends at room $$$b$$$. | 256 megabytes | /*
bts songs to dance to:
I need U
Run
ON
Filter
I'm fine
*/
import static java.lang.Math.max;
import static java.lang.Math.min;
import static java.lang.Math.abs;
import static java.lang.System.out;
import java.util.*;
import java.io.*;
import java.math.*;
public class x1514E
{
public static void main(String hi[]) throws Exception
{
BufferedReader infile = new BufferedReader(new InputStreamReader(System.in));
int T = Integer.parseInt(infile.readLine());
while(T-->0)
{
int N = Integer.parseInt(infile.readLine());
ArrayList<Integer> path = get(0, N-1, infile);
int[][] res = new int[N+1][N+1];
for(int a=0; a < N; a++)
for(int b=a+1; b < N; b++)
res[path.get(a)][path.get(b)] = 1;
//path should contain all N nodes
int prev = N-2;
for(int i=N-1; i > 0; i--)
{
prev = min(prev, i-1);
while(prev >= 0)
{
ArrayList<Integer> cands = new ArrayList<Integer>();
for(int a=0; a <= prev; a++)
cands.add(path.get(a));
StringBuilder query = new StringBuilder("2 ");
query.append(path.get(i)+" "+cands.size()+" ");
for(int x: cands)
query.append(x+" ");
System.out.println(query.toString().trim());
int result = Integer.parseInt(infile.readLine());
if(result == 0)
break;
prev--;
}
for(int a=prev+1; a < i; a++)
res[path.get(i)][path.get(a)] = 1;
}
//floyd warshall bs
for(int c=0; c < N; c++)
for(int a=0; a < N; a++)
for(int b=0; b < N; b++)
if(res[a][c] == 1 && res[c][b] == 1)
res[a][b] = 1;
//print result
System.out.println(3);
StringBuilder sb;
for(int r=0; r < N; r++)
{
res[r][r] = 1;
sb = new StringBuilder();
for(int c=0; c < N; c++)
sb.append(res[r][c]);
System.out.println(sb);
}
int result = Integer.parseInt(infile.readLine());
}
}
public static ArrayList<Integer> get(int left, int right, BufferedReader infile) throws Exception
{
ArrayList<Integer> ls = new ArrayList<Integer>();
if(left == right)
{
ls.add(left);
return ls;
}
int mid = (left+right)>>1;
ArrayList<Integer> first = get(left, mid, infile);
ArrayList<Integer> second = get(mid+1, right, infile);
//query stuff
int dex1 = 0, dex2 = 0;
while(dex1 < first.size() && dex2 < second.size())
{
int a = first.get(dex1);
int b = second.get(dex2);
System.out.println("1 "+a+" "+b);
int tag = Integer.parseInt(infile.readLine());
if(tag == 1)
ls.add(first.get(dex1++));
else
ls.add(second.get(dex2++));
}
while(dex1 < first.size())
ls.add(first.get(dex1++));
while(dex2 < second.size())
ls.add(second.get(dex2++));
return ls;
}
} | Java | ["1\n4\n\n0\n\n0\n\n1\n\n1\n\n1"] | 1 second | ["2 3 3 0 1 2\n\n1 0 1\n\n1 0 2\n\n2 2 1 1\n\n3\n1111\n1111\n1111\n0001"] | NoteIn the given example:The first query asks whether there's a passage from room $$$3$$$ to any of the other rooms.The second query asks about the direction of the passage between rooms $$$0$$$ and $$$1$$$.After a couple other queries, we concluded that you can go from any room to any other room except if you start at room $$$3$$$, and you can't get out of this room, so we printed the matrix:1111111111110001The interactor answered with $$$1$$$, telling us the answer is correct. | Java 8 | standard input | [
"binary search",
"graphs",
"interactive",
"sortings",
"two pointers"
] | beae75b649ca6ed26180954faf73e5a3 | The first line contains an integer $$$t$$$ ($$$1 \le t \le 30$$$) — the number of test cases you need to solve. Then each test case starts with an integer $$$n$$$ ($$$4 \le n \le 100$$$) — the number of rooms. The sum of $$$n$$$ across the test cases doesn't exceed $$$500$$$. | 2,700 | To print the answer for a test case, print a line containing "3", followed by $$$n$$$ lines, each containing a binary string of length $$$n$$$. The $$$j$$$-th character of the $$$i$$$-th string should be $$$1$$$ if there's a path from room $$$i$$$ to room $$$j$$$, and $$$0$$$ if there isn't. The $$$i$$$-th character of the $$$i$$$-th string should be $$$1$$$ for each valid $$$i$$$. After printing the answer, we will respond with a single integer. If it's $$$1$$$, you printed a correct answer and should keep solving the test cases (or exit if it is the last one). If it's $$$-1$$$, you printed a wrong answer and should terminate to get Wrong answer verdict. Otherwise, you can get an arbitrary verdict because your solution will continue to read from a closed stream. | standard output | |
PASSED | 7fc0442c744ab5b34e163933a5cb383c | 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 java.util.Map.Entry;
public class Solution2 {
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;
}
}
static boolean isPrime(long n)
{
// Corner cases
if (n <= 1)
return false;
if (n <= 3)
return true;
// This is checked so that we can skip
// middle five numbers in below loop
if (n % 2 == 0 || n % 3 == 0)
return false;
for (long i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0)
return false;
return true;
}
public static int gcd(int a, int b) {
int t;
while(b != 0){
t = a;
a = b;
b = t%b;
}
return a;
}
public static boolean relativelyPrime(int a, int b) {
return gcd(a,b) == 1;
}
static int __gcd(int a, int b)
{
return b == 0? a:__gcd(b, a % b);
}
// recursive implementation
static int GcdOfArray(int[] arr, int idx)
{
if (idx == arr.length - 1) {
return arr[idx];
}
int a = arr[idx];
int b = GcdOfArray(arr, idx + 1);
return __gcd(
a, b); // __gcd(a,b) is inbuilt library function
}
public static class Pair{
int a;
int b;
Pair(int a, int b){
this.a = a;
this.b = b;
}
}
static boolean SieveOfEratosthenes(int n, boolean isPrime[])
{
// Initialize all entries of boolean
// array as true. A value in isPrime[i]
// will finally be false if i is Not a
// prime, else true bool isPrime[n+1];
isPrime[0] = isPrime[1] = false;
for (int i = 2; i <= n; i++)
isPrime[i] = true;
for (int p = 2; p * p <= n; p++)
{
// If isPrime[p] is not changed,
// then it is a prime
if (isPrime[p] == true)
{
// Update all multiples of p
for (int i = p * p; i <= n; i += p)
isPrime[i] = false;
}
}
return false;
}
// Prints a prime pair with given sum
static int[] findPrimePair(int n)
{
// Generating primes using Sieve
boolean isPrime[]=new boolean[n + 1];
SieveOfEratosthenes(n, isPrime);
int[] arr = new int[2];
// Traversing all numbers to find first
// pair
for (int i = 0; i < n; i++)
{
if (isPrime[i] && isPrime[n - i])
{
arr[0] = i;
arr[1] = (n - i);
return arr;
}
}
return arr;
}
static int merge(ArrayList<int[]> intervals){
int[] temp = new int[2];
temp[0] = intervals.get(0)[0];
temp[1] = intervals.get(0)[1];
ArrayList<int[]> ls = new ArrayList<>();
ls.add(temp);
int j = 0;
for(int i=0; i<intervals.size()-1; i++){
if((temp[1]>=intervals.get(i+1)[0] && temp[1]<=intervals.get(i+1)[1]) || (temp[0]>=intervals.get(i+1)[0] && temp[0]<=intervals.get(i+1)[1])){
if(temp[0]<intervals.get(i+1)[0]) temp[0] = intervals.get(i+1)[0];
if(temp[1]>intervals.get(i+1)[1]) temp[1] = intervals.get(i+1)[1];
}
else{
return 0;
}
}
// for(int[] arr: ls) {
// System.out.println(arr[0] + " " + arr[1]);
// }
return Math.abs(temp[1]-temp[0]);
}
public static int num(String s) {
int n = 0;
for(char c: s.toCharArray()) {
if(c=='1') n++;
}
return n;
}
static int onesComplement(int n) {
int number_of_bits =
(int)(Math.floor(Math.log(n) /
Math.log(2))) + 1;;
return ((1 << number_of_bits) - 1) ^ n;
}
public static int check(long[] arr, long h) {
for(int i=0; i<arr.length; i++) {
if(h+arr[i]<=0) return i;
}
return -1;
}
public static boolean isPossible(int n, int k) {
if(n-k>=0) {
n = n-k;
if(n==0) return false;
else return true;
}
return true;
}
public static long getAns(int a, int b, int[] pos) {
int n = pos.length;
if(n==0) return 0;
if(n == 1) {
if(pos[0]==1) {
return b;
}
return a;
}
int mid = (int)(n/2);
int left[] = new int[mid];
int right[] = new int[n-mid];
for(int i=0;i<mid;i++) {
left[i] = pos[i];
}
for(int i=mid;i<n;i++) {
right[i-mid] = pos[i];
}
long a1 = getAns(a, b, left);
long a2 = getAns(a, b, right);
int ctn = 0;
for(int i=0; i<n; i++) {
if(pos[i]==1) ctn++;
}
long a3 = ctn==0 ? a : (long) (b*ctn*n);
return Math.min((a1+a2), a3);
}
public static int divSum(long num)
{
int result = 0;
for (int i = 1; i <= Math.sqrt(num); i++)
{
if (num % i == 0)
{
if (i == (num / i))
result += i;
else
result += (i + num / i);
}
}
return (result);
}
public static boolean isPal(String s) {
int l = 0;
int r = s.length()-1;
while(l<=r) {
if(s.charAt(l)!=s.charAt(r)) return false;
l++;
r--;
}
return true;
}
public static String rev(String s) {
String a = "";
int i = s.length()-1;
while(i>=0) {
a = a+s.charAt(i);
i--;
}
return a;
}
static boolean isPowerOfTwo(int 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)))));
}
public static void subSequenceSum(
ArrayList<ArrayList<Long>> ans,
ArrayList<Long> a, ArrayList<Long> temp,
long k, int start)
{
// Here we have used ArrayList
// of ArrayList in in Java for
// implementation of Jagged Array
// if k < 0 then the sum of
// the current subsequence
// in temp is greater than K
if(start > a.size() || k < 0)
return ;
// if(k==0) means that the sum
// of this subsequence
// is equal to K
if(k == 0)
{
ans.add(
new ArrayList<Long>(temp)
);
return ;
}
else {
for (int i = start;
i < a.size(); i++) {
// Adding a new
// element into temp
temp.add(a.get(i));
// After selecting an
// element from the
// array we subtract K
// by that value
subSequenceSum(ans, a,
temp, k - a.get(i),i+1);
// Remove the lastly
// added element
temp.remove(temp.size() - 1);
}
}
}
public static int count(int a) {
int ans = 0;
while(a>0) {
if(a%2==1) ans++;
a = a/2;
}
return ans;
}
static int nCrModpLucas(int n, int r, int p)
{
// Base case
if (r==0)
return 1;
// Compute last digits of n and r in base p
int ni = n%p;
int ri = r%p;
// Compute result for last digits computed above, and
// for remaining digits. Multiply the two results and
// compute the result of multiplication in modulo p.
return (nCrModpLucas(n/p, r/p, p) * // Last digits of n and r
nCrModpDP(ni, ri, p)) % p; // Remaining digits
}
static int nCrModpDP(int n, int r, int p)
{
// The array C is going to store last row of
// pascal triangle at the end. And last entry
// of last row is nCr
int[] C=new int[r+1];
C[0] = 1; // Top row of Pascal Triangle
// One by constructs remaining rows of Pascal
// Triangle from top to bottom
for (int i = 1; i <= n; i++)
{
// Fill entries of current row using previous
// row values
for (int j = Math.min(i, r); j > 0; j--)
// nCj = (n-1)Cj + (n-1)C(j-1);
C[j] = (C[j] + C[j-1])%p;
}
return C[r];
}
static int size = 10000000;
static boolean[] isPrime = new boolean[size];
public static void sieve() {
Arrays.fill(isPrime, true);
isPrime[0] = false;
isPrime[1] = false;
for(int i=2; i*i<size; i++) {
if(isPrime[i]) {
for(int j=i*i; j<size; j=j+i) {
isPrime[j] = false;
}
}
}
}
public static void main(String[] args) throws Exception{
FastReader sc = new FastReader();
int t = sc.nextInt();
while(t-- > 0) {
int n = sc.nextInt();
String s = sc.nextLine();
int c = 0;
int i = 0;
int j = 1;
while(i<s.length() && j<s.length()) {
if(s.charAt(i)=='(' && i+1<s.length()) {
i = i + 2;
j = i + 1;
c++;
}
else {
while(j<s.length() && s.charAt(j)!=')') {
j++;
}
if(j==s.length()) break;
i = j + 1;
j = i + 1;
c++;
}
}
int r = s.length() - i;
System.out.println(c + " " + r);
}
}
}
| 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 11 | 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 | 0210866c8be210fddf66102db55098d4 | 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.List;
import java.util.Scanner;
import java.util.StringTokenizer;
public class Bracket_Sequence_Deletion {
static class RealScanner {
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());
}
public boolean isSorted(List<Long> list) {
for (int i = 0; i < list.size() - 1; i++) {
if (list.get(i) > list.get(i + 1))
return false;
}
return true;
}
}
public static void main(String[] args) {
RealScanner sc = new RealScanner();
PrintWriter out = new PrintWriter(System.out);
int t = sc.nextInt();
while (t-- > 0) {
int n = sc.nextInt();
String s = sc.next();
int count = 0;
int i = 0;
while (i < n) {
// System.out.println("kk");
if (s.charAt(i) == '(') {
// String sub = s.substring(i, i + 2);
if (i == n - 1) {
break;
}
if (n - i >= 2 && s.length() >= 2) {
count++;
i += 2;
}
} else if (s.charAt(i) == ')') {
// System.out.println(idx);
// sub += s.charAt(i);
// StringBuffer sb = new StringBuffer(sub);
// sb.reverse();
// String check = String.valueOf(sb);
// if (check.length() >= 2 && check.equals(sub)) {
// count++;
// }
int j = i + 1;
boolean check = false;
for (; j < s.length(); j++) {
// con += s.charAt(j);
// if (con.length() >= 2) {
// StringBuffer sb = new StringBuffer(con);
// sb.reverse();
// String check = String.valueOf(sb);
// if (check.equals(con)) {
// count++;
// break;
// }
// }
if (s.charAt(j) == ')') {
check = true;
count++;
i = j + 1;
break;
}
}
if (!check) {
break;
}
// i = j;
// break;
// System.out.println(i);
}
if (i == n - 1) {
break;
}
}
System.out.println(count + " " + (n - i));
}
out.flush();
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 11 | 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 | 3de30b95aee267bf47e7e73c4e6f2e1c | 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.BufferedWriter;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Writer;
import java.util.Arrays;
public class Test {
private static Reader reader;
private static OutputWriter writer;
private static void solve() throws IOException {
int t = reader.nextInt();
while (t-- > 0) {
int n = reader.nextInt();
String s = reader.nextString(n);
int count = 0, ind = 0;
for (int i = 0; i < n - 1;) {
if (i < n && s.charAt(i) == '(') {
i += 2;
count++;
ind = i;
} else {
i++;
while (i < n && s.charAt(i) == '(') {
i++;
}
if (i < n && s.charAt(i) == ')') {
i++;
count++;
ind = i;
}
}
}
writer.println(count + " " + (n - ind));
}
}
static class Element implements Comparable<Element> {
int value;
int freq;
Element(int value, int freq) {
this.value = value;
this.freq = freq;
}
public int compareTo(Element e) {
if (this.freq > e.freq) {
return 1;
}
if (this.freq == e.freq) {
return 0;
}
return -1;
}
}
public static void main(String[] args) throws Exception {
// console input output
reader = new Reader();
writer = new OutputWriter();
// File input output
// reader = new Reader("input.txt");
// writer=new OutputWriter("output.txt");
solve();
reader.close();
writer.close();
}
private static long gcd(long a, long b) {
if (b == 0 || a == b)
return a;
if (a == 1 || b == 1)
return 1;
return gcd(b, a % b);
}
private static long gcd(long... values) {
long ans = gcd(values[0], values[1]);
for (long value : values) {
ans = gcd(ans, value);
}
return ans;
}
private static long min(long... values) {
long min = values[0];
for (long value : values) {
if (min < value) {
min = value;
}
}
return min;
}
private static long max(long... values) {
long max = values[0];
for (long value : values) {
if (max < value) {
max = value;
}
}
return max;
}
private static long powerMod(long num, long pow, long mod) {
if (pow == 0 || num == 1)
return 1;
if (num == 0 || pow == 1)
return num;
long ans = powerMod(num, pow / 2, mod) % mod;
ans = (ans * ans) % mod;
if (pow % 2 != 0) {
ans = (ans * num) % mod;
}
return ans;
}
private static boolean[] SieveOfEratosthenes() {
int n = (int) 1e7 + 7;
boolean[] ans = new boolean[n];
Arrays.fill(ans, true);
ans[0] = false;
ans[1] = false;
for (int i = 2; i < n; i++) {
if (ans[i]) {
for (int j = i * i; j < n; j = j + i) {
ans[j] = false;
}
}
}
return ans;
}
static class Reader {
final private int BUFFER_SIZE = 1 << 16;
private DataInputStream dataInputStream;
private int bufferPointer, bytesRead;
private byte[] buffer;
public Reader() {
this.dataInputStream = new DataInputStream(System.in);
this.buffer = new byte[BUFFER_SIZE];
this.bufferPointer = 0;
this.bytesRead = 0;
}
public Reader(String fileName) throws FileNotFoundException {
this.dataInputStream = new DataInputStream(new FileInputStream(fileName));
this.buffer = new byte[BUFFER_SIZE];
this.bufferPointer = 0;
this.bytesRead = 0;
}
public String nextLine(int n) throws IOException {
byte[] arr = new byte[n + 1];
int count = 0;
byte b;
while ((b = readByte()) != -1) {
if (b == '\n') {
if (count != 0) {
break;
} else {
continue;
}
}
arr[count++] = b;
}
return new String(arr, 0, count);
}
public String nextString(int n) throws IOException {
byte[] arr = new byte[n + 1];
int count = 0;
byte b;
while ((b = readByte()) != -1) {
if (b == ' ' || b == '\n') {
if (count != 0) {
break;
} else {
continue;
}
}
arr[count++] = b;
}
return new String(arr, 0, count);
}
public char nextChar() throws IOException {
byte b = readByte();
while (b == ' ') {
b = readByte();
}
return (char) b;
}
public int nextInt() throws IOException {
int res = 0;
byte b = readByte();
while (b <= ' ') {
b = readByte();
}
boolean negative = (b == '-');
if (negative) {
b = readByte();
}
do {
res = res * 10 + (b - '0');
} while ((b = readByte()) >= '0' && b <= '9');
if (negative) {
res *= -1;
}
return res;
}
public long nextLong() throws IOException {
long res = 0;
byte b = readByte();
while (b <= ' ') {
b = readByte();
}
boolean negative = (b == '-');
if (negative) {
b = readByte();
}
do {
res = res * 10 + (b - '0');
} while ((b = readByte()) >= '0' && b <= '9');
if (negative) {
res *= -1;
}
return res;
}
public float nextFloat() throws IOException {
float res = 0, div = 1;
byte b = readByte();
while (b <= ' ') {
b = readByte();
}
boolean negative = (b == '-');
if (negative) {
b = readByte();
}
do {
res = res * 10 + (b - '0');
} while ((b = readByte()) >= '0' && b <= '9');
if (b == '.') {
while ((b = readByte()) >= '0' && b <= '9') {
res += (b - '0') / (div *= 10);
}
}
if (negative) {
res *= -1;
}
return res;
}
public double nextDouble() throws IOException {
double res = 0, div = 1;
byte b = readByte();
while (b <= ' ') {
b = readByte();
}
boolean negative = (b == '-');
if (negative) {
b = readByte();
}
do {
res = res * 10 + (b - '0');
} while ((b = readByte()) >= '0' && b <= '9');
if (b == '.') {
while ((b = readByte()) >= '0' && b <= '9') {
res += (b - '0') / (div *= 10);
}
}
if (negative) {
res *= -1;
}
return res;
}
private void fillBuffer() throws IOException {
bytesRead = dataInputStream.read(buffer, bufferPointer = 0, BUFFER_SIZE);
if (bytesRead == -1) {
buffer[0] = -1;
}
}
private byte readByte() throws IOException {
if (bufferPointer == bytesRead) {
fillBuffer();
}
return buffer[bufferPointer++];
}
public void close() throws IOException {
if (dataInputStream == null) {
return;
}
dataInputStream.close();
}
}
static class OutputWriter {
private final PrintWriter printWriter;
public OutputWriter() {
printWriter = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
}
public OutputWriter(String fileName) throws FileNotFoundException {
printWriter = new PrintWriter(
new BufferedWriter(
new OutputStreamWriter(
new FileOutputStream(fileName))));
}
public OutputWriter(OutputStream outputStream) {
printWriter = new PrintWriter(
new BufferedWriter(new OutputStreamWriter(outputStream)));
}
public OutputWriter(Writer writer) {
this.printWriter = new PrintWriter(writer);
}
public void print(Object... objects) {
for (int i = 0; i < objects.length; i++) {
if (i != 0)
printWriter.print(' ');
printWriter.print(objects[i]);
}
}
public void println(Object... objects) {
print(objects);
printWriter.println();
}
public void close() {
printWriter.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 11 | 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 | 680680c5f708a76d875648b517c7d1da | 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.BufferedWriter;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Writer;
import java.util.Arrays;
import java.util.StringTokenizer;
public class Test {
private static Reader reader;
private static OutputWriter writer;
private static void solve() throws IOException {
int t = reader.nextInt();
while (t-- > 0) {
int n = reader.nextInt();
String s = reader.nextString(n);
int count = 0, ind = 0;
for (int i = 0; i < n - 1;) {
if (i < n && s.charAt(i) == '(') {
i += 2;
count++;
ind = i;
} else {
i++;
while (i < n && s.charAt(i) == '(') {
i++;
}
if (i < n && s.charAt(i) == ')') {
i++;
count++;
ind = i;
}
}
}
writer.println(count + " " + (n - ind));
}
}
static class Element implements Comparable<Element> {
int value;
int freq;
Element(int value, int freq) {
this.value = value;
this.freq = freq;
}
public int compareTo(Element e) {
if (this.freq > e.freq) {
return 1;
}
if (this.freq == e.freq) {
return 0;
}
return -1;
}
}
public static void main(String[] args) throws Exception {
// console input output
reader = new Reader();
writer = new OutputWriter();
// File input output
// reader = new Reader("input.txt");
// writer=new OutputWriter("output.txt");
solve();
reader.close();
writer.close();
}
private static long gcd(long a, long b) {
if (b == 0 || a == b)
return a;
if (a == 1 || b == 1)
return 1;
return gcd(b, a % b);
}
private static long gcd(long... values) {
long ans = gcd(values[0], values[1]);
for (long value : values) {
ans = gcd(ans, value);
}
return ans;
}
private static long min(long... values) {
long min = values[0];
for (long value : values) {
if (min < value) {
min = value;
}
}
return min;
}
private static long max(long... values) {
long max = values[0];
for (long value : values) {
if (max < value) {
max = value;
}
}
return max;
}
private static long powerMod(long num, long pow, long mod) {
if (pow == 0 || num == 1)
return 1;
if (num == 0 || pow == 1)
return num;
long ans = powerMod(num, pow / 2, mod) % mod;
ans = (ans * ans) % mod;
if (pow % 2 != 0) {
ans = (ans * num) % mod;
}
return ans;
}
private static boolean[] SieveOfEratosthenes() {
int n = (int) 1e7 + 7;
boolean[] ans = new boolean[n];
Arrays.fill(ans, true);
ans[0] = false;
ans[1] = false;
for (int i = 2; i < n; i++) {
if (ans[i]) {
for (int j = i * i; j < n; j = j + i) {
ans[j] = false;
}
}
}
return ans;
}
static class Reader {
final private int BUFFER_SIZE = 1 << 16;
private DataInputStream dataInputStream;
private int bufferPointer, bytesRead;
private byte[] buffer;
public Reader() {
this.dataInputStream = new DataInputStream(System.in);
this.buffer = new byte[BUFFER_SIZE];
this.bufferPointer = 0;
this.bytesRead = 0;
}
public Reader(String fileName) throws FileNotFoundException {
this.dataInputStream = new DataInputStream(new FileInputStream(fileName));
this.buffer = new byte[BUFFER_SIZE];
this.bufferPointer = 0;
this.bytesRead = 0;
}
public String nextLine(int n) throws IOException {
byte[] arr = new byte[n + 1];
int count = 0;
byte b;
while ((b = readByte()) != -1) {
if (b == '\n') {
if (count != 0) {
break;
} else {
continue;
}
}
arr[count++] = b;
}
return new String(arr, 0, count);
}
public String nextString(int n) throws IOException {
byte[] arr = new byte[n + 1];
int count = 0;
byte b;
while ((b = readByte()) != -1) {
if (b == ' ' || b == '\n') {
if (count != 0) {
break;
} else {
continue;
}
}
arr[count++] = b;
}
return new String(arr, 0, count);
}
public char nextChar() throws IOException {
byte b = readByte();
while (b == ' ') {
b = readByte();
}
return (char) b;
}
public int nextInt() throws IOException {
int res = 0;
byte b = readByte();
while (b <= ' ') {
b = readByte();
}
boolean negative = (b == '-');
if (negative) {
b = readByte();
}
do {
res = res * 10 + (b - '0');
} while ((b = readByte()) >= '0' && b <= '9');
if (negative) {
res *= -1;
}
return res;
}
public long nextLong() throws IOException {
long res = 0;
byte b = readByte();
while (b <= ' ') {
b = readByte();
}
boolean negative = (b == '-');
if (negative) {
b = readByte();
}
do {
res = res * 10 + (b - '0');
} while ((b = readByte()) >= '0' && b <= '9');
if (negative) {
res *= -1;
}
return res;
}
public float nextFloat() throws IOException {
float res = 0, div = 1;
byte b = readByte();
while (b <= ' ') {
b = readByte();
}
boolean negative = (b == '-');
if (negative) {
b = readByte();
}
do {
res = res * 10 + (b - '0');
} while ((b = readByte()) >= '0' && b <= '9');
if (b == '.') {
while ((b = readByte()) >= '0' && b <= '9') {
res += (b - '0') / (div *= 10);
}
}
if (negative) {
res *= -1;
}
return res;
}
public double nextDouble() throws IOException {
double res = 0, div = 1;
byte b = readByte();
while (b <= ' ') {
b = readByte();
}
boolean negative = (b == '-');
if (negative) {
b = readByte();
}
do {
res = res * 10 + (b - '0');
} while ((b = readByte()) >= '0' && b <= '9');
if (b == '.') {
while ((b = readByte()) >= '0' && b <= '9') {
res += (b - '0') / (div *= 10);
}
}
if (negative) {
res *= -1;
}
return res;
}
private void fillBuffer() throws IOException {
bytesRead = dataInputStream.read(buffer, bufferPointer = 0, BUFFER_SIZE);
if (bytesRead == -1) {
buffer[0] = -1;
}
}
private byte readByte() throws IOException {
if (bufferPointer == bytesRead) {
fillBuffer();
}
return buffer[bufferPointer++];
}
public void close() throws IOException {
if (dataInputStream == null) {
return;
}
dataInputStream.close();
}
}
static class OutputWriter {
private final PrintWriter printWriter;
public OutputWriter() {
printWriter = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
}
public OutputWriter(String fileName) throws FileNotFoundException {
printWriter = new PrintWriter(
new BufferedWriter(
new OutputStreamWriter(
new FileOutputStream(fileName))));
}
public OutputWriter(OutputStream outputStream) {
printWriter = new PrintWriter(
new BufferedWriter(new OutputStreamWriter(outputStream)));
}
public OutputWriter(Writer writer) {
this.printWriter = new PrintWriter(writer);
}
public void print(Object... objects) {
for (int i = 0; i < objects.length; i++) {
if (i != 0)
printWriter.print(' ');
printWriter.print(objects[i]);
}
}
public void println(Object... objects) {
print(objects);
printWriter.println();
}
public void close() {
printWriter.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 11 | 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 | 7c0c9da876c1c98d0dc6e5e0c515c3fb | 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.BufferedWriter;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Writer;
import java.util.Arrays;
public class C {
private static Reader reader;
private static OutputWriter writer;
private static void solve() throws IOException {
int t = reader.nextInt();
while (t-- > 0) {
int n = reader.nextInt();
String s = reader.nextString();
int count = 0, ind = 0;
for (int i = 0; i < n - 1;) {
if (i < n && s.charAt(i) == '(') {
i += 2;
count++;
ind = i;
} else {
i++;
while (i < n && s.charAt(i) == '(') {
i++;
}
if (i < n && s.charAt(i) == ')') {
i++;
count++;
ind = i;
}
}
}
writer.println(count + " " + (n - ind));
}
}
static class Element implements Comparable<Element> {
int value;
int freq;
Element(int value, int freq) {
this.value = value;
this.freq = freq;
}
public int compareTo(Element e) {
if (this.freq > e.freq) {
return 1;
}
if (this.freq == e.freq) {
return 0;
}
return -1;
}
}
public static void main(String[] args) throws Exception {
// console input output
reader = new Reader();
writer = new OutputWriter();
// File input output
// reader = new Reader("input.txt");
// writer=new OutputWriter("output.txt");
solve();
reader.close();
writer.close();
}
private static long gcd(long a, long b) {
if (b == 0 || a == b)
return a;
if (a == 1 || b == 1)
return 1;
return gcd(b, a % b);
}
private static long gcd(long... values) {
long ans = gcd(values[0], values[1]);
for (long value : values) {
ans = gcd(ans, value);
}
return ans;
}
private static long min(long... values) {
long min = values[0];
for (long value : values) {
if (min < value) {
min = value;
}
}
return min;
}
private static long max(long... values) {
long max = values[0];
for (long value : values) {
if (max < value) {
max = value;
}
}
return max;
}
private static long powerMod(long num, long pow, long mod) {
if (pow == 0 || num == 1)
return 1;
if (num == 0 || pow == 1)
return num;
long ans = powerMod(num, pow / 2, mod) % mod;
ans = (ans * ans) % mod;
if (pow % 2 != 0) {
ans = (ans * num) % mod;
}
return ans;
}
private static boolean[] SieveOfEratosthenes() {
int n = (int) 1e7 + 7;
boolean[] ans = new boolean[n];
Arrays.fill(ans, true);
ans[0] = false;
ans[1] = false;
for (int i = 2; i < n; i++) {
if (ans[i]) {
for (int j = i * i; j < n; j = j + i) {
ans[j] = false;
}
}
}
return ans;
}
static class Reader {
final private int BUFFER_SIZE = 1 << 16;
final private int BYTE_ARRAY_SIZE = 1 << 20;
private DataInputStream dataInputStream;
private int bufferPointer, bytesRead;
private byte[] buffer;
public Reader() {
this.dataInputStream = new DataInputStream(System.in);
this.buffer = new byte[BUFFER_SIZE];
this.bufferPointer = 0;
this.bytesRead = 0;
}
public Reader(String fileName) throws FileNotFoundException {
this.dataInputStream = new DataInputStream(new FileInputStream(fileName));
this.buffer = new byte[BUFFER_SIZE];
this.bufferPointer = 0;
this.bytesRead = 0;
}
public String nextLine() throws IOException {
byte[] arr = new byte[BYTE_ARRAY_SIZE];
int count = 0;
byte b;
while ((b = readByte()) != -1) {
if (b == '\n') {
if (count != 0) {
break;
} else {
continue;
}
}
arr[count++] = b;
}
return new String(arr, 0, count);
}
public String nextString() throws IOException {
byte[] arr = new byte[BYTE_ARRAY_SIZE];
int count = 0;
byte b;
while ((b = readByte()) != -1) {
if (b == ' ' || b == '\n') {
if (count != 0) {
break;
} else {
continue;
}
}
arr[count++] = b;
}
return new String(arr, 0, count);
}
public char nextChar() throws IOException {
byte b = readByte();
while (b == ' ') {
b = readByte();
}
return (char) b;
}
public int nextInt() throws IOException {
int res = 0;
byte b = readByte();
while (b <= ' ') {
b = readByte();
}
boolean negative = (b == '-');
if (negative) {
b = readByte();
}
do {
res = res * 10 + (b - '0');
} while ((b = readByte()) >= '0' && b <= '9');
if (negative) {
res *= -1;
}
return res;
}
public long nextLong() throws IOException {
long res = 0;
byte b = readByte();
while (b <= ' ') {
b = readByte();
}
boolean negative = (b == '-');
if (negative) {
b = readByte();
}
do {
res = res * 10 + (b - '0');
} while ((b = readByte()) >= '0' && b <= '9');
if (negative) {
res *= -1;
}
return res;
}
public float nextFloat() throws IOException {
float res = 0, div = 1;
byte b = readByte();
while (b <= ' ') {
b = readByte();
}
boolean negative = (b == '-');
if (negative) {
b = readByte();
}
do {
res = res * 10 + (b - '0');
} while ((b = readByte()) >= '0' && b <= '9');
if (b == '.') {
while ((b = readByte()) >= '0' && b <= '9') {
res += (b - '0') / (div *= 10);
}
}
if (negative) {
res *= -1;
}
return res;
}
public double nextDouble() throws IOException {
double res = 0, div = 1;
byte b = readByte();
while (b <= ' ') {
b = readByte();
}
boolean negative = (b == '-');
if (negative) {
b = readByte();
}
do {
res = res * 10 + (b - '0');
} while ((b = readByte()) >= '0' && b <= '9');
if (b == '.') {
while ((b = readByte()) >= '0' && b <= '9') {
res += (b - '0') / (div *= 10);
}
}
if (negative) {
res *= -1;
}
return res;
}
private void fillBuffer() throws IOException {
bytesRead = dataInputStream.read(buffer, bufferPointer = 0, BUFFER_SIZE);
if (bytesRead == -1) {
buffer[0] = -1;
}
}
private byte readByte() throws IOException {
if (bufferPointer == bytesRead) {
fillBuffer();
}
return buffer[bufferPointer++];
}
public void close() throws IOException {
if (dataInputStream == null) {
return;
}
dataInputStream.close();
}
}
static class OutputWriter {
private final PrintWriter printWriter;
public OutputWriter() {
printWriter = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
}
public OutputWriter(String fileName) throws FileNotFoundException {
printWriter = new PrintWriter(
new BufferedWriter(
new OutputStreamWriter(
new FileOutputStream(fileName))));
}
public OutputWriter(OutputStream outputStream) {
printWriter = new PrintWriter(
new BufferedWriter(new OutputStreamWriter(outputStream)));
}
public OutputWriter(Writer writer) {
this.printWriter = new PrintWriter(writer);
}
public void print(Object... objects) {
for (int i = 0; i < objects.length; i++) {
if (i != 0)
printWriter.print(' ');
printWriter.print(objects[i]);
}
}
public void println(Object... objects) {
print(objects);
printWriter.println();
}
public void close() {
printWriter.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 11 | 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 | 9b324ed4e20bcf2f5023927b399034b7 | 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.BufferedWriter;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Writer;
import java.util.Arrays;
public class C {
private static Reader reader;
private static OutputWriter writer;
private static void solve() throws IOException {
int t = reader.nextInt();
while (t-- > 0) {
int n = reader.nextInt();
String s = reader.nextString();
int count = 0, ind = 0;
for (int i = 0; i < n - 1;) {
if (i < n && s.charAt(i) == '(') {
i += 2;
count++;
ind = i;
} else {
i++;
while (i < n && s.charAt(i) == '(') {
i++;
}
if (i < n && s.charAt(i) == ')') {
i++;
count++;
ind = i;
}
}
}
writer.println(count + " " + (n - ind));
}
}
static class Element implements Comparable<Element> {
int value;
int freq;
Element(int value, int freq) {
this.value = value;
this.freq = freq;
}
public int compareTo(Element e) {
if (this.freq > e.freq) {
return 1;
}
if (this.freq == e.freq) {
return 0;
}
return -1;
}
}
public static void main(String[] args) throws Exception {
// console input output
reader = new Reader();
writer = new OutputWriter();
// File input output
// reader = new Reader("input.txt");
// writer=new OutputWriter("output.txt");
solve();
reader.close();
writer.close();
}
private static long gcd(long a, long b) {
if (b == 0 || a == b)
return a;
if (a == 1 || b == 1)
return 1;
return gcd(b, a % b);
}
private static long gcd(long... values) {
long ans = gcd(values[0], values[1]);
for (long value : values) {
ans = gcd(ans, value);
}
return ans;
}
private static long min(long... values) {
long min = values[0];
for (long value : values) {
if (min < value) {
min = value;
}
}
return min;
}
private static long max(long... values) {
long max = values[0];
for (long value : values) {
if (max < value) {
max = value;
}
}
return max;
}
private static long powerMod(long num, long pow, long mod) {
if (pow == 0 || num == 1)
return 1;
if (num == 0 || pow == 1)
return num;
long ans = powerMod(num, pow / 2, mod) % mod;
ans = (ans * ans) % mod;
if (pow % 2 != 0) {
ans = (ans * num) % mod;
}
return ans;
}
private static boolean[] SieveOfEratosthenes() {
int n = (int) 1e7 + 7;
boolean[] ans = new boolean[n];
Arrays.fill(ans, true);
ans[0] = false;
ans[1] = false;
for (int i = 2; i < n; i++) {
if (ans[i]) {
for (int j = i * i; j < n; j = j + i) {
ans[j] = false;
}
}
}
return ans;
}
static class Reader {
final private int BUFFER_SIZE = 1 << 20;
final private int BYTE_ARRAY_SIZE = 1 << 20;
private DataInputStream dataInputStream;
private int bufferPointer, bytesRead;
private byte[] buffer;
public Reader() {
this.dataInputStream = new DataInputStream(System.in);
this.buffer = new byte[BUFFER_SIZE];
this.bufferPointer = 0;
this.bytesRead = 0;
}
public Reader(String fileName) throws FileNotFoundException {
this.dataInputStream = new DataInputStream(new FileInputStream(fileName));
this.buffer = new byte[BUFFER_SIZE];
this.bufferPointer = 0;
this.bytesRead = 0;
}
public String nextLine() throws IOException {
byte[] arr = new byte[BYTE_ARRAY_SIZE];
int count = 0;
byte b;
while ((b = readByte()) != -1) {
if (b == '\n') {
if (count != 0) {
break;
} else {
continue;
}
}
arr[count++] = b;
}
return new String(arr, 0, count);
}
public String nextString() throws IOException {
byte[] arr = new byte[BYTE_ARRAY_SIZE];
int count = 0;
byte b;
while ((b = readByte()) != -1) {
if (b == ' ' || b == '\n') {
if (count != 0) {
break;
} else {
continue;
}
}
arr[count++] = b;
}
return new String(arr, 0, count);
}
public char nextChar() throws IOException {
byte b = readByte();
while (b == ' ') {
b = readByte();
}
return (char) b;
}
public int nextInt() throws IOException {
int res = 0;
byte b = readByte();
while (b <= ' ') {
b = readByte();
}
boolean negative = (b == '-');
if (negative) {
b = readByte();
}
do {
res = res * 10 + (b - '0');
} while ((b = readByte()) >= '0' && b <= '9');
if (negative) {
res *= -1;
}
return res;
}
public long nextLong() throws IOException {
long res = 0;
byte b = readByte();
while (b <= ' ') {
b = readByte();
}
boolean negative = (b == '-');
if (negative) {
b = readByte();
}
do {
res = res * 10 + (b - '0');
} while ((b = readByte()) >= '0' && b <= '9');
if (negative) {
res *= -1;
}
return res;
}
public float nextFloat() throws IOException {
float res = 0, div = 1;
byte b = readByte();
while (b <= ' ') {
b = readByte();
}
boolean negative = (b == '-');
if (negative) {
b = readByte();
}
do {
res = res * 10 + (b - '0');
} while ((b = readByte()) >= '0' && b <= '9');
if (b == '.') {
while ((b = readByte()) >= '0' && b <= '9') {
res += (b - '0') / (div *= 10);
}
}
if (negative) {
res *= -1;
}
return res;
}
public double nextDouble() throws IOException {
double res = 0, div = 1;
byte b = readByte();
while (b <= ' ') {
b = readByte();
}
boolean negative = (b == '-');
if (negative) {
b = readByte();
}
do {
res = res * 10 + (b - '0');
} while ((b = readByte()) >= '0' && b <= '9');
if (b == '.') {
while ((b = readByte()) >= '0' && b <= '9') {
res += (b - '0') / (div *= 10);
}
}
if (negative) {
res *= -1;
}
return res;
}
private void fillBuffer() throws IOException {
bytesRead = dataInputStream.read(buffer, bufferPointer = 0, BUFFER_SIZE);
if (bytesRead == -1) {
buffer[0] = -1;
}
}
private byte readByte() throws IOException {
if (bufferPointer == bytesRead) {
fillBuffer();
}
return buffer[bufferPointer++];
}
public void close() throws IOException {
if (dataInputStream == null) {
return;
}
dataInputStream.close();
}
}
static class OutputWriter {
private final PrintWriter printWriter;
public OutputWriter() {
printWriter = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
}
public OutputWriter(String fileName) throws FileNotFoundException {
printWriter = new PrintWriter(
new BufferedWriter(
new OutputStreamWriter(
new FileOutputStream(fileName))));
}
public OutputWriter(OutputStream outputStream) {
printWriter = new PrintWriter(
new BufferedWriter(new OutputStreamWriter(outputStream)));
}
public OutputWriter(Writer writer) {
this.printWriter = new PrintWriter(writer);
}
public void print(Object... objects) {
for (int i = 0; i < objects.length; i++) {
if (i != 0)
printWriter.print(' ');
printWriter.print(objects[i]);
}
}
public void println(Object... objects) {
print(objects);
printWriter.println();
}
public void close() {
printWriter.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 11 | 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 | e0a6ac2dafd0b34b37012427c342c2a4 | 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.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Objects;
import java.util.Queue;
import java.util.StringTokenizer;
import java.util.function.BiFunction;
import java.util.function.Function;
public class Main {
public static final int INT = 10000000;
static BiFunction<Integer, Integer, Integer> ADD = (x, y) -> (x + y);
static BiFunction<ArrayList<Integer>, ArrayList<Integer>, ArrayList<Integer>> ADD_ARRAY_LIST = (x, y) -> {
x.addAll(y);
return x;
};
static Function<Pair<Integer, Integer>, Integer> GET_FIRST = (x) -> (x.first);
static Function<Pair<Integer, Integer>, Integer> GET_SECOND = (x) -> (x.second);
static Comparator<Pair<Integer, Integer>> C = Comparator.comparing(x -> x.first + x.second);
static long MOD = 1_000_000_000 + 7;
public static void main(String[] args) throws Exception {
long startTime = System.nanoTime();
int t = in.nextInt();
while (t-- > 0) {
solve();
}
long endTime = System.nanoTime();
err.println("Execution Time : +" + (endTime - startTime) / 1000000 + " ms");
exit(0);
}
static void solve() {
int n = in.nextInt();
String s = in.next();
int ans = 0;
for (int i = 0; i < n; i++) {
int b = getPalinLength(s, i, n - 1);
int v = getRegularBracketLength(s, i, b);
//out.println(v + " " + b);
if (v == b && v == INT) {
out.println(ans + " " + (n - i));
return;
}
ans++;
//out.println(Math.min(v, b));
i += Math.min(v, b) - 1;
}
out.println(ans + " " + 0);
}
static int getRegularBracketLength(String s, int start, int max) {
int count = 0;
int ans = 0;
for (int i = start; i < s.length() && i <= start + max; i++) {
/// out.println(count + " @ " + i);
if (s.charAt(i) == '(') {
count++;
} else {
count--;
}
ans++;
if (count == 0) {
return ans;
}
if (count < 0) {
return INT;
}
}
return INT;
}
static int getPalinLength(String s, int start, int max) {
for (int i = start + 1; i < s.length() && i <= start + max; i++) {
if (s.charAt(i) == s.charAt(start)) {
if (isPaling(s, start, i)) {
return (i - start) + 1;
}
}
}
return INT;
}
static boolean isPaling(String s, int start, int end) {
for (int i = start, j = end; i < j; i++, j--) {
if (s.charAt(i) == s.charAt(j)) {
continue;
}
return false;
}
return true;
}
static void debug(Object... args) {
for (Object a : args) {
out.println(a);
}
}
static int dist(Pair<Integer, Integer> a, Pair<Integer, Integer> b) {
return Math.abs(a.first - b.first) + Math.abs(a.second - b.second);
}
static void y() {
out.println("YES");
}
static void n() {
out.println("NO");
}
static int[] stringToArray(String s) {
return s.chars().map(x -> Character.getNumericValue(x)).toArray();
}
static <T> T min(T a, T b, Comparator<T> C) {
if (C.compare(a, b) <= 0) {
return a;
}
return b;
}
static <T> T max(T a, T b, Comparator<T> C) {
if (C.compare(a, b) >= 0) {
return a;
}
return b;
}
static void fail() {
out.println("-1");
}
static class Pair<T, R> {
public T first;
public R second;
public Pair(T first, R second) {
this.first = first;
this.second = second;
}
@Override
public boolean equals(final Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
final Pair<?, ?> pair = (Pair<?, ?>) o;
return Objects.equals(first, pair.first) && Objects.equals(second, pair.second);
}
@Override
public int hashCode() {
return Objects.hash(first, second);
}
@Override
public String toString() {
return "Pair{" + "a=" + first + ", b=" + second + '}';
}
public T getFirst() {
return first;
}
public R getSecond() {
return second;
}
}
static <T, R> Pair<T, R> make_pair(T a, R b) {
return new Pair<>(a, b);
}
static long mod_inverse(long a, long m) {
Number x = new Number(0);
Number y = new Number(0);
extended_gcd(a, m, x, y);
return (m + x.v % m) % m;
}
static long extended_gcd(long a, long b, Number x, Number y) {
long d = a;
if (b != 0) {
d = extended_gcd(b, a % b, y, x);
y.v -= (a / b) * x.v;
} else {
x.v = 1;
y.v = 0;
}
return d;
}
static class Number {
long v = 0;
public Number(long v) {
this.v = v;
}
}
static long lcm(long a, long b, long c) {
return lcm(a, lcm(b, c));
}
static long lcm(long a, long b) {
long p = 1L * a * b;
return p / gcd(a, b);
}
static long gcd(long a, long b) {
while (b != 0) {
long t = b;
b = a % b;
a = t;
}
return a;
}
static long gcd(long a, long b, long c) {
return gcd(a, gcd(b, c));
}
static class ArrayUtils {
static void swap(int[] a, int i, int j) {
int 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 void print(char[] a) {
for (char c : a) {
out.print(c);
}
out.println("");
}
static int[] reverse(int[] data) {
int[] p = new int[data.length];
for (int i = 0, j = data.length - 1; i < data.length; i++, j--) {
p[i] = data[j];
}
return p;
}
static void prefixSum(long[] data) {
for (int i = 1; i < data.length; i++) {
data[i] += data[i - 1];
}
}
static void prefixSum(int[] data) {
for (int i = 1; i < data.length; i++) {
data[i] += data[i - 1];
}
}
static long[] reverse(long[] data) {
long[] p = new long[data.length];
for (int i = 0, j = data.length - 1; i < data.length; i++, j--) {
p[i] = data[j];
}
return p;
}
static char[] reverse(char[] data) {
char[] p = new char[data.length];
for (int i = 0, j = data.length - 1; i < data.length; i++, j--) {
p[i] = data[j];
}
return p;
}
static int[] MergeSort(int[] A) {
if (A.length > 1) {
int q = A.length / 2;
int[] left = new int[q];
int[] right = new int[A.length - q];
System.arraycopy(A, 0, left, 0, q);
System.arraycopy(A, q, right, 0, A.length - q);
int[] left_sorted = MergeSort(left);
int[] right_sorted = MergeSort(right);
return Merge(left_sorted, right_sorted);
} else {
return A;
}
}
static int[] Merge(int[] left, int[] right) {
int[] A = new int[left.length + right.length];
int i = 0;
int j = 0;
for (int k = 0; k < A.length; k++) {
// To handle left becoming empty
if (i == left.length && j < right.length) {
A[k] = right[j];
j++;
continue;
}
// To handle right becoming empty
if (j == right.length && i < left.length) {
A[k] = left[i];
i++;
continue;
}
if (left[i] <= right[j]) {
A[k] = left[i];
i++;
} else {
A[k] = right[j];
j++;
}
}
return A;
}
static long[] MergeSort(long[] A) {
if (A.length > 1) {
int q = A.length / 2;
long[] left = new long[q];
long[] right = new long[A.length - q];
System.arraycopy(A, 0, left, 0, q);
System.arraycopy(A, q, right, 0, A.length - q);
long[] left_sorted = MergeSort(left);
long[] right_sorted = MergeSort(right);
return Merge(left_sorted, right_sorted);
} else {
return A;
}
}
static long[] Merge(long[] left, long[] right) {
long[] A = new long[left.length + right.length];
int i = 0;
int j = 0;
for (int k = 0; k < A.length; k++) {
// To handle left becoming empty
if (i == left.length && j < right.length) {
A[k] = right[j];
j++;
continue;
}
// To handle right becoming empty
if (j == right.length && i < left.length) {
A[k] = left[i];
i++;
continue;
}
if (left[i] <= right[j]) {
A[k] = left[i];
i++;
} else {
A[k] = right[j];
j++;
}
}
return A;
}
static int upper_bound(int[] data, int num, int start) {
int low = start;
int high = data.length - 1;
int mid = 0;
int ans = -1;
while (low <= high) {
mid = (low + high) / 2;
if (data[mid] < num) {
low = mid + 1;
} else if (data[mid] >= num) {
high = mid - 1;
ans = mid;
}
}
if (ans == -1) {
return 100000000;
}
return data[ans];
}
static int lower_bound(int[] data, int num, int start) {
int low = start;
int high = data.length - 1;
int mid = 0;
int ans = -1;
while (low <= high) {
mid = (low + high) / 2;
if (data[mid] <= num) {
low = mid + 1;
ans = mid;
} else if (data[mid] > num) {
high = mid - 1;
}
}
if (ans == -1) {
return 100000000;
}
return data[ans];
}
}
static boolean[] primeSieve(int n) {
boolean[] primes = new boolean[n + 1];
Arrays.fill(primes, true);
primes[0] = false;
primes[1] = false;
for (int i = 2; i <= Math.sqrt(n); i++) {
if (primes[i]) {
for (int j = i * i; j <= n; j += i) {
primes[j] = false;
}
}
}
return primes;
}
// Iterative Version
static HashMap<Integer, Boolean> subsets_sum_iter(int[] data) {
HashMap<Integer, Boolean> temp = new HashMap<Integer, Boolean>();
temp.put(data[0], true);
for (int i = 1; i < data.length; i++) {
HashMap<Integer, Boolean> t1 = new HashMap<Integer, Boolean>(temp);
t1.put(data[i], true);
for (int j : temp.keySet()) {
t1.put(j + data[i], true);
}
temp = t1;
}
return temp;
}
static HashMap<Integer, Integer> subsets_sum_count(int[] data) {
HashMap<Integer, Integer> temp = new HashMap<>();
temp.put(data[0], 1);
for (int i = 1; i < data.length; i++) {
HashMap<Integer, Integer> t1 = new HashMap<>(temp);
t1.merge(data[i], 1, ADD);
for (int j : temp.keySet()) {
t1.merge(j + data[i], temp.get(j) + 1, ADD);
}
temp = t1;
}
return temp;
}
static class Graph {
ArrayList<Integer>[] g;
boolean[] visited;
ArrayList<Integer>[] graph(int n) {
g = new ArrayList[n];
visited = new boolean[n];
for (int i = 0; i < n; i++) {
g[i] = new ArrayList<>();
}
return g;
}
void BFS(int s) {
Queue<Integer> Q = new ArrayDeque<>();
visited[s] = true;
Q.add(s);
while (!Q.isEmpty()) {
int v = Q.poll();
for (int a : g[v]) {
if (!visited[a]) {
visited[a] = true;
Q.add(a);
}
}
}
}
}
static class SparseTable {
int[] log;
int[][] st;
public SparseTable(int n, int k, int[] data, BiFunction<Integer, Integer, Integer> f) {
log = new int[n + 1];
st = new int[n][k + 1];
log[1] = 0;
for (int i = 2; i <= n; i++) {
log[i] = log[i / 2] + 1;
}
for (int i = 0; i < data.length; i++) {
st[i][0] = data[i];
}
for (int j = 1; j <= k; j++)
for (int i = 0; i + (1 << j) <= data.length; i++)
st[i][j] = f.apply(st[i][j - 1], st[i + (1 << (j - 1))][j - 1]);
}
public int query(int L, int R, BiFunction<Integer, Integer, Integer> f) {
int j = log[R - L + 1];
return f.apply(st[L][j], st[R - (1 << j) + 1][j]);
}
}
static class InputReader {
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream), 2048);
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 long nextLong() {
return Long.parseLong(next());
}
public int nextInt() {
return Integer.parseInt(next());
}
public int[] readAllInts(int n) {
int[] p = new int[n];
for (int i = 0; i < n; i++) {
p[i] = in.nextInt();
}
return p;
}
public int[] readAllInts(int n, int s) {
int[] p = new int[n + s];
for (int i = s; i < n + s; i++) {
p[i] = in.nextInt();
}
return p;
}
public long[] readAllLongs(int n) {
long[] p = new long[n];
for (int i = 0; i < n; i++) {
p[i] = in.nextLong();
}
return p;
}
public long[] readAllLongs(int n, int s) {
long[] p = new long[n + s];
for (int i = s; i < n + s; i++) {
p[i] = in.nextLong();
}
return p;
}
public double nextDouble() {
return Double.parseDouble(next());
}
}
static void exit(int a) {
out.close();
err.close();
System.exit(a);
}
static InputStream inputStream = System.in;
static OutputStream outputStream = System.out;
static OutputStream errStream = System.err;
static InputReader in = new InputReader(inputStream);
static PrintWriter out = new PrintWriter(outputStream);
static PrintWriter err = new PrintWriter(errStream);
static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
}
| 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 11 | 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 | 70db6fa821b79964e709ba281bd7b89c | 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.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Objects;
import java.util.Queue;
import java.util.StringTokenizer;
import java.util.function.BiFunction;
import java.util.function.Function;
public class Main {
public static final int INT = 10000000;
static BiFunction<Integer, Integer, Integer> ADD = (x, y) -> (x + y);
static BiFunction<ArrayList<Integer>, ArrayList<Integer>, ArrayList<Integer>> ADD_ARRAY_LIST = (x, y) -> {
x.addAll(y);
return x;
};
static Function<Pair<Integer, Integer>, Integer> GET_FIRST = (x) -> (x.first);
static Function<Pair<Integer, Integer>, Integer> GET_SECOND = (x) -> (x.second);
static Comparator<Pair<Integer, Integer>> C = Comparator.comparing(x -> x.first + x.second);
static long MOD = 1_000_000_000 + 7;
public static void main(String[] args) throws Exception {
long startTime = System.nanoTime();
int t = in.nextInt();
while (t-- > 0) {
solve();
}
long endTime = System.nanoTime();
err.println("Execution Time : +" + (endTime - startTime) / 1000000 + " ms");
exit(0);
}
static void solve() {
int n = in.nextInt();
String s = in.next();
int ans = 0;
for (int i = 0; i < n; i++) {
int b = getPalinLength(s, i);
int v = getRegularBracketLength(s, i);
//out.println(v + " " + b);
if (v == b && v == INT) {
out.println(ans + " " + (n - i));
return;
}
ans++;
//out.println(Math.min(v, b));
i += Math.min(v, b) - 1;
}
out.println(ans + " " + 0);
}
static int getRegularBracketLength(String s, int start) {
int count = 0;
int ans = 0;
for (int i = start; i < s.length() && i <= start + 10; i++) {
/// out.println(count + " @ " + i);
if (s.charAt(i) == '(') {
count++;
} else {
count--;
}
ans++;
if (count == 0) {
return ans;
}
if (count < 0) {
return INT;
}
}
return INT;
}
static int getPalinLength(String s, int start) {
for (int i = start + 1; i < s.length(); i++) {
if (s.charAt(i) == s.charAt(start)) {
if (isPaling(s, start, i)) {
return (i - start) + 1;
}
}
}
return INT;
}
static boolean isPaling(String s, int start, int end) {
for (int i = start, j = end; i < j; i++, j--) {
if (s.charAt(i) == s.charAt(j)) {
continue;
}
return false;
}
return true;
}
static void debug(Object... args) {
for (Object a : args) {
out.println(a);
}
}
static int dist(Pair<Integer, Integer> a, Pair<Integer, Integer> b) {
return Math.abs(a.first - b.first) + Math.abs(a.second - b.second);
}
static void y() {
out.println("YES");
}
static void n() {
out.println("NO");
}
static int[] stringToArray(String s) {
return s.chars().map(x -> Character.getNumericValue(x)).toArray();
}
static <T> T min(T a, T b, Comparator<T> C) {
if (C.compare(a, b) <= 0) {
return a;
}
return b;
}
static <T> T max(T a, T b, Comparator<T> C) {
if (C.compare(a, b) >= 0) {
return a;
}
return b;
}
static void fail() {
out.println("-1");
}
static class Pair<T, R> {
public T first;
public R second;
public Pair(T first, R second) {
this.first = first;
this.second = second;
}
@Override
public boolean equals(final Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
final Pair<?, ?> pair = (Pair<?, ?>) o;
return Objects.equals(first, pair.first) && Objects.equals(second, pair.second);
}
@Override
public int hashCode() {
return Objects.hash(first, second);
}
@Override
public String toString() {
return "Pair{" + "a=" + first + ", b=" + second + '}';
}
public T getFirst() {
return first;
}
public R getSecond() {
return second;
}
}
static <T, R> Pair<T, R> make_pair(T a, R b) {
return new Pair<>(a, b);
}
static long mod_inverse(long a, long m) {
Number x = new Number(0);
Number y = new Number(0);
extended_gcd(a, m, x, y);
return (m + x.v % m) % m;
}
static long extended_gcd(long a, long b, Number x, Number y) {
long d = a;
if (b != 0) {
d = extended_gcd(b, a % b, y, x);
y.v -= (a / b) * x.v;
} else {
x.v = 1;
y.v = 0;
}
return d;
}
static class Number {
long v = 0;
public Number(long v) {
this.v = v;
}
}
static long lcm(long a, long b, long c) {
return lcm(a, lcm(b, c));
}
static long lcm(long a, long b) {
long p = 1L * a * b;
return p / gcd(a, b);
}
static long gcd(long a, long b) {
while (b != 0) {
long t = b;
b = a % b;
a = t;
}
return a;
}
static long gcd(long a, long b, long c) {
return gcd(a, gcd(b, c));
}
static class ArrayUtils {
static void swap(int[] a, int i, int j) {
int 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 void print(char[] a) {
for (char c : a) {
out.print(c);
}
out.println("");
}
static int[] reverse(int[] data) {
int[] p = new int[data.length];
for (int i = 0, j = data.length - 1; i < data.length; i++, j--) {
p[i] = data[j];
}
return p;
}
static void prefixSum(long[] data) {
for (int i = 1; i < data.length; i++) {
data[i] += data[i - 1];
}
}
static void prefixSum(int[] data) {
for (int i = 1; i < data.length; i++) {
data[i] += data[i - 1];
}
}
static long[] reverse(long[] data) {
long[] p = new long[data.length];
for (int i = 0, j = data.length - 1; i < data.length; i++, j--) {
p[i] = data[j];
}
return p;
}
static char[] reverse(char[] data) {
char[] p = new char[data.length];
for (int i = 0, j = data.length - 1; i < data.length; i++, j--) {
p[i] = data[j];
}
return p;
}
static int[] MergeSort(int[] A) {
if (A.length > 1) {
int q = A.length / 2;
int[] left = new int[q];
int[] right = new int[A.length - q];
System.arraycopy(A, 0, left, 0, q);
System.arraycopy(A, q, right, 0, A.length - q);
int[] left_sorted = MergeSort(left);
int[] right_sorted = MergeSort(right);
return Merge(left_sorted, right_sorted);
} else {
return A;
}
}
static int[] Merge(int[] left, int[] right) {
int[] A = new int[left.length + right.length];
int i = 0;
int j = 0;
for (int k = 0; k < A.length; k++) {
// To handle left becoming empty
if (i == left.length && j < right.length) {
A[k] = right[j];
j++;
continue;
}
// To handle right becoming empty
if (j == right.length && i < left.length) {
A[k] = left[i];
i++;
continue;
}
if (left[i] <= right[j]) {
A[k] = left[i];
i++;
} else {
A[k] = right[j];
j++;
}
}
return A;
}
static long[] MergeSort(long[] A) {
if (A.length > 1) {
int q = A.length / 2;
long[] left = new long[q];
long[] right = new long[A.length - q];
System.arraycopy(A, 0, left, 0, q);
System.arraycopy(A, q, right, 0, A.length - q);
long[] left_sorted = MergeSort(left);
long[] right_sorted = MergeSort(right);
return Merge(left_sorted, right_sorted);
} else {
return A;
}
}
static long[] Merge(long[] left, long[] right) {
long[] A = new long[left.length + right.length];
int i = 0;
int j = 0;
for (int k = 0; k < A.length; k++) {
// To handle left becoming empty
if (i == left.length && j < right.length) {
A[k] = right[j];
j++;
continue;
}
// To handle right becoming empty
if (j == right.length && i < left.length) {
A[k] = left[i];
i++;
continue;
}
if (left[i] <= right[j]) {
A[k] = left[i];
i++;
} else {
A[k] = right[j];
j++;
}
}
return A;
}
static int upper_bound(int[] data, int num, int start) {
int low = start;
int high = data.length - 1;
int mid = 0;
int ans = -1;
while (low <= high) {
mid = (low + high) / 2;
if (data[mid] < num) {
low = mid + 1;
} else if (data[mid] >= num) {
high = mid - 1;
ans = mid;
}
}
if (ans == -1) {
return 100000000;
}
return data[ans];
}
static int lower_bound(int[] data, int num, int start) {
int low = start;
int high = data.length - 1;
int mid = 0;
int ans = -1;
while (low <= high) {
mid = (low + high) / 2;
if (data[mid] <= num) {
low = mid + 1;
ans = mid;
} else if (data[mid] > num) {
high = mid - 1;
}
}
if (ans == -1) {
return 100000000;
}
return data[ans];
}
}
static boolean[] primeSieve(int n) {
boolean[] primes = new boolean[n + 1];
Arrays.fill(primes, true);
primes[0] = false;
primes[1] = false;
for (int i = 2; i <= Math.sqrt(n); i++) {
if (primes[i]) {
for (int j = i * i; j <= n; j += i) {
primes[j] = false;
}
}
}
return primes;
}
// Iterative Version
static HashMap<Integer, Boolean> subsets_sum_iter(int[] data) {
HashMap<Integer, Boolean> temp = new HashMap<Integer, Boolean>();
temp.put(data[0], true);
for (int i = 1; i < data.length; i++) {
HashMap<Integer, Boolean> t1 = new HashMap<Integer, Boolean>(temp);
t1.put(data[i], true);
for (int j : temp.keySet()) {
t1.put(j + data[i], true);
}
temp = t1;
}
return temp;
}
static HashMap<Integer, Integer> subsets_sum_count(int[] data) {
HashMap<Integer, Integer> temp = new HashMap<>();
temp.put(data[0], 1);
for (int i = 1; i < data.length; i++) {
HashMap<Integer, Integer> t1 = new HashMap<>(temp);
t1.merge(data[i], 1, ADD);
for (int j : temp.keySet()) {
t1.merge(j + data[i], temp.get(j) + 1, ADD);
}
temp = t1;
}
return temp;
}
static class Graph {
ArrayList<Integer>[] g;
boolean[] visited;
ArrayList<Integer>[] graph(int n) {
g = new ArrayList[n];
visited = new boolean[n];
for (int i = 0; i < n; i++) {
g[i] = new ArrayList<>();
}
return g;
}
void BFS(int s) {
Queue<Integer> Q = new ArrayDeque<>();
visited[s] = true;
Q.add(s);
while (!Q.isEmpty()) {
int v = Q.poll();
for (int a : g[v]) {
if (!visited[a]) {
visited[a] = true;
Q.add(a);
}
}
}
}
}
static class SparseTable {
int[] log;
int[][] st;
public SparseTable(int n, int k, int[] data, BiFunction<Integer, Integer, Integer> f) {
log = new int[n + 1];
st = new int[n][k + 1];
log[1] = 0;
for (int i = 2; i <= n; i++) {
log[i] = log[i / 2] + 1;
}
for (int i = 0; i < data.length; i++) {
st[i][0] = data[i];
}
for (int j = 1; j <= k; j++)
for (int i = 0; i + (1 << j) <= data.length; i++)
st[i][j] = f.apply(st[i][j - 1], st[i + (1 << (j - 1))][j - 1]);
}
public int query(int L, int R, BiFunction<Integer, Integer, Integer> f) {
int j = log[R - L + 1];
return f.apply(st[L][j], st[R - (1 << j) + 1][j]);
}
}
static class InputReader {
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream), 2048);
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 long nextLong() {
return Long.parseLong(next());
}
public int nextInt() {
return Integer.parseInt(next());
}
public int[] readAllInts(int n) {
int[] p = new int[n];
for (int i = 0; i < n; i++) {
p[i] = in.nextInt();
}
return p;
}
public int[] readAllInts(int n, int s) {
int[] p = new int[n + s];
for (int i = s; i < n + s; i++) {
p[i] = in.nextInt();
}
return p;
}
public long[] readAllLongs(int n) {
long[] p = new long[n];
for (int i = 0; i < n; i++) {
p[i] = in.nextLong();
}
return p;
}
public long[] readAllLongs(int n, int s) {
long[] p = new long[n + s];
for (int i = s; i < n + s; i++) {
p[i] = in.nextLong();
}
return p;
}
public double nextDouble() {
return Double.parseDouble(next());
}
}
static void exit(int a) {
out.close();
err.close();
System.exit(a);
}
static InputStream inputStream = System.in;
static OutputStream outputStream = System.out;
static OutputStream errStream = System.err;
static InputReader in = new InputReader(inputStream);
static PrintWriter out = new PrintWriter(outputStream);
static PrintWriter err = new PrintWriter(errStream);
static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
}
| 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 11 | 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 | 7a74c689fc80f7a27923275785bfe2bb | 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.*;
public class class401 {
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 main(String arg[])
{
FastReader sc=new FastReader();
int t=sc.nextInt();
while(t-->0)
{
int n=sc.nextInt();
String s=sc.next();
int x=0,c=0,flag=0;
while(x<n-1)
{
flag=0;
int i,c1=0,fl=0;
if(s.charAt(x)=='(')
{
x+=2;
c++;
continue;
}
for( i=x+1;i<n;i++)
{
if(s.charAt(i)==')')
{
flag=1;
break;
}
}
if(flag==0)
break;
x=i+1;
c++;
}
int res=0;
if(x>=n)
res=0;
else if(x==n-1)
res=1;
else if(x==0)
res=n;
else
res=n-x;
System.out.println(c+" "+res);
}
}
}
| 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 11 | 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 | d939f6e1319cb69bd0f727890a2b07bf | 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 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 a[]=sc.next().toCharArray();
int cnt=0;
int i=0;
int last=-1;
while(i<n) {
boolean open=(a[i]=='(');
int j=i+1;
if(open && j<n) {
cnt++;
last=j;
i=j+1;
}
else {
while(j<n && a[j]!=')') {
j++;
}
if(j<n && a[j]==')') {
cnt++;
last=j;
}
i=j+1;
}
}
System.out.println(cnt+" "+(n-last-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 11 | 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 | b84975ce0e9e04e487844d0f690a05c9 | 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.lang.*;
import java.io.*;
public class Main
{
static long mod = (int)1e9+7;
static PrintWriter out=new PrintWriter(new BufferedOutputStream(System.out));
public static void main (String[] args) throws java.lang.Exception
{
FastReader sc =new FastReader();
int t=sc.nextInt();
// int t=1;
O : while(t-->0)
{
int n = sc.nextInt();
String s = sc.nextLine();
int count = 0;
int i = 0;
while(i<n)
{
if(s.charAt(i) == '(')
{
if(i+1 < n)
{
i += 2;
count++;
}
else
break;
}
else
{
if(i == n-1)
break;
if(s.charAt(i+1) == ')')
{
i += 2;
count++;
}
else
{
int j =i+1;
while(j+1 < n && s.charAt(j) == s.charAt(j+1))
{
j++;
}
if(j == n-1)
break;
count++;
j += 2;
i = j;
}
}
}
System.out.println(count + " " + (n-i));
}
out.flush();
}
static void printN()
{
System.out.println("NO");
}
static void printY()
{
System.out.println("YES");
}
static int findfrequencies(int a[],int n)
{
int count=0;
for(int i=0;i<a.length;i++)
{
if(a[i]==n)
{
count++;
}
}
return count;
}
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());
}
float nextFloat()
{
return Float.parseFloat(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;
}
long[] readArrayLong(int n) {
long[] a=new long[n];
for (int i=0; i<n; i++) a[i]=nextLong();
return a;
}
}
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[] EvenOddArragement(int a[])
{
ArrayList<Integer> list=new ArrayList<>();
for(int i=0;i<a.length;i++)
{
if(a[i]%2==0)
{
list.add(a[i]);
}
}
for(int i=0;i<a.length;i++)
{
if(a[i]%2!=0)
{
list.add(a[i]);
}
}
for(int i=0;i<a.length;i++)
{
a[i]=list.get(i);
}
return a;
}
static int gcd(int a, int b) {
while (b != 0) {
int t = a;
a = b;
b = t % b;
}
return a;
}
static int lcm(int a, int b)
{
return (a / gcd(a, b)) * b;
}
public static HashMap<Integer, Integer> sortByValue(HashMap<Integer, Integer> hm)
{
// Create a list from elements of HashMap
List<Map.Entry<Integer, Integer> > list =
new LinkedList<Map.Entry<Integer, Integer> >(hm.entrySet());
// Sort the list
Collections.sort(list, new Comparator<Map.Entry<Integer, Integer> >() {
public int compare(Map.Entry<Integer, Integer> o1,
Map.Entry<Integer, Integer> o2)
{
return (o1.getValue()).compareTo(o2.getValue());
}
});
// put data from sorted list to hashmap
HashMap<Integer, Integer> temp = new LinkedHashMap<Integer, Integer>();
for (Map.Entry<Integer, Integer> aa : list) {
temp.put(aa.getKey(), aa.getValue());
}
return temp;
}
static int DigitSum(int n)
{
int r=0,sum=0;
while(n>=0)
{
r=n%10;
sum=sum+r;
n=n/10;
}
return sum;
}
static boolean checkPerfectSquare(int number)
{
double sqrt=Math.sqrt(number);
return ((sqrt - Math.floor(sqrt)) == 0);
}
static boolean isPowerOfTwo(int 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 boolean isPrime2(int n)
{
if (n <= 1)
{
return false;
}
if (n == 2)
{
return true;
}
if (n % 2 == 0)
{
return false;
}
for (int i = 3; i <= Math.sqrt(n) + 1; i = i + 2)
{
if (n % i == 0)
{
return false;
}
}
return true;
}
static String minLexRotation(String str)
{
int n = str.length();
String arr[] = new String[n];
String concat = str + str;
for(int i=0;i<n;i++)
{
arr[i] = concat.substring(i, i + n);
}
Arrays.sort(arr);
return arr[0];
}
static String maxLexRotation(String str)
{
int n = str.length();
String arr[] = new String[n];
String concat = str + str;
for (int i = 0; i < n; i++)
{
arr[i] = concat.substring(i, i + n);
}
Arrays.sort(arr);
return arr[arr.length-1];
}
static class P implements Comparable<P> {
int i, j;
public P(int i, int j) {
this.i=i;
this.j=j;
}
public int compareTo(P o) {
return Integer.compare(i, o.i);
}
}
static int binary_search(int a[],int value)
{
int start=0;
int end=a.length-1;
int mid=start+(end-start)/2;
while(start<=end)
{
if(a[mid]==value)
{
return mid;
}
if(a[mid]>value)
{
end=mid-1;
}
else
{
start=mid+1;
}
mid=start+(end-start)/2;
}
return -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 11 | 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 | 85e9ecddee5d90a5328cc37362c9ed97 | 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 {
public static void main(String[] args) throws IOException {
//FileReader fr = new FileReader(new File("input.txt"));
InputStreamReader sr = new InputStreamReader(System.in);
BufferedReader reader = new BufferedReader(sr);
StringBuilder sb = new StringBuilder();
int t = Integer.parseInt(reader.readLine());
while (t-- > 0) {
int n = Integer.parseInt(reader.readLine());
char[] s = reader.readLine().toCharArray();
int i = 0, cnt = 0;
while (i + 1 < n) {
int temp = i;
if (s[i] == s[i+1] || s[i] == '(' && s[i+1] == ')') {
++cnt;
i += 2;
} else {
int j = i + 1;
while (j < n && s[i] != s[j]) j++;
if (j == n) j--;
if (s[i] == s[j]) {
i = j + 1;
++cnt;
}
}
if (i == temp) break;
}
sb.append(cnt + " " + (n - i) + "\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 11 | 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 | 145385bd8f050d26ca18c5f2c48f0eb5 | 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.Scanner;
public class C {
public static void main(String[] args) {
Scanner go = new Scanner(System.in);
int t = go.nextInt();
while (t-->0){
int n = go.nextInt();
String s = go.next();
int ans = 0;
int pos = 0;
String now = "";
String d = "";
int i = 0;
while (i+1 < n){
now = String.valueOf(s.charAt(i));
if (s.charAt(i) == '(' && s.charAt(i+1) == ')'){
ans++;
pos = i+1;
i += 2;
}else{
char f = s.charAt(i);
i++;
if (i < n){
for (int j = i; j<n; j++){
i = j;
if (f == s.charAt(j)){
ans++;
pos = j;
break;
}
}
}
i ++;
}
}
if (n == 1){
System.out.println("0 1");
}else {
if (ans == 0){
System.out.println("0" + " " + n);
}else {
System.out.println(ans + " " + (n-1-pos));
}
}
}
}
}
/*
((((
n
d
*/ | 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 11 | 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 | 72cb23ab13d550d049e60c7e49fd7666 | 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 | /*
++:,,;:,,,,,,,,:;:,,,,,,;:;;,,,,,,,:+:,;+;:,,,,,,,::,,:+;+;,,,,,,,,,,,,,,,:;,,::,:;,,,,:,,,,:;+;:,:,,,,:,,,,,,,,,,,,:,,,
++,,:;,,,,,,,,,:+:,,,,,:;;+:,,,,,,:;;:;;:,,,,,,,,,::,,;;;+;:,,,,,,,,,,,,,,;;,,::,,;,,,,:,,,,,,;+;:;:,,,;,,,,,,,,,,,,::,,
+;,,::,,,,,,,,,:+;,,,,,:++;,,,,,,:+;:+;:,,,,,,,,,,;,,,+;;+;:,,,,,,,,,,,,,:+:,,::,,;:,,::,,,,,,,;+;;;,,,;,,,,,,,,,,,,,:,,
+:,,::,,,,,,,,,:+;,,,,,:++:,,,,:;+;;+:,,,,,,,,,,,,;,,:+;;+;:,,,,,,,,,,,,,;+:,,::,,::,,::,,,,,,,,;;;;,,,;,,,,,,,,,,,,,;,,
+:,,::,,,,,,,,,:+;,,,,,:+;,,,,:;;+;;:,,,,,,,,,,,,::,,;:;++;:,:,,,,,,,,,,:+;:,,;:,,,;,,::,,,,,,,,,+;+:,,;:,,,,,,;:,,,,:,,
+,,,::,,,,,,,,,:++,,,,,;+;,,,:;++;:,,,,,,,,,,,,,,::,:::;++;:,;:,,,,,,,,:++;:,,;,,,,:,,;,,,,,,,,,,:+;;,,;:,,,,,,;:,,,,::,
;,,,::,,,,,,,,,:;+,,,,,;+,,:;;++;,,,,,,,,,,,,,,,,;::;,:;+;;::;:,,,,,,,:;+;;:,:;::::;,,;:::::::::,:;+;,,;:,,,,,,;:,,,,::,
;,,,::,,,,,,,,,;;+:,,,,;;,:;;++:,,,::::::::;;;;;;;,;:,,;+;;;+;:,,,,,,,;+*;;:,;;::::;::;,,,,,,,,,,,:++,,;:,,,,,:+:,,,,:;,
:,,,::,,,,,,,,,:;+:,,,,;::;;+;:::::::::::::::::,:;:;,,,++;;++;:,,,,,,;;;+;;,,;:::,,::;:,,,,,,,,,,,,;+:,;:,,,,,;+:,,,,,;:
:,,,::,,,,,,,,,:;+:,,,,;;;;+;,,,,,,,,,,,,,,,,:;;+:;,,,:++;++;;:,,,,,:;;;+;;,;;::,,,::;,,,,,,,,,,,,,,+;,;,,,,,,;;:,,,,,+:
:,,,::,,,,,,,,,:;+;,,,,:+;+;,,,,,,,,,,,,,,,,,,,:;;+:,,:+;+++;;:,,,,:;;:;;;::;,,,,,,:;:,,,,,,,,,,,,,,;;,;,,,,,:+;:,,,,,+;
,,,,::,,,,,,,,,:;;+:,,,:++:,,,,,,,,,,,,,,,,,,,,:+:,,,,;+;+:+;;:,,,:;+:,+;;:;,,,,,,,;;,,,,,,,,,,,,,,,,;:;,,,,,;+;:,,,,,+;
:,,,:;,,,,,,,,,,;;+:,,,:+:,,,,,,,,,,,,,,,,,::::;;::,,,+;+;:+;;:,,:;+:,:+;;;:,,,,,,,;:,::::;;;;+++**+:;::,,,,,+;;,,,,,,+;
:,,,,;,,,,,,,,,,:;+;,,,:;::::::;;;;;;;;++++***?%?%?:,:++;,;+;;,,:;+:,,;+;;:,::;;++**??%%SS#######SS#%+;:,,,,;+;:,,,,,,+;
:,,,,;:,,,,,,,,,:;;+:,,:;+%%SSSSS#######@#@########%*+++:,+;;;:;;+:,,,+;;;,;?%SSSS%%S##SSS#S%;:;;,,?+;;,,,,:+;;:,,,,,,+;
:,,,,;:,,,,,,,,,:;;+:,,,+%##?******?#%%%SSS%::;,,,;;;++:,:+;;;;++:,,,;++;,:+++;;::::;S%??%SS?;::;::;,;;,,,,;+;;,,,::,,++
:,,,,+;,,,,,,,,,,:;++,,,::;%?:,,,,,:%%?*?SS%;:;;;,,,++;,,;+;;;++:,,,,++;,,,,,,,,,,,.:S?*?SSS%**%%;:,,;:,,,;+;;:,,,::,:;+
;,,,:++:,,,,,,,,,:;;+:,,::,:*+,,,,,,+S*:+%#S?;*S*,,:++,,,++;;++:,,,,;+;,,,,,,,,,,,,,,%?;+?%%*:+%;,,,,;,,,:+;;;:,,,;,,:;;
;,,,:++:,,,,,,,,,,;;;+:,,;,,,;;,,,,,,**::;+;:+%?,,:++:,,:+;;+;,,,,,:+:,,,,,,,,,,,,,,.+*:,::::*?;,,,,:;,,:+;;;;,,,:;,,:::
+,,,:++;,::,,,,,,,:;;+;,,::,,,,,,,,,,,:*?***?%+,,,++:,,,;+;+;,,,,,,;:,,,,,,,,,,,,,,,,,,;****?*:,,,,,;:,:+;;;;:,,,::,,::,
+:,,:+;+:,;:,,,,,,,;;;+:,:;,,,,,,,,,,,:;+++++:,,,;;,,,,:+++:,,,,,,,,,,,,,,,,,,,,,,,::::;+++;:,,,,,,::,:+;;;;;,,,,::,,:;+
+:,,:+;+;,:;,,,,,,,:;;++,,::,,,,,,,,,,,,,,,,,,,,::,,,,,;+;:,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,:;,:+;;;;;:,,,,;:,,;;;
+;,,:+;++::+:,,,,,,,;;;+;,,;::::::::,,,,,,,,,,,,,,,,,,:+:,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,::::::::,,;::+;;;;;;,,,,:;,,,;::
++,,:+;++:,;+:,,,,,,:;;;+;,:;,,::::,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,:::::::;;;+;;;+;;:,,,,;:,,:;:;
;+:,;+;+:;::+;,,,,,,:;;;+;:,::,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,:,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,:;:;+;;++;;,,,,:;,,,;+++
;+;,;++;,:;,;+;,,,,,,:;;+;::,;:,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,;:,,,,,,,,,,,,,,,,,,,,,,,,,,,,:;:,;+;++;;:,,,,;;,,:++?%
;++,;++:,,:::;+;,,,,,:;;;+::::;,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,:+;;++;:,,,,:+;,,;+++*
;;+::+;,,,,;:;;+;,,,,,:;;+:,::::,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,;;;++;;,,,,,;;:,:*****
;;+;:+:,,,,:;:;;+:,,,,,;;+;,,::;:,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,:+;+*;;:,,,,:;;:,;?????
;;;+;;,,,,,,;;:;;+:,,,,:;;+:,,:;;:,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,:+;+*+;:,,,,:;:;::?%%%??
;;;++;,,,,,:;+;;;+*:,,,,:;+;,,,:;;:,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,:*+++++:,,,,,;:,;,+???++;
;;+;;+,,,,:;+++;;;++;,,,,;;+:,,,,;+:,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,;++++++;,,,,,::,:;;****+++
;+;,:+:,,:;;++++;;+++;,,,:;++,,,,,:+:,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,:;++++;+;:,,,,:;,,:;;;*****+
+;,,,;:,:;;++;;++;;++++:,,:;++:,,,,,;:,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,;++++++++:,,,,:;,,,;;::***??*
;,,,,,:,;;+++;;;++;+++++:,,:;++;::,,,:,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,:++;+*++++:,,,,:;:,,:+:::*??*?*
,,,,,,,:;;++;;;+++++*++;+:,,;+++++;:,,,,,,,,,,,,,,,,,,,:::::::,,:::::,,,,,,,,,,,,,,,,,,:;+;;;*+;;*;,,,,:+;:,,;:,,;*S%%%%
,,,,,,:;;++;;;++;;++++;;;+;,:;++;+++;;:,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,:;++;;;;++;;++:,,,;+;;:,::,,,:*SS%SS
,,,,,:;;+++;+++;;;;+**;;;;+;::;++++;;+++;:,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,:;++++;;;;++;;;+:,,,;+;;;;,,,,,,,+SSS#S
,,,,:;;+++;+++;;;;;++*+;;;;++;:;+*+;;;++++;;:,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,:;;+++;++;;;;;;;;+;,,:++;;;;;:,,,,,,:%SSSS
,,,:;;;++;+++;;;;;++;+*+;;;;++;;;++;;;;+;;;++;;:,,,,,,,,,,,,,,,,,,,,,,,,,,,:;;++;;++;++;;;;;;;;+:,;+++;;;;;;,,,,,,,*S#SS
,,:;;;+++++;;;;;;+++;;+++;;++;+++++++;;++;;;;;;+;;::,,,,,,,,,,,,,,,,,,,::;;+;;*+;;++;++;;;;;;;+::;++++;;;;;;:,,,,,,:%S##
,:;;;+++++;;;;;;;++;;;;++;;++;++++++++;++;;;;;;;;;++;;:,,,,,,,,,,,,,:;;++;;;;+*;;;++;++;;;;;;+;:++;+*+;;;;;;;:,,,,,,+SS#
:;;;++++;;;;;;;;++;;;;;;;;;++;++;;++++++*;;;;;;;;;;;;+++;;:,,,,,:;;+++;;;;;;;+*+;;;+;;++;;;;;+;+;;;;+*+;;;;;;:,,,,,,:?##
;;;+*++;;;;;;;;++;;;;;;;;;++;++;+++;;+*+*;;;;;;;;;;;;;;;;;+;;;;+++;;;;;;;;;;;++;+++++;++;;;;+++;;;;;+*+;;;;;;;:,,,,,,:%#
;;+*+;;;;;;;;;++;;;;;;;;;;++;+++;;;;;;;*?;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+?+;;;;++++;;;;+;;;;;;;;+*;;;;;;;;,,,,,,,+S
;+*+;;;;;;;;;++;;;;;;;;;;+++++;;;;;;;;*?*::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;*??*;;;;;;;+++;;;;;;;;;;;*+;;;;;;;:,,,,,,:?
++;;;;;;;;;;+++;;;;;;;;;+++;;;;;;;;;;*??*,,,,,:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;*???+;;;;;;;;+++;;;;;;;;;++;;;;;;;;:,,,,,,:
+;;;;;;;;;;+++;;;;;;;+++;;;;;;;;;;;;;???;,,,,,,,::;;;;;;;;;;;;;;;;;;;;;;;;;;:*????;;;;;;;;;;++++;;;;;;;++;;;;;;;;:,,,,,,
;;;;;;;;;;+++;;;;+++++;;;;;;;;;;;;;;+?*;,,,,,,,,,,,::;;;;;;;;;;;;;;;;;;;;;:,,;+*??*;;;;;;;;;;;;++++;;;;++;;;;;;;;;:,,,,,
;;;;;;;;;++;;;++++;;;;;;;;;;;;;;;;;;*+:,,,,,,,,,,,,,,,,::;;;;;;;;;;;;:::,,,,,,,:;*?;;;;;;;;;;;;;;;+++++;++;;;;;;;;;,,,,,
;;;;;;;;+++++++;;;;;;;;;;;;;;;;;;;;;+,,,,,,,,,,,,,,,,,,,,,,:::::::,,,,,,,,,,,,,,,,;;;;;;;;;;;;;;;;;;;;+++*+;;;;;;;;:,,,,
;;;;;;++*+++;;;;;;;;;;;;;;;;;;;;;;;;+:,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,;;;;;;;;;;;;;;;;;;;;;;;;+++++;;;;;:,,,
;++++++;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+:,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,;;;;;;;;;;;;;;;;;;;;;;;;;;;;+++++;;:,,
++;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;++++:,
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,:,,,,,,,,,,,,:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:,,,,,,,,,,,,,,,,,,,,,,,,,,,,;:,,,,,,,,,,,,;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;,,,,,,,,,,,,,,,,,,,,,,,,,,,;:,,,,,,,,,,,,:+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;++:::,,,,,,,,,,,,,,,,,,,,,,:;,,,,,,,::::::;+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+:::::::::::,,,,,,,,,,,,,::,,,:::::::::,,;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;,,,,,,::::::;:,,,,,,,,,,,,::::,,,,,,,,:+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
*/
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.util.Arrays;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int t = Integer.parseInt(br.readLine());
int[] opArray = new int[t];
int[] symbLeft = new int[t];
for(int a = 0; a < t; a++) {
int n = Integer.parseInt(br.readLine());
String line = br.readLine();
byte[] lineArray = new byte[n];
for(int i = 0; i < n; i++){
char ch = line.charAt(i);
if (ch == '(') lineArray[i] = 1;
else lineArray[i] = 2;
}
int weight = 0;
boolean startNew = true;
boolean canBeEqual = false;
int startNum = 0;
int currentLen = 0;
int operations = 0;
for(byte l: lineArray){
if (startNew){
startNum = l;
if(l == 1){
canBeEqual = true;
weight++;
}
startNew = false;
currentLen++;
continue;
}
currentLen++;
if (canBeEqual){
if(l == 1) weight++;
else weight--;
// erasing by weight
if (weight == 0) {
startNew = true;
canBeEqual = false;
operations++;
n -= currentLen;
currentLen = 0;
continue;
}
}
// erasing by palynom
if(l == startNum){
startNew = true;
canBeEqual = false;
operations++;
n -= currentLen;
weight = 0;
currentLen = 0;
}
}
opArray[a] = operations;
symbLeft[a] = n;
}
for(int i = 0; i < t; i++){
System.out.println(opArray[i] + " " + symbLeft[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 11 | 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 | d6b85627f076a8d80a6240ba71b8bfc9 | 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 c {
private static class pair implements Comparable<pair> {
int low, high;
pair(int low, int high) {
this.low = low;
this.high = high;
}
@Override
public int hashCode()
{
// uses roll no to verify the uniqueness
// of the object of Student class
final int temp = 14;
int ans = 1;
ans = (temp * ans) + low +high;
return ans;
}
public int compareTo(pair o)
{
return this.low-o.low;
}
// Equal objects must produce the same
// hash code as long as they are equal
@Override
public boolean equals(Object o)
{
if (this == o) {
return true;
}
if (o == null) {
return false;
}
if (this.getClass() != o.getClass()) {
return false;
}
pair other = (pair)o;
if (this.low != other.low && this.high !=other.high) {
return false;
}
return true;
}
}
static class InputReader {
private InputStream stream;
private byte[] buf = new byte[8192];
private int curChar, snumChars;
private InputReader.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);
}
}
public static void main(String[] args) {
InputReader in=new InputReader(System.in);
PrintWriter out=new PrintWriter(System.out);
int t = in.nextInt();
while (t-- != 0) {
int n=in.nextInt();
String s=in.readString();
int i=0,c=0;
while(i<s.length()-1)
{
if(s.charAt(i)==s.charAt(i+1))
{
c++;i+=2;continue;
}
if(s.charAt(i)=='('&&s.charAt(i+1)==')')
{
c++;i+=2;continue;
}
int ind=-1;
for(int k=i+1;k<n;k++)
{
if(s.charAt(k)==')')
{
c++;
ind=k;break;
}
}
if(ind==-1)
{
break;
}
i=ind+1;
}
int low=0;
if(i<n){
low=n-i;
}
out.println(c+" "+low);
}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 11 | 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 | 74aaa2c4f991ec9e229240faa26e488e | 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.text.*;
import java.io.*;
public class Main {
public static void main(String[] args) throws Exception {
FastReader sc = new FastReader();
PrintWriter writer = new PrintWriter(System.out);
int t = sc.nextInt();
while(t-->0) {
int n = sc.nextInt();
String str = sc.next();
int op = 0;
int left = 0;
if(n==1) {
writer.println(0 + " " + 1);
}else {
for(int i = 0; i < n ;) {
if((i+1) < n && (str.charAt(i) == str.charAt(i+1) || (str.charAt(i) == '(' && str.charAt(i+1) == ')'))) {
op++;
i+=2;
}else {
int j = i+2;
while(j < n && str.charAt(j) == '(')j++;
if(j==n) {
left = j - i;
break;
}else if(j>n) {
left = 1;
break;
}
else {
op++;
i = j+1;
}
}
}
writer.println(op + " " + left);
}
}
writer.flush();
writer.close();
}
private static long power (long a, long n, long p) {
long res = 1;
while(n!=0) {
if(n%2==1) {
res=(res*a)%p;
n--;
}else {
a= (a*a)%p;
n/=2;
}
}
return res;
}
private static boolean isPrime(int c) {
for (int i = 2; i*i <= c; i++) {
if(c%i==0)return false;
}
return true;
}
private static int find(int a , int arr[]) {
if(arr[a] != a) return arr[(int)a] = find(arr[(int)a], arr);
return arr[(int)a];
}
private static void union(int a, int b, int arr[]) {
int aa = find(a,arr);
int bb = find(b, arr);
arr[aa] = bb;
}
private static int gcd(int a, int b) {
if(a==0)return b;
return gcd(b%a, a);
}
public static int[] readIntArray(int size, FastReader s) {
int[] array = new int[size];
for (int i = 0; i < size; i++) {
array[i] = s.nextInt();
}
return array;
}
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;
}
}
}
class SegmentTree{
int size;
long arr[];
SegmentTree(int n){
size = 1;
while(size<n)size*=2;
arr = new long[size*2];
}
public void build(int input[]) {
build(input, 0,0, size);
}
public void set(int i, int v) {
set(i,v,0,0,size);
}
// sum from l + r-1
public long sum(int l, int r) {
return sum(l,r,0,0,size);
}
private void build(int input[], int x, int lx, int rx) {
if(rx-lx==1) {
if(lx < input.length )
arr[x] = 1;
return;
}
int mid = (lx+rx)/2;
build(input, 2*x+1, lx, mid);
build(input,2*x+2,mid,rx);
arr[x] = arr[2*x+1] + arr[2*x+2];
}
private void set(int i, int v, int x, int lx, int rx) {
if(rx-lx==1) {
arr[x] = v;
return;
}
int mid = (lx+rx)/2;
if(i < mid) set(i, v, 2*x+1, lx, mid);
else set(i,v,2*x+2,mid,rx);
arr[x] = arr[2*x+1] + arr[2*x+2];
}
private long sum(int l, int r, int x, int lx, int rx) {
if(lx>=r || rx <= l)return 0;
if(lx>=l && rx <= r)return arr[x];
int mid = (lx+rx)/2;
long s1 = sum(l,r,2*x+1,lx,mid);
long s2 = sum(l,r,2*x+2,mid,rx);
return s2+s1;
}
// int first_above(int v, int l, int x, int lx, int rx) {
// if(arr[x].a<v)return -1;
// if(rx<=l)return -1;
// if(rx-lx==1)return lx;
// int m = (lx+rx)/2;
// int res = first_above(v,l,2*x+1,lx,m);
// if(res==-1)res = first_above(v,l,2*x+2,m,rx);
// return res;
//
// }
}
class Trie{
Trie arr[] = new Trie[26];
boolean isEnd;
Trie(){
for(int i = 0; i < 26; i++)arr[i] = null;
isEnd = false;
}
}
class Pair implements Comparable<Pair>{
long a;
long b;
long c;
Pair(long a, long b, long c){
this.a = a;
this.b = b;
this.c = c;
}
Pair(long a, long b){
this.a = a;
this.b = b;
this.c = 0;
}
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || obj.getClass()!= this.getClass()) return false;
Pair pair = (Pair) obj;
return (pair.a == this.a && pair.b == this.b && pair.c == this.c);
}
@Override
public int compareTo(Pair o) {
// if(o.a != this.a) return Long.compare(this.a, o.a);
// else
return Long.compare(o.b, this.b);
}
@Override
public String toString() {
return this.a + " " + this.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 11 | 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 | 2e9c0724a6ca8ecba6127a86206125e2 | 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 {
// when can't think of anything -->>
// 1. In sorting questions try to think about all possibilities like sorting from start, end, middle.
// 2. Two pointers, brute force.
// 3. In graph query questions try to solve it reversely or try to process all the queries in a single parse.
// 4. If order does not matter then just sort the data if constraints allow. It'll never harm.
// 5. In greedy problems if you are just overwhelmed by the possibilities and stuck, try to code whatever you come up with.
// 6. Think like a robot, just consider all the possibilities not probabilities if you still can't solve.
// 7. Try to solve it from back or reversely.
public static void main(String[] args) throws Exception {
FastReader sc = new FastReader();
PrintWriter writer = new PrintWriter(System.out);
int t = sc.nextInt();
while(t-->0) {
int n = sc.nextInt();
String s = sc.next();
int arr[] = new int[n];
int v = -1;
if(s.charAt(n-1) == ')') v = n-1;
for(int i = n-2; i >= 0; i--) {
if(s.charAt(i) == ')') {
arr[i] = v;
v = i;
}
}
int moves = 0;
int val = 0;
for (int i = 0; i < s.length();) {
char c = s.charAt(i);
if(c == '(') {
if(i!= n-1) {
moves++;
i+=2;
}else {
val = 1;
i++;
}
}else {
if(i==n-1) {
i++;
val = 1;
}
else {
if(arr[i] == -1) {
val = n-i;
break;
}else {
moves++;
i = arr[i]+1;
}
}
}
}
writer.println(moves + " " + val);
}
writer.flush();
writer.close();
}
private static boolean isPrime(int c) {
for (int i = 2; i*i <= c; i++) {
if(c%i==0)return false;
}
return true;
}
private static int find(int a , int arr[]) {
if(arr[a] != a) return arr[a] = find(arr[a], arr);
return arr[a];
}
private static void union(int a, int b, int arr[]) {
int aa = find(a,arr);
int bb = find(b, arr);
arr[aa] = bb;
}
private static int gcd(int a, int b) {
if(a==0)return b;
return gcd(b%a, a);
}
public static int[] readIntArray(int size, FastReader s) {
int[] array = new int[size];
for (int i = 0; i < size; i++) {
array[i] = s.nextInt();
}
return array;
}
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;
}
}
}
class Pair implements Comparable<Pair>{
int a;
int b;
Pair(int a, int b){
this.a = a;
this.b = b;
}
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || obj.getClass()!= this.getClass()) return false;
Pair pair = (Pair) obj;
return (pair.a == this.a && pair.b == this.b);
}
@Override
public int hashCode()
{
return Objects.hash(a,b);
}
@Override
public int compareTo(Pair o) {
if(this.a == o.a) {
return Integer.compare(this.b, o.b);
}else {
return Integer.compare(this.a, o.a);
}
}
@Override
public String toString() {
return this.a + " " + this.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 11 | 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 | b84a30956e3fc1d7feead3c9575b126b | 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 {
private boolean oj = System.getProperty("ONLINE_JUDGE") != null;
private FastWriter wr;
private Reader rd;
public final int MOD = 1000000007;
/************************************************** FAST INPUT IMPLEMENTATION *********************************************/
class Reader {
BufferedReader br;
StringTokenizer st;
public Reader() {
br = new BufferedReader(
new InputStreamReader(System.in));
}
public Reader(String path) throws FileNotFoundException {
br = new BufferedReader(
new InputStreamReader(new FileInputStream(path)));
}
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 int ni() throws IOException {
return rd.nextInt();
}
public long nl() throws IOException {
return rd.nextLong();
}
char nc() throws IOException {
return rd.next().charAt(0);
}
public String ns() throws IOException {
return rd.nextLine();
}
public Double nd() throws IOException {
return rd.nextDouble();
}
public int[] nai(int n) throws IOException {
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = ni();
}
return arr;
}
public long[] nal(int n) throws IOException {
long[] arr = new long[n];
for (int i = 0; i < n; i++) {
arr[i] = nl();
}
return arr;
}
/************************************************** FAST OUTPUT IMPLEMENTATION *********************************************/
public static class FastWriter {
private static final int BUF_SIZE = 1 << 13;
private final byte[] buf = new byte[BUF_SIZE];
private final OutputStream out;
private int ptr = 0;
private FastWriter() {
out = null;
}
public FastWriter(OutputStream os) {
this.out = os;
}
public FastWriter(String path) {
try {
this.out = new FileOutputStream(path);
} catch (FileNotFoundException e) {
throw new RuntimeException("FastWriter");
}
}
public FastWriter write(byte b) {
buf[ptr++] = b;
if (ptr == BUF_SIZE) innerflush();
return this;
}
public FastWriter write(char c) {
return write((byte) c);
}
public FastWriter write(char[] s) {
for (char c : s) {
buf[ptr++] = (byte) c;
if (ptr == BUF_SIZE) innerflush();
}
return this;
}
public FastWriter write(String s) {
s.chars().forEach(c -> {
buf[ptr++] = (byte) c;
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 FastWriter write(int x) {
if (x == Integer.MIN_VALUE) {
return write((long) x);
}
if (ptr + 12 >= BUF_SIZE) innerflush();
if (x < 0) {
write((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 FastWriter write(long x) {
if (x == Long.MIN_VALUE) {
return write("" + x);
}
if (ptr + 21 >= BUF_SIZE) innerflush();
if (x < 0) {
write((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 FastWriter write(double x, int precision) {
if (x < 0) {
write('-');
x = -x;
}
x += Math.pow(10, -precision) / 2;
// if(x < 0){ x = 0; }
write((long) x).write(".");
x -= (long) x;
for (int i = 0; i < precision; i++) {
x *= 10;
write((char) ('0' + (int) x));
x -= (int) x;
}
return this;
}
public FastWriter writeln(char c) {
return write(c).writeln();
}
public FastWriter writeln(int x) {
return write(x).writeln();
}
public FastWriter writeln(long x) {
return write(x).writeln();
}
public FastWriter writeln(double x, int precision) {
return write(x, precision).writeln();
}
public FastWriter write(int... xs) {
boolean first = true;
for (int x : xs) {
if (!first) write(' ');
first = false;
write(x);
}
return this;
}
public FastWriter write(long... xs) {
boolean first = true;
for (long x : xs) {
if (!first) write(' ');
first = false;
write(x);
}
return this;
}
public FastWriter writeln() {
return write((byte) '\n');
}
public FastWriter writeln(int... xs) {
return write(xs).writeln();
}
public FastWriter writeln(long... xs) {
return write(xs).writeln();
}
public FastWriter writeln(char[] line) {
return write(line).writeln();
}
public FastWriter writeln(char[]... map) {
for (char[] line : map) write(line).writeln();
return this;
}
public FastWriter writeln(String s) {
return write(s).writeln();
}
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");
}
}
public FastWriter print(byte b) {
return write(b);
}
public FastWriter print(char c) {
return write(c);
}
public FastWriter print(char[] s) {
return write(s);
}
public FastWriter print(String s) {
return write(s);
}
public FastWriter print(int x) {
return write(x);
}
public FastWriter print(long x) {
return write(x);
}
public FastWriter print(double x, int precision) {
return write(x, precision);
}
public FastWriter println(char c) {
return writeln(c);
}
public FastWriter println(int x) {
return writeln(x);
}
public FastWriter println(long x) {
return writeln(x);
}
public FastWriter println(double x, int precision) {
return writeln(x, precision);
}
public FastWriter print(int... xs) {
return write(xs);
}
public FastWriter print(long... xs) {
return write(xs);
}
public FastWriter println(int... xs) {
return writeln(xs);
}
public FastWriter println(long... xs) {
return writeln(xs);
}
public FastWriter println(char[] line) {
return writeln(line);
}
public FastWriter println(char[]... map) {
return writeln(map);
}
public FastWriter println(String s) {
return writeln(s);
}
public FastWriter println() {
return writeln();
}
}
/********************************************************* USEFUL CODE **************************************************/
boolean[] SAPrimeGenerator(int n) {
// TC-N*LOG(LOG N)
//Create Prime Marking Array and fill it with true value
boolean[] primeMarker = new boolean[n + 1];
Arrays.fill(primeMarker, true);
primeMarker[0] = false;
primeMarker[1] = false;
for (int i = 2; i <= n; i++) {
if (primeMarker[i]) {
// we start from 2*i because i*1 must be prime
for (int j = 2 * i; j <= n; j += i) {
primeMarker[j] = false;
}
}
}
return primeMarker;
}
private void tr(Object... o) {
if (!oj) System.out.println(Arrays.deepToString(o));
}
class Pair<F, S> {
private F first;
private S second;
Pair(F first, S second) {
this.first = first;
this.second = second;
}
public F getFirst() {
return first;
}
public S getSecond() {
return second;
}
@Override
public String toString() {
return "Pair{" +
"first=" + first +
", second=" + second +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Pair<F, S> pair = (Pair<F, S>) o;
return first == pair.first && second == pair.second;
}
@Override
public int hashCode() {
return Objects.hash(first, second);
}
}
public static void main(String[] args) throws IOException {
new Main().run();
}
public void run() throws IOException {
if (oj) {
rd = new Reader();
wr = new FastWriter(System.out);
} else {
File input = new File("input.txt");
File output = new File("output.txt");
if (input.exists() && output.exists()) {
rd = new Reader(input.getPath());
wr = new FastWriter(output.getPath());
} else {
rd = new Reader();
wr = new FastWriter(System.out);
oj = true;
}
}
long s = System.currentTimeMillis();
solve();
wr.flush();
tr(System.currentTimeMillis() - s + "ms");
}
/***************************************************************************************************************************
*********************************************************** MAIN CODE ******************************************************
****************************************************************************************************************************/
boolean[] sieve;
public void solve() throws IOException {
int t = 1;
t = ni();
while (t-- > 0) {
go();
}
}
/********************************************************* MAIN LOGIC HERE ****************************************************/
long gcd(long a, long b)
{
if (a == 0)
return b;
return gcd(b % a, a);
}
public void go() throws IOException {
int n=ni();
String st=ns();
int counter=0;
int left=st.length();
// if(n==1){
// wr.println(0+" "+1);
// return;
// }
for(int i=0;i<n;){
char ch=st.charAt(i);
if(ch=='(' && i<n-1){
i+=2;
counter++;
left-=2;
}else if(ch==')'){
i++;
int cnt=0;
while (i<n && st.charAt(i)!=')') {
cnt++;
i++;
}
if(i<n && st.charAt(i)==')'){
counter++;
left=left-cnt-2;
i++;
}
}else {
i++;
}
}
wr.println(counter+" "+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 11 | 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 | 47666f689e670948a1ac8f759ba7ab18 | 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.Scanner;
// public class CFE125_C {
// public static void main(String[] args) {
// Scanner cs=new Scanner(System.in);
// int t=cs.nextInt();
// while(t-->0){
// int n=cs.nextInt();
// String s=cs.next();
// int x=0;
// int y=0;
// StringBuilder st=new StringBuilder();
// for(int i=0;i<n;i++){
// st.append(s.charAt(i));
// if(st.toString().equals("((") || st.toString().equals("))") || st.toString().equals("()")){
// y+=2;
// x++;
// st=new StringBuilder();;
// }else if(st.length()>1){
// if(s.charAt(i)==')'){
// y+=st.length();
// x++;
// st=new StringBuilder();;
// }
// }
// }
// // for(int p: ans) System.out.print(p+" ");
// System.out.println(x+" "+(n-y));
// }
// cs.close();
// }
// }
import java.util.Scanner;
public class CFE125_C {
public static void main(String[] args) {
Scanner cs=new Scanner(System.in);
int t=cs.nextInt();
while(t-->0){
int n=cs.nextInt();
String s=cs.next();
int x=0;
int y=0;
StringBuilder st=new StringBuilder();
for(int i=0;i<n;i++){
st.append(s.charAt(i));
if(st.toString().equals("((") || st.toString().equals("))") || st.toString().equals("()")){
y+=2;
x++;
st=new StringBuilder();;
}else if(st.length()>1){
int j=0;
while(i<n && s.charAt(i)=='('){
i++;
j++;
}
if(i==n) break;
if(s.charAt(i)==')'){
y+=j+2;
x++;
st=new StringBuilder();;
}
}
}
// for(int p: ans) System.out.print(p+" ");
System.out.println(x+" "+(n-y));
}
cs.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 11 | 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 | cfe638f419e0df9fa46723a2b5f1dab0 | 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.Scanner;
public class CFE125_C {
public static void main(String[] args) {
Scanner cs=new Scanner(System.in);
int t=cs.nextInt();
while(t-->0){
int n=cs.nextInt();
String s=cs.next();
// int x=0;
// int y=0;
// StringBuilder st=new StringBuilder();
// for(int i=0;i<n;i++){
// st.append(s.charAt(i));
// if(st.toString().equals("((") || st.toString().equals("))") || st.toString().equals("()")){
// y+=2;
// x++;
// st=new StringBuilder();;
// }else if(st.length()>1){
// if(s.charAt(i)==')'){
// y+=st.length();
// x++;
// st=new StringBuilder();;
// }
// }
// }
// for(int p: ans) System.out.print(p+" ");
int i=0,c=0;
while(i<n-1){
if(s.charAt(i)==s.charAt(i+1)){
c++;
i+=2;
continue;
}
if(s.charAt(i)=='(' && s.charAt(i+1)==')'){
c++;
i+=2;
continue;
}
int idx=-1;
for(int k=i+1;k<n;k++){
if(s.charAt(k)==')'){
c++;
idx=k;
break;
}
}
if(idx==-1) break;
i = idx+1;
}
int l=0;
if(i<n){
l=n-i;
}
// bw.write(c+" "+l+"\n");
System.out.println(c+" "+l);
}
cs.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 11 | 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 | d5ccfeb84ba033c99792a0699a289f8c | 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.math.*;
import java.io.*;
public class Solution {
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 inmatrix(char[][] a, int n, int m) {
for (int i = 0; i < n; i++) {
String s = sc.next();
for (int j = 0; j < m; j++) {
a[i][j] = s.charAt(j);
}
}
}
public static void main(String[] args) throws IOException {
sc = new FastReader();
out = new PrintWriter(System.out);
// primes();
// ________________________________
StringBuilder output = new StringBuilder();
int test = sc.nextInt();
// int test = 1;
int t = test;
while (test-- > 0) {
int n = sc.nextInt();
char [] ch = sc.next().toCharArray();
solver(n,ch);
}
out.flush();
}
public static void solver(int n, char []arr) {
int ans=0;
int rem=0;
int next[]=new int[n+1];
next[n]=n;
for(int i=n-1;i>=0;i--) {
if(arr[i]==')') {
next[i]=i;
}
else next[i]=next[i+1];
}
int i=0;
while(i<n-1) {
if(arr[i]=='(') {
i+=2;
ans++;
}
else {
int j= next[i+1]+1;
if(j<n+1) {
ans++;
i=j;
}
else {
break;
}
}
}
rem=Math.max(0, n-i);
if(ans==0) rem=n;
System.out.println(ans+" "+rem);
}
static class Pair implements Comparable<Pair> {
int at;
int amount;
int dt;
Pair(int at, int amount, int dt) {
this.at = at;
this.amount = amount;
this.dt = dt;
}
public int compareTo(Pair o) {
if (this.dt == o.dt)
return o.amount - this.amount;
return this.dt - o.dt;
}
}
static void sort(int a[]) { // int -> long
ArrayList<Integer> arr = new ArrayList<>(); // Integer -> Long
for (int i = 0; i < a.length; i++)
arr.add(a[i]);
Collections.sort(arr);
for (int i = 0; i < a.length; i++)
a[i] = arr.get(i);
}
public static void leftRotate(int a[], int n, int k) {
k = k % n;
reverseArray(a, 0, k - 1);
reverseArray(a, k, n - 1);
reverseArray(a, 0, n - 1);
}
private static long gcd(long a, long b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
private static void inarr(long a[]) {
for (int i = 0; i < a.length; i++) {
a[i] = sc.nextLong();
}
}
private static long pow(long x, long y) {
if (y == 0)
return 1;
long temp = pow(x, y / 2);
if (y % 2 == 1) {
return x * temp * temp;
} else {
return temp * temp;
}
}
static long powM(long a, long b) {
if (b == 0)
return 1;
long res = pow(a, b / 2);
res = (res % mod * res % mod) % 1_000_000_007;
if (b % 2 == 1) {
res = (res % mod * a % mod) % 1_000_000_007;
}
return res % mod;
}
static int log(long n) {
int res = 0;
while (n > 0) {
res++;
n /= 2;
}
return res;
}
static int mod = (int) 1e9 + 7;
static PrintWriter out;
static FastReader sc;
static class Edge {
int u, v;
Edge(int u, int v) {
this.u = u;
this.v = v;
}
}
// static class Pair implements Comparable <Pair>{
// int l, r;
//
// Pair(int l, int r)
// {
// this.l = l;
// this.r = r;
//
// }
// public int compareTo(Pair o)
// {
//
// return this.l-o.l;
// }
// }
static long[] dp;
public static int setbitcnt(long n) {
int nb = 0;
while (n != 0) {
long rmsb = n & (-n);
n = n - rmsb;
nb++;
}
return nb;
}
public static long log2(long N) {
// calculate log2 N indirectly
// using log() method
long result = (long) (Math.log(N) / Math.log(2));
return result;
}
static long highestPowerof2(long x) {
// check for the set bits
x |= x >> 1;
x |= x >> 2;
x |= x >> 4;
x |= x >> 8;
x |= x >> 16;
// Then we remove all but the top bit by xor'ing the
// string of 1's with that string of 1's shifted one to
// the left, and we end up with just the one top bit
// followed by 0's.
return x ^ (x >> 1);
}
public static void rotate(int[] arr, int s, int n) {
int x = arr[n], i;
for (i = n; i > s; i--)
arr[i] = arr[i - 1];
arr[s] = x;
// for(int j=s;j<=n;j++)
// System.out.print(arr[j]+" ");
// System.out.println();
}
static int lower_bound(int[] a, long x) {
int i = 0;
int j = a.length - 1;
// if(arr[i] > key)return -1;
if (a[j] < x)
return a.length;
while (i < j) {
int mid = (i + j) / 2;
if (a[mid] == x) {
j = mid;
}
else if (a[mid] < x) {
i = mid + 1;
} else
j = mid - 1;
}
return i;
}
int upper_bound(int[] arr, int key) {
int i = 0;
int j = arr.length - 1;
if (arr[j] <= key)
return j + 1;
while (i < j) {
int mid = (i + j) / 2;
if (arr[mid] <= key) {
i = mid + 1;
} else
j = mid;
}
return i;
}
static void reverseArray(int arr[], int start, int end) {
while (start < end) {
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
start++;
end--;
}
}
} | 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 11 | 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 | 013a60276ca0af314c97b558ec7b992c | 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 Bracket extends PrintWriter {
Bracket() { super(System.out); }
Scanner sc = new Scanner(System.in);
public static void main(String[] $) {
Bracket o = new Bracket(); o.main(); o.flush();
}
void main() {
int t = sc.nextInt();
while (t-- > 0) {
int n = sc.nextInt();
byte[] cc = sc.next().getBytes();
int k = 0, i = 0;
while (i + 1 < n)
if (cc[i] == cc[i + 1] || cc[i] == '(' && cc[i + 1] == ')') {
k++;
i += 2;
} else {
int j = i + 1;
while (j < n && cc[j] == '(')
j++;
if (j == n)
break;
k++;
i = j + 1;
}
println(k + " " + (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 11 | 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 | 1c4f9f998852eab0f4e52cf767d11537 | 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 B {
static FastScanner fs = new FastScanner();
static PrintWriter pw = new PrintWriter(System.out);
static StringBuilder sb = new StringBuilder("");
public static void main(String[] args) {
int t = fs.nextInt();
for (int tt = 0; tt < t; tt++) {
int n = fs.nextInt();
String s = fs.next();
int ans = 0;
int i = 0;
while (i < n-1) {
if (s.charAt(i) == '(') {
i += 2;
ans++;
} else {
int j = i+1;
while (j < n && s.charAt(j) == '(') j++;
if (j == n) break;
i = j+1;
ans++;
}
}
sb.append(ans + " " + (n-i) + "\n");
}
pw.print(sb.toString());
pw.close();
}
static void sort(int[] a) {
ArrayList<Integer> al = new ArrayList<>();
for (int i : a)
al.add(i);
Collections.sort(al);
for (int i = 0; i < a.length; i++)
a[i] = al.get(i);
}
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());}
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 11 | 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 | 21b8ce2ad159b9ad4b3ed228110cf925 | 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.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Writer;
import java.lang.reflect.Array;
import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;
import org.w3c.dom.NamedNodeMap;
import java.io.*;
import java.math.*;
import java.util.*;
import java.util.Arrays;
import java.util.Comparator;
import java.util.*;
import java.util.Collections;
import java.util.Date;
import java.util.Random;
import java.util.LinkedList;
public class div {
static PrintWriter output = new PrintWriter(System.out);
public static void main(String[] args) throws java.lang.Exception {
OutputWriter out = new OutputWriter(System.out);
div.FastReader sc =new FastReader();
int t =sc.nextInt();
for(int i =0;i<t;i++) {
int n =sc.nextInt(); String s =sc.next(); long count=0; int x=0;
while(x<n-1) {
int k=-1;
if(s.charAt(x)==s.charAt(x+1)) {
count++;x+=2; continue;
}
else if(s.charAt(x)!=s.charAt(x+1)&&s.charAt(x)=='(') {
count++; x+=2;continue;
}
for(int e=x+1;e<n;e++){
if(s.charAt(e)!='('){
count++;k=e;break;}
}
if(k==-1)break;
x=k+1;
}
if(x<n)out.println(count+" "+(n-x));
else out.println(count+" "+"0");
}
out.close();
}
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());
}
float nextFloat()
{
return Float.parseFloat(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;
}
long[] readArrayLong(int n) {
long[] a=new long[n];
for (int i=0; i<n; i++) a[i]=nextLong();
return a;
}
}
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 void reverse_sorted(int[] arr)
{
ArrayList<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);
}
}
static int LowerBound(int a[], int 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(ArrayList<Integer> list, int x) {// x is the key or target value
int l=-1,r=list.size();
while(l+1<r) {
int m=(l+r)>>>1;
if(list.get(m)<=x) l=m;
else r=m;
}
return l+1;
}
public static HashMap<String, Integer> sortByValue(HashMap<String, Integer> hm)
{
// Create a list from elements of HashMap
List<Map.Entry<String, Integer> > list =
new LinkedList<Map.Entry<String, Integer> >(hm.entrySet());
// Sort the list
Collections.sort(list, new Comparator<Map.Entry<String, Integer> >() {
public int compare(Map.Entry<String, Integer> o1,
Map.Entry<String, Integer> o2)
{
return (o1.getValue()).compareTo(o2.getValue());
}
});
// put data from sorted list to hashmap
HashMap<String, Integer> temp = new LinkedHashMap<String, Integer>();
for (Map.Entry<String, Integer> aa : list) {
temp.put(aa.getKey(), aa.getValue());
}
return temp;
}
static class Queue_Pair implements Comparable<Queue_Pair> {
int first , second;
public Queue_Pair(int first, int second) {
this.first=first;
this.second=second;
}
public int compareTo(Queue_Pair o) {
return Integer.compare(o.first, first);
}
}
static void leftRotate(int arr[], int d, int n)
{
for (int i = 0; i < d; i++)
leftRotatebyOne(arr, n);
}
static void leftRotatebyOne(int arr[], int n)
{
int i, temp;
temp = arr[0];
for (i = 0; i < n - 1; i++)
arr[i] = arr[i + 1];
arr[n-1] = temp;
}
static boolean isPalindrome(String str)
{
// Pointers pointing to the beginning
// and the end of the string
int i = 0, j = str.length() - 1;
// While there are characters to compare
while (i < j) {
// If there is a mismatch
if (str.charAt(i) != str.charAt(j))
return false;
// Increment first pointer and
// decrement the other
i++;
j--;
}
// Given string is a palindrome
return true;
}
static boolean palindrome_array(char arr[], int n)
{
// Initialise flag to zero.
int flag = 0;
// Loop till array size n/2.
for (int i = 0; i <= n / 2 && n != 0; i++) {
// Check if first and last element are different
// Then set flag to 1.
if (arr[i] != arr[n - i - 1]) {
flag = 1;
break;
}
}
// If flag is set then print Not Palindrome
// else print Palindrome.
if (flag == 1)
return false;
else
return true;
}
static boolean allElementsEqual(long[] arr,int n)
{
int z=0;
for(int i=0;i<n-1;i++)
{
if(arr[i]==arr[i+1])
{
z++;
}
}
if(z==n-1)
{
return true;
}
else
{
return false;
}
}
static boolean allElementsDistinct(int[] arr,int n)
{
int z=0;
for(int i=0;i<n-1;i++)
{
if(arr[i]!=arr[i+1])
{
z++;
}
}
if(z==n-1)
{
return true;
}
else
{
return false;
}
}
public static void reverse(int[] array)
{
// Length of the array
int n = array.length;
// Swaping the first half elements with last half
// elements
for (int i = 0; i < n / 2; i++) {
// Storing the first half elements temporarily
int temp = array[i];
// Assigning the first half to the last half
array[i] = array[n - i - 1];
// Assigning the last half to the first half
array[n - i - 1] = temp;
}
}
public static void reverse_Long(long[] array)
{
// Length of the array
int n = array.length;
// Swaping the first half elements with last half
// elements
for (int i = 0; i < n / 2; i++) {
// Storing the first half elements temporarily
long temp = array[i];
// Assigning the first half to the last half
array[i] = array[n - i - 1];
// Assigning the last half to the first half
array[n - i - 1] = temp;
}
}
static boolean isSorted(int[] a)
{
for (int i = 0; i < a.length - 1; i++)
{
if (a[i] > a[i + 1]) {
return false;
}
}
return true;
}
static boolean isReverseSorted(int[] a)
{
for (int i = 0; i < a.length - 1; i++)
{
if (a[i] < a[i + 1]) {
return false;
}
}
return true;
}
static int[] rearrangeEvenAndOdd(int arr[], int n)
{
ArrayList<Integer> list = new ArrayList<>();
for(int i=0;i<n;i++)
{
if(arr[i]%2==0)
{
list.add(arr[i]);
}
}
for(int i=0;i<n;i++)
{
if(arr[i]%2!=0)
{
list.add(arr[i]);
}
}
int len = list.size();
int[] array = list.stream().mapToInt(i->i).toArray();
return array;
}
static long[] rearrangeEvenAndOddLong(long arr[], int n)
{
ArrayList<Long> list = new ArrayList<>();
for(int i=0;i<n;i++)
{
if(arr[i]%2==0)
{
list.add(arr[i]);
}
}
for(int i=0;i<n;i++)
{
if(arr[i]%2!=0)
{
list.add(arr[i]);
}
}
int len = list.size();
long[] array = list.stream().mapToLong(i->i).toArray();
return array;
}
static boolean isPrime(long n)
{
// Check if number is less than
// equal to 1
if (n <= 1)
return false;
// Check if number is 2
else if (n == 2)
return true;
// Check if n is a multiple of 2
else if (n % 2 == 0)
return false;
// If not, then just check the odds
for (long i = 3; i <= Math.sqrt(n); i += 2)
{
if (n % i == 0)
return false;
}
return true;
}
static long getSum(long n)
{
long sum = 0;
while (n != 0)
{
sum = sum + n % 10;
n = n/10;
}
return sum;
}
static int gcd(int a, int b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
static long gcdLong(long a, long b)
{
if (b == 0)
return a;
return gcdLong(b, a % b);
}
static void swap(int i, int j)
{
int temp = i;
i = j;
j = temp;
}
static int countDigit(int n)
{
return (int)Math.floor(Math.log10(n) + 1);
}
//////////////////////////////////////////////////////////////////////////////
public static class OutputWriter {
private final PrintWriter writer;
public OutputWriter(OutputStream outputStream) {
writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
}
public OutputWriter(Writer writer) {
this.writer = new PrintWriter(writer);
}
public void print(char[] array) {
writer.print(array);
}
public void print(Object... objects) {
for (int i = 0; i < objects.length; i++) {
if (i != 0) {
writer.print(' ');
}
writer.print(objects[i]);
}
}
public void print(int[] array) {
for (int i = 0; i < array.length; i++) {
if (i != 0) {
writer.print(' ');
}
writer.print(array[i]);
}
}
public void print(double[] array) {
for (int i = 0; i < array.length; i++) {
if (i != 0) {
writer.print(' ');
}
writer.print(array[i]);
}
}
public void print(long[] array) {
for (int i = 0; i < array.length; i++) {
if (i != 0) {
writer.print(' ');
}
writer.print(array[i]);
}
}
public void println(int[] array) {
print(array);
writer.println();
}
public void println(double[] array) {
print(array);
writer.println();
}
public void println(long[] array) {
print(array);
writer.println();
}
public void println() {
writer.println();
}
public void println(Object... objects) {
print(objects);
writer.println();
}
public void print(char i) {
writer.print(i);
}
public void println(char i) {
writer.println(i);
}
public void println(char[] array) {
writer.println(array);
}
public void printf(String format, Object... objects) {
writer.printf(format, objects);
}
public void close() {
writer.close();
}
public void flush() {
writer.flush();
}
public void print(long i) {
writer.print(i);
}
public void println(long i) {
writer.println(i);
}
public void print(int i) {
writer.print(i);
}
public void println(int i) {
writer.println(i);
}
public void separateLines(int[] array) {
for (int i : array) {
println(i);
}
}
}
/*
Arrays.sort(arr, Comparator.comparingDouble(o -> o[0]));
q.replace(i, i+1, "4");
StringBuilder q = new StringBuilder(s);
List arr1 = new ArrayList();
String.format("%.2f",arr[ee][0])
Hashtable s = new Hashtable();
*/
/*
*/
}
| 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 11 | 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 | ae2d1e7cc79ab9d2432d24ab63e17676 | 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 cf {
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());
}
float nextFloat() {
return Float.parseFloat(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
void readArr(int[] ar, int n) {
for (int i = 0; i < n; i++) {
ar[i] = nextInt();
}
}
}
public static long gcd(long a, long b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
public static boolean binary_search(long[] a, long k) {
long low = 0;
long high = a.length - 1;
long mid = 0;
while (low <= high) {
mid = low + (high - low) / 2;
if (a[(int) mid] == k) {
return true;
} else if (a[(int) mid] < k) {
low = mid + 1;
} else {
high = mid - 1;
}
}
return false;
}
public static int bSearchDiff(long[] a, int low, int high) {
int mid = low + ((high - low) / 2);
int hight = high;
int lowt = low;
while (lowt < hight) {
mid = lowt + (hight - lowt) / 2;
if (a[high] - a[mid] <= 5) {
hight = mid;
} else {
lowt = mid + 1;
}
}
return lowt;
}
public static long lowerbound(long a[], long ddp) {
long low = 0;
long high = a.length;
long mid = 0;
while (low < high) {
mid = low + (high - low) / 2;
// if (a[(int) mid] == ddp) {
// return mid;
// }
if (a[(int) mid] <= ddp) {
low = mid + 1;
} else {
high = mid;
}
}
// if(low + 1 < a.length && a[(int)low + 1] <= ddp){
// low++;
// }
if (low == a.length && low != 0) {
low--;
return low;
}
if (a[(int) low] > ddp && low != 0) {
low--;
}
return low;
}
public static long lowerbound(long a[], long ddp, long factor) {
long low = 0;
long high = a.length;
long mid = 0;
while (low < high) {
mid = low + (high - low) / 2;
if ((a[(int) mid] + (mid * factor)) == ddp) {
return mid;
}
if ((a[(int) mid] + (mid * factor)) < ddp) {
low = mid + 1;
} else {
high = mid;
}
}
// if(low + 1 < a.length && a[(int)low + 1] <= ddp){
// low++;
// }
if (low == a.length && low != 0) {
low--;
return low;
}
if (a[(int) low] > ddp - (low * factor) && low != 0) {
low--;
}
return low;
}
public static long lowerbound(List<Long> a, long ddp) {
long low = 0;
long high = a.size();
long mid = 0;
while (low < high) {
mid = low + (high - low) / 2;
// if (a.get((int) mid) == ddp) {
// return mid;
// }
if (a.get((int) mid) < ddp) {
low = mid + 1;
} else {
high = mid;
}
}
// if(low + 1 < a.length && a[(int)low + 1] <= ddp){
// low++;
// }
// if (low == a.size() && low != 0) {
// low--;
// return low;
// }
// if (a.get((int) low) >= ddp && low != 0) {
// low--;
// }
return low;
}
public static long lowerboundforpairs(pair a[], double pr) {
long low = 0;
long high = a.length;
long mid = 0;
while (low < high) {
mid = low + (high - low) / 2;
if (a[(int) mid].w <= pr) {
low = mid + 1;
} else {
high = mid;
}
}
// if(low + 1 < a.length && a[(int)low + 1] <= ddp){
// low++;
// }
// if(low == a.length && low != 0){
// low--;
// return low;
// }
// if(a[(int)low].w > pr && low != 0){
// low--;
// }
return low;
}
public static long upperbound(long a[], long ddp) {
long low = 0;
long high = a.length;
long mid = 0;
while (low < high) {
mid = low + (high - low) / 2;
if (a[(int) mid] <= ddp) {
low = mid + 1;
} else {
high = mid;
}
}
if (low == a.length) {
return a.length - 1;
}
return low;
}
public static long upperbound(ArrayList<Long> a, long ddp) {
long low = 0;
long high = a.size();
long mid = 0;
while (low < high) {
mid = low + (high - low) / 2;
if (a.get((int) mid) <= ddp) {
low = mid + 1;
} else {
high = mid;
}
}
if (low == a.size()) {
return a.size() - 1;
}
// System.out.println(a.get((int) low) + " " + ddp);
if (low + 1 < a.size() && a.get((int) low) <= ddp) {
low++;
}
return low;
}
// public static class pair implements Comparable<pair> {
// long w;
// long h;
// public pair(long w, long h) {
// this.w = w;
// this.h = h;
// }
// public int compareTo(pair b) {
// if (this.w != b.w)
// return (int) (this.w - b.w);
// else
// return (int) (this.h - b.h);
// }
// }
public static class pairs {
char w;
int h;
public pairs(char w, int h) {
this.w = w;
this.h = h;
}
}
public static class pair {
long w;
long h;
public pair(long w, long h) {
this.w = w;
this.h = h;
}
@Override
public int hashCode() {
return Objects.hash(w, h);
}
@Override
public boolean equals(Object o) {
if (o == this) {
return true;
}
if (!(o instanceof pair)) {
return false;
}
pair c = (pair) o;
return Long.compare(this.w, c.w) == 0 && Long.compare(this.h, h) == 0;
}
}
public static class trinary {
long a;
long b;
long c;
public trinary(long a, long b, long c) {
this.a = a;
this.b = b;
this.c = c;
}
}
public static pair[] sortpair(pair[] a) {
Arrays.sort(a, new Comparator<pair>() {
public int compare(pair p1, pair p2) {
if (p1.w != p2.w) {
return (int) (p1.w - p2.w);
}
return (int) (p1.h - p2.h);
}
});
return a;
}
public static trinary[] sortpair(trinary[] a) {
Arrays.sort(a, new Comparator<trinary>() {
public int compare(trinary p1, trinary p2) {
if (p1.b != p2.b) {
return (int) (p1.b - p2.b);
} else if (p1.c != p2.c) {
return (int) (p1.c - p2.c);
}
return (int) (p1.a - p2.a);
}
});
return a;
}
public static void sort(long[] arr) {
ArrayList<Long> a = new ArrayList<>();
for (long i : arr) {
a.add(i);
}
Collections.sort(a);
for (int i = 0; i < a.size(); i++) {
arr[i] = a.get(i);
}
}
public static void sortForObjecttypes(pair[] arr) {
ArrayList<pair> a = new ArrayList<>();
for (pair i : arr) {
a.add(i);
}
Collections.sort(a, new Comparator<pair>() {
@Override
public int compare(pair a, pair b) {
return (int) (a.h - b.h);
}
});
for (int i = 0; i < a.size(); i++) {
arr[i] = a.get(i);
}
}
public static boolean ispalindrome(String s) {
long i = 0;
long j = s.length() - 1;
boolean is = false;
while (i < j) {
if (s.charAt((int) i) == s.charAt((int) j)) {
is = true;
i++;
j--;
} else {
is = false;
return is;
}
}
return is;
}
public static long power(long base, long pow, long mod) {
long result = base;
long temp = 1;
while (pow > 1) {
if (pow % 2 == 0) {
result = ((result % mod) * (result % mod)) % mod;
pow /= 2;
} else {
temp = temp * base;
pow--;
}
}
result = ((result % mod) * (temp % mod));
// System.out.println(result);
return result;
}
public static long sqrt(long n) {
long res = 1;
long l = 1, r = (long) 10e9;
while (l <= r) {
long mid = (l + r) / 2;
if (mid * mid <= n) {
res = mid;
l = mid + 1;
} else
r = mid - 1;
}
return res;
}
public static boolean is[] = new boolean[100001];
public static int a[] = new int[100001];
public static Vector<Integer> seiveOfEratosthenes() {
Vector<Integer> listA = new Vector<>();
for (int i = 2; i * i <= a.length; i++) {
if (a[i] != 1) {
for (long j = i * i; j < a.length; j += i) {
a[(int) j] = 1;
}
}
}
for (int i = 2; i < a.length; i++) {
if (a[i] == 0) {
is[i] = true;
listA.add(i);
}
}
return listA;
}
public static Vector<Integer> ans = seiveOfEratosthenes();
public static long sumOfDigits(long n) {
long ans = 0;
while (n != 0) {
ans += n % 10;
n /= 10;
}
return ans;
}
public static long gcdTotal(long a[]) {
long t = a[0];
for (int i = 1; i < a.length; i++) {
t = gcd(t, a[i]);
}
return t;
}
public static ArrayList<Long> al = new ArrayList<>();
public static void makeArr() {
long t = 1;
while (t <= 10e17) {
al.add(t);
t *= 2;
}
}
public static boolean isBalancedBrackets(String s) {
if (s.length() == 1) {
return false;
}
Stack<Character> sO = new Stack<>();
int id = 0;
while (id < s.length()) {
if (s.charAt(id) == '(') {
sO.add('(');
}
if (s.charAt(id) == ')') {
if (!sO.isEmpty()) {
sO.pop();
} else {
return false;
}
}
id++;
}
if (sO.isEmpty()) {
return true;
}
return false;
}
public static long kadanesAlgo(long a[], int start, int end) {
long maxSoFar = Long.MIN_VALUE;
long maxEndingHere = 0;
for (int i = start; i < end; i++) {
maxEndingHere += a[i];
if (maxSoFar < maxEndingHere) {
maxSoFar = maxEndingHere;
}
if (maxEndingHere < 0) {
maxEndingHere = 0;
}
}
return maxSoFar;
}
public static Vector<Integer> prime = new Vector<>();
public static int components = 0;
public static void search(HashMap<Integer, Integer> hm, int max, int start, int high) {
if (start == 0) {
components++;
return;
}
int t = max;
boolean is = false;
for (int i = start; i < high; i++) {
if (hm.get(t) >= start) {
t--;
is = true;
} else {
// System.out.println(start + " " + high + " " + hm.get(t) + " " + hm.get(max));
is = false;
break;
}
}
// System.out.println(max + " " + is + " " + t);
if (is) {
search(hm, t, hm.get(t), start);
components++;
} else {
// System.out.println(t);
search(hm, max, hm.get(t), high);
}
}
public static void solve(FastReader sc, PrintWriter w, StringBuilder sb) throws Exception {
int n = sc.nextInt();
String s = sc.nextLine();
ArrayList<Long> al = new ArrayList<>();
for (int i = 0; i < n; i++) {
if (s.charAt(i) == ')') {
al.add((long) i);
}
}
// System.out.println("sile: " + al.size());
int not = 0;
int c = 0;
for (int i = 0; not < n - 1; i++) {
if (s.charAt(not) == '(') {
not += 2;
c++;
} else {
if (s.charAt(not + 1) == ')') {
not += 2;
c++;
} else {
int id = (int) upperbound(al, not);
// System.out.println(al.get(id));
if (al.get(id) <= not) {
break;
}
boolean is = false;
for (int j = id; j < al.size(); j++) {
String t = s.substring(not, (int) (al.get(id) + 1));
if (ispalindrome(t)) {
is = true;
c++;
not = (int) (al.get(id) + 1);
break;
}
}
if (!is) {
break;
}
}
}
}
sb.append(c + " " + (n - not) + "\n");
}
public static void main(String[] args) throws Exception {
FastReader sc = new FastReader();
PrintWriter w = new PrintWriter(System.out);
StringBuilder sb = new StringBuilder();
// prime = seiveOfEratosthenes();
long o = sc.nextLong();
// makeArr();
while (o > 0) {
solve(sc, w, sb);
o--;
}
System.out.print(sb.toString());
w.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 11 | 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 | fcf898c3d591b4ffb946f7389adb2271 | 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 BracketSequenceDeletion {
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();
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 11 | 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 | e887a9ca6fbb1e13a0d982b5f5c1b8e7 | 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.Scanner;
public class Solution{
public static String get_ans(int l, String brackets){
int key = 0;
char ch;
int operations = 0;
int rem = l;
int len = 0;
while(key < l){
ch = brackets.charAt(key);
if(key == l - 1)
return "" + operations + " 1";
if(ch == '('){
operations++;
key += 2;
rem -= 2;
}
else{
key++;
len++;
while(key < l){
len++;
if(brackets.charAt(key++) == ')'){
operations++;
rem -= len;
len = 0;
break;
}
}
}
}
return "" + operations + " " + rem;
}
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int test = sc.nextInt();
for(int i = 1; i <= test; i++){
int l = sc.nextInt();
sc.nextLine();
System.out.println(get_ans(l, sc.nextLine()));
}
}
} | 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 11 | 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 | d3e132c0d138e199b6d5d2f37a551d75 | 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 |
/*
_oo0oo_
o8888888o
88" . "88
(| -_- |)
0\ = /0
___/`---'\___
.' \\| |// '.
/ \\||| : |||// \
/ _||||| -:- |||||- \
| | \\\ - /// | |
| \_| ''\---/'' |_/ |
\ .-\__ '-' ___/-. /
___'. .' /--.--\ `. .'___
."" '< `.___\_<|>_/___.' >' "".
| | : `- \`.;`\ _ /`;.`/ - ` : | |
\ \ `_. \_ __\ /__ _/ .-` / /
=====`-.____`.___ \_____/___.-`___.-'=====
`=---='
*/
import java.util.*;
import java.math.*;
import java.io.*;
import java.lang.Math.*;
public class KickStart2020 {
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());
}
float nextFloat() {
return Float.parseFloat(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
static long gcd(long a, long b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
static long lcm(long a, long b) {
return a / gcd(a, b) * b;
}
public static class Pair implements Comparable<Pair> {
public int index;
public int value;
public Pair(int index, int value) {
this.index = index;
this.value = value;
}
@Override
public int compareTo(Pair other) {
// multiplied to -1 as the author need descending sort order
if(other.index < this.index) return 1;
if(other.index > this.index) return -1;
return 0;
}
@Override
public String toString() {
return this.index + " " + value;
}
}
static boolean isPrime(long d) {
if(d == 0) return true;
if (d == 1)
return false;
for (int i = 2; i <= (long) Math.sqrt(d); i++) {
if (d % i == 0)
return false;
}
return true;
}
static int decimalTob(long n, int k , int count) {
long x = n % k;
long y = n / k;
count += x;
if(y > 0) {
count = decimalTob(y, k, count);
}
return count;
}
static long powermod(long x, long y, long mod) {
if(y == 0) return 1;
long value = powermod(x, y / 2, mod);
if(y % 2 == 0) return (value * value) % mod;
return (value * (value * x) % mod) % mod;
}
static long power(long x, long y) {
if(y == 0) return 1;
long value = power(x, y / 2);
if(y % 2 == 0) return (value * value);
return value * value * x;
}
static int bS(int l, int r, int find, int arr[]) {
if(r < l) return l;
int mid = (l + r) / 2;
if(arr[mid] >= find) return bS(l, mid - 1, find, arr);
return bS(mid + 1, r, find, arr);
}
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;
}
return true;
}
static boolean perf(int n) {
int z = (int)Math.sqrt(n);
return z * z == n;
}
public static void main(String[] args) throws Exception {
FastReader sc = new FastReader();
PrintWriter out = new PrintWriter(System.out);
int t = sc.nextInt();
outerloop:
while(t-- > 0) {
int n = sc.nextInt();
String s = sc.next();
TreeSet<Integer> ss = new TreeSet<>();
TreeSet<Integer> ssd = new TreeSet<>();
for(int i = 0; i < n; i++) {
if(s.charAt(i) == '(') ss.add(i);
else ssd.add(i);
}
int remain = n;
int opr = 0;
for(int i = 0; i < n; i++) {
if(i + 1 < n && s.charAt(i) == '(') {
opr++;
i++;
remain -= 2;
}
else {
if(s.charAt(i) == '(') {
if(ss.higher(i) != null) {
opr++;
remain += i;
i = ss.higher(i);
remain -= i + 1;
}
else break;
}
else {
if(ssd.higher(i) != null) {
opr++;
remain += i;
i = ssd.higher(i);
remain -= i + 1;
}
else break;
}
}
}
out.println(opr + " " + remain);
}
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 11 | 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 | 389621c95201cf99b1e34f7d12b1010a | 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 cf1657Ca {
public static void main(String[] args) {
FastReader in = new FastReader();
int t = in.nextInt();
for (int i = 0; i < t; i++) {
int n = in.nextInt();
String s = in.nextLine();
int count = 0;
int l = 0;
while (l + 1 < n) {
if (s.charAt(l)=='(' || (s.charAt(l)==')' && s.charAt(l+1)==')')){
l += 2;
count++;
} else {
int r = l + 1;
while (r < n && s.charAt(r) != ')'){
r++;
}
if (r == n){
break;
}
l = r + 1;
count++;
}
}
System.out.println(count+" "+(n-l));
}
}
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 11 | 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 | df6a7d172ac15bb2a39e8186500c6135 | 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.text.DecimalFormat;
import java.util.*;
public class Main
{
static class Pair
{
int u,d;
public Pair(int u,int d)
{
this.u=u;
this.d=d;
}
public String toString() {
return u+" "+d;
}
}
static final int INF = 1 << 30;
static final long INFL = 1L << 60;
static final long NINF = INFL * -1;
static final long mod = (long) 1e9 + 7;
static final long mod2 = 998244353;
static DecimalFormat df = new DecimalFormat("0.00000000000000");
public static final double PI = 3.141592653589793d, eps = 1e-9;
public static void main(String[] args) throws IOException {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
OutputWriter out = new OutputWriter(outputStream);
TaskC solver = new TaskC();
solver.solve(1, in, out);
out.close();
}
static class TaskC
{
static long[] p;
static long[] h;
static long[] inv;
static long pp=500009;
public static void dp(String s)
{
long power=1;
int n=s.length();
p[0]=1;
for(int i=1;i<=n;i++)
{
p[i]=(p[i-1]*pp)%mod;
}
for(int i=1;i<=n;i++)
{
int ch=s.charAt(i-1)=='('?2:1;
h[i]=(h[i-1]*pp+ch)%mod;
}
for(int i=n;i>=1;--i)
{
int ch=(s.charAt(i-1)=='('?2:1);
inv[i]=(inv[i+1]*pp+ch)%mod;
}
}
static long geths(int l,int r)
{
return (h[r]-h[l-1]*p[r-l+1]+(long)mod*mod)%mod;
}
static long getrhs(int l,int r)
{
return (inv[l]-inv[r+1]*p[r-l+1]+(long)mod*mod)%mod;
}
public static void solve(int testNumber, InputReader in, OutputWriter out)
{
int t1=in.readInt();
while (t1-->0)
{
int n=in.readInt();
char ch[]=in.readString().toCharArray();
String s=new String(ch);
h=new long[n+10];
p=new long[n+10];
inv=new long[n+10];
dp(s);
int cnt=0,rem=0;
int open=0,close=0,flag=1,last=0,i=0;
while(i<n)
{
if(ch[i]=='(')
{
++open;
}
else
{
++close;
}
if(flag==1 && close>open)
{
flag=0;
}
if(close+open>=2 && flag==1)
{
++cnt;
flag=1;
last=i+1;
open=0;
close=0;
++i;
continue;
}
//out.printLine(geths(last+1,i+1)+" "+getrhs(last+1,i+1));
if(close+open>=2 && geths(last+1,i+1)==getrhs(last+1,i+1))
{
++cnt;
flag=1;
last=i+1;
open=0;
close=0;
}
++i;
}
if(last!=n)
{
rem+=n-last;
}
out.printLine(cnt+" "+rem);
Arrays.fill(h,0);
Arrays.fill(inv,0);
Arrays.fill(p,0);
}
}
}
static class InputReader {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
private InputReader.SpaceCharFilter filter;
public InputReader(InputStream stream) {
this.stream = stream;
}
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 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 int[] nextIntArray(int arraySize) {
int[] array = new int[arraySize];
for (int i = 0; i < arraySize; i++) {
array[i] = readInt();
}
return array;
}
private int skip() {
int b;
while ((b = read()) != -1 && isSpaceChar(b)) ;
return b;
}
private String ns() {
int b = skip();
StringBuilder sb = new StringBuilder();
while (!(isSpaceChar(b))) { // when nextLine, (isSpaceChar(b) && b != ' ')
sb.appendCodePoint(b);
b = read();
}
return sb.toString();
}
private char[] ns(int n) {
char[] buf = new char[n];
int b = skip(), p = 0;
while (p < n && !(isSpaceChar(b))) {
buf[p++] = (char) b;
b = read();
}
return n == p ? buf : Arrays.copyOf(buf, p);
}
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 isNewLine(int c) {
return c == '\n';
}
public String nextLine() {
int c = read();
StringBuilder result = new StringBuilder();
do {
result.appendCodePoint(c);
c = read();
} while (!isNewLine(c));
return result.toString();
}
public long nextLong() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
int sign = 1;
if (c == '-') {
sign = -1;
c = read();
}
long result = 0;
do {
if (c < '0' || c > '9') {
throw new InputMismatchException();
}
result *= 10;
result += c & 15;
c = read();
} while (!isSpaceChar(c));
return result * sign;
}
public long[] nextLongArray(int arraySize) {
long array[] = new long[arraySize];
for (int i = 0; i < arraySize; i++) {
array[i] = nextLong();
}
return array;
}
public double nextDouble() {
double ret = 0, div = 1;
byte c = (byte) read();
while (c <= ' ') {
c = (byte) read();
}
boolean neg = (c == '-');
if (neg) {
c = (byte) read();
}
do {
ret = ret * 10 + c - '0';
} while ((c = (byte) read()) >= '0' && c <= '9');
if (c == '.') {
while ((c = (byte) read()) >= '0' && c <= '9') {
ret += (c - '0') / (div *= 10);
}
}
if (neg) {
return -ret;
}
return ret;
}
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;
}
public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
}
public static class CP {
static boolean isPrime(long n) {
if (n <= 1)
return false;
if (n == 2 || n == 3)
return true;
if (n % 2 == 0 || n % 3 == 0)
return false;
for (int i = 5; (long) i * i <= n; i += 6) {
if (n % i == 0 || n % (i + 2) == 0)
return false;
}
return true;
}
public static int log2(int N) {
int result = (int) (Math.log(N) / Math.log(2));
return result;
}
public static long pow(long a, long n, long mod) {
// a %= mod;
long ret = 1;
int x = 63 - Long.numberOfLeadingZeros(n);
for (; x >= 0; x--) {
ret = ret * ret % mod;
if (n << 63 - x < 0)
ret = ret * a % mod;
}
return ret;
}
public static boolean isComposite(long n) {
if (n < 2)
return true;
if (n == 2 || n == 3)
return false;
if (n % 2 == 0 || n % 3 == 0)
return true;
for (long i = 6L; i * i <= n; i += 6)
if (n % (i - 1) == 0 || n % (i + 1) == 0)
return true;
return false;
}
static int ifnotPrime(int[] prime, int x) {
return (prime[x / 64] & (1 << ((x >> 1) & 31)));
}
static int log2(long n) {
return (int) (Math.log10(n) / Math.log10(2));
}
static void makeComposite(int[] prime, int x) {
prime[x / 64] |= (1 << ((x >> 1) & 31));
}
public static String swap(String a, int i, int j) {
char temp;
char[] charArray = a.toCharArray();
temp = charArray[i];
charArray[i] = charArray[j];
charArray[j] = temp;
return String.valueOf(charArray);
}
static void reverse(long arr[]){
int l = 0, r = arr.length-1;
while(l<r){
long temp = arr[l];
arr[l] = arr[r];
arr[r] = temp;
l++;
r--;
}
}
static void reverse(int arr[]){
int l = 0, r = arr.length-1;
while(l<r){
int temp = arr[l];
arr[l] = arr[r];
arr[r] = temp;
l++;
r--;
}
}
public static int[] sieveEratosthenes(int n) {
if (n <= 32) {
int[] primes = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31};
for (int i = 0; i < primes.length; i++) {
if (n < primes[i]) {
return Arrays.copyOf(primes, i);
}
}
return primes;
}
int u = n + 32;
double lu = Math.log(u);
int[] ret = new int[(int) (u / lu + u / lu / lu * 1.5)];
ret[0] = 2;
int pos = 1;
int[] isnp = new int[(n + 1) / 32 / 2 + 1];
int sup = (n + 1) / 32 / 2 + 1;
int[] tprimes = {3, 5, 7, 11, 13, 17, 19, 23, 29, 31};
for (int tp : tprimes) {
ret[pos++] = tp;
int[] ptn = new int[tp];
for (int i = (tp - 3) / 2; i < tp << 5; i += tp)
ptn[i >> 5] |= 1 << (i & 31);
for (int j = 0; j < sup; j += tp) {
for (int i = 0; i < tp && i + j < sup; i++) {
isnp[j + i] |= ptn[i];
}
}
}
// 3,5,7
// 2x+3=n
int[] magic = {0, 1, 23, 2, 29, 24, 19, 3, 30, 27, 25, 11, 20, 8, 4,
13, 31, 22, 28, 18, 26, 10, 7, 12, 21, 17, 9, 6, 16, 5, 15, 14};
int h = n / 2;
for (int i = 0; i < sup; i++) {
for (int j = ~isnp[i]; j != 0; j &= j - 1) {
int pp = i << 5 | magic[(j & -j) * 0x076be629 >>> 27];
int p = 2 * pp + 3;
if (p > n)
break;
ret[pos++] = p;
if ((long) p * p > n)
continue;
for (int q = (p * p - 3) / 2; q <= h; q += p)
isnp[q >> 5] |= 1 << q;
}
}
return Arrays.copyOf(ret, pos);
}
static int digit(long s) {
int brute = 0;
while (s > 0) {
s /= 10;
brute++;
}
return brute;
}
public static int[] primefacs(int n, int[] primes) {
int[] ret = new int[15];
int rp = 0;
for (int p : primes) {
if (p * p > n) break;
int i;
for (i = 0; n % p == 0; n /= p, i++) ;
if (i > 0) ret[rp++] = p;
}
if (n != 1) ret[rp++] = n;
return Arrays.copyOf(ret, rp);
}
static ArrayList<Integer> bitWiseSieve(int n) {
ArrayList<Integer> al = new ArrayList<>();
int prime[] = new int[n / 64 + 1];
for (int i = 3; i * i <= n; i += 2) {
if (ifnotPrime(prime, i) == 0)
for (int j = i * i, k = i << 1;
j < n; j += k)
makeComposite(prime, j);
}
al.add(2);
for (int i = 3; i <= n; i += 2)
if (ifnotPrime(prime, i) == 0)
al.add(i);
return al;
}
public static long[] sort(long arr[]) {
List<Long> list = new ArrayList<>();
for (long n : arr) {
list.add(n);
}
Collections.sort(list);
for (int i = 0; i < arr.length; i++) {
arr[i] = list.get(i);
}
return arr;
}
public static long[] revsort(long[] arr) {
List<Long> list = new ArrayList<>();
for (long n : arr) {
list.add(n);
}
Collections.sort(list, Collections.reverseOrder());
for (int i = 0; i < arr.length; i++) {
arr[i] = list.get(i);
}
return arr;
}
public static int[] revsort(int[] arr) {
List<Integer> list = new ArrayList<>();
for (int n : arr) {
list.add(n);
}
Collections.sort(list, Collections.reverseOrder());
for (int i = 0; i < arr.length; i++) {
arr[i] = list.get(i);
}
return arr;
}
public static ArrayList<Integer> reverse(
ArrayList<Integer> data,
int left, int right)
{
// Reverse the sub-array
while (left < right)
{
int temp = data.get(left);
data.set(left++,
data.get(right));
data.set(right--, temp);
}
// Return the updated array
return data;
}
static ArrayList<Integer> sieve(long size) {
ArrayList<Integer> pr = new ArrayList<Integer>();
boolean prime[] = new boolean[(int) size];
for (int i = 2; i < prime.length; i++) prime[i] = true;
for (int i = 2; i * i < prime.length; i++) {
if (prime[i]) {
for (int j = i * i; j < prime.length; j += i) {
prime[j] = false;
}
}
}
for (int i = 2; i < prime.length; i++) if (prime[i]) pr.add(i);
return pr;
}
static ArrayList<Integer> segmented_sieve(int l, int r, ArrayList<Integer> primes) {
ArrayList<Integer> al = new ArrayList<>();
if (l == 1) ++l;
int max = r - l + 1;
int arr[] = new int[max];
for (int p : primes) {
if (p * p <= r) {
int i = (l / p) * p;
if (i < l) i += p;
for (; i <= r; i += p) {
if (i != p) {
arr[i - l] = 1;
}
}
}
}
for (int i = 0; i < max; ++i) {
if (arr[i] == 0) {
al.add(l + i);
}
}
return al;
}
static boolean isfPrime(long n, int iteration) {
if (n == 0 || n == 1)
return false;
if (n == 2)
return true;
if (n % 2 == 0)
return false;
Random rand = new Random();
for (int i = 0; i < iteration; i++) {
long r = Math.abs(rand.nextLong());
long a = r % (n - 1) + 1;
if (modPow(a, n - 1, n) != 1)
return false;
}
return true;
}
static long modPow(long a, long b, long c) {
long res = 1;
for (int i = 0; i < b; i++) {
res *= a;
res %= c;
}
return res % c;
}
private static long binPower(long a, long l, long mod) {
long res = 0;
while (l > 0) {
if ((l & 1) == 1) {
res = mulmod(res, a, mod);
l >>= 1;
}
a = mulmod(a, a, mod);
}
return res;
}
private static long mulmod(long a, long b, long c) {
long x = 0, y = a % c;
while (b > 0) {
if (b % 2 == 1) {
x = (x + y) % c;
}
y = (y * 2L) % c;
b /= 2;
}
return x % c;
}
static long binary_Expo(long a, long b) {
long res = 1;
while (b != 0) {
if ((b & 1) == 1) {
res *= a;
--b;
}
a *= a;
b /= 2;
}
return res;
}
static void swap(int a, int b) {
int tp = b;
b = a;
a = tp;
}
static long Modular_Expo(long a, long b, long mod) {
long res = 1;
while (b != 0) {
if ((b & 1) == 1) {
res = (res * a) % mod;
--b;
}
a = (a * a) % mod;
b /= 2;
}
return res % mod;
}
static int i_gcd(int a, int b) {
while (true) {
if (b == 0)
return a;
int c = a;
a = b;
b = c % b;
}
}
static long gcd(long a, long b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
static long ceil_div(long a, long b) {
return (a + b - 1) / b;
}
static int getIthBitFromInt(int bits, int i) {
return (bits >> (i - 1)) & 1;
}
private static TreeMap<Long, Long> primeFactorize(long n) {
TreeMap<Long, Long> pf = new TreeMap<>(Collections.reverseOrder());
long cnt = 0;
long total = 1;
for (long i = 2; (long) i * i <= n; ++i) {
if (n % i == 0) {
cnt = 0;
while (n % i == 0) {
++cnt;
n /= i;
}
pf.put(cnt, i);
//total*=(cnt+1);
}
}
if (n > 1) {
pf.put(1L, n);
//total*=2;
}
return pf;
}
//less than or equal
private static int lower_bound(List<Integer> list, int val) {
int ans = -1, lo = 0, hi = list.size() - 1;
while (lo <= hi) {
int mid = (lo + hi) / 2;
if (list.get(mid) <= val) {
ans = mid;
lo = mid + 1;
} else {
hi = mid - 1;
}
}
return ans;
}
private static int lower_bound(int[] arr, int val) {
int ans = -1, lo = 0, hi = arr.length - 1;
while (lo <= hi) {
int mid = (lo + hi) / 2;
if (arr[mid] <= val) {
ans = mid;
lo = mid + 1;
} else {
hi = mid - 1;
}
}
return ans;
}
private static int lower_bound(long[] arr, long val) {
int ans = -1, lo = 0, hi = arr.length - 1;
while (lo <= hi) {
int mid = (lo + hi) / 2;
if (arr[mid] <= val) {
ans = mid;
lo = mid + 1;
} else {
hi = mid - 1;
}
}
return ans;
}
// greater than or equal
private static int upper_bound(List<Integer> list, int val) {
int ans = list.size(), lo = 0, hi = ans - 1;
while (lo <= hi) {
int mid = (lo + hi) / 2;
if (list.get(mid) >= val) {
ans = mid;
hi = mid - 1;
} else {
lo = mid + 1;
}
}
return ans;
}
private static int upper_bound(int[] arr, int val) {
int ans = arr.length, lo = 0, hi = ans - 1;
while (lo <= hi) {
int mid = (lo + hi) / 2;
if (arr[mid] >= val) {
ans = mid;
hi = mid - 1;
} else {
lo = mid + 1;
}
}
return ans;
}
private static int upper_bound(long[] arr, long val) {
int ans = arr.length, lo = 0, hi = ans - 1;
while (lo <= hi) {
int mid = (lo + hi) / 2;
if (arr[mid] >= val) {
ans = mid;
hi = mid - 1;
} else {
lo = mid + 1;
}
}
return ans;
}
// ==================== LIS & LNDS ================================
private static int[] LIS(long arr[], int n) {
List<Long> list = new ArrayList<>();
int[] cnt=new int[n];
for (int i = 0; i < n; i++) {
int idx = find1(list, arr[i]);
if (idx < list.size())
list.set(idx, arr[i]);
else
list.add(arr[i]);
cnt[i]=list.size();
}
return cnt;
}
private static int find1(List<Long> list, long val) {
int ret = list.size(), i = 0, j = list.size() - 1;
while (i <= j) {
int mid = (i + j) / 2;
if (list.get(mid)>=val) {
ret = mid;
j = mid - 1;
} else {
i = mid + 1;
}
}
return ret;
}
private static int LNDS(int[] arr, int n) {
List<Integer> list = new ArrayList<>();
for (int i = 0; i < n; i++) {
int idx = find2(list, arr[i]);
if (idx < list.size())
list.set(idx, arr[i]);
else
list.add(arr[i]);
}
return list.size();
}
private static int find2(List<Integer> list, int val) {
int ret = list.size(), i = 0, j = list.size() - 1;
while (i <= j) {
int mid = (i + j) / 2;
if (list.get(mid) <= val) {
i = mid + 1;
} else {
ret = mid;
j = mid - 1;
}
}
return ret;
}
private static long nCr(long n, long r,long mod) {
if (n - r > r)
r = n - r;
long ans = 1L;
for (long i = r + 1; i <= n; i++)
ans = (ans%mod*i%mod)%mod;
for (long i = 2; i <= n - r; i++)
ans /= i;
return ans%mod;
}
private static boolean isPalindrome(String str) {
int i = 0, j = str.length() - 1;
while (i < j)
if (str.charAt(i++) != str.charAt(j--))
return false;
return true;
}
private static String reverseString(String str) {
StringBuilder sb = new StringBuilder(str);
return sb.reverse().toString();
}
private static String sortString(String str) {
int[] arr = new int[256];
for (char ch : str.toCharArray())
arr[ch]++;
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 256; i++)
while (arr[i]-- > 0)
sb.append((char) i);
return sb.toString();
}
static boolean isSquarefactor(int x, int factor, int target) {
int s = (int) Math.round(Math.sqrt(x));
return factor * s * s == target;
}
static boolean isSquare(int x) {
int s = (int) Math.round(Math.sqrt(x));
return x * x == s;
}
static int bs(ArrayList<Integer> al, int val) {
int l = 0, h = al.size() - 1, mid = 0, ans = -1;
while (l <= h) {
mid = (l + h) >> 1;
if (al.get(mid) == val) {
return mid;
} else if (al.get(mid) > val) {
h = mid - 1;
} else {
l = mid + 1;
}
}
return ans;
}
static void sort(int a[]) // heap sort
{
PriorityQueue<Integer> q = new PriorityQueue<>();
for (int i = 0; i < a.length; i++)
q.add(a[i]);
for (int i = 0; i < a.length; i++)
a[i] = q.poll();
}
static void shuffle(int[] in) {
for (int i = 0; i < in.length; i++) {
int idx = (int) (Math.random() * in.length);
fast_swap(in, idx, i);
}
}
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[] computeLps(String pat) {
int len = 0, i = 1, m = pat.length();
int lps[] = new int[m];
lps[0] = 0;
while (i < m) {
if (pat.charAt(i) == pat.charAt(len)) {
++len;
lps[i] = len;
++i;
} else {
if (len != 0) {
len = lps[len - 1];
} else {
lps[i] = len;
++i;
}
}
}
return lps;
}
static ArrayList<Integer> kmp(String s, String pat) {
ArrayList<Integer> al = new ArrayList<>();
int n = s.length(), m = pat.length();
int lps[] = computeLps(pat);
int i = 0, j = 0;
while (i < n) {
if (s.charAt(i) == pat.charAt(j)) {
i++;
j++;
if (j == m) {
al.add(i - j);
j = lps[j - 1];
}
} else {
if (j != 0) {
j = lps[j - 1];
} else {
i++;
}
}
}
return al;
}
static void reverse_ruffle_sort(int a[]) {
shuffle(a);
Arrays.sort(a);
for (int l = 0, r = a.length - 1; l < r; ++l, --r)
fast_swap(a, l, r);
}
static void ruffle_sort(int a[]) {
shuffle(a);
Arrays.sort(a);
}
static int getMax(int arr[], int n) {
int mx = arr[0];
for (int i = 1; i < n; i++)
if (arr[i] > mx)
mx = arr[i];
return mx;
}
static ArrayList<Long> primeFactors(long n) {
ArrayList<Long> al = new ArrayList<>();
al.add(1L);
while (n % 2 == 0) {
if (!al.contains(2L)) {
al.add(2L);
}
n /= 2L;
}
for (long i = 3; (long) i * i <= n; i += 2) {
while ((n % i == 0)) {
if (!al.contains((long) i)) {
al.add((long) i);
}
n /= i;
}
}
if (n > 2) {
if (!al.contains(n)) {
al.add(n);
}
}
return al;
}
public static long totFactors(long n) {
long cnt = 0, tot = 1;
while (n % 2 == 0) {
n /= 2;
++cnt;
}
tot *= (cnt + 1);
for (int i = 3; i <= Math.sqrt(n); i += 2) {
cnt = 0;
while (n % i == 0) {
n /= i;
++cnt;
}
tot *= (cnt + 1);
}
if (n > 2) {
tot *= 2;
}
return tot;
}
static int[] z_function(String s) {
int n = s.length(), z[] = new int[n];
for (int i = 1, l = 0, r = 0; i < n; ++i) {
if (i <= r)
z[i] = Math.min(z[i - l], r - i + 1);
while (i + z[i] < n && s.charAt(z[i]) == s.charAt(i + z[i]))
++z[i];
if (i + z[i] - 1 > r) {
l = i;
r = i + z[i] - 1;
}
}
return z;
}
static void fast_swap(int[] a, int idx1, int idx2) {
if (a[idx1] == a[idx2])
return;
a[idx1] ^= a[idx2];
a[idx2] ^= a[idx1];
a[idx1] ^= a[idx2];
}
static void fast_swap(long[] a, int idx1, int idx2) {
if (a[idx1] == a[idx2])
return;
a[idx1] ^= a[idx2];
a[idx2] ^= a[idx1];
a[idx1] ^= a[idx2];
}
public static void fast_sort(long[] array) {
ArrayList<Long> copy = new ArrayList<>();
for (long i : array)
copy.add(i);
Collections.sort(copy);
for (int i = 0; i < array.length; i++)
array[i] = copy.get(i);
}
static int factorsCount(int n) {
boolean hash[] = new boolean[n + 1];
Arrays.fill(hash, true);
for (int p = 2; p * p < n; p++)
if (hash[p] == true)
for (int i = p * 2; i < n; i += p)
hash[i] = false;
int total = 1;
for (int p = 2; p <= n; p++) {
if (hash[p]) {
int count = 0;
if (n % p == 0) {
while (n % p == 0) {
n = n / p;
count++;
}
total = total * (count + 1);
}
}
}
return total;
}
static long binomialCoeff(long n, long k) {
long res = 1;
if (k > n - k)
k = n - k;
for (int i = 0; i < k; ++i) {
res = (res * (n - i));
res /= (i + 1);
}
return res;
}
static long nck(long fact[], long inv[], long n, long k) {
if (k > n) return 0;
long res = fact[(int) n]%mod;
res = (int) ((res%mod* inv[(int) k]%mod))%mod;
res = (int) ((res%mod*inv[(int) (n - k)]%mod))%mod;
return res % mod;
}
public static long fact(long x) {
long fact = 1;
for (int i = 2; i <= x; ++i) {
fact = fact * i;
}
return fact;
}
public static ArrayList<Long> getFact(long x) {
ArrayList<Long> facts = new ArrayList<>();
for (long i = 2; i * i <= x; ++i) {
if (x % i == 0) {
facts.add(i);
if (i != x / i) {
facts.add(x / i);
}
}
}
return facts;
}
static void matrix_ex(long n, long[][] A, long[][] I) {
while (n > 0) {
if (n % 2 == 0) {
Multiply(A, A);
n /= 2;
} else {
Multiply(I, A);
n--;
}
}
}
static void Multiply(long[][] A, long[][] B) {
int n = A.length, m = A[0].length, p = B[0].length;
long[][] C = new long[n][p];
for (int i = 0; i < n; i++) {
for (int j = 0; j < p; j++) {
for (int k = 0; k < m; k++) {
C[i][j] += ((A[i][k] % mod) * (B[k][j] % mod)) % mod;
C[i][j] = C[i][j] % mod;
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < p; j++) {
A[i][j] = C[i][j];
}
}
}
public static HashMap<Character, Integer> sortMapDesc(HashMap<Character, Integer> map) {
List<Map.Entry<Character, Integer>> list = new LinkedList<>(map.entrySet());
Collections.sort(list, (o1, o2) -> o2.getValue() - o1.getValue());
HashMap<Character, Integer> temp = new LinkedHashMap<>();
for (Map.Entry<Character, Integer> i : list) {
temp.put(i.getKey(), i.getValue());
}
return temp;
}
public static HashMap<Integer, Integer> sortMapAsc(HashMap<Integer, Integer> map) {
List<Map.Entry<Integer, Integer>> list = new LinkedList<>(map.entrySet());
Collections.sort(list, (o1, o2) -> o1.getValue() - o2.getValue());
HashMap<Integer, Integer> temp = new LinkedHashMap<>();
for (Map.Entry<Integer, Integer> i : list) {
temp.put(i.getKey(), i.getValue());
}
return temp;
}
public static long lcm(long l, long l2) {
long val = gcd(l, l2);
return (l * l2) / val;
}
public static int isSubsequence(String s, String t) {
int n = s.length();
int m = t.length();
if (m > n) {
return Integer.MAX_VALUE;
}
int i = 0, j = 0, skip = 0;
while (i < n && j < m) {
if (s.charAt(i) == t.charAt(j)) {
--skip;
++j;
}
++skip;
++i;
}
while (i < n) {
++i;
++skip;
}
if (j != m) {
skip = Integer.MAX_VALUE;
}
return skip;
}
public static long[][] combination(int l, int r) {
long[][] pascal = new long[l + 1][r + 1];
pascal[0][0] = 1;
for (int i = 1; i <= l; ++i) {
pascal[i][0] = 1;
for (int j = 1; j <= r; ++j) {
pascal[i][j] = pascal[i - 1][j - 1] + pascal[i - 1][j];
}
}
return pascal;
}
public static long gcd(long... array) {
long ret = array[0];
for (int i = 1; i < array.length; ++i) ret = gcd(ret, array[i]);
return ret;
}
public static long lcm(int... array) {
long ret = array[0];
for (int i = 1; i < array.length; ++i) ret = lcm(ret, array[i]);
return ret;
}
public static int min(int a, int b) {
return a < b ? a : b;
}
public static int min(int... array) {
int ret = array[0];
for (int i = 1; i < array.length; ++i) ret = min(ret, array[i]);
return ret;
}
public static long min(long a, long b) {
return a < b ? a : b;
}
public static long min(long... array) {
long ret = array[0];
for (int i = 1; i < array.length; ++i) ret = min(ret, array[i]);
return ret;
}
public static int max(int a, int b) {
return a > b ? a : b;
}
public static int max(int... array) {
int ret = array[0];
for (int i = 1; i < array.length; ++i) ret = max(ret, array[i]);
return ret;
}
public static long max(long a, long b) {
return a > b ? a : b;
}
public static long max(long... array) {
long ret = array[0];
for (int i = 1; i < array.length; ++i) ret = max(ret, array[i]);
return ret;
}
public static long sum(int... array) {
long ret = 0;
for (int i : array) ret += i;
return ret;
}
public static long sum(long... array) {
long ret = 0;
for (long i : array) ret += i;
return ret;
}
public static long[] facts(int n)
{
long[] fact=new long[1005];
fact[0]=1;
fact[1]=1;
for(int i=2;i<n;i++)
{
fact[i]=(long)(i*fact[i-1])%mod;
}
return fact;
}
public static long[] inv(long[] fact,int n)
{
long[] inv=new long[n];
inv[n-1]= CP.Modular_Expo(fact[n-1],mod-2,mod)%mod;
for(int i=n-2;i>=0;--i)
{
inv[i]=(inv[i+1]*(i+1))%mod;
}
return inv;
}
public static int modinv(long x, long mod) {
return (int) (CP.Modular_Expo(x, mod - 2, mod) % mod);
}
public static int lcs(String s, String t) {
int n = s.length(), m = t.length();
int dp[][] = new int[n + 1][m + 1];
for (int i = 0; i <= n; ++i) {
for (int j = 0; j <= m; ++j) {
if (i == 0 || j == 0) {
dp[i][j] = 0;
} else if (s.charAt(i - 1) == t.charAt(j - 1)) {
dp[i][j] = dp[i - 1][j - 1] + 1;
} else {
dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
}
}
}
return dp[n][m];
}
}
static class OutputWriter {
private final PrintWriter writer;
public OutputWriter(OutputStream outputStream) {
writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
}
public OutputWriter(Writer writer) {
this.writer = new PrintWriter(writer);
}
public void print(int[] array) {
for (int i = 0; i < array.length; i++) {
if (i != 0) {
writer.print(' ');
}
writer.print(array[i]);
}
}
public void printLine(int[] array) {
print(array);
writer.println();
}
public void close() {
writer.close();
}
public void printLine(long i) {
writer.println(i);
}
public void printLine(int i) {
writer.println(i);
}
public void printLine(char c) {
writer.println(c);
}
public void print(Object... objects) {
for (int i = 0; i < objects.length; i++) {
if (i != 0) {
writer.print(' ');
}
writer.print(objects[i]);
}
}
public void printLine(Object... objects) {
print(objects);
writer.println();
}
void flush() {
writer.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 11 | 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 | d50ab4c6fb2dab0f33a964698334019f | 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 | /**
* 03/22/22 morning
* https://codeforces.com/contest/1657/problem/C
*/
// package codeforce.ecf.r125;
import java.util.*;
import java.io.*;
public class C {
static PrintWriter pw;
void solve(int n, String s) {
int i, remove = 0;
for (i = 0; i + 1 < n; ) {
char c = s.charAt(i);
if (c == '(') {
remove++;
i += 2;
} else {
int preI = i;
i++;
while (i < n && s.charAt(i) == '(') i++;
if (i == n) {
i = preI;
break;
}
i++;
remove++;
}
}
pr(remove + " " + (n - i));
}
// TLE
void solve1(int n, String s) {
// test(n, s);
int i, remove = 0;
String pre = "";
int preI = -1;
for (i = 0; i < n; i++) {
char c = s.charAt(i);
pre += c;
if (pre.length() >= 2) {
if (isPalindrome(pre) || (c == ')' && validParentheses(pre))) {
remove++;
pre = "";
preI = i;
}
}
}
// tr(s, preI, i, "rest", s.substring(preI + 1));
pr(remove + " " + (n - preI - 1));
}
void test(int n, String s) {
// tr(validParentheses("(())()"), validParentheses("()"), validParentheses("(()(()))"));
// tr(validParentheses(")("), validParentheses("(()"), validParentheses("(()))("));
int cnt = 0;
while (true) {
String pre = "";
boolean find = false;
int i;
for (i = 0; i < s.length(); i++) {
pre += s.charAt(i);
if (isGood(pre)) {
find = true;
break;
}
}
if (!find) break;
s = s.substring(i + 1);
cnt++;
}
tr("test", s, cnt + " " + s.length());
}
boolean isGood(String s) {
return validParentheses(s) || (s.length() >= 2 && isPalindrome(s));
}
boolean isPalindrome(String s) {
int n = s.length(), i = 0, j = n - 1;
while (i < j) {
if (s.charAt(i++) != s.charAt(j--)) return false;
}
return true;
}
boolean validParentheses(String s) {
Stack<Character> st = new Stack<>();
Map<Character, Character> m = Map.of('(', ')', '{', '}', '[', ']');
int n = s.length();
for (int i = 0; i < n; i++) {
char c = s.charAt(i);
if (m.containsKey(c)) {
st.push(c);
} else {
if (st.size() == 0) return false;
char preL = st.pop();
if (m.get(preL) != c) {
return false;
}
}
}
return st.size() == 0;
}
boolean validParentheses2(String s) {
int left = 0, n = s.length();
for (int i = 0; i < n; i++) {
char c = s.charAt(i);
if (c == '(') {
left++;
} else {
if (left > 0) {
left--;
} else {
return false;
}
}
}
return left == 0;
}
private void run() {
// read_write_file(); // comment this before submission
FastScanner fs = new FastScanner();
int t = fs.nextInt();
while (t-- > 0) {
int n = fs.nextInt();
String s = fs.next();
solve(n, s);
}
}
private final String INPUT = "input.txt";
private final String OUTPUT = "output.txt";
void read_write_file() {
FileInputStream instream = null;
PrintStream outstream = null;
try {
instream = new FileInputStream(INPUT);
outstream = new PrintStream(new FileOutputStream(OUTPUT));
System.setIn(instream);
System.setOut(outstream);
} catch (Exception e) {
}
}
public static void main(String[] args) {
pw = new PrintWriter(System.out);
new C().run();
pw.close();
}
<T> void pr(T t) {
pw.println(t);
}
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());
}
double nextDouble() {
return Double.parseDouble(next());
}
}
void tr(Object... o) {
pw.println(Arrays.deepToString(o));
}
} | 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 11 | 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 | e999e56073d7c97ae66064c390928d95 | 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 Test
{
final static FastReader fr = new FastReader();
final static PrintWriter out = new PrintWriter(System.out) ;
static long mod = (long)1e9 + 7 ;
static boolean[][] dp;
static void solve()
{
int n = fr.nextInt();
String s = fr.next() ;
long ans =0, removed = 0 ;
int i = 0;
while (true)
{
if (i < n-1)
{
if (s.charAt(i) == s.charAt(i+1)) {
ans++ ;
removed += 2 ;
i += 2 ;
}
else if (s.charAt(i) == '(' && s.charAt(i+1) == ')') {
ans++ ;
removed += 2 ;
i += 2 ;
}
else {
int j = i+1 ;
while (j < s.length() && s.charAt(j) != s.charAt(i)){
j++ ;
}
if (j != s.length()){
ans++ ;
removed += (j - i + 1) ;
i = j+1 ;
} else break;
}
} else break;
}
out.println(ans + " " + (n - removed));
}
public static void main(String[] args)
{
int testcases = fr.nextInt() ;
while (testcases-- > 0)
{
solve() ;
}
out.close() ;
}
static long getMax(long ... a)
{
long max = Long.MIN_VALUE ;
for (long x : a) max = Math.max(x, max) ;
return max ;
}
static long getMin(long ... a)
{
long max = Long.MAX_VALUE ;
for (long x : a) max = Math.min(x, max) ;
return max ;
}
static long fastPower(double a, long b)
{
double ans = 1 ;
while (b > 0)
{
if ((b & 1) != 0) ans *= a ;
a *= a ;
b >>= 1 ;
}
return (long)(ans + 0.5) ;
}
static long fastPower(long a, long b, long mod)
{
long ans = 1 ;
while (b > 0)
{
if ((b&1) != 0) ans = (ans%mod * a%mod) %mod;
b >>= 1 ;
a = (a%mod * a%mod)%mod ;
}
return ans ;
}
static int lower_bound(List<Integer> arr, int key)
{
int pos = Collections.binarySearch(arr, key) ;
if (pos < 0)
{
pos = - (pos + 1) ;
}
return pos ;
}
static int upper_bound(List<Integer> arr, int key)
{
int pos = Collections.binarySearch(arr, key);
pos++ ;
if (pos < 0)
{
pos = -(pos) ;
}
return pos ;
}
static int upper_bound(int arr[], int key)
{
int start = 0 , end = arr.length - 1 ;
int ans = -1 ;
while (start <= end)
{
int mid = start + ((end - start) >> 1) ;
if (arr[mid] == key) ans = mid ;
if (arr[mid] <= key) start = mid + 1 ;
else end = mid-1 ;
}
return ans ;
}
static int lower_bound(int arr[], int key)
{
int start = 0 , end = arr.length -1;
int ans = -1 ;
while (start <= end)
{
int mid = start + ((end - start )>>1) ;
if (arr[mid] == key) {
ans = mid ;
}
if (arr[mid] >= key){
end = mid - 1 ;
}
else start = mid + 1 ;
}
return ans ;
}
static class Pair{
long x;
long y ;
int z ;
Pair(long x, long y, int z){
this.x = x ;
this.y= y ;
this.z = z ;
}
}
static long gcd(long a, long b)
{
if (b == 0) return a ;
return gcd(b, a%b) ;
}
static long lcm(long a, long b)
{
long lcm = a/gcd(a, b)*b ;
return lcm ;
}
static List<Long> seive(int n)
{
// all are false by default
// false -> prime, true -> composite
int[] nums = new int[n+1] ;
for (int i = 2 ; i <= Math.sqrt(n); i++)
{
if (nums[i] == 0)
{
for (int j = i*i ; j <= n ; j += i)
{
nums[j] = 1 ;
}
}
}
long[] freq = new long[1000001] ;
freq[2] = 1 ;
for (int i = 2 ; i <= n ; i++)
{
if (nums[i] == 0) freq[i] = freq[i-1]+1 ;
else freq[i] = freq[i-1] ;
}
ArrayList<Long>primes = new ArrayList<>() ;
for (int i = 2 ; i <=n ; i++)
{
if (nums[i] == 0) primes.add(i* 1L) ;
}
return primes ;
}
static boolean isVowel(char ch)
{
return ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u';
}
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 11 | 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 | 4619bd6812487d2fe66d05c0e8f6300a | 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 cf1657C {
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 i = 0;
int j = 0;
int cnt = 0;
if(n == 1){
System.out.println(0 + " " + 1);
continue;
}
while(j<n){
if(s.charAt(j) == '('){
j+=2;
i = j;
}
else{
j++;
while(j<n && s.charAt(j)!=')') j++;
if(j == n) break;
else{
i = j+1;
}
j++;
}
cnt++;
if(j == n-1) break;
}
if(i>=n){
System.out.println(cnt + " " + 0);
}
else{
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 11 | 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 | 49b4d54b79058dc0fd4ebaa832b91a59 | 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.Scanner;
public class BracketSequenceDeletion {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int t=sc.nextInt();
while(t-->0){
int n=sc.nextInt();
String str=sc.next();
StringBuilder str1=new StringBuilder();
StringBuilder str2=new StringBuilder();
String str3=Character.toString(str.charAt(0));
str1.append(str3);
str2.append(str3);
int cnt=0;
int last=0;
for(int i=1;i<n;i++){
String str4=Character.toString(str.charAt(i));
int len1=str1.length();
if(len1>0&&str4.charAt(0)==')'&&str1.charAt(len1-1)=='('){
str1.delete(len1-1,len1);
if(str1.length()==0){
cnt++;
last=i+1;
str2.delete(0,str2.length());
continue;
}
}else{
str1.append(str4);
}
str2.append(str4);
int len2=str2.length();
int low=0;
int high=len2-1;
int num=len2/2+len2%2;
while(high>=low){
if(str2.charAt(low)!=str2.charAt(high)) break;
low++;
high--;
}
if(low==num&&len2>=2){
cnt++;
last=i+1;
str2.delete(0,str2.length());
str1.delete(0,str1.length());
continue;
}
}
System.out.println(cnt+" "+(n-last));
}
sc.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 11 | 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 | 4dfd3902c902783833dd869969ad1305 | 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.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();
String str=sc.next();
StringBuilder str1=new StringBuilder();
StringBuilder str2=new StringBuilder();
String str3=Character.toString(str.charAt(0));
str1.append(str3);
str2.append(str3);
int cnt=0;
int last=0;
for(int i=1;i<n;i++){
String str4=Character.toString(str.charAt(i));
int len1=str1.length();
if(len1>0&&str4.charAt(0)==')'&&str1.charAt(len1-1)=='('){
str1.delete(len1-1,len1);
if(str1.length()==0){
cnt++;
last=i+1;
str2.delete(0,str2.length());
continue;
}
}else{
str1.append(str4);
}
str2.append(str4);
int len2=str2.length();
int low=0;
int high=len2-1;
int num=len2/2+len2%2;
while(high>=low){
if(str2.charAt(low)!=str2.charAt(high)) break;
low++;
high--;
}
if(low==num&&len2>=2){
cnt++;
last=i+1;
str2.delete(0,str2.length());
str1.delete(0,str1.length());
continue;
}
}
System.out.println(cnt+" "+(n-last));
}
sc.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 11 | 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 | 73a79bc8c38546ffcc2dc5fa29662997 | 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 Kattio io;
static long mod = 998244353, inv2 = 499122177;
static {
io = new Kattio();
}
public static void main(String[] args) {
int t = io.nextInt();
for (int i = 0; i < t; i++) {
solve();
}
io.close();
}
private static void solve() {
int n = io.nextInt();
String str = io.next();
char [] arr= str.toCharArray();
int l = 0;
int cnt = 0;
while (l + 1 < n) {
if (arr[l] == '(' || (arr[l] == ')' && arr[l + 1] == ')')) {
l += 2;
} else {
int r = l + 1;
while (r < n && arr[r] != ')') {
++r;
}
if (r == n) {
break;
}
l = r + 1;
}
++cnt;
}
io.println(cnt + " " + (n-l));
}
static class pair implements Comparable<pair> {
private final int x;
private final int y;
int id;
public pair(final int x, final int y) {
this.x = x;
this.y = y;
}
@Override
public String toString() {
return "pair{" +
"x=" + x +
", y=" + y +
'}';
}
@Override
public boolean equals(final Object o) {
if (this == o) {
return true;
}
if (!(o instanceof pair)) {
return false;
}
final pair pair = (pair) o;
if (x != pair.x) {
return false;
}
if (y != pair.y) {
return false;
}
return true;
}
@Override
public int hashCode() {
int result = x;
result = (int) (31 * result + y);
return result;
}
@Override
public int compareTo(pair pair) {
return Integer.compare(pair.x, this.x);
}
}
static class Kattio extends PrintWriter {
private BufferedReader r;
private StringTokenizer st;
// standard input
public Kattio() {
this(System.in, System.out);
}
public Kattio(InputStream i, OutputStream o) {
super(o);
r = new BufferedReader(new InputStreamReader(i));
}
// USACO-style file input
public Kattio(String problemName) throws IOException {
super(new FileWriter(problemName + ".out"));
r = new BufferedReader(new FileReader(problemName + ".in"));
}
// returns null if no more input
public String next() {
try {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(r.readLine());
return st.nextToken();
} catch (Exception e) {}
return null;
}
public int nextInt() {
return Integer.parseInt(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
public 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 11 | 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 | edece68804de60a10829a7b67384b2d6 | 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.BufferedWriter;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Writer;
import java.util.Arrays;
public class Test {
private static Reader reader;
private static OutputWriter writer;
private static void solve() throws IOException {
int t = reader.nextInt();
while (t-- > 0) {
int n = reader.nextInt();
String s = reader.next();
int count = 0, ind = 0;
for (int i = 0; i < n - 1;) {
if (i < n && s.charAt(i) == '(') {
i += 2;
count++;
ind = i;
} else {
i++;
while (i < n && s.charAt(i) == '(') {
i++;
}
if (i < n && s.charAt(i) == ')') {
i++;
count++;
ind = i;
}
}
}
writer.println(count + " " + (n - ind));
}
}
static class Element implements Comparable<Element> {
int value;
int freq;
Element(int value, int freq) {
this.value = value;
this.freq = freq;
}
public int compareTo(Element e) {
if (this.freq > e.freq) {
return 1;
}
if (this.freq == e.freq) {
return 0;
}
return -1;
}
}
public static void main(String[] args) throws Exception {
// console input output
reader = new Reader();
writer = new OutputWriter();
// File input output
// reader = new Reader("input.txt");
// writer=new OutputWriter("output.txt");
solve();
reader.close();
writer.close();
}
private static long gcd(long a, long b) {
if (b == 0 || a == b)
return a;
if (a == 1 || b == 1)
return 1;
return gcd(b, a % b);
}
private static long gcd(long... values) {
long ans = gcd(values[0], values[1]);
for (long value : values) {
ans = gcd(ans, value);
}
return ans;
}
private static long min(long... values) {
long min = values[0];
for (long value : values) {
if (min < value) {
min = value;
}
}
return min;
}
private static long max(long... values) {
long max = values[0];
for (long value : values) {
if (max < value) {
max = value;
}
}
return max;
}
private static long powerMod(long num, long pow, long mod) {
if (pow == 0 || num == 1)
return 1;
if (num == 0 || pow == 1)
return num;
long ans = powerMod(num, pow / 2, mod) % mod;
ans = (ans * ans) % mod;
if (pow % 2 != 0) {
ans = (ans * num) % mod;
}
return ans;
}
private static boolean[] SieveOfEratosthenes() {
int n = (int) 1e7 + 7;
boolean[] ans = new boolean[n];
Arrays.fill(ans, true);
ans[0] = false;
ans[1] = false;
for (int i = 2; i < n; i++) {
if (ans[i]) {
for (int j = i * i; j < n; j = j + i) {
ans[j] = false;
}
}
}
return ans;
}
static class Reader {
final private int BUFFER_SIZE = 1 << 16;
private DataInputStream dataInputStream;
private int bufferPointer, bytesRead;
private byte[] buffer;
public Reader() {
this.dataInputStream = new DataInputStream(System.in);
this.buffer = new byte[BUFFER_SIZE];
this.bufferPointer = 0;
this.bytesRead = 0;
}
public Reader(String fileName) throws FileNotFoundException {
this.dataInputStream = new DataInputStream(new FileInputStream(fileName));
this.buffer = new byte[BUFFER_SIZE];
this.bufferPointer = 0;
this.bytesRead = 0;
}
public String next() throws IOException {
int c;
do {
c = readByte();
} while (c <= ' ');
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = readByte();
} while (c > ' ');
return res.toString();
}
public String nextLine(int n) throws IOException {
byte[] arr = new byte[n + 1];
int count = 0;
byte b;
while ((b = readByte()) != -1) {
if (b == '\n') {
if (count != 0) {
break;
} else {
continue;
}
}
arr[count++] = b;
}
return new String(arr, 0, count);
}
public String nextString(int n) throws IOException {
byte[] arr = new byte[n + 10];
int count = 0;
byte b;
while ((b = readByte()) != -1) {
if (b == ' ' || b == '\n') {
if (count != 0) {
break;
} else {
continue;
}
}
arr[count++] = b;
}
return new String(arr, 0, count);
}
// TODO: char is of 2 bytes, used only 1, correct it.
public char nextChar() throws IOException {
byte b = readByte();
while (b == ' ') {
b = readByte();
}
return (char) b;
}
public int nextInt() throws IOException {
int res = 0;
byte b = readByte();
while (b <= ' ') {
b = readByte();
}
boolean negative = (b == '-');
if (negative) {
b = readByte();
}
do {
res = res * 10 + (b - '0');
} while ((b = readByte()) >= '0' && b <= '9');
if (negative) {
res *= -1;
}
return res;
}
public long nextLong() throws IOException {
long res = 0;
byte b = readByte();
while (b <= ' ') {
b = readByte();
}
boolean negative = (b == '-');
if (negative) {
b = readByte();
}
do {
res = res * 10 + (b - '0');
} while ((b = readByte()) >= '0' && b <= '9');
if (negative) {
res *= -1;
}
return res;
}
public float nextFloat() throws IOException {
float res = 0, div = 1;
byte b = readByte();
while (b <= ' ') {
b = readByte();
}
boolean negative = (b == '-');
if (negative) {
b = readByte();
}
do {
res = res * 10 + (b - '0');
} while ((b = readByte()) >= '0' && b <= '9');
if (b == '.') {
while ((b = readByte()) >= '0' && b <= '9') {
res += (b - '0') / (div *= 10);
}
}
if (negative) {
res *= -1;
}
return res;
}
public double nextDouble() throws IOException {
double res = 0, div = 1;
byte b = readByte();
while (b <= ' ') {
b = readByte();
}
boolean negative = (b == '-');
if (negative) {
b = readByte();
}
do {
res = res * 10 + (b - '0');
} while ((b = readByte()) >= '0' && b <= '9');
if (b == '.') {
while ((b = readByte()) >= '0' && b <= '9') {
res += (b - '0') / (div *= 10);
}
}
if (negative) {
res *= -1;
}
return res;
}
private void fillBuffer() throws IOException {
bytesRead = dataInputStream.read(buffer, bufferPointer = 0, BUFFER_SIZE);
if (bytesRead == -1) {
buffer[0] = -1;
}
}
private byte readByte() throws IOException {
if (bufferPointer == bytesRead) {
fillBuffer();
}
return buffer[bufferPointer++];
}
public void close() throws IOException {
if (dataInputStream == null) {
return;
}
dataInputStream.close();
}
}
static class OutputWriter {
private final PrintWriter printWriter;
public OutputWriter() {
printWriter = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
}
public OutputWriter(String fileName) throws FileNotFoundException {
printWriter = new PrintWriter(
new BufferedWriter(
new OutputStreamWriter(
new FileOutputStream(fileName))));
}
public OutputWriter(OutputStream outputStream) {
printWriter = new PrintWriter(
new BufferedWriter(new OutputStreamWriter(outputStream)));
}
public OutputWriter(Writer writer) {
this.printWriter = new PrintWriter(writer);
}
// TODO: do something foe this flush, it will make code slower
public void print(Object... objects) {
for (int i = 0; i < objects.length; i++) {
if (i != 0)
printWriter.print(' ');
printWriter.print(objects[i]);
}
// printWriter.flush();
}
public void println(Object... objects) {
print(objects);
printWriter.println();
// printWriter.flush();
}
public void close() {
printWriter.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 11 | 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 | b707594262ccb409da9cb1cf1712efe7 | 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.BufferedWriter;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Writer;
import java.util.Arrays;
public class Test {
private static Reader reader;
private static OutputWriter writer;
private static void solve() throws IOException {
int t = reader.nextInt();
while (t-- > 0) {
int n = reader.nextInt();
String s = reader.nextString(n);
int count = 0, ind = 0;
for (int i = 0; i < n - 1;) {
if (i < n && s.charAt(i) == '(') {
i += 2;
count++;
ind = i;
} else {
i++;
while (i < n && s.charAt(i) == '(') {
i++;
}
if (i < n && s.charAt(i) == ')') {
i++;
count++;
ind = i;
}
}
}
writer.println(count + " " + (n - ind));
}
}
static class Element implements Comparable<Element> {
int value;
int freq;
Element(int value, int freq) {
this.value = value;
this.freq = freq;
}
public int compareTo(Element e) {
if (this.freq > e.freq) {
return 1;
}
if (this.freq == e.freq) {
return 0;
}
return -1;
}
}
public static void main(String[] args) throws Exception {
// console input output
reader = new Reader();
writer = new OutputWriter();
// File input output
// reader = new Reader("input.txt");
// writer=new OutputWriter("output.txt");
solve();
reader.close();
writer.close();
}
private static long gcd(long a, long b) {
if (b == 0 || a == b)
return a;
if (a == 1 || b == 1)
return 1;
return gcd(b, a % b);
}
private static long gcd(long... values) {
long ans = gcd(values[0], values[1]);
for (long value : values) {
ans = gcd(ans, value);
}
return ans;
}
private static long min(long... values) {
long min = values[0];
for (long value : values) {
if (min < value) {
min = value;
}
}
return min;
}
private static long max(long... values) {
long max = values[0];
for (long value : values) {
if (max < value) {
max = value;
}
}
return max;
}
private static long powerMod(long num, long pow, long mod) {
if (pow == 0 || num == 1)
return 1;
if (num == 0 || pow == 1)
return num;
long ans = powerMod(num, pow / 2, mod) % mod;
ans = (ans * ans) % mod;
if (pow % 2 != 0) {
ans = (ans * num) % mod;
}
return ans;
}
private static boolean[] SieveOfEratosthenes() {
int n = (int) 1e7 + 7;
boolean[] ans = new boolean[n];
Arrays.fill(ans, true);
ans[0] = false;
ans[1] = false;
for (int i = 2; i < n; i++) {
if (ans[i]) {
for (int j = i * i; j < n; j = j + i) {
ans[j] = false;
}
}
}
return ans;
}
static class Reader {
final private int BUFFER_SIZE = 1 << 16;
private DataInputStream dataInputStream;
private int bufferPointer, bytesRead;
private byte[] buffer;
public Reader() {
this.dataInputStream = new DataInputStream(System.in);
this.buffer = new byte[BUFFER_SIZE];
this.bufferPointer = 0;
this.bytesRead = 0;
}
public Reader(String fileName) throws FileNotFoundException {
this.dataInputStream = new DataInputStream(new FileInputStream(fileName));
this.buffer = new byte[BUFFER_SIZE];
this.bufferPointer = 0;
this.bytesRead = 0;
}
public String next() throws IOException {
int c;
do {
c = readByte();
} while (c <= ' ');
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = readByte();
} while (c > ' ');
return res.toString();
}
public String nextLine(int n) throws IOException {
byte[] arr = new byte[n + 1];
int count = 0;
byte b;
while ((b = readByte()) != -1) {
if (b == '\n') {
if (count != 0) {
break;
} else {
continue;
}
}
arr[count++] = b;
}
return new String(arr, 0, count);
}
public String nextString(int n) throws IOException {
byte[] arr = new byte[n + 10];
int count = 0;
byte b;
while ((b = readByte()) != -1) {
if (b == ' ' || b == '\n') {
if (count != 0) {
break;
} else {
continue;
}
}
arr[count++] = b;
}
return new String(arr, 0, count);
}
// TODO: char is of 2 bytes, used only 1, correct it.
public char nextChar() throws IOException {
byte b = readByte();
while (b == ' ') {
b = readByte();
}
return (char) b;
}
public int nextInt() throws IOException {
int res = 0;
byte b = readByte();
while (b <= ' ') {
b = readByte();
}
boolean negative = (b == '-');
if (negative) {
b = readByte();
}
do {
res = res * 10 + (b - '0');
} while ((b = readByte()) >= '0' && b <= '9');
if (negative) {
res *= -1;
}
return res;
}
public long nextLong() throws IOException {
long res = 0;
byte b = readByte();
while (b <= ' ') {
b = readByte();
}
boolean negative = (b == '-');
if (negative) {
b = readByte();
}
do {
res = res * 10 + (b - '0');
} while ((b = readByte()) >= '0' && b <= '9');
if (negative) {
res *= -1;
}
return res;
}
public float nextFloat() throws IOException {
float res = 0, div = 1;
byte b = readByte();
while (b <= ' ') {
b = readByte();
}
boolean negative = (b == '-');
if (negative) {
b = readByte();
}
do {
res = res * 10 + (b - '0');
} while ((b = readByte()) >= '0' && b <= '9');
if (b == '.') {
while ((b = readByte()) >= '0' && b <= '9') {
res += (b - '0') / (div *= 10);
}
}
if (negative) {
res *= -1;
}
return res;
}
public double nextDouble() throws IOException {
double res = 0, div = 1;
byte b = readByte();
while (b <= ' ') {
b = readByte();
}
boolean negative = (b == '-');
if (negative) {
b = readByte();
}
do {
res = res * 10 + (b - '0');
} while ((b = readByte()) >= '0' && b <= '9');
if (b == '.') {
while ((b = readByte()) >= '0' && b <= '9') {
res += (b - '0') / (div *= 10);
}
}
if (negative) {
res *= -1;
}
return res;
}
private void fillBuffer() throws IOException {
bytesRead = dataInputStream.read(buffer, bufferPointer = 0, BUFFER_SIZE);
if (bytesRead == -1) {
buffer[0] = -1;
}
}
private byte readByte() throws IOException {
if (bufferPointer == bytesRead) {
fillBuffer();
}
return buffer[bufferPointer++];
}
public void close() throws IOException {
if (dataInputStream == null) {
return;
}
dataInputStream.close();
}
}
static class OutputWriter {
private final PrintWriter printWriter;
public OutputWriter() {
printWriter = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
}
public OutputWriter(String fileName) throws FileNotFoundException {
printWriter = new PrintWriter(
new BufferedWriter(
new OutputStreamWriter(
new FileOutputStream(fileName))));
}
public OutputWriter(OutputStream outputStream) {
printWriter = new PrintWriter(
new BufferedWriter(new OutputStreamWriter(outputStream)));
}
public OutputWriter(Writer writer) {
this.printWriter = new PrintWriter(writer);
}
// TODO: do something foe this flush, it will make code slower
public void print(Object... objects) {
for (int i = 0; i < objects.length; i++) {
if (i != 0)
printWriter.print(' ');
printWriter.print(objects[i]);
}
// printWriter.flush();
}
public void println(Object... objects) {
print(objects);
printWriter.println();
// printWriter.flush();
}
public void close() {
printWriter.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 11 | 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 | a842dc0c30f0d91d30bb0727da6ab010 | 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.BufferedWriter;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Writer;
import java.util.Arrays;
public class Test {
private static Reader reader;
private static OutputWriter writer;
private static void solve() throws IOException {
int t = reader.nextInt();
while (t-- > 0) {
int n = reader.nextInt();
String s = reader.nextString();
int count = 0, ind = 0;
for (int i = 0; i < n - 1;) {
if (i < n && s.charAt(i) == '(') {
i += 2;
count++;
ind = i;
} else {
i++;
while (i < n && s.charAt(i) == '(') {
i++;
}
if (i < n && s.charAt(i) == ')') {
i++;
count++;
ind = i;
}
}
}
writer.println(count + " " + (n - ind));
}
}
static class Element implements Comparable<Element> {
int value;
int freq;
Element(int value, int freq) {
this.value = value;
this.freq = freq;
}
public int compareTo(Element e) {
if (this.freq > e.freq) {
return 1;
}
if (this.freq == e.freq) {
return 0;
}
return -1;
}
}
public static void main(String[] args) throws Exception {
// console input output
reader = new Reader();
writer = new OutputWriter();
// File input output
// reader = new Reader("input.txt");
// writer=new OutputWriter("output.txt");
solve();
reader.close();
writer.close();
}
private static long gcd(long a, long b) {
if (b == 0 || a == b)
return a;
if (a == 1 || b == 1)
return 1;
return gcd(b, a % b);
}
private static long gcd(long... values) {
long ans = gcd(values[0], values[1]);
for (long value : values) {
ans = gcd(ans, value);
}
return ans;
}
private static long min(long... values) {
long min = values[0];
for (long value : values) {
if (min < value) {
min = value;
}
}
return min;
}
private static long max(long... values) {
long max = values[0];
for (long value : values) {
if (max < value) {
max = value;
}
}
return max;
}
private static long powerMod(long num, long pow, long mod) {
if (pow == 0 || num == 1)
return 1;
if (num == 0 || pow == 1)
return num;
long ans = powerMod(num, pow / 2, mod) % mod;
ans = (ans * ans) % mod;
if (pow % 2 != 0) {
ans = (ans * num) % mod;
}
return ans;
}
private static boolean[] SieveOfEratosthenes() {
int n = (int) 1e7 + 7;
boolean[] ans = new boolean[n];
Arrays.fill(ans, true);
ans[0] = false;
ans[1] = false;
for (int i = 2; i < n; i++) {
if (ans[i]) {
for (int j = i * i; j < n; j = j + i) {
ans[j] = false;
}
}
}
return ans;
}
static class Reader {
final private int BUFFER_SIZE = 1 << 16;
private DataInputStream dataInputStream;
private int bufferPointer, bytesRead;
private byte[] buffer;
public Reader() {
this.dataInputStream = new DataInputStream(System.in);
this.buffer = new byte[BUFFER_SIZE];
this.bufferPointer = 0;
this.bytesRead = 0;
}
public Reader(String fileName) throws FileNotFoundException {
this.dataInputStream = new DataInputStream(new FileInputStream(fileName));
this.buffer = new byte[BUFFER_SIZE];
this.bufferPointer = 0;
this.bytesRead = 0;
}
public String next() throws IOException {
int c;
do {
c = readByte();
} while (c <= ' ');
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = readByte();
} while (c > ' ');
return res.toString();
}
public String nextLine(int n) throws IOException {
byte[] arr = new byte[n + 1];
int count = 0;
byte b;
while ((b = readByte()) != -1) {
if (b == '\n') {
if (count != 0) {
break;
} else {
continue;
}
}
arr[count++] = b;
}
return new String(arr, 0, count);
}
public String nextString() throws IOException {
byte[] arr = new byte[1 << 20];
int count = 0;
byte b;
while ((b = readByte()) != -1) {
if (b == ' ' || b == '\n') {
if (count != 0) {
break;
} else {
continue;
}
}
arr[count++] = b;
}
return new String(arr, 0, count);
}
// TODO: char is of 2 bytes, used only 1, correct it.
public char nextChar() throws IOException {
byte b = readByte();
while (b == ' ') {
b = readByte();
}
return (char) b;
}
public int nextInt() throws IOException {
int res = 0;
byte b = readByte();
while (b <= ' ') {
b = readByte();
}
boolean negative = (b == '-');
if (negative) {
b = readByte();
}
do {
res = res * 10 + (b - '0');
} while ((b = readByte()) >= '0' && b <= '9');
if (negative) {
res *= -1;
}
return res;
}
public long nextLong() throws IOException {
long res = 0;
byte b = readByte();
while (b <= ' ') {
b = readByte();
}
boolean negative = (b == '-');
if (negative) {
b = readByte();
}
do {
res = res * 10 + (b - '0');
} while ((b = readByte()) >= '0' && b <= '9');
if (negative) {
res *= -1;
}
return res;
}
public float nextFloat() throws IOException {
float res = 0, div = 1;
byte b = readByte();
while (b <= ' ') {
b = readByte();
}
boolean negative = (b == '-');
if (negative) {
b = readByte();
}
do {
res = res * 10 + (b - '0');
} while ((b = readByte()) >= '0' && b <= '9');
if (b == '.') {
while ((b = readByte()) >= '0' && b <= '9') {
res += (b - '0') / (div *= 10);
}
}
if (negative) {
res *= -1;
}
return res;
}
public double nextDouble() throws IOException {
double res = 0, div = 1;
byte b = readByte();
while (b <= ' ') {
b = readByte();
}
boolean negative = (b == '-');
if (negative) {
b = readByte();
}
do {
res = res * 10 + (b - '0');
} while ((b = readByte()) >= '0' && b <= '9');
if (b == '.') {
while ((b = readByte()) >= '0' && b <= '9') {
res += (b - '0') / (div *= 10);
}
}
if (negative) {
res *= -1;
}
return res;
}
private void fillBuffer() throws IOException {
bytesRead = dataInputStream.read(buffer, bufferPointer = 0, BUFFER_SIZE);
if (bytesRead == -1) {
buffer[0] = -1;
}
}
private byte readByte() throws IOException {
if (bufferPointer == bytesRead) {
fillBuffer();
}
return buffer[bufferPointer++];
}
public void close() throws IOException {
if (dataInputStream == null) {
return;
}
dataInputStream.close();
}
}
static class OutputWriter {
private final PrintWriter printWriter;
public OutputWriter() {
printWriter = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
}
public OutputWriter(String fileName) throws FileNotFoundException {
printWriter = new PrintWriter(
new BufferedWriter(
new OutputStreamWriter(
new FileOutputStream(fileName))));
}
public OutputWriter(OutputStream outputStream) {
printWriter = new PrintWriter(
new BufferedWriter(new OutputStreamWriter(outputStream)));
}
public OutputWriter(Writer writer) {
this.printWriter = new PrintWriter(writer);
}
// TODO: do something foe this flush, it will make code slower
public void print(Object... objects) {
for (int i = 0; i < objects.length; i++) {
if (i != 0)
printWriter.print(' ');
printWriter.print(objects[i]);
}
// printWriter.flush();
}
public void println(Object... objects) {
print(objects);
printWriter.println();
// printWriter.flush();
}
public void close() {
printWriter.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 11 | 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 | 2afdd20580c7b3aa751e5a5ae32ce677 | 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.BufferedWriter;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Writer;
import java.util.Arrays;
public class Test {
private static Reader reader;
private static OutputWriter writer;
private static void solve() throws IOException {
int t = reader.nextInt();
while (t-- > 0) {
int n = reader.nextInt();
String s = reader.nextString();
int count = 0, ind = 0;
for (int i = 0; i < n - 1;) {
if (i < n && s.charAt(i) == '(') {
i += 2;
count++;
ind = i;
} else {
i++;
while (i < n && s.charAt(i) == '(') {
i++;
}
if (i < n && s.charAt(i) == ')') {
i++;
count++;
ind = i;
}
}
}
writer.println(count + " " + (n - ind));
}
}
static class Element implements Comparable<Element> {
int value;
int freq;
Element(int value, int freq) {
this.value = value;
this.freq = freq;
}
public int compareTo(Element e) {
if (this.freq > e.freq) {
return 1;
}
if (this.freq == e.freq) {
return 0;
}
return -1;
}
}
public static void main(String[] args) throws Exception {
// console input output
reader = new Reader();
writer = new OutputWriter();
// File input output
// reader = new Reader("input.txt");
// writer=new OutputWriter("output.txt");
solve();
reader.close();
writer.close();
}
private static long gcd(long a, long b) {
if (b == 0 || a == b)
return a;
if (a == 1 || b == 1)
return 1;
return gcd(b, a % b);
}
private static long gcd(long... values) {
long ans = gcd(values[0], values[1]);
for (long value : values) {
ans = gcd(ans, value);
}
return ans;
}
private static long min(long... values) {
long min = values[0];
for (long value : values) {
if (min < value) {
min = value;
}
}
return min;
}
private static long max(long... values) {
long max = values[0];
for (long value : values) {
if (max < value) {
max = value;
}
}
return max;
}
private static long powerMod(long num, long pow, long mod) {
if (pow == 0 || num == 1)
return 1;
if (num == 0 || pow == 1)
return num;
long ans = powerMod(num, pow / 2, mod) % mod;
ans = (ans * ans) % mod;
if (pow % 2 != 0) {
ans = (ans * num) % mod;
}
return ans;
}
private static boolean[] SieveOfEratosthenes() {
int n = (int) 1e7 + 7;
boolean[] ans = new boolean[n];
Arrays.fill(ans, true);
ans[0] = false;
ans[1] = false;
for (int i = 2; i < n; i++) {
if (ans[i]) {
for (int j = i * i; j < n; j = j + i) {
ans[j] = false;
}
}
}
return ans;
}
static class Reader {
final private int BUFFER_SIZE = 1 << 16;
private DataInputStream dataInputStream;
private int bufferPointer, bytesRead;
private byte[] buffer;
public Reader() {
this.dataInputStream = new DataInputStream(System.in);
this.buffer = new byte[BUFFER_SIZE];
this.bufferPointer = 0;
this.bytesRead = 0;
}
public Reader(String fileName) throws FileNotFoundException {
this.dataInputStream = new DataInputStream(new FileInputStream(fileName));
this.buffer = new byte[BUFFER_SIZE];
this.bufferPointer = 0;
this.bytesRead = 0;
}
public String next() throws IOException {
int c;
do {
c = readByte();
} while (c <= ' ');
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = readByte();
} while (c > ' ');
return res.toString();
}
public String nextLine(int n) throws IOException {
byte[] arr = new byte[n + 1];
int count = 0;
byte b;
while ((b = readByte()) != -1) {
if (b == '\n') {
if (count != 0) {
break;
} else {
continue;
}
}
arr[count++] = b;
}
return new String(arr, 0, count);
}
public String nextString() throws IOException {
byte[] arr = new byte[1 << 20];
int count = 0;
byte b;
while ((b = readByte()) != -1) {
if (b == ' ' || b == '\n') {
if (count != 0) {
break;
} else {
continue;
}
}
arr[count++] = b;
}
return new String(arr, 0, count);
}
// TODO: char is of 2 bytes, used only 1, correct it.
public char nextChar() throws IOException {
byte b = readByte();
while (b == ' ') {
b = readByte();
}
return (char) b;
}
public int nextInt() throws IOException {
int res = 0;
byte b = readByte();
while (b <= ' ') {
b = readByte();
}
boolean negative = (b == '-');
if (negative) {
b = readByte();
}
do {
res = res * 10 + (b - '0');
} while ((b = readByte()) >= '0' && b <= '9');
if (negative) {
res *= -1;
}
return res;
}
public long nextLong() throws IOException {
long res = 0;
byte b = readByte();
while (b <= ' ') {
b = readByte();
}
boolean negative = (b == '-');
if (negative) {
b = readByte();
}
do {
res = res * 10 + (b - '0');
} while ((b = readByte()) >= '0' && b <= '9');
if (negative) {
res *= -1;
}
return res;
}
public float nextFloat() throws IOException {
float res = 0, div = 1;
byte b = readByte();
while (b <= ' ') {
b = readByte();
}
boolean negative = (b == '-');
if (negative) {
b = readByte();
}
do {
res = res * 10 + (b - '0');
} while ((b = readByte()) >= '0' && b <= '9');
if (b == '.') {
while ((b = readByte()) >= '0' && b <= '9') {
res += (b - '0') / (div *= 10);
}
}
if (negative) {
res *= -1;
}
return res;
}
public double nextDouble() throws IOException {
double res = 0, div = 1;
byte b = readByte();
while (b <= ' ') {
b = readByte();
}
boolean negative = (b == '-');
if (negative) {
b = readByte();
}
do {
res = res * 10 + (b - '0');
} while ((b = readByte()) >= '0' && b <= '9');
if (b == '.') {
while ((b = readByte()) >= '0' && b <= '9') {
res += (b - '0') / (div *= 10);
}
}
if (negative) {
res *= -1;
}
return res;
}
private void fillBuffer() throws IOException {
bytesRead = dataInputStream.read(buffer, bufferPointer = 0, BUFFER_SIZE);
if (bytesRead == -1) {
buffer[0] = -1;
}
}
private byte readByte() throws IOException {
if (bufferPointer == bytesRead) {
fillBuffer();
}
return buffer[bufferPointer++];
}
public void close() throws IOException {
if (dataInputStream == null) {
return;
}
dataInputStream.close();
}
}
static class OutputWriter {
private final PrintWriter printWriter;
public OutputWriter() {
printWriter = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
}
public OutputWriter(String fileName) throws FileNotFoundException {
printWriter = new PrintWriter(
new BufferedWriter(
new OutputStreamWriter(
new FileOutputStream(fileName))));
}
public OutputWriter(OutputStream outputStream) {
printWriter = new PrintWriter(
new BufferedWriter(new OutputStreamWriter(outputStream)));
}
public OutputWriter(Writer writer) {
this.printWriter = new PrintWriter(writer);
}
// TODO: do something foe this flush, it will make code slower
public void print(Object... objects) {
for (int i = 0; i < objects.length; i++) {
if (i != 0)
printWriter.print(' ');
printWriter.print(objects[i]);
}
printWriter.flush();
}
public void println(Object... objects) {
print(objects);
printWriter.println();
printWriter.flush();
}
public void close() {
printWriter.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 11 | 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 | cfc78d8b25c1f5e916bceff02a1624db | 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.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;
public class Test{
static FastReader scan;
static void solve(){
int n=scan.nextInt();
String s=scan.next();
char[]ch=s.toCharArray();
int prev=0;
int ans=0,li=-1;
for(int i=1;i<n;i++){
if(ch[prev]=='('){
ans++;
li=i;
prev=i+1;
i++;
}
else if(ch[i]==')'){
ans++;
li=i;
prev=i+1;
i++;
}
// vector<int> v;
// for(int i=0;i<n;i++){
// if(s[i]==')') v.push_back(i);
// }
// for(int i=0;i<n;i++){
// if(s[i]=='('){
// ans++;
// i++;
// }
// else if(s[i]){
// }
// }
}
System.out.println(ans+" "+(n-li-1));
}
public static void main (String[] args) throws java.lang.Exception{
scan=new FastReader();
int t=scan.nextInt();
while(t-->0){
solve();
}
}
static class Pair implements Comparable<Pair>{
int x;
int y;
Pair(int x,int y){
this.x=x;
this.y=y;
}
@Override
public int compareTo(Pair p){
return this.y-p.y;
}
public String toString(){
return "("+x+" "+y+")";
}
}
static boolean sq(int i){
int temp=(int)Math.sqrt(i);
return temp*temp==i;
}
static boolean cb(int i){
int temp=(int)Math.cbrt(i);
return temp*temp*temp==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;
}
}
static void printLong(long []arr){
for(long x:arr)System.out.print(x+" ");
}
static void printInt(int []arr){
for(int x:arr)System.out.print(x+" ");
}
static void scanInt(int []arr){
for(int i=0;i<arr.length;i++){
arr[i]=scan.nextInt();
}
}
static void scanLong(long []arr){
for(int i=0;i<arr.length;i++){
arr[i]=scan.nextLong();
}
}
static long gcd(long a, long b){
if (b == 0)
return a;
return gcd(b, a % b);
}
static long power(long x, long y, long mod){
long res = 1;
x = x % mod;
if (x == 0)
return 0;
while (y > 0){
if ((y & 1) != 0)
res = (res * x) % mod;
y = y >> 1;
x = (x * x) % mod;
}
return res;
}
static long add(long a,long b,long mod){
a = a % mod;
b = b % mod;
return (((a + b) % mod) + mod) % mod;
}
static long sub(long a, long b,long mod){
a = a % mod;
b = b % mod;
return (((a - b) % mod) + mod) % mod;
}
static long mul(long a, long b,long mod){
a = a % mod;
b = b % mod;
return (((a * b) % mod) + mod) % mod;
}
static long mminvprime(long a, long b,long mod) {
return power(a, b - 2,mod);
}
} | 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 11 | 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 | bf35392864239a8dcf6920f8cd2ac37c | 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 {
final static int mod = 1000000007;
final static String yes = "YES";
final static String no = "NO";
public static void main(String[] args) throws Exception {
FastReader sc = new FastReader();
int t = sc.nextInt();
HashSet<Integer> set = new HashSet<>();
for (int i = 1; i < 51; i++) {
set.add(i * i);
}
outer: while (t-- > 0) {
int n = sc.nextInt();
char[] c = sc.next().toCharArray();
int count=0;
int i=0;
while(i<n-1){
if(c[i]==c[i+1] || c[i]=='('){
count++;
i+=2;
continue;
}else{
int x = i+2;
while(x<n && c[x]=='(')
x++;
if(x==n)
break;
i=x+1;
count++;
}
}
System.out.println(count+" "+(n-i));
}
}
static void sortLong(long[] a) // check for long
{
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 void sortInt(Integer[] a) // check for int
{
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);
}
public static boolean isSorted(int[] nums, int n) {
for (int i = 1; i < n; i++) {
if (nums[i] < nums[i - 1])
return false;
}
return true;
}
public static boolean isPalindrome(String s) {
StringBuilder sb = new StringBuilder(s);
return s.equals(sb.reverse().toString());
}
// public static boolean isPalindrome(String s) {
// int i = 0, j = s.length() - 1;
// while (i <= j) {
// if (s.charAt(i) != s.charAt(j))
// return false;
// i++;
// j--;
// }
// return true;
// }
static long kadane(long A[]) {
long lsum = A[0], gsum = 0;
gsum = Math.max(gsum, lsum);
for (int i = 1; i < A.length; i++) {
lsum = Math.max(lsum + A[i], A[i]);
gsum = Math.max(gsum, lsum);
}
return gsum;
}
public static void sortByColumn(int arr[][], int col) {
Arrays.sort(arr, new Comparator<int[]>() {
@Override
public int compare(final int[] entry1,
final int[] entry2) {
// To sort in descending order revert
// the '>' Operator
if (entry1[col] > entry2[col])
return 1;
else
return -1;
}
});
}
public static void backtrack(String[] letters, int index, String digits, StringBuilder build, List<String> result) {
if (build.length() >= digits.length()) {
result.add(build.toString());
return;
}
char[] key = letters[digits.charAt(index) - '2'].toCharArray();
for (int j = 0; j < key.length; j++) {
build.append(key[j]);
backtrack(letters, index + 1, digits, build, result);
build.deleteCharAt(build.length() - 1);
}
}
public static String get(String s, int k) {
int n = s.length();
int rep = k % n == 0 ? k / n : k / n + 1;
s = s.repeat(rep);
return s.substring(0, k);
}
public static int diglen(Long y) {
int a = 0;
while (y != 0L) {
y /= 10;
a++;
}
return a;
}
static class FastReader {
BufferedReader br;
StringTokenizer st; // StringTokenizer() is used to read long strings
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 class Pair implements Comparable<Pair> {
public final int index;
public final int value;
public Pair(int index, int value) {
this.index = index;
this.value = value;
}
@Override
public int compareTo(Pair other) {
// multiplied to -1 as the author need descending sort order
return -1 * Integer.valueOf(this.value).compareTo(other.value);
}
}
static String reverseString(String str) {
StringBuilder input = new StringBuilder();
return input.append(str).reverse().toString();
}
static void printArray(int[] nums) {
for (int i = 0; i < nums.length; i++) {
System.out.print(nums[i] + "->");
}
System.out.println();
}
static long factorial(int n, int b) {
if (n == b)
return 1;
return n * factorial(n - 1, b);
}
static int lcm(int ch, int b) {
return ch * b / gcd(ch, b);
}
static int gcd(int ch, int b) {
return b == 0 ? ch : gcd(b, ch % b);
}
static double ceil(double n, double k) {
return Math.ceil(n / k);
}
static int sqrt(double n) {
return (int) Math.sqrt(n);
}
}
| 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 11 | 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 | 02a1961703a0d9f024e3e7f0a072468e | 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 PrintWriter out;
static Kioken sc;
public static void main(String[] args) throws FileNotFoundException {
boolean t = true;
boolean f = false;
if (f) {
out = new PrintWriter("output.txt");
sc = new Kioken("input.txt");
} else {
out = new PrintWriter((System.out));
sc = new Kioken();
}
int tt = 1;
tt = sc.nextInt();
while (tt-- > 0) {
solve();
}
out.flush();
out.close();
}
public static void solve() {
int n = sc.nextInt();
String s = sc.nextLine();
char[] c = s.toCharArray();
int rem = 0, cnt = 0;
for(int i = 0; i < n; i++){
// out.println(" cnt " + cnt + " " + rem);
if(c[i] == '(' && i < n - 1){
cnt++;
i++;
}else if(c[i] == '('){
rem++;
break;
}else if(c[i] == ')'){
int index = -1;
for(int j = i+1; j < n; j++){
if(c[j] == ')'){
index = j;
break;
}
}
if(index == -1){
// not found
rem = n - i;
break;
}else{
i = index;
cnt++;
}
}
}
out.println(cnt + " " + rem);
}
public static long gcd(long a, long b) {
while (b != 0) {
long rem = a % b;
a = b;
b = rem;
}
return a;
}
static long MOD = 1000000007;
static 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);}}
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 sort(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 class Kioken {
// FileInputStream br = new FileInputStream("input.txt");
BufferedReader br;
StringTokenizer st;
Kioken(String filename) {
try {
FileReader fr = new FileReader(filename);
br = new BufferedReader(fr);
st = new StringTokenizer("");
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
}
Kioken() {
try {
br = new BufferedReader(new InputStreamReader(System.in));
st = new StringTokenizer("");
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
}
public String next() {
while (!st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (Exception e) {
e.printStackTrace();
}
}
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 String nextLine() {
try {
return br.readLine();
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
public boolean hasNext() {
String next = null;
try {
next = br.readLine();
} catch (Exception e) {
}
if (next == null || next.length() == 0) {
return false;
}
st = new StringTokenizer(next);
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 11 | 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 | e355b1d1bd4b545cdbc02bb1b8a2dabd | 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.PrintWriter;
import java.util.*;
public class fire extends PrintWriter {
fire() { super(System.out); }
static Scanner sc = new Scanner(System.in);
public static void main(String[] $) {
fire o = new fire(); o.main(); o.flush();
}
void main() {
int t = sc.nextInt();
while(t--!=0){
int n = sc.nextInt();
String str = sc.next();
int count = 0,i=0;
char[] arr = str.toCharArray();
while(i+1<n) {
char c = arr[i];
if(c==arr[i+1] || (c=='(' && arr[i+1]==')')) {count++;i+=2;}
else {
int j =i+1;
while(j<n && arr[j]=='(') j++;
if(j==n) break;
count++;
i=j+1;
}
}
println(count+" "+(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 11 | 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 | 5c7ee0262c9403d932e1f48c3171523f | 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 BSD {
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());
char[] ch = br.readLine().toCharArray();//Stack<Character> stk = new Stack<>();
int r = 0;
int c = 0;
int j = 0;
int i = 0;
for(i = 0; i < ch.length-1; i+=2){
if(ch[i] == '(' && ch[i+1] == ')'){
r++;
}
else if(ch[i] == ')' && ch[i+1] == ')'){
r++;
}
else if(ch[i] == '(' && ch[i+1] == '('){
r++;
}
else{
j = i+2;
while(j < n && ch[j] != ')')j++;
if(j < n){
r++;
i = j-1;
}
else break;
}
}
System.out.println(r+" "+(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 11 | 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 | 35e38561ff14844da95c40d054df0fdf | 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 AC {
public static void main(String args[]) throws IOException {
FastReader sc = new FastReader();
PrintWriter out = new PrintWriter(System.out);
int tc, i, j;
String s;
char p;
tc = sc.nextInt();
while (tc-- > 0) {
int n = sc.nextInt();
s=sc.nextLine();
i=0;long count=0;
long pos=-1;
long ans=0;
while(i <= n - 2) {
if (s.charAt(i) == ')' && s.charAt(i + 1) == '(') {
pos = i;
i++;
while (i<n && s.charAt(i) == '(')
i++;
if (i == n)
break;
long temp = i - pos + 1;
ans -= temp;
count++;
i++;
}
else{
count++;
ans-=2;
i+=2;
}
}
out.println(count+" "+(ans+n));
}
out.close();
}
public static boolean palin(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;
}
public static boolean bal(String expr)
{
Deque<Character> stack = new ArrayDeque<Character>();
for (int i = 0; i < expr.length(); i++)
{
char x = expr.charAt(i);
if (x == '(' || x == '[' || x == '{')
{
stack.push(x);
continue;
}
if (stack.isEmpty())
return false;
char check;
switch (x) {
case ')':
check = stack.pop();
if (check == '{' || check == '[')
return false;
break;
case '}':
check = stack.pop();
if (check == '(' || check == '[')
return false;
break;
case ']':
check = stack.pop();
if (check == '(' || check == '{')
return false;
break;
}
}
// Check Empty Stack
return (stack.isEmpty());
}
/*--------------------------------------------------------
----------------------------------------------------------*/
//Pair Class
public static class Pair implements Comparable<Pair> {
int x, y;
Pair(int x, int y) {
this.x = x;
this.y = y;
}
@Override
public int compareTo(Pair o) {
return this.x - o.x;
}
}
/*
FASTREADER
*/
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;
}
/*DEFINED BY ME*/
//READING ARRAY
int[] readArray(int n) {
int arr[] = new int[n];
for (int i = 0; i < n; i++)
arr[i] = nextInt();
return arr;
}
//COLLECTIONS SORT
void sort(int arr[]) {
ArrayList<Integer> l = new ArrayList<>();
for (int i : arr)
l.add(i);
Collections.sort(l);
for (int i = 0; i < arr.length; i++)
arr[i] = l.get(i);
}
//EUCLID'S GCD
int gcd(int a, int b) {
if (b != 0)
return gcd(b, a % b);
else
return a;
}
void swap(int arr[], int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
} | 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 11 | 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 | 044faf02c19adeac7f6eab43d4674ca5 | 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.math.*;
public class C_Bracket_Sequence_Deletion{
static final int MOD = (int) 1e9 + 7;
public static void main (String[] args){
FastReader s = new FastReader();
int t=1;t=s.ni();
outer: for(int test=1;test<=t;test++){
int n = s.ni();
long ans = 0;
String S = s.nextLine();
char a[] = S.toCharArray();
if (n == 1) {
System.out.println("0 1");
continue;
}
int i;
for (i = 0; i < n-1; i++) {
if (a[i] == '(') {
ans++;
i++;
}
else {
int j = i;
i++;
while (i < n && a[i] != ')') {
i++;
}
if (i == n) {
System.out.println(ans + " " + (n - j));
continue outer;
}
else
ans++;
}
}
System.out.println(ans+" "+(n-i));
}
}
static class FastReader {
BufferedReader br; StringTokenizer st;
public FastReader(){
br = new BufferedReader(new InputStreamReader(System.in));}
int ni() { return Integer.parseInt(next()); }
long nl() { return Long.parseLong(next()); }
double nd() { return Double.parseDouble(next()); }
int[] readArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++) a[i] = ni();
return a;
}
long[] readLongArray(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++) a[i] = nl();
return a;
}
String next(){
while (st == null || !st.hasMoreElements()) {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;}
}
static void sort(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 void pArray(long[] a){
int n=a.length;
for(int i=0;i<n;i++)
System.out.print(a[i]+" ");
}
static long sum(long[] a){
int n=a.length;long sum=0;
for(int i=0;i<n;i++)
sum+=a[i];
return sum;
}
static boolean prime(long sq){
if(BigInteger.valueOf(sq).isProbablePrime(12))
return true;
return false;
}
}
//Collections.sort(a, Collections.reverseOrder()); | 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 11 | 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 | 564b7dfddba1ff9351336018182ac776 | 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 Solution{
public static void main(String[] args){
Scanner scn = new Scanner(System.in);
int t = scn.nextInt();
while(t>0){
t--;
int n = scn.nextInt();
scn.nextLine();
String s = scn.nextLine();
int ans=0;
int done=-1;
int i=0;
while(i<n)
{
char c = s.charAt(i);
if(c=='(' && i<n-1)
{
i+=2;
done=i-1;
ans++;
}
else
{
int j=i+1;
while(j<n)
{
char d = s.charAt(j);
if(d==')')
{
break;
}
j++;
}
if(j<n)
{
ans++;
done=j;
i=j+1;
}
else
{
break;
}
}
}
System.out.println(ans+" "+(n-done-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 11 | 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 | 299e2bd6d303983004c7a3fcb77edf60 | 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.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;
import java.util.*;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
TaskA solver = new TaskA();
int testNum = in.nextInt();
solver.solve(testNum, in, out);
out.close();
}
static class TaskA {
public void solve(int testNumber, InputReader in, PrintWriter out) {
for (int z = 0; z < testNumber; z++) {
int n = in.nextInt();
String s = in.next();
int op = 0;
int startCounter= 0;
int endCounter = 1;
while (true) {
char startChar = s.charAt(startCounter);
int openCounter = 0;
boolean regularBlocked = false;
boolean found = false;
if (s.charAt(startCounter) == '(') {
openCounter++;
} else {
regularBlocked =true;
}
for (int i = startCounter + 1; i < s.length(); i++) { // longer prefix
if (s.charAt(i) == startChar) { // palindrome break
startCounter = i + 1;
op++;
found = true;
break;
}
if (s.charAt(i) == '(') {
openCounter++;
} else if (!regularBlocked) {
if (openCounter == 1) { // regular, break
startCounter = i + 1;
op++;
found = true;
break;
} else if (openCounter < 0) {
regularBlocked = true;
} else {
openCounter--;
}
}
}
if (startCounter >= s.length() - 1 || !found) {
break;
}
}
out.println(op + " " + (s.length() - startCounter));
}
}
}
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());
}
}
}
| 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 11 | 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 | 090f7848e5ec8c929ba111acecd6517b | 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.text.*;
import java.math.*;
import java.util.regex.*;
public class JaiShreeRam{
static Scanner in=new Scanner();
static long mod = 1000000007;
static List<List<Integer>> adj;
static int seive[]=new int[1000001];
static long C[][];
static long ans=Long.MIN_VALUE;
public static void main(String[] args) throws Exception{
int z=in.readInt();
while(z-->0) {
solve();
ans=Long.MIN_VALUE;
}
}
static void solve() {
int n=in.readInt();
char c[]=in.readString().toCharArray();
int f=0;
int cnt1=0,cnt2=n;
for(int i=1;i<n;i++) {
if(c[i]==')'&&c[i-1]=='('&&f==0) {
i+=1;
cnt1++;
cnt2=n-i;
}
else if(c[i]-c[i-1]==0&&f==0) {
i+=1;
cnt1++;
cnt2=n-i;
}
else if(f==1){
if(c[i-1]=='('&&c[i]==')') {
cnt1+=1;
cnt2=n-i-1;
f=0;
i++;
}
}
else {
f=1;
}
}
print(cnt1+" "+cnt2);
}
static long fn(int ind,long b,long x,long y,long sum,int n) {
if(ind==n) {
return 0;
}
long ans=(long)-1e15;
if(sum+x<b) {
ans=x+fn(ind+1,b,x,y,sum+x,n);
}
ans=Math.max(ans,-y+fn(ind+1,b,x,y,sum-y,n));
return ans;
}
static long maxsumsub(ArrayList<Long> al) {
long max=0;
long sum=0;
for(int i=0;i<al.size();i++) {
sum+=al.get(i);
if(sum<0) {
sum=0;
}
max=Math.max(max,sum);
}
return max;
}
static long abs(long a) {
return Math.abs(a);
}
static void ncr(int n, int k){
C= new long[n + 1][k + 1];
int i, j;
for (i = 0; i <= n; i++) {
for (j = 0; j <= Math.min(i, k); j++) {
if (j == 0 || j == i)
C[i][j] = 1;
else
C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
}
}
}
static boolean isPalin(String s) {
int i=0,j=s.length()-1;
while(i<=j) {
if(s.charAt(i)!=s.charAt(j)) {
return false;
}
i++;
j--;
}
return true;
}
static int knapsack(int W, int wt[],int val[], int n){
int []dp = new int[W + 1];
for (int i = 1; i < n + 1; i++) {
for (int w = W; w >= 0; w--) {
if (wt[i - 1] <= w) {
dp[w] = Math.max(dp[w],dp[w - wt[i - 1]] + val[i - 1]);
}
}
}
return dp[W];
}
static void seive() {
Arrays.fill(seive, 1);
seive[0]=0;
seive[1]=0;
for(int i=2;i*i<1000001;i++) {
if(seive[i]==1) {
for(int j=i*i;j<1000001;j+=i) {
if(seive[j]==1) {
seive[j]=0;
}
}
}
}
}
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 sort(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 int[] nia(int n){
int[] arr= new int[n];
int i=0;
while(i<n){
arr[i++]=in.readInt();
}
return arr;
}
static long[] nla(int n){
long[] arr= new long[n];
int i=0;
while(i<n){
arr[i++]=in.readLong();
}
return arr;
}
static int[] nia1(int n){
int[] arr= new int[n+1];
int i=1;
while(i<=n){
arr[i++]=in.readInt();
}
return arr;
}
static Integer[] nIa(int n){
Integer[] arr= new Integer[n];
int i=0;
while(i<n){
arr[i++]=in.readInt();
}
return arr;
}
static Long[] nLa(int n){
Long[] arr= new Long[n];
int i=0;
while(i<n){
arr[i++]=in.readLong();
}
return arr;
}
static long gcd(long a, long b) {
if (b==0) return a;
return gcd(b, a%b);
}
static void print(long i) {
System.out.println(i);
}
static void print(Object o) {
System.out.println(o);
}
static void print(int a[]) {
for(int i:a) {
System.out.print(i+" ");
}
System.out.println();
}
static void print(long a[]) {
for(long i:a) {
System.out.print(i+" ");
}
System.out.println();
}
static void print(ArrayList<Long> a) {
for(long i:a) {
System.out.print(i+" ");
}
System.out.println();
}
static void print(Object a[]) {
for(Object i:a) {
System.out.print(i+" ");
}
System.out.println();
}
static class Scanner{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st=new StringTokenizer("");
String readString() {
while (!st.hasMoreTokens())
try {
st=new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
return st.nextToken();
}
double readDouble() {
return Double.parseDouble(readString());
}
int readInt() {
return Integer.parseInt(readString());
}
long readLong() {
return Long.parseLong(readString());
}
}
} | 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 11 | 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 | 20dd56a07e8698fc994b36a2461f144c | 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.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class C {
static InputReader reader;
public static void main(String[] args) throws IOException {
reader = new InputReader(System.in);
int n = reader.nextInt();
for (int i = 0; i < n; i++) {
reader.reader.readLine();
String s = reader.reader.readLine();
solve(s);
}
}
private static void solve(String s) {
int counter = 0;
StringBuilder builder = new StringBuilder();
int sum = 0;
boolean flag = true;
for(char c : s.toCharArray()) {
builder.append(c);
if(c=='(') sum++;
if(c==')') sum--;
if(sum <0) {
flag = false;
}
if((sum == 0 && flag) || ( builder.length()>=2 && isPalindrom(builder))) {
counter++;
builder.setLength(0);
sum = 0;
flag = true;
}
}
System.out.println(counter +" " + builder.length());
}
private static boolean isPalindrom(StringBuilder s) {
for (int i = 0; i < s.length()/2; i++) {
if(s.charAt(i) != s.charAt(s.length() - 1 - i)) {
return false;
}
}
return true;
}
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());
}
}
}
| 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 11 | 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 | 99ce1c8525285cdf076b02442245b6b0 | 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 |
/*
* 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 C {
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 n = sc.nextInt();
char str[] = sc.next().toCharArray();
String s = new String(str);
String r = reverse(s, n);
Hashing h1 = new Hashing(n + 1, (int) 1e9 + 7, 35);
Hashing h3 = new Hashing(n + 1, (int) 1e9 + 7, 35);
Hashing h2 = new Hashing(n + 1, (int) 1e9 + 9, 32);
Hashing h4 = new Hashing(n + 1, (int) 1e9 + 9, 32);
h1.precalc();
h1.build(s);
h2.precalc();
h2.build(s);
h3.precalc();
h3.build(r);
h4.precalc();
h4.build(r);
boolean onlyPalin = false;
int open = 0;
int operations = 0;
int left = 0;
for (int i = 0; i < n; i++) {
if (str[i] == '(') {
++open;
// Check for palin
if ((left != i) && palin(s, r, left, i, n, h1, h2, h3, h4)) {
++operations;
left = i + 1;
onlyPalin = false;
open = 0;
continue;
}
} else {
if (open == 0) {
onlyPalin = true;
} else {
open--;
}
// Check for regular
if (open == 0 && !onlyPalin) {
++operations;
left = i + 1;
open = 0;
continue;
}
// Check for palin
if ((left != i) && palin(s, r, left, i, n, h1, h2, h3, h4)) {
++operations;
left = i + 1;
onlyPalin = false;
open = 0;
continue;
}
}
}
ans.append(operations + " " + (n - left) + "\n");
}
System.out.print(ans);
}
static boolean palin(String s, String r, int i, int j, int n, Hashing h1, Hashing h2, Hashing h3, Hashing h4) {
// System.out.println(s.substring(i, j) + " " + r.substring(n - i));
return (h1.getHash(i, j) == h3.getHash(n - 1 - j, n - j - 1 + (j - i))
&& h2.getHash(i, j) == h4.getHash(n - 1 - j, n - j - 1 + (j - i)));
}
static String reverse(String s, int n) {
StringBuilder str = new StringBuilder();
for (int i = 0; i < n; i++) {
str = str.append(s.charAt(i));
}
return str.reverse().toString();
}
static class Hashing {
int N;
int base;
int mod;
int pw[];
int inv[];
int H[];
Hashing() {
}
Hashing(int N, int mod, int base) {
this.N = N;
this.mod = mod;
this.base = base;
pw = new int[N];
inv = new int[N];
H = new int[N];
}
int add(int a, int b, int mod) {
int res = (a + b) % mod;
if (res < 0)
res += mod;
return res;
}
int mult(int a, int b, int mod) {
int res = (int) ((((long) a) * b) % mod);
if (res < 0)
res += mod;
return res;
}
int power(int a, int b, int mod) {
int res = 1;
while (b > 0) {
if ((b % 2) == 1)
res = mult(res, a, mod);
a = mult(a, a, mod);
b /= 2;
}
return res;
}
void precalc() {
pw[0] = 1;
for (int i = 1; i < N; i++)
pw[i] = mult(pw[i - 1], base, mod);
int pw_inv = power(base, mod - 2, mod);
inv[0] = 1;
for (int i = 1; i < N; i++)
inv[i] = mult(inv[i - 1], pw_inv, mod);
}
void build(String s) {
int n = s.length();
for (int i = 0; i < n; ++i) {
H[i] = add((i == 0) ? 0 : H[i - 1], mult(pw[i], s.charAt(i) - 'a' + 1, mod), mod);
}
}
int getHash(int x, int y) {
int res = add(H[y], (x == 0) ? 0 : -H[x - 1], mod);
res = mult(res, (x == 0) ? 1 : inv[x], mod);
return 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 | ["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 11 | 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 | bf85f6914158cd8e02e17f8838c21a04 | 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.StringTokenizer;
public class C1657C {
public static void solve (int n, String s){
int index = 0;
int operations = 0;
while (index < n){
if (s.charAt(index) == '('){
index += 2;
operations++;
}
else {
boolean done = true;
for (int i=index+1; i < n; i++){
if (s.charAt(i) == ')'){
operations++;
done = false;
index = i+1;
break;
}
}
if (done){
System.out.println(operations + " " + (n-index));
return;
}
}
}
if (index == n){
System.out.println(operations + " " + 0);
}
else {
System.out.println((operations-1) + " " + 1);
}
}
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int t = Integer.parseInt(br.readLine());
for (int i=0; i < t; i++){
int n = Integer.parseInt(br.readLine());
String s = br.readLine();
solve (n, s);
}
}
}
| 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 11 | 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 | 97fbeeb0e846b492cbedaa2e404366e9 | 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 | /***** ---> :) Vijender Srivastava (: <--- *****/
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main
{
static FastReader sc =new FastReader();
static PrintWriter out=new PrintWriter(System.out);
static long mod=(long)32768;
static StringBuilder sb = new StringBuilder();
/* start */
public static void main(String [] args)
{
int testcases = 1;
testcases = i();
// calc();
while(testcases-->0)
{
solve();
}
out.flush();
out.close();
}
static void solve()
{
int n = i();
String s = sc.nextLine();
Stack<Character> st = new Stack<>();
int cnt = 0,x=0;
for(int i=0;i<n;i++)
{
if(st.isEmpty()) st.push(s.charAt(i));
else {
if(st.peek() == s.charAt(i))
{
st.pop();
cnt++;
x=0;
} else if(st.peek()=='(')
{
st.pop();
cnt++;
x=0;
} else x++;
}
}
pl(cnt+" "+(st.size()+x));
}
/* end */
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;
}
}
static void p(Object o)
{
out.print(o);
}
static void pl(Object o)
{
out.println(o);
}
static int i() {
return sc.nextInt();
}
static String s() {
return sc.next();
}
static long l() {
return sc.nextLong();
}
static char[] inputC()
{
String s = sc.nextLine();
return s.toCharArray();
}
static int[] input(int n) {
int A[]=new int[n];
for(int i=0;i<n;i++) {
A[i]=sc.nextInt();
}
return A;
}
static long[] inputL(int n) {
long A[]=new long[n];
for(int i=0;i<n;i++) {
A[i]=sc.nextLong();
}
return A;
}
static long[] putL(long a[]) {
long A[]=new long[a.length];
for(int i=0;i<a.length;i++) {
A[i]=a[i];
}
return A;
}
static String[] inputS(int n) {
String A[]=new String[n];
for(int i=0;i<n;i++) {
A[i]=sc.next();
}
return A;
}
static int gcd(int a, int b)
{
if (a == 0)
return b;
return gcd(b % a, a);
}
static long gcd(long a, long b)
{
if (a == 0)
return b;
return gcd(b % a, a);
}
static int lcm(int a, int b)
{
return (a / gcd(a, b)) * b;
}
static String reverse(String s) {
StringBuffer p=new StringBuffer(s);
p.reverse();
return p.toString();
}
static int min(int a,int b) {
return Math.min(a, b);
}
static int min(int a,int b,int c) {
return Math.min(a, Math.min(b, c));
}
static int min(int a,int b,int c,int d) {
return Math.min(a, Math.min(b, Math.min(c, d)));
}
static int max(int a,int b) {
return Math.max(a, b);
}
static int max(int a,int b,int c) {
return Math.max(a, Math.max(b, c));
}
static int max(int a,int b,int c,int d) {
return Math.max(a, Math.max(b, Math.max(c, d)));
}
static long min(long a,long b) {
return Math.min(a, b);
}
static long min(long a,long b,long c) {
return Math.min(a, Math.min(b, c));
}
static long min(long a,long b,long c,long d) {
return Math.min(a, Math.min(b, Math.min(c, d)));
}
static long max(long a,long b) {
return Math.max(a, b);
}
static long max(long a,long b,long c) {
return Math.max(a, Math.max(b, c));
}
static long max(long a,long b,long c,long d) {
return Math.max(a, Math.max(b, Math.max(c, d)));
}
static long sum(int A[]) {
long sum=0;
for(int i : A) {
sum+=i;
}
return sum;
}
static long sum(long A[]) {
long sum=0;
for(long i : A) {
sum+=i;
}
return sum;
}
static void print(int A[]) {
for(int i : A) {
System.out.print(i+" ");
}
System.out.println();
}
static void print(long A[]) {
for(long i : A) {
System.out.print(i+" ");
}
System.out.println();
}
static long mod(long x) {
return ((x%mod + mod)%mod);
}
static long power(long x, long y)
{
if(y==0)
return 1;
if(x==0)
return 0;
long res = 1;
while (y > 0) {
if (y % 2 == 1)
res = (res * x) ;
y = y >> 1;
x = (x * x);
}
return res;
}
static boolean prime(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;
}
static boolean prime(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;
}
static long[] sort(long a[]) {
ArrayList<Long> arr = new ArrayList<>();
for(long i : a) {
arr.add(i);
}
Collections.sort(arr);
for(int i = 0; i < arr.size(); i++) {
a[i] = arr.get(i);
}
return a;
}
static int[] sort(int a[])
{
ArrayList<Integer> arr = new ArrayList<>();
for(Integer i : a) {
arr.add(i);
}
Collections.sort(arr);
for(int i = 0; i < arr.size(); i++) {
a[i] = arr.get(i);
}
return a;
}
//pair class
private static class Pair implements Comparable<Pair> {
long first, second;
public Pair(long f, long s) {
first = f;
second = s;
}
@Override
public int compareTo(Pair p) {
if (first < p.first)
return 1;
else if (first > p.first)
return -1;
else {
if (second > p.second)
return 1;
else if (second < p.second)
return -1;
else
return 0;
}
}
}
} | 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 11 | 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 | c0a3a047ba8d955fdf021148f0ba8118 | 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 | /***** ---> :) Vijender Srivastava (: <--- *****/
import java.util.Queue;
import java.util.LinkedList;
import java.util.*;
import java.lang.*;
// import java.lang.reflect.Array;
import java.io.*;
public class Main
{
static FastReader sc =new FastReader();
static PrintWriter out=new PrintWriter(System.out);
static long mod=998244353;
static StringBuilder sb = new StringBuilder();
/* start */
public static void main(String [] args)
{
// int testcases = 1;
int testcases = i();
while(testcases-->0)
{
solve();
}
out.flush();
out.close();
}
static void solve()
{
int n = i();
char c[] = inputC();
int cnt = 0,i=0;
while(i<n)
{
if(c[i]=='(' && i+1<n)
{
i+=2;
cnt++;
continue;
}
if(c[i]==')')
{
int j = i+1;
while(j<n && c[j]!=')')
{
j++;
}
if(j>=n || (j<n && c[j]!=')')) break;
cnt++;
i=j+1;
continue;
}
break;
}
pl(cnt+" "+(n-i));
}
// )((()( ())
/* end */
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;
}
}
static void p(Object o)
{
out.print(o);
}
static void pl(Object o)
{
out.println(o);
}
static int i() {
return sc.nextInt();
}
static String s() {
return sc.next();
}
static long l() {
return sc.nextLong();
}
static char[] inputC()
{
String s = sc.nextLine();
return s.toCharArray();
}
static int[] input(int n) {
int A[]=new int[n];
for(int i=0;i<n;i++) {
A[i]=sc.nextInt();
}
return A;
}
static long[] inputL(int n) {
long A[]=new long[n];
for(int i=0;i<n;i++) {
A[i]=sc.nextLong();
}
return A;
}
static long[] putL(long a[]) {
long A[]=new long[a.length];
for(int i=0;i<a.length;i++) {
A[i]=a[i];
}
return A;
}
static String[] inputS(int n) {
String A[]=new String[n];
for(int i=0;i<n;i++) {
A[i]=sc.next();
}
return A;
}
static int gcd(int a, int b)
{
if (a == 0)
return b;
return gcd(b % a, a);
}
static long gcd(long a, long b)
{
if (a == 0)
return b;
return gcd(b % a, a);
}
static int lcm(int a, int b)
{
return (a / gcd(a, b)) * b;
}
static String reverse(String s) {
StringBuffer p=new StringBuffer(s);
p.reverse();
return p.toString();
}
static int min(int a,int b) {
return Math.min(a, b);
}
static int min(int a,int b,int c) {
return Math.min(a, Math.min(b, c));
}
static int min(int a,int b,int c,int d) {
return Math.min(a, Math.min(b, Math.min(c, d)));
}
static int max(int a,int b) {
return Math.max(a, b);
}
static int max(int a,int b,int c) {
return Math.max(a, Math.max(b, c));
}
static int max(int a,int b,int c,int d) {
return Math.max(a, Math.max(b, Math.max(c, d)));
}
static long min(long a,long b) {
return Math.min(a, b);
}
static long min(long a,long b,long c) {
return Math.min(a, Math.min(b, c));
}
static long min(long a,long b,long c,long d) {
return Math.min(a, Math.min(b, Math.min(c, d)));
}
static long max(long a,long b) {
return Math.max(a, b);
}
static long max(long a,long b,long c) {
return Math.max(a, Math.max(b, c));
}
static long max(long a,long b,long c,long d) {
return Math.max(a, Math.max(b, Math.max(c, d)));
}
static long sum(int A[]) {
long sum=0;
for(int i : A) {
sum+=i;
}
return sum;
}
static long sum(long A[]) {
long sum=0;
for(long i : A) {
sum+=i;
}
return sum;
}
static void print(int A[]) {
for(int i : A) {
System.out.print(i+" ");
}
System.out.println();
}
static void print(long A[]) {
for(long i : A) {
System.out.print(i+" ");
}
System.out.println();
}
static long mod(long x) {
return ((x%mod + mod)%mod);
}
static long power(long x, long y)
{
if(y==0)
return 1;
if(x==0)
return 0;
long res = 1;
while (y > 0) {
if (y % 2 == 1)
res = (res * x) ;
y = y >> 1;
x = (x * x);
}
return res;
}
static boolean prime(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;
}
static boolean prime(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;
}
static long[] sort(long a[]) {
ArrayList<Long> arr = new ArrayList<>();
for(long i : a) {
arr.add(i);
}
Collections.sort(arr);
for(int i = 0; i < arr.size(); i++) {
a[i] = arr.get(i);
}
return a;
}
static int[] sort(int a[])
{
ArrayList<Integer> arr = new ArrayList<>();
for(Integer i : a) {
arr.add(i);
}
Collections.sort(arr);
for(int i = 0; i < arr.size(); i++) {
a[i] = arr.get(i);
}
return a;
}
//pair class
private static class Pair implements Comparable<Pair> {
int first, second;
public Pair(int f, int s) {
first = f;
second = s;
}
@Override
public int compareTo(Pair p) {
if (first > p.first)
return 1;
else if (first < p.first)
return -1;
else {
if (second < p.second)
return 1;
else if (second > p.second)
return -1;
else
return 0;
}
}
}
} | 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 11 | 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 | 9139c3a696c77eab37d1a77fd7e0add0 | 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.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Stack;
import java.util.StringTokenizer;
public class Main {
static long [][]memo;
static int n;
static int []a;
static int []b;
public static long dp(int idx,int line)
{
if (idx==n)
return 0;
if(memo[idx][line]!=-1)
return memo[idx][line];
long take=(line==0?a[idx]:b[idx])+dp(idx+1,1-line);
long leave=dp(idx+1,line);
return memo[idx][line]=Math.max(take, leave);
}
public static void trace(int idx,int line)
{
if (idx==n)
return;
System.out.println(idx+" "+line);
if (idx==2)
{
System.out.println(memo[idx][line]+" ha "+memo[idx+1][1-line]);
}
if (memo[idx][line]==a[idx]+memo[idx+1][1-line])
{
System.out.println("Line "+line+" "+a[idx]);
trace(idx+1,1-line);
}
else if (memo[idx][line]==b[idx]+memo[idx+1][1-line])
{
System.out.println("Line "+line+" "+b[idx]);
trace(idx+1,1-line);
}
else
{
trace(idx+1,line);
}
}
public static void main(String[] args) throws FileNotFoundException,IOException, InterruptedException {
Scanner s=new Scanner(System.in);
PrintWriter pw=new PrintWriter(System.out);
// n=s.nextInt();
// a=s.nextIntArr(n);
// b=s.nextIntArr(n);
// memo=new long[n+1][2];
// for (long[]x:memo)
// Arrays.fill(x,-1);
// pw.println(Math.max(dp(0,0),dp(0,1)));
//
// trace(0,1);
int t=s.nextInt();
outer: while (t-->0)
{
int n=s.nextInt();
char[]x=s.next().toCharArray();
int cnt=0;
int index=0;
int ops=0;
Stack<Character>st=new Stack<>();
boolean flag=true;
boolean now=true;
for (int i=0; i<n;i++)
{
if (x[i]=='(')
st.push(x[i]);
else if (!st.isEmpty() && st.peek()=='(')st.pop();
else flag=false;
if (st.isEmpty() && flag)
{
ops++;
index=i; //inclusive
now=true;
continue;
}
//Palindrome
if (x[i]=='(')
{
boolean cond1=now && i+1<n && x[i+1]=='(';
boolean cond2=!now && i+1<n && x[i+1]==')';
if (!cond1 && !cond2)
{
now=false;
continue;
}
ops++;
index=++i;
now=true;
flag=true;
st=new Stack<>();
}
else
{
boolean cond1=now && i+1<n && x[i+1]==')';
boolean cond2=!now && i+1<n && x[i+1]=='(';
if (!cond1 && !cond2)
{
now=false;
continue;
}
ops++;
index=++i;;
now=true;
flag=true;
st=new Stack<>();
}
}
pw.println(ops+" "+(ops==0?n:(n-index-1)));
//pw.println(n-index-1);
}
pw.flush();
}
static int gcd(int a, int b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
//returns INDEX
public static Integer ceiling (int []arr, int x)
{
int lower=0,upper=arr.length-1;
Integer index=-1;
while (lower<=upper)
{
int mid=lower+(upper-lower)/2;
if (arr[mid]>=x)
{
upper=mid-1;
index=mid;
}
else
lower=mid+1;
}
return index!=-1?arr[index]:(int)2e9;
}
public static Integer floor (int []arr,int x)
{
int lower=0,upper=arr.length-1;
Integer index=-1;
while (lower<=upper)
{
int mid=lower+(upper-lower)/2;
if (arr[mid]<=x)
{
lower=mid+1;
index=mid;
}
else
upper=mid-1;
}
return index!=-1?arr[index]:(int)2e9;
}
public static void permute(char []a , int l, int r)
{
if (l == r)
{
// permutation in hand here
System.out.println(Arrays.toString(a));
}
else
{
for (int i = l; i <= r; i++)
{
a= swap(a,l,i);
permute(a, l+1, r);
a = swap(a,l,i);
}
}
}
public static void permute1(char []a , int l, int r)
{
if (l == r)
{
// permutation in hand here
System.out.println(Arrays.toString(a));
}
else
{
for (int i = l; i <= r; i++)
{
a= swap(a,l,i);
permute(a, l+1, r);
a = swap(a,l,i);
}
}
}
public static char[] swap(char []a, int l, int i) {
char temp=a[l];
a[l]=a[i];
a[i]=temp;
return a;
}
public static double log2(long m)
{
double result = (double)(Math.log(m) / Math.log(2));
return result;
}
public static void shuffle(int []a)
{
for (int i=0; i<a.length;i++)
{
int randIndex=(int)(Math.random()*a.length);
int temp=a[i];
a[i]=a[randIndex];
a[randIndex]=temp;
}
}
public static void shuffle(Object []a)
{
for (int i=0; i<a.length;i++)
{
int randIndex=(int)(Math.random()*a.length);
Object temp=a[i];
a[i]=a[randIndex];
a[randIndex]=temp;
}
}
}
class Triplet {
long x,y,z;
public Triplet(long x, long y, long z)
{
this.x=x;
this.y=y;
this.z=z;
}
}
class Pair implements Comparable{
int x;
int y;
Pair(int x, int y)
{
this.x=x;
this.y=y;
}
@Override
public int compareTo(Object o) {
Pair p=(Pair)o;
return this.x-p.x;
}
public String toString()
{
return "("+x+","+y+")";
}
}
class Scanner
{
StringTokenizer st;
BufferedReader br;
public Scanner() {
br = new BufferedReader(new InputStreamReader(System.in));
}
public Scanner(String s) throws FileNotFoundException
{
br =new BufferedReader(new FileReader(s));
}
public Scanner(InputStream s){ br = new BufferedReader(new InputStreamReader(s));}
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[] nextLongArr(int n) throws IOException {
long[] arr = new long[n];
for (int i = 0; i < n; i++)
arr[i] = nextLong();
return arr;
}
public int[] nextIntArr(int n) throws IOException {
int[] arr = new int[n];
for (int i = 0; i < arr.length; i++)
arr[i] = nextInt();
return arr;
}
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 11 | 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 | c0d75c18c96d3323909fac79be770e82 | 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_Bracket_Sequence_Deletion{
public static void main(String[] args) throws Exception{
FastReader fr = new FastReader(System.in);
int t = fr.nextInt();
while(t-->0){
int n = fr.nextInt();
String input = fr.next();
int opCount = 0;
int left = 0;
while(left<input.length()-1){
if(input.charAt(left)=='('){
left+=2;
opCount++;
}else{
int right = left+1;
while(right<input.length() && input.charAt(right)=='('){
right++;
}
if(right<input.length()){
opCount++;
left=right+1;
}else{
break;
}
}
}
System.out.println(opCount+" "+(input.length()-left));
}
}
public static void print(Object val){
System.out.print(val);
}
public static void println(Object val){
System.out.println(val);
}
public static int[] sort(int[] vals){
ArrayList<Integer> values = new ArrayList<>();
for(int i = 0;i<vals.length;i++){
values.add(vals[i]);
}
Collections.sort(values);
for(int i =0;i<values.size();i++){
vals[i] = values.get(i);
}
return vals;
}
public static long[] sort(long[] vals){
ArrayList<Long> values = new ArrayList<>();
for(int i = 0;i<vals.length;i++){
values.add(vals[i]);
}
Collections.sort(values);
for(int i =0;i<values.size();i++){
vals[i] = values.get(i);
}
return vals;
}
public static void reverseArray(long[] vals){
int startIndex = 0;
int endIndex = vals.length-1;
while(startIndex<=endIndex){
long temp = vals[startIndex];
vals[startIndex] = vals[endIndex];
vals[endIndex] = temp;
startIndex++;
endIndex--;
}
}
public static void reverseArray(int[] vals){
int startIndex = 0;
int endIndex = vals.length-1;
while(startIndex<=endIndex){
int temp = vals[startIndex];
vals[startIndex] = vals[endIndex];
vals[endIndex] = temp;
startIndex++;
endIndex--;
}
}
static class FastReader{
byte[] buf = new byte[2048];
int index, total;
InputStream in;
FastReader(InputStream is) {
in = is;
}
int scan() throws IOException {
if (index >= total) {
index = 0;
total = in.read(buf);
if (total <= 0) {
return -1;
}
}
return buf[index++];
}
String next() throws IOException {
int c;
for (c = scan(); c <= 32; c = scan());
StringBuilder sb = new StringBuilder();
for (; c > 32; c = scan()) {
sb.append((char) c);
}
return sb.toString();
}
int nextInt() throws IOException {
int c, val = 0;
for (c = scan(); c <= 32; c = scan());
boolean neg = c == '-';
if (c == '-' || c == '+') {
c = scan();
}
for (; c >= '0' && c <= '9'; c = scan()) {
val = (val << 3) + (val << 1) + (c & 15);
}
return neg ? -val : val;
}
long nextLong() throws IOException {
int c;
long val = 0;
for (c = scan(); c <= 32; c = scan());
boolean neg = c == '-';
if (c == '-' || c == '+') {
c = scan();
}
for (; c >= '0' && c <= '9'; c = scan()) {
val = (val << 3) + (val << 1) + (c & 15);
}
return neg ? -val : val;
}
}
public static int GCD(int numA, int numB){
if(numA==0){
return numB;
}else if(numB==0){
return numA;
}else{
if(numA>numB){
return GCD(numA%numB,numB);
}else{
return GCD(numA,numB%numA);
}
}
}
}
| 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 11 | 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 | 56d1e4d123d9e71b190527cad9dbfc14 | 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 claas{
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 ans=0;
int i=0;
while(i<n) {
if(s.charAt(i)=='(') {
if(i+2>n) break;
ans++;
i+=2;
}
else {
boolean check=true;
for(int j=i+1;j<n;j++) {
if(s.charAt(j)==')') {
ans++;
check=false;
i=j+1;
break;
}
}
if(check) {
break;
}
}
}
System.out.print(ans+" "+(n-i));
System.out.println();
}
}
} | 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 11 | 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 | 25ab37746f7d756a21210cb571aee23b | 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.max;
import static java.lang.Math.min;
import static java.lang.Math.abs;
import java.util.*;
import java.io.*;
import java.math.*;
public class C_Bracket_Sequence_Deletion {
public static void main(String[] args) {
OutputStream outputStream = System.out;
PrintWriter out = new PrintWriter(outputStream);
FastReader f = new FastReader();
int t = f.nextInt();
while(t-- > 0){
solve(f, out);
}
out.close();
}
public static void solve(FastReader f, PrintWriter out) {
int n = f.nextInt();
String s = f.nextLine();
int regularTrack = 0;
int operationCount = 0;
int lastProssesdInd = -1;
for(int i = 0; i < n; i++) {
if(regularTrack >= 0) {
if(s.charAt(i) == '(') {
regularTrack++;
} else {
regularTrack--;
}
}
if(regularTrack == 0) {
operationCount++;
lastProssesdInd = i;
} else if((i-lastProssesdInd) > 1 && isPal(s, lastProssesdInd, i)) {
operationCount++;
regularTrack = 0;
lastProssesdInd = i;
}
}
out.print(operationCount + " ");
out.println(n - 1 - lastProssesdInd);
}
public static boolean isPal(String s, int lastProssesdInd, int i) {
int start = lastProssesdInd+1;
int end = i;
while(end > start) {
if(s.charAt(start) != s.charAt(end)) {
return false;
}
start++;
end--;
}
return true;
}
public static void sort(int arr[]) {
ArrayList<Integer> al = new ArrayList<>();
for(int i: arr) {
al.add(i);
}
Collections.sort(al);
for(int i = 0; i < arr.length; i++) {
arr[i] = al.get(i);
}
}
public static void allDivisors(int n) {
for(int i = 1; i*i <= n; i++) {
if(n%i == 0) {
System.out.println(i + " ");
if(i != n/i) {
System.out.println(n/i + " ");
}
}
}
}
public static boolean isPrime(int n) {
if(n < 1) return false;
if(n == 2 || 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;
}
public static int gcd(int a, int b) {
int dividend = a > b ? a : b;
int divisor = a < b ? a : b;
while(divisor > 0) {
int reminder = dividend % divisor;
dividend = divisor;
divisor = reminder;
}
return dividend;
}
public static int lcm(int a, int b) {
int lcm = gcd(a, b);
int hcf = (a * b) / lcm;
return hcf;
}
public static String sortString(String inputString) {
char tempArray[] = inputString.toCharArray();
Arrays.sort(tempArray);
return new String(tempArray);
}
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());
}
float nextFloat() {
return Float.parseFloat(next());
}
boolean nextBoolean() {
return Boolean.parseBoolean(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
}
catch (IOException e) {
e.printStackTrace();
}
return str;
}
int[] nextArray(int n) {
int[] a = new int[n];
for(int i=0; i<n; i++) {
a[i] = nextInt();
}
return a;
}
}
}
/**
Dec Char Dec Char Dec Char Dec Char
--------- --------- --------- ----------
0 NUL (null) 32 SPACE 64 @ 96 `
1 SOH (start of heading) 33 ! 65 A 97 a
2 STX (start of text) 34 " 66 B 98 b
3 ETX (end of text) 35 # 67 C 99 c
4 EOT (end of transmission) 36 $ 68 D 100 d
5 ENQ (enquiry) 37 % 69 E 101 e
6 ACK (acknowledge) 38 & 70 F 102 f
7 BEL (bell) 39 ' 71 G 103 g
8 BS (backspace) 40 ( 72 H 104 h
9 TAB (horizontal tab) 41 ) 73 I 105 i
10 LF (NL line feed, new line) 42 * 74 J 106 j
11 VT (vertical tab) 43 + 75 K 107 k
12 FF (NP form feed, new page) 44 , 76 L 108 l
13 CR (carriage return) 45 - 77 M 109 m
14 SO (shift out) 46 . 78 N 110 n
15 SI (shift in) 47 / 79 O 111 o
16 DLE (data link escape) 48 0 80 P 112 p
17 DC1 (device control 1) 49 1 81 Q 113 q
18 DC2 (device control 2) 50 2 82 R 114 r
19 DC3 (device control 3) 51 3 83 S 115 s
20 DC4 (device control 4) 52 4 84 T 116 t
21 NAK (negative acknowledge) 53 5 85 U 117 u
22 SYN (synchronous idle) 54 6 86 V 118 v
23 ETB (end of trans. block) 55 7 87 W 119 w
24 CAN (cancel) 56 8 88 X 120 x
25 EM (end of medium) 57 9 89 Y 121 y
26 SUB (substitute) 58 : 90 Z 122 z
27 ESC (escape) 59 ; 91 [ 123 {
28 FS (file separator) 60 < 92 \ 124 |
29 GS (group separator) 61 = 93 ] 125 }
30 RS (record separator) 62 > 94 ^ 126 ~
31 US (unit separator) 63 ? 95 _ 127 DEL
*/
| 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 11 | 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 | 7264ad8c6a35fcef2cf4b515d2f963df | 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.max;
import static java.lang.Math.min;
import static java.lang.Math.abs;
import java.util.*;
import java.io.*;
import java.math.*;
public class C_Bracket_Sequence_Deletion {
public static void main(String[] args) {
OutputStream outputStream = System.out;
PrintWriter out = new PrintWriter(outputStream);
FastReader f = new FastReader();
int t = f.nextInt();
while(t-- > 0){
solve(f, out);
}
out.close();
}
public static void solve(FastReader f, PrintWriter out) {
int n = f.nextInt();
String s = f.nextLine();
int regularTrack = 0;
int operationCount = 0;
int lastProssesdInd = -1;
for(int i = 0; i < n; i++) {
if(regularTrack >= 0) {
if(s.charAt(i) == '(') {
regularTrack++;
} else {
regularTrack--;
}
}
if(regularTrack == 0) {
operationCount++;
lastProssesdInd = i;
} else if((i-lastProssesdInd) > 1 && isPas(s, lastProssesdInd, i)) {
operationCount++;
regularTrack = 0;
lastProssesdInd = i;
}
}
out.print(operationCount + " ");
out.println(n - 1 - lastProssesdInd);
}
// public static boolean func(int lastProssesdInd, int i, String s) {
// StringBuilder sb = new StringBuilder(s.substring(i+1 - (i-lastProssesdInd)/2, i+1));
// return (s.substring(lastProssesdInd+1+(i-lastProssesdInd)/2).equals(sb.reverse().toString()));
// }
public static boolean isPas(String s, int lastProssesdInd, int i) {
int start = lastProssesdInd+1;
int end = i;
while(end > start) {
if(s.charAt(start) != s.charAt(end)) {
return false;
}
start++;
end--;
}
return true;
}
public static void sort(int arr[]) {
ArrayList<Integer> al = new ArrayList<>();
for(int i: arr) {
al.add(i);
}
Collections.sort(al);
for(int i = 0; i < arr.length; i++) {
arr[i] = al.get(i);
}
}
public static void allDivisors(int n) {
for(int i = 1; i*i <= n; i++) {
if(n%i == 0) {
System.out.println(i + " ");
if(i != n/i) {
System.out.println(n/i + " ");
}
}
}
}
public static boolean isPrime(int n) {
if(n < 1) return false;
if(n == 2 || 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;
}
public static int gcd(int a, int b) {
int dividend = a > b ? a : b;
int divisor = a < b ? a : b;
while(divisor > 0) {
int reminder = dividend % divisor;
dividend = divisor;
divisor = reminder;
}
return dividend;
}
public static int lcm(int a, int b) {
int lcm = gcd(a, b);
int hcf = (a * b) / lcm;
return hcf;
}
public static String sortString(String inputString) {
char tempArray[] = inputString.toCharArray();
Arrays.sort(tempArray);
return new String(tempArray);
}
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());
}
float nextFloat() {
return Float.parseFloat(next());
}
boolean nextBoolean() {
return Boolean.parseBoolean(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
}
catch (IOException e) {
e.printStackTrace();
}
return str;
}
int[] nextArray(int n) {
int[] a = new int[n];
for(int i=0; i<n; i++) {
a[i] = nextInt();
}
return a;
}
}
}
/**
Dec Char Dec Char Dec Char Dec Char
--------- --------- --------- ----------
0 NUL (null) 32 SPACE 64 @ 96 `
1 SOH (start of heading) 33 ! 65 A 97 a
2 STX (start of text) 34 " 66 B 98 b
3 ETX (end of text) 35 # 67 C 99 c
4 EOT (end of transmission) 36 $ 68 D 100 d
5 ENQ (enquiry) 37 % 69 E 101 e
6 ACK (acknowledge) 38 & 70 F 102 f
7 BEL (bell) 39 ' 71 G 103 g
8 BS (backspace) 40 ( 72 H 104 h
9 TAB (horizontal tab) 41 ) 73 I 105 i
10 LF (NL line feed, new line) 42 * 74 J 106 j
11 VT (vertical tab) 43 + 75 K 107 k
12 FF (NP form feed, new page) 44 , 76 L 108 l
13 CR (carriage return) 45 - 77 M 109 m
14 SO (shift out) 46 . 78 N 110 n
15 SI (shift in) 47 / 79 O 111 o
16 DLE (data link escape) 48 0 80 P 112 p
17 DC1 (device control 1) 49 1 81 Q 113 q
18 DC2 (device control 2) 50 2 82 R 114 r
19 DC3 (device control 3) 51 3 83 S 115 s
20 DC4 (device control 4) 52 4 84 T 116 t
21 NAK (negative acknowledge) 53 5 85 U 117 u
22 SYN (synchronous idle) 54 6 86 V 118 v
23 ETB (end of trans. block) 55 7 87 W 119 w
24 CAN (cancel) 56 8 88 X 120 x
25 EM (end of medium) 57 9 89 Y 121 y
26 SUB (substitute) 58 : 90 Z 122 z
27 ESC (escape) 59 ; 91 [ 123 {
28 FS (file separator) 60 < 92 \ 124 |
29 GS (group separator) 61 = 93 ] 125 }
30 RS (record separator) 62 > 94 ^ 126 ~
31 US (unit separator) 63 ? 95 _ 127 DEL
*/
| 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 11 | 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 | dc94e453f77d241d3bab55c803c33bcf | 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.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class C1657 {
public static void main(String[] args) {
FastReader fs = new FastReader();
int t = fs.nextInt();
StringBuilder sb = new StringBuilder();
while (t-- > 0) {
int n = fs.nextInt();
char[] arr = fs.nextLine().toCharArray();
int operations = 0, idx = 0;
boolean flag = true;
for (int i = 0; i < n; i++) {
if (arr[i] == '(' && flag) {
operations += (i + 1) < n ? 1 : 0;
idx = (i + 1) < n ? i + 2 : i;
i++;
} else if (arr[i] == ')' && flag) {
flag = false;
} else if (arr[i] == ')' && !flag) {
flag = true;
operations++;
idx = (i + 1) <= n ? i + 1 : i;
}
}
sb.append(operations).append(" ").append(n - idx).append("\n");
}
System.out.println(sb);
}
private static int lowerBound(long[] arr, long val, int start) {
int low = 0, high = arr.length - 1;
while (low <= high) {
int mid = (low + high) / 2;
if (arr[mid] >= val) {
high = mid - 1;
} else {
low = mid + 1;
}
}
return low;
}
private static int upperBound(long[] arr, long val, int start) {
int low = start, high = arr.length - 1;
while (low < high) {
int mid = (low + high) / 2;
if (arr[mid] <= val) {
low = mid + 1;
} else {
high = mid;
}
}
return low;
}
private static boolean isPrime(long num) {
if (num == 2L) {
return true;
}
for (long i = 2; i * i <= num; i++) {
if (num % i == 0) {
return false;
}
}
return true;
}
private static long getGcd(long a, long b) {
if (b == 0) return a;
return getGcd(b, a % b);
}
private static long binaryExponentiation(long a, long b) {
long res = 1;
while (b > 0) {
if ((b & 1) == 1) res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
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;
}
long[] readArray(int n) {
long[] arr = new long[n];
for (int i = 0; i < n; i++) arr[i] = Integer.parseInt(next());
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 11 | 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 | 5c1272a1769d6c701b6e0356829b3a54 | 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.Stack;
import java.util.StringTokenizer;
import static java.lang.Double.parseDouble;
import static java.lang.Integer.parseInt;
import static java.lang.Long.parseLong;
import static java.lang.System.in;
import static java.lang.System.out;
public class Bracket_Sequence_Deletion {
public static void main(String[] args) {
try {
FastReader in = new FastReader();
FastWriter out = new FastWriter();
int test = in.nextInt();
while (test > 0) {
//Your Code Here
int n = in.nextInt();
String s = in.next();
calc(n, s);
test--;
}
out.close();
} catch (Exception e) {
return;
}
}
private static void calc(int n, String s) {
char begin = 'n';
int last_index = -1;
int change = -1;
int count = 0;
boolean stack = false;
boolean stack_input = false;
Stack<Character> record = new Stack<>();
for (int i = 0; i < n; i++) {
if (begin == 'n') {
begin = s.charAt(i);
change = i;
}
if (s.charAt(i) == '(') {
stack_input = false;
record.add('(');
} else if (s.charAt(i) == ')' && !record.empty()) {
record.pop();
if (record.empty()) {
stack_input = true;
}
} else if (s.charAt(i) == ')' && record.empty()) {
stack = true;
}
if ((s.charAt(i) == begin && begin != 'n' && change != i)) {
last_index = i;
count++;
record.removeAllElements();
stack_input = false;
stack = false;
begin = 'n';
// out.println(last_index);
} else if (stack_input && !stack) {
last_index = i;
count++;
begin = 'n';
stack_input = false;
stack = false;
}
}
if (last_index == -1) {
out.println(0 + " " + s.length());
} else {
out.println(count + " " + (s.length() - 1 - last_index));
}
}
static class FastWriter {
private final BufferedWriter bw;
public FastWriter() {
this.bw = new BufferedWriter(new OutputStreamWriter(out));
}
public void print(Object object) throws IOException {
bw.append("" + object);
}
public void println(Object object) throws IOException {
print(object);
bw.append("\n");
}
public void close() throws IOException {
bw.close();
}
}
public static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
br = new BufferedReader(new InputStreamReader(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 parseInt(next());
}
long nextLong() {
return parseLong(next());
}
double nextDouble() {
return parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine().trim();
} catch (Exception 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 11 | 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 | d25772d100d53779f1e5b2637a1defbe | 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 CF1657C extends PrintWriter {
CF1657C() { super(System.out); }
Scanner sc = new Scanner(System.in);
public static void main(String[] $) {
CF1657C o = new CF1657C(); o.main(); o.flush();
}
void main() {
int t = sc.nextInt();
while (t-- > 0) {
int n = sc.nextInt();
byte[] cc = sc.next().getBytes();
int k = 0, i = 0;
while (i + 1 < n)
if (cc[i] == cc[i + 1] || cc[i] == '(' && cc[i + 1] == ')') {
k++;
i += 2;
} else {
int j = i + 1;
while (j < n && cc[j] == '(')
j++;
if (j == n)
break;
k++;
i = j + 1;
}
println(k + " " + (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 11 | 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 | 74f20a5b5b009dedaccf83ac52acbc96 | 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 cf;
import java.util.Scanner;
public class barket_sequence {
static boolean pd(int l,int r,String a) {
int n=(r-l+1)/2;
//System.out.println(n);
for(int i=0;i<n;++i) {
if(a.charAt(l+i)!=a.charAt(r-i))return false;
}
return true;
}
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
while(n>0) {
n--;
int len=sc.nextInt();
String a=sc.next();
int c=0;
int l=0;
while(l<a.length()-1) {
if(a.charAt(l)=='(') {
l+=2;
++c;
}
else if(a.charAt(l)==a.charAt(l+1)) {
l+=2;
++c;
}
else {
int r=l+1;
for(;r<a.length();++r)
if(pd(l,r,a)) {
++c;
//System.out.println(c+" "+l);
l=r+1;
break;
}
if(r==len)break;
}
}
//System.out.println();
System.out.println(c+" "+(a.length()-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 11 | 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 | 6577d4b98da0e32fd9315ca7bd4ff8c6 | 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.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Scanner;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
Scanner in = new Scanner(inputStream);
PrintWriter out = new PrintWriter(outputStream);
TaskC solver = new TaskC();
solver.solve(1, in, out);
out.close();
}
static class TaskC {
public void solve(int testNumber, Scanner in, PrintWriter out) {
int T = in.nextInt();
while (T-- > 0) {
solveOne(in, out);
}
}
private void solveOne(Scanner in, PrintWriter out) {
int N = in.nextInt();
char[] chars = in.next().toCharArray();
int idx = 0, ops = 0;
int len = N;
while (idx < N) {
if (chars[idx] == '(' && idx + 1 < N) {
ops++;
idx++;
len -= 2;
} else if (chars[idx] == ')') {
int local = 1;
while (idx + 1 < N) {
idx++;
local++;
if (chars[idx] == ')') {
ops++;
len -= local;
break;
}
}
}
if (idx + 1 == N) {
break;
}
idx++;
}
L.print(out, ops, len);
}
}
static class L {
public static void print(PrintWriter out, int... v1) {
StringBuilder sb = new StringBuilder();
for (int v : v1) sb.append(v).append(" ");
out.println(sb.toString().trim());
}
}
}
| 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 11 | 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 | a022867eff5b894fe9a259e6ae036b9b | 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.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Scanner;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
Scanner in = new Scanner(inputStream);
PrintWriter out = new PrintWriter(outputStream);
TaskC solver = new TaskC();
solver.solve(1, in, out);
out.close();
}
static class TaskC {
public void solve(int testNumber, Scanner in, PrintWriter out) {
int T = in.nextInt();
while (T-- > 0) {
solveOne(in, out);
}
}
private void solveOne(Scanner in, PrintWriter out) {
int N = in.nextInt();
char[] chars = in.next().toCharArray();
int idx = 0, ops = 0;
int len = N;
while (idx < N) {
if (chars[idx] == '(') {
if (idx + 1 < N) {
ops++;
idx += 2;
len -= 2;
} else break;
} else if (chars[idx] == ')') {
int local = 1;
if (idx + 1 == N) {
break;
}
while (idx + 1 < N) {
idx++;
local++;
if (chars[idx] == ')') {
ops++;
idx++;
len -= local;
break;
}
}
}
}
L.print(out, ops, len);
}
}
static class L {
public static void print(PrintWriter out, int... v1) {
StringBuilder sb = new StringBuilder();
for (int v : v1) sb.append(v).append(" ");
out.println(sb.toString().trim());
}
}
}
| 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 11 | 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 | 7a735eefd7ef4de44d44f52ffc6238e8 | 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.util.*;
public class Solution {
public static void main(String[] args) throws IOException {
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
StringBuilder ansStr = new StringBuilder();
while (t-->0){
int n = sc.nextInt();
String s = sc.next();
StringBuilder sb = new StringBuilder();
int start = 0;
boolean isValid = s.charAt(start) == '(';
sb.append(s.charAt(start));
int value = isValid ? 1 : -1;
int ans = 0;
for(int i=1;i<n;i++){
value += (s.charAt(i)=='(' ? +1 : -1);
sb.append(s.charAt(i));
if(isValid &&value==0){
ans++;
start = i+1;
if(start<n) {
i++;
isValid = s.charAt(start) == '(';
sb = new StringBuilder();
sb.append(s.charAt(start));
value = isValid ? 1 : -1;
}
}else {
if(isPalindrom(sb)){
ans++;
start = i+1;
if(start<n) {
i++;
isValid = s.charAt(start) == '(';
sb = new StringBuilder();
sb.append(s.charAt(start));
value = isValid ? 1 : -1;
}
}
}
}
ansStr.append(ans +" "+(s.length()-start));
ansStr.append("\n");
}
System.out.println(ansStr.toString().trim());
}
private static boolean isPalindrom(StringBuilder sb) {
int len = sb.length();
for(int i=0;i<len/2;i++){
if(sb.charAt(i) != sb.charAt(len-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 11 | 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 | 4e14eade9bf803effa3d9f95fd0f6077 | 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 Scanner sc = new Scanner(System.in);
static StringBuilder out = new StringBuilder();
static String testCase = "Case #";
static long mod = 998244353;
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
int t = sc.nextInt();
int tc = 0;
while (tc++ < t) {
Solution run = new Solution();
run.run();
}
System.out.println(out);
}
static ArrayList<Integer> gr[];
static HashMap<Integer,Integer> hs;
static String s;
public void run() throws IOException {
int n=sc.nextInt();
String s=sc.next();
int i=0;
int cnt=0;
while(i<n) {
if(i+1>=n)break;
if(s.charAt(i)=='(')i+=2;
else {
int j=i+1;
while(j<n && s.charAt(j)!=')')j++;
if(j<n)
i=j+1;
else break;
}
cnt++;
}
out.append(cnt+" "+(n-i)+"\n");
}
static int getParent(int x, int par[]) {
if (x == par[x])
return x;
par[x] = getParent(par[par[x]], par);
return par[x];
}
static int bit[];
static void modify(int x, int val) {
for (; x < bit.length; x += (x & -x))
bit[x] += val;
}
static int get(int x) {
int sum = 0;
for (; x > 0; x -= (x & -x))
sum += bit[x];
return sum;
}
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 = 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 class Reader {
final private int BUFFER_SIZE = 1 << 16;
private DataInputStream din;
private byte[] buffer;
private int bufferPointer, bytesRead;
public Reader() {
din = new DataInputStream(System.in);
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public Reader(String file_name) throws IOException {
din = new DataInputStream(new FileInputStream(file_name));
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public String readLine() throws IOException {
byte[] buf = new byte[64]; // line length
int cnt = 0, c;
while ((c = read()) != -1) {
if (c == '\n') {
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;
}
public long nextLong() 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 nextDouble() 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();
}
}
}
| 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 11 | 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 | adabb561a9423e3b64dacfd00db6d4e0 | 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 cp1 {
public static void main(String[] args)throws Exception {
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
int t=Integer.parseInt(br.readLine());
while(t-->0) {
int n=Integer.parseInt(br.readLine());
String s1=br.readLine();
char c[]=new char[n];
c=s1.toCharArray();
int pos=0;int op=0,nd=n;
boolean b=true;
while(pos<=n-2) {
if(c[pos]==c[pos+1]) {
op++;
nd-=2;
pos=pos+2;
}
else if(c[pos]=='('&&c[pos+1]==')') {
op++;
nd-=2;
pos=pos+2;
}
else {
int index=pos;
for(int i=index+1;i<=n-1;i++) {
if(c[i]==')') {
nd=n-(i+1);
pos=i+1;
op++;
break;
}
pos++;
if(i>=n-1)
{break;}
}
}
}
System.out.println(op+" "+nd);
}
}
} | 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 11 | 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 | 3a16d61af48dfc689859ea4328a16f20 | 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.swing.plaf.synth.SynthPasswordFieldUI;
import java.io.*;
public class 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;
}
}
public static void main(String args[]) {
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
while (t-- > 0) {
int n = sc.nextInt();
sc.nextLine();
String s = sc.nextLine();
int cnt = 0;
int i = 0;
for (; i < n;) {
if (i == n - 1) {
break;
}
if (s.charAt(i) == '(') {
i = i + 2;
cnt++;
} else {
int j = i + 1;
for (; j < n; j++) {
if (s.charAt(j) == ')') {
break;
}
}
if (j < n) {
i = j + 1;
cnt++;
} else
break;
}
}
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 11 | 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 | f98c36d5f89c8d5d23f81b49c5c5d25c | 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.*;
import java.util.*;
public class BracketSequenceDeletion {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner s = new Scanner(System.in);
int t = s.nextInt();
while(t-- > 0) {
int n = s.nextInt();
String st = s.next();
int i = 0;
int c = 0;
int r = 0;
while(i < n) {
char ch = st.charAt(i);
if(ch == '(') {
if(i == n - 1) {
r = 1;
i++;
}
else {
c++;
i += 2;
r = n - i;
}
}
else {
int j = i + 1;
while(j < n && st.charAt(j) != ')') {
j++;
}
if(j == n)
{
r = n - i;
i = n;
}
else
{
i = j + 1;
r = n - i;
c++;
}
}
}
System.out.println(c + " " + r);
}
}
}
| 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 11 | 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 | 9e7fdc693e7edd6920589927cfb37624 | 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.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;
import java.math.BigInteger;
public final class Main{
static class Reader {
final private int BUFFER_SIZE = 1 << 16;
private DataInputStream din;
private byte[] buffer;
private int bufferPointer, bytesRead;
public Reader() {
din = new DataInputStream(System.in);
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public Reader(String file_name) throws IOException {
din = new DataInputStream(
new FileInputStream(file_name));
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public String readLine() throws IOException {
byte[] buf = new byte[64]; // line length
int cnt = 0, c;
while ((c = read()) != -1) {
if (c == '\n') {
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;
}
public long nextLong() 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 nextDouble() 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();
}
}
static class Kattio extends PrintWriter {
private BufferedReader r;
private StringTokenizer st;
// standard input
public Kattio() { this(System.in, System.out); }
public Kattio(InputStream i, OutputStream o) {
super(o);
r = new BufferedReader(new InputStreamReader(i));
}
// USACO-style file input
public Kattio(String problemName) throws IOException {
super(new FileWriter(problemName + ".out"));
r = new BufferedReader(new FileReader(problemName + ".in"));
}
// returns null if no more input
public String next() {
try {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(r.readLine());
return st.nextToken();
} catch (Exception e) { }
return null;
}
public int nextInt() { return Integer.parseInt(next()); }
public double nextDouble() { return Double.parseDouble(next()); }
public long nextLong() { return Long.parseLong(next()); }
}
static Kattio sc = new Kattio();
static long mod = 998244353l;
static PrintWriter out =new PrintWriter(System.out);
//Heapify function to maintain heap property.
public static void swap(int i,int j,int arr[]) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
static String endl = "\n" , gap = " ";
public static int ans;
public static void main(String[] args)throws IOException {
int t = ri();
while(t-->0) {
solve();
}
out.close();
}
static int move = 0;
public static void solve()throws IOException {
int n = ri();
char s[] = rac();
move = 0;
int ans = callfun(s , 0);
// System.out.println(ans + "is ans ");
System.out.print(move + " ");
// System.out.println("is ");
System.out.println(ans);
}
public static int callfun(char s[] , int start) {
int n = s.length;
Stack<Integer> v = new Stack<>();
Stack<Integer> p = new Stack<>();
for(int i =start;i<n;i++) {
if(v.size() == 0 || s[i] == '(') {
v.push(i);
}
else {
if(s[v.peek()] == '(') {
v.pop();
if(v.size() ==0 ){
move++;
p.clear();
continue;
// return callfun(s , i + 1);
}
}
else v.push(i);
}
if(p.size() == 0) {
p.add(i);
}
else {
if(s[i] == s[p.peek()]) {
p.pop();
if(p.size() ==0 ) {
move++;
v.clear();
continue;
// return callfun(s , i + 1);
}
}
else {
if(p.size() == 2){
int t = p.pop();
if(s[p.peek()] == s[i]) {
move++;
p.clear();
v.clear();
continue;
// return callfun(s , i + 1);
}
p.add(t);
}
p.add(i);
}
}
}
// System.out.println(p + " " + v);
if(v.size() == 0 || p.size() == 0) return 0;
int min = s.length;
while(v.size() > 0) {
min = Math.min(min , v.pop());
}
while(p.size() > 0) {
min = Math.min(min , p.pop());
}
return (n-1)-min + 1;
}
public static long get(long a) {
long ans = 1;
for(long i = (long)Math.sqrt(a);i>=1;i--) {
if(i*(i+1l)/2l <= a) return i;
}
return ans;
}
public static long get2(long a) {
long ans = 1;
for(long i = (long)Math.sqrt(a);i>=1;i--) {
if(i*(i+1)/2 < a ) return ans;
ans = i;
}
return 1l;
}
public static long rl() {
return sc.nextLong();
}
public static char[] rac() {
return sc.next().toCharArray();
}
public static String rs() {
return sc.next();
}
public static char rc() {
return sc.next().charAt(0);
}
public static int [] rai(int n) {
int ans[] = new int[n];
for(int i =0;i<n;i++) {
ans[i] = sc.nextInt();
}
return ans;
}
public static long [] ral(int n) {
long ans[] = new long[n];
for(int i =0;i<n;i++) {
ans[i] = sc.nextLong();
}
return ans;
}
public static int ri() {
return sc.nextInt();
}
public static int getValue(int num ) {
int ans = 0;
while(num > 0) {
ans++;
num = num&(num-1);
}
return ans;
}
public static boolean isValid(int x ,int y , int n,char arr[][],boolean visited[][][][]) {
return x>=0 && x<n && y>=0 && y <n && !(arr[x][y] == '#');
}
// public static Pair join(Pair a , Pair b) {
// Pair res = new Pair(Math.min(a.min , b.min) , Math.max(a.max , b.max) , a.count + b.count);
// return res;
// }
// segment tree query over range
// public static int query(int node,int l , int r,int a,int b ,Pair tree[] ) {
// if(tree[node].max < a || tree[node].min > b) return 0;
// if(l > r) return 0;
// if(tree[node].min >= a && tree[node].max <= b) {
// return tree[node].count;
// }
// int mid = l + (r-l)/2;
// int ans = query(node*2 ,l , mid ,a , b , tree) + query(node*2 +1,mid + 1, r , a , b, tree);
// return ans;
// }
// // segment tree update over range
// public static void update(int node, int i , int j ,int l , int r,long value, long arr[] ) {
// if(l >= i && j >= r) {
// arr[node] += value;
// return;
// }
// if(j < l|| r < i) return;
// int mid = l + (r-l)/2;
// update(node*2 ,i ,j ,l,mid,value, arr);
// update(node*2 +1,i ,j ,mid + 1,r, value , arr);
// }
public static long pow(long a , long b , long mod) {
if(b == 1) return a;
if(b == 0) return 1;
long ans = pow(a , b/2 , mod)%mod;
if(b%2 == 0) {
return (ans*ans)%mod;
}
else {
return ((ans*ans)%mod*a)%mod;
}
}
public static boolean isVowel(char ch) {
if(ch == 'a' || ch == 'e'||ch == 'i' || ch == 'o' || ch == 'u') return true;
return false;
}
public static int getFactor(int num) {
if(num==1) return 1;
int ans = 2;
int k = num/2;
for(int i = 2;i<=k;i++) {
if(num%i==0) ans++;
}
return Math.abs(ans);
}
public static int[] readarr()throws IOException {
int n = sc.nextInt();
int arr[] = new int[n];
for(int i =0;i<n;i++) {
arr[i] = sc.nextInt();
}
return arr;
}
public static boolean isPowerOfTwo (long x) {
return x!=0 && ((x&(x-1)) == 0);
}
public static boolean isPrime(long num) {
if(num==1) return false;
if(num<=3) return true;
if(num%2==0||num%3==0) return false;
for(long i =5;i*i<=num;i+=6) {
if(num%i==0 || num%(i+2) == 0) return false;
}
return true;
}
// public static boolean isPrime(long num) {
// if(num==1) return false;
// if(num<=3) return true;
// if(num%2==0||num%3==0) return false;
// for(int i =5;i*i<=num;i+=6) {
// if(num%i==0) return false;
// }
// return true;
// }
public static long gcd(long a , long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
public static long get_gcd(long a , long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
// public static long fac(long num) {
// long ans = 1;
// int mod = (int)1e9+7;
// for(long i = 2;i<=num;i++) {
// ans = (ans*i)%mod;
// }
// return ans;
// }
} | 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 11 | 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 | 26ae92798486d31c31b89719dda7c76f | 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.max;
import static java.lang.Math.min;
import static java.lang.Math.abs;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;
import java.io.BufferedReader;
import java.util.StringTokenizer;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class Problem_C {
private final static int INF = 1_000_000_005;
public static void main(String[] dummy) {
MyScanner ms = new MyScanner();
PrintStream out = new PrintStream(System.out);
int testcases = ms.nextInt();
while (testcases-- > 0) {
int N = ms.nextInt();
char[] s = ms.next().toCharArray();
int ans = 0;
int start = 0;
for (int i = 0; i < N;) {
if (s[i] == ')') {
i++;
while (i < N && s[i] == '(') i++;
if (i < N && s[i] == ')') {
ans++;
i++;
start = i;
}
} else {
if (i + 1 < N) {
ans++;
start += 2;
}
i += 2;
}
}
int remaining = N - start;
out.println(ans + " " + remaining);
}
out.flush();
out.close();
}
public static void reverseSort(int[] A) { // TODO : Collections.sort always uses Merge sort
ArrayList<Integer> sorted = new ArrayList<>();
for (int x : A)
sorted.add(x);
Collections.sort(sorted, (x, y) -> Integer.compare(y, x));
for (int i = 0; i < A.length; i++)
A[i] = sorted.get(i);
}
static class MyScanner {
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 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;
}
}
}
| 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 11 | 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 | 1d05cbae69f2fc165461b651d83ac739 | 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.max;
import static java.lang.Math.min;
import static java.lang.Math.abs;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;
import java.io.BufferedReader;
import java.util.StringTokenizer;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class Problem_C {
private final static int INF = 1_000_000_005;
public static void main(String[] dummy) {
MyScanner ms = new MyScanner();
PrintStream out = new PrintStream(System.out);
int testcases = ms.nextInt();
while (testcases-- > 0) {
int N = ms.nextInt();
char[] s = ms.next().toCharArray();
if (N == 1) {
out.println("0 " + "1");
continue;
}
int ans = 0;
int start = 0;
String curr = "";
boolean flag = true;
for (int i = 0; i < N;) {
if (s[i] == ')') {
i++;
while (i < N && s[i] == '(') i++;
if (i < N && s[i] == ')') {
ans++;
i++;
start = i;
}
} else {
if (i + 1 < N) {
ans++;
start += 2;
}
i += 2;
}
}
int remaining = N - start;
out.println(ans + " " + remaining);
}
out.flush();
out.close();
}
public static void reverseSort(int[] A) { // TODO : Collections.sort always uses Merge sort
ArrayList<Integer> sorted = new ArrayList<>();
for (int x : A)
sorted.add(x);
Collections.sort(sorted, (x, y) -> Integer.compare(y, x));
for (int i = 0; i < A.length; i++)
A[i] = sorted.get(i);
}
static class MyScanner {
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 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;
}
}
}
| 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 11 | 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 | 1e9513c547474270a4f69d80960b5f9b | 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 codechef; // don't place package name! */
import java.util.*;
import java.lang.*;
import java.io.*;
/* Name of the class has to be "Main" only if the class is public. */
public class Main
{
public static void main (String[] args) throws java.lang.Exception
{
Scanner cin=new Scanner(System.in);
int t=cin.nextInt();
while(t-->0)
{
int n=cin.nextInt();
StringBuilder s=new StringBuilder(cin.next());
int one=0,zero=0,r=0,count=0,count1=0;
for(int i=0;i<n;i++)
{
count++;
if(one!=0)
{
if(s.charAt(i)=='(')
one++;
else
zero++;
if(one==zero)
{
r++;
one=0;zero=0;
count1+=count;
count=0;
}
else if(count>1)
{
// System.out.println("one"+(i-(count-1))+" "+i);
if(palindrome(s,i-(count-1),i))
{
one=0;zero=0;count1+=count;count=0;
r++;
}
}
}
else
{
if(s.charAt(i)=='(')
one++;
else
zero++;
if(count>1)
{
//System.out.println((i-(count-1))+" "+i);
if(palindrome(s,i-(count-1),i))
{
one=0;zero=0;count1+=count;count=0;
r++;
}
}
}
}
System.out.println(r+" "+(n-count1));
}
// out.close();
}
public static boolean palindrome(StringBuilder s,int i,int j)
{
while(i<j)
{
if(s.charAt(i)==s.charAt(j))
{i++;j--;}
else
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 11 | 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 | 5e217ebac7f5dba94582c2b95a61a2f7 | 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.Scanner;
import java.util.*;
public class CF{
public static void main(String[] args){
Scanner sc= new Scanner(System.in);
long t= Long.parseLong(sc.nextLine());
for(int z = 0; z < t; z++){
long n = Long.parseLong(sc.nextLine());
String inp = sc.nextLine();
StringBuilder str = new StringBuilder();
str.append(inp);
int op=0;
int flag =1;
int i=0;
int len = str.length();
int end = 0;
while(i < len-1 && flag==1){
char ch = str.charAt(i);
if(ch == '(') {
op++;
end=i+2;
i+=2;
}
else{
i=i+1;
while(i<len){
if(str.charAt(i) == ')'){
op++;
flag = 1;
end=i+1;
i++;
break;
}
i++;
flag=0;
}
}
}
System.out.println(op+ " "+ (len-end));
}
}
} | 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 11 | 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 | ae203b6866856e1044579060d29c2f56 | 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 | //not all import are used to solve every problem .. but these are the most important one
import java.io.DataInputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;
public class CodeforcesEducationalRound_125_C {
@SuppressWarnings("FieldCanBeLocal")
private static Reader in;
private static PrintWriter out;
private static int MinValue = 0;
private static void solve() throws IOException{
//Your Code Goes Here;
long n = in.nextLong();
char[] s = in.next().toCharArray();
long first = 0, second = 1, count = 0;
while(first < n && second < n){
if(s[(int) first] == ')' && s[(int) second] == '('){
second += 1;
}
else{
first = second + 1;
second += 2;
count++;
}
}
long ans = (n - first);
System.out.println(count + " " + ans);
}
public static void main(String[] args) throws IOException {
//FastScaner fs = new FastScaner();//There is a class below .. uncomment that class to instantiate an object from that class;
//int t = fs.nextInt();//uncomment this line when you're using the fastscaner class;
in = new Reader();
out = new PrintWriter(new OutputStreamWriter(System.out));
int T = in.nextInt();
while(T-->0){
solve();
}
out.flush();
in.close();
out.close();
}
static final double INF = 1e18;
static final Random random = new Random();
static final int mod = 1_000_000_007;
//Taken From "Second Thread"
static void ruffleSort(int[] a){
int n = a.length;//shuffles, then sort;
for(int i=0; i<n; i++){
int oi = random.nextInt(n), temp = a[oi];
a[oi] = a[i]; a[i] = temp;
}
sort(a);
}
public static boolean primeFinder(int n){
int m = 0;
int flag = 0;
m = n / 2;
if(n == 0 ||n == 1){
return false;
}
else{
for(int i=2;i<=m;i++){
if(n % i == 0){
return false;
}
}
return true;
}
}
private static boolean[] sieveOfEratosthenes(long n) {
boolean prime[] = new boolean[(int)n + 1];
for (int i = 0; i <= n; i++) {
prime[i] = true;
}
for (long p = 2; p * p <= n; p++) {
if (prime[(int)p] == true) {
for (long i = p * p; i <= n; i += p)
prime[(int)i] = false;
}
}
return prime;
}
private static long add(long a, long b){
return (a + b) % mod;
}
private static int gcd(int a, int b) {
if (a == 0 || b == 0)
return 0;
while (b != 0) {
int tmp;
tmp = a % b;
a = b;
b = tmp;
}
return a;
}
private static long lcm(long a, long b){
return (a / gcd((int) a, (int) b) * b);
}
private 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);
}
public static int[][] prefixSum( int n , int m , int[][] arr){
int[][] prefixSum = new int[n+1][m+1];
for( int i = 1 ;i <= n ;i++) {
for( int j = 1 ; j<= m ; j++) {
int toadd = 0;
if( arr[i-1][j-1] == 1) {
toadd = 1;
}
prefixSum[i][j] = toadd + prefixSum[i][j-1] + prefixSum[i-1][j] - prefixSum[i-1][j-1];
}
}
return prefixSum;
}
private static int sumOfArrayElements(int[] arr){
int sum = 0; // Initialize sum ;
//Iterate through all elements and add them to sum;
for(int i=0;i<arr.length;i++){
sum += arr[i];
}
return sum;
}
//call this method when you want to read an integer array;
private static int[] readArray(int len) throws IOException{
int[] a = new int[len];
for(int i=0;i<len;i++)a[i] = in.nextInt();
return a;
}
//call this method when you want to read an Long array;
private static long[] readLongArray(int len) throws IOException{
long[] a = new long[len];
for(int i=0;i<len;i++) a[i] = in.nextLong();
return a;
}
//call this method to print the integer array;
private static void printArray(int[] array){
for(int now : array) out.print(now);out.print(' ');out.close();
}
//call this method to print the long array;
private static void printLongArray(long[] array){
for(long now:array) out.print(now); out.print(' '); out.close();
}
/*Another way of Reading input...collected from a online blog
from here => https://codeforces.com/contest/1625/submission/144334744;*/
static class Reader {
private static final int BUFFER_SIZE = 1 << 16;
private final DataInputStream din;
private final byte[] buffer;
private int bufferPointer, bytesRead;
Reader() {//Constructor;
din = new DataInputStream(System.in);
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public String readLine() throws IOException {//To take user input for String values;
final byte[] buf = new byte[1024]; // 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 nextSign() throws IOException {//For taking the signs like plus or minus ...
byte c = read();
while ('+' != c && '-' != c) {
c = read();
}
return '+' == c ? 0 : 1;
}
private static boolean isSpaceChar(int c) {
return !(c >= 33 && c <= 126);
}
public int skip() throws IOException {
int b;
// noinspection ALL
while ((b = read()) != -1 && isSpaceChar(b)) {
;
}
return b;
}
public char nc() throws IOException {
return (char) skip();
}
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');
if (neg) {
return -ret;
}
return 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');
if (neg) {
return -ret;
}
return 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);
}
}
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 {
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 11 | 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 | 846c333b3fb1d55fba7c643819a96b20 | 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;
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.Scanner;
public class edu125c {
static boolean areBracketsBalanced(String expr) {
Deque<Character> stack
= new ArrayDeque<Character>();
for (int i = 0; i < expr.length(); i++) {
char x = expr.charAt(i);
if (x == '(' || x == '[' || x == '{') {
stack.push(x);
continue;
}
if (stack.isEmpty())
return false;
char check;
switch (x) {
case ')':
check = stack.pop();
if (check == '{' || check == '[')
return false;
break;
case '}':
check = stack.pop();
if (check == '(' || check == '[')
return false;
break;
case ']':
check = stack.pop();
if (check == '(' || check == '{')
return false;
break;
}
}
return (stack.isEmpty());
}
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;
}
public static void main(String[] args) {
Scanner sc = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
int t = sc.nextInt();
while (t-- > 0) {
int n = sc.nextInt();
String s = sc.next();
int i = 0;
int c = 0;
while (i < s.length() - 1) {
if (s.charAt(i) == s.charAt(i + 1)) {
c++;
i = i + 2;
continue;
}
if (s.charAt(i) == '(' && s.charAt(i + 1) == ')') {
c++;
i += 2;
continue;
}
int index = -1;
for (int k = i + 1; k < n; k++) {
if (s.charAt(k) == ')') {
c++;
index = k;
break;
}
}
if (index == -1) break;
i = index + 1;
}
int l = 0;
if (i < n) {
l = n - i;
}
System.out.println(c+" "+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 11 | 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 | d4f2ab4798793cc83e76160b52f208f4 | 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 codechef; // don't place package name! */
import java.util.*;
import java.lang.*;
import java.io.*;
/* Name of the class has to be "Main" only if the class is public. */
public class Solution
{
static boolean f=false;
static int ans=0;
static int lasti=-1;
public static void main (String[] args) throws java.lang.Exception
{
// your code goes her
Scanner sc=new Scanner(System.in);
int t=sc.nextInt();
while(t>0){
t--;
int n=sc.nextInt();
String s=sc.next();
if(n==1){
System.out.println(0+" "+1);
}
else{
ans=0;
lasti=0;
// check(s,0);
int i=0;
for( i=0;i+1<s.length();i+=2){
char c1=s.charAt(i);
char c2=s.charAt(i+1);
if(c1==')' && c2=='('){
int b=0;
int j=i+1;
while(j<n&&s.charAt(j)=='('){
j++;
}
if(j<n&&s.charAt(j)==')'){
lasti=j+1;
ans++;
i=j-1;
}
else{
break;
}
}
else{
ans++;
lasti=i+2;
}
}
System.out.println((ans)+" "+(n-lasti));}
}
}
} | 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 11 | 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 | 03fb97949fea11f01a6ea5cb7ced39a9 | 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.lang.*;
import java.io.*;
public class Main
{
static long mod = (int)1e9+7;
// static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
public static void main (String[] args) throws java.lang.Exception
{
FastReader sc =new FastReader();
int t=sc.nextInt();
// int t=1;
while(t-->0)
{
int n = sc.nextInt();
char arr[] = sc.next().toCharArray();
int i = 0;
int count = 0;
String ans = "";
while(i < n - 1)
{
if(arr[i] == arr[i + 1])
{
count++;
i += 2;
continue;
}
if(arr[i] == '(' && arr[i + 1] == ')')
{
count++;
i += 2;
continue;
}
int ind = -1;
for(int j=i+1;j<n;j++)
{
if(arr[j] == ')')
{
count++;
ind = j;
break;
}
}
if(ind == -1)
{
break;
}
i = ind + 1;
}
int left = 0;
if(i < n)
{
left = n - i;
}
System.out.println(count+" "+left);
}
}
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());
}
float nextFloat()
{
return Float.parseFloat(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;
}
long[] readArrayLong(int n) {
long[] a=new long[n];
for (int i=0; i<n; i++) a[i]=nextLong();
return a;
}
}
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 void reverse_sorted(int[] arr)
{
ArrayList<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);
}
}
static int LowerBound(int a[], int 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(ArrayList<Integer> list, int x) {// x is the key or target value
int l=-1,r=list.size();
while(l+1<r) {
int m=(l+r)>>>1;
if(list.get(m)<=x) l=m;
else r=m;
}
return l+1;
}
public static HashMap<Integer, Integer> sortByValue(HashMap<Integer, Integer> hm)
{
// Create a list from elements of HashMap
List<Map.Entry<Integer, Integer> > list =
new LinkedList<Map.Entry<Integer, Integer> >(hm.entrySet());
// Sort the list
Collections.sort(list, new Comparator<Map.Entry<Integer, Integer> >() {
public int compare(Map.Entry<Integer, Integer> o1,
Map.Entry<Integer, Integer> o2)
{
return (o1.getValue()).compareTo(o2.getValue());
}
});
// put data from sorted list to hashmap
HashMap<Integer, Integer> temp = new LinkedHashMap<Integer, Integer>();
for (Map.Entry<Integer, Integer> aa : list) {
temp.put(aa.getKey(), aa.getValue());
}
return temp;
}
static class Queue_Pair implements Comparable<Queue_Pair> {
int first , second;
public Queue_Pair(int first, int second) {
this.first=first;
this.second=second;
}
public int compareTo(Queue_Pair o) {
return Integer.compare(o.first, first);
}
}
static void leftRotate(int arr[], int d, int n)
{
for (int i = 0; i < d; i++)
leftRotatebyOne(arr, n);
}
static void leftRotatebyOne(int arr[], int n)
{
int i, temp;
temp = arr[0];
for (i = 0; i < n - 1; i++)
arr[i] = arr[i + 1];
arr[n-1] = temp;
}
static boolean isPalindrome(String str)
{
// Pointers pointing to the beginning
// and the end of the string
int i = 0, j = str.length() - 1;
// While there are characters to compare
while (i < j) {
// If there is a mismatch
if (str.charAt(i) != str.charAt(j))
return false;
// Increment first pointer and
// decrement the other
i++;
j--;
}
// Given string is a palindrome
return true;
}
static boolean palindrome_array(char arr[], int n)
{
// Initialise flag to zero.
int flag = 0;
// Loop till array size n/2.
for (int i = 0; i <= n / 2 && n != 0; i++) {
// Check if first and last element are different
// Then set flag to 1.
if (arr[i] != arr[n - i - 1]) {
flag = 1;
break;
}
}
// If flag is set then print Not Palindrome
// else print Palindrome.
if (flag == 1)
return false;
else
return true;
}
static boolean allElementsEqual(int[] arr,int n)
{
int z=0;
for(int i=0;i<n-1;i++)
{
if(arr[i]==arr[i+1])
{
z++;
}
}
if(z==n-1)
{
return true;
}
else
{
return false;
}
}
static boolean allElementsDistinct(int[] arr,int n)
{
int z=0;
for(int i=0;i<n-1;i++)
{
if(arr[i]!=arr[i+1])
{
z++;
}
}
if(z==n-1)
{
return true;
}
else
{
return false;
}
}
public static void reverse(int[] array)
{
// Length of the array
int n = array.length;
// Swaping the first half elements with last half
// elements
for (int i = 0; i < n / 2; i++) {
// Storing the first half elements temporarily
int temp = array[i];
// Assigning the first half to the last half
array[i] = array[n - i - 1];
// Assigning the last half to the first half
array[n - i - 1] = temp;
}
}
public static void reverse_Long(long[] array)
{
// Length of the array
int n = array.length;
// Swaping the first half elements with last half
// elements
for (int i = 0; i < n / 2; i++) {
// Storing the first half elements temporarily
long temp = array[i];
// Assigning the first half to the last half
array[i] = array[n - i - 1];
// Assigning the last half to the first half
array[n - i - 1] = temp;
}
}
static boolean isSorted(int[] a)
{
for (int i = 0; i < a.length - 1; i++)
{
if (a[i] > a[i + 1]) {
return false;
}
}
return true;
}
static boolean isReverseSorted(int[] a)
{
for (int i = 0; i < a.length - 1; i++)
{
if (a[i] < a[i + 1]) {
return false;
}
}
return true;
}
static int[] rearrangeEvenAndOdd(int arr[], int n)
{
ArrayList<Integer> list = new ArrayList<>();
for(int i=0;i<n;i++)
{
if(arr[i]%2==0)
{
list.add(arr[i]);
}
}
for(int i=0;i<n;i++)
{
if(arr[i]%2!=0)
{
list.add(arr[i]);
}
}
int len = list.size();
int[] array = list.stream().mapToInt(i->i).toArray();
return array;
}
static long[] rearrangeEvenAndOddLong(long arr[], int n)
{
ArrayList<Long> list = new ArrayList<>();
for(int i=0;i<n;i++)
{
if(arr[i]%2==0)
{
list.add(arr[i]);
}
}
for(int i=0;i<n;i++)
{
if(arr[i]%2!=0)
{
list.add(arr[i]);
}
}
int len = list.size();
long[] array = list.stream().mapToLong(i->i).toArray();
return array;
}
static boolean isPrime(long n)
{
// Check if number is less than
// equal to 1
if (n <= 1)
return false;
// Check if number is 2
else if (n == 2)
return true;
// Check if n is a multiple of 2
else if (n % 2 == 0)
return false;
// If not, then just check the odds
for (long i = 3; i <= Math.sqrt(n); i += 2)
{
if (n % i == 0)
return false;
}
return true;
}
static long getSum(long n)
{
long sum = 0;
while (n != 0)
{
sum = sum + n % 10;
n = n/10;
}
return sum;
}
static int gcd(int a, int b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
static long gcdLong(long a, long b)
{
if (b == 0)
return a;
return gcdLong(b, a % b);
}
static void swap(int i, int j)
{
int temp = i;
i = j;
j = temp;
}
static int countDigit(int n)
{
return (int)Math.floor(Math.log10(n) + 1);
}
}
class Pair
{
int first;
int second;
Pair(int first , int second)
{
this.first = first;
this.second = second;
}
}
| 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 11 | 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 | b8140a5b53a45f4bd2c34b670a2d0a1a | 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.*;
import java.io.*;
import java.math.BigInteger;
public class template{
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());
}
}
static class helper{
//reverse 1-d Array
public static void reverse(char arr[],int i,int j) {
// int i = 0;
// int j = arr.length - 1;
while(i<j) {
char temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
i++;
j--;
}
}
//gcd of two numbers
public static long gcd(long a,long b) {
if(b == 0) {
return a;
}
return gcd(b,a%b);
}
//calculate ncr
public static int ncr(int n,int r) {
int num = n;
int deno = r;
int a1 = 1;
int a2 = 1;
for(int i=0;i<r;i++) {
a1 *= num;
a2 *= deno;
num--;
deno--;
}
int ans = a1/a2;
return ans;
}
//isPalindrome
public static boolean isPalindrome(String substring){
char ch[] = substring.toCharArray();
int i = 0;
int j = ch.length-1;
while(i<j){
char temp = ch[i];
ch[i] = ch[j];
ch[j] = temp;
i++;
j--;
}
String rev = String.valueOf(ch);
if(rev.equals(substring)){
return true;
}
else{
return false;
}
}
//sorting
public static void suffleSort(int[] arr) {
int n = arr.length;
Random rnd = new Random();
for (int i = 0; i < n; ++i) {
int tmp = arr[i];
int randomPos = i + rnd.nextInt(n - i);
arr[i] = arr[randomPos];
arr[randomPos] = tmp;
}
Arrays.sort(arr);
}
//isPowerOfTwo
public static boolean isPowerOfTwo(long x)
{
/* First x in the below expression is
for the case when x is 0 */
return x != 0 && ((x & (x - 1)) == 0);
}
//nextPowerOfTwo
public static long nextPowerOfTwo(long n)
{
n--;
n |= n >> 1;
n |= n >> 2;
n |= n >> 4;
n |= n >> 8;
n |= n >> 16;
n++;
return n;
}
static int highestPowerof2(int x)
{
// check for the set bits
x |= x >> 1;
x |= x >> 2;
x |= x >> 4;
x |= x >> 8;
x |= x >> 16;
// Then we remove all but the top bit by xor'ing the
// string of 1's with that string of 1's shifted one to
// the left, and we end up with just the one top bit
// followed by 0's.
return x ^ (x >> 1);
}
static long divSum(long num)
{
// Final result of summation of divisors
long result = 0;
// find all divisors which divides 'num'
for (int i = 1; i <= Math.sqrt(num); i++)
{
// if 'i' is divisor of 'num'
if (num % i == 0)
{
// if both divisors are same then
// add it only once else add both
if (i == (num / i))
result += i;
else
result += (i + num / i);
}
}
// Add 1 to the result as 1 is also
// a divisor
return (result );
}
}
public static void main(String[] args) {
FastScanner sc = new FastScanner();
PrintWriter out = new PrintWriter(System.out);
helper help = new helper();
long test = sc.nextLong();
while(test-- > 0) {
int nn = sc.nextInt();
String s = sc.next();
int i=0;
int op = 0;
StringBuilder sb = new StringBuilder(s);
while(i<sb.length()-1) {
if(sb.charAt(i) == '(' && sb.charAt(i+1) == ')'
||sb.charAt(i) == '(' && sb.charAt(i+1) == '('
||sb.charAt(i) == ')' && sb.charAt(i+1) == ')') {
// sb.deleteCharAt(i);
// sb.deleteCharAt(i);
i+=2;
op++;
continue;
}
else if(sb.charAt(i) == ')' && sb.charAt(i+1) == '(') {
int orgi = i;
i+=2;
boolean flag = false;
while(i<sb.length() && sb.charAt(i) != ')') {
i++;
if(i == sb.length()) {
flag = true;
break;
}
}
if(i==sb.length() || flag) {
i = orgi;
break;
}
else {
// sb.delete(orgi,i+1);
op++;
i++;
// i=orgi;
}
}
else {
break;
}
}
out.println(op + " " + (sb.length()-i));
}
out.flush();
}
public static boolean check(long n) {
String s = String.valueOf(n);
long sum = 0;
long prod = 1;
for(int i=0;i<s.length();i++) {
long num = Long.parseLong(String.valueOf(s.charAt(i)));
sum += num;
prod *= num;
}
if(prod%sum == 0) {
return true;
}
return false;
}
public static void bfs(Map<Integer,ArrayList<Integer>> map,boolean visited[],int time) {
Deque<pair> queue = new LinkedList<>();
for(int i=1;i<visited.length;i++) {
if(visited[i]) {
queue.add(new pair(i,0));
visited[i] = false;
}
}
//queue.add(new pair(src,0));
//visited[src] = false;
boolean flag = false;
while(queue.size() > 0) {
pair rem = queue.poll();
if(rem.time > time) {
break;
}
if(visited[rem.v]) {
continue;
}
else {
visited[rem.v] = true;
}
for(int i=0;i<map.get(rem.v).size();i++) {
int ngh = map.get(rem.v).get(i);
if(visited[ngh] == false) {
queue.add(new pair(ngh,rem.time+1));
}
}
}
queue.clear();
}
public static void swap(int arr[],int i,int j) {
int temp = arr[i];
arr[i]= arr[j];
arr[j] = temp;
}
}
class pair {
int v;
int time;
public pair(int v,int time) {
this.v = v;
this.time = time;
}
}
| 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 11 | 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 | 2b9b468531ce32a800df57f012811805 | 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 {
public static void main(String[] args) throws IOException {
int qwe = in.nextInt();
while (qwe-- > 0) {
int n = in.nextInt();
String s = in.next();
char[] str = s.toCharArray();
int c = 0;
int r = 0;
int cnt = 1;
for (int i = 0; i < str.length; i++) {
if (n-r==1){
break;
}
if (str[i] == '(') {
++i;
c++;
r += 2;
} else if (str[i] == ')') {
boolean ok = false;
for (int j = i + 1;j < str.length; j++) {
cnt++;
if (str[j] == ')') {
ok = true;
c++;
r += cnt;
i += cnt-1;
cnt = 1;
break;
}
}
if (!ok){
break;
}
}
}
System.out.println(c + " " + (n - r));
}
}
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());
}
}
static FastScanner in = new FastScanner(System.in);
static PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(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 11 | 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 | ca0677b0b849323b4b63099cdbf5a793 | 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.*;
import java.util.*;
public class ComdeFormces {
public static void main(String[] args) throws Exception{
// TODO Auto-generated method stub
// Reader.init(System.in);
FastReader sc=new FastReader();
BufferedWriter log = new BufferedWriter(new OutputStreamWriter(System.out));
// OutputStream out = new BufferedOutputStream ( System.out );
int t=sc.nextInt();
while(t--!=0) {
int n=sc.nextInt();
char a[]=sc.next().toCharArray();
Stack<Character> st=new Stack<>();
int i=0;
int cnt=0;
boolean p=false;
int r=0;
while(i<a.length){
if(p) {
int pr=0;
while(i<n && a[i]=='(') {
i++;
pr++;
}
if(i<n) {
cnt++;
r+=(pr+3);
i++;
p=false;
continue;
}
}
else {
if(a[i]=='(') {
if(i+1<n && a[i+1]==')') {
i+=2;
r+=2;
cnt++;
}
else if(i+1<n && a[i+1]=='(') {
i+=2;
r+=2;
cnt++;
}
else break;
}
else {
if(i+1<n && a[i+1]==')') {
i+=2;
r+=2;
cnt++;
}
else if(i+1<n && a[i+1]=='(') {
i+=2;
p=true;
}
else break;
}
}
}
log.write(cnt+" "+(n-r)+"\n");
log.flush();
}
}
static int evv(int cnt[],int cnt2[]) {
int ans=0;
for(int i=1;i<cnt.length;i++) {
if(cnt[i]>cnt2[i]) {
ans+=cnt[i]-cnt2[i];
}
}
return ans;
}
public static void fb(HashMap<Long,Integer> hm,HashSet<Long> hs, long s) {
if(hs.contains(s)) {
hm.put(s,hm.get(s)-1);
if(hm.get(s)==0)hs.remove(s);
return;
}
else if(s<=1)return;
fb(hm,hs,s/2);
fb(hm,hs,(s+1)/2);
}
public static void radixSort(int a[]) {
int n=a.length;
int res[]=new int[n];
int p=1;
for(int i=0;i<=8;i++) {
int cnt[]=new int[10];
for(int j=0;j<n;j++) {
a[j]=res[j];
cnt[(a[j]/p)%10]++;
}
for(int j=1;j<=9;j++) {
cnt[j]+=cnt[j-1];
}
for(int j=n-1;j>=0;j--) {
res[cnt[(a[j]/p)%10]-1]=a[j];
cnt[(a[j]/p)%10]--;
}
p*=10;
}
}
static int bits(long n) {
int ans=0;
while(n!=0) {
if((n&1)==1)ans++;
n>>=1;
}
return ans;
}
static long flor(ArrayList<Long> ar,long el) {
int s=0;
int e=ar.size()-1;
while(s<=e) {
int m=s+(e-s)/2;
if(ar.get(m)==el)return ar.get(m);
else if(ar.get(m)<el)s=m+1;
else e=m-1;
}
return e>=0?e:-1;
}
public static int kadane(int a[]) {
int sum=0,mx=Integer.MIN_VALUE;
for(int i=0;i<a.length;i++) {
sum+=a[i];
mx=Math.max(mx, sum);
if(sum<0) sum=0;
}
return mx;
}
public static int m=1000000007;
public static int mul(int a, int b) {
return ((a%m)*(b%m))%m;
}
public static long mul(long a, long b) {
return ((a%m)*(b%m))%m;
}
public static int add(int a, int b) {
return ((a%m)+(b%m))%m;
}
public static long add(long a, long b) {
return ((a%m)+(b%m))%m;
}
//debug
public static <E> void p(E[][] a,String s) {
System.out.println(s);
for(int i=0;i<a.length;i++) {
for(int j=0;j<a[0].length;j++) {
System.out.print(a[i][j]+" ");
}
System.out.println();
}
}
public static void p(int[] a,String s) {
System.out.print(s+"=");
for(int i=0;i<a.length;i++)System.out.print(a[i]+" ");
System.out.println();
}
public static void p(long[] a,String s) {
System.out.print(s+"=");
for(int i=0;i<a.length;i++)System.out.print(a[i]+" ");
System.out.println();
}
public static <E> void p(E a,String s){
System.out.println(s+"="+a);
}
public static <E> void p(ArrayList<E> a,String s){
System.out.println(s+"="+a);
}
public static <E> void p(LinkedList<E> a,String s){
System.out.println(s+"="+a);
}
public static <E> void p(HashSet<E> a,String s){
System.out.println(s+"="+a);
}
public static <E> void p(Stack<E> a,String s){
System.out.println(s+"="+a);
}
public static <E> void p(Queue<E> a,String s){
System.out.println(s+"="+a);
}
//utils
static ArrayList<Integer> divisors(int n){
ArrayList<Integer> ar=new ArrayList<>();
for (int i=2; i<=Math.sqrt(n); i++){
if (n%i == 0){
if (n/i == i) {
ar.add(i);
}
else {
ar.add(i);
ar.add(n/i);
}
}
}
return ar;
}
static int primeDivisor(int n){
ArrayList<Integer> ar=new ArrayList<>();
int cnt=0;
boolean pr=false;
while(n%2==0) {
pr=true;
n/=2;
}
if(pr)ar.add(2);
for(int i=3;i*i<=n;i+=2) {
pr=false;
while(n%i==0) {
n/=i;
pr=true;
}
if(pr)ar.add(i);
}
if(n>2) ar.add(n);
return ar.size();
}
static long gcd(long a,long b) {
if(b==0)return a;
else return gcd(b,a%b);
}
static int gcd(int a,int b) {
if(b==0)return a;
else return gcd(b,a%b);
}
static long factmod(long n,long mod,long img) {
if(n==0)return 1;
long ans=1;
long temp=1;
while(n--!=0) {
if(temp!=img) {
ans=((ans%mod)*((temp)%mod))%mod;
}
temp++;
}
return ans%mod;
}
static int ncr(int n, int r){
if(r>n-r)r=n-r;
int ans=1;
for(int i=0;i<r;i++){
ans*=(n-i);
ans/=(i+1);
}
return ans;
}
public static class trip{
int a,b;
int c;
public trip(int a,int b,int c) {
this.a=a;
this.b=b;
this.c=c;
}
public int compareTo(trip q) {
return this.b-q.b;
}
}
static void mergesort(long[] a,int start,int end) {
if(start>=end)return ;
int mid=start+(end-start)/2;
mergesort(a,start,mid);
mergesort(a,mid+1,end);
merge(a,start,mid,end);
}
static void merge(long[] a, int start,int mid,int end) {
int ptr1=start;
int ptr2=mid+1;
long b[]=new long[end-start+1];
int i=0;
while(ptr1<=mid && ptr2<=end) {
if(a[ptr1]<=a[ptr2]) {
b[i]=a[ptr1];
ptr1++;
i++;
}
else {
b[i]=a[ptr2];
ptr2++;
i++;
}
}
while(ptr1<=mid) {
b[i]=a[ptr1];
ptr1++;
i++;
}
while(ptr2<=end) {
b[i]=a[ptr2];
ptr2++;
i++;
}
for(int j=start;j<=end;j++) {
a[j]=b[j-start];
}
}
public static class FastReader {
BufferedReader b;
StringTokenizer s;
public FastReader() {
b=new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while(s==null ||!s.hasMoreElements()) {
try {
s=new StringTokenizer(b.readLine());
}
catch(IOException e) {
e.printStackTrace();
}
}
return s.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str="";
try {
str=b.readLine();
}
catch(IOException e) {
e.printStackTrace();
}
return str;
}
boolean hasNext() {
if (s != null && s.hasMoreTokens()) {
return true;
}
String tmp;
try {
b.mark(1000);
tmp = b.readLine();
if (tmp == null) {
return false;
}
b.reset();
} catch (IOException e) {
return false;
}
return true;
}
}
public static class pair{
int a;
int b;
public pair(int a,int b) {
this.a=a;
this.b=b;
}
public int compareTo(pair b) {
return this.a-b.a;
}
// public int compareToo(pair b) {
// return this.b-b.b;
// }
@Override
public String toString() {
return "{"+this.a+" "+this.b+"}";
}
}
static long pow(long a, long pw) {
long temp;
if(pw==0)return 1;
temp=pow(a,pw/2);
if(pw%2==0)return temp*temp;
return a*temp*temp;
}
static int pow(int a, int pw) {
int temp;
if(pw==0)return 1;
temp=pow(a,pw/2);
if(pw%2==0)return temp*temp;
return a*temp*temp;
}
}
| 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 11 | 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 | 75741fe4db3ca08a3060abb91e4e461e | 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.*;
import java.util.*;
public class Main {
public static int mod = (int) 1e9 + 7;
// **** -----> Disjoint Set Union(DSU) Start **********
public static int findPar(int node, int[] parent) {
if (parent[node] == node)
return node;
return parent[node] = findPar(parent[node], parent);
}
public static boolean union(int u, int v, int[] rank, int[] parent) {
u = findPar(u, parent);
v = findPar(v, parent);
if(u == v) return false;
if (rank[u] < rank[v])
parent[u] = v;
else if (rank[u] > rank[v])
parent[v] = u;
else {
parent[u] = v;
rank[v]++;
}
return true;
}
// **** DSU Ends ***********
//Pair with int int
public static class Pair{
public int a;
public int b;
Pair(int a , int b){
this.a = a;
this.b = b;
}
@Override
public String toString(){
return a + " -> " + b;
}
}
public static String toBinary(int decimal) {StringBuilder sb = new StringBuilder();while (decimal > 0) {sb.append(decimal % 2);decimal = decimal / 2;}return sb.reverse().toString();}
public static boolean isPalindrome(String s) {int i = 0, j = s.length() - 1;while (i < j) {if (s.charAt(i) != s.charAt(j))return false;i++;j--;}return true;}
public static boolean isPalindrome(int[] arr) {int i = 0, j = arr.length - 1;while (i < j) {if (arr[i] != arr[j])return false;}return true;}
public static int pow(int x, int y) {int res = 1;x = x % mod;if (x == 0)return 0;while (y > 0) {if ((y & 1) != 0)res = (res * x) % mod;y = y >> 1;x = (x * x) % mod;}return res;}
public static int gcd(int a, int b) {if (b == 0)return a;return gcd(b, a % b);}
public static long gcd(long a, long b) {if (b == 0)return a;return gcd(b, a % b);}
public static void sort(long[] a) {Random rnd = new Random();for (int i = 0; i < a.length; i++) {int pos = i + rnd.nextInt(a.length - i);long temp = a[i];a[i] = a[pos];a[pos] = temp;}Arrays.sort(a);}
public static void reverse(int a[]) {int i, k, t, n = a.length;for (i = 0; i < n / 2; i++) {t = a[i];a[i] = a[n - i - 1];a[n - i - 1] = t;}}
public static void sort(int[] a) {Random rnd = new Random();for (int i = 0; i < a.length; i++) {int pos = i + rnd.nextInt(a.length - i);int temp = a[i];a[i] = a[pos];a[pos] = temp;}Arrays.sort(a);}
public static void revSort(int[] a) {Random rnd = new Random();for (int i = 0; i < a.length; i++) {int pos = i + rnd.nextInt(a.length - i);int temp = a[i];a[i] = a[pos];a[pos] = temp;}Arrays.sort(a);reverse(a);}
public static long LCM(long a, long b) {if (a > b) {long t = a;a = b;b = t;}a /= gcd(a, b);return (a * b);}
public static int findMax(int[] a, int left, int right) {int res = left;int max = a[left];for (int i = left + 1; i <= right; i++) {if (a[i] > max) {max = a[i];res = i;}}return res;}
public static long findClosest(long arr[], long target) {int n = arr.length;if (target <= arr[0])return arr[0];if (target >= arr[n - 1])return arr[n - 1];int i = 0, j = n, mid = 0;while (i < j) {mid = (i + j) / 2;if (arr[mid] == target)return arr[mid];if (target < arr[mid]) {if (mid > 0 && target > arr[mid - 1])return getClosest(arr[mid - 1], arr[mid], target);j = mid;} else {if (mid < n - 1 && target < arr[mid + 1])return getClosest(arr[mid], arr[mid + 1], target);i = mid + 1;}}return arr[mid];}
public static long getClosest(long val1, long val2, long target) {if (target - val1 >= val2 - target)return val2;else return val1;}
public static int findClosest(int arr[], int target) { int n = arr.length; if (target <= arr[0]) return arr[0]; if (target >= arr[n - 1]) return arr[n - 1]; int i = 0, j = n, mid = 0; while (i < j) { mid = (i + j) / 2; if (arr[mid] == target) return arr[mid];if (target < arr[mid]) {if (mid > 0 && target > arr[mid - 1])return getClosest(arr[mid - 1], arr[mid], target);j = mid;} else {if (mid < n - 1 && target < arr[mid + 1])return getClosest(arr[mid], arr[mid + 1], target);i = mid + 1;}}return arr[mid];}
public static int getClosest(int val1, int val2, int target) {if (target - val1 >= val2 - target)return val2;else return val1;}
public static String reverse(String str) {String nstr = "";char ch;for (int i = 0; i < str.length(); i++) {ch = str.charAt(i);nstr = ch + nstr;}return nstr;}
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;for (int i = 5; i * i <= n; i = i + 6)if (n % i == 0 || n % (i + 2) == 0)return false;return true;}
public static int xorSum(int arr[], int n){int bits = 0;for (int i = 0; i < n; ++i)bits |= arr[i];int ans = bits * (int)Math.pow(2, n-1);return ans;}
public static ArrayList<Integer> primeFactors(int n) { ArrayList<Integer> res = new ArrayList<>();while (n%2 == 0) { res.add(2); n = n/2; } for (int i = 3; i <= Math.sqrt(n); i = i+2) { while (n%i == 0) { res.add(i); n = n/i; } } if (n > 2) res.add(n);return res;}
public static ArrayList<Long> primeFactors(long n) { ArrayList<Long> res = new ArrayList<>();while (n%2 == 0) { res.add(2L); n = n/2; } for (long i = 3; i <= Math.sqrt(n); i = i+2) { while (n%i == 0) { res.add(i); n = n/i; } } if (n > 2) res.add(n);return res;}
static int lower_bound(int array[], int low, int high, int key){
int mid;
while (low < high) {
mid = low + (high - low) / 2;
if (key <= array[mid]) high = mid;
else low = mid + 1;
}
if (low < array.length && array[low] < key) low++;
return low;
}
/********************************* Start Here ***********************************/
// int mod = 1000000007;
static HashSet<Integer> set;
public static void main(String[] args) throws java.lang.Exception {
if (System.getProperty("ONLINE_JUDGE") == null) {
PrintStream ps = new PrintStream(new File("output.txt"));
System.setOut(ps);
}
FastScanner sc = new FastScanner("input.txt");
StringBuilder result = new StringBuilder();
set = new HashSet<>();
// sieveOfEratosthenes(1000000);
int T = sc.nextInt();
// int T = 1;
while (T-- > 0) {
int n = sc.nextInt();
String s = sc.next();
int count = 0;
int till = -1;
int op = 0;
boolean reg = true;
for(int i = 0; i < n; i++){
if(s.charAt(i) == '(') count++;
else if(count == 0) {
count--;
reg = false;
}
else count--;
if((count == 0 && reg) || (i - till >= 2 && check(s, till+1, i))){
op++;
till = i;
count = 0;
reg = true;
}
}
result.append(op+" "+(n-till-1)+"\n");
}
System.out.println(result);
System.out.close();
}
static boolean check(String s, int i, int j){
// System.out.println(s + " "+i + " " + j);
while(i <= j){
if(s.charAt(i) != s.charAt(j)) return false;
i++;
j--;
}
return true;
}
static void 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;
}
}
for (int i = 2; i <= n; i++){
if (prime[i] == true)
set.add(i);
}
}
public static class FastScanner {
BufferedReader br;
StringTokenizer st;
public FastScanner(String s) {
try {
br = new BufferedReader(new FileReader(s));
} catch (FileNotFoundException e) {
br = new BufferedReader(new InputStreamReader(System.in));
}
}
String nextToken() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return st.nextToken();
}
public String nextLine() {
if (st == null || !st.hasMoreTokens()) {
try {
return br.readLine();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return st.nextToken("\n");
}
public String[] readStringArray(int n) {
String[] a = new String[n];
for (int i = 0; i < n; i++) {
a[i] = next();
}
return a;
}
int nextInt() {
return Integer.parseInt(nextToken());
}
String next() {
return nextToken();
}
long nextLong() {
return Long.parseLong(nextToken());
}
double nextDouble() {
return Double.parseDouble(nextToken());
}
int[] readArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
long[] readLongArray(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++)
a[i] = nextLong();
return a;
}
int[][] read2dArray(int n, int m) {
int[][] a = new int[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
a[i][j] = nextInt();
}
}
return a;
}
long[][] read2dlongArray(int n, int m) {
long[][] a = new long[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
a[i][j] = nextLong();
}
}
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 11 | 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 | c30fe494f98b687b8466894973b528d0 | 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 CodeForcesTest {
static class Pair{
int f;
int s;
Pair(int f,int s){
this.f=f;
this.s=s;
}
}
public static void main(String[] args) throws IOException {
FastReader sc=new FastReader();
BufferedWriter out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(java.io.FileDescriptor.out), "ASCII"), 512);
int T=sc.nextInt();
for(int t=0;t<T;t++){
int n = sc.nextInt(),cnt=0,ans=0;
String s = sc.next();
if(n==1){
ans=1;
cnt=0;
}
else{
for(int i=0;i<n;i++){
int x=i;
if(i==n-1){
ans=1;
}
else if(s.charAt(i)=='('){
cnt++;
i++;
}
else{
for(int j=i+1;j<n;j++){
if(s.charAt(j)==')'){
cnt++;
i=j;
break;
}
}
}
if(x==i){
ans=n-x;
break;
}
}
}
System.out.println(cnt+" "+ans);
}
out.close();
}
static boolean isPerfectSquare(int x)
{
if (x >= 0) {
// Find floating point value of
// square root of x.
int sr = (int)Math.sqrt(x);
// if product of square root
// is equal, then
// return T/F
return ((sr * sr) == x);
}
return false;
}
public static String decToBinary(int n,int cnt)
{
// Size of an integer is assumed to be 32 bits
String s ="";
for (int i = cnt-1; i >= 0; i--) {
int k = n >> i;
if ((k & 1) > 0)
s+="1";
else
s+="0";
}
return s;
}
static int longestPalSubstr(String str){
// get length of input String
int n = str.length();
// All subStrings of length 1
// are palindromes
int maxLength = 1, start = 0;
// Nested loop to mark start and end index
for (int i = 0; i < str.length(); i++) {
for (int j = i; j < str.length(); j++) {
int flag = 1;
// Check palindrome
for (int k = 0; k < (j - i + 1) / 2; k++)
if (str.charAt(i + k) != str.charAt(j - k))
flag = 0;
// Palindrome
if (flag!=0 && (j - i + 1) > maxLength) {
start = i;
maxLength = j - i + 1;
}
}
}
// return length of LPS
return maxLength;
}
static boolean arraySortedOrNot(int arr[], int n)
{
// Array has one or no element
if (n == 0 || n == 1)
return true;
for (int i = 1; i < n; i++)
// Unsorted pair found
if (arr[i - 1] > arr[i])
return false;
// No unsorted pair found
return true;
}
static class segTree{
int size;
ArrayList<Integer> values;
segTree(int n){
size=1;
while(size<n){
size*=2;
}
values=new ArrayList<>(2*size);
for(int i=0;i<2*size;i++){
values.add(0);
}
}
private void build(ArrayList<Integer> a,int x,int lx,int rx){
if(rx-lx==1){
if(lx<a.size()){
values.set(x, a.get(lx));
}
return;
}
int m = (lx+rx)/2;
build(a, 2*x+1, lx, m);
build(a, 2*x+2, m, rx);
values.set(x, Math.min(values.get(2*x+1),values.get(2*x+2)));
}
void build(ArrayList<Integer> a){
build(a, 0, 0, size);
}
private void set(int i,int v,int x,int lx,int rx){
if(rx-lx==1){
values.set(x,v);
return;
}
int m = (lx+rx)/2;
if(i<m){
set(i, v, 2*x+1, lx, m);
}
else{
set(i, v, 2*x+2, m, rx);
}
values.set(x, Math.min(values.get(2*x+1),values.get(2*x+2)));
}
void set(int i,int v){
set(i, v, 0, 0, size);
}
private int calc(int l,int r,int x,int lx,int rx){
if(lx>=r || l>=rx)
return Integer.MAX_VALUE;
if(lx>=l && rx<=r)
return values.get(x);
int m =(lx+rx)/2;
int s1 = calc(l, r, 2*x+1, lx, m);
int s2 = calc(l, r, 2*x+2, m, rx);
return Math.min(s1,s2);
}
int calc(int l,int r){
return calc(l, r,0,0,size);
}
}
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){
FastReader sc = new FastReader();
int[] a = new int[n];
for(int i=0;i<n;i++){
a[i]=sc.nextInt();
}
return a;
}
}
static int Mex(int[] a){
Arrays.sort(a);
if(a[0]!=1){
return 1;
}
for(int i=0;i<a.length-1;i++){
if(a[i]!=a[i+1] && a[i+1]>a[i]+1){
return a[i]+1;
}
}
return a[a.length-1]+1;
}
static int gcd(Integer a,Integer b)
{
if(b==0)
return a;
else
return gcd(b,a%b);
}
static boolean isPrime(long n)
{
// Check if number is less than
// equal to 1
if (n <= 1)
return false;
// Check if number is 2
else if (n == 2)
return true;
// Check if n is a multiple of 2
else if (n % 2 == 0)
return false;
// If not, then just check the odds
double l = Math.sqrt(n);
for (int i = 3; i <= l; i += 2)
{
if (n % i == 0)
return false;
}
return true;
}
static class Edge{
int to,weight;
public Edge(int to,int weight){
this.to=to;
this.weight=weight;
}
}
}
| 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 11 | 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 |
Subsets and Splits