code stringlengths 4 1.01M | language stringclasses 2
values |
|---|---|
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric, core.bitop;
enum P = 998244353;
void main()
{
auto ns = readln.split.to!(long[]);
auto N = ns[0];
auto S = ns[1];
auto as = readln.split.to!(long[]);
auto DP = new long[][][](N+1, S+1, 2);
fo... | 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 |
import std.stdio, std.conv, std.string;
import std.array, std.range, std.algorithm, std.container;
import std.math, std.random, std.bigint, std.datetime, std.format;
string read(){ static string[] ss; while(!ss.length) ss = readln.chomp.split; string res = ss[0]; ss.popFront; return res; }
int DEBUG_LEVEL = 0;
void pr... | 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;
long calc(long[] a) {
if (a.any!(e => e == 0)) return 0;
long x = 1;
foreach (e; a) {
long y = x * e;
if (y < x) return -1; // overflow
if (y > 10L ^^ 18) return -1;
x = y;
}
return x;
}
void main() {
int n; scan(n);
auto a = reads!long;
wri... | 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.algorithm;
import std.conv;
import std.stdio;
import std.string;
void main()
{
auto hw = readln.split.map!( to!byte );
auto s = new string[ hw[ 0 ] ];
foreach( ref sl; s )
{
sl = readln.strip;
}
writeln( solve( hw[ 0 ], hw[ 1 ], s ) );
}
string solve( in byte h, in byte w, in string[] s )
{
for... | 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;
void main() {
int n... | 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.stdlib;
void main() {
auto s = readln.split.map!(to!long);
auto N = s[0];
auto A = s[1];
auto B = s[2];
auto C... | D |
void main()
{
long n, l;
rdVals(n, l);
long[] a = rdRow;
long idx;
bool ok;
foreach (i; 0.. n-1)
{
if (a[i] + a[i+1] >= l)
{
idx = i;
ok = true;
break;
}
}
if (!ok)
{
"Impossible".writeln;
return;
}... | 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() {
while (solve) {}
}
bool solve() {
auto s = readln.split.map!(to!int);
auto N = s[0];
auto M... | D |
/* imports all std modules {{{*/
import
std.algorithm,
std.array,
std.ascii,
std.base64,
std.bigint,
std.bitmanip,
std.compiler,
std.complex,
std.concurrency,
std.container,
std.conv,
std.csv,
std.datetime,
std.demangle,
std.encoding,
std.exception,
std.file,
std.format,
std.functi... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
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.algorithm;
import std.bigint;
import std.container;
import std.conv;
import std.functional;
import std.math;
import std.meta;
import std.random;
import std.range;
import std.stdio;
import std.string;
import std.traits;
import std.typecons;
long solve(string s, string t){
auto conn = new long[26][](s.le... | D |
void main()
{
long a, b;
rdVals(a, b);
writeln(a * b);
}
enum long mod = 10L^^9 + 7;
enum long inf = 1L << 60;
enum double eps = 1.0e-9;
T rdElem(T = long)()
if (!is(T == struct))
{
return readln.chomp.to!T;
}
alias rdStr = rdElem!string;
alias rdDchar = rdElem!(dchar[]);
T rdElem(T)()
if (is(T == ... | D |
void main()
{
long a, b, c;
rdVals(a, b, c);
writeln((a * b) >> 1);
}
enum long mod = 10^^9 + 7;
enum long inf = 1L << 60;
T rdElem(T = long)()
if (!is(T == struct))
{
return readln.chomp.to!T;
}
alias rdStr = rdElem!string;
alias rdDchar = rdElem!(dchar[]);
T rdElem(T)()
if (is(T == struct))
{
... | 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, 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 N = readln.chomp.to!int;
auto A = readln.split.map!(to!int).array;
auto odd = A.map!(a => a... | D |
import std.algorithm;
import std.array;
import std.ascii;
import std.bigint;
import std.complex;
import std.container;
import std.conv;
import std.functional;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
auto readInts() {
return array(map!(to!int)(readln().strip().split... | D |
import std.stdio;
import std.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.algorithm,
std.array,
std.conv;
void main(){
int[] ary = readln.split.to!(int[]);
ary = array(filter!("a != 5")(ary));
ary[0] == 7 && ary.length == 1 ? write("YES") : write("NO");
} | 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 |
void main()
{
string[] tmp = readln.split;
long n = tmp[0].to!long, k = tmp[1].to!long;
long[] d = readln.split.to!(long[]);
bool[] ok = new bool[10];
ok[] = true;
foreach (x; d)
{
ok[x] = false;
}
long okmin = ok.countUntil(true);
long len = tmp[0].length;
long[] m... | 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 |
/+ dub.sdl:
name "A"
dependency "dcomp" version=">=0.7.4"
+/
import std.stdio, std.algorithm, std.range, std.conv, std.math;
// import dcomp.foundation, dcomp.scanner;
// import dcomp.geo.primitive, dcomp.geo.circle;
int solve() {
alias C = Circre2D!double;
C[2] c;
foreach (i; 0..2) {
dou... | 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 |
/+ dub.sdl:
name "A"
dependency "dcomp" version=">=0.6.0"
+/
import std.stdio, std.algorithm, std.range, std.conv;
import std.typecons;
import std.bigint;
// import dcomp.foundation, dcomp.scanner;
// import dcomp.container.deque;
int main() {
auto sc = new Scanner(stdin);
int n, m, k;
sc.read(n... | 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.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.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 |
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;
void main(string[] args)
{
inputFile = stdin;
debug inputFile = File(args[1]);
auto t = next!int;
foreach(tc; 0 .. t... | 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 |
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.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;
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 |
import std;
void main(){
int n = readln.chomp.to!int;
long[] as = readln.chomp.split.to!(long[]);
int[long] ac;
long ans;
foreach(a; as){
if(a !in ac) ac[a] = 0;
ac[a] += 1;
ans += a;
}
int q = readln.chomp.to!int;
foreach(_; 0 .. q){
long[] bc = readln.chomp.split.to!(long[]);
... | D |
import std.stdio, std.string, std.conv, std.range;
void main() {
long mod = 1_000_000_007;
int[] tmp = readln.split.to!(int[]);
int n = tmp[0], m = tmp[1];
bool[] ok = true.repeat(n+2).array;
foreach (i; 0 .. m) {
int a = readln.chomp.to!int;
ok[a+1] = false;
}
long[] dp = n... | D |
import std.stdio, std.string, std.array, std.conv;
void main() {
int[] a;
int q = readln.chomp.to!int;
foreach (i; 0 .. q) {
int[] tmp = readln.chomp.split.to!(int[]);
if (tmp[0] == 0) {
a ~= tmp[1];
} else if (tmp[0] == 1) {
a[tmp[1]].writeln;
} else... | 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!(long[]);
auto N = nx[0];
auto x = nx[1];
auto as = readln.split.to!(long[]);
long[] bs;
foreach (a; as) bs ~= a;
long min_s = long.max;
foreac... | 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, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto hw = readln.split.to!(long[]);
auto H = hw[0];
auto W = hw[1];
if (H == 1 || W == 1) {
writeln(1);
} else if((H*W)%2 == 0) {
writeln(H*W/2);
} else {
... | 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 |
import std.stdio;
import std.algorithm;
import std.conv;
import std.string;
void main() {
auto n = readln.chomp.to!(long);
auto t = readln.split.to!(long[]);
auto m = readln.chomp.to!(long);
long[] p;
long[] x;
long s = sum(t);
foreach (i; 0..m){
auto px = readln.split.to!(ulong[])... | 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 readC(T...)(size_t n,ref T t){foreach(ref v;t)v=new typeof(v)(n);foreach(i;0..n){auto r=rdsp;foreach(ref v;t)pic... | D |
import std.stdio;
import std.algorithm;
import std.math;
import std.conv;
import std.string;
T readNum(T)(){
return readStr.to!T;
}
T[] readNums(T)(){
return readStr.split.to!(T[]);
}
string readStr(){
return readln.chomp;
}
void main(){
auto ap = readNums!int;
writeln((ap[0]*3+ap[1])/2);
}
| 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 bignu... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
int[101] T;
void main()
{
auto N = readln.chomp.to!int;
foreach (a; readln.split.to!(int[])) ++T[a];
size_t i;
for (;; ++i) {
if (T[i] == 0) continue;
break;
}
auto h = i.to!... | D |
module app;
import core.bitop;
import std.algorithm;
import std.array;
import std.bigint;
import std.container.rbtree;
import std.conv;
import std.stdio;
import std.string;
import std.traits;
struct Input
{
string n;
}
void parseInput(T)(out Input input, T adapter)
{
with (input)
{
n = adapter.readln();
}
}
... | D |
import std.conv, std.stdio;
import std.algorithm, std.array, std.range, std.string;
enum p = 26;
void main()
{
(readln.chomp.to!ulong - 1).solve.writeln;
}
private:
auto solve(ulong n)
{
long a = p;
auto i = 1;
while (a <= n)
{
n -= a;
a *= p;
i += 1;
}
return n.to... | D |
import std.stdio, std.algorithm, std.range, std.conv, std.string, std.math, std.container, std.typecons;
import core.stdc.stdio;
// foreach, foreach_reverse, writeln
void main() {
const int MOD = 998244353;
int k, n;
scanf("%d%d", &k, &n);
long[][] r = new long[][](2,k+1);
long[] dp = new long[n+1];
dp[0] = 1;
... | 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;
void main() {
int n... | 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.numeric;
void main()
{
auto s = readln.chomp;
auto rn = s.count('0');
auto bn = s.co... | D |
void main() {
long n = readln.chomp.to!long;
long mod = 10 ^^ 9 + 7;
long[] factors = new long[n+1];
foreach (i; 1 .. n+1) {
long d = i;
long tmp;
while (d % 2 == 0) {
++tmp;
d /= 2;
}
factors[2] += tmp;
long ind = 3;
while ... | 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 V = readln.split.to!(int[]);
auto C = readln.split.to!(int[]);
int X;
int Y;
foreach(i; 0..N){
if(V[i] > C[i]){
X += V[i];
Y += C[i];
}
}
if(X-Y<=0){
wr... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto D = readln.chomp.to!int;
switch (D) {
case 22:
writeln("Christmas Eve Eve Eve");
break;
case 23:
writeln("Christmas Eve Eve");
... | 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 d = readln.chomp.split.to!(int[]);
int sum;
... | 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.algorithm; import std.array; import std.conv; import std.string; import std.uni; import std.range; import std.algorithm; void main() { while (!stdin.eof) { auto a = readln.strip; if (a == "-") break; auto m = readln.strip.to!int; foreach (x; iota(m).map!(x => readln.strip.to!int)) { a = a[x... | D |
//dlang template---{{{
import std.stdio;
import std.conv;
import std.string;
import std.array;
import std.algorithm;
// MIT-License https://github.com/kurokoji/nephele
class Scanner
{
import std.stdio : File, stdin;
import std.conv : to;
import std.array : split;
import std.string;
import std.traits : isSome... | 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;
import std.range, std.algorithm, std.array;
void main() {
string vo = "aiueo";
char a;
scan(a);
writeln(vo.canFind(a) ? "vowel" : "consonant");
}
void scan(T...)(ref T args) {
import std.stdio : readln;
import std.algorithm : splitter;
import std.... | 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.split.map!(to!int);
auto N = s[0];
auto Q = s[1];
if (N == 1) {
while (Q--) {
... | D |
void main()
{
long n = rdElem;
writeln((n + 1) / 2);
}
enum long mod = 10^^9 + 7;
enum long inf = 1L << 60;
T rdElem(T = long)()
if (!is(T == struct))
{
return readln.chomp.to!T;
}
alias rdStr = rdElem!string;
alias rdDchar = rdElem!(dchar[]);
T rdElem(T)()
if (is(T == struct))
{
T result;
stri... | 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; }
long ... | D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
auto di1 = readln.split.map!(to!int).array;
auto di2 = readln.split.map!(to!int).array;
auto dice1 = new Dice(di1);
auto dice2 = new Dice(di2);
auto rollings = ["", "T", "TT", "TTT",
"N", "NT", "NTT", "NTTT",... | D |
import std;
void main() {
int s, w; scan(s, w);
writeln(s <= w ? "unsafe" : "safe");
}
void scan(T...)(ref T a) {
string[] ss = readln.split;
foreach (i, t; T) a[i] = ss[i].to!t;
}
T read(T)() { return readln.chomp.to!T; }
T[] reads(T)() { return readln.split.to!(T[]); }
alias readint = read!int;
alia... | 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];
int X;
if(A > B){
X += A;
A--;
} else {
X += B;
B--;
}
if(A > B){
X += A;
} else {
X += B;
}
writeln(X);
} | D |
void main(){
import std.stdio, std.algorithm, std.string, std.conv;
struct P{
int idx1, idx2;
}
int K; rd(K);
P[int] set;
for(int k=1; k<=K; k++){
int n; rd(n);
auto as=readln.split.to!(int[]);
int s=reduce!"a+b"(as);
P[] cand;
foreach(int i, a; as){
int t=s-a;
if(t in s... | D |
void main() {
int[] tmp = readln.split.to!(int[]);
int n = tmp[0], y = tmp[1];
int yukichi = -1, ichiyou = -1, hideyo = -1;
foreach (i; 0 .. n+1) {
foreach (j; 0 .. n-i+1) {
int k = n - i - j;
if (10000 * i + 5000 * j + 1000 * k == y) {
yukichi = i;
... | 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.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(){
int a, b;
scanf("%d %d", &a, &b);
writeln(a+b>=10?"error":(a+b).to!string);
}
import std.stdio, std.conv, std.algorithm, std.numeric, std.string, std.math, std.range;
const long mod = 10^^9+7;
// 1要素のみの入力
T inelm(T= int)(){
return to!(T)( readln().chomp() );
}
// 1行に同一型の複数入力
T[] inln(... | D |
import std.algorithm;
import std.array;
import std.container;
import std.conv;
import std.math;
import std.numeric;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
void scan(T...)(ref T a) {
string[] ss = readln.split;
foreach (i, t; T) a[i] = ss[i].to!t;
}
T read(T)() { return read... | D |
import std.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.