code stringlengths 4 1.01M | language stringclasses 2
values |
|---|---|
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto nd = readln.split.to!(int[]);
auto N = nd[0];
auto D = nd[1];
auto d = D*2+1;
writeln((N+d-1) / d);
} | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array;
void main() {
string s = readln.chomp;
writeln("2018" ~ s[4 .. $]);
}
void scan(T...)(ref T args) {
import std.stdio : readln;
import std.algorithm : splitter;
import std.conv : to;
import std.range.primitiv... | D |
import std.stdio;
import std.algorithm;
import std.string;
import std.range;
import std.array;
import std.conv;
void main() {
int [] dp = new int[101];
dp[] = 0;
long n;
while(!stdin.eof()) {
auto s = readln().replace(",", " ").split();
if(!s.empty()){
int [] newdp;
int offset;
if(n < s.length) {
... | 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, std.bitmanip;
immutable long MOD = 10^^9 + 7;
void main() {
auto S = readln.chomp;
auto T = readln.chomp;
int N = S.length.to!i... | 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() {
while (1) {
int n;
scan(n);
if (!n) return;
int ans = 10^^7;
for (int z; z^^3 <= n; z++) {
for (... | D |
import std.algorithm;
import std.conv;
import std.stdio;
import std.string;
void main()
{
auto abck = readln.split.map!( to!long );
writeln( solve( abck[ 0 ], abck[ 1 ], abck[ 2 ], abck[ 3 ] ) );
}
long solve( in long a, in long b, in long c, in long k )
{
if( k % 2 == 0 ) return a - b;
else return b... | D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
auto n = readln.chomp.to!size_t;
auto root = new RootNode!int;
foreach (_; n.iota) {
auto rd = readln.chomp.splitter(' '), cmd = rd.front;
switch (cmd) {
case "insert":
rd.popFront;
root.insert(rd.front.to!in... | D |
/+ dub.sdl:
name "E"
dependency "dunkelheit" version="1.0.1"
+/
import std.stdio, std.algorithm, std.range, std.conv, std.string;
// import dkh.foundation, dkh.scanner, dkh.container.deque;
int main() {
Scanner sc = new Scanner(stdin);
scope(exit) assert(!sc.hasNext);
string s;
sc.read(s);
... | 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.string;
void main() {
auto T = readln.chomp.to!int;
while (T--) {
auto s = readln.split.map!(to!long);
aut... | 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 |
void main()
{
long n = rdElem;
long f(long x)
{
return x * (x + 1) / 2;
}
long l, r = n;
while (r - l > 1)
{
long m = (l + r) / 2;
long p = f(m);
if (p < n) l = m;
else r = m;
}
long total = f(r);
long diff = total - n;
foreach (i; 1... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.math;
void main() {
string input = readln();
if(input[0] == input[2]) "Yes".writeln;
else "No".writeln;
}
| D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
auto n = readln.chomp.to!size_t;
auto root = new RootNode!int;
foreach (_; n.iota) {
auto rd = readln.chomp.splitter(' '), cmd = rd.front;
switch (cmd) {
case "insert":
rd.popFront;
root.insert(rd.front.to!in... | D |
import std.algorithm;
import std.array;
import std.container;
import std.conv;
import std.math;
import std.numeric;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
void scan(T...)(ref T a) {
string[] ss = readln.split;
foreach (i, t; T) a[i] = ss[i].to!t;
}
T read(T)() { return read... | 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.functional,
std.algorithm,
std.bigint,
std.string,
std.traits,
std.array,
std.range,
std.stdio,
std.conv;
void main() {
int[] ABCD = readln.chomp.split.to!(int[]);
int A = ABCD[0],
B = ABCD[1],
C = ABCD[2],
D = ABCD[3];
int L = ... | 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 main()
{
string o; readV(o);
string e; re... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
void inputLine(A...)(ref A a) {
string[] line = readln.chomp.split;
if (a.length != line.length) {
throw new Exception("not equal number of input elements and number of variable elements.");
}
foreach (int i, ref e; a) ... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto lr = readln.split.to!(long[]);
auto L = lr[0];
auto R = min(L+2020, lr[1]+1);
long x = long.max;
foreach (i; L..R) {
foreach (j; i+1..R) {
x = min(x, i*j%20... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto nq = readln.split.to!(int[]);
auto N = nq[0];
auto Q = nq[1];
auto S = readln.chomp;
auto cs = new int[](N);
foreach (i; 1..N) {
cs[i] += cs[i-1];
if (S[i-1]... | D |
import std.stdio;
import std.range;
import std.array;
import std.algorithm;
import std.string;
import std.conv;
void main(){
immutable train_01 = readln.chomp.to!int;
immutable train_02 = readln.chomp.to!int;
immutable bus_01 = readln.chomp.to!int;
immutable bus_02 = readln.chomp.to!int;
immutable... | D |
import std.stdio,
std.string,
std.conv;
void main() {
int N = readln.chomp.to!(int);
string[] S;
bool[] tate;
for (int i = 0; i < 2; i++) {
S ~= readln.chomp;
}
for (int i = 0; i < N; i++) {
if (S[0][i] == S[1][i]) {
tate ~= true;
}
else {
tate ~= false;
i++;... | D |
import std.stdio;
import std.algorithm;
import std.math;
import std.conv;
import std.string;
T readNum(T)(){
return readStr.to!T;
}
T[] readNums(T)(){
return readStr.split.to!(T[]);
}
string readStr(){
return readln.chomp;
}
void main(){
auto nmx = readNums!int;
auto ca = new int[][](nmx[0], nmx[1]+1);
... | D |
import std.stdio;
import std.conv;
import std.string;
void main()
{
string s = chomp(readln());
long sec = to!long(s);
string hh = to!string(sec / 3600);
string mm = to!string((sec % 3600) / 60);
string ss = to!string(sec % 3600 % 60);
write(hh);
write(":");
write(mm);
write(":");
writeln(ss);
... | 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;
static import std.ascii;
// dfmt off
T lread(T = long)(){return readln.chomp.to!T();}
T[] aryread(T = long)(){return r... | 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() {
while (1) {
int a,L;
scan(a,L);
if (!L) return;
solve(a,L);
}
}
void solve(int a, int L) {
auto as = new int[](2... | 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, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric, std.container, std.range;
struct Dsu
{
public:
this(int n)
{
_n = n, parent_or_size = new int[](n);
parent_or_size[] = -1;
}
int merge(int a, int b)
{
assert(0 <= a && a <... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons;
void main()
{
auto N = readln.chomp.to!int;
auto K = readln.chomp.to!int;
int sum_t;
foreach (x; readln.split.to!(int[])) {
auto a = x * 2;
auto b = abs(x - K) * 2;
sum_t += min(a, b);... | D |
void main(){
import std.stdio, std.string, std.conv, std.algorithm;
auto n=readln.chomp.to!(int);
foreach(b; 0..(1<<3)){
auto tmp=n, sum=0;
foreach(i; 0..3){
if((b>>i)&1) sum+=tmp%10;
else sum-=tmp%10;
tmp/=10;
}
sum+=tmp;
if(sum==7){
char[] s;
foreach(i; 0..3... | 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 |
void main()
{
long k, s;
rdVals(k, s);
long cnt;
foreach (x; 0 .. k+1)
{
foreach (y; 0 .. k+1)
{
long z = s - x - y;
if (0 <= z && z <= k) ++cnt;
}
}
cnt.writeln;
}
enum long mod = 10^^9 + 7;
enum long inf = 1L << 60;
T rdElem(T = long)()
i... | D |
void main(){
string[] val = inln!string();
writeln( (val[0]=="H")^(val[1]=="H")?'D':'H');
}
import std.stdio, std.conv, std.algorithm, std.numeric, std.string, std.math, std.range;
const long mod = 10^^9+7;
// 1要素のみの入力
T inelm(T= int)(){
return to!(T)( readln().chomp() );
}
// 1行に同一型の複数入力
T[] inln(... | D |
import std.stdio;
import std.algorithm;
import std.range;
import std.conv;
void main() {
string[] input = split(readln());
long n = to!long(input[0]);
long m = to!long(input[1]);
if (n > m) swap(n,m);
long ans = 0;
if (n == 1) {
ans = max(0, m-2);
if (m == 1) ans = 1;
} else... | D |
import std.stdio, std.string, std.conv, std.algorithm;
import std.range, std.array, std.math, std.typecons, std.container, core.bitop;
void main() {
int n;
scan(n);
int ans;
foreach (i ; 0 .. n) {
int li, ri;
scan(li, ri);
ans += ri - li + 1;
}
writeln(ans);
}
void... | 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.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;
int main()
{
while (true) {
string[] str = readln().chomp().split();
int n = str[0].to!int;
int m = str[1].to!int;
if (m == n && n == 0) break;
int[1001] ans;
int c = n - 1;
for (int i = 0; i < n; i++) an... | D |
import std.stdio,
std.string,
std.conv,
std.typecons,
std.algorithm;
int abs(int n) {
return n >= 0 ? n : -n;
}
void main() {
int[] buf = readln.chomp.split.to!(int[]);
int H = buf[0], W = buf[1], D = buf[2];
alias Tuple!(int, "x", int, "y") Grid;
Grid[int] A;
for (int i = 1; ... | D |
void main() {
import std.stdio, std.string, std.conv, std.algorithm;
auto n = readln.chomp.to!(char[]);
auto dp = new long[][][][](n.length + 1, 2, 1000, 2);
dp[0][0][0][0] = 1;
foreach (i; 0 .. (n.length)) {
foreach (l; 0 .. 2) {
foreach (k; 0 .. 1000) {
foreach (ok; 0 .. 2) {
a... | 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;
immutable long inf = 3L * 10L^^18;
void main() {
int n, m;
scan(n, m);
auto uf = UnionFind(n);
foreach (i ; 0 .. m) {
int ai, bi;
scan(a... | D |
void main(){
import std.stdio, std.string, std.conv, std.algorithm;
int x, k;
rd(x); rd(k);
auto r=readln.split.to!(int[]);
int q; rd(q);
int u=x, l=0;
int j=0, p=0;
int d=0, e=-1;
while(q--){
int t, a; rd(t, a);
while(j<k && r[j]<=t){
int dd=(r[j]-p)*e;
p=r[j++]; e*=-1;
... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.range;
import std.container;
import std.bigint;
void main()
{
readln.chomp.toUpper.writeln;
} | 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;
import std.string;
import std.conv;
import std.math;
void main() {
string[] inputs = split(readln());
//int r = to!int(inputs[0]);
int g = to!int(inputs[1]);
int b = to!int(inputs[2]);
if((10*g + b) % 4 == 0) "YES".writeln;
else "NO".writeln;
}
| D |
import std.stdio;
import std.conv;
import std.array;
void main()
{
int N = readln.split[0].to!int;
int[] H = readln.split.to!(int[]);
int max = 0;
int ans = 0;
foreach (h; H){
if (h >= max){
ans++;
max = h;
}
}
writeln(ans);
}
| D |
import std;
void main(){
int n,m;
scanf("%d %d\n", &n, &m);
auto hs = readln.chomp.split.to!(int[]);
auto as = new int[m];
auto bs = new int[m];
auto mem = new bool[n];
foreach(ref x; mem) {
x = true;
}
foreach(i; 0..m) {
int a,b;
scanf("%d %d\n", &a, &b);
if (hs[a-1] <= hs[b-1]) {
mem[a-1] &= fal... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto nm = readln.split.to!(int[]);
auto N = nm[0];
auto M = nm[1];
int[] as, bs;
int t = 1, cnt;
foreach_reverse (i; 1..M+1) if (i%2 == 1) {
as ~= t++;
++cnt;
... | D |
import std.stdio, std.algorithm, std.string, std.ascii;
void main()
{
char[] s = readln.strip.dup;
if (s[0] != 'A') {
writeln("WA");
return;
}
auto p = s.indexOf('C');
if (p == -1 || p <= 1 || p > s.length-2) {
writeln("WA");
return;
}
s[0] = 'a';
s[p] = 'a';
if (s.all!(isLower)) {
... | 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.stdio;
import std.algorithm;
import std.string;
import std.range;
import std.array;
import std.conv;
import std.complex;
import std.math;
bool is_uruu(int n) {
return n%400 == 0 || (n%100 != 0 && n%4 == 0);
}
void main() {
bool f = false;
while(true... | 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;
void main() {
immutable int MAX = 5010;
auto N = readln.chomp.to!int;
auto A = readln.split.map!(to!int).array;
auto L = n... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric, std.container, std.range;
void get(Args...)(ref Args args)
{
import std.traits, std.meta, std.typecons;
static if (Args.length == 1) {
alias Arg = Args[0];
static if (isArray!Arg) {
... | 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 hwk = readln.split.to!(int[]);
auto H = hwk[0];
auto W = hwk[1];
auto K = hwk[2];
auto MAP = new char[][](H, W);
auto MEMO = new bool[][](H, W);
... | D |
import std;
alias sread = () => readln.chomp();
alias lread = () => readln.chomp.to!long();
alias aryread(T = long) = () => readln.split.to!(T[]);
void main()
{
auto x = lread();
if (x < 1200)
{
writeln("ABC");
return;
}
writeln("ARC");
}
void scan(L...)(ref L A)
{
auto l = re... | D |
import std.stdio;
import std.string;
import std.algorithm;
import std.array;
import std.ascii;
import std.conv;
// エンコード化
string decrypt(string from, uint alpha, uint beta) {
string chars;
foreach(c; from) {
chars ~= isAlpha(c) ? ((c - "a"[0]) * alpha + beta) % 26 + "a"[0] : c;
}
return chars;
}
void mai... | 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;
}
long calc(int n, int s) {
long rec(int p, int s... | 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 |
module c;
import std.conv, std.stdio;
import std.algorithm, std.array, std.string, std.range;
void main()
{
auto buf = readln.chomp.split.to!(long[]);
auto n = buf[0], k = buf[1];
n = n % k;
n.min(k-n).writeln;
}
| 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;
// }}}
// nep.scanner {{{
class Scanner
{
import std.stdio : File, stdin;
import std.conv : to;
import std.array : split;
import ... | 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.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, 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.algorithm, std.conv, std.array, std.string, std.math;
void main()
{
auto N = readln.chomp.to!int;
auto AS = readln.split.to!(long[]);
long[] BS;
BS.length = N + 1;
foreach (i, a; AS) {
BS[i+1] = BS[i] + a;
}
long[long] memo;
foreach (b; BS) {
if ... | D |
import std.stdio, std.array, std.string, std.conv;
void main() {
int n = to!int(chomp(readln()));
string[] a = split(readln());
for (int i = n - 1; i >= 0; --i) {
write(a[i]);
write(i ? " ": "\n");
}
} | D |
import std.stdio;
import std.algorithm;
import std.string;
import std.array;
import std.conv;
import std.range;
void solve(int[] table) {
auto answer =
['A': [1, 11, 10],
'B': [10, 20, 30],
'C': [1, 2, 3],
'D': [10, 9, 19],
'E': [1, 11, 12],
'F': [10, 11, 21],
'G': [1, 10, 9],
... | D |
import std.stdio;import std.conv;import std.algorithm;import std.array;
void main()
{
auto it = readln().split().map!(to!int);
writeln(it[0]*it[1]," ",(it[0]+it[1])*2);
} | D |
import std.stdio, std.conv, std.string, std.algorithm,
std.math, std.array, std.container, std.typecons;
void main() {
int[] abc = readln.chomp.split.to!(int[]);
if(abc[0]!=abc[1]&&abc[1]==abc[2] ||
abc[0]!=abc[1]&&abc[0]==abc[2] ||
abc[0]==abc[1]&&abc[1]!=abc[2]) writeln("Yes");
else writeln("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;
void main() {
int n;
scan(n);
auto s = readln.chomp.to!string;
auto pf = new int[](n + 1);
foreach (i ; 1 .. n + 1) {
pf[i] = pf[i-1] ... | D |
// Your code here!
import std.stdio,std.conv,std.string,std.algorithm,std.array;
void main(){
auto s=readln().chomp().split().map!(to!int);
int a=s[0],b=s[1];
if(a>b)
writeln(a-1);
else
writeln(a);
} | D |
import std.stdio;
import std.algorithm;
import std.math;
import std.conv;
import std.string;
T readNum(T)(){
return readStr.to!T;
}
T[] readNums(T)(){
return readStr.split.to!(T[]);
}
string readStr(){
return readln.chomp;
}
void main(){
auto abck = readNums!int;
int qty, ret;
if(abck[0] > 0 && qty !... | D |
import std.stdio, std.string, std.array, std.algorithm, std.conv, std.typecons, std.numeric, std.math;
void main()
{
auto n = readln.chomp.to!int;
auto DP = new long[](n+1);
DP[0] = 1;
DP[1] = 1;
foreach (i; 2..n+1) {
DP[i] = DP[i-1] + DP[i-2];
}
writeln(DP[n]);
}
| D |
//dlang template---{{{
import std.stdio;
import std.conv;
import std.string;
import std.array;
import std.algorithm;
import std.typecons;
import std.math;
import std.range;
// MIT-License https://github.com/kurokoji/nephele
class Scanner
{
import std.stdio : File, stdin;
import std.conv : to;
import std.array : ... | D |
import std.functional,
std.algorithm,
std.typecons,
std.bigint,
std.string,
std.traits,
std.array,
std.range,
std.stdio,
std.conv,
std.math;
T read_num(T)() { return readln.chomp.to!T; }
T min(T)(T a, T b) { return a < b ? a : b; }
void main() {
... | D |
/+ dub.sdl:
name "A"
dependency "dunkelheit" version="1.0.1"
+/
import std.stdio, std.algorithm, std.range, std.conv;
// import dkh.foundation, dkh.scanner;
int main() {
Scanner sc = new Scanner(stdin);
scope(exit) assert(!sc.hasNext);
int n, k;
sc.read(n, k);
writeln(n - k + 1);
retur... | D |
import std.stdio, std.math, std.algorithm, std.array, std.string, std.conv, std.container, std.range;
T Read(T)() { return readln.chomp.to!(T); }
T[] Reads(T)() { return readln.split.to!(T[]); }
alias read = Read!(int);
alias reads = Reads!(int);
void main() {
int n = read();
int[] h = reads();
auto dp =... | 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;
static import std.ascii;
// dfmt off
T lread(T = long)(){return readln.chomp.to!T();}
T[] lreads(T = long)(long n){ret... | 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 main()
{
long a, b, x; readV(a, b, x);
wr... | D |
void main()
{
int n = readln.chomp.to!int;
int t, x, y;
bool ok = true;
foreach (i; 0 .. n)
{
int[] tmp = readln.split.to!(int[]);
int ti = tmp[0], xi = tmp[1], yi = tmp[2];
int len = abs(xi - x) + abs(yi - y);
if (ti - t < len)
{
ok = false;
... | D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
auto k = readln.chomp.to!long, n = 50;
auto kd = k/n, km = k%n;
auto a = new long[](n);
a[] = n-1+kd;
foreach (i; 0..km) {
a[] -= 1;
a[i] += n+1;
}
writeln(n);
foreach (i, ai; a)
write(ai, i < n-1 ? " " : "");... | D |
import std.stdio, std.conv, std.string;
import std.algorithm, std.array, std.container;
import std.numeric, std.math;
import core.bitop;
string my_readln() { return chomp(readln()); }
long mod = pow(10, 9) + 7;
long moda(long x, long y) { return (x + y) % mod; }
long mods(long x, long y) { return ((x + mod) - (y % mo... | D |
import std.stdio,
std.string,
std.conv,
std.algorithm;
long abs(long n) {
if (n < 0) {
return -n;
}
return n;
}
void main() {
int N = readln.chomp.to!(int);
long[] A = readln.chomp.split.to!(long[]);
if (N == 2) {
writeln(abs(A[1]) * 2);
writeln(abs(A[0]) * 2);
return... | D |
import std.stdio;
import std.conv;
import std.algorithm;
import std.range;
import std.string;
import std.math;
void main() {
readln;
auto s = readln.chomp.split.map!(to!int);
readln;
auto t = readln.chomp.split.map!(to!int);
int cnt = 0;
foreach (e; t) {
if (!s.find(e).empty) cnt++;
}
cnt.writeln... | 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 X = readln.chomp.to!int;
auto ns = new bool[](100004);
foreach (i; 2..100004) {
if (ns[i]) continue;
if (i >= X) {
writeln(i);
return;
}... | D |
import std.algorithm;
import std.conv;
import std.math;
import std.range;
import std.stdio;
import std.string;
void main ()
{
auto tests = readln.strip.to !(int);
foreach (test; 0..tests)
{
auto s = readln.strip;
auto balance = abs (s.count ('0').to !(int) -
s.count ('1').to !(int));
auto moves = (s.len... | D |
import std.stdio, std.string, std.range, std.conv, std.array, std.algorithm, std.math, std.typecons;
void main() {
const tmp = readln.split.to!(int[]);
writeln(tmp[0] + tmp[1]/2);
}
| D |
import std.algorithm;
import std.array;
import std.conv;
import std.math;
import std.stdio;
import std.string;
import std.range;
int readint() {
return readln.chomp.to!int;
}
int[] readints() {
return readln.split.map!(to!int).array;
}
void main() {
auto s = readln.chomp;
auto t = readln.chomp;
... | D |
module app;
import core.bitop;
import std.algorithm;
import std.array;
import std.bigint;
import std.conv;
import std.stdio;
import std.string;
void main()
{
Input input = void;
parseInput(input, stdin);
auto result = main2(&input);
writeln(result);
}
auto main2(Input* input)
{
foreach (i, c; input... | D |
import std.stdio, std.conv, std.string, std.array, std.range, std.algorithm, std.container;
import std.math, std.random, std.bigint, std.datetime, std.format;
void main(string[] args){ if(args.length > 1) if(args[1] == "-debug") DEBUG = 1; solve(); }
void log()(){ writeln(""); } void log(T, A ...)(T t, lazy A a){ if(DE... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array, std.typecons;
import std.math, std.numeric;
immutable long mod = 10L^^9 + 7;
void main() {
int n; scan(n);
auto fact = new long[](n + 1);
auto rfact = new long[](n + 1);
fact[0] = 1;
foreach (i ; 1 .. n + 1) {
... | 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 std.stdio, std.string, std.conv;
import std.typecons;
import std.algorithm, std.array, std.range, std.container;
void main() {
auto N = readln.split[0].to!ulong;
ulong[] p;
N.iota.each!(x => p ~= readln.split[0].to!ulong);
auto sum = p.sum, max_price = p.minPos!("a > b")[0];
(p.sum - max_price/2).writeln;... | D |
import std.conv, std.functional, std.range, std.stdio, std.string;
import std.algorithm, std.array, std.bigint, std.bitmanip, std.complex, std.container, std.math, std.mathspecial, std.numeric, std.regex, std.typecons;
import core.bitop;
class EOFException : Throwable { this() { super("EOF"); } }
string[] tokens;
stri... | 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 main() {
auto N = readln.chomp.to!int;
auto G = new Tuple!(int, int)[][](N);
foreach (i; 0..N-1) {
... | 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.string;
immutable long MOD = 998244353;
void main() {
auto N = readln.chomp.to!int;
auto S = N.iota.map!(_ => readln.chom... | D |
import std.stdio, std.string, std.conv, std.array, std.algorithm;
void main() {
auto a = readln.split.map!(to!int);
if (a[4] <= a[2] && a[2] <= a[0] - a[4] && a[4] <= a[3] && a[3] <= a[1] - a[4]) writeln("Yes");
else
writeln("No");
} | 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!(int[]);
auto M = tmp[0], N = tmp[1], X = tmp[2];
auto a = readln.split.to!(int[]);
auto left = a.filter!(x => x < X).walkLength;
auto right = a.filter!(x ... | D |
import std.stdio, std.string, std.algorithm, std.range;
void main() {
auto abc = readln.chomp.split.sort.uniq.array;
abc.length.writeln;
}
| 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;
if (((n[0] == n[1]) && (n[1] == n[2])) || ((n[1] == n[2]) &&... | D |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.