code stringlengths 4 1.01M | language stringclasses 2
values |
|---|---|
import std.array;
import std.range;
import std.algorithm;
import std.conv;
import std.stdio;
import std.string;
void main(string[] args) {
string s = readln.chomp;
string[] words = ["dream", "dreamer", "erase", "eraser"];
bool ans = false;
loop: while (true) {
if (s.length <= 0) {
... | 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;
int r, b;
foreach (i; 0..n... | D |
import std.algorithm;
import std.array;
import std.range;
import std.conv;
import std.stdio;
import std.string;
import std.typecons;
alias FairyPos = Tuple!(int,int);
void main(){
auto inputs = readln.chomp.split.map!(to!int);
auto a = inputs[0];
auto b = inputs[1];
auto c = inputs[2];
string ans... | 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 adj = new int[][](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;
enum mod = 1_000_000_007L;
alias Edge = Tuple!(int, "to", int, "idx");
void main() {... | D |
import std.stdio;
import std.range;
import std.array;
import std.string;
import std.conv;
import std.typecons;
import std.algorithm;
import std.container;
import std.typecons;
import std.random;
import std.csv;
import std.regex;
import std.math;
import core.time;
import std.ascii;
import std.digest.sha;
import std.outb... | D |
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;
int[] di = [1, 1, -1, -1];
int[] dj = [1, -1, 1, -1];
void main() {
... | 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()
{
bool[string] c;
auto a = readln.chomp.split;
foreach (e; a) {
c[e] = true;
... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array;
void main() {
writeln(readln.chomp.group.canFind!"a[1] >= 3" ? "Yes" : "No");
}
void scan(T...)(ref T args) {
import std.stdio : readln;
import std.algorithm : splitter;
import std.conv : to;
import std.range.pr... | 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 |
// 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;
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; // ??\????????????????????????
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, 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, 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;
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 |
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.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.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 |
//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 |
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.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 |
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;
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;
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;
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 |
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.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;
/// [..)
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 |
/* 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;
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.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 |
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.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 = 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.algorithm;
import std.array;
import std.conv;
import std.math;
import std.range;
import std.stdio;
import std.string;
void main() {
auto s = readln.strip;
auto cl = s.count!"a == 'x'";
writeln (cl <= 7 ? "YES" : "NO");
}
| D |
void main(){
import std.stdio, std.string, std.conv, std.algorithm;
long l, r; rd(l, r);
writeln("YES");
for(auto i=l; i+1<=r; i+=2){
writeln(i, " ", i+1);
}
}
void rd(T...)(ref T x){
import std.stdio, std.string, std.conv;
auto l=readln.split;
assert(l.length==x.length);
foreach(i, ref e; x) e... | 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;
import std.conv;
import std.string;
import std.typecons;
import std.algorithm;
import std.array;
import std.range;
import std.math;
import std.regex : regex;
import std.container;
import std.bigint;
void main()
{
auto n = readln.chomp.to!int;
int sum;
foreach (i; 1..n+1) {
sum += i;
}
... | 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], d = rd[3];
writeln(max(0, min(b, d) - max(a, c)));
}
| 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(readln.chomp.to!int^^3);
}
| D |
import core.bitop;
import std.algorithm;
import std.ascii;
import std.bigint;
import std.conv;
import std.functional;
import std.math;
import std.numeric;
import std.range;
import std.stdio;
import std.string;
import std.random;
import std.typecons;
import std.container;
alias sread = () => readln.chomp();
ulong MOD =... | D |
import std.algorithm, 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 r; readV(r);
if (r < 1200)
... | D |
import std.stdio;
import std.conv;
void main()
{
char[] buf;
readln(buf);
for (int i = to!(int)(buf.length); i > 1; i--) {
write(buf[i-2]);
}
write("\n");
} | D |
/*
AOJ 0501 'Data Conversion'
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0501
*/
import std.stdio;
import std.array;
import std.range;
import std.conv;
import std.string;
import std.algorithm;
void main()
{
while(true)
{
int N = readln().chomp().to!int;
if(N == 0) break;
int[char] table;
... | 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;
immutable long MOD = 998244353;
void main() {
auto s = readln.split.map!(to!int);
auto N = s[0];
auto K = s[1]... | D |
import std.algorithm, std.conv, std.range, 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 readA(T)(size_t n,ref T t){t=new T(n);auto r=readln.splitter;foreach(ref v;t){v=r.front.to!(ElementType!T);r.popFront;}}
void readM(T...)(size_... | D |
import std.stdio, std.conv, std.functional, std.string;
import std.algorithm, std.array, std.container, std.range, std.typecons;
import std.bigint, std.numeric, std.math, std.random;
import core.bitop;
string FMT_F = "%.10f";
static File _f;
void file_io(string fn) { _f = File(fn, "r"); }
static string[] s_rd;
T _RD(... | D |
import std.conv;
import std.stdio;
import std.string;
void main()
{
auto nk = readln.split.to!( int[] );
auto as = readln.split.to!( int[] );
writeln( solve( nk[ 1 ], as ) );
}
auto solve( in int k, in int[] as )
{
auto as_r = as.length - k;
auto k_r = k - 1;
auto c = 1 + as_r / k_r;
auto re = ( as_r % k_r ==... | D |
import std.stdio;
import std.string;
import std.conv;
void main() {
string input = readln();
char a = input[0];
char b = input[1];
if(a == '9' || b == '9') {
"Yes".writeln;
} else {
"No".writeln;
}
}
| D |
import std.stdio;
void main() {
int n, k, s;
scanf("%d %d %d\n", &n, &k, &s);
if (s == 10^^9) {
foreach(_;0..n-k) {
write(1, " ");
}
foreach(_;0..k) {
write(10^^9, " ");
}
}
else {
foreach(_;0..n-k) {
write(s+1, " ");
}
foreach(_;0..k) {
write(s, " ");
}
}
}
| D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
void main() {
int a = to!int(chomp(readln()));
int b = to!int(chomp(readln()));
int h = to!int(chomp(readln()));
int surface = (a + b) * h / 2;
surface.writeln;
}
| D |
import std.stdio, std.conv, std.functional, std.string;
import std.algorithm, std.array, std.container, std.range, std.typecons;
import std.bigint, std.numeric, std.math, std.random;
import core.bitop;
string FMT_F = "%.10f";
static File _f;
void file_io(string fn) { _f = File(fn, "r"); }
static string[] s_rd;
T _RD(... | D |
void main(){
import std.stdio, std.conv, std.string, std.algorithm;
long n, a, b, k; rd(n, a, b, k);
const long mod=998244353;
const int M=1_000_00*4;
auto fact=new long[](M);
fact[0]=fact[1]=1;
foreach(i; 2..M) fact[i]=i*fact[i-1]%mod;
auto inv_fact=new long[](M);
long powmod(long a, long x){
i... | D |
import core.bitop, std.algorithm, std.ascii, std.bigint, std.conv, std.math,
std.functional, std.numeric, std.range, std.stdio, std.string, std.random,
std.typecons, std.container, std.format;
// dfmt off
T lread(T = long)(){return readln.chomp.to!T();}
T[] lreads(T = long)(long n){return generate(()=>readln.c... | D |
void main() {
int n = readln.chomp.to!int;
writeln(800 * n - n / 15 * 200);
}
import std.stdio;
import std.string;
import std.array;
import std.conv;
import std.algorithm;
import std.range;
import std.math;
import std.numeric;
import std.container;
import std.typecons;
import std.ascii;
import std.uni; | D |
import core.bitop, std.algorithm, std.ascii, std.bigint, std.conv, std.math,
std.functional, std.numeric, std.range, std.stdio, std.string, std.random,
std.typecons, std.container, std.format;
static import std.ascii;
// dfmt off
T lread(T = long)(){return readln.chomp.to!T();}
T[] aryread(T = long)(){return r... | D |
import core.stdc.stdio;
long gcd(long a,long b){
return b?gcd(b,a%b):a;
}
long lcd(long a,long b){
return a/gcd(a,b)*b;
}
void main(){
while(1){
int n;
scanf("%d",&n);
if(!n)
break;
auto p=new long[n],q=new long[n];
auto r=new int[n],b=new int[n],ic=new int[n];
foreach(i;0..n){
scanf("%lld%lld%d%d",&p... | D |
import core.bitop, std.algorithm, std.ascii, std.bigint, std.conv, std.math,
std.functional, std.numeric, std.range, std.stdio, std.string, std.random,
std.typecons, std.container;
// dfmt off
T lread(T = long)(){return readln.chomp.to!T();}
T[] aryread(T = long)(){return readln.split.to!(T[])();}
void scan(TL... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string;
void main()
{
readln;
auto s = readln.chomp;
string k;
string kk;
string l;
int p;
foreach (c; s) {
switch (c) {
case '(':
if (!p++) {
kk ~= k;
k = ... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math;
void main()
{
auto s = readln.chomp.to!(dchar[]);
s[3] = '8';
writeln(s);
} | D |
import std;
alias sread = () => readln.chomp();
alias lread = () => readln.chomp.to!long();
alias aryread(T = long) = () => readln.split.to!(T[]);
//aryread!string();
void main()
{
auto s = sread();
// writeln(s);
// writeln(s[0 .. (s.length) / 2]);
// writeln(s[(s.length) / 2 .. $]);
foreach (i; 2... | 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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.