code stringlengths 4 1.01M | language stringclasses 2
values |
|---|---|
import std.stdio;
void main()
{
int n;
scanf("%d", &n);
long[500][500] m;
int r, c;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
scanf("%lld", &m[i][j]);
if (m[i][j] == 0) {
r = i;
c = j;
}
}
}
long sum = 0;
long s = 1;
if (n > 1) {
int g = 0;
if (r == 0) {
g++;
... | 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 s... | D |
import std.stdio;
import std.string;
import std.conv;
import std.typecons;
import std.algorithm;
import std.functional;
import std.bigint;
import std.numeric;
import std.array;
import std.math;
import std.range;
import std.container;
import std.ascii;
void times(alias pred)(int n) {
foreach(i; 0..n) pred();
}
auto ... | D |
import std.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 w, h, n; readV(w, h, n);
au... | D |
//
import std.stdio,std.array,std.conv;
void main(){
auto sn=readln.split,n=to!int(sn[0]);
auto sk=readln.split,k=to!int(sk[0]);
int d=1;
for(int i=0;i<n;i++){
int a=d*2;
int b=d+k;
if(a>b) d=b;
else d=a;
}
writeln(d);
} | 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;
immutable long mod = 10^^9 + 7;
int n;
int[] t, a;
void main() {
scan(n);
t = readl... | 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;
void main() {
int n;
scan(n);
auto c = new char[](2*n + 1);
auto a = new int[](2*n + 1);
c[0] = '#', a[0] = 0;
foreach (i ; 1 .. 2*n + 1) ... | D |
/+ dub.sdl:
name "A"
dependency "dcomp" version=">=0.0.2"
+/
import std.algorithm, std.range, std.stdio, std.math, std.conv, core.bitop;
// import dcomp.scanner;
// import dcomp.algorithm;
int main() {
import std.conv;
auto sc = new Scanner();
int n;
int[] ai;
sc.read(n, ai);
bool solve... | D |
import std.functional,
std.algorithm,
std.bigint,
std.string,
std.traits,
std.array,
std.range,
std.stdio,
std.conv;
void main() {
string s = readln.chomp;
int c;
foreach (i; 0..s.length-1) {
if (s[i] != s[i + 1]) {
c++;
}
}
writeln(c);
... | D |
import std.stdio, std.conv, std.string, std.array, std.math, std.regex, std.range, std.ascii;
import std.typecons, std.functional;
import std.algorithm, std.container;
void main()
{
auto N = scanElem;
auto M = scanElem;
auto Q = scanElem;
long[501][501] table;
foreach(i; 0..M)
{
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.stdio, std.string, std.conv, std.algorithm;
import std.range, std.array, std.math, std.typecons, std.container, core.bitop;
void main() {
int N;
int[][] A;
scan(N);
A = new int[][](N, N);
iota(N).each!(i => A[i] = readln.split.to!(int[]));
long ans;
foreach (i ; 0 .. N) {
... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array, std.math;
void main() {
int a, b, x;
scan(a, b, x);
writeln(0 <= x - a && x - a <= b ? "YES" : "NO");
}
void scan(T...)(ref T args) {
import std.stdio : readln;
import std.algorithm : splitter;
import std.co... | D |
import std.stdio;
import std.string;
import std.conv;
void main() {
int n;
while ((n = readln.chomp.to!int) != 0) {
int count = 0;
while ((n /= 5) != 0) {
count += n;
}
writeln(count);
}
} | D |
void main() {
auto N = readAs!ulong;
// 75 = 3 * 5^2
// (75), (3, 25), (5, 15), (3, 5, 5)
// (74), (2, 24), (4, 14), (2, 4, 4)
pl = generate_prime_list(100);
ulong[ulong] arr;
foreach(i; 1..N+1) {
foreach(k; pl) {
ulong p = 1;
while(i % k^^p == 0) {
arr[k]++;
p++;
}
}
}
ulong res;
ulo... | D |
/+ dub.sdl:
name "A"
dependency "dcomp" version=">=0.3.2"
lflags "-stack_size" "100000000"
+/
import std.algorithm, std.conv, std.range, std.stdio;
// import dcomp.scanner;
// import dcomp.algorithm;
// import dcomp.container.deque;
int main(string[] argv) {
auto sc = new Scanner();
int n, a, b;
... | D |
import std.stdio;
import std.conv;
import std.string;
import std.typecons;
import std.algorithm;
import std.array;
import std.range;
import std.math;
import std.regex : regex;
import std.container;
import std.bigint;
void main()
{
auto n = readln.chomp.to!int;
auto a = readln.chomp.split.map!(to!int).array;
aut... | 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;
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 d, int n) ... | D |
void main() {
auto b = rs;
switch(b) {
case "A": writeln("T"); break;
case "T": writeln("A"); break;
case "G": writeln("C"); break;
case "C": writeln("G"); break;
default: break;
}
}
// ===================================
import std.stdio;
import std.string;
import std.functional;
import std.algorithm;
i... | D |
import std.stdio, std.algorithm, std.range, std.array, std.conv, std.string;
void main() {
int[][] C;
foreach (i; 0..3) {
C ~= readln.split.to!(int[]);
}
writeln(
C[0][1] - C[0][0] == C[1][1] - C[1][0]
&& C[0][1] - C[0][0] == C[2][1] - C[2][0]
&& C[0][2] - C[0][0] == C[1][2] -... | D |
import std.stdio, std.string, std.array, std.conv;
int arrayGCD(int[] x) {
while (x.length > 1) {
int a = x[0] < x[1] ? x[1] : x[0];
int b = x[0] < x[1] ? x[0] : x[1];
int r;
while (b > 0) {
r = a % b;
a = b;
b = r;
}
x[1] = a;
... | 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, z, w;
scan(N, z, w);
auto a = readln.split.to!(int[... | 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;
T gcd(T)(T a, T b) {
... | D |
import std.stdio, std.string, std.conv, std.algorithm;
import std.range, std.array, std.math, std.typecons, std.container, core.bitop;
immutable mod = 10^^9 + 7;
void main() {
int h, w;
scan(h, w);
auto map = new char[][](h + 2, w + 2);
iota(h).each!(i => map[i + 1][1 .. w + 1] = readln.chomp.to!(cha... | D |
import core.bitop;
import core.checkedint;
import core.simd;
import core.stdc.stdlib;
import core.stdc.string;
import std.algorithm;
import std.array;
import std.ascii;
import std.bigint;
import std.bitmanip;
import std.complex;
import std.container;
import std.conv;
import std.datetime;
import std.format;
import std.f... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto nm = readln.split.to!(int[]);
auto N = nm[0];
auto M = nm[1];
auto qs = new int[](N);
foreach (_; 0..M) {
auto ab = readln.split.to!(int[]);
++qs[ab[0]-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;
void scan(T...)(ref T args) {
import std.stdio : readln;
import std.algorithm : splitter;
import std.conv : to;
import std.range.primiti... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.range;
import std.array;
void main(){
auto s=readln.chomp;
if(s=="abc"||s=="acb"||s=="bac"||s=="bca"||s=="cab"||s=="cba")writeln("Yes");
else writeln("No");
} | D |
import std.algorithm;
import std.conv;
import std.stdio;
import std.string;
void main(){
foreach(string s; stdin.lines)
writeln(s.chomp.split.map!(to!int).reduce!"a + b");
} | D |
import std.stdio, std.conv, std.string, std.array, std.math, std.regex, std.range, std.ascii, std.numeric, std.random;
import std.typecons, std.functional, std.traits,std.concurrency;
import std.algorithm, std.container;
import core.bitop, core.time, core.memory;
import std.bitmanip;
import std.regex;
enum INF = long.... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.math;
void main() {
int input;
immutable limitList = 200000;
bool[] listNumbers = new bool[](limitList);
int[] listPrimeNumbers;
listNumbers.fill(true);
foreach (i; 2..limitList.to!double.sqrt.to!int) {
... | D |
import std.stdio;
import std.string;
import std.array;
import std.range;
import std.random;
import std.algorithm;
import std.conv;
void main(){
auto nk = readln().chomp().split().map!(to!int).array();
auto as = readln().chomp().split().map!(to!int).array();
auto k = nk[1];
auto n = nk[0];
solve(n, ... | 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 readInt() {
return readInts()[0];
}
auto readInts() {
return array(map!(to!int)(rea... | D |
/* imports all std modules {{{*/
import
std.algorithm,
std.array,
std.ascii,
std.base64,
std.bigint,
std.bitmanip,
std.compiler,
std.complex,
std.concurrency,
std.container,
std.conv,
std.csv,
std.datetime,
std.demangle,
std.encoding,
std.exception,
std.file,
std.format,
std.functi... | D |
import std.stdio, std.conv, std.array, std.range, std.algorithm,
std.string, std.math;
void main(){
auto n = readln.chomp.to!long;
auto as = [0L] ~ readln.chomp.split.to!(long[]) ~ [0L];
long[] ans = [];
long s = 0;
foreach(i; 0 .. n + 1) s += abs(as[i] - as[i + 1]);
foreach(i; 1 .. n + 1){... | D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
auto n = readln.chomp.to!size_t;
auto si = readln.split.to!(int[]);
auto q = readln.chomp.to!size_t;
auto ti = readln.split.to!(int[]);
writeln(ti.count!(t => si.assumeSorted.contains(t)));
} | D |
//dlang template---{{{
import std.stdio;
import std.conv;
import std.string;
import std.array;
import std.algorithm;
// MIT-License https://github.com/kurokoji/nephele
class Scanner
{
import std.stdio : File, stdin;
import std.conv : to;
import std.array : split;
import std.string;
import std.traits : isSome... | 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;
struct Puzzle
{
int[9] panel;
size_t toHash() const @safe pure nothrow
{
size_t hash =... | 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.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.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;
void main() {
int N, K;
scan(N, K);
auto a = ... | D |
void main() {
writeln(2 ^^ readln.chomp.to!int.log2.to!int);
}
import std.stdio;
import std.string;
import std.array;
import std.conv;
import std.algorithm;
import std.range;
import std.math;
import std.numeric;
import std.container;
import std.typecons;
import std.ascii;
import std.uni; | D |
import std.stdio;
import std.string;
import std.conv;
int main()
{
int n = readln().chomp().to!int();
string s = "Hoshino";
while (n--) {
string str = readln().chomp();
char[] ans;
for (int i = 0; i < str.length; i++) {
ans ~= str[i];
if (str[i] == 'H') {
... | 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.array, std.algorithm;
ulong[] getArray() {
auto ary = appender( new ulong[]( 0 ) );
foreach ( n; 1 .. 1000 ) {
immutable ulong val = n * ( n + 1 ) * ( n + 2 ) / 6;
if ( val >= 10 ^^ 6 ) {
break;
} else {
ary.put( val );
}
}
return ary.data;
}
ulong[] getOd... | D |
import std.stdio, std.string, std.conv, std.bigint, std.typecons, std.algorithm, std.array, std.math, std.range, std.functional;
void main() {
auto N = readln.chomp.to!long;
auto x = readln.split.to!(long[]);
long cnt = 0;
foreach (i; 0..N) {
if (x[i] == i+1) {
cnt++;
s... | 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;}}
T[] readArray(T)(size_t n){auto a=new T[](n),r=readln.splitter;foreach(ref v;a){v=r.front.to!T;r.popFront;}return a;}
T[] readArrayM(T)(size_t n){au... | 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;
void main()
{
... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
long P = 10^^9+7;
int[2][] prime_division(int m)
{
int[2][] r;
for (int x = 2; x^^2 <= m; ++x) {
int cnt;
while (m % x == 0) {
++cnt;
m /= x;
}
if (cnt... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.array;
void main(){
auto z=readln.split.to!(int[]),a=z[0],b=z[1];
if(a%3==0||b%3==0||(a+b)%3==0)writeln("Possible");
else writeln("Impossible");
} | D |
import std.stdio;
import std.string;
import std.math;
import std.conv;
import std.algorithm;
import std.bigint;
void main(){
int d,m;
int date = 2;
auto ds = ["Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday","Monday"];
auto a = [31,29,31,30,31,30,31,31,30,31,30,31];
while(true){
date... | D |
//prewritten code: https://github.com/antma/algo
import std.algorithm;
import std.array;
import std.conv;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.traits;
final class InputReader {
private:
ubyte[] p, buffer;
bool eof;
bool rawRead () {
if (eof) {
return fals... | 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;
void main(){
auto n = readln.chomp.to!int;
auto s = readln.chomp;
int stack;
int lb, rb;
... | 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 nte = readln.chomp.split.map!(to!int);
auto lo = nte[1] - nte[2];
auto up = nte[1] + nte[2];
auto ... | D |
void main() {
int[] tmp = readln.split.to!(int[]);
int hw = tmp[0], ww = tmp[1];
tmp = readln.split.to!(int[]);
int hb = tmp[0], wb = tmp[1];
writeln((hw - hb) * (ww - wb));
}
import std.stdio;
import std.string;
import std.array;
import std.conv;
import std.algorithm;
import std.range;
import std.... | 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() {
auto S = rs;
ulong res;
ulong tmp;
foreach(i; S) {
if(i == 'A' || i == 'T' || i == 'C' || i == 'G') {
tmp++;
} else {
res = max(res, tmp);
tmp = 0;
}
}
res = max(res, tmp);
res.writeln;
}
// ===================================
import std.stdio;
import std.string;
import std.functio... | D |
import std.stdio;
import std.array;
import std.conv;
import std.string;
import std.algorithm;
void main()
{
string[string] cards;
auto n = readln.strip.to!int;
foreach(i;0..n) {
auto s = readln;
cards[s] = s;
}
foreach(i;["S","H","C","D"]) {
foreach(j;0..13){
st... | D |
import std;
void main() {
int k; scan(k);
string s; scan(s);
if (s.length > k) writeln(s[0..k], "...");
else writeln(s);
}
void scan(T...)(ref T a) {
string[] ss = readln.split;
foreach (i, t; T) a[i] = ss[i].to!t;
}
T read(T=string)() { return readln.chomp.to!T; }
T[] reads(T)() { return read... | D |
void main()
{
long[] tmp = rdRow;
long a = tmp[0], b = tmp[1], k = tmp[2];
long c = min(a, k);
a -= c;
long d = min(b, k - c);
b -= d;
writeln(a, " ", b);
}
T rdElem(T = long)()
{
//import std.stdio : readln;
//import std.string : chomp;
//import std.conv : to;
return rea... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric, std.container, std.range;
void get(Args...)(ref Args args)
{
import std.traits, std.meta, std.typecons;
static if (Args.length == 1) {
alias Arg = Args[0];
static if (isArray!Arg) {
... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
enum P = 10L^^9+7;
void main()
{
auto nm = readln.split.to!(int[]);
auto N = nm[0];
auto M = nm[1];
auto AS = readln.split.to!(int[]);
auto BS = readln.split.to!(int[]);
auto CS = new int[](N... | 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.algorithm, std.numeric;
import std.range, std.array, std.math, std.typecons, std.container, core.bitop;
void main() {
while (true) {
string s;
scan(s);
if (s == "#") return;
solve(s);
}
}
void solve(string s) {
auto h = "qwertas... | D |
import std.stdio;
import std.string;
import std.array;
import std.conv;
import std.algorithm;
import std.math;
void main()
{
int[3] n;
n = numText2IntArray(readln());
if((n[0] + n[1]) == n[2] || (n[0] + n[2]) == n[1] || (n[1] + n[2]) == n[0])
{
writeln("Yes");
}
else
{
writeln("No");
}
}
int[] numText2Int... | D |
import std.stdio;
import std.conv;
import std.algorithm;
import std.string;
import std.array;
void main() {
int n = readln.chomp.to!int;
string[] s = new string[](n);
char[5] initial = ['M', 'A', 'R', 'C', 'H'];
long[5] num;
for (int i = 0; i < n; ++i) {
s[i] = readln.chomp;
... | D |
import std.stdio;
import std.string;
import std.conv;
import std.typecons;
import std.algorithm;
import std.functional;
import std.bigint;
import std.numeric;
import std.array;
import std.math;
import std.range;
import std.container;
import std.ascii;
void main()
{
auto N = readln.chomp.to!int;
int res;
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 k,a,b;
scan(k, a, b);
if (a >= k) {
writeln(1);
return;
}
if (a <= b) {
writeln(-1);
}
else {
... | D |
void main() {
int[] tmp = readln.split.to!(int[]);
int a = tmp[0], b = tmp[1];
writeln(b % a == 0 ? a + b : b - a);
}
import std.stdio;
import std.string;
import std.array;
import std.conv;
import std.algorithm;
import std.range;
import std.math;
import std.container;
import std.typecons; | D |
import std.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 std.stdio,std.string,std.conv,std.math;
int main()
{
int[4] a,b;
int count,count_2;
string s,s2;
while((s = readln.chomp).length != 0 )
{
s2 = readln.chomp;
string[] input = split(s);
string[] input2 = split(s2);
foreach(i;0..4)
{
a[i] = input[i].to!int;
b[i] = input2[i].to!int;
}
cou... | D |
import std;
// 累積和による解法
long calc(string s) {
int n = cast(int)s.length;
auto acc = new int[][](3, n);
foreach (i; 0..n) {
acc[0][i] = (s[i] == 'R') + (i > 0 ? acc[0][i-1] : 0);
acc[1][i] = (s[i] == 'G') + (i > 0 ? acc[1][i-1] : 0);
acc[2][i] = (s[i] == 'B') + (i > 0 ? acc[2][i-1] ... | D |
import std;
import core.bitop;
ulong MAX = 100_100, MOD = 1_000_000_007, INF = 1_000_000_000_000;
alias sread = () => readln.chomp();
alias lread(T = long) = () => readln.chomp.to!(T);
alias aryread(T = long) = () => readln.split.to!(T[]);
alias Pair = Tuple!(long, "x", long, "y");
alias PQueue(T, alias less = "a>b") ... | 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() {
while(true) {
int n = readln.chomp.to!int;
if (n==0... | D |
/* imports all std modules {{{*/
import
std.algorithm,
std.array,
std.ascii,
std.base64,
std.bigint,
std.bitmanip,
std.compiler,
std.complex,
std.concurrency,
std.container,
std.conv,
std.csv,
std.datetime,
std.demangle,
std.encoding,
std.exception,
std.file,
std.format,
std.functi... | D |
import 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, std.datetime;
// dfmt off
T lread(T = long)(){return readln.chomp.to!T();}
T[] lreads(T = long)(long n){return generat... | D |
// module dcomp.scanner;
class Scanner {
import std.stdio : File, readln, stdin;
import std.conv : to;
import std.range : front, popFront, array, ElementType;
import std.array : split;
import std.traits : isSomeString, isDynamicArray;
import std.algorithm : map;
File f;
this(File f = stdin) {
this.f = f;
}
... | 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.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()
{
readln;
int[int] list;
foreach (line; stdin.byLine) {
auto n = line.chomp.to!... | 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 = 10L^^12;
void main() {
int n, k;
scan(n, k);
auto x = readln.split.to!(int[]);
long ans = inf;
foreach (i ; 0 .. n - k + 1) {
... | 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 K = to!ulong(tokens[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 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, std.conv;
import std.typecons;
import std.algorithm, std.array, std.range, std.container;
import std.math;
void main() {
auto N = readln.split[0].to!int;
auto A = readln.split.to!(int[]);
auto Amin = A.reduce!"min(a,b)";
auto gcd = 1;
_gcd: foreach_reverse(d; 1 .. Amin+1) {
forea... | D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
auto rd = readln.split.to!(int[]), k = rd[0], s = rd[1];
auto ans = 0;
foreach (x; 0..k+1)
foreach (y; 0..k+1) {
auto z = s-x-y;
if (0 <= z && z <= k) ++ans;
}
writeln(ans);
}
| 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.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, a, b;
scan(n, a, b);
auto x = readl... | 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.range;
import std.stdio;
import std.string;
import std.typecons;
void main()
{
int n = readln.chomp.to!int;
int sum = 0;
foreach (i; 0..n) {
auto ... | D |
void main() {
int n = readln.chomp.to!int;
int[string] a;
foreach (i; 0 .. n) {
string s = readln.chomp;
if (s in a) ++a[s];
else a[s] = 1;
}
int m = readln.chomp.to!int;
foreach (i; 0 .. m) {
string t = readln.chomp;
if (t in a) --a[t];
else a[t] ... | 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, 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.algorithm, std.conv, std.array, std.string, std.math, std.typecons;
void main()
{
auto ab = readln.split.to!(int[]);
writeln(ab[0] & 1 && ab[1] & 1 ? "Yes" : "No");
} | D |
import std.algorithm;
import std.array;
import std.ascii;
import std.bigint;
import std.complex;
import std.container;
import std.conv;
import std.functional;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
auto readInts() {
return array(map!(to!int)(readln().strip().split... | D |
import std.stdio, std.conv, std.string;
import std.algorithm, std.array, std.container;
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.chomp; }
long ... | D |
import std.stdio, std.string, std.conv, std.array, std.algorithm;
import std.uni, std.range, std.math, std.container, std.datetime;
import core.bitop, std.typetuple, std.typecons;
immutable long MOD = 1_000_000_007;
alias tie = TypeTuple;
void main(){
int a, b;
char op;
while(true){
readVars(a, o... | 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.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto hw = readln.split.to!(int[]);
auto H = hw[0];
auto W = hw[1];
char[][] MAP;
foreach (_; 0..H) MAP ~= readln.chomp.to!(char[]);
auto MEMO = new int[][](H, W);
foreach (re... | D |
import std.stdio;
import std.string;
import std.conv;
import std.array;
import std.algorithm;
void main() {
string[] input = new string[](3);
while ((input = readln.chomp.split(" ")).length != 0) {
auto sum = 0;
auto data = input.map!(to!int).array;
data[0] %= data[1];
forea... | D |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.