code stringlengths 4 1.01M | language stringclasses 2
values |
|---|---|
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;
import core.bitop : popcnt;
alias Generator ... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.array;
import std.range;
import std.regex;
import std.math;
void main(){
auto a=readln.chomp;
writeln(a.count('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;
auto XS = readln.split.to!(long[]);
long r = long.max;
foreach (long p; 0..101) {
long rr;
foreach (x; XS) rr += (p - x)^^2;
r = min... | D |
import std.stdio, std.string, std.range, std.conv, std.array, std.algorithm, std.math, std.typecons;
void main() {
const N = readln.chomp.to!long;
const as = readln.split.to!(long[]);
writeln(as.reduce!max - as.reduce!min);
}
| D |
import std.stdio, std.conv, std.string;
void main()
{
while ( true ) {
immutable int n = to!int( readln().strip() );
if ( n == 0 ) break;
int count = 0;
bool right = false;
bool left = false;
bool isUp = false;
foreach ( s; split( readln() ) ) {
switch ( s ) {
case "lu":
left = true;
break;
case... | 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 N = s[0];
auto M = s[1];
... | D |
import std.stdio, std.string, std.algorithm, std.conv, std.array, std.math;
void main(){
auto hw=readln.split.to!(long[]);
auto h=hw[0], w=hw[1];
if(h % 3 == 0 || w % 3 == 0){
writeln(0);
return;
}
writeln(min(VtHr(h, w), HrVt(h, w), h, w));
}
long VtHr(long h, long w){
return HrVt(w, h);
}
auto... | 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;
int n, m;
int[][] a;
void main() {
scan(n, m);
int lim = 2 * max(n, m);
a = new int[][](lim + 1, lim + 1);
i... | D |
void main() {
auto S = rs.map!(i => i == '0').array;
auto k = S.length;
ulong cnt;
while(true) {
bool flag = false;
if(S.length <= 1) break;
foreach(i; 0..S.length-1) {
if(S[i] != S[i+1]) {
cnt++;
flag = true;
S = S[0..i] ~ S[i+2..$];
break;
}
}
if(!flag) break;
}
writeln(cnt*2);
}... | D |
// Vicfred
// https://atcoder.jp/contests/abc052/tasks/arc067_a
// math
import std.algorithm;
import std.array;
import std.conv;
import std.functional;
import std.math;
import std.range;
import std.stdio;
import std.string;
uint[] sieve(in uint limit) nothrow @safe {
if (limit < 2)
return [];
auto comp... | D |
import std.stdio, std.algorithm, std.string;
void main()
{
int[string] count;
int maxCount;
string maxWord;
auto input = readln.split;
foreach(str; input)
{
++count[str];
if(maxCount < count[str])
{
maxCount = count[str];
maxWord = str;
}... | 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.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; readV(n);
auto g = Graph... | D |
import std.stdio, std.conv, std.array, std.string;
import std.algorithm;
import std.container;
import std.range;
import core.stdc.stdlib;
import std.math;
void main() {
auto N = readln.chomp.to!int;
auto Dn = readln.split.to!(int[]);
int total = 0;
foreach(i; 0..N) {
for(int o=i+1; o<N; o++) {
total... | 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;
// }}}
// tbh.scanner {{{
class Scanner {
import std.stdio;
import std.conv : to;
import std.ar... | 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;
void main()
{
auto n = readln.strip.to!int;
if(n%2==0){
writeln(n);
return;
}
writeln(n*2);
} | 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[]);
int cnt = 1... | D |
import std.stdio, std.string, std.conv;
void main() {
auto x = readln.chomp.to!int;
writeln(x*x*x);
} | 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 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();
alias Point... | D |
import std.stdio;
import std.array;
import std.algorithm;
import std.conv;
import std.numeric;
import std.string;
void main() {
auto l = readln.chomp.split.map!(to!int).array;
int H = l[0], W = l[1];
int[][] c = new int[][](10, 10);
int[][] A = new int[][](H, W);
foreach(i; 0..10) {
c[i][] = readln.chom... | D |
void main()
{
long[] abc = readln.split.to!(long[]);
if (abc.all!"a % 2 == 0")
{
if (abc.all!(x => x == abc[0]))
{
writeln(-1);
}
else
{
long cnt;
while (abc.all!"a % 2 == 0")
{
long[] tmp = new long[3];
... | 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 INF = 1L << 50;
void main() {
auto s = readln.split.map!(to!int);
auto N = s[0];
auto M = s[1];
... | D |
void main()
{
long n = rdElem;
dchar[] s = rdDchar;
Fenwick[] tree = new Fenwick[26];
foreach (i; 0 .. 26) tree[i] = Fenwick(n);
foreach (i, x; s)
{
tree[x-'a'].add(i+1, 1);
}
long q = rdElem;
foreach (i; 0 .. q)
{
long num, pos;
string c;
rdVals... | 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() {
int N, K;
scan(N, K);
if (K == 1) {
... | D |
import std.conv;
import std.string;
import std.algorithm;
import std.array;
import std.stdio;
void main() {
auto limit = readln.chomp.split(' ').map!(to!long).array[2];
auto booksA = readln.chomp.split(' ').map!(to!long).array;
auto booksB = readln.chomp.split(' ').map!(to!long).array;
long count;
long time;
si... | 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.string, std.array, std.range, std.algorithm, std.container;
import std.math, std.random, std.bigint, std.datetime, std.format;
import std.typecons;
void main() {
auto s = read();
const string t = "CODEFESTIVAL2016";
int ret = 0;
foreach(i; 0..t.length) {
if (s[i]... | D |
import std.container;
import std.range;
import std.algorithm;
import std.array;
import std.string;
import std.conv;
import std.stdio;
import std.container;
int de(string s, string t) {
int c;
foreach (i;0..t.length) {
if (s[i] != t[i]) {
++c;
}
}
return c;
}
void main() {
auto s = readln.chomp;
auto t = ... | 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 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 x = lread();
if (x >= 30)
{
writeln("Yes");
... | 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.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto K = readln.chomp.to!long;
long s;
foreach (a; 1..K+1) foreach (b; 1..K+1) {
auto x = gcd(a, b);
foreach (c; 1..K+1) s += gcd(c, x);
}
writeln(s);
} | D |
import std.stdio, std.string, std.conv;
import std.array, std.algorithm, std.range;
void main()
{
auto nq = readln().split().map!(to!int);
immutable n=nq[0], q=nq[1];
int[][] r;
for(int i=n; i>1; i=(i+1)/2)
r~=new int[i];
r~=new int[1];
foreach(_;0..q)
{
auto av = readln().s... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons;
void main()
{
auto N = readln.chomp.to!int;
for (int a = 0; a * 4 <= 100; ++a) {
for (int b = 0; b * 7 <= 100; ++b) {
if (a * 4 + b * 7 == N) {
writeln("Yes");
return;
... | D |
void main(){
import std.stdio, std.string, std.conv, std.algorithm;
int n; rd(n);
auto s=readln.chomp.to!(char[]);
auto e=new int[](n+1), w=new int[](n+1);
foreach(i; 0..n){
if(s[i]=='E') e[i+1]++;
else w[i+1]++;
}
foreach(i; 0..n){
e[i+1]+=e[i];
w[i+1]+=w[i];
}
int mn=n;
foreach(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[] lreads(T = long)(long n){ret... | D |
import std.stdio, std.string;
void main(){
auto a = readln.split;
writeln(a[0][$-1]==a[1][0] && a[1][$-1]==a[2][0] ? "YES" : "NO");
} | 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.stdio;
import std.string;
void main()
{
immutable n = readln.chomp.to!int;
((n % 10 == 7 || n % 100 / 10 == 7 || n / 100 == 7) ? "Yes" : "No").writeln;
} | 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.to!(int[]).sum;
writeln(s > 21 ? "bus... | 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()
{
foreach (line; stdin.byLine) {
auto str = line.chomp;
string ans = "";
int i;
while (i < str.lengt... | 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 K = readln.chomp.to!long;
foreach (i; 0..K) {
if (S[i] != '1' || i == K-1) {
writeln(S[i]);
return;
}
}
} | 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 |
/+ dub.sdl:
name "C"
dependency "dcomp" version=">=0.3.2"
lflags "-stack_size" "100000000"
+/
import std.algorithm, std.conv, std.range, std.stdio;
import core.sys.posix.stdlib;
// import dcomp.scanner;
int n;
Scanner sc;
static this(){
sc = new Scanner();
}
bool que(string[2] s) {
writeln(s[0]... | 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.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;
int INF = 1 << 29;
void main() {
auto s = readln.split.map!(to!int);
auto N = s[0];
auto M = s[1];
auto G = new int[][](N, ... | D |
void main(){
import std.stdio, std.string, std.conv, std.algorithm;
long n, m; rd(n, m);
if(n>m) swap(n, m);
if((m-n)>=2){
writeln(0);
return;
}
long tot=1, mod=10^^9+7;
for(int i=1; i<=n; i++) (tot*=i)%=mod;
for(int i=1; i<=m; i++) (tot*=i)%=mod;
if(n==m) (tot*=2)%=mod;
writeln(tot);
}
v... | D |
import core.bitop, std.algorithm, std.ascii, std.bigint, std.conv, std.math,
std.functional, std.numeric, std.range, std.stdio, std.string, std.random,
std.typecons, std.container, std.format;
// dfmt off
T lread(T = long)(){return readln.chomp.to!T();}
T[] aryread(T = long)(){return readln.split.to!(T[])();}
... | D |
import std.stdio, std.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, std.datetime;
void main() {
long[long] s;
auto N = readln.chomp.to!int;
foreach (_; 0..N) {
auto t = read... | D |
import std.stdio;
import std.string;
import std.conv;
import std.array;
void main(){
int n=to!int(chomp(readln())),b=0;
string s="";
bool f=false;
for(int i=0;i<n;++i){
string[] input=split(readln());
if(input[0]=="(") b+=to!int(input[1]);
else b-=to!int(input[1]);
if(b<0) f=true;
}
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 x... | D |
import std.stdio,std.conv,std.string;
void main(){
int D,N;
auto DN = readArray!int();
D = DN[0];
N = DN[1];
if( N == 100 ){
(100^^D*101).writeln();
}else{
(100^^D*N).writeln();
}
}
T[] readArray(T)(){
T[] ret;
foreach( elm ; readln().split() ){
ret ~= elm.to!T();
}
return ret;
} | D |
unittest
{
assert( [ "A" ].parse.expand.solve == "T" );
assert( [ "G" ].parse.expand.solve == "C" );
}
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( isInputRange!Range && is( ElementTy... | D |
void main()
{
string l = rdStr;
long len = l.length;
long[] exp = new long[len];
exp[len-1] = 1;
foreach_reverse (i; 0 .. len-1)
{
exp[i] = (3 * exp[i+1]) % mod;
}
long num = 1;
long result;
foreach (i, x; l)
{
if (x == '0') continue;
result = (resul... | 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;
int[2] ans;
ans[0] = 101;
ans[1] = -1;
while (n--) {
auto x = readln.s... | D |
import std.stdio;
import std.string;
import std.conv;
int main()
{
while (true) {
string[] str = readln().split();
if (str[0] == "0" && str[1] == "0") break;
for (int i = 0; i < str[0].to!int(); i++) {
for (int j = 0; j < str[1].to!int(); j++) {
char s;
... | 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.string,
std.array,
std.range,
std.stdio,
std.conv;
void main() {
string s = readln.chomp;
writeln(s[0], s[1..$-1].length, s[$-1]);
}
| D |
import std.stdio, std.algorithm, std.range, std.conv, std.string, std.math, std.container, std.typecons;
import core.stdc.stdio;
// foreach, foreach_reverse, writeln
void main() {
int n, k;
scanf("%d%d", &n, &k);
long ans = 0;
long f(long x) {
return x*x*x;
}
ans += f(n/k);
if (k%2 == 0) ans += f((n+k/2)/k);
... | D |
import std.stdio, std.string, std.conv, std.algorithm;
void main() {
auto d = readln.chomp.to!(char[]);
d.reverse;
d.to!string.writeln;
} | 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;
bool solve() {
auto s = readln.split.map!(to!int);
auto P = s[0];
auto Q = s[1];
auto A = s[2];
auto N = s[3];
if (P... | 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 |
void main() {
import std.stdio, std.string, std.conv, std.algorithm;
int n, m;
long k;
rd(n, m, k);
auto a = readln.split.to!(long[]);
for (auto i = n - 1, r = k; i >= 0; i--) {
if ((r -= a[i]) < 0) {
if ((--m) == 0) {
writeln(n - i - 1);
return;
}
r = k - a[i];
}... | 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);
auto a = readln.split.to!(int[]);
auto... | 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.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;
import std.typecons;
auto readInts() {
return array(map!(to!int)(readln().strip().split()));
}
auto readInt() ... | D |
import std.stdio, std.range, std.conv, std.string, std.array, std.functional, std.math;
import std.algorithm.comparison, std.algorithm.iteration, std.algorithm.mutation, std.algorithm.searching, std.algorithm.setops, std.algorithm.sorting;
import std.container.binaryheap;
import std.typecons;
void main()
{
const ... | 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.math;
import core.time;
int[][] ofs = [
[0, 1],
[1, 0],
[-1, 0],
[0, -1]
];
void fill(bool[][] field, bool[]... | 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() {
int[] NK = readln.chomp.split.to!(int[]);
int N = NK[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;
import std.container;
string read(){ static string[] ss; while(!ss.length) ss = readln.chomp.split; string res = ss[0]; ss.popFront; return res; }
void main(){
long n = read... | D |
import std.stdio;
import std.string;
import std.range;
import std.conv;
void main()
{
auto N = readln.chomp;
if(N[0]=='9' || N[1]=='9'){
writeln("Yes");
}else{
writeln("No");
}
}
| D |
import std.stdio, std.conv, std.string, std.algorithm, std.math, std.array;
bool p(string s) {
for(int i=0; i<s.length/2; i++) {
if(s[i] != s[$-1-i]) return false;
}
return true;
}
bool q(string s) {
return p(s) && p(s[0..$/2]);
}
void main() {
string s = readln[0..$-1];
if(q(s)) writeln("Yes");
el... | D |
import std.stdio, std.string, std.array, std.conv, std.algorithm;
long P = 10^^9+7;
void main()
{
auto n = readln.chomp.to!long;
long ret = 1;
foreach (i; 0..n) {
ret *= i + 1;
ret %= P;
}
writeln(ret);
} | D |
import std.stdio,
std.string,
std.conv,
std.algorithm;
void main() {
long[] buf = readln.chomp.split.to!(long[]);
long q = buf[0],
h = buf[1],
s = buf[2],
d = buf[3];
long N = readln.chomp.to!(long);
long min_cost_per_1L = min(q * 4, h * 2, s);
long min_cost_per_2L = m... | D |
import std.stdio,std.ascii,std.conv,std.string,std.algorithm,std.range,std.functional,std.math,core.bitop;
void main()
{
auto a=readln.chomp.to!int;
auto b=readln.chomp.to!int;
auto h=readln.chomp.to!int;
writeln((a+b)*(h/2));
} | 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.math;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
T read(T)() { return readln.chomp.to!T; }
T[] reads(T)() { return readln.split.to!(T[]); }
alias readint = read!int;
alias readints = reads!int;
int calc(int[] xs) {
... | D |
void main(){
import std.stdio, std.conv, std.string, std.algorithm;
long n, a, b, k; rd(n, a, b, k);
const long mod=998244353;
const int M=1_000_00*4;
auto fact=new long[](M);
fact[0]=fact[1]=1;
foreach(i; 2..M) fact[i]=i*fact[i-1]%mod;
auto inv_fact=new long[](M);
long powmod(long a, long x){
i... | 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 N = readln.chomp.to!int;
auto A = readln.split.map!(to!long).array;
auto S = A.sum;
auto md = 1L << 59;
... | D |
import std.algorithm;
import std.array;
import std.conv;
import std.math;
import std.stdio;
import std.string;
import std.range;
int readint() {
return readln.chomp.to!int;
}
int[] readints() {
return readln.split.map!(to!int).array;
}
void main() {
int n = readint();
int ans = 1;
while (ans * 2... | D |
/+ dub.sdl:
name "A"
dependency "dcomp" version=">=0.7.3"
+/
import std.stdio, std.algorithm, std.range, std.conv;
// import dcomp.foundation, dcomp.scanner;
int main() {
Scanner sc = new Scanner(stdin);
string s;
sc.read(s);
writeln(s[0..$-8]);
return 0;
}
/* IMPORT /home/yosupo/Program/d... | 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;
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, m;
scan(n, m);
auto adj = new int[... | D |
import std.algorithm,
std.string,
std.array,
std.range,
std.stdio,
std.conv;
void main() {
int[] nm = readln.chomp.split.to!(int[]);
int n = nm[0],
m = nm[1];
writeln((n - 1) * (m - 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[] AS;
foreach (_; 0..N) AS ~= readln.chomp.to!int;
int[] cs;
foreach (a; AS) {
if (cs.empty || cs[$-1] >= a) {
cs ~= a;
... | D |
import std.stdio, std.string, std.array, std.conv;
void main() {
int n = readln.chomp.to!int;
int[] point = new int[2];
foreach (i; 0 .. n) {
string[] tmp = readln.chomp.split;
if (tmp[0] == tmp[1]) {
point[] += 1;
} else if (tmp[0] < tmp[1]) {
point[1] += 3;... | D |
import std.stdio,std.conv,std.string,std.algorithm;
void main(){
auto k=readln.chomp.split.to!(int[])[0];
auto a=readln.chomp.split.to!(int[]);
int[] d;
foreach(i;1..a.length){
d~=a[i]-a[i-1];
}
d~=a[0]+(k-a[$-1]);
(k-max(d)).writeln;
}
auto max(int[] arr){
int m;
fore... | D |
import core.stdc.stdio;
import std.stdio;
import std.algorithm;
static immutable int unSet=-114514;
struct Data{
int a,l,r,m;
}
Data Comb(const ref Data a,const ref Data b){
Data r;
r.a=a.a+b.a;
r.l=max(a.l,a.a+b.l);
r.r=max(a.r+b.a,b.r);
r.m=max(a.m,b.m,a.r+b.l);
return r;
}
struct Node{
Node* l,r,p;
int d... | D |
import core.bitop;
import std.algorithm;
import std.ascii;
import std.bigint;
import std.conv;
import std.functional;
import std.math;
import std.numeric;
import std.range;
import std.stdio;
import std.string;
import std.random;
import std.typecons;
import std.container;
alias sread = () => readln.chomp();
ulong bignu... | D |
import std.algorithm;
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() {
readi... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string;
int[int][10^^5 + 1] MEMO;
void main()
{
auto s = readln.chomp;
int v, p;
foreach (gp; s) {
switch (gp) {
case 'g':
if (p == 0) {
++p;
} else {
--p;... | D |
void main() {
problem();
}
void problem() {
auto K = scan!int;
long solve() {
int unitMod = 7 % K;
if (unitMod == 0) return 1;
int mod = unitMod;
foreach(i; 0..K) {
mod = (mod * 10) + unitMod;
mod %= K;
if (mod == 0) return 2 + i;
}
return -1;
}
solve... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array;
void main() {
readln.split.to!(int[]).reduce!"a ^ b".writeln;
}
void scan(T...)(ref T args) {
import std.stdio : readln;
import std.algorithm : splitter;
import std.conv : to;
import std.range.primitives;
a... | D |
import std.stdio;
import std.string, std.conv, std.array, std.algorithm;
import std.uni, std.math, std.container, std.typecons;
import core.bitop, std.datetime, std.range;
void main(){
auto rd = readln.split.to!(int[]);
auto n = rd[0], q = rd[1];
auto uf = new UnionFind(n);
foreach(lp ; 0 .. q){
... | 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;
import std.typecons;
auto readInts() {
return array(map!(to!int)(readln().strip().split()));
}
auto readInt() ... | 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.string;
void main() {
auto s = readln.split.map!(to!int);
auto N = s[0];
auto Q = s[1];
auto st = new LazySegmentT... | D |
import std.stdio, std.conv, std.string, std.math, std.regex, std.range, std.ascii, std.algorithm;
void main(){
auto ip = readln.split.to!(int[]), N=ip[0], K=ip[1];
auto S = readln.chomp.to!(dchar[]);
S[K-1] += 0x20;
writeln(S);
} | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string;
void main()
{
auto abck = readln.split.to!(long[]);
auto A = abck[0];
auto B = abck[1];
auto K = abck[3];
writeln(K&1 ? B - A : A - B);
} | D |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.