code stringlengths 4 1.01M | language stringclasses 2
values |
|---|---|
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons;
void main()
{
auto S = readln.chomp.to!(wchar[]);
if (S[0] != 'A') {
writeln("WA");
return;
}
auto len = S.length;
int C;
foreach (i, c; S) {
if (!i) continue;
if (i >= 2 &&... | 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[] tmp = readln.split.to!(int[]);
int w = tmp[0], a = tmp[1], b = tmp[2];
writeln(abs(b-a) > w ? abs(b-a) - w : 0);
}
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.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() {
auto N = readln.chomp.map!(ch => (ch - ... | D |
void main()
{
int n = readln.chomp.to!int;
int[] s = new int[n];
foreach (i; 0 .. n)
{
s[i] = readln.chomp.to!int;
}
bool[] dp = new bool[10001];
dp[0] = true;
foreach (p; s)
{
foreach_reverse (i, d; dp)
{
if (d)
{
dp[i... | 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.array, std.conv, std.string, std.algorithm, std.math;
void main() {
while (true) {
auto input = readln.chomp.split.map!(to!int);
auto h = input[0];
auto w = input[1];
if (h == 0 && w == 0) { break; }
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
... | 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 ip = readln.chomp;
writeln(ip.count("o")*100+... | 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;
import std.string;
void main()
{
string S = readln.chomp;
ulong len = S.length;
ulong ans = 0;
foreach (i; 0..len){
if (S[i] != '0' + (i % 2)) ans++;
}
if ((len - ans) < ans) ans = len - ans;
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;
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;
import std.string;
import std.conv;
import std.array;
import std.algorithm;
import std.range;
void main(){
auto Q=readln.split.to!(int[]),a=Q[0],b=Q[1],c=Q[2];
if(b-a==c-b)writeln("YES");
else writeln("NO");
} | D |
import std.stdio;
import std.string;
import std.format;
import std.conv;
import std.typecons;
import std.algorithm;
import std.functional;
import std.bigint;
import std.numeric;
import std.array;
import std.math;
import std.range;
import std.container;
import std.ascii;
import std.concurrency;
import std.traits;
import... | D |
import std;
auto input()
{
return readln().chomp();
}
alias sread = () => readln.chomp();
alias aryread(T = long) = () => readln.split.to!(T[]);
void main()
{
string s;
s = input();
// writeln(s);
string key;
key = "keyence";
foreach (i; 0 .. key.length + 1)
{
string tmp = s[... | D |
void main() {
int[] tmp = readln.split.to!(int[]);
int r = tmp[0], d = tmp[1], x = tmp[2];
foreach (i; 0 .. 10) {
x = r * x - d;
x.writeln;
}
}
import std.stdio;
import std.string;
import std.array;
import std.conv;
import std.algorithm;
import std.range;
import std.typecons; | D |
import std.algorithm;
import std.array;
import std.conv;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
void main ()
{
string s;
while ((s = readln.strip) != "")
{
s = readln.strip;
writeln (s.count ('R') > s.count ('B') ? "Yes" : "No");
}
}
| D |
// import chie template :) {{{
static if (__VERSION__ < 2090) {
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,
std.bitmanip, std.numeric;
} else {
import std;
}
// }}}
// nep.scanner {{{
class Scanner {
... | 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 x = readln.chomp.split.to!(int[]);
if (x[0]+x[1]<x[2]) {
writeln("No");
... | D |
// tested by Hightail - https://github.com/dj3500/hightail
import std.stdio, std.string, std.conv, std.algorithm;
import std.range, std.array, std.math, std.typecons, std.container, core.bitop;
import std.datetime, std.bigint;
int n;
int[][] adj;
void main() {
scan(n);
adj = new int[][](n, 0);
int ai, bi... | D |
import core.bitop;
import std.algorithm;
import std.array;
import std.ascii;
import std.container;
import std.conv;
import std.format;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
void main()
{
auto v = readln.chomp.split.map!(to!int);
int x = v[0];
int a = v[1];
... | 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.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.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto S = readln.chomp.to!(char[]);
auto front = S[0..2];
auto rear = S[2..$];
auto front_ok = front != "00" && front.to!int <= 12;
auto rear_ok = rear != "00" && rear.to!int <= 12;
... | D |
import std.stdio,std.conv,std.string,std.array;
void main(){
auto a=readln.chomp.split;
int x = to!int(a[0]), y = to!int(a[1]);
writeln( x*y , " " , (x+y)*2);
} | D |
import std.stdio, std.conv, std.string, std.bigint;
import std.math, std.random, std.datetime;
import std.array, std.range, std.algorithm, std.container, std.format;
string read(){ static string[] ss; while(!ss.length) ss = readln.chomp.split; string res = ss[0]; ss.popFront; return res; }
void main(){
long l = read.... | 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;
}
int calc(int n, bool[][] adj) {
auto refs = new ... | D |
import std.stdio;
import std.algorithm;
import std.string;
import std.conv;
void main() {
int n, x;
scanf("%d %d\n", &n, &x);
auto ls = readln.chomp.split.to!(int[]);
int d, cnt;
foreach(l; ls) {
d += l;
++cnt;
if (d > x) {
cnt.write;
return;
}
}
write(n+1);
}
| 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, W;
scan(N, W);
auto 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;
alias sread = () => readln.chomp();
ulong bignu... | 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()
{
long[] input = readln().split.to!(long[]);
long A = input[0];
long B = input[1];
write... | 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 n = lread();
auto a = aryread();
// writeln(a);
aut... | D |
import std.stdio;
import std.conv, std.array, std.algorithm, std.string;
import std.math, std.random, std.range;
import std.bigint;
void main(){
long[] ins = readln.chomp.split.map!(to!long).array;
long n = ins[0], x = ins[1];
long y = n - x;
long a, b;
if(x > y) a = x, b = y;
else a = y, b = x;
long ... | D |
import std.stdio, std.string, std.conv, std.array, std.algorithm;
void main() {
auto a = readln.split.map!(to!int);
int count = 0;
foreach (i; a[0]..a[1]+1) if (a[2] % i == 0) count++;
writeln(count);
} | 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, std.bitmanip;
// }}}
// nep.scanner {{{
class Scanner {
import std.stdio : File, stdin;
import std.conv : to;
import std.array : ... | 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;
final class InputReader {
private:
ubyte[] p, buffer;
bool eof;
bool rawRead () {
if (eof) {
return fals... | D |
void main()
{
dchar[] s = rdDchar;
dchar[] t = rdDchar;
long pos = t.length - 1;
bool ok;
foreach_reverse (long i, x; s)
{
if (x == t[pos] || x == '?')
{
bool check;
if (i - pos >= 0)
{
check = true;
foreach (j;... | D |
import std.stdio;
import std.array;
import std.conv;
void main()
{
while (1) {
auto input = split(readln());
switch (input[1]) {
case "+":
writeln(to!(int)(input[0]) + to!(int)(input[2]));
break;
case "-":
writeln(to!(int)(in... | D |
import std.stdio, std.algorithm, std.conv, std.string, std.array, std.math;
void main()
{
readln;
const s = readln.chomp;
if (s.length%2 == 0 && s[0..$/2] == s[$/2..$]) {
"Yes".writeln;
return;
}
"No".writeln;
} | D |
/+ dub.sdl:
name "hello"
+/
import std.algorithm;
import std.conv;
import std.stdio;
import std.string;
void main()
{
auto N = readln.chomp.to!int;
auto A = readln.chomp.to!int;
writeln(N * N - A);
}
| D |
import std.stdio;
import std.algorithm;
import std.range;
import std.conv;
import std.format;
import std.array;
import std.math;
import std.string;
import std.container;
import std.numeric;
void main() {
int N, M;
readlnTo(N, M);
long ans = 1;
for (long i = 1; i * i <= M; i++) {
if (M % i != 0)
cont... | 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 s = readln.chomp;
auto t = readln.chomp;
auto res = false;
foreach (i; 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.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto av = readln.split.to!(long[]);
auto A = av[0];
auto V = av[1];
auto bw = readln.split.to!(long[]);
auto B = bw[0];
auto W = bw[1];
auto T = readln.chomp.to!long;
if... | D |
import std.stdio;
void main(){
foreach(i; 1 .. 10){
foreach(j; 1 .. 10){
writeln(i, "x", j, "=", i * j);
}
}
} | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric, std.container, std.range;
void main()
{
auto xkd = readln.split.to!(long[]);
auto X = xkd[0];
auto K = xkd[1];
auto D = xkd[2];
X = abs(X);
if (X/D >= K) {
writeln(X - K*D);
re... | 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 a = readln.chomp.split.to!(int[]);
int odd, ev... | 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();
alias Point... | 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;
int s;
long number (string str) {
auto l = s;
s++;
while (str[s] >= '0' && str[s] <= '9') s++;
return str[l..s].to!long... | D |
import std.stdio;
import std.typecons;
void main()
{
int r, c, n, k;
scanf("%d%d%d%d", &r, &c, &n, &k);
Tuple!(int, int)[] alts = new Tuple!(int, int)[n];
for (int i = 0; i < n; i++)
scanf("%d%d", &alts[i][0], &alts[i][1]);
int res = 0;
for (int i = 1; i <= r; i++)
for (int j = 1; j <= c; j++)
for... | 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 k, p;
scan(k, p);
if (p == 1) {
writeln(0);
return;
}
long ans;
foreach (i ; 1 .. k + 1) {
long zcy =... | D |
import std.stdio :write, writeln;
import std.array;
import std.range;
import std.typecons;
import std.algorithm : max, min;
string[] src = [
"111111101010101111100101001111111",
"100000100000000001010110001000001",
"101110100110110000011010001011101",
"101110101011001001111101001011101",
"10111010110001100011110010101... | D |
module main;
import core.stdc.stdio;
int main(string[] argv) {
int n = 0;
scanf("%d", &n);
if((n & 1) == 1) {
n -= 3;
putchar('7');
}
for(int i = 0; i < n; i += 2)
putchar('1');
return 0;
}
| 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, std.bitmanip;
// }}}
// nep.scanner {{{
class Scanner {
import std.stdio : File, stdin;
import std.conv : to;
import std.array : ... | 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;
void main(){
int n, t;
{
int[] tmp = readln.chomp.split.map!(to!int).array;
n = tmp[0], t = tmp[1];
}
int[] as = readln.chomp.split.map!(to!int).array;
int[] bs;... | D |
void main() {
auto N = ri;
if(N <= 999) {
"ABC".writeln;
} else {
"ABD".writeln;
}
}
// ===================================
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.range;
import std.traits;
import std.math;
import std.container;
import std.bigint;
import std.nume... | 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;
import std.regex;
void main(){
//auto io = new IO();
char[][char] card;
card['a'] = str();//io.rect!char()[0];
card['b'] = str();
card['c'] = str();
char[char] ptr;
ptr['a']=ptr['b']=ptr['c']=0;
//= ["a":0,"b":0,"c":0];
char target = 'a';
foreach( i ; 0..100*100*100+10 ){
auto now = p... | D |
import core.bitop, std.algorithm, std.ascii, std.bigint, std.conv, std.math,
std.functional, std.numeric, std.range, std.stdio, std.string, std.random,
std.typecons, std.container;
// dfmt off
T lread(T = long)(){return readln.chomp.to!T();}
T[] aryread(T = long)(){return readln.split.to!(T[])();}
void scan(TL... | D |
import std.stdio, std.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 a, b, c;
scan(a, b, c);
auto ans = mi... | 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.string, std.array, std.conv, std.algorithm, std.typecons, std.range, std.container, std.math, std.algorithm.searching, std.functional,std.mathspecial;
void main(){
auto N=readln.chomp.to!int;
if(N==1){
writeln(1);
return;
}
long[int] divs;
auto primes=get_pri... | D |
void main()
{
long x = rdElem;
bool op(long len, long cnt)
{
if (len <= 2) return cnt <= x;
return op((len-1)>>1, cnt+1);
}
long ok, ng = inf;
while (ng - ok > 1)
{
long m = (ok + ng) >> 1;
if (op(m, 0)) ok = m;
else ng = m;
}
ok.writeln;
}
... | 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.stdio;
import std.string;
import std.algorithm;
import std.conv;
void main() {
int N=to!int(chomp(readln()));
string[] input=split(readln());
int ans=1<<30;
foreach(item;input) {
int A=to!int(item);
int cnt=0;
while(A%2==0) A/=2,cnt++;
ans=min(ans,cnt);
}
writeln(ans);
}
| 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 n = lread();
auto h = aryread();
foreach (i; 0 .. (n - ... | D |
import std.stdio;
import std.conv;
import std.string;
void main()
{
string s = chomp(readln()); // ??????????????????
long l = to!long(s);
writeln(l*l*l);
} | D |
void main() {
int[] tmp = readln.split.to!(int[]);
int a = tmp[0], b = tmp[1], c = tmp[2];
writeln(a <= c && c <= b ? "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;
i... | 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;
import std.conv;
import std.string;
import std.algorithm;
import std.range;
void main()
{
auto input = readln.split.to!(int[]);
auto N = input[0];
auto M = input[1];
ulong X;
( 2 ^^ M * (M * 1900 + (N - M) * 100) ).writeln;
} | D |
import std.stdio, std.conv, std.string, std.algorithm,
std.math, std.array, std.container, std.typecons;
void main() {
auto sw = readln.chomp.split.to!(int[]);
if(sw[0]<=sw[1]) writeln("unsafe");
else writeln("safe");
}
| 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, k;
scan(n, k);
writeln(n % k == 0 ? 0 : 1);
}
void scan(T...)(ref T args) {
import std.stdio : re... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
enum R = [
"SUN": 7,
"MON": 6,
"TUE": 5,
"WED": 4,
"THU": 3,
"FRI": 2,
"SAT": 1
];
void main()
{
writeln(R[readln.chomp]);
} | 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.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.array;
import std.conv;
import std.math;
import std.numeric;
import std.stdio;
import std.string;
void main()
{
long n = readln.chomp.to!long;
for (long cake = 0; cake <= 100; ++cake)
{
for (long donuts = 0; donuts <= 100; ++donuts)
{
if (cake * ... | D |
import std.stdio,std.conv,std.string;
void main(){
bool[9][9] m;
foreach(y;0..8){
foreach(x,c;readln.chomp){
m[y*2][1+x*2]=c=='1';
}
foreach(x,c;readln.chomp){
m[y*2+1][x*2]=c=='1';
}
}
int x,y,dir=6;
while(true){
final switch(dir){
... | D |
module app;
import core.bitop;
import std.algorithm;
import std.array;
import std.bigint;
import std.conv;
import std.stdio;
import std.string;
struct Input
{
int n;
}
void parseInput(T)(out Input input, T file)
{
with (file) with (input)
{
auto single = readln().strip();
n = single.to!int;
}
}
struc... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm: canFind;
void main() {
string[] inputs = split(readln());
string A = inputs[0];
string B = inputs[1];
string C = inputs[2];
if(A[$-1] == B[0] && B[$-1] == C[0]) "YES".writeln;
else "NO".writeln;
}
| 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.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;
void main() {
string s = read!string;
writeln(s.canFind('7') ? "Yes" : "No");
}
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 readln.split.to!(T[]); }
alias readint = read!int;... | D |
import std.stdio, std.conv, std.array,std.string,std.algorithm;
void main()
{
auto n=readln.chomp.to!int,k=readln.chomp.to!int;
int i,ans=1;
for(i=0;i<n;i++){
ans=min(2*ans,ans+k);
}
writeln(ans);
} | 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 s = readln.chomp;
auto k = readln.chomp.to!long;
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;
void main()
{
auto u = readln.chomp, A = u[0], B = u[1], C = u[2];
auto s = readln.chomp, D = s[0], E = s[1], F = s[2];
if(A == F && B == E && C == D){
writeln("YES");
} else {
writeln("NO");
}
} | D |
import std.stdio, std.conv, std.string, std.bigint;
import std.math, std.random, std.datetime;
import std.array, std.range, std.algorithm, std.container, std.format;
string read(){ static string[] ss; while(!ss.length) ss = readln.chomp.split; string res = ss[0]; ss.popFront; return res; }
/*
行列累乗 有向パス 数え上げ
--------... | 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 core.bitop, std.algorithm, std.ascii, std.bigint, std.conv, std.math,
std.functional, std.numeric, std.range, std.stdio, std.string, std.random,
std.typecons, std.container;
// dfmt off
T lread(T = long)(){return readln.chomp.to!T();}
T[] aryread(T = long)(){return readln.split.to!(T[])();}
void scan(TL... | D |
import std.stdio;
import std.conv;
import std.string;
import std.typecons;
import std.algorithm;
import std.array;
import std.range;
import std.math;
import std.regex : regex;
import std.container;
import std.bigint;
import std.numeric;
void main()
{
auto n = readln.chomp.to!long;
long res = (10L^^12)+1;
... | 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;
void main(string[] args){ if(args.length > 1) if(args[1] == "-debug") DEBUG = 1; solve(); }
void log()(){ writeln(""); } void log(T, A ...)(T t, lazy A a){ if(DE... | 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 L;
string s, t;
scan(L);
scan(s);
scan(t);
if (s > t) {
swap(s, t);
}
if (s == t[0 .. s.length]) {
st... | D |
import std.stdio,std.string,std.conv;
int main()
{
string s;
int count = 0;
while((s = readln.chomp).length != 0)
{
if(s.length == 1)
{
count++;
}
else
{
bool flag = true;
foreach(i;0..s.length/2)
{
if(s[i] != s[s.length - i - 1])
{
flag = false;
}
}
if(flag)
{
... | 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;
void main() {
auto s = readln.split.map!(to!int);
auto N = s[0];
auto M = s[1];
auto A = new int[](N+1);
foreach (i; 0.... | D |
void main(){
int r = _scan();
if( r<1200 )writeln("ABC");
else if( r<2800 )writeln("ARC");
else writeln("AGC");
}
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;
for... | D |
import std.stdio;
import std.string;
void main(){
string str = chomp(readln());
int len = cast(int)str.length;
char[1000] str2;
foreach(i; 0 .. len){
str2[i] = str[len - i - 1];
}
str2[len] = '\0';
writeln(str2);
} | 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 x; readV(x);
auto c = 0;
... | D |
import std.stdio, std.conv, std.array, std.string, std.algorithm, std.container, std.range, core.stdc.stdlib, std.math, std.typecons, std.numeric;
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 .. $].combin... | D |
import std.stdio,std.conv, std.algorithm, std.container,std.array,std.range,std.string,std.typecons;
const dx = [1,0,-1,0];
const dy = [0,1,0,-1];
void read(T...)(auto ref T args){
auto line = readln().split();
foreach(i,ref arg; args) arg = line[i].to!(typeof(arg));
}
int sum(int n){return n * (n + 1)/ 2;}
void ma... | D |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.