code stringlengths 4 1.01M | language stringclasses 2
values |
|---|---|
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 |
import std.stdio, std.algorithm, std.conv, std.array, std.string;
wchar[600][600] BD1, BD2;
void main()
{
auto N = readln.chomp.to!int;
foreach (i; 0..N) {
foreach (j, c; readln.chomp) {
BD1[i][j] = BD1[i][N+j] = BD1[N+i][j] = BD1[N+i][N+j]= c;
BD2[j][i] = BD2[j][N+i] = BD2[N+... | D |
import std.stdio, std.conv, std.string, std.algorithm.iteration, std.math, std.range, std.algorithm.sorting, std.algorithm.searching, std.algorithm.mutation, std.array, std.typecons;
void main()
{
readln;
auto t = readln;
int[] list = t.split.to!(int[]);
int[] eList;
int[] oList;
eList.length =... | D |
import std.stdio, std.string, std.conv, std.algorithm;
import std.range, std.array, std.math, std.typecons, std.container, core.bitop;
alias Edge = Tuple!(int, "to", int, "c", int, "rev");
immutable inf = 101101;
void main() {
int n, m;
scan(n, m);
auto adj = new Edge[][](n, 0);
foreach (i ; 0 .. m)... | D |
import std.stdio; // ??\????????????????????????
import std.string; // chomp????????????????????????(?????????????????????)
import std.conv; // to????????????????????????
import std.array; // split?????????????????????
import std.algorithm; // map?????????????????????
void main() {
auto input = readln.split.map!(... | 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... | D |
import std.stdio;
import std.string;
import std.array;
import std.conv;
import std.algorithm;
import std.range;
uint readNumber() {
return readln.chomp.to!uint;
}
void main() {
uint[3 * 3] numbers;
bool[3 * 3] checked;
size_t contain(uint x,out size_t index) {
foreach (size_t i, n;numbers) {
if (n == x) {
... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto S = readln.chomp;
writeln(S[2] == S[3] && S[4] == S[5] ? "Yes" : "No");
} | 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 |
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;
void main()
{
auto n = readln.chomp.to!int;
while (n--) {
auto pat = readln.chomp;
auto str = readln.chomp;
foreach_reverse (e; pat) {
i... | 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;
enum mod = 1_000_000_007L;
void main() {
int q;
scan(q);
while (q--) {
... | D |
import std.stdio, std.conv, std.string;
import std.algorithm, std.array, std.container;
import std.numeric, std.math;
import core.bitop;
T RD(T = string)() { static string[] ss; while(!ss.length) ss = readln.chomp.split; string res = ss[0]; ss.popFront; return res.to!T; }
string RDR()() { return readln.chomp; }
void E... | D |
import std.stdio, std.array, std.conv, std.string, std.range, std.algorithm;
void main() {
long n = readln.strip.to!(long);
string s = readln.strip;
long k = readln.strip.to!(long);
writeln(cast(dchar[])(s.map!(c => (c == s[k-1]) ? c : '*').array));
}
| D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto S = readln.chomp;
writeln(S.length > 3 && S[0..4] == "YAKI" ? "Yes" : "No");
} | 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 s = readln.chomp;
if (n % 2 == 0 && s[0..n/2] ... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math;
void main()
{
auto X = readln.chomp.to!int;
auto A = readln.chomp.to!int;
auto B = readln.chomp.to!int;
writeln((X - A) % B);
} | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array;
void main() {
int n, k, x, y;
scan(n);
scan(k);
scan(x);
scan(y);
writeln(x*(min(k, n)) + y*(max(0, n - k)));
}
void scan(T...)(ref T args) {
import std.stdio : readln;
import std.algorithm : splitte... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array, std.typecons, std.container;
import std.math, std.numeric, std.random, core.bitop;
enum inf = 1_001_001_001;
enum inf6 = 1_001_001_001_001_001_001L;
enum mod = 1_000_000_007L;
void main() {
string s, t;
scan(s);
scan(t);
... | D |
import std.stdio, std.math, std.algorithm, std.array, std.string, std.conv, std.container, std.range;
void main() {
int n = readln.chomp.to!int;
iota(1, n+1).filter!(i => i.to!string.length & 1)
.array
.length
.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 readA(T)(size_t n,ref T[]t){t=new T[](n);auto ... | D |
import std.stdio;
import std.conv, std.array, std.algorithm, std.string;
import std.math, std.random, std.range, std.datetime;
import std.bigint;
void main(){
int h, w;
{
int[] tmp = readln.chomp.split.map!(to!int).array;
h = tmp[0], w = tmp[1];
}
int count;
for(int i = 0; i < h; i ++){
string s = readln... | D |
import std.stdio;
import std.string;
import std.format;
import std.conv;
import std.typecons;
import std.algorithm;
import std.functional;
import std.bigint;
import std.numeric;
import std.array;
import std.math;
import std.range;
import std.container;
import std.concurrency;
import std.traits;
import std.uni;
import c... | D |
import std.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.conv, std.functional, std.range, std.stdio, std.string;
import std.algorithm, std.array, std.bigint, std.complex, std.container, std.math, std.numeric, std.regex, std.typecons;
import core.bitop;
class EOFException : Throwable { this() { super("EOF"); } }
string[] tokens;
string readToken() { for (; tokens.... | D |
void main(){
import std.stdio, std.string, std.conv, std.algorithm;
int a, b; rd(a, b);
if(a+b==15){
writeln("+");
}else if(a*b==15){
writeln("*");
}else{
writeln("x");
}
}
void rd(T...)(ref T x){
import std.stdio, std.string, std.conv;
auto l=readln.split;
assert(l.length==x.length);
... | D |
import std.algorithm;
import std.array;
import std.ascii;
import std.bigint;
import std.complex;
import std.container;
import std.conv;
import std.functional;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
auto readInts() {
return array(map!(to!int)(readln().strip().split... | D |
import std.stdio;
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;
void main()
{
int[10] wSum, kSum;
foreach (i; 0..10) {
wSum[i] = readln.chomp.to!int;
}
foreach (i; 0..10) {
kSum... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto xy = readln.split.to!(long[]);
auto x = xy[0];
auto y = xy[1];
if (y > x) {
if (x < 0 && y > 0) {
writeln(min(y - x, abs(y + x) + 1));
} else {
... | D |
import std.stdio;
import std.string;
import std.conv;
import std.typecons;
import std.algorithm;
import std.functional;
import std.bigint;
import std.numeric;
import std.array;
import std.math;
import std.range;
import std.container;
import std.ascii;
import std.concurrency;
import core.bitop : popcnt;
alias Generator ... | D |
/+ dub.sdl:
name "A"
dependency "dcomp" version=">=0.7.4"
+/
import std.stdio, std.algorithm, std.range, std.conv;
import std.numeric : gcd;
// import dcomp.foundation, dcomp.scanner;
int main() {
Scanner sc = new Scanner(stdin);
int n;
sc.read(n);
long[] a;
sc.read(a);
int zc = a.coun... | D |
import std.algorithm;
import std.conv;
import std.range;
import std.stdio;
import std.string;
immutable int letters = 26;
void main ()
{
auto tests = readln.strip.to !(int);
foreach (test; 0..tests)
{
auto n = readln.strip.to !(int);
auto s = readln.strip.map !(q{a - 'a'}).array;
auto t = readln.strip.map !(... | D |
import std.stdio, std.array, std.string, std.conv, std.algorithm;
import std.typecons, std.range, std.random, std.math, std.container;
import std.numeric, std.bigint, core.bitop, core.stdc.string;
void main() {
auto N = readln.chomp.to!int;
auto S = readln.chomp;
auto ans = new int[](N);
int tmp = 0;
... | D |
//prewritten code: https://github.com/antma/algo
import std.algorithm;
import std.array;
import std.conv;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.traits;
int sign (int x) {
if (!x) return 0;
if (x > 0) return 1;
return -1;
}
long test () {
auto s = readln.splitter.ma... | D |
import std.stdio;
import std.algorithm;
import std.conv;
import std.range;
import std.string;
import std.regex;
void main() {
int n, x;
int ans = 1;
int a=0, b=0;
int c=0, d=-1;
scanf("%d", &n );
for( int i = 1; i <= n; i ++ )
{
scanf( "%d", &x );
if( d == -1 )
{
d = x;
}
if( d ... | D |
void main(){
import std.stdio, std.string, std.conv, std.algorithm;
int n; rd(n);
auto x=readln.split.to!(int[]);
auto y=readln.split.to!(int[]);
if(x.reduce!"a+b">=y.reduce!"a+b") writeln("Yes");
else writeln("No");
}
void rd(T...)(ref T x){
import std.stdio, std.string, std.conv;
auto l=readln.spl... | D |
//prewritten code: https://github.com/antma/algo
import std.algorithm;
import std.array;
import std.conv;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.traits;
final class InputReader {
private:
ubyte[] p, buffer;
bool eof;
bool rawRead () {
if (eof) {
return fals... | D |
import std.algorithm;
import std.conv;
import std.range;
import std.stdio;
import std.string;
string solve (int n, int [] a)
{
foreach_reverse (b; 0..30)
{
auto z = a.count !(x => (x & (1 << b)) > 0);
if (z & 1)
{
if (z % 2 == n % 2 && z % 4 == 3)
{
return "LOSE";
}
return "WIN";
}
}
return... | D |
import std.stdio;
import std.conv;
import std.algorithm;
import std.range;
import std.string;
import std.math;
import std.format;
void main() {
string[][] q;
int n = readln.chomp.to!int;
q.length = n;
foreach (string line; stdin.lines) {
if (line == "quit\n") break;
auto s = line.chomp.split;
s... | D |
void main(){
long n = _scan!long();
long cnt;
foreach(i; 1..n+1){
if(i%3==0 || i%5==0)continue;
else cnt += i;
}
cnt.writeln();
}
import std.stdio, std.conv, std.algorithm, std.numeric, std.string, std.math, std.regex;
// 1่ฆ็ด ใฎใฟใฎๅ
ฅๅ
T _scan(T= int)(){
return to!(T)( readln().chomp() );
}
// 1่กใซๅไธๅใฎ่คๆฐๅ
ฅๅ
T[] _... | 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.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;
long MOD = 10^^9 + 7;
void main() {
auto N = readln.chomp.to!int;
int px = 0, py = 0, pt = 0;
foreach (_; 0..N) {
auto... | D |
void main() {
problem();
}
void problem() {
const N = scan!int;
const K = scan!long;
const A = scan!int(N);
int solve() {
int[int] visited;
int[] stack = new int[N];
{
int next = A[0];
foreach(i; 0..N) {
if (i == K - 1) return next;
stack[i] = next;
visited[... | D |
import std.stdio, std.conv, std.string, std.array, std.range, std.algorithm, std.container;
import std.math, std.random, std.bigint, std.datetime, std.format;
void main(string[] args){ if(args.length > 1) if(args[1] == "-debug") DEBUG = 1; solve(); }
void log()(){ writeln(""); } void log(T, A ...)(T t, lazy A a){ if(DE... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
enum P = 10^^9L+7;
long[10^^5+1] SS;
bool[10^^5+1] BS;
void main()
{
auto nm = readln.split.to!(int[]);
auto N = nm[0];
auto M = nm[1];
foreach (_; 0..M) {
auto a = readln.chomp.to!int;
... | D |
import std.stdio, std.math, std.algorithm, std.array, std.string, std.conv, std.container, std.range;
pragma(inline, true) T[] Reads(T)() { return readln.split.to!(T[]); }
alias reads = Reads!int;
pragma(inline, true) void scan(Args...)(ref Args args) {
string[] ss = readln.split;
foreach (i, ref arg ; args) ar... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto xa = readln.split.to!(int[]);
writeln(xa[0] < xa[1] ? 0 : 10);
} | D |
// Vicfred
// https://atcoder.jp/contests/abc158/tasks/abc158_a
// implementation
import std.stdio;
import std.string;
void main() {
string s = readln.chomp;
if(s.count('A') > 0 && s.count('B') > 0)
"Yes".writeln;
else
"No".writeln;
}
| D |
// dfmt off
T lread(T=long)(){return readln.chomp.to!T;}T[] lreads(T=long)(long n){return iota(n).map!((_)=>lread!T).array;}
T[] aryread(T=long)(){return readln.split.to!(T[]);}void arywrite(T)(T a){a.map!text.join(' ').writeln;}
void scan(L...)(ref L A){auto l=readln.split;foreach(i,T;L){A[i]=l[i].to!T;}}alias sread=(... | D |
import std.stdio, std.algorithm, std.range, std.conv, std.string;
import core.stdc.stdio;
// foreach, foreach_reverse, writeln
void main() {
int n;
scanf("%d", &n);
int[] a = new int[n];
int[] b = new int[n];
foreach (i; 0..n) scanf("%d", &a[i]);
foreach (i; 0..n) scanf("%d", &b[i]);
int ans = 0;
foreach (k; 0... | 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, p; readV(a, p);
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;
void main() {
int n;
scan(n);
auto a = readln.split.to!(int[]);
writeln(a.reduce!max - a.reduce!min);
}
vo... | 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 ans = "";
// writeln(ans);
// w... | D |
void main() {
int[] tmp = readln.split.to!(int[]);
int a = tmp[0], b = tmp[1];
writeln(max(a+b, a-b, a*b));
}
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;
impor... | D |
import std.stdio, std.string, std.array, std.conv;
void main() {
foreach (i; 0 .. 50) {
int[] tmp = readln.chomp.split.to!(int[]);
int m = tmp[0], f = tmp[1], r = tmp[2];
if (m == -1 && f == -1 && r == -1) break;
if (m == -1 || f == -1) {
"F".writeln;
} else if (... | 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;
class InputReader {
private:
ubyte[] p;
ubyte[] buffer;
size_t cur;
public:
this () {
buffer = uninitializ... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto nm = readln.split.to!(int[]);
auto N = nm[0];
auto M = nm[1];
writeln(N * (N-1) / 2 + M * (M-1) / 2);
} | D |
void main(){
import std.stdio, std.string, std.conv, std.algorithm;
int n; rd(n);
auto a=new long[](n+1);
for(int i=1; i<=n; i++){
int q=i;
for(int j=2; j<=i; j++){
while(q>1 && q%j==0){
q/=j;
a[j]++;
}
}
}
// writeln(a);
const long mod=1_000_000_000+7;
auto r... | D |
import std.stdio, std.string, std.range, std.algorithm, std.math, std.typecons, std.conv;
void main() {
auto inp = readln.split.to!(long[]);
auto N = inp[0], T = inp[1];
auto t = readln.split.to!(long[]);
long res = 0;
foreach (i; 0..N-1) {
res += min(T, t[i+1] - t[i]);
}
res += T;
writeln(res);
}
| 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 d; readV(d);
write("Christm... | 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.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.format;
void main()
{
auto ab = readln.split.to!(int[])... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array, std.typecons, std.container;
import std.math, std.numeric, core.bitop;
enum inf3 = 1_001_001_001;
enum inf6 = 1_001_001_001_001_001_001L;
enum mod = 1_000_000_007L;
void main() {
int N;
scan(N);
auto h = readln.split.to... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.array;
import std.range;
import std.math;
import std.regex;
void main(){
auto n=readln.chomp.to!int;
if(n%2==0)writeln(n);
else writeln(2*n);
} | D |
import std.stdio;
int main()
{
int n = 0;
scanf("%d", &n);
writeln(n*n*n);
return 0;
} | D |
void main(){
import std.stdio, std.string, std.conv, std.algorithm;
int n; rd(n);
auto a=readln.split.to!(int[]);
int cnt=0;
void f(int i=0, int pro=1){
if(i==n){if(pro%2==0) cnt++; return;}
for(int d=-1; d<=1; d++) f(i+1, pro*(a[i]+d));
}
f();
writeln(cnt);
}
void rd(T...)(ref T x){
imp... | D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
auto rd = readln.split.to!(int[]), a = rd[0], b = rd[1], c = rd[2];
writeln(c >= a && c <= b ? "Yes" : "No");
}
| D |
import std.algorithm;
import std.conv;
import std.stdio;
import std.string;
void main()
{
auto abc = readln.split.map!( to!int );
auto k = readln.strip.to!int;
writeln( solve( abc[ 0 ], abc[ 1 ], abc[ 2 ], k ) );
}
int solve( in int a, in int b, in int c, in int k )
{
return a + b + c + max( a, b, c ) * ( 2 ^^... | D |
import std.stdio,
std.array,
std.conv,
std.string,
std.algorithm;
void main(){
string s;
for(;;){
s=readln();
if(stdin.eof()) break;
int num = to!int(chomp(s));
int a,b,c,d,result=0;
for(a = 0;a < 10;++a){
for(b = 0;b < 10;++b){
for(c = 0;c < 10;++c){
for... | D |
import std.stdio;
import std.conv;
import std.string;
import std.typecons;
import std.algorithm;
import std.array;
import std.range;
import std.math;
import std.regex : regex;
import std.container;
import std.bigint;
import std.ascii;
void main()
{
auto s = readln.chomp;
long cnt, res;
foreach (i; 0..s.length) ... | D |
/+ dub.sdl:
name "A"
dependency "dcomp" version=">=0.6.0"
+/
import std.stdio, std.algorithm, std.range, std.conv;
// import dcomp.foundation, dcomp.scanner;
// import dcomp.bigint;
int main() {
auto sc = new Scanner(stdin);
long aa, bb, cc;
sc.read(aa, bb, cc);
alias Uint = uintN!1;
aut... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto na = readln.split.to!(int[]);
auto N = na[0];
auto A = na[1];
auto xs = readln.split.to!(int[]);
auto DP = new long[][][](N, N, N*50+1);
foreach (ref a; DP) foreach (ref b;... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
/// [..)
struct SegTree(alias _fun, alias def, T)
if (is(typeof(def) : T))
{
import std.functional : binaryFun;
alias fun = binaryFun!_fun;
///
this(size_t n, T[] ts) {
this.n = 1;
wh... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto nk = readln.split.to!(int[]);
auto N = nk[0];
auto K = nk[1];
auto S = readln.chomp;
int cnt, p;
int[] as;
foreach (c; S) {
auto pp = c == '0' ? -1 : 1;
... | 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 |
/* 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.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
struct Graph(T)
{
T L, R;
T[][] adj;
this(T L, T R)
{
this.L = L;
this.R = R;
adj.length = L + R;
}
void add_edge(T u, T v)
{
adj[u] ~= v+L;
adj[v... | D |
import std;
alias sread = () => readln.chomp();
alias lread = () => readln.chomp.to!long();
alias aryread(T = long) = () => readln.split.to!(T[]);
void main()
{
auto s = sread();
auto s_len = s.length;
// writeln(s_len);
foreach (i; 0 .. s_len)
{
write('x');
}
}
void scan(L...)(ref L ... | D |
import std.stdio, std.conv, std.functional, std.string;
import std.algorithm, std.array, std.container, std.typecons;
import std.numeric, std.math;
import core.bitop;
string FMT_F = "%.10f";
T RD(T = long)() { static string[] ss; while(!ss.length) ss = readln.chomp.split; string res = ss[0]; ss.popFront; return res.t... | D |
import std.stdio, std.array, std.conv, std.algorithm, std.string, std.numeric, std.range;
string swap(string s){
if(s.indexOf("apple")!=-1) return s.replace("apple", "peach");
else if(s.indexOf("peach")!=-1) return s.replace("peach", "apple");
else return s;
}
void main() {
string s;
while( (s=readln.strip).length... | D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
auto rd = readln.split.to!(int[]), n = rd[0], y = rd[1]/1000;
foreach (u; 0..n+1)
foreach (v; 0..n+1) {
auto w = n-u-v;
if (w >= 0 && 10*u+5*v+w == y) {
writeln(u, " ", v, " ", w);
return;
}
}
... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
enum P = 10^^9+7L;
long[10^^5*2+50] F, RF;
void init()
{
F[0] = F[1] = 1;
foreach (i, ref x; F[2..$]) x = (F[i+1] * (i+2)) % P;
{
RF[$-1] = 1;
auto x = F[$-1];
auto k = P-2;
... | 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; readV(a, b);
if (a+b >... | D |
void main() {
int[] xy = readln.split.to!(int[]);
int x = xy[0], y = xy[1];
bool ok = true;
int[] d30 = [4, 6, 9, 11];
if (xy.any!"a == 2") {
ok = false;
} else if (d30.canFind(x) != d30.canFind(y)) {
ok = false;
}
writeln(ok ? "Yes" : "No");
}
import std.stdio;
import s... | D |
import std.stdio;
import std.ascii;
import std.conv;
import std.string;
import std.algorithm;
import std.range;
import std.functional;
import std.math;
import core.bitop;
import std.numeric;
void main()
{
auto hw = readln.split.to!(long[]);
long h = hw[0];
long w = hw[1];
char[][] table;
foreach (i... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array;
void main() {
int n, m;
scan(n, m);
auto uf = WeightedUnionFind!(int)(n + 1);
bool ok = 1;
foreach (i ; 0 .. m) {
int l, r, d;
scan(l, r, d);
if (uf.same(l, r)) {
if (uf.diff(l... | 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 s = new int[](n);
foreach (i; 0..n) {
s[i]... | 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;
immutable long MOD = 10^^9 + 7;
immutable long INF = 1L << 59;
void main() {
auto s = readln.split.map!(to!int);
auto... | D |
void main() {
problem();
}
void problem() {
auto N = scan;
void solve() {
writeln(N.canFind('7') ? "Yes" : "No");
}
solve();
}
// ----------------------------------------------
import std.stdio, std.conv, std.array, std.string, std.algorithm, std.container, std.range, core.stdc.stdlib, std.math, std.... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.math;
import std.bigint;
void main(){
auto qty = readInt();
auto num = readLongs();
ulong negative = num.count!("a < 0");
bool zero = num.find(0).length ? true : false;
auto pnum = num.map!(a => abs(a));
auto re... | D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
auto n = readln.chomp.to!int;
auto k = readln.chomp.to!int;
auto ans = int.max;
foreach (i; 0..1<<n) {
auto r = 1;
foreach (j; 0..n)
if (i.bitTest(j)) r *= 2;
else r += k;
ans = min(ans, r);
... | D |
void main() {
import std.stdio, std.string, std.conv, std.algorithm;
auto s = readln.chomp.to!(char[]);
long k;
rd(k);
int j = -1;
for (int i = 0; i < s.length; i++) {
if (s[i] > '1') {
j = i;
break;
}
}
if (j < 0) {
writeln(1);
} else {
if (k <= j) {
writeln(1);
... | D |
import core.bitop;
import std.algorithm;
import std.ascii;
import std.bigint;
import std.conv;
import std.functional;
import std.format;
import std.math;
import std.numeric;
import std.range;
import std.stdio;
import std.string;
import std.random;
import std.typecons;
alias sread = () => readln.chomp();
alias Point2 ... | D |
import std.stdio, std.string, std.conv;
void main(){
auto xyz = readln.split.to!(int[]);
auto x = xyz[0], y = xyz[1], z = xyz[2];
writeln((x - z) / (y + z));
} | D |
void main()
{
long n, m;
rdVals(n, m);
long[][] edge = new long[][](n);
foreach (i; 0 .. m)
{
long a, b;
rdVals(a, b);
--a, --b;
edge[a] ~= b, edge[b] ~= a;
}
long[] dist = new long[n];
long[] que;
que ~= 0;
while (!que.empty)
{
long n... | D |
void main()
{
long n = rdElem;
long l, r = n - 1;
string s;
string t = "Vacant";
l.writeln;
stdout.flush;
s = rdStr;
if (s == t) return;
string f = s;
r.writeln;
stdout.flush;
s = rdStr;
if (s == t) return;
foreach (i; 0 .. 21)
{
long m = (l + r) >... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons;
void main()
{
auto ab = readln.split.to!(int[]);
auto A = ab[0];
auto B = ab[1];
writeln(A <= 8 && B <= 8 ? "Yay!" : ":(");
} | D |
// Cheese-Cracker: cheese-cracker.github.io
void theCode(){
ll a = scan;
ll b = scan;
ll diff = abs(a - b);
ll rem = 0;
if(diff > 0){
rem = min(b % diff, diff - (b % diff));
}
writeln(diff, " ", rem);
}
void main(){
long tests = scan; // Toggle!
while(tests--) theCod... | D |
import std.stdio, std.array, std.string, std.conv, std.algorithm;
import std.typecons, std.range, std.random, std.math, std.container;
import std.numeric, std.bigint, core.bitop, core.stdc.string;
immutable long MOD = 10^^9 + 7;
void main() {
auto s = readln.split;
auto N = s[0].to!int;
auto K = s[1].to!l... | D |
import std.stdio, std.conv, std.functional, std.string;
import std.algorithm, std.array, std.container, std.range, std.typecons;
import std.bigint, std.numeric, std.math, std.random;
import core.bitop;
string FMT_F = "%.10f";
static File _f;
void file_io(string fn) { _f = File(fn, "r"); }
static string[] s_rd;
T _RD(... | D |
import std.stdio, std.array, std.string, std.conv, std.algorithm;
import std.typecons, std.range, std.random, std.math, std.container;
import std.numeric, std.bigint, core.bitop, std.bitmanip;
immutable int INF = 1 << 29;
void main() {
auto s = readln.split.map!(to!int);
auto N = s[0];
auto K = s[1];
... | D |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.