code stringlengths 4 1.01M | language stringclasses 2
values |
|---|---|
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 |
void main() {
import std.stdio, std.string, std.conv, std.algorithm;
auto s = readln.chomp.to!(char[]);
auto t = readln.chomp.to!(char[]);
foreach (i; 0 .. s.length) {
if (s == t) {
writeln("Yes");
return;
}
s = s[$ - 1] ~ s[0 .. ($ - 1)];
}
writeln("No");
}
void rd(T...)(ref T ... | D |
import core.bitop, std.algorithm, std.ascii, std.bigint, std.conv, std.math,
std.functional, std.numeric, std.range, std.stdio, std.string, std.random,
std.typecons, std.container, std.format;
// 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.string;
import std.conv;
import std.algorithm;
import std.array;
void main() {
auto data = readln().split();
auto A = data[0].to!int(), B = data[1].to!int(), K = data[2].to!int();
int[] list;
foreach_reverse(i; 1 .. min(A, B)+1) {
if (A % i == 0 && B % i == 0) list ~= i;
}
writel... | 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() {
foreach(int i;1..10) foreach(int j; 1..10) {
writeln(i, "x"... | D |
void main() {
int[] tmp = readln.split.to!(int[]);
int a = tmp[0] - 1, b = tmp[1] - 1;
writeln(a * b);
}
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 |
void main() {
writeln(readln.chomp.to!double.sqrt.to!int ^^ 2);
}
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, std.array, std.conv, std.typecons, std.algorithm;
T diff(T)(const ref T a, const ref T b) { return a > b ? a - b : b - a; }
void main() {
immutable i = readln.split.to!(ulong[]);
immutable R = i[0], G = i[1], B = i[2], N = i[3];
ulong cnt = 0;
for(ulong r = 0; r <= N / R; r++) {
... | D |
import std.stdio; void main () {writeln ("NO");}
| D |
import std.stdio, std.algorithm, std.array, std.math, std.typecons, std.bigint, std.conv;
void main()
{
int k;
scanf("%d", &k);
long res1 = 2UL^^k - 2;
BigInt n = 4;
BigInt res2 = powmod(n, to!BigInt(res1), to!BigInt(10^^9 + 7));
writeln((res2 * to!BigInt(6)) % (10^^9 + 7));
} | D |
/+ dub.sdl:
name "B"
dependency "dunkelheit" version=">=0.9.0"
+/
import std.stdio, std.algorithm, std.range, std.conv;
// import dkh.foundation, dkh.scanner;
int main() {
Scanner sc = new Scanner(stdin);
scope(exit) sc.read!true;
int n;
sc.read(n);
int[][] g = new int[][](n);
foreach... | D |
module sigod.codeforces.p287A;
import std.stdio;
import std.string;
void main()
{
bool[4][4] square = read();
bool answer = solve(square);
stdout.writeln(answer ? "YES" : "NO");
}
private
bool[4][4] read()
{
bool[4][4] square;
foreach (ref line; square) {
auto tmp = stdin.readln().strip();
foreach (i; 0... | 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;
import std.ascii;
import core.stdc.stdio;
import std.algorithm;
int main()
{
int n = readInt!int;
auto a = new long[](n);
foreach(ref ai; a) ai = readInt!long;
int pos = cast(int) a.count!(ai => ai >= 0);
long[][] maxSum = new long[][](n + 1, n + 1);
maxSum[0][0] = (a[0] < 0)?... | D |
import std.algorithm;
import std.conv;
import std.array;
import std.stdio;
import std.string;
void main() {
string[][int] blocks;
readln; // to skip n
loop:
for (;;) {
auto command = readln.strip.split;
auto operation = command[0];
final switch (operation) {
case "push":
auto dst = command[1].to!int -... | 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() {
char x, y;
scan(x, y);
char ans;
if (x < y) {
ans = '<';
}
else if (x > y) {
ans = '>';
}
else {
a... | D |
void main() {
string[dchar] s;
s['a'] = readln.chomp;
s['b'] = readln.chomp;
s['c'] = readln.chomp;
dchar now = 'a';
dchar ans;
while (true) {
dchar tmp = s[now][0];
s[now] = s[now][1..$];
now = tmp;
if (s[now].length == 0) {
ans = tmp;
... | 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 N = readln.chomp.to!long;
long ans = 0;
foreach (i; 2..N) ans += i * (i + 1);
ans.wri... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto N = readln.chomp.to!int;
auto r = long.max;
foreach (x; 0..N+1) {
long rr;
auto a = x;
while (a) rr += a%6, a /= 6;
auto b = N-x;
while (b) rr... | D |
/+ dub.sdl:
name "F"
dependency "dcomp" version=">=0.7.3"
+/
import std.stdio, std.algorithm, std.range, std.conv;
// import dcomp.foundation, dcomp.scanner;
import std.typecons;
alias E = Tuple!(int, "to", int, "dist");
alias D = int;
int main() {
Scanner sc = new Scanner(stdin);
static struct ... | D |
import std.stdio;
import std.string;
import std.conv;
void main() {
string input;
while ((input = readln.chomp).length != 0) {
auto n = input.to!int;
auto sum = 0;
auto a = 2;
sum += a;
if (n >= 2) {
sum += (n+2)*(n-1)/2;
}
writeln(sum);
... | 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 = 100_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;
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;
void main() {
auto N = readln.chomp.to!int;
auto A = N.iota.map!(_ => readln.chomp.to!int - 1).array;
auto B = new... | D |
import std.algorithm;
import std.stdio;
void main ()
{
auto s = readln;
auto x = (s[0] == 'a' || s[0] == 'h');
auto y = (s[1] == '1' || s[1] == '8');
writeln (8 - 3 * (x + y) + (x * y));
}
| 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 M, D;
scan(M, D);
int... | 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 N = s[0];
auto P = s[1];
auto A = readln.split.map!(... | 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 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.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);
auto a = new int[](N);
a[] = -1;... | D |
import std.stdio;
import std.string;
void main() {
string s = readln.chomp;
if (s == "SUN") writeln(7);
if (s == "MON") writeln(6);
if (s == "TUE") writeln(5);
if (s == "WED") writeln(4);
if (s == "THU") writeln(3);
if (s == "FRI") writeln(2);
if (s == "SAT") writeln(1);
}
| 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);
writeln(n % s(n) == 0 ? "Yes" : "No");
}
int s(int n) {
return n > 0 ? s(n / 10) + n % 10 : 0;
}
... | 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.string, std.array, std.math, std.regex, std.range, std.ascii;
import std.typecons, std.functional;
import std.algorithm, std.container;
struct Qes{
char t;
char d;
}
long N;
string S;
Qes[] qs;
long calc(long s, long g)
{
long pos = (s+g)/2;
foreach(q; qs)
{
... | 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;
void main()
{
const K = readln().chomp().to!ulong();
ulong sum = 0;
foreach (i; 1 .. K + 1)
foreach (j; 1 .. K + 1)
foreach (k; 1 .. K + 1)
{
sum += gcd(gcd(i, j), k);
}
writeln(sum);
}
| D |
void main() {
auto N = ri;
ulong a = 0, b = 0;
while(4*a <= 100) {
ulong tmp = 4*a + 7*b;
while(tmp <= 100) {
if(tmp == N) {
writeln("Yes");
return;
}
b++;
tmp = 4*a + 7*b;
}
a++;
b = 0;
}
writeln("No");
}
// ===================================
import std.stdio;
import std.string;
i... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto s = readln.chomp.to!(char[]);
if (s[0] == s[$-1] && s.length%2 == 0 || s[0] != s[$-1] && s.length%2 == 1) {
writeln("First");
} else {
writeln("Second");
}
} | D |
import std.stdio, std.string, std.conv;
void main() {
int n = readln.chomp.to!int;
bool ok;
foreach (i; 1 .. 10) {
foreach (j; 1 .. 10) {
if (i * j == n) ok = true;
}
}
writeln(ok ? "Yes" : "No");
} | 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.string, std.conv;
import std.typecons;
import std.algorithm, std.array, std.range, std.container;
import std.math;
void main() {
auto input = readln.split.to!(int[]);
auto A = input[0], B = input[1], C = input[2], D = input[3];
writeln( (C%B == 0 ? C/B : C/B+1) <= (A%D == 0 ? A/D : A/D+1) ? ... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
readln;
int c;
foreach (i; readln.split.to!(int[])) if (i%2 == 1) ++c;
writeln(c%2 == 0 ? "YES" : "NO");
} | D |
/+ dub.sdl:
name "C"
dependency "dunkelheit" version=">=0.9.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);
long a, b, c, x, y;
sc.read(a, b, c, x, y);
a = min(... | 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);
int ds = digsum(n);
writeln(n % ds == 0 ? "Yes" : "No");
}
int digsum(int n) {
return n > 0 ? digsum(n / 10) + (n % 10... | 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.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 |
import std.stdio;
import std.string;
import std.conv;
import std.bigint;
import std.typecons;
import std.algorithm;
import std.array;
void main() {
auto a = readln.chomp.dup;
auto b = readln.chomp.dup;
reverse(b);
writeln(a == b ? "YES" : "NO");
}
| D |
import std.stdio, std.string, std.range, std.conv, std.array, std.algorithm, std.math, std.typecons;
void main() {
const tmp = readln.split.to!(long[]);
writeln(tmp[0] <= 8 && tmp[1] <= 8 ? "Yay!" : ":(");
}
| 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.conv;
import std.array;
void main()
{
while (1) {
int cnt = 0;
string[] input = split(readln());
int n = to!(int)(input[0]);
int x = to!(int)(input[1]);
if (n == 0 && x == 0) break;
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
... | D |
import std.stdio, std.conv, std.array, std.range, std.algorithm, std.string, std.typecons;
void main() {
auto s = readln.strip;
if (15 - s.length + s.count('o') >= 8) {
writeln("YES");
} else {
writeln("NO");
}
}
| 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;
foreach (e; s) {
if (e == '1') {
... | D |
void main() {
long[] tmp = readln.split.to!(long[]);
long n = tmp[0], a = tmp[1], b = tmp[2];
long[] x = readln.split.to!(long[]);
long result;
foreach (i; 1 .. n) {
long diff = x[i] - x[i-1];
result += min(a*diff, b);
}
result.writeln;
}
import std.stdio;
import std.string;... | D |
import std.stdio;
import std.algorithm;
import std.string;
import std.conv;
import std.math;
void main(){
bool[3] a;
a[0] = true;
a[1] = false;
a[2] = false;
while(true){
auto s = readln();
if(stdin.eof()) break;
s = chomp(s);
swap(a[to!int(s[0]-'A')],a[to!int(s[2]-'A')]);
}
for(int i=... | 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, std.format, std.datetime;
// dfmt off
T lread(T = long)(){return readln.chomp.to!T();}
T[] lreads(T = long)(long n){return generat... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
void main() {
auto S = split(readln())[0];
auto year = to!int(S[0 .. 4]), month = to!int(S[5 .. 7]), day = to!int(S[8 .. 10]);
string result = (year < 2019 || year == 2019 && month < 4 || year == 2019 && month == 4 && day <= 30) ? "Heisei" ... | D |
import std.stdio, std.string, std.conv, std.array, std.algorithm, std.range;
void main()
{
0.iota(readln.chomp.to!int+1).reduce!"a+b".writeln;
} | D |
import std.stdio;
import std.conv;
import std.string;
import std.typecons;
import std.algorithm;
import std.array;
import std.range;
import std.math;
import std.regex : regex;
import std.container;
import std.bigint;
import std.numeric;
void main()
{
auto x = readln.chomp.to!int;
while (x > 0) {
auto m = x %... | D |
/+ dub.sdl:
name "B"
dependency "dcomp" version=">=0.6.0"
+/
import std.stdio, std.algorithm, std.range, std.conv;
// import dcomp.foundation, dcomp.scanner, dcomp.algorithm;
int main() {
auto sc = new Scanner(stdin);
int[] buf = new int[1000];
int a, b;
sc.read(a, b);
foreach (i; a..b) {... | D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
auto rd = readln.split.to!(long[]), n = rd[0], m = rd[1];
auto c = min(n, m/2);
m -= c*2;
c += m/4;
writeln(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 r... | D |
import std.stdio, std.ascii;
void main() {
auto d = readln.dup;
foreach (c; d) c.isLower ? c.toUpper.write : c.toLower.write;
} | 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()
{
(48-readln.chomp.to!int).writeln;
}
| D |
import std.stdio;
import std.string;
import std.conv;
void main() {
uint[string] table;
while(true) {
string line = readln.chomp;
if (stdin.eof) break;
auto data = line.split(",");
table[data[1]] += 1;
}
foreach(type; ["A", "B", "AB", "O"]) {
if (type in table)
writeln(table[type]);
... | 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.bigint;
void main()
{
auto str1 = readln.chomp;
auto str2 = readln.chomp;
int s1, s2;
for (int i; i < str1.length; ... | 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 |
// 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.algorithm;
import std.string;
void main() {
while (true) {
int H, N;
scanf("%d %d\n", &H, &N);
if (H == 0 && N == 0) break;
const int X = 20;
auto F = new string[2][X];
foreach (i; 0 .. H) {
F[i][0] = readln.chomp;
... | 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 |
void main()
{
string s = readln.chomp;
s[0..$-8].writeln;
}
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, 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.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 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.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;
auto a = readln.chomp.... | 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() {
auto s = new bool[](10^^6 + 1);
s[] = 1;
s[0] = s[1] = 0;
for (int p = 2; p*p <= 10^^6; p++) {
if (s[p]) {
for (int q =... | D |
void main(){
auto S = readln().chomp();
auto T = readln().chomp();
if ( S[] == T[0..$-1] ){
writeln("Yes");
} else {
writeln("No");
}
}
import std;
string readStr(){
return readln().chomp();
}
T[] readLine( T = long )(){
return readln().split().to!(T[])();
} | 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.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, 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 = "%.15f";
static string[] s_rd;
T RD(T = long)() { while(!s_rd.length) s_rd = readln.chomp.split; string res = s_r... | D |
import std;
void main() {
int n; scan(n);
int m = n % 10;
if (m == 3) writeln("bon");
else if (m == 0 || m == 1 || m == 6 || m == 8) writeln("pon");
else writeln("hon");
}
void scan(T...)(ref T a) {
string[] ss = readln.split;
foreach (i, t; T) a[i] = ss[i].to!t;
}
T read(T=string)() { ret... | D |
void main()
{
long k = rdElem;
string s = rdStr;
if (s.length <= k) s.writeln;
else writeln(s[0..k], "...");
}
enum long mod = 10L^^9 + 7;
enum long inf = 1L << 60;
enum double eps = 1.0e-9;
T rdElem(T = long)()
if (!is(T == struct))
{
return readln.chomp.to!T;
}
alias rdStr = rdElem!string;
ali... | 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 x, y; readV(x, y);
writeln(... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
void main() {
char[] input = readln().dup;
input[5] = ' ';
input[13] = ' ';
input.writeln;
}
| D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto N = readln.chomp.to!int;
auto H = readln.chomp.to!int;
auto W = readln.chomp.to!int;
writeln((N - W + 1) * (N - H + 1));
} | 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.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 |
void main() {
auto O = rs, E = rs;
foreach(i; 0..O.length) {
O[i].write;
if(!(i > E.length-1)) E[i].write;
}
writeln;
}
// ===================================
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.range;
import std.traits;
import std.math;
import std.bigint;
im... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto lr = readln.split.to!(long[]);
auto L = lr[0];
auto R = lr[1]+1;
long x = long.max;
foreach (l; L..min(L+2020, R)) {
foreach (r; l+1..min(L+2020,R)) {
x = m... | 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.string;
import std.algorithm;
import std.container;
import std.range;
import core.stdc.stdlib;
import std.math;
import std.typecons;
void main() {
auto N = readln.chomp.to!int;
int[] prices;
foreach(i; 0..50000) {
auto price = cast(int)(1.08f * cast(real)i);
if ... | 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.random;
void main() {
auto x = readln.chomp.split.map!(to!int);
auto a = x[0];
auto b = x[1];
auto op = a == b ? "==" : a > b ... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
void main()
{
auto N = readln.chomp.to!int;
bool[int] data;
foreach(_; 0..N){
auto A = readln.chomp.to!int;
if(A in data)
data.remove(A);
else
data[A] = true;
}
writeln(data.... | D |
import std.stdio, std.conv, std.string, std.array, std.algorithm,
std.numeric, std.math, std.range;
void main()
{
string s = readln.strip;
long[] xs = new long[](s.length);
char prev = 'x';
bool last_even = false;
long last_marked = -1;
long next = 0;
long next_1 = 0;
foreach (i; 0... | 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 core.bitop, std.algorithm, std.ascii, std.bigint, std.conv, std.math,
std.functional, std.numeric, std.range, std.stdio, std.string, std.random,
std.typecons, std.container, std.format;
static import std.ascii;
// dfmt off
T lread(T = long)(){return readln.chomp.to!T();}
T[] aryread(T = long)(){return r... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto X = readln.chomp.to!long;
auto fs = new long[](1001);
foreach (long i; 0..1001) fs[i] = i^^5;
foreach (i; 0..1001) {
foreach (j; 0..1001) {
if (fs[i] - fs[j] ==... | D |
import std.stdio, std.string, std.conv, std.algorithm, std.math;
void main()
{
while(true)
{
auto inp = readln.split.map!(to!int);
if(!inp[0] && !inp[1] && !inp[2]) break;
real a = inp[0], b = inp[1], c = inp[2];
real r = min(a * a + b * b, b * b + c * c, c * c + a * a).sqrt;
... | 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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.