code stringlengths 4 1.01M | language stringclasses 2
values |
|---|---|
void main() {
int n = readln.chomp.to!int;
string s = readln.chomp;
int cnt;
foreach (i; 1 .. n) {
int tmp;
foreach (x; lowercase) {
if (s[0..i].canFind(x) && s[i..$].canFind(x)) {
++tmp;
}
}
cnt = max(cnt, tmp);
}
cnt.write... | 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()
{
ulong n = readln.chomp.to!ulong;
ulong[] a = readln.ch... | 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";
// riteln(s[0 .. 7]);
// if (s[0 .. 7] == key)
// {
... | D |
import std.stdio;
import std.array;
import std.string;
import std.container;
import std.ascii;
import std.random;
import std.algorithm;
import std.conv;
import std.range;
import std.math;
import std.format;
import std.typecons;
import std.numeric;
import std.datetime;
/*
??????????????????, ?????§??¨?????¨, ??¨?????... | 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 n, k;
scan(n, k);
int ans = n - k + 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(); } bool DEBUG = 0;
void log(A ...)(lazy A a){ if(DEBUG) print(a); }
voi... | 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 a = readln.chomp.split.map!(to!int);
writeln = max(0, a[0] - a[1]);
... | 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.split.to!(int[]);
((ip[0] + ip[1]) ... | D |
void main(){
string[] s = inln!string();
string ans;
foreach(elm; s)ans ~= elm[0];
ans.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行に同一型の複数入力... | 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, a, b; readV(n, a, b);
writeln(min(n*a, b));
}
| 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;
auto input()
{
return readln().chomp();
}
alias sread = () => readln.chomp();
void main()
{
long h, m;
scan(h, m);
auto s = new string[](h);
foreach (i; 0 .. h)
{
s[i] = sread();
}
//writeln(s);
foreach (i; 0 .. h)
{
foreach (j; 0 .. m)
{
... | 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((... | D |
import std.stdio, std.conv, std.string;
import std.algorithm, std.array, std.container;
import std.numeric, std.math;
import core.bitop;
T RD(T)() { static string[] ss; while(!ss.length) ss = readln.chomp.split; string res = ss[0]; ss.popFront; return res.to!T; }
string RDR()() { return readln.chomp; }
long mod = pow... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
auto Px = [-1, 0, 1, 0];
auto Py = [ 0, 1, 0,-1];
void main()
{
auto line = split(readln()).map!(a => to!int(a));
int z = 0;
auto ret = solve(line[z++], line[z++], line[z++], line[z++], line[z++]);
writeln(ret ? "Yes" : "No... | 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 ip = readln.split.to!(ulong[]);
immutable n = ip[0], x = ip[1];
immutable ls = readln.split.to!(ulong[]);
ulong cnt = 0;
ulong xi =... | 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, std.string, std.conv, std.algorithm, std.numeric;
import std.range, std.array, std.math, std.typecons, std.container, core.bitop;
void main() {
long a, b, x, y, z;
scan(a, b);
scan(x, y, z);
writeln(max(0, 2*x + y - a) + max(0, y + 3*z - b));
}
void scan(T...)(ref T args) {
str... | D |
void main(){
import std.stdio, std.string, std.conv, std.algorithm;
long x, y; rd(x, y);
long count(long st, long ed){
if(st>ed) return 0;
long ret=1;
while(st*2<=ed) st*=2, ret++;
return ret;
}
writeln(max(count(x, y), count(x+1, y)));
}
void rd(T...)(ref T x){
import std.stdio, std... | D |
void main() {
import std.stdio, std.string, std.conv, std.algorithm;
int n;
rd(n);
struct P {
int y, x;
}
auto xs = new int[](n), ys = new int[](n);
bool[P] seen;
foreach (i; 0 .. n) {
rd(xs[i], ys[i]);
if (i > 0) {
seen[P(xs[i], ys[i])] = true;
}
}
auto vy = new int[](n), vx... | 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() {
string INF = "|";
string[] input;
while(true) {
inp... | D |
import std.stdio, std.string, std.conv;
void main()
{
int a,b;
scanf("%d %d",&a, &b);
writeln(2*b-a);
}
| D |
import std.stdio;
import std.string;
import std.algorithm;
void main() {
readln;
auto a = readln.chomp.dup;
int count;
int left, right = cast(int)a.length - 1;
for (;;) {
while (left < a.length) {
if (a[left] == 'W') {
break;
}
++left;
}
while (right >= 0) {
if (a[right] == 'R') {
brea... | D |
import std.stdio;
import std.string;
import std.range;
import std.conv;
void main()
{
auto X = readln.chomp.to!int;
auto A = readln.chomp.to!int;
auto B = readln.chomp.to!int;
writeln((X-A)%B);
} | D |
import std.stdio, std.conv, std.string, std.math, std.regex, std.range, std.ascii, std.algorithm;
void main(){
auto N = readln.chomp.to!int;
auto K = readln.chomp.to!int;
auto X = readln.chomp.to!int;
auto Y = readln.chomp.to!int;
if(N-K <= 0){
writeln(N*X);
}else{
writeln(K*X + (N-K)*Y);
}
} | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto ab = readln.split.to!(int[]);
auto A = ab[0];
auto B = ab[1];
writeln(max(0, A - B*2));
} | D |
void main() {
writeln(readln.chomp.to!int ^^ 2 - readln.chomp.to!int);
}
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.string, std.conv, std.algorithm;
import std.range, std.array, std.math, std.typecons, std.container, core.bitop;
void main() {
int A, B, C, D, E, F;
scan(A, B, C, D, E, F);
int ans_w = 100*A, ans_s = 0;
foreach (x ; 0 .. 31) {
foreach (y ; 0 .. 31) {
int wat... | D |
import std.stdio,std.string,std.conv,std.algorithm;
void main(){
while(1){
auto rd = readln().chomp();
if(rd){
auto v = to!double( rd );
auto t = v/9.8;
auto y = 4.9*t*t;
for(int i=1;i<100000;i++){
if( y <= 5*i-5 ){
writeln(i);
break;
}
}
}else{
break;
}
}
} | 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;
auto as=readln.split.map!(to!long).array;
long fromNega;
long fromPosi;
long current... | D |
import std.stdio;
import std.conv;
import std.array;
import std.string;
import std.algorithm;
int main(string[] argv)
{
while (1)
{
auto s = readln().chomp().split().map!(to!int);
int mf = s[0] + s[1];
if (s[0] + s[1] + s[2] == -3) break;
if (s[0] == -1 || s[1] == -1) writeln("F");
else if (80 ... | 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 n; long x; readV(n, x);
aut... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto S = readln.chomp;
long solve(size_t i, long sum) {
if (i == S.length) return sum;
long r;
foreach (j; i+1..S.length+1) {
r += solve(j, sum + S[i..j].to!l... | D |
import std.stdio : writeln;
void main()
{
foreach(i; 1..10){
foreach(j; 1..10){
writeln(i, "x", j, "=", i*j);
}
}
} | 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.conv, std.array, std.algorithm, std.string;
import std.math, std.random, std.range, std.datetime;
import std.bigint;
int n;
void main(){
n = readln.chomp.to!int;
bool[][] xss;
foreach(i; 0 .. n){
xss ~= readln.chomp.map!(x => (x == '#')).array;
}
int donecolumncount = 0;
foreach(... | D |
import std.stdio,std.string,std.conv,std.array;
void main(){
//for(;;){
auto rc = readln().chomp();
auto transTable1 = makeTrans("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
writeln( translate(rc, transTable1) );
//}
} | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons;
long[] make_lucas()
{
long[] ls = [2,1];
for (int i = 2; i < 87; ++i) {
ls ~= ls[i-1] + ls[i-2];
}
return ls;
}
enum LS = make_lucas();
void main()
{
writeln(LS[readln.chomp.to!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.chomp;
auto T = readln.chomp;
long hatena = 0;
foreach (s; S) if (s == '?') ... | 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 par=new int[](n);
par[0]=-1;
foreach(int i; 1..n){
int p; rd(p);
par[i]=(p-1);
}
auto leaf=new bool[](n);
foreach(i; 0..n){
auto c=count(par, i);
if(c==0) leaf[i]=true;
}
foreach(i; 0..n)if(leaf[... | 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 solve() {
auto N = readln.chomp.to!int;
auto S = readln.chomp;
int pos = -1;
foreach (i; 0..N) if (S[... | D |
import std.stdio;
import std.range;
import std.array;
import std.string;
import std.conv;
import std.typecons;
import std.algorithm;
import std.container;
import std.typecons;
import std.random;
import std.csv;
import std.regex;
import std.math;
import core.time;
import std.ascii;
import std.digest.sha;
import std.outb... | D |
import std.stdio, std.array, std.string, std.conv, std.algorithm;
import std.typecons, std.range, std.random, std.math, std.container;
import std.numeric, std.bigint, core.bitop, std.bitmanip;
void main() {
auto s = readln.split.map!(to!long);
auto N = s[0];
auto K = s[1];
long x = K % 2 == 1 ? K / 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 |
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, std.numeric;
import std.range, std.array, std.math, std.typecons, std.container, core.bitop;
void main() {
string s, t;
scan(s);
scan(t);
int n = s.length.to!int, m = t.length.to!int;
auto dp = new int[][](n + 1, m + 1);
foreach (i ; 1 ..... | D |
import std;
void main()
{
const N = readln().chomp().to!long();
ulong sum = 0;
foreach (i; 1 .. N + 1)
{
if (i % 3 == 0) continue;
if (i % 5 == 0) continue;
sum += i;
}
writeln(sum);
} | 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.string, std.array, std.math, std.regex, std.range, std.ascii;
import std.typecons, std.functional;
import std.algorithm, std.container;
void scanValues(TList...)(ref TList list)
{
auto lit = readln.splitter;
foreach (ref e; list)
{
e = lit.fornt.to!(typeof(e));
... | 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 x, a;
scan(x, a);
writeln(x < a ? 0 : 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.stdio;
import std.conv;
import std.string;
import std.algorithm;
import std.array;
void main() {
auto tmp = readln.split.map!(s => s.chomp[0]).array;
auto X = tmp[0];
auto Y = tmp[1];
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()
{
auto n = readln.chomp.to!int;
int[string] words;
auto f = true;
auto prev = re... | 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() {
auto s = iota(3).map!(i => readln.chomp.map!(ch => ch - 'a').array... | D |
import core.bitop, std.algorithm, std.ascii, std.bigint, std.conv, std.math,
std.functional, std.numeric, std.range, std.stdio, std.string, std.random,
std.typecons, std.container, std.format;
// dfmt off
T lread(T = long)(){return readln.chomp.to!T();}
T[] lreads(T = long)(long n){return generate(()=>readln.c... | D |
import std.algorithm, 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, c; readV(a, b, c);
wri... | 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 N = readln.chomp;
int s;
foreach (c; N) s += (c - '0').to!int;
writeln(s%9 == 0 ? "Yes" : "No");
} | 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 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();
void main(... | D |
import std.stdio,std.conv,std.string;
void main(){
foreach(_;0..readln.chomp.to!int){
int point,base,_out;
while(1){
final switch(readln.chomp){
case "HIT":
if(base==3)++point;
else ++base;
break;
... | D |
void main()
{
long[] tmp = readln.split.to!(long[]);
long n = tmp[0], t = tmp[1];
long[] a = readln.split.to!(long[]);
long x = t;
foreach (i; 0 .. n-1)
{
x += min(t, a[i+1]-a[i]);
}
x.writeln;
}
import std.stdio;
import std.string;
import std.array;
import std.conv;
import st... | 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 lo = int.max;
int hi = 0;
bool ok = true;
for... | 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;
long n, s;
void main() {
scan(n);
scan(s);
if (n == s) {
writeln(n + 1);
return;
}
for... | 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, c; readV(a, b, c);
au... | 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.array;
void main()
{
auto reader = readln.split;
int N = reader[0].to!int;
int K = reader[1].to!int;
string S = readln.chomp;
int[] cnt;
int beforeI = 0;
if (S[0] == '0') cnt ~= 0;
foreach (i; 0..N){
if (S[i] != S... | D |
void main() {
import std.stdio, std.string, std.conv, std.algorithm;
int n;
rd(n);
auto s = readln.chomp.to!(char[]);
int sum = 0;
foreach (c; s[1 .. $]) {
if (c == 'E')
sum++;
}
auto mn = sum;
foreach (i; 1 .. n) {
if (s[i - 1] == 'W')
sum++;
if (s[i] == 'E')
sum--;
... | 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.typecons;
import std.algorithm;
import std.array;
import std.range;
import std.math;
import std.regex : regex;
import std.container;
import std.bigint;
import std.ascii;
void main()
{
auto s = readln.chomp;
auto f = true;
if (!(s.length % 2)) {
... | D |
void main() {
import std.stdio, std.string, std.conv, std.algorithm;
auto s = readln.chomp.to!(char[]);
char[] t;
foreach (i; 0 .. (s.length)) {
if (i % 2 == 0) {
t ~= s[i];
}
}
writeln(t);
}
void rd(T...)(ref T x) {
import std.stdio : readln;
import std.string : split;
import std.con... | D |
import std;
alias sread = () => readln.chomp();
alias lread = () => readln.chomp.to!long();
alias aryread(T = long) = () => readln.split.to!(T[]);
void main()
{
auto n = lread();
auto a = aryread();
auto ans = new long[](2 * (10 ^^ 5) + 10);
foreach (i; 0 .. n - 1)
{
ans[a[i]] += 1;
}
... | D |
import std.stdio,std.string,std.array;
void main(){
string line,sw;
size_t total=0;
sw = readln().chomp();
while( 1 ){
line = readln().chomp();
if( line == "END_OF_TEXT" ){ break; }
foreach( w ; line.split() ){
if( toLower(w) == toLower(sw) ) total++;
}
}
writeln( total );
} | 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;
void position(int n, int row, int col, char[6][1000] rows)
{
rows[row][col] = rows[row][col + 1] = '+';
printf("YES\n");
for (int i = 0; i < n; i++) {
printf("%s\n", rows[i].ptr);
}
}
void main()
{
int n;
scanf("%d", &n);
char[6][1000] rows;
for (int i = 0; i < n; i++) {
scanf("%s", ro... | 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(){
(readln.chomp.to!int / 3).writeln;
} | D |
import std.stdio, std.conv, std.string;
import std.algorithm, std.array, std.container;
import std.numeric, std.math;
import core.bitop;
string my_readln() { return chomp(readln()); }
long mod = pow(10, 9) + 7;
long moda(long x, long y) { return (x + y) % mod; }
long mods(long x, long y) { return ((x + mod) - (y % mo... | 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 |
/+ dub.sdl:
name "D"
dependency "dcomp" version=">=0.7.3"
+/
import std.stdio, std.algorithm, std.range, std.conv;
// import dcomp.foundation, dcomp.scanner;
// import dcomp.algorithm;
int main() {
Scanner sc = new Scanner(stdin);
int n, k;
sc.read(n, k);
int[2][] p = new int[2][n];
fore... | D |
// Cheese-Cracker: cheese-cracker.github.io
void theCode(){
ll n = scan;
ll tim = (n / 2) * 5;
if(n % 2 != 0) tim += 5;
tim = max(tim, 15);
writeln(tim);
}
void main(){
long tests = scan; // Toggle!
while(tests--) theCode();
}
/********* That's All Folks! *********/
import std.st... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array, std.math;
void main() {
int a, b, c, x, y;
scan(a, b, c, x, y);
int ans = 1<<30;
foreach (i ; 0 .. 2 * 10^^5 + 1) {
int xr = max(0, x - i / 2);
int yr = max(0, y - i / 2);
int tmp = xr * a + yr... | D |
import std.algorithm;
import std.container;
import std.conv;
import std.functional;
import std.math;
import std.meta;
import std.random;
import std.range;
import std.stdio;
import std.string;
import std.traits;
import std.typecons;
void main() {
int ans = 0;
foreach (c; readln.chomp)
if (c == '+')
ans++... | 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 c = new string[](2);
c[0] = readln.chomp;
c[1] = readln.chomp;
string ans = (equal(c[0], c[1].retro)) ? "YES" : "NO";
writeln(ans... | 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()
{
while(true)
{
int num = readln.chomp.to!int, cnt;
if(!num)break;
while(num) cnt += num /= 5;
cnt.writeln;
}
} | 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.concurrency;
import std.traits;
import std.uni;
import c... | 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.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.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;
string result;
while (n != 0)
{
long m = n % -2;
// writeln([n,m]);
... | 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;
void main() {
auto N = readln.chomp.to!ulong;
ulong answer = N-1;
for(ulong i = 1; i * i <= N; i++) {
if (N % i != 0) continue;
auto j = N/i;
au... | D |
void main() {
int x = readln.chomp.to!int;
int d = x / 100, r = x % 100;
writeln(d >= (r + 4) / 5 ? 1 : 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;
import std.typecons;
imp... | D |
import std.stdio, std.string, std.conv;
import std.array, std.algorithm, std.range;
void main()
{
int c=0;
foreach(s;stdin.byLine())
{
bool f=true;
foreach(i;0..s.length/2+1)
if(s[i]!=s[$-i-1])
{ f=false;break;}
if(f) ++c;
}
writeln(c);
} | D |
import std.stdio;
import std.string;
import std.conv;
import std.range;
import std.array;
import std.algorithm;
void main(){
auto S=readln.chomp;
if(S[0]=='a' && S[1]=='b' && S[2]=='c')writeln("Yes");
else if(S[0]=='a' && S[1]=='c' && S[2]=='b')writeln("Yes");
else if(S[0]=='b' && S[1]=='a' && S[2]=='c')writel... | D |
import std.stdio;
import std.string;
import std.conv;
void main() {
while (true) {
auto input = readln().split;
if (input.length == 0) break;
writeln(to!int(input[0]) + to!int(input[1]));
}
} | D |
void main() {
writeln(48 - readln.chomp.to!int);
}
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 |
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 adapter)
{
with (input)
{
s = adapter.readln();
}
}
... | D |
import std.stdio, std.string, std.range, std.conv, std.array, std.algorithm, std.math, std.typecons, std.functional;
void main() {
readln.chomp.to!int.pipe!(K => (K+1)/2 * (K/2)).writeln;
}
| D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array;
void main() {
int a, b;
scan(a, b);
auto map = new char[][](100, 100);
fillAll(map, '.');
foreach (i ; 0 .. 50) {
foreach (j ; 0 .. 50) {
map[i][j] = '#';
}
}
a--;
foreac... | D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
auto s = readln.chomp;
writeln(s.canFind('9') ? "Yes" : "No");
}
| D |
import std.stdio, std.algorithm, std.conv, std.array, std.string;
void main()
{
auto a = readln.chomp.to!int;
auto b = readln.chomp.to!int;
auto h = readln.chomp.to!int;
writeln((a + b) * h / 2);
} | D |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.