exec_outcome stringclasses 1
value | code_uid stringlengths 32 32 | file_name stringclasses 111
values | prob_desc_created_at stringlengths 10 10 | prob_desc_description stringlengths 63 3.8k | prob_desc_memory_limit stringclasses 18
values | source_code stringlengths 117 65.5k | lang_cluster stringclasses 1
value | prob_desc_sample_inputs stringlengths 2 802 | prob_desc_time_limit stringclasses 27
values | prob_desc_sample_outputs stringlengths 2 796 | prob_desc_notes stringlengths 4 3k ⌀ | lang stringclasses 5
values | prob_desc_input_from stringclasses 3
values | tags listlengths 0 11 | src_uid stringlengths 32 32 | prob_desc_input_spec stringlengths 28 2.37k ⌀ | difficulty int64 -1 3.5k ⌀ | prob_desc_output_spec stringlengths 17 1.47k ⌀ | prob_desc_output_to stringclasses 3
values | hidden_unit_tests stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
PASSED | b8e511c8e48fa06de2bdfd6477710139 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.util.*;
import java.io.*;
public class Main {
static long mod = 1000000007;
static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
public static void main(String[] args) throws IOException {
FastReader sc = new FastReader();
int t = sc.nextInt();
while( t-- ... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 558941e992248f70a4a8ddb50f2ca71d | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.util.*;
import java.io.*;
public class Main {
static long mod = 1000000007;
static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
public static void main(String[] args) throws IOException {
FastReader sc = new FastReader();
int t = sc.nextInt();
while( t-- ... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | cf97606303f266b3a736a953a6d851ef | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.util.*;
public class r789 {
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[] arr=new int[n];
char[] tttt=s.toCharArr... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 937e5e6caa11a329d01e25083b2c04f1 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes |
import java.util.Scanner;
import java.util.Stack;
public class Solution {
static Scanner scan = new Scanner(System.in);
private static final Integer INF = 32768;
public static void main(String[] args) {
int cas = scan.nextInt();
while(cas-->0){
int n = scan.nextInt();... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 7c3c0a19d81792420301cfc40ce4f95c | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.io.*;
import java.lang.*;
import java.util.*;
public class ComdeFormces {
public static int cc2;
public static pair pr;
public static long sum;
public static int ind2;
public static void main(String[] args) throws Exception{
// TODO Auto-generated method stub
// Reader.init(System.in);
... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 7df3018193795c4cbe17330c7695b0f2 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;
public class B {
static final FastReader sc = new FastReader();
static final PrintWriter out = ne... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 54d37cc2d2b83bf186253174ca864f83 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.util.*;
import java.io.*;
// import java.math.*;
public class A {
static class Reader {
BufferedReader br;
StringTokenizer st;
public Reader() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 5b703262ef2404b92ceafceb70d23cc0 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | //package Algorithm;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.ut... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 5412cff5d93114a47cfda76eeb330a13 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | //Utilities
import java.io.*;
import java.util.*;
public class a {
static int t;
static int n;
static char[] a;
static ArrayDeque<Integer> dq;
static int res;
public static void main(String[] args) throws IOException {
t = in.iscan();
while (t-- > 0) {
n = in.iscan();
dq = new ArrayDeq... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 2abaf11588f4f8cb10e6db8d76306d8b | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.util.*;
import java.lang.*;
import java.io.*;
public class Main {
public static void main (String[] args) throws java.lang.Exception {
Scanner scn = new Scanner(System.in);
int tc = scn.nextInt();
while (tc != 0) {
int n = scn.nextInt();
String s = scn.next();
sol... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 7d3556c320e02ca9ab6bfb2492301f6b | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.util.*;
public class codefr4 {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int t = s.nextInt();
while(t-->0) {
int n = s.nextInt();
String st = s.next();
char tem = 'q';
int x = 0;
int y = 0;
for(int i = 0; i<n; ... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | cdba5d9ff52f9ba174e83275bb46286e | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | //package solve;
import java.util.Scanner;
public class TokitsukazeandGoodString {
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
int t = scanner.nextInt();
while (t-- > 0) {
int n = scanner.nextInt();
String s = scanner.next()... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 267e99ce07114c78afc98c77d3d271c1 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int T = s.nextInt();
for(int t=0;t<T;t++) {
String str;
int n, cnt = 0;
n = s.nextInt();
str = s.next();
for(int i=0;i<n;i+=2) {
if(str.charAt(i+1) == str.c... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 60708c09394fd20cdee42d781398587d | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.io.*;
import java.util.*;
import static java.lang.Integer.parseInt;
import static java.lang.Long.parseLong;
import static java.lang.Double.parseDouble;
public class Main {
public static void main(String[] args) throws IOException {
in = new BufferedReader(new InputStreamReader(System.in));
... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 96b4696e033b99ebb0b2046005798bef | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.io.*;
import java.util.*;
import static java.lang.Integer.parseInt;
import static java.lang.Long.parseLong;
import static java.lang.Double.parseDouble;
public class Main {
public static void main(String[] args) throws IOException {
in = new BufferedReader(new InputStreamReader(System.in));
... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 5f9f0d31ac47119b82b3ce331c3537cf | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.util.*;
public class B1{
public static int solve(String str){
ArrayList<Integer> arr=new ArrayList<>();
int count=1;
for(int i=0;i<str.length()-1;i++){
char ch1=str.charAt(i);
char ch2=str.charAt(i+1);
if(ch1!=ch2){
arr... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 9256d6b3f301af55b1d469f21a5a0726 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.util.*;
public class B1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int test = sc.nextInt();
while(test -- > 0) {
int n = sc.nextInt();
String s = sc.next();
ArrayList<Strin... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 42f3c0d99b5b6611919554f3d3a893cb | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.util.*;
public class Solution {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int test = sc.nextInt();
while(test -- > 0) {
int n = sc.nextInt();
String s = sc.next();
int count = 0;
ch... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | f2a9dab1c010cb177037d87079a02e4c | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.io.BufferedReader;
import java.io.InputStreamReader;
public class B {
public static void main(String args[]) throws Exception {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int t = Integer.parseInt(br.readLine().trim());
StringBuilder sb = new StringBuilder();
... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 5da9420b7c5f6a9fb40efca93c38d1ed | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Deque;
import java.util.LinkedList;
public class B {
public static void main(String[] args) throws Exception {
var br = new BufferedReader(new InputStreamReader(System.in));
int t = Integer... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 58b2d8846956fe69a8afe080ac23410b | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.util.Scanner;
public class TokitsukazeandGood01Stringeasyversion {
public static void findOper(int n, String str) {
int count = 0;
int i = 0;
while(i<n) {
int j = i;
int curr = 0;
while(j<n && str.charAt(i) == str.charAt(j)) {
j++;
curr++;
}
if(curr%2 != 0) {
... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 78d84e0db84519288feee7f90fe9916a | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class B {
public static void main(String[] args) throws IOExce... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | b7d8a593ae8ceb1541b39b606502a679 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes |
import java.util.*;
import java.lang.*;
import java.io.*;
public class B {
public static void main(String[] args) throws java.lang.Exception {
try {
FastReader sc = new FastReader();
int t = sc.nextInt();
while (t-- > 0) {
int n=sc.nextInt();
String s=sc.next();
char ch[]=s... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 508c17823b5f246dc57e5688d9f52142 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.io.*;
import java.text.DecimalFormat;
import java.util.*;
public class Main
{
static class Pair
{
long a,b;
public Pair(long a,long b)
{
this.a=a;
this.b=b;
}
// @Override
// public int compareTo(Pair p) {
// ... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 8b4222475d8ead93c9eec80e41396177 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.util.*;
import java.util.zip.CheckedInputStream;
public class CFGood {
public static void main(String[] args) {
Scanner sn=new Scanner(System.in);
int t=Integer.parseInt(sn.nextLine());
while(t-->0){
int n=Integer.parseInt(sn.nextLine());
String s=sn.n... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | a5210566076d70f088a8a015954ee43b | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.util.*;
import java.io.*;
public class Solution {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int t = Integer.parseInt(br.readLine());
BufferedWriter output = new Buffere... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | b1b151159cec504fb4f00344c4175704 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class Main {
static int stoi(String s) {
return Integer.parseInt(s);
}
static long stol(String s) {
return Long.parseLong(s);
}
static int[] mapToIntArray(String[] s) {
int[] A = n... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 8b8ac17f28b27cc0b267a620fb02473d | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.util.*;
import java.io.*;
import java.math.*;
public class Main{
public static void main(String[]args){
long s = System.currentTimeMillis();
new Solver().run();
System.err.println(System.currentTimeMillis()-s+"ms");
}
}
class Solver{
final long... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | cd986ff8410808d3f161e07a62ec159b | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.io.*;
import java.util.*;
// program with user defined FastReader
import java.util.Scanner;
public class Main {
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
br = new BufferedReader(
... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 3e807e4300d1c0213246ec8edc133997 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.io.*;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.StringTokenizer;
public class CodeForces789_2 {
final static class IO {
final static class Reader {
BufferedReader reader;
StringTokenizer tokenizer = null;
Reader() {
... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 06c03c0c405c71e6704d5e74f4d0d94d | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | // B1. Tokitsukaze and Good 01-String (easy version)
import java.util.*;
import java.lang.*;
import java.io.*;
public final class Main {
FastReader s;
// PrintWriter out ;
public static void main(String[] args) throws java.lang.Exception {
new Main().run();
}
void run... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 59268d923eed5c770c8f745c5e35ef4e | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.io.*;
import java.util.*;
public class Main{
private static final String name = "walk";
private static PrintWriter out;
private static FastIO sc;
private static final int mod = 1_000_000_007;
public static void main(String[] args) throws Exception {
try{
sc = new FastIO(name+".... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 6297f3ea6e40c42a30323dff870511b5 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.io.*;
import java.util.*;
public class Good01String {
public static void main(String[] args) throws IOException {
// BufferedReader in = new BufferedReader(new FileReader("Good01String.in"));
// PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("Good01String.out")));
BufferedReader... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | b36d6b2aaadccef9c4680bb1421edd15 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.util.*;
import java.io.*;
public class Solution {
public static void main(String[] args) throws IOException {
int t = sc.nextInt();
while (t-- > 0) {
int n = sc.nextInt();
char[] arr = sc.next().toCharArray();
ArrayList<Integer> list = new ... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 4c2f3ff14c2231d2dc6b142f9d389460 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.util.Scanner;
public class code{
public static void main(String args[]){
Scanner s = new Scanner(System.in);
int t = s.nextInt();
while(t-->0){
int n = s.nextInt();
String str = s.next();
int count = 0;
for(int i = n-1;i>=... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 40eb2fd52d2059f5b05fb872c0ffda12 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | /*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
//package solution;
import java.io.*;
import java.util.*;
//import javafx.util.*;
/**
*
* @author Beaudelaire HOUNDO
... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | caebe3306c6c61a4da6c41283962f1b5 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.util.*;
public class Main {
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
// System.out.println(sc.nextByte());
goodstring(sc);
}
private static void goodstring(Scanner scanner){
int testcase=scanner.nextInt();
for(int... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | e7b2e4a033ca8febae797d24785fc1f8 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes |
import java.util.*;
import java.lang.*;
import java.io.*;
public class Solutions2 {
public static void main (String[] args) throws java.lang.Exception
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
PrintWriter out = new PrintWriter(System.out);
int testCases = I... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 4ead152d683d3c6b512fbd4f4cdd9c8a | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.util.*;
public class Sereja {
public static void main(String[] args){
Scanner in = new Scanner(System.in);
int months=0;
int cent=0;
int length = in.nextInt();
for(int i = 0 ; i< length; i++){
int size = in.nex... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | ff9ad9f1082ba6f601867544af6edceb | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | /* package codechef; // don't place package name! */
import java.util.*;
import java.lang.*;
import java.io.*;
/* Name of the class has to be "Main" only if the class is public. */
public class Main
{
static class FastReader
{
BufferedReader br;
StringTokenizer st;
... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | d86bd8f395ba589ee6c89ea707e72d37 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.util.*;
public class Q1678B {
public static void main(String args[])
{
Scanner s = new Scanner(System.in);
int t = s.nextInt();
while(t-->0)
{
int n = s.nextInt();
String a = s.next();
ArrayList<Integer> count = new ArrayList<>();
int c = 1;
for(int i=1; i<=n-1; i++)... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 9270a2d56e6a636a81e7107b3b5912ad | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes |
import java.util.*;
//import org.graalvm.compiler.phases.graph.FixedNodeProbabilityCache;
//import org.graalvm.compiler.phases.graph.FixedNodeProbabilityCache;
import java.io.*;
import java.math.*;
import java.sql.Array;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.SQLIntegri... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 557effb6ccf08a33f05bbfed28434b0f | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Random;
import java.util.Set;... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 102cc14efb1a1fbc1322d162ee0b38b1 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.sort;
public class Round12 {
public static void main(String[] args) {
FastReader fastRe... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 6791b02337ac013dec3920d2215412f4 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.util.*;
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 A_Number_Transformation{
public static void main (String[] args) throws java.lang.Exception
{
FastReader sc = new FastReader() ;
... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 091d548456e7e81756dbb8a29934fd9f | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.util.*;
public class B
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
while(t-->0)
{
int n = sc.nextInt();
char[] s = sc.next().toCharArray();
int i = 0;
int k = 1;
... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 169cbd15e1f3247095229c9240eac55f | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.util.*;
public class Codeforce {
public static void main(String[] args) {
Scanner scn = new Scanner(System.in);
int t = scn.nextInt();
while(t-- > 0){
int n = scn.nextInt();
int operations = 0;
StringBuilder str = new StringBuilder(... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 712858ee4a92e0373cf9582c5af999f8 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.io.*;import java.lang.*;import java.util.*;
//* --> number of prime numbers less then or equal to x are --> x/ln(x)
//* --> String concatenation using the + operator within a loop should be avoided. Since the String object is immutable, each call for concatenation will
// result in a new String object ... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 069c643b9f46471b6ae8eeda534321aa | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Random;
import java.util.StringTokenizer;... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | a173ee6472d7f49ab2ad732d9f062404 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.util.*;
import java.io.*;
// you can compare with output.txt and expected out
public class Round789B1 {
MyPrintWriter out;
MyScanner in;
final static String IMPOSSIBLE = "IMPOSSIBLE";
final static String POSSIBLE = "POSSIBLE";
final static String YES = "YES";
final static String NO = "NO... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 9a742982a9c82b7ad1559d5b1006f119 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.util.Scanner;
public class SolutionB {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
for(int i = 0; i < n; i++) {
int l = sc.nextInt();
char[] bin = sc.next().toCharArray();
int count = 0;
char prev = bin[0];
int cu... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 9ccad66d3125219ee8391ca5aed48f0b | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.io.*;
import java.sql.Array;
import java.util.*;
import java.util.concurrent.locks.ReentrantLock;
public class JavaApplication {
static BufferedReader in;
static StringTokenizer st;
static String token;
public final String Arr[] = { "", "./", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 1f94e59ee64f0a4eee36cb3206cae8d3 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.io.*;
import java.util.*;
/**
* @author atulanand
*/
public class Solution {
static class Result {
public int solve(int[] arr, int n) {
int last = -1;
List<Integer> vals = new ArrayList<>();
int curr = 0;
for (int i : arr) {
if (last == i) {
... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 65d3804a9673a4ab8f507aca6ca10a46 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 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 CH... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 878cdde5bb6d9aa917c407979bb0eea9 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes |
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.BigInteger;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 9a0f381bbd48f45aecc6c458f0e585f3 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.util.Scanner;
public class Tokitsukaze_and_Good_01_String_easy_version {
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
int T = sc.nextInt();
for(int f=1; f<=T; f++)
{
int n = sc.nextInt();
String s = sc.next();
char c[] = s.toCharArray();
... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | ed3445e9bda636ed5731a19681afecbd | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 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... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | e4b79aa0ea22a8612ee3ba0720c521f7 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.io.*;
import java.util.*;
public class Main {
static ArrayList<String> l = new ArrayList<>();
public static void main(String[] args) {
FastReader in = new FastReader(System.in);
PrintWriter pw = new PrintWriter(System.out);
int test = in.nextInt();... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 7b7cb86d111f0e6d32ccf62e3b2fd1b3 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.util.Scanner;
public class Testing1 {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int t = in.nextInt();
for(int w = 0; w < t; w++){
int n = in.nextInt();
in.nextLine();
char[] ch = in.nextLine().toCha... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 9a7c469458545e4c22201357e6291467 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes |
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
public class cf1678B1 {
// https://codeforces.com/problemset/prob... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | fb265839d66fff9417ab3e7b63114d57 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.util.*;
import java.io.*;
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.ha... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 8d486e1e1a8d2f3712e02645f6e0b279 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;
import java.util.Vector;
import static java.lang.Math.PI;
import static java.lang.Math.pow;
public class haha {
static cla... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | a75e0c927a91b83df711ae8ca08a2d6b | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.Input... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 073eeff213f4005b1fa7576d2470af3c | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.util.*;
import java.io.*;
public class Practice {
static boolean multipleTC = true;
final static int mod2 = 1000000007;
final static int mod = 998244353;
final double E = 2.7182818284590452354;
final double PI = 3.14159265358979323846;
int MAX = 1005;
void pre() throws Exception {
}
// All th... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | cf10effdc1861b91c40dde329868c130 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.util.*;
public class Main {
public static void main(String[] args) {
// write your code here
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
while (t-- > 0) {
int n = sc.nextInt();
String xx = sc.nextLine();
Stri... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | ba9bb928827accd224340b1afb901e2b | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes |
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.*;
public class Round_789 {
static BufferedReader sc = new BufferedReader(new InputStreamReader(System.in));
st... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 4b8e30ca621b310e4d5d8cafddd6819a | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.util.*;
public class Program1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
while (--t >= 0) {
int n = sc.nextInt();
int c = 0;
char[] s = sc.next().toCharArray();
for (int i = 0; i < ... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 73233e63cc83fbbbb730c819c9bb509e | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.util.*;
public class Solution {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
while(t-- !=0){
int n = sc.nextInt();
String str = sc.next();
int count = 0;
for(int ... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | bdfc87079bf14a329118250a81b90fc5 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.security.cert.X509CRL;
import java.util.*;
import java.lang.*;
import java.util.stream.Collector;
import java.util.stream.Co... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | b37b5ea3ca9c09de058b5902674013a5 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.util.Arrays;
import java.util.ArrayList;
public class Main {
public static void main(String[] args) throws IOException {
... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 604280c80fef363c1c08d1f60796213c | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | /*
Enjoy the code :>
Modular Arithematic
1. (a + b)%c = ((a%c)+(b%c))%c
2. (a - c)%c = ((a%c)-(b%c) + c)%c
3. (a * c)%c = ((a%c)*(b*c))%c
4. (a / b)%c = ((a%c)*(b-1%c))%c
Modular Exponetion --> time complexity O(logN)
*/
import static java.lang.Math.max;
import static java.lang.Math.min;
import s... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 22fd686b974307578e616fa11f8c61cc | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.util.Scanner; // Import the Scanner class
import java.util.ArrayList; // import the ArrayList class
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int n = input.nextInt();
ArrayList<Integer> len = new ArrayList<Integer>();
A... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | b5aa4748eee7df9c03d9b08ba404c510 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes |
import java.util.Scanner;
/**
*
* @author Lenovo
*/
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int t = input.nextInt();
for (int i = 0; i < t; i++) {
int count = 0;
int n = input.nextI... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 3d553076349cc670efe03c0d5d381ebc | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | // Working program using Reader Class
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Scanner;
import java.util.StringTokenizer;
import java.util.Collections;
import java.util.*;
public... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 4170099630668893d05fc842f96c6388 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class B {
public static void main(String[] args) {
Scanner in = new Scanner(new BufferedReader(new InputStreamReader(Syst... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 8ccb4f3985d9407f9278303131a96d6f | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.io.*;
import java.util.*;
public class Q1678B1 {
static int mod = (int) (1e9 + 7);
static void solve() {
int count=1;
int n=i();
char[]arr=s().toCharArray();
ArrayList<Integer>al=new ArrayList<>();
for(int i=1;i<arr.length;i++){
if(arr[i]==arr[... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 2c7559ddbe562e2dfc23db2cbae83524 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.util.*;
public class JavaApplication4{
public static void main(String[]args){
Scanner in =new Scanner(System.in);
int t=in.nextInt();
for(int c=0;c<t;++c){
int n=in.nextInt();
String s =in.next();
int count =1;
int min=0;
for(int i=0;i<n-1;++i){
if(s.charAt(i)!= s.charAt... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | bf8cdf670cd9a1ea74540c32eaf63568 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
public class TokitsukazeAndGoodLine {
private static int getNumMinOperForGoodLine(int len, String str) {
int[] arrOfBit = Arrays.stream(str.split("")).mapToInt(Integer::parseInt).t... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 08727fb4961246c2a823a24c68791342 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.util.Scanner;
public class Tokitsukaze_and_Good_01_string {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
int n;
int counter;
String input;
while(t -- > 0){
counter =0;
... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | ab9edb6904aa7c49185d8513723daead | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.util.Scanner;
public class P1678B1 {
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 bin=0;
for(int i=0;i<n;... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 2c6a7b9be559690fe99874fc7a4cb906 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.lang.*;
// import java.math.*;
import java.io.*;
import java.util.*;
public class Main{
public static int mod=(int)(1e9) + 7;
public static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
public static PrintWriter ot=new PrintWriter(System.out);
public static int[] ... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | b4fafafb6fc3b1cc04444e8cac34fbf6 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.util.Scanner;
public class ContestAns {
public static void main(String[] args){
Scanner scin = new Scanner(System.in);
int t = scin.nextInt();
while (t --> 0){
int size = scin.nextInt();
String s = scin.next();
int[] a = new int[s... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 6bc2c19d3a2246d828a756b6757b3dd0 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.util.*;
import java.io.*;
public class B {
public void prayGod() throws IOException {
int t = nextInt();
while (t-- > 0) {
int n = nextInt();
String s = next();
int idx = 0;
ArrayList<Integer> oddLength = new ArrayList<>();
... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 754a34e8e6db6e3fc1dc7fc558d5358e | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.util.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
public class Solution {
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br = new BufferedReader(
new InputStr... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 11 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 92773047c9e22ee15c4282d13827ee63 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes |
import java.util.*;
import java.io.*;
import java.math.BigInteger;
public class Main {
public static FastReader cin;
public static PrintWriter out;
public static long MOD = (long)(1e9 + 7);
public static int [][]dir = new int [][]{{1,0},{0,1},{0,-1},{-1,0},{-1,-1},{-1,1},{1,1},{1,-1}};
... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 17 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 78f8c1913c1f2d9fff2d8c63805e691d | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | //package com.company;
import java.util.*;
import java.util.Stack;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int t = in.nextInt();
while(t-- > 0){
int n = in.nextInt();
String s = in.next();
... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 17 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 72c4338dc9ab5069d339d7a258238a19 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.util.*;
public class MyClass {
public static void main(String args[]) {
Scanner sc = new Scanner(System.in);
int tc = sc.nextInt();
while(tc > 0){
tc--;
int n = sc.nextInt();
String str = sc.next();
int ans = 0;
... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 17 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | ebe91c74e4ccc8e5f378a90088f29cac | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.util.Scanner;
public class problem11 {
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 opr=0;
for(int i=0;... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 17 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 4f95fae1a5e34f52f619d1ec7a7d65e7 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes |
/**
* @author luke_nguyen
* @link https://codeforces.com/contest/1709/problem/E
*/
import java.util.Scanner;
import java.io.BufferedWriter;
import java.io.OutputStreamWriter;
import java.io.IOException;
import java.io.PrintWriter;
public class codeforces_1678B1 {
public static void main(String[] args) throws IO... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 17 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | b7cd81f7578498fde07f08d1b15ba315 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes |
import java.io.*;
import java.util.*;
public class TokitsukazeAndGoodString_Easy {
public static void main(String[] args) throws IOException {
Scanner sc = new Scanner(System.in);
int testcases = sc.nextInt();
StringBuilder sb = new StringBuilder();
while (testcases-->... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 17 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | dda29ab357cc8df6f4e7e9b9c5f45a63 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.io.*;
import java.util.*;
import java.math.*;
//import javafx.util.*;
public class Main
{
static PrintWriter out = new PrintWriter(System.out);
static FastReader in = new FastReader();
static int INF = Integer.MAX_VALUE;
static int NINF = Integer.MIN_VALUE;
static long mod ... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 8 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | c41d7816414fe4b55e115ad7a2ed138f | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.io.*;
import java.util.*;
import java.math.*;
//import javafx.util.*;
public class Main
{
static PrintWriter out = new PrintWriter(System.out);
static FastReader in = new FastReader();
static int INF = Integer.MAX_VALUE;
static int NINF = Integer.MIN_VALUE;
static long mod ... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 8 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | eb2deff5d8d33885e1b79e3f5170f7e1 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.io.*;
import java.util.*;
public class CodeForces {
/*-------------------------------------------EDITING CODE STARTS HERE-------------------------------------------*/
public static void solve(int tCase) throws IOException {
int n = sc.nextInt();
char[] str = sc.next().toCharArray();
... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 8 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 8b3dc4154b3d2377ba03f0c62190f111 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.io.*;
import java.util.*;
public class CodeForces {
/*-------------------------------------------EDITING CODE STARTS HERE-------------------------------------------*/
public static void solve(int tCase) throws IOException {
int n = sc.nextInt();
char[] str = sc.next().toCharArray()... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 8 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 9f376f87ba89f586d3d3992c5a80e6e1 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes |
import java.io.*;
import java.util.*;
public class B {
static class Pair
{
int f;int s; //
Pair(){}
Pair(int f,int s){ this.f=f;this.s=s;}
}
static class Fast {
BufferedReader br;
StringTokenizer st;
public Fast() {
br = new Bu... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 8 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | f49b3b124fe99529aacee308644117f8 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.util.Scanner;
/**
*
* @author Acer
*/
public class NewClass_B {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int T = sc.nextInt();
while(T-- > 0){
int n = sc.nextInt();
char ch[] = sc.next().toCharArra... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 8 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 672f6c72ba2a99cecad73eeac95b8bce | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Scanner;
public class Main {
static class Reader {
final private int BUFFER_SIZE = 1 << 16;
private DataInputStream din;
private byte[] buffer;
private int bufferPointer, bytesRead... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 8 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | c576477707d2f2bef250ecb54c83fefa | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;
import java.util.*;
public class Main {
public static int n,t;
public static void main(String[]args) throws IOException {
Scanner scan = new Scanner(System.in);
... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 8 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | b9e6cc1db8db3733056b85b710e97e81 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | //---#ON_MY_WAY---
//---#THE_SILENT_ONE---
import static java.lang.Math.*;
import java.io.*;
import java.math.*;
import java.util.*;
public class B {
static FastReader x = new FastReader();
static OutputStream outputStream = System.out;
static PrintWriter out = new PrintWriter(outputStream);
/*----... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 8 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output | |
PASSED | 07f7d545a8d766f54a5606cc48127597 | train_108.jsonl | 1652020500 | This is the easy version of the problem. The only difference between the two versions is that the harder version asks additionally for a minimum number of subsegments.Tokitsukaze has a binary string $$$s$$$ of length $$$n$$$, consisting only of zeros and ones, $$$n$$$ is even.Now Tokitsukaze divides $$$s$$$ into the mi... | 256 megabytes | import java.util.*;
import java.io.*;
import java.math.*;
/*
Challenge 1: Newbie to CM in 1year (Dec 2021 - Nov 2022) 5* Codechef
Challenge 2: CM to IM in 1 year (Dec 2022 - Nov 2023) 6* Codechef
Challenge 3: IM to GM in 1 year (Dec 2023 - Nov 2024) 7* Codechef
Goal: Become better in CP!... | Java | ["5\n10\n1110011000\n8\n11001111\n2\n00\n2\n11\n6\n100110"] | 1 second | ["3\n0\n0\n0\n3"] | NoteIn the first test case, one of the ways to make $$$s$$$ good is the following.Change $$$s_3$$$, $$$s_6$$$ and $$$s_7$$$ to '0', after that $$$s$$$ becomes "1100000000", it can be divided into "11" and "00000000", which lengths are $$$2$$$ and $$$8$$$ respectively. There are other ways to operate $$$3$$$ times to ma... | Java 8 | standard input | [
"implementation"
] | aded139ff4d3f313f8e4d81559760f12 | The first contains a single positive integer $$$t$$$ ($$$1 \leq t \leq 10\,000$$$) — the number of test cases. For each test case, the first line contains a single integer $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) — the length of $$$s$$$, it is guaranteed that $$$n$$$ is even. The second line contains a binary string ... | 800 | For each test case, print a single line with one integer — the minimum number of operations to make $$$s$$$ good. | standard output |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.