code
stringlengths 4
1.01M
| language
stringclasses 2
values |
|---|---|
import std.algorithm,
std.string,
std.array,
std.range,
std.stdio,
std.conv;
void main() {
int n = readln.chomp.to!int;
int[] a = readln.chomp.split.to!(int[]);
int m1,
m2,
m4;
bool flag;
foreach (ai; a) {
if (ai % 4 == 0) {
m4++;
} else if (ai % 2 == 0) {
m2++;
} else {
m1++;
}
}
if (m2) {
flag = (m1 <= m4);
} else {
flag = (m1 <= m4 + 1);
}
writeln(flag ? "Yes" : "No");
}
|
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 C = readln.split.map!(to!int).array;
auto A = readln.split.map!(to!int).array;
int ans = 0;
for (int i = 0, p = 0; i < N && p < M; ++i) {
if (C[i] <= A[p]) {
ans += 1;
p += 1;
}
}
ans.writeln;
}
|
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 route = Tuple!(long, "From", long, "To");
long bignum = 1_000_000_007;
T lread(T = long)()
{
return readln.chomp.to!T();
}
T[] aryread(T = long)()
{
return readln.split.to!(T[])();
}
void scan(TList...)(ref TList Args)
{
auto line = readln.split();
foreach (i, T; TList)
{
T val = line[i].to!(T);
Args[i] = val;
}
}
void main()
{
long a, b, c, d;
auto tmp = lread();
a = tmp / 1000;
tmp %= 1000;
b = tmp / 100;
tmp %= 100;
c = tmp / 10;
tmp %= 10;
d = tmp;
if (a + b + c + d == 7)
{
writeln(a, "+", b, "+", c, "+", d, "=7");
return;
}
if (a + b + c - d == 7)
{
writeln(a, "+", b, "+", c, "-", d, "=7");
return;
}
if (a + b - c + d == 7)
{
writeln(a, "+", b, "-", c, "+", d, "=7");
return;
}
if (a + b - c - d == 7)
{
writeln(a, "+", b, "-", c, "-", d, "=7");
return;
}
if (a - b + c + d == 7)
{
writeln(a, "-", b, "+", c, "+", d, "=7");
return;
}
if (a - b + c - d == 7)
{
writeln(a, "-", b, "+", c, "-", d, "=7");
return;
}
if (a - b - c + d == 7)
{
writeln(a, "-", b, "-", c, "+", d, "=7");
return;
}
if (a - b - c - d == 7)
{
writeln(a, "-", b, "-", c, "-", d, "=7");
return;
}
}
|
D
|
import std.stdio;
import std.string;
import std.range;
import std.conv;
void main()
{
auto ip = readln.split.to!(int[]), a = ip[0], b = ip[1];
writeln(((b-a)*(1+(b-a))/2)-b);
}
|
D
|
void main()
{
dchar c = rdElem!dchar;
writeln((c + 1).to!dchar);
}
T rdElem(T = long)()
{
//import std.stdio : readln;
//import std.string : chomp;
//import std.conv : to;
return readln.chomp.to!T;
}
alias rdStr = rdElem!string;
dchar[] rdDchar()
{
//import std.conv : to;
return rdStr.to!(dchar[]);
}
T[] rdRow(T = long)()
{
//import std.stdio : readln;
//import std.array : split;
//import std.conv : to;
return readln.split.to!(T[]);
}
T[] rdCol(T = long)(long col)
{
//import std.range : iota;
//import std.algorithm : map;
//import std.array : array;
return iota(col).map!(x => rdElem!T).array;
}
T[][] rdMat(T = long)(long col)
{
//import std.range : iota;
//import std.algorithm : map;
//import std.array : array;
return iota(col).map!(x => rdRow!T).array;
}
void wrMat(T = long)(T[][] mat)
{
//import std.stdio : write, writeln;
foreach (row; mat)
{
foreach (j, compo; row)
{
compo.write;
if (j == row.length - 1) writeln;
else " ".write;
}
}
}
import std.stdio;
import std.string;
import std.array;
import std.conv;
import std.algorithm;
import std.range;
import std.math;
import std.numeric;
import std.container;
import std.typecons;
import std.ascii;
import std.uni;
|
D
|
import std.stdio;
import std.string;
import std.conv;
import std.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 main() {
string str = readln.chomp;
auto po = (iota('a', 'z').chain('z'.only)).find!(c => !str.canFind(c)).array;
if (po.empty) {
"None".writeln;
} else {
po.front.writeln;
}
}
// ----------------------------------------------
void times(alias fun)(int n) {
// n.iota.each!(i => fun());
foreach(i; 0..n) fun();
}
auto rep(alias fun, T = typeof(fun()))(int n) {
// return n.iota.map!(i => fun()).array;
T[] res = new T[n];
foreach(ref e; res) e = fun();
return res;
}
// fold was added in D 2.071.0
static if (__VERSION__ < 2071) {
template fold(fun...) if (fun.length >= 1) {
auto fold(R, S...)(R r, S seed) {
static if (S.length < 2) {
return reduce!fun(seed, r);
} else {
return reduce!fun(tuple(seed), r);
}
}
}
}
// cumulativeFold was added in D 2.072.0
static if (__VERSION__ < 2072) {
template cumulativeFold(fun...)
if (fun.length >= 1)
{
import std.meta : staticMap;
private alias binfuns = staticMap!(binaryFun, fun);
auto cumulativeFold(R)(R range)
if (isInputRange!(Unqual!R))
{
return cumulativeFoldImpl(range);
}
auto cumulativeFold(R, S)(R range, S seed)
if (isInputRange!(Unqual!R))
{
static if (fun.length == 1)
return cumulativeFoldImpl(range, seed);
else
return cumulativeFoldImpl(range, seed.expand);
}
private auto cumulativeFoldImpl(R, Args...)(R range, ref Args args)
{
import std.algorithm.internal : algoFormat;
static assert(Args.length == 0 || Args.length == fun.length,
algoFormat("Seed %s does not have the correct amount of fields (should be %s)",
Args.stringof, fun.length));
static if (args.length)
alias State = staticMap!(Unqual, Args);
else
alias State = staticMap!(ReduceSeedType!(ElementType!R), binfuns);
foreach (i, f; binfuns)
{
static assert(!__traits(compiles, f(args[i], e)) || __traits(compiles,
{ args[i] = f(args[i], e); }()),
algoFormat("Incompatible function/seed/element: %s/%s/%s",
fullyQualifiedName!f, Args[i].stringof, E.stringof));
}
static struct Result
{
private:
R source;
State state;
this(R range, ref Args args)
{
source = range;
if (source.empty)
return;
foreach (i, f; binfuns)
{
static if (args.length)
state[i] = f(args[i], source.front);
else
state[i] = source.front;
}
}
public:
@property bool empty()
{
return source.empty;
}
@property auto front()
{
assert(!empty, "Attempting to fetch the front of an empty cumulativeFold.");
static if (fun.length > 1)
{
import std.typecons : tuple;
return tuple(state);
}
else
{
return state[0];
}
}
void popFront()
{
assert(!empty, "Attempting to popFront an empty cumulativeFold.");
source.popFront;
if (source.empty)
return;
foreach (i, f; binfuns)
state[i] = f(state[i], source.front);
}
static if (isForwardRange!R)
{
@property auto save()
{
auto result = this;
result.source = source.save;
return result;
}
}
static if (hasLength!R)
{
@property size_t length()
{
return source.length;
}
}
}
return Result(range, args);
}
}
}
// minElement/maxElement was added in D 2.072.0
static if (__VERSION__ < 2072) {
auto minElement(alias map, Range)(Range r)
if (isInputRange!Range && !isInfinite!Range)
{
alias mapFun = unaryFun!map;
auto element = r.front;
auto minimum = mapFun(element);
r.popFront;
foreach(a; r) {
auto b = mapFun(a);
if (b < minimum) {
element = a;
minimum = b;
}
}
return element;
}
auto maxElement(alias map, Range)(Range r)
if (isInputRange!Range && !isInfinite!Range)
{
alias mapFun = unaryFun!map;
auto element = r.front;
auto maximum = mapFun(element);
r.popFront;
foreach(a; r) {
auto b = mapFun(a);
if (b > maximum) {
element = a;
maximum = b;
}
}
return element;
}
}
|
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 f1, f2;
foreach (e; s) {
if (!f1) {
if (e == 'C') {
f1 = true;
}
} else {
if (e == 'F') {
f2 = true;
}
}
}
if (f1 && f2) writeln("Yes");
else writeln("No");
}
|
D
|
#!/usr/bin/rdmd
import std.stdio;
immutable hW = "Hello World";
void main()
{
foreach(i;0..1000)
{
writeln(hW);
}
}
|
D
|
import std;
// dfmt off
T lread(T = long)(){return readln.chomp.to!T();}
T[] lreads(T = long)(long n){return generate(()=>readln.chomp.to!T()).take(n).array();}
T[] aryread(T = long)(){return readln.split.to!(T[])();}
void scan(TList...)(ref TList Args){auto line = readln.split();
foreach (i, T; TList){T val = line[i].to!(T);Args[i] = val;}}
alias sread = () => readln.chomp();enum MOD = 10 ^^ 9 + 7;
alias PQueue(T, alias less = "a<b") = BinaryHeap!(Array!T, less);
// dfmt on
void main()
{
auto X = BigInt(sread());
auto v = BigInt(100);
foreach (i; 0 .. 1_000_000)
{
if (X <= v)
{
writeln(i);
return;
}
v = (v * 101) / 100;
}
}
|
D
|
import std.stdio;
import std.string;
import std.conv;
void main()
{
auto input = split( readln() );
int sup = to!int(input[1]), inf = to!int(input[0]);
int i = inf;
int cnt = 0;
while (i <= sup) {
int n1 = i % 10;
int n2 = (i % 100 - n1) / 10;
int n3 = (i % 1000 - 10 * n2 - n1) / 100;
int n4 = (i % 10000 - 100 * n3 - 10 * n2 - n1) / 1000;
int n5 = (i - 1000 * n4 - 100 * n3 - 10 * n2 - n1) / 10000;
if (n1 == n5 && n2 == n4) { cnt += 1; }
i+=1;
}
writeln(cnt);
}
|
D
|
import std.stdio, std.conv, std.string;
void main()
{
auto N = readln.chomp;
writeln("ABC", N);
}
|
D
|
void main() {
problem();
}
void problem() {
auto N = scan!int;
auto D = N.iota.map!(x => [scan!int, scan!int]);
string solve() {
int continuasLevel;
foreach(d; D) {
if (d[0] == d[1]) continuasLevel++;
if (d[0] != d[1]) continuasLevel = 0;
if (continuasLevel == 3) {
return "Yes";
}
}
return "No";
}
solve().writeln;
}
// ----------------------------------------------
import std.stdio, std.conv, std.array, std.string, std.algorithm, std.container, std.range, core.stdc.stdlib, std.math, std.typecons, std.numeric;
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); }
string scan(){ static string[] ss; while(!ss.length) ss = readln.chomp.split; string res = ss[0]; ss.popFront; return res; }
T scan(T)(){ return scan.to!T; }
T[] scan(T)(int n){ return n.iota.map!(i => scan!T()).array; }
void deb(T ...)(T t){ debug writeln(t); }
alias Point = Tuple!(long, "x", 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[]);
auto f = false;
foreach (e; a) {
if (e % 2 == 0) {
if (e % 3 && e % 5) {
f = true;
}
}
}
if (f) {
writeln("DENIED");
} else {
writeln("APPROVED");
}
}
|
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() {
long a, b, c, d;
scan(a, b, c, d);
auto ans = (b - a + 1) - (f(b, c, d) - f(a - 1, c, d));
writeln(ans);
}
long f(long x, long c, long d) {
auto ans = x / c + x / d - x / lcm(c, d);
return ans;
}
long lcm(long c, long d) {
return c / gcd(c, d) * d;
}
void scan(T...)(ref T args) {
import std.stdio : readln;
import std.algorithm : splitter;
import std.conv : to;
import std.range.primitives;
auto line = readln().splitter();
foreach (ref arg; args) {
arg = line.front.to!(typeof(arg));
line.popFront();
}
assert(line.empty);
}
void fillAll(R, T)(ref R arr, T value) {
static if (is(typeof(arr[] = value))) {
arr[] = value;
}
else {
foreach (ref e; arr) {
fillAll(e, value);
}
}
}
bool chmin(T, U...)(ref T x, U args) {
bool isChanged;
foreach (arg; args) {
if (x > arg) {
x = arg;
isChanged = true;
}
}
return isChanged;
}
bool chmax(T, U...)(ref T x, U args) {
bool isChanged;
foreach (arg; args) {
if (x < arg) {
x = arg;
isChanged = true;
}
}
return isChanged;
}
|
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 = Tuple!(long, "y", long, "x");
T lread(T = long)()
{
return readln.chomp.to!T();
}
T[] aryread(T = long)()
{
return readln.split.to!(T[])();
}
void scan(TList...)(ref TList Args)
{
auto line = readln.split();
foreach (i, T; TList)
{
T val = line[i].to!(T);
Args[i] = val;
}
}
enum MOD = (10 ^^ 9) + 7;
void main()
{
long N = lread();
long sum;
long mins = long.max;
foreach (_; 0 .. N)
{
long s = lread();
if (s % 10 != 0)
mins = mins.min(s);
sum += s;
}
if (sum % 10 != 0)
{
writeln(sum);
return;
}
if (mins != long.max)
{
writeln(sum - mins);
return;
}
writeln(0);
}
|
D
|
import std.stdio,std.string,std.conv,std.array,std.algorithm;
void main(){
for(;;write("\n")){
auto a = readln().chomp().split();
if( a[0]=="0" && a[1]=="0" ){ break; }
foreach(y;0..to!int(a[0])){
foreach(x;0..to!int(a[1])){ write("#"); }
write("\n");
}
}
}
|
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, K;
scan(N, K);
auto ans = K;
foreach (i ; 0 .. N - 1) {
ans *= K - 1;
}
writeln(ans);
}
void scan(T...)(ref T args) {
auto line = readln.split;
foreach (ref arg; args) {
arg = line.front.to!(typeof(arg));
line.popFront;
}
assert(line.empty);
}
void fillAll(R, T)(ref R arr, T value) {
static if (is(typeof(arr[] = value))) {
arr[] = value;
}
else {
foreach (ref e; arr) {
fillAll(e, value);
}
}
}
bool chmin(T, U...)(ref T x, U args) {
bool isChanged;
foreach (arg; args) if (x > arg) {
x = arg;
isChanged = true;
}
return isChanged;
}
bool chmax(T, U...)(ref T x, U args) {
bool isChanged;
foreach (arg; args) if (x < arg) {
x = arg;
isChanged = true;
}
return isChanged;
}
void yes(bool ok, string y = "Yes", string n = "No") {
return writeln(ok ? y : 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;
import std.ascii;
void main()
{
writeln(700 + readln.chomp.to!(char[]).count!(x=>x=='o') * 100);
}
|
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", long, "x");
T lread(T = long)()
{
return readln.chomp.to!T();
}
T[] aryread(T = long)()
{
return readln.split.to!(T[])();
}
void scan(TList...)(ref TList Args)
{
auto line = readln.split();
foreach (i, T; TList)
{
T val = line[i].to!(T);
Args[i] = val;
}
}
void minAssign(T, U = T)(ref T dst, U src)
{
dst = cast(T) min(dst, src);
}
void maxAssign(T, U = T)(ref T dst, U src)
{
dst = cast(T) max(dst, src);
}
enum MOD = (10 ^^ 9) + 7;
void main()
{
long[64] t;
string s = sread();
foreach (c; s)
{
t[c - 'a']++;
}
writeln(t.reduce!((a, b) => (a & 1) | (b & 1)) == 0 ? "Yes" : "No");
}
|
D
|
// Vicfred
// https://atcoder.jp/contests/abc159/tasks/abc159_a
// math
import std.algorithm;
import std.array;
import std.conv;
import std.stdio;
import std.string;
long gauss(long n) {
return n*(n-1)/2;
}
void main() {
long n = readln.chomp.to!long;
long[] a = readln.split.map!(to!long).array;
long[long] balls;
foreach(ball; a) {
if(ball in balls)
balls[ball] += 1;
else
balls[ball] = 1;
}
long ways = 0;
foreach(i; balls.keys)
ways += gauss(balls[i]);
for(int k = 0; k < n; k++) {
long ans = ways-balls[a[k]]+1;
ans.writeln;
}
}
|
D
|
import std.stdio;
import std.algorithm;
import std.array;
import std.conv;
import std.string;
void main() {
int n = readln.chomp.to!int, ans;
bool[int] mp;
foreach(i; 0..n) {
int d = readln.chomp.to!int;
// keyが連想配列に登録されているかどうか
if ((d in mp) == null) {
ans++;
mp[d] = true;
}
}
ans.writeln;
}
|
D
|
import std.stdio,std.conv,std.string;
void main(){
auto args = readln().chomp().split();
writeln( to!int(args[0]) * to!int(args[1])," ",(to!int(args[0]) + to!int(args[1])) * 2 );
}
|
D
|
import std.stdio;
import std.string;
import std.range;
import std.conv;
void main()
{
auto ip = readln.split.to!(int[]), a = ip[0], b = ip[1], c = ip[2];
if(b-a==c-b){
writeln("YES");
}else{
writeln("NO");
}
}
|
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()
{
string s; readV(s);
auto n = s.length.to!int, k = (n+1)/2+1;
for (; k <= n; ++k)
if (s[k-1] != s[n-k] || s[k-1] != s[k-2]) break;
writeln(k-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;
// dfmt off
T lread(T = long)(){return readln.chomp.to!T();}
T[] lreads(T = long)(long n){return generate(()=>readln.chomp.to!T()).take(n).array();}
T[] aryread(T = long)(){return readln.split.to!(T[])();}
void scan(TList...)(ref TList Args){auto line = readln.split();
foreach (i, T; TList){T val = line[i].to!(T);Args[i] = val;}}
alias sread = () => readln.chomp();enum MOD = 10 ^^ 9 + 7;
alias PQueue(T, alias less = "a<b") = BinaryHeap!(Array!T, less);
// dfmt on
void main()
{
long K, A, B;
scan(K, A, B);
long a = K + 1;
long b = (max(0, K - (A - 1)) / 2) * max(B - A, 0) + A + (max(0, K - (A - 1)) % 2);
writeln(max(a, b));
}
|
D
|
import std.stdio;
import std.algorithm;
import std.string;
import std.conv;
import std.math;
void main(){
while(true){
auto s = readln();
if(stdin.eof()) break;
s = chomp(s);
if(s=="")break;
string s1,s2;
s1 = s;
s2 = s;
while(s1.length > 1){
s2 = "";
for(int i=0;i<s1.length-1;i++){
s2 ~= to!char( '0' + (to!int(s1[i]-'0') + to!int(s1[i+1]-'0'))%10);
}
swap(s1,s2);
}
writeln(s1);
}
}
|
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);
auto t = "";
foreach (si; s) {
if (si == 'B') {
if (!t.empty) t = t[0..$-1];
} else {
t ~= si;
}
}
writeln(t);
}
|
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;
enum MAX = 1_000_100;
ulong MOD = 1_000_000_007;
ulong INF = 1_000_000_000_000;
alias sread = () => readln.chomp();
alias Pair = Tuple!(long, "a", long, "b");
alias PQueue(T, alias less = "a<b") = BinaryHeap!(Array!T, less);
void main()
{
auto n = lread();
string s, t;
scan(s, t);
foreach(i; iota(n))
write(s[i], t[i]);
writeln();
}
T lread(T = long)()
{
return readln.chomp.to!T();
}
T[] aryread(T = long)()
{
return readln.split.to!(T[])();
}
void scan(TList...)(ref TList Args)
{
auto line = readln.split();
foreach (i, T; TList)
{
T val = line[i].to!(T);
Args[i] = val;
}
}
|
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 = 998244353;
void main() {
auto S = readln.chomp;
auto N = S.length.to!int;
long ans = 1;
auto dp = new long[][](2, 2*N+1); // これまで何個赤を使っているか？
dp[0][0] = 1;
int red = 0;
int blue = 0;
int cur = 0;
int tar = 1;
foreach (i; 0..2*N) {
dp[tar][] = 0;
int cand = (i + 1) * 2 - i;
if (i < N) {
red += 2 - (S[i] - '0');
blue += S[i] - '0';
}
foreach (used_red; 0..2*N+1) {
if (dp[cur][used_red] == 0) continue;
int used_blue = i - used_red;
int rest_red = red - used_red;
int rest_blue = blue - used_blue;
if (rest_red > 0) {
(dp[tar][used_red+1] += dp[cur][used_red]) %= MOD;
}
if (rest_blue > 0) {
(dp[tar][used_red] += dp[cur][used_red]) %= MOD;
}
}
swap(cur, tar);
}
dp[cur][red].writeln;
}
|
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, k;
scan(n, k);
int ans = n - k + 1;
writeln(ans);
}
int[][] readGraph(int n, int m, bool isUndirected = true, bool is1indexed = true) {
auto adj = new int[][](n, 0);
foreach (i; 0 .. m) {
int u, v;
scan(u, v);
if (is1indexed) {
u--, v--;
}
adj[u] ~= v;
if (isUndirected) {
adj[v] ~= u;
}
}
return adj;
}
alias Edge = Tuple!(int, "to", int, "cost");
Edge[][] readWeightedGraph(int n, int m, bool isUndirected = true, bool is1indexed = true) {
auto adj = new Edge[][](n, 0);
foreach (i; 0 .. m) {
int u, v, c;
scan(u, v, c);
if (is1indexed) {
u--, v--;
}
adj[u] ~= Edge(v, c);
if (isUndirected) {
adj[v] ~= Edge(u, c);
}
}
return adj;
}
void yes(bool b) {
writeln(b ? "Yes" : "No");
}
void YES(bool b) {
writeln(b ? "YES" : "NO");
}
T[] readArr(T)() {
return readln.split.to!(T[]);
}
T[] readArrByLines(T)(int n) {
return iota(n).map!(i => readln.chomp.to!T).array;
}
void scan(T...)(ref T args) {
import std.stdio : readln;
import std.algorithm : splitter;
import std.conv : to;
import std.range.primitives;
auto line = readln().splitter();
foreach (ref arg; args) {
arg = line.front.to!(typeof(arg));
line.popFront();
}
assert(line.empty);
}
void fillAll(R, T)(ref R arr, T value) {
static if (is(typeof(arr[] = value))) {
arr[] = value;
}
else {
foreach (ref e; arr) {
fillAll(e, value);
}
}
}
bool chmin(T, U...)(ref T x, U args) {
bool isChanged;
foreach (arg; args) {
if (x > arg) {
x = arg;
isChanged = true;
}
}
return isChanged;
}
bool chmax(T, U...)(ref T x, U args) {
bool isChanged;
foreach (arg; args) {
if (x < arg) {
x = arg;
isChanged = true;
}
}
return isChanged;
}
|
D
|
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
auto rd = readln.split.to!(long[]), a = rd[0], b = rd[1], x = rd[2];
if (a > 0)
writeln(b/x - (a-1)/x);
else
writeln(b/x + 1);
}
|
D
|
import std.stdio;
import std.algorithm;
import std.array;
import std.conv;
import std.string;
import std.math;
void main() {
int N;
N = readln.chomp.to!int;
auto s = [0, 0, 0];
bool is_reach = true;
for (int i = 0; i < N; ++i) {
auto g = readln.chomp.split.map!(to!int).array;
int t = g[0] - s[0], dist = abs(g[1] - s[1]) + abs(g[2] - s[2]);
if (!(t >= dist && (t - dist) % 2 == 0)) {
is_reach = false;
}
s = g;
}
if (is_reach) {
writeln("Yes");
}
else {
writeln("No");
}
return;
}
|
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_rd[0]; s_rd.popFront; return res.to!T; }
string RDR()() { return readln.chomp; }
T[] ARR(T = long)(in string str, T fix = 0) { auto r = str.split.to!(T[]); r[] += fix; return r; }
size_t[] MAKE_IDX(alias less = "a < b", Range)(Range range) { auto idx = new size_t[](range.length); makeIndex!(less)(range, idx); return idx;}
size_t MIN_POS(alias less = "a < b", Range)(Range range) { auto r = minPos!(less)(range); return range.length - r.length; }
bool inside(T)(T x, T b, T e) { return x >= b && x < e; }
long lcm(long x, long y) { return x * y / gcd(x, y); }
long mod = 10^^9 + 7;
//long mod = 998244353;
//long mod = 1_000_003;
void moda(ref long x, long y) { x = (x + y) % mod; }
void mods(ref long x, long y) { x = ((x + mod) - (y % mod)) % mod; }
void modm(ref long x, long y) { x = (x * y) % mod; }
void main()
{
auto X = RD;
auto t = RD;
writeln(max(X - t, 0));
stdout.flush();
debug readln();
}
|
D
|
import std.stdio, std.algorithm, std.conv, std.array, std.string;
void main()
{
writeln("A" ~ readln.split[1][0] ~ "C");
}
|
D
|
import std.stdio, std.conv, std.string, std.algorithm.comparison, std.algorithm.searching, std.algorithm.sorting;
void main()
{
int[] input = readln().split.to!(int[]);
int X = input[0];
int Y = input[1];
writeln(X + Y / 2);
}
|
D
|
import std.stdio, std.string, std.algorithm;
void main() {
string s = readln.chomp;
s ~= s;
string p = readln.chomp;
writeln(s.canFind(p) ? "Yes" : "No");
}
|
D
|
import std.stdio, std.string, std.conv;
void main()
{
auto x = readln.split.to!(int[]), n = x[0], a = x[1], b = x[2];
if(a*n < b){
writeln(a*n);
} else {
writeln(b);
}
}
|
D
|
import std.stdio;
import std.algorithm;
import std.array;
import std.conv;
import std.string;
void main() {
int n, a, b;
auto l = readln.chomp.split.map!(to!int);
n = l[0], a = l[1], b = l[2];
long ans; // longである必要はない
foreach(i; 1..(n + 1)) {
int sum, num = i;
while (num > 0) {
sum += (num % 10);
num /= 10;
}
if (a <= sum && sum <= b) {
ans += i;
}
}
ans.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, std.bitmanip;
void main() {
auto S = readln.chomp;
auto N = S.length.to!int;
if (S.map!(s => s == S[0]).all) {
writeln(N);
return;
}
int ans = 1000000;
foreach (i; 0..N-1) if (S[i] != S[i+1]) ans = min(ans, max(i+1,N-i-1));
ans.writeln;
}
|
D
|
import std.stdio, std.conv, std.string, std.math;
void main(){
auto ip = readln.split.to!(int[]);
if(ip[0] == ip[1]){
"Draw".writeln;
} else if(ip[0] == 1){
"Alice".writeln;
} else if(ip[1] == 1){
"Bob".writeln;
} else if (ip[0] > ip[1]){
"Alice".writeln;
} else {
"Bob".writeln;
}
}
|
D
|
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.array;
import std.range;
void main(){
auto Q=readln.split.to!(int[]),A=Q[0],B=Q[1];
if(A+B>=24)writeln((A+B)-24);
else writeln(A+B);
}
|
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 readS(T)(size_t n,ref T t){t=new T(n);foreach(ref v;t){auto r=rdsp;foreach(ref j;v.tupleof)pick(r,j);}}
const mod = 10^^9+7;
alias mint = FactorRing!mod;
void main()
{
int n, m; readV(n, m);
struct C { int l, r, x; }
C[] c; readS(m, c);
C[][int] ch;
foreach (ci; c) ch[ci.r] ~= ci;
auto dp = new int[][][](n+1, n+1, n+1);
dp[0][0][0] = 1;
foreach (r; 0..n+1)
foreach (g; 0..n+1)
foreach (b; 0..n+1) {
auto k = max(r, g, b);
if (k in ch) {
foreach (ci; ch[k]) {
if (r == k) {
if ((b >= ci.l) + (g >= ci.l) + 1 != ci.x)
dp[r][g][b] = 0;
} else if (g == k) {
if ((r >= ci.l) + (b >= ci.l) + 1 != ci.x)
dp[r][g][b] = 0;
} else {
if ((r >= ci.l) + (g >= ci.l) + 1 != ci.x)
dp[r][g][b] = 0;
}
}
}
if (k < n) {
(dp[k+1][g][b] += dp[r][g][b]) %= mod;
(dp[r][k+1][b] += dp[r][g][b]) %= mod;
(dp[r][g][k+1] += dp[r][g][b]) %= mod;
}
}
auto ans = 0;
foreach (c1; 0..n)
foreach (c2; 0..n) {
(ans += dp[n][c1][c2]) %= mod;
(ans += dp[c1][n][c2]) %= mod;
(ans += dp[c1][c2][n]) %= mod;
}
writeln(ans);
}
struct FactorRing(int m, bool pos = false)
{
version(BigEndian) union { long vl; struct { int vi2; int vi; } } else union { long vl; int vi; }
alias FR = FactorRing!(m, pos);
@property static init() { return FR(0); }
@property int value() { return vi; }
@property void value(int v) { vi = mod(v); }
alias value this;
this(int v) { vi = v; }
this(int v, bool runMod) { vi = runMod ? mod(v) : v; }
this(long v) { vi = mod(v); }
ref auto opAssign(int v) { vi = v; return this; }
pure auto mod(int v) const { static if (pos) return v%m; else return (v%m+m)%m; }
pure auto mod(long v) const { static if (pos) return cast(int)(v%m); else return cast(int)((v%m+m)%m); }
static if (!pos) pure ref auto opUnary(string op: "-")() { return FR(mod(-vi)); }
static if (m < int.max / 2) {
pure ref auto opBinary(string op)(int r) if (op == "+" || op == "-") { return FR(mod(mixin("vi"~op~"r"))); }
ref auto opOpAssign(string op)(int r) if (op == "+" || op == "-") { vi = mod(mixin("vi"~op~"r")); return this; }
} else {
pure ref auto opBinary(string op)(int r) if (op == "+" || op == "-") { return FR(mod(mixin("vl"~op~"r"))); }
ref auto opOpAssign(string op)(int r) if (op == "+" || op == "-") { vi = mod(mixin("vl"~op~"r")); return this; }
}
pure ref auto opBinary(string op: "*")(int r) { return FR(mod(vl*r)); }
ref auto opOpAssign(string op: "*")(int r) { vi = mod(vl*r); return this; }
pure ref auto opBinary(string op)(ref FR r) if (op == "+" || op == "-" || op == "*") { return opBinary!op(r.vi); }
ref auto opOpAssign(string op)(ref FR r) if (op == "+" || op == "-" || op == "*") { return opOpAssign!op(r.vi); }
}
|
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;
long digit_sum(long b, long n) {
if (n < b)
return n;
else
return digit_sum(b, n/b) + n % b;
}
void main() {
auto N = readln.chomp.to!long;
auto S = readln.chomp.to!long;
if (N == S) {
writeln(N+1);
return;
}
for (long b = 2; b * b <= N; b++) {
if (digit_sum(b, N) == S) {
writeln(b);
return;
}
}
long ans = long.max;
for (long p = 1; p * p <= N; p++) {
if ((p-S+N) % p != 0)
continue;
long b = (p-S+N) / p;
if (b > 1 && digit_sum(b, N) == S)
ans = min(ans, b);
}
writeln(ans == long.max ? -1 : ans);
}
|
D
|
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons;
void main()
{
auto N = readln.chomp.to!(wchar[]);
writeln(N[1] != N[2] ? "No" : N[0] == N[1] || N[2] == N[3] ? "Yes" : "No");
}
|
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 x, y;
scan(x, y);
long[] tmp;
tmp ~= x;
while (x * 2 <= y)
{
x *= 2;
tmp ~= x;
}
// writeln(tmp);
writeln(tmp.length);
}
void scan(L...)(ref L A)
{
auto l = readln.split;
foreach (i, T; L)
{
A[i] = l[i].to!T;
}
}
void arywrite(T)(T a)
{
a.map!text.join(' ').writeln;
}
|
D
|
void main() {
import std.stdio, std.string, std.conv, std.algorithm;
int y, b, r;
rd(y, b, r);
int mx = 0;
for (int i = 1; i <= y; i++) {
for (int j = 1; j <= b; j++) {
for (int k = 1; k <= r; k++) {
if (i + 1 == j && j + 1 == k) {
mx = max(mx, i + j + k);
}
}
}
}
writeln(mx);
}
void rd(T...)(ref T x) {
import std.stdio : readln;
import std.string : split;
import std.conv : to;
auto l = readln.split;
assert(l.length == x.length);
foreach (i, ref e; x)
e = l[i].to!(typeof(e));
}
|
D
|
import std.stdio;
import std.conv;
import std.string;
void main() {
auto n = readln.chomp.to!(int);
((n / 111 + (n % 111 != 0)) * 111).writeln;
}
|
D
|
import std.stdio,std.conv,std.algorithm,std.array;
int[] raia() { return readln().split().map!(to!int).array; } //read stdin as int[]
void main(){
auto it = raia();
int count;
for(auto i=it[0];i<=it[1];i++)
if(it[2]%i == 0) count++;
writeln(count);
}
|
D
|
// unihernandez22
// https://atcoder.jp/contests/abc157/tasks/abc157_b
// implementation
import std.stdio: writeln, writefln, readln;
import std.array: array, split;
import std.algorithm: map;
import std.string: chomp;
import std.conv: to;
void main() {
int[3][3] bingo;
foreach(byte i; 0..3) {
int[3] input = readln.split.map!(to!int).array;
bingo[i] = input;
}
int n = readln.chomp.to!int;
bool[int] won;
foreach(_; 0..n) {
int x = readln.chomp.to!int;
won[x] = true;
}
// Check rows
foreach(int[3] i; bingo) {
if (won.get(i[0], false) && won.get(i[1], false) && won.get(i[2], false)) {
writeln("Yes");
return;
}
}
// Check columns
foreach(byte i; 0..3) {
if (won.get(bingo[0][i], false) && won.get(bingo[1][i], false) && won.get(bingo[2][i], false)) {
writeln("Yes");
return;
}
}
// Check a diagonal
bool diagonal_a = true;
foreach(byte i; 0..3)
diagonal_a = diagonal_a && won.get(bingo[i][i], false);
// The other diagonal
bool diagonal_b = true;
foreach(byte i; 0..3)
diagonal_b = diagonal_b && won.get(bingo[i][2-i], false);
if (diagonal_a || diagonal_b)
writeln("Yes");
else
writeln("No");
}
|
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); }
void print(){ writeln(""); } void print(T)(T t){ writeln(t); } void print(T, A ...)(T t, A a){ write(t, " "), print(a); }
string unsplit(T)(T xs){ return xs.array.to!(string[]).join(" "); }
string scan(){ static string[] ss; while(!ss.length) ss = readln.chomp.split; string res = ss[0]; ss.popFront; return res; }
T scan(T)(){ return scan.to!T; } T[] scan(T)(int n){ return n.iota.map!(i => scan!T()).array; }
T lowerTo(T)(ref T x, T y){ if(x > y) x = y; return x; } T raiseTo(T)(ref T x, T y){ if(x < y) x = y; return x; }
// ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- //
void solve(){
string s = scan;
if(s[2] == s[3] && s[4] == s[5]) "Yes".print;
else "No".print;
}
|
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;
long X;
int cnt = 0;
void ans(long x) {
debug {
writeln((x == X) ? "OK ": "NG");
writeln(cnt);
return;
}
writeln("! ", x);
stdout.flush;
}
bool ask(long x, long y) {
debug {
cnt += 1;
return x % X >= y % X;
}
writeln("? ", x, " ", y);
stdout.flush;
return readln.chomp == "x";
}
void solve() {
if (ask(1, 2)) {
if (ask(2, 1)) {
ans(1);
} else {
ans(2);
}
return;
}
long mn = 2;
long mx = 4;
while (true) {
if (ask(mn, mx)) {
break;
} else {
mx *= 2;
mn *= 2;
}
}
while (mx - mn > 1) {
long next_mn = (mx + mn) / 2;
if (ask(next_mn, mx)) {
mn = next_mn;
} else {
mx = next_mn;
}
}
ans (mx);
}
void main() {
debug {
X = readln.chomp.to!int;
solve;
return;
}
while (true) {
auto s = readln.chomp;
if (s == "start") solve;
else break;
}
}
|
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;
import std.random;
final class InputReader {
private:
ubyte[] p, buffer;
bool eof;
bool rawRead () {
if (eof) {
return false;
}
p = stdin.rawRead (buffer);
if (p.empty) {
eof = true;
return false;
}
return true;
}
ubyte nextByte(bool check) () {
static if (check) {
if (p.empty) {
if (!rawRead ()) {
return 0;
}
}
}
auto r = p.front;
p.popFront ();
return r;
}
public:
this () {
buffer = uninitializedArray!(ubyte[])(16<<20);
}
bool seekByte (in ubyte lo) {
while (true) {
p = p.find! (c => c >= lo);
if (!p.empty) {
return false;
}
if (!rawRead ()) {
return true;
}
}
}
template next(T) if (isSigned!T) {
T next () {
if (seekByte (45)) {
return 0;
}
T res;
ubyte b = nextByte!false ();
if (b == 45) {
while (true) {
b = nextByte!true ();
if (b < 48 || b >= 58) {
return res;
}
res = res * 10 - (b - 48);
}
} else {
res = b - 48;
while (true) {
b = nextByte!true ();
if (b < 48 || b >= 58) {
return res;
}
res = res * 10 + (b - 48);
}
}
}
}
template next(T) if (isUnsigned!T) {
T next () {
if (seekByte (48)) {
return 0;
}
T res = nextByte!false () - 48;
while (true) {
ubyte b = nextByte!true ();
if (b < 48 || b >= 58) {
break;
}
res = res * 10 + (b - 48);
}
return res;
}
}
T[] nextA(T) (in int n) {
auto a = uninitializedArray!(T[]) (n);
foreach (i; 0 .. n) {
a[i] = next!T;
}
return a;
}
}
void main() {
auto r = new InputReader ();
const n = r.next!uint ();
const m = r.next!uint ();
const p = r.next!uint ();
auto a = r.nextA!uint (n);
auto b = r.nextA!uint (m);
int i, j;
for (i = n - 1; i >= 0 && !(a[i] % p); --i) {}
for (j = m - 1; j >= 0 && !(b[j] % p); --j) {}
writeln (i + j);
}
|
D
|
import std.stdio, std.string, std.conv, std.algorithm, std.array;
void main() {
string S, T;
S = readln().chomp();
T = readln().chomp();
string res = S.replace("?","z");
const string ng = "UNRESTORABLE";
bool flg = false;
foreach(int i; 0..(to!(int)(S.length)-to!(int)(T.length)+1)) {
bool f = true;
foreach(int j; 0..to!(int)(T.length)) {
if(S[i+j]!=T[j] && S[i+j]!='?') {
f = false;
break;
}
}
if(f) {
flg = true;
res = min(res, (S[0..i] ~ T ~ S[(i+to!(int)(T.length))..to!int(S.length)]).replace("?","a"));
}
}
if(flg) writeln(res);
else writeln(ng);
}
|
D
|
import std.stdio, std.string, std.conv;
void main()
{
auto r = readln.split.to!(int[]), R = r[0];
auto g = readln.split.to!(int[]), G = g[0];
writeln(2*G-R);
}
|
D
|
import std.stdio;
import std.string;
import std.conv;
void main(){
while(true){
auto s = readln();
if(stdin.eof()) break;
real w = to!real(chomp(s));
if(w <= 48.0) writeln("light fly");
else if(w <= 51.0) writeln("fly");
else if(w <= 54.0) writeln("bantam");
else if(w <= 57.0) writeln("feather");
else if(w <= 60.0) writeln("light");
else if(w <= 64.0) writeln("light welter");
else if(w <= 69.0) writeln("welter");
else if(w <= 75.0) writeln("light middle");
else if(w <= 81.0) writeln("middle");
else if(w <= 91.0) writeln("light heavy");
else writeln("heavy");
}
}
|
D
|
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
void main() {
int N = to!int(chomp(readln()));
int K = to!int(chomp(readln()));
int X = to!int(chomp(readln()));
int Y = to!int(chomp(readln()));
int fee;
if(N < K) {
fee = N*X;
fee.writeln;
return;
}
fee += K*X;
if(!N-K < 1) fee += (N-K)*Y;
fee.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;
immutable int MAX = 10^^3+1;
immutable long MOD = 10^^9+7;
auto modinv = new long[](MAX);
auto f_mod = new long[](MAX);
auto f_modinv = new long[](MAX);
long[][] mem;
int N, A, B, C, D;
long powmod(long a, long x, long m) {
long ret = 1;
while (x >= 1) {
if (x % 2 == 1)
ret = ret * a % m;
a = a * a % m;
x /= 2;
}
return ret;
}
long nck(int n, int k) {
if (n < k) return 0;
return f_mod[n] * f_modinv[n-k] % MOD * f_modinv[k] % MOD;
}
long dp(int g, int n) {
if (n == 0) return 1;
if (n < g) return 0;
if (g > B) return 0;
if (mem[g][n] >= 0) return mem[g][n];
mem[g][n] = dp(g+1, n);
foreach (i; C..D+1) {
if (g * i > n) break;
auto cnt =
nck(n, g*i) * f_mod[g*i] % MOD
* powmod(f_modinv[g], i, MOD) % MOD;
cnt = cnt * f_modinv[i] % MOD;
mem[g][n] = (mem[g][n] + dp(g+1, n-g*i)*cnt%MOD) % MOD;
}
return mem[g][n];
}
void main() {
modinv[0] = modinv[1] = 1;
foreach(i; 2..MAX) {
modinv[i] = modinv[MOD % i] * (MOD - MOD / i) % MOD;
}
f_mod[0] = f_mod[1] = 1;
f_modinv[0] = f_modinv[1] = 1;
foreach(i; 2..MAX) {
f_mod[i] = (i * f_mod[i-1]) % MOD;
f_modinv[i] = (modinv[i] * f_modinv[i-1]) % MOD;
}
scanf("%d %d %d %d %d", &N, &A, &B, &C, &D);
mem = new long[][](B+1, N+1);
foreach (i; 0..B+1) fill(mem[i], -1);
dp(A, N).writeln;
}
|
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();
long cnt;
foreach (i; 1 .. n + 1)
{
string s;
s = i.to!string();
if (s.length % 2 != 0)
{
cnt += 1;
}
}
writeln(cnt);
}
void scan(L...)(ref L A)
{
auto l = readln.split;
foreach (i, T; L)
{
A[i] = l[i].to!T;
}
}
|
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!double;
int cnt;
while (n > 1) {
n /= 3;
cnt++;
}
cnt.writeln;
}
|
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, std.datetime;
// dfmt off
T lread(T = long)(){return readln.chomp.to!T();}
T[] lreads(T = long)(long n){return generate(()=>readln.chomp.to!T()).take(n).array();}
T[] aryread(T = long)(){return readln.split.to!(T[])();}
void scan(TList...)(ref TList Args){auto line = readln.split();
foreach (i, T; TList){T val = line[i].to!(T);Args[i] = val;}}
alias sread = () => readln.chomp();enum MOD = 10 ^^ 9 + 7;
alias PQueue(T, alias less = "a<b") = BinaryHeap!(Array!T, less);
// dfmt on
void main()
{
long H, W, N;
scan(H, W, N);
long SR, SC;
scan(SR, SC);
auto S = sread();
auto T = sread();
long l = SC;
long r = W - SC + 1;
long u = SR;
long d = H - SR + 1;
foreach (i; 0 .. N)
{
switch (S[i])
{
case 'L':
l--;
break;
case 'R':
r--;
break;
case 'U':
u--;
break;
case 'D':
d--;
break;
default:
assert(0);
}
// writefln("%s %s %s %s", l, r, u, d);
if (l <= 0 || r <= 0 || u <= 0 || d <= 0)
{
writeln("NO");
return;
}
switch (T[i])
{
case 'L':
if (r < W)
r++;
break;
case 'R':
if (l < W)
l++;
break;
case 'U':
if (d < H)
d++;
break;
case 'D':
if (u < H)
u++;
break;
default:
assert(0);
}
}
writeln("YES");
}
|
D
|
import std.stdio;
import std.conv;
import std.string;
void main()
{
int[] input = readln.split.to!(int[]);
int a = input[0];
int b = input[1];
if (a + b == 15){
writeln("+");
} else if (a * b == 15){
writeln("*");
} else {
writeln("x");
}
}
|
D
|
import std.stdio;
import std.string;
string toSwapCase(string s) {
if (s == s.toLower) {
return s.toUpper;
}
if (s == s.toUpper) {
return s.toLower;
}
return s;
}
void main() {
auto str = readln;
foreach (ch; str) {
write(toSwapCase(ch ~ ""));
}
}
|
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; }
long calc(int n) {
if (n == 1) return 1;
long a = 2;
long b = 1;
for (int i = 2; i <= n; i++) {
long c = a + b;
a = b;
b = c;
}
return b;
}
void main() {
int n = readint;
writeln(calc(n));
}
|
D
|
import std.stdio;
import std.algorithm;
int main() {
int t;
scanf("%d", &t);
while (t --> 0) {
int n;
scanf("%d", &n);
int[] a = new int[n];
int[] cnt = new int [42];
long result = 0;
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
int bit_id = 0;
while (a[i] > 0) {
++bit_id;
a[i] /= 2;
}
result += cnt[bit_id];
++cnt[bit_id];
}
printf("%lld\n", result);
}
return 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(DEBUG) write(t, " "), log(a); } bool DEBUG = 0;
string read(){ static string[] ss; while(!ss.length) ss = readln.chomp.split; string res = ss[0]; ss.popFront; return res; }
// ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- //
void solve(){
int n = read.to!int;
Node[] nodes;
foreach(i; 0 .. n) nodes ~= new Node(i);
foreach(i; 0 .. n - 1){
int u = read.to!int - 1;
int v = read.to!int - 1;
nodes[u].nodes ~= nodes[v];
nodes[v].nodes ~= nodes[u];
}
int f = 0;
foreach(nd; nodes){
if(nd.nodes.length == 2) f = 1;
}
if(f == 1) "NO".writeln;
else "YES".writeln;
}
/*
A1: YES if and only if there are no vertex with degree 2.
*/
class Node{
int id;
Node[] nodes;
this(int id){
this.id = id;
}
}
|
D
|
module main;
import core.stdc.stdio;
char[9][6] a;
char[9][6] ud;
void print() {
for (int i = 0; i < 6; i++) {
printf("%s\n", &a[i]);
}
}
int main(string[] argv) {
ud[0] = "334433";
ud[1] = "334433";
ud[2] = "223322";
ud[3] = "223322";
ud[4] = "112211";
ud[5] = "112211";
//for (int i = 0; i < 6; i++) {
// printf("%s\n", &ud[i]);
//}
for (int i = 0; i < 6; i++) {
scanf("%s", &a[i]);
a[i][8] = '\0';
}
for (char i = '4'; i > '0'; i--) {
for (int x = 0; x < 6; x++) {
for (int b = 0; b < 9; b++) {
int b2 = b - (b>1) - (b>4);
if (a[x][b] == '.' && ud[x][b2] == i) {
a[x][b] = 'P';
print();
return 0;
}
}
}
}
return 0;
}
|
D
|
import std.stdio :write, writeln;
import std.array;
import std.range;
import std.typecons;
import std.algorithm : max, min;
string[] list = [
"",
"Washington",
"Adams",
"Jefferson",
"Madison",
"Monroe",
"Adams",
"Jackson",
"Van Buren",
"Harrison",
"Tyler",
"Polk",
"Taylor",
"Fillmore",
"Pierce",
"Buchanan",
"Lincoln",
"Johnson",
"Grant",
"Hayes",
"Garfield",
"Arthur",
"Cleveland",
"Harrison",
"Cleveland",
"McKinley",
"Roosevelt",
"Taft",
"Wilson",
"Harding",
"Coolidge",
"Hoover",
"Roosevelt",
"Truman",
"Eisenhower",
"Kennedy",
"Johnson",
"Nixon",
"Ford",
"Carter",
"Reagan"
];
void main(){
list[ next!int ].writeln;
}
import std.stdio : readln;
import std.conv : to;
import std.string : split, chomp;
import std.traits;
string[] input;
string delim = " ";
T next(T)()
in
{
assert(hasNext());
}
out
{
input.popFront;
}
body
{
return input.front.to!T;
}
bool hasNext(){
if(input.length > 0){
return true;
}
string str = readln;
if(str.length > 0){
input ~= str.chomp.split(delim);
return true;
}else{
return false;
}
}
void dbg(T...)(T vs)
{
import std.stdio : stderr;
foreach(v; vs)
stderr.write(v.to!string ~ " ");
stderr.write("\n");
}
T clone(T)(T v){
T v_;
static if(isInputRange!(T)){
foreach(ite; v){
v_ ~= ite.clone;
}
}else{
v_ = v;
}
return v_;
}
|
D
|
// tested by Hightail - https://github.com/dj3500/hightail
import std.stdio, std.string, std.conv, std.algorithm;
import std.range, std.array, std.math, std.typecons, std.container, core.bitop;
int n;
long a, b, c, d;
void main() {
scan(n, a, b, c, d);
b = b - a;
a = 0;
n--;
foreach (i ; 0 .. n + 1) {
if (i * c - (n - i) * d <= b && b <= i * d - (n - i) * c) {
writeln("YES");
return;
}
}
writeln("NO");
}
void scan(T...)(ref T args) {
string[] line = readln.split;
foreach (ref arg; args) {
arg = line.front.to!(typeof(arg));
line.popFront();
}
assert(line.empty);
}
void fillAll(R, T)(ref R arr, T value) {
static if (is(typeof(arr[] = value))) {
arr[] = value;
}
else {
foreach (ref e; arr) {
fillAll(e, value);
}
}
}
|
D
|
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math;
void main()
{
auto ab = readln.split.join("").to!int;
writeln(ab == ab.to!float.sqrt.to!int^^2 ? "Yes" : "No");
}
|
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_rd[0]; s_rd.popFront; return res.to!T; }
string RDR()() { return readln.chomp; }
T[] ARR(T = long)(in string str, T fix = 0) { auto r = str.split.to!(T[]); r[] += fix; return r; }
size_t[] MAKE_IDX(alias less = "a < b", Range)(Range range) { auto idx = new size_t[](range.length); makeIndex!(less)(range, idx); return idx;}
size_t MIN_POS(alias less = "a < b", Range)(Range range) { auto r = minPos!(less)(range); return range.length - r.length; }
bool inside(T)(T x, T b, T e) { return x >= b && x < e; }
bool minimize(T)(ref T x, T y) { if (x > y) { x = y; return true; } else { return false; } }
bool maximize(T)(ref T x, T y) { if (x < y) { x = y; return true; } else { return false; } }
long mod = 10^^9 + 7;
void moda(ref long x, long y) { x = (x + y) % mod; }
void mods(ref long x, long y) { x = ((x + mod) - (y % mod)) % mod; }
void modm(ref long x, long y) { x = (x * y) % mod; }
void main()
{
auto N = RD!uint;
auto s = RD!string;
auto actg = "ACTG";
long f(in string str)
{
long cnt;
foreach (i; 0..4)
{
auto x = str[i] < actg[i] ? actg[i] - str[i] : str[i] - actg[i];
cnt += min(x, 26 - x);
}
return cnt;
}
long ans = long.max;
foreach (i; 0..N-3)
{
auto r = f(s[i..i+4]);
ans = min(ans, r);
}
writeln(ans);
stdout.flush();
debug readln();
}
|
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(TList...)(ref TList Args){auto line = readln.split();
foreach (i, T; TList){T val = line[i].to!(T);Args[i] = val;}}
alias sread = () => readln.chomp();enum MOD = 10 ^^ 9 + 7;
// dfmt on
void main()
{
long r = lread();
writeln(3 * r * r);
}
|
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;
// }}}
// 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 = stdin) {
this.file = file;
this.idx = 0;
}
this(StrType)(StrType s, File file = stdin) if (isSomeString!(StrType)) {
this.file = file;
this.idx = 0;
fromString(s);
}
private char[] next() {
if (idx < str.length) {
return str[idx++];
}
char[] s;
while (s.length == 0) {
s = file.readln.strip.to!(char[]);
}
str = s.split;
idx = 0;
return str[idx++];
}
T next(T)() {
return next.to!(T);
}
T[] nextArray(T)(size_t len) {
T[] ret = new T[len];
foreach (ref c; ret) {
c = next!(T);
}
return ret;
}
void scan()() {
}
void scan(T, S...)(ref T x, ref S args) {
x = next!(T);
scan(args);
}
void fromString(StrType)(StrType s) if (isSomeString!(StrType)) {
str ~= s.to!(char[]).strip.split;
}
}
// }}}
void main() {
auto cin = new Scanner;
string s = cin.next!string;
if (s == "AAA" || s == "BBB") {
writeln("No");
} else {
writeln("Yes");
}
}
|
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[] ss) {
bool[string] d = [ss[0]: true];
for (int i = 1; i < ss.length; i++) {
if (ss[i] in d) return false;
if (ss[i-1][$-1] != ss[i][0]) return false;
d[ss[i]] = true;
}
return true;
}
void main() {
int n = readint;
string[] ss;
for (int i = 0; i < n; i++) {
ss ~= read!string;
}
writeln(calc(ss) ? "Yes" : "No");
}
|
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);
int res = 0;
for (int a = 3; ; a += 2)
{
int d = a * a;
int b = d / 2;
int c = d - b;
if (c > n)
{
break;
}
res += 1;
}
writeln (res);
}
}
|
D
|
import std.stdio, std.string,std.range, std.conv, std.array, std.algorithm, std.math, std.typecons;
void main() {
auto S = [readln.chomp, readln.chomp, readln.chomp];
auto current = 0;
int[3] count;
while (true) {
if (count[current] == S[current].length) {
writeln(current == 0 ? "A" : current == 1 ? "B" : "C");
return;
}
auto next = S[current][count[current]] - 'a';
count[current]++;
current = next;
}
}
|
D
|
import core.bitop;
import std.algorithm;
import std.ascii;
import std.bigint;
import std.conv;
import std.functional;
import std.math;
import std.numeric;
import std.range;
import std.stdio;
import std.string;
import std.random;
T lread(T = long)()
{
return readln.chomp.to!T();
}
T[] aryread(T = long)()
{
return readln.split.to!(T[])();
}
void minAssign(T)(ref T dst, T src)
{
dst = min(dst, src);
}
alias sread = () => readln.chomp();
void main()
{
long N = lread();
auto dp = new long[](N + 1);
dp[] = long.max;
dp[0] = 0;
foreach (i; 0 .. N)
if (dp[i] != long.max)
{
dp[i + 1].minAssign(dp[i] + 1);
size_t j = 6;
while (i + j < dp.length)
{
dp[i + j].minAssign(dp[i] + 1);
j *= 6;
}
j = 9;
while (i + j < dp.length)
{
dp[i + j].minAssign(dp[i] + 1);
j *= 9;
}
}
dp[N].writeln();
}
|
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_rd[0]; s_rd.popFront; return res.to!T; }
string RDR()() { return readln.chomp; }
T[] ARR(T = long)(in string str, T fix = 0) { auto r = str.split.to!(T[]); r[] += fix; return r; }
T[] RDA(T = long)(T fix = 0) { auto r = readln.chomp.split.to!(T[]); r[] += fix; return r; }
T[][] RDA2(T = long)(size_t n, T[] fix = []) { auto r = new T[][](n); foreach (i; 0..n) { r[i] = readln.chomp.split.to!(T[]); foreach (j, e; fix) r[i][j] += e; } return r; }
size_t[] MAKE_IDX(alias less = "a < b", Range)(Range range) { auto idx = new size_t[](range.length); makeIndex!(less)(range, idx); return idx;}
size_t MIN_POS(alias less = "a < b", Range)(Range range) { auto r = minPos!(less)(range); return range.length - r.length; }
bool inside(T)(T x, T b, T e) { return x >= b && x < e; }
long lcm(long x, long y) { return x * (y / gcd(x, y)); }
long mod = 10^^9 + 7;
//long mod = 998244353;
//long mod = 1_000_003;
void moda(ref long x, long y) { x = (x + y) % mod; }
void mods(ref long x, long y) { x = ((x + mod) - (y % mod)) % mod; }
void modm(ref long x, long y) { x = (x * y) % mod; }
void main()
{
auto N = RD;
long ans, x = 2;
ans += (RD - 1);
foreach (i; 1..N)
{
auto A = RD;
ans += (A - 1) / x;
if (A == x)
{
x = A+1;
}
debug writeln("ans:", ans, " x:", x);
}
writeln(ans);
stdout.flush();
debug readln();
}
|
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,a,b;
scan(n, a, b);
auto ans = min(a*n, b);
writeln(ans);
}
void scan(T...)(ref T args) {
import std.stdio : readln;
import std.algorithm : splitter;
import std.conv : to;
import std.range.primitives;
auto line = readln().splitter();
foreach (ref arg; args) {
arg = line.front.to!(typeof(arg));
line.popFront();
}
assert(line.empty);
}
void fillAll(R, T)(ref R arr, T value) {
static if (is(typeof(arr[] = value))) {
arr[] = value;
}
else {
foreach (ref e; arr) {
fillAll(e, value);
}
}
}
bool chmin(T, U...)(ref T x, U args) {
bool isChanged;
foreach (arg; args) {
if (x > arg) {
x = arg;
isChanged = true;
}
}
return isChanged;
}
bool chmax(T, U...)(ref T x, U args) {
bool isChanged;
foreach (arg; args) {
if (x < arg) {
x = arg;
isChanged = true;
}
}
return isChanged;
}
|
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 = 10L^^15;
void main() {
int n, m;
scan(n, m);
auto adj = new int[][](n, 0);
foreach (i ; 0 .. m) {
int xi, yi;
scan(xi, yi);
xi--, yi--;
adj[yi] ~= xi;
}
auto dp = new int[](n);
dp[] = -1;
int dfs(int v) {
if (dp[v] != -1) {
return dp[v];
}
dp[v] = 0;
foreach (u ; adj[v]) {
dp[v] = max(dp[v], dfs(u) + 1);
}
return dp[v];
}
int ans;
foreach (i ; 0 .. n) {
ans = max(dfs(i), ans);
}
writeln(ans);
}
void scan(T...)(ref T args) {
import std.stdio : readln;
import std.algorithm : splitter;
import std.conv : to;
import std.range.primitives;
auto line = readln().splitter();
foreach (ref arg; args) {
arg = line.front.to!(typeof(arg));
line.popFront();
}
assert(line.empty);
}
void fillAll(R, T)(ref R arr, T value) {
static if (is(typeof(arr[] = value))) {
arr[] = value;
}
else {
foreach (ref e; arr) {
fillAll(e, value);
}
}
}
|
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() {
int n;
scan(n);
auto s = iota(n + 1).array;
long ans = 1;
foreach (p ; 2 .. n + 1) {
if (s[p] > 1) {
int cnt = 1;
for (int q = p; q < n + 1; q += p) {
while (s[q] % p == 0) {
cnt++;
s[q] /= p;
}
}
(ans *= cnt) %= mod;
}
}
writeln(ans);
}
void scan(T...)(ref T args) {
string[] line = readln.split;
foreach (ref arg; args) {
arg = line.front.to!(typeof(arg));
line.popFront();
}
assert(line.empty);
}
void fillAll(R, T)(ref R arr, T value) {
static if (is(typeof(arr[] = value))) {
arr[] = value;
}
else {
foreach (ref e; arr) {
fillAll(e, value);
}
}
}
|
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[]);
auto q = readln.chomp.to!int;
auto r = 1;
string a = "";
string b = "";
foreach (_; 0..q) {
auto x = readln.chomp.split;
if (x[0].to!int == 1) {
r *= -1;
} else {
if (x[1].to!int == 1) {
if (r == 1) {
a = x[2] ~ a;
} else {
b = b ~ x[2];
}
} else {
if (r == -1) {
a = x[2] ~ a;
} else {
b = b ~ x[2];
}
}
}
}
s = a ~ s ~ b;
if (r == -1) {
reverse(s);
}
s.writeln;
}
|
D
|
import std.algorithm, std.container, std.conv, std.math, std.range, std.typecons, std.stdio, std.string;
auto rdsp(){return readln.splitter;}
void pick(R,T)(ref R r,ref T t){t=r.front.to!T;r.popFront;}
void readV(T...)(ref T t){auto r=rdsp;foreach(ref v;t)pick(r,v);}
void main()
{
int n; readV(n);
writeln(n%2 == 0 ? n : n*2);
}
|
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 n, k;
string s;
void main() {
scan(n, k);
s = readln.chomp;
auto t = new int[](n + 10);
foreach (char ch ; 'A' .. 'Z' + 1) {
foreach (i ; 0 .. n) {
if (s[i] == ch) {
t[i]++;
break;
}
}
foreach_reverse (i ; 0 .. n) {
if (s[i] == ch) {
t[i + 1]--;
break;
}
}
}
foreach (i ; 0 .. n + 1) {
t[i + 1] += t[i];
}
debug {
writeln(t);
}
if (t.reduce!max > k) {
writeln("YES");
}
else {
writeln("NO");
}
}
void scan(T...)(ref T args) {
string[] line = readln.split;
foreach (ref arg; args) {
arg = line.front.to!(typeof(arg));
line.popFront();
}
assert(line.empty);
}
void fillAll(R, T)(ref R arr, T value) {
static if (is(typeof(arr[] = value))) {
arr[] = value;
}
else {
foreach (ref e; arr) {
fillAll(e, value);
}
}
}
|
D
|
/+ dub.sdl:
name "B"
dependency "dcomp" version=">=0.7.3"
+/
import std.stdio, std.algorithm, std.range, std.conv;
// import dcomp.foundation, dcomp.scanner;
int main() {
Scanner sc = new Scanner(stdin);
int n; int[] a;
sc.read(n, a);
long all = 1, err = 1;
foreach (d; a) {
all *= 3;
if (d % 2 == 0) {
err *= 2;
} else {
err *= 1;
}
}
writeln(all - err);
return 0;
}
/* IMPORT /home/yosupo/Program/dcomp/source/dcomp/foundation.d */
// module dcomp.foundation;
static if (__VERSION__ <= 2070) {
/*
Copied by https://github.com/dlang/phobos/blob/master/std/algorithm/iteration.d
Copyright: Andrei Alexandrescu 2008-.
License: $(HTTP boost.org/LICENSE_1_0.txt, Boost License 1.0).
*/
template fold(fun...) if (fun.length >= 1) {
auto fold(R, S...)(R r, S seed) {
import std.algorithm : reduce;
static if (S.length < 2) {
return reduce!fun(seed, r);
} else {
import std.typecons : tuple;
return reduce!fun(tuple(seed), r);
}
}
}
}
/* IMPORT /home/yosupo/Program/dcomp/source/dcomp/scanner.d */
// module dcomp.scanner;
// import dcomp.array;
class Scanner {
import std.stdio : File;
import std.conv : to;
import std.range : front, popFront, array, ElementType;
import std.array : split;
import std.traits : isSomeChar, isStaticArray, isArray;
import std.algorithm : map;
File f;
this(File f) {
this.f = f;
}
char[512] lineBuf;
char[] line;
private bool succW() {
import std.range.primitives : empty, front, popFront;
import std.ascii : isWhite;
while (!line.empty && line.front.isWhite) {
line.popFront;
}
return !line.empty;
}
private bool succ() {
import std.range.primitives : empty, front, popFront;
import std.ascii : isWhite;
while (true) {
while (!line.empty && line.front.isWhite) {
line.popFront;
}
if (!line.empty) break;
line = lineBuf[];
f.readln(line);
if (!line.length) return false;
}
return true;
}
private bool readSingle(T)(ref T x) {
import std.algorithm : findSplitBefore;
import std.string : strip;
import std.conv : parse;
if (!succ()) return false;
static if (isArray!T) {
alias E = ElementType!T;
static if (isSomeChar!E) {
auto r = line.findSplitBefore(" ");
x = r[0].strip.dup;
line = r[1];
} else static if (isStaticArray!T) {
foreach (i; 0..T.length) {
bool f = succW();
assert(f);
x[i] = line.parse!E;
}
} else {
FastAppender!(E[]) buf;
while (succW()) {
buf ~= line.parse!E;
}
x = buf.data;
}
} else {
x = line.parse!T;
}
return true;
}
int read(T, Args...)(ref T x, auto ref Args args) {
if (!readSingle(x)) return 0;
static if (args.length == 0) {
return 1;
} else {
return 1 + read(args);
}
}
}
/* IMPORT /home/yosupo/Program/dcomp/source/dcomp/array.d */
// module dcomp.array;
T[N] fixed(T, size_t N)(T[N] a) {return a;}
struct FastAppender(A, size_t MIN = 4) {
import std.algorithm : max;
import std.conv;
import std.range.primitives : ElementEncodingType;
import core.stdc.string : memcpy;
private alias T = ElementEncodingType!A;
private T* _data;
private uint len, cap;
@property size_t length() const {return len;}
bool empty() const { return len == 0; }
void reserve(size_t nlen) {
import core.memory : GC;
if (nlen <= cap) return;
void* nx = GC.malloc(nlen * T.sizeof);
cap = nlen.to!uint;
if (len) memcpy(nx, _data, len * T.sizeof);
_data = cast(T*)(nx);
}
void free() {
import core.memory : GC;
GC.free(_data);
}
void opOpAssign(string op : "~")(T item) {
if (len == cap) {
reserve(max(MIN, cap*2));
}
_data[len++] = item;
}
void insertBack(T item) {
this ~= item;
}
void removeBack() {
len--;
}
void clear() {
len = 0;
}
ref inout(T) back() inout { assert(len); return _data[len-1]; }
ref inout(T) opIndex(size_t i) inout { return _data[i]; }
T[] data() {
return (_data) ? _data[0..len] : null;
}
}
/*
This source code generated by dcomp and include dcomp's source code.
dcomp's Copyright: Copyright (c) 2016- Kohei Morita. (https://github.com/yosupo06/dcomp)
dcomp's License: MIT License(https://github.com/yosupo06/dcomp/blob/master/LICENSE.txt)
*/
|
D
|
import std.algorithm, std.container, std.conv, std.math, std.range, std.typecons, std.stdio, std.string;
auto rdsp(){return readln.splitter;}
void pick(R,T)(ref R r,ref T t){t=r.front.to!T;r.popFront;}
void readV(T...)(ref T t){auto r=rdsp;foreach(ref v;t)pick(r,v);}
void main()
{
int a, b, c; readV(a, b, c);
writeln(a <= c && c <= b ? "Yes" : "No");
}
|
D
|
/+ dub.sdl:
name "J"
dependency "dcomp" version=">=0.6.0"
+/
import std.stdio, std.algorithm, std.range, std.conv;
// import dcomp.foundation, dcomp.scanner;
import std.typecons;
int main() {
auto sc = new Scanner(stdin);
alias Edge = Tuple!(int, "to", int, "dist");
int n;
sc.read(n);
Edge[][] g = new Edge[][](n);
foreach (i; 0..n) {
int a, b, c;
sc.read(a, b, c);
g[a] ~= Edge(b, c);
g[b] ~= Edge(a, c);
}
int ma = -1;
void dfs(int p, int b, int nd) {
ma = max(ma, nd);
foreach (e; g[p]) {
if (e.to == b) continue;
dfs(e.to, p, nd + e.dist);
}
}
dfs(0, -1, 0);
writeln(ma);
return 0;
}
/* IMPORT /Users/yosupo/Program/dcomp/source/dcomp/scanner.d */
// module dcomp.scanner;
class Scanner {
import std.stdio : File;
import std.conv : to;
import std.range : front, popFront, array, ElementType;
import std.array : split;
import std.traits : isSomeChar, isStaticArray, isArray;
import std.algorithm : map;
File f;
this(File f) {
this.f = f;
}
char[512] lineBuf;
char[] line;
private bool succ() {
import std.range.primitives : empty, front, popFront;
import std.ascii : isWhite;
while (true) {
while (!line.empty && line.front.isWhite) {
line.popFront;
}
if (!line.empty) break;
if (f.eof) return false;
line = lineBuf[];
f.readln(line);
}
return true;
}
private bool readSingle(T)(ref T x) {
import std.algorithm : findSplitBefore;
import std.string : strip;
import std.conv : parse;
if (!succ()) return false;
static if (isArray!T) {
alias E = ElementType!T;
static if (isSomeChar!E) {
auto r = line.findSplitBefore(" ");
x = r[0].strip.dup;
line = r[1];
} else {
auto buf = line.split.map!(to!E).array;
static if (isStaticArray!T) {
assert(buf.length == T.length);
}
x = buf;
line.length = 0;
}
} else {
x = line.parse!T;
}
return true;
}
int read(T, Args...)(ref T x, auto ref Args args) {
if (!readSingle(x)) return 0;
static if (args.length == 0) {
return 1;
} else {
return 1 + read(args);
}
}
}
/* IMPORT /Users/yosupo/Program/dcomp/source/dcomp/foundation.d */
// module dcomp.foundation;
static if (__VERSION__ <= 2070) {
template fold(fun...) if (fun.length >= 1) {
auto fold(R, S...)(R r, S seed) {
import std.algorithm : reduce;
static if (S.length < 2) {
return reduce!fun(seed, r);
} else {
import std.typecons : tuple;
return reduce!fun(tuple(seed), r);
}
}
}
}
version (X86) static if (__VERSION__ < 2071) {
int bsf(ulong v) {
foreach (i; 0..64) {
if (v & (1UL << i)) return i;
}
return -1;
}
int bsr(ulong v) {
foreach_reverse (i; 0..64) {
if (v & (1UL << i)) return i;
}
return -1;
}
int popcnt(ulong v) {
int c = 0;
foreach (i; 0..64) {
if (v & (1UL << i)) c++;
}
return c;
}
}
|
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", long, "x");
T lread(T = long)()
{
return readln.chomp.to!T();
}
T[] aryread(T = long)()
{
return readln.split.to!(T[])();
}
void scan(TList...)(ref TList Args)
{
auto line = readln.split();
foreach (i, T; TList)
{
T val = line[i].to!(T);
Args[i] = val;
}
}
void minAssign(T, U = T)(ref T dst, U src)
{
dst = cast(T) min(dst, src);
}
void maxAssign(T, U = T)(ref T dst, U src)
{
dst = cast(T) max(dst, src);
}
enum MOD = (10 ^^ 9) + 7;
void main()
{
long A, B, C;
scan(A, B, C);
bool[long] b;
long n = A;
b[A % B] = true;
while (true)
{
if (C in b)
{
writeln("YES");
return;
}
n += A;
n %= B;
if (n in b)
{
writeln("NO");
return;
}
b[n] = true;
}
}
|
D
|
import std.stdio, std.string, std.conv, std.array, std.algorithm;
import std.uni, std.range, std.math, std.container, std.datetime;
import core.bitop, std.typetuple, std.typecons;
immutable long MOD = 1_000_000_007;
alias tie = TypeTuple;
alias triplet = Tuple!(int, int, int);
void main(){
int a, b, c;
readVars(a, b, c);
if (a & 1 || b & 1 || c & 1) {
writeln(0);
return;
}
if (a == b && b == c) {
writeln(-1);
return;
}
int ans;
while(true){
if (a & 1 || b & 1 || c & 1) {
writeln(ans);
return;
}
auto tmp1 = (b + c) / 2, tmp2 = (a + c) / 2, tmp3 = (a + b) / 2;
a = tmp1, b = tmp2, c = tmp3;
ans++;
}
}
void readVars(T...)(auto ref T args){
auto line = readln.split;
foreach(ref arg ; args){
arg = line.front.to!(typeof(arg));
line.popFront;
}
if(!line.empty){
throw new Exception("args num < input num");
}
}
|
D
|
import std;
// dfmt off
T lread(T = long)(){return readln.chomp.to!T();}
T[] lreads(T = long)(long n){return generate(()=>readln.chomp.to!T()).take(n).array();}
T[] aryread(T = long)(){return readln.split.to!(T[])();}
void scan(TList...)(ref TList Args){auto line = readln.split();
foreach (i, T; TList){T val = line[i].to!(T);Args[i] = val;}}
alias sread = () => readln.chomp();enum MOD = 10 ^^ 9 + 7;
alias PQueue(T, alias less = "a<b") = BinaryHeap!(Array!T, less);
// dfmt on
void main()
{
long S, W;
scan(S, W);
writeln((S <= W) ? "unsafe" : "safe");
}
|
D
|
void main() {
string s = readln.chomp;
long k = readln.chomp.to!int;
auto g = s.group.array;
long ans;
if (g.length == 1) {
ans = k * g[0][1].to!long / 2;
} else {
foreach (x; g) {
ans += x[1] / 2;
}
ans *= k;
if (s[0] == s[$-1]) {
long tmp = (g[0][1] + g[$-1][1]) / 2;
tmp -= g[0][1] / 2 + g[$-1][1] / 2;
ans += (k - 1) * tmp;
}
}
ans.writeln;
}
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
|
void main() {
problem();
}
void problem() {
auto S = scan;
auto T = scan;
auto SL = S.length;
auto TL = T.length;
long solve() {
int max_contained;
foreach(i; 0..SL - TL + 1) {
int contained;
foreach(j; 0..TL) {
if (T[j] == S[i + j]) contained++;
}
if (max_contained < contained) max_contained = contained;
}
return TL - max_contained;
}
solve().writeln;
}
// ----------------------------------------------
import std.stdio, std.conv, std.array, std.string, std.algorithm, std.container, std.range, core.stdc.stdlib, std.math, std.typecons, std.numeric;
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); }
string scan(){ static string[] ss; while(!ss.length) ss = readln.chomp.split; string res = ss[0]; ss.popFront; return res; }
T scan(T)(){ return scan.to!T; }
T[] scan(T)(int n){ return n.iota.map!(i => scan!T()).array; }
void deb(T ...)(T t){ debug writeln(t); }
alias Point = Tuple!(long, "x", long, "y");
// -----------------------------------------------
|
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 data = readln.split.to!(int[]);
writeln( max(data[0] * 2 - 1, data[0] + data[1], data[1] * 2 - 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(T = long)() { while(!s_rd.length) s_rd = readln.chomp.split; string res = s_rd[0]; s_rd.popFront; return res.to!T; }
T _RD(T = long)(File f) { while(!s_rd.length) s_rd = f.readln.chomp.split; string res = s_rd[0]; s_rd.popFront; return res.to!T; }
T[] _RDA(T = long)(T fix = 0) { auto r = readln.chomp.split.to!(T[]); r[] += fix; return r; }
T[] _RDA(T = long)(File f, T fix = 0) { auto r = f.readln.chomp.split.to!(T[]); r[] += fix; return r; }
T RD(T = long)() { if (_f.isOpen) return _RD!T(_f); else return _RD!T; }
T[] RDA(T = long)(T fix = 0) { if (_f.isOpen) return _RDA!T(_f, fix); else return _RDA!T(fix); }
size_t[] MAKE_IDX(alias less = "a < b", Range)(Range range) { auto idx = new size_t[](range.length); makeIndex!(less)(range, idx); return idx;}
size_t MIN_POS(alias less = "a < b", Range)(Range range) { auto r = minPos!(less)(range); return range.length - r.length; }
void chmin(T)(ref T x, T y) { x = min(x, y); } void chmax(T)(ref T x, T y) { x = max(x, y); }
bool inside(T)(T x, T b, T e) { return x >= b && x < e; }
T lcm(T)(T x, T y) { return x * (y / gcd(x, y)); }
long mod = 10^^9 + 7;
//long mod = 998_244_353;
//long mod = 1_000_003;
void moda(T)(ref T x, T y) { x = (x + y) % mod; }
void mods(T)(ref T x, T y) { x = ((x + mod) - (y % mod)) % mod; }
void modm(T)(ref T x, T y) { x = (x * y) % mod; }
void modpow(T)(ref T x, T y) { if (!y) { x = 1; return; } auto t = x; x.modpow(y>>1); x.modm(x); if (y&1) x.modm(t); }
void modd(T)(ref T x, T y) { y.modpow(mod - 2); x.modm(y); }
void main()
{
auto X = RD;
writeln(X >= 30 ? "Yes" : "No");
stdout.flush;
debug readln;
}
|
D
|
import std.stdio, std.string, std.algorithm, std.array;
void bracket (int count)
{
for (int i = count; i >= 1; i--)
{
string s = "";
s ~= replicate("(", i);
s ~= replicate(")", i);
s ~= replicate("(", count - i);
s ~= replicate(")", count - i);
writeln(s);
}
}
void main()
{
int t;
scanf("%d", &t);
getchar();
foreach(_; 0..t){
int n;
scanf("%d", &n);
bracket(n);
}
}
|
D
|
import std.stdio, std.conv, std.string;
void main(){
auto ip = readln.split.to!(int[]), x = ip[0], y = ip[1];
const gr = [0, 1, 2, 1, 3, 1, 3, 1, 1, 3, 1, 3, 1];
if(gr[x] == gr[y]){
writeln("Yes");
} else {
writeln("No");
}
}
|
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); }
void print(){ writeln(""); } void print(T)(T t){ writeln(t); } void print(T, A ...)(T t, A a){ write(t, " "), print(a); }
string unsplit(T)(T xs){ return xs.array.to!(string[]).join(" "); }
string scan(){ static string[] ss; while(!ss.length) ss = readln.chomp.split; string res = ss[0]; ss.popFront; return res; }
T scan(T)(){ return scan.to!T; } T[] scan(T)(int n){ return n.iota.map!(i => scan!T()).array; }
T lowerTo(T)(ref T x, T y){ if(x > y) x = y; return x; } T raiseTo(T)(ref T x, T y){ if(x < y) x = y; return x; }
// ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- //
void solve(){
foreach(_; 0 .. scan!int){
int a = scan!int, b = scan!int;
if(a % b == 0) "YES".print;
else "NO".print;
}
}
|
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_rd[0]; s_rd.popFront; return res.to!T; }
string RDR()() { return readln.chomp; }
T[] ARR(T = long)(in string str, T fix = 0) { auto r = str.split.to!(T[]); r[] += fix; return r; }
size_t[] MAKE_IDX(alias less = "a < b", Range)(Range range) { auto idx = new size_t[](range.length); makeIndex!(less)(range, idx); return idx;}
size_t MIN_POS(alias less = "a < b", Range)(Range range) { auto r = minPos!(less)(range); return range.length - r.length; }
bool inside(T)(T x, T b, T e) { return x >= b && x < e; }
long lcm(long x, long y) { return x * y / gcd(x, y); }
long mod = 10^^9 + 7;
//long mod = 998244353;
//long mod = 1_000_003;
void moda(ref long x, long y) { x = (x + y) % mod; }
void mods(ref long x, long y) { x = ((x + mod) - (y % mod)) % mod; }
void modm(ref long x, long y) { x = (x * y) % mod; }
void main()
{
auto N = RD;
writeln(N / 3);
stdout.flush();
debug readln();
}
|
D
|
void main() {
if(rs.count('7')) writeln("Yes");
else writeln("No");
}
// ===================================
import std.stdio;
import std.string;
import std.functional;
import std.algorithm;
import std.range;
import std.traits;
import std.math;
import std.container;
import std.bigint;
import std.numeric;
import std.conv;
import std.typecons;
import std.uni;
import std.ascii;
import std.bitmanip;
import core.bitop;
T readAs(T)() if (isBasicType!T) {
return readln.chomp.to!T;
}
T readAs(T)() if (isArray!T) {
return readln.split.to!T;
}
T[][] readMatrix(T)(uint height, uint width) if (!isSomeChar!T) {
auto res = new T[][](height, width);
foreach(i; 0..height) {
res[i] = readAs!(T[]);
}
return res;
}
T[][] readMatrix(T)(uint height, uint width) if (isSomeChar!T) {
auto res = new T[][](height, width);
foreach(i; 0..height) {
auto s = rs;
foreach(j; 0..width) res[i][j] = s[j].to!T;
}
return res;
}
int ri() {
return readAs!int;
}
double rd() {
return readAs!double;
}
string rs() {
return readln.chomp;
}
|
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); }
void main() {
auto Ns = readln.split.to!(int[]);
writeln(Ns[0]+Ns[1]+Ns[2] >= 22 ? "bust" : "win");
}
|
D
|
import std.stdio, std.algorithm, std.range, std.conv, std.string, std.math;
import core.stdc.stdio;
// foreach, foreach_reverse, writeln
void main() {
int n; long c;
scanf("%d%ld", &n, &c);
struct P { long x; int v;}
P[] p = new P[n];
foreach (i; 0..n) {
long x; int v;
scanf("%ld%d", &x, &v);
p[i] = P(x,v);
}
long ans = 0;
foreach (_; 0..2) {
p.sort!("a.x<b.x");
long[] l = new long[n+1];
{
long sum = 0, best = 0;
foreach (i; 0..n) {
sum += p[i].v;
best = max(best, sum-p[i].x);
l[i+1] = best;
}
}
long[] r = new long[n+1];
{
long sum = 0, best = 0;
foreach_reverse (i; 0..n) {
sum += p[i].v;
best = max(best, sum-(c-p[i].x)*2);
r[i] = best;
}
}
foreach (i; 0..n+1) {
ans = max(ans, l[i]+r[i]);
}
foreach (i; 0..n) {
p[i].x = c-p[i].x;
}
}
writeln(ans);
}
|
D
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.