code stringlengths 4 1.01M | language stringclasses 2
values |
|---|---|
import std.stdio, std.string, std.conv, std.math, std.regex;
void main()
{
auto n = readln.split.to!(int[]);
if(abs(n[1] - n[0]) < abs(n[2] - n[0])){
writeln('A');
} else {
writeln('B');
}
} | 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;
bool calc(int k, int a, int b) {
// return a <= b / k * k;
return (a + k - 1) / k * k <= b;
}
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[] ss = readln.split;
foreach (i, t; T) a[i] = ss[i].to!t... | 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()
{
char[] S = readln.strip.to!(char[]);
auto a = S[0..2].to!int;
auto b = S[2..4].to!int;
;
bool... | D |
import std.stdio;
import std.algorithm;
import std.string;
import std.conv;
void main() {
auto value =[6, 4, 3, 2];
foreach (i; 0..4) {
auto a = readln.split.map!(to!int);
writeln(value[a[0]-1] * a[1] * 1000);
}
} | 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.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.conv;
import std.algorithm;
import std.math;
import std.regex;
import std.range;
void main() {
auto ip = readln.split.to!(ulong[]), N = ip[0], M = ip[1];
/*auto a = new bool[][](N, M);
//N: tate, M: yoko
// omote: false, ura: true
foreach(i; 0..N) { //tate
foreac... | 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()
{
auto r = -1;
foreach (i; 1..11) ... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric, std.bigint;
struct PriorityQueue(alias _fun, T) {
import std.functional : binaryFun;
import std.algorithm : swap;
alias fun = binaryFun!_fun;
///
this(T[] ts) {
foreach (t; ts) enqueue(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;
enum inf = 1_001_001_001;
enum infl = 1_001_001_001_001_001_001L;
struct UnionFind {
int N;
int[] parent; // 根は -(連結成分のサイズ) としておく
int cc;
... | D |
import std.stdio, std.string, std.conv, std.algorithm, std.numeric;
import std.range, std.array, std.math, std.typecons, std.container, core.bitop;
void main() {
string n;
scan(n);
if (n[0 .. 3].to!int % 111 == 0 || n[1 .. 4].to!int % 111 == 0) {
writeln("Yes");
}
else {
writeln("N... | 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 n, m;
scan(n, m);
writeln(n == m ? "Ye... | D |
import std.stdio, std.string, std.conv;
import std.typecons;
import std.algorithm, std.array, std.range, std.container;
import std.math;
// mod must be a prime number
struct Mod(uint mod) if (mod < int.max) {
import std.conv : to;
uint n;
this(int m) { this(long(m)); }
this(long m) { this.n = m >= 0L ? cast(ui... | D |
import std.algorithm, std.stdio, std.range;
int N;
immutable W = 10, M = 12;
immutable dy = [-2,-2,-2,-1,-1,0,0,1,1,2,2,2], dx = [-1,0,1,-2,2,-2,2,-2,2,-1,0,1];
immutable ddy = [-1,-1,-1,0,0,0,1,1,1], ddx = [-1,0,1,-1,0,1,-1,0,1];
int[] ys, xs;
void main(){
for(;init;){
writeln(solve ? "OK" : "NA");
}
}
bool ini... | D |
import std.stdio;
import std.string;
import std.algorithm;
import std.conv;
import std.array;
import std.range;
import std.math;
int main(string[] argv)
{
auto gunVeSekerCifti = stdin.readln.chomp.split.map!( to!int );
int gunSayisi = gunVeSekerCifti[0];
size_t sekerTalebi = gunVeSekerCifti[1];
int[] sekerKutulari... | 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() {
string s;
scan(s);
int n = s.le... | D |
import std.algorithm;
import std.array;
import std.conv;
import std.range;
import std.stdio;
import std.string;
void main()
{
auto nums = [6, 2, 5, 5, 4, 5, 6, 3, 7, 6];
int n;
scanf("%d", &n);
int len = n / 2;
while (len > 0)
{
foreach_reverse (i; 0..10)
if ((len - 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 std.conv, std.array, std.algorithm, std.string;
import std.math, std.random, std.range, std.datetime;
import std.bigint;
void main(){
string s = readln.chomp;
long ans;
for(long x = 0; x < 2 ^^ (s.length - 1); x ++){
long a = 0, tmp = ("" ~ s[0]).to!long;
for(int i = 0; i < s.leng... | D |
import core.stdc.stdio;
import std.stdio;
void main(){
int n;
scanf("%d",&n);
char[] buf = new char[n+1];
scanf("%s",buf.ptr);
buf = buf[0..n];
bool[] used = new bool[n];
int[] op = new int[n];
bool Solve(char[] data,int c){
used[] = false;
int ic=n;
int a;
for(int i=n-1;i>=0;i--)
if(a<c&&data[i]=='... | D |
void main(){
import std.stdio, std.string, std.conv, std.algorithm;
string s; rd(s);
if(s.length<4){writeln("No"); return;}
auto t="YAKI";
foreach(i; 0..t.length){
if(s[i]!=t[i]){writeln("No"); return;}
}
writeln("Yes");
}
void rd(T...)(ref T x){
import std.stdio, std.string, std.conv;
auto l=... | D |
import std.stdio, std.conv, std.array, std.string;
import std.algorithm;
import std.container;
import std.range;
import core.stdc.stdlib;
import std.math;
void main() {
auto N = readln.chomp.to!int / 2;
auto S = readln.chomp;
auto T = S[0..N];
writeln(T ~ T == S ? "Yes" : "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 s = readln.chomp.to!int;
int an = s;
int[int] cnt;
foreach (i; 2..1_000_0... | 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()
{
foreach (line; stdin.byLine) {
auto w = line.chomp.to!double;
string str;
if (w <= 48) str = "light ... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.array;
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(X*K+(N-K)*Y);
}
else writeln(N*X);
} | 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];
int[][] ps;
auto memo = new bool[][](H, W);
foreach (i; 0..H) {
foreach (j, c; readln.chomp) {
... | D |
import std.stdio;
import std.string;
import std.conv;
void main() {
auto N =readln.chomp.to!int;
auto A =readln.chomp.to!int;
writeln(N*N-A);
} | D |
import std.stdio, std.conv, std.algorithm, std.range, std.array, std.string, std.uni, std.bigint, std.math;
void main() {
auto n = readln.chomp.to!uint;
auto an = readln.split.to!(long[]);
min(func(an, 0), func(an, 1)).writeln;
}
ulong func(long[] an, uint mod) {
long sum = 0;
ulong res = 0;
foreach(i,a; ... | D |
import std.stdio;
import std.array;
import std.conv;
void main()
{
while (1) {
auto input = to!(int[])(split(readln()));
int total = input[0] + input[1];
if (input[0] == -1 && input[1] == -1 && input[2] == -1) break;
if (input[0] == -1 || input[1] == -1) {
writeln... | 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;
long x;
scan(n, x);
auto a = new long[](n + 1); // 長さ
auto b = new long[](n + 1); // Pの枚数
a[0] = b[0] = 1;
fore... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric, std.container, std.range;
void main()
{
auto S = readln.chomp;
if (S == "RRR") {
writeln(3);
} else if (S == "SRR" || S == "RRS") {
writeln(2);
} else if (S == "SSS") {
writeln... | 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.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.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 a, b;
scan(a, b);
auto ans = xorsum(b)... | D |
#!/usr/bin/rdmd
import std.stdio;
void main()
{
foreach(i ; 1..10)
foreach(j ; 1..10)
writeln(i, "x", j, "=", i*j);
} | D |
import std.stdio, std.conv, std.array, std.string;
import std.algorithm;
import std.container;
import std.range;
import core.stdc.stdlib;
import std.math;
void main() {
auto N = readln.chomp.to!int;
auto Bn = readln.split.to!(int[]);
int total = Bn[0] + Bn[N-2];
foreach(i; 0..N-2) {
total += min(Bn[i], Bn... | D |
void main(){
int a, b;
char op;
scanf("%d %c %d", &a, &op,&b);
writeln(op=='+'?a+b:a-b);
}
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 |
void main() {
int n = readln.chomp.to!int;
string s = readln.chomp;
int x, xmax;
foreach (c; s) {
if (c == 'I') ++x;
else --x;
xmax = max(xmax, x);
}
xmax.writeln;
}
import std.stdio;
import std.string;
import std.array;
import std.conv;
import std.algorithm;
import std.... | 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!long;
long res;
foreach (i; 1..n+1) {
auto x = (i.to... | 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() {
int r, g, b, n;
scan(r, g, b, n);
int an... | D |
import std.stdio, std.string, std.conv, std.ascii, std.array;
void main()
{
foreach(_; 0 .. readln.chomp.to!int)
{
line = readln.chomp;
add.writeln;
}
}
string line;
int add()
{
int lhs = mul;
loop:
while(true)
{
switch(line[0])
{
case '+... | 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 |
// xxx
import std.algorithm;
import std.random;
import std.stdio;
import std.string;
void main ()
{
auto normal = ["no", "not bad", "cool", "don't think so", "great!",
"don't touch me!"];
auto grumpy = ["no", "don't even", "worse", "no way", "terrible",
"go die in a hole", "are you serious?"];
rndGen.seed... | 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.string;
void main() {
auto s = readln.split.map!(to!int);
auto N = s[0];
auto M = s[1];
auto A = readln.split.map... | 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;
void main(string[] args) {
int n;
int[1440] time;
scanf("%d", &n);
for ( int i = 0; i < 1440; i++ ) {
time[ i ] = 0;
}
int h, m;
for ( int i = 0; i < n; i++ ) {
scanf("%d:%d", &h, &m);
time[h*60+m] = 1;
}
int mm=0;
int cur=0;
int cur1=0;
int t ... | D |
import std.algorithm;
import std.conv;
import std.range;
import std.stdio;
import std.string;
void main ()
{
auto tests = readln.strip.to !(int);
foreach (test; 0..tests)
{
auto n = readln.strip.to !(int);
auto a = readln.splitter.map !(to !(int)).array;
writeln (a.minElement == a.maxElement ? n : 1);
}
}
| D |
// import chie template :) {{{
import std;
// }}}
// nep.scanner {{{
class Scanner {
import std.stdio : File, stdin;
import std.conv : to;
import std.array : split;
import std.string;
import std.traits : isSomeString;
private File file;
private char[][] str;
private size_t idx;
this(File file = std... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto nmk = readln.split.to!(int[]);
auto N = nmk[0];
auto M = nmk[1];
auto K = nmk[2];
foreach (y; 0..N+1) {
foreach (x; 0..M+1) {
if (x*y + (M-x)*(N-y) == K) {
... | 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 x = readln.chomp.replace(" ", "").to!int;
auto y = sqrt(x.to!double);
if ... | D |
void main()
{
long n = readln.chomp.to!long;
long x = 1, y = 1;
foreach (i; 0 .. n)
{
long[] tmp = readln.split.to!(long[]);
long t = tmp[0], a = tmp[1];
long m = max((x+t-1)/t, (y+a-1)/a);
x = m * t, y = m * a;
}
writeln(x + y);
}
import std.stdio;
import std... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string;
void main()
{
auto s = readln.chomp;
auto cnt = 0;
char last = s[0];
foreach (c; s[1..$]) {
if (c != last) {
++cnt;
last = c;
}
}
writeln(cnt);
} | D |
import std.stdio;
import std.conv;
import std.string;
import std.typecons;
import std.algorithm;
import std.array;
import std.range;
import std.math;
import std.container;
import std.random;
void main() {
int i;
while (1) {
auto n = readln.chomp.to!int;
if (!n) break;
writeln("Case ", ++i, ": ", n);... | 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;
const mod = 10^^9 + 7;
... | 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.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 |
void main() {
int n = readln.chomp.to!int;
writeln(n / 1000 ? "ABD" : "ABC");
}
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.uni; | 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.string, std.algorithm, std.math, std.array, std.container;
void main() {
long[] hw = readln.chomp.split.to!(long[]);
if(hw[0]==1 || hw[1]==1) writeln(1);
else writeln((hw[0]*hw[1]+1)/2);
}
| D |
import std.stdio;
import std.algorithm;
import std.conv;
import std.string;
void main()
{
auto n = to!int(chomp(readln()));
string[] ws;
ws ~= chomp(readln());
bool isYes = true;
foreach (i; 1..n)
{
ws ~= chomp(readln());
if (ws[i-1][$-1] != ws[i][0])
{
isYes = false;
break;
}
else if (countUntil... | D |
import std;
alias sread = () => readln.chomp();
alias lread = () => readln.chomp.to!long();
alias aryread(T = long) = () => readln.split.to!(T[]);
//aryread!string();
void main()
{
auto n = lread();
auto t = aryread();
// writeln(t);
auto m = lread();
auto px = new long[][](m, 2);
foreach (i; 0... | 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;
auto cnt = new int[](26);
void solve() {
auto s = readln.split.map!(to!int);
auto N = s[0];
auto K = s[1];
... | 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 a = readln.chomp.split.to!(int[]);
writeln((a[0]*3+a[1])/2);... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
long P = 10^^9 + 7;
void main()
{
auto N = readln.chomp.to!int;
auto S = readln.chomp.to!(char[]);
long[26] as;
foreach (c; S) {
if (as[c-97] == 0) {
as[c-97] = 2;
} els... | 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 nmxy = readln.chomp.split.to!(int[]);
auto x = max(readln.chomp.split.to!(int[... | 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, 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 main() {
int n, k;
scan(n, k);
auto a = readln.split.to!(int[]);
foreach (i; k .. n) {
yes(a[i] > a[i - k]);
}
}
void ... | 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.array, std.conv;
int selectionSort(int n, int[] x) {
int cnt = 0;
foreach (i; 0 .. n-1) {
int minj = i;
foreach (j; i .. n) {
if (x[j] < x[minj]) minj = j;
}
if (i != minj) {
int t = x[i];
x[i] = x[minj];
... | D |
import std.array;
import std.range;
import std.algorithm;
import std.conv;
import std.stdio;
import std.string;
import std.traits;
import std.ascii;
class Solver {
private int[char] hash;
private bool firstUpdate = true;
public this() {
foreach(c; lowercase) {
hash[c] = 0;
}
}
public void up... | 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.algorithm;
import std.array;
import std.conv;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
int readint() { return readln.chomp.to!int; }
int[] readints() { return readln.split.map!(to!int).array; }
bool isParallel(Vec2 a, Vec2 b, Vec2 c, Vec2 d) {
auto ab... | D |
import std.stdio;
import std.string;
import std.conv;
void main(){
int[string] diction;
int max;
string longest="";
foreach( c ; readln().chomp().split() ){
diction[c]++;
if( max < diction[c] ){
max = diction[c];
}
if( longest.length < c.length ){
longest = c;
}
}
foreach( c,i ; diction ){
if( m... | 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 md = readNums!int;
int ret;
foreach(m; 1 .. md[0]+1){
fo... | 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.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric, std.container, std.range;
void main()
{
auto N = readln.chomp.to!int;
auto ss = new int[][](N, N);
auto memo = new bool[][](N, N);
foreach (i; 0..N) foreach (j; 0..N) {
ss[i][j] = min(i, N-i-1... | 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.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
auto c = readln.chomp;
writeln("aeiou".canFind(c) ? "vowel" : "consonant");
}
| D |
import std.conv, std.functional, std.range, std.stdio, std.string;
import std.algorithm, std.array, std.bigint, std.bitmanip, std.complex, std.container, std.math, std.mathspecial, std.numeric, std.regex, std.typecons;
import core.bitop;
class EOFException : Throwable { this() { super("EOF"); } }
string[] tokens;
stri... | D |
import std.stdio,std.conv,std.algorithm,std.string;alias L=long;L M=998244353;L[]X;L[L]C;L h(L m,L[]U){L f;foreach(u;U[0..m])f=f*2%M+u;foreach(i,u;U)if(i/m&1^U[i%m]^u)return f+u;return f+1;}void main(){L n=readln.chomp.to!L,b=n*2;foreach(c;readln.chomp)X~=c-'0';for(L d=n|1;d>2;d-=2)if(n%d<1){L c=h(n/d,X);foreach(e,q;C)... | 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[] a, s... | D |
import std.stdio, std.conv, std.functional, std.string;
import std.algorithm, std.array, std.container, std.range, std.typecons;
import std.bigint, std.numeric, std.math, std.random;
import core.bitop;
string FMT_F = "%.10f";
static File _f;
void file_io(string fn) { _f = File(fn, "r"); }
static string[] s_rd;
T _RD(... | D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
auto rd = readln.split.to!(int[]), n = rd[0], a = rd[1];
auto x = readln.split.to!(int[]), xs = x.sum;
auto dp = new long[][][](n+1, n+1, xs+1);
dp[0][0][0] = 1;
foreach (i; 0..n)
foreach (j; 0..n+1)
foreach (k; 0..xs... | 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;
int calc(int k, string ... | D |
void main()
{
int n = readln.chomp.to!int;
string s = readln.chomp;
int cnt = s[1..$].count('E').to!int;
int result = cnt;
foreach (i; 1 .. n)
{
if (s[i-1] == 'W') ++cnt;
if (s[i] == 'E') --cnt;
result = min(result, cnt);
}
result.writeln;
}
import std.stdio;
i... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric, std.container, std.range;
long floorSum(long n, long m, long a, long b)
{
long ans;
if (m <= a)
{
ans += (n - 1) * n * (a / m) / 2;
a %= m;
}
if (m <= b)
{
ans += n * (... | D |
void main()
{
long k = rdElem;
long total;
foreach (i; 1 .. k+1)
{
foreach (j; 1 .. k+1)
{
long g = gcd(i, j);
foreach (l; 1 .. k+1)
{
total += gcd(g, l);
}
}
}
total.writeln;
}
enum long mod = 10^^9 + 7;
... | D |
import std.conv, std.functional, std.range, std.stdio, std.string;
import std.algorithm, std.array, std.bigint, std.complex, std.container, std.math, std.numeric, std.regex, std.typecons;
import core.bitop;
class EOFException : Throwable { this() { super("EOF"); } }
string[] tokens;
string readToken() { for (; tokens.... | 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(int n) {
... | 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;
int calc(string s) {
... | D |
import std.stdio: writeln, readln;
import std.array: split;
void main() {
string[] s = readln.split;
if (s[0][$-1] == s[1][0] && s[1][$-1] == s[2][0])
writeln("YES");
else
writeln("NO");
}
| D |
import std.stdio;
import std.string;
import std.conv;
void main() {
auto n = to!int(readln.chomp!());
writeln(n / 3);
// to!(int[])(readln.split(",")).writeln;
}
| D |
void main() {
auto N = ri;
auto A = rs, B = rs, C = rs;
ulong cnt;
foreach(i; 0..N) {
if(A[i] == B[i] && B[i] == C[i]) continue;
if(A[i] == B[i] || B[i] == C[i] || C[i] == A[i]) cnt++;
else cnt+=2;
}
cnt.writeln;
}
// ===================================
import std.stdio;
import std.string;
import std.func... | D |
import std.stdio, std.conv, std.string, std.array, std.algorithm, std.math;
void main()
{
auto nm = readln.chomp.split(" ").map!(to!int);
auto n = nm[0];
auto m = nm[1];
auto stus = new int[2][n];
foreach (i; 0..n) stus[i] = readln.chomp.split(" ").map!(to!int).array;
auto cps = new int[2][m]... | 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, std.bitmanip;
immutable long MOD = 10^^9+7;
void main() {
auto N = readln.chomp.to!int;
auto cnt = new long[](10... | D |
import std.stdio, std.string, std.array, std.conv;
bool linearSearch(int n, int key, int[] x) {
int i = 0;
x ~= key;
while (x[i] != key) ++i;
return i != n;
}
void main() {
int n = readln.chomp.to!int;
int[] s = readln.chomp.split.to!(int[]);
int q = readln.chomp.to!int;
int[] t = read... | D |
void main()
{
long n = rdElem;
long k = 1L << n;
long[] a = k.rdCol;
auto st = SegTree!((x, y) => x == y ? x : abs(x-y), long, 0)(k);
foreach (i, x; a)
{
st.update(i, x);
}
st.tree[1].writeln;
}
struct SegTree(alias pred, T, T init)
{
import core.bitop;
alias F = binar... | D |
import std.stdio;
import std.conv;
import std.string;
import std.typecons;
import std.algorithm;
import std.array;
alias Tuple!(double, "x", double, "y") Point;
void main()
{
double[] input;
while ((input = readln().split().map!(to!double)().array()).length != 0) {
Point[3] p;
foreach (i, j; [0, 2, 4]) {
... | D |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.