code stringlengths 4 1.01M | language stringclasses 2
values |
|---|---|
import std.stdio, std.string, std.conv, std.algorithm, std.numeric;
import std.range, std.array, std.math, std.typecons, std.container, core.bitop;
void main() {
int n, a, b;
scan(n, a, b);
writeln(min(n*a, b));
}
void scan(T...)(ref T args) {
string[] line = readln.split;
foreach (ref arg; args... | 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 N = readln.chomp.to!int;
auto Comb = new Combination();
if (N... | 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, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto N = readln.chomp.to!int;
int sum_p, max_p;
foreach (_; 0..N) {
auto p = readln.chomp.to!int;
sum_p += p;
max_p = max(max_p, p);
}
writeln(sum_p - max_p /... | D |
import std.stdio;
import std.string;
import std.conv;
import std.array;
import std.range;
void main(){
auto F=readln.split.to!(int[]),A=F[0],B=F[1];
if(A+B>=24)writeln((A+B)-24);
else writeln(A+B);
} | D |
import std.stdio;
import std.conv;
import std.string;
import std.format;
void main()
{
string s = chomp(readln());
string[] array = s.split(" ");
int W = to!int(array[0]);
int H = to!int(array[1]);
int x = to!int(array[2]);
int y = to!int(array[3]);
int r = to!int(array[4]);
// (0, 0) <= (x, y) <=... | 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.algorithm,
std.math, std.array, std.container, std.typecons;
void main() {
auto nm = readln.chomp.split.to!(int[]);
if(nm[0]==nm[1]) writeln("Yes");
else writeln("No");
}
| D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
auto rd = readln.split.to!(long[]), x = rd[0], y = rd[1];
auto c = 1;
for (;;) {
x *= 2;
if (x > y) break;
++c;
}
writeln(c);
}
| D |
import std.stdio;
import std.algorithm;
import std.array;
import std.conv;
import std.datetime;
import std.numeric;
import std.math;
import std.string;
string my_readln() { return chomp(readln()); }
void main()
{
auto tokens = my_readln().split();
auto A = tokens[0].to!uint;
auto B = tokens[1].to!uint;
auto C = t... | 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()
{
auto rd = readln.split.map!(to!int);
auto a = rd[0], b = rd[1], c = rd[2];
auto d = 0;
foreach (i; a..b... | 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 a = new int[][](3, 3);
foreach (i; 0..3) {
a[i] = readln.chomp.split.to!(i... | D |
import std.conv, std.stdio;
import std.algorithm, std.array, std.string, std.range;
void main()
{
auto s = cast(ubyte[])readln.chomp;
(s[2] == s[3] && s[4] == s[5] ? "Yes" : "No").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 : File, stdin;
import std.conv : to;
import std.array : split;
import ... | D |
// unihernandez22
// https://atcoder.jp/contests/abc076/tasks/abc076_c
// string manipulation
import std.stdio;
import std.string;
void main() {
string s = readln.chomp;
string t = readln.chomp;
ulong idx = -1;
bool matched;
foreach(i; 0..(s.count-t.count)+1) {
if (s[i] == '?' || s[i] == t[0]) {
matched = tr... | 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 s = readln.chomp.to!(char[]).array;
auto k = r... | D |
import std.stdio, std.string, std.conv, std.algorithm;
import std.range, std.array, std.math, std.typecons, std.container, core.bitop;
void main() {
string s = readln.chomp;
writeln(s[0 .. min($, 4)] == "YAKI" ? "Yes" : "No");
}
void scan(T...)(ref T args) {
string[] line = readln.split;
foreach (r... | 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 File _f;
void file_io(string fn) { _f = File(fn, "r"); }
static string[] s_rd;
T _RD(T = long)() ... | D |
const int max = 1000000;
void main(){
int s = _scan();
int[int] dic;
dic[s]++;
// 初項sでa_1, ... なので2から始まる
foreach(i; 2..max+1){
if(s&1) s = 3*s +1;
else s = s/2;
dic[s]++;
if(dic[s]==2){
i.writeln();
break;
}
}
}
import std.stdio, std.conv, std.algorithm, std.numeric, std.string, std.math;
// 1... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.array;
void main(){
auto N=readln.chomp.to!int;
auto K=readln.chomp.to!int;
auto X=readln.chomp.to!int;
auto Y=readln.chomp.to!int;
if(N>K)writeln(X*K+(N-K)*Y);
else writeln(N*X);
} | 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;
auto a = readln.chomp.to!int;
wri... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array, std.typecons, std.container;
import std.math, std.numeric, core.bitop;
void main() {
int n;
long x;
scan(n, x);
auto a = new long[](n + 1); // 長さ
auto b = new long[](n + 1); // Pの枚数
a[0] = b[0] = 1;
fore... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array;
void main() {
int h, w;
scan(h, w);
auto map = new char[][](h, w);
iota(h).each!(i => map[i] = readln.chomp.to!(char[]));
if (map[0][0] != '#') {
writeln("Impossible");
return;
}
int pi, ... | 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;
alias Edge = Tuple!(int, "u", int, "v");
long[] f(long x) {
if (x == 0) {
long[] ans = new long[](42);
... | 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[] AS;
long a_sum;
foreach (a; readln.split.to!(long[])) {
AS ~= a;
a_sum += a;
}
if (N == 1) {
... | D |
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 : 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.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 |
//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;
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 |
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 |
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 |
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.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 |
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 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.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 |
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, 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 |
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.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.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.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 |
// 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.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 |
/+ 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 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, 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.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; // ??\????????????????????????
import std.string; // chomp????????????????????????(?????????????????????)
import std.conv; // to????????????????????????
import std.array; // split?????????????????????
import std.algorithm; // map?????????????????????
void main() {
auto input = readln.split.map!(... | 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;
import std.string;
import std.conv,std.array,std.datetime;
void main(){
while(1){
auto cs = readln().chomp().split();
if( cs[0]=="0" ){ break; }
final switch( Date( 2004, to!int(cs[0]), to!int(cs[1])).dayOfWeek() ){
case 0:writeln("Sunday");break;
case 1:writeln("Monday");break;
case 2:w... | D |
import std.stdio,
std.conv,
std.array,
std.string;
void main() {
int n = to!int(chomp(readln()));
while(n--) {
string[] l = split(readln());
int a = to!int(l[0]);
int b = to!int(l[1]);
int c = to!int(l[2]);
if(a*a==b*b+c*c
||b*b==c*c+a*a
||c*c==a*a+b*b) {
wr... | D |
// Cheese-Cracker: cheese-cracker.github.io
void play(){
int n, m;
n = rd!int;
m = rd!int;
int summ = 0, el;
foreach(i; 0..n){
el = rd!int;
summ += el;
}
if(summ == m){
writeln("YES");
}else{
writeln("NO");
}
}
int main(){
long t = 1;
t = rd;... | D |
void main(){
import std.stdio, std.string, std.conv, std.algorithm;
int l, r, a; rd(l, r, a);
if(l>r) swap(l, r);
if(r-l>=a){writeln((l+a)*2); return;}
a-=(r-l);
if(a&1) a--;
writeln(r*2+a);
}
void rd(T...)(ref T x){
import std.stdio, std.string, std.conv;
auto l=readln.split;
assert(l.length==x.... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto S = readln.chomp;
auto T = readln.chomp;
int[26] cs, ds;
foreach (i; 0..S.length) {
auto s = S[i] - 'a';
auto t = T[i] - 'a';
if (cs[s] == 0 && ds[t] == 0) ... | 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 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.stdio, std.algorithm, std.array, std.string, std.conv;
void main() {
auto s = readln.chomp.to!(dchar[]);
if (s.length == 3) s.reverse();
writeln(s);
}
| D |
const int m=10000000+10;
bool[m] pp;
void main(){
import std.stdio, std.string, std.conv, std.algorithm;
int n; rd(n);
if(n==1){
writeln(0);
return;
}
if(n==2){
writeln(0);
return;
}
mp();
int cnt=0;
for(int p=1; p<=n; p++){
if(pp[p] && pp[p+2]){
cnt++;
}
}
wr... | 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 s = readln.chomp;
auto l_res = new int[](s.length + 1);
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.container;
import std.datetime;
void main()
{
while (1) {
auto x = readln.chomp.split.map!(to!int).array;
if (x[0] == 0) break;
x[1]--;
int winner, s... | D |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.