code stringlengths 4 1.01M | language stringclasses 2
values |
|---|---|
import std.stdio,std.conv,std.string;
void main(){
auto m=readln.chomp.to!int;
auto t=m/500;
auto f=(m%500)/5;
(t*1000+f*5).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()
{
int a, b; string op; readV(a, op, ... | D |
import std.stdio, std.string, std.conv, std.algorithm;
void main() {
readln;
auto S = readln.chomp.map!(a => a == 'I' ? 1 : -1);
auto c = 0;
auto res = 0;
foreach (s; S) {
c += s;
res = max(res, c);
}
writeln(res);
}
| D |
import std.stdio;
import std.conv;
import std.string;
void main() {
int N = to!int(readln.chomp);
int i = 1;
while (i * i <= N) { i++; }
i--; i *= i;
i.writeln;
} | D |
void main() {
int n = readln.chomp.to!int;
long[] lucas = new long[n+1];
lucas[0] = 2, lucas[1] = 1;
foreach (i; 2 .. n+1) {
lucas[i] = lucas[i-1] + lucas[i-2];
}
lucas[n].writeln;
}
import std.stdio;
import std.string;
import std.array;
import std.conv;
import std.algorithm;
import std... | 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.conv;
import std.range;
import std.stdio;
import std.string;
int [] prepare (int limit)
{
auto res = limit.iota.array;
for (int d = 2; d * d < limit; d++)
{
if (res[d] == d)
{
for (int e = d * d; e < limit; e += d)
{
if (res[e] == e)
{
res[e] = d;
}
}
... | D |
import std.stdio : write, writeln;
import std.array;
import std.range;
import std.typecons;
import std.bigint;
import std.algorithm;
void main(){
int cnt;
bool flag1 = false;
bool ans = true;
foreach( c; next!string ){
if( c == '4' ){
ans &= flag1 || cnt>0;
if( ++cnt > 2 ){
ans &= false;
}
flag1 ... | D |
/+ dub.sdl:
name "A"
dependency "dunkelheit" version=">=0.9.0"
+/
import std.stdio, std.algorithm, std.range, std.conv;
// import dkh.foundation, dkh.scanner;
int main() {
Scanner sc = new Scanner(stdin);
long n, m;
sc.read(n, m);
n = min(n, 60);
writeln(m % (2L ^^ n));
return 0;
}
... | 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.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(){
import std.stdio, std.string, std.conv, std.algorithm;
import std.exception, std.random;
long a, b; rd(a, b);
// auto rnd=Random(unpredictableSeed);
// long a=uniform(1, 100, rnd), b=uniform(1, 100, rnd);
while(a>0 && b>0){
if(a>=b*2){
auto m=a/b;
if(m&1) m--;
enforce(m>... | 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 |
//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 |
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 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;
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 r = readln.chomp.to!int;
writeln(3 * r * r);
}
| 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;
void main() {
int[char] aa = ['J':0, 'O':1, 'I':2];
int N = readln.chomp.to!i... | D |
import std.stdio, std.array, std.conv, std.typecons, std.algorithm;
T diff(T)(const ref T a, const ref T b) { return a > b ? a - b : b - a; }
void main() {
immutable ip = readln.split.to!(ulong[]);
immutable x = ip[0], a = ip[1];
ulong ret;
if (x<a) ret = 0;
else ret = 10;
writeln(ret);
}
| D |
import std.stdio, std.algorithm, std.array, std.string, std.conv;
void main()
{
int t;
scanf("%d", &t);
foreach(_; 0..t)
{
int str_len;
scanf("%d", &str_len);
getchar();
auto str = readln.strip();
// writeln(str);
int[] check = new int[str_len];
... | 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 MOD = 10^^9 + 7;
void main() {
auto s = readln.split.map!(to!int);
auto N = s[0];
auto M = s[1];
... | D |
import std.stdio;
import std.string;
import std.conv;
void main() {
string input = readln();
char X = input[0];
char Y = input[2];
if(X < Y) writeln("<");
else if(X > Y) writeln(">");
else writeln("=");
}
| D |
void main()
{
long n = rdElem;
long[string] list;
string s = rdStr;
++list[s];
foreach (i; 1 .. n)
{
string w = rdStr;
if (s[$-1] != w[0] || w in list)
{
"No".writeln;
return;
}
++list[w];
s = w;
}
"Yes".writeln;
}... | D |
void main()
{
string s = readln.chomp;
s.count('1').writeln;
}
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 |
void main()
{
long n = rdElem;
long[] a = rdRow;
long ave1 = a.sum / n;
long ave2 = (a.sum + n - 1) / n;
long total1, total2;
foreach (x; a)
{
total1 += (x - ave1) ^^ 2;
total2 += (x - ave2) ^^ 2;
}
min(total1, total2).writeln;
}
enum long mod = 10^^9 + 7;
enum lo... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.bigint, std.container;
alias X = Tuple!(long, "a", long, "b");
alias E = Tuple!(int, "to", long, "s");
X[10^^5] XS;
E[][10^^5] G;
bool[10^^5] F;
void main()
{
auto nm = readln.split.to!(int[]);
auto N = nm[0];
a... | 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 |
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 T = new int[][](N, N);
int x = 1, s = 2;
foreach (i; 1..N) {
if (T[0][i] == 0) {
while (i < N) {
T[0][i] = x;
... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
uint[] bits(uint n) {
uint[] res;
for(uint i = 0; i <= 9; i++) {
if ((n & (1 << i)) != 0) {
res ~= (1 << i);
}
}
return res;
}
void main() {
string line;
while((line = readln.chomp) != null) bits(line.to!(int)).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;
alias Point = Tuple!(int, "x", int, "y", int, "i");
void main() {
auto s = readln.split.map!(to!int);
auto N = s[0];
... | D |
void main(){
import std.stdio, std.string, std.conv, std.algorithm;
auto s=readln.chomp.to!(char[]);
int x, y; rd(x, y);
auto n=s.length;
int[] dxs, dys;
for(int i=0, t=1; i<n; i++, t^=1){
int d=0;
while(i<n && s[i]=='F') i++, d++;
if(d==0) continue;
if(t&1) dxs~=d;
else dys~=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, 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 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 |
void main() {
import std.stdio, std.string, std.conv, std.algorithm;
import std.math : abs;
int n;
rd(n);
auto m = n / 2 + 1;
writeln(m);
for (int i = 1, r = 1, c = 1; i <= n; i++) {
writeln(r, " ", c);
if (i & 1) {
c++;
} else {
r++;
}
}
}
void rd(T...)(ref T x) {
impo... | 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 s = a.sum;
auto m = a.maxElement;
writeln (s %... | D |
import std.stdio;
import std.array;
import std.conv;
import std.algorithm;
void main() {
string s, maxls, maxas;
int[string] nums;
while( (s=readln()).length != 0 ){
string[] input = split(s);
foreach(int i, string ts; input){
nums[ts]++;
if(maxls.length<ts.length) maxls=ts;
}
}
int mn=-1;
foreach(str... | D |
void main(){
int d = _scan();
switch(d){
case 22: writeln("Christmas Eve Eve Eve"); break;
case 23: writeln("Christmas Eve Eve"); break;
case 24: writeln("Christmas Eve"); break;
default:writeln("Christmas"); break;
}
}
import std.stdio, std.conv, std.algorithm, std.numeric, std.string, std.math;
// 1要素のみの... | D |
void main()
{
import std.algorithm, std.array, std.stdio, std.string, std.conv;
readln;
auto yum = readln.chomp.split.to!(int[]);
auto sum1 = yum.sum;
auto sum2 = yum.map!(_=>_*_).sum;
((sum1*sum1 - sum2)/2).writeln;
}
| D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto nml = readln.split.to!(int[]);
auto N = nml[0];
auto M = nml[1];
long L = nml[2];
auto G = new long[][](N, N);
foreach (ref g; G) foreach (ref e; g) e = long.max / 3;
f... | D |
import std.stdio;
import core.stdc.stdio;
import std.algorithm.comparison;
int f(int x, int cnt) {
return (x % 2 == 1 ? cnt : f(x / 2, cnt + 1));
}
void main() {
int n;
scanf("%d", &n);
int ans = 1 << 30;
foreach(i; 0..n) {
int x;
scanf("%d", &x);
ans = min(ans, f(x, 0));
... | 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 = 100_100, MOD = 1_000_000_007, INF = 1_000_000_000_000;
alias sread = () => readln.chomp();
alias lread(T = long) = () ... | 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;
if (n % 2 == 0) {
n.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() {
int n;
scan(n);
auto a = readln.split.to!(int[]);
int ans = 1;
foreach (i ; 0 .. n) {
ans *= 2^^(!(a[i] & 1));
}
ans = 3^^n - ans;... | 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.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 n;
scan(n);
auto ans = (n + 1) / 2;
writeln(ans);
... | D |
void main() {
import std.stdio, std.string, std.conv, std.algorithm;
int n, m;
rd(n, m);
writeln((2 ^^ m) * ((1900 * m) + (100 * (n - m))));
}
void rd(T...)(ref T x) {
import std.stdio : readln;
import std.string : split;
import std.conv : to;
auto l = readln.split;
assert(l.length == x.length);
... | 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.bigint;
import std.bitmanip;
import std.concurrency : generator = Generator, yield;
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.st... | 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
{
string s;
}
void parseInput(T)(out Input input, T file)
{
with (file) with (input)
{
s = readln().strip(... | 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.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.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);
foreach (i; 0.... | D |
import std.stdio, std.string, std.range, std.conv, std.array, std.algorithm, std.math, std.typecons;
void main() {
auto tmp = readln.split.to!(int[]);
auto H = tmp[0], W = tmp[1];
string[] A;
foreach (i; 0..H) {
auto as = readln.chomp;
if (as.all!(a => a == '.')) continue;
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 n = readln.chomp.to!int;
bool f;
foreach (i; 1..10) {
foreach (j; 1..... | D |
import std.stdio, std.string, std.conv;
void main(){
auto ip = readln.split.to!(int[]);
writeln(ip[0] - ip[1] + 1);
} | 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 |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto N = readln.chomp;
foreach (c; N) if (c == '7') {
writeln("Yes");
return;
}
writeln("No");
} | 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 n = readint;
int k = readi... | D |
void main(){
import std.stdio, std.string, std.conv, std.algorithm;
int n; long c; rd(n, c);
auto x=new long[](n), v=new long[](n);
foreach(i; 0..n) rd(x[i], v[i]);
// import std.exception;
// enforce(n<=100);
x=0L~x~c;
v=0L~v~0L;
long mx=0, inf=2e18.to!(long);
auto a=new long[](n+2); // a[i]... | 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 main() {
int n, m; scan(n, m);
auto uf = new UnionFind(n);
for (int i = 0; i < m; i++) {
int x, y, z; scan(x, y, z);
uf.unite(x, y);
... | D |
import std.stdio, std.conv, std.string;
import std.algorithm, std.array, std.container;
import std.numeric, std.math;
import core.bitop;
string my_readln() { return chomp(readln()); }
long mod = pow(10, 9) + 7;
long moda(long x, long y) { return (x + y) % mod; }
long mods(long x, long y) { return ((x + mod) - (y % mo... | 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.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
int i;
foreach (c; readln.chomp.to!(char[])) {
if (c == '+') ++i;
if (c == '-') --i;
}
writeln(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;
immutable inf = 10^^9 + 7;
void main() {
int n;
scan(n);
auto f = new int[][](n, 10);
auto p = new int[][](n, 11);
foreach (i ; 0 .. n) {
f[... | 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 dump(T)(T[][] g) {... | 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.string, std.algorithm;
void main()
{
char[] input = chomp(readln()).dup;
char[] input2 = chomp(readln()).dup;
swap(input[0], input[2]);
if(input == input2) {
writeln("YES");
return;
} else {
writeln("NO");
return;
}
}
| 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;
void main() {
auto t = readln.split.to!(int[]);
writeln(t[0] <= t[2] && t[2] <=t[0]+t[1] ? "YES" : "NO");
}
| D |
import core.stdc.stdio;
import std.range;
import std.algorithm;
void main(){
int[] buf_p = new int[1001];
int[] buf_d = new int[1001*500];
while(1){
int n,m;
scanf("%d%d",&n,&m);
if(n==0&&m==0)
break;
int[] p = buf_p[0..++n];
foreach(ref v;p[1..$])
scanf("%d",&v);
p[0]=0;
int[] d=buf_d[0..n*(n-1)/2];
... | D |
/+ dub.sdl:
name "B"
dependency "dunkelheit" version="1.0.1"
+/
import std.stdio, std.algorithm, std.range, std.conv;
// import dkh.foundation, dkh.scanner, dkh.algorithm;
int main() {
Scanner sc = new Scanner(stdin);
scope(exit) assert(!sc.hasNext);
string s;
sc.read(s);
if (s.count('o'... | 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";
T RD(T = long)() { static string[] ss; while(!ss.length) ss = readln.chomp.split; string res = ss[0]; ss.popFront; return res.t... | 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;
void main() {
int n, m;
int[][] a;
scan(n, m);
a = new int[][](n, m);
i... | 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 x;
scan(x);
int ans = 1;
foreach (i ; 2 .. x + 1) {
for (int d = i*i; d <= x; d *= i) {
ans = max(ans, d);
... | 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()
{
auto ans = 'A';
foreach (line; stdin.byLine) {
auto sw = line.split(",").map!(to!char);
if (sw[0] == ... | 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 |
// 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.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;
immutable int MOD = 10^^9+7;
immutable int MAX = 401;
void main() {
auto s = readln.split.map!(to!int);
auto 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,std.string,std.conv,std.array,std.algorithm;
void main(){
for(;;write("\n")){
auto a = readln().chomp().split();
if( a[0]=="0" && a[1]=="0" ){ break; }
int h=to!int(a[0]) , w=to!int(a[1]);
foreach(y;0..h){
foreach(x;0..w){
if( 0<x && x<w-1 && 0<y && y<h-1 ){
write(".");
}else{... | 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 rck = readln.split.to!(int[]);
auto R = rck[0];
auto C = rck[1];
auto K = rck[2];
auto MAP = new long[][](R, C);
foreach (_; 0..K) {
auto r... | D |
/+ dub.sdl:
name "B"
dependency "dcomp" version=">=0.7.3"
+/
import std.stdio, std.algorithm, std.range, std.conv;
// import dcomp.foundation, dcomp.scanner;
// import dcomp.dungeon;
int main() {
Scanner sc = new Scanner(stdin);
int h, w;
sc.read(h, w);
auto dh = DungeonHelper(h, w);
char[... | 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 cnt;
foreach (line; stdin.byLine) {
auto s = line.chomp;
auto t = s.dup.reverse;
if (s == t) cn... | D |
import std.algorithm;
import std.array;
import std.container;
import std.conv;
import std.math;
import std.numeric;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
void scan(T...)(ref T a) {
string[] ss = readln.split;
foreach (i, t; T) a[i] = ss[i].to!t;
}
T read(T)() { return read... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array, std.typecons, std.container;
import std.math, std.numeric, core.bitop;
enum inf3 = 1_001_001_001;
enum inf6 = 1_001_001_001_001_001_001L;
enum mod = 1_000_000_007L;
void main() {
readln;
readln.split.to!(int[]).reduce!gcd.wri... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.range;
alias Point = Tuple!(int, "x", int, "y", int, "p");
int N;
Point[100] RS, BS;
int[][200] GS;
void main()
{
N = readln.chomp.to!int;
foreach (i; 0..N) {
auto ab = readln.split.to!(int[]);
RS[i]... | D |
// import chie template :) {{{
import std.stdio,
std.algorithm,
std.array,
std.string,
std.math,
std.conv,
std.range,
std.container,
std.bigint;
// }}}
void main() {
int n = readln.chomp.to!int;
writeln(24 + (24 - n));
}
| D |
import std.algorithm;
import std.array;
import std.conv;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
T read(T)() { return readln.chomp.to!T; }
T[] reads(T)() { return readln.split.to!(T[]); }
alias readint = read!int;
alias readints = reads!int;
void main() {
int 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;
int readint() {
return readln.chomp.to!int;
}
int[] readints() {
return readln.split.map!(to!int).array;
}
void main() {
_lazy[] = NIL;
_mini[] = int.m... | 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, k; readV(n, k);
writeln(n... | D |
void main()
{
long[] tmp = readln.split.to!(long[]);
long n = tmp[0], a = tmp[1], b = tmp[2];
max(0, (n - 2) * (b - a) + 1).writeln;
}
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;
... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto st = readln.split.to!(string[]);
writeln(st[1] ~ st[0]);
} | 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(); } bool DEBUG = 0;
void log(A ...)(lazy A a){ if(DEBUG) print(a); }
voi... | 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;
import std.algorithm;
import std.conv;
import std.numeric;
import std.math;
import std.string;
void main()
{
auto tokens = split(chomp(readln()));
auto N = to!ulong(tokens[0]);
auto T = to!ulong(tokens[1]);
ulong c_min;
c_min = ulong.max;
foreach (i; 0..N)
{
auto tokens1 = split(chomp(readl... | 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 |
void main() {
import std.stdio, std.string, std.conv, std.algorithm;
import std.numeric;
int n;
rd(n);
long l = 1;
long lcm(long a, long b) {
return a / gcd(a, b) * b;
}
while (n--) {
long t;
rd(t);
l = lcm(l, t);
}
writeln(l);
}
void rd(T...)(ref T x) {
import std.stdio : read... | D |
import std.stdio, std.conv, std.functional, std.string;
import std.algorithm, std.array, std.container, std.range, std.typecons;
import std.bigint, std.numeric, std.math, std.random;
import core.bitop;
string FMT_F = "%.10f";
static File _f;
void file_io(string fn) { _f = File(fn, "r"); }
static string[] s_rd;
T _RD(... | D |
import std.stdio, std.array, std.string, std.conv, std.algorithm;
import std.typecons, std.range, std.random, std.math, std.container;
import std.numeric, std.bigint, core.bitop, std.bitmanip;
void main() {
auto s = readln.split.map!(to!int);
auto H = s[0];
auto W = s[1];
auto A = H.iota.map!(_ => read... | D |
import std.stdio; // ??\????????????????????????
import std.string; // chomp????????????????????????(?????????????????????)
import std.conv; // to????????????????????????
import std.array; // split?????????????????????
import std.algorithm; // map?????????????????????
void main() {
auto input = readln.split.map!(... | D |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.