code stringlengths 4 1.01M | language stringclasses 2
values |
|---|---|
/+ dub.sdl:
name "D"
dependency "dunkelheit" version=">=0.9.0"
+/
import std.stdio, std.algorithm, std.range, std.conv;
// import dkh.foundation, dkh.scanner;
long solve(bool[] v) {
long ans = 0;
long sm = 0;
foreach (f; v) {
if (f) {
sm++;
continue;
} else ... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
int[26] CS;
void main()
{
auto S = readln.chomp.to!(char[]);
foreach (c; S) ++CS[c-97];
foreach (i, n; CS) {
if (!n) {
writeln(S ~ cast(char)(i+97));
return;
}
... | 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 |
void main(){
int n = _scan();
(n/2 +n%2).writeln();
}
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()){
ln ~= elm.to!T()... | 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.math,std.string,std.conv,std.typecons,std.format;
import std.algorithm,std.range,std.array;
T[] readarr(T=long)(){return readln.chomp.split.to!(T[]);}
void scan(T...)(ref T args){auto input=readln.chomp.split;foreach(i,t;T)args[i]=input[i].to!t;}
//END OF TEMPLATE
void main(){
ulong m,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 n; readV(n);
auto m = n, s ... | D |
import std.stdio;
import std.string;
import std.array;
import std.range;
import std.algorithm;
import std.conv;
void main(string[] args) {
readln();
string input = readln().chomp;
int cur = 0;
int min = 0;
int e = 0;
foreach(c; input){
if(c == 'E'){e++; cur--;}
else{cur++;}
if(cur < min){min ... | 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.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 core.bitop, std.algorithm, std.ascii, std.bigint, std.conv,
std.functional, std.math, std.numeric, std.range, std.stdio, std.string,
std.random, std.typecons, std.container;
ulong MAX = 1_000_100, MOD = 1_000_000_007, INF = 1_000_000_000_000;
alias sread = () => readln.chomp();
alias lread(T = long) = (... | D |
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 MOD =... | D |
import std.stdio;
import std.algorithm;
import std.string;
import std.conv;
void main() {
auto N = to!int(readln.chomp);
foreach (i; 0..N) {
auto input = readln.split.map!(to!int);
if (input[2] >= 5 && input[3] >= 2) {
writeln((input[0] * input[2] + input[1] * input[3]) * 4 / 5);
} else if (input[2] >= 5) {... | 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;
import std.array;
import std.string;
import std.conv;
import std.algorithm;
import std.typecons;
import std.range;
void main() {
auto input = readln().split.map!(to!int);
int H = input[0];
int W = input[1];
string[] blocks = new string[](H);
foreach (i; iota(H))
blocks[i] = readln().cho... | 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.container;
import std.datetime;
void main()
{
auto path = new int[][](5, 5);
auto key = [' ', 'U', 'L', ' ', 'D', ' ', ' ', ' ', 'R'];
auto dx = [0, 0, -1,... | D |
import core.bitop, std.algorithm, std.ascii, std.bigint, std.conv,
std.functional, std.math, std.numeric, std.range, std.stdio, std.string,
std.random, std.typecons, std.container;
ulong MAX = 1_000_100, MOD = 1_000_000_007, INF = 1_000_000_000_000;
alias sread = () => readln.chomp();
alias lread(T = long) = (... | D |
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(){
string s = readln.chomp;
string ans;
if(s.length % 2){
if(s[0] == s[$ - 1]) ans = "Second"; // like "aba"
else ans = "First"; // like "acb"
}
else{
... | 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;
foreach (i; 0..10) {
foreach (j; i..10) {
if (N == i*j) {
writeln("Yes");
return;
}
}
}
... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array;
void main() {
auto s = readln.split;
writeln(s[0][$-1] == s[1][0] && s[1][$-1] == s[2][0] ? "YES" : "NO");
}
void scan(T...)(ref T args) {
import std.stdio : readln;
import std.algorithm : splitter;
import std.c... | D |
import std;
void main() {
auto l = readln();
writeln(l.canFind('7') ? "Yes" : "No");
} | D |
import std.stdio, std.string, std.algorithm, std.functional;
void main() {
readln.chomp.map!(a => a=='p' ? -1:1).sum.pipe!"a/2".writeln;
}
| 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.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 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;
int calc(int a, int b, ... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons;
void main()
{
auto N = readln.chomp.to!int;
auto n = N;
int s;
while (n) {
s += n % 10;
n /= 10;
}
writeln(N % s ? "No" : "Yes");
} | 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 f = new int[][](n, 10);
au... | D |
import std.stdio;
import std.conv;
import std.string;
void main() {
string[] input = split(readln());
int a = to!int(input[0])-1;
int b = to!int(input[1]);
int ans = 0;
int tap = 1;
while (tap < b) {
tap += a;
ans++;
}
writeln(ans);
} | 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()
{
dchar[] s; readV(s);
writeln(s.u... | D |
import std.stdio, std.conv, std.array, std.string, std.algorithm, std.container, std.range, core.stdc.stdlib, std.math, std.typecons;
T[][] combinations(T)(T[] s, in int m) { if (!m) return [[]]; if (s.empty) return []; return s[1 .. $].combinations(m - 1).map!(x => s[0] ~ x).array ~ s[1 .. $].combinations(m); }
... | D |
import std.stdio, std.conv, std.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.algorithm, std.conv, std.array, std.string, std.math, std.numeric, std.typecons;
void main()
{
auto N = readln.chomp.to!int;
int[][] AAS;
AAS.length = N;
foreach (ref AA; AAS) AA = readln.split.to!(int[]);
foreach (k; 0..N)
foreach (i; 0..N)
foreach (j; 0... | D |
import std.stdio, std.conv, std.functional, std.string;
import std.algorithm, std.array, std.container, std.range, std.typecons;
import std.numeric, std.math, std.random;
import core.bitop;
string FMT_F = "%.10f";
static string[] s_rd;
T RD(T = long)() { while(!s_rd.length) s_rd = readln.chomp.split; string res = s_r... | D |
import std.stdio;
import std.conv;
import std.algorithm;
import std.range;
import std.string;
import std.typecons;
void main()
{
auto a = readln().strip;
auto b = readln().strip;
size_t sub = 0;
while (true)
{
sub = a.indexOf(b, sub);
if (sub == cast(size_t)-1)
{
... | D |
unittest
{
assert( [ "oxoxoxoxoxoxox" ].parse.expand.solve == "YES" );
assert( [ "xxxxxxxx" ].parse.expand.solve == "NO" );
}
import std.algorithm;
import std.conv;
import std.range;
import std.stdio;
import std.typecons;
void main()
{
stdin.byLineCopy.parse.expand.solve.writeln;
}
auto parse( Range )( Range in... | D |
void main()
{
int n = readln.chomp.to!int;
int[] a = readln.split.to!(int[]);
double m = a.sum / n.to!double;
double diff = double.max;
ulong frame;
foreach (i, x; a)
{
if (abs(x.to!double - m) < diff)
{
frame = i;
diff = abs(x.to!double - m);
... | 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];
int[][] AS;
AS.length = N;
foreach (ref A; AS) {
A = readln.split.to!(int[]).map!"a-1".array;
}
... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.math;
void main() {
int x = readln.chomp.to!(int);
int[1001] arr;
for (int i = 1; i <= x; i++) {
for (int j = 2; j <= 100; j++) {
int t = pow(i, j);
if (t <= x) {
arr[i] =... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
enum P = 10L^^9+7;
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 main()
{
auto nk = readln.sp... | D |
import std.algorithm;
import std.stdio;
import std.string;
void main() {
bool[string] cups = ["A": true, "B": false, "C": false];
foreach (string line; stdin.lines) {
string[] cup = line.chomp.split(",");
swap(cups[cup[0]],cups[cup[1]]);
}
foreach (k; cups.keys) {
if (cups[k] == true) {
k.w... | D |
/+ dub.sdl:
name "C"
dependency "dcomp" version=">=0.7.4"
+/
import std.stdio, std.algorithm, std.range, std.conv;
// import dcomp.foundation, dcomp.scanner;
int main() {
Scanner sc = new Scanner(stdin);
int n; int[] a;
sc.read(n);
sc.read(a);
bool[] ok = new bool[1<<24];
ok[1] = true;... | 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, z, w;
scan(n, z, w);
auto a = readln.split.to!(int[]);
if (n == 1) {
writeln(abs(a[0] - w));
return;
}
if (... | D |
void main() {
auto N = readAs!long;
ulong current = ulong.max;
foreach(long i; 1..N.to!real.sqrt.ceil.to!long+1) {
if(N % i == 0) {
current = min(current, abs(i + N / i));
}
}
(current-2).writeln;
}
ulong[] getDivisors(ulong N) {
ulong[] res;
foreach(i; 1..N.to!real.sqrt.ceil.to!ulong) {
if(N % i == 0... | 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;
if (N == 1) {
writeln("Hello World");
} else {
auto A = readln.chomp.to!int;
auto B = readln.chomp.to!int;
writeln(A + B);
}... | 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 len = S.length;
if (len%2 == 1) {
writeln("No");
return;
}
foreach (i; 0..len/2) {
auto c = S[len-i-1];
switch (S[i]) {
... | D |
/+ dub.sdl:
name "A"
dependency "dunkelheit" version="1.0.0"
+/
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 ans = 10^^9;
foreach (a; 1... | 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 fun)(int n) {
foreach(i; 0..n) fun();
}
auto re... | 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.string, std.conv;
import std.range, std.algorithm, std.array, std.math;
long n, m;
void main() {
scan(n, m);
auto cmb = new long[][](n + 1, n + 1);
auto dp = new long[][](n + 1, n + 1);
foreach (i ; 0 .. n + 1) {
cmb[i][0] = cmb[i][i] = 1;
dp[i][0] = dp[i][i] = 1... | 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 S = readln.chomp;
writeln(S[$-1] == 's' ? S ~ "es" : S ~ "s");
} | D |
import std.algorithm;
import std.conv;
import std.range;
import std.stdio;
import std.string;
void main ()
{
auto tests = readln.strip.to !(int);
foreach (test; 0..tests)
{
auto n = readln.strip.to !(int);
auto a = readln.splitter.map !(to !(long)).array;
auto m = a.maxElement * (n - 1L);
auto t = a.sum (0L... | D |
import std.stdio, std.string, std.conv;
import std.array, std.algorithm, std.range;
void main()
{
immutable T = ["A":0,"B":1,"AB":2,"O":3];
int[4] c;
foreach(v;stdin.byLine().map!(s=>T[s.split(",")[1]])) ++c[v];
foreach(v;c) writeln(v);
} | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
void main() {
int[] buf = readln.chomp.split.to!(int[]);
int n = buf[0], k = buf[1];
int[] arr = readln.chomp.split.to!(int[]);
int ans = 0;
n -= 1;
while (n > 0) {
n -= k - 1;
ans++;
}
writeln... | D |
import std.stdio;
import std.string;
import std.conv;
import std.array;
import std.algorithm;
import std.range;
void main(){
auto N=readln.chomp.to!int;
if(N/10==9||N%10==9)writeln("Yes");
else writeln("No");
} | 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()
{
long n, k; readV(n, k);
auto x ... | 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.container;
void main()
{
auto n = readln.chomp.to!int;
foreach (c; 1..n+1) {
readln;
auto area = new char[][](8, 8);
foreach (i; 0..8) {
area[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;
int readint() {
return readln.chomp.to!int;
}
int[] readints() {
return readln.split.map!(to!int).array;
}
void main() {
int w = readint;
int n = readi... | D |
import std.stdio, std.string, std.array, std.conv;
long modexp(long x, long n) {
if (n == 0) return 1;
long mod = 1_000_000_007;
long result = modexp(x, n/2);
result = result * result % mod;
if (n % 2 == 1) result = result * x % mod;
return result;
}
void main() {
long[] tmp = readln.chomp... | 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.algorithm;
import std.array;
import std.bigint;
import std.bitmanip;
import std.conv;
import std.numeric;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
// 差の絶対値
@nogc @safe pure T diff(T)(const ref T a, const ref T b) { return a > b ? a - b : b - a; }
// 切り上げ除算
@nogc @safe pur... | 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, k;
scan(n, k);
auto a = readln.split.to!(int[]);
auto dp = new int[](k + 1);
dp[0] = 0;
// 0: 先手負け(=後手勝ち)、 1: 先手勝ち
... | D |
import std.stdio;
import std.conv;
import std.string;
import core.bitop;
void main() {
auto n = readln.chomp.to!uint;
if (n == 0) return;
writeln(1U << (n.bsr));
}
| D |
import std;
auto input()
{
return readln().chomp();
}
alias sread = () => readln.chomp();
void main()
{
string s = input();
long s_len = s.length;
//writeln(s);
//writeln(s_len);
writeln(s[0 .. ((s.length) - 8)]);
}
void scan(L...)(ref L A)
{
auto l = readln.split;
foreach (i, T; L)
... | D |
import std.stdio, std.string, std.conv;
void main() {
auto n = readln.chomp.to!int;
string[] result;
foreach (i; 0..n) {
result ~= readln.chomp.replace("Hoshino", "Hoshina");
}
foreach (r; result) r.writeln;
} | D |
import std.algorithm, std.container, std.conv, std.math, std.range, std.typecons, std.stdio, std.string;
void readV(T...)(ref T t){auto r=readln.splitter;foreach(ref v;t){v=r.front.to!(typeof(v));r.popFront;}}
void readA(T)(size_t n,ref T[]t){t=new T[](n);auto r=readln.splitter;foreach(ref v;t){v=r.front.to!T;r.popFro... | D |
module app;
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.range;
void main(string[] argv){
// input
int n;
n = to!int(readln().chop());
int[] a1;
a1 = map!(to!int)(readln().chop().split()).array();
int[] a2;
a2 = map!(to!int)(readln().chop().split... | D |
import std.algorithm, std.container, std.conv, std.math, std.range, std.typecons, std.stdio, std.string;
auto rdsp(){return readln.splitter;}
void pick(R,T)(ref R r,ref T t){t=r.front.to!T;r.popFront;}
void readV(T...)(ref T t){auto r=rdsp;foreach(ref v;t)pick(r,v);}
void main()
{
int n, m; readV(n, m);
auto g =... | D |
import std.stdio;
import std.algorithm;
import std.conv;
import std.math;
import std.string;
void main()
{
auto tokens = split(chomp(readln()));
auto h = to!int(tokens[0]);
auto w = to!int(tokens[1]);
int[][] cell;
cell.length = h;
foreach (y; 0..h)
{
foreach (token; split(chomp(readln())))
{
cell[y] ~= ... | 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 N = s[1];
auto A = readln.split.map!(... | D |
import std.stdio;
import std.conv;
import std.array;
void main()
{
int a = readln.split[0].to!int;
int b = readln.split[0].to!int;
int c = readln.split[0].to!int;
int d = readln.split[0].to!int;
int e = readln.split[0].to!int;
int k = readln.split[0].to!int;
if (e - a <= k){
writel... | D |
import std.stdio, std.conv, std.functional, std.string;
import std.algorithm, std.array, std.container, std.range, std.typecons;
import std.numeric, std.math, std.random;
import core.bitop;
string FMT_F = "%.10f";
static string[] s_rd;
T RD(T = long)() { while(!s_rd.length) s_rd = readln.chomp.split; string res = s_r... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array, std.typecons, std.container;
import std.math, std.numeric, core.bitop;
enum inf3 = 1_001_001_001;
enum inf6 = 1_001_001_001_001_001_001L;
enum mod = 1_000_000_007L;
enum L = 2001;
void main() {
int n;
scan(n);
auto s = r... | 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 |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array, std.typecons, std.container;
import std.math, std.numeric, std.random, core.bitop;
enum inf = 1_001_001_001;
enum inf6 = 1_001_001_001_001_001_001L;
enum mod = 1_000_000_007L;
alias Pair = Tuple!(int, "a", int, "b");
void main() {
... | 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];
hw = readln.split.to!(int[]);
auto h = hw[0];
auto w = hw[1];
writeln(H*W - h*W - w*H + h*w);
} | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.range;
import std.traits;
import std.math;
import std.conv;
void main() {
auto S = readln.chomp;
S.check.writeln;
}
int check(string s) {
if(s.length & 1) s.popBack();
else { s.popBack; s.popBack; }
while(true) {
if(s[0..$ /... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array, std.math;
void main() {
int h, w;
scan(h, w);
auto ban = new char[][](h, w);
iota(h).each!(i => ban[i] = readln.chomp.to!(char[]));
auto cnt = new int[](26);
foreach (i ; 0 .. h) {
foreach (j ; 0 .. w... | D |
import std;
import core.bitop;
// dfmt off
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[]);
void aryWrite(T = long)(T[] ary){ ary.map!(x => x.text()).join(' ')... | 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 |
void main() {
auto s = rs;
if(s.length == 2) writeln(s);
else writeln(s[2], s[1], s[0]);
}
// ===================================
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 std.bigint;
import s... | D |
void main(){
int k = _scan();
string s = readln().chomp();
if( s.length <= k ){
s.writeln();
return;
}else{
( s[0..k] ~ "..." ).writeln();
}
}
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... | D |
// import chie template :) {{{
static if (__VERSION__ < 2090) {
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,
std.bitmanip, std.numeric;
} else {
import std;
}
// }}}
// nep.scanner {{{
class Scanner {
... | D |
import std.stdio, std.string;
void main()
{
readln.replace(",", " ").writeln;
}
| D |
void main() {
auto N = ri;
auto H = ri;
auto W = ri;
writeln(max(0, N - H + 1) * max(0, N - W + 1));
}
// ===================================
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 std.big... | D |
import std.stdio, std.string, std.conv;
void main(){
auto ip = readln.split.to!(int[]);
if(ip[0] + ip[1] > ip[2] + ip[3]){
writeln("Left");
}else if(ip[0] + ip[1] < ip[2] + ip[3]){
writeln("Right");
}else{
writeln("Balanced");
}
} | 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 ip = readln.split.to!(int[]), a = ip[0], b = ip[... | 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.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;
string s = rdStr;
long[] r = new long[n+1], g = new long[n+1], b = new long[n+1];
foreach (i, x; s)
{
r[i+1] += r[i];
g[i+1] += g[i];
b[i+1] += b[i];
if (x == 'R') ++r[i+1];
if (x == 'G') ++g[i+1];
if (x == 'B') ++b[i+1... | D |
import std.algorithm;
import std.ascii;
import std.array;
import std.container;
import std.conv;
import std.numeric;
import std.stdio;
import std.string;
import std.typecons;
void log(A...)(A arg) {
stderr.writeln(arg);
}
int size(T)(in T s) {
return cast(int)s.length;
}
const int INF = 10000;
int op(char c,... | D |
import std.stdio;
void main() {
char b = 'a';
foreach(c; readln) {
if (b == c) {
write("Bad");
return;
}
b = c;
}
write("Good");
}
| 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()
{
int[4] s;
foreach (i; 0..3) {
auto d = readln.chomp.split.to!(int[]);
s[d[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;
void main(string[] args) {
string s = readln.chomp;
char[] st;
foreach(c; s){
if(c == 'T' && !st.empty && st.back == 'S'){
st.popBack();
... | D |
import std;
auto input()
{
return readln().chomp();
}
void main()
{
long x, y;
scan(x, y);
if (x % y == 0)
{
writeln(-1);
}
else
{
writeln(x);
}
}
void scan(L...)(ref L A)
{
auto l = readln.split;
foreach (i, T; L)
{
A[i] = l[i].to!T;
}
}
| 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;
real[12][1<<12] dp;
int[] cakes;
int n;
real saiki(int u,int v){
if(dp[u][v] > 0) return dp[u][v];
if( u == ((1<<n) - 1... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math;
int[10^^5] XS;
void main()
{
auto nk = readln.split.to!(int[]);
auto N = nk[0];
auto K = nk[1];
foreach (i, x; readln.split.to!(int[])) {
XS[i] = x;
}
int l, r = K - 1, min_res = int.max;
while (r < N) {
... | D |
import core.bitop, std.bitmanip;
import core.checkedint;
import std.algorithm, std.functional;
import std.array, std.container;
import std.bigint;
import std.conv;
import std.math, std.numeric;
import std.range, std.range.interfaces;
import std.stdio, std.string;
import std.typecons;
void main()
{
auto s = readln.... | 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.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 = 998244353;
void main() {
auto N = readln.chomp.to!int;
auto A = readln.split.map!(to!long).array... | D |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.