code stringlengths 4 1.01M | language stringclasses 2
values |
|---|---|
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;
bool valid(int mask) {
while (mask > 0) {
if ((mask & 0b11) == 0b11) {
... | D |
import std.algorithm, std.array, std.conv, std.range, std.stdio, std.string;
void main()
{
immutable n = readln.chomp.to!size_t;
ubyte[][] b;
foreach (i; 0..n)
b ~= cast(ubyte[])readln.chomp;
size_t ret;
foreach (i; 0..n)
{
ret += b.sym * n;
b = b[1..$] ~ b[0];
}
ret.writeln;
}
bool sym(T)(T[][] b)
{
... | D |
import std.stdio, std.string, std.conv;
import std.algorithm, std.array;
auto solve(string s_) {
immutable N = s_.to!int();
auto a = readln.split.map!(to!int).array();
uint n=1; while(n<N) n*=2;
auto s = new int[n*2]; s[]=-1;
void update(int v, int i) {
for(uint p=v-1+n; p>0; p/=2) s[p]=max(... | 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;
if (N == 0) {
"a".writeln;
return;
}
string ans = "";
cha... | D |
void main()
{
string s = rdStr;
writeln(s[0..4], " ", s[4..$]);
}
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 resul... | D |
import std.stdio, std.conv, std.array, std.string;
import std.algorithm;
void main() {
ulong count = 0;
int[string] dict;
auto N = readln.chomp.to!int;
foreach (i; 0..N) {
char[] line = readln.chomp.dup;
sort(line.representation);
auto word = line.to!string;
if (!(word in dict)) {
dict[... | D |
void main() {
auto s = rs;
ulong tmp;
foreach(i, v; s) {
if(v == 'A') {
tmp = i;
break;
}
}
foreach_reverse(i, v; s) {
if(v == 'Z') {
(i - tmp + 1).writeln;
return;
}
}
}
// ===================================
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import... | D |
import std.stdio, std.string, std.conv, std.algorithm;
int lcs(string x, string y) {
int m = x.length.to!int, n = y.length.to!int;
int[][] c = new int[][](m+1, n+1);
foreach (i; 1 .. m+1) {
foreach (j; 1 .. n+1) {
if (x[i-1] == y[j-1]) {
c[i][j] = c[i-1][j-1] + 1;
... | D |
void main() {
import std.stdio, std.string, std.conv, std.algorithm;
auto s = readln.chomp.to!(char[]);
auto t = readln.chomp.to!(char[]);
const no = "UNRESTORABLE";
if (t.length > s.length) {
writeln(no);
return;
}
char[][] cand;
for (size_t i = 0; i + t.length <= s.length; i++) {
bool ok... | D |
import std.algorithm;
import std.array;
import std.conv;
import std.math;
import std.stdio;
import std.string;
import std.range;
int readint() {
return readln.chomp.to!int;
}
int[] readints() {
return readln.split.map!(to!int).array;
}
struct S {
int node;
long cost;
}
long[] bfs(int k, int n, S[][i... | 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;
immutable long MOD = 10^^9+7;
void main() {
auto s = readln.split.map!(to!long);
auto N = s[0];
auto M = s[1... | D |
import std.stdio;
import std.string;
import std.conv;
import std.array;
void main()
{
ulong N = readln.split[0].to!ulong;
char[] S = readln.chomp.to!(char[]);
ulong K = readln.split[0].to!ulong;
foreach (i; 0..N) if (S[i] != S[K - 1]) S[i] = '*';
writeln(S.to!string);
}
| D |
import std.stdio, std.array, std.conv, std.string, std.algorithm, std.range;
void main() {
long n = readln.chomp.to!long;
long ans = 1;
for (long i = 1; i <= 20; i++) {
ans *= i;
}
ans.writeln;
} | D |
import std.stdio, std.conv, std.string;
void main(){
int n=to!int(chomp(readln()));
string s, t;
s=chomp(readln());
t=chomp(readln());
if(n==1){
writeln(3);
return;
}
const mod=1_000_000_000+7;
bool y=s[0]==t[0];
long c=y? 3: 6;
int i=y? 1: 2;
while(i<n){
if(i+1<n){
if(s[i]==t[... | 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 x = readln.chomp.to!int;
auto a = readln.chomp.... | 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 |
import std.stdio, std.string, std.conv, std.bigint, std.typecons, std.algorithm, std.array, std.math, std.range;
void main() {
auto tmp = readln.split.to!(uint[]);
auto A = tmp[0];
auto B = tmp[1];
auto C = tmp[2];
auto D = tmp[3];
auto E = tmp[4];
auto F = tmp[5];
real rateMax = 0;
... | D |
import std.stdio;
import std.algorithm;
import std.array;
import std.conv;
import std.string;
void main() {
int N = readln.chomp.to!int;
auto c = readln.chomp.split.map!(to!int).array;
int Q = readln.chomp.to!int;
bool flag = true;
int[] apple = new int[](N);
for (int i = 0; i < Q; i++) {
... | D |
import std.stdio, std.string, std.range, std.conv, std.array, std.algorithm, std.math, std.typecons;
void main() {
const tmp = readln.split.to!(long[]);
const A = tmp[0], B = tmp[1], K = tmp[2];
int cnt;
foreach_reverse (x; 1..min(A,B)+1) {
if (A % x == 0 && B % x == 0) {
if (++cnt... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
ulong[50] solve(ulong x)
{
ulong[50] r;
auto y = x;
size_t i;
while (y > 0) {
r[i] = x / 2^^(i+1) * 2^^i;
if (x % 2^^(i+1) >= 2^^i) r[i] += x % 2^^(i+1) + 1 - 2^^i;
++i;
... | 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 s = readln.strip;
writeln (s.maxElement);
}
}
| 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()
{
long A = scanElem;
long B = scanElem;
writeln((A-1)*(B-1));
}
class UnionFind{
Uni... | 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 |
import std.stdio, std.conv, std.string, std.math;
void main()
{
int input = to!int(chomp(readln()));
int i = 1;
if(input==1) {
writeln(1);
return;
}
while (pow(i, 2) <= input) {
i++;
}
writeln(pow(i-1, 2));
}
| D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto rgbn = readln.split.to!(int[]);
auto R = rgbn[0];
auto G = rgbn[1];
auto B = rgbn[2];
auto N = rgbn[3];
int ret;
foreach (r; 0..3001) {
foreach (g; 0..3001) {
... | D |
void main() {
import std.stdio, std.string, std.conv, std.algorithm;
int n, l, a;
rd(n, l, a);
auto s = new int[](n), t = new int[](n);
foreach (i; 0 .. n)
rd(s[i], t[i]);
long cnt = 0;
foreach (i; 1 .. n) {
cnt += (s[i] - (s[i - 1] + t[i - 1])) / a;
}
if (n > 0) {
cnt += (s[0]) / a;
... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.range;
void main()
{
auto s1 = split(readln());
bool flag;
foreach (ind; 0 .. to!int(s1[0]))
{
auto s2 = split(readln);
if (!s2.find("C").empty || !s2.find("M").empty || !s2.find("Y").empty)
{
flag = true;
break;
... | 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 |
// Code By H~$~C
module main;
import std.stdio, std.array, std.string, std.math, std.uni, std.format, std.bigint;
import std.algorithm, std.conv, std.container, std.range, std.functional;
import std.random, std.typecons;
// FIXME
int[] buildZ(in string s) {
int n = cast(int)(s.length);
int[] z; z.length = n;
f... | 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.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 |
import std.stdio;
import std.string;
void main ()
{
string s;
while ((s = readln.strip) != "")
{
long res = 0;
foreach (pos; 1..s.length + 1)
{
res += !(s[pos - 1] & 3);
if (pos > 1 && !((s[pos - 2] * 2 + s[pos - 1]) & 3))
{
res += pos - 1;
}
}
writeln (res);
}
}
| D |
import std.stdio, std.string, std.conv, std.algorithm;
import std.range, std.array, std.math, std.typecons;
immutable int inf = 10^^9 + 7;
int N, W;
int[] v, w;
void main() {
scan(N, W);
int vi, wi;
auto v = new int[](N);
auto w = new int[](N);
foreach (i ; 0 .. N) {
scan(vi, wi);
... | D |
import std.stdio, std.algorithm, std.conv, std.string, std.array, std.math;
void main()
{
const r = readln.chomp.to!int;
(r*r).writeln;
} | 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 s;
scan(s);
if (s.canFind("AC")) {
writeln("Yes");
}
else {
writeln("No");
}
}
void scan(T...)(ref T args) {
strin... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons;
enum PS = [11, 31, 41, 61, 71, 101, 131, 151, 181, 191, 211, 241, 251, 271, 281, 311, 331, 401, 421, 431, 461, 491, 521, 541, 571, 601, 631, 641, 661, 691, 701, 751, 761, 811, 821, 881, 911, 941, 971, 991, 1021, 1031, 1051, 1061,... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array;
import std.math : abs;
void main() {
int n;
scan(n);
int t, x, y;
bool ok = 1;
foreach (i ; 0 .. n) {
int ti, xi, yi;
scan(ti, xi, yi);
int dt = ti - t;
int dist = abs(xi - x) + a... | 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 a, b;
scan(a, b);
writeln(max(a + b,... | 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.ascii;
import std.conv;
import std.string;
import std.algorithm;
import std.range;
import std.functional;
import std.math;
import core.bitop;
void main()
{
auto nm = readln.chomp.split.map!(to!long);
long n = nm[0];
long m = nm[1];
auto A = readln.chomp.split.map!(to!long).... | 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()
{
string x, y; readV(x, y);
writeln(x > y ? ">" : x < y ? "<" : "=");
}
| D |
import std.stdio;
import std.conv;
import std.string;
import std.typecons;
import std.algorithm;
import std.array;
import std.range;
import std.math;
import std.regex : regex;
import std.container;
import std.bigint;
void main()
{
readln.chomp.count!(x=>x=='1').writeln;
}
| D |
import std.stdio, std.algorithm, std.range, std.conv, std.string;
import core.stdc.stdio;
// foreach, foreach_reverse, writeln
void main() {
int n;
scanf("%d", &n);
int[] a = new int[n];
int[] b = new int[n];
foreach (i; 0..n) scanf("%d", &a[i]);
foreach (i; 0..n) scanf("%d", &b[i]);
int ans = 0;
foreach (k; 0... | D |
// Vicfred
// https://atcoder.jp/contests/abc176/tasks/abc176_b
// implementation
import std.stdio;
import std.string;
void main() {
string n = readln.strip;
int sum = 0;
foreach(ch; n) {
sum += ch - '0';
sum %= 9;
}
if(sum == 0)
"Yes".writeln;
else
"No".writel... | 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, std.algorithm;
void main()
{
auto ip = readln.split.to!(int[]), a = ip[0], b = ip[1];
int s = max(a+b, a-b, a*b);
writeln(s);
} | D |
import std.stdio, std.array, std.conv, std.string, std.range, std.algorithm;
void main() {
long n = readln.strip.to!(long);
string s = readln.strip;
long l = 0, r = s.length - 1;
while (l < s.length && s[l] == '.') {
l++;
}
while (r >= 0 && s[r] == '#') {
r--;
}
r++;
... | 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;
immutable long MOD = 10^^9 + 7;
long powmod(long a, long x, long m) {
long ret = 1;
while (x) {
if (x % 2) ret = ret * a %... | D |
import std.stdio, std.typecons, std.algorithm;
alias Tuple!(int, "top", int, "bottom") Bundle;
const int INF = (1 << 24);
void main() {
int times; scanf("%d", ×);
int[][] dp = new int[][](times, times);
Bundle[] cards;
foreach(i; 0..times) {
int top, bottom; scanf("%d %d", &top, &bottom);
cards... | D |
import std.algorithm, std.container, std.conv, std.math, std.range, std.typecons, std.stdio, std.string;
auto rdsp(){return readln.splitter;}
void pick(R,T)(ref R r,ref T t){t=r.front.to!T;r.popFront;}
void readV(T...)(ref T t){auto r=rdsp;foreach(ref v;t)pick(r,v);}
void main()
{
string s; readV(s);
writeln(min(... | D |
import std.algorithm;
import std.array;
import std.conv;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.traits;
class InputReader {
private:
ubyte[] p;
ubyte[] buffer;
size_t cur;
public:
this () {
buffer = uninitializedArray!(ubyte[])(16<<20);
p = stdin.rawRead ... | 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()
{
int[string] cnt;
string len;
auto str = readln.split;
foreach (s; str) {
if (s.length > len.length) {... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string;
void main()
{
auto T = readln.chomp.split(" ")[1].to!long;
auto ts = readln.chomp.split(" ").map!(to!int);
long sum;
int last = 0;
foreach (t; ts[1..$]) {
if (t - last < T)
sum += (t - last);
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 |
import std.stdio;
import std.array;
import std.conv;
import std.string;
import std.algorithm;
void main()
{
string s;
while( (s=readln.strip) != "0 0") {
auto n = map!(to!int)(s.strip.split);
int h = n[0], w = n[1];
writeln(replicate("#",w));
for(int i=1;i<h-1;i++) {
... | D |
import std.stdio, std.conv, std.functional, std.string;
import std.algorithm, std.array, std.container, std.range, std.typecons;
import std.numeric, std.math, std.random;
import core.bitop;
string FMT_F = "%.10f";
static string[] s_rd;
T RD(T = long)() { while(!s_rd.length) s_rd = readln.chomp.split; string res = s_r... | D |
import std.stdio, std.conv, std.string, std.range, std.algorithm, std.array,
std.functional, std.container, std.typecons;
void main() {
int N = readln.chomp.to!int;
int[] d = readln.split.to!(int[]);
int ans = 0;
foreach(i; 0..N) {
foreach(j; (1+i)..N) {
ans += d[i] * d[j];
}
}
ans.writeln... | D |
import std.algorithm, std.conv, std.range, 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!(ElementType!T);r.popFront;}}
void readM(T...)(size_... | D |
void main(){
import std.stdio, std.string, std.conv, std.algorithm;
int n; rd(n);
auto d=new int[](n);
foreach(i; 0..n) rd(d[i]);
bool ok=true;
void f(){
int r=0;
foreach(int i, int e; d){
ok&=i*10<=r;
chmax(r, i*10+e);
}
}
f();
reverse(d);
f();
if(ok) writeln("yes");
... | 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;
import std.concurrency;
void times(alias fun)(int n) {
foreach(i... | 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;
import std.concurrency;
long MOD = 10L^^9+7;
long f(long x, long y)... | D |
import std.algorithm;
import std.array;
import std.conv;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
immutable int letters = 26;
string solve (string s)
{
auto n = s.length.to !(int);
if (n == letters)
{
auto t = s.dup;
if (nextPermutation (t.representation))
{
auto r = t.i... | 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() {
int n, q;
scan(n, q);
while (q--) {
int vi, wi;
scan(vi, wi);
solve(n, vi, wi);
}
}
void solve(int n, int v, int w... | 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.conv,std.string;
void main(){
auto n=readln.chomp.to!int;
(n%2==0?n/2:n/2+1).writeln;
} | D |
import std.functional,
std.algorithm,
std.bigint,
std.string,
std.traits,
std.array,
std.range,
std.stdio,
std.conv;
void main() {
ulong[] NM = readln.chomp.split.to!(ulong[]);
ulong N = NM[0],
M = NM[1];
ulong x = 1900*M + 100*(N - M);
ulong p = ... | D |
import std.stdio, std.string, std.array, std.conv;
void insertionSort(int n, int[] x) {
foreach (i; 1 .. n) {
int v = x[i];
int j = i - 1;
while (j >= 0 && x[j] > v) {
x[j+1] = x[j];
--j;
}
x[j+1] = v;
foreach (k, y; x) {
y.write;
... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.array;
import std.range;
import std.math;
import std.regex;
void main(){
auto a=readln.split.to!(int[]),n=a[0],k=a[1];
if(n%k>0)writeln(1);
else if(n%k==0)writeln(0);
} | D |
import std.algorithm;
import std.array;
import std.conv;
import std.math;
import std.range;
import std.stdio;
import std.string;
auto a = ["SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"];
void main() {
auto s = readln.strip;
foreach (i; 0 .. a.length) {
if (a[i] == s) {
writeln (7 - i);
break;
... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto nc = readln.split.to!(long[]);
auto N = nc[0];
auto C = nc[1];
long[] xs, vs;
foreach (_; 0..N) {
auto xv = readln.split.to!(long[]);
xs ~= xv[0];
vs ~= ... | 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.chomp;
auto T = readln.chomp;
auto N = S.length.to!int;
auto M = T.length.t... | D |
import std.stdio, std.string, std.range, std.conv, std.algorithm, std.typecons;
void main(){
alias Tuple!(int, int) Data;
int N, M;
auto input = readln.split.map!(to!int);
N = input[0], M = input[1];
int[] A = new int[N]; //?????¨
foreach (i; 0..N) {
A[i] = readln.chomp.to!int;
}
int[] vote = new int[N];
for... | D |
import std.algorithm;
import std.array;
import std.conv;
import std.numeric;
import std.stdio;
import std.string;
void main()
{
long n;
long sum;
n = readln.chomp.to!(long);
sum = 0;
for (long i = 1; i <= n; i++) {
for (long j = 1; j <= n; j++) {
for (long k = 1; ... | D |
import std.stdio;
import std.ascii;
import std.conv;
import std.string;
import std.algorithm;
import std.range;
import std.functional;
import std.math;
import core.bitop;
void main()
{
auto n = readln.chomp.to!long;
foreach (seven; 0 .. (n / 7 + 1))
{
if ((n - (7 * seven)) % 4 == 0)
{
... | D |
import std;
void main(string[] args){ if(args.length > 1) if(args[1] == "-debug") DEBUG = 1; solve(); } bool DEBUG = 0;
void log(A ...)(lazy A a){ if(DEBUG) print(a); }
void print(){ writeln(""); } void print(T)(T t){ writeln(t); } void print(T, A ...)(T t, A a){ std.stdio.write(t, " "), print(a); }
string unsplit(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 readC(T...)(size_t n,ref T t){foreach(ref v;t)... | 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);
auto s = readln.chomp;
int e, w;
foreach (i ; 0 .. n) {
if (s[i] == 'E') e++;
}
int ans = 1<<3... | D |
void main()
{
long n, m;
rdVals(n, m);
Edge[][] edge = new Edge[][](n);
foreach (i; 0 .. m)
{
long l, r, d;
rdVals(l, r, d);
--l, --r;
edge[l] ~= Edge(r, d), edge[r] ~= Edge(l, -d);
}
bool[] seen = new bool[n];
long[] dist = new long[n];
bool ok = tru... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string;
void main()
{
auto str = readln.split(" ");
writeln(
str[0][$-1] == str[1][0] && str[1][$-1] == str[2][0] ? "YES" : "NO"
);
} | 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()
{
long n = rdElem;
long[] a = rdRow;
bool minus;
bool zero;
long result;
long amin = 1L << 60;
foreach (x; a)
{
result += x.abs;
amin = min(amin, x.abs);
if (x < 0) minus ^= true;
if (x == 0) zero = true;
}
if (minus && !zero) result -... | D |
import std.stdio;
import std.array;
import std.string;
import std.conv;
import std.algorithm;
import std.typecons;
import std.range;
import std.random;
import std.math;
import std.container;
void main() {
auto input = readln.split.map!(to!int);
int W = input[0];
int H = input[1];
int N = input[2];
int[4] A =... | 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);
int k; readV(k);
auto r = 10^^9;
foreach (i; 0..1<<n) {
auto d =... | 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, std.algorithm, std.range, std.conv, std.string, std.math;
import core.stdc.stdio;
// foreach, foreach_reverse, writeln
class BIT {
int[] data;
this(int n) {
data = new int[n+1];
}
BIT dup() {
BIT ret = new BIT(to!int(data.length));
ret.data = data.dup;
return ret;
}
void add(int i, int ... | 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 M = 2 * N - 1;
auto A = readln.split.map!(to!int).array;
int hi = M + 1;
... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math;
void main()
{
auto it = readln.split.to!(int[]);
auto A = it[0];
auto B = it[1];
auto C = it[2];
auto X = it[3];
auto Y = it[4];
int cost;
if (A + B > C*2) {
if (X > Y) {
cost += 2 * Y * C;... | D |
import std.stdio, std.conv, std.string;
void main()
{
int N = to!int(chomp(readln()));
string str = to!string(N);
int count;
foreach(char chr; str) {
count += to!int(chr)-48;
}
if(N % count == 0) {
writeln("Yes");
} else writeln("No");
}
| D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
int n;
foreach (c; readln.chomp) {
if (c == '+') {
++n;
} else {
--n;
}
}
writeln(n);
} | 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;
import std.array;
import std.string;
import std.conv;
import std.algorithm;
import std.typecons;
import std.range;
import std.random;
import std.math;
import std.container;
void main() {
auto S = readln.chomp;
char c = S[0];
int ans = 0;
foreach (s; S)
if (s != c) {
ans += 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 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.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 |
import std.stdio, std.array, std.conv, std.algorithm, std.string, std.numeric, std.range;
void main() {
string s;
while( (s=readln.strip).length != 0 ){
auto as = s.to!int;
if(as == 0) break;
int ans = 0;
while(0 < as){
ans += as/5;
as /= 5;
}
writeln(ans);
}
} | 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;
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 r... | D |
import std.algorithm;
import std.array;
import std.conv;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
T read(T)() { return readln.chomp.to!T; }
T[] reads(T)() { return readln.split.to!(T[]); }
alias readint = read!int;
alias readints = reads!int;
int calc(int[] a) {
... | D |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.