code stringlengths 4 1.01M | language stringclasses 2
values |
|---|---|
import std.stdio, std.conv, std.string, std.math;
void main()
{
int input = to!int(chomp(readln()));
int i = 1;
if(input==1) {
writeln(1);
return;
}
while (pow(i, 2) <= input) {
i++;
}
writeln(pow(i-1, 2));
}
| D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto rgbn = readln.split.to!(int[]);
auto R = rgbn[0];
auto G = rgbn[1];
auto B = rgbn[2];
auto N = rgbn[3];
int ret;
foreach (r; 0..3001) {
foreach (g; 0..3001) {
... | D |
void main() {
import std.stdio, std.string, std.conv, std.algorithm;
int n, l, a;
rd(n, l, a);
auto s = new int[](n), t = new int[](n);
foreach (i; 0 .. n)
rd(s[i], t[i]);
long cnt = 0;
foreach (i; 1 .. n) {
cnt += (s[i] - (s[i - 1] + t[i - 1])) / a;
}
if (n > 0) {
cnt += (s[0]) / a;
... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.range;
void main()
{
auto s1 = split(readln());
bool flag;
foreach (ind; 0 .. to!int(s1[0]))
{
auto s2 = split(readln);
if (!s2.find("C").empty || !s2.find("M").empty || !s2.find("Y").empty)
{
flag = true;
break;
... | 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 |
// Code By H~$~C
module main;
import std.stdio, std.array, std.string, std.math, std.uni, std.format, std.bigint;
import std.algorithm, std.conv, std.container, std.range, std.functional;
import std.random, std.typecons;
// FIXME
int[] buildZ(in string s) {
int n = cast(int)(s.length);
int[] z; z.length = n;
f... | D |
import std.stdio;
import std.string;
void main ()
{
string s;
while ((s = readln.strip) != "")
{
long res = 0;
foreach (pos; 1..s.length + 1)
{
res += !(s[pos - 1] & 3);
if (pos > 1 && !((s[pos - 2] * 2 + s[pos - 1]) & 3))
{
res += pos - 1;
}
}
writeln (res);
}
}
| D |
import std.stdio, std.string, std.conv, std.algorithm;
import std.range, std.array, std.math, std.typecons;
immutable int inf = 10^^9 + 7;
int N, W;
int[] v, w;
void main() {
scan(N, W);
int vi, wi;
auto v = new int[](N);
auto w = new int[](N);
foreach (i ; 0 .. N) {
scan(vi, wi);
... | D |
import std.stdio, std.algorithm, std.conv, std.string, std.array, std.math;
void main()
{
const r = readln.chomp.to!int;
(r*r).writeln;
} | 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() {
string s;
scan(s);
if (s.canFind("AC")) {
writeln("Yes");
}
else {
writeln("No");
}
}
void scan(T...)(ref T args) {
strin... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array;
import std.math : abs;
void main() {
int n;
scan(n);
int t, x, y;
bool ok = 1;
foreach (i ; 0 .. n) {
int ti, xi, yi;
scan(ti, xi, yi);
int dt = ti - t;
int dist = abs(xi - x) + a... | D |
import std.stdio;
import std.ascii;
import std.conv;
import std.string;
import std.algorithm;
import std.range;
import std.functional;
import std.math;
import core.bitop;
void main()
{
auto nm = readln.chomp.split.map!(to!long);
long n = nm[0];
long m = nm[1];
auto A = readln.chomp.split.map!(to!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 main()
{
string x, y; readV(x, y);
writeln(x > y ? ">" : x < y ? "<" : "=");
}
| D |
import std.stdio;
import std.conv;
import std.string;
import std.typecons;
import std.algorithm;
import std.array;
import std.range;
import std.math;
import std.regex : regex;
import std.container;
import std.bigint;
void main()
{
readln.chomp.count!(x=>x=='1').writeln;
}
| D |
import std.stdio, std.algorithm, std.range, std.conv, std.string;
import core.stdc.stdio;
// foreach, foreach_reverse, writeln
void main() {
int n;
scanf("%d", &n);
int[] a = new int[n];
int[] b = new int[n];
foreach (i; 0..n) scanf("%d", &a[i]);
foreach (i; 0..n) scanf("%d", &b[i]);
int ans = 0;
foreach (k; 0... | D |
// Vicfred
// https://atcoder.jp/contests/abc176/tasks/abc176_b
// implementation
import std.stdio;
import std.string;
void main() {
string n = readln.strip;
int sum = 0;
foreach(ch; n) {
sum += ch - '0';
sum %= 9;
}
if(sum == 0)
"Yes".writeln;
else
"No".writel... | 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, std.algorithm;
void main()
{
auto ip = readln.split.to!(int[]), a = ip[0], b = ip[1];
int s = max(a+b, a-b, a*b);
writeln(s);
} | D |
import std.stdio, std.array, std.conv, std.string, std.range, std.algorithm;
void main() {
long n = readln.strip.to!(long);
string s = readln.strip;
long l = 0, r = s.length - 1;
while (l < s.length && s[l] == '.') {
l++;
}
while (r >= 0 && s[r] == '#') {
r--;
}
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;
immutable long MOD = 10^^9 + 7;
long powmod(long a, long x, long m) {
long ret = 1;
while (x) {
if (x % 2) ret = ret * a %... | D |
import std.stdio, std.typecons, std.algorithm;
alias Tuple!(int, "top", int, "bottom") Bundle;
const int INF = (1 << 24);
void main() {
int times; scanf("%d", ×);
int[][] dp = new int[][](times, times);
Bundle[] cards;
foreach(i; 0..times) {
int top, bottom; scanf("%d %d", &top, &bottom);
cards... | 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 s; readV(s);
writeln(min(... | 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;
class InputReader {
private:
ubyte[] p;
ubyte[] buffer;
size_t cur;
public:
this () {
buffer = uninitializedArray!(ubyte[])(16<<20);
p = stdin.rawRead ... | D |
import std.stdio;
import std.conv;
import std.string;
import std.typecons;
import std.algorithm;
import std.array;
import std.range;
import std.math;
import std.regex : regex;
import std.container;
void main()
{
int[string] cnt;
string len;
auto str = readln.split;
foreach (s; str) {
if (s.length > len.length) {... | 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.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(){
import std.stdio, std.string, std.conv, std.algorithm;
int n; rd(n);
auto d=new int[](n);
foreach(i; 0..n) rd(d[i]);
bool ok=true;
void f(){
int r=0;
foreach(int i, int e; d){
ok&=i*10<=r;
chmax(r, i*10+e);
}
}
f();
reverse(d);
f();
if(ok) writeln("yes");
... | 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;
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;
long MOD = 10L^^9+7;
long f(long x, long y)... | D |
import std.algorithm;
import std.array;
import std.conv;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
immutable int letters = 26;
string solve (string s)
{
auto n = s.length.to !(int);
if (n == letters)
{
auto t = s.dup;
if (nextPermutation (t.representation))
{
auto r = t.i... | D |
import std.stdio, std.string, std.conv, std.algorithm, std.numeric;
import std.range, std.array, std.math, std.typecons, std.container, core.bitop;
void main() {
int n, q;
scan(n, q);
while (q--) {
int vi, wi;
scan(vi, wi);
solve(n, vi, wi);
}
}
void solve(int n, int v, int w... | D |
import std.stdio,std.conv,std.string;
void main(){
auto n=readln.chomp.to!int;
(n%2==0?n/2:n/2+1).writeln;
} | D |
import std.functional,
std.algorithm,
std.bigint,
std.string,
std.traits,
std.array,
std.range,
std.stdio,
std.conv;
void main() {
ulong[] NM = readln.chomp.split.to!(ulong[]);
ulong N = NM[0],
M = NM[1];
ulong x = 1900*M + 100*(N - M);
ulong p = ... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.array;
import std.range;
import std.math;
import std.regex;
void main(){
auto a=readln.split.to!(int[]),n=a[0],k=a[1];
if(n%k>0)writeln(1);
else if(n%k==0)writeln(0);
} | D |
import std.algorithm;
import std.array;
import std.conv;
import std.math;
import std.range;
import std.stdio;
import std.string;
auto a = ["SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"];
void main() {
auto s = readln.strip;
foreach (i; 0 .. a.length) {
if (a[i] == s) {
writeln (7 - i);
break;
... | 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 T = readln.chomp;
auto N = S.length.to!int;
auto M = T.length.t... | D |
import std.stdio, std.string, std.range, std.conv, std.algorithm, std.typecons;
void main(){
alias Tuple!(int, int) Data;
int N, M;
auto input = readln.split.map!(to!int);
N = input[0], M = input[1];
int[] A = new int[N]; //?????¨
foreach (i; 0..N) {
A[i] = readln.chomp.to!int;
}
int[] vote = new int[N];
for... | D |
import std.algorithm;
import std.array;
import std.conv;
import std.numeric;
import std.stdio;
import std.string;
void main()
{
long n;
long sum;
n = readln.chomp.to!(long);
sum = 0;
for (long i = 1; i <= n; i++) {
for (long j = 1; j <= n; j++) {
for (long k = 1; ... | D |
import std.stdio;
import std.ascii;
import std.conv;
import std.string;
import std.algorithm;
import std.range;
import std.functional;
import std.math;
import core.bitop;
void main()
{
auto n = readln.chomp.to!long;
foreach (seven; 0 .. (n / 7 + 1))
{
if ((n - (7 * seven)) % 4 == 0)
{
... | 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 readC(T...)(size_t n,ref T t){foreach(ref v;t)... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array, std.typecons, std.container;
import std.math, std.numeric, core.bitop;
void main() {
int n;
scan(n);
auto s = readln.chomp;
int e, w;
foreach (i ; 0 .. n) {
if (s[i] == 'E') e++;
}
int ans = 1<<3... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string;
void main()
{
auto str = readln.split(" ");
writeln(
str[0][$-1] == str[1][0] && str[1][$-1] == str[2][0] ? "YES" : "NO"
);
} | 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.array;
import std.string;
import std.conv;
import std.algorithm;
import std.typecons;
import std.range;
import std.random;
import std.math;
import std.container;
void main() {
auto input = readln.split.map!(to!int);
int W = input[0];
int H = input[1];
int N = input[2];
int[4] A =... | 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 n; readV(n);
int k; readV(k);
auto r = 10^^9;
foreach (i; 0..1<<n) {
auto d =... | D |
import std.stdio, std.algorithm, std.range, std.conv, std.string, std.math;
import core.stdc.stdio;
// foreach, foreach_reverse, writeln
class BIT {
int[] data;
this(int n) {
data = new int[n+1];
}
BIT dup() {
BIT ret = new BIT(to!int(data.length));
ret.data = data.dup;
return ret;
}
void add(int i, int ... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math;
void main()
{
auto it = readln.split.to!(int[]);
auto A = it[0];
auto B = it[1];
auto C = it[2];
auto X = it[3];
auto Y = it[4];
int cost;
if (A + B > C*2) {
if (X > Y) {
cost += 2 * Y * C;... | D |
import std.stdio, std.conv, std.string;
void main()
{
int N = to!int(chomp(readln()));
string str = to!string(N);
int count;
foreach(char chr; str) {
count += to!int(chr)-48;
}
if(N % count == 0) {
writeln("Yes");
} else writeln("No");
}
| D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
int n;
foreach (c; readln.chomp) {
if (c == '+') {
++n;
} else {
--n;
}
}
writeln(n);
} | D |
import std.stdio, std.conv, std.functional, std.string;
import std.algorithm, std.array, std.container, std.range, std.typecons;
import std.numeric, std.math, std.random;
import core.bitop;
string FMT_F = "%.10f";
static string[] s_rd;
T RD(T = long)() { while(!s_rd.length) s_rd = readln.chomp.split; string res = s_r... | D |
import std.stdio;
import std.array;
import std.string;
import std.conv;
import std.algorithm;
import std.typecons;
import std.range;
import std.random;
import std.math;
import std.container;
void main() {
auto S = readln.chomp;
char c = S[0];
int ans = 0;
foreach (s; S)
if (s != c) {
ans += 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, 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.conv, std.algorithm, std.string, std.numeric, std.range;
void main() {
string s;
while( (s=readln.strip).length != 0 ){
auto as = s.to!int;
if(as == 0) break;
int ans = 0;
while(0 < as){
ans += as/5;
as /= 5;
}
writeln(ans);
}
} | D |
import std.algorithm;
import std.array;
import std.conv;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
void scan(T...)(ref T a) {
string[] ss = readln.split;
foreach (i, t; T) a[i] = ss[i].to!t;
}
T read(T)() { return readln.chomp.to!T; }
T[] reads(T)() { return r... | D |
import std.stdio, std.conv, std.string, std.range, std.typecons, std.format;
import std.algorithm.searching, std.algorithm.sorting, std.algorithm.iteration, std.algorithm.mutation;
void main()
{
string input = readln().strip();
foreach(c; input)
{
write(c=='1'?'9':'1');
}
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 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.algorithm;
import std.conv;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
int solve (string s)
{
auto n = s.length.to !(int);
s ~= ".?!";
auto f = new int [3] [n + 4];
f[1][1] = 1;
f[2][2] = 1;
foreach (i; 0..n)
{
foreach (j; 1..3)
{
if (f[i][j])
{
f[i + 3 ... | D |
import std.algorithm;
import std.array;
import std.conv;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.bitmanip;
void main() {
immutable n = readln.strip.to!int;
auto s = readln.strip;
BitArray m1, m2, m3;
m1.length = 10;
m2.length = 100;
m3.length = 1000;
debug stder... | D |
import std.algorithm;
import std.array;
import std.stdio;
import std.numeric;
import std.conv;
void main(){
auto input = readln.split.map!(to!int);
gcd(input[0], input[1]).writeln;
} | D |
import std.stdio;
import std.algorithm;
import std.conv;
import std.numeric;
import std.math;
import std.string;
void main()
{
auto tokens = split(chomp(readln()));
auto N = to!ulong(tokens[0]);
if (N == 1) writeln("Hello World");
else
{
auto a = to!int(chomp(readln()));
auto b = to!int(chomp(readln()));
w... | 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;
ulong MOD = 1_000_000_007;
ulong INF = 1_000_00... | D |
import std.stdio, std.string, std.conv;
import std.algorithm, std.array;
auto solve(string s_) {
immutable N = s_.to!int();
auto ab = new long[2][N];
foreach(ref v;ab) v = readln.split.map!(to!long).array();
long c=0;
foreach_reverse(ref v;ab) {
immutable a=v[0], b=v[1];
c+=(b-(a+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 n... | 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.string,
std.stdio,
std.algorithm;
void main() {
char[] s = readln.chomp.dup.reverse;
writeln(s);
} | 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;
int sum;
auto i = 1;
while (s... | D |
void main(){
string s = readln().chomp();
if(s.count('a') == 1 && s.count('b') == 1 && s.count('c') == 1){
writeln("Yes");
}else{
writeln("No");
}
}
import std.stdio, std.conv, std.algorithm, std.numeric, std.string, std.math, std.range;
// 1要素のみの入力
T inelm(T= int)(){
return to!(T)( 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 |
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() {
long a, b;
scan(a, b);
writeln(a / gcd(a, ... | D |
import std.algorithm;
import std.conv;
import std.stdio;
import std.string;
void main() {
string[] b_type = [ "A", "B", "AB", "O" ];
int[string] b_counter;
foreach (b; b_type) {
b_counter[b] = 0;
}
foreach (string line; stdin.lines) {
string b = line.chomp.split(",")[1];
b_counter[b]++;
}
f... | D |
import std.stdio, std.string, std.conv, std.bigint, std.typecons, std.algorithm, std.array, std.math, std.range;
void main() {
auto N = readln.chomp.to!int;
writeln(N / 10 == 9 || N % 10 == 9 ? "Yes" : "No");
} | D |
import std.stdio,std.string,std.array,std.algorithm,std.range,std.conv;
int main(){
auto s=readln.chomp;
auto n=s.length;
if(s.equal(s.retro)){
auto s1=s[0..(n-1)/2];
if(s1.equal(s1.retro)){
auto s2=s[(n+3)/2-1..$];
if(s2.equal(s2.retro)){
"Yes".write... | 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);}
const mod = 10^^9+7;
void main()
{
int n; readV... | 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 (_t; 0..T) {
auto N = readln.chomp.to!long;
long a = 2L^^N, b;
foreach (i; 1..N/2) {
a += 2L^^i;
}
forea... | D |
import std.functional,
std.algorithm,
std.bigint,
std.string,
std.traits,
std.array,
std.range,
std.stdio,
std.conv;
void main() {
ulong N = readln.chomp.to!ulong;
ulong[] a = readln.chomp.split.to!(ulong[]);
ulong[ulong] h;
foreach (e; a) {
if (e in... | 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_007;
void main() {
int a, b;
scan(a, b);
if ((a + b) % 2) {... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric, std.container, std.range;
void get(Args...)(ref Args args)
{
import std.traits, std.meta, std.typecons;
static if (Args.length == 1) {
alias Arg = Args[0];
static if (isArray!Arg) {
... | D |
import std.stdio, std.conv, std.string, std.array, std.range, std.algorithm, std.container;
import std.math, std.random, std.bigint, std.datetime, std.format;
import std.typecons, std.regex;
void main() {
auto s = read.to!string;
writeln(s[0..$-8]);
}
string read() {
static string[] ss;
while (!ss.len... | D |
import std.stdio;
import std.string;
import std.conv;
void main() {
int times = readln.chomp.to!(int);
foreach(t; 0..times) {
dchar[] line = readln.chomp.dup.to!(dchar[]);
if ( line.length >= 6) {
for(uint i = 0; i < line.length - 6; i++) {
if (line[i..(i + 7)] == "Hoshino") {
line... | 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 H, A;
scan(H, A);
int ans = (H + A - 1... | 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.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.conv;
import std.algorithm;
import std.array;
import std.range;
void main(){
auto N=readln.chomp.to!int;
auto A=readln.chomp.to!int;
if(N%500<=A)writeln("Yes");
else if(N%500>A)writeln("No");
} | D |
import std.stdio, std.string, std.conv, std.array, std.algorithm;
void main()
{
auto q = readln.chomp.to!int;
for(int i=0;i<q;++i){
auto b = readln.split.map!(to!int);
int c=b[0],a=b[1],n=b[2];
int ans=0;
if(a<n){
ans+=min(c,a);
c=max(0,c-ans);
a=max(0,a-ans);
n=max(0,n-ans);... | D |
void main(){
string s = readln().chomp();
string t = readln().chomp();
if( s==t[0..s.length] && t[s.length..$].length==1 ){
writeln("Yes");
}else{
writeln("No");
}
}
import std.stdio, std.conv, std.algorithm, std.numeric, std.string, std.math;
// 1要素のみの入力
T _scan(T= int)(){
return to!(T)( readln().chomp() )... | D |
import std.stdio, std.string, std.range, std.conv, std.array, std.algorithm, std.math, std.typecons;
void main() {
auto S = readln.chomp;
auto T = readln.chomp;
char[char] c0, c1;
foreach (i; 0..S.length) {
const s = S[i];
const t = T[i];
if (s !in c0 && t !in c1) {
... | 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 H = input[0];
int W = input[1];
input = r... | 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.stdc.stdio;
import std.algorithm;
void main(){
int s,t;
scanf("%d%d",&s,&t);
char[] x = new char[s+1],y=new char[t+1];
scanf("%s%s",x.ptr,y.ptr);
int[][][] dp = new int[][][](2,s+1,t+1);
foreach(d;dp[0])
d[]=-1145141919;
foreach(i;0..s+1)
foreach(j;0..t+1){
if(i<s)
if(x[i]=='I')
dp[0... | D |
/+ dub.sdl:
name "D"
dependency "dunkelheit" version="1.0.1"
+/
import std.stdio, std.algorithm, std.range, std.conv;
// import dkh.foundation, dkh.scanner, dkh.numeric.prime;
int main() {
Scanner sc = new Scanner(stdin);
scope(exit) assert(!sc.hasNext);
debug {
foreach (n; 3..1001) {
... | D |
import std.stdio;
void main() {
string[] weather = ['S' : "Cloudy", 'C' : "Rainy", 'R' : "Sunny"];
weather[readln[0]].writeln;
} | D |
void main() {
import std.stdio, std.string, std.conv, std.algorithm;
int n;
rd(n);
auto s = readln.chomp.to!(char[]);
auto bf = new int[](26), af = new int[](26);
int kind = 0;
foreach (c; s) {
af[c - 'a']++;
if (af[c - 'a'] == 1) {
kind++;
}
}
int ans = 0, mod = 998244353;
for (... | 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, std.algorithm;
void main() {
enum cs = "MARCH";
size_t[char] d;
foreach (c; cs) {
d[c] = 0;
}
foreach (s; stdin.byLine) {
if (s[0] in d) {
++d[s[0]];
}
}
size_t ret = 0;
foreach (i, c0; cs[0..$-2]) {
if (d[c0] == 0) continue;... | D |
void main()
{
long[] tmp = readln.split.to!(long[]);
long a = tmp[0], b = tmp[1], c = tmp[2];
writeln(a + b >= c - 1 ? b + c : 2 * b + a + 1);
}
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.c... | D |
import std.stdio : writeln;
void main() {
int a,b,c,d;
scan(a,b,c,d);
if (a+b > c+d) {
writeln("Left");
}
else if (a+b < c+d) {
writeln("Right");
}
else {
writeln("Balanced");
}
}
void scan(T...)(ref T args) {
import std.stdio : readln;
import std.a... | D |
import std.stdio, std.conv, std.string, std.algorithm;
void main() {
writeln(readln.split.to!(uint[]).reduce!"a*b" % 2 == 0 ? "Even" : "Odd");
}
| D |
void main()
{
string s = rdStr;
long len = s.length;
long l, r = len - 1;
long cnt;
while (l < r)
{
if (s[l] == s[r])
{
++l, --r;
}
else
{
if (s[l] == 'x')
{
++cnt;
++l;
}
... | D |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.