code stringlengths 4 1.01M | language stringclasses 2
values |
|---|---|
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.array, std.string, std.conv, std.algorithm;
import std.typecons, std.range, std.random, std.math, std.container;
import std.numeric, std.bigint, core.bitop;
void main() {
auto s = readln.split.map!(to!int);
auto N = s[0];
auto M = s[1];
auto edges = new int[][](N);
foreach (_;... | 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;
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 readInts() {
return array(map!(to!int)(readln().strip().split()));
}
auto readInt() ... | 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.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.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 main()
{
auto ns = readln.split.to!(int[]);
auto N = ns[0];
auto A = ns[1];
auto B = ns[2];
auto C = ns[3];
int[] ls;
foreach (_; 0..N) ls ~= readln.chomp.to!int;
auto as = new i... | D |
import std.algorithm;
import std.bigint;
import std.concurrency;
import std.container;
import std.conv;
import std.functional;
import std.format;
import std.math;
import std.meta;
import std.numeric;
import std.random;
import std.range;
import std.stdio;
import std.string;
import std.traits;
import std.typecons;
auto... | D |
void main() {
auto N = rs;
auto arr = [2,4,5,7,9];
auto arr2 = [0,1,6,8];
if(arr.canFind(N.back - '0')) {
writeln("hon");
} else if(arr2.canFind(N.back - '0')) {
writeln("pon");
} else writeln("bon");
}
// ===================================
import std.stdio;
import std.string;
import std.functional;
import... | 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;
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 a = readNums!int;
foreach(i; 0 .. (2*a[0]-2)){
write(i + a[... | 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 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 scan(T...)(ref T args) {
import std.stdio : readln;
import std.algorithm : splitter;
import std.conv : to;
import std.range.primiti... | 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.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;
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 |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
long[] AS, BS;
void main()
{
auto N = readln.chomp.to!long;
AS = readln.split.to!(long[]);
BS = readln.split.to!(long[]);
long[][3] DP;
foreach (ref dp; DP) dp.length = N+1;
foreach_reverse ... | D |
void main(){
auto NMX = readLine!size_t();
size_t minCost = size_t.max;
size_t cost;
size_t[][] bookList;
foreach( n ; 0..NMX[0] ){
bookList ~= readLine!size_t();
}
size_t[] skillList;
foreach( i ; 0..(2.pow(NMX[0])) ){
skillList = new size_t[](NMX[1]);
cost = 0;
foreach( size_t j ; 0... | 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 nx = readln.split.to!(int[]);
auto N = nx[0];
auto x = nx[1];
if (x == 1 || x == N*2-1) {
writeln("No");
return;
}
writeln("Yes");
... | 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 |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array, std.math;
void main() {
int n, q;
scan(n, q);
auto sd = SqrtDecomp(n);
foreach (_ ; 0 .. q) {
auto line = readln.split.to!(int[]);
if (line[0] == 0) {
sd.add(line[1] - 1, line[2], line[3])... | 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 |
module app;
import core.bitop;
import std.algorithm;
import std.array;
import std.bigint;
import std.conv;
import std.stdio;
import std.string;
import std.traits;
struct Magic
{
int a;
int b;
}
struct Input
{
int h;
int n;
Magic[] m;
}
void parseInput(T)(out Input input, T file)
{
with (file) with (inp... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string;
void main()
{
auto nab = readln.split.to!(long[]);
auto n = nab[0];
auto a = nab[1];
auto b = nab[2];
auto hs = new long[n];
foreach (i; 0..n) {
hs[i] = readln.chomp.to!long;
}
auto d = a - b;
bool check(lo... | 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 |
// 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 n, a;
int[] x;
void main() {
scan(n, a);
x = readln.split.to!(int[]);
x[] ... | 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.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric, std.container;
void main()
{
auto nv = readln.split.to!(long[]);
auto N = nv[0];
auto V = nv[1];
auto aa = readln.split.to!(long[]);
auto bb = readln.split.to!(long[]);
auto cc = readln.split.... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto nm = readln.split.to!(int[]);
auto N = nm[0];
auto M = nm[1];
int as;
foreach (a; readln.split.to!(int[])) as += a;
writeln(max(-1, N - as));
} | 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 |
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 |
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.conv, std.array, std.string, std.math, std.typecons;
void main()
{
auto N = readln.chomp.to!int;
long s;
bool neq;
long[] AS, BS;
foreach (_; 0..N) {
auto ab = readln.split.to!(long[]);
auto A = ab[0];
auto B = ab[1];
s += A;
... | 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.conv, std.functional, std.string;
import std.algorithm, std.array, std.container, std.range, std.typecons;
import std.bigint, std.numeric, std.math, std.random;
import core.bitop;
string FMT_F = "%.10f";
static File _f;
void file_io(string fn) { _f = File(fn, "r"); }
static string[] s_rd;
T _RD(... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array, 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.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 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 |
void main()
{
string s = rdStr;
long[] cnts = new long[3];
foreach (x; s)
{
++cnts[x-'a'];
}
cnts.sort!"a < b";
writeln(cnts[2] - cnts[0] < 2 ? "YES" : "NO");
}
T rdElem(T = long)()
{
//import std.stdio : readln;
//import std.string : chomp;
//import std.conv : to;
... | 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.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 w; readV(w);
auto c = ne... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto nk = readln.split.to!(long[]);
auto N = nk[0];
auto K = nk[1];
auto S = readln.chomp.to!(char[]);
long[] NS;
long n;
char last;
foreach (c; S) {
if (c == la... | 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 std.functional,
std.algorithm,
std.bigint,
std.string,
std.traits,
std.array,
std.range,
std.stdio,
std.conv,
std.math;
void main() {
int N = readln.chomp.to!int;
int[] a = readln.chomp.split.to!(int[]);
int t = round((a.sum / a.length.to!doub... | 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 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 |
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;
/// 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 |
// 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.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 N = readln.chomp.to!int;
auto A = readln.split.map!(to!long).a... | D |
import std.array;
import std.conv;
import std.string;
import std.algorithm;
import std.stdio;
void main() {
int n = readln.chomp.to!int;
auto a = readln.chomp.split(' ').map!(to!int).array;
auto m = reduce!max(a);
int count;
bool top = false;
while (m > 0) {
foreach (ref e;a) {
if (top) {
if (e == m) {... | 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 inp = readln.chomp.split.to!(long[]);
long num;
if (inp[0] % inp[2]) {
i... | 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;
long[] ts, xs, ys;
foreach (_; 0..N) {
auto txy = readln.split.to!(long[]);
ts ~= txy[0];
xs ~= txy[1];
ys ~= txy[2];
}
... | D |
import core.bitop;
import std.algorithm;
import std.ascii;
import std.bigint;
import std.conv;
import std.functional;
import std.format;
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 =... | 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;
import std.array;
int n;
rd(n);
auto a = readln.split
.to!(int[])
.map!((e) => (e + 1))
.array;
int M = 100000 + 5;
auto map = new int[](M);
foreach (e; a) {
for (int d = -1; d <= 1; d++) {
map[e + d]++;
}
... | D |
import std.stdio, std.conv, std.array, std.string;
import std.algorithm;
import std.container;
void main() {
auto N = readln.chomp.to!int;
auto Hn = readln.split.to!(int[]);
int prev = Hn[0];
int count = 0;
int max_count = 0;
foreach(h; Hn[1..Hn.length]) {
if (h > prev) {
count = 0;
prev =... | 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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.