code stringlengths 4 1.01M | language stringclasses 2
values |
|---|---|
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() {
string s;
long k;
scan(s);
scan(k);
k--;
int pos = -1;
char nm = '1';
foreach (i ; 0 .. s.length) {
if (s[... | D |
import std.stdio,std.string,std.conv;
void main(){
auto input=readln.chomp.split;
auto n=input[0].to!ulong;
auto a=input[1].to!ulong;
auto b=input[2].to!ulong;
auto ans=n/(a+b)*a;
ans+=n%(a+b)>a?a:n%(a+b);
writeln(ans);
} | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons;
void main()
{
auto xyz = readln.split.to!(int[]);
int c;
xyz[0] -= xyz[2];
while (xyz[0] >= xyz[1] + xyz[2]) {
xyz[0] -= (xyz[1] + xyz[2]);
++c;
}
writeln(c);
} | 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 |
void main(){
import std.stdio, std.string, std.conv, std.algorithm;
import std.numeric;
long a, b, x, y; rd(a, b, x, y);
auto g=gcd(x, y);
x/=g; y/=g;
writeln(min(a/x, b/y));
}
void rd(T...)(ref T x){
import std.stdio, std.string, std.conv;
auto l=readln.split;
assert(l.length==x.length);
foreach... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
int[2][10^^5*2] DP;
void main()
{
auto S = readln.chomp.to!string;
foreach_reverse (i; 0..S.length) {
if (i == S.length-1) {
DP[i][0] = 1;
DP[i][1] = int.min;
} else ... | 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 |
void main() {
int n = readln.chomp.to!int;
if (n == 1) {
"Hello World".writeln;
} else {
writeln(readln.chomp.to!int + readln.chomp.to!int);
}
}
import std.stdio;
import std.string;
import std.array;
import std.conv;
import std.algorithm;
import std.range;
import std.math;
import std.co... | 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;
void main() {
auto N = readln.chomp.to!int;
int ds(int x) {
int ret = 0;
while (x > 0) ret += x % 10,... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
void main() {
int N = to!int(chomp(readln()));
int res;
for(int i = 0; i <= N; i++) {
res += i;
}
res.writeln;
}
| 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;
sc.read(n);
int[] a, b;
sc.read(a, b);
... | D |
import std.stdio,std.conv,std.string;
void main()
{
auto num = readln.strip.to!long;
if (num < 1200) {
writeln("ABC");
}
else if (num < 2800) {
writeln("ARC");
}
else {
writeln("AGC");
}
}
| D |
import std.algorithm, std.container, std.conv, std.math, std.range, std.typecons, std.stdio, std.string;
import std.numeric;
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 readA(T)(size_t n,ref T[]t... | D |
void main(){
import std.stdio, std.string, std.conv, std.algorithm;
int m; rd(m);
writeln(24+(24-m));
}
void rd(T...)(ref T x){
import std.stdio, std.string, std.conv;
auto l=readln.split;
assert(l.length==x.length);
foreach(i, ref e; x){
e=l[i].to!(typeof(e));
}
}
void wr(T...)(T x){
import st... | 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, d; readV(a, b, c, d);... | D |
import std.stdio,std.string,std.conv;
int main()
{
string[char] ID;
ID[' '] = "101";
ID['\''] = "000000";
ID[','] = "000011";
ID['-'] = "10010001";
ID['.'] = "010001";
ID['?'] = "000001";
ID['A'] = "100101";
ID['B'] = "10011010";
ID['C'] = "0101";
ID['D'] = "0001";
ID['E'] = "110";
ID['F'] = "01001";
ID[... | D |
import std.stdio, std.string, std.conv, std.algorithm;
import std.range, std.array, std.math, std.typecons, std.container, core.bitop;
void main() {
string n = readln.chomp;
writeln(n.canFind('9') ? "Yes" : "No");
}
void scan(T...)(ref T args) {
string[] line = readln.split;
foreach (ref arg; args... | 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, std.typecons, std.format;
// }}}
// nep.scanner {{{
class Scanner {
import std.stdio : File, stdin;
import std.conv : to;
import std.array : split;
impor... | D |
void main() {
auto N = ri;
fact(N).writeln;
}
ulong fact(ulong n) {
if(n<=1) return 1;
else return n*fact(n-1)%(10UL^^9 + 7);
}
// ===================================
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.range;
import std.traits;
import std.math;
import std.bigin... | D |
import std.stdio, std.conv, std.string, std.array, std.math, std.regex, std.range, std.ascii, std.numeric, std.random;
import std.typecons, std.functional, std.traits,std.concurrency;
import std.algorithm, std.container;
import core.bitop, core.time, core.memory;
import std.bitmanip;
import std.regex;
enum INF = long.... | D |
const long mod=998244353;
const int M=1_000_00*4;
void main(){
import std.stdio, std.algorithm;
long n, a, b, k; rd(n, a, b, k);
auto fact=genFact(M, mod);
auto invFact=genInv(fact, mod);
long comb(long nn, long rr){
if(nn<rr) return 0;
long ret=fact[nn]%mod;
(ret*=invFact[rr])%=mod;
(re... | D |
import std.stdio;
import std.string;
enum conv = [
'I':1,
'V':5,
'X':10,
'L':50,
'C':100,
'D':500,
'M':1000
];
void main()
{
foreach (input; stdin.byLine()){
int total = 0;
if (input.length == ... | 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.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
auto n = readln.chomp.to!int;
writeln(n * 800 - (n/15) * 200);
}
| D |
import std.stdio, std.array, std.conv, std.string;
void main() {
string[] input = split(readln());
int[] a = new int[3];
for (int i = 0; i < 3; ++i) {
a[i] = to!int(input[i]);
}
if (a[0] < a[1] && a[1] < a[2]) {
writeln("Yes");
} else {
writeln("No");
}
} | D |
import std.stdio, std.conv, std.string;
void main()
{
auto ip = readln.split.to!(int[]), n = ip[0], m = ip[1];
writeln((n - 1)*(m - 1));
} | D |
import std.stdio,std.string,std.conv,std.algorithm;
void main(){
auto readline = to!int(readln().chomp());
for( ; 0 < readline ; readline-- ){
auto arr = readln().chomp().split();
check( to!int(arr[0]),to!int(arr[1]),to!int(arr[2]));
}
}
void check(int x,int y,int z){
if( x*x+y*y==z*z || x*x+z*z==y*y || y*y+z*z... | D |
import std.stdio, std.conv, std.string, std.algorithm, std.range;
void main() {
auto N = readln.chomp.to!int;
auto A = readln.chomp.to!int;
writeln(N % 500 <= A ? "Yes" : "No");
}
| D |
import std.stdio, std.conv, std.string, std.algorithm,
std.math, std.array, std.container, std.typecons;
void main() {
auto s = readln.chomp;
auto t = readln.chomp[0..$-1];
if(s==t) writeln("Yes");
else writeln("No");
}
| D |
import std.stdio;
import std.conv;
import std.string;
import std.typecons;
import std.algorithm;
import std.array;
import std.range;
import std.math;
import std.regex : regex;
import std.container;
import std.bigint;
void main()
{
auto n = readln.chomp.to!int;
auto a = new int[](n+1);
long res;
foreach (i; 1.... | 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 core.stdc.stdio;
import std.typecons;
import std.algorithm;
void main(){
int n;
long h;
scanf("%d%lld",&n,&h);
long[] ds = new long[n];
long[] hs = new long[n-1];
for(int i=0;i<n-1;i++)
scanf("%lld%lld",&ds[i+1],&hs[i]);
for(int i=1;i<n;i++)
ds[i] += ds[i-1];
//ds.writeln;
long he... | 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, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void solve()
{
auto N = readln.chomp.to!int;
auto ps = readln.split.to!(int[]);
auto ii = new size_t[](N);
foreach (i, ref p; ps) {
p -= 1;
ii[p] = i;
}
auto bs = new bool[](... | 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) {
int n = readln.chomp.to!int;
string p = readln.chomp;
string s = readln.chomp;
for(int i = 0; i < n; i++){
if(p[i..$] == ... | D |
import std.stdio,
std.string,
std.conv;
void main() {
int[] buf = readln.chomp.split.to!(int[]);
int N = buf[0], A = buf[1], B = buf[2];
int d = B - A;
writeln(d & 1 ? "Borys" : "Alice");
}
| D |
import std.stdio, std.string, std.array, std.conv, std.algorithm;
void main() {
int n = readln.chomp.to!int;
string a = readln.chomp.split.join;
int m = readln.chomp.to!int;
string b = readln.chomp.split.join;
writeln(a < b ? 1 : 0);
}
| D |
import std.stdio;
import std.conv;
import std.string;
void main() {
string s;
while((s = readln()).length != 0) {
int [] c = [500, 100, 50, 10, 5, 1];
int res = 0;
int a;
a = to!int(chomp(s));
if(a == 0) break;
a = 1000 - a;
for(int i = 0; i < c.length; i++) {
if(a >= c[i]) {
res++;
a -= c[i... | 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 readA(T)(size_t n,ref T[]t){t=new T[](n);auto ... | D |
import std.stdio;
import std.string;
import std.array; // split
import std.conv; // to
void main()
{
string s = chomp(readln());
for(int i=0; i<18; ++i){
if(i == 5 || i == 13){
write(" ");
} else {
write(s[i]);
}
}
writeln(s[18]);
} | 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.functional,
std.algorithm,
std.container,
std.typetuple,
std.typecons,
std.bigint,
std.string,
std.traits,
std.array,
std.range,
std.stdio,
std.conv,
std.format,
std.math;
void main()
{
auto o = readln.chomp;
auto e... | 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.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 ip1 = readln.chomp.to!int;
auto ip2 = readln.ch... | 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 |
// Vicfred
// https://atcoder.jp/contests/abc176/tasks/abc176_c
// greedy
import std.algorithm;
import std.array;
import std.conv;
import std.stdio;
import std.string;
void main() {
long n = readln.chomp.to!long;
long[] a = readln.split.map!(to!long).array;
long last = a[0];
long ans = 0;
for(int ... | D |
import std.stdio;
import std.string;
import std.conv;
void main() {
int c = 0;
int[] numstack;
string[] opstack;
int calc() {
ulong i = 0;
int x = numstack[i++];
foreach (op; opstack) {
switch (op) {
case "+":
x += numstack[i++];
... | D |
import std.stdio; // ??\????????????????????????
import std.string; // chomp????????????????????????(?????????????????????)
import std.conv; // to????????????????????????
import std.array; // split?????????????????????
import std.algorithm; // map?????????????????????
void main() {
int S = readln.chomp.to!int;
... | D |
void main() {
import std.stdio, std.string, std.conv, std.algorithm;
auto a = readln.split.to!(int[]);
auto ch = ['A', 'B', 'C'];
auto mx = a.reduce!(max);
foreach (i; 0 .. 3) {
if (a[i] == mx) {
writeln(ch[i]);
return;
}
}
}
void rd(T...)(ref T x) {
import std.stdio : readln;
imp... | 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.typecons;
void main()
{
auto n = readln.chomp.to!int;
int min, max = -1;
foreach (_; 0..n) {
auto ab = readln.split.to!(int[]);
if (ab[0] > max) {
max = ab[0];
min = ab[1];
}
}
writ... | 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 tmp = new long[](10 ^^ 5);
foreach (i... | D |
void main()
{
long n = readln.chomp.to!long;
long a, b, ab;
long cnt;
foreach (i; 0 .. n)
{
string s = readln.chomp;
cnt += s.count("AB");
if (s[$-1] == 'A' && s[0] == 'B') ++ab;
else if (s[$-1] == 'A') ++a;
else if (s[0] == 'B') ++b;
}
if (ab > 0)
... | D |
import std.stdio;
import std.string;
import std.algorithm;
import std.exception;
import std.conv;
import std.array;
import std.range;
int toplamGuzellikSayisi = 0;
void main() {
auto satirSayisi = stdin.readln.strip.to!int();
char[] hulkunHisleri;
for ( int i = 0; i < satirSayisi; i++ )
{
if ( i == satirSay... | D |
void main() {
bool n, w, s, e;
auto S = rs;
foreach(c; S) {
switch(c) {
case 'N': n = true; break;
case 'W': w = true; break;
case 'S': s = true; break;
case 'E': e = true; break;
default: assert(0);
}
}
if(n && !s || !n && s || w && !e || !w && e) writeln("No");
else writeln("Yes");
}
// ====... | D |
// Your code here!
import std.stdio;
import std.range;
import std.array;
import std.algorithm;
import std.conv;
import std.string;
void main(){
auto ab = readln().chomp().split().map!(to!long);
auto a = ab[0];
auto b = ab[1];
solve(a, b).writeln();
}
long solve(long a, long b){
auto eastIdx = b - a;
... | D |
import std;
void main() {
auto N = readln.split[0].to!long;
auto A = readln.split.to!(long[]);
ulong[long] Aminus;
foreach (j; 0 .. N) {
if (j-A[j] !in Aminus) Aminus[j-A[j]] = 0;
Aminus[j-A[j]]++;
}
ulong ans;
foreach (i; 0 .. N) {
if (A[i]+i !in Aminus) continue;
... | D |
void main() {
auto c = readMatrix!char(3, 3);
foreach(i; 0..3) c[i][i].write;
writeln;
}
// ===================================
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.range;
import std.traits;
import std.math;
import std.container;
import std.bigint;
import std.numer... | 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 ABN = readln.split.to!(long[]);
auto A = ABN[0], B = ABN[1], N = ABN[2];
auto x = min(B-1, N);
writeln(cast(long) (floor(cast(double) A * cast(doub... | D |
import std.stdio, std.string, std.conv;
void main()
{
readln().chomp().toUpper().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 |
void main() {
writeln(readln.split.join.to!int % 4 == 0 ? "YES" : "NO");
}
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 |
void main()
{
dchar[] s = readln.chomp.to!(dchar[]);
long k = readln.chomp.to!long;
long n = s.length;
foreach (i, ref x; s)
{
if (i == n - 1)
{
s[i] = ((s[i] - 'a' + (k % 26)) % 26 + 'a').to!dchar;
}
else
{
long m = (26 - (s[i] - 'a')... | 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.range, std.conv, std.string;
import core.stdc.stdio;
// foreach, foreach_reverse, writeln
const int INF = 1_000_000_007;
void main() {
int n;
scanf("%d", &n);
int[] a = new int[n];
foreach (i; 0..n) scanf("%d", &a[i]);
int p = 0, m = -INF; long val = -INF;
foreach (parity; 0... | 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() {
string s;
scan(s);
auto ok = s[0] == 'A' ... | 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 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.string;
void main(){
int w, h;
while(true){
scanf("%d %d", &h, &w);
if (w == 0 && h == 0) break;
foreach(i; 0..h){
foreach(j; 0..w){
write("#");
}
writeln();
}
writeln();
}
} | D |
import std.stdio,std.string,std.conv;
int main()
{
int sum = 0,count = 0;
double num = 0;
string s;
while((s = readln.chomp).length != 0)
{
count++;
string[] _s = s.split(",");
sum += _s[0].to!int * _s[1].to!int;
num += _s[1].to!int;
}
sum.writeln;
writeln(cast(int)((num/count) + 0.5));
return 0;
} | D |
import std.stdio, std.conv, std.array, std.algorithm, std.string, std.math;
void main() {
string s;
while ((s = readln()).length != 0) {
int[] nx;
if (to!uint(s.chomp) == 0) {break;}
for (uint i = 0; i < to!uint(s.chomp); ++i) {
nx ~= to!int(readln().chomp);
}
... | 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.conv, std.string, std.array, std.range, std.algorithm, std.container;
import std.math, std.random, std.bigint, std.datetime, std.format;
bool DEBUG = 0; void log(A ...)(lazy A a){ if(DEBUG) print(a); }
void main(string[] args){ args ~= ["", ""]; string cmd = args[1]; if(cmd == "-debug") DEBUG = 1;... | 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(){
long n, m;
{
long[] tmp = readln.chomp.split.map!(to!long).array;
n = tmp[0], m = tmp[1];
}
long ans;
/*
long x = n * 2 + m;
long y = x / 4;
... | D |
import core.bitop, std.algorithm, std.ascii, std.bigint, std.conv, std.math,
std.functional, std.numeric, std.range, std.stdio, std.string, std.random,
std.typecons, std.container, std.format;
static import std.ascii;
// dfmt off
T lread(T = long)(){return readln.chomp.to!T();}
T[] lreads(T = long)(long n){ret... | 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 |
void main(){
int n = _scan();
int[] a = _scanln();
int ans;
for(int i=1; i<=a.length; i+=2){
if(a[i-1]&1)ans++;
}
ans.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 = ... | D |
void main() {
import std.stdio, std.string, std.conv, std.algorithm;
int n;
rd(n);
auto s = readln.chomp.to!(char[]);
int mx = 0;
foreach (i; 1 .. n) {
bool[char] map;
foreach (j; 0 .. i) {
map[s[j]] = true;
}
int c = 0;
foreach (j; i .. n) {
if (s[j] in map) {
c++;... | D |
import std.stdio;
import std.conv;
import std.string;
import std.typecons;
import std.algorithm;
import std.array;
import std.range;
import std.math;
import std.regex : regex;
import std.container;
import std.bigint;
import std.ascii;
void main()
{
auto n = readln.chomp.to!int;
int cnt;
foreach (i; 1..n/2+1) {
... | D |
import std;
auto input()
{
return readln().chomp();
}
void main()
{
// long[] ary = to!(long[])(split(readln()));
auto ary = readln().split().to!(long[])();
// writeln(join(to!(string[])(ary), " "));
long a = ary[0];
long b = ary[1];
long c = ary[2];
long k = ary[3];
if (a >= k)
... | D |
// tested by Hightail - https://github.com/dj3500/hightail
import std.stdio, std.string, std.conv, std.algorithm;
import std.range, std.array, std.math, std.typecons, std.container, core.bitop;
import std.datetime, std.bigint;
int s, v1, v2, t1, t2;
void main() {
scan(s, v1, v2, t1, t2);
int a, b;
a = 2*... | 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() {
auto ... | D |
import std.stdio, std.string, std.conv, std.algorithm;
void main(string[] args) {
auto x = readln().chomp.split.map!(to!int);
auto a = x[0]-x[1];
if(a<0){0.writeln;}else{a.writeln;}
} | 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,
std.typecons;
// }}}
// nep.scanner {{{
class Scanner {
import std.stdio;
import std.conv... | D |
void main(){
import std.stdio, std.string, std.conv, std.algorithm;
int n, a, b; rd(n, a, b);
writeln(min(a*n, b));
}
void rd(T...)(ref T x){
import std.stdio, std.string, std.conv;
auto l=readln.split;
assert(l.length==x.length);
foreach(i, ref e; x){
e=l[i].to!(typeof(e));
}
} | 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.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
auto rd = readln.split.to!(int[]), a = rd[0], b = rd[1];
auto pa = a == 1 ? 14 : a, pb = b == 1 ? 14 : b;
if (pa == pb) writeln("Draw");
else if (pa > pb) writeln("Alice");
else writeln("Bob");
}
| 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;
import std.string;
import std.conv;
import std.algorithm: canFind;
void main() {
string[] inputs = split(readln());
int A = to!int(inputs[0]);
int B = to!int(inputs[1]);
((A + B) % 24).writeln;
}
| D |
import std.stdio, std.conv, std.array;
import std.math;
void main(){
double r = readln.split[0].to!double;
r = 2 * PI * r;
printf("%lf\n",r);
} | D |
import std.stdio, std.string, std.conv;
void main() {
auto input = getStdin!(string[])[0].split(" ");
int w = input[0].to!(int);
int h = input[1].to!(int);
int x = input[2].to!(int);
int y = input[3].to!(int);
int r = input[4].to!(int);
if (x - r < 0 || x + r > w || y - r < 0 || y + r > h) {
"No".writeln;
... | 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.string, std.algorithm, std.conv, std.array;
void main(){
auto nx=readln.split.map!(to!long).array;
auto n=nx[0], x=nx[1];
auto as=readln.split.map!(to!long).array;
auto c=0L;
long result=0;
foreach(a; as){
if(a+c>x){
result+=a+c-x;
c=-c+x;
}else{
c=a;
}
... | D |
import std.stdio;
import std.datetime;
import std.conv;
void main()
{
auto s = TimeOfDay.fromISOExtString(readln[0 .. $-1] ~ ":00");
auto t = readln;
auto d = dur!"hours"((t[0..2]).to!long)
+ dur!"minutes"(t[3..5].to!long);
writeln((s - d).toISOExtString[0..5]);
} | 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 |
// 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;
ulong idx = -1;
bool matched;
for(long i = (s.count-t.count); i >= 0; i--) {
if (s[i] == '?' || s[i] == t[0]) {
ma... | 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, std.typecons;
// }}}
// nep.scanner {{{
class Scanner
{
import std.stdio : File, stdin;
import std.conv : to;
import std.array : split;
import ... | D |
import std.stdio;
import std.ascii;
import std.conv;
import std.string;
import std.array;
void main() {
int sum = 0;
while(true) {
string line = readln.chomp;
bool prev_digit = false;
string number = "";
if (stdin.eof) break;
foreach(x; line) {
if (isDigit(x)) {
number ~= x;
... | 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 N = readln.chomp.to!int;
auto A = readln.chomp;
auto B = readln.chomp;
bool[] tate;
for (int i = 0; ... | D |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.