code stringlengths 4 1.01M | language stringclasses 2
values |
|---|---|
import std.stdio, std.conv, std.string, std.range, std.typecons, std.format;
import std.algorithm.searching, std.algorithm.sorting, std.algorithm.iteration, std.algorithm.mutation;
void main()
{
string input = readln().strip();
foreach(c; input)
{
write(c=='1'?'9':'1');
}
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 readA(T)(size_t n,ref T[]t){t=new T[](n);auto ... | D |
import std.algorithm;
import std.conv;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
int solve (string s)
{
auto n = s.length.to !(int);
s ~= ".?!";
auto f = new int [3] [n + 4];
f[1][1] = 1;
f[2][2] = 1;
foreach (i; 0..n)
{
foreach (j; 1..3)
{
if (f[i][j])
{
f[i + 3 ... | D |
import std.algorithm;
import std.array;
import std.conv;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.bitmanip;
void main() {
immutable n = readln.strip.to!int;
auto s = readln.strip;
BitArray m1, m2, m3;
m1.length = 10;
m2.length = 100;
m3.length = 1000;
debug stder... | D |
import std.algorithm;
import std.array;
import std.stdio;
import std.numeric;
import std.conv;
void main(){
auto input = readln.split.map!(to!int);
gcd(input[0], input[1]).writeln;
} | 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]);
if (N == 1) writeln("Hello World");
else
{
auto a = to!int(chomp(readln()));
auto b = to!int(chomp(readln()));
w... | 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;
ulong MOD = 1_000_000_007;
ulong INF = 1_000_00... | 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;
const long MOD = 10^^9 + 7;
const long INF = 1L << 59;
void main() {
auto s = readln.split.map!(to!int);
auto N = s[0... | D |
import std.stdio, std.string, std.conv;
import std.algorithm, std.array;
auto solve(string s_) {
immutable N = s_.to!int();
auto ab = new long[2][N];
foreach(ref v;ab) v = readln.split.map!(to!long).array();
long c=0;
foreach_reverse(ref v;ab) {
immutable a=v[0], b=v[1];
c+=(b-(a+c)%... | 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, 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.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.string,
std.stdio,
std.algorithm;
void main() {
char[] s = readln.chomp.dup.reverse;
writeln(s);
} | 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.numeric;
void main()
{
auto x = readln.chomp.to!int;
int sum;
auto i = 1;
while (s... | D |
void main(){
string s = readln().chomp();
if(s.count('a') == 1 && s.count('b') == 1 && s.count('c') == 1){
writeln("Yes");
}else{
writeln("No");
}
}
import std.stdio, std.conv, std.algorithm, std.numeric, std.string, std.math, std.range;
// 1要素のみの入力
T inelm(T= int)(){
return to!(T)( readln().chomp(... | 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;
alias sread = () => readln.chomp();
alias Point2 = Tuple!(long, "y", ... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array, std.typecons, std.container;
import std.math, std.numeric, core.bitop;
enum inf = 1_001_001_001;
enum inf6 = 1_001_001_001_001_001_001L;
enum mod = 1_000_000_007L;
void main() {
long a, b;
scan(a, b);
writeln(a / gcd(a, ... | D |
import std.algorithm;
import std.conv;
import std.stdio;
import std.string;
void main() {
string[] b_type = [ "A", "B", "AB", "O" ];
int[string] b_counter;
foreach (b; b_type) {
b_counter[b] = 0;
}
foreach (string line; stdin.lines) {
string b = line.chomp.split(",")[1];
b_counter[b]++;
}
f... | D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
import std.bitmanip; // BitArray
void main()
{
auto rd = readln.split.to!(int[]), n = rd[0], k = rd[1];
auto a = readln.split.to!(int[]);
auto dp1 = new BitArray[](n+1), dp2 = new BitArray[](n+1);
dp1[0].length = dp2[0].length = k;
dp1[0][0]... | D |
import std.stdio, std.string, std.conv, std.bigint, std.typecons, std.algorithm, std.array, std.math, std.range;
void main() {
auto N = readln.chomp.to!int;
writeln(N / 10 == 9 || N % 10 == 9 ? "Yes" : "No");
} | D |
import std.stdio,std.string,std.array,std.algorithm,std.range,std.conv;
int main(){
auto s=readln.chomp;
auto n=s.length;
if(s.equal(s.retro)){
auto s1=s[0..(n-1)/2];
if(s1.equal(s1.retro)){
auto s2=s[(n+3)/2-1..$];
if(s2.equal(s2.retro)){
"Yes".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);}
const mod = 10^^9+7;
void main()
{
int n; readV... | D |
import std.algorithm;
import std.array;
import std.conv;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
int readint() {
return readln.chomp.to!int;
}
int[] readints() {
return readln.split.map!(to!int).array;
}
void main() { // 日本語文字列のテスト
int w = readint;
... | D |
import std.stdio, std.conv, std.string, std.array, std.math, std.regex, std.range, std.ascii;
import std.typecons, std.functional;
import std.algorithm, std.container;
void main()
{
readln();
long[] list = scanArray;
long sum;
long res;
long l;
foreach(r; 0..list.length)
{
while((su... | 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 (_t; 0..T) {
auto N = readln.chomp.to!long;
long a = 2L^^N, b;
foreach (i; 1..N/2) {
a += 2L^^i;
}
forea... | D |
import std.functional,
std.algorithm,
std.bigint,
std.string,
std.traits,
std.array,
std.range,
std.stdio,
std.conv;
void main() {
ulong N = readln.chomp.to!ulong;
ulong[] a = readln.chomp.split.to!(ulong[]);
ulong[ulong] h;
foreach (e; a) {
if (e in... | 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_007;
void main() {
int a, b;
scan(a, b);
if ((a + b) % 2) {... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric, std.container, std.range;
void get(Args...)(ref Args args)
{
import std.traits, std.meta, std.typecons;
static if (Args.length == 1) {
alias Arg = Args[0];
static if (isArray!Arg) {
... | 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;
import std.typecons, std.regex;
void main() {
auto s = read.to!string;
writeln(s[0..$-8]);
}
string read() {
static string[] ss;
while (!ss.len... | D |
import std.stdio;
import std.string;
import std.conv;
void main() {
int times = readln.chomp.to!(int);
foreach(t; 0..times) {
dchar[] line = readln.chomp.dup.to!(dchar[]);
if ( line.length >= 6) {
for(uint i = 0; i < line.length - 6; i++) {
if (line[i..(i + 7)] == "Hoshino") {
line... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array, std.typecons, std.container;
import std.math, std.numeric, core.bitop;
enum inf = 1_001_001_001;
enum inf6 = 1_001_001_001_001_001_001L;
enum mod = 1_000_000_007L;
void main() {
int H, A;
scan(H, A);
int ans = (H + A - 1... | D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
auto n = readln.chomp.to!size_t;
auto p = readln.split.to!(int[]);
auto r = 0;
foreach (i; 0..n-1) {
if (i+1 == p[i]) {
swap(p[i], p[i+1]);
++r;
}
}
if (p[n-1] == n) ++r;
writeln(r);
}
| D |
import core.bitop;
import std.algorithm;
import std.ascii;
import std.bigint;
import std.conv;
import std.functional;
import std.math;
import std.numeric;
import std.range;
import std.stdio;
import std.string;
import std.random;
import std.typecons;
alias sread = () => readln.chomp();
alias Point2 = Tuple!(long, "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;
import std.string;
import std.conv;
import std.algorithm;
import std.array;
import std.range;
void main(){
auto N=readln.chomp.to!int;
auto A=readln.chomp.to!int;
if(N%500<=A)writeln("Yes");
else if(N%500>A)writeln("No");
} | D |
import std.stdio, std.string, std.conv, std.array, std.algorithm;
void main()
{
auto q = readln.chomp.to!int;
for(int i=0;i<q;++i){
auto b = readln.split.map!(to!int);
int c=b[0],a=b[1],n=b[2];
int ans=0;
if(a<n){
ans+=min(c,a);
c=max(0,c-ans);
a=max(0,a-ans);
n=max(0,n-ans);... | D |
void main(){
string s = readln().chomp();
string t = readln().chomp();
if( s==t[0..s.length] && t[s.length..$].length==1 ){
writeln("Yes");
}else{
writeln("No");
}
}
import std.stdio, std.conv, std.algorithm, std.numeric, std.string, std.math;
// 1要素のみの入力
T _scan(T= int)(){
return to!(T)( readln().chomp() )... | D |
import std.stdio, std.string, std.range, std.conv, std.array, std.algorithm, std.math, std.typecons;
void main() {
auto S = readln.chomp;
auto T = readln.chomp;
char[char] c0, c1;
foreach (i; 0..S.length) {
const s = S[i];
const t = T[i];
if (s !in c0 && t !in c1) {
... | D |
import std.stdio, std.range, std.conv, std.string;
import std.algorithm.comparison, std.algorithm.iteration, std.algorithm.mutation, std.algorithm.searching, std.algorithm.setops, std.algorithm.sorting;
void main()
{
int[] input = readln().split.to!(int[]);
int H = input[0];
int W = input[1];
input = r... | 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 core.stdc.stdio;
import std.algorithm;
void main(){
int s,t;
scanf("%d%d",&s,&t);
char[] x = new char[s+1],y=new char[t+1];
scanf("%s%s",x.ptr,y.ptr);
int[][][] dp = new int[][][](2,s+1,t+1);
foreach(d;dp[0])
d[]=-1145141919;
foreach(i;0..s+1)
foreach(j;0..t+1){
if(i<s)
if(x[i]=='I')
dp[0... | D |
/+ dub.sdl:
name "D"
dependency "dunkelheit" version="1.0.1"
+/
import std.stdio, std.algorithm, std.range, std.conv;
// import dkh.foundation, dkh.scanner, dkh.numeric.prime;
int main() {
Scanner sc = new Scanner(stdin);
scope(exit) assert(!sc.hasNext);
debug {
foreach (n; 3..1001) {
... | D |
import std.stdio;
void main() {
string[] weather = ['S' : "Cloudy", 'C' : "Rainy", 'R' : "Sunny"];
weather[readln[0]].writeln;
} | D |
void main() {
import std.stdio, std.string, std.conv, std.algorithm;
int n;
rd(n);
auto s = readln.chomp.to!(char[]);
auto bf = new int[](26), af = new int[](26);
int kind = 0;
foreach (c; s) {
af[c - 'a']++;
if (af[c - 'a'] == 1) {
kind++;
}
}
int ans = 0, mod = 998244353;
for (... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric, std.container, std.range;
enum P = 10L^^9+7;
void main()
{
auto nm = readln.split.to!(int[]);
auto N = nm[0];
auto M = nm[1];
auto ab = new bool[][](2, N*M);
foreach (a; readln.split.to!(int[]))... | 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 |
void main()
{
long A, B, m;
rdVals(A, B, m);
long[] a = rdRow;
long[] b = rdRow;
long result = a.reduce!min + b.reduce!min;
foreach (i; 0 .. m)
{
long x, y, c;
rdVals(x, y, c);
--x, --y;
result = min(result, a[x]+b[y]-c);
}
result.writeln;
}
enum lo... | D |
import std.stdio;
import std.algorithm;
import std.string;
import std.range;
import std.array;
import std.conv;
import std.complex;
import std.math;
import std.ascii;
import std.bigint;
import std.container;
import std.typecons;
auto readInts() {
return array(map!(to!int)(readln().strip().split()));
}
auto readInt() ... | D |
import std.stdio, std.algorithm;
void main() {
enum cs = "MARCH";
size_t[char] d;
foreach (c; cs) {
d[c] = 0;
}
foreach (s; stdin.byLine) {
if (s[0] in d) {
++d[s[0]];
}
}
size_t ret = 0;
foreach (i, c0; cs[0..$-2]) {
if (d[c0] == 0) continue;... | D |
void main()
{
long[] tmp = readln.split.to!(long[]);
long a = tmp[0], b = tmp[1], c = tmp[2];
writeln(a + b >= c - 1 ? b + c : 2 * b + a + 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.c... | D |
import std.stdio : writeln;
void main() {
int a,b,c,d;
scan(a,b,c,d);
if (a+b > c+d) {
writeln("Left");
}
else if (a+b < c+d) {
writeln("Right");
}
else {
writeln("Balanced");
}
}
void scan(T...)(ref T args) {
import std.stdio : readln;
import std.a... | D |
import std.stdio, std.conv, std.string, std.algorithm;
void main() {
writeln(readln.split.to!(uint[]).reduce!"a*b" % 2 == 0 ? "Even" : "Odd");
}
| D |
unittest
{
assert( [ "xyz", "abc" ].parse.expand.solve == "xaybzc" );
assert( [ "atcoderbeginnercontest", "atcoderregularcontest" ].parse.expand.solve == "aattccooddeerrbreeggiunlnaerrccoonntteesstt" );
}
import std.conv;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
void main()
{
s... | 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[] sieve(int 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 |
void main()
{
string s = rdStr;
long len = s.length;
long l, r = len - 1;
long cnt;
while (l < r)
{
if (s[l] == s[r])
{
++l, --r;
}
else
{
if (s[l] == 'x')
{
++cnt;
++l;
}
... | 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 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;
alias sread = () => readln.chomp();
alias Point2 = Tuple!(long, "y", ... | 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_001L;
void main() {
int n;
scan(n);
auto a = readln.split.to!(long[]);
a = [inf] ~ a ~ [-inf];
long mon = 100... | 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;
scan(N);
auto a = readln... | 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.conv;
import std.array;
import std.string;
import std.algorithm;
void main() {
int n;
n = to!int(chomp(readln()));
int [] a;
for(int i = 0; i < n; i++) {
a ~= to!int(chomp(readln()));
}
sort(a);
a ~= -1;
int res = 0;
int cnt = 1;
for(int i = 1; i < a.length; i++) {
if(a[i] ==... | 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 |
long[long] solve(long n){
long[long] dic;
for(long x=1; x^^2<=n; x++){
for(long y=1; x^^2+y^^2<=n; y++){
for(long z=1; x^^2+y^^2+z^^2<=n; z++){
dic[x^^2+y^^2+z^^2 + x*y+y*z+z*x]++;
}
}
}
return dic;
}
void main(){
long n = _scan!long();
auto ans = solve(n);
foreach(i; 1..n+1){
ans.get(i, 0).wri... | 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 |
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 n = readln.chomp.to!int;
auto ans = new int[6];
foreach (_; 0..n) {
auto x = readln.chomp.to!dou... | D |
void main()
{
int n = readln.chomp.to!int;
writeln(readln.split.to!(int[]).sum - n);
}
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;
import std.conv, std.array, std.algorithm, std.string;
import std.math, std.random, std.range, std.datetime;
import std.bigint;
import std.container;
string read(){ static string[] ss; while(!ss.length) ss = readln.chomp.split; string res = ss[0]; ss.popFront; return res; }
void main(){
long n = re... | D |
// Cheese-Cracker: cheese-cracker.github.io
void theCode(){
auto word = scan!(dchar[]);
int n = word.length.to!int;
auto vis = new bool[n];
int cnt = 0;
for(int i = 0; i < n-1; ++i){
if(vis[i]) continue;
if(i < n - 2 && word[i] == word[i+1] && word[i] == word[i+2]){
cnt... | D |
void main(){
string[] val = inln!string();
bool a = (val[0]=="H")?true:false;
bool b = (val[1]=="H")?true:false;
bool ans = a^b;
writeln(( (a^b)==false)?'H':'D');
}
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=... | 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 ans = 0;
... | D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void readV(T...)(ref T t){auto r=readln.splitter;foreach(ref v;t){v=r.front.to!(typeof(v));r.popFront;}}
void readA(T)(size_t n,ref T t){t=new T(n);auto r=readln.splitter;foreach(ref v;t){v=r.front.to!(ElementType!T);r.popFront;}}
void readM(T...)(size_... | 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() {
char[] s;
scan(s);
int ans = 100000;
... | 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 q; readV(q);
foreach (_; 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 |
// Try AtCoder
/// author: Leonardone @ NEETSDKASU
import std.stdio : readln, writeln;
import std.string : chomp;
import std.array : split;
import std.conv : to;
auto getVals(T)() { return readln.chomp.split.to!(T[]); }
void main() {
bool[char] table;
foreach (ch; readln.chomp) {
table... | D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
import std.math;
void main()
{
for (;;) {
auto rd = readln.split, a = rd[0].to!int, op = rd[1], b = rd[2].to!int;
if (op == "?") break;
writeln(op.predSwitch("+", a + b, "-", a - b, "*", a * b, "/", a / b));
}
} | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array, std.typecons, std.container;
import std.math, std.numeric, core.bitop;
enum inf = 1_001_001_001;
enum inf6 = 1_001_001_001_001_001_001L;
enum mod = 1_000_000_007L;
void main() {
int H, N;
scan(H, N);
auto a = readln.spli... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math;
void main()
{
auto S = readln.chomp.to!(wchar[]);
auto w = readln.chomp.to!size_t;
size_t i;
while (i < S.length) {
write(S[i]);
i += w;
}
writeln("");
} | D |
import std.stdio, std.array, std.string, std.conv, std.algorithm;
import std.typecons, std.range, std.random, std.math, std.container;
import std.numeric, std.bigint, core.bitop, core.stdc.stdio;
void main() {
auto T = readln.chomp.to!int;
while (T--) {
auto s = readln.split.map!(to!long);
aut... | D |
import std.stdio, std.conv, std.string, std.algorithm,
std.math, std.array, std.container, std.typecons;
void main() {
int n = readln.chomp.to!int;
bool[string] map;
for(int i=0; i<n; i++) map[readln.chomp] = true;
writeln(map.length);
}
| D |
void main() {
problem();
}
void problem() {
auto X = scan!ulong;
ulong solve() {
ulong years;
real money = 100;
while(money < X) {
years++;
money = cast(ulong)(cast(real)money * 1.01);
}
return years;
}
writeln(solve());
}
// ----------------------------------------------... | D |
import std.stdio, std.string, std.conv, std.math, std.regex;
void main()
{
auto t = readln;
writeln("ABC" ~ t);
} | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
int[10^^5+1] MEMO;
void main()
{
auto nm = readln.split.to!(int[]);
auto N = nm[0];
auto M = nm[1];
foreach (_; 0..M) {
auto lr = readln.split.to!(int[]);
auto L = lr[0]-1;
au... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons;
int[30][30] DC;
int[30][3] CS;
void main()
{
auto nc = readln.split.to!(int[]);
auto N = nc[0];
auto C = nc[1];
foreach (i; 0..C) {
foreach (j, d; readln.split) {
DC[i][j] = d.to!int;
... | D |
import std.stdio, std.conv, std.functional, std.string;
import std.algorithm, std.array, std.container, std.range, std.typecons;
import std.bigint, std.numeric, std.math, std.random;
import core.bitop;
string FMT_F = "%.10f";
static File _f;
void file_io(string fn) { _f = File(fn, "r"); }
static string[] s_rd;
T _RD(... | D |
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.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 D = readln.split.map!(to!int).array;
auto M = readln.chomp.to!int;
auto T =... | D |
import std.stdio;
import std.algorithm;
import std.string;
import std.functional;
import std.array;
import std.conv;
import std.math;
import std.typecons;
import std.regex;
import std.range;
void main(){
int n = readln().chomp().to!int;
real ans;
ans = 0;
for(int i=0;i<n;i++){
ans += readln().chomp()... | D |
void main()
{
long n, m;
rdVals(n, m);
bool[] ac = new bool[n+1];
long[] wa = new long[n+1];
foreach (i; 0 .. m)
{
long p;
string s;
rdVals(p, s);
if (s == "AC")
{
if (!ac[p]) ac[p] = true;
}
else
{
if (!ac... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto N = readln.chomp;
auto K = readln.chomp.to!int;
auto DP = new long[][][](3, K+1, N.length);
DP[2][K-1][0] += 1;
foreach (x; 1..N[0]-'0') DP[1][K-1][0] += 1;
DP[0][K][0] += ... | 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;
import std.concurrency;
void times(alias fun)(int n) {
foreach(i... | D |
import std.container;
import std.range;
import std.algorithm;
import std.array;
import std.string;
import std.conv;
import std.stdio;
import std.container;
void main() {
readln;
auto a = readln.chomp.split(' ').map!(to!int).array;
auto c = new int[10 ^^ 6 + 1];
foreach (e;a) {
++c[e];
}
auto pairwise = true;
... | D |
import std.stdio, std.conv, std.functional, std.string;
import std.algorithm, std.array, std.container, std.range, std.typecons;
import std.bigint, std.numeric, std.math, std.random;
import core.bitop;
string FMT_F = "%.10f";
static File _f;
void file_io(string fn) { _f = File(fn, "r"); }
static string[] s_rd;
T _RD(... | D |
import std.algorithm;
import std.array;
import std.conv;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
T read(T)() { return readln.chomp.to!T; }
T[] reads(T)() { return readln.split.to!(T[]); }
alias readint = read!int;
alias readints = reads!int;
int maxSumSequence(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.regex : regex;
import std.container;
import std.bigint;
void main()
{
auto n = readln.chomp.to!int;
auto a = readln.chomp.split.map!(to!int).array;
int ... | D |
void main() {
auto N = ri;
auto A = iota(N).map!(a => ri).array;
if(A[0] > 0) {
writeln(-1);
return;
}
foreach(i; 0..N-1) {
if(A[i+1]-A[i] > 1) {
writeln(-1);
return;
}
}
ulong ans;
foreach(i; 0..N-1) {
if(A[i]+1 == A[i+1]) ans++;
else ans += A[i+1];
}
ans.writeln;
}
// ====================... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto nm = readln.split.to!(int[]);
auto N = nm[0];
auto M = nm[1];
int[][] ss;
ss.length = M;
foreach (i; 0..M) {
auto ks = readln.split.to!(int[]);
foreach (s; k... | D |
import std.stdio, std.string, std.conv, std.math;
void main() {
auto ip = readln.split.to!(int[]);
if(0 <= (ip[1] - ip[2])){
writeln("delicious");
} else if(ip[0] + 1 > abs(ip[1] - ip[2])){
writeln("safe");
} else {
writeln("dangerous");
}
} | D |
import std.stdio, std.conv, std.algorithm, std.range, std.array, std.string, std.uni;
void main() {
auto inp = readln.split.to!(int[]);
if (inp[1] * 2 == inp[0] + inp[2]) {
writeln("YES");
} else {
writeln("NO");
}
} | D |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.