code stringlengths 4 1.01M | language stringclasses 2
values |
|---|---|
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.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.to!(int[]), a = rd[0], b = rd[1], c = a+b;
if (c >= 10) writeln("error");
else writeln(c);
}
| D |
void main(){
int[][] group = [[1,3,5,7,8,10,12],[4,6,9,11],[2]];
int[] xy = inln();
int x, y;
foreach(i,elm; group){
if(elm.count(xy[0]) != 0 && elm.count(xy[1]) != 0){
writeln("Yes");
return;
}
}
writeln("No");
}
import std.stdio, std.conv, std.algorithm, std.numeric, std.string, std.math, std.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 |
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!int;
if ((N/2)%2 == 1) {
writeln("NO");
continue;
}
int[] as, b... | D |
import std.stdio, std.string, std.algorithm, std.conv, std.array, std.math, std.container, std.range;
void main(){
readln.split.map!(to!int).reduce!"a-b+1".writeln;
}
| D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto ad = readln.split.to!(int[]);
auto A = ad[0];
auto B = ad[1];
auto C = ad[2];
auto D = ad[3];
for (;;) {
C -= B;
if (C <= 0) {
writeln("Yes");
... | 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.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 readA(T)(size_t n,ref T[]t){t=new T[](n);auto ... | D |
void main(){
int[] a = _scanln();
writeln( a.sum()>=22? "bust": "win" );
}
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().split()... | 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 |
void main()
{
long[] tmp = rdRow;
long n = tmp[0], m = tmp[1];
auto tree = new UnionFind(n);
foreach (i; 0 .. m)
{
long[] xyz = rdRow;
long x = xyz[0] - 1, y = xyz[1] - 1, z = xyz[2];
tree.unite(x, y);
}
long cnt;
foreach (i; 0 .. n)
{
if (i == tree.... | D |
import std.stdio;
import std.string;
void main()
{
char[] input = chomp(readln).dup;
int i = 0;
foreach(e; input) {
if(e == '+') {
i += 1;
} else {
i -= 1;
}
}
writeln(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 |
/+ dub.sdl:
name "A"
dependency "dcomp" version=">=0.6.0"
+/
import std.stdio, std.algorithm, std.range, std.conv;
import std.typecons;
import std.bigint;
// import dcomp.foundation, dcomp.scanner;
int main() {
auto sc = new Scanner(stdin);
long n, m;
sc.read(n, m);
long[][] a = new long[][](... | D |
import std.stdio, std.conv, std.string, std.array, std.math, std.regex, std.range, std.ascii;
import std.typecons, std.functional, std.traits;
import std.algorithm, std.container;
import core.stdc.stdlib;
long scanState()
{
auto s = scanElem!string;
if(s=="Male") return 0;
if(s=="Female") return 1;
ex... | D |
import std.stdio, std.conv, std.string;
void main() {
int [] a;
a = readln().chomp().split().to!(int[]);
if(a[0] <= 8 && a[1] <= 8)
writeln("Yay!");
else
writeln(":(");
}
| D |
import std.stdio, std.algorithm, std.range, std.conv, std.string, std.math;
import core.stdc.stdio;
// foreach, foreach_reverse, writeln
void main() {
int n;
scanf("%d", &n);
int[] x = new int[n];
foreach (i; 0..n) scanf("%d", &x[i]);
int[] y = x.dup;
y.sort;
int l = y[n/2-1], r = y[n/2];
foreach (i; 0..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, 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 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.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto M = readln.chomp.to!int;
long r, n = -1;
foreach (_; 0..M) {
auto dc = readln.split.to!(long[]);
auto d = dc[0];
auto c = dc[1];
if (n == -1) {
... | D |
void main() {
int[] tmp = readln.split.to!(int[]);
int d = tmp[0], n = tmp[1];
writeln(n != 100 ? 100 ^^ d * n : 100 ^^ d * (n + 1));
}
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;
... | D |
import std.stdio;
import std.string;
import std.algorithm;
void main() {
auto s = readln.chomp;
size_t begin, end = 1, cnt;
string cache = "";
while (end < s.length) {
if (cache != s[begin..end]) {
++cnt;
cache = s[begin..end];
begin = end;
end = end + 1;
}
else {
++end;
}
}
if (cache == 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.stdio;
void main() {
auto s = readln.split.map!(to!int);
auto K = s[0];
auto Q = s[1];
auto D = readln.split.map!(... | D |
// import chie template :) {{{
import std.stdio, std.algorithm, std.array, std.string, std.math, std.conv,
std.range, std.container, std.bigint, std.ascii, std.typecons, std.format;
// }}}
// 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;
int cmp(string a, strin... | D |
import std.stdio,std.conv, std.string;
void main(){
if(readln.chomp.to!int == 1){
writeln("Hello World");}
else{
auto a = readln.chomp.to!int;
auto b = readln.chomp.to!int;
writeln(a+b);}
} | D |
import std.algorithm, std.container, std.conv, std.math, std.range, std.typecons, std.stdio, std.string;
auto rdsp(){return readln.splitter;}
void pick(R,T)(ref R r,ref T t){t=r.front.to!T;r.popFront;}
void readV(T...)(ref T t){auto r=rdsp;foreach(ref v;t)pick(r,v);}
void readC(T...)(size_t n,ref T t){foreach(ref v;t)... | D |
import std.stdio, std.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.split.map!(to!int);
auto H = s[0];
auto W = s[1];
... | 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;
void main(){
int n = stdin.readln.chomp.to!int;
int money = 100_000;
while(n--){
money = cast(int)(money * 1.05);
if(money % 1_000)
money = money - (money % 1_000) + 1_000;
}
writeln(money);
} | 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 File _f;
void file_io(string fn) { _f = File(fn, "r"); }
static string[] s_rd;
T _RD(T = long)() ... | 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 a = readln.split.to!(... | 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.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.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 u = s[1] - 1;
auto v = s[2] - 1;
... | 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!(long[]);
const a = tmp[0], b = tmp[1], c = tmp[2], d = tmp[3];
writeln(abs(a-c) <= d || (abs(a-b) <= d && abs(b-c) <= d) ? "Yes" : "No");
}
| D |
import std.stdio;
import std.algorithm;
import std.string;
import std.range;
string[dchar] code1;
dchar[string] code2;
void main() {
code1[' '] = "101";
code1['\''] = "000000";
code1[','] = "000011";
code1['-'] = "10010001";
code1['.'] = "010001";
code1['?'] = "000001";
code1['A'] = "100101";
code1['B'] = "10... | D |
import std.stdio, std.string, std.conv;
import std.array, std.algorithm, std.range;
void main()
{
foreach(_;0..readln().chomp().to!int())
{
bool f=true;
auto a=int.min, b=a;
foreach(v;readln().split().map!(to!int))
if(v>a) a=v;
else if(v>b) b=v;
else{... | D |
void main(){
string[] st = _scanln!string();
writeln(st[1], st[0]);
}
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().split()){
... | D |
import std.stdio, std.string, std.conv, std.range, std.algorithm;
void main() {
auto S = readln.split.to!(int[]);
auto N = S[0], Ma = S[1], Mb = S[2];
auto data = new int[3][N];
foreach (i; 0..N) {
data[i] = readln.split.to!(int[]);
}
auto dp = new int[401][401][41];
foreach (i; 0..... | D |
import std.stdio, std.conv, std.functional, std.string;
import std.algorithm, std.array, std.container, std.typecons;
import std.numeric, std.math;
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_rd[0]; s_rd.popFront; re... | 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.conv;
import std.stdio;
import std.string;
void main ()
{
long [] a;
while ((a = readln.splitter.map !(to !(long)).array) != [])
{
auto n = readln.strip.to !(long);
foreach (i, c; a)
{
if (i > 0)
{
a[i] = min (a[i], a[i - 1] * 2);
}
}
writeln... | D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
auto n = readln.chomp.to!size_t;
auto s = readln.chomp;
auto isValid(bool[] sw)
{
foreach (i; 2..n)
sw[i] = sw[i-1] ^ (s[i-1] != 'o') ^ sw[i-2];
return ((sw[$-1] ^ (s[$-1] != 'o') ^ sw[$-2]) == sw[0] &&
... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
void main() {
int N = readln.chomp.to!(int);
int[] a = readln.chomp.split.to!(int[]);
int ans;
for (int i = 0; i < a.length - 1; i++) {
if (a[i] == a[i + 1]) {
ans += 1;
i += 1;
}
}
... | 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 File _f;
void file_io(string fn) { _f = File(fn, "r"); }
static string[] s_rd;
T _RD(T = long)() ... | 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 |
// 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.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto N = readln.chomp.to!long;
if (N == 2) {
writeln(1);
return;
}
int res;
long d;
for (d = 2; d^^2 < N; ++d) {
if (N % d == 1) {
auto dd = ... | D |
import std.stdio, std.string, std.array, std.conv;
void main() {
auto a = readln.chomp.split.to!(int[]);
writeln(a[0] < a[1] && a[1] < a[2] ? "Yes" : "No");
}
| D |
void main(){
import std.stdio, std.string, std.conv, std.algorithm;
int n, m; rd(n, m);
auto g=new int[][](n, 0);
foreach(_; 0..m){
int a, b; rd(a, b);
a--; b--;
g[a]~=b; g[b]~=a;
}
auto c=new int[](n);
fill(c, -1);
bool dfs(int i, int w, int p=-1){
c[i]=w;
bool ret=true;
for... | 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-1)*(b-1));
}
| 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[] stk;
foreach (_; 0..N) {
auto a = readln.chomp.to!int;
if (stk.empty || stk[$-1] >= a) {
stk ~=a;
continue;
... | 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 std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto kn = readln.split.to!(int[]);
auto K = kn[0];
auto N = kn[1];
auto as = readln.split.to!(int[]);
int max_a = K - as[$-1] + as[0];
foreach (i; 0..N-1) max_a = max(max_a, as[i... | 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!int;
auto b = readln.chomp.to!int;
auto c = readln.chomp.to!int;
auto d = readln.chomp.to!int;
auto e = readln.chomp.to!int;
auto k = readln.chomp.to!int... | D |
module app;
import core.bitop;
import std.algorithm;
import std.array;
import std.bigint;
import std.conv;
import std.math;
import std.stdio;
import std.string;
struct Input
{
ulong a,b;
}
void parseInput(T)(out Input input, T file)
{
with (file) with (input)
{
auto ab = readln().strip().split();
a = ab[0].t... | D |
import std.stdio;
import std.conv;
import std.array;
void main()
{
auto reader = readln.split;
int N = reader[0].to!int;
int D = reader[1].to!int;
int range = D * 2 + 1;
int ans = N / range;
if (N % range > 0){
ans++;
}
writeln(ans);
}
| D |
import core.bitop, std.algorithm, std.ascii, std.bigint, std.conv, std.math,
std.functional, std.numeric, std.range, std.stdio, std.string, std.random,
std.typecons, std.container;
// dfmt off
T lread(T = long)(){return readln.chomp.to!T();}
T[] aryread(T = long)(){return readln.split.to!(T[])();}
void scan(TL... | D |
import std.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;
void main() {
int A, B, C, D, P;
scanf("%d\n", &A);
scanf("%d\n", &B);
scanf("%d\n", &C);
scanf("%d\n", &D);
scanf("%d\n", &P);
writeln( min(A * P, B + D * max(0, P - C)) );
} | 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;
import std.concurrency;
void times(alias fun)(int n) {
// n.iota... | 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, q; rd(n, q);
auto tree=new SquareRootDecomposition(n);
while(q--){
auto args=readln.split.to!(int[]);
if(args[0]==0){
tree.add(args[1], args[2]+1, args[3]);
}else{
writeln(tree.rmin(args[1], args[2]+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.stdio;
immutable int INF = 1 << 29;
void main() {
auto s = readln.split.map!(to!int);
auto H = s[0];
auto W = s[1];
... | D |
void main()
{
long n = rdElem;
long[] a = rdRow;
long[] b = rdRow;
long monster;
foreach (i; 0 .. n)
{
if (b[i] >= a[i])
{
monster += a[i];
long diff = b[i] - a[i];
long next = min(a[i+1], diff);
a[i+1] -= next;
monster... | D |
import std.stdio;
import std.string, std.conv;
import std.array, std.algorithm;
import std.math;
void main() {
int[] weight = [200, 300, 500, 200 * 5, 300 * 4, 500 * 3];
int[] price = [380, 550, 850, 1520, 1870, 2244];
int[5000+1] dp = cast(int)1e9;
dp[0] = 0;
foreach(i; 0 .. 6) {
for(int j = weight[i]; ... | 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;
void scan(T...)(ref T a) {
string[] ss = readln.split;
foreach (i, t; T) a[i] = ss[i].to!t;
}
T read(T)() { return readln.chomp.to!T; }
T[] reads(T)() { return r... | D |
import core.bitop, std.algorithm, std.ascii, std.bigint, std.conv, std.math,
std.functional, std.numeric, std.range, std.stdio, std.string, std.random,
std.typecons, std.container, std.format;
// dfmt off
T lread(T = long)(){return readln.chomp.to!T();}
T[] aryread(T = long)(){return readln.split.to!(T[])();}
... | D |
import std.stdio;
import std.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;
import std.format;
void main()
{
auto l = readln.chomp;
if (l.equal(l.retro)) {
writeln = "Yes";
} else {
writeln =... | D |
import std.algorithm;
import std.array;
import std.bitmanip;
import std.conv;
import std.stdio;
import std.string;
import std.typecons;
T diff(T)(const ref T a, const ref T b) { return a > b ? a - b : b - a; }
void main() {
immutable ip = readln.split.to!(ulong[]);
immutable n = ip[0], k = ip[1];
ulong r... | D |
import std.stdio;
import std.algorithm;
import std.range;
import std.conv;
int f(int n, int m, int k) {
if (n < m) return max(0, n-k+1);
return f(n%m, m, k) + (n/m)*(m-k);
}
void main() {
string[] input = split(readln());
int n = to!int(input[0]);
int k = to!int(input[1]);
long ans = 0;
fo... | D |
import std.stdio, std.string, std.conv;
import std.typecons;
import std.algorithm, std.array, std.range, std.container;
import std.math;
void main() {
auto abc = readln.split.to!(int[]);
if (abc[0] > abc[1]) {
auto tmp = abc[0];
abc[0] = abc[1];
abc[1] = tmp;
}
writeln(abc[0] <... | D |
import std.stdio;
void main() {
while(true) {
uint[][][char] mapping;
char[3][3] field;
foreach (c; ['b', 'w', '+'])
mapping[c] = new uint[][](3, 3);
for(int i = 0; i < 3; i++)
for(int j = 0; j < 3; j++) {
scanf(j == 2 ? "%c\n" : "%c", &field[i][j]);
if (field[i][j] == '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;
void main() {
auto T = readln.chomp.to!int;
while (T--) solve;
}
void solve() {
auto N = readln.chomp.to!int;
... | D |
import std.stdio;
import std.conv;
import std.string;
import std.math;
import std.random;
import std.range;
import std.algorithm;
import std.functional;
import core.bitop;
import std.bigint;
import std.typecons;
import std.container;
void main()
{
auto input = readln.split.to!(int[]);
auto A = input[0], B = i... | D |
void main() {
int n = readln.chomp.to!int;
int cnt;
for (int i = 1; i <= n; i += 2) {
int divisor;
for (int j = 1; j * j <= i; j += 2) {
if (i % j == 0) {
++divisor;
if (j * j != i) ++divisor;
}
}
if (divisor == 8) ++cnt... | D |
void main(){
int a = _scan();
string s = readln().chomp();
if(a>=3200)s.writeln();
else writeln("red");
}
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(str... | 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;
immutable long MOD = 998244353;
void main() {
auto N = readln.chomp.to!int;
auto A = iota(N).map!(_ => readln.chom... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
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;
}
return y;
}
void init()
{
... | 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;
string s;
scan(N);
scan(s);
long r, g, b;... | 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 nq = readln.split.to!(int[]);
auto N = nq[0];
auto Q = nq[1];
long r = (N.to!long-2)^^2;
auto lms = new int[](N+1);
int min_w = N;
auto bms =... | 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.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 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.functional,
std.algorithm,
std.container,
std.typetuple,
std.typecons,
std.bigint,
std.string,
std.traits,
std.array,
std.range,
std.stdio,
std.conv;
void main()
{
auto s = readln.chomp.to!int;
writeln((s/3600).to!string ~ ":" ~ (s... | D |
import std.stdio, std.algorithm;
void main(){
foreach(char[] line; lines(stdin)){
foreach(i; 0..26){
foreach(ref c; line){
if('a' <= c && c <= 'z') c = c == 'z' ? 'a' : cast(char)(c + 1);
}
if(line.countUntil("the") + 1 || line.countUntil("this") + 1 || line.countUntil("th... | D |
import std.stdio,
std.array,
std.conv,
std.algorithm;
void main() {
string s;
while((s=readln()).length != 0) {
string[] input = split(s);
int pos = 1;
int carry = 0;
int lena = to!int(input[0].length);
int lenb = to!int(input[1].length);
while(true) {
int a = len... | 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 x; readV(x);
writeln(x == 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.map!(x=>(x-'0').to!int).array;
auto op = ['-', ' ', '+'];
... | D |
import std.functional,
std.algorithm,
std.container,
std.typetuple,
std.typecons,
std.bigint,
std.string,
std.traits,
std.array,
std.range,
std.stdio,
std.conv,
std.format,
std.math;
void main()
{
auto n = readln.chomp.to!int;
... | D |
import std.stdio;
import std.conv;
import std.string;
import std.typecons;
import std.algorithm;
import std.array;
void main()
{
string input;
int num;
int[] train;
while ((input = readln().chomp()).length != 0) {
num = input.to!int();
if (num == 0) {
writeln(train[$ - 1]);
train.length--;... | D |
import std.stdio;
import std.algorithm;
import std.string;
import std.functional;
import std.array;
import std.conv;
import std.math;
import std.typecons;
import std.regex;
import std.range;
void main(){
while(true){
auto a = readln();
if(stdin.eof()) break;
if(a.chomp() == "0") break;
int n =a.chomp().to!int... | D |
import std.stdio;
import std.algorithm;
import std.string;
import std.container;
import std.typecons;
void log(A...)(A arg) {
stderr.writeln(arg);
}
void main() {
long N, K; scanf("%d %d\n", &N, &K);
long f(long n) {
return n + 1 + (n / (K - 1));
}
long x = 0;
for (long n = 1; n < N; n... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array, std.typecons, std.container;
import std.math, std.numeric, core.bitop;
enum inf = 1_001_001_001;
enum inf6 = 1_001_001_001_001_001_001L;
enum mod = 1_000_000_007L;
void main() {
char c;
scan(c);
writeln((c + 1).to!char);... | 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, std.conv, std.range, std.stdio, std.string;
void main()
{
auto n = readln.chomp.to!size_t;
auto ans = 0;
foreach (_; 0..n) {
auto rd = readln.split.to!(int[]), l = rd[0], r = rd[1];
ans += r - l + 1;
}
writeln(ans);
}
| D |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.