code stringlengths 4 1.01M | language stringclasses 2
values |
|---|---|
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 |
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;
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.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 |
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.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 |
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 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.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 |
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.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.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 |
// 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 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 |
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 |
import std;
auto input()
{
return readln().chomp();
}
alias sread = () => readln.chomp();
alias aryread(T = long) = () => readln.split.to!(T[]);
void main()
{
long n;
scan(n);
auto T = new long[](n);
foreach (i; 0 .. n)
{
long t;
scan(t);
T[i] = t;
}
// writeln... | 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();
writeln(800 * n - (n / 15) * 200);
}
void scan(L...)(ref L A)
{
auto l = readln.split;
foreach (i, T; L)
{
A[i... | 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.random;
void main() {
auto x = readln.chomp.split.map!(to!int);
if (x[0] < x[1] && x[1] < x[2]) writeln("Yes");
else writeln("No... | 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 |
/* 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.stdio;
import std.algorithm;
import std.string;
import std.conv;
import std.array;
void main() {
auto Q = readln.chomp.to!int;
foreach (i; 0..Q) {
auto input = readln.split.map!(to!int).array;
//??????CAN?????°????±??????????CAN?????°??????min(C, A, N)????????????
int can = min(input[0], input[1], i... | 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;
scanf("%d", &n);
int[] X = new int[n];
int[] Y = new int[n];
long INF = 1L<<40;
int parity = 0;
foreach (i; 0..n) {
scanf("... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array, std.typecons;
import std.math, std.numeric;
void main() {
int n, q; scan(n, q);
auto uf = UnionFind(n);
foreach (_ ; 0 .. q) {
int com, x, y; scan(com, x, y);
if (com == 0) {
uf.merge(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.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto nk = readln.split.to!(int[]);
auto N = nk[0];
auto K = nk[1];
writeln((N+1) / 2 >= K ? "YES" : "NO");
} | 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() {
long T1, T2;
long A1, A2;
long ... | D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
for (;;) {
auto rd = readln.split.map!(to!int), h = rd[0], w = rd[1];
if (h == 0 && w == 0) break;
foreach (i; 0..h) {
foreach (j; 0..w)
write((i + j) % 2 == 0 ? '#' : '.');
writeln;
}
writeln;
}... | D |
// Vicfred
// https://atcoder.jp/contests/abc152/tasks/abc152_d
// math, combinatorics
import std.conv;
import std.stdio;
import std.string;
void main() {
int n = readln.chomp.to!int;
long[10][10] digits;
// count the numbers starting in i and ending in j
for(int i = 0; i <= n; i++)
digits[i.... | 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);
scope(exit) sc.read!true;
int n, a, b;
sc.read(n, a, b);
import std.math;
if (abs... | 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.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 ((... | D |
import std.algorithm;
import std.array;
import std.container;
import std.conv;
import std.exception;
import std.functional;
import std.math;
import std.numeric;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
import core.bitop;
void main ()
{
int n;
while (scanf (" %d", &n) > 0)
{
int ... | D |
import std.stdio;
import std.string;
import std.conv;
import std.typecons;
import std.algorithm;
import std.functional;
import std.bigint;
import std.numeric;
import std.array;
import std.math;
import std.range;
import std.container;
import std.ascii;
void main() {
long[] ans = new long[31];
ans[0] = 1;
fo... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto T = readln.chomp.to!int;
foreach (_; 0..T) {
auto N = readln.chomp.to!int;
auto as = readln.split.to!(int[]);
auto xs = new int[](5001);
auto ls = new int[](... | 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()
{
auto n = readln.chomp.to!int;
bool[string] ids;
foreach (i; 0..n) {
auto x = readln.chomp;
ids[x] = 1;
}... | 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() {
auto s = iota(3).map!(i => readln.chomp).array;
auto n = iota(... | D |
import std.stdio, std.string, std.conv;
void main() {
int s = readln.chomp.to!int;
int h = s / 3600;
s %= 3600;
int m = s / 60;
s %= 60;
writeln(h, ":", m, ":", s);
}
| D |
import std.stdio, std.conv, std.string, std.range, std.algorithm, std.array, std.functional, std.container;
import std.typecons;
void main() {
auto S = readln.chomp;
auto N = S.length;
Tuple!(int, int)[] arr;
int i = 0;
while(i < N) {
int r,l;
while(i < N && S[i]=='R') { i++; r++; }
while(i < N &... | D |
void main(){
import std.stdio, std.string, std.conv, std.algorithm;
import core.bitop;
int n; rd(n);
int k=1;
while(k*2<=n) k*=2;
writeln(max(popcnt(n), popcnt(k-1)));
}
void rd(T...)(ref T x){
import std.stdio, std.string, std.conv;
auto l=readln.split;
assert(l.length==x.length);
foreach(i, r... | D |
void main()
{
long x = rdElem;
Pair[] list;
foreach (i; 0L .. 3000L)
{
list ~= Pair(i, i ^^ 5);
if (i) list ~= Pair(-i, -i ^^ 5);
}
foreach (a; list)
{
foreach (b; list)
{
if (a.b - b.b == x)
{
writeln(a.a, " ", b.a);
... | 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 |
void main(){
int[] ngs = [7, 5, 3];
int x = _scan();
writeln(ngs.count(x)==1? "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(string elm; read... | D |
import std.stdio, std.conv, std.string, std.array, std.algorithm;
long maximalModulus(long left, long right) {
if (right / 2 + 1 >= left) {
return right % (right / 2 + 1);
}
else {
long max = -1;
long i = 1;
long x = 1;
while (x > max + 1) {
x = ((right -... | D |
import std.stdio;
import std.string;
void main()
{
foreach (i; 0 .. 3)
{
auto tmp = readln.chop();
tmp[i].write();
}
writeln();
}
| D |
import std.stdio;
import std.array;
import std.algorithm;
import std.string;
import std.container;
import std.typecons;
int size(in string s) {
return cast(int)s.length;
}
void main() {
string s = readln.chomp;
immutable X = "ABC";
bool check(in string s) {
foreach (i, c; s) {
if ... | 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;
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();
bool[] tmp = [false, false];
foreach (i; 0... | D |
import std.algorithm;
import std.conv;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
@safe
long solve (const string s) {
enum m = 2019;
auto c = new int[m];
auto d = new int[m];
long res;
foreach (ch; s) {
c[0] += 1;
const int k = ch.to!int - 48;
d[]... | D |
import std.stdio; // readln
import std.array; // split
import std.conv; // to
import std.typecons;
import std.range;
import std.algorithm;
void main(){
string[] s = split(readln());
int n = to!int(s[0]);
s = split(readln());
int[] a = new int[](n);
for(int i = 0; i < n; i++){
a[i] = to!int(s[i]);
a[i]--;
}
... | D |
import std;
void main() {
int n; scan(n);
int ans = 0;
bool[string] d;
foreach (_; 0..n) {
string s = read!string;
d[s] = true;
}
writeln(d.keys.length);
}
void scan(T...)(ref T a) {
string[] ss = readln.split;
foreach (i, t; T) a[i] = ss[i].to!t;
}
T read(T)() { return... | 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() {
string[] tmp = readln.split;
int a = tmp[0].to!int, b = tmp[1].to!int;
string p = tmp[0];
int cnt;
foreach (i; a .. b+1) {
char[] q = p.dup;
reverse(q);
if (p == q) ++cnt;
p = p.succ;
}
cnt.writeln;
}
import std.stdio;
import std.string;
import ... | 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 |
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(){
int n = _scan();
int[] a = _scanln();
bool approve = true;
foreach(elm; a){
if(elm%2 == 0){
if( elm%3==0 || elm%5==0 )continue;
else{
approve = false;
break;
}
}
}
writeln(approve? "APPROVED": "DENIED");
}
import std.stdio, std.conv, std.algorithm, std.numeric, std.string, std.m... | 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 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()
{
int k = readln.chomp.to!int;
int[] done = new int[](k)... | 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, std.conv, std.range, std.stdio, std.string;
void main()
{
auto x = readln.chomp.to!int;
writeln(x < 1200 ? "ABC" : "ARC");
}
| D |
import std.stdio, std.algorithm, std.string;
void main()
{
readln();
auto s = readln().strip();
bool ok = true;
ok &= !canFind(s, "000");
ok &= !canFind(s, "11");
ok &= !s.startsWith("00");
ok &= !s.endsWith("00");
ok &= s != "0";
writeln(ok ? "Yes" : "No");
} | 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];
int ans1, ans2;
foreach (i; 0 .. S.length) {
if (i % 2 == 0) {
S[i] == '0' ? ans1++ : ans2++;
}
else {
S[i] == '0' ? ans2++ ... | D |
import std.stdio;
import std.conv;
import std.algorithm;
import std.range;
import std.string;
import std.math;
import std.format;
void main() {
string[] q;
foreach (string line; stdin.lines) {
if (line == "quit\n") break;
string op, clr;
auto s = line.chomp.split;
if (s.length == 1) {
op = ... | D |
void main() {
problem();
}
void problem() {
auto N = scan!ulong;
ulong solve() {
// Sum_{k=1..n} k/2 * floor(n/k) * floor(1 + n/k)
ulong ans;
foreach(k; 1..N+1) {
ulong x = k * cast(ulong)floor(cast(real)N/k) * cast(ulong)floor(1 + cast(real)N/k);
ans += x / 2;
}
return ans;
}
... | D |
import std.stdio;
import std.string;
import std.algorithm;
import std.conv;
import std.array;
import std.math;
import std.range;
void main()
{
auto w = readln.chomp.toLower;
string[] ss;
while(1){
auto line = readln.chomp;
if(line == "END_OF_TEXT") break;
ss ~= line.toLower.split;
... | D |
import std.stdio,
std.string,
std.conv,
std.algorithm;
void main() {
int[] buf = readln.chomp.split.to!(int[]);
int a = buf[0] - 1, b = buf[1] - 1;
int K = 50;
char[100][100] m;
for (int i = 0; i < K; i++) {
for (int j = 0; j < K * 2; j++) {
m[i][j] = '#';
}
}
for (in... | D |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.