code stringlengths 4 1.01M | language stringclasses 2
values |
|---|---|
import std.algorithm,
std.string,
std.array,
std.range,
std.stdio,
std.conv;
void main() {
string s = readln.chomp;
writeln(s[0], s[1..$-1].length, s[$-1]);
}
| D |
import std.stdio, std.algorithm, std.range, std.conv, std.string, std.math, std.container, std.typecons;
import core.stdc.stdio;
// foreach, foreach_reverse, writeln
void main() {
int n, k;
scanf("%d%d", &n, &k);
long ans = 0;
long f(long x) {
return x*x*x;
}
ans += f(n/k);
if (k%2 == 0) ans += f((n+k/2)/k);
... | D |
import std.stdio, std.string, std.conv, std.algorithm;
void main() {
auto d = readln.chomp.to!(char[]);
d.reverse;
d.to!string.writeln;
} | 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;
bool solve() {
auto s = readln.split.map!(to!int);
auto P = s[0];
auto Q = s[1];
auto A = s[2];
auto N = s[3];
if (P... | 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 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.range, std.conv, std.string, std.array, std.functional, std.math;
import std.algorithm.comparison, std.algorithm.iteration, std.algorithm.mutation, std.algorithm.searching, std.algorithm.setops, std.algorithm.sorting;
import std.container.binaryheap;
import std.typecons;
void main()
{
const ... | D |
import std.functional,
std.algorithm,
std.container,
std.typetuple,
std.typecons,
std.bigint,
std.string,
std.traits,
std.array,
std.range,
std.stdio,
std.conv;
void main() {
int[] NK = readln.chomp.split.to!(int[]);
int N = NK[0],
... | 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; }
void main(){
long n = read... | D |
import std.stdio;
import std.string;
import std.range;
import std.conv;
void main()
{
auto N = readln.chomp;
if(N[0]=='9' || N[1]=='9'){
writeln("Yes");
}else{
writeln("No");
}
}
| D |
import std.stdio, std.conv, std.string, std.algorithm, std.math, std.array;
bool p(string s) {
for(int i=0; i<s.length/2; i++) {
if(s[i] != s[$-1-i]) return false;
}
return true;
}
bool q(string s) {
return p(s) && p(s[0..$/2]);
}
void main() {
string s = readln[0..$-1];
if(q(s)) writeln("Yes");
el... | D |
import std.stdio, std.string, std.array, std.conv, std.algorithm;
long P = 10^^9+7;
void main()
{
auto n = readln.chomp.to!long;
long ret = 1;
foreach (i; 0..n) {
ret *= i + 1;
ret %= P;
}
writeln(ret);
} | D |
import std.stdio,std.ascii,std.conv,std.string,std.algorithm,std.range,std.functional,std.math,core.bitop;
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 |
void main(){
import std.stdio, std.conv, std.string, std.algorithm;
long n, a, b, k; rd(n, a, b, k);
const long mod=998244353;
const int M=1_000_00*4;
auto fact=new long[](M);
fact[0]=fact[1]=1;
foreach(i; 2..M) fact[i]=i*fact[i-1]%mod;
auto inv_fact=new long[](M);
long powmod(long a, long x){
i... | D |
import std.algorithm;
import std.array;
import std.conv;
import std.math;
import std.stdio;
import std.string;
import std.range;
int readint() {
return readln.chomp.to!int;
}
int[] readints() {
return readln.split.map!(to!int).array;
}
void main() {
int n = readint();
int ans = 1;
while (ans * 2... | D |
/+ dub.sdl:
name "A"
dependency "dcomp" version=">=0.7.3"
+/
import std.stdio, std.algorithm, std.range, std.conv;
// import dcomp.foundation, dcomp.scanner;
int main() {
Scanner sc = new Scanner(stdin);
string s;
sc.read(s);
writeln(s[0..$-8]);
return 0;
}
/* IMPORT /home/yosupo/Program/d... | D |
import core.bitop, std.algorithm, std.ascii, std.bigint, std.conv, std.math,
std.functional, std.numeric, std.range, std.stdio, std.string, std.random,
std.typecons, std.container, std.format;
// dfmt off
T lread(T = long)(){return readln.chomp.to!T();}
T[] lreads(T = long)(long n){return generate(()=>readln.c... | D |
import std.stdio, 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, m;
scan(n, m);
auto adj = new int[... | D |
import std.algorithm,
std.string,
std.array,
std.range,
std.stdio,
std.conv;
void main() {
int[] nm = readln.chomp.split.to!(int[]);
int n = nm[0],
m = nm[1];
writeln((n - 1) * (m - 1));
}
| 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;
int[] AS;
foreach (_; 0..N) AS ~= readln.chomp.to!int;
int[] cs;
foreach (a; AS) {
if (cs.empty || cs[$-1] >= a) {
cs ~= a;
... | D |
import std.stdio, std.string, std.array, std.conv;
void main() {
int n = readln.chomp.to!int;
int[] point = new int[2];
foreach (i; 0 .. n) {
string[] tmp = readln.chomp.split;
if (tmp[0] == tmp[1]) {
point[] += 1;
} else if (tmp[0] < tmp[1]) {
point[1] += 3;... | D |
import core.stdc.stdio;
import std.stdio;
import std.algorithm;
static immutable int unSet=-114514;
struct Data{
int a,l,r,m;
}
Data Comb(const ref Data a,const ref Data b){
Data r;
r.a=a.a+b.a;
r.l=max(a.l,a.a+b.l);
r.r=max(a.r+b.a,b.r);
r.m=max(a.m,b.m,a.r+b.l);
return r;
}
struct Node{
Node* l,r,p;
int d... | 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;
int[int][10^^5 + 1] MEMO;
void main()
{
auto s = readln.chomp;
int v, p;
foreach (gp; s) {
switch (gp) {
case 'g':
if (p == 0) {
++p;
} else {
--p;... | D |
void main() {
problem();
}
void problem() {
auto K = scan!int;
long solve() {
int unitMod = 7 % K;
if (unitMod == 0) return 1;
int mod = unitMod;
foreach(i; 0..K) {
mod = (mod * 10) + unitMod;
mod %= K;
if (mod == 0) return 2 + i;
}
return -1;
}
solve... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string;
void main()
{
auto abck = readln.split.to!(long[]);
auto A = abck[0];
auto B = abck[1];
auto K = abck[3];
writeln(K&1 ? B - A : A - B);
} | D |
/* imports all std modules {{{*/
import
std.algorithm,
std.array,
std.ascii,
std.base64,
std.bigint,
std.bitmanip,
std.compiler,
std.complex,
std.concurrency,
std.container,
std.conv,
std.csv,
std.datetime,
std.demangle,
std.encoding,
std.exception,
std.file,
std.format,
std.functi... | D |
import std.stdio, std.conv, std.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.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 T = readln.chomp.to!int;
while (T--) {
auto X = readln.chomp.to!long;
auto 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;
switch (N[$-1]) {
case '3': writeln("bon"); return;
case '0':
case '1':
case '6':
case '8': writeln("pon"); return;
default... | 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 = readln.chomp.to!int;
int[] ts, as;
foreach(i; 0 .. n){
int[] tmp = readln.chomp.split.map!(to!int).array;
ts ~= tmp[0], as ~= tmp[1];
}
lo... | 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.string, std.range, std.conv, std.array, std.algorithm, std.math, std.typecons;
void main() {
const tmp = readln.split.to!(long[]);
writeln(tmp[0] < tmp[2] && tmp[2] < tmp[1] || tmp[0] > tmp[2] && tmp[2] > tmp[1] ? "Yes" : "No");
}
| D |
import std.stdio, std.conv, std.string;
void main() {
int N = readln().chomp().to!(int);
long [256] cnt;
foreach(i; 0..256) cnt[i] = 0;
foreach(i; 0..N) {
string S;
S = readln();
cnt[S[0]]++;
}
long res = 0;
string m = "MARCH";
foreach(i; 0..5) {
foreach(j; (i+1)..5) {
foreach(k; (j+1)..5) {
re... | D |
import core.bitop, std.algorithm, std.ascii, std.bigint, std.conv, std.math,
std.functional, std.numeric, std.range, std.stdio, std.string, std.random,
std.typecons, std.container, std.format;
// dfmt off
T lread(T = long)(){return readln.chomp.to!T();}
T[] lreads(T = long)(long n){return generate(()=>readln.c... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto T = readln.chomp.to!int;
foreach (_; 0..T) {
auto S = readln.chomp;
int max_l, l;
foreach (c; S) {
if (c == 'L') {
l += 1;
... | D |
import std.stdio, std.conv, std.functional, std.string;
import std.algorithm, std.array, std.container, std.typecons;
import std.numeric, std.math;
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_rd[0]; s_rd.popFront; re... | 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;
import core.bitop : popcnt;
alias Generator ... | 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()
{
int n = readln.chomp.to!int;
char[][] field = new char[][](4, n + 2);
f... | D |
/* imports all std modules {{{*/
import
std.algorithm,
std.array,
std.ascii,
std.base64,
std.bigint,
std.bitmanip,
std.compiler,
std.complex,
std.concurrency,
std.container,
std.conv,
std.csv,
std.datetime,
std.demangle,
std.encoding,
std.exception,
std.file,
std.format,
std.functi... | D |
import std.stdio;
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;
import core.bitop : popcnt;
alias Generator ... | 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()
{
auto s = readln.chomp.to!int;
writeln(s/3600, ":", s%3600/60, ":", s%60);
} | D |
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()
{
int n = readln.chomp.to!int;
int k = readln.chomp.to!int;
int sum = 0;
foreach (x; readl... | 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.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;
int color (int[] c1, int[] c2) {
return (c1[0] - c2[0])^^2 + (c1[1] - c2[1])^^2 + (c1[2] - c2[2])^^2;
}
void main()
{
... | 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(){
string s = readln.chomp;
bool[char] flag;
foreach(c; s) flag[c] = 1;
string ans = "Yes";
if('N' in flag && !('S' in flag)) ans = "No";
if('S' in flag ... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.typecons;
void main() {
auto S = readln;
int[char] count;
foreach (c; S) {
if (c != '\n')
count[c]++;
}
int[] data;
int oddCount = 0;
foreach(int co; count) {
if (co % 2 == 1) oddCount++;
else data ~= co / 2;
}
if (... | D |
void main() {
int[] tmp = readln.split.to!(int[]);
int k = tmp[0], s = tmp[1];
int cnt;
foreach (x; 0 .. k+1) {
foreach (y; 0 .. k+1) {
int z = s - x - y;
if (0 <= z && z <= k) ++cnt;
}
}
cnt.writeln;
}
import std.stdio;
import std.string;
import std.arra... | D |
void main(){
string[] val = inln!string();
bool a = (val[0]=="H")?true:false;
bool b = (val[1]=="H")?true:false;
writeln(( (a^b)==false)?'H':'D');
}
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 ... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
void main()
{
auto N = readln.chomp.to!int;
int ans = 0;
foreach(_; 0..N){
auto l = readln.chomp.split.map!(to!int);
ans += l[1] - l[0] + 1;
}
writeln(ans);
} | D |
import std;
int calc(string s) {
int[2019] a;
a[0] = 1;
int ans = 0;
int p = 1;
int now = 0;
foreach_reverse (c; s) {
now = (now + p * (c - '0')) % 2019;
p = p * 10 % 2019;
ans += a[now];
a[now]++;
}
return ans;
}
void main() {
string s = read!strin... | D |
import std.stdio, std.string, std.conv;
import std.typecons;
import std.algorithm, std.array, std.range, std.container;
import std.math;
void main() {
auto N = readln.split[0].to!int;
bool[string] S;
foreach (i; 0 .. N) {
S[readln.split[0]] = true;
}
writeln(S.keys.length);
}
| D |
import std.stdio,std.algorithm;void main(){readln;writeln(readln.canFind("Y")?"Four":"Three");} | 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 w, a, b; readV(w, a, b);
if... | D |
import std.stdio;
import std.conv;
import std.string;
import std.typecons;
import std.algorithm;
import std.array;
import std.range;
import std.math;
import std.container;
void main()
{
auto n = readln.chomp.to!int;
long sum;
foreach (i; 0..n) {
sum += readln.chomp.to!long;
}
writeln(sum / n);
} | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.array;
void main(){
auto x=readln.chomp.to!int;
if(x<1200)writeln("ABC");
else writeln("ARC");
} | D |
// Vicfred
// https://atcoder.jp/contests/abc043/tasks/arc059_a
// brute force
import std.algorithm;
import std.array;
import std.conv;
import std.stdio;
import std.string;
void main() {
int n = readln.chomp.to!int;
int[] a = readln.split.map!(to!int).array;
long minima = long.max;
for(int i = -100; i... | D |
import std.algorithm;
import std.conv;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
void main ()
{
string s;
while ((s = readln.strip) != "")
{
int res1 = 0;
int res2 = 0;
foreach (i, c; s)
{
res1 += (c != ('0' ^ (i & 1)));
res2 += (c != ('1' ^ (i & 1)));
}
writeln (... | D |
import std.stdio, std.conv, std.functional, std.string;
import std.algorithm, std.array, std.container, std.range, std.typecons;
import std.numeric, std.math, std.random;
import core.bitop;
string FMT_F = "%.15f";
static string[] s_rd;
T RD(T = long)() { while(!s_rd.length) s_rd = readln.chomp.split; string res = s_r... | D |
/+ dub.sdl:
name "A"
dependency "dunkelheit" version=">=0.9.0"
+/
import std.stdio, std.algorithm, std.range, std.conv;
// import dkh.foundation, dkh.scanner;
int main() {
Scanner sc = new Scanner(stdin);
scope(exit) assert(!sc.hasNext);
int[long] mp;
int n;
sc.read(n);
long[] a;
s... | 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.string, std.conv, std.range;
import std.algorithm, std.array, std.typecons, std.container;
import std.math, std.numeric, std.random, core.bitop;
void scan(T...)(ref T args) {
import std.stdio : readln;
import std.algorithm : splitter;
import std.conv : to;
import std.range.primiti... | D |
import std.stdio, std.string, std.conv, std.array, std.algorithm;
void main() {
auto a = readln.split.map!(to!int).array;
writeln(a[0]*a[1], " ",(a[0]+a[1])*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.algorithm;
import std.array;
import std.conv;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
T read(T)() { return readln.chomp.to!T; }
T[] reads(T)() { return readln.split.to!(T[]); }
alias readint = read!int;
alias readints = reads!int;
void main() {
auto ... | D |
import std.stdio, std.string, std.conv;
void main() {
int n = readln.chomp.to!int;
int[] fib = new int[n+1];
fib[0] = fib[1] = 1;
foreach (i; 2 .. n+1) {
fib[i] = fib[i-1] + fib[i-2];
}
fib[n].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.conv;
import std.array;
void main()
{
long N = readln.split[0].to!long;
long[] T = new long[5];
foreach (i; 0..5){
T[i] = readln.split[0].to!long;
}
long minT = T[0];
foreach (t; T){
if (t < minT) minT = t;
}
long ans = N / minT;
if (N ... | D |
import core.bitop, std.algorithm, std.ascii, std.bigint, std.conv,
std.functional, std.math, std.numeric, std.range, std.stdio, std.string,
std.random, std.typecons, std.container;
ulong MAX = 100_100, MOD = 1_000_000_007, INF = 1_000_000_000_000;
alias sread = () => readln.chomp();
alias lread(T = long) = () ... | D |
import std.functional,
std.algorithm,
std.container,
std.typetuple,
std.typecons,
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... | 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;
import std.range, std.algorithm, std.array, std.typecons, std.container;
import std.math, std.numeric, core.bitop;
enum inf = int.max;
void main() {
int n, q;
scan(n, q);
auto st = SegmentTree!(int, min, inf)(n);
foreach (_ ; 0 .. q) {
int com, x, y;
... | D |
import std.conv, std.stdio;
import std.algorithm, std.array, std.range, std.string;
void main()
{
(6 - readln.chomp.to!int - readln.chomp.to!int).writeln;
}
| 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, std.regex;
void main() {
int[] dr = [1, -1, 0, 0];
int[] dc = [0, 0, 1, -1];
auto s = readln.split.map!(to!int);
... | D |
import std.stdio;
import std.string;
import std.conv;
import std.array;
void main(){
string[] sqlen = readln().chomp().split();
int a = sqlen[0].to!int(); int b = sqlen[1].to!int();
writeln(a*b, " ", (a+b)*2);
} | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto nm = readln.split.to!(long[]);
auto N = nm[0];
auto M = nm[1];
writeln(N == 1 && M == 1 ? 1 : N == 1 ? max(0, M-2) : M == 1 ? max(0, N-2) : (N-2) * (M-2));
} | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
void main() {
auto a = readln.chomp.split.map!(to!int);
int w = a[0], h = a[1], x = a[2], y = a[3], r = a[4];
if (x - r >= 0 && x + r <= w && y - r >= 0 && y + r <= h) {
writeln("Yes");
} else {
writeln("No");
... | D |
import std.stdio;
import core.stdc.stdio;
import std.algorithm;
struct state{
int x;
int y;
int z;
int r;
}
void main(){
while(1){
int a,b,c;
scanf("%d%d%d",&a,&b,&c);
if(a==0&&b==0&&c==0)
break;
int m = a+b+c;
int n;
scanf("%d",&n);
int[] dec = new int[m];
dec[] = 2;
state[] sts = new state[n];
for... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
int[30] CNT;
void main()
{
auto nm = readln.split.to!(int[]);
auto N = nm[0];
auto M = nm[1];
foreach (_; 0..N) {
auto as = readln.split.to!(int[]);
foreach (n; as[1..$]) {
... | 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 = sread();
// writeln(n);
if ((n[0] == n[1]) && (n[0] == n[2]))
{
writeln("Yes");
return;
}
if ((n[1] == n[2])... | D |
import std;
void main() {
int a, b; scan(a, b);
writeln(a * b);
}
void scan(T...)(ref T a) {
string[] ss = readln.split;
foreach (i, t; T) a[i] = ss[i].to!t;
}
T read(T=string)() { return readln.chomp.to!T; }
T[] reads(T)() { return readln.split.to!(T[]); }
alias readints = reads!int;
| D |
import std.algorithm, std.array, std.conv, std.range, std.stdio, std.string;
void main()
{
immutable n = readln.chomp.to!size_t;
ubyte[][] b;
foreach (i; 0..n)
b ~= cast(ubyte[])readln.chomp;
size_t ret;
foreach (i; 0..n)
{
ret += b.sym * n;
b = b[1..$] ~ b[0];
}
ret.writeln;
}
bool sym(T)(T[][] b)
{
... | 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 N = readln.chomp.to!int;
if (N == 0) {
"a".writeln;
return;
}
string ans = "";
cha... | D |
void main()
{
string s = rdStr;
writeln(s[0..4], " ", s[4..$]);
}
enum long mod = 10^^9 + 7;
enum long inf = 1L << 60;
T rdElem(T = long)()
if (!is(T == struct))
{
return readln.chomp.to!T;
}
alias rdStr = rdElem!string;
alias rdDchar = rdElem!(dchar[]);
T rdElem(T)()
if (is(T == struct))
{
T resul... | D |
void main() {
auto s = rs;
ulong tmp;
foreach(i, v; s) {
if(v == 'A') {
tmp = i;
break;
}
}
foreach_reverse(i, v; s) {
if(v == 'Z') {
(i - tmp + 1).writeln;
return;
}
}
}
// ===================================
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import... | D |
import std.stdio, std.string, std.conv, std.algorithm;
int lcs(string x, string y) {
int m = x.length.to!int, n = y.length.to!int;
int[][] c = new int[][](m+1, n+1);
foreach (i; 1 .. m+1) {
foreach (j; 1 .. n+1) {
if (x[i-1] == y[j-1]) {
c[i][j] = c[i-1][j-1] + 1;
... | D |
void main() {
import std.stdio, std.string, std.conv, std.algorithm;
auto s = readln.chomp.to!(char[]);
auto t = readln.chomp.to!(char[]);
const no = "UNRESTORABLE";
if (t.length > s.length) {
writeln(no);
return;
}
char[][] cand;
for (size_t i = 0; i + t.length <= s.length; i++) {
bool ok... | D |
import std.algorithm;
import std.array;
import std.conv;
import std.math;
import std.stdio;
import std.string;
import std.range;
int readint() {
return readln.chomp.to!int;
}
int[] readints() {
return readln.split.map!(to!int).array;
}
struct S {
int node;
long cost;
}
long[] bfs(int k, int n, S[][i... | 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;
immutable long MOD = 10^^9+7;
void main() {
auto s = readln.split.map!(to!long);
auto N = s[0];
auto M = s[1... | D |
import std.stdio;
import std.string;
import std.conv;
import std.array;
void main()
{
ulong N = readln.split[0].to!ulong;
char[] S = readln.chomp.to!(char[]);
ulong K = readln.split[0].to!ulong;
foreach (i; 0..N) if (S[i] != S[K - 1]) S[i] = '*';
writeln(S.to!string);
}
| D |
import std.stdio, std.array, std.conv, std.string, std.algorithm, std.range;
void main() {
long n = readln.chomp.to!long;
long ans = 1;
for (long i = 1; i <= 20; i++) {
ans *= i;
}
ans.writeln;
} | D |
import std.stdio, std.conv, std.string;
void main(){
int n=to!int(chomp(readln()));
string s, t;
s=chomp(readln());
t=chomp(readln());
if(n==1){
writeln(3);
return;
}
const mod=1_000_000_000+7;
bool y=s[0]==t[0];
long c=y? 3: 6;
int i=y? 1: 2;
while(i<n){
if(i+1<n){
if(s[i]==t[... | D |
import std.stdio;
import std.string;
import std.conv;
import std.typecons;
import std.algorithm;
import std.functional;
import std.bigint;
import std.numeric;
import std.array;
import std.math;
import std.range;
import std.container;
import std.ascii;
void main(){
auto x = readln.chomp.to!int;
auto a = readln.chomp.... | 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.algorithm;
import std.array;
import std.conv;
import std.string;
void main() {
int N = readln.chomp.to!int;
auto c = readln.chomp.split.map!(to!int).array;
int Q = readln.chomp.to!int;
bool flag = true;
int[] apple = new int[](N);
for (int i = 0; i < Q; i++) {
... | 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], K = tmp[2];
int cnt;
foreach_reverse (x; 1..min(A,B)+1) {
if (A % x == 0 && B % x == 0) {
if (++cnt... | 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 s = readln.strip;
writeln (s.maxElement);
}
}
| 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;
void main()
{
long A = scanElem;
long B = scanElem;
writeln((A-1)*(B-1));
}
class UnionFind{
Uni... | 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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.