code stringlengths 4 1.01M | language stringclasses 2
values |
|---|---|
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 L, R;
scan(L, R);
auto D = R - L + 1... | D |
import std.algorithm;
import std.array;
import std.conv;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
T read(T)() { return readln.chomp.to!T; }
T[] reads(T)() { return readln.split.to!(T[]); }
alias readint = read!int;
alias readints = reads!int;
void main() {
int a... | D |
import std.algorithm;
import std.array;
import std.bitmanip;
import std.container;
import std.conv;
import std.functional;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
void main()
{
auto n = readln.chomp;
int[10] cnt;
foreach (i, ref e; cnt) {
... | D |
// unihernandez22
// https://atcoder.jp/contests/abc150/tasks/abc150_b
// implementation
import std.stdio: readln, writeln;
import std.string: chomp;
import std.algorithm: count;
void main() {
readln;
string s = readln.chomp;
s.count("ABC").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;
void main() {
auto S = readln.chomp;
auto N = S.length.to!int;
auto C = new long[](26);
foreach (i; 0..N) C[S[i] - 'a'] += 1... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons;
int[int] NS;
void main()
{
auto N = readln.chomp.to!int;
foreach (_; 0..N) {
auto A = readln.chomp.to!int;
if (A in NS)
++NS[A];
else
NS[A] = 1;
}
int ret;
fore... | D |
import std.stdio, std.math, std.conv, std.string;
bool is_prime(int n)
{
auto t = sqrt(n.to!double);
for (int i = 2; i <= t; ++i) {
if (n % i == 0) return false;
}
return true;
}
void main()
{
auto N = readln.chomp.to!int;
int cnt;
foreach (_; 0..N) {
if (is_prime(readln.... | D |
import std.stdio, std.string, std.conv, std.algorithm;
import std.range, std.array, std.math, std.typecons, std.container, core.bitop;
void main() {
string s;
scan(s);
int n = s.length.to!int;
auto a = new int[](n + 1);
foreach (i ; 0 .. n) {
a[i + 1] = a[i] ^ (1 << (s[i] - 'a'));
}
... | D |
import std.stdio;
import std.regex;
void main(){
auto io = new IO();
auto S = io.line!string()[0];
if ( S.have("N") ^ S.have("S") || S.have("W") ^ S.have("E") ){
writeln("No");
}else{
writeln("Yes");
}
return;
}
import std.stdio,std.conv,std.string;
import std.algorithm,std.array,std.math;
class IO
{
... | 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 str = readln.chomp;
int[char] count;
for(int i=0; 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, std.random, core.bitop;
enum inf = 1_001_001_001;
enum inf6 = 1_001_001_001_001_001_001L;
enum mod = 1_000_000_007L;
alias Pair = Tuple!(int, "a", int, "b");
void main() {
... | 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;
void main() {
auto s = readln.split.map!(to!long);
auto N = s[0].to!int;
auto A = s[1];
auto... | D |
void main(){
string[] val = inln!string();
bool a = val[0]=="H";
bool b = val[1]=="H";
writeln( a^b?'D':'H');
}
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() );
}
/... | D |
import std.algorithm, std.container, std.conv, std.math, std.range, std.typecons, std.stdio, std.string;
import std.uni;
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 s1, s2, s3;... | D |
import std.stdio;
import std.algorithm;
import std.conv;
import std.string;
void main()
{
auto tokens = split(chomp(readln()));
int a = to!int(tokens[0]);
int b = to!int(tokens[1]);
if ((a * b) % 2 == 0)
writeln("No");
else
writeln("Yes");
stdout.flush();
} | D |
import std.stdio, std.conv, std.range, std.string, std.array;
void main(){
auto ip = readln.chomp;
writeln(ip.count('1'));
} | D |
import std.stdio;
import std.string;
import std.conv;
int main()
{
int N = readln().chomp().to!int();
string[] num = readln().split();
for (int i = N - 1; i > 0; i--)
write(num[i], " ");
writeln(num[0]);
return 0;
} | 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 x = readln.chomp.to!int;
writeln(x < 1200 ? "ABC" : "ARC");
}
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;
import std.string;
import std.conv;
import std.ascii;
import std.algorithm;
void main()
{
foreach (_; 0..readln.chomp.to!int) {
auto script = readln;
auto keys = script.split.filter!(str => str.length == 4);
loop:
foreach (a; [0, 1, 3, 5, 7, 9, 11, 15, 17, 19, 21, 2... | 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, std.numeric;
void main()
{
auto S = readln.chomp;
auto N = S.length;
int r1, r2;
foreach (i; 0..N) {
auto c = i%2 == 0 ? '0' : '1';
if (S[i] == c) ++r1;
if (S[i] != c) ++r2;
}
writ... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array, std.typecons, std.container;
import std.math, std.numeric, core.bitop;
enum inf = 1_001_001_001;
enum inf6 = 1_001_001_001_001_001_001L;
enum mod = 1_000_000_007L;
void main() {
int p, q, r;
scan(p, q, r);
auto ans = min... | D |
/+ dub.sdl:
name "A"
dependency "dunkelheit" version="1.0.1"
+/
import std.stdio, std.algorithm, std.range, std.conv;
// import dkh.foundation, dkh.scanner, dkh.algorithm;
int main() {
Scanner sc = new Scanner(stdin);
scope(exit) assert(!sc.hasNext);
int n;
sc.read(n);
writeln((n - 2) * ... | D |
import std.stdio;
import std.string;
import std.conv;
import std.range;
import std.array;
import std.algorithm;
void main() {
string input;
while ((input = readln.chomp).length != 0) {
auto line = input.map!(a => a.to!int - '0').array;
while (line.length > 1) {
for (int i = 0; i <... | 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() {
strin... | 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 |
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.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;
immutable long MOD = 10^^9 + 7;
void main() {
auto N = readln.chomp.to!int;
auto A = readln.chomp.map!(a => a == '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;
auto AS = readln.split.to!(int[]);
int c;
foreach (a; AS) {
while (a && a%2 == 0) {
++c;
a /= 2;
}
}
writeln... | 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;
string read(){ static string[] ss; while(!ss.length) ss = readln.chomp.split; string res = ss[0]; ss.popFront; return res; }
class Node{
Node[] adjnodes;
Node[] kids;
Nod... | D |
import std.stdio;
import std.conv;
import std.string;
import std.typecons;
import std.algorithm;
import std.array;
import std.range;
import std.math;
import std.regex : regex;
import std.container;
import std.bigint;
import std.numeric;
void main()
{
auto x = readln.chomp.to!int;
immutable m = 200_000 + 1;
auto... | 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 _1, s, _2; readV(_1, s, _2)... | 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;
static import std.ascii;
// dfmt off
T lread(T = long)(){return readln.chomp.to!T();}
T[] lreads(T = long)(long n){ret... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array, std.typecons, std.container;
import std.math, std.numeric, core.bitop;
enum inf = 1_001_001_001;
enum inf6 = 1_001_001_001_001_001_001L;
enum mod = 1_000_000_007L;
void main() {
string S;
scan(S);
auto N = S.length;
... | D |
import std.stdio;
import std.algorithm;
import std.range;
import std.array;
import std.string;
import std.conv;
void main(){
int[] inputs = readln.chomp.split.map!(to!int).array;
auto n = inputs[0];
auto a = inputs[1];
auto b = inputs[2];
auto answer = min(n * a, b);
writeln(answer);
} | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array;
void main() {
string s;
scan(s);
int n = s.length.to!int;
int btm = 1, top = n + 1;
bool check(int k) {
if (2*k <= n) {
return true;
}
bool b = 1;
char ch = s[n-k];
... | D |
import std.stdio, std.string, std.array, std.conv, std.algorithm.iteration, std.functional;
void main()
{
auto ip = readln.chomp.split(" ").map!(pipe!((c => c.to!int), (i => i == 1 ? 14 : i))).array;
auto a = ip[0];
auto b = ip[1];
writeln(
a > b ? "Alice"
: a < b ? "Bob"
: "Dr... | 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 |
// 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;
int a, b;
void main() {
scan(a, b);
a = min(a, b);
long ans = 1L;
foreach (i ; 1 .. a + 1) {
ans *... | 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[] input = readln.split;
int N = input[0].to!int;
int... | 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.format;
void main()
{
auto abbcca = readln.split.to!(in... | D |
import std.stdio, std.string, std.conv, std.array, std.algorithm;
void main()
{
auto a = readln.split.map!(to!int);
if(a[0]+a[1]==2||a[2]==1) writeln("Open");
else writeln("Close");
} | D |
void main(){
long a;
long[2] bb;
scanf("%ld %ld.%ld", &a, &bb[0], &bb[1]);
long b = bb[0]*100.to!long + bb[1];
( a*b/100 ).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行に同一型の複数... | D |
import std.stdio, std.string, std.conv, std.array;
string mathed(char[] s, char[] t)
{
for (int i = cast(int)(s.length-t.length); i >= 0; i--) {
if (s[i] == t[0] || s[i] == '?') {
int ii = i;
bool flag = true;
for (int j = 0; j < t.length;) {
if (!(s[i] == t[j] || s[i] == '?')) {
flag = fal... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array;
void main() {
int r, g;
scan(r);
scan(g);
auto ans = r + (g - r) * 2;
writeln(ans);
}
void scan(T...)(ref T args) {
import std.stdio : readln;
import std.algorithm : splitter;
import std.conv : to;
... | 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 abc = aryread();
// writeln(abc);
long cnt5;
long c... | D |
void main(){
string s = readln().chomp();
string t = readln().chomp();
int ans;
foreach(i; 0..s.length){
if(s[i] != t[i])ans++;
}
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行に同一型の複数入力
... | 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!int;
auto s = readln.chomp;
int res;... | D |
//dlang template---{{{
import std.stdio;
import std.conv;
import std.string;
import std.array;
import std.algorithm;
import std.typecons;
import std.math;
import std.range;
// MIT-License https://github.com/kurokoji/nephele
class Scanner
{
import std.stdio : File, stdin;
import std.conv : to;
import std.array : ... | 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 a = readln.chomp.to!int;
writeln = n * n - a;
}
| 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, m; readV(n, m);
auto r =... | D |
import std.stdio;
import std.ascii;
import std.algorithm;
static import core.stdc.stdio;
long[300_000+2] a;
long[300_000+2] c;
int main()
{
int[][] parent = new int[][](300_000+2, 20);
int q = readInt!int;
a[0] = readInt!long;
c[0] = readInt!long;
parent[0][] = -1;
int getNthParent(int v, int ... | D |
import std.stdio;
void main()
{
foreach(i; 1 .. 10)
{
foreach(j; 1 .. 10)
{
writeln(i, 'x', j, '=', i * j);
}
}
} | D |
import std.stdio;
void main(){for(int i;i<81;i++){
writeln(i/9+1,"x",i%9+1,"=",(i/9+1)*(i%9+1));
}} | D |
import std.stdio;
import std.algorithm;
import std.string;
import std.conv;
import std.math;
void main(){
while(true){
auto s = readln();
if(stdin.eof()) break;
s = chomp(s);
char win = 'd';
for(int i=0;i<3;i++){
if(s[3*i] != 's' && s[3*i] == s[3*i+1] && s[3*i] == s[3*i+2]) win = s[3*i];
}
for(int i=0;... | 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()
{
auto R = scanElem;
auto G = scanElem;
auto B = scanElem;
auto N = scanElem;
int... | D |
/+ dub.sdl:
name "B"
dependency "dunkelheit" version="1.0.1"
+/
import std.stdio, std.algorithm, std.range, std.conv;
// import dkh.foundation, dkh.scanner, dkh.algorithm;
int main() {
Scanner sc = new Scanner(stdin);
scope(exit) assert(!sc.hasNext);
string s;
sc.read(s);
int n = s.lengt... | 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;
auto A = readln.split.map!(to!int).array;
int ans = 0;
foreach (i; 0..N) {
... | D |
import std.stdio, std.conv, std.functional, std.string;
import std.algorithm, std.array, std.container, std.range, std.typecons;
import std.bigint, std.numeric, std.math, std.random;
import core.bitop;
string FMT_F = "%.10f";
static File _f;
void file_io(string fn) { _f = File(fn, "r"); }
static string[] s_rd;
T _RD(... | D |
void main() {
import std.stdio, std.string, std.conv, std.algorithm;
long n, m;
rd(n, m);
auto mn = max(0, n - m * 2);
long mx = 0;
for (auto k = 0L; k <= n; k++) {
if (k * (k - 1) / 2 >= m) {
mx = max(mx, n - k);
}
}
writeln(mn, " ", mx);
}
void rd(T...)(ref T x) {
import std.stdio :... | D |
import std;
enum inf(T)()if(__traits(isArithmetic,T)){return T.max/4;}
T[]readarr(T=long)(){return readln.chomp.split.to!(T[]);}
void scan(T...)(ref T args){auto input=readln.chomp.split;foreach(i,t;T)args[i]=input[i].to!t;}
struct Queue(T){T[]e;auto enq(T t){e~=t;}auto enq(T[]ts){e~=ts;}T deq(){T tp=e[0];e=e.length>1?... | 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;
}
bool calc(int rows, int cols, int k) {
for (int ... | 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 times(alias fun)(int n) {
foreach(i; 0..n) fun();
}
auto re... | D |
import std.stdio,std.conv,std.algorithm,std.array;
int oneint(){ return readln().split().map!(to!int).array()[0];} //read from stdin as only one int
void main(){ for(int i=1,x;(x = oneint())!=0;i++){ writeln("Case ",i,": ",x); } } | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric, std.bigint;
void main()
{
auto n = readln.chomp.to!int;
auto s = readln.chomp;
int r = int.max;
foreach (i; 0..n-3) {
int t;
t += min(abs(s[i] - 39), abs(s[i] - 65), abs(s[i] - 91));
... | D |
import std.stdio;
import std.string;
import std.array; // split
import std.conv; // to
void main()
{
string s = chomp(readln());
int a = to!int(s); // 第0要素を整数に変換
if(a > 999){
writeln("ABD");
} else {
writeln("ABC");
}
} | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto S = readln.chomp;
if (S == "AAA" || S == "BBB") {
writeln("No");
} else {
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.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 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()
{
immutable k = readln.chomp.to!long;
enum N = 50;
lon... | 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 times(alias fun)(int n) {
foreach(i; 0..n) fun();
}
auto re... | 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;
T lread(T = long)()
{
return readln.chomp.to!T();
}
T[] aryread(T = long)()
{
ret... | 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 h = lread();
func(h).writeln();
}
long func(long h)
{
... | 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 std.algorithm;
import std.conv;
import std.stdio;
import std.string;
import std.math;
void main()
{
auto ab = readln.split.map!( to!int );
auto add = ab[ 0 ] + ab[ 1 ];
auto sub = ab[ 0 ] - ab[ 1 ];
auto mul = ab[ 0 ] * ab[ 1 ];
writeln( max( add, sub, mul ) );
}
| D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
enum PS = [300000, 200000, 100000];
void main()
{
auto xy = readln.split.to!(int[]);
auto X = xy[0];
auto Y = xy[1];
int r;
if (X <= 3) r += PS[X-1];
if (Y <= 3) r += PS[Y-1];
if (X == 1 ... | D |
/+ dub.sdl:
name "B"
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);
int n;
sc.read(n);
int[] p = new int[n];
int[] rp = new int[n];
foreach (i; 0..n)... | D |
import std;
void main(){
auto s = readln.chomp;
if (s == "ABC")
"ARC".writeln;
else
"ABC".writeln;
}
| D |
module main;
import std.stdio : readln, writeln, write, writefln, writef;
import std.conv : to;
import std.array : split, replace;
import std.string : strip;
import std.algorithm : max, min, map, reduce, sort, reverse;
import std.functional : memoize;
version = A;
version (A)
{
void main()
{
auto seq... | D |
void main(){
import std.stdio, std.string, std.conv, std.algorithm;
int a, b; rd(a, b);
auto s=readln.chomp.to!(char[]);
if(count(s, '-')!=1){writeln("No"); return;}
if(s[a]=='-') writeln("Yes");
else writeln("No");
}
void rd(T...)(ref T x){
import std.stdio, std.string, std.conv;
auto l=readln.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.stdio, std.conv, std.string, std.array, std.math, std.regex, std.range, std.ascii, std.numeric, std.random;
import std.typecons, std.functional, std.traits,std.concurrency;
import std.algorithm, std.container;
import core.bitop, core.time, core.memory;
import std.bitmanip;
import std.regex;
enum INF = long.... | D |
import std.stdio,std.string,std.conv;
void main(){
writeln( readln().chomp().to!int^^3 );
} | D |
import std.stdio, std.string, std.array, std.conv;
struct Card {
char suit, value;
}
void bubble(int n, Card[] x) {
foreach (i; 0 .. n) {
foreach_reverse (j; i+1 .. n) {
if (x[j].value < x[j-1].value) {
Card t = x[j];
x[j] = x[j-1];
x[j-1] = ... | D |
import std.stdio, std.conv, std.algorithm, std.string;
alias L = long;
L M = 998244353;
L[] X;
L[L] C;
L h(L m, L[] U){
L f;
foreach(u; U[0 .. m]) f = f * 2 % M + u;
foreach(i, u; U) if(i / m & 1 ^ U[i % m] ^ u) return f + u;
return f + 1;
}
void main(){
L n = readln.chomp.to!L, b = n * 2;
foreach(c; readln.chomp... | D |
import std.stdio, std.string, std.array, std.conv;
long cnt;
int[] y;
void insertionSort(int n, int g, int[] x) {
foreach (i; g .. n) {
int v = x[i];
int j = i - g;
while (j >= 0 && x[j] > v) {
x[j+g] = x[j];
j -= g;
++cnt;
}
x[j+g] = v;
... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto N = readln.chomp;
int X;
foreach (c; N.to!(char[])) X += c-48;
writeln(N.to!int % X == 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;
static import std.ascii;
// dfmt off
T lread(T = long)(){return readln.chomp.to!T();}
T[] aryread(T = long)(){return r... | 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 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.range, std.algorithm;
void main() {
string s = strip(readln());
size_t n = s.length;
auto odd = filter!(a => a%2 == 0)(iota(n));
foreach (c; map!(i => s[i])(odd)) {
write(c);
}
writeln();
}
| D |
void main() {
problem();
}
void problem() {
auto a = scan!long;
long solve() {
return a + a*a + a*a*a;
}
solve().writeln;
}
// ----------------------------------------------
import std.stdio, std.conv, std.array, std.string, std.algorithm, std.container, std.range, core.stdc.stdlib, std.math, std.typ... | D |
void main(){
int n = _scan();
if(n>81){
writeln("No");
return;
}
foreach(i; 1..81+1){
if(i<=9 && n/i<=9 && n%i==0){
writeln("Yes");
return;
}
}
writeln("No");
}
import std.stdio, std.conv, std.algorithm, std.numeric, std.string, std.math;
// 1要素のみの入力
T _scan(T= int)(){
return to!(T)( readln().cho... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array, std.typecons, std.container;
import std.math, std.numeric, core.bitop;
enum inf = 1<<30;
enum mod = 10L^^9 + 7;
void main() {
int h, w, a, b;
scan(h, w, a, b);
auto fact = new long[](h + w + 1);
auto rfact = new long[... | 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;
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 k = lread();
long ans = 1;
foreac... | 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 AS = new int[](2^^N);
foreach (i; 0..2^^N) {
AS[i] = readln.chomp.to!int;
}
while (AS.length > 1) {
int[] NAS;
for (int i;... | D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void readV(T...)(ref T t){auto r=readln.splitter;foreach(ref v;t){v=r.front.to!(typeof(v));r.popFront;}}
void readA(T)(size_t n,ref T t){t=new T(n);auto r=readln.splitter;foreach(ref v;t){v=r.front.to!(ElementType!T);r.popFront;}}
void readM(T...)(size_... | D |
void main() {
string s = readln.chomp;
int n = s.to!int;
int fx;
foreach (x; s) {
fx += x - '0';
}
writeln(n % fx == 0 ? "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;
... | 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;
static import std.ascii;
// dfmt off
T lread(T = long)(){return readln.chomp.to!T();}
T[] lreads(T = long)(long n){ret... | D |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.