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;
void main() {
int n;
scan(n);
auto b = iota(n).map!(i => readln.chomp).array;
int checkLeft(string s) {
int h;
foreach (ch ; s)... | 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 = 2*10^^9 + 7;
void main() {
int n, k; scan(n, k);
auto a = new int[](n);
auto b = new int[](n);
foreach (i ; 0 .. n) {
int ai, bi... | 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() {
readi... | D |
import std;
long calc(long x) {
long s = 100;
for (int i = 1; ; i++) {
s = s + cast(long)(s * 0.01);
if (s >= x) return i;
}
assert(false);
}
void main() {
long x; scan(x);
writeln(calc(x));
}
void scan(T...)(ref T a) {
string[] ss = readln.split;
foreach (i, t; T) a[i... | D |
import std.algorithm;
import std.array;
import std.conv;
import std.math;
import std.numeric;
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() {
string s;
... | D |
import std.stdio;
import std.string;
import std.algorithm;
import std.conv;
void main() {
readln.chomp.count('1').writeln;
} | D |
void main() {
writeln("ABC", readln.chomp);
}
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 core.bitop;
import std.algorithm;
import std.ascii;
import std.bigint;
import std.conv;
import std.functional;
import std.math;
import std.numeric;
import std.range;
import std.stdio;
import std.string;
import std.random;
import std.typecons;
import std.container;
alias sread = () => readln.chomp();
ulong bignu... | D |
import std.stdio;
import std.string;
void main() {
const string m = "kstnhm";
const string ch = "aiueo";
const string dir = "TLURD";
auto str = readln;
bool flag = false;
foreach (int i, c; str) {
if (!(i % 2)) {
auto a = c - '0';
if (a == 0) flag = true;
else if (2 <= a && a <= 7) {
write(m[a-2])... | D |
void main() {
int[] tmp = readln.split.to!(int[]);
int n = tmp[0], m = tmp[1];
int[] road = new int[n];
foreach (i; 0 .. m) {
tmp = readln.split.to!(int[]);
int a = tmp[0] - 1, b = tmp[1] - 1;
++road[a], ++road[b];
}
foreach (x; road) {
x.writeln;
}
}
import ... | 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 inf = 3L * 10L^^18;
void main() {
int n, k;
scan(n, k);
auto w = new long[](n);
auto d = new long[](n);
foreach (i ; 0 .. n) {
... | D |
import std;
import core.bitop;
ulong MAX = 100_100, MOD = 1_000_000_007, INF = 1_000_000_000_000;
alias sread = () => readln.chomp();
alias lread(T = long) = () => readln.chomp.to!(T);
alias aryread(T = long) = () => readln.split.to!(T[]);
alias Pair = Tuple!(long, "x", long, "g");
alias PQueue(T, alias less = "a>b") ... | D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
auto rd = readln.split.to!(int[]), w = rd[0], a = rd[1], b = rd[2];
if (a > b) swap(a, b);
writeln(b <= a+w ? 0 : b-(a+w));
}
| D |
import std.stdio;
import std.algorithm;
import std.math;
import std.conv;
import std.string;
T readNum(T)(){
return readStr.to!T;
}
T[] readNums(T)(){
return readStr.split.to!(T[]);
}
string readStr(){
return readln.chomp;
}
void main(){
auto nm = readNums!int;
auto n = new int[](nm[0]);
int penalty, ... | D |
void main()
{
string n = rdStr;
long k = rdElem;
long len = n.length;
long[][][] dp = new long[][][](len+1, k+2, 2);
dp[0][0][0] = 1;
foreach (i, x; n)
{
long d = x - '0';
foreach (j; 0 .. k+1)
{
foreach (u; 0 .. 2)
{
foreach (... | 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;
void main() {
int n;
scan(n);
auto a = readln.split.to!(int[]);
auto pf = new long[](n + 1);
foreach (i ; 1 .. n + 1) {
pf[i] = pf[i-1... | D |
import std;
ulong MAX = 100_100, MOD = 1_000_000_007, INF = 1_000_000_000_000;
alias sread = () => readln.chomp();
alias lread(T = long) = () => readln.chomp.to!(T);
alias aryread(T = long) = () => readln.split.to!(T[]);
alias Pair = Tuple!(long, "base", long, "cnt");
alias PQueue(T, alias less = "a>b") = BinaryHeap!(... | D |
import std.stdio, std.conv, std.string, std.math;
void main(){
auto ip = readln.chomp.to!int;
if(ip < 1200){
"ABC".writeln;
} else {
"ARC".writeln;
}
} | D |
import std.stdio;
import std.algorithm;
import std.string;
import std.functional;
import std.array;
import std.conv;
import std.math;
import std.typecons;
import std.regex;
import std.range;
void main(){
int[] s = readln().split().to!(int[]);
int n,r,l;
n = s[0];
r = s[1];
l = s[2];
int[] d,t,... | 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 nm = readints();
int n = nm[0], m = nm[1];
... | D |
import core.bitop;
import std.algorithm;
import std.ascii;
import std.bigint;
import std.conv;
import std.functional;
import std.math;
import std.numeric;
import std.range;
import std.stdio;
import std.string;
import std.random;
import std.typecons;
import std.container;
alias sread = () => readln.chomp();
ulong MOD =... | 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.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 calc(string s) {
... | D |
import std.stdio, std.conv, std.string;
import std.array, std.range, std.algorithm, std.container;
import std.math, std.random, std.bigint, std.datetime, std.format;
string read(){ static string[] ss; while(!ss.length) ss = readln.chomp.split; string res = ss[0]; ss.popFront; return res; }
int DEBUG_LEVEL = 0;
void pr... | 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 n = read.to!long;
lo... | D |
import std.stdio, std.array, std.string, std.conv, std.algorithm;
import std.typecons, std.range, std.random, std.math, std.container;
import std.numeric, std.bigint, core.bitop, std.bitmanip, std.regex;
void main() {
auto S = readln.chomp;
auto K = readln.chomp.to!int;
auto N = S.length.to!int;
bool[... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
writeln(180 * (readln.chomp.to!int-2));
} | D |
import std.stdio;
import std.string;
import std.math;
import std.conv;
import std.algorithm;
import std.bigint;
void main(){
real[4] x,y;
auto n = to!int(chomp(readln()));
for(int j=0;j<n;j++){
auto s = split(readln());
for(int i=0;i<4;i++){
x[i] = to!real(s[2*i]);
y[i] = to!real(s[2*i+1]);
}... | D |
import std.algorithm;
import std.array;
import std.bigint;
import std.bitmanip;
import std.conv;
import std.math;
import std.numeric;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
T diff(T)(const ref T a, const ref T b) { return a > b ? a - b : b - a; }
T[] readToArray(T)() {
return ... | D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
auto n = readln.chomp.to!size_t;
auto ri = n.iota.map!(_ => readln.chomp.to!int).array;
auto maxR = ri.back;
auto maxP = int.min;
foreach_reverse (i; 0..n-1) {
maxP = max(maxP, maxR - ri[i]);
maxR = max(maxR, ri[i]);
... | D |
void main()
{
long[] tmp = readln.split.to!(long[]);
long k = tmp[0], a = tmp[1], b = tmp[2];
long op = k - a + 1;
long cal = a + (b - a) * (op / 2) + op % 2;
max(k + 1, cal).writeln;
}
import std.stdio;
import std.string;
import std.array;
import std.conv;
import std.algorithm;
import std.range;
... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math;
void main()
{
auto n = readln.chomp.to!int;
auto as = readln.split.to!(long[]);
auto x = as[0];
auto y = reduce!"a + b"(0L, as[1..$]);
auto d = abs(x - y);
for (int i = 1; i < n-1; ++i) {
x += as[i];
y... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array;
void main() {
int a, b, c, d;
scan(a, b, c, d);
writeln(max(a*b, c*d));
}
void scan(T...)(ref T args) {
import std.stdio : readln;
import std.algorithm : splitter;
import std.conv : to;
import std.range.... | 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();
string s;
string t;
scan(s, t);
//... | 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 INF = 1L << 59;
void main() {
auto s = readln.split.map!(to!int);
auto N = s[0];
auto M = s[1]... | 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.algorithm;
import std.conv;
import std.range;
import std.stdio;
import std.string;
void main ()
{
auto tests = readln.strip.to !(int);
multitest_loop:
foreach (test; 0..tests)
{
auto n = readln.strip.to !(int);
auto p = readln.splitter.map !(to !(int)).array;
int res = 0;
foreach (j; 0..n)
{
... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm;
void main() {
int n,k;
scan(n,k);
auto w = new int[][][](2, k, k);
auto b = new int[][][](2, k, k);
foreach (i ; 0 .. n) {
char ci;
int xi, yi;
scan(xi, yi, ci);
auto e = ((xi / k % 2) + (yi ... | 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.string;
import std.conv;
import std.range;
import std.array;
import std.algorithm;
void main(){
auto Z=readln.split.to!(int[]),a=Z[0],b=Z[1],c=Z[2];
if(a+b>=c)writeln("Yes");
else writeln("No");
} | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array, std.math, std.typecons;
void main() {
int n; scan(n);
writeln(euler_phi(n));
}
int euler_phi(int n) {
int ans = n;
for (int p = 2; p*p <= n; p++) {
if (n % p == 0) {
ans = ans / p * (p - 1);
... | 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;
long [] [] s = [[0], [0], [0]];
foreach (i, c; a)
{... | D |
void main() {
int[] tmp = readln.split.to!(int[]);
int n = tmp[0], a = tmp[1], b = tmp[2];
min(a*n, b).writeln;
}
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;
i... | 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 |
/* imports all std modules {{{*/
import
std.algorithm,
std.array,
std.ascii,
std.base64,
std.bigint,
std.bitmanip,
std.compiler,
std.complex,
std.concurrency,
std.container,
std.conv,
std.csv,
std.datetime,
std.demangle,
std.encoding,
std.exception,
std.file,
std.format,
std.functi... | D |
import std.stdio, std.conv, std.string, std.array, std.math, std.regex, std.range, std.ascii, std.numeric, std.random;
import std.typecons, std.functional, std.traits,std.concurrency;
import std.algorithm, std.container;
import core.bitop, core.time, core.memory;
import std.bitmanip;
import std.regex;
enum INF = long.... | D |
import std.stdio;
import std.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() {
int N = 100;
int[] ary = new int[N+1];
while(true) {
... | D |
void main()
{
long n, x;
rdVals(n, x);
long[] l = rdRow;
long[] d = new long[n+1];
foreach (i; 1 .. n+1)
{
d[i] = d[i-1] + l[i-1];
}
long cnt;
foreach (i; 0 .. n+1)
{
if (d[i] <= x) ++cnt;
}
cnt.writeln;
}
enum long mod = 10^^9 + 7;
enum long inf = 1L ... | 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;
void main() {
string n;
scan(n);
bool yn = n[0 .. 3].to!int % 111 == 0 || n[1 .. 4].to!int % 111 == 0;
writeln(yn ? "Yes" : "No");
}
void scan(T...)(r... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
void main() {
auto data = split(readln());
( to!int(data[0]) * to!int(data[1]) / 2 ).writeln();
} | D |
// Vicfred
// https://atcoder.jp/contests/abc177/tasks/abc177_c
// math
import std.algorithm;
import std.array;
import std.conv;
import std.stdio;
import std.string;
void main() {
const long mod = 10^^9+7;
long n = readln.chomp.to!long;
long[] a = readln.split.map!(to!long).array;
long sum = 0;
fo... | 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 pred)(int n) {
foreach(i; 0..n) pred();
}
auto ... | D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
auto s = readln.chomp;
writeln(s.lastIndexOf("Z") - s.indexOf("A") + 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.chomp;
auto N = S.length.to!int;
int v_count = 0;
int h_count = 0;
foreach... | 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;
bool test(int[][] s, int n) {
auto rect = new bool[](n+1);
rect[n] = false;
foreach(_; 0..n) {
foreach(i; ... | 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.string, std.conv, std.algorithm;
import std.range, std.array, std.math, std.typecons, std.container, core.bitop;
immutable inf = 1<<30;
string ng = "UNRESTORABLE";
void main() {
string s, t;
scan(s);
scan(t);
int n = s.length.to!int, k = t.length.to!int;
foreach_reverse (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;
int readint() {
return readln.chomp.to!int;
}
int[] readints() {
return readln.split.map!(to!int).array;
}
void main() {
auto s = readln.chomp;
writeln... | D |
import std.stdio, std.string, std.array, std.conv;
void main() {
int[] tmp = readln.chomp.split.to!(int[]);
int a = tmp[0], b = tmp[1];
writeln(a > 2 * b ? a - 2 * b : 0);
} | D |
import std.algorithm;
import std.array;
import std.conv;
import std.range;
import std.stdio;
import std.string;
void main()
{
auto nx = readln.split.map!( to!int );
auto ms = nx[ 0 ].iota.map!( a => readln.strip ).map!( to!int ).array;
writeln( solve( nx[ 1 ], ms ) );
}
int solve( in int x, in int[] ms )
{
retur... | D |
void main()
{
long n = readln.chomp.to!long;
long[] a = readln.split.to!(long[]);
long psum, msum;
long pcnt, mcnt;
foreach (i; 0 .. n)
{
psum = psum + a[i];
msum = msum + a[i];
if (i & 1)
{
if (psum >= 0)
{
pcnt += psum +... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto nx = readln.split.to!(long[]);
auto N = nx[0];
auto X = nx[1];
long[51] as, ps;
as[0] = 1;
ps[0] = 1;
foreach (i; 1..51) {
as[i] = as[i-1] * 2 + 3;
ps[i... | 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 |
/+ 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.... | D |
import std.algorithm;
import std.array;
import std.bigint;
import std.bitmanip;
import std.conv;
import std.numeric;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
T diff(T)(const ref T a, const ref T b) { return a > b ? a - b : b - a; }
T[] readToArray(T)() {
return readln.split.to!(... | 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;
int main() {
Scanner scn = new Scanner(stdin);
scope(exit) assert(!scn.hasNext);
int h, w, n, sr, sc;
string s, t;
scn.read(h, w, n,... | D |
import std.stdio, std.algorithm, std.range, std.conv;
void main(){
iota(1, 10).map!(a => iota(1, 10).map!(b => text(a, "x", b, "=", a*b)).join("\n")).join("\n").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, core.stdc.stdio, std.bitmanip;
bool ok(ref long[] A, ref long[] B, long n) {
long s = n * (n+1) / 2;
if (A.sum % s != 0)
re... | D |
import std.conv, std.stdio;
import std.algorithm, std.array, std.string, std.range;
void main()
{
auto
x = readln.chomp.to!int,
t = x / 500,
s = (x % 500) / 5;
(t * 1000 + s * 5).writeln;
}
| 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() {
auto ip = readAs!(string[]), A = ip[0].to!int, B = ip[2].to!int, op = ip[1];
if(op == "+") {
writeln(A + B);
} else {
writeln(A - B);
}
}
// ===================================
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.range;
import std.traits;
import... | 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;
void times(alias fun)(int n) {
foreach(i... | D |
/+ dub.sdl:
name "A"
dependency "dcomp" version=">=0.0.2"
+/
import std.algorithm, std.range, std.stdio, std.math, std.conv, core.bitop;
// import dcomp.scanner;
// import dcomp.algorithm;
// import dcomp.container.simpleSeg;
int main() {
import std.conv;
auto sc = new Scanner();
int n; long e, T... | 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 a = readln.splitter.map !(to !(int)).array;
auto n = a[0] - 2;
a = a[1..$];
bool ok = false;
foreach (i; 0..16)
{
auto corn... | D |
// Try Codeforces
// author: Leonardone @ NEETSDKASU
import std.stdio, std.string, std.array, std.algorithm, std.ascii;
void main() {
readln();
auto xs = split(chomp(readln()));
auto ys = xs.map!( (x) => x.count!( isUpper ) );
writeln(ys.maxCount[0]);
} | 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.datetime;
void main() {
auto N = readln.chomp.to!int;
auto G = new int[][](N);
foreach (i; 0..N-1) {
auto v = readln... | 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 |
//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 |
// Try Codeforces
// author: Leonardone @ NEETSDKASU
import std.algorithm : sort, sum;
import std.array : split, appender;
import std.conv : to;
import std.stdio : readln, writeln;
import std.string : chomp;
auto gets() { return readln.chomp; }
auto getV(T)() { return gets.to!T; }
auto getVals(T)(... | D |
void main(){
import std.stdio, std.string, std.conv, std.algorithm;
import std.math;
int n; rd(n);
auto a=readln.split.to!(int[]);
writeln(reduce!((r,e)=>(r+e.abs))(0, a));
}
void rd(T...)(ref T x){
import std.stdio, std.string, std.conv;
auto l=readln.split;
assert(l.length==x.length);
foreach(i, ... | 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.uni;
import std.conv;
import std.container;
import std.functional;
import std.algorithm;
import std.array;
import std.typecons;
void main(string[] args)
{
inputFile = stdin;
debug inputFile = File(args[1]);
auto nt = next!int;
foreach(t; 0 .. nt)
{
auto n = next!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 |
import std.stdio, std.algorithm, std.range, std.conv, std.string, std.math;
import core.stdc.stdio;
// foreach, foreach_reverse, writeln
void main() {
const int MOD = 998244353;
string s = chomp(readln());
int n = to!int(s.length);
int[] a = new int[n];
foreach (i; 0..n) {
a[i] = s[i]-'a';
}
bool same() {
... | 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 ab = aryread!string();
// writeln(ab);
string ab_str = ... | D |
void main() {
problem();
}
void problem() {
const N = scan!int;
const K = scan!long;
const A = scan!int(N);
void solve() {
int[int] alreadyVisited;
int count;
int last;
for(int next = 1; !(next in alreadyVisited); next = A[next-1]) {
if (count == K) {
writeln(next);
re... | 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;
void main()
{
auto r = readln.chomp.to!int;
writeln(3 * r^^2);
} | D |
import std.stdio;
import std.algorithm;
import std.math;
import std.conv;
import std.string;
T readNum(T)(){
return readStr.to!T;
}
T[] readNums(T)(){
return readStr.split.to!(T[]);
}
string readStr(){
return readln.chomp;
}
void main(){
auto xa = readNums!int;
if(xa[0] < xa[1]){
writeln(0);
} else... | D |
void main(){
int[] x = _scanln!()();
foreach(i, elm; x){
if(elm == 0){
writeln(i+1);
return;
}
}
}
import std.stdio, std.conv, std.algorithm, std.numeric, std.string;
// 1要素のみの入力
T _scan(T= int)(){
return to!(T)( readln().chomp() );
}
// 1行に同一型の複数入力
T[] _scanln(T = int)(){
T[] ln;
foreach(string elm... | 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;
void main() {
int n, m;
scan(n, m);
auto a = readln.split.to!(int[]);
int[int] asc;
int[] b = new int[](n + 1);
asc[0] = 1;
b[n] = 0;... | D |
import std.stdio, std.string, std.conv;
void main()
{
auto ip = readln.chomp, X = ip[0], Y = ip[2];
if(X > Y){
writeln(">");
} else if(X < Y){
writeln("<");
} else {
writeln("=");
}
} | D |
import std.stdio, std.string, std.range, std.conv, std.array, std.algorithm, std.math, std.typecons;
void main() {
auto N = readln.chomp.to!int;
string[] wordList;
bool result = true;
foreach (i; 0..N) {
auto W = readln.chomp;
scope(exit) wordList ~= W;
if (wordList is null) con... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string;
void main()
{
readln.count('1').writeln;
} | D |
import core.stdc.stdio;
import std.algorithm;
import std.stdio;
int lowerBound(int[] data,int t){
int l=0;
int r=cast(int)data.length+1;
while(r-l>1){
int m=(l+r)/2;
if(data[m-1]<t)
l=m;
else
r=m;
}
return l;
}
void main(){
int n,m;
scanf("%d%d",&n,&m);
int[] u = new int[n];
int[] k = new int[n];... | 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 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;
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 = sread();
// writeln(n);
long ans;
foreach (i; 0... | D |
void main() {
problem();
}
void problem() {
const MAX = 1_000_000_000_000_001;
auto N = scan!long - 1;
string solve() {
char[] ans;
foreach(i; 0..1000) {
auto mod = N % 26;
N /= 26;
N -= 1;
ans ~= 'a' + cast(char)mod;
if (N < 0) {
break;
}
}
... | 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;
void main() {
int a, b;
scan(a, b);
writeln(max(a + b, a - b, a * b));
}
void scan(T...)(ref T args) {
import ... | D |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.