code stringlengths 4 1.01M | language stringclasses 2
values |
|---|---|
import std.stdio;
import std.conv;
import std.array;
void main()
{
int N = readln.split[0].to!int;
int[] V = readln.split.to!(int[]);
int[] C = readln.split.to!(int[]);
int ans = 0;
foreach (i; 0..N){
if (V[i] > C[i]) ans += V[i] - C[i];
}
writeln(ans);
}
| 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 std.stdio, std.math, std.algorithm, std.array, std.string, std.conv, std.container, std.range;
T Read(T)() { return readln.chomp.to!(T); }
T[] Reads(T)() { return readln.split.to!(T[]); }
alias read = Read!(int);
alias reads = Reads!(int);
void main() {
int d = read();
if (d == 25)
writeln("Chr... | D |
import std.stdio, std.array, std.conv;
void main() {
while (true) {
string[] input = split(readln());
int H = to!int(input[0]);
int W = to!int(input[1]);
if (H == 0 && W == 0) return;
for (int i = 0; i < H; ++i) {
for (int j= 0; j < W; ++j) {
write(is_side(i, j, H, W) ? "#" : ".")... | 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 h = aryread();
long cnt;
foreach (i; 0 .. n - 1)
{
if (h[i] < h[i + 1])
{
h[i + 1] -= ... | D |
void main() {
long n = readln.chomp.to!long;
writeln(2 * n / gcd(2, n));
}
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.uni; | D |
// dfmt off
T lread(T=long)(){return readln.chomp.to!T;}T[] lreads(T=long)(long n){return iota(n).map!((_)=>lread!T).array;}
T[] aryread(T=long)(){return readln.split.to!(T[]);}void arywrite(T)(T a){a.map!text.join(' ').writeln;}
void scan(L...)(ref L A){auto l=readln.split;foreach(i,T;L){A[i]=l[i].to!T;}}alias sread=(... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons;
void main()
{
auto nk = readln.split.to!(int[]);
writeln(nk[0] % nk[1] ? 1 : 0);
} | 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.conv;
import std.stdio;
import std.string;
void main()
{
auto s = readln.strip;
writeln( solve( s ) );
}
auto solve( in string s )
{
auto n = s.to!int;
auto sn = 0;
foreach( c; s )
{
sn += [ c ].to!int;
}
return ( n % sn == 0 ) ? "Yes" : "No";
}
unittest
{
assert( solve( "12" ) == "Yes" );... | 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; }
/*
部分文字列 文字列の一致
sのi文字目までとt... | D |
// Vicfred
// https://atcoder.jp/contests/abc162/tasks/abc162_c
// math
import std.conv;
import std.stdio;
import std.string;
long gcd(long a, long b) {
if(b == 0)
return a;
return gcd(b, a%b);
}
long gcd(long a, long b, long c) {
return gcd(a,gcd(b,c));
}
void main() {
int K = readln.chomp.t... | D |
import std.stdio, std.string, std.algorithm, std.array;
void main()
{
int t;
scanf("%d", &t);
getchar();
foreach(i; 0..t){
long a,b,c,m;
scanf("%lld %lld %lld %lld", &a, &b, &c, &m);
auto top_max = a + b + c - 3;
auto max_v = max(a,b,c);
auto min_v = min(a,b,c);
auto mid_v... | 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;
import std.string;
void main()
{
auto n = readln;
auto s = readln.strip;
writeln( solve( s ) );
}
int solve( in string s )
{
auto lc = new int[ s.length ];
lc[ 0 ] = 0;
foreach( i; 1 .. s.length )
{
lc[ i ] = lc[ i - 1 ] + ( s[ i - 1 ] == 'E' ? 0 : 1 );
}
auto rc = new int[ s.length ]... | 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() {
bool[int] kuku_answers;
foreach(i; 1..10) {
foreach(o; 1..10) {
kuku_answers[i*o] = true;
}
}
auto N = readln.chomp.to!int;
... | 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 abc=readln.split.array;
if(abc[0][$-1]==abc[1][0] && abc[1][$-1]==abc[2][0])writeln("YES");
else writeln("NO");
} | D |
void main(){
int[] n = _scanln();
(n[0]-n[1]+1).writeln();
}
import std.stdio, std.conv, std.algorithm, std.numeric, std.string, std.math;
// 1要素のみの入力
T _scan(T= int)(){
return to!(T)( readln().chomp() );
}
// 1行に同一型の複数入力
T[] _scanln(T = int)(){
T[] ln;
foreach(string elm; readln().chomp().split()){
ln ~= elm... | D |
import std;
enum inf(T)()if(__traits(isArithmetic,T)){return T.max/4;}
T scan(T=long)(){return readln.chomp.to!T;}
void scan(T...)(ref T args){auto input=readln.chomp.split;foreach(i,t;T)args[i]=input[i].to!t;}
T[] scanarr(T=long)(){return readln.chomp.split.to!(T[]);}
alias Queue=DList;auto enq(T)(ref Queue!T q,T e){q... | D |
// import chie template :) {{{
import std;
// }}}
// nep.scanner {{{
class Scanner {
import std.stdio : File, stdin;
import std.conv : to;
import std.array : split;
import std.string;
import std.traits : isSomeString;
private File file;
private char[][] str;
private size_t idx;
this(File file = std... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.math;
import std.regex;
void main() {
auto N = readln.chomp.to!int, K = readln.chomp.to!int;
int res = 1;
foreach(i; 0..N) res = (res * 2 < res + K ? res * 2 : res + K);
writeln(res);
} | D |
import std.stdio;
import std.string;
import std.conv;
void main() {
string s = readln.chomp;
ulong k = readln.chomp.to!ulong;
foreach(i, c; s) {
if (c != '1') {
if (i < k) {
s[i].writeln;
return;
}
}
}
1.writeln;
}
| D |
import std.conv;
import std.stdio;
import std.string;
void main()
{
auto s = readln.strip;
writeln( solve( s ) );
}
auto solve( in string s )
{
auto r = 0;
foreach( c; s )
{
if( c == '+' ) r++;
else r--;
}
return r;
}
unittest
{
assert( solve( "+-++" ) == 2 );
assert( solve( "-+--" ) == -2 ... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.math;
import std.regex;
void main() {
auto ip = readln.split.to!(int[]), X = ip[0], Y = ip[1], Z = ip[2];
auto a = X - Z, b = Z + Y;
writeln(a / b);
} | 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.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()
{
dchar[] n; readV(n);
foreach (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, 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.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.stdio;
import std.algorithm;
import std.range;
import std.functional;
import std.conv;
import std.string;
import std.math;
import core.bitop;
ulong diff(ulong a, ulong b) {
ulong res = 0;
foreach (bit; 0 .. 64) {
if ((a & (1UL << bit)) != (b & (1UL << bit))) {
res++;
}
}
return ... | D |
import std.algorithm, std.container, std.conv, std.math, std.range, std.typecons, std.stdio, std.string;
auto rdsp(){return readln.splitter;}
void pick(R,T)(ref R r,ref T t){t=r.front.to!T;r.popFront;}
void readV(T...)(ref T t){auto r=rdsp;foreach(ref v;t)pick(r,v);}
void main()
{
string s; readV(s);
writeln(s <=... | D |
import std.stdio;
import std.conv;
import std.array;
import std.string;
void main()
{
while (1) {
string[] input = split(readln());
int h = to!(int)(input[0]);
int w = to!(int)(input[1]);
if (h == 0 && w == 0) break;
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
if (j... | 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, std.string, std.range, std.conv, std.array, std.algorithm, std.math, std.typecons;
void main() {
const R = readln.chomp.to!int;
writeln(R < 1200 ? "ABC" : R < 2800 ? "ARC" : "AGC");
}
| D |
import std.stdio, std.string, std.conv;
void main()
{
auto M = readln.chomp.to!int;
writeln(48 - M);
} | D |
import std.algorithm;
import std.conv;
import std.range;
import std.stdio;
import std.string;
auto go (string s, string c)
{
char [] stack = "**".dup;
foreach (ref e; s.filter !(e => c.canFind (e)))
{
stack.assumeSafeAppend ();
stack ~= e;
if (stack[$ - 2..$] == c)
{
stack.popBackN (2);
}
}
return st... | D |
import std.stdio;
import std.string;
import std.conv : to;
import std.algorithm : fill;
import std.math : sqrt;
void main() {
int input;
immutable limitList = 200000;
bool[] listNumbers = new bool[](limitList);
int[] listPrimeNumbers;
listNumbers.fill(true);
foreach (i; 2..limitList.to!doubl... | D |
import std.algorithm, std.array, std.conv, std.range, std.stdio, std.string;
void main()
{
auto buf = readln.chomp.split;
(buf[1] ~ buf[0]).writeln;
}
| D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
bool[10^^5+1] NS;
void main()
{
auto nk = readln.split.to!(int[]);
auto N = nk[0];
auto K = nk[1];
auto as = readln.split.to!(int[]);
foreach (i; 0..K+1) {
bool win;
foreach (j;... | 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 a, b;
void main() {
scan(a, b);
if (a % 3 == 0 || b % 3 == 0 || (a + b) % 3 ==... | D |
import std.stdio;
import std.string;
import std.math;
import std.conv;
import std.algorithm;
import std.bigint;
void main(){
int d,m;
int date = 2;
auto ds = ["Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday","Monday"];
auto a = [31,29,31,30,31,30,31,31,30,31,30,31];
while(true){
date... | D |
import std.stdio;
import std.conv;
import std.string;
const int DATA = 200;
int main() {
int data = to!(int)(chomp(readln));
string[] result = new string[data];
for(int i=0; i<data; i++) {
int a, b, c, tmp; // a:max
string[] input = (chomp(readln)).split(" ");
a = to!(int)(input[0]);
b = to!(in... | D |
import std.stdio,std.conv,std.string,std.algorithm,std.array;
void main(){
auto sn=readln().split();
auto sa=readln().split();
int n,a;
n=to!int(sn[0]);
a=to!int(sa[0]);
if(n%500<=a) writeln("Yes");
else writeln("No");
} | D |
import std.stdio,
std.string,
std.conv;
void main() {
int N = readln.chomp.to!int;
while(N--) {
auto i = readln.split;
auto c = i[0].to!int, a = i[1].to!int, n = i[2].to!int;
int ans;
while(c && a && n) {
ans++;
c--;
a--;
... | D |
import std.algorithm;
import std.array;
import std.conv;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
int readint() {
return readln.chomp.to!int;
}
int[] readints() {
return readln.split.map!(to!int).array;
}
void main() {
auto xs = readints;
int[int] m... | D |
import core.bitop;
import std.algorithm;
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 Point2 = Tuple!(long, "... | 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 S = readln.split[0];
auto cnt = 0;
string[] answers = [ "" ];
while (cnt < S.length) {
if ( S[cnt] == 'A' || S[cnt] == 'T' || S[cnt] == 'G' ||... | 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()
{
int N = readln.split[0].to!int;
auto reader = readln.split;
int[] A = new int[N + 1];
for(uint i = 0; i < N + 1; i++){
A[i] = reader[i].to!int;
}
reader = readln.split;
int[] B = new int[N];
for(uint i = 0; i < N... | D |
import std;
void main(){
auto input=readln.chomp.split.to!(size_t[]);
auto x=input[0];
auto y=input[1];
auto b_2=y-2*x;
if(b_2%2!=0){
"No".writeln;
return;
}
auto b=b_2/2;
if(x<b){
"No".writeln;
return;
}
"Yes".writeln;
} | D |
import std.stdio, std.string, std.conv, std.range, std.algorithm;
void main() {
auto _n = readln;
string[] n = [];
string line;
while((line = readln.chomp) != "") {
n ~= line;
}
foreach (_s; ["S", "H", "C", "D"])
foreach (_i; 1..14) {
auto t = _s ~ " " ~ _i.to!string;
if (!n.canFind(t)) t.writeln;
}... | D |
import std.algorithm, std.array, std.container, std.range, std.bitmanip;
import std.numeric, std.math, std.bigint, std.random, core.bitop;
import std.string, std.conv, std.stdio, std.typecons;
void main()
{
while (true) {
auto rd = readln.split.map!(to!int);
auto h = rd[0], w = rd[1];
if (h == 0 && w ==... | 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;
// }}}
// tbh.scanner {{{
class Scanner {
import std.stdio;
import std.conv : to;
import std.ar... | D |
import std.stdio;
import std.conv;
import std.string;
void main()
{
char[] s = readln.dup.chomp;
s[5] = ' ';
s[13] = ' ';
writeln(s);
}
| 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()
{
long a, b, c, d;
scan(a, b, c, d);
if (a + b > c + d)
{
... | D |
import std.stdio;
import std.string;
import std.array; // split
import std.conv; // to
void main()
{
string[] input = split(readln()); // splitで文字列を文字列の配列に切り分け
int a = to!int(input[0]); // 第0要素を整数に変換
int b = to!int(input[1]); // 第1要素を整数に変換
if((a*b)%2 == 0){
writeln("Even"); // 表示
} else {
... | D |
import std.stdio,std.ascii,std.conv,std.string,std.algorithm,std.range,std.functional,std.math,core.bitop;
void main()
{
int num;
auto a=readln.chomp.to!int;
for(int i=0;i<=a;i++){
if(i%2==0)continue;
int b;
for(int j=1;j<=i;j++){
if(i%j==0)b++;
}
if(b=... | 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() {
string a, b, c;
scan(a);
scan(b);
scan(c);
auto A... | D |
import std.stdio, std.string, std.conv;
import std.algorithm, std.array;
auto solve(string X) {
immutable N = X.length.to!int();
int n=0,q=0;
foreach(c;X) {
if(c=='S') ++q;
else if(q>0) --q;
else ++n;
}
return n+q;
}
void main(){ for(string s; (s=readln.chomp()).length;) writ... | 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;
immutable long INF = 1L << 59;
void main() {
auto s = readln.split.map!(to!int);
... | D |
string solve(int n){
int x = (n.to!double/1.08).to!int();
if((x*1.08).to!int() < n)x++;
if((x*1.08).to!int()==n)return x.to!string();
else return ":(";
}
void main(){
int n = inelm();
writeln(solve(n));
}
import std.stdio, std.conv, std.algorithm, std.numeric, std.string, std.math, std.range;
const long mod... | 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 n;
scan(n);
int[int] cnt;
foreach (i ; 0 .. n) {
int ai;
scan(ai);
cnt[ai]++;
debug {
writeln(cnt);
... | 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.chomp;
auto N = S.length.to!int;
auto ans = new int[](N);
foreach (i; 0..N-1) {... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array, std.typecons, std.container;
import std.math, std.numeric, core.bitop;
enum inf = 1_001_001_001;
enum inf6 = 1_001_001_001_001_001_001L;
enum mod = 1_000_000_007L;
void main() {
int h, n;
scan(h, n);
auto a = new int[](... | D |
//dlang template---{{{
import std.stdio;
import std.conv;
import std.string;
import std.array;
import std.algorithm;
import std.typecons;
// MIT-License https://github.com/kurokoji/nephele
class Scanner
{
import std.stdio : File, stdin;
import std.conv : to;
import std.array : split;
import std.string;
impor... | D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
auto a = readln.chomp.map!(c => cast(int)(c-'0')).array;
foreach (i; 0..1<<3) {
auto r = a[0];
foreach (j; 0..3)
r += a[j+1] * (i.bitTest(j) ? 1 : -1);
if (r == 7) {
write(a[0]);
foreach (j; 0..3)
... | D |
import std.algorithm, std.array, std.conv, std.stdio, std.string;
void main()
{
writeln(cast(char)(readln[0]+1));
}
| D |
import std.stdio, std.string, std.algorithm, std.array;
void main()
{
writeln(readln.chomp.split(" ").uniq.array.length == 1 ? "H" : "D");
} | D |
import std.stdio, std.algorithm, std.string, std.conv, std.array, std.range, std.math, core.stdc.stdio;
void main() {
string[3] ss;
foreach(ref s; ss) s = readln();
writeln(ss[0][0], ss[1][1], ss[2][2]);
} | 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()
{
auto nm = readln.chomp.split.map!(to!int);
int n = nm.... | 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;
void main() {
int a, b;
scan(a, b);
writeln(a... | 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;
bool[char] ch;
foreach (e; s) {
ch[e] = false;
}
... | D |
import std.stdio, std.conv, std.functional, std.string;
import std.algorithm, std.array, std.container, std.range, std.typecons;
import std.bigint, std.numeric, std.math, std.random;
import core.bitop;
string FMT_F = "%.10f";
static File _f;
void file_io(string fn) { _f = File(fn, "r"); }
static string[] s_rd;
T _RD(... | D |
import std.stdio;
import std.string;
import std.conv;
void main() {
int n = readln.chomp.to!int;
bool[string] table;
foreach (i;0..n) {
auto line = readln.chomp;
table[line] = true;
}
writeln(table.length);
}
| D |
import std.stdio;
import std.conv;
import std.algorithm;
import std.string;
import std.array;
void main() {
int n = readln.chomp.to!int;
auto s = readln.chomp.split;
bool[string] dict;
int ans;
foreach(ss; s) {
if ((ss in dict) is null) {
dict[ss] = true;
ans++;
... | D |
import std.stdio, std.algorithm, std.string, std.conv, std.array, std.range, std.math, core.stdc.stdio;
int f(int x) {
string s = x.to!string;
int r = 1, n = cast(int) s.length;
foreach(i, c; s) {
r &= s[i] == s[n-1-i];
}
return r;
}
void main() {
int a, b;
scanf("%d %d", &a, &b);
... | D |
import std.stdio;
void main() {
string line=readln();
int ans=0;
for(int i=0;i<3;i++) ans+=line[i]-'0';
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.ascii;
void main()
{
auto n = readln.chomp;
writeln("ABC" ~ n);
}
| D |
import core.bitop, std.algorithm, std.ascii, std.bigint, std.conv, std.math,
std.functional, std.numeric, std.range, std.stdio, std.string, std.random,
std.typecons, std.container;
// 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.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;
string ans = "";
string[] boin =... | 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;
import std.array;
import std.conv;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
void main() {
//stdin.open("input.txt", "r");
//stdout.open("output.txt", "w");
string num = strip(readln());
if (num[0] == '-') {
int a = to!int(num[0..$-1]);
... | 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;
import std.string;
import std.conv;
void main() {
int x = to!int(chomp(readln()));
writeln(x < 1200 ? "ABC": "ARC");
}
| 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 N = readln.chomp.to!int;
auto A = readln.split.map!(to!int).array;
auto B = new long[](N+10... | D |
import std.stdio;
import std.conv;
import std.string;
import std.algorithm;
import std.math;
void main(){
while(true){
string[] s = [];
for(int i=0;i<8;i++){
string temp = readln();
if(stdin.eof()) break;
s ~= chomp(temp);
}
if(stdin.eof()) break;
string ans = "none";
for(int i=0;i<7;i++)
... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.range;
import std.container;
import std.bigint;
import std.math;
void main()
{
auto ab = readln.split.map!(to!int);
writeln(ab[0]*ab[1], " ", ab[0]*2+ab[1]*2);
} | 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;
auto halfN = N / 2;
writeln(halfN - (N%2 == 0 ? 1 : 0));
}
| 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 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.stdio, std.conv, std.string, std.math;
void main(){
auto ip = readln.split.to!(int[]);
if(ip[0] * ip[1] < ip[2] * ip[3]){
writeln(ip[2] * ip[3]);
} else if(ip[0] * ip[1] > ip[2] * ip[3]){
writeln(ip[0] * ip[1]);
} else {
writeln(ip[2] * ip[3]);
}
} | 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 |
/+ dub.sdl:
name "F"
dependency "dunkelheit" version=">=0.7.4"
+/
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[][] g = new int[][n];
foreach (i; 0..n-1) {
int a, b;
... | D |
import std.stdio, std.conv, std.functional, std.string;
import std.algorithm, std.array, std.container, std.range, std.typecons;
import std.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.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric, std.container, core.bitop;
Tuple!(N, N)[] prime_division(N)(N n)
{
auto nn = n;
Tuple!(N, N)[] res;
for (N i = 2; i^^2 <= nn; ++i) {
if (n%i == 0) {
N cnt;
while (n%i == 0)... | D |
import std.stdio, std.string, std.conv, std.algorithm;
import std.range, std.array, std.math, std.typecons, std.container, core.bitop;
import std.numeric;
void main() {
int n;
scan(n);
foreach (k ; 1 .. n + 1) {
int s = k * (k + 1) / 2;
if (n <= s) {
int x = s - n;
... | D |
import std.algorithm;
import std.array;
import std.conv;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
int readint() {
return readln.chomp.to!int;
}
int[] readints() {
return readln.split.map!(to!int).array;
}
void main() {
readln;
auto xs = readints();
... | D |
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 x, a, b; readV(x, a, b);
writeln((x-a).abs < (x-b).abs ? "A" : "B");
}
| D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto k = readln.chomp.to!int;
auto ab = readln.split.to!(int[]);
auto A = ab[0];
auto B = ab[1];
auto x = k;
while (x <= B) {
if (x >= A) {
writeln("OK");
... | D |
import std.stdio;
import std.algorithm;
import std.math;
import std.conv;
import std.string;
int readInt(){
return readln.chomp.to!int;
}
int[] readInts(){
return readln.chomp.split.to!(int[]);
}
void main(){
string s = readln.chomp;
int nf = s[0 .. 2].to!int;
int nl = s[2 .. 4].to!int;
bool YYMM = fals... | D |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.