verify/unit-test/unit-test-fast-io.test.cpp

• View this file on GitHub
• Last update: 2022-07-21 16:12:33-04:00
• Problem: https://judge.yosupo.jp/problem/many_aplusb

Depends on

• library/misc/fast-io.hpp

Code

#define PROBLEM "https://judge.yosupo.jp/problem/many_aplusb"

#include <bits/stdc++.h>
#include "../../library/misc/fast-io.hpp"

Scanner sc(stdin);
Printer pr(stdout);

int main() {
	using namespace std;
	int tt;
	sc.read(tt);
	while (tt--) {
		long long a, b;
		sc.read(a, b);
		pr.writeln(a + b);
	}
	return 0;
}

#define PROBLEM "https://judge.yosupo.jp/problem/many_aplusb"

#include <bits/stdc++.h>

#include <unistd.h>

struct Scanner {
	int fd = -1;
	char line[(1 << 15) + 1];
	size_t st = 0, ed = 0;
	
	void reread() {
		memmove(line, line + st, ed - st);
		ed -= st;
		st = 0;
		ed += ::read(fd, line + ed, (1 << 15) - ed);
		line[ed] = '\0';
	}
	
	bool succ() {
		while (true) {
			if (st == ed) {
				reread();
				if (st == ed) return false;
			}
			while (st != ed && isspace(line[st])) st++;
			if (st != ed) break;
		}
		if (ed - st <= 50) {
			bool sep = false;
			for (size_t i = st; i < ed; i++) {
				if (isspace(line[i])) {
					sep = true;
					break;
				}
			}
			if (!sep) reread();
		}
		return true;
	}
	
	template <class T, std::enable_if_t<std::is_same<T, std::string>::value, int> = 0>
	bool read_single(T& ref) {
		if (!succ()) return false;
		while (true) {
			size_t sz = 0;
			while (st + sz < ed && !isspace(line[st + sz])) sz++;
			ref.append(line + st, sz);
			st += sz;
			if (!sz || st != ed) break;
			reread();            
		}
		return true;
	}
	
	template <class T, std::enable_if_t<std::is_integral<T>::value, int> = 0>
	bool read_single(T& ref) {
		if (!succ()) return false;
		bool neg = false;
		if (line[st] == '-') {
			neg = true;
			st++;
		}
		ref = T(0);
		while (isdigit(line[st])) {
			ref = 10 * ref + (line[st++] & 0xf);
		}
		if (neg) ref = -ref;
		return true;
	}
	
	template <class T> bool read_single(std::vector<T>& ref) {
		for (auto& d : ref) {
			if (!read_single(d)) return false;
		}
		return true;
	}
	
	void read() {}
	
	template <class H, class... T> void read(H& h, T&... t) {
		bool f = read_single(h);
		assert(f);
		read(t...);
	}
	
	Scanner(FILE* fp) : fd(fileno(fp)) {}
};

struct Printer {
  public:
	template <bool F = false> void write() {}
	template <bool F = false, class H, class... T>
	
	void write(const H& h, const T&... t) {
		if (F) write_single(' ');
		write_single(h);
		write<true>(t...);
	}
	
	template <class... T> void writeln(const T&... t) {
		write(t...);
		write_single('\n');
	}

	Printer(FILE* _fp) : fp(_fp) {}
	~Printer() { flush(); }

private:
	static constexpr size_t SIZE = 1 << 15;
	FILE* fp;
	char line[SIZE], small[50];
	size_t pos = 0;
	
	void flush() {
		fwrite(line, 1, pos, fp);
		pos = 0;
	}
	
	void write_single(const char& val) {
		if (pos == SIZE) flush();
		line[pos++] = val;
	}
	
	template <class T, std::enable_if_t<std::is_integral<T>::value, int> = 0>
	void write_single(T val) {
		if (pos > (1 << 15) - 50) flush();
		if (val == 0) {
			write_single('0');
			return;
		}
		if (val < 0) {
			write_single('-');
			val = -val;  // todo min

		}
		size_t len = 0;
		while (val) {
			small[len++] = char(0x30 | (val % 10));
			val /= 10;
		}
		for (size_t i = 0; i < len; i++) {
			line[pos + i] = small[len - 1 - i];
		}
		pos += len;
	}
	
	void write_single(const std::string& s) {
		for (char c : s) write_single(c);
	}
	
	void write_single(const char* s) {
		size_t len = strlen(s);
		for (size_t i = 0; i < len; i++) write_single(s[i]);
	}

	template <class T> void write_single(const std::vector<T>& val) {
		auto n = val.size();
		for (size_t i = 0; i < n; i++) {
			if (i) write_single(' ');
			write_single(val[i]);
		}
	}
};

Scanner sc(stdin);
Printer pr(stdout);

int main() {
	using namespace std;
	int tt;
	sc.read(tt);
	while (tt--) {
		long long a, b;
		sc.read(a, b);
		pr.writeln(a + b);
	}
	return 0;
}

Back to top page