code stringlengths 4 1.01M | language stringclasses 2
values |
|---|---|
module main;
import core.stdc.stdio;
import std.algorithm;
int gcd(int a, int b){
while (a > 0 && b > 0){
if (a > b){
a = a % b;
} else {
b = b % a;
}
}
return a + b;
}
int main(string[] argv)
{
int n;
scanf("%d", &n);
int [] arr = new int[n];
for(int i = 0; i<n; i++)
scanf("%d", &arr[i]);
arr.sor... | D |
import std.stdio, std.range, std.conv, std.algorithm, std.array, std.string, std.ascii, std.math;
void main() {
readln;
auto a = readln.strip, b = readln.strip;
uint sum;
foreach (i, e; a) {
auto tmpA = e.to!int, tmpB = b[i].to!int;
auto minA = min(tmpA, tmpB), maxB = max(tmpA, tmpB);
auto cl = maxB - min... | D |
module sigod.codeforces.p290D;
import std.conv;
import std.stdio;
import std.string;
void main()
{
string str = stdin.readln().strip();
int value = stdin.readln().strip().to!int();
stdout.write(solve(str, value));
}
string solve(string str, int value)
{
string result;
foreach (ref ch; str.toLower()) {
if (c... | 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;
long sd(long n)
{
long res = 0;
while(n)
{
res += n % 10;
n /= 10;
}
return res;
}
long pmod(long a, long m)
{
return (a%m + m)%m;
}
... | D |
import std.algorithm;
import std.conv;
import std.range;
import std.stdio;
import std.string;
void main ()
{
string s;
while ((s = readln.strip) != "")
{
auto n = s.length.to !(int);
s ~= s;
int res = 1;
int cur = 1;
foreach (i; 1..n * 2)
{
if (s[i - 1] != s[i])
{
cur += 1;
res = max (res,... | D |
import core.bitop;
import std.algorithm;
import std.ascii;
import std.bigint;
import std.conv;
import std.functional;
import std.math;
import std.numeric;
import std.range;
import std.stdio;
import std.string;
import std.random;
import std.typecons;
alias sread = () => readln.chomp();
alias Point2 = Tuple!(long, "y", ... | D |
import std.stdio, std.string, std.array, std.conv, std.algorithm;
void main() {
foreach (i; 0 .. 3000) {
int[] x = readln.chomp.split.to!(int[]);
if (x[0] == 0 && x[1] == 0) break;
writeln(min(x[0], x[1]), " ", max(x[0], x[1]));
}
}
| 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 N = readln.chomp.to!int;
long ans = 0;
foreach (i; 1..N+1) if (i % 3 != 0 && i % 5 != 0) an... | D |
import std.stdio, std.string, std.conv;
void main(){
for(uint i;;++i){
auto a = readln.chomp.to!int;
if(!a) break;
writeln("Case ",i+1,": ",a);
}
} | 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;
int n, x;
int[] a;
void main() {
scan(n, x);
a = readln.split.to!(int[]);
auto b = a.dup();
long ans = 10L... | 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;
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.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.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 (n - a.count (a.minElement));
}
}
| D |
// import chie template :) {{{
static if (__VERSION__ < 2090) {
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,
std.bitmanip, std.numeric;
} else {
import std;
}
// }}}
// nep.scanner {{{
class Scanner {
... | D |
// problem: http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=GRL_3_A
// require: graph/articulation_points.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;
//LRD... | D |
import std.stdio, std.string, std.conv;
import std.algorithm, std.array, std.range;
import std.bigint, std.math;
auto solve(string s_)
{
immutable N = s_.to!int();
auto AS = new long[N];
foreach(ref v;AS) v=readln.chomp().to!long();
immutable M=AS.reduce!max();
immutable M2=sqrt(M.to!real()).to!lo... | D |
pragma(inline, true)
void chmin(T)(ref T a, T b) {
if (a > b) a = b;
}
int[] init() {
enum INF = 1 << 28;
int[] dp = new int[100010];
foreach (i; 1..100001) {
dp[i] = INF;
int p6 = 1, p9 = 1;
while (p6 <= i || p9 <= i) {
if (i - p6 >= 0)
chmin(dp[i], ... | 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 |
//dlang template---{{{
import std.stdio;
import std.conv;
import std.string;
import std.array;
import std.algorithm;
import std.typecons;
import std.math;
import std.range;
// MIT-License https://github.com/kurokoji/nephele
class Scanner
{
import std.stdio : File, stdin;
import std.conv : to;
import std.array : ... | D |
void main()
{
long[] tmp = readln.split.to!(long[]);
long n = tmp[0], m = tmp[1];
long[] p = readln.split.to!(long[]);
p[] -= 1;
auto tree = UnionFind(n);
foreach (i; 0 .. m)
{
tmp = readln.split.to!(long[]);
long x = tmp[0] - 1, y = tmp[1] - 1;
tree.unite(p[x], p[y]... | D |
import std.stdio, std.typecons, std.algorithm;
alias Tuple!(int, "top", int, "bottom") Bundle;
const int INF = (1 << 24);
void main() {
uint times; scanf("%d", ×);
uint[][] dp = new uint[][](times, times);
Bundle[] cards;
foreach(t; 0..times) {
uint top, bottom; scanf("%d %d", &top, &bottom);
c... | 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()
{
string s;
scan(s);
// writeln(s[0]);
long x;
long y;
foreach (i; 0 .. s.length)
{
if (s[i] == '0')
... | D |
import std.algorithm;
import std.array;
import std.container;
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[]... | D |
import std.stdio;
import std.algorithm;
import std.string;
import std.functional;
import std.array;
import std.conv;
import std.math;
import std.typecons;
import std.regex;
import std.range;
void main(){
int n = readln().chomp().to!int;
for(int i=0;i<n;i++){
int point,o,r;
while(true){
string s = readl... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto S = readln.chomp;
writeln(S[1] == 'B' ? "ARC" : "ABC");
} | 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.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric, std.container, std.range;
int celiPow2(int n)
{
int x = 0;
while ((1u << x) < cast(uint)(n))
x++;
return x;
}
struct Segtree(S, alias op, alias e)
{
import std.functional : binaryFun, unaryFu... | D |
/+ dub.sdl:
name "B"
dependency "dcomp" version=">=0.6.0"
+/
import std.stdio, std.algorithm, std.range, std.conv;
// import dcomp.foundation, dcomp.scanner;
int main() {
auto sc = new Scanner(stdin);
int n;
int[] a;
sc.read(n, a); a[] -= 1;
bool[] b = n.iota.map!(i => i == a[i]).array;
... | D |
void main() {
int n = readln.chomp.to!int;
int[] a = readln.split.to!(int[]);
int cnt;
while (a.all!(t => t % 2 == 0)) {
a[] /= 2;
++cnt;
}
cnt.writeln;
}
import std.stdio;
import std.string;
import std.array;
import std.conv;
import std.algorithm;
import std.range;
import std.m... | 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 |
void main() {
("aiueo".canFind(rs) ? "vowel" : "consonant").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.numeric;
import std.conv;... | D |
import std.stdio, std.conv, std.string, std.bigint;
import std.math, std.random, std.datetime;
import std.array, std.range, std.algorithm, std.container;
string read(){ static string[] ss; while(!ss.length) ss = readln.chomp.split; string res = ss[0]; ss.popFront; return res; }
// 26文字より少ない → まだ使っていない最小の文字を追加する
// zyx... | D |
import std.stdio,std.math,std.string,std.conv,std.typecons,std.format;
import std.algorithm,std.range,std.array,std.numeric;
T[] readarr(T=long)(){return readln.chomp.split.to!(T[]);}
void scan(T...)(ref T args){auto input=readln.chomp.split;foreach(i,t;T)args[i]=input[i].to!t;}
struct Queue(T){T[]e;auto enq(T t){e~=t... | D |
void main()
{
long[] tmp = readln.split.to!(long[]);
long n = tmp[0], m = tmp[1];
writeln((100 * (n - m) + 1900 * m) * 2 ^^ m);
}
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;
impor... | D |
void main(){
int s, w;
scanf("%d %d", &s, &w);
if( s<=w )writeln("unsafe");
else writeln("safe");
}
import std.stdio, std.conv, std.algorithm, std.numeric, std.string, std.math;
// 1要素のみの入力
T _scan(T= int)(){
return to!(T)( readln().chomp() );
}
// 1行に同一型の複数入力
T[] _scanln(T = int)(){
T[] ln;
foreach(string el... | D |
module b;
import std.conv, std.stdio;
import std.algorithm, std.array, std.string, std.range;
void main()
{
auto buf = readln.chomp.split.to!(int[]);
auto votes = readln.chomp.split.to!(int[]);
auto s = votes.sum;
auto popular = votes.count!(a => s <= a * 4 * buf[1]);
((buf[1] <= popular) ? "Yes" ... | 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!(int[]);
writeln(min(1, tmp[0] % tmp[1]));
}
| 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;
auto days = ["SUN","MON","TUE","WED","THU","FRI","SAT"];
foreach(i; 0..7) {
if (N == days[i]) {
writeln(7-i);
... | D |
import std.algorithm;
import std.stdio;
import std.string;
void main()
{
auto n = readln;
auto s = readln.strip;
auto lts = new int[ s.length ];
auto rts = new int[ s.length ];
auto result = int.max;
lts[ 0 ] = 0;
rts[ $-1 ] = 0;
for( int index = 1; index < s.length; index++ )
{
lts[ index ] = lts[ ind... | 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;
auto x = new int [] [] (n + 1, n + 1);
foreach (i; 0... | D |
void main(){
int[] ab = _scanln();
if( ab[0]>ab[1] )writeln(ab[0]+ab[0]-1);
else if( ab[0]<ab[1] )writeln(ab[1]+ab[1]-1);
else writeln(ab[0]*2);
}
import std.stdio, std.conv, std.algorithm, std.numeric, std.string, std.math;
// 1要素のみの入力
T _scan(T= int)(){
return to!(T)( readln().chomp() );
}
// 1行に同一型の複数入力
T[] ... | D |
import std.stdio, std.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 |
// Try Codeforces
// author: Leonardone @ NEETSDKASU
import std.stdio : readln, writeln;
import std.array : split;
import std.string : chomp;
import std.conv : to;
void main()
{
auto n = readln.chomp.to!int;
auto ts = readln.chomp.split.to!(int[]);
auto ord = new int[n + 1];
auto ti... | 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;
import std.conv;
import std.string;
void main()
{
auto N = readln.chomp.to!long;
writeln(N / 3);
}
| D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto N = readln.chomp.to!int;
auto as = new int[](N);
foreach (i; 0..N) as[i] = readln.chomp.to!int;
sort!"a > b"(as);
uint x;
foreach (i; 1..N) if ((as[i-1] - as[i]) % 2) {
... | 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 k = readln.chomp.to!int;
auto x = 1;
foreac... | D |
import std.stdio;
import std.algorithm;
import std.conv;
import std.array;
import std.string;
import std.math;
import std.functional;
import std.range;
import std.typecons;
import std.format;
void main(string[] args) {
readln.solve.writeln;
}
auto solve(string line1) {
auto _ = line1.split.map!(to!real);
real a... | 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()
{
long n, a, b;
rdVals(n, a, b);
long c = a + b;
long d = n / c, r = n % c;
writeln(a * d + min(a, r));
}
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 = rd... | 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, std.conv, std.functional, std.string;
import std.algorithm, std.array, std.container, std.typecons;
import std.numeric, std.math;
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_rd[0]; s_rd.popFront; re... | D |
void main()
{
long[] nmq = rdRow;
long n = nmq[0], m = nmq[1], q = nmq[2];
long[][] lists = new long[][](n+1, n+1);
foreach (i; 0 .. m)
{
long[] tmp = rdRow;
long l = tmp[0], r = tmp[1];
++lists[l][r];
}
foreach (i; 1 .. n+1)
{
foreach (j; 1 .. n+1)
... | 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.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 c1 = readln.chomp;
auto c2 = readln.chomp;
if (c1[0] == c... | 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;
import std.range;
import std.array;
import std.string;
import std.conv;
import std.typecons;
import std.algorithm;
import std.container;
import std.typecons;
import std.random;
import std.csv;
import std.regex;
import std.math;
import core.time;
import std.ascii;
import std.digest.sha;
import std.outb... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto abx = readln.split.to!(int[]);
auto c = abx[2] - abx[0];
writeln(c >= 0 && c <= abx[1] ? "YES" : "NO");
} | D |
import std.stdio, std.string, std.conv;
void main() {
string t = readln.chomp;
string p = readln.chomp;
int i = 0;
while (true) {
i = indexOf(t, p, i).to!int;
if (i == - 1) break;
i.writeln;
++i;
}
}
| D |
import std.stdio, std.string, std.conv;
void main() {
int[] tmp = readln.split.to!(int[]);
int a = tmp[0], b = tmp[1];
writeln(0 < a && a < 10 && 0 < b && b < 10 ? a * b : -1);
} | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto N = readln.chomp.to!int;
auto cs = new int[](101);
foreach (n; 2..N+1) {
foreach (d; 2..N+1) {
while (n%d == 0) {
cs[d] += 1;
n /= d;... | D |
import std.stdio, std.string, std.conv, std.range;
import std.algorithm, std.array, std.typecons, std.container;
import std.math, std.numeric, std.random, core.bitop;
enum inf = 1_001_001_001;
enum infl = 1_001_001_001_001_001_001L;
void main() {
int M;
scan(M);
auto d = new long[](M);
auto c = new ... | 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.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, 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);
if (n == 1) {
... | D |
import std.stdio;
import std.algorithm;
import std.conv;
import std.typecons;
void main() {
int n;
scanf("%d", &n);
auto ipt = new Tuple!(int, int)[n];
foreach(i;0..n) {
int a, b;
scanf("%d %d", &a, &b);
ipt[i] = tuple(a, b);
}
ipt.sort!((a, b) => a[1] < b[1]);
int t;
foreach(x; ipt){
t += x[0];
if (... | D |
import std.algorithm, std.container, std.conv, std.math, std.range, std.typecons, std.stdio, std.string;
void readV(T...)(ref T t){auto r=readln.splitter;foreach(ref v;t){v=r.front.to!(typeof(v));r.popFront;}}
void readA(T)(size_t n,ref T[]t){t=new T[](n);auto r=readln.splitter;foreach(ref v;t){v=r.front.to!T;r.popFro... | D |
import std.stdio, std.array, std.string, std.conv, std.algorithm;
import std.typecons, std.range, std.random, std.math, std.container;
import std.numeric, std.bigint, core.bitop, core.stdc.string;
bool check(string S, string T) {
while (!S.empty && !T.empty) {
if (S.length > T.length) {
swap(S,... | 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 X = readln.chomp.to!int;
auto dp = new int[](100);
dp[] = 1 << 29;
dp[0] = 0;
fore... | 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[] xs) {
... | 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 h = readln.chomp.to!int;
auto w = readln.chomp.to!int;
aut... | D |
void main(){
import std.stdio, std.string, std.conv, std.algorithm;
int h, w; rd(h, w);
auto c=new char[][](h, w);
foreach(i; 0..h) c[i]=readln.chomp.to!(char[]);
auto dd=[[1, 0], [0, 1], [-1, 0], [0, -1], [1, 1], [1, -1], [-1, 1], [-1, -1]];
foreach(i; 0..h)foreach(j; 0..w)if(c[i][j]!='#'){
int cnt=0... | D |
import std.stdio;
import std.conv;
import std.algorithm;
import std.string;
import std.file;
import std.math;
int main() {
string l;
l = readln().split[0];
int c = to!int(l); // iteration
int d = 100000; // debt
for(int i=0; i<c; i++){
d *= 1.05;
... | 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;
import core.bitop;
// dfmt off
ulong MAX = 100_100, MOD = 1_000_000_007, INF = 1_000_000_000_000;
alias sread = () => readln.chomp();
alias lread(T = long) = () => readln.chomp.to!(T);
alias aryread(T = long) = () => readln.split.to!(T[]);
void aryWrite(T = long)(T[] ary){ ary.map!(x => x.text()).join(' ')... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array, std.math;
long n, m;
void main() {
scan(n, m);
auto cmb = new long[][](n + 1, n + 1);
auto dp = new long[][](n + 1, n + 1);
foreach (i ; 0 .. n + 1) {
cmb[i][0] = cmb[i][i] = 1;
dp[i][0] = dp[i][i] = 1... | 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 INF = 1L << 58;
void main() {
auto s = readln.split.map!(to!int);
auto N = s[0];
auto Q = s[1];
... | D |
import std.stdio;
import std.algorithm;
import std.string;
import std.range;
import std.array;
import std.conv;
import std.complex;
import std.math;
import std.ascii;
import std.bigint;
import std.container;
import std.typecons;
auto readInt() {
return readInts()[0];
}
auto readInts() {
return array(map!(to!int)(rea... | D |
import core.bitop, std.algorithm, std.ascii, std.bigint, std.conv,
std.functional, std.math, std.numeric, std.range, std.stdio, std.string,
std.random, std.typecons, std.container;
ulong MAX = 1_000_100, MOD = 1_000_000_007, INF = 1_000_000_000_000;
alias sread = () => readln.chomp();
alias lread(T = long) = (... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array;
import std.math;
void main() {
int n;
scan(n);
auto a = readln.split.to!(int[]);
a = [0] ~ a ~ [0];
long s;
foreach (i ; 1 .. n + 2) {
s += abs(a[i] - a[i-1]);
}
foreach (i ; 1 .. n + 1) {
... | D |
import std.stdio, std.string, std.array, std.conv;
bool binarySearch(int n, int key, int[] x) {
int l = 0, r = n, m;
while (l < r) {
m = (l + r) / 2;
if (key == x[m]) return true;
if (key < x[m]) {
r = m;
} else {
l = m + 1;
}
}
return fal... | D |
void main()
{
long n = rdElem;
long p = 1;
foreach (i; 1 .. n+1)
{
p = p * i % mod;
}
p.writeln;
}
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!(d... | 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 X = readln.split.map!(to!int).array;
auto L = readln.chomp.to!int;
auto dp... | D |
import std.algorithm;
import std.conv;
import std.stdio;
import std.string;
void main() {
int w = readln.chomp.to!int;
int[] amida;
amida.length = w + 1;
foreach (i, ref n; amida) {
n = i.to!int;
}
int n = readln.chomp.to!int;
for (int i = 0; i < n; i++) {
auto ab = readln.chomp.split(",").map!... | 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, std.datetime;
void main() {
auto N = readln.chomp.to!int;
auto A = readln.split.map!(to!long).array;
long ans = N... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math;
int[int] HS;
void main()
{
auto N = readln.chomp.to!int;
auto as = readln.split.to!(int[]);
foreach (a; as) {
if (a in HS)
++HS[a];
else
HS[a] = 1;
}
int cnt;
foreach (i, h; HS) ... | D |
void main(){
int n = _scan();
int[] ans_arr = [1, 2, 4, 8, 16, 32, 64];
int ans;
foreach(elm; ans_arr){
if(elm>n)break;
ans = elm;
}
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行に同一型の... | D |
/+ dub.sdl:
name "C"
dependency "dcomp" version=">=0.6.0"
+/
import std.stdio, std.algorithm, std.range, std.conv;
// import dcomp.foundation, dcomp.scanner, dcomp.algorithm;
// import dcomp.numeric.primitive;
int main() {
auto sc = new Scanner(stdin);
int n;
sc.read(n);
long f = 1;
foreac... | D |
import std.stdio;
import std.algorithm;
import std.string;
import std.functional;
import std.array;
import std.conv;
import std.math;
import std.typecons;
import std.regex;
import std.range;
void main(){
int n = readln().chomp().to!int;
for(int i=0;i<n;i++){
char[] s = readln().chomp().to!(char[]);
if(s.len... | 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.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.conv, std.algorithm;
void main(string[] args) {
readln();
auto p = readln().chomp.split.map!(to!int);
int a;
for(int i; i<p.length; i++){
if(p[i]==i+1){a++; i++;}
}
a.writeln;
} | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto N = readln.chomp.to!int;
auto as = readln.split.to!(uint[]);
int[uint] MEMO;
foreach (a; as) {
if (a !in MEMO) MEMO[a] = 0;
++MEMO[a];
}
uint[] ns;
forea... | D |
import core.bitop;
import std.algorithm;
import std.ascii;
import std.bigint;
import std.conv;
import std.functional;
import std.math;
import std.numeric;
import std.range;
import std.stdio;
import std.string;
import std.random;
import std.typecons;
alias sread = () => readln.chomp();
alias Point2 = Tuple!(long, "y", ... | D |
import std.stdio, std.conv, std.string;
void main() {
auto ip = readln.split.to!(int[]);
if(ip[0] % 3 == 0 || ip[1] % 3 == 0 || (ip[0] + ip[1]) % 3 == 0){
writeln("Possible");
} else {
writeln("Impossible");
}
} | D |
import std.stdio, std.string, std.conv;
import std.array, std.algorithm, std.range;
void main()
{
immutable string[7] W = [
"Monday",
"Tuesday",
"Wednesday",
"Thursday",
"Friday",
"Saturday",
"Sunday"];
immutable int[12] D = [0,31,29,31,30,31,30,31,31,30,... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array;
void main() {
int n, a;
scan(n);
scan(a);
writeln(n % 500 <= a ? "Yes" : "No");
}
void scan(T...)(ref T args) {
import std.stdio : readln;
import std.algorithm : splitter;
import std.conv : to;
impo... | 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 d = readln.chomp.split.to!(int[]);
if (d[0] == d[1] && d[1] == d[2]) writeln("... | D |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.