code stringlengths 4 1.01M | language stringclasses 2
values |
|---|---|
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 |
/+ dub.sdl:
name "D"
dependency "dcomp" version=">=0.6.0"
+/
import std.stdio, std.algorithm, std.range, std.conv;
// import dcomp.foundation, dcomp.scanner;
// import dcomp.algorithm;
import std.typecons;
int main() {
auto sc = new Scanner(stdin);
int n;
sc.read(n);
alias Edge = Tuple!(int, ... | D |
void main() {
dchar[] s = readln.chomp.to!(dchar[]);
int cnt;
foreach (i; 1 .. s.length) {
if (s[i] == s[i-1]) {
if (s[i] == '1') s[i] = '0';
else s[i] = '1';
++cnt;
}
}
cnt.writeln;
}
import std.stdio;
import std.string;
import std.array;
import ... | D |
import std.stdio, std.conv, std.string, std.range, std.algorithm, std.array, std.functional;
void main() {
auto input = readln.split.to!(int[]);
auto N = input[0], K = input[1], Q = input[2];
auto A = new int[Q];
foreach(i; 0..Q) {
A[i] = readln.split[0].to!int - 1;
}
auto ps = new int[N];
ps[] = K;... | D |
void main()
{
writeln(180 * (readln.chomp.to!int - 2));
}
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;
alias sread = () => readln.chomp();
alias lread = () => readln.chomp.to!long();
alias aryread(T = long) = () => readln.split.to!(T[]);
void main()
{
long n;
scan(n);
auto a = aryread();
long cnt;
foreach (i; 0 .. n)
{
if ((i % 2 == 0) && (a[i] % 2 != 0))
cnt += ... | D |
void main() {
int[] tmp = readln.split.to!(int[]);
int a = tmp[0], b = tmp[1];
writeln(a <= b ? a : a - 1);
}
import std.stdio;
import std.string;
import std.array;
import std.conv;
import std.algorithm;
import std.range;
import std.math;
import std.numeric;
import std.container;
import std.typecons;
impor... | D |
import std.stdio, std.conv, std.functional, std.string;
import std.algorithm, std.array, std.container, std.range, std.typecons;
import std.bigint, std.numeric, std.math, std.random;
import core.bitop;
string FMT_F = "%.10f";
static File _f;
void file_io(string fn) { _f = File(fn, "r"); }
static string[] s_rd;
T _RD(... | D |
import std.stdio,
std.string,
std.conv;
R delegate(Args) Z(R, Args...)(R delegate(R delegate(Args), Args) f){
return (Args args) => f(Z(f), args);
}
void main() {
(N =>
(Fibonacci =>
Fibonacci(1, 1, N)
)(Z((ulong delegate(ulong, ulong, ulong)solver, ulong n1, ulong n2, ulong N) =>
... | 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.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.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, d, x; readV(r, d, x);
fo... | D |
import std.stdio;
import std.math;
import std.conv;
import std.string;
int solve(int x) {
return pow(x,3);
}
void main() {
writeln(solve(to!int(chomp(readln))));
} | D |
void main() {
long s = readln.chomp.to!long;
long x1 = 1L;
long x2 = 10L ^^ 9;
long y1 = (s + x2 - 1) / x2;
long y2 = x2 * y1 - s;
writeln(0, " ", 0, " ", x1, " ", y1, " ", x2, " ", y2);
}
import std.stdio;
import std.string;
import std.array;
import std.conv;
import std.algorithm;
import std... | D |
import std.stdio;
void main(string[] args) {
int done = 0;
string[6] data;
for (int i = 0; i < 6; i++)
{
data[i] = std.stdio.readln();
// data[i] = std.string.stripRight(data[i]);
}
int[][] cost = [
[ 3, 3, 0, 4, 4, 0, 3, 3 ],
[ 3, 3, 0, 4, 4, 0, 3... | D |
import std.stdio, std.conv, std.string, std.math, std.regex, std.range, std.ascii, std.algorithm;
void main(){
auto ip = readln.split.to!(int[]), A=ip[0], B=ip[1];
if(A<6) writeln(0);
else if(A<13) writeln(B/2);
else writeln(B);
} | D |
module main;
import core.stdc.stdio ;
int main()
{
int n,l,r,q,k=0,j=0,ans=0,low,mid,i;
scanf("%d", &q);
int [] a = new int[1000005];
for(i=0;i<q;i++)
{
scanf("%d:%d",&l,&r);
k=l*60+r;
a[k]++;
a[k+1440]++;
}
for(i=0;i<2879;i++){
if(a[i]==0) j++;
else {
... | D |
import std.algorithm;
import std.array;
import std.conv;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
int readint() {
return readln.chomp.to!int;
}
int[] readints() {
return readln.split.map!(to!int).array;
}
void main() {
auto xab = readints();
int x =... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto A = readln.chomp.to!int;
auto B = readln.chomp.to!int;
if (A + B == 5) {
writeln(1);
} else if (A + B == 4) {
writeln(2);
} else if (A + B == 3) {
writel... | 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.algorithm;
import std.conv;
import std.datetime;
import std.numeric;
import std.math;
import std.string;
string my_readln() { return chomp(readln()); }
void main()
{
auto N = to!ulong(my_readln());
auto tokens = split(my_readln());
auto T = to!long(tokens[0]);
auto A = to!long(tokens[... | D |
import std.stdio, std.string, std.conv;
import std.algorithm;
void main()
{
for(string t; (t=readln().chomp()).length;)
{
immutable N = t.length;
auto a = new int[26][N+1];
int s=-1, e=-1;
void solve()
{
foreach(int i,c;t)
{
immuta... | D |
import std.stdio, std.string, std.conv, std.algorithm, std.array;
struct P { int x, y; }
void main()
{
int[102][102] m;
auto f = readln.split.map!(to!int);
int W = f[0],
H = f[1];
foreach(i; 0 .. H)
{
foreach(j, n; readln.split.map!(to!int).array)
{
m[i + 1][j ... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math;
void main()
{
auto N = readln.chomp.to!int;
wchar[][] MAP;
MAP.length = N;
foreach (ref line; MAP) {
auto cs = readln.chomp.to!(wchar[]);
line = cs ~ cs;
}
int cnt;
foreach (o; 0..N) {
void ... | D |
import std.conv;
import std.stdio;
import std.array;
import std.range;
import std.string;
import std.algorithm;
void main()
{
switch(readln().chomp()) {
case "1 0 0" : writeln("Close"); break;
case "0 1 0" : writeln("Close"); break;
case "1 1 0" : writeln("Open"); break;
case "0 0 1" : writeln("Open"); break;
ca... | D |
import std.stdio, std.string, std.conv;
import std.array, std.algorithm, std.range;
void main()
{
for(;;)
{
string[] ss;
for(string t; (t=readln().chomp())!="" && t!="0 0"; ss~=t){}
if(ss.length==0) break;
int[] c = new int[3];
foreach(s;ss)
{
auto m ... | D |
import std.algorithm;
import std.conv;
import std.range;
import std.stdio;
import std.string;
bool ask (int x, int y)
{
writeln ("?", " ", x, " ", y);
stdout.flush ();
auto s = readln.strip;
if (s == "e")
{
assert (false);
}
return (s == "x");
}
void main ()
{
string s;
while ((s = readln.strip) != "")
{
... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto N = readln.chomp.to!int;
auto S = readln.chomp;
int min_l, max_l = N/2+1;
while (min_l+1 < max_l) {
auto l = (min_l + max_l) / 2;
int[string] memo;
bool ok;... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto S = readln.chomp.to!(char[]);
auto T = readln.chomp.to!(char[]);
auto N = S.length;
auto M = T.length;
foreach_reverse (i; 0..N-M+1) {
foreach (j; 0..M) {
if... | D |
import std.stdio;
import std.algorithm;
import std.string;
import std.functional;
import std.array;
import std.conv;
import std.math;
import std.typecons;
import std.regex;
import std.range;
void main(){
while(true){
auto temp = readln();
if(stdin.eof()) break;
auto s = split(temp).to!(int[]);
writeln(s[0]-s[... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
readln;
auto S = readln.chomp.to!(char[]);
auto K = readln.chomp.to!int;
auto c = S[K-1];
foreach (ref s; S) if (s != c) s = '*';
writeln(S);
} | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.array;
void main() {
string str = chomp(readln());
long n = to!long(str);
writeln(factrial(n));
}
long factrial(long n) {
if (n == 0) {
return 1;
} else {
return n * factrial(n-1);
}
} | D |
import std.stdio;
import std.string;
import std.conv;
import std.typecons;
import std.algorithm;
import std.functional;
import std.bigint;
import std.numeric;
import std.array;
import std.math;
import std.range;
import std.container;
void main() {
string[] input = readln.split;
int N = input[0].to!int;
int... | D |
import std.stdio;
import std.string;
import std.range;
import std.conv;
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.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];
auto min_i = 1, max_i = M;
auto mid_i = (min_i + max_i) / 2;
while (max_i - min_i > 1) {
mid_i = (min_... | D |
void main() {
/*auto S = rs, T = rs;
foreach(i; 0..S.length) {
string tmp = S[1..$];
tmp ~= S[0];
if(S == T) {
writeln("Yes");
return;
}
S = tmp;
}
writeln("No");*/
auto S = rs, T = rs;
S ~= S;
if(S.canFind(T)) writeln("Yes");
else writeln("No");
}
// ===================================
import... | D |
import std.stdio, std.string, std.array, std.conv, std.algorithm, std.typecons, std.range, std.container, std.math, std.algorithm.searching, std.functional,std.mathspecial;
void main(){
writeln(totalSum(readln.chomp));
}
long totalSum(string str){
long total=0;
foreach(i,s;str){
auto num=[s].to!lo... | D |
module aizu_online_judge;
import std.stdio;
int main(){
for(int i = 1; i <= 9; i++) {
for(int j = 1; j <= 9; j++) {
writeln(i, "x", j, "=", i * j);
}
}
return 0;
} | D |
void main() {
problem();
}
void problem() {
auto X = scan!long;
auto K = scan!long;
auto D = scan!long;
long solve() {
if (X < 0) X = -X;
auto times = X / D;
if (K < times) {
return X - D*K;
}
auto loopTimes = K - times;
if (loopTimes % 2 == 0) {
return X - D*times;
... | D |
import std.stdio;
import std.string;
void main() {
string s = chomp(readln());
string t = chomp(readln());
int ans = 0;
for (int i=0; i<s.length; i++) {
if (s[i] == t[i]) ans++;
}
writeln(ans);
} | 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;
void main() {
auto n = readln.strip.to!int;
Tuple!(string, int)[] a;
foreach (i; 0 .. n) {
auto s = readln.splitter;
auto z = s.front;
s.popFront ();
... | D |
import std.stdio;
void main() {
int r,g,b,n;
scanf("%d %d %d %d", &r, &g, &b, &n);
size_t total;
for (int i; i <= n; i += r) {
for (int j = i; j <= n; j += g) {
if ((n - j) % b == 0) ++total;
}
}
total.write;
}
| D |
import std.algorithm;
import std.conv;
import std.range;
import std.stdio;
import std.string;
import std.utf;
bool isGood (R) (R s)
{
int balance = 0;
foreach (c; s)
{
balance += c ? +1 : -1;
if (balance < 0)
{
return false;
}
}
return balance == 0;
}
void main ()
{
auto tests = readln.strip.to !(int... | D |
import std.algorithm;
import std.array;
import std.range;
import std.stdio;
import std.string;
string solve (string s, int i, int j, int n)
{
char [13] [2] res;
int loopLength = (j - i + 1) / 2;
while (i > 0)
{
s = s[1..$] ~ s[0];
i -= 1;
j -= 1;
}
debug {writeln (s, " ", i, " ", j);}
int mid = loopLengt... | 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 |
//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.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 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.range, std.array, std.conv, std.string, std.math, std.container, std.typecons;
void main() {
auto a = readln.chomp.to!int;
auto b = readln.chomp.to!int;
auto c = readln.chomp.to!int;
auto x = readln.chomp.to!int;
int cnt = 0;
foreach (i; 0..min(x/500,a)+1) {... | D |
import core.bitop;
import std.algorithm;
import std.ascii;
import std.bigint;
import std.conv;
import std.functional;
import std.math;
import std.numeric;
import std.range;
import std.stdio;
import std.string;
import std.random;
import std.typecons;
alias sread = () => readln.chomp();
alias Point2 = Tuple!(long, "y", ... | 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 |
// 10進数から26進数への基数変換と同様に考えれば良い
// 但し, 番号は1から始まるので注意
void main(){
long n = _scan!long();
string ans;
while(n>0){
int rem = (n%26==0)?26:n%26;
ans ~= ( ('a'-1) + rem );
n = (n -1)/26;
}
ans.retro.array.to!string.writeln();
}
import std.stdio, std.conv, std.algorithm, std.numeric, std.string, std.math, std.rang... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
int a, b;
foreach (c; readln.chomp) {
if (c == '0') {
++a;
} else {
++b;
}
}
writeln(min(a, b) * 2);
} | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto nl = readln.split.to!(int[]);
auto N = nl[0];
auto L = nl[1];
int s, e = int.max;
foreach (i; 0..N) {
s += L+i;
if (abs(L+i) < abs(e)) e = L+i;
}
wr... | D |
import std.stdio, std.conv, std.string, std.algorithm;
void main() {
uint n = readln.chomp.to!uint;
uint[] result;
foreach (i; 0..n) {
uint outNum = 0;
bool[3] fieldPlayer;
uint point = 0;
while (outNum < 3) {
auto str = readln.chomp;
if (str == "HIT") {
if (fieldPlayer[2]) point++;
fieldPla... | 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 arywrite(T=long)(T[] ary){ary.map!(text).join(' ').writeln;}
void scan(TList...)(ref TList Args){auto line =... | D |
void main() {
int d = readln.chomp.to!int;
string s = "Christmas";
string t = " Eve";
while (d < 25) {
s ~= t;
++d;
}
s.writeln;
}
import std.stdio;
import std.string;
import std.array;
import std.conv;
import std.algorithm;
import std.range;
import std.math;
import std.containe... | 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 as = readln.chomp.split.to!(int[]);
auto res =... | 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.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);
writeln("aei... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
int[26] CS;
void main()
{
auto S = readln.chomp.to!(char[]);
foreach (c; S) ++CS[c-97];
foreach (i, n; CS) {
if (!n) {
writeln(S ~ cast(char)(i+97));
return;
}
... | D |
void main(){
int n = _scan();
(n/2 +n%2).writeln();
}
import std.stdio, std.conv, std.algorithm, std.numeric, std.string, std.math;
// 1要素のみの入力
T _scan(T= int)(){
return to!(T)( readln().chomp() );
}
// 1行に同一型の複数入力
T[] _scanln(T = int)(){
T[] ln;
foreach(string elm; readln().chomp().split()){
ln ~= elm.to!T()... | 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.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);
auto m = n, s ... | D |
import std.stdio;
import std.string;
import std.array;
import std.range;
import std.algorithm;
import std.conv;
void main(string[] args) {
readln();
string input = readln().chomp;
int cur = 0;
int min = 0;
int e = 0;
foreach(c; input){
if(c == 'E'){e++; cur--;}
else{cur++;}
if(cur < min){min ... | D |
/* imports all std modules {{{*/
import
std.algorithm,
std.array,
std.ascii,
std.base64,
std.bigint,
std.bitmanip,
std.compiler,
std.complex,
std.concurrency,
std.container,
std.conv,
std.csv,
std.datetime,
std.demangle,
std.encoding,
std.exception,
std.file,
std.format,
std.functi... | D |
import core.bitop, std.algorithm, std.ascii, std.bigint, std.conv,
std.functional, std.math, std.numeric, std.range, std.stdio, std.string,
std.random, std.typecons, std.container;
ulong MAX = 1_000_100, MOD = 1_000_000_007, INF = 1_000_000_000_000;
alias sread = () => readln.chomp();
alias lread(T = long) = (... | 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.stdio;
import std.algorithm;
import std.string;
import std.conv;
void main() {
auto N = to!int(readln.chomp);
foreach (i; 0..N) {
auto input = readln.split.map!(to!int);
if (input[2] >= 5 && input[3] >= 2) {
writeln((input[0] * input[2] + input[1] * input[3]) * 4 / 5);
} else if (input[2] >= 5) {... | 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 |
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 path = new int[][](5, 5);
auto key = [' ', 'U', 'L', ' ', 'D', ' ', ' ', ' ', 'R'];
auto dx = [0, 0, -1,... | D |
import core.bitop, std.algorithm, std.ascii, std.bigint, std.conv,
std.functional, std.math, std.numeric, std.range, std.stdio, std.string,
std.random, std.typecons, std.container;
ulong MAX = 1_000_100, MOD = 1_000_000_007, INF = 1_000_000_000_000;
alias sread = () => readln.chomp();
alias lread(T = long) = (... | 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(){
string s = readln.chomp;
string ans;
if(s.length % 2){
if(s[0] == s[$ - 1]) ans = "Second"; // like "aba"
else ans = "First"; // like "acb"
}
else{
... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto N = readln.chomp.to!int;
foreach (i; 0..10) {
foreach (j; i..10) {
if (N == i*j) {
writeln("Yes");
return;
}
}
}
... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array;
void main() {
auto s = readln.split;
writeln(s[0][$-1] == s[1][0] && s[1][$-1] == s[2][0] ? "YES" : "NO");
}
void scan(T...)(ref T args) {
import std.stdio : readln;
import std.algorithm : splitter;
import std.c... | D |
import std;
void main() {
auto l = readln();
writeln(l.canFind('7') ? "Yes" : "No");
} | D |
import std.stdio, std.string, std.algorithm, std.functional;
void main() {
readln.chomp.map!(a => a=='p' ? -1:1).sum.pipe!"a/2".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_r... | D |
import std.stdio, std.conv, std.functional, std.string;
import std.algorithm, std.array, std.container, std.range, std.typecons;
import std.numeric, std.math, std.random;
import core.bitop;
string FMT_F = "%.10f";
static string[] s_rd;
T RD(T = long)() { while(!s_rd.length) s_rd = readln.chomp.split; string res = s_r... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons;
void main()
{
auto N = readln.chomp.to!int;
auto n = N;
int s;
while (n) {
s += n % 10;
n /= 10;
}
writeln(N % s ? "No" : "Yes");
} | D |
import std.stdio;
import std.conv;
import std.string;
void main() {
string[] input = split(readln());
int a = to!int(input[0])-1;
int b = to!int(input[1]);
int ans = 0;
int tap = 1;
while (tap < b) {
tap += a;
ans++;
}
writeln(ans);
} | 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()
{
dchar[] s; readV(s);
writeln(s.u... | 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); }
... | 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.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.conv;
import std.algorithm;
import std.range;
import std.string;
import std.typecons;
void main()
{
auto a = readln().strip;
auto b = readln().strip;
size_t sub = 0;
while (true)
{
sub = a.indexOf(b, sub);
if (sub == cast(size_t)-1)
{
... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.math;
void main() {
int x = readln.chomp.to!(int);
int[1001] arr;
for (int i = 1; i <= x; i++) {
for (int j = 2; j <= 100; j++) {
int t = pow(i, j);
if (t <= x) {
arr[i] =... | D |
import std.algorithm;
import std.stdio;
import std.string;
void main() {
bool[string] cups = ["A": true, "B": false, "C": false];
foreach (string line; stdin.lines) {
string[] cup = line.chomp.split(",");
swap(cups[cup[0]],cups[cup[1]]);
}
foreach (k; cups.keys) {
if (cups[k] == true) {
k.w... | D |
/+ dub.sdl:
name "C"
dependency "dcomp" version=">=0.7.4"
+/
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);
sc.read(a);
bool[] ok = new bool[1<<24];
ok[1] = true;... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto N = readln.chomp.to!int;
if (N == 1) {
writeln("Hello World");
} else {
auto A = readln.chomp.to!int;
auto B = readln.chomp.to!int;
writeln(A + B);
}... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto S = readln.chomp;
auto len = S.length;
if (len%2 == 1) {
writeln("No");
return;
}
foreach (i; 0..len/2) {
auto c = S[len-i-1];
switch (S[i]) {
... | D |
import std.stdio;
import std.string;
import std.conv;
import std.typecons;
import std.algorithm;
import std.functional;
import std.bigint;
import std.numeric;
import std.array;
import std.math;
import std.range;
import std.container;
import std.ascii;
void times(alias fun)(int n) {
foreach(i; 0..n) fun();
}
auto re... | 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[] aryread(T = long)(){return readln.split.to!(T[])();}
... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array, std.math;
long n, m;
void main() {
scan(n, m);
auto cmb = new long[][](n + 1, n + 1);
auto dp = new long[][](n + 1, n + 1);
foreach (i ; 0 .. n + 1) {
cmb[i][0] = cmb[i][i] = 1;
dp[i][0] = dp[i][i] = 1... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric, std.container, std.range;
void main()
{
auto S = readln.chomp;
writeln(S[$-1] == 's' ? S ~ "es" : S ~ "s");
} | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
void main() {
int[] buf = readln.chomp.split.to!(int[]);
int n = buf[0], k = buf[1];
int[] arr = readln.chomp.split.to!(int[]);
int ans = 0;
n -= 1;
while (n > 0) {
n -= k - 1;
ans++;
}
writeln... | D |
import std.stdio;
import std.string;
import std.conv;
import std.array;
import std.algorithm;
import std.range;
void main(){
auto N=readln.chomp.to!int;
if(N/10==9||N%10==9)writeln("Yes");
else writeln("No");
} | 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()
{
long n, k; readV(n, k);
auto x ... | D |
import std.stdio, std.string, std.array, std.conv;
long modexp(long x, long n) {
if (n == 0) return 1;
long mod = 1_000_000_007;
long result = modexp(x, n/2);
result = result * result % mod;
if (n % 2 == 1) result = result * x % mod;
return result;
}
void main() {
long[] tmp = readln.chomp... | D |
import std.stdio, std.array, std.string, std.conv, std.algorithm;
import std.typecons, std.range, std.random, std.math, std.container;
import std.numeric, std.bigint, core.bitop, core.stdc.string;
void main() {
auto s = readln.split.map!(to!int);
auto N = s[0];
auto Q = s[1];
auto st = new LazySegmentT... | D |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.