code stringlengths 4 1.01M | language stringclasses 2
values |
|---|---|
import std;
alias sread = () => readln.chomp();
alias lread = () => readln.chomp.to!long();
alias aryread(T = long) = () => readln.split.to!(T[]);
//aryread!string();
void main()
{
auto n = lread();
auto ans = new long[](10 ^^ 5);
foreach (i; 1 .. 101)
{
foreach (j; 1 .. 101)
{
... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
string m(string a, string b)
{
if (a == "T" && b == "T") return "T";
if (a == "T" && b == "F") return "F";
if (a == "F" && b == "T") return "T";
return "T";
}
void main()
{
auto N = readln.chomp.... | D |
import std.stdio,std.conv,std.string;
int main(){
int x;
x=stdin.readln().chomp.to!int;
if(x==3||x==5||x==7){
write("YES");
}
else{
write("NO");
}
return 0;
} | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.array;
import std.range;
void main(){
auto Q=readln.split,a=Q[0],b=Q[1];
if(a==b)writeln("H");
else writeln("D");
} | D |
import std.stdio, std.algorithm, std.string;
void main()
{
readln();
auto s = readln().strip();
int[string] d;
foreach (i; 0 .. s.length - 1)
{
d[s[i .. i+2]]++;
}
int maxCount = 0;
string maxStr = "";
foreach (str, count; d)
{
if (count > maxCount)
{... | 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 std.stdio, std.algorithm, std.range, std.conv, std.string, std.math;
import core.stdc.stdio;
// foreach, foreach_reverse, writeln
void main() {
int q;
scanf("%d", &q);
foreach (i; 0..q) {
int a, b;
scanf("%d%d", &a, &b);
if (a > b) swap(a,b);
int l = 0, r = b;
while (l+1 < r) {
int x = (l+r)/2;
... | D |
import std;
// dfmt off
T lread(T = long)(){return readln.chomp.to!T();}
T[] lreads(T = long)(long n){return generate(()=>readln.chomp.to!T()).take(n).array();}
T[] aryread(T = long)(){return readln.split.to!(T[])();}
void scan(TList...)(ref TList Args){auto line = readln.split();
foreach (i, T; TList){T val = line[i]... | D |
import std.stdio, std.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[] lis;
foreach (a; AS) {
if (lis.empty || lis[$-1] < a) {
lis ~= a;
... | 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 s = readln.chomp.split;
int[string] cnt;
for... | D |
import std.stdio;
import std.conv;
import std.string;
import std.array;
void main() {
string[] input1 = split(readln());
string[] input2 = split(readln());
int S;
int T;
for(int i = 0; i < 4; ++i)
S += to!int(input1[i]);
for(int i = 0; i < 4; ++i)
T += to!int(input2[i]);
if (S > T)
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 |
#!/usr/bin/env rdmd
import std.stdio, std.string, std.conv;
import std.algorithm, std.array;
import std.math, std.numeric;
import std.range;
void main()
{
for(string S; (S=readln().chomp()).length; )
{
auto m = S.split().map!(to!int)();
auto n = m[0], l=m[1], r=m[2], Ql=m[3], Qr=m[4];
a... | 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.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.string, std.conv;
void main() {
auto S = readln.split.to!(int[]);
auto sx = S[0], sy = S[1], tx = S[2], ty = S[3];
void po(string c, int x) {
foreach (i; 0..x) {
write(c);
}
}
po("R", tx-sx);
po("U", ty-sy);
po("L", tx-sx);
po("D", ty-s... | 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);
auto S = readln.chomp... | 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 ss = readln.chomp;
int res0, res1;
foreach (i, s; ss) {
if (i % 2) {
... | D |
import std.stdio;
import core.stdc.stdio;
import std.array;
import std.conv;
import std.algorithm;
import std.range;
void main() {
int n; scanf("%d",&n);
int[] a; a.length=n;
foreach(i; 0..n) scanf("%d", &a[i]);
a.sort().reverse();
int x, y;
foreach(i, v; a) {
if(i & 1) y += v;
... | 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;
const int DATA = 10;
int main() {
int max=-1, mid=-1, min=-1;
for(int i=0; i<DATA; i++) {
int d = to!(int)(chomp(readln));
if(max < d) {
min = mid;
mid = max;
max = d;
}
else if(mid < d) {
min = mid;
mid = d;
}... | D |
import std.stdio;
import std.string;
import std.conv;
import std.math;
void main() {
string[] inputs = split(readln());
int X = to!int(inputs[0]);
int A = to!int(inputs[1]);
int B = to!int(inputs[2]);
if(A - B >= 0) "delicious".writeln;
else if(X >= abs(A - B)) "safe".writeln;
else "dangerous".writeln;
}
| D |
static immutable MOD = 4;
static immutable MOD_OVERAL = 5;
static immutable MODS = [
[1, 1, 1, 1],
[1, 2, 4, 3],
[1, 3, 4, 2],
[1, 4, 1, 4]
];
uint solve(const string n) {
uint sum = 0;
foreach (ch; n) {
if (ch < '0' || ch > '9') {break;}
sum = ( (sum * 10) + (ch - '0') ) % MOD;
}
sum %= MOD;
uint res = ... | D |
import core.bitop;
import std.algorithm;
import std.ascii;
import std.bigint;
import std.conv;
import std.functional;
import std.math;
import std.numeric;
import std.range;
import std.stdio;
import std.string;
import std.random;
import std.typecons;
alias sread = () => readln.chomp();
alias Point2 = Tuple!(long, "y", ... | D |
import std.algorithm, std.container, std.conv, std.math, std.range, std.typecons, std.stdio, std.string;
auto rdsp(){return readln.splitter;}
void pick(R,T)(ref R r,ref T t){t=r.front.to!T;r.popFront;}
void readV(T...)(ref T t){auto r=rdsp;foreach(ref v;t)pick(r,v);}
void readA(T)(size_t n,ref T[]t){t=new T[](n);auto ... | D |
import std.stdio, 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 main() {
long n;
scan(n);
if (n == 1) {
writeln(0);
return;
}
long ans;
for (long i = 1; i * i <= n; i++)... | D |
import std.stdio;
import std.array;
import std.string;
import std.conv;
void main()
{
uint count = 0;
auto n = chomp(readln());
auto s = split(readln());
auto q = to!(int)(chomp(readln()));
auto t = split(readln());
foreach (i; t)
foreach (j; s)
if (i == j) {count++; b... | D |
import std.stdio,std.range,std.algorithm,std.conv,std.array,std.string;
void main()
{
int[1000] field;
int[1000] dice;
while(true)
{
auto input=readln.split;
int N=input[0].to!int;
int M=input[1].to!int;
if(N==0&&M==0)break;
foreach(i; 0..N)
{
... | 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 |
//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;
class InputReader {
private:
ubyte[] p;
ubyte[] buffer;
size_t cur;
public:
this () {
buffer = uninitializ... | 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.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 |
void main() {
auto S = rs;
auto A = S[0..2].to!int;
auto B = S[2..4].to!int;
bool YYMM = 0 <= A && A <= 99 && 0 < B && B <= 12;
bool MMYY = 0 <= B && B <= 99 && 0 < A && A <= 12;
if(YYMM && MMYY) writeln("AMBIGUOUS");
else if(YYMM) writeln("YYMM");
else if(MMYY) writeln("MMYY");
else writeln("NA");
}
// ======... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
void main() {
string[] inputs = split(readln());
int a = to!int(inputs[0]);
int b = to!int(inputs[1]);
int c = to!int(inputs[2]);
bool[int] flags;
flags[a] = true;
flags[b] = true;
flags[c] = true;
flags.length.writeln;
}
| 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 pickV(R,T...)(ref R r,ref T t){foreach(ref v;t)pick(r,v);}
void readV(T...)(ref T t){auto r=rdsp;foreach(ref v;t... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto nx = readln.split.to!(int[]);
auto N = nx[0];
auto X = nx[1];
auto LS = readln.split.to!(int[]);
int d, c;
foreach (l; LS) {
++c;
d += l;
if (d > X)... | 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!ulong(tokens[0]);
auto H = to!ulong(tokens[1]);
auto W = to!ulong(t... | D |
void main(){
int[] ab = _scanln();
(ab[0] * ab[1]).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 ~= ... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string;
wchar[600][600] BD1, BD2;
void main()
{
auto N = readln.chomp.to!int;
foreach (i; 0..N) {
foreach (j, c; readln.chomp) {
BD1[i][j] = BD1[i][N+j] = BD1[N+i][j] = BD1[N+i][N+j] = c;
BD2[j][i] = BD2[j][N+i] = BD2[N... | 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 s = sread();
long n = s.length;
long max_x = long.min;
... | D |
import std.stdio, std.string, std.algorithm, std.array, std.range, std.conv,
std.typecons, std.math, std.container, std.format;
void main(string[] args)
{
auto s = readln.strip();
long cnt = 0;
foreach (i; 0 .. s.length / 2)
{
if (s[i] != s[s.length - i - 1])
{
cnt++;
... | 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 n;
while ((n = readint) > ... | D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
auto x = readln.chomp.to!long;
auto ans = x / 11 * 2, mod = x % 11;
if (1 <= mod && mod <= 6) ans += 1;
else if (5 <= mod) ans += 2;
writeln(ans);
}
| D |
import std.stdio;
import std.string;
import std.conv;
void main() {
string ans = "UNRESTORABLE";
string s = readln.chomp;
string t = readln.chomp;
if (t.length <= s.length) {
char[] t_ans;
foreach_reverse (i; 0..s.length - t.length + 1) {
bool flag = true;
t_ans... | 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 main()
{
int r; readV(r);
int g; readV(g);
writeln(2*g-r);
}
| D |
import std.stdio;
import std.array;
import std.string;
import std.conv;
import std.algorithm;
import std.typecons;
import std.range;
import std.random;
import std.math;
void main() {
int N = readln().chomp.to!int;
int Lsum = 0;
int Rsum = 0;
int[] L = new int[](N);
int[] R = new int[](N);
foreach (i; iota(... | 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 s;
scan(s);
int ans = 1;
bool[lo... | D |
import std.stdio, std.string, std.conv;
void main()
{
auto n = readln.chomp.to!int;
auto a = readln.chomp.to!int;
writeln(n * n - 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, M;
scan(N, M);
int ans;
for (int i = 1; i*i <= M... | D |
//dlang template---{{{
import std.stdio;
import std.conv;
import std.string;
import std.array;
import std.algorithm;
import std.typecons;
import std.math;
import std.range;
// MIT-License https://github.com/kurokoji/nephele
class Scanner
{
import std.stdio : File, stdin;
import std.conv : to;
import std.array : ... | D |
import std.stdio;
import std.algorithm;
import std.string;
import std.functional;
import std.array;
import std.conv;
import std.math;
import std.typecons;
import std.regex;
import std.range;
void main(){
while(true){
int n = readln().chomp().to!int;
if(n==0)break;
int m = readln().chomp().to!int;
int p = read... | D |
import std.algorithm;
import std.conv;
import std.range;
import std.stdio;
void main(){
iota(1, 10).map!(a => iota(1, 10).map!(b => text(a, "x", b, "=", a * b)).join("\n")).join("\n").writeln;
} | 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;
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;
auto t = readln.chomp;
int cnt;
foreac... | D |
import std.stdio, std.string, std.conv, std.algorithm, std.numeric;
import std.range, std.array, std.math, std.typecons, std.container, core.bitop;
void main() {
int n;
scan(n);
auto luca = new long[](100);
luca[0] = 2, luca[1] = 1;
foreach (i ; 2 .. 100) {
luca[i] = luca[i - 1] + luca[i ... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
long[10^^5*2] AS;
long[10^^5*2][5] MEMO;
void main()
{
auto L = readln.chomp.to!int;
foreach (i; 0..L) {
AS[i] = readln.chomp.to!long;
}
foreach (ref m; MEMO) m[] = -1;
long solve(int 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.traits;
import std.typecons;
int cvt (dchar c) {
return (c.to!int - 97);
}
void main() {
immutable n = readln.strip.to!int;
string s = readln.strip;
auto idx = new int[][... | 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, std.bitmanip;
void main() {
auto s = readln.split.map!(to!int);
auto N = s[0];
auto M = s[1];
auto Q = s[2];
auto S = r... | D |
import std.stdio;
void main()
{
printf("25\n");
}
| D |
import std.stdio, std.string, std.conv, std.algorithm;
void main(){
int n; rd(n);
auto s=readln.chomp.to!(char[]);
if(n==1){
writeln("Yes");
return;
}
bool[char] set;
foreach(c; s){
if(c in set){
writeln("Yes");
return;
}
set[c]=true;
}
writeln("No");
}
void rd(T..... | 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;
string s;
scan(n);
scan(s);
s = "0" ~ s ~ "0";
auto dp = new int[](n + 1);
foreach (i ; 3 .. n + 1) {
dp[i] = max(dp[i], dp[... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons;
long[10^^5][4] CS;
int P = 10^^9+7;
void main()
{
auto S = readln.chomp.to!(wchar[]);
auto len = S.length;
foreach_reverse(i, c; S) {
if (i == len-1) {
switch (c) {
case 'C':
... | D |
import std.stdio, std.array, std.string, std.conv, std.algorithm;
import std.typecons, std.range, std.random, std.math, std.container;
import std.numeric, std.bigint, core.bitop;
void main() {
auto N = readln.chomp.to!int;
auto A = readln.split.map!(to!int).array;
auto C = new int[](101010);
foreach ... | 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;
writeln(N < 1000 ? "ABC" : "ABD");
}
| D |
import std.algorithm;
import std.array;
import std.conv;
import std.math;
import std.range;
import std.stdio;
import std.string;
void main() {
auto s = readln.stripRight[0 .. 3];
writeln ((s.count ('A') < 3 && s.count('B') < 3) ? "Yes" : "No");
}
| D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
auto n = 3;
auto s = new string[](n);
foreach (i; 0..n) s[i] = readln.chomp;
auto turn = 0;
for (;;) {
if (s[turn].empty) {
writeln(cast(char)('A' + turn));
return;
}
auto next = cast(int)(s[turn][0] - '... | D |
import std.stdio;
import std.string;
import std.algorithm;
import std.conv;
import std.math;
void main()
{
int A, B, C;
auto input = readln.split.to!(int[]);
A = input[0];
B = input[1];
C = input[2];
if(A > B){
writeln(0);
}else if(B/A >C){
writeln(C);
}else{
writeln(B/A);... | D |
import std.stdio,std.string,std.conv;
void main(){
foreach(i;1..int.max){
int a = to!int(readln().chomp());
if( a==0 ){ break; }
writeln("Case ",i,": ",a);
}
} | D |
import std.stdio,std.conv,std.string,std.algorithm,std.array;
void main(){
auto s=readln().chomp().split().map!(to!int);
int a=s[0],b=s[1];
writeln(max(a+b,a-b,a*b));
} | D |
import std.stdio, std.algorithm, std.range, std.conv, std.string, std.math;
import core.stdc.stdio;
// foreach, foreach_reverse, writeln
void main() {
int n;
scanf("%d\n", &n);
int[][] g = new int[][n];
int[] degree = new int[n];
foreach (i; 0..n-1) {
int x, y;
scanf("%d %d\n", &x, &y);
--x; --y;
g[x] ~= ... | 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() {
import std.stdio, std.string, std.conv, std.algorithm;
int n, g;
rd(n, g);
struct P {
int p, c;
}
auto ps = new P[](n);
foreach (i; 0 .. n)
rd(ps[i].p, ps[i].c);
int mn = 1000000000;
foreach (bit; 0 .. (1 << n)) {
int s = 0, cnt = 0;
foreach (i; 0 .. n) {
if (bit ... | D |
import std.stdio, std.conv, std.string, std.range, std.algorithm;
void main() {
int d = readln.chomp.to!int;
("Christmas " ~ repeat("Eve", 25 - d).join(" ")).writeln;
} | D |
import std.algorithm;
import std.array;
import std.ascii;
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;
bool ... | 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[] aryread(T = long)(){return readln.split.to!(T[])();}
... | D |
import std.stdio, std.algorithm, std.string, std.conv, std.array, std.range, std.math;
int read() { return readln.chomp.to!int; }
void main() {
int n = read();
writeln(n&1 ? 2*n : n);
}
| D |
import std.stdio;
import std.algorithm;
import std.conv;
import std.array;
import std.string;
void main() {
int n = readln.chomp.to!int;
auto L = readln.chomp.split.map!(to!int).array;
int[] is_alive = new int[n];
for (int i = n - 1; i > 0; i--) {
if (L[i] == 0) continue;
int idx = max(0, i - L[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;
void times(alias fun)(int n) {
foreach(i; 0..n) fun();
}
auto re... | 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.chomp;
auto N = S.length.to!int;
long ans = 0;
long w = 0;
foreach_rev... | D |
void main() {
int[] tmp = readln.split.to!(int[]);
int a = tmp[0], b = tmp[1], c = tmp[2];
writeln(c % gcd(a, b) == 0 ? "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;... | D |
import std.stdio;
import std.algorithm;
import std.math;
import std.conv;
import std.string;
T readNum(T)(){
return readStr.to!T;
}
T[] readNums(T)(){
return readStr.split.to!(T[]);
}
string readStr(){
return readln.chomp;
}
void main(){
auto s = readStr;
int[char] dic;
foreach(c; s){
dic[c]++;
}... | D |
void main()
{
string s = readln.chomp;
string t = "CODEFESTIVAL2016";
int cnt;
foreach (i; 0 .. 16)
{
if (s[i] != t[i]) ++cnt;
}
cnt.writeln;
}
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;
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; }
T[] AR... | D |
import std.stdio, std.conv, std.string;
import std.algorithm, std.array, std.container;
import std.numeric, std.math;
string my_readln() { return chomp(readln()); }
long mod = pow(10, 9) + 7;
long moda(long x, long y) { return (x + y) % mod; }
long mods(long x, long y) { return ((x + mod) - (y % mod)) % mod; }
long m... | D |
import std.stdio;
import std.string;
import std.algorithm;
import std.conv;
import std.array;
import std.math;
import std.range;
void main()
{
foreach(line; stdin.byLine)
{
auto s = line.chomp;
if(s == "0") return;
writeln(reduce!"a+b"(0, s.map!"a-'0'"));
}
} | D |
import std.stdio;
import std.string;
import std.conv;
import std.math;
void main() {
string[] inputs = split(readln());
int A = to!int(inputs[0]);
int B = to!int(inputs[1]);
int result = A + B;
if(result < 10) result.writeln;
else "error".writeln;
}
| 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.conv, std.stdio, std.typecons;
void main()
{
while (true) {
auto rd = readln.split.map!(to!int);
auto h = rd[0], w = rd[1];
if (h == 0 && w ==... | D |
import std.algorithm;
import std.array;
import std.conv;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
T read(T)() { return readln.chomp.to!T; }
T[] reads(T)() { return readln.split.to!(T[]); }
alias readint = read!int;
alias readints = reads!int;
void main() {
int n... | D |
#!/usr/bin/env rdmd
import std.stdio, std.string, std.conv;
import std.algorithm, std.array;
void main()
{
for(string S; (S=readln().chomp()).length; )
{
long[3] h;
foreach(c;S)
if(c=='B') ++h[0];
else if(c=='S') ++h[1];
else ++h[2];
auto n = array(re... | 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;
immutable long mod = 10^^9 + 7;
void main() {
int n;
scan(n);
auto s = iota(n + 1).array;
long ans = 1;
foreach (p ; 2 .. n + 1) {
if (s[p] ... | 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;
int readint() {
return readln.chomp.to!int;
}
int[] readints() {
return readln.split.map!(to!int).array;
}
void main() {
readint();
auto ss = readints(... | D |
import std.stdio : writeln;
void main() {
int a,b;
scan(a,b);
writeln((a+b+1)/2);
}
void scan(T...)(ref T args) {
import std.stdio : readln;
import std.array : split;
import std.conv : to;
import std.range.primitives;
string[] line = readln.split;
foreach (ref arg; args) {
... | 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() {
int x, y, z;
scan(x, y, z);
int ans = (x - z) / (y + z);
writeln(ans);
}
void scan(T...)(ref T args) {
string[] line = readln.split;
... | 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;
writeln(0);
stdout.flush();
auto f = readln.chomp;
if (f == "Vacant") return;
int l = 0, r = N;
for (;;) {
auto m = (l+r)/2;
wri... | 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;
bool calc(int a, int b)... | D |
void main()
{
dchar[] s = readln.chomp.to!(dchar[]);
reverse(s);
string[] words = ["dream", "dreamer", "erase", "eraser"];
dchar[][] rev = new dchar[][](4);
foreach (i, x; words)
{
rev[i] = x.to!(dchar[]);
reverse(rev[i]);
}
long index;
bool ok = true;
while (in... | D |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.