code stringlengths 4 1.01M | language stringclasses 2
values |
|---|---|
import std.stdio, std.array, std.conv, std.algorithm, std.string, std.numeric, std.range;
void main() {
auto n = readln.strip.to!int;
foreach(i; 0..n){
readln.chomp.replace("Hoshino", "Hoshina").writeln();
}
} | 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];
int r;
while (N) {
++r;
N /= K;
}
writeln(r);
} | 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()
{
readln;
auto p = readln.chomp.split.map!(to!int).array;
int cnt;
foreach (i; 0... | D |
import std.stdio;
import std.string;
import std.conv;
immutable MAX_INPUT = 1000;
immutable MAX_COUNT = 1000;
int main(string[] argv)
{
int Count;
string[] Ans;
Count = readln().chomp().to!int();
if(Count <= MAX_COUNT){
for(int i = 0;i < Count;i++){
string[] tmp = readln().chomp().split(" ");
int[3] ... | 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 |
void main() {
auto N = ri, A = ri;
(N % 500 <= A ? "Yes" : "No").writeln;
}
// ===================================
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.range;
import std.traits;
import std.math;
import std.bigint;
import std.numeric;
import std.conv;
import std.type... | 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 |
//dlang template---{{{
import std.stdio;
import std.conv;
import std.string;
import std.array;
import std.algorithm;
import std.typecons;
import std.math;
import std.range;
// MIT-License https://github.com/kurokoji/nephele
class Scanner
{
import std.stdio : File, stdin;
import std.conv : to;
import std.array : ... | 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.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.... | 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.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;
import std.conv;
import std.math;
import std.range;
import std.stdio;
import std.string;
void main ()
{
auto tests = readln.strip.to !(int);
foreach (test; 0..tests)
{
auto s = readln.strip;
int res = s.length.to !(int);
int a = 0, b = 0;
foreach (c; s)
{
if (c == 'A')
{
a ... | 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;
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();
long ok = (N + 1);
long ng = -1;
while... | 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.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;
if (n[0] == n[2]) {
writeln("Yes");
} else {
writ... | D |
import std.stdio;
import std.conv;
import std.array;
void main()
{
auto reader = readln.split;
int A = reader[0].to!int;
int B = reader[1].to!int;
int C = reader[2].to!int;
if ((A < C && C < B) || (A > C && C > B)) writeln("Yes");
else writeln("No");
}
| 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, core.stdc.stdio;
void main() {
auto s = readln.split.map!(to!int);
auto N = s[0];
auto M = s[1];
auto edges = new int[][](N... | 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, 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;
void main() {
auto S = readln.chomp;
auto N = S.length.to!int;
int ans = 0;
for (int p = 0, q = N-1; p < q; ) {
if ... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.math : abs;
import core.stdc.stdlib : exit;
void main()
{
auto A = to!int(split(readln())[0]);
auto B = to!int(split(readln())[0]);
auto C = to!int(split(readln())[0]);
auto D = to!int(split(readln())[0]);
writeln( (A < B ? A... | D |
void main() {
import std.stdio, std.string, std.conv, std.algorithm;
int n;
rd(n);
auto s = new char[][](2, n);
foreach (i; 0 .. 2)
s[i] = readln.chomp.to!(char[]);
const long mod = 10 ^^ 9 + 7;
auto dp = new long[][](2, n);
if (s[0][0] == s[1][0])
dp[0][0] += 3;
else
dp[1][1] += 6;
fo... | D |
void main() {
import std.stdio, std.string, std.conv, std.algorithm;
int n;
rd(n);
if (n % 3 < 2) {
writeln(1, " ", 1, " ", n - 2);
} else {
writeln(1, " ", 2, " ", n - 3);
}
}
void rd(T...)(ref T x) {
import std.stdio, std.string, std.conv;
auto l = readln.split;
assert(l.length == x.lengt... | 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.string, std.conv, std.algorithm;
int n;
rd(n);
auto a = new int[](n);
foreach (i; 0 .. n)
rd(a[i]);
bool[int] map;
foreach (e; a) {
if (e in map)
map.remove(e);
else
map[e] = true;
}
writeln(map.length);
}
void rd(T...)(ref T x) {
import... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
void main() {
auto s = readln.chomp;
auto y = new int[s.length];
int begin, i;
char mode = 'R';
foreach(c; s) {
if (c != mode && mode == 'R') {
y[i-1] += (i-begin+1)/2;
y[i] += (i-begin+1)/2 + (i-begin+1)%2;
begin = i;
mode ... | 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.algorithm;
void main() {
int n;
scanf("%d\n", &n);
int incl, lb, ra, half;
for(size_t i;i < n; ++i){
auto l = readln.chomp;
incl += l.count("AB");
auto b = l[0] == 'B';
auto a = l[$-1] == 'A';
if (a) ++ra;
if (b) ++lb;
if ((a || b) && (a != b)) ++half;
... | D |
void main() {
import std.stdio, std.string, std.conv, std.algorithm;
int n;
rd(n);
auto a = readln.split.to!(int[]);
int o, t, f;
foreach (e; a) {
if (e % 4 == 0)
f++;
else if (e % 2 == 0)
t++;
else
o++;
}
t %= 2;
o += t;
if (o <= f + 1) {
writeln("Yes");
} else... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
char[] r;
foreach (c; readln.chomp) {
if (c == '?') {
r ~= 'D';
} else {
r ~= c;
}
}
writeln(r);
} | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto X = readln.chomp.to!int;
writeln(X == 7 || X == 5 || X == 3 ? "YES" : "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()
{
string s; readV(s);
auto r = 10... | D |
import std.stdio;
import std.range;
import std.array;
import std.algorithm;
import std.string;
void main(){
auto input_1 = readln.chomp;
auto input_2 = readln.chomp;
auto input_3 = readln.chomp;
auto answer = "" ~ input_1[0] ~ input_2[1] ~ input_3[2];
writeln(answer);
} | 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 |
void main() {
import std.stdio, std.string, std.conv, std.algorithm;
int q;
rd(q);
while (q--) {
long n, a, b;
rd(n, a, b);
auto ans = n * a;
if (n & 1) {
ans = min(ans, n / 2 * b + a);
} else {
ans = min(ans, n / 2 * b);
}
writeln(ans);
}
}
void rd(T...)(ref T x) {
... | 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 n, m;
scan(n, m);
auto 杯 = new long[](n);
杯[] = 1;
... | D |
import std.stdio;
import std.string;
void main(){
writeln(toUpper(chomp(readln())));
} | D |
import std.stdio;
void main()
{
foreach (i; 0..1000) {
writeln("Hello World");
}
} | D |
import std.stdio;
import std.range;
import std.array;
import std.algorithm;
import std.string;
import std.conv;
void main(){
immutable n = readln.chomp.to!int;
auto d_x = readln.chomp.split.map!(to!int);
auto days = d_x[0];
auto rest = d_x[1];
int[] as;
as.length = n;
as.each!((ref a){
... | 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[]),r=Q[0],g=Q[1],b=Q[2];
if((100*r+10*g+b)%4==0)writeln("YES");
else writeln("NO");
} | D |
import std.stdio, std.conv, std.string, std.algorithm, std.range;
void main() {
auto N = readln.split[0].to!int;
auto A = readln.split.to!(int[]);
auto B = readln.split.to!(int[]);
auto C = readln.split.to!(int[]);
int result = 0;
int before = -1;
foreach(a; A) {
result += B[a - 1];
if (before !... | 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() {
auto s = readln.chomp.to!(char[]);
int k;
scan(k);
in... | D |
import std.stdio;
void main() {
writeln("ABC" ~ readln());
}
| D |
import std.stdio, std.conv, std.functional, std.string;
import std.algorithm, std.array, std.container, std.range, std.typecons;
import std.numeric, std.math, std.random;
import core.bitop;
string FMT_F = "%.10f";
static string[] s_rd;
T RD(T = long)() { while(!s_rd.length) s_rd = readln.chomp.split; string res = s_r... | D |
import std.stdio, std.conv, std.string, std.algorithm, std.array;
void main()
{
int n, m;
scanf("%d %d", &n, &m);
int[] map;
map.length=n;
for (int i = 0; i < m; i++) {
int from, to;
scanf("%d %d", &from, &to);
from--;
... | 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;
void main() {
auto S = readln.chomp;
auto K = readln.chomp.to!int;
auto N = S.length.to!int;
auto dp = new... | 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.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 s) {
... | 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, t; readV(a, b, t);
wri... | D |
void main()
{
long n = rdElem;
void dfs(string s, long len, long cnt)
{
if (len == n)
{
s.writeln;
return;
}
foreach (i; 0 .. cnt+2)
{
long num = max(cnt, (s[len-1] - 'a') + 1);
if (i <= num) dfs(s~lowercase[i], len+1,... | 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 c1 = s... | D |
import std.algorithm, std.container, std.conv, std.math, std.range, std.typecons, std.stdio, std.string;
struct Spl{auto r="".splitter;auto rd(){r=readln.splitter;}auto bd(T)(ref T t){t=r.front.to!T;r.popFront;}}
auto _s = Spl();
auto getV(T...)(ref T t){foreach(ref u;t)_s.bd(u);}
auto getA(T)(size_t n,ref T t){t=new ... | D |
import std.stdio, std.string, std.algorithm, std.array;
void main()
{
int t;
scanf("%d", &t);
getchar();
foreach(i; 0..t){
int n, s;
scanf("%d %d", &n, &s);
auto num_zero = (n - 1) / 2;
writeln(s / (n - num_zero));
}
}
| 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.conv, std.string, std.array, std.math, std.regex, std.range, std.ascii;
import std.typecons, std.functional, std.traits;
import std.algorithm, std.container;
import core.stdc.stdlib;
void main()
{
auto M = scanElem;
auto K = scanElem;
if(K >= pow(2, M)){
writeln(-1);
... | D |
import std.stdio, std.conv, std.array,std.string,std.algorithm;
void main()
{
auto input=readln.split;
writeln(max(input[0].to!int*input[1].to!int,input[2].to!int*input[3].to!int));
} | D |
void main()
{
long[] tmp = readln.split.to!(long[]);
long x = tmp[0], y = tmp[1];
writeln(log2(y/x).to!long + 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... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric, std.container, std.range;
enum P = 10L^^9+7;
void main()
{
auto N = readln.chomp.to!int;
auto DP = new long[][](N+1, 4);
DP[0][0] = 1;
foreach (i; 0..N) {
(DP[i+1][0] += DP[i][0] * 8 % P) %= ... | D |
/+ dub.sdl:
name "A"
dependency "dcomp" version=">=0.4.0"
+/
import std.stdio, std.range, std.algorithm, std.conv;
import core.bitop;
// import dcomp.scanner;
void main() {
auto sc = new Scanner(stdin);
int n;
sc.read(n);
int[][] g = new int[][](n);
foreach(i; 0..n-1) {
int a, b;
... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons;
void main()
{
auto abc = readln.split.to!(int[]);
writeln(abc[2] <= abc[0] + abc[1] ? "Yes" : "No");
} | 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 tokens = split(my_readln());
auto X = to!ulong(tokens[0]);
auto Y = to!ulong(tokens[1]);
writeln(X + Y / 2);
std... | D |
import std;
bool calc(int k, int a, int b) {
for (int i = 0; i <= b; i++) {
auto x = i * k;
if (a <= x && x <= b) return true;
}
return false;
}
void main() {
int k; scan(k);
int a, b; scan(a, b);
writeln(calc(k, a, b) ? "OK" : "NG");
}
void scan(T...)(ref T a) {
string[] ... | 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() {
int a, b;
scan(a);
scan(b);
writeln(6 ... | D |
import core.bitop;
import std.algorithm;
import std.ascii;
import std.bigint;
import std.conv;
import std.functional;
import std.math;
import std.numeric;
import std.range;
import std.stdio;
import std.string;
import std.random;
import std.typecons;
import std.container;
alias sread = () => readln.chomp();
alias Point... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto l = readln.split.to!(int[]);
auto H = l[0];
auto W = l[1];
auto A = l[2];
auto B = l[3];
char[][] R;
R.length = H;
foreach (h; 0..H) {
foreach (w; 0..W) {
... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto nx = readln.split.to!(int[]);
auto N = nx[0];
auto X = nx[1];
int r = 1, d;
foreach (l; readln.split.to!(int[])) {
d += l;
if (d > X) break;
++r;
}
... | D |
import std.stdio, std.string;
void main(){
auto s = readln().chomp();
if( s.length == 4 && s[1]==s[2] &&
(s[0] == s[1] || s[2] == s[3]))
writeln("Yes");
else writeln("No");}
| D |
import std.stdio;
import std.range;
import std.array;
import std.functional;
import std.algorithm;
import std.conv;
import std.container;
import std.math;
import std.numeric;
import std.string;
bool[11] vars;
string input;
bool check() {
string[] eq = input.split("=");
bool val(string s) {
int index =... | 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+110)... | 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 s... | D |
import std.stdio;
import std.algorithm;
import std.conv;
import std.math;
import std.string;
void main()
{
uint ans = 0 - 1;
int[] a = readln.split.to!(int[]);
foreach (i; 0..3){
foreach (j; 0..3) {
foreach (k; 0..3) {
int t_ans = 0;
if (i == j || j == ... | D |
// unihernandez22
// https://atcoder.jp/contests/abc076/tasks/abc076_c
// string manipulation
import std.stdio;
import std.string;
void main() {
string s = readln.chomp;
string t = readln.chomp;
long idx = -1;
bool matched;
for(long i = (s.count-t.count); i >= 0; i--) {
if (s[i] == '?' || s[i] == t[0]) {
mat... | D |
import std.stdio;
import std.algorithm;
import std.string;
import std.conv;
import std.math;
void main(){
int ans = 0;
while(true){
auto s = readln();
if(stdin.eof()) break;
s = chomp(s);
for(int i=0;i<s.length;i++){
char c = s[i];
if('1' <= c && c <= '9' ){
int temp = 0;
while('0' <= s[i+te... | D |
import std.stdio, std.conv, std.string, std.math, std.regex, std.range, std.ascii, std.algorithm;
void main(){
auto N = readln.chomp.to!int;
auto S = readln.chomp.to!(char[]);
auto K = readln.chomp.to!int;
char C = S[K-1];
foreach(i; 0..N){
if(S[i] != C){
S[i] = '*';
}
}
writeln(S);
} | D |
import std.stdio;
import std.string;
import std.conv;
void main() {
string input;
const string[] classBoxing = ["light fly", "fly", "bantam", "feather", "light", "light welter", "welter", "light middle", "middle", "light heavy", "heavy"];
while ((input = readln.chomp).length != 0) {
double weigh... | D |
import std.algorithm,
std.string,
std.range,
std.stdio,
std.conv;
void main() {
int N = readln.chomp.to!int,
K = readln.chomp.to!int,
X = readln.chomp.to!int,
Y = readln.chomp.to!int;
int ans;
if (N <= K) {
ans = N * X;
} else {
int cost1 = K * X,
... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons;
void main()
{
writeln(readln.chomp.to!int ^^ 2 - readln.chomp.to!int);
} | D |
import std.stdio;
import std.range;
import std.array;
import std.algorithm;
import std.string;
import std.conv;
import std.typecons;
import std.math;
void main(){
string s = readln().chomp();
string t = readln().chomp();
solve(s,t).writeln();
}
string solve(string s,string t){
string result;
string ... | 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;
void main(){
foreach(i;1..10)
foreach(j;1..10)
writeln(i,"x",j,"=",i * j);
} | D |
import std.stdio;
int main() {
for(int i=1; i<=9; i++) for(int j=1; j<=9; j++) printf("%dx%d=%d\n", i, j, i*j);
return 0;
} | D |
import std.stdio,std.string,std.conv;
int main()
{
string s;
while((s = readln.chomp).length != 0)
{
bool flag = true;
for(int i=0;i<7;i += 3)
{
if(s[i] != 's' && s[i] == s[i+1] && s[i+1] == s[i+2])
{
s[i].writeln;
flag = false;
break;
}
}
if(flag)
{
foreach(i;0..3)
{
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.regex : regex;
import std.container;
void main()
{
while (1) {
auto n = readln.chomp.to!int;
if (!n) break;
int[] list;
int cnt;
foreach... | 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.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;
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();
auto p = aryread();
// writeln(p);
aut... | 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;
import std.numeric;
class InputReader {
private:
ubyte[] p;
ubyte[] buffer;
size_t cur;
public:
this () {
... | D |
void main(){
import std.stdio, std.string, std.conv, std.algorithm;
auto s=readln.chomp.to!(char[]);
auto pat=['a', 'i', 'u', 'e', 'o'];
int tot=0;
foreach(char c; s){
if('0'<=c && c<='9'){
int x=c-'0';
if(x&1) tot++;
}else{
if(count(pat, c)>0) tot++;
}
}
writeln(tot);
}
... | 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!long).array;
auto B = s[0];
auto K = s[1];
auto A = readln.spl... | 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 = 998244353;
void main() {
auto S = readln.chomp;
auto N = S.length.to!int;
S ~= S;
char p... | 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(){
for(auto i =0; i< 10000;i++)
{auto it = raia();
if(it[0] == 0 && it[1] == 0){ return;}
else if( it[0] > it[1]){
writeln(it[1]," ",it[0]);
}else{
writeln(i... | D |
import std.algorithm;
import std.array;
import std.conv;
import std.stdio;
import std.string;
void main()
{
long n;
long sum;
n = readln.chomp.to!(long);
for (long i = 1; i <= n; i++) {
if (i % 15 == 0) {
continue;
}
if (i % 3 == 0) {
continue;
... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array, std.typecons;
import std.math, std.numeric;
void main() {
int n, m, k; scan(n, m, k);
foreach (i ; 0 .. n + 1) {
foreach (j ; 0 .. m + 1) {
if ((m - j)*i + (n - i)*j == k) {
writeln("Yes");
... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm;
void main() {
auto n = readln.split.join.to!int;
foreach (i ; 0 .. n) {
if (i*i > n) break;
if (i*i == n) {
writeln("Yes");
return;
}
}
writeln("No");
}
void scan(T...)(ref T arg... | D |
void main() {
int a = readln.chomp.to!int;
int b = readln.chomp.to!int;
int c = readln.chomp.to!int;
int x = readln.chomp.to!int;
int cnt;
foreach (i; 0 .. a+1) {
foreach (j; 0 .. b+1) {
int tmp = (x - 500 * i - 100 * j) / 50;
if (0 <= tmp && tmp <= c) ++cnt;
... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons;
void main()
{
writeln(readln.chomp.to!int <= 999 ? "ABC" : "ABD");
} | 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()
{
while (1) {
auto field = new char[14][14];
field[0][] = '0';
field[$-1][] = '0';
foreach (i; 1..13... | D |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.