code stringlengths 4 1.01M | language stringclasses 2
values |
|---|---|
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, 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;
immutable long MOD = 10^^9 + 7;
void main() {
auto t = readln.split.map!(to!int);
auto H = t[0];
auto W = t[1];
... | D |
// Cheese-Cracker: cheese-cracker.github.io
void solve(){
auto n = scan!int;
auto arr = iota(1L, n+1L).array;
long a = scan;
long b = scan;
if(abs(a - b) > 1 || a + b > n - 2){
writeln(-1);
return;
}
long swp = max(a, b);
if(a > b){
arr.reverse;
}
for(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 |
//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;
import std.numeric;
class InputReader {
private:
ubyte[] p;
ubyte[] buffer;
size_t cur;
public:
this () {
... | D |
import std.stdio;
import std.ascii;
import core.stdc.stdio;
int main()
{
int t = readInt!int;
while (t--)
{
long x = readInt!long;
long m111 = 0;
bool can = false;
int maxrep = 20;
int i = 0;
while (m111 <= x && i < maxrep)
{
if ((x - m111... | D |
import std.stdio;
int l,r;
void main()
{
scanf("%d %d", &l, &r);
long low = 1;
int ans = 0;
while(low<=r){
long x=low;
while(x<=r){
if(x>=l){
ans++;
}
x*=2;
}
low*=3;
}
printf("%d",ans);
} | 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, std.algorithm, std.numeric;
import std.range, std.array, std.math, std.typecons, std.container, core.bitop;
void main() {
int a,b,c,d;
scan(a,b,c,d);
foreach (i ; a .. 2*a + 1) {
foreach (j ; b .. min(i, 2*b + 1)) {
foreach (k ; c .. min(j, 2*c +... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto s1 = readln.chomp;
auto s2 = readln.chomp;
writeln(levenshteinDistance(s1, s2));
}
| D |
void main(){
real num = readln().chomp().replace(" ","").to!int();
writeln(num%sqrt(num)==0?"Yes":"No");
}
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(stri... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.range;
enum PS = [11, 31, 41, 61, 71, 101, 131, 151, 181, 191, 211, 241, 251, 271, 281, 311, 331, 401, 421, 431, 461, 491, 521, 541, 571, 601, 631, 641, 661, 691, 701, 751, 761, 811, 821, 881, 911, 941, 971,991, 1021, 1031, 1... | 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.to!(int[]); }
alias Plan = Tuple!(int, "t", int, "x", int, "y");
bool calc(Plan[] ... | D |
import std.conv, std.stdio;
import std.algorithm, std.range, std.string;
void main()
{
auto i = readln.chomp.split.to!(int[]);
only(i[0]+i[1], i[0]-i[1], i[0]*i[1]).reduce!max.writeln;
}
| D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
enum P = 10^^9L+7;
long[10^^5*2+1] SS;
bool[10^^5*2+1] BS;
void main()
{
auto nm = readln.split.to!(int[]);
auto N = nm[0];
auto M = nm[1];
foreach (_; 0..M) {
auto a = readln.chomp.to!int;
... | D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
const alpha = 26, a = 'a';
void main()
{
auto n = readln.chomp.to!size_t;
auto b = new int[](alpha), bs = new int[](alpha);
b[] = int.max;
foreach (_; 0..n) {
auto s = readln.chomp;
bs[] = 0;
foreach (c; s) ++bs[c-a];
foreach ... | 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.string,std.conv,std.array;
void main(){
int[26] arr;
for(;;){
auto rc = readln().chomp();
if(!rc){ break; }
foreach( c ; rc ){
if( 'a' <= c && c <= 'z' ){
arr[c-'a']++;
} else if ( 'A' <= c && c <= 'Z' ){
arr[c-'A']++;
}
}
}
foreach( key,i ; arr ){
writeln( to!char(ke... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array;
void main() {
int a,b,c,x;
scan(a);
scan(b);
scan(c);
scan(x);
int ans;
foreach(i;0..a+1){
foreach(j;0..b+1){
foreach(k;0..c+1){
if(500*i+100*j+50*k == x) ans++;
... | D |
void main() {
import std.stdio, std.string, std.conv, std.algorithm;
int n, m;
rd(n, m);
auto a = readln.split.to!(long[]);
long[long] map;
long tot = 0, mulm = 0;
for (int i = 0; i < n; i++) {
if (i > 0) {
a[i] += a[i - 1];
}
if (a[i] % m == 0) {
tot += (++mulm);
} else {
... | 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 ip = readln.chomp;
if(ip... | D |
void main() {
import std.stdio, std.string, std.conv, std.algorithm;
int h, w;
rd(h, w);
int a, b;
rd(a, b);
auto p = h / a, q = w / b;
writeln((h - p * a) * w + h * (w - q * b) - ((h - p * a) * (w - q * b)));
}
void rd(T...)(ref T x) {
import std.stdio : readln;
import std.string : split;
import... | 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[] aryread(T = long)(){return readln.split.to!(T[])();}
... | D |
import std.algorithm;
import std.range;
import std.ascii;
import std.array;
import std.container;
import std.conv;
import std.numeric;
import std.stdio;
import std.string;
import std.typecons;
void log(A...)(A arg) {
stderr.writeln(arg);
}
int size(T)(in T s) {
return cast(int)s.length;
}
long modPow(long mod... | D |
import std.conv, std.functional, std.stdio, std.string;
import std.algorithm, std.array, std.bigint, std.container, std.math, std.numeric, std.range, std.regex, std.typecons;
import core.bitop;
class EOFException : Throwable { this() { super("EOF"); } }
string[] tokens;
string readToken() { for (; tokens.empty; ) { if... | D |
import std.stdio, std.conv, std.string;
import std.array, std.range, std.algorithm, std.container;
import std.math, std.random, std.bigint, std.datetime, std.format;
string read(){ static string[] ss; while(!ss.length) ss = readln.chomp.split; string res = ss[0]; ss.popFront; return res; }
int DEBUG_LEVEL = 0;
void pr... | 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;
enum mod = 1_000_000_007L;
void main() {
int N, M;
scan(N, M);
auto adj... | D |
void main() {
string s = readln.chomp;
writeln(2 * min(s.count('0'), s.count('1')));
}
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.string, std.conv;
import std.range, std.algorithm, std.array, std.math, std.typecons;
void main() {
int n; scan(n);
auto ban = new int[][](1010, 1010);
foreach (i ; 0 .. n) {
int x1, y1, x2, y2;
scan(x1, y1, x2, y2);
ban[x1][y1]++;
ban[x1][y2]--;
... | D |
import std.stdio;
import std.string;
import std.conv;
int main()
{
int n = readln().chomp().to!int();
while (n--) {
int times = 3;
int Hit = 0;
int result = 0;
while (times) {
string str = readln().chomp();
if (str == "HIT") {
if (Hit == 3... | D |
void main() {
auto S = rs;
if(S == "ABC") {
writeln("ARC");
} else writeln("ABC");
}
// ===================================
import std.stdio;
import std.string;
import std.functional;
import std.algorithm;
import std.range;
import std.traits;
import std.math;
import std.container;
import std.bigint;
import std.n... | D |
import std.stdio, std.math, std.algorithm, std.array, std.string, std.conv, std.container, std.range;
pragma(inline, true) T[] Reads(T)() { return readln.split.to!(T[]); }
alias reads = Reads!int;
pragma(inline, true) void scan(Args...)(ref Args args) {
string[] ss = readln.split;
foreach (i, ref arg ; args) ar... | D |
import std.stdio, std.array, std.string, std.conv, std.algorithm;
import std.typecons, std.range, std.random, std.math, std.container;
import std.numeric, std.bigint, core.bitop;
void main() {
auto N = readln.chomp.to!int;
auto A = readln.split.map!(to!int).array;
int ans = 0;
for (int i = 0; i < N; ... | D |
void main() {
while(true) {
auto S = rs.to!(dchar[]);
if(S == "-") break;
auto m = ri;
foreach(i; 0..m) {
auto h = ri;
S = S[h..$] ~ S[0..h];
}
S.writeln;
}
}
// ===================================
import std.stdio;
import std.string;
import std.functional;
import std.algorithm;
import std.range;
... | 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 count2(int n) {
... | 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;
struct Deque(T) {
private {
int N, head, tail;
T[] deq;
}
... | D |
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
void main() {
string input = chomp(readln());
switch(input) {
case "a", "i", "u", "e", "o":
"vowel".writeln;
break;
default:
"consonant".writeln;
break;
}
}
| 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;
void main()
{
auto x = readln.chomp.to!int;
writeln(x^^3);
}
| D |
import std;
alias sread = () => readln.chomp();
alias lread = () => readln.chomp.to!long();
alias aryread(T = long) = () => readln.split.to!(T[]);
void main()
{
auto n = lread();
auto a = aryread();
long x = 3 ^^ n;
long y = 1;
foreach (i; 0 .. n)
{
if (a[i] % 2 == 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 |
import std.stdio;
import std.string;
import std.conv;
import std.bigint;
import std.typecons;
import std.algorithm;
import std.array;
void main() {
auto tmp = readln.split.to!(int[]);
auto W = tmp[1], H = tmp[0];
int[][] cost;
foreach (i; 0..10) {
tmp = readln.split.to!(int[]);
cost ~=... | D |
import std.stdio;
import std.string;
import std.conv;
void main() {
auto n = readln.chomp.to!uint;
writeln((n + 1) / 2);
}
| 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, std.format, std.bitmanip;
// }}}
// nep.scanner {{{
class Scanner {
import std.stdio : File, stdin;
import std.conv : to;
import std.array : ... | D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
auto rd = readln.split.to!(size_t[]), n = rd[0], m = rd[1];
auto a = new string[](n), b = new string[](m);
foreach (i; 0..n) a[i] = readln.chomp;
foreach (i; 0..m) b[i] = readln.chomp;
auto isSame(size_t i, size_t j)
{
for... | D |
import std.algorithm;
import std.array;
import std.conv;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
T read(T)() { return readln.chomp.to!T; }
T[] reads(T)() { return readln.split.to!(T[]); }
alias readint = read!int;
alias readints = reads!int;
void main() {
int n... | D |
import std.stdio;
import std.array;
import std.string;
import std.algorithm;
import std.conv;
int[] g;
int insertionSort(ref int[] arr, int n, int g) {
int cnt = 0;
for (auto i = g; i < n; i++) {
int v = arr[i];
int j = i - g;
while (j >= 0 && arr[j] > v) {
arr[j+g] = arr[j];
j = j - g;
... | 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, k;
scan(n, k);
auto s = readln.chomp... | 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;
bool chmin(T)(ref T a, T b) {
if (b < a) {
a = b;
return true;
} else... | 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 N = readln.split[0].to!int;
// p = 10^^k <= N < 10^^(k+1)
int p = 1, k = 0;
foreach (i; 0 .. 10) {
if (p <= N && N < p*10) break;
p *= 10; k += 1;
}
... | D |
import std.algorithm;
import std.conv;
import std.range;
import std.stdio;
import std.string;
void main ()
{
auto tests = readln.strip.to !(int);
foreach (test; 0..tests)
{
auto n = readln.strip.to !(int);
auto a = readln.splitter.map !(to !(int)).array;
writeln (isSorted (a) ? "NO" : "YES");
}
}
| D |
// Vicfred
// https://atcoder.jp/contests/abc154/tasks/abc154_b
// simulation
import std.stdio;
import std.string;
void main() {
string S = readln.chomp;
foreach(ch; S) {
'x'.write;
} writeln;
}
| D |
import std.stdio;
import std.string;
void main ()
{
int divs = 0;
foreach (p; 2..51)
{
bool ok = true;
for (int d = 2; d * d <= p; d++)
{
if (p % d == 0)
{
ok = false;
}
}
if (!ok)
{
continue;
}
writeln (p);
stdout.flush ();
bool cur = (readln.strip == "yes");
divs += cur;
if... | 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.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
auto s = readln.chomp;
char[] t;
foreach (i, c; s)
if (i % 2 == 0) t ~= c;
writeln(t);
}
| D |
void main() {
int[] tmp = readln.split.to!(int[]);
int h = tmp[0], w = tmp[1];
string[] a;
foreach (i; 0 .. h) {
string row = readln.chomp;
if (row.any!(c => c == '#')) a ~= row;
}
h = a.length.to!int;
int j;
while (j < w) {
int cnt;
foreach (i; 0 .. h) {
... | D |
import std.stdio, std.algorithm, std.range, std.conv, std.string, std.math, std.container;
import core.stdc.stdio;
// foreach, foreach_reverse, writeln
void main() {
int n;
scanf("%d\n", &n);
string s = readln().chomp;
int[] score = new int[n];
{
int cur = 0;
foreach (i; 0..n) {
score[i] += cur;
if (s[... | D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
auto rd = readln.split, a = rd[0], b = rd[1], c = rd[2];
writeln(a[$-1] == b[0] && b[$-1] == c[0] ? "YES" : "NO");
}
| 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 N, i;
scan(N, i);
auto ans ... | 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 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, std.format, std.bitmanip;
// }}}
// nep.scanner {{{
class Scanner {
import std.stdio : File, stdin;
import std.conv : to;
import std.array : ... | D |
import std.functional,
std.algorithm,
std.typecons,
std.bigint,
std.string,
std.traits,
std.array,
std.range,
std.stdio,
std.conv,
std.math;
T read_num(T)() { return readln.chomp.to!T; }
T[] read_nums(T)() { return readln.chomp.split.to!(T[]); }
en... | D |
import std.stdio;
import std.string;
import std.conv;
import std.bigint;
import std.typecons;
import std.algorithm;
import std.array;
import std.math;
import std.range;
void main() {
auto N = readln.chomp.to!int;
auto K = readln.chomp.to!int;
auto x = 1;
foreach (i; 0..N) {
if (x < K) x *= 2;
... | D |
import std;
alias sread = () => readln.chomp();
alias lread = () => readln.chomp.to!long();
alias aryread(T = long) = () => readln.split.to!(T[]);
void main()
{
long a1, a2, a3;
scan(a1, a2, a3);
if (a1 + a2 + a3 <= 21)
{
writeln("win");
}
else if (22 <= a1 + a2 + a3)
{
wri... | D |
import std.stdio,std.string,std.conv;
int main()
{
string s;
while((s = readln.chomp).length != 0)
{
for(int i=0;i<s.length;i++)
{
if(s[i] == '@')
{
int count = s[i+1] - '0';
foreach(j;0..count)
{
write(s[i+2]);
}
i += 2;
}
else
{
write(s[i]);
}
}
writeln;
}
... | 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 s = sread();
auto k = lread();
// writeln(s);
// wr... | D |
void main(){
string s = readln().chomp();
int ans;
foreach(elm; s){
ans += (elm=='+')?1:-1;
}
ans.writeln();
}
import std.stdio, std.conv, std.algorithm, std.numeric, std.string, std.math, std.range;
const long mod = 10^^9+7;
// 1要素のみの入力
T inelm(T= int)(){
return to!(T)( readln().chomp() );
}
... | D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
auto s = readln.chomp;
writeln(s.uniq.array.length-1);
}
| 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() {
alias Section = Tuple!(int, "l", int, "r");
auto data = readln.split, N = data[0].to!int, M = data[1].to!int, Q = data[2].to!int;
int[500][500] train;
int[500][50... | D |
unittest
{
assert( [ "pot", "top" ].parse.expand.solve == "YES" );
assert( [ "tab", "bet" ].parse.expand.solve == "NO" );
assert( [ "eye", "eel" ].parse.expand.solve == "NO" );
}
import std.conv;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
void main()
{
stdin.byLineCopy.parse.exp... | D |
import std.stdio;
import std.conv;
import std.algorithm;
import std.string;
import std.array;
void main() {
auto l = readln.chomp.split.map!(to!int).array;
int a = l[0], b = l[1], x = l[2];
for (int i = 0; i <= b; ++i) {
if (a + i == x) {
writeln("YES");
return;
}
... | D |
import std.stdio, std.string, std.conv;
import std.array, std.algorithm, std.range;
void main()
{
for(int n; 0!=(n=readln().chomp().to!int()); )
{
auto a=0,b=0;
foreach(i;1..n+1)
{
auto t=i;
while(t%2==0) t/=2,++a;
while(t%5==0) t/=5,++b;
}
... | 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 a = aryread();
long sum_a;
foreac... | 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.conv;
import std.range, std.algorithm, std.array, std.typecons, std.container;
import std.math, std.numeric, core.bitop;
void main() {
int d, n;
scan(d, n);
if (n == 100) {
writeln(100^^(d+1) + 100^^d);
return;
}
writeln(100^^d * n);
}
... | D |
import std;
import core.bitop;
ulong MAX = 100_100, MOD = 1_000_000_007, INF = 1_000_000_000_000;
alias sread = () => readln.chomp();
alias lread(T = long) = () => readln.chomp.to!(T);
alias aryread(T = long) = () => readln.split.to!(T[]);
alias Pair = Tuple!(long, "x", long, "c");
alias PQueue(T, alias less = "a>b") ... | D |
import std.stdio, std.algorithm, std.range, std.conv, std.string, std.math, std.container, std.typecons;
import core.stdc.stdio;
// foreach, foreach_reverse, writeln
void main() {
int n, k;
scanf("%d%d", &n, &k);
int[] a = new int[n];
foreach (i ; 0..n) scanf("%d", &a[i]);
int s = 10^^9;
foreach (x ; a) s = min(... | D |
void main(){
import std.stdio, std.string, std.conv, std.algorithm;
const int n=3;
auto c=new int[][](n, n);
foreach(i; 0..n) c[i]=readln.split.to!(int[]);
for(int a0=-105; a0<=105; a0++){
auto a=new int[](n), b=new int[](n);
a[0]=a0;
foreach(j; 0..n) b[j]=c[0][j]-a[0];
foreach(i; 1..n) a[i]... | D |
void main(){
import std.stdio, std.string, std.conv, std.algorithm;
int t; rd(t);
while(t--){
auto s=readln.chomp.to!(char[]);
int d=0, l=0, u=0;
foreach(c; s){
if('0'<=c && c<='9') d++;
if('a'<=c && c<='z') l++;
if('A'<=c && c<='Z') u++;
}
if(d>0 && l>0 && u>0){
write... | D |
void main()
{
long h, w, k;
rdVals(h, w, k);
string[] s = h.rdCol!string;
long result = inf;
outer: foreach (i; 0 .. 1L<<(h-1))
{
long cnt = i._popcnt;
long[][] list = new long[][](w, cnt+1);
foreach (j; 0 .. w)
{
long idx;
foreach (l; 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 |
module app;
import core.bitop;
import std.algorithm;
import std.array;
import std.bigint;
import std.conv;
import std.math;
import std.stdio;
import std.string;
struct Input
{
ulong n;
}
void parseInput(T)(out Input input, T file)
{
with (file) with (input)
{
n = readln().strip().to!ulong;
}
}
struct Output
... | 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 = 10L^^15;
enum mod = 10L ^^ 9 + 7;
void main() {
int h, w;
scan(h, w);
auto ban = iota(h).map!(i => readln.chomp).array;
auto dp = new lo... | 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 calc(string[] ss) {
int rows = cast(int) ss... | D |
import std.stdio, std.string, std.conv, std.math;
void main() {
int n = readln.chomp.to!int;
long debt = 100000;
foreach(i;0..n) debt = (((debt+debt*0.05)/1000.0).ceil*1000).to!long;
debt.writeln;
} | D |
import std.stdio;
import std.string;
void main() {
auto s = readln.chomp;
writeln(s[0..1], s.length - 2, s[$ - 1..$]);
}
| D |
import std.stdio, std.string, std.conv, std.array, std.algorithm;
import std.uni, std.range, std.math, std.container, std.datetime;
import core.bitop, std.typetuple, std.typecons;
immutable long MOD = 1_000_000_007;
alias tie = TypeTuple;
alias triplet = Tuple!(int, int, int);
void main(){
int N, M, a, b;
rea... | 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.to!(int[]); }
void main() {
int n = readint;
int[] a;
int[string] db; ... | D |
import std.stdio, std.ascii;
void main() {
auto d = stdin.readln.dup;
foreach (c; d) {
if (c.isLower) c.toUpper.write;
else c.toLower.write;
}
} | 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);
foreach (i;... | D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
auto m = readln.chomp.to!int;
writeln(48-m);
}
| D |
void main(){
import std.stdio, std.string, std.conv, std.algorithm;
auto s=readln.chomp.to!(char[]);
if(s.length>"AKIHABARA".length){
writeln("NO"); return;
}
auto cs=['K', 'I', 'H', 'B', 'R'];
bool[char] exist; exist['A']=true;
foreach(c; cs) exist[c]=true;
foreach(c; s){
if((c in exist)==nu... | 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 |
// Try Codeforces
// author: Leonardone @ NEETSDKASU
import std.stdio : readln, writeln;
import std.array : split;
import std.string : chomp;
import std.conv : to;
auto gets() { return readln.chomp; }
auto getVals(T)() { return gets.split.to!(T[]); }
void main() {
auto xs = getVals!long;
a... | D |
import std.stdio, std.string, std.array, std.algorithm, std.conv, std.typecons, std.numeric, std.math;
alias M = Tuple!(int, "a", int, "b", int, "c");
void main()
{
immutable nm = readln.chomp.split(" ").map!(to!int).array;
immutable n = nm[0];
immutable ma = nm[1];
immutable mb = nm[2];
auto ... | 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.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, 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 readS(T)(size_t n,ref T t){t=new T(n);foreach(... | D |
void main(){
import std.stdio, std.string, std.conv, std.algorithm;
int n; rd(n);
auto a=readln.split.to!(int[]);
int cur=-1, len=1;
int need=0;
foreach(e; a){
if(cur==e) len++;
else{
need+=len/2;
len=1;
cur=e;
}
}
writeln(need+len/2);
}
void rd(T...)(ref T x){
imp... | D |
void main(){
import std.stdio, std.algorithm;
long n, a, b, k; rd(n, a, b, k);
const long mod=998244353;
const int M=1_000_00*4;
auto fact=genFact(M, mod);
auto invFact=genInv(fact, mod);
long comb(long nn, long rr){
if(nn<rr) return 0;
long ret=fact[nn]%mod;
(ret*=invFact[rr])%=mod;
... | D |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.