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;
void times(alias fun)(int n) {
foreach(i... | 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;
import core.bitop : popcnt;
alias Generator ... | D |
import std.stdio, std.conv, std.functional, std.string;
import std.algorithm, std.array, std.container, std.range, std.typecons;
import std.bigint, std.numeric, std.math, std.random;
import core.bitop;
string FMT_F = "%.10f";
static File _f;
void file_io(string fn) { _f = File(fn, "r"); }
static string[] s_rd;
T _RD(... | D |
/+ dub.sdl:
name "A"
dependency "dcomp" version=">=0.7.3"
+/
import std.stdio, std.algorithm, std.range, std.conv;
// import dcomp.foundation, dcomp.scanner;
int main() {
Scanner sc = new Scanner(stdin);
int a, b, c;
sc.read(a, b, c);
if (a == b) writeln(c);
else if (b == c) writeln(a);
... | D |
import std.algorithm;
import std.array;
import std.conv;
import std.range;
import std.stdio;
import std.string;
enum S { E = 0, A = 1, B = 2 };
void main() {
string s = readln.strip;
immutable n = s.length;
auto z = new dchar[n];
s.copy(z);
debug stderr.writeln(z);
long res;
int i;
int cnt;
S t = S... | 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.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!(i... | 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;
auto input()
{
return readln().chomp();
}
alias sread = () => readln.chomp();
alias aryread(T = long) = () => readln.split.to!(T[]);
void main()
{
long x;
scan(x);
long k = 1;
while ((x * k) % 360 != 0)
{
k++;
}
writeln(k);
}
void scan(L...)(ref L A)
{
auto ... | 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 N = S.length;
long min_n;
auto ns = new long[](N+1);
long x;
foreach (i; 1..N+1) {
if (S[i-1] == '<') {
ns[i] = ++x;
} els... | 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 |
void main() {
problem();
}
void problem() {
auto a = scan!long;
long solve() {
auto mod = a % 1000;
return mod == 0 ? 0 : 1000 - mod;
}
solve().writeln;
}
// ----------------------------------------------
import std.stdio, std.conv, std.array, std.string, std.algorithm, std.container, std.range, ... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.array;
import std.range;
void main(){
auto A=readln.chomp;
writeln(A.replace(","," "));
} | 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 infl = 1_001_001_001_001_001_001L;
enum mod = 1_000_000_007L;
void main() {
int n, h, w;
scan(n);
scan(h);
scan(w);
... | D |
import std.stdio, std.conv, std.array,std.string;
void main()
{
string[] input=readln.split;
int a=input[0].to!int,b=input[1].to!int;
if((a*b)%2==0){
writeln("Even");
}else{
writeln("Odd");
}
} | D |
import std.algorithm;
import std.array;
import std.conv;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
T read(T)() { return readln.chomp.to!T; }
T[] reads(T)() { return readln.split.to!(T[]); }
alias readint = read!int;
alias readints = reads!int;
void main() {
auto ... | D |
import std.stdio,std.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 k;
... | 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[] sieve(int n) {
... | D |
import std.algorithm;
import std.array;
import std.container;
import std.conv;
import std.math;
import std.numeric;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
void scan(T...)(ref T a) {
string[] ss = readln.split;
foreach (i, t; T) a[i] = ss[i].to!t;
}
T read(T)() { return read... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto s = readln.chomp;
size_t i, j = s.length-1;
int c;
while (j > i) {
if (s[i] == s[j]) {
++i; --j;
} else if (s[i] == 'x') {
++i; ++c;
... | D |
import std.algorithm;
import std.array;
import std.container;
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[]... | D |
import std.stdio, std.range, std.random, std.conv, std.string, std.math;
import std.algorithm.comparison, std.algorithm.iteration, std.algorithm.mutation, std.algorithm.searching, std.algorithm.sorting;
void main()
{
int[5] l;
foreach(i; 0..3) {
int[] input = readln().strip.split().to!(int[]);
... | 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() {
long n, p;
scan(n, p);
long ans = 1;
for (long i = 2; i*i <= p; i++) {
int cnt;
while (p % i == 0) {
p... | D |
import std.conv, std.functional, std.range, std.stdio, std.string;
import std.algorithm, std.array, std.bigint, std.bitmanip, std.complex, std.container, std.math, std.mathspecial, std.numeric, std.regex, std.typecons;
import core.bitop;
class EOFException : Throwable { this() { super("EOF"); } }
string[] tokens;
stri... | D |
void main()
{
string s = rdStr;
string t = "AKIHABARA";
string u;
foreach (i, x; s)
{
if (i == 0 && x != 'A') u ~= 'A';
if ((x == 'B' || x == 'R') && u.back != 'A') u ~= 'A';
u ~= x;
if (i == s.length - 1 && x == 'R') u ~= 'A';
}
writeln(t == u ? "YES" : "NO... | D |
import core.stdc.stdio;
import std.typecons;
import std.algorithm;
struct Seg{
Seg* l,r;
int c;
}
int Count(Seg* x){
return x is null?0:x.c;
}
Seg* Left(Seg* x){
return x is null?null:x.l;
}
Seg* Right(Seg* x){
return x is null?null:x.r;
}
Seg[] buf;
Seg* newSeg(Seg* l,Seg* r){
static int i;
buf[i]=Seg(l,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 inf = 1_001_001_001;
enum inf6 = 1_001_001_001_001_001_001L;
enum mod = 1_000_000_007L;
void main() {
int n;
scan(n);
int ma;
int ans;
... | D |
import std.stdio;
import std.conv;
import std.algorithm;
import std.string;
import std.file;
int main() {
int[] hs;
string l;
while((l = readln()).length >= 2) printf("%d\n", to!string(to!int(l.split()[0]) + to!int(l.split()[1])).length);
return 0;
} | D |
import std.stdio, std.range, std.conv, std.string;
import std.algorithm.comparison, std.algorithm.iteration, std.algorithm.mutation, std.algorithm.searching, std.algorithm.setops, std.algorithm.sorting;
void main()
{
int[] input = readln().split.to!(int[]);
int N = input[0];
int M = input[1];
int C = 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;
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 h, int w)... | D |
void main(){
import std.stdio, std.string, std.conv, std.algorithm;
int n, m;
rd(n, m);
auto a=readln.split.to!(int[]);
auto b=readln.split.to!(int[]);
int mx=0;
foreach(i; 0..m){
int j=i;
foreach(e; a){
if(j>=m) break;
if(e==b[j]) j++;
}
mx=max(mx, j-i);
}
writeln(mx... | 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 |
void main() {
int[] tmp = readln.split.to!(int[]);
int a = tmp[0], b = tmp[1];
int diff = b - a;
writeln(iota(1, diff+1).sum - b);
}
import std.stdio;
import std.string;
import std.array;
import std.conv;
import std.algorithm;
import std.range;
import std.math;
import std.numeric;
import std.container;... | D |
import std.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 a, b; readV(a, b);
writel... | D |
import std;
void main() {
int n;
scanf("%d\n", &n);
auto as = readln.chomp.split.to!(int[]);
long count = 0;
int[long] memj;
foreach(i;0..as.length) {
++memj[i-as[i]];
}
foreach(i;0..as.length) {
if (i+as[i] in memj) {
count += memj[i+as[i]];
}
}
write(count);
}
| 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 a = readln.chomp[0];
auto b = readln.chomp[1];
auto c = re... | D |
// Code By H~$~C
module main;
import core.stdc.stdlib, core.stdc.string;
import std.stdio, std.array, std.string, std.math, std.uni;
import std.algorithm, std.range, std.random, std.container;
import std.conv, std.typecons, std.functional;
immutable Maxn = 100005;
int n, q;
Tuple!(int, int, int)[][Maxn] g;
int[Maxn... | D |
import std.stdio, std.array, std.string, std.conv, std.algorithm;
import std.typecons, std.range, std.random, std.math, std.container;
import std.numeric, std.bigint, core.bitop, std.bitmanip;
void main() {
auto S = readln.chomp;
auto N = S.length.to!int;
int[] cnt = new int[](26);
foreach (s; S) cnt[... | D |
import std.stdio;
import std.algorithm;
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!string(tokens[0]);
ulong ans;
foreach (e; N)
{
if (e == '2') +... | 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() {
while (true) {
auto ab = r... | D |
void main()
{
long i, o, t, j, l, s, z;
rdVals(i, o, t, j, l, s, z);
long result = o;
if (i && j && l && (i & 1) + (j & 1) + (l & 1) >= 2)
{
result += 3;
--i, --j, --l;
}
result += 2 * (i / 2 + j / 2 + l / 2);
result.writeln;
}
enum long mod = 10^^9 + 7;
enum long inf ... | D |
void main(){
import std.stdio, std.string, std.conv, std.algorithm;
auto s=readln.chomp.to!(char[]);
int w; rd(w);
auto t="".to!(char[]);
int i=0;
while(i<s.length){
t~=s[i];
i+=w;
}
writeln(t);
}
void rd(T...)(ref T x){
import std.stdio, std.string, std.conv;
auto l=readln.split;
ass... | D |
import std.stdio, std.conv, std.functional, std.string;
import std.algorithm, std.array, std.container, std.range, std.typecons;
import std.bigint, std.numeric, std.math, std.random;
import core.bitop;
string FMT_F = "%.10f";
static File _f;
void file_io(string fn) { _f = File(fn, "r"); }
static string[] s_rd;
T _RD(... | D |
import std.stdio, std.conv, std.functional, std.string;
import std.algorithm, std.array, std.container, std.range, std.typecons;
import std.bigint, std.numeric, std.math, std.random;
import core.bitop;
string FMT_F = "%.10f";
static File _f;
void file_io(string fn) { _f = File(fn, "r"); }
static string[] s_rd;
T _RD(... | D |
import std.stdio;
import std.algorithm;
import std.math;
import std.string;
import std.conv;
import std.range;
void main() {
int sum = 0;
foreach (i; 0..10) {
sum += readln.chomp.to!int;
}
sum.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.algorithm;
import std.array;
import std.conv;
import std.math;
import std.numeric;
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() {
string 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;}}
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.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;
void main() {
const string m = "kstnhm";
const string ch = "aiueo";
const string dir = "TLURD";
auto str = readln;
bool flag = false;
foreach (int i, c; str) {
if (!(i % 2)) {
auto a = c - '0';
if (a == 0) flag = true;
else if (2 <= a && a <= 7) {
write(m[a-2])... | 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;
scan(N);
auto a = readln... | 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;
immutable long MOD = 10^^9 + 7;
void main() {
auto s = readln.split.map!(to!int);
auto N = s[0];
auto L = s[1... | D |
import std.stdio, std.array, std.string, std.conv, std.algorithm;
import std.typecons, std.range, std.random, std.math, std.container;
import std.numeric, std.bigint, core.bitop, core.stdc.stdlib;
void main() {
auto s = readln.split.map!(to!int);
auto N = s[0];
auto K = s[1];
auto C = s[2];
auto S ... | D |
module AOJ_Volume0093;
import std.stdio,std.string,std.conv;
int main()
{
bool first = true;
while(true)
{
string[] s = readln.chomp.split(" ");
int a = s[0].to!int;
int b = s[1].to!int;
if(a == 0 && b == 0) break;
if(first)
{
first = false;
}
else
{
writeln;
}
bool flag = true;
fo... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array;
void main() {
writeln(readln.chomp.to!int < 1200 ? "ABC" : "ARC");
}
void scan(T...)(ref T args) {
import std.stdio : readln;
import std.algorithm : splitter;
import std.conv : to;
import std.range.primitives;
... | D |
import std.stdio;
import std.algorithm;
import std.string;
import std.conv;
import std.array;
import std.typecons;
import std.container;
void main() {
auto inp = readln.split.map!(to!int);
int N = inp[0], R = inp[1], L = inp[2];
alias Tuple!(int, "point", int, "time") Team;
Team[] datas = new Team[N];
foreach (i;... | 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.algorithm, std.conv, std.array, std.string;
void main()
{
auto stxy = readln.split.to!(int[]);
auto xd = stxy[2] - stxy[0];
auto yd = stxy[3] - stxy[1];
string ret;
foreach (_; 0..yd) ret ~= "U";
foreach (_; 0..xd) ret ~= "R";
foreach (_; 0..yd) ret ~= "D";
foreac... | 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;
// 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.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto N = readln.chomp;
int l = N.length.to!int;
int r, p;
foreach (int i, c; N) {
auto n = c-48;
if (n) {
r = max(r, p + n-1 + (l-i-1)*9);
p += n;... | D |
import std.stdio;
import std.conv;
import std.string;
import std.array;
import std.algorithm;
void main() {
auto n = readln.chomp.to!int;
auto a = readln.chomp.split(" ").map!(to!long).array;
long[long] table;
foreach (e;a) {
++table[e];
}
table.rehash;
long patterns = 0;
foreach (value;table.values) {
... | 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() {
string s;
scan(s);
bool fir... | 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) {
string str = readln.chomp;
if (str ==... | D |
import std.algorithm, std.array, std.bitmanip, std.conv, std.stdio, std.string,std.typecons;
T diff(T)(const ref T a, const ref T b) { return a > b ? a - b : b - a; }
void main() {
immutable ip = readln.split.to!(ulong[]);
immutable n = ip[0], m = ip[1];
auto sw_vec = new BitArray[m];
for (int i = 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.string;
import std.algorithm.mutation;
void main()
{
readln;
string[] s = readln.split;
s.reverse();
writeln(s.join(" "));
} | D |
import std.stdio, std.string, std.conv;
import std.array, std.algorithm, std.range;
void main()
{
do{
auto m = iota(8).map!(_=>countUntil(readln().chomp(),'1')).array().filter!"a>=0"().array();
char c='Z';
switch(m.length)
{
case 1:
c = 'C';
break;
... | 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.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.container;
import std.range;
import std.algorithm;
import std.array;
import std.string;
import std.conv;
import std.stdio;
import std.container;
void main() {
auto n = readln.chomp.to!int;
auto l = readln.chomp.split(' ').map!(to!int).array;
long count;
foreach (i;0..n - 2) {
foreach (j;i + 1..n - 1)... | D |
import std.stdio;
import std.string;
void main() {
auto ar = readln.chomp.split(" ");
auto a = ar[0];
auto b = ar[1];
auto c = ar[2];
if (a == b && b == c) {
writeln("No");
return;
}
if (a != b && a != c && b != c) {
writeln("No");
return;
}
writeln("Yes");
}
| D |
import std.stdio, std.conv, std.functional, std.string;
import std.algorithm, std.array, std.container, std.range, std.typecons;
import std.bigint, std.numeric, std.math, std.random;
import core.bitop;
string FMT_F = "%.10f";
static File _f;
void file_io(string fn) { _f = File(fn, "r"); }
static string[] s_rd;
T _RD(... | D |
import std.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.string, std.conv;
import std.array, std.algorithm, std.range;
void main()
{
foreach(s;stdin.byLine())
{
int[] a;
foreach(c;s) a~=c-'0';
foreach_reverse(i;1..a.length)
foreach(j;0..i) a[j]=(a[j]+a[j+1])%10;
writeln(a[0]);
}
} | D |
import std.stdio, std.string, std.conv, std.range, std.algorithm;
void main() {
auto s = readln.chomp;
char[] line;
foreach (c; s) {
if (c == 'B' && line.length > 0) {
line = line.dropBackOne;
} else if (c == '0' || c == '1') {
line ~= c;
}
}
line.writeln;
}
| D |
void main() {
auto N = ri;
auto ip = readAs!(string[]), S = ip[0], T = ip[1];
foreach(i; 0..N) {
write(S[i]);
write(T[i]);
}
writeln;
}
// ===================================
import std.stdio;
import std.string;
import std.functional;
import std.algorithm;
import std.range;
import std.traits;
import std.math... | D |
import std.stdio;
import std.string;
import std.conv,std.array;
void main(){
//auto i = to!int( readln().chomp() );
Map map = new Map();
while(1){
auto cs = readln().chomp().split(",");
if( !cs ){ break; }
map.drop( to!int(cs[0]), to!int(cs[1]), to!int(cs[2]) );
}
writeln(map.not);
writeln(map.max);
}
class... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto T = readln.chomp.to!int;
foreach (_; 0..T) {
auto n = readln.split.to!(int[]);
writeln(n[1], " ", n[2], " ", n[2]);
}
} | 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.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 N = readln.chomp.to!int;
auto ans = new int[](N);
int tmp = 1... | D |
void main()
{
long n = rdElem;
Point[] p = n.rdCol!Point;
Point q = Point(0, 0, 0);
foreach (x; p)
{
Point diff = x - q;
if (diff.t < diff.len || (diff.t & 1) != (diff.len & 1))
{
"No".writeln;
return;
}
q = x;
}
"Yes".writeln... | D |
import std.algorithm;
import std.conv;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
immutable int mod = 998_244_353;
void main ()
{
string s;
while ((s = readln.strip ()) != "")
{
auto t = readln.strip;
auto n = s.length.to !(int);
auto m = t.length.to !(int);
auto f = new in... | 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 |
module main;
import core.stdc.stdio;
int main(string[] argv)
{
int n,l,tmp;
scanf("%d", &n);
int [] a = new int[n+5];
for(int i = 0; i<n; i++)
scanf("%d", &a[i]);
for(int i=0;i<n;i++)
{
if (i==0||a[i]==a[i-1])
l = i + 1;
else break;
}
tmp = l;
for(int i=0; i<n; i++)
{
if (i==0||a[i]!=a[... | D |
void main() {
int[] tmp = readln.split.to!(int[]);
int a = tmp[0], b = tmp[1], c = tmp[2];
writeln(a + b >= c ? "Yes" : "No");
}
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 ... | 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 |
module main;
import core.stdc.stdio;
import std.algorithm;
int main(string[] argv)
{
int n, ans = 0;
scanf("%d", &n);
int[] t = new int[n];
for (int i = 0; i < n; ++i) {
int h, m;
scanf("%d:%d", &h, &m);
t[i] = 60*h+m;
}
if (n == 1) {
puts("23:59");
retur... | 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[int] cnt;
foreach (a; readln.chomp.spl... | D |
import std.algorithm, std.array, std.container, std.range, std.bitmanip;
import std.numeric, std.math, std.bigint, std.random, core.bitop;
import std.string, std.ascii, std.regex, std.conv, std.stdio, std.typecons;
void main()
{
auto s = readln.chomp;
auto p = readln.chomp;
foreach (i; 0..s.length)
if ((s[i... | D |
import std.stdio, std.string, std.conv, std.algorithm;
void main() {
string s = readln.chomp;
string odd, even;
foreach (i, x; s) {
if (i % 2) even ~= x;
else odd ~= x;
}
writeln(odd.count('L') || even.count('R') ? "No" : "Yes");
} | D |
import std.stdio, std.string, std.conv, std.range, std.algorithm, std.functional;
void main() {
readln.split.to!(int[]).pipe!(input => writeln(min(input[0] * input[1], input[2])));
}
| D |
import std.stdio;
import std.array;
import std.conv;
void main() {
string[] input=split(readln());
int N=to!int(input[0]);
int A=to!int(input[1]);
int B=to!int(input[2]);
int ans=0;
for(int i=1;i<=N;i++) {
int sum=0;
int j=i;
while(j>0) sum+=j%10,j/=10;
if(A<=sum&&sum<=B) ans+=i;
}
write... | D |
import std.stdio, std.string, std.array, std.conv, std.algorithm, std.typecons, std.range, std.container, std.math, std.algorithm.searching, std.functional,std.mathspecial;
void main(){
auto ab=readln.split.map!(to!int).map!"a==1?999:a".array;
if(ab[0]==ab[1]) writeln("Draw");
else if(ab[0]<ab[1]) writeln(... | D |
/+ dub.sdl:
name "E"
dependency "dcomp" version=">=0.6.0"
+/
import std.stdio, std.algorithm, std.range, std.conv;
// import dcomp.foundation, dcomp.scanner;
// import dcomp.container.deque;
int main() {
auto sc = new Scanner(stdin);
int n, m;
int[] a;
sc.read(n, m, a); a[] -= 1;
long[] ... | D |
void main() {
int n = readln.chomp.to!int;
int[] p = new int[n];
foreach (i; 0 .. n) {
p[i] = readln.chomp.to!int;
}
writeln(p.sum - p.reduce!max / 2);
}
import std.stdio;
import std.string;
import std.array;
import std.conv;
import std.algorithm;
import std.range;
import std.math;
import s... | D |
import std.stdio, std.conv, std.string, std.math, std.algorithm;
void main(){
auto ip = readln.split.to!(int[]);
if(ip[0] + ip[1] < 24) (ip[0] + ip[1]).writeln;
else (ip[0] + ip[1] - 24).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 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;
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();
ulong MOD =... | D |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.