code stringlengths 4 1.01M | language stringclasses 2
values |
|---|---|
import std.stdio;
import std.conv;
import std.algorithm;
import std.string;
import std.array;
void main() {
int n = readln.chomp.to!int;
int[] a = 0~readln.split.map!(to!int).array;
int ans = 0;
for(int i = 1; i <= a.length; i++)
if(i%2 == 1 && a[i]%2 == 1)
ans += 1;
ans.writeln... | 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;
long calc(long a, long b, long c, long k) {
long ans = 0;
long x = min(a, k);
ans += x;
k -= x;
k -= min(b, k);
long y = min(c, k);
ans += -1 * y;
return ans;
}
void main() {
long a, b, c, k; scan(a, b, c, k);
writeln(calc(a, b, c, k));
}
void scan(T...)(ref T a) {... | D |
unittest
{
assert( [ "keyofscience" ].parse.expand.solve == "YES" );
assert( [ "mpyszsbznf" ].parse.expand.solve == "NO" );
assert( [ "ashlfyha" ].parse.expand.solve == "NO" );
assert( [ "keyence" ].parse.expand.solve == "YES" );
assert( [ "keyencex" ].parse.expand.solve == "YES" ); // 追加ケース
assert( [ "xkeyen... | 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 |
void main()
{
long n = readln.chomp.to!long;
string[] tmp = readln.split;
string s = tmp[0], t = tmp[1];
foreach (i; 0 .. n)
{
write(s[i], t[i]);
}
writeln;
}
import std.stdio;
import std.string;
import std.array;
import std.conv;
import std.algorithm;
import std.range;
import std.... | 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(){
int[] nk = readInts();
int ret = nk[0] - nk[1] + 1;
writeln(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 mod = 10L^^9 + 7;
void main() {
int n;
scan(n);
auto h = readln.split.to!(int[]);
auto dp = new long[](n + 1);
dp[1] = abs(h[1] - h[0]);
... | 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;
void main()
{
auto n = readln.chomp.to!int;
auto a = readln.chomp.split.to!(int[]);
int cnt;
... | 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;
long calc(long n) {
... | D |
import std.stdio;
import std.array;
import std.algorithm;
import std.string;
import std.conv;
void main(){
int[] pasta; int[] juice;
for(int i = 0; i < 3; i++){
pasta ~= readln().chomp().to!int();
}
for(int i = 0; i < 2; i++){
juice ~= readln().chomp().to!int();
}
writeln(pasta.... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
void main() {
string[] inputs = split(readln());
int X = to!int(inputs[0]);
int t = to!int(inputs[1]);
max(0, X-t).writeln;
}
| 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;
import std.string;
import std.conv;
import std.array;
import std.range;
import std.algorithm;
void main() {
string input;
while ((input = readln.chomp).length != 0) {
int[] tehai = new int[](9);
int[] yama = new int[](9);
int[] ans;
fill(yama, 4);
f... | D |
import std.stdio, std.conv, std.string, std.range, std.algorithm, std.array, std.functional;
void main() {
auto S = readln.chomp;
auto res = true;
foreach(i, c; S) {
auto odd = i % 2;
if(!odd && !c.among('R', 'U', 'D')) res = false;
if(odd && !c.among('L', 'U', 'D')) res = false;
}
writeln(res ... | D |
// Vicfred
// https://atcoder.jp/contests/abc126/tasks/abc126_b
// implementation
import std.algorithm;
import std.conv;
import std.stdio;
import std.string;
void main() {
const int a = readln.chomp.to!int;
const int yy = a / 100;
const int mm = a % 100;
if(yy >= 1 && yy <= 12) {
if(mm >= 1 &... | D |
import std.stdio, std.string, std.conv;
void main() {
auto AB = readln.split.to!(int[]);
auto A = AB[0], B = AB[1];
A = (A + 11) % 13;
B = (B + 11) % 13;
if (A < B) writeln("Bob");
else if (A > B) writeln("Alice");
else writeln("Draw");
} | 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 sum, m;
foreach (i; 0..n) {
auto p = readln... | D |
void main()
{
long n = rdElem;
long[] a = rdRow;
long mod = 10 ^^ 9 + 7;
long[] hat = new long[n];
long result = 1;
foreach (x; a)
{
if (x == 0)
{
result = result * (3 - hat[0]) % mod;
++hat[0];
}
else
{
result = re... | 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;
alias Tuple!(int, "l", int, "r", int, "x") Condition;
immutable int MOD = 10^^9 + 7;
void main() {
auto s = readln.... | 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 core.bitop;
import std.algorithm;
import std.ascii;
import std.bigint;
import std.conv;
import std.functional;
import std.math;
import std.numeric;
import std.range;
import std.stdio;
import std.string;
import std.random;
import std.typecons;
import std.container;
alias sread = () => readln.chomp();
alias Point... | D |
import std.stdio;
void main(){
auto n=readln();
if(n[0]==n[1]&&n[1]==n[2]) writeln("Yes");
else if(n[1]==n[2]&&n[2]==n[3]) writeln("Yes");
else writeln("No");
} | D |
import std.stdio, std.conv, std.string, std.range, std.algorithm, std.array, std.functional;
void main() {
auto s = readln.chomp;
auto t = readln.chomp;
auto idx = new ulong[][256];
foreach(i, c; s) {
idx[c] ~= 1 + i;
}
long f() {
ulong l,j;
foreach(c; t) {
if(idx[c].length == 0) return... | D |
import std.stdio, std.range, std.conv, std.string;
import std.algorithm.comparison, std.algorithm.iteration, std.algorithm.mutation, std.algorithm.searching, std.algorithm.setops, std.algorithm.sorting;
int calc(int time, int[] n)
{
if(n.length==0)
{
return time;
}
while(time%10!=0)
{
... | D |
// import chie template :) {{{
static if (__VERSION__ < 2090) {
import std.stdio, std.algorithm, std.array, std.string, std.math, std.conv,
std.range, std.container, std.bigint, std.ascii, std.typecons, std.format,
std.bitmanip, std.numeric;
} else {
import std;
}
// }}}
// nep.scanner {{{
class Scanner {
... | D |
import std.stdio;
import std.algorithm;
import std.conv;
import std.numeric;
import std.math;
import std.string;
void main()
{
auto n = to!int(chomp(readln()));
int result;
while (true)
{
auto a1 = n / 100;
auto a2 = (n / 10) % 10;
auto a3 = n % 10;
if (a1 == a2 && a1 == a3)
{
result = n;
break;... | D |
import std.stdio;
import std.algorithm;
import std.string;
import std.range;
import std.array;
import std.conv;
import std.complex;
import std.math;
import std.ascii;
import std.bigint;
import std.container;
import std.typecons;
auto readInts() {
return array(map!(to!int)(readln().strip().split()));
}
auto readInt() ... | D |
import std.stdio,std.conv,std.string;
void main(){
auto s=readln.chomp;
if(s[2]==s[3]&&s[4]==s[5])
"Yes".writeln;
else
"No".writeln;
} | D |
void main() {
int[] a = readln.split.to!(int[]);
writeln(a.reduce!max - a.reduce!min);
}
import std.stdio;
import std.string;
import std.array;
import std.conv;
import std.algorithm;
import std.range;
import std.math;
import std.container;
import std.typecons; | 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.stdlib;
immutable int INF = 1 << 29;
void main() {
auto s = readln.split.map!(to!int);
auto N = s[0];
auto K = s[1];
... | 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 r = readln.chomp.to!int;
int g = readln.chomp.to!int;
writeln = (g ... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric, std.container, std.range;
void get(Args...)(ref Args args)
{
import std.traits, std.meta, std.typecons;
static if (Args.length == 1) {
alias Arg = Args[0];
static if (isArray!Arg) {
... | D |
import std.stdio, std.string, std.algorithm, std.array, std.range, std.conv,
std.typecons, std.math, std.container, std.format, std.numeric;
void main(string[] args)
{
string s = readln.strip;
string t = readln.strip;
long cnt = 0;
foreach (i; 0 .. s.length)
{
if (s[i] != t[i])
... | D |
import core.bitop;
import std.algorithm;
import std.ascii;
import std.bigint;
import std.conv;
import std.functional;
import std.math;
import std.numeric;
import std.range;
import std.stdio;
import std.string;
import std.random;
import std.typecons;
alias sread = () => readln.chomp();
alias Point2 = Tuple!(long, "y", ... | D |
import std.stdio;
import std.conv;
import std.string;
void main()
{
int[] a;// = to!( int[] )( readln.chomp() );
for(;a.length<4;)a~= to!( int )( readln.chomp() );
writeln(a[0] > a[1] ? a[1] * a[2] + (a[0] - a[1]) * a[3]:a[0] * a[2]);
}
| 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.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;
bool calc(string s, st... | 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 "A"
dependency "dcomp" version=">=0.6.0"
+/
import std.stdio, std.algorithm, std.range, std.conv;
import std.typecons;
import std.bigint;
// import dcomp.foundation, dcomp.scanner;
// import dcomp.container.deque;
int main() {
auto sc = new Scanner(stdin);
int n, m, k;
sc.read(n... | D |
import std.stdio;
void main()
{
foreach(i;1..10)
foreach(j;1..10)
writeln(i,"x",j,"=",i*j);
} | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto N = readln.chomp.to!int;
auto ss = new string[](N);
auto ts = new int[](N);
foreach (i; 0..N) {
auto st = readln.split;
ss[i] = st[0];
ts[i] = st[1].to!int;
... | D |
import std.stdio, std.string, std.range, std.conv, std.array, std.algorithm, std.math, std.typecons, std.functional;
void main() {
const tmp = readln.split.to!(long[]);
const N = tmp[0], K = tmp[1];
const as = readln.split.to!(long[]);
ulong X = 0;
foreach_reverse(i; 0..64) {
const cnt = a... | 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() {
int N;
scan(N);
auto a = iota(N).map!(i => readln.chomp.t... | D |
// Try Codeforces
// author: Leonardone @ NEETSDKASU
import std.stdio, std.string, std.array, std.algorithm, std.conv;
void main() {
auto nab = to!(int[])(split(chomp(readln())));
int n = nab[0], a = nab[1], b = nab[2];
int ans = 0;
int[101] u, w;
for (int i = 0; i < n; i++) {
auto xy = to!... | 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 |
/+ dub.sdl:
name "B"
dependency "dcomp" version=">=0.9.0"
+/
import std.stdio, std.algorithm, std.range, std.conv;
// import dcomp.foundation, dcomp.scanner;
import std.typecons;
int main() {
Scanner sc = new Scanner(stdin);
int n;
sc.read(n);
int[] a = [1];
int[] b = [];
foreach (_; ... | 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.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.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 |
//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;
int f (int x) {
return (x * (x - 1) ) / 2;
}
void main() {
int n = readln.strip.to!int;
int[26] c;
foreach (i; 0 ... | D |
// cheese-cracker [2022-02-06]
void solve(){
long n = scan;
long x = scan;
long y = scan;
auto arr = scanArray;
long summ = arr.sum + x;
if(summ % 2 == y % 2){
writeln("Alice");
}else{
writeln("Bob");
}
}
void main(){
long tests = scan; // Toggle!
while(t... | 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 |
module main;
import core.stdc.stdio;
int main()
{
int n;
scanf("%d", &n);
int [] a = new int[n];
int [] b = new int [n];
int k = 1, id = 0;
a[0]=-1;
for(int i = 1; i <= n; i ++)
{
scanf("%d", &a[i]);
if(a[i] == a[i - 1])
k ++;
else
{
if(i != 1) {
id ++;
b[id] = k;
k = 1;
}
}
}
... | 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!int);
auto N = s[0];
auto M = s[1];
auto K = s[2];
auto G = ne... | D |
import std.algorithm;
import std.conv;
import std.range;
import std.stdio;
import std.string;
void main ()
{
auto n = readln.strip.to!int;
int k = 0;
int [] [] a;
n.iota.each !(_ => a ~= readln.split.map!(to!int).array);
n.iota.each !(k =>
n.iota.each !(i =>
n.iota.each !(j =>
a[i][j] = min (a[i][j], a[i... | 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;
immutable long mod = 10^^9 + 7;
void main() {
long n, m, k;
scan(n, m, k);
if (n > m) swap(n, m);
long ans = powmod(2, n - 1, mod);
ans = powmod(ans... | 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 s = readln.split.map!(to!int);
auto N = s[0];
auto Q = s[1];
auto st = new LazySegmentT... | 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 File _f;
void file_io(string fn) { _f = File(fn, "r"); }
static string[] s_rd;
T _RD(T = long)() ... | 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;
while (n >= 2 && a.front == a.back)
{
n -= 2;
a... | 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.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
enum P = 10^^9L+7;
long[10^^5*2+1] SS;
bool[10^^5*2+1] BS;
void main()
{
auto nm = readln.split.to!(int[]);
auto N = nm[0];
auto M = nm[1];
foreach (_; 0..M) {
auto a = readln.chomp.to!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 main() {
int[char] aa;
string alphabet = "abcdefghijkl... | D |
import std.stdio, std.string, std.conv;
import std.algorithm, std.array;
auto solve(string s_)
{
auto Nx = s_.split.map!(to!long)();
immutable N=Nx[0], x=Nx[1];
auto as = readln.split.map!(to!long).array();
long m=sum(as);
foreach(k;1..N)
{
auto dp = new long[N];
foreach(i;0..N... | D |
import std.stdio;
import std.conv;
import std.string;
import std.typecons;
import std.algorithm;
import std.array;
import std.range;
import std.math;
import std.regex : regex;
import std.container;
import std.bigint;
void main()
{
auto x = readln.chomp.to!int;
auto c = ('C' + (x / 1000)).to!char;
writeln("AB" ~... | 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.range, std.algorithm, std.math, std.conv;
void main() {
auto N = readln.chomp.to!int;
auto T = readln.split.to!(int[]);
auto M = readln.chomp.to!int;
auto s = T.sum;
foreach (i; 0..M) {
auto inp = readln.split.to!(int[]);
auto P = inp[0]-1, X = inp[1];
writ... | 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 |
pragma(inline, true)
void chmin(T)(ref T a, T b) {
if (a > b) a = b;
}
int[] init() {
enum INF = 1 << 28;
int[] dp = new int[100010];
foreach (i; 1..100001) {
dp[i] = INF;
int p6 = 1, p9 = 1;
while (p6 <= i || p9 <= i) {
if (i - p6 >= 0)
chmin(dp[i], ... | 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 core.bitop;
import std.algorithm;
import std.ascii;
import std.bigint;
import std.conv;
import std.functional;
import std.math;
import std.numeric;
import std.range;
import std.stdio;
import std.string;
import std.random;
import std.typecons;
alias sread = () => readln.chomp();
alias Point2 = Tuple!(long, "y", ... | D |
import std.stdio, std.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() {
string s;
scan(s);
int x, y;
scan(x, y... | D |
import std.stdio, std.string, std.range, std.conv, std.array, std.algorithm, std.math, std.typecons, std.random;
void main() {
const tmp = readln.split.to!(long[]);
auto N = tmp[0], M = tmp[1];
auto ps = readln.split.to!(long[]);
auto pairs = M.iota.map!(_ => readln.split.to!(long[])).array;
auto ... | D |
import std.stdio, std.math, std.algorithm, std.array, std.string, std.conv, std.container, std.range;
pragma(inline, true) T[] Reads(T)() { return readln.split.to!(T[]); }
alias reads = Reads!int;
pragma(inline, true) void scan(Args...)(ref Args args) {
string[] ss = readln.split;
foreach (i, ref arg ; args) ar... | D |
void main() {
import std.stdio, std.string, std.conv, std.algorithm;
import std.math : abs;
int x, y, z;
rd(x, y, z);
bool plus = false, minus = false, zero = false;
if (x + z > y) {
plus = true;
}
if (x < y + z) {
minus = true;
}
if (z >= abs(x - y)) {
if ((z - abs(x - y)) % 2 == 0) {... | D |
import std.stdio, std.conv, std.string, std.array, std.range, std.algorithm, std.container;
import std.math, std.random, std.bigint, std.datetime, std.format;
void main(string[] args){ if(args.length > 1) if(args[1] == "-debug") DEBUG = 1; solve(); }
void log()(){ writeln(""); } void log(T, A ...)(T t, lazy A a){ if(DE... | D |
import std.stdio, std.string, std.conv, std.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.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.conv, std.stdio, std.algorithm, std.string, std.range, std.math;
void main() {
readln;
const tako = readln.split.map!(to!int).array;
const N = tako.length;
int z;
foreach (x; 0..N) foreach (y; x+1..N) {
z += tako[x]*tako[y];
}
z.writeln;
} | D |
import std.stdio;
import std.algorithm;
import std.array;
import std.conv;
import std.string;
import std.uni;
import std.range;
import std.algorithm;
void main()
{
while (!stdin.eof)
{
auto a = readln.strip;
if (a == "-")
break;
auto m = readln.strip.to!int;
foreach ... | 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 |
void main(){
import std.stdio, std.string, std.conv, std.algorithm;
int n; rd(n);
auto d=new int[](n);
foreach(i; 0..n) rd(d[i]);
bool ok=true;
void f(){
int r=0;
foreach(int i, int e; d){
ok&=i*10<=r;
r=max(r, i*10+e);
}
}
f();
reverse(d);
f();
if(ok) writeln("yes");
... | D |
import std.stdio, std.string, std.range, std.conv, std.array, std.algorithm, std.math, std.typecons;
void main() {
const N = readln.chomp.to!long;
writeln(N*(1+(N&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;
}
int calc(int[] xs) {
int rec(int p, int[] buf) ... | D |
import std.stdio;
import std.conv;
import std.string;
import std.typecons;
import std.algorithm;
import std.array;
import std.range;
import std.math;
import std.regex : regex;
import std.container;
import std.bigint;
void main()
{
auto x = readln.chomp.split.to!(int[]);
auto k = readln.chomp.to!int;
int index;
... | D |
import std.stdio,std.string,std.conv;
immutable int MAX = 50;
immutable int COUNT = 9;
void main(){
char[] buf;
int[] dataset;
while(stdin.readln(buf)){
if(buf.chomp().to!string().isNumeric){
dataset ~= buf.chomp().to!int();
}
if(dataset.length > 50)
break;
... | 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() {
while(true) {
string str = readln.chomp;
if (str ==... | 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, 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;
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 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() {
int N, M;
scan(N, M);
auto a = readln.split.to!(int[]);
... | 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 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;
ulong MOD = 1_000_000_007;
ulong INF = 1_000_00... | 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, core.bitop;
enum MOD = pow(10,9)+7;
void main()
{
auto S = scanString;
if(S[0]==S[1]&&S[2]==S[3]&&S[0]!=S... | D |
void main()
{
long n, c;
ipElems(n, c);
Sushi[] sushi = n.rdCol!Sushi;
long[] l = new long[n+1];
long[] lrev = new long[n+1], lrevmax = new long[n+1];
long pos;
foreach (i, s; sushi)
{
l[i+1] = l[i] + s.v - s.x + pos;
lrev[i+1] = l[i+1] - s.x;
lrevmax[i+1] = max(... | D |
void main() {
int[] tmp = readln.split.to!(int[]);
int a = tmp[0], b = tmp[1];
int coin;
foreach (i; 0 .. 2) {
if (a > b) {
coin += a;
--a;
} else {
coin += b;
--b;
}
}
coin.writeln;
}
import std.stdio;
import std.string;
i... | D |
import std.stdio, std.string, std.array;
void main()
{
readln.replace("apple", "##").replace("peach", "apple").replace("##", "peach").write;
} | D |
import std.stdio, std.conv, std.functional, std.string;
import std.algorithm, std.array, std.container, std.range, std.typecons;
import std.bigint, std.numeric, std.math, std.random;
import core.bitop;
string FMT_F = "%.10f";
static File _f;
void file_io(string fn) { _f = File(fn, "r"); }
static string[] s_rd;
T _RD(... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric, std.container;
void main()
{
auto a = readln.chomp.to!int;
writeln(a + a^^2 + a^^3);
} | D |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.