code stringlengths 4 1.01M | language stringclasses 2
values |
|---|---|
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();
long ans = long.max;
// foreach (i; 1 .. (... | D |
import std.stdio,
std.string,
std.conv,
std.algorithm;
void main() {
int N = readln.chomp.to!(int);
int[] A = readln.chomp.split.to!(int[]);
if (N == 1) {
writeln(1);
return;
}
int ans;
for (int i = 1; i < N; ) {
i += max(plus(A, i), minus(A, i)) + 1;
ans++;
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.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() {
auto xs = readints();
int a = xs[0], b = xs[1], c =... | 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 |
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.conv, std.array, std.algorithm, std.math, std.typecons;
void main() {
const N = readln.chomp.to!long;
auto as = readln.split.to!(long[]);
auto res = long.max;
while (true) {
auto candidates = as.filter!(a => a > 0);
if (candidates.empty) brea... | D |
import std.stdio, std.algorithm, std.range, std.conv, std.string, std.math;
import core.stdc.stdio, core.bitop;
// foreach, foreach_reverse, writeln
void main() {
int n, MOD;
scanf("%d%d", &n, &MOD);
long[][] c = new long[][](n+1,n+2);
c[0][0] = 1;
foreach (i; 0..n) {
foreach (j; 0..i+1) {
(c[i+1][j] += c[... | D |
void main() {
int k = readln.chomp.to!int;
writeln(k / 2 * ((k + 1) / 2));
}
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.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;
alias Point = Tuple!(int, "x", int, "y", int, "h");
Point[101] points;
Point point_;
foreach (i; 0 .. N) {
auto data = readln.sp... | D |
void main(){
import std.stdio, std.string, std.conv, std.algorithm;
import std.math;
int n, d; rd(n, d);
auto t=new long[](n);
auto f=new long[](n);
foreach(i; 0..n) rd(t[i], f[i]);
long sm=0, pos=1, tm=0, m=0;
foreach(i; 0..n){
if(tm+(pos-1)+(f[i]-1)<=t[i]){
sm+=m*(pos-1);
m=1;
}e... | D |
import std.stdio;
import std.conv;
import std.array;
import std.string;
import std.algorithm;
void main() {
string S;
S = chomp(readln());
string res = "";
if(S[0] == '9' || S[1] == '9') {
res = "Yes";
}
else{
res = "No";
}
writeln(res);
}
| 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()
{
immutable mod = 1_000_000_000 + 7;
auto n = readln.chomp.to!int... | D |
import std.algorithm;
import std.array;
import std.container;
import std.conv;
import std.math;
import std.numeric;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
bool isPalindrome(string s) {
int n = cast(int)s.length;
for (int i = 0; i < n/2; i++) {
if (s[i] != s[$-i-1]) ... | D |
void main() {
int n = readln.chomp.to!int;
int[] a = new int[n];
foreach (i; 0 .. n) {
a[i] = readln.chomp.to!int;
}
bool[] light = new bool[n];
light[0] = true;
int now = a[0];
int cnt;
while (!light[1]) {
if (light[now-1]) {
cnt = -1;
break;
... | D |
unittest
{
assert( [ "6", "ooxoox" ].parse.expand.solve == "SSSWWS" );
assert( [ "3", "oox" ].parse.expand.solve == "-1" );
assert( [ "10", "oxooxoxoox" ].parse.expand.solve == "SSWWSSSWWS" );
}
import std.conv;
import std.range;
import std.stdio;
import std.typecons;
void main()
{
stdin.byLineCopy.parse.expand... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.array;
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 |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
auto P = 10L^^9+7;
long[100][5][5][5] MEMO;
void main()
{
auto N = readln.chomp.to!int;
foreach (ref xx; MEMO) foreach (ref yy; xx) foreach (ref zz; yy) foreach (ref memo; zz) memo = -1;
long solve(in... | 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.algorithm, std.container, std.conv, std.math, std.range, std.typecons, std.stdio, std.string;
import std.numeric;
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 readC(T...)(size_t n,ref T... | 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 n = read();
int[] a = reads();
int ans = i... | D |
void main() {
problem();
}
void problem() {
auto N = scan!int;
auto M = scan!int;
auto Q = scan!int;
auto ABCD = Q.iota.map!(x => scan!int(4)).array;
long calcScore(int[] nm) {
long s;
foreach(abcd; ABCD) {
auto a = abcd[0];
auto b = abcd[1];
auto c = abcd[2];
auto d =... | D |
void main() {
int n = readln.chomp.to!int;
int[] a1 = readln.split.to!(int[]);
int[] a2 = readln.split.to!(int[]);
int candy;
foreach (i; 0 .. n) {
candy = max(candy, a1[0..i+1].sum+a2[i..$].sum);
}
candy.writeln;
}
import std.stdio;
import std.string;
import std.array;
import std... | 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;
import std.datetime;
void main()
{
auto n = readln.chomp.to!int;
foreach (_; 0..n) {
bool[int] f;
auto x = readln.chomp.to!int;
int cnt;
... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric, std.container;
long P = 10^^9+7;
long[10^^5*2] F, RF;
long pow(long x, long n) {
long y = 1;
while (n) {
if (n%2 == 1) y = (y * x) % P;
x = x^^2 % P;
n /= 2;
}
return y;
}
lo... | 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 s = readln.split.map!(to!long);
auto A = s[0];
auto B = s[1];
long[] X, Y;
bool[lo... | 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;
bool[][] G;
G.length = N;
foreach (i; 0..N) {
G[i].length = N;
foreach (j, x; readln.chomp) {
if (x == '1') G[i][j] = true;
... | D |
import std.stdio, std.conv, std.string, std.range, std.algorithm, std.array,
std.functional, std.container, std.typecons;
void main() {
auto input = readln.split.to!(int[]);
auto N = input[0], D = input[1];
auto r = 2*D + 1;
((N + r -1) / r).writeln;
}
| 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 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.string;
import std.conv;
import std.bigint;
import std.typecons;
import std.algorithm;
import std.array;
import std.math;
import std.range;
void main() {
auto tmp = readln.split.to!(int[]);
if (tmp[0] == tmp[1]) writeln(tmp[2]);
else if (tmp[1] == tmp[2]) writeln(tmp[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, core.bitop;
void main(){
auto S = scanString;
string NS;
bool B;
for(int i = 0;i < S.length-1;i++... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric, std.container, std.range;
void main()
{
auto N = readln.chomp.to!int;
auto as = readln.split.to!(int[]);
auto a_max = as.maxElement;
if (as.all!(a => a == a_max) && a_max+1 == N) {
writeln("Y... | 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;
string read(){ static string[] ss; while(!ss.length) ss = readln.chomp.split; string res = ss[0]; ss.popFront; return res; }
void main(){
long a = read.to!long;
... | D |
// Vicfred
// https://atcoder.jp/contests/abc135/tasks/abc135_c
// greedy
import std.algorithm;
import std.array;
import std.conv;
import std.stdio;
import std.string;
void main() {
long n = readln.chomp.to!long;
long[] as = readln.split.map!(to!long).array;
long[] bs = readln.split.map!(to!long).array;
... | 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 = 1L << 50;
enum mod = 10L^^9 + 7;
void main() {
int n;
scan(n);
auto adj = new int[][](n, 0);
foreach (i ; 0 .. n-1) {
int x, y;
... | D |
import std.stdio, std.string, std.algorithm, std.conv, std.range, std.array;
void main(){
auto input = readln.chomp.split.map!(to!int).array;
chain(iota(input[0],min(input[0]+input[2],(input[1]+input[0]+1)/2)),iota(max(input[1]-input[2]+1,(input[0]+input[1])/2),input[1]+1)).uniq.each!writeln;
} | 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()
{
while (1) {
auto x = readln.chomp.split.map!(to!int);
if (x[0] == 0) break;
foreach (i; 0..x[0]) {
foreach (j; 0..x[1]) {
if (... | D |
void main()
{
long n = rdElem;
long[][] lists = new long[][](10, 10);
foreach (i; 1 .. n+1)
{
long f = i;
long b = f % 10;
while (f > 9) f /= 10;
++lists[f][b];
}
long result;
foreach (i; 0 .. 10)
{
foreach (j; 0 .. 10)
{
resu... | D |
import std.algorithm;
import std.array;
import std.conv;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.traits;
import std.random;
void test () {
auto s = readln.strip;
int[26] c;
foreach (i; s) {
++c[i.to!int - 97];
}
auto x = iota (0, 26, 2), y = iota (1, 26, 2);
a... | D |
import std.algorithm;
import std.array;
import std.ascii;
import std.bigint;
import std.complex;
import std.container;
import std.conv;
import std.functional;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
auto readInts() {
return array(map!(to!int)(readln().strip().split... | 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 A, B, M;
scan(A, B, M);
auto a = readln.split.to!(int... | 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 |
/+ dub.sdl:
name "C"
dependency "dcomp" version=">=0.6.0"
+/
import std.stdio, std.range, std.algorithm, std.conv;
// import dcomp.scanner;
// import dcomp.algorithm;
int main() {
auto sc = new Scanner(stdin);
int n, m;
sc.read(n, m);
int[][] g = new int[][](n);
foreach (i; 0..m) {
... | D |
import std.stdio, std.conv, std.array,std.string;
void main()
{
string[] input=readln.split(",");
writeln(input[0]~" "~input[1]~" "~input[2]);
} | 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 h = readln.chomp.to!int;
auto w = readln.chomp... | D |
import std.stdio,std.conv,std.string,std.algorithm,std.array;
void main(){
auto s=readln().chomp().split().map!(to!int);
int a,b,c,d;
a=s[0];
b=s[1];
c=s[2];
d=s[3];
if(a+b>c+d) writeln("Left");
else if(a+b==c+d) writeln("Balanced");
else writeln("Right");
} | D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
auto ma = 10^^5;
auto p = primes(10^^5);
auto b = new bool[](ma+1);
foreach (pi; p) b[pi] = true;
auto c = new bool[](ma+1);
foreach (i; 0..ma+1) c[i] = (i&1) && b[i] && b[(i+1)/2];
auto d = new int[](ma+1);
foreach (i; ... | D |
import std.algorithm;
import std.array;
import std.container;
import std.conv;
import std.math;
import std.numeric;
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 read... | 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.to!(char[]).array;
int i, res;
i = res = 0;
while (i != s... | D |
import std.stdio, std.range, std.conv, std.string, std.array, std.functional;
import std.algorithm.comparison, std.algorithm.iteration, std.algorithm.mutation, std.algorithm.searching, std.algorithm.setops, std.algorithm.sorting;
import std.container.binaryheap;
void main()
{
auto input = readln().strip.split.to!(... | D |
import std.stdio, std.string, std.range, std.conv, std.array, std.algorithm, std.math, std.typecons;
void main() {
writeln(min(readln.chomp.to!int, readln.chomp.to!int) + min(readln.chomp.to!int, readln.chomp.to!int));
}
| D |
void main() {
auto N = ri;
auto S = rs;
if(S.length == 1) {
writeln(3);
return;
}
bool[] arr;
ulong index = 0;
while(index < N - 1) {
if(S[index] != S[index+1]) {
arr ~= false;
if(index == N - 2) arr ~= false;
index++;
} else {
arr ~= true;
index += 2;
}
}
ulong res;
if(arr[0]) res =... | D |
void main() {
problem();
}
void problem() {
const N = scan!ulong;
const K = scan!int;
const steps = K.iota.map!(x => [scan!ulong, 1 + scan!ulong]).array;
steps.deb;
ulong solve() {
ulong ans;
auto dp = new ulong[N + 1];
dp[N - 1] = 1;
auto acc = new ulong[2 * N + 2];
acc[N - 1] = 1;
... | D |
void main()
{
long n = rdElem;
long[] b = rdRow;
long[] lists = new long[n];
long idx = n;
foreach (i; 0 .. n)
{
foreach_reverse (j; 0 .. idx)
{
if (j + 1 == b[j])
{
--idx;
lists[idx] = b[j];
b = b[0..j] ~ b... | 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;
import std.conv;
import std.string;
void main() {
int S = to!int(chomp(readln()));
int s = S % 60;
S /= 60;
int m = S % 60;
S /= 60;
int h = S;
writeln(to!string(h) ~ ":" ~ to!string(m) ~ ":" ~ to!string(s));
} | D |
import std.stdio, std.math, std.conv, std.algorithm, std.string, std.array;
double[12][1 << 12] dp;
int[] arr;
double search_min_length(int used, int[] rest, int last) {
if (used == ((1 << arr.length) - 1)) return arr[last];
if (dp[used][last] != -1) return dp[used][last];
double res = int.max;
foreach(int i... | D |
import std.stdio, std.string, std.conv, std.range, std.array, std.algorithm;
import std.uni, std.math, std.container, std.typecons, std.typetuple;
import core.bitop, std.datetime;
immutable long mod = 10^^9 + 7;
immutable long inf = mod;
void main(){
int n = readln.chomp.to!int;
int ans;
foreach(i ; 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, 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 r1, c1, r2, c2;
scan(r1, c1, r2, c2);
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;
T read(T)() { return readln.chomp.to!T; }
T[] reads(T)() { return readln.split.to!(T[]); }
alias readint = read!int;
alias readints = reads!int;
int countAB(string s) {... | 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, std.typecons, std.format, std.bitmanip;
// }}}
// nep.scanner {{{
class Scanner {
import std.stdio : File, stdin;
import std.conv : to;
import std.array : ... | D |
void main()
{
long[] tmp = rdRow;
long h = tmp[0], n = tmp[1];
long[] a = new long[n], b = new long[n];
foreach (i; 0 .. n)
{
tmp = rdRow;
a[i] = tmp[0], b[i] = tmp[1];
}
long inf = 1L << 60;
long[] dp = new long[](h+1);
dp[] = inf;
dp[0] = 0;
foreach (i; 0 .... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
int[10^^5] AS, BS, CS;
int[10^^5][3] MEMO;
void main()
{
auto N = readln.chomp.to!int;
foreach (i; 0..N) {
auto abc = readln.split.to!(int[]);
AS[i] = abc[0];
BS[i] = abc[1];
... | D |
import std.conv, std.stdio;
import std.algorithm, std.array, std.range, std.string;
import std.typecons;
alias Pair = Tuple!(size_t, bool);
void main()
{
immutable n = readln.chomp.to!size_t,
a = readln.chomp.split.to!(long[]);
// dp[i, k, 0] := max sum of k elements < i
// dp[i, k, 1] := max sum of k-1... | D |
// Cheese-Cracker: cheese-cracker.github.io
void theCode(){
int n;
n = scan!int;
auto arr = scanArray;
auto freq = new ll[1000];
for(int i = 0; i < n; ++i){
for(int j = 0; j < i; ++j){
++freq[to!int(abs(arr[j] - arr[i]))];
}
}
ll cnt = 0;
for(int i = 0; i < 1... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric, std.container, std.range;
enum P = 10L^^9+7;
void main()
{
auto nm = readln.split.to!(long[]);
auto N = nm[0];
auto M = nm[1];
auto xx = readln.split.to!(long[]);
auto yy = readln.split.to!(long[... | D |
void main() {
auto N = readAs!ulong;
auto k = 1;
ulong a = 0;
if(N % 2 == 1) {
writeln(0);
return;
}
for(ulong i = 10; N >= i; i *= 5) a += N / i;
a.writeln;
}
// ===================================
import std.stdio;
import std.string;
import std.functional;
import std.algorithm;
import std.range;
import s... | D |
import std.stdio, std.string, std.range, std.conv, std.array, std.algorithm, std.math, std.typecons;
void main() {
3.iota.map!(i => readln.chomp[i]).array.writeln;
}
| D |
// Code By H~$~C
module main;
import core.stdc.stdlib, core.stdc.string;
import std.stdio, std.array, std.string, std.math, std.uni;
import std.algorithm, std.range, std.random, std.container;
import std.conv, std.typecons, std.functional;
immutable Maxn = 100005;
immutable LOG = 19;
int n, q;
Tuple!(int, int, int)... | 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() {
string s = readln.chomp;
foreach (x; lowercase) {
if (!s.canFind(x)) {
x.writeln;
break;
}
if (x == 'z') "None".writeln;
}
}
import std.stdio;
import std.string;
import std.array;
import std.conv;
import std.algorithm;
import std.range;
import s... | D |
import std.algorithm;
import std.array;
import std.container;
import std.conv;
import std.math;
import std.numeric;
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 read... | D |
void main() {
problem();
}
void problem() {
const S = scan;
auto N = S.length;
long solve() {
if (N < 4) return 0;
const P = 2019;
long ans;
auto cs = new long[](P);
cs[0] = 1;
long x, t = 1;
foreach_reverse (c; S) {
x = ((c-'0').to!long * t + x) % P;
t = (t ... | D |
import std;
auto input()
{
return readln().chomp();
}
alias sread = () => readln.chomp();
void main()
{
long n, m;
scan(n, m);
//writeln(n, m);
auto color = new bool[](n);
color[0] = true;
auto cup = new long[](n);
cup[] = 1;
foreach (i; 0 .. m)
{
long x, y;
sc... | D |
import std.stdio;
void main()
{
for (int i = 0; i < 1000; i++) {
writeln("Hello World");
}
} | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array;
void main() {
int n;
scan(n);
int d, x;
scan(d, x);
foreach (i ; 0 .. n) {
int ai;
scan(ai);
x += (d + ai - 1) / ai;
}
writeln(x);
}
void scan(T...)(ref T args) {
import std.s... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array;
void main() {
writeln(readln.chomp.replace(" ", "").to!int % 4 ? "NO" : "YES");
}
void scan(T...)(ref T args) {
import std.stdio : readln;
import std.algorithm : splitter;
import std.conv : to;
import std.range.... | 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 |
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(){
char[] s = readln.chomp.to!(char[]);
long k = readln.chomp.to!long;
foreach(i, c; s){
int x = 'z' + 1 - c;
if(s[i] > 'a' && x <= k){
s[i] = 'a';
... | 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;
void calc(int n, int m) {
int lo = 1;
int hi = n;
bool[int] used;
foreach (i; 0..m) {
int a = abs(lo - hi);
int b = n - a;
if (a == b || a in used || b in used) {
hi--;
}
writeln(lo, " ", hi);
lo++;
hi--;
used[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;
void main() {
int a, b, c;
scan(a, b, c);
int k;
scan(k);
int cnt;
while (a >= b) {
b *= 2;
cnt++;
}
wh... | D |
import std.stdio;
import std.string;
void main() {
string ans = "WA";
string s = readln.strip;
if (s[0] == 'A') {
ulong c = 0;
foreach(i, e; s[0..$ - 1]) {
if (e == 'C' && i > 1) {
c = i;
break;
}
}
if (c > 1) {
... | D |
void main() {
import std.stdio, std.string, std.conv, std.algorithm;
int n;
rd(n);
auto s = readln.chomp.to!(char[]);
int q;
rd(q);
auto ks = readln.split.to!(int[]);
foreach (k; ks) {
long d = 0, dm = 0, dmc = 0;
long m = 0;
foreach (i; 0 .. k) {
if (s[i] == 'D') {
d++;
... | D |
class UnionFind{
int[] root;
this(int n){
root.length=n;
foreach(i; 0..n) root[i]=i;
}
int find(int x){
if(x==root[x]) return x;
else return root[x]=find(root[x]);
}
void merge(int x, int y){
x=find(x); y=find(y);
if(x==y) return;
root[x]=y;
}
}
void main(){
import std.stdio... | 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();
long bignum... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
int main()
{
string[] num = readln().split();
num.sort;
writeln(num[0], " ", num[1], " ", num[2]);
return 0;
} | D |
import std.stdio, std.conv, std.string, std.algorithm, std.math, std.array, std.container;
int n, k, c;
bool[] solve() {
scanf("%d %d %d\n", &n, &k, &c);
string s = readln.chomp;
bool[] banned = s.map!(c => c=='x').array;
int[] l = new int[k];
int k_cnt = 0;
for(int i=0; i<n; i++) {
if(!banned[i]) {
... | D |
import std.stdio;
//import std.string;
//import std.conv;
import core.stdc.stdio;
void main(){
//int a = to!int(chomp(readln()));
//int b = to!int(chomp(readln()));
int a;
int b;
scanf("%d",&a);
scanf("%d",&b);
if(a == b)
writeln("a == b");
else
writeln((a < b) ? "a < b" : "a > b");
} | D |
import std.stdio;
import std.string;
import std.conv;
int main()
{
while (true) {
string[] str = readln().split();
if (str[0] == "0" && str[1] == "0") break;
for (int i = 0; i < str[0].to!int(); i++) {
for (int j = 0; j < str[1].to!int(); j++) {
write("#");
... | D |
void main() {
long[] tmp = readln.split.to!(long[]);
long n = tmp[0], k = tmp[1];
writeln(k * (k - 1) ^^ (n - 1));
}
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... | D |
void main() {
(700 + readln.chomp.count!"a == 'o'" * 100).writeln;
}
// ===================================
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.range;
import std.traits;
import std.math;
import std.bigint;
import std.numeric;
import std.conv;
import std.typecons;
im... | D |
import std.stdio;
import std.string;
import std.array;
import std.conv;
import std.algorithm;
import std.math;
void main()
{
string w = chomp(readln());
int[26] alphabet_list;
for(int i = 0;i < w.length;i ++)
{
alphabet_list[to!int(w[i])-97] ++;
}
int odd_num_count = 0;
for(int i=0;i < 26;i ++)
{
if(alp... | 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;
int[(10^^5)*2] AS;
void main()
{
auto N = readln.chomp.to!int;
foreach (i; 0..N) AS[i] = readln.chomp.to!int;
if (AS[0]) {
writeln("-1");
return;
}
long cnt;
foreach (i; 1..N) {
if (AS[i] > AS[i-1]+1) {... | D |
import std.stdio, std.conv, std.functional, std.string;
import std.algorithm, std.array, std.container, std.range, std.typecons;
import std.bigint, std.numeric, std.math, std.random;
import core.bitop;
string FMT_F = "%.10f";
static File _f;
void file_io(string fn) { _f = File(fn, "r"); }
static string[] s_rd;
T _RD(... | D |
import std.stdio, std.string, std.conv;
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;
scan(n);
auto a = iota(n).map!(i ... | D |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.