code stringlengths 4 1.01M | language stringclasses 2
values |
|---|---|
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 n... | 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;
void main()
{
int n = 0;
scanf("%d", &n);
writeln(n^^3);
} | 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 as = readln.chomp.split.map!(to!int);
int res ... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array;
void main() {
int a, b, c;
scan(a, b, c);
writeln(a <= c && c <= b ? "Yes" : "No");
}
void scan(T...)(ref T args) {
import std.stdio : readln;
import std.algorithm : splitter;
import std.conv : to;
impor... | D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
auto memo = new int[](51);
foreach (i; 0..10)
foreach (j; 0..10)
++memo[i + j];
string line;
while ((line = readln) !is null) {
auto n = line.chomp.to!int;
auto r = 0;
foreach (i; 0..n+1)
r += memo[i] *... | 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 |
/+ dub.sdl:
name "A"
dependency "dcomp" version=">=0.6.0"
+/
import std.stdio, std.algorithm, std.range, std.conv;
// import dcomp.foundation, dcomp.scanner;
int main() {
auto sc = new Scanner(stdin);
long a, b, c;
sc.read(a, b, c);
int co = 0;
while (co < 10^^7) {
if (a%2 || b%2 |... | 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() {
int s, w;
scan(s, w);
auto safe = s > w;
yes(safe, "saf... | 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 a = read.... | 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();
foreach (_; 0 .. s.length)
{
write('x');
}
}
void scan(L...)(ref L A)
{
auto l = readln.split;
... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric, std.container, std.range;
void main()
{
writeln(readln.chomp.to!int >= 30 ? "Yes" : "No");
} | D |
import std.stdio,std.string,std.conv;
int main()
{
string s = readln.chomp;
char[] ans;
ans.length = s.length;
foreach(i;0..s.length)
{
if(s[i] == 'a' && s[i+1] == 'p' &&s[i+2] == 'p' && s[i+3] == 'l' && s[i+4] == 'e')
{
ans[i] = 'p';
ans[i+1] = 'e';
ans[i+2] = 'a';
ans[i+3] = 'c';
ans[i+4] = ... | 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() {
int K;
scan(K);
long ans;
foreach (i ; 1 .. K + 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.stdio, std.string, std.conv;
void main() {
while (true) {
string str = readln.chomp;
if (str == "0") break;
int sum = 0;
foreach (x; str) {
sum += x - '0';
}
sum.writeln;
}
}
| 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;
foreach (_; 0..T) {
auto N = readln.chomp.to!long;
long x = 1;
foreach (k; 1..34) {
x += 1L<<k;
if (N%x == 0) {
... | D |
void main(){
int n = inelm();
(n/3).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[] ln;
foreach(string elm; r... | D |
import std.stdio, std.string, std.range, std.conv, std.array, std.algorithm, std.math, std.typecons, std.functional;
void main() {
readln.split.to!(int[]).pipe!(a => a[0] - a[1] + 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;
enum MAX = 1_000_100;
ulong MOD = 1_000_000_007... | 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;
void main()
{
auto S = readln.chomp.to!(wchar[]);
auto K = readln.chomp;
int il;
for (int i; i < S.length; ++i) {
if (S[i] == '1') {
++il;
} else break;
}
if (il == S.length) {... | 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.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.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;
int[] dist, prev;
void main() {
int a, b;
scan(a,... | 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;
import std.algorithm;
import std.array;
import std.conv;
import std.string;
import std.uni;
void main()
{
int[dchar] b;
for (dchar c = 'a'; c <= 'z'; c++)
b[c] = 0;
while (!stdin.eof)
{
auto a = readln.strip;
foreach (i; a)
{
if (i.isAlpha)
... | D |
import std.stdio,std.string,std.conv,std.algorithm,std.array;
void main()
{
bool[501][501] M;
while(true)
{
int n, m;
string line=readln.chomp;
try{n=line.to!int;}catch(Exception e){ throw new Exception(line);}
try{m=readln.chomp.to!int;}catch(Exception e){ throw new Except... | 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;
int n;
int[] a;
int[][][] memo;
bool[][] done;
int[] dfs(int turn, int 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;
import std.ascii;
void main()
{
auto n = readln.chomp.to!int;
auto res = int.max;
foreach (a; 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.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto H = readln.chomp.to!int;
auto W = readln.chomp.to!int;
auto N = readln.chomp.to!int;
writeln((N + max(H, W) - 1) / max(H, W));
} | D |
import core.bitop;
import std.algorithm;
import std.ascii;
import std.bigint;
import std.conv;
import std.functional;
import std.format;
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 ... | D |
import std.stdio, std.string, std.conv, std.ascii;
void main() {
auto d = stdin.readln.dup;
foreach (c; d) {
if (c.isLower) c -= 32;
else if (c.isUpper) c+= 32;
c.write;
}
} | D |
void main()
{
string s = rdStr;
long len = s.length;
foreach (i; 0 .. len-1)
{
if (s[i] == s[i+1])
{
writeln(i + 1, " ", i + 2);
return;
}
if (i == len - 2) break;
if (s[i] == s[i+2])
{
writeln(i + 1, " ", i + 3);
... | 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.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 s = readln.chomp;
... | D |
import std.stdio;
import std.string;
import std.conv;
int main()
{
int MAX = 1000000;
int[] prime;
prime.length = MAX;
prime[0] = prime[1] = 0;
foreach(int i;2..MAX)
{
prime[i] = 1;
}
foreach(int i;2..1001)
{
if(prime[i])
{
for(int j=2*i;j<MAX;j += i)
{
prime[j] = 0;
}
}
}
string s;
w... | D |
import std.algorithm, std.container, std.conv, std.math, std.range, std.typecons, std.stdio, std.string;
void readV(T...)(ref T t){auto r=readln.splitter;foreach(ref v;t){v=r.front.to!(typeof(v));r.popFront;}}
void main()
{
string n; readV(n);
writeln(n.canFind('9') ? "Yes" : "No");
}
| 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 abcd = readln.split.to!(long[]);
auto a = abcd[0];
auto b = abcd[1];
auto c = abcd[2];
auto d = abcd[3];
writeln(max(a*c, a*d, b*c, b*d));
} | 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);
// writeln(s[0 .. (s.length - 1) / 2]);
// writeln(s[((s.length + 3) / 2) - 1 .. $]);
if (s[... | D |
import std.stdio,
std.string;
void main() {
long[dchar] table = ['I' : 1, 'V' : 5, 'X' : 10, 'L' : 50, 'C' : 100, 'D' : 500, 'M' : 1000];
foreach(input; stdin.byLine) {
dchar current = 'I';
long sum = 0;
foreach_reverse(dchar c; input) {
if(table[c] < table[current]) ... | 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()
{
// writeln(gcd(2, 3));
// writeln((2 * 3) / gcd(2, 3));
auto... | 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, std.conv, std.range, std.stdio, std.string;
void main()
{
auto rd = readln.split.map!(to!int), a = rd[0], b = rd[1], c = rd[2];
writeln(a < b && b < c ? "Yes" : "No");
} | D |
import std.stdio;
import std.algorithm;
import core.stdc.stdio;
int[] ds;
int[] as;
int[][] dim2arr(int w,int h){
int[] buf = new int[w*h];
int[][] ret = new int[][h];
for(int i=0;i<h;i++){
ret[i] = buf[i*w..(i+1)*w];
}
return ret;
}
int factorial(int a){
if(a <= 1)
return 1;
else
return a * (a-1).facto... | D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void readV(T...)(ref T t){auto r=readln.splitter;foreach(ref v;t){v=r.front.to!(typeof(v));r.popFront;}}
void readA(T)(size_t n,ref T t){t=new T(n);auto r=readln.splitter;foreach(ref v;t){v=r.front.to!(ElementType!T);r.popFront;}}
void readM(T...)(size_... | 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);
string t; re... | D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
auto s = readln.chomp, n = s.length;
foreach_reverse(i; 1..n/2) {
if (s[0..i] == s[i..i*2]) {
writeln(i*2);
break;
}
}
}
| D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric, std.container, std.range;
enum P = 10L^^9+7;
void main()
{
auto S = readln.chomp.to!int;
auto DP = new long[](S+1);
DP[] = -1;
long solve(int s) {
if (s == 0) return 1;
if (s < 3... | 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()
{
long a, b, c, k;
scan(a, b, c, k);
if (k % 2 == 0)
{
... | D |
module app;
import core.bitop;
import std.algorithm;
import std.array;
import std.bigint;
import std.conv;
import std.stdio;
import std.string;
struct Input
{
string s;
}
void parseInput(T)(out Input input, T file)
{
with (file) with (input)
{
s = readln().strip();
}
}
auto main2(Input* input)... | D |
import std.stdio, std.string, std.array, std.conv, std.algorithm;
void main() {
string[] mark = ["S", "H", "C", "D"];
bool[] cards = new bool[52];
int n = readln.chomp.to!int;
foreach (i; 0 .. n) {
string[] tmp = readln.chomp.split;
cards[mark.countUntil(tmp[0])*13+tmp[1].to!int-1] = tr... | 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 |
// 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;
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 s = readln.chomp;
auto t = readln.chomp;
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 n;
scan(n);
writeln(n / 100 == n % 10 ? "Yes" : "No");
}
void scan(T...)(ref T args) {
string[] line = readln.split;
foreach (ref arg; args) {... | 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() {
auto s = readln.split.map!(to!int);
auto N = s[0];
auto K = s[1];
long ans = 0;
if (K == 0) {
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, std.conv, std.string, std.range, std.array, std.algorithm;
import std.bigint;
void main()
{
while (true){
ulong n = readln().chomp().to!ulong;
if (n == 0) break;
ulong pat = shinobu(n);
pat /= 10;
if (pat % 10 != 0){
pat++;
}
writeln(pat / 365 + 1);
}
}
ulong s... | D |
void main() {
string o = readln.chomp;
string e = readln.chomp;
string password;
foreach (i; 0 .. e.length) {
password ~= o[i];
password ~= e[i];
}
if (o.length != e.length) password ~= o[$-1];
password.writeln;
}
import std.stdio;
import std.string;
import std.array;
import... | 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 = "%.15f";
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.string;
import std.algorithm, std.array, std.container, std.typecons;
import std.numeric, std.math;
import core.bitop;
T RD(T = string)() { static string[] ss; while(!ss.length) ss = readln.chomp.split; string res = ss[0]; ss.popFront; return res.to!T; }
string RDR()() { return readln.c... | D |
/+ dub.sdl:
name "B"
dependency "dcomp" version=">=0.6.0"
+/
import std.stdio, std.algorithm, std.range, std.conv;
// import dcomp.foundation, dcomp.scanner;
// import dcomp.functional;
int n;
int[][] g;
int[] gsm;
int main() {
auto sc = new Scanner(stdin);
int m;
sc.read(n, m);
calc.init(... | 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.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.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.container;
import std.conv;
import std.range;
import std.stdio;
import std.string;
void main() {
int n = readln.chomp.to!int;
bool[string] dic;
for (int i = 0; i < n; i++) {
auto input = readln.chomp.split;
auto key = input[1];
if (input[0] == "i... | 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;
import std.conv;
import std.algorithm;
import std.string;
import std.file;
int main() {
int[] hs;
string l;
while((l = readln()).length >= 2){
float a, b, c, d, e, f;
a = to!int(l.split()[0]), b = to!int(l.split()[1]), c = to!int(l.split()[2]);... | D |
import std.stdio, std.conv, std.math, std.string, std.range, std.array,
std.algorithm;
long s(long n)
{
long s;
while(n > 0)
{
s += n % 10;
n /= 10;
}
return s;
}
void main(){
auto K = readln().strip().to!int();
long step = 1;
long befoki = 0;
long i = 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, std.bitmanip;
void main() {
auto S = readln.chomp;
auto N = S.length.to!int;
string A = "";
string B = "";
foreach (i; ... | D |
// Cheese-Cracker: cheese-cracker.github.io
void theCode(){
ll l = scan;
ll r = scan;
if(l == r){
writeln(0);
return;
}
ll d = r/2 + 1;
d = max(l, d);
writeln(r % d);
}
void main(){
long tests = scan; // Toggle!
while(tests--) theCode();
}
/********* That's... | D |
import std.stdio, std.algorithm, std.conv, std.string;
void main(){
while(true){
ulong[int] sales;
int[] order;
int data=readln.chomp.to!int;
if(data==0)break;
foreach(_;0..data){
auto inp=readln.split.map!(to!int);
int id=inp[0],sale=inp[1],num=inp[2... | 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.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 |
import std.stdio, std.conv, std.string, std.math, std.algorithm;
void main(){
auto ip = readln.chomp;
if(ip[0] == 'H'){
if(ip[2] == 'H') 'H'.writeln;
else if(ip[2] == 'D') 'D'.writeln;
} else if(ip[0] == 'D') {
if(ip[2] == 'H') 'D'.writeln;
else if(ip[2] == 'D') 'H'.writeln;
}
}
| 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 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;
import std.conv... | 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[] lreads(T = long)(long n){return generate(()=>readln.c... | D |
import std.stdio, std.string, std.conv, std.algorithm;
import std.range, std.array, std.math, std.typecons, std.functional;
void main() {
char[] s = readln.chomp.to!(char[]);
int n = s.length.to!int;
bool[] app = new bool[](26);
foreach (ch ; s) {
app[ch - 'a'] = 1;
}
debug {
... | 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;
T lread(T = long)()
{
return readln.chomp.to!T();
}
T[] aryread(T = long)()
{
ret... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array;
void main() {
int q;
scan(q);
while (q--) {
long ai, bi;
scan(ai, bi);
solve(ai, bi);
}
}
void solve(long ai, long bi) {
long l = sqrt(ai*bi);
debug {
writefln("l:%s", l);
... | 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 w = readln.chomp.to!int;
string x = "";
foreach (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() {
long n;
scan(n);
int k;
while (10L^^(k+1)-1 <= 2*n - 1) k++;
debug {
writeln(k);
}
long ans;
foreach (d ; 1 .. 10... | D |
import std.stdio,std.string,std.conv,std.array,std.algorithm;
void main(){
int[string] mark;
mark["S"]=0;
mark["H"]=1;
mark["C"]=2;
mark["D"]=3;
bool[13][4] card;
readln();
for(;;){
auto rcs = readln().chomp().split();
if(!rcs){break;}
card[mark[rcs[0]]][to!int(rcs[1])-1]=true;
}
foreach(m;0..4){foreach... | 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() {
int sum = 0;
foreach(i; 0..10) sum += readln.chomp.to!int;
... | 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;
bool[string] res;
foreach (_; 0..N) {
res[readln.chomp] = true;
}
writeln(res.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;
void main() {
auto N = readln.chomp.to!int;
auto S = readln.chomp;
auto cnt = new long[string][](N+1);
long an... | 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);
writeln("ABC... | 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 n, m; readV(n, m);
auto g =... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
void main() {
readln;
auto r = readln.chomp.split(" ").map!(to!uint).all!((a) => (a % 2 == 1) || (a % 3 == 0) || (a % 5 == 0));
if (r) {
writeln("APPROVED");
} else {
writeln("DENIED");
}
}
| D |
import std.stdio;
import std.conv;
import std.algorithm;
import std.range;
import std.string;
import std.typecons;
import std.math;
import std.range;
void main()
{
auto count = readln().strip.to!int;
auto m = new int[(count + 1) * (count + 1)].chunks(count + 1);
auto p = new int[count + 1];
foreach (i; ... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto N = readln.chomp;
auto DP = new long[][](N.length, 2);
foreach (ref dp; DP) dp[] = -1;
long solve(int i, bool k) {
if (i == N.length) return k == 0 ? 0 : long.max/3;
... | 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 ds = readln.chomp.split.to!(int[]);
auto m = r... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
enum as = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51];
void main()
{
writeln(as[readln.chomp.to!int-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;
void main() {
int n;
scan(n);
void solve(int i, int shu, string s) {
... | D |
import std.algorithm;
import std.array;
import std.stdio;
import std.string;
void main() {
string[] blocks;
loop:
for (;;) {
auto command = readln.strip.split;
auto operation = command[0];
final switch (operation) {
case "push":
auto block = command[1];
blocks ~= block;
break;
case "pop":
aut... | 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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.