code stringlengths 4 1.01M | language stringclasses 2
values |
|---|---|
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.conv, std.string, std.array, std.range, std.algorithm, std.container;
import std.math, std.random, std.bigint, std.datetime, std.format;
bool DEBUG = 0; void log(A ...)(lazy A a){ if(DEBUG) print(a); }
void main(string[] args){ args ~= ["", ""]; string cmd = args[1]; if(cmd == "-debug") DEBUG = 1;... | 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 s = sread();
auto t = sread();
// writeln(s);
long ... | 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 d = readln.chomp.split.to!(int[]);
int res;
foreach (_; 0..2) {
if (d[0]... | 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()
{
long n = rdElem;
long[] a = rdRow;
a[] -= 1;
long[] list = new long[n];
foreach (x; a)
{
++list[x];
}
foreach (l; list)
{
l.writeln;
}
}
enum long mod = 10^^9 + 7;
enum long inf = 1L << 60;
enum double eps = 1.0e-9;
T rdElem(T = long)()
if (!is(T... | D |
import std.stdio, std.conv, std.string, std.algorithm, std.range, std.math;
void main() {
alias f = a => a == 2 ? 0 : (a == 4 || a == 6 || a== 9 || a == 11) ? 1 : 2;
auto po = readln.split.to!(int[]).map!f.array;
writeln(po[0] == po[1] ? "Yes" : "No");
}
| D |
import std.stdio;
import std.conv;
import std.string;
import std.algorithm;
void main()
{
string s;
while( (s=readln.strip) != "0 0") {
auto n = map!(to!int)(s.strip.split);
for(int i=0;i<n[0];i++) {
for(int j=0;j<n[1];j++) {
write("#");
}
wri... | D |
import std.stdio, std.conv, std.string, std.array, std.math, std.regex, std.range, std.ascii, std.numeric, std.random;
import std.typecons, std.functional, std.traits,std.concurrency;
import std.algorithm, std.container;
import core.bitop, core.time, core.memory;
import std.bitmanip;
import std.regex;
enum INF = long.... | D |
import std.stdio;
import std.ascii;
import std.conv;
import std.string;
import std.algorithm;
import std.range;
import std.functional;
import std.math;
import core.bitop;
import std.numeric;
void main()
{
auto ab = readln.split.to!(long[]);
(ab[0] - ab[1] + 1).writeln;
}
| 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;
long[10^^5*2+50] 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;
}
r... | 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;
void main() {
string s;
scan(s);
yes(s.canFind('7'));
}
void scan(T..... | D |
import std.stdio, std.string, std.conv, std.algorithm;
import std.range, std.array, std.math, std.typecons, std.container, core.bitop;
immutable inf = 1<<30;
void main() {
int n, k;
scan(n);
scan(k);
int ans = inf;
void dfs(int i, int val) {
if (i == n) {
ans = min(ans, val);... | 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;
int N;
int[] colors;
int[][] adj;
void main() {
N = readln.chomp.to!int;
adj = new int[][](N);
... | 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;
T lread(T = long)()
{
return readln.chomp.to!T();
}
T[] aryread(T = long)()
{
return readln.split.to!(T[])();
}
void sca... | 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;
import std.string;
import std.array;
import std.range;
import std.random;
import std.algorithm;
import std.conv;
void main(){
auto input = readln().chomp();
solve(input).writeln();
}
int solve(string input){
auto result = 0;
foreach(s; input){
if(s == '+'){
result... | 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;
long calc(int x, int y,... | D |
import std;
auto input()
{
return readln().chomp();
}
alias sread = () => readln.chomp();
alias aryread(T = long) = () => readln.split.to!(T[]);
void main()
{
long a, b;
scan(a, b);
foreach (i; 0 .. 1001)
{
if (((i * 8) / 100 == a) && ((i * 10) / 100 == b))
{
writeln(... | 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;
string read(){ static string[] ss; while(!ss.length) ss = readln.chomp.split; string res = ss[0]; ss.popFront; return res; }
void main(){
int a = read.to!int;
int ... | D |
unittest
{
assert( [ "erasedream" ].parse.expand.solve == "YES" );
assert( [ "dreameraser" ].parse.expand.solve == "YES" );
assert( [ "dreamerer" ].parse.expand.solve == "NO" );
}
import std.conv;
import std.range;
import std.stdio;
import std.typecons;
void main()
{
stdin.byLineCopy.parse.expand.solve.writeln;... | D |
import std.stdio;
import std.math;
import std.algorithm;
import std.conv;
long bisect(T)(T[] arr, T p) {
long u, t = arr.length-1;
long i = (u + t) / 2;
while(i != 0 && i != arr.length - 1 && (arr[i] > p || arr[i+1] <= p)) {
if (arr[i] > p) {
t = i;
}
else {
if (u == i)
u = i + 1;
else
u = i;... | D |
import std.stdio,std.string,std.conv,std.array;
void main(){
for(;;){
auto rcs = readln().chomp().split();
auto n = to!int(rcs[0]);
auto x = to!int(rcs[1]);
if( n==0 && x==0 ){ break; }
int hit=0;
for( int a=1;a <= n-2; a++ ){
for( int b=a+1;b <= n-1; b++ ){
for( int c=b+1;c <= n; c++ ){
if(... | D |
void main() {
int n = readln.chomp.to!int;
int[] l = readln.split.to!(int[]);
writeln(l.sum > 2 * l.reduce!max ? "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.container;
import std.typecons; | D |
import std.stdio, std.string, std.conv, std.algorithm;
import std.range, std.array, std.container, std.math, std.typecons;
immutable int max = 2 * 10^^5 + 10;
int n, k, q;
//int[] l, r;
void main() {
scan(n, k, q);
auto adm = new int[](max);
int li, ri;
foreach (i ; 0 .. n) {
scan(li, ... | D |
import std.stdio, std.conv, std.array, std.string;
import std.algorithm;
void main() {
string s = readln.chomp;
string prev;
uint count = 0;
auto n = s.length;
for(uint i=0; i<n; i++) {
if (s[i..i+1] == prev) {
if (i+1 == n) break;
prev = s[i..i+2];
count++;
i++;
continue;
... | 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 |
unittest
{
assert( [ "2019/04/30" ].parse.expand.solve == "Heisei" );
assert( [ "2019/11/01" ].parse.expand.solve == "TBD" );
}
import std.conv;
import std.range;
import std.stdio;
import std.typecons;
void main()
{
stdin.byLineCopy.parse.expand.solve.writeln;
}
auto parse( Range )( Range input )
if( isInputRan... | D |
import std.stdio, std.conv, std.array, std.string;
import std.algorithm.iteration, std.algorithm.mutation, std.algorithm.searching, std.algorithm.sorting;
void main()
{
int N = readln().strip.to!int;
if(N==1)
{
writeln("Hello World");
}else{
auto r = readln().strip.to!int +
read... | D |
import std.stdio;
import std.string, std.conv, std.array, std.algorithm;
import std.uni, std.math, std.container;
import core.bitop, std.datetime;
void main(){
auto N = readln.chomp.to!int;
int ans = N * (N + 1) / 2;
ans.writeln;
} | 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(){
auto n = read.... | D |
void main()
{
long n = readln.chomp.to!long;
long[] a = new long[n], b = new long[n];
foreach (i; 0 .. n)
{
long[] tmp = readln.split.to!(long[]);
a[i] = tmp[0], b[i] = tmp[1];
}
long buttons;
foreach_reverse (i; 0 .. n)
{
long r = (a[i] + buttons) % b[i];
... | D |
import std.stdio, std.string, std.conv, std.bigint, std.typecons, std.algorithm, std.array, std.math, std.range, std.functional;
void main() {
auto tmp = readln.split.to!(int[]);
writeln(max(0, min(tmp[3], tmp[1]) - max(tmp[2], tmp[0])));
} | D |
/* imports all std modules {{{*/
import
std.algorithm,
std.array,
std.ascii,
std.base64,
std.bigint,
std.bitmanip,
std.compiler,
std.complex,
std.concurrency,
std.container,
std.conv,
std.csv,
std.datetime,
std.demangle,
std.encoding,
std.exception,
std.file,
std.format,
std.functi... | D |
import std.stdio, std.string, std.array, std.conv, std.algorithm;
long solve(long n, long m)
{
if (2*n > m)
return m / 2;
auto ret = n;
m -= n*2;
ret += m/4;
return ret;
}
void main()
{
auto nm = readln.split.to!(long[]);
writeln(solve(nm[0], nm[1]));
} | D |
import std.conv;
import std.stdio;
import std.string;
void main()
{
auto r = readln.strip.to!int;
writeln( solve( r ) );
}
auto solve( in int r )
{
if( r < 1200 ) return "ABC";
if( r < 2800 ) return "ARC";
return "AGC";
}
| 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;
void main(){
auto cin = new Cin();
auto S = cin.line!string()[0];
bool succeed = false;
foreach( i ; 0..S.length-1 ){
if( S[i]==S[i+1] ){
writeln( i+1," ",i+2 );
return;
}
}
foreach( i ; 0..S.length-2 ){
if( S[i]==S[i+2] ){
writeln( i+1," ",i+3 );
return;
}
}
write... | D |
import std.stdio,std.conv,std.string,std.algorithm,std.array,std.math;
void main(){
auto s=readln().chomp().split().map!(to!int);
int a,b,c,d;
a=s[0];
b=s[1];
c=s[2];
d=s[3];
if(abs(c-a)<=d)
writeln("Yes");
else if(abs(b-a)<=d && abs(c-b)<=d)
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;
void main()
{
auto n = readln.chomp.to!int;
foreach (i; 0..n) {
auto as = readln.split.map!(to!int);
int l ,r;
b... | 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;
import std.ascii;
void main()
{
auto s = readln.chomp.split;
writeln(s[1] ~ s[0]);
}
| 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;
class A{
int a;
int b;
int c;
int p;
this(int a, int b, int c){
this.a = a, this.b = b, this.c = c;
this.p = ma * b - mb * a;
}
}
int n, ma, mb;
// 問題はsum(p) ... | D |
void main()
{
string s = rdStr;
long n = s.length;
bool ok = true;
foreach (i; 0 .. n/2)
{
if (s[i] != s[n-i-1]) ok = false;
}
long m = (n - 1) / 2;
foreach (i; 0 .. m)
{
if (s[i] != s[m-i-1]) ok = false;
if (s[m+i+1] != s[n-i-1]) ok = false;
}
writ... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.math;
import std.regex;
import std.range;
import core.exception;
void main() {
auto N = readln.chomp.to!int;
auto a = new int[](N);
foreach(i; 0..N) {
a[i] = readln.chomp.to!int;
}
bool[int] b;
foreach(i; 0..N+1) b[i] = fals... | D |
import std.stdio, std.range, std.random, std.conv, std.string;
import std.algorithm.comparison, std.algorithm.iteration, std.algorithm.mutation, std.algorithm.searching, std.algorithm.sorting;
void main()
{
int[] input = readln().strip.split().to!(int[]);
int N = input[0];
int T = input[1];
int minCos... | D |
import std.stdio, std.conv, std.string, std.math;
void main(){
((a, b, h) => (a + b) * h / 2)(r, r, r).writeln;
}
int r() { return readln.chomp.to!int; } | D |
char t(ulong c) {
switch(c) {
case 0: return 'A';
case 1: return 'C';
case 2: return 'G';
case 3: return 'T';
default: return 'x';
}
}
void main() {
auto N = ri;
ulong MOD = 1000000007;
auto dp = new long[][][][](N+1, 4, 4, 4);
dp[0][3][3][3] = 1;
foreach(n; 0..N) foreach(t1; 0..4) foreach(t2; 0.... | 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 = 998244353;
void main() {
auto s = readln.split.map!(to!long);
auto N = s[0].to!int;
auto A ... | 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.conv, std.string, std.array, std.math, std.regex, std.range, std.ascii, std.numeric, std.random;
import std.typecons, std.functional, std.traits,std.concurrency;
import std.algorithm, std.container;
import core.bitop, core.time, core.memory;
import std.bitmanip;
import std.regex;
enum INF = long.... | D |
import std.stdio, std.string, std.conv;
void main() {
auto input = getStdin!(string[])()[0];
int[] num = input.split(" ").to!(int[]);
if (num[0] < num[1]) {
if (num[1] < num[2]) {
"Yes".writeln;
return;
}
}
"No".writeln;
}
T getStdin(T)() {
string[] cmd;
string line;
while ((line = chomp(st... | 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 std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto N = readln.chomp.to!int;
int[] AS, cs;
foreach (_; 0..N) AS ~= readln.chomp.to!int;
foreach (a; AS) {
if (cs.empty || cs[$-1] >= a) {
cs ~= a;
} else if ... | D |
import std.stdio;
import std.algorithm;
import std.array;
import std.conv;
import std.string;
import std.uni;
import std.range;
import std.algorithm;
void main()
{
auto n = readln.strip.to!int;
auto h = 0, t = 0;
while (n--)
{
auto k = readln.strip.split(" ");
if (k[0] == k[1])
... | D |
import std.stdio;
import core.stdc.stdio;
import core.memory;
import std.algorithm;
import std.typecons;
int TopBit(int a){
for(int i=18;i>=0;i--)
if((1<<i)&a) return i;
return -1;
}
alias Tuple!(int,"val",int,"idx") vi;
struct SparseTable{
vi[][] st;
void Initialize(vi[] d){
int h=TopBit(cast(int)d.length)+... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
enum P = 10L^^9+7;
void main()
{
auto S = readln.chomp.to!(char[]);
auto DP = new long[][](S.length, 13);
foreach (i, c; S) {
foreach (n; 0..10) {
if (c == '?' || n == c-'0') {
... | D |
import std.stdio;
import std.string;
import std.conv;
void main() {
auto n = to!int(readln.chomp());
auto a = to!int(readln.chomp());
writeln((n % 500) <= a ? "Yes" : "No");
}
| 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.string;
import std.array;
import std.algorithm;
import std.conv;
import std.range;
import std.functional;
import std.bigint;
import std.typecons;
void main(string[] args) {
readln;
string s = readln.chomp;
enum Transit {
StoS,
StoW,
WtoS,
WtoW,... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto S = readln.chomp;
auto T = readln.chomp;
int[27] ss, ts;
foreach (i; 0..S.length) {
int s = S[i] - 'a' + 1;
int t = T[i] - 'a' + 1;
if (ts[s] == 0 || ts[s] =... | 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.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(string s) {
... | D |
import std.stdio, std.range, std.conv, std.string, std.array, std.functional;
import std.algorithm.comparison, std.algorithm.iteration, std.algorithm.mutation, std.algorithm.searching, std.algorithm.setops, std.algorithm.sorting;
import std.container.binaryheap;
void main()
{
string S;
// scanf("%s", &S);
... | D |
import core.bitop, std.bitmanip;
import core.checkedint;
import std.algorithm, std.functional;
import std.array, std.container;
import std.bigint;
import std.conv;
import std.math, std.numeric;
import std.range, std.range.interfaces;
import std.stdio, std.string;
import std.typecons;
void main()
{
auto s = readln.... | D |
void main() {
int[] tmp = readln.split.to!(int[]);
int a = tmp[0], b = tmp[1], k = tmp[2];
int[] ans;
foreach (i; 0 .. k) {
if (a + i <= b) {
ans ~= a + i;
}
}
foreach_reverse (i; 0 .. k) {
if (!ans.canFind(b - i) && b - i >= a) {
ans ~= b - i;
... | 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 |
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;
int[] r;
int n;
foreach (int i; 1..5000) {
n += i;
r ~= i;
if (n >= N) break;
}
if (n > N) {
r[n-N-1] = 0;
}
... | 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;
import std.ascii;
void times(alias pred)(int n) {
foreach(i; 0..n) pred();
}
auto ... | D |
import std.stdio, std.string, std.conv, std.bigint, std.typecons, std.algorithm, std.array, std.math, std.range, std.functional;
void main() {
auto N = readln.chomp;
writeln(N.retro.retro.array == N.retro.array ? "Yes" : "No");
} | D |
void main()
{
int[] tmp = readln.split.to!(int[]);
int n = tmp[0], k = tmp[1];
writeln(k == 1 ? 0 : n - k);
}
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;
import std.typecons;
impo... | D |
import std.stdio, std.string, std.conv;
void main()
{
while(true)
{
int n=readln.chomp.to!int;
if(n==0) break;
if(n==1)
{
"deficient number".writeln;
continue;
}
int s=1;
for(int i=2; i*i <= n; ++i)
{
if(n/i*i==n... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array;
void main() {
int n, k;
scan(n, k);
auto dp = new long[](2*n + 1);
foreach (b ; 1 .. n + 1) {
if (b <= k) continue;
for (int r = b; r <= 2*n; r += b) {
dp[r - (b - k)]++;
dp[r]... | 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 n;
scan(n);
auto p = readln.split.to... | D |
void main(){
int[] ab = _scanln();
(ab[0]*ab[1]&1)?writeln("Odd"):writeln("Even");
}
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;
foreach(string elm; readln().chomp... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.container;
import std.array;
import std.math;
import std.range;
import std.typecons;
import std.ascii;
void main()
{
int n = readln.chomp.to!int;
int l = int.max;
int r = int.min;
foreach (v; readln.chomp.split.map!(to!int))... | 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.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 |
/+ dub.sdl:
name "B"
dependency "dcomp" version=">=0.6.0"
+/
import std.stdio, std.algorithm, std.range, std.conv;
// import dcomp.scanner;
// import dcomp.graph.dijkstra;
struct State {
int tm;
int col;
int opCmp(State r) {
if (tm < r.tm) return -1;
if (tm > r.tm) return 1;
... | 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;
// 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;
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 kt = readln.chomp.split.map!(to!int);
auto a = readln.chomp.split.map!(to!int).... | 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 |
import std.algorithm, std.array, std.container, std.range, std.bitmanip;
import std.numeric, std.math, std.bigint, std.random, core.bitop;
import std.string, std.conv, std.stdio, std.typecons;
void main()
{
auto s = readln.chomp.to!int;
writeln(s / (60 * 60), ":", s % (60 * 60) / 60, ":", s % 60);
} | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto A = readln.chomp.to!(char[]);
long N = A.length;
long[char] CNT;
foreach (a; A) {
if (a !in CNT) CNT[a] = 0;
++CNT[a];
}
long r = N * (N-1) / 2 + 1;
for... | 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 MOD =... | D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
import std.math;
void main()
{
auto n = readln.chomp.to!size_t;
auto r = 0;
loop: foreach (_; 0..n) {
auto a = readln.chomp.to!int;
if (a == 2) {
++r;
continue;
}
if (a % 2 == 0)
continue;
foreach (i; iota(... | 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;
int[] A, B;
int K;
void main() {
string[] input = readln.split;
A = input[0].... | D |
import std.stdio;
import std.string;
import std.conv;
void main(){
int n;
while(true){
int allLunch, allDinner, allMidnight;
int lunch, dinner, midnight;
n = readln().chomp().to!int();
if(n == 0){
break;
}
foreach(i; 0..n){
auto input = re... | D |
void main() {
int[] tmp = readln.split.to!(int[]);
int n = tmp[0], m = tmp[1], c = tmp[2];
int[] b = readln.split.to!(int[]);
int cnt;
foreach (i; 0 .. n) {
int[] a = readln.split.to!(int[]);
int src = c;
foreach (j; 0 .. m) {
src += a[j] * b[j];
}
... | D |
void main() {
int n = readln.chomp.to!int;
int k = readln.chomp.to!int;
int[] x = readln.split.to!(int[]);
int ans;
foreach (y; x) {
ans += 2 * min(y, k-y);
}
ans.writeln;
}
import std.stdio;
import std.string;
import std.array;
import std.conv;
import std.algorithm;
import std.rang... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto hn = readln.split.to!(int[]);
long H = hn[0];
auto N = hn[1];
long[] AS, BS;
foreach (_; 0..N) {
auto ab = readln.split.to!(long[]);
AS ~= ab[0];
BS ~= a... | D |
import core.stdc.stdio;
import std.algorithm;
import std.math;
import std.conv;
void main(){
int n,a,b;
scanf("%d%d%d",&n,&a,&b);
int[] cs = new int[n];
int kc;
scanf("%d",&kc);
for(int i=0;i<n;i++){
scanf("%d",&cs[i]);
}
cs.sort!"a>b";
double ans = kc.to!double/a;
int csum = kc;
for(int i=0;i<n;i++){
... | 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 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 MOD =... | 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 calc(string s) {
int toi(char c) { return c - '0'; }... | D |
import std.stdio,std.string,std.conv;
void main(){
int sum;
while( 1 ){
auto rd = readln().chomp();
if( !rd ){ break; }
sum=0;
int d = to!int(rd);
for( int i=d; i<600; i+=d ){
sum += i*i*d;
}
writeln(sum);
}
} | 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 |
void main() {
auto N = readAs!ulong;
auto k = 1;
ulong a = 0;
if(N % 2 == 1) {
writeln(0);
return;
}
N /= 2;
for(ulong i = 5; N / i >= 1; i *= 5) a += N / i;
a.writeln;
}
// ===================================
import std.stdio;
import std.string;
import std.functional;
import std.algorithm;
import std.ran... | 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!(long[]);
auto N = nm[0];
auto M = nm[1];
if (N > M) swap(N, M);
if (N == 1) {
writeln(M == 1 ? 1 : M-2);
} else if (N == 2) {
writeln(0... | D |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.