oj.uz

답안 #792959

# 제출 시각 아이디 문제 언어 결과 실행 시간 메모리
792959 2023-07-25T11:38:16 Z esomer Vision Program (IOI19_vision) C++17
59 / 100
 9 ms 1232 KB 
#include<bits/stdc++.h>
#include "vision.h"

using namespace std;

#define endl "\n"

typedef long long ll;

int h, w;

void calc_spec(int n, vector<int>& dist, int k, bool type){
	vector<int> val(n); //Whether each row has at least one black.
	for(int i = 0; i < n; i++){
		vector<int> nws;
		if(type == 0){
			for(int j = 0; j < w; j++){
				nws.push_back(i * w + j);
			}
		}else{
			for(int j = 0; j < h; j++){
				nws.push_back(j * w + i);
			}
		}
		val[i] = add_or(nws);
	}
	vector<int> previous((int)dist.size(), 0);
	vector<int> primes;
	for(int q = 2; q < n; q++){
		bool prime = 1;
		for(int k = 2; k * k <= q; k++){
			if((q % k) == 0){
				prime = 0;
			}
		}
		if(prime){
			vector<int> powers = {q};
			vector<int> before;
			for(int l = (int)powers.size() - 1; l >= 0; l--){
				int d = powers[l];
				vector<int> all_res;
				for(int i = 0; i < d && i + d < n; i++){
					vector<int> nws;
					for(int j = i; j < n; j += d){
						//~ cout << "d " << d << " j " << j << " type " << type << endl;
						nws.push_back(val[j]);
					}
					int orr = add_or(nws);
					int xorr = add_xor(nws);
					int nott = add_not(xorr);
					//~ cout << "orr "<< orr << " xorr " << xorr << " nott " << nott << endl;
					all_res.push_back(add_and({orr, nott}));
				}
				//~ cout << "hi d " << d <<endl;
				int orr = add_or(all_res);
				if((int)before.size() == 0){
					before.push_back(orr);
					previous[d] = orr;
					primes.push_back(previous[d]);
					continue;
				}
				//~ cout << "here" << endl;
				int orr_before = add_or(before);
				//Now, I'm one if and(orr, not(orr_before)) is 1, so I'm one and no one before is one).
				int nott = add_not(orr_before);
				previous[d] = add_and({orr, nott});
				//~ cout << "there" << endl;
				before.push_back(previous[d]);
				primes.push_back(previous[d]);
			}
			//~ cout << "left"<< endl;
		}
	}
	vector<int> before = {1};
	for(int d = min((int)dist.size() - 1, 1); d > 0; d--){
		if(d == 1){
			int xorr = add_xor(val);
			if((int)before.size() == 0){
				dist[d] = add_not(xorr);
				continue;
			}
			int orr_before = add_or(primes);
			//It's only 1 if it is not any of the previous.
			int nott = add_not(orr_before);
			dist[d] = add_and({nott, add_not(xorr)});
			before.push_back(dist[d]);
			continue;
		}
		vector<int> all_res;
		int x = d;
		for(int k = 2; k * k <= x; k++){
			ll crr = 1;
			while(x % k == 0){
				crr *= k;
				x /= k;
			}
			if(crr != 1){
				all_res.push_back(previous[crr]);
			}
		}
		if(x > 1){
			all_res.push_back(previous[x]);
		}
		int orr = add_and(all_res);
		if((int)before.size() == 0){
			before.push_back(orr);
			dist[d] = orr;
			continue;
		}
		int orr_before = add_or(before);
		//Now, I'm one if and(orr, not(orr_before)) is 1, so I'm one and no one before is one).
		int nott = add_not(orr_before);
		dist[d] = add_and({orr, nott});
		before.push_back(dist[d]);
	}
	dist[0] = add_xor(val);
}

void calc(int n, vector<int>& dist, int k, bool type){
	vector<int> val(n); //Whether each row has at least one black.
	for(int i = 0; i < n; i++){
		vector<int> nws;
		if(type == 0){
			for(int j = 0; j < w; j++){
				nws.push_back(i * w + j);
			}
		}else{
			for(int j = 0; j < h; j++){
				nws.push_back(j * w + i);
			}
		}
		val[i] = add_or(nws);
	}
	vector<int> previous((int)dist.size());
	for(int q = 2; q < n; q++){
		bool prime = 1;
		for(int k = 2; k * k <= q; k++){
			if((q % k) == 0){
				prime = 0;
			}
		}
		if(prime){
			vector<int> powers = {q};
			int x = q * q;
			while(x < n){
				powers.push_back(x);
				x *= q;
			}
			vector<int> before;
			for(int l = (int)powers.size() - 1; l >= 0; l--){
				int d = powers[l];
				vector<int> all_res;
				for(int i = 0; i < d && i + d < n; i++){
					vector<int> nws;
					for(int j = i; j < n; j += d){
						//~ cout << "d " << d << " j " << j << " type " << type << endl;
						nws.push_back(val[j]);
					}
					int orr = add_or(nws);
					int xorr = add_xor(nws);
					int nott = add_not(xorr);
					//~ cout << "orr "<< orr << " xorr " << xorr << " nott " << nott << endl;
					all_res.push_back(add_and({orr, nott}));
				}
				//~ cout << "hi d " << d <<endl;
				int orr = add_or(all_res);
				if((int)before.size() == 0){
					before.push_back(orr);
					previous[d] = orr;
					continue;
				}
				//~ cout << "here" << endl;
				int orr_before = add_or(before);
				//Now, I'm one if and(orr, not(orr_before)) is 1, so I'm one and no one before is one).
				int nott = add_not(orr_before);
				previous[d] = add_and({orr, nott});
				//~ cout << "there" << endl;
				before.push_back(previous[d]);
			}
			//~ cout << "left"<< endl;
		}
	}
	vector<int> before;
	for(int d = (int)dist.size() - 1; d > 0; d--){
		if(d == 1){
			int xorr = add_xor(val);
			if((int)before.size() == 0){
				dist[d] = add_not(xorr);
				continue;
			}
			int orr_before = add_or(before);
			//It's only 1 if it is not any of the previous.
			int nott = add_not(orr_before);
			dist[d] = add_and({nott, add_not(xorr)});
			before.push_back(dist[d]);
			continue;
		}
		vector<int> all_res;
		int x = d;
		for(int k = 2; k * k <= x; k++){
			ll crr = 1;
			while(x % k == 0){
				crr *= k;
				x /= k;
			}
			if(crr != 1){
				all_res.push_back(previous[crr]);
			}
		}
		if(x > 1){
			all_res.push_back(previous[x]);
		}
		int orr = add_and(all_res);
		if((int)before.size() == 0){
			before.push_back(orr);
			dist[d] = orr;
			continue;
		}
		int orr_before = add_or(before);
		//Now, I'm one if and(orr, not(orr_before)) is 1, so I'm one and no one before is one).
		int nott = add_not(orr_before);
		dist[d] = add_and({orr, nott});
		before.push_back(dist[d]);
	}
	dist[0] = add_xor(val);
}

void construct_network(int H, int W, int K){
	//Now, I want to get the value of each row.
	h = H;
	w = W;
	if(min(W, H) == 1){
		vector<int> results;
		for(int i = 0; i < H; i++){
			for(int j = 0; j < W; j++){
				for(int addi = -K; addi <= K; addi += K){
					for(int addj = -K; addj <= K; addj += K){
						int nwi = i + addi;
						int nwj = j + addj;
						if(nwi < 0 || nwi >= H || nwj < 0 || nwj >= W || (nwi == i && nwj == j)) continue;
						int ind1 = i * W + j;
						int ind2 = nwi * W + nwj;
						results.push_back(add_and({ind1, ind2}));
					}
				}
			}
		}
		add_or(results);
	}else if(max(W, H) <= 100){
		vector<int> distr(H, 0);
		vector<int> distc(W, 0);
		calc(H, distr, K, 0);
		calc(W, distc, K, 1);
		vector<int> possibilities;
		for(int i = 0; i < (int)distr.size() && i <= K; i++){
			int j = K - i;
			if(j >= (int)distc.size()) continue;
			possibilities.push_back(add_and({distr[i], distc[j]}));
		}
		add_or(possibilities);
	}else if(K == 1){
		vector<int> distr(H, 0);
		vector<int> distc(W, 0);
		calc_spec(H, distr, K, 0);
		calc_spec(W, distc, K, 1);
		vector<int> possibilities;
		for(int i = 0; i < (int)distr.size() && i <= K; i++){
			int j = K - i;
			if(j >= (int)distc.size()) continue;
			possibilities.push_back(add_and({distr[i], distc[j]}));
		}
		add_or(possibilities);	
	}else{
		vector<int> results;
		for(int i = 0; i < H; i++){
			for(int j = 0; j < W; j++){
				if(i + j == K){
					results.push_back(add_and({0, i * W + j}));
				}
			}
		}
		add_or(results);
	}
}

//~ static const int MAX_INSTRUCTIONS = 10000;
//~ static const int MAX_INPUTS = 1000000;

//~ static const int _AND = 0;
//~ static const int _OR = 1;
//~ static const int _XOR = 2;
//~ static const int _NOT = 3;

//~ static inline bool increasing(int a, int b, int c) {
	//~ return a <= b && b <= c;
//~ }

//~ [[noreturn]] static inline void error(string message) {
	//~ printf("%s\n", message.c_str());
	//~ exit(0);
//~ }

//~ class InstructionNetwork {

	//~ struct Instruction {
		//~ int type;
		//~ vector<int> input_indexes;

		//~ inline Instruction(int _type, const vector<int>& _input_indexes):
				//~ type(_type), input_indexes(_input_indexes) {
		//~ }

		//~ inline int apply(int a, int b) const {
			//~ switch (type) {
				//~ case _AND:
					//~ return a & b;
				//~ case _OR:
					//~ return a | b;
				//~ case _XOR:
					//~ return a ^ b;
				//~ default:
					//~ return 0;
			//~ }
		//~ }

		//~ inline int compute(const vector<int>& memory_cells) const {
			//~ int r = memory_cells[input_indexes[0]];
			//~ if (type == _NOT)
				//~ return 1 - r;
			//~ for (int j = 1; j < (int)input_indexes.size(); j++)
				//~ r = apply(r, memory_cells[input_indexes[j]]);
			//~ return r;
		//~ }
	//~ };

	//~ int input_size;
	//~ int total_inputs;
	//~ vector<Instruction> instructions;

//~ public:

	//~ inline void init(int _input_size) {
		//~ this->input_size = _input_size;
		//~ this->total_inputs = 0;
		//~ this->instructions.clear();
	//~ }

	//~ inline int add_instruction(int type, const vector<int>& input_indexes) {
		//~ if (input_indexes.size() == 0)
			//~ error("Instruction with no inputs");

		//~ if (instructions.size() + 1 > MAX_INSTRUCTIONS)
			//~ error("Too many instructions");

		//~ if (total_inputs + input_indexes.size() > MAX_INPUTS)
			//~ error("Too many inputs");

		//~ instructions.emplace_back(type, input_indexes);
		//~ total_inputs += input_indexes.size();
		//~ int new_index = input_size + (int)instructions.size() - 1;

		//~ for (int input_index : input_indexes)
			//~ if (!increasing(0, input_index, new_index-1))
				//~ error("Invalid index");

		//~ return new_index;
	//~ }

	//~ inline int compute(vector<int> &memory_cells) const {
		//~ for (auto &instruction : instructions)
			//~ memory_cells.push_back(instruction.compute(memory_cells));
		//~ return memory_cells.back();
	//~ }
//~ };


//~ static InstructionNetwork instructionNetwork;

//~ int main() {
	//~ freopen("in.txt", "r", stdin);
	//~ int H, W, K;
	//~ assert(3 == scanf("%d%d%d", &H, &W, &K));

	//~ FILE *log_file = fopen("log.txt","w");

	//~ instructionNetwork.init(H * W);
	//~ construct_network(H, W, K);

	//~ while (true) {
		//~ int rowA, colA, rowB, colB;
		//~ assert(1 == scanf("%d", &rowA));
		//~ if (rowA == -1)
			//~ break;
		//~ assert(3 == scanf("%d%d%d", &colA, &rowB, &colB));

		//~ if ((!increasing(0, rowA, H-1)) ||
			//~ (!increasing(0, colA, W-1)) ||
			//~ (!increasing(0, rowB, H-1)) ||
			//~ (!increasing(0, colB, W-1)) ||
			//~ (rowA == rowB && colA == colB)) {
			//~ printf("-1\n");
			//~ fprintf(log_file, "-1\n");
			//~ fflush(stdout);
			//~ fflush(log_file);
			//~ continue;
		//~ }

		//~ vector<int> memory_cells;
		//~ for (int row = 0; row < H; row++)
			//~ for (int col = 0; col < W; col++) {
				//~ bool active = (row == rowA && col == colA) || (row == rowB && col == colB);
				//~ memory_cells.push_back(active ? 1 : 0);
			//~ }
		//~ int computation_result = instructionNetwork.compute(memory_cells);

		//~ printf("%d\n", computation_result);
		//~ fflush(stdout);

		//~ for(int i = 0; i < (int)memory_cells.size(); i++){
			//~ fprintf(log_file, "i: %d\n", i);
			//~ fprintf(log_file, (i ? " %d" : "%d"), memory_cells[i]);
			//~ fprintf(log_file, "\n");
		//~ }
		//~ fprintf(log_file, "\n");
		//~ fflush(log_file);
	//~ }
	//~ fclose(stdin);
//~ }

//~ int add_and(vector<int> Ns) {
	//~ return instructionNetwork.add_instruction(_AND, Ns);
//~ }

//~ int add_or(vector<int> Ns) {
	//~ return instructionNetwork.add_instruction(_OR, Ns);
//~ }

//~ int add_xor(vector<int> Ns) {
	//~ return instructionNetwork.add_instruction(_XOR, Ns);
//~ }

//~ int add_not(int N) {
	//~ vector<int> Ns = {N};
	//~ return instructionNetwork.add_instruction(_NOT, Ns);
//~ }

Subtask #1
10.0 / 10.0

# 결과 실행 시간 메모리 Grader output
1 Correct 0 ms 212 KB Output is correct
2 Correct 0 ms 212 KB Output is correct
3 Correct 0 ms 212 KB Output is correct
4 Correct 1 ms 212 KB Output is correct
5 Correct 1 ms 212 KB Output is correct
6 Correct 1 ms 212 KB Output is correct
7 Correct 0 ms 212 KB Output is correct
8 Correct 1 ms 212 KB Output is correct
9 Correct 1 ms 212 KB Output is correct
10 Correct 0 ms 212 KB Output is correct
11 Correct 1 ms 296 KB Output is correct
12 Correct 1 ms 300 KB Output is correct
13 Correct 1 ms 212 KB Output is correct
14 Correct 1 ms 212 KB Output is correct
15 Correct 1 ms 212 KB Output is correct
16 Correct 1 ms 212 KB Output is correct
17 Correct 0 ms 212 KB Output is correct
18 Correct 1 ms 212 KB Output is correct

Subtask #2
11.0 / 11.0

# 결과 실행 시간 메모리 Grader output
1 Correct 0 ms 212 KB Output is correct
2 Correct 0 ms 212 KB Output is correct
3 Correct 0 ms 212 KB Output is correct
4 Correct 1 ms 212 KB Output is correct
5 Correct 1 ms 212 KB Output is correct
6 Correct 1 ms 212 KB Output is correct
7 Correct 0 ms 212 KB Output is correct
8 Correct 1 ms 212 KB Output is correct
9 Correct 1 ms 212 KB Output is correct
10 Correct 0 ms 212 KB Output is correct
11 Correct 1 ms 296 KB Output is correct
12 Correct 1 ms 300 KB Output is correct
13 Correct 1 ms 212 KB Output is correct
14 Correct 1 ms 212 KB Output is correct
15 Correct 1 ms 212 KB Output is correct
16 Correct 1 ms 212 KB Output is correct
17 Correct 0 ms 212 KB Output is correct
18 Correct 1 ms 212 KB Output is correct
19 Correct 1 ms 212 KB Output is correct
20 Correct 1 ms 212 KB Output is correct
21 Correct 1 ms 212 KB Output is correct
22 Correct 1 ms 212 KB Output is correct
23 Correct 1 ms 212 KB Output is correct
24 Correct 1 ms 212 KB Output is correct
25 Correct 1 ms 212 KB Output is correct
26 Correct 1 ms 212 KB Output is correct
27 Correct 1 ms 212 KB Output is correct

Subtask #3
11.0 / 11.0

# 결과 실행 시간 메모리 Grader output
1 Correct 0 ms 212 KB Output is correct
2 Correct 0 ms 212 KB Output is correct
3 Correct 0 ms 212 KB Output is correct
4 Correct 1 ms 212 KB Output is correct
5 Correct 1 ms 212 KB Output is correct
6 Correct 1 ms 212 KB Output is correct
7 Correct 0 ms 212 KB Output is correct
8 Correct 1 ms 212 KB Output is correct
9 Correct 1 ms 212 KB Output is correct
10 Correct 0 ms 212 KB Output is correct
11 Correct 1 ms 296 KB Output is correct
12 Correct 1 ms 300 KB Output is correct
13 Correct 1 ms 212 KB Output is correct
14 Correct 1 ms 212 KB Output is correct
15 Correct 1 ms 212 KB Output is correct
16 Correct 1 ms 212 KB Output is correct
17 Correct 0 ms 212 KB Output is correct
18 Correct 1 ms 212 KB Output is correct
19 Correct 1 ms 212 KB Output is correct
20 Correct 1 ms 212 KB Output is correct
21 Correct 1 ms 212 KB Output is correct
22 Correct 1 ms 212 KB Output is correct
23 Correct 1 ms 212 KB Output is correct
24 Correct 1 ms 212 KB Output is correct
25 Correct 1 ms 212 KB Output is correct
26 Correct 1 ms 212 KB Output is correct
27 Correct 1 ms 212 KB Output is correct
28 Correct 1 ms 340 KB Output is correct
29 Correct 0 ms 212 KB Output is correct
30 Correct 1 ms 212 KB Output is correct
31 Correct 1 ms 340 KB Output is correct
32 Correct 1 ms 300 KB Output is correct
33 Correct 1 ms 340 KB Output is correct
34 Correct 2 ms 340 KB Output is correct
35 Correct 1 ms 340 KB Output is correct
36 Correct 2 ms 340 KB Output is correct
37 Correct 2 ms 340 KB Output is correct

Subtask #4
15.0 / 15.0

# 결과 실행 시간 메모리 Grader output
1 Correct 0 ms 212 KB Output is correct
2 Correct 0 ms 212 KB Output is correct
3 Correct 0 ms 212 KB Output is correct
4 Correct 1 ms 212 KB Output is correct
5 Correct 1 ms 212 KB Output is correct
6 Correct 1 ms 212 KB Output is correct
7 Correct 0 ms 212 KB Output is correct
8 Correct 1 ms 212 KB Output is correct
9 Correct 1 ms 212 KB Output is correct
10 Correct 0 ms 212 KB Output is correct
11 Correct 1 ms 296 KB Output is correct
12 Correct 1 ms 300 KB Output is correct
13 Correct 1 ms 212 KB Output is correct
14 Correct 1 ms 212 KB Output is correct
15 Correct 1 ms 212 KB Output is correct
16 Correct 1 ms 212 KB Output is correct
17 Correct 0 ms 212 KB Output is correct
18 Correct 1 ms 212 KB Output is correct
19 Correct 1 ms 212 KB Output is correct
20 Correct 1 ms 212 KB Output is correct
21 Correct 1 ms 212 KB Output is correct
22 Correct 1 ms 212 KB Output is correct
23 Correct 1 ms 212 KB Output is correct
24 Correct 1 ms 212 KB Output is correct
25 Correct 1 ms 212 KB Output is correct
26 Correct 1 ms 212 KB Output is correct
27 Correct 1 ms 212 KB Output is correct
28 Correct 1 ms 340 KB Output is correct
29 Correct 0 ms 212 KB Output is correct
30 Correct 1 ms 212 KB Output is correct
31 Correct 1 ms 340 KB Output is correct
32 Correct 1 ms 300 KB Output is correct
33 Correct 1 ms 340 KB Output is correct
34 Correct 2 ms 340 KB Output is correct
35 Correct 1 ms 340 KB Output is correct
36 Correct 2 ms 340 KB Output is correct
37 Correct 2 ms 340 KB Output is correct
38 Correct 6 ms 1192 KB Output is correct
39 Correct 1 ms 212 KB Output is correct
40 Correct 1 ms 212 KB Output is correct
41 Correct 4 ms 808 KB Output is correct
42 Correct 5 ms 808 KB Output is correct
43 Correct 9 ms 1228 KB Output is correct
44 Correct 7 ms 1176 KB Output is correct
45 Correct 6 ms 1232 KB Output is correct
46 Correct 8 ms 1232 KB Output is correct
47 Correct 8 ms 1188 KB Output is correct

Subtask #5
12.0 / 12.0

# 결과 실행 시간 메모리 Grader output
1 Correct 1 ms 340 KB Output is correct
2 Correct 1 ms 212 KB Output is correct
3 Correct 1 ms 212 KB Output is correct
4 Correct 1 ms 212 KB Output is correct
5 Correct 1 ms 212 KB Output is correct
6 Correct 1 ms 304 KB Output is correct
7 Correct 1 ms 212 KB Output is correct
8 Correct 0 ms 212 KB Output is correct
9 Correct 1 ms 340 KB Output is correct
10 Correct 1 ms 336 KB Output is correct
11 Correct 1 ms 212 KB Output is correct
12 Correct 1 ms 212 KB Output is correct
13 Correct 1 ms 212 KB Output is correct
14 Correct 1 ms 212 KB Output is correct
15 Correct 1 ms 340 KB Output is correct
16 Correct 1 ms 340 KB Output is correct
17 Correct 1 ms 212 KB Output is correct
18 Correct 1 ms 300 KB Output is correct
19 Correct 0 ms 212 KB Output is correct
20 Correct 0 ms 212 KB Output is correct
21 Correct 1 ms 212 KB Output is correct
22 Correct 1 ms 212 KB Output is correct

Subtask #6
0 / 8.0

# 결과 실행 시간 메모리 Grader output
1 Correct 0 ms 212 KB Output is correct
2 Correct 0 ms 212 KB Output is correct
3 Correct 2 ms 596 KB Output is correct
4 Correct 1 ms 212 KB Output is correct
5 Correct 0 ms 212 KB Output is correct
6 Correct 1 ms 212 KB Output is correct
7 Correct 1 ms 212 KB Output is correct
8 Correct 5 ms 724 KB Output is correct
9 Correct 0 ms 212 KB Output is correct
10 Correct 1 ms 212 KB Output is correct
11 Correct 1 ms 296 KB Output is correct
12 Correct 1 ms 232 KB Output is correct
13 Correct 1 ms 292 KB Output is correct
14 Correct 1 ms 212 KB Output is correct
15 Correct 1 ms 212 KB Output is correct
16 Correct 1 ms 296 KB Output is correct
17 Correct 1 ms 300 KB Output is correct
18 Correct 1 ms 212 KB Output is correct
19 Correct 1 ms 212 KB Output is correct
20 Incorrect 3 ms 1108 KB WA in grader: Too many instructions
21 Halted 0 ms 0 KB -

Subtask #7
0 / 14.0

# 결과 실행 시간 메모리 Grader output
1 Incorrect 2 ms 1232 KB WA in grader: Too many instructions
2 Halted 0 ms 0 KB -

Subtask #8
0 / 19.0

# 결과 실행 시간 메모리 Grader output
1 Correct 0 ms 212 KB Output is correct
2 Correct 0 ms 212 KB Output is correct
3 Correct 0 ms 212 KB Output is correct
4 Correct 1 ms 212 KB Output is correct
5 Correct 1 ms 212 KB Output is correct
6 Correct 1 ms 212 KB Output is correct
7 Correct 0 ms 212 KB Output is correct
8 Correct 1 ms 212 KB Output is correct
9 Correct 1 ms 212 KB Output is correct
10 Correct 0 ms 212 KB Output is correct
11 Correct 1 ms 296 KB Output is correct
12 Correct 1 ms 300 KB Output is correct
13 Correct 1 ms 212 KB Output is correct
14 Correct 1 ms 212 KB Output is correct
15 Correct 1 ms 212 KB Output is correct
16 Correct 1 ms 212 KB Output is correct
17 Correct 0 ms 212 KB Output is correct
18 Correct 1 ms 212 KB Output is correct
19 Correct 1 ms 212 KB Output is correct
20 Correct 1 ms 212 KB Output is correct
21 Correct 1 ms 212 KB Output is correct
22 Correct 1 ms 212 KB Output is correct
23 Correct 1 ms 212 KB Output is correct
24 Correct 1 ms 212 KB Output is correct
25 Correct 1 ms 212 KB Output is correct
26 Correct 1 ms 212 KB Output is correct
27 Correct 1 ms 212 KB Output is correct
28 Correct 1 ms 340 KB Output is correct
29 Correct 0 ms 212 KB Output is correct
30 Correct 1 ms 212 KB Output is correct
31 Correct 1 ms 340 KB Output is correct
32 Correct 1 ms 300 KB Output is correct
33 Correct 1 ms 340 KB Output is correct
34 Correct 2 ms 340 KB Output is correct
35 Correct 1 ms 340 KB Output is correct
36 Correct 2 ms 340 KB Output is correct
37 Correct 2 ms 340 KB Output is correct
38 Correct 6 ms 1192 KB Output is correct
39 Correct 1 ms 212 KB Output is correct
40 Correct 1 ms 212 KB Output is correct
41 Correct 4 ms 808 KB Output is correct
42 Correct 5 ms 808 KB Output is correct
43 Correct 9 ms 1228 KB Output is correct
44 Correct 7 ms 1176 KB Output is correct
45 Correct 6 ms 1232 KB Output is correct
46 Correct 8 ms 1232 KB Output is correct
47 Correct 8 ms 1188 KB Output is correct
48 Correct 1 ms 340 KB Output is correct
49 Correct 1 ms 212 KB Output is correct
50 Correct 1 ms 212 KB Output is correct
51 Correct 1 ms 212 KB Output is correct
52 Correct 1 ms 212 KB Output is correct
53 Correct 1 ms 304 KB Output is correct
54 Correct 1 ms 212 KB Output is correct
55 Correct 0 ms 212 KB Output is correct
56 Correct 1 ms 340 KB Output is correct
57 Correct 1 ms 336 KB Output is correct
58 Correct 1 ms 212 KB Output is correct
59 Correct 1 ms 212 KB Output is correct
60 Correct 1 ms 212 KB Output is correct
61 Correct 1 ms 212 KB Output is correct
62 Correct 1 ms 340 KB Output is correct
63 Correct 1 ms 340 KB Output is correct
64 Correct 1 ms 212 KB Output is correct
65 Correct 1 ms 300 KB Output is correct
66 Correct 0 ms 212 KB Output is correct
67 Correct 0 ms 212 KB Output is correct
68 Correct 1 ms 212 KB Output is correct
69 Correct 1 ms 212 KB Output is correct
70 Correct 0 ms 212 KB Output is correct
71 Correct 0 ms 212 KB Output is correct
72 Correct 2 ms 596 KB Output is correct
73 Correct 1 ms 212 KB Output is correct
74 Correct 0 ms 212 KB Output is correct
75 Correct 1 ms 212 KB Output is correct
76 Correct 1 ms 212 KB Output is correct
77 Correct 5 ms 724 KB Output is correct
78 Correct 0 ms 212 KB Output is correct
79 Correct 1 ms 212 KB Output is correct
80 Correct 1 ms 296 KB Output is correct
81 Correct 1 ms 232 KB Output is correct
82 Correct 1 ms 292 KB Output is correct
83 Correct 1 ms 212 KB Output is correct
84 Correct 1 ms 212 KB Output is correct
85 Correct 1 ms 296 KB Output is correct
86 Correct 1 ms 300 KB Output is correct
87 Correct 1 ms 212 KB Output is correct
88 Correct 1 ms 212 KB Output is correct
89 Incorrect 3 ms 1108 KB WA in grader: Too many instructions
90 Halted 0 ms 0 KB -