code stringlengths 4 1.01M | language stringclasses 2
values |
|---|---|
import std.algorithm;
import std.array;
import std.bigint;
import std.bitmanip;
import std.conv;
import std.numeric;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
// 差の絶対値
@nogc @safe pure T diff(T)(const ref T a, const ref T b) { return a > b ? a - b : b - a; }
// 切り上げ除算
@nogc @safe pur... | D |
import std.stdio;
import std.conv;
import std.string;
import core.bitop;
void main() {
auto n = readln.chomp.to!uint;
if (n == 0) return;
writeln(1U << (n.bsr));
}
| D |
import std;
auto input()
{
return readln().chomp();
}
alias sread = () => readln.chomp();
void main()
{
string s = input();
long s_len = s.length;
//writeln(s);
//writeln(s_len);
writeln(s[0 .. ((s.length) - 8)]);
}
void scan(L...)(ref L A)
{
auto l = readln.split;
foreach (i, T; L)
... | D |
import std.stdio, std.string, std.conv;
void main() {
auto n = readln.chomp.to!int;
string[] result;
foreach (i; 0..n) {
result ~= readln.chomp.replace("Hoshino", "Hoshina");
}
foreach (r; result) r.writeln;
} | D |
import std.algorithm, std.container, std.conv, std.math, std.range, std.typecons, std.stdio, std.string;
void readV(T...)(ref T t){auto r=readln.splitter;foreach(ref v;t){v=r.front.to!(typeof(v));r.popFront;}}
void readA(T)(size_t n,ref T[]t){t=new T[](n);auto r=readln.splitter;foreach(ref v;t){v=r.front.to!T;r.popFro... | 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 K = s[0];
auto N = s[1];
auto A = readln.split.map!(... | D |
import std.stdio;
import std.conv;
import std.array;
void main()
{
int a = readln.split[0].to!int;
int b = readln.split[0].to!int;
int c = readln.split[0].to!int;
int d = readln.split[0].to!int;
int e = readln.split[0].to!int;
int k = readln.split[0].to!int;
if (e - a <= k){
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, 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;
enum L = 2001;
void main() {
int n;
scan(n);
auto s = r... | D |
// import chie template :) {{{
import std.stdio,
std.algorithm,
std.array,
std.string,
std.math,
std.conv,
std.range,
std.container,
std.bigint,
std.ascii;
// }}}
// tbh.scanner {{{
class Scanner {
import std.stdio;
import std.conv : to;
import std.ar... | 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;
alias Pair = Tuple!(int, "a", int, "b");
void main() {
... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto hw = readln.split.to!(int[]);
auto H = hw[0];
auto W = hw[1];
hw = readln.split.to!(int[]);
auto h = hw[0];
auto w = hw[1];
writeln(H*W - h*W - w*H + h*w);
} | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.range;
import std.traits;
import std.math;
import std.conv;
void main() {
auto S = readln.chomp;
S.check.writeln;
}
int check(string s) {
if(s.length & 1) s.popBack();
else { s.popBack; s.popBack; }
while(true) {
if(s[0..$ /... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array, std.math;
void main() {
int h, w;
scan(h, w);
auto ban = new char[][](h, w);
iota(h).each!(i => ban[i] = readln.chomp.to!(char[]));
auto cnt = new int[](26);
foreach (i ; 0 .. h) {
foreach (j ; 0 .. w... | D |
import std;
import core.bitop;
// dfmt off
ulong MAX = 100_100, MOD = 1_000_000_007, INF = 1_000_000_000_000;
alias sread = () => readln.chomp();
alias lread(T = long) = () => readln.chomp.to!(T);
alias aryread(T = long) = () => readln.split.to!(T[]);
void aryWrite(T = long)(T[] ary){ ary.map!(x => x.text()).join(' ')... | 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 |
void main() {
auto s = rs;
if(s.length == 2) writeln(s);
else writeln(s[2], s[1], s[0]);
}
// ===================================
import std.stdio;
import std.string;
import std.functional;
import std.algorithm;
import std.range;
import std.traits;
import std.math;
import std.container;
import std.bigint;
import s... | D |
void main(){
int k = _scan();
string s = readln().chomp();
if( s.length <= k ){
s.writeln();
return;
}else{
( s[0..k] ~ "..." ).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... | D |
import std.stdio, std.string;
void main()
{
readln.replace(",", " ").writeln;
}
| D |
import std.stdio, std.string, std.conv;
void main(){
auto ip = readln.split.to!(int[]);
if(ip[0] + ip[1] > ip[2] + ip[3]){
writeln("Left");
}else if(ip[0] + ip[1] < ip[2] + ip[3]){
writeln("Right");
}else{
writeln("Balanced");
}
} | 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 main(){
auto ip = readln.split.to!(int[]), a = ip[0], b = ip[... | 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;
void scan(T...)(ref T args) {
import std.stdio : readln;
import std.algorithm : splitter;
import std.conv : to;
import std.range.primiti... | D |
void main()
{
long n = rdElem;
string s = rdStr;
long[] r = new long[n+1], g = new long[n+1], b = new long[n+1];
foreach (i, x; s)
{
r[i+1] += r[i];
g[i+1] += g[i];
b[i+1] += b[i];
if (x == 'R') ++r[i+1];
if (x == 'G') ++g[i+1];
if (x == 'B') ++b[i+1... | D |
import std.algorithm;
import std.ascii;
import std.array;
import std.container;
import std.conv;
import std.numeric;
import std.stdio;
import std.string;
import std.typecons;
void log(A...)(A arg) {
stderr.writeln(arg);
}
int size(T)(in T s) {
return cast(int)s.length;
}
const int INF = 10000;
int op(char c,... | D |
import std.stdio;
void main() {
char b = 'a';
foreach(c; readln) {
if (b == c) {
write("Bad");
return;
}
b = c;
}
write("Good");
}
| 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()
{
int[4] s;
foreach (i; 0..3) {
auto d = readln.chomp.split.to!(int[]);
s[d[0... | 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[] args) {
string s = readln.chomp;
char[] st;
foreach(c; s){
if(c == 'T' && !st.empty && st.back == 'S'){
st.popBack();
... | D |
import std;
auto input()
{
return readln().chomp();
}
void main()
{
long x, y;
scan(x, y);
if (x % y == 0)
{
writeln(-1);
}
else
{
writeln(x);
}
}
void scan(L...)(ref L A)
{
auto l = readln.split;
foreach (i, T; L)
{
A[i] = l[i].to!T;
}
}
| D |
import std.stdio;
import std.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;
real[12][1<<12] dp;
int[] cakes;
int n;
real saiki(int u,int v){
if(dp[u][v] > 0) return dp[u][v];
if( u == ((1<<n) - 1... | D |
import core.bitop, std.bitmanip;
import core.checkedint;
import std.algorithm, std.functional;
import std.array, std.container;
import std.bigint;
import std.conv;
import std.math, std.numeric;
import std.range, std.range.interfaces;
import std.stdio, std.string;
import std.typecons;
void main()
{
auto s = readln.... | D |
import std.stdio;
import std.functional;
alias memoize!(c) cm;
ulong c(ulong n, ulong k){
if(k==0 || n==k) return 1;
return cm(n-1, k) + cm(n-1, k-1);
}
int main(){
auto s = readln;
ulong[char] maji;
foreach(i; 0..s.length-1){
maji[s[i]]++;
}
bool shinu = false;
foreach(i; maji){
if(i%2){
if(shinu){
... | D |
import std.conv, std.stdio;
import std.algorithm, std.array, std.range, std.string;
import std.numeric;
void main()
{
auto n = readln.chomp.to!ulong;
if (n & 1)
return 0.writeln;
n /= 2;
ulong ret;
while (n)
{
n /= 5;
ret += n;
}
ret.writeln;
}
| D |
import core.bitop;
import std.algorithm;
import std.ascii;
import std.bigint;
import std.conv;
import std.functional;
import std.math;
import std.numeric;
import std.range;
import std.stdio;
import std.string;
import std.random;
import std.typecons;
import std.container;
alias sread = () => readln.chomp();
long bignum... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.math;
import std.regex;
void main() {
auto N = readln.chomp.to!int;
int count;
foreach(_; 0..N) {
auto ip = readln.split.to!(int[]);
count += ip[1] - ip[0] + 1;
}
writeln(count);
} | D |
void main()
{
string s = rdStr;
string f(string x, dchar y)
{
string t;
long len = x.length.to!long - 1;
foreach (i; 0 .. len)
{
if (x[i] == y || x[i+1] == y) t ~= y;
else t ~= s[i];
}
return t;
}
long result = inf;
forea... | D |
import std.stdio, std.conv, std.string;
void main(){
auto ip = readln.split.to!(int[]);
if(ip[0] == 2 || ip[1] == 2){
writeln("No");
} else {
writeln("Yes");
}
} | D |
import std.stdio, std.algorithm, std.array, std.string, std.conv;
void main()
{
int t;
scanf("%d", &t);
getchar();
foreach(_; 0..t)
{
int n;
scanf("%d", &n);
getchar();
auto str1 = readln.strip();
auto str2 = readln.strip();
bool flag = true;
... | D |
import std.algorithm;
import std.array;
import std.ascii;
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 log(A...)(A arg) {
stderr.writeln(arg);
}
int size(T)(in T s) {
return cast(int)s.length;
}
voi... | D |
import std.stdio: writeln;
void main()
{
foreach(int i; 0 .. 1000)
{
writeln("Hello World");
}
} | D |
import std.algorithm;
import std.array;
import std.conv;
import std.math;
import std.numeric;
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() {
string s;
... | D |
// import chie template :) {{{
import std.stdio,
std.algorithm,
std.array,
std.string,
std.math,
std.conv,
std.range,
std.container,
std.bigint,
std.ascii;
// }}}
// tbh.scanner {{{
class Scanner {
import std.stdio;
import std.conv : to;
import std.ar... | D |
import std.stdio;
import std.string;
import std.array; // split
import std.conv; // to
void main()
{
string s = chomp(readln());
write("ABC");
writeln(s);
} | D |
import std.stdio;
void main() {
int n, m;
scanf("%d %d\n", &n, &m);
auto add = new int[n];
auto sub = new int[n];
foreach (i; 0..m) {
int l, r;
scanf("%d %d\n", &l, &r);
++add[l-1];
++sub[r-1];
}
int y, cnt;
foreach(i; 0..n) {
y += add[i];
if (y == m) ++cnt;
y -= sub[i];
}
cnt.write;
}
| 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() {
int N, M;
scan(N, M);
auto deg... | 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;
const long MOD = 998244353;
const long INF = 1L << 59;
void main() {
auto N = readln.chomp.to!int;
auto G = new int[]... | D |
void main(){
import std.stdio, std.string, std.conv, std.algorithm;
import std.array;
int n, m; rd(n, m);
auto g=new int[][](n, n);
foreach(_; 0..m){
int a, b; rd(a, b);
g[a-1][b-1]=g[b-1][a-1]=1;
}
auto v=new int[](0); v~=0;
auto usd=new bool[](n); usd[0]=true;
int f(int k){
if(k==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;
void main() {
int N;
scan(N);
auto row = new ... | D |
import std;
auto input()
{
return readln().chomp();
}
alias sread = () => readln.chomp();
alias aryread(T = long) = () => readln.split.to!(T[]);
void main()
{
long n, m;
scan(n, m);
auto ACしたか = new bool[](n + 1);
// ACしたか[n] = false;
// writeln(ACしたか);
auto 何回WAしたか = new long[](n + 1);
... | D |
import std.stdio;
import std.conv;
import std.string;
void main(){
auto A =readln.chomp.to!int;
if(A<1200){
"ABC".writeln;
}else{
"ARC".writeln;
}
} | D |
import std.stdio, std.array, std.string, std.conv, std.algorithm;
import std.typecons, std.range, std.random, std.math, std.container;
import std.numeric, std.bigint, core.bitop, core.stdc.stdio;
void main() {
auto T = readln.chomp.to!int;
auto cnt = new int[](10);
while (T--) {
cnt[] = 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, b, c; readV(a, b, c);
wri... | 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.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() {
long k, a, b;
scan(k, a, b);
if (b - a <=... | D |
void main()
{
string s = readln.chomp;
string t = "keyence";
bool ok;
foreach (i; 0 .. 8)
{
if (s[0..i] == t[0..i] && s[$-7+i..$] == t[i..$])
{
ok = true;
}
}
writeln(ok ? "YES" : "NO");
}
import std.stdio;
import std.string;
import std.array;
import st... | 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 |
void main()
{
int n = readln.chomp.to!int;
int[] a = readln.split.to!(int[]);
int cnt;
foreach (x; a)
{
while (x % 2 == 0)
{
x /= 2;
++cnt;
}
}
cnt.writeln;
}
import std.stdio;
import std.string;
import std.array;
import std.conv;
import std... | 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 |
/* 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.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
auto rd = readln.split.to!(int[]), n = rd[0], a = rd[1], b = rd[2];
writeln(min(a*n, b));
}
| D |
import std.stdio;
import std.string;
import std.conv;
void main() {
string[] inputs = split(readln());
int A = to!int(inputs[0]);
int B = to!int(inputs[1]);
if(A == B) "Draw".writeln;
else if(A == 1 && B > 1) "Alice".writeln;
else if(B == 1 && A > 1) "Bob".writeln;
else if(A > B) "Alice".writeln;
else "Bob".wr... | 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;
void main() {
auto N = readln.chomp.to!long;
if (N <= 2) {
writeln("No");
... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.range, std.string, std.math, std.typecons;
void main()
{
auto nm = readln.split.to!(long[]);
auto N = nm[0];
auto M = nm[1];
long ret;
if (N == 1 && M == 1) {
ret = 1;
} else if (N == 1) {
ret = M - 2;
} else if (M =... | D |
import std;
alias sread = () => readln.chomp();
alias lread = () => readln.chomp.to!long();
alias aryread(T = long) = () => readln.split.to!(T[]);
void main()
{
long a, b, c;
scan(a, b, c);
long max_x = max(a, b, c);
long sum_x = a + b + c;
long x, y;
if (((max_x % 2 == 0) && (sum_x % 2 == 0))... | 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 = 100_100, MOD = 1_000_000_007, INF = 1_000_000_000_000;
alias sread = () => readln.chomp();
alias lread(T = long) = () ... | D |
import std;
import core.bitop;
ulong MAX = 100_100, MOD = 1_000_000_007, INF = 1_000_000_000_000;
alias sread = () => readln.chomp();
alias lread(T = long) = () => readln.chomp.to!(T);
alias aryread(T = long) = () => readln.split.to!(T[]);
alias Pair = Tuple!(long, "x", long, "c");
alias PQueue(T, alias less = "a>b") ... | D |
import std.stdio;
import std.conv;
import std.array;
void main()
{
int[] T = new int[5];
foreach (i; 0..5){
T[i] = readln.split[0].to!int;
}
int ans = 0;
int minMod = 0;
foreach (t; T){
if (t % 10 == 0){
ans += t;
} else {
if (minMod == 0 || t % ... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto ab = readln.split.to!(int[]);
writeln(ab[0] * ab[1]);
} | D |
void main(){
int[] hen = _scanln();
(hen[0]*hen[1]/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 ... | D |
import std.stdio;
import std.string;
import std.conv;
void main() {
// input
int n = to!int(readln.chomp);
int k = to!int(readln.chomp);
int[] x, y;
x.length = y.length = k;
for(int i=0; i<k; ++i) {
auto temp = readln.split;
x[i] = to!int(temp[0]);
y[i] = ... | D |
import std.stdio, std.string, std.conv;
import std.typecons;
import std.algorithm, std.array, std.range, std.container;
import std.math;
void main() {
auto N = readln.split[0].to!int;
foreach (n; 1 .. 10) {
if (N <= n*111) { writeln(n*111); return; }
}
} | D |
import std.stdio;
import std.conv;
import std.string;
import std.format;
void main()
{
string s = chomp(readln());
int min = to!int(s.split(" ")[0]);
int max = to!int(s.split(" ")[1]);
int val = to!int(s.split(" ")[2]);
int result = 0;
for (int i = min; i <= max; i++ ) {
if (val % i == 0) {
res... | D |
import std.stdio: writeln, writefln, readln;
import std.array: array, split;
import std.algorithm: map;
import std.string: chomp;
import std.conv: to;
void main() {
int[3][3] bingo;
foreach(byte i; 0..3) {
int[] input = readln.split.map!(to!int).array;
foreach(int j; 0..3)
bingo[i][j] = input[j];
}
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.string, std.range, std.conv, std.algorithm;
void main(){
int s;
foreach (i; 0..5) {
s += max(readln.chomp.to!int, 40);
}
writeln(s / 5);
} | D |
import core.bitop;
import std.algorithm;
import std.array;
import std.ascii;
import std.container;
import std.conv;
import std.format;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
void main()
{
string s = readln.chomp;
string t = readln.chomp;
string ans = '~'.repe... | D |
import std.stdio;
import std.string;
import std.conv;
void main() {
int R = to!int(chomp(readln()));
int G = to!int(chomp(readln()));
// (R + P)/2 = G
// R + P = 2G
// P = 2G - R
writeln(2*G - R);
}
| D |
void main(){
int[] abc = _scanln();
writeln(abc.count(5)==2 && abc.count(7)==1? "YES": "NO");
}
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; re... | D |
/+ dub.sdl:
name "A"
dependency "dcomp" version=">=0.6.0"
+/
import std.stdio, std.algorithm, std.range, std.conv, std.string;
// import dcomp.foundation, dcomp.scanner;
int main() {
Scanner sc = new Scanner(stdin);
string s;
sc.read(s);
if (s.startsWith("YAKI")) {
writeln("Yes");
... | D |
import std.stdio, std.range, std.conv, std.string;
import std.algorithm.comparison, std.algorithm.iteration, std.algorithm.mutation, std.algorithm.searching, std.algorithm.setops, std.algorithm.sorting;
void main()
{
long s = readln().strip.to!(long);
long[] list;
list ~= s;
while(1)
{
auto... | D |
import std.stdio, std.string, std.conv, std.range, std.algorithm;
void main() {
auto N = readln.chomp.to!int;
auto K = readln.chomp.to!int;
auto X = readln.chomp.to!int;
auto Y = readln.chomp.to!int;
if (N < K) {
writeln(N * X);
} else {
writeln(K * X + (N - K) * Y);
}
}
| D |
void main() {
string s = readln.chomp;
string t = readln.chomp;
bool ok;
foreach (i; 0 .. s.length) {
if (s == t) ok = true;
s = s[$-1] ~ s[0..$-1];
}
writeln(ok ? "Yes" : "No");
}
import std.stdio;
import std.string;
import std.array;
import std.conv;
import std.algorithm;
impo... | D |
// Vicfred
// https://atcoder.jp/contests/abc045/tasks/arc061_a
// brute force, bitmask
import std.algorithm;
import std.array;
import std.conv;
import std.stdio;
import std.string;
void main() {
string s = readln.strip;
const long n = s.length;
long ans = 0;
for(int bit = 0; bit < (1 << n - 1); bit+... | 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 a, b;
scan(a, b);
if (a + b == 15) {
writeln("+");
}
else if (a * b == 15) {
writeln("*");
}
else {... | 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() {
long x;
scan(x);
auto ans = (x / 500) * 1000 + ((x % 500)... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string;
void main()
{
auto line = readln.split;
auto a = line[0].to!long;
auto b = line[2].to!long;
writeln(line[1] == "+" ? a + b : a - b);
} | D |
import std.stdio;
import std.string;
string toSwapCase(string s) {
if (s == s.toLower) {
return s.toUpper;
}
if (s == s.toUpper) {
return s.toLower;
}
return s;
}
void main() {
auto str = readln;
foreach (ch; str.split("")) {
write(toSwapCase(ch));
}
} | D |
import std.algorithm, std.container, std.conv, std.math, std.range, std.typecons, std.stdio, std.string;
void readV(T...)(ref T t){auto r=readln.splitter;foreach(ref v;t){v=r.front.to!(typeof(v));r.popFront;}}
void main()
{
int n; readV(n);
auto l = new long[](n+1);
l[0] = 2; l[1] = 1;
foreach (i; 2..n+1) l[i... | D |
import std.stdio;
import std.uni;
import std.conv;
import std.container;
import std.functional;
import std.algorithm;
import std.array;
import std.typecons;
import std.range;
import std.numeric;
import std.traits;
long pmod(long a, long m)
{
if (a < 0) return (a % m) + m;
return a % m;
}
void main(string[] args)
... | D |
/+ dub.sdl:
name "A"
dependency "dunkelheit" version=">=0.9.0"
+/
import std.stdio, std.algorithm, std.range, std.conv;
// import dkh.foundation, dkh.scanner;
int main() {
Scanner sc = new Scanner(stdin);
scope(exit) assert(!sc.hasNext);
int h, w;
sc.read(h, w);
bool[][] g = new bool[][]... | 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() {
writeln(canFind(rs, "AC") ? "Yes" : "No");
}
// ===================================
import std.stdio;
import std.string;
import std.functional;
import std.algorithm;
import std.range;
import std.traits;
import std.math;
import std.container;
import std.bigint;
import std.numeric;
import std.conv;
impor... | 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 readC(T...)(size_t n,ref T t){foreach(ref v;t)... | 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;
void scan(T...)(ref T args) {
import std.stdio : readln;
import std.algorithm : splitter;
import std.conv : to;
import std.range.primiti... | D |
import std.stdio, std.string, std.conv;
import std.algorithm, std.array;
auto solve(string s_) {
auto NT = s_.split.map!(to!int)();
immutable N=NT[0], T=NT[1];
auto A = readln.split.map!(to!int).array();
int m=0,d=0,nl=0, nr=0, n=0, nm=0;
foreach_reverse(v;A) {
if(v>m) m=v,++n,nm=1;
... | 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);
if (n <= 999) {
writeln("ABC");
}
else {
writeln("ABD");
}
}
... | 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() {
string s;
scan(s);
auto ok = iota(3).all!(i => s[i] == s[... | D |
import std.stdio, std.string, std.conv;
import std.array, std.algorithm, std.range;
void main()
{
string s;
do{
char[][] m;
while((s=readln()).chomp().length) m~=s.chomp().to!(char[]);
void update(int x, int y)
{
if(x<0 || m.length<=x || y<0 || m[x].length<=y)
... | D |
/+ dub.sdl:
name "C"
dependency "dunkelheit" version=">=0.9.0"
+/
import std.stdio, std.algorithm, std.range, std.conv;
// import dkh.foundation, dkh.scanner;
int main() {
Scanner sc = new Scanner(stdin);
scope(exit) assert(!sc.hasNext);
int n, m;
sc.read(n, m);
int a, b; //a : <>, b : ^v... | 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;
import std.string;
import std.typecons;
import std.algorithm;
import std.array;
import std.range;
import std.math;
import std.regex : regex;
import std.container;
import std.bigint;
void main()
{
auto s = new string[](3);
foreach (i; 0..3) {
s[i] = readln.chomp;
}
auto i... | D |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.