code stringlengths 4 1.01M | language stringclasses 2
values |
|---|---|
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 infl = 1_001_001_001_001_001_001L;
enum mod = 1_000_000_007L;
void main() {
string s;
scan(s);
auto n = s.length.to!in... | D |
import std.stdio, std.string, std.range, std.conv, std.array, std.algorithm, std.math, std.typecons;
void main() {
const N = readln.chomp.to!long;
const xs = 5.iota.map!(_ => readln.chomp.to!long).array;
writeln(4 + cast(long)ceil(cast(double)N / xs.reduce!min));
}
| 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, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto N = readln.chomp.to!int;
auto st = readln.split.to!(char[][]);
char[] u;
foreach (i; 0..N) {
u ~= st[0][i];
u ~= st[1][i];
}
writeln(u);
} | D |
import std.algorithm;
import std.array;
import std.stdio;
import std.conv;
import std.string;
import std.range;
void main(){
size_t w, h, sx, sy;
char[][] data = new char[][](20, 20);
while(true){
auto input = readln.split;
w = input[0].to!int;
h = input[1].to!int;
if(!(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 |
void main()
{
long n = readln.chomp.to!long;
long total;
for (long i = 1; i * i < n; ++i)
{
if (n % i == 0)
{
long d = n / i;
if (i == n % (d - 1)) total += d - 1;
}
}
total.writeln;
}
import std.stdio;
import std.string;
import std.array;
impor... | D |
void main(){
long x, t;
scanf("%ld %ld", &x, &t);
(x-t>0?x-t:0).writeln();
}
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(T = int)(){
T... | D |
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],c=s[2];
if(a+b>=c)
writeln("Yes");
else
writeln("No");
} | 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()
{
readln;
auto a = readln.chomp.split.map!(to!int);
auto s = new int[](100003);
f... | 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() {
readln;
auto xs = readints();
... | D |
void main() {
int[] tmp = readln.split.to!(int[]);
int x = tmp[0], a = tmp[1], b = tmp[2];
writeln(abs(x-a) < abs(x-b) ? 'A' : 'B');
}
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 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(){
import std.stdio, std.string, std.conv, std.algorithm;
int n; rd(n);
auto g=new int[][](n+1, 0);
auto can=new int[](n+1);
void f(int i){
if(g[i].length==0){can[i]=0; return;}
foreach(j; g[i]) f(j);
foreach(j; g[i])if(can[j]==0){
can[i]=can[j]=1; break;
}
can[i]=max(can... | D |
import std.algorithm;
import std.bigint;
import std.concurrency;
import std.container;
import std.conv;
import std.functional;
import std.format;
import std.math;
import std.meta;
import std.numeric;
import std.random;
import std.range;
import std.stdio;
import std.string;
import std.traits;
import std.typecons;
immu... | 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;
import std.container;
string read(){ static string[] ss; while(!ss.length) ss = readln.chomp.split; string res = ss[0]; ss.popFront; return res; }
const ulong MOD = 1_000_00... | D |
void main(){
int ans = 6;
int[] ab;
ab ~= _scan();
ab ~= _scan();
foreach(elm; ab)ans -= elm;
ans.writeln();
}
import std.stdio, std.conv, std.algorithm, std.numeric, std.string, std.math;
// 1要素のみの入力
T _scan(T= int)(){
return to!(T)( readln().chomp() );
}
// 1行に同一型の複数入力
T[] _scanln(T = int)(){
T[] ln;
fore... | 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 s; readV(s);
auto u = s[... | D |
void main()
{
int[] tmp = readln.split.to!(int[]);
int h = tmp[0], w = tmp[1];
string[] s = new string[h];
coord[] black;
foreach (i; 0 .. h)
{
s[i] = readln.chomp;
foreach (j, c; s[i])
{
if (c == '#')
{
black ~= coord(i, j.to!int)... | D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
auto rd = readln.split.to!(int[]), a = rd[0], b = rd[1];
writeln((a + b) % 24);
}
| 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;
import std.ascii;
import std.bigint;
import std.container;
void main() {
int h,w;
int[] hw = array(map!(a => to!int(a))(readln().strip().split()));
h = hw[0];
w = hw[... | D |
import std.stdio, std.array, std.conv, std.string;
void main() {
string[] input = split(readln());
int W = to!int(input[0]), H = to!int(input[1]);
int x = to!int(input[2]), y = to!int(input[3]), r = to!int(input[4]);
if (r <= x && r <= (W - x) && r <= y && r <= (H - y)) {
writeln("Yes");
} else {
w... | D |
import std.stdio;
import std.algorithm;
import std.conv;
import std.numeric;
import std.math;
import std.string;
void main()
{
auto tokens = split(chomp(readln()));
int n = to!int(tokens[0]);
int m = to!int(tokens[1]);
int[][] nodes;
int[][] edges;
nodes.length = n;
foreach (i; 0..m)
{
auto tokens2 = split(c... | 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!long;
auto s = readln.chomp.to!long;
long b = 2;
for (; b^^2 <= n; ++b) {
auto m = n;
long t;
while (m) {
t += m % b;
... | D |
import std.stdio, std.string;
void main() {
string input = chomp(readln());
char lastChar = ' ';
byte count = 1;
foreach(char i; input) {
if(lastChar == ' ') {
lastChar = i;
continue;
}
if(lastChar == i) {
count++;
} else {
count = 1;
lastChar = i;
}
if(count >= 3) {
writeln("Yes"... | 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, 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.container;
import std.conv;
import std.math;
import std.numeric;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
void log(A...)(A arg) { stderr.writeln(arg); }
int size(T)(in T s) { return cast(int)s.length; }
void main() ... | 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(); } bool DEBUG = 0;
void log(A ...)(lazy A a){ if(DEBUG) print(a); }
voi... | D |
void main() {
string n = readln.chomp;
while (n.count(n[0]) != 3) {
n = n.succ;
}
n.writeln;
}
import std.stdio;
import std.string;
import std.array;
import std.conv;
import std.algorithm;
import std.range;
import std.math;
import std.container;
import std.typecons; | 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();
long bignum... | 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, std.string, std.conv;
void main() {
int n = readln.chomp.to!int;
int[] p = readln.split.to!(int[]);
int cnt;
foreach (i, x; p) {
if (x != i + 1) ++cnt;
}
writeln(cnt < 3 ? "YES" : "NO");
} | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto nk = readln.split.to!(long[]);
auto N = nk[0];
auto K = nk[1];
long r;
foreach (n; K+1..N+1) {
r += N/n * (n-K);
r += max(0, N - N/n * n - max(0, K-1));
}
... | D |
import std.stdio, std.algorithm, std.conv, std.string, std.range;
import std.container;
void main(string[] args) {
auto dlist = DList!int();
int n = readln.chomp.to!int;
foreach (i; 0..n) {
string op = readln.chomp;
if (op[0..7] == "insert ") {
dlist.insertFront(op[7..$].to!in... | D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
import std.container;
void main()
{
auto ai = new PriorityQueue!int(2_0000_000);
for (;;) {
auto rd = readln.chomp.splitter(' '), cmd = rd.front;
switch (cmd) {
case "insert":
rd.popFront;
ai.insert(rd.front.to!int);
... | 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 r, g;
scan(r);
scan(g);
writeln(2*g - r);
}
void scan(T...)(ref T args) {
string[] line = readln.split;
foreach (ref arg; args) {
... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.array;
void main(){
auto F=readln.split.to!(int[]),A=F[0],B=F[1],C=F[2];
if(A+B+C==17)writeln("YES");
else writeln("NO");
} | 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, std.bitmanip;
import std.datetime;
immutable long MOD = 10^^9 + 7;
int N, X, Y, Z, S, MASK, NG;
long[][] mem;
long dp... | D |
// Vicfred
// https://atcoder.jp/contests/abc174/tasks/abc174_d
// greedy
import std.algorithm;
import std.array;
import std.conv;
import std.stdio;
import std.string;
void main() {
const int n = readln.chomp.to!int;
string s = readln.strip;
int reds = 0;
foreach(ch; s)
if(ch == 'R')
... | D |
void main() {
problem();
}
void problem() {
auto S = scan;
auto T = scan;
long solve() {
long ans;
foreach(i; 0..S.length) {
if (S[i] != T[i]) ans++;
}
return ans;
}
solve().writeln;
}
// ----------------------------------------------
import std.stdio, std.conv, std.array, std.str... | 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.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array;
void main() {
int x, a, b;
scan(x);
scan(a);
scan(b);
writeln((x-a)%b);
}
void scan(T...)(ref T args) {
import std.stdio : readln;
import std.algorithm : splitter;
import std.conv : to;
import std... | 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 |
void main()
{
import std.array, std.stdio, std.string, std.conv;
auto buf = readln.chomp.split.to!(int[]);
auto window = buf[0];
auto curtain = buf[1] << 1;
if (window > curtain)
(window - curtain).writeln;
else
0.writeln;
}
| D |
void main(){
import std.stdio, std.string, std.conv, std.algorithm;
long A, B, C, D, E, F; rd(A, B, C, D, E, F);
A*=100; B*=100;
long tot=A, su=0;
for(long a=0; a<=F; a+=A)for(long b=0; a+b<=F; b+=B){
for(long c=0; a+b+c<=F; c+=C){
if(c*100>(a+b)*E) continue;
for(long d=0; a+b+c+d<=F; d+=D){... | D |
import std.stdio;
import std.algorithm;
import std.conv;
import std.numeric;
import std.math;
import std.string;
void main()
{
auto tokens = split(chomp(readln()));
auto N = to!ulong(tokens[0]);
auto M = to!ulong(tokens[1]);
ulong inc = 1;
if (M % 2 == 1)
{
if (N % 2 == 0) ++N;
inc = 2;
}
ulong blocks = M... | D |
import std.conv;
import std.stdio;
import std.string;
void main()
{
auto s = readln.strip;
auto t = readln.strip;
writeln( solve( s, t ) );
}
auto solve( in string s, in string t )
{
foreach( i; 0 .. t.length )
{
auto ts = t[ i .. $ ] ~ t[ 0 .. i ];
if( s == ts ) return "Yes";
}
return "No";
}
| 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 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 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.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()
{
int a, b; readV(a, b);
writeln(a... | 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!long;
auto AS = readln.split.to!(long[]);
long sum_a;
foreach (a; AS) sum_a += a;
auto d = (N+1) * N / 2;
if (sum_a % d != 0) {
writeln("NO");
... | D |
void main() {
auto N = ri;
auto S = rs;
int res, tmp;
foreach(i; S) {
if(i == 'I') tmp++;
else tmp--;
res = max(res, tmp);
}
res.writeln;
}
// ===================================
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.range;
import std.traits;
import std.mat... | 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.random;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
void main()
{
long n = readln.chomp.to!long;
long ans = 0;
foreach... | 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.algorithm;
import std.conv;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
void main ()
{
auto tests = readln.strip.to !(int);
foreach (test; 0..tests)
{
readln.splitter.map !(to !(int)).sum.writeln;
}
}
| D |
/+ dub.sdl:
name "A"
dependency "dunkelheit" version=">=0.9.0"
+/
import std.stdio, std.algorithm, std.range, std.conv;
// import dkh.foundation, dkh.scanner;
import core.bitop;
immutable int B = 26;
int main() {
Scanner sc = new Scanner(stdin);
int n;
sc.read(n);
int f = (1<<B) - 1;
int... | D |
import std.algorithm;
import std.conv;
import std.range;
import std.stdio;
import std.string;
void main ()
{
auto tests = readln.strip.to !(int);
foreach (test; 0..tests)
{
auto n = readln.strip.to !(int);
auto a = readln.splitter.map !(to !(int)).array;
int res = n - (n == 1);
foreach (i; 0..n)
{
fore... | 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;
void main() {
auto N = readln.chomp.to!int;
auto A = 2.iota.map!(_ => readln.split.map!(to!long).array).array;
aut... | D |
import std.stdio;
void main()
{
long n;
scanf("%lld", &n);
printf("%lld\n", n / (2 * 2 * 2* 3 * 3 * 5 * 7));
} | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric, std.bigint;
void main()
{
auto N = readln.chomp.to!int;
auto AS = readln.split.to!(int[]);
auto k = int.max, x = int.max, n = N;
size_t i, j = N-1;
while (i <= j) {
--n;
x = min(x... | D |
import std.stdio : writeln, stdin;
import std.conv : to;
import std.range : dropOne;
import core.stdc.stdio;
void main()
{
int n;
scanf("%d", &n);
string ss;
int[100005] arr;
for(int i = 0 ;i < 100005; ++i){
arr[i] = 1;
}
foreach(word; stdin.byLine)
{
ss = to!strin... | 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 s = readln.split.map!(to!int);
auto N = s[0];
auto K = s[1].to!long;
auto A = readln.spl... | D |
import std;
long calc(int n) {
long sum = 0;
for (int i = 1; i <= n; i++) {
if (i % 3 == 0 || i % 5 == 0) continue;
sum += i;
}
return sum;
}
void main() {
int n; scan(n);
writeln(calc(n));
}
void scan(T...)(ref T a) {
string[] ss = readln.split;
foreach (i, t; T) a[i]... | 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 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 = new long[](10^^5+1);
long S;
foreach (a; readln.split.to!(long[])) {
S += a;
++as[a];
}
auto Q = readln.chomp.to!int;
... | 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 long mod = 10^^9 + 7;
void main() {
string s = readln.chomp;
string abc = "ABC";
int n = s.length.to!int;
auto dp = new long[][](n + 1, 4);
... | 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 nx = readln.split.to!(int[]);
auto N = nx[0];
long x = nx[1];
auto AS = readln.split.to!(long[]);
auto min_as = new long[](N);
min_as[] = long.max... | D |
import std.stdio,std.conv,std.string,std.algorithm,std.array;
void main(){
auto sn=readln().split();
int n=to!int(sn[0]);
if(n<1000)
writeln("ABC");
else
writeln("ABD");
} | D |
module app;
import core.bitop;
import std.algorithm;
import std.array;
import std.bigint;
import std.container.rbtree;
import std.conv;
import std.stdio;
import std.string;
import std.traits;
struct Input
{
string s;
}
void parseInput(T)(out Input input, T file)
{
with (file) with (input)
{
s = readln().strip(... | 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.string, std.conv, std.algorithm;
import std.range, std.array, std.math, std.typecons, std.container, core.bitop;
import std.numeric;
void main() {
int n, m;
scan(n, m);
auto adj = new int[][](m, 0);
auto ex = new bool[](m);
foreach (i ; 0 .. n) {
auto line = readln.... | D |
import std.stdio, std.conv, std.array, std.string, std.algorithm, std.container, std.range, core.stdc.stdlib, std.math, std.typecons;
T[][] combinations(T)(T[] s, in int m) { if (!m) return [[]]; if (s.empty) return []; return s[1 .. $].combinations(m - 1).map!(x => s[0] ~ x).array ~ s[1 .. $].combinations(m); }
... | D |
/+ dub.sdl:
name "A"
dependency "dcomp" version=">=0.6.0"
+/
import std.stdio, std.algorithm, std.range, std.conv;
import std.typecons;
// import dcomp.foundation, dcomp.scanner;
// import dcomp.array;
// import dcomp.ldc.inline;
int[] primeList(int n) {
bool[] used = new bool[n+1];
FastAppender!(int... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons;
int[11] NS = [59049, 46656, 7776, 6561, 1296, 729, 216, 81, 36, 9, 6];
void main()
{
auto N = readln.chomp.to!int;
int[int][11] memo;
int solve(int i, int n) {
if (n == 0) return 0;
if (i == 11) ret... | 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, 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, M;
scan(N, M);
auto adj... | D |
// This file is a "Hello, world!" in D language by DMD for wandbox.
import std.algorithm, std.conv, std.stdio, std.array, std.math, std.string;
void main()
{
const N = readln.chomp.to!long;
const V = readln.split.map!(to!long).array;
const C = readln.split.map!(to!long).array;
long ans;
foreach (b; 0..2.pow... | D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
auto rd = readln.split.to!(long[]), n = rd[0], ts = rd[1];
auto t = readln.split.to!(long[]);
auto ans = 0L;
foreach (i; 0..n-1)
ans += t[i+1]-t[i] > ts ? ts : t[i+1]-t[i];
ans += ts;
writeln(ans);
}
| D |
void main() {
import std.stdio, std.string, std.conv, std.algorithm;
int n, d;
rd(n, d);
struct P {
int x, y;
}
P[] vec = [P(d, -d), P(n - d, n - d), P(-d, d), P(d - n, d - n)];
P[] ps = [P(0, d), P(d, 0), P(n, n - d), P(n - d, n)];
int m;
rd(m);
while (m--) {
int x, y;
rd(x, y);
i... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.range;
import std.container;
import std.bigint;
import std.math;
void main()
{
while (1) {
auto x = readln.chomp.split.map!(to!int);
if (x[0] == 0) break;
foreach (i; 0..x[0]) {
foreach (j; 0..x[1]) {
if (... | 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 std.stdio;
void main() {
string land = stdin.readln();
size_t position = 1;
foreach (char command; stdin.readln()) {
if (command == land[position - 1]) {
++position;
}
}
stdout.write(position);
} | 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 nml = readln.split.to!(int[]);
auto N = nml[0];
auto M = nml[1];
long L = nml[2];
auto G = new long[][](N, N);
foreach (ref g; G) g[] = long.max/3;... | 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;
int count2(int 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.container;
import std.datetime;
void main()
{
while (1) {
auto str = readln.chomp;
if (str == "#") break;
int i = str.length.to!int-1;
long a, b = 1;... | 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 mod = 10L^^9 + 7;
alias Pair = Tuple!(long, "s", long, "x");
void main() {
long n;
scan(n);
long[Pair] mem;
long func(long s, long x) {
... | 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 = 100_100, MOD = 1_000_000_007, INF = 1_000_000_000_000;
alias sread = () => readln.chomp();
alias lread(T = long) = () ... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm: canFind;
void main() {
string[] inputs = split(readln());
int A = to!int(inputs[0]);
int B = to!int(inputs[1]);
int C = to!int(inputs[2]);
if(C >= A && C <= B) "Yes".writeln;
else "No".writeln;
}
| D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.array;
import std.range;
import std.math;
void main(){
auto z=readln.split.to!(int[]),a=z[0],b=z[1],c=z[2];
auto k=readln.chomp.to!int;
if(a>=b&&a>=c)writeln(b+c+a*(2^^k));
else if(b>=a&&b>=c)writeln(a+c+b*(2^^k));
else if(c... | D |
import std.stdio,
std.string,
std.conv;
void main() {
while(true){
string s = readln;
if (stdin.eof()) break;
int n = s.chomp.to!int;
int c = 0;
foreach(int i; 0..10)
foreach(int j; 0..10)
foreach(int k; 0..10)
foreach(int l; 0..10)
if (i + j + k + l == n){
c += 1;
}
writeln(c);
}
} | D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void main() {
string s = readln.strip;
long sm = 0, cnt = 0;
foreach(i,c;s) if(c == 'W')
sm += i - cnt++;
writeln(sm);
}
| 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;
int calc(int a, int b, ... | 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, std.container;
alias E = Tuple!(int, "from", int, "to", long, "c");
void main()
{
auto nmp = readln.split.to!(int[]);
auto N = nmp[0];
auto M = nmp[1];
long P = nmp[2];
E[] es;
foreach (_; 0.... | D |
import std.stdio, std.conv, std.string, std.range, std.algorithm, std.array,
std.functional, std.container, std.typecons;
void main() {
int N = readln.chomp.to!int;
int[] A = readln.split.to!(int[]);
int[] B = new int[N];
B[0] = A.sum - 2 * iota(1, N-1, 2).map!(i => A[i]).sum;
foreach(i; 1..N) {
B[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;
import std.container;
alias sread = () => readln.chomp();
ulong bignu... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
enum CF = "CODEFESTIVAL2016";
void main()
{
auto S = readln.chomp;
int r;
foreach (i, c; S) if (c != CF[i]) ++r;
writeln(r);
} | 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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.