code stringlengths 4 1.01M | language stringclasses 2
values |
|---|---|
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.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto N = readln.chomp.to!int;
auto st = readln.split.to!(char[][]);
char[] u;
foreach (i; 0..N) {
u ~= st[0][i];
u ~= st[1][i];
}
writeln(u);
} | D |
import std.algorithm;
import std.array;
import std.stdio;
import std.conv;
import std.string;
import std.range;
void main(){
size_t w, h, sx, sy;
char[][] data = new char[][](20, 20);
while(true){
auto input = readln.split;
w = input[0].to!int;
h = input[1].to!int;
if(!(w | ... | D |
void main()
{
long n = readln.chomp.to!long;
long total;
for (long i = 1; i * i < n; ++i)
{
if (n % i == 0)
{
long d = n / i;
if (i == n % (d - 1)) total += d - 1;
}
}
total.writeln;
}
import std.stdio;
import std.string;
import std.array;
impor... | D |
void main(){
long x, t;
scanf("%ld %ld", &x, &t);
(x-t>0?x-t:0).writeln();
}
import std.stdio, std.conv, std.algorithm, std.numeric, std.string, std.math, std.range;
const long mod = 10^^9+7;
// 1要素のみの入力
T inelm(T= int)(){
return to!(T)( readln().chomp() );
}
// 1行に同一型の複数入力
T[] inln(T = int)(){
T... | 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],c=s[2];
if(a+b>=c)
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;
void main()
{
readln;
auto a = readln.chomp.split.map!(to!int);
auto s = new int[](100003);
f... | 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() {
readln;
auto xs = readints();
... | D |
void main() {
int[] tmp = readln.split.to!(int[]);
int x = tmp[0], a = tmp[1], b = tmp[2];
writeln(abs(x-a) < abs(x-b) ? '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.numeric;
import std.container;
i... | 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; rd(n);
auto g=new int[][](n+1, 0);
auto can=new int[](n+1);
void f(int i){
if(g[i].length==0){can[i]=0; return;}
foreach(j; g[i]) f(j);
foreach(j; g[i])if(can[j]==0){
can[i]=can[j]=1; break;
}
can[i]=max(can... | D |
import std.stdio;
import std.conv, std.array, std.algorithm, std.string;
import std.math, std.random, std.range, std.datetime;
import std.bigint;
import std.container;
string read(){ static string[] ss; while(!ss.length) ss = readln.chomp.split; string res = ss[0]; ss.popFront; return res; }
const ulong MOD = 1_000_00... | D |
void main(){
int ans = 6;
int[] ab;
ab ~= _scan();
ab ~= _scan();
foreach(elm; ab)ans -= elm;
ans.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;
fore... | 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);
auto u = s[... | D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
auto rd = readln.split.to!(int[]), a = rd[0], b = rd[1];
writeln((a + b) % 24);
}
| D |
import std.stdio, std.array, std.conv, std.string;
void main() {
string[] input = split(readln());
int W = to!int(input[0]), H = to!int(input[1]);
int x = to!int(input[2]), y = to!int(input[3]), r = to!int(input[4]);
if (r <= x && r <= (W - x) && r <= y && r <= (H - y)) {
writeln("Yes");
} else {
w... | 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!long;
auto s = readln.chomp.to!long;
long b = 2;
for (; b^^2 <= n; ++b) {
auto m = n;
long t;
while (m) {
t += m % b;
... | D |
import std.stdio, std.string;
void main() {
string input = chomp(readln());
char lastChar = ' ';
byte count = 1;
foreach(char i; input) {
if(lastChar == ' ') {
lastChar = i;
continue;
}
if(lastChar == i) {
count++;
} else {
count = 1;
lastChar = i;
}
if(count >= 3) {
writeln("Yes"... | 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 |
void main() {
string n = readln.chomp;
while (n.count(n[0]) != 3) {
n = n.succ;
}
n.writeln;
}
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 |
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();
long bignum... | 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;
void main() {
int n = readln.chomp.to!int;
int[] p = readln.split.to!(int[]);
int cnt;
foreach (i, x; p) {
if (x != i + 1) ++cnt;
}
writeln(cnt < 3 ? "YES" : "NO");
} | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto nk = readln.split.to!(long[]);
auto N = nk[0];
auto K = nk[1];
long r;
foreach (n; K+1..N+1) {
r += N/n * (n-K);
r += max(0, N - N/n * n - max(0, K-1));
}
... | 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 r, g;
scan(r);
scan(g);
writeln(2*g - r);
}
void scan(T...)(ref T args) {
string[] line = readln.split;
foreach (ref arg; args) {
... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.array;
void main(){
auto F=readln.split.to!(int[]),A=F[0],B=F[1],C=F[2];
if(A+B+C==17)writeln("YES");
else writeln("NO");
} | 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, std.bitmanip;
import std.datetime;
immutable long MOD = 10^^9 + 7;
int N, X, Y, Z, S, MASK, NG;
long[][] mem;
long dp... | D |
// Vicfred
// https://atcoder.jp/contests/abc174/tasks/abc174_d
// greedy
import std.algorithm;
import std.array;
import std.conv;
import std.stdio;
import std.string;
void main() {
const int n = readln.chomp.to!int;
string s = readln.strip;
int reds = 0;
foreach(ch; s)
if(ch == 'R')
... | D |
void main() {
problem();
}
void problem() {
auto S = scan;
auto T = scan;
long solve() {
long ans;
foreach(i; 0..S.length) {
if (S[i] != T[i]) ans++;
}
return ans;
}
solve().writeln;
}
// ----------------------------------------------
import std.stdio, std.conv, std.array, std.str... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array;
void main() {
int x, a, b;
scan(x);
scan(a);
scan(b);
writeln((x-a)%b);
}
void scan(T...)(ref T args) {
import std.stdio : readln;
import std.algorithm : splitter;
import std.conv : to;
import std... | 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(){
import std.stdio, std.string, std.conv, std.algorithm;
long A, B, C, D, E, F; rd(A, B, C, D, E, F);
A*=100; B*=100;
long tot=A, su=0;
for(long a=0; a<=F; a+=A)for(long b=0; a+b<=F; b+=B){
for(long c=0; a+b+c<=F; c+=C){
if(c*100>(a+b)*E) continue;
for(long d=0; a+b+c+d<=F; d+=D){... | 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]);
auto M = to!ulong(tokens[1]);
ulong inc = 1;
if (M % 2 == 1)
{
if (N % 2 == 0) ++N;
inc = 2;
}
ulong blocks = M... | D |
import std.conv;
import std.stdio;
import std.string;
void main()
{
auto s = readln.strip;
auto t = readln.strip;
writeln( solve( s, t ) );
}
auto solve( in string s, in string t )
{
foreach( i; 0 .. t.length )
{
auto ts = t[ i .. $ ] ~ t[ 0 .. i ];
if( s == ts ) return "Yes";
}
return "No";
}
| 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;
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 bignu... | D |
import std.algorithm, std.container, std.conv, std.math, std.range, std.typecons, std.stdio, std.string;
auto rdsp(){return readln.splitter;}
void pick(R,T)(ref R r,ref T t){t=r.front.to!T;r.popFront;}
void readV(T...)(ref T t){auto r=rdsp;foreach(ref v;t)pick(r,v);}
void main()
{
int a, b; readV(a, b);
writeln(a... | 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!long;
auto AS = readln.split.to!(long[]);
long sum_a;
foreach (a; AS) sum_a += a;
auto d = (N+1) * N / 2;
if (sum_a % d != 0) {
writeln("NO");
... | 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.random;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
void main()
{
long n = readln.chomp.to!long;
long ans = 0;
foreach... | 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.algorithm;
import std.conv;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
void main ()
{
auto tests = readln.strip.to !(int);
foreach (test; 0..tests)
{
readln.splitter.map !(to !(int)).sum.writeln;
}
}
| D |
import std.algorithm;
import std.conv;
import std.range;
import std.stdio;
import std.string;
void main ()
{
auto tests = readln.strip.to !(int);
foreach (test; 0..tests)
{
auto n = readln.strip.to !(int);
auto a = readln.splitter.map !(to !(int)).array;
int res = n - (n == 1);
foreach (i; 0..n)
{
fore... | D |
import std.stdio;
void main()
{
long n;
scanf("%lld", &n);
printf("%lld\n", n / (2 * 2 * 2* 3 * 3 * 5 * 7));
} | D |
import std.stdio : writeln, stdin;
import std.conv : to;
import std.range : dropOne;
import core.stdc.stdio;
void main()
{
int n;
scanf("%d", &n);
string ss;
int[100005] arr;
for(int i = 0 ;i < 100005; ++i){
arr[i] = 1;
}
foreach(word; stdin.byLine)
{
ss = to!strin... | D |
import std;
long calc(int n) {
long sum = 0;
for (int i = 1; i <= n; i++) {
if (i % 3 == 0 || i % 5 == 0) continue;
sum += i;
}
return sum;
}
void main() {
int n; scan(n);
writeln(calc(n));
}
void scan(T...)(ref T a) {
string[] ss = readln.split;
foreach (i, t; T) a[i]... | 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 long mod = 10^^9 + 7;
void main() {
string s = readln.chomp;
string abc = "ABC";
int n = s.length.to!int;
auto dp = new long[][](n + 1, 4);
... | D |
import std.stdio,std.conv,std.string,std.algorithm,std.array;
void main(){
auto sn=readln().split();
int n=to!int(sn[0]);
if(n<1000)
writeln("ABC");
else
writeln("ABD");
} | D |
module app;
import core.bitop;
import std.algorithm;
import std.array;
import std.bigint;
import std.container.rbtree;
import std.conv;
import std.stdio;
import std.string;
import std.traits;
struct Input
{
string s;
}
void parseInput(T)(out Input input, T file)
{
with (file) with (input)
{
s = readln().strip(... | D |
import std.stdio, std.string, std.conv, std.algorithm;
import std.range, std.array, std.math, std.typecons, std.container, core.bitop;
import std.numeric;
void main() {
int n, m;
scan(n, m);
auto adj = new int[][](m, 0);
auto ex = new bool[](m);
foreach (i ; 0 .. n) {
auto line = readln.... | 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.algorithm, std.conv, std.array, std.string, std.math, std.typecons;
int[11] NS = [59049, 46656, 7776, 6561, 1296, 729, 216, 81, 36, 9, 6];
void main()
{
auto N = readln.chomp.to!int;
int[int][11] memo;
int solve(int i, int n) {
if (n == 0) return 0;
if (i == 11) ret... | 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, M;
scan(N, M);
auto adj... | D |
// This file is a "Hello, world!" in D language by DMD for wandbox.
import std.algorithm, std.conv, std.stdio, std.array, std.math, std.string;
void main()
{
const N = readln.chomp.to!long;
const V = readln.split.map!(to!long).array;
const C = readln.split.map!(to!long).array;
long ans;
foreach (b; 0..2.pow... | D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
auto rd = readln.split.to!(long[]), n = rd[0], ts = rd[1];
auto t = readln.split.to!(long[]);
auto ans = 0L;
foreach (i; 0..n-1)
ans += t[i+1]-t[i] > ts ? ts : t[i+1]-t[i];
ans += ts;
writeln(ans);
}
| D |
void main() {
import std.stdio, std.string, std.conv, std.algorithm;
int n, d;
rd(n, d);
struct P {
int x, y;
}
P[] vec = [P(d, -d), P(n - d, n - d), P(-d, d), P(d - n, d - n)];
P[] ps = [P(0, d), P(d, 0), P(n, n - d), P(n - d, n)];
int m;
rd(m);
while (m--) {
int x, y;
rd(x, y);
i... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.range;
import std.container;
import std.bigint;
import std.math;
void main()
{
while (1) {
auto x = readln.chomp.split.map!(to!int);
if (x[0] == 0) break;
foreach (i; 0..x[0]) {
foreach (j; 0..x[1]) {
if (... | 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;
void main() {
string land = stdin.readln();
size_t position = 1;
foreach (char command; stdin.readln()) {
if (command == land[position - 1]) {
++position;
}
}
stdout.write(position);
} | D |
import std.stdio;
import std.conv;
import std.string;
import std.typecons;
import std.algorithm;
import std.array;
import std.range;
import std.math;
import std.container;
import std.datetime;
void main()
{
while (1) {
auto str = readln.chomp;
if (str == "#") break;
int i = str.length.to!int-1;
long a, b = 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;
enum mod = 10L^^9 + 7;
alias Pair = Tuple!(long, "s", long, "x");
void main() {
long n;
scan(n);
long[Pair] mem;
long func(long s, long x) {
... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm: canFind;
void main() {
string[] inputs = split(readln());
int A = to!int(inputs[0]);
int B = to!int(inputs[1]);
int C = to!int(inputs[2]);
if(C >= A && C <= B) "Yes".writeln;
else "No".writeln;
}
| D |
import std.stdio,
std.string,
std.conv;
void main() {
while(true){
string s = readln;
if (stdin.eof()) break;
int n = s.chomp.to!int;
int c = 0;
foreach(int i; 0..10)
foreach(int j; 0..10)
foreach(int k; 0..10)
foreach(int l; 0..10)
if (i + j + k + l == n){
c += 1;
}
writeln(c);
}
} | D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void main() {
string s = readln.strip;
long sm = 0, cnt = 0;
foreach(i,c;s) if(c == 'W')
sm += i - cnt++;
writeln(sm);
}
| 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;
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 bignu... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
enum CF = "CODEFESTIVAL2016";
void main()
{
auto S = readln.chomp;
int r;
foreach (i, c; S) if (c != CF[i]) ++r;
writeln(r);
} | 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);
string t; re... | 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;
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.string, std.algorithm, std.conv, std.array, std.math, std.container, std.range;
void main(){
readln.split.map!(to!int).reduce!"a-b+1".writeln;
}
| D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto ad = readln.split.to!(int[]);
auto A = ad[0];
auto B = ad[1];
auto C = ad[2];
auto D = ad[3];
for (;;) {
C -= B;
if (C <= 0) {
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 |
void main(){
int[] a = _scanln();
writeln( a.sum()>=22? "bust": "win" );
}
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()... | 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()
{
char[] input = chomp(readln).dup;
int i = 0;
foreach(e; input) {
if(e == '+') {
i += 1;
} else {
i -= 1;
}
}
writeln(i);
} | D |
import std.stdio, std.conv, std.string, std.array, std.math, std.regex, std.range, std.ascii;
import std.typecons, std.functional, std.traits;
import std.algorithm, std.container;
import core.stdc.stdlib;
long scanState()
{
auto s = scanElem!string;
if(s=="Male") return 0;
if(s=="Female") return 1;
ex... | D |
import std.stdio, std.conv, std.string;
void main() {
int [] a;
a = readln().chomp().split().to!(int[]);
if(a[0] <= 8 && a[1] <= 8)
writeln("Yay!");
else
writeln(":(");
}
| 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);
int[] x = new int[n];
foreach (i; 0..n) scanf("%d", &x[i]);
int[] y = x.dup;
y.sort;
int l = y[n/2-1], r = y[n/2];
foreach (i; 0..n) {
... | 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 |
void main() {
int[] tmp = readln.split.to!(int[]);
int d = tmp[0], n = tmp[1];
writeln(n != 100 ? 100 ^^ d * n : 100 ^^ d * (n + 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.container;
... | D |
import std.stdio;
import std.string;
import std.algorithm;
void main() {
auto s = readln.chomp;
size_t begin, end = 1, cnt;
string cache = "";
while (end < s.length) {
if (cache != s[begin..end]) {
++cnt;
cache = s[begin..end];
begin = end;
end = end + 1;
}
else {
++end;
}
}
if (cache == s... | D |
// import chie template :) {{{
import std.stdio, std.algorithm, std.array, std.string, std.math, std.conv,
std.range, std.container, std.bigint, std.ascii, std.typecons, std.format;
// }}}
// nep.scanner {{{
class Scanner {
import std.stdio : File, stdin;
import std.conv : to;
import std.array : split;
impor... | 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 cmp(string a, strin... | D |
import std.stdio,std.conv, std.string;
void main(){
if(readln.chomp.to!int == 1){
writeln("Hello World");}
else{
auto a = readln.chomp.to!int;
auto b = readln.chomp.to!int;
writeln(a+b);}
} | D |
import std.stdio, std.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.string;
import std.conv;
void main(){
int n = stdin.readln.chomp.to!int;
int money = 100_000;
while(n--){
money = cast(int)(money * 1.05);
if(money % 1_000)
money = money - (money % 1_000) + 1_000;
}
writeln(money);
} | 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 u = s[1] - 1;
auto v = s[2] - 1;
... | 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[]);
const a = tmp[0], b = tmp[1], c = tmp[2], d = tmp[3];
writeln(abs(a-c) <= d || (abs(a-b) <= d && abs(b-c) <= d) ? "Yes" : "No");
}
| D |
import std.stdio;
import std.algorithm;
import std.string;
import std.range;
string[dchar] code1;
dchar[string] code2;
void main() {
code1[' '] = "101";
code1['\''] = "000000";
code1[','] = "000011";
code1['-'] = "10010001";
code1['.'] = "010001";
code1['?'] = "000001";
code1['A'] = "100101";
code1['B'] = "10... | D |
import std.stdio, std.string, std.conv;
import std.array, std.algorithm, std.range;
void main()
{
foreach(_;0..readln().chomp().to!int())
{
bool f=true;
auto a=int.min, b=a;
foreach(v;readln().split().map!(to!int))
if(v>a) a=v;
else if(v>b) b=v;
else{... | D |
void main(){
string[] st = _scanln!string();
writeln(st[1], st[0]);
}
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()){
... | 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.stdio;
import std.string;
void main ()
{
long [] a;
while ((a = readln.splitter.map !(to !(long)).array) != [])
{
auto n = readln.strip.to !(long);
foreach (i, c; a)
{
if (i > 0)
{
a[i] = min (a[i], a[i - 1] * 2);
}
}
writeln... | D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
auto n = readln.chomp.to!size_t;
auto s = readln.chomp;
auto isValid(bool[] sw)
{
foreach (i; 2..n)
sw[i] = sw[i-1] ^ (s[i-1] != 'o') ^ sw[i-2];
return ((sw[$-1] ^ (s[$-1] != 'o') ^ sw[$-2]) == sw[0] &&
... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
void main() {
int N = readln.chomp.to!(int);
int[] a = readln.chomp.split.to!(int[]);
int ans;
for (int i = 0; i < a.length - 1; i++) {
if (a[i] == a[i + 1]) {
ans += 1;
i += 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 = 100_100, MOD = 1_000_000_007, INF = 1_000_000_000_000;
alias sread = () => readln.chomp();
alias lread(T = long) = () ... | 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, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto N = readln.chomp.to!long;
if (N == 2) {
writeln(1);
return;
}
int res;
long d;
for (d = 2; d^^2 < N; ++d) {
if (N % d == 1) {
auto dd = ... | D |
import std.stdio, std.string, std.array, std.conv;
void main() {
auto a = readln.chomp.split.to!(int[]);
writeln(a[0] < a[1] && a[1] < a[2] ? "Yes" : "No");
}
| D |
void main(){
import std.stdio, std.string, std.conv, std.algorithm;
int n, m; rd(n, m);
auto g=new int[][](n, 0);
foreach(_; 0..m){
int a, b; rd(a, b);
a--; b--;
g[a]~=b; g[b]~=a;
}
auto c=new int[](n);
fill(c, -1);
bool dfs(int i, int w, int p=-1){
c[i]=w;
bool ret=true;
for... | D |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.