code stringlengths 4 1.01M | language stringclasses 2
values |
|---|---|
void main()
{
int n = readln.chomp.to!int;
int[] a = readln.split.to!(int[]);
int m = round(a.sum / n.to!double).to!int;
int cost;
foreach (x; a)
{
cost += (x - m) ^^ 2;
}
cost.writeln;
}
import std.stdio;
import std.string;
import std.array;
import std.conv;
import std.algori... | D |
import std.stdio;
import std.string;
void main()
{
string S = readln.chomp;
ulong len = S.length;
ulong ans = 0;
foreach (i; 0..len){
if (S[i] != '0' + (i % 2)) ans++;
}
if ((len - ans) < ans) ans = len - ans;
writeln(ans);
}
| D |
import std.algorithm;
import std.array;
import std.conv;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
T read(T)() { return readln.chomp.to!T; }
T[] reads(T)() { return readln.split.to!(T[]); }
alias readint = read!int;
alias readints = reads!int;
void main() {
auto ... | D |
import std.stdio;
import std.string;
import std.conv;
import std.array;
import std.algorithm;
import std.range;
void main(){
auto Q=readln.split.to!(int[]),a=Q[0],b=Q[1],c=Q[2];
if(b-a==c-b)writeln("YES");
else writeln("NO");
} | D |
import std.stdio;
import std.string;
import std.format;
import std.conv;
import std.typecons;
import std.algorithm;
import std.functional;
import std.bigint;
import std.numeric;
import std.array;
import std.math;
import std.range;
import std.container;
import std.ascii;
import std.concurrency;
import std.traits;
import... | D |
import std.stdio, std.conv, std.functional, std.string;
import std.algorithm, std.array, std.container, std.range, std.typecons;
import std.bigint, std.numeric, std.math, std.random;
import core.bitop;
string FMT_F = "%.10f";
static File _f;
void file_io(string fn) { _f = File(fn, "r"); }
static string[] s_rd;
T _RD(... | D |
import std.stdio, std.conv, std.functional, std.string;
import std.algorithm, std.array, std.container, std.range, std.typecons;
import std.numeric, std.math, std.random;
import core.bitop;
string FMT_F = "%.10f";
static string[] s_rd;
T RD(T = long)() { while(!s_rd.length) s_rd = readln.chomp.split; string res = s_r... | D |
import std.stdio, std.conv, std.math, std.string, std.range, std.array, std.algorithm, std.typecons;
void main(){
auto buf = readln().strip().split().map!(to!int)();
immutable K = buf[0];
immutable A = buf[1];
immutable B = buf[2];
if(B - A <= 2 || K <= A - 1) {
writeln(K + 1);
ret... | D |
import std;
auto input()
{
return readln().chomp();
}
alias sread = () => readln.chomp();
alias aryread(T = long) = () => readln.split.to!(T[]);
void main()
{
string s;
s = input();
// writeln(s);
string key;
key = "keyence";
foreach (i; 0 .. key.length + 1)
{
string tmp = s[... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric, std.container;
long P = 10^^9+7;
long[2001] F, RF;
long pow(long x, long n) {
long y = 1;
while (n) {
if (n%2 == 1) y = (y * x) % P;
x = x^^2 % P;
n /= 2;
}
return y;
}
long ... | D |
void main()
{
long n = rdElem;
long[] a = rdRow;
long q = rdElem;
foreach (i; 0 .. q)
{
long p = rdElem;
long r = a.binSrch!"a < b"(p);
writeln(r + 1);
}
}
long binSrch(alias pred = "a < b")(long[] arr, long val)
{
alias predFun = binaryFun!pred;
long l = -1, r ... | D |
void main() {
int[] tmp = readln.split.to!(int[]);
int r = tmp[0], d = tmp[1], x = tmp[2];
foreach (i; 0 .. 10) {
x = r * x - d;
x.writeln;
}
}
import std.stdio;
import std.string;
import std.array;
import std.conv;
import std.algorithm;
import std.range;
import std.typecons; | D |
import std.algorithm;
import std.array;
import std.conv;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
void main ()
{
string s;
while ((s = readln.strip) != "")
{
s = readln.strip;
writeln (s.count ('R') > s.count ('B') ? "Yes" : "No");
}
}
| D |
// import chie template :) {{{
static if (__VERSION__ < 2090) {
import std.stdio, std.algorithm, std.array, std.string, std.math, std.conv,
std.range, std.container, std.bigint, std.ascii, std.typecons, std.format,
std.bitmanip, std.numeric;
} else {
import std;
}
// }}}
// nep.scanner {{{
class Scanner {
... | D |
import std.stdio, std.conv, std.string, std.algorithm,
std.math, std.array, std.container, std.typecons;
int[] p, q;
int a, b, n, count=0;
void solve(bool[] used, int[] array, int depth=0) {
if(depth==n) {
count++;
if(array==p) a = count;
if(array==q) b = count;
return;
}
for(int i=0; i<n... | D |
import std.stdio;
import std.conv;
import std.string;
import std.typecons;
import std.algorithm;
import std.array;
import std.range;
import std.math;
import std.regex : regex;
import std.container;
import std.bigint;
void main()
{
auto x = readln.chomp.split.to!(int[]);
if (x[0]+x[1]<x[2]) {
writeln("No");
... | D |
import std.stdio;
import std.string;
import std.format;
import std.conv;
import std.typecons;
import std.algorithm;
import std.functional;
import std.bigint;
import std.numeric;
import std.array;
import std.math;
import std.range;
import std.container;
import std.concurrency;
import std.traits;
import std.uni;
import c... | D |
// tested by Hightail - https://github.com/dj3500/hightail
import std.stdio, std.string, std.conv, std.algorithm;
import std.range, std.array, std.math, std.typecons, std.container, core.bitop;
import std.datetime, std.bigint;
int n;
int[][] adj;
void main() {
scan(n);
adj = new int[][](n, 0);
int ai, bi... | D |
void main() {
problem();
}
void problem() {
const MAX = 10L.pow(18);
auto N = scan!int;
auto A = scan!ulong(N);
long solve() {
ulong multi = 1;
real floatMulti = 1;
foreach(a; A) {
floatMulti *= cast(real)a;
multi *= a;
}
return floatMulti > MAX ? -1 : multi;
}
solve().... | D |
import core.bitop;
import std.algorithm;
import std.array;
import std.ascii;
import std.container;
import std.conv;
import std.format;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
void main()
{
auto v = readln.chomp.split.map!(to!int);
int x = v[0];
int a = v[1];
... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto hw = readln.split.to!(int[]);
auto H = hw[0];
auto W = hw[1];
auto MAP = new char[][](H, W);
int bc;
foreach (i; 0..H) foreach (j, c; readln.chomp.to!(char[])) {
if ... | D |
import std.algorithm;
import std.array;
import std.conv;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
int readint() {
return readln.chomp.to!int;
}
int[] readints() {
return readln.split.map!(to!int).array;
}
void main() {
auto nq = readints();
int n = ... | D |
import std;
// dfmt off
T lread(T = long)(){return readln.chomp.to!T();}
T[] lreads(T = long)(long n){return generate(()=>readln.chomp.to!T()).take(n).array();}
T[] aryread(T = long)(){return readln.split.to!(T[])();}
void scan(TList...)(ref TList Args){auto line = readln.split();
foreach (i, T; TList){T val = line[i]... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math;
struct UFTree(T)
{
struct Node
{
T parent;
T rank = 1;
}
this(T n)
{
nodes.length = n;
foreach (i, ref node; nodes) node = Node(i.to!T);
}
void unite(T a, T b)
{
a = roo... | D |
import std.stdio, std.conv, std.functional, std.string;
import std.algorithm, std.array, std.container, std.range, std.typecons;
import std.bigint, std.numeric, std.math, std.random;
import core.bitop;
string FMT_F = "%.10f";
static File _f;
void file_io(string fn) { _f = File(fn, "r"); }
static string[] s_rd;
T _RD(... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto S = readln.chomp.to!(char[]);
auto front = S[0..2];
auto rear = S[2..$];
auto front_ok = front != "00" && front.to!int <= 12;
auto rear_ok = rear != "00" && rear.to!int <= 12;
... | D |
import std.stdio,std.conv, std.algorithm, std.container,std.array,std.range,std.string,std.typecons;
const dx = [1,0,-1,0], dy = [0,1,0,-1];
const readMixin = q{
auto line = readln().split();
if (line.length < args.length) return;
foreach(i,ref arg; args) arg = line[i].to!(typeof(arg));
};
void read(T...) (auto re... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons;
auto DS = [[1,0], [-1,0], [0,1], [0,-1]];
wchar[50][50] MAP;
void main()
{
auto hw = readln.split.to!(int[]);
auto H = hw[0];
auto W = hw[1];
foreach (i; 0..H) {
foreach (j, c; readln.chomp.to!(wchar[])... | D |
import std.stdio,std.conv,std.string,std.array;
void main(){
auto a=readln.chomp.split;
int x = to!int(a[0]), y = to!int(a[1]);
writeln( x*y , " " , (x+y)*2);
} | D |
import std.stdio, std.conv, std.string, std.bigint;
import std.math, std.random, std.datetime;
import std.array, std.range, std.algorithm, std.container, std.format;
string read(){ static string[] ss; while(!ss.length) ss = readln.chomp.split; string res = ss[0]; ss.popFront; return res; }
void main(){
long l = read.... | D |
import std.stdio, std.string, std.conv;
import std.algorithm, std.array;
void main()
{
for(string s_; (s_=readln.chomp()).length;)
{
auto NL = s_.split.map!(to!int);
immutable N=NL[0], L=NL[1];
immutable a = readln.split.map!(to!int).array();
int k=0,m=-1;
foreach(i;1..... | D |
import std.algorithm;
import std.array;
import std.conv;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
int readint() {
return readln.chomp.to!int;
}
int[] readints() {
return readln.split.map!(to!int).array;
}
int calc(int n, bool[][] adj) {
auto refs = new ... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
struct UFTree(T)
{
struct Node
{
T parent;
T rank = 1;
}
///
this(T n)
{
nodes.length = n;
sizes.length = n;
foreach (i, ref node; nodes) {
... | D |
import std.stdio;
import std.algorithm;
import std.string;
import std.conv;
void main() {
int n, x;
scanf("%d %d\n", &n, &x);
auto ls = readln.chomp.split.to!(int[]);
int d, cnt;
foreach(l; ls) {
d += l;
++cnt;
if (d > x) {
cnt.write;
return;
}
}
write(n+1);
}
| D |
import std.stdio, std.string, std.conv, std.range;
import std.algorithm, std.array, std.typecons, std.container;
import std.math, std.numeric, std.random, core.bitop;
enum inf = 1_001_001_001;
enum infl = 1_001_001_001_001_001_001L;
enum mod = 1_000_000_007L;
void main() {
int N, W;
scan(N, W);
auto w = ... | D |
import core.bitop;
import std.algorithm;
import std.ascii;
import std.bigint;
import std.conv;
import std.functional;
import std.math;
import std.numeric;
import std.range;
import std.stdio;
import std.string;
import std.random;
import std.typecons;
import std.container;
alias sread = () => readln.chomp();
ulong bignu... | D |
import std.stdio, std.range, std.conv, std.string;
import std.algorithm.comparison, std.algorithm.iteration, std.algorithm.mutation, std.algorithm.searching, std.algorithm.setops, std.algorithm.sorting;
void main()
{
long[] input = readln().split.to!(long[]);
long A = input[0];
long B = input[1];
write... | D |
import std;
alias sread = () => readln.chomp();
alias lread = () => readln.chomp.to!long();
alias aryread(T = long) = () => readln.split.to!(T[]);
//aryread!string();
//auto PS = new Tuple!(long,string)[](M);
//x[]=1;でlong[]全要素1に初期化
void main()
{
auto n = lread();
auto a = aryread();
// writeln(a);
aut... | D |
import std.stdio;
import std.conv, std.array, std.algorithm, std.string;
import std.math, std.random, std.range;
import std.bigint;
void main(){
long[] ins = readln.chomp.split.map!(to!long).array;
long n = ins[0], x = ins[1];
long y = n - x;
long a, b;
if(x > y) a = x, b = y;
else a = y, b = x;
long ... | D |
import std.stdio, std.string, std.conv, std.array, std.algorithm;
void main() {
auto a = readln.split.map!(to!int);
int count = 0;
foreach (i; a[0]..a[1]+1) if (a[2] % i == 0) count++;
writeln(count);
} | D |
import std.stdio, std.array, std.string, std.conv, std.algorithm;
import std.typecons, std.range, std.random, std.math, std.container;
import std.numeric, std.bigint, core.bitop, core.stdc.stdio;
void solve() {
auto s = readln.split.map!(to!int);
auto N = s[0];
auto M = s[1];
auto A = readln.split.map!... | D |
// import chie template :) {{{
import std.stdio, std.algorithm, std.array, std.string, std.math, std.conv,
std.range, std.container, std.bigint, std.ascii, std.typecons, std.format, std.bitmanip;
// }}}
// nep.scanner {{{
class Scanner {
import std.stdio : File, stdin;
import std.conv : to;
import std.array : ... | D |
//prewritten code: https://github.com/antma/algo
import std.algorithm;
import std.array;
import std.conv;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.traits;
final class InputReader {
private:
ubyte[] p, buffer;
bool eof;
bool rawRead () {
if (eof) {
return fals... | D |
void main()
{
dchar[] s = rdDchar;
dchar[] t = rdDchar;
long pos = t.length - 1;
bool ok;
foreach_reverse (long i, x; s)
{
if (x == t[pos] || x == '?')
{
bool check;
if (i - pos >= 0)
{
check = true;
foreach (j;... | D |
import std.stdio;
import std.string;
import std.conv;
import std.typecons;
import std.algorithm;
import std.functional;
import std.bigint;
import std.numeric;
import std.array;
import std.math;
import std.range;
import std.container;
void main() {
foreach(int i; 0..7) {
int[] input = readln.split.to!(int[]... | D |
// tested by Hightail - https://github.com/dj3500/hightail
import std.stdio, std.string, std.conv, std.algorithm;
import std.range, std.array, std.math, std.typecons, std.container, core.bitop;
import std.numeric;
alias Pair = Tuple!(int, "to", int, "cost");
int n, q, k;
Pair[][] adj;
void main() {
scan(n);
... | D |
import std.stdio;
import std.array;
import std.conv;
void main()
{
while (1) {
auto input = split(readln());
switch (input[1]) {
case "+":
writeln(to!(int)(input[0]) + to!(int)(input[2]));
break;
case "-":
writeln(to!(int)(in... | D |
import std.stdio, std.algorithm, std.conv, std.string, std.array, std.math;
void main()
{
readln;
const s = readln.chomp;
if (s.length%2 == 0 && s[0..$/2] == s[$/2..$]) {
"Yes".writeln;
return;
}
"No".writeln;
} | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
alias P = Tuple!(size_t, "x", size_t, "y");
void main()
{
auto hw = readln.split.to!(int[]);
auto H = hw[0];
auto W = hw[1];
char[][] AS;
AS.length = H;
foreach (i; 0..H) {
AS[i] = r... | D |
/+ dub.sdl:
name "hello"
+/
import std.algorithm;
import std.conv;
import std.stdio;
import std.string;
void main()
{
auto N = readln.chomp.to!int;
auto A = readln.chomp.to!int;
writeln(N * N - A);
}
| D |
import std.stdio;
import std.algorithm;
import std.range;
import std.conv;
import std.format;
import std.array;
import std.math;
import std.string;
import std.container;
import std.numeric;
void main() {
int N, M;
readlnTo(N, M);
long ans = 1;
for (long i = 1; i * i <= M; i++) {
if (M % i != 0)
cont... | D |
import std.stdio;
import std.conv;
import std.string;
import std.typecons;
import std.algorithm;
import std.array;
import std.range;
import std.math;
import std.regex : regex;
import std.container;
import std.bigint;
void main()
{
auto s = readln.chomp;
auto t = readln.chomp;
auto res = false;
foreach (i; 0.... | D |
import std.algorithm, std.container, std.conv, std.math, std.range, std.typecons, std.stdio, std.string;
auto rdsp(){return readln.splitter;}
void pick(R,T)(ref R r,ref T t){t=r.front.to!T;r.popFront;}
void readV(T...)(ref T t){auto r=rdsp;foreach(ref v;t)pick(r,v);}
void readC(T...)(size_t n,ref T t){foreach(ref v;t)... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto av = readln.split.to!(long[]);
auto A = av[0];
auto V = av[1];
auto bw = readln.split.to!(long[]);
auto B = bw[0];
auto W = bw[1];
auto T = readln.chomp.to!long;
if... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.array;
import std.range;
void main() {
auto data = readln().split();
auto A = data[0].to!int(), B = data[1].to!int(), K = data[2].to!int();
iota(min(A, B), 0, -1).filter!(x => A%x == 0 && B%x == 0).array[K-1].writeln();
}
| D |
import core.bitop;
import std.algorithm;
import std.ascii;
import std.bigint;
import std.conv;
import std.functional;
import std.math;
import std.numeric;
import std.range;
import std.stdio;
import std.string;
import std.random;
import std.typecons;
import std.container;
alias sread = () => readln.chomp();
ulong bignu... | D |
import std.stdio;
void main(){
foreach(i; 1 .. 10){
foreach(j; 1 .. 10){
writeln(i, "x", j, "=", i * j);
}
}
} | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric, std.container, std.range;
void main()
{
auto xkd = readln.split.to!(long[]);
auto X = xkd[0];
auto K = xkd[1];
auto D = xkd[2];
X = abs(X);
if (X/D >= K) {
writeln(X - K*D);
re... | D |
import std.stdio;
import std.conv;
import std.string;
import std.typecons;
import std.algorithm;
import std.array;
import std.range;
import std.math;
import std.regex : regex;
import std.container;
import std.bigint;
void main()
{
auto n = readln.chomp.to!int;
auto a = readln.chomp.split.to!(int[]);
int odd, ev... | D |
import core.bitop;
import std.algorithm;
import std.ascii;
import std.bigint;
import std.conv;
import std.functional;
import std.math;
import std.numeric;
import std.range;
import std.stdio;
import std.string;
import std.random;
import std.typecons;
import std.container;
alias sread = () => readln.chomp();
alias Point... | D |
import std.stdio;
import std.conv;
import std.string;
import std.typecons;
import std.algorithm;
import std.array;
import std.range;
import std.math;
import std.container;
import std.datetime;
int s;
long number (string str) {
auto l = s;
s++;
while (str[s] >= '0' && str[s] <= '9') s++;
return str[l..s].to!long... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto N = readln.chomp.to!int;
auto ps = readln.split.to!(int[]);
auto qs = new bool[](N+1);
int r, last = 1;
foreach_reverse (p; ps) {
qs[p] = true;
if (p == last) ++... | D |
import std.stdio;
import std.typecons;
void main()
{
int r, c, n, k;
scanf("%d%d%d%d", &r, &c, &n, &k);
Tuple!(int, int)[] alts = new Tuple!(int, int)[n];
for (int i = 0; i < n; i++)
scanf("%d%d", &alts[i][0], &alts[i][1]);
int res = 0;
for (int i = 1; i <= r; i++)
for (int j = 1; j <= c; j++)
for... | D |
import std.stdio, std.conv, std.functional, std.string;
import std.algorithm, std.array, std.container, std.range, std.typecons;
import std.bigint, std.numeric, std.math, std.random;
import core.bitop;
string FMT_F = "%.10f";
static File _f;
void file_io(string fn) { _f = File(fn, "r"); }
static string[] s_rd;
T _RD(... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto T = readln.chomp.to!int;
auto ps = new long[](10^^6+1);
foreach (i; 2..10^^6+1) if (ps[i] == 0) {
ps[i] = i;
auto x = i;
while (x <= 10^^6) {
if (ps[... | D |
import std.stdio, std.conv, std.functional, std.string;
import std.algorithm, std.array, std.container, std.range, std.typecons;
import std.bigint, std.numeric, std.math, std.random;
import core.bitop;
string FMT_F = "%.10f";
static File _f;
void file_io(string fn) { _f = File(fn, "r"); }
static string[] s_rd;
T _RD(... | D |
import std.stdio, std.string, std.conv, std.algorithm, std.numeric;
import std.range, std.array, std.math, std.typecons, std.container, core.bitop;
void main() {
int k, p;
scan(k, p);
if (p == 1) {
writeln(0);
return;
}
long ans;
foreach (i ; 1 .. k + 1) {
long zcy =... | D |
import std.stdio, std.conv, std.string;
import std.array, std.range, std.algorithm, std.container;
import std.math, std.random, std.bigint, std.datetime, std.format;
string read(){ static string[] ss; while(!ss.length) ss = readln.chomp.split; string res = ss[0]; ss.popFront; return res; }
int DEBUG_LEVEL = 0;
void pr... | D |
import std.stdio :write, writeln;
import std.array;
import std.range;
import std.typecons;
import std.algorithm : max, min;
string[] src = [
"111111101010101111100101001111111",
"100000100000000001010110001000001",
"101110100110110000011010001011101",
"101110101011001001111101001011101",
"10111010110001100011110010101... | D |
module main;
import core.stdc.stdio;
int main(string[] argv) {
int n = 0;
scanf("%d", &n);
if((n & 1) == 1) {
n -= 3;
putchar('7');
}
for(int i = 0; i < n; i += 2)
putchar('1');
return 0;
}
| D |
// import chie template :) {{{
import std.stdio, std.algorithm, std.array, std.string, std.math, std.conv,
std.range, std.container, std.bigint, std.ascii, std.typecons, std.format, std.bitmanip;
// }}}
// nep.scanner {{{
class Scanner {
import std.stdio : File, stdin;
import std.conv : to;
import std.array : ... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric, std.container, std.range;
long P = 10^^9+7;
void main()
{
auto nm = readln.split.to!(int[]);
auto N = nm[0];
auto M = nm[1];
auto SS = readln.split.to!(int[]);
auto TS = readln.split.to!(int[]);... | D |
void main() {
problem();
}
void problem() {
auto N = scan!int;
auto A = scan!long(N);
auto Q = scan!int;
auto Queues = Q.iota.map!(x => Queue(scan!long, scan!long)).array;
void solve() {
long[long] nums;
long summary;
foreach(a; A) {
nums[a]++;
summary += a;
}
foreach(q; Q... | D |
import std.stdio;
import std.conv, std.array, std.algorithm, std.string;
import std.math, std.random, std.range, std.datetime;
import std.bigint;
void main(){
int n, t;
{
int[] tmp = readln.chomp.split.map!(to!int).array;
n = tmp[0], t = tmp[1];
}
int[] as = readln.chomp.split.map!(to!int).array;
int[] bs;... | D |
import std.algorithm;
import std.array;
import std.conv;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
T read(T)() { return readln.chomp.to!T; }
T[] reads(T)() { return readln.split.to!(T[]); }
alias readint = read!int;
alias readints = reads!int;
void main() {
int a... | D |
void main() {
auto N = ri;
if(N <= 999) {
"ABC".writeln;
} else {
"ABD".writeln;
}
}
// ===================================
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.range;
import std.traits;
import std.math;
import std.container;
import std.bigint;
import std.nume... | D |
import std.stdio, std.conv, std.functional, std.string;
import std.algorithm, std.array, std.container, std.range, std.typecons;
import std.bigint, std.numeric, std.math, std.random;
import core.bitop;
string FMT_F = "%.10f";
static File _f;
void file_io(string fn) { _f = File(fn, "r"); }
static string[] s_rd;
T _RD(... | D |
import std.algorithm;
import std.array;
import std.ascii;
import std.bigint;
import std.complex;
import std.container;
import std.conv;
import std.functional;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
auto readInts() {
return array(map!(to!int)(readln().strip().split... | D |
import core.bitop, std.algorithm, std.ascii, std.bigint, std.conv, std.math,
std.functional, std.numeric, std.range, std.stdio, std.string, std.random,
std.typecons, std.container, std.format;
// dfmt off
T lread(T = long)(){return readln.chomp.to!T();}
T[] aryread(T = long)(){return readln.split.to!(T[])();}
... | D |
import std.stdio;
import std.regex;
void main(){
//auto io = new IO();
char[][char] card;
card['a'] = str();//io.rect!char()[0];
card['b'] = str();
card['c'] = str();
char[char] ptr;
ptr['a']=ptr['b']=ptr['c']=0;
//= ["a":0,"b":0,"c":0];
char target = 'a';
foreach( i ; 0..100*100*100+10 ){
auto now = p... | D |
import core.bitop, std.algorithm, std.ascii, std.bigint, std.conv, std.math,
std.functional, std.numeric, std.range, std.stdio, std.string, std.random,
std.typecons, std.container;
// dfmt off
T lread(T = long)(){return readln.chomp.to!T();}
T[] aryread(T = long)(){return readln.split.to!(T[])();}
void scan(TL... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array, std.typecons, std.container;
import std.math, std.numeric, core.bitop;
enum inf3 = 1_001_001_001;
enum inf6 = 1_001_001_001_001_001_001L;
enum mod = 1_000_000_007L;
void main() {
int a, b, c;
scan(a, b, c);
auto ans = mi... | D |
// dfmt off
T lread(T=long)(){return readln.chomp.to!T;}T[] lreads(T=long)(long n){return iota(n).map!((_)=>lread!T).array;}
T[] aryread(T=long)(){return readln.split.to!(T[]);}void arywrite(T)(T a){a.map!text.join(' ').writeln;}
void scan(L...)(ref L A){auto l=readln.split;foreach(i,T;L){A[i]=l[i].to!T;}}alias sread=(... | D |
import core.bitop, std.algorithm, std.ascii, std.bigint, std.conv,
std.functional, std.math, std.numeric, std.range, std.stdio, std.string,
std.random, std.typecons, std.container;
ulong MAX = 1_000_100, MOD = 1_000_000_007, INF = 1_000_000_000_000;
alias sread = () => readln.chomp();
alias lread(T = long) = (... | D |
import core.bitop;
import std.algorithm;
import std.ascii;
import std.bigint;
import std.conv;
import std.functional;
import std.math;
import std.numeric;
import std.range;
import std.stdio;
import std.string;
import std.random;
import std.typecons;
import std.container;
alias sread = () => readln.chomp();
ulong bignu... | D |
unittest
{
assert( [ "0011" ].parse.expand.solve == 4 );
assert( [ "11011010001011" ].parse.expand.solve == 12 );
assert( [ "0" ].parse.expand.solve == 0 );
}
import std.conv;
import std.range;
import std.stdio;
import std.typecons;
void main()
{
stdin.byLineCopy.parse.expand.solve.writeln;
}
auto parse( Range... | D |
import std.stdio, std.string, std.array, std.conv, std.algorithm, std.typecons, std.range, std.container, std.math, std.algorithm.searching, std.functional,std.mathspecial;
void main(){
auto N=readln.chomp.to!int;
if(N==1){
writeln(1);
return;
}
long[int] divs;
auto primes=get_pri... | D |
// import chie template :) {{{
import std.stdio, std.algorithm, std.array, std.string, std.math, std.conv,
std.range, std.container, std.bigint, std.ascii, std.typecons, std.format;
// }}}
// nep.scanner {{{
class Scanner {
import std.stdio : File, stdin;
import std.conv : to;
import std.array : split;
impor... | D |
import std.stdio, std.string, std.range, std.conv, std.array, std.algorithm, std.math, std.typecons;
void main() {
auto tmp = readln.split.to!(long[]);
const D = tmp[0], G = tmp[1];
struct Po { long p, c; }
auto po = new Po[D];
auto completePointList = new long[D];
foreach (i; 0..D) {
t... | D |
void main()
{
long x = rdElem;
bool op(long len, long cnt)
{
if (len <= 2) return cnt <= x;
return op((len-1)>>1, cnt+1);
}
long ok, ng = inf;
while (ng - ok > 1)
{
long m = (ok + ng) >> 1;
if (op(m, 0)) ok = m;
else ng = m;
}
ok.writeln;
}
... | D |
import std.stdio, std.conv, std.string, std.range, std.algorithm;
void main() {
int d = readln.chomp.to!int;
("Christmas " ~ repeat("Eve", 25 - d).join(" ")).writeln;
} | D |
import std.stdio;
import std.string;
import std.conv;
void main() {
int n;
scanf("%d\n", &n);
auto ds = readln.chomp.split.to!(long[]);
long total = 0;
foreach(i; 0..ds.length) {
foreach(j; i+1..ds.length) {
total += ds[i] * ds[j];
}
}
total.write;
}
| D |
import std.stdio;
import std.string;
import std.algorithm;
import std.conv;
void main() {
int N=to!int(chomp(readln()));
string[] input=split(readln());
int ans=1<<30;
foreach(item;input) {
int A=to!int(item);
int cnt=0;
while(A%2==0) A/=2,cnt++;
ans=min(ans,cnt);
}
writeln(ans);
}
| D |
import std;
alias sread = () => readln.chomp();
alias lread = () => readln.chomp.to!long();
alias aryread(T = long) = () => readln.split.to!(T[]);
//aryread!string();
//auto PS = new Tuple!(long,string)[](M);
//x[]=1;でlong[]全要素1に初期化
void main()
{
auto n = lread();
auto h = aryread();
foreach (i; 0 .. (n - ... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array, std.typecons, std.container;
import std.math, std.numeric, core.bitop;
enum inf = 1_001_001_001;
enum inf6 = 1_001_001_001_001_001_001L;
enum mod = 1_000_000_007L;
void main() {
int n;
scan(n);
auto a = readln.split.to!(... | D |
import std.stdio;
import std.conv;
import std.string;
void main()
{
string s = chomp(readln()); // ??????????????????
long l = to!long(s);
writeln(l*l*l);
} | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto N = readln.chomp.to!int;
auto AS = readln.split.to!(int[]);
int all = 1, odd = 1;
foreach (a; AS) {
int x, y;
foreach (i; a-1..a+2) {
++x;
if... | D |
void main() {
int[] tmp = readln.split.to!(int[]);
int a = tmp[0], b = tmp[1], c = tmp[2];
writeln(a <= c && c <= b ? "Yes" : "No");
}
import std.stdio;
import std.string;
import std.array;
import std.conv;
import std.algorithm;
import std.range;
import std.math;
import std.numeric;
import std.container;
i... | D |
import core.bitop;
import std.algorithm;
import std.ascii;
import std.bigint;
import std.conv;
import std.functional;
import std.math;
import std.numeric;
import std.range;
import std.stdio;
import std.string;
import std.random;
import std.typecons;
alias sread = () => readln.chomp();
alias Point2 = Tuple!(long, "y", ... | D |
import std.algorithm;
import std.conv;
import std.stdio;
import std.string;
void main() {
for (;;) {
string line = readln.strip;
if (line == "0") {
break;
}
int sum = line.split("").map!(to!int).sum();
writeln(sum);
}
} | D |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.