code stringlengths 4 1.01M | language stringclasses 2
values |
|---|---|
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto ab = readln.split.to!(long[]);
auto A = ab[0];
auto B = ab[1];
if (B < A) swap(A, B);
long s = 1, r = 1;
long[] rest;
void solve(long x) {
if (A%x != 0) return;... | D |
import std.stdio, std.conv, std.string, std.range, std.algorithm, std.array,
std.functional, std.container, std.typecons;
int M = 1000000007;
int[] tbl = [ 1, 10, 9, 12, 3, 4 ];
void main() {
string S = readln.chomp;
auto N = S.length;
ulong[] items = new ulong[0];
int baseMod13 = 0;
foreach(i; 0..N) {
... | D |
import std.stdio;
import std.string;
import std.conv;
import std.range;
import std.array;
import std.algorithm;
void main(){
auto a=readln.chomp.to!int;
auto b=readln.chomp.to!int;
if(a%500<=b)writeln("Yes");
else writeln("No");
} | 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(){
int q = readln().chomp().to!int;
for(int i=0;i<q;i++){
int c,a,n;
int[] s = readln().split().to!(int[]);
... | D |
import std.stdio;
import std.conv;
import std.algorithm;
import std.range;
import std.string;
import std.typecons;
import std.math;
import std.random;
import std.range;
import std.functional;
import std.container;
class bt(T)
{
t!T root;
bool containsKey(T key)
{
return !!find(key);
}
void d... | 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 main()
{
string s; readV(s);
auto n = s.l... | D |
import std.stdio;
void main() {
int m1, m2, d1, d2;
scanf("%d %d\n%d %d\n", &m1, &d1, &m2, &d2);
if (m1 == m2) {
0.write;
}
else {
1.write;
}
}
| 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 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;
T lread(T = long)()
{
return readln.chomp.to!T();
}
T[] aryread(T = long)()
{
return readln.split.to... | D |
void main() {
auto k = ri;
auto s = rs;
if (s.length <= k) writeln(s);
else writeln(s[0..k] ~ "...");
}
// ===================================
import std.stdio;
import std.string;
import std.functional;
import std.algorithm;
import std.range;
import std.traits;
import std.math;
import std.container;
import st... | D |
void main()
{
string s = rdStr;
if (s[0] == '>') s = '<' ~ s;
if (s[$-1] == '<') s ~= '>';
auto g = s.group.array;
long result;
for (long i = 0; i < g.length; i += 2)
{
long x = g[i][1], y = g[i+1][1];
if (x < y)
{
result += x * (x - 1) / 2;
r... | 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.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||a+c==b||b+c==a)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;
import std.numeric;
void main()
{
auto n = readln.chomp.to!int;
long[char] cnt;
foreach (_; 0..... | D |
import std.stdio;
import std.algorithm;
import std.array;
import std.conv;
import std.datetime;
import std.numeric;
import std.math;
import std.string;
string my_readln() { return chomp(readln()); }
void main()
{//try{
//auto tokens = split(my_readln());
//auto N = to!ulong(tokens[0]);
//auto W = to!ulong(tokens[1... | 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],D=F[3];
if(A+B<C+D)writeln("Right");
else if(A+B>C+D)writeln("Left");
else writeln("Balanced");
} | D |
import std.stdio;
import std.array;
import std.conv;
void main() {
string[] input = split(readln());
int a=to!int(input[0]);
int b=to!int(input[1]);
if((a*b)%2==0) {
writeln("Even");
}else {
writeln("Odd");
}
}
| 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) {
foreach(i... | D |
void main(){
import std.stdio, std.string, std.conv, std.algorithm;
const mx=1_000_00+5;
auto isPrime=new bool[](mx);
auto sub=new int[](mx);
isPrime[2]=true;
for(int i=3; i<=1_000_00; i+=2){
for(int j=3; j*j<=i; j+=2){
if(i%j==0) goto hell;
}
isPrime[i]=true;
if(isPrime[(i+1)/2]) su... | 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;
void main(){
int k, t;
{
int[] tmp = readln.chomp.split.map!(to!int).array;
k = tmp[0], t = tmp[1];
}
int[] as = readln.chomp.split.map!(to!int).array;
int ama... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons;
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;
writeln(min(A, B) + min(C, D));
} | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
int[2][6] pt;
void main()
{
foreach (i; 0..3) {
auto ab = readln.split.to!(int[]);
pt[i] = [ab[0], ab[1]];
pt[3+i] = [ab[1], ab[0]];
}
foreach (i, a; pt) {
foreach (j, b;... | D |
// dfmt off
T lread(T=long)(){return readln.chomp.to!T;}T[] lreads(T=long)(long n){return iota(n).map!((_)=>lread!T).array;}
T[] aryread(T=long)(){return readln.split.to!(T[]);}void arywrite(T)(T a){a.map!text.join(' ').writeln;}
void scan(L...)(ref L A){auto l=readln.split;foreach(i,T;L){A[i]=l[i].to!T;}}alias sread=(... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array, std.typecons, std.container;
import std.math, std.numeric, core.bitop;
enum inf = 1L << 60;
void main() {
int n;
scan(n);
auto a = readln.split.to!(int[]);
auto dp = new long[][](n + 1, n + 1);
fillAll(dp, -inf); ... | D |
import std.stdio, std.conv, std.string, std.algorithm,
std.math, std.array, std.container, std.typecons;
void main() {
readln;
string s = readln.chomp;
int count=0;
for(int i=0; i<s.length-2; i++) {
if(s[i]=='A'&&s[i+1]=='B'&&s[i+2]=='C') count++;
}
writeln(count);
}
| D |
import std.stdio;
import std.range;
import std.array;
import std.string;
import std.conv;
import std.typecons;
import std.algorithm;
import std.container;
import std.typecons;
import std.random;
import std.csv;
import std.regex;
import std.math;
import core.time;
import std.ascii;
import std.digest.sha;
import std.outb... | 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.split.to!(int[]);
auto f = true;
if (s[0] % s[1]) writel... | D |
void main()
{
long n = readln.chomp.to!long;
long result;
foreach (i; 1 .. 500001)
{
int x = 108 * i / 100;
if (x == n)
{
result = i;
break;
}
}
if (result > 0)
{
result.writeln;
}
else
{
":(".writeln;
... | 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;
double offset(int lr, int rr) {
return sqrt((lr+rr)^^2.-(lr-rr)^^2);
}
void main() {
while(!stdin.eof()) {
... | 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.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 k, int[] ... | D |
/+ dub.sdl:
name "C"
dependency "dunkelheit" version="1.0.1"
+/
import std.stdio, std.algorithm, std.range, std.conv;
// import dkh.foundation, dkh.scanner;
int main() {
Scanner sc = new Scanner(stdin);
scope(exit) assert(!sc.hasNext);
int n;
sc.read(n);
int sm, _a, b_, ba;
foreac... | 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;
struct E{
long[] parentes;
long h=-1;
}
E[] list;
long calc(long i)
{
if(list[i].parentes.empty){
list[i].parentes = [... | 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 |
// dfmt off
T lread(T=long)(){return readln.chomp.to!T;}T[] lreads(T=long)(long n){return iota(n).map!((_)=>lread!T).array;}
T[] aryread(T=long)(){return readln.split.to!(T[]);}void arywrite(T)(T a){a.map!text.join(' ').writeln;}
void scan(L...)(ref L A){auto l=readln.split;foreach(i,T;L){A[i]=l[i].to!T;}}alias sread=(... | D |
import std.stdio, std.string, std.range, std.algorithm;
import std.conv;
void main() {
int n = readln.strip.to!int;if (n == 3 || n == 5 || n == 7) writeln("YES"); else writeln("NO");
} | D |
/+ dub.sdl:
name "D"
dependency "dcomp" version=">=0.7.4"
+/
import std.stdio, std.algorithm, std.range, std.conv;
// import dcomp.foundation, dcomp.scanner;
// import dcomp.graph.dijkstra;
struct E {
int to;
int dist;
}
int main() {
Scanner sc = new Scanner(stdin);
int k;
sc.read(k);
... | D |
import std.stdio,
std.string,
std.conv;
string selectOp(int f) {
return (f ? "+" : "-");
}
void main() {
string s = readln.chomp;
int[] a;
for (int i = 0; i < s.length; i++) {
a ~= cast(char)s[i] - '0';
}
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
for (int k... | 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 |
import std.stdio;
import std.conv;
import std.algorithm;
import std.range;
import std.string;
import std.math;
import std.format;
void main() {
int[] q;
foreach (string line; stdin.lines) {
int n = line.chomp.to!int;
if (n == 0) {
q.back.writeln;
q.popBack;
} else {
q ~= n;
}
... | D |
import std.algorithm;
import std.conv;
import std.range;
import std.stdio;
import std.string;
void main()
{
auto ab = readln.split.to!( int[] );
writeln( solve( ab[ 0 ], ab[ 1 ] ) );
}
auto solve( in int a, in int b )
{
auto d = b - a;
auto h = iota( 1, d ).sum;
return h - a;
}
unittest
{
assert( solve( 8, ... | 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 S = readln.split[0];
int result = 10000;
foreach (i; 0 .. S.length-2) { result = min( (S[i .. i+3].to!int - 753).abs, result); }
result.writeln;
}
| D |
import std.stdio, std.conv, std.functional, std.string;
import std.algorithm, std.array, std.container, std.range, std.typecons;
import std.bigint, std.numeric, std.math, std.random;
import core.bitop;
string FMT_F = "%.10f";
static File _f;
void file_io(string fn) { _f = File(fn, "r"); }
static string[] s_rd;
T _RD(... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons;
void main()
{
foreach (i; 0..3) write(readln.chomp.to!(wchar[])[i]);
writeln("");
} | D |
import std;
long calc(long a, long b, long n) {
long x = min(b-1, n);
return a * x / b;
}
void main() {
long a, b, n; scan(a, b, n);
writeln(calc(a, b, n));
}
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; ... | 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.range;
import std.stdio;
import std.typecons;
import std.traits;
import std.array;
struct Input
{
T next(T)()
{
import std.conv;
return to!T(nextWord);
}
string nextWord()
{
if (_nextWords.empty)
_nextWords.insertFront(readln().split);
string word = _nextWords... | 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() {
int n;
scan(n);
auto c = new int[](n);
auto s = new int[](n);
auto f = new int[](n);
foreach (i ; 0 .. n-1) {
int ci, si, fi... | 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 ts = readln.split.to!(long[]);
auto I = ts[0];
auto O = ts[1];
auto J = ts[3];
auto L = ts[4];
auto K = O + I/2*2 + J/2*2 + L/2*2;
auto r = I%... | D |
import std.stdio, std.string, std.conv, std.range, std.array, std.algorithm;
import std.uni, std.math, std.container, std.typecons, std.typetuple;
import core.bitop, std.datetime;
immutable long mod = 10^^9 + 7;
immutable int inf = mod;
void main(){
int n = readln.chomp.to!int;
auto a = new int[](n + 1);
... | D |
import std.stdio, std.string, std.algorithm, std.array, std.conv;
void main() {
for (int i = 0; i < 1000; i++) {
"Hello World".writeln;
}
} | 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() {
int n... | 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 r, g, b; readV(r, g, b);
wri... | 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 a = readln.chomp.split.to!(int[]);
auto b = re... | 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!int;
const hs = readln.split.to!(int[]);
N.iota.filter!(i => reduce!max(0, hs[0..i]) <= hs[i]).walkLength.writeln;
}
| D |
// tested by Hightail - https://github.com/dj3500/hightail
import std.stdio, std.string, std.conv, std.algorithm;
import std.range, std.array, std.math, std.typecons, std.container, core.bitop;
import std.datetime, std.bigint;
void main() {
string n;
scan(n);
writeln("ABC" ~ n);
}
void scan(T...)(ref ... | D |
import std.stdio, std.conv,std.string;
void main()
{
while(true)
{
int sum=readln.chomp.to!int;
if(sum==0)break;
foreach(unused;0..9)
{
sum-=readln.chomp.to!int;
}
sum.writeln;
}
} | 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 |
void main()
{
long N = rdElem;
foreach (h; 1 .. 3501)
{
foreach (n; 1 .. 3501)
{
long numer = h * n * N;
long dinom = 4 * h * n - (h + n) * N;
if (dinom <= 0) continue;
long w = numer / dinom, rem = numer % dinom;
if (w > 0 && rem... | 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 core.bitop;
import std.algorithm;
import std.ascii;
import std.bigint;
import std.conv;
import std.functional;
import std.math;
import std.numeric;
import std.range;
import std.stdio;
import std.string;
import std.random;
import std.typecons;
alias sread = () => readln.chomp();
alias Point2 = Tuple!(long, "y", ... | D |
import std.algorithm;
import std.stdio;
import std.string;
void main()
{
auto s = readln.strip;
writeln( solve( s ) );
}
int solve( in string s )
{
return 700 + s.map!( a => ( a == 'o' ) ? 100 : 0 ).sum;
}
unittest
{
assert( solve( "oxo" ) == 900 );
assert( solve( "ooo" ) == 1000 );
assert( solve( "xxx" ) == ... | 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;
void main()
{
auto A = scanElem;
auto B = scanElem;
auto T = scanElem;
writeln((T/A)*B);
}
class... | D |
void main() {
auto arr = [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];
writeln(arr[ri-1]);
}
// ===================================
import std.stdio;
import std.string;
import std.functional;
import std.algorithm;
import std.range;
import std.traits;
import std... | D |
import std.stdio, std.string, std.algorithm, std.array, std.conv;
int mex(int[] arr)
{
if (arr.maxElement == 2)
return 2;
else if (arr.minElement == arr.maxElement)
return 1 - arr.minElement;
else
return 2;
}
void main()
{
int t;
scanf("%d", &t);
getchar();
foreach(j; 0..t){
int str_l;
scan... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.math;
void main() {
auto N = readln.chomp.to!int;
bool[int] d;
foreach(_; 0..N) {
d[readln.chomp.to!int] = true;
}
writeln(d.length);
}
| D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array;
void main() {
int x, a, b;
scan(x, a, b);
if (b - a <= 0) {
writeln("delicious");
}
else if (b - a <= x) {
writeln("safe");
}
else {
writeln("dangerous");
}
}
void scan(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;
// 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, std.conv, std.array, std.algorithm, std.string, std.math;
void main() {
uint count = to!uint(readln().chomp);
for (uint i = 0; i < count; ++i) {
double[] t = map!(to!double)(readln().chomp.split).array;
double[] a = [t[0]-t[2], t[1]-t[3]];
double[] b = [t[4]-t[6], t[5]... | D |
import std.stdio;
import std.string;
import std.conv;
import std.range;
import std.algorithm;
void main() {
int n = readln.chomp.to!int;
int minv = readln.chomp.to!int;
int maxv = -1_000_000_000;
foreach (i; iota(1, n, 1)) {
int l = readln.chomp.to!int;
maxv = max(maxv, l - minv);
... | 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;
alias sread = () => readln.chomp();
alias lread = () => readln.chomp.to!long();
alias aryread(T = long) = () => readln.split.to!(T[]);
void main()
{
long l, r, d;
scan(l, r, d);
long cnt;
foreach (i; l .. r + 1)
{
if (i % d == 0)
{
cnt += 1;
}
}
... | 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.numeric;
void main()
{
auto n = readln.chomp.to!int;
auto a = readln.chomp.split.to!(l... | D |
void main() {
int[] tmp = readln.split.to!(int[]);
int a = tmp[0], b = tmp[1], c = tmp[2], d = tmp[3];
max(a*b, c*d).writeln;
}
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 s... | D |
import std.stdio, std.string,std.range, std.conv, std.array, std.algorithm, std.math, std.typecons, std.container, std.datetime;
void main() {
auto S = readln.chomp;
string result;
foreach (s; S) {
final switch (s) {
case '0':
case '1':
result ~= s;
break;
case 'B':
... | 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){
int h,w;
string[] map;
auto s = readln().split().to!(int[]);
h = s[0];
w = s[1];
if(h==0&&w... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array, std.typecons;
import std.math, std.numeric;
import core.bitop;
void main() {
int n; scan(n);
auto a = iota(n).map!(i => readln.chomp.to!int).array;
auto on = new bool[](32);
int xs;
foreach (i ; 0 .. n) {
o... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.array;
void main() {
auto N = readln().split()[0].to!int();
int[] h = readln().split().map!(x => x.to!int())().array;
writeln(solve(h));
}
int solve(int[] h) {
if (h.length == 0) return 0;
if (h.length == 1) return h[0];
au... | 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, k;
scan(n, k);
auto a = new int[][... | D |
module main;
import core.stdc.stdio;
import std.algorithm.sorting;
int gcd (int a, int b) {
if (b == 0)
return a;
else
return gcd (b, a % b);
}
int main(string[] argv)
{
int n;
scanf("%d", &n);
int [] a = new int[n];
for(int i = 0; i < n; i++) scanf("%d", &a[i]);
a.sort();
int small = a[1] - a[0];
for(... | 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;
int calc2(int n) {
if(n <= 1000) {
return n+1;
} else {
return 2000-n+1;
}
}
void main() {
while(!stdin.eof()){
auto s = readln().strip();
if(s.empty())
... | 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 + b >= c ? "Yes" : "No");
}
void scan(T...)(ref T args) {
import std.stdio : readln;
import std.algorithm : splitter;
import std.conv : to;
import std.r... | D |
void main()
{
long n, m;
rdVals(n, m);
long[] a = new long[m], b = new long[m];
foreach (i; 0 .. m)
{
rdVals(a[i], b[i]);
--a[i], --b[i];
}
auto uf = UnionFind(n);
long[] result = new long[m];
result[$-1] = (n * (n - 1)) >> 1;
foreach_reverse (i; 1 .. m)
{
... | 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[string] ss;
foreach (_; 0..N) ++ss[readln.chomp];
int max_n;
foreach (_, n; ss) max_n = max(max_n, n);
string[] rs;
foreach (s, n; ss) if (n... | D |
void main() {
problem();
}
void problem() {
const MAX = 10L.pow(18);
auto N = scan!int;
auto A = scan!ulong(N);
long solve() {
ulong multi = 1;
real floatMulti = 1;
foreach(a; A) {
floatMulti *= cast(real)a;
multi *= a;
}
return floatMulti > MAX ? -1 : multi;
}
solve().... | 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.algorithm;
import std.conv;
import std.math;
import std.range;
import std.stdio;
import std.string;
void main ()
{
auto tests = readln.strip.to !(int);
foreach (test; 0..tests)
{
auto s = readln.strip;
int balance = 0;
int lo = 0;
long res = s.length;
foreach (i, char c; s)
{
balance += (c... | D |
import std.stdio, std.string, std.array, std.conv, std.algorithm;
void main(){
int[] xs = readln.chomp.split.map!(to!int).array;
int x = xs[0], y = xs[1];
writeln(x + y / 2);
} | D |
module Main;
import std.stdio;
import std.string;
import std.conv;
import std.array;
import std.range;
import std.algorithm;
alias map!(to!string) stringize;
void main() {
string input;
while ((input = readln.chomp).length != 0) {
int[] tehai = new int[](9);
int[] yama = new int[](9);
... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.array;
void main() {
auto s = readln.chomp.split.map!(to!int).array;
if (s[0] * s[1] < s[2]) writeln(s[0] * s[1]);
else s[2].writeln;
} | D |
// tested by Hightail - https://github.com/dj3500/hightail
import std.stdio, std.string, std.conv, std.algorithm;
import std.range, std.array, std.math, std.typecons, std.container, core.bitop;
immutable long mod = 10L^^9 + 7L;
long n, m;
void main() {
scan(n, m);
if (n < m) swap(n, m);
if (n == m) {
... | D |
import std.stdio;
import std.algorithm;
import std.conv;
import std.array;
import std.string;
import std.math;
import std.functional;
import std.range;
import std.typecons;
import std.format;
void main(string[] args) {
readln.solve.writeln;
}
auto solve(string line1) {
auto _ = line1.chomp.split.map!(to!int).arra... | 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;
bool calc(int h, int w, string[] ss) {
foreach (r; 0..h) {
foreach (c; 0..w) {
if (ss[r][c] == '#') {
... | 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 = 10^^9 + 7;
void main() {
auto N = readln.chomp.to!int;
auto A = readln.split.map!(to!int).arr... | 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;
long N, cnt;
bool ask(long n) {
writeln("? ", n);
stdout.flush;
cnt += 1;
debug {
string sn = n.to!string;
... | 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 nx = readln.split.to!(long[]);
auto N = nx[0];
auto x = nx[1];
auto as = readln.split.to!(long[]);
long r;
if (as[0] > x) {
r += as[0] - x;
as[0] = x;
}
... | 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; }
/*
ナップサック問題
xs[i][w]: i個目よ... | D |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.