code stringlengths 4 1.01M | language stringclasses 2
values |
|---|---|
/* imports all std modules {{{*/
import
std.algorithm,
std.array,
std.ascii,
std.base64,
std.bigint,
std.bitmanip,
std.compiler,
std.complex,
std.concurrency,
std.container,
std.conv,
std.csv,
std.datetime,
std.demangle,
std.encoding,
std.exception,
std.file,
std.format,
std.functi... | D |
import std.conv;
import std.stdio;
import std.string;
void main()
{
auto s = readln.strip;
writeln( solve( s ) );
}
auto solve( in string s )
{
auto n = s.to!int;
auto sn = 0;
foreach( c; s )
{
sn += [ c ].to!int;
}
return ( n % sn == 0 ) ? "Yes" : "No";
}
unittest
{
assert( solve( "12" ) == "Yes" );... | D |
// cheese-cracker [2022-02-12]
void solve(){
int n = scan!int;
auto arr = scanArray;
long summ = 0;
for(int i = 1; i <= n; ++i){
summ += i * (n + 1 - i);
}
for(int i = 1; i <= n; ++i){
if(arr[i-1] == 0){
summ += i * (n + 1 - i);
}
}
writeln(summ);
}
... | 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, std.format;
string read(){ static string[] ss; while(!ss.length) ss = readln.chomp.split; string res = ss[0]; ss.popFront; return res; }
/*
部分文字列 文字列の一致
sのi文字目までとt... | D |
// Vicfred
// https://atcoder.jp/contests/abc162/tasks/abc162_c
// math
import std.conv;
import std.stdio;
import std.string;
long gcd(long a, long b) {
if(b == 0)
return a;
return gcd(b, a%b);
}
long gcd(long a, long b, long c) {
return gcd(a,gcd(b,c));
}
void main() {
int K = readln.chomp.t... | D |
import std.stdio, std.string, std.algorithm, std.array;
void main()
{
int t;
scanf("%d", &t);
getchar();
foreach(i; 0..t){
long a,b,c,m;
scanf("%lld %lld %lld %lld", &a, &b, &c, &m);
auto top_max = a + b + c - 3;
auto max_v = max(a,b,c);
auto min_v = min(a,b,c);
auto mid_v... | D |
import std;
// dfmt off
T lread(T = long)(){return readln.chomp.to!T();}
T[] lreads(T = long)(long n){return generate(()=>readln.chomp.to!T()).take(n).array();}
T[] aryread(T = long)(){return readln.split.to!(T[])();}
void scan(TList...)(ref TList Args){auto line = readln.split();
foreach (i, T; TList){T val = line[i]... | D |
//prewritten code: https://github.com/antma/algo
import std.algorithm;
import std.array;
import std.conv;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.traits;
final class InputReader {
private:
ubyte[] p, buffer;
bool eof;
bool rawRead () {
if (eof) {
return fals... | D |
import std.stdio;
import std.string;
void main()
{
auto n = readln;
auto s = readln.strip;
writeln( solve( s ) );
}
int solve( in string s )
{
auto lc = new int[ s.length ];
lc[ 0 ] = 0;
foreach( i; 1 .. s.length )
{
lc[ i ] = lc[ i - 1 ] + ( s[ i - 1 ] == 'E' ? 0 : 1 );
}
auto rc = new int[ s.length ]... | 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() {
bool[int] kuku_answers;
foreach(i; 1..10) {
foreach(o; 1..10) {
kuku_answers[i*o] = true;
}
}
auto N = readln.chomp.to!int;
... | D |
import std.stdio, std.string, std.array, std.conv, std.algorithm, std.typecons, std.range, std.container, std.math, std.algorithm.searching, std.functional,std.mathspecial;
void main(){
auto abc=readln.split.array;
if(abc[0][$-1]==abc[1][0] && abc[1][$-1]==abc[2][0])writeln("YES");
else writeln("NO");
} | D |
void main(){
int[] n = _scanln();
(n[0]-n[1]+1).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 = int)(){
T[] ln;
foreach(string elm; readln().chomp().split()){
ln ~= elm... | D |
import std;
enum inf(T)()if(__traits(isArithmetic,T)){return T.max/4;}
T scan(T=long)(){return readln.chomp.to!T;}
void scan(T...)(ref T args){auto input=readln.chomp.split;foreach(i,t;T)args[i]=input[i].to!t;}
T[] scanarr(T=long)(){return readln.chomp.split.to!(T[]);}
alias Queue=DList;auto enq(T)(ref Queue!T q,T e){q... | 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;
import std.string;
import std.conv;
import std.algorithm;
import std.math;
import std.regex;
void main() {
auto N = readln.chomp.to!int, K = readln.chomp.to!int;
int res = 1;
foreach(i; 0..N) res = (res * 2 < res + K ? res * 2 : res + K);
writeln(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;
import std.container;
alias sread = () => readln.chomp();
alias route... | D |
import std.stdio;
import std.string;
import std.conv;
void main() {
string s = readln.chomp;
ulong k = readln.chomp.to!ulong;
foreach(i, c; s) {
if (c != '1') {
if (i < k) {
s[i].writeln;
return;
}
}
}
1.writeln;
}
| D |
import std.conv;
import std.stdio;
import std.string;
void main()
{
auto s = readln.strip;
writeln( solve( s ) );
}
auto solve( in string s )
{
auto r = 0;
foreach( c; s )
{
if( c == '+' ) r++;
else r--;
}
return r;
}
unittest
{
assert( solve( "+-++" ) == 2 );
assert( solve( "-+--" ) == -2 ... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.math;
import std.regex;
void main() {
auto ip = readln.split.to!(int[]), X = ip[0], Y = ip[1], Z = ip[2];
auto a = X - Z, b = Z + Y;
writeln(a / b);
} | 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;
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 |
module app;
import core.bitop;
import std.algorithm;
import std.array;
import std.bigint;
import std.conv;
import std.stdio;
import std.string;
struct Input
{
int a,b;
}
void parseInput(T)(out Input input, T file)
{
with (file) with (input)
{
auto ab = readln().strip().split();
a = ab[0].to!int;
b = ab[1].... | 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.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()
{
dchar[] n; readV(n);
foreach (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();
alias Point... | D |
import std.stdio, std.string, std.array, std.conv, std.algorithm.iteration, std.functional;
void main()
{
auto nab = readln.split.to!(int[]);
auto a = nab[1];
auto b = nab[2];
auto xs = readln.split.to!(long[]);
long ret, pos = xs[0];
foreach (x; xs[1..$]) {
auto d = (x - pos) * a;
... | 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 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.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 |
import std.stdio;
import std.stdio;
import std.algorithm;
import std.range;
import std.functional;
import std.conv;
import std.string;
import std.math;
import core.bitop;
ulong diff(ulong a, ulong b) {
ulong res = 0;
foreach (bit; 0 .. 64) {
if ((a & (1UL << bit)) != (b & (1UL << bit))) {
res++;
}
}
return ... | 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(s <=... | D |
import std.stdio;
import std.conv;
import std.array;
import std.string;
void main()
{
while (1) {
string[] input = split(readln());
int h = to!(int)(input[0]);
int w = to!(int)(input[1]);
if (h == 0 && w == 0) break;
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
if (j... | 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() {
int[] tmp = readln.split.to!(int[]);
int a = tmp[0], b = tmp[1], c = tmp[2], d = tmp[3];
int[] time = new int[101];
++time[a], --time[b], ++time[c], --time[d];
foreach (i; 1 .. 101) {
time[i] += time[i-1];
}
time.count(2).writeln;
}
import std.stdio;
import std.string;... | 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.range, std.conv, std.array, std.algorithm, std.math, std.typecons;
void main() {
const R = readln.chomp.to!int;
writeln(R < 1200 ? "ABC" : R < 2800 ? "ARC" : "AGC");
}
| 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;
T gcd(T)(T a, T b) {
... | D |
import std.stdio, std.string, std.conv;
void main()
{
auto M = readln.chomp.to!int;
writeln(48 - M);
} | D |
import std.algorithm;
import std.conv;
import std.range;
import std.stdio;
import std.string;
auto go (string s, string c)
{
char [] stack = "**".dup;
foreach (ref e; s.filter !(e => c.canFind (e)))
{
stack.assumeSafeAppend ();
stack ~= e;
if (stack[$ - 2..$] == c)
{
stack.popBackN (2);
}
}
return st... | D |
import std.stdio;
import std.string;
import std.conv : to;
import std.algorithm : fill;
import std.math : sqrt;
void main() {
int input;
immutable limitList = 200000;
bool[] listNumbers = new bool[](limitList);
int[] listPrimeNumbers;
listNumbers.fill(true);
foreach (i; 2..limitList.to!doubl... | 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;
real[] r1 = [ 70,55,50,43,40,37.5,35.5];
real[] r2 = [ 148,116,105,89,83,77,71];
string[] ans = ["NA","E","D","C","B","A","AA","A... | D |
import std.algorithm, std.array, std.conv, std.range, std.stdio, std.string;
void main()
{
auto buf = readln.chomp.split;
(buf[1] ~ buf[0]).writeln;
}
| 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;
}
void main() { // 日本語文字列のテスト
int w = readint;
... | D |
import std.stdio,
std.string,
std.conv;
void main() {
int N = readln.chomp.to!(int);
int[] a = readln.chomp.split.to!(int[]);
int[int] mp;
for (int i = 0; i < N; i++) {
mp[a[i]]++;
}
int ans;
foreach (m; mp.byKey) {
if (m <= mp[m]) {
ans += mp[m] - m;
}
else {
... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
bool[10^^5+1] NS;
void main()
{
auto nk = readln.split.to!(int[]);
auto N = nk[0];
auto K = nk[1];
auto as = readln.split.to!(int[]);
foreach (i; 0..K+1) {
bool win;
foreach (j;... | D |
import std.algorithm;
import std.conv;
import std.range;
import std.stdio;
import std.string;
int best (int [] a)
{
int res = 0;
int cur = 0;
foreach (ref c; a)
{
cur += c;
res = max (res, cur);
}
return res;
}
int solve (int [] r, int [] b)
{
return best (r) + best (b);
}
void main ()
{
auto tests = rea... | 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 s = readln.split.map!(to!int);
auto H = s[0];
auto W = s[1];
auto A = H.iota.map!(_ => r... | D |
import std.stdio;
import std.string;
import std.conv;
void main()
{
int N = readln.chomp.to!(int);
int[][2] arr;
for (int i = 0; i < 2; i++) {
arr[i] = readln.chomp.split.to!(int[]);
}
int ans;
for (int i = 0; i < N; i++) {
int sum;
for (int j = 0; j <= i; j++) {
... | D |
import std.stdio, std.string, std.array, std.conv, std.algorithm, std.typecons, std.range, std.container, std.math, std.algorithm.searching, std.functional,std.mathspecial, std.numeric;
long[] scores;
long[][] abcs;
int N;
bool[] updated;
void main(){
auto nm=readln.split.map!(to!int).array;
N=nm[0];
aut... | 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 a, b;
void main() {
scan(a, b);
if (a % 3 == 0 || b % 3 == 0 || (a + b) % 3 ==... | D |
import std.stdio;
import std.string;
import std.math;
import std.conv;
import std.algorithm;
import std.bigint;
void main(){
int d,m;
int date = 2;
auto ds = ["Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday","Monday"];
auto a = [31,29,31,30,31,30,31,31,30,31,30,31];
while(true){
date... | D |
import std.stdio;
import std.conv;
import std.string;
const int DATA = 200;
int main() {
int data = to!(int)(chomp(readln));
string[] result = new string[data];
for(int i=0; i<data; i++) {
int a, b, c, tmp; // a:max
string[] input = (chomp(readln)).split(" ");
a = to!(int)(input[0]);
b = to!(in... | D |
import std.stdio,std.conv,std.string,std.algorithm,std.array;
void main(){
auto sn=readln().split();
auto sa=readln().split();
int n,a;
n=to!int(sn[0]);
a=to!int(sa[0]);
if(n%500<=a) writeln("Yes");
else writeln("No");
} | D |
import std.stdio,
std.string,
std.conv;
void main() {
int N = readln.chomp.to!int;
while(N--) {
auto i = readln.split;
auto c = i[0].to!int, a = i[1].to!int, n = i[2].to!int;
int ans;
while(c && a && n) {
ans++;
c--;
a--;
... | 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;
}
void main() {
auto xs = readints;
int[int] m... | 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);
int n = s.length.to!i... | D |
import core.bitop;
import std.algorithm;
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 Point2 = Tuple!(long, "... | 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 S = readln.split[0];
auto cnt = 0;
string[] answers = [ "" ];
while (cnt < S.length) {
if ( S[cnt] == 'A' || S[cnt] == 'T' || S[cnt] == 'G' ||... | D |
import std.stdio;
import std.string;
import std.format;
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.concurrency;
import std.traits;
import std.uni;
import c... | D |
import std.stdio;
import std.conv;
import std.array;
void main()
{
int N = readln.split[0].to!int;
auto reader = readln.split;
int[] A = new int[N + 1];
for(uint i = 0; i < N + 1; i++){
A[i] = reader[i].to!int;
}
reader = readln.split;
int[] B = new int[N];
for(uint i = 0; i < N... | D |
import std;
void main(){
auto input=readln.chomp.split.to!(size_t[]);
auto x=input[0];
auto y=input[1];
auto b_2=y-2*x;
if(b_2%2!=0){
"No".writeln;
return;
}
auto b=b_2/2;
if(x<b){
"No".writeln;
return;
}
"Yes".writeln;
} | D |
import std.stdio, std.string, std.conv, std.range, std.algorithm;
void main() {
auto _n = readln;
string[] n = [];
string line;
while((line = readln.chomp) != "") {
n ~= line;
}
foreach (_s; ["S", "H", "C", "D"])
foreach (_i; 1..14) {
auto t = _s ~ " " ~ _i.to!string;
if (!n.canFind(t)) t.writeln;
}... | D |
import std.algorithm, std.array, std.container, std.range, std.bitmanip;
import std.numeric, std.math, std.bigint, std.random, core.bitop;
import std.string, std.conv, std.stdio, std.typecons;
void main()
{
while (true) {
auto rd = readln.split.map!(to!int);
auto h = rd[0], w = rd[1];
if (h == 0 && w ==... | 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.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, stri... | 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 |
module app;
import core.bitop;
import std.algorithm;
import std.array;
import std.bigint;
import std.container.rbtree;
import std.conv;
import std.stdio;
import std.string;
import std.traits;
struct Input
{
int n, p;
string s;
}
void parseInput(T)(out Input input, T file)
{
with (file) with (input)
{
auto ar ... | D |
import std.stdio;
import std.conv;
import std.string;
void main()
{
char[] s = readln.dup.chomp;
s[5] = ' ';
s[13] = ' ';
writeln(s);
}
| 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()
{
long a, b, c, d;
scan(a, b, c, d);
if (a + b > c + d)
{
... | D |
import std.stdio;
import std.string;
import std.array; // split
import std.conv; // to
void main()
{
string[] input = split(readln()); // splitで文字列を文字列の配列に切り分け
int a = to!int(input[0]); // 第0要素を整数に変換
int b = to!int(input[1]); // 第1要素を整数に変換
if((a*b)%2 == 0){
writeln("Even"); // 表示
} else {
... | D |
import std.stdio,std.ascii,std.conv,std.string,std.algorithm,std.range,std.functional,std.math,core.bitop;
void main()
{
int num;
auto a=readln.chomp.to!int;
for(int i=0;i<=a;i++){
if(i%2==0)continue;
int b;
for(int j=1;j<=i;j++){
if(i%j==0)b++;
}
if(b=... | D |
import std.stdio, std.string, std.conv;
import std.array, std.algorithm, std.range;
void main()
{
for(string s; (s=readln().chomp()).length; )
{
immutable N=4;
auto a = s.split().map!(to!int).array();
auto b = readln().split().map!(to!int).array();
int h=0,m=0;
foreach(i... | 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 |
import std.algorithm;
import std.conv;
import std.stdio;
import std.string;
import std.typecons;
alias Tuple!(int, "x", int, "y") Point;
auto move = [[-1, 0], [0, 1], [1, 0], [0, -1]];
void main(){
string input;
Point[200] points;
while((input = readln.chomp) != "0"){
int n = input.to!int;
... | D |
import std.stdio;
import std.string;
import std.algorithm;
import std.conv;
import std.array;
long[] read_nums() {return readln.strip.chomp.split(" ").map!(to!(long)).array;}
void main() {
while(true) {
long[] data = read_nums;
long people = data[0];
long kinds = data[1];
if (people == 0 && kinds =... | 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() {
string a, b, c;
scan(a);
scan(b);
scan(c);
auto A... | D |
import std.stdio, std.string, std.conv;
import std.algorithm, std.array;
auto solve(string X) {
immutable N = X.length.to!int();
int n=0,q=0;
foreach(c;X) {
if(c=='S') ++q;
else if(q>0) --q;
else ++n;
}
return n+q;
}
void main(){ for(string s; (s=readln.chomp()).length;) writ... | 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;
immutable long INF = 1L << 59;
void main() {
auto s = readln.split.map!(to!int);
... | 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 |
string solve(int n){
int x = (n.to!double/1.08).to!int();
if((x*1.08).to!int() < n)x++;
if((x*1.08).to!int()==n)return x.to!string();
else return ":(";
}
void main(){
int n = inelm();
writeln(solve(n));
}
import std.stdio, std.conv, std.algorithm, std.numeric, std.string, std.math, std.range;
const long mod... | 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() {
int n;
scan(n);
int[int] cnt;
foreach (i ; 0 .. n) {
int ai;
scan(ai);
cnt[ai]++;
debug {
writeln(cnt);
... | D |
import std.stdio, std.array, std.string, std.conv, std.algorithm;
import std.typecons, std.range, std.random, std.math, std.container;
import std.numeric, std.bigint, core.bitop, std.bitmanip;
void main() {
auto S = readln.chomp;
auto N = S.length.to!int;
auto ans = new int[](N);
foreach (i; 0..N-1) {... | 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 n;
scan(n);
int ca, cb, cab;
int... | 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 h, n;
scan(h, n);
auto a = new int[](... | D |
//dlang template---{{{
import std.stdio;
import std.conv;
import std.string;
import std.array;
import std.algorithm;
import std.typecons;
// 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;
impor... | 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!long;
long r;
foreach (i; 1..N+1) {
r += i * (N-i+1);
}
foreach (_; 1..N) {
auto uv = readln.split.to!(long[]);
... | D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
auto a = readln.chomp.map!(c => cast(int)(c-'0')).array;
foreach (i; 0..1<<3) {
auto r = a[0];
foreach (j; 0..3)
r += a[j+1] * (i.bitTest(j) ? 1 : -1);
if (r == 7) {
write(a[0]);
foreach (j; 0..3)
... | D |
import std.algorithm;
import std.array;
import std.conv;
import std.math;
import std.numeric;
import std.stdio;
import std.string;
void main()
{
long n = readln.chomp.to!long;
long[] a = readln.chomp.split(" ").to!(long[]);
long sum;
foreach (x; a)
{
sum += x - 1;
}
writeln(sum);... | D |
import std.algorithm, std.array, std.conv, std.stdio, std.string;
void main()
{
writeln(cast(char)(readln[0]+1));
}
| D |
import std.stdio, std.string, std.algorithm, std.array;
void main()
{
writeln(readln.chomp.split(" ").uniq.array.length == 1 ? "H" : "D");
} | D |
void main()
{
long n = rdElem;
long[] a = rdRow;
long[long] list;
foreach (i, x; a)
{
++list[i-x];
}
long result;
foreach (i, x; a)
{
--list[i-x];
if (i + x in list)
{
result += list[i+x];
}
}
result.writeln;
}
enum long... | D |
import std.stdio, std.algorithm, std.string, std.conv, std.array, std.range, std.math, core.stdc.stdio;
void main() {
string[3] ss;
foreach(ref s; ss) s = readln();
writeln(ss[0][0], ss[1][1], ss[2][2]);
} | D |
import core.bitop;
import std.algorithm;
import std.array;
import std.ascii;
import std.container;
import std.conv;
import std.format;
import std.math;
import std.random;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
void main()
{
auto nm = readln.chomp.split.map!(to!int);
int n = nm.... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array, std.typecons, std.container;
import std.math, std.numeric, std.random, 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 a, b;
scan(a, b);
writeln(a... | 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;
bool[char] ch;
foreach (e; s) {
ch[e] = false;
}
... | D |
import std.conv, std.stdio, std.string, std.typecons, std.math;
alias Tuple!(int,int) p;
void main() {
int [] hwd = readln().chomp().split().to!(int[]);
int H = hwd[0], W = hwd[1];
int D = hwd[2];
int [][] A;
p [] crd;
A.length = H;
crd.length = H*W+1;
foreach(i; 0..H) {
A[i] = readln().chomp().split().to!(... | 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.algorithm, std.array, std.range;
void main()
{
for(string s_; (s_=readln().chomp()).length;)
{
auto NM = s_.split().map!(to!int)();
immutable N=NM[0], M=NM[1];
auto xy = new int[][M];
foreach(ref a;xy) a=readln.split.map!(x=>x.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;
import std.string;
import std.conv;
void main() {
int n = readln.chomp.to!int;
bool[string] table;
foreach (i;0..n) {
auto line = readln.chomp;
table[line] = true;
}
writeln(table.length);
}
| D |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.