code
stringlengths 4
1.01M
| language
stringclasses 2
values |
|---|---|
import std.algorithm, std.array, std.container, std.range;
import std.string, std.uni, std.regex;
import std.stdio, std.conv, std.typecons;
void main()
{
for (;;) {
auto s = readln.chomp;
if (s == "-") break;
auto m = readln.chomp.to!size_t;
auto hi = iota(m).map!(_ => readln.chomp.to!int);
foreach (h; hi)
s = s[h..$] ~ s[0..h];
writeln(s);
}
}
|
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", long, "x");
T lread(T = long)()
{
return readln.chomp.to!T();
}
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].to!(T);
Args[i] = val;
}
}
void minAssign(T, U = T)(ref T dst, U src)
{
dst = cast(T) min(dst, src);
}
void maxAssign(T, U = T)(ref T dst, U src)
{
dst = cast(T) max(dst, src);
}
void main()
{
char c;
scan(c);
auto s = "aeiou";
foreach(cc;s)
{
if (c == cc)
{
writeln("vowel");
return;
}
}
writeln("consonant");
}
|
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[] x = new int[n*2];
int[] c = new int[n*2];
foreach (color; 0..2) {
foreach (i; 0..n) {
int a, b;
scanf("%d%d", &a, &b);
x[b] = a; c[b] = color;
}
}
int ans = 0;
int[] set = new int[n*2];
foreach (y; 0..n*2) {
if (c[y] == 0) {
set[x[y]] = 1;
} else {
foreach_reverse (i; 0..x[y]) {
if (set[i]) {
ans++;
set[i] = 0;
break;
}
}
}
}
writeln(ans);
}
|
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 n;
scan(n);
foreach (i ; 0 .. n) {
string s;
scan(s);
solve(s);
}
}
void solve(string s) {
auto a = [".,!? ", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"];
auto ss = s.group;
string res;
foreach (si ; ss) {
if (si[0] == '0') continue;
int d = si[0] - '0' - 1;
res ~= a[d][(si[1]-1) % a[d].length];
}
writeln(res);
}
void scan(T...)(ref T args) {
string[] line = readln.split;
foreach (ref arg; args) {
arg = line.front.to!(typeof(arg));
line.popFront();
}
assert(line.empty);
}
void fillAll(R, T)(ref R arr, T value) {
static if (is(typeof(arr[] = value))) {
arr[] = value;
}
else {
foreach (ref e; arr) {
fillAll(e, value);
}
}
}
|
D
|
import std.stdio;
import std.conv;
import std.string;
void main() {
int n = readln.chomp.to!int;
if (n % 2) (n/2 +1).writeln;
else (n/2).writeln;
}
|
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", long, "x");
T lread(T = long)()
{
return readln.chomp.to!T();
}
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].to!(T);
Args[i] = val;
}
}
void minAssign(T, U = T)(ref T dst, U src)
{
dst = cast(T) min(dst, src);
}
void maxAssign(T, U = T)(ref T dst, U src)
{
dst = cast(T) max(dst, src);
}
enum MOD = (10 ^^ 9) + 7;
void main()
{
long N, M;
scan(N, M);
auto A = new string[](N);
auto B = new string[](M);
foreach (i; 0 .. N)
scan(A[i]);
foreach (i; 0 .. M)
scan(B[i]);
foreach (i; 0 .. N - M + 1)
foreach (j; 0 .. N - M + 1)
{
bool b = true;
foreach (k; 0 .. M)
b = b && (A[i + k][j .. j + M] == B[k]);
if (b)
{
writeln("Yes");
return;
}
}
writeln("No");
}
|
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 r=rdsp;foreach(ref v;t)pick(r,v);}
void main()
{
int n, a; readV(n, a);
int[] x; readA(n, x);
auto s = x.sum, dp = new long[][][](n+1, n+1, s+1);
dp[0][0][0] = 1;
foreach (i; 0..n)
foreach (j; 0..n+1)
foreach (k; 0..s+1) {
dp[i+1][j][k] = dp[i][j][k];
if (j >= 1 && k >= x[i])
dp[i+1][j][k] += dp[i][j-1][k-x[i]];
}
auto r = 0L;
foreach (j; 1..n+1) {
if (j*a > s) break;
r += dp[n][j][j*a];
}
writeln(r);
}
|
D
|
// tested by Hightail - https://github.com/dj3500/hightail
import std.stdio, std.string, std.conv, std.algorithm;
import std.range, std.array, std.math, std.typecons, std.container, core.bitop;
long m, b;
void main() {
scan(m, b);
long ans = -1;
foreach (long a ; 0L .. m * b + 1) {
long ya = (m*b - a) / m;
long v = a * (a + 1) / 2L * (ya + 1L) + ya * (ya + 1L) / 2L * (a + 1L);
debug {
writefln("a: %s, v: %s", a, v);
}
ans = max(ans, v);
}
writeln(ans);
}
void scan(T...)(ref T args) {
string[] line = readln.split;
foreach (ref arg; args) {
arg = line.front.to!(typeof(arg));
line.popFront();
}
assert(line.empty);
}
void fillAll(R, T)(ref R arr, T value) {
static if (is(typeof(arr[] = value))) {
arr[] = value;
}
else {
foreach (ref e; arr) {
fillAll(e, value);
}
}
}
|
D
|
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto N = readln.chomp.to!int;
auto S = readln.chomp;
auto es = new int[](N);
auto ws = new int[](N);
foreach (i; 0..N) {
if (i > 0) ws[i] += ws[i-1];
if (S[i] == 'W') ws[i] += 1;
}
foreach_reverse (i; 0..N) {
if (i < N-1) es[i] += es[i+1];
if (S[i] == 'E') es[i] += 1;
}
int r = N;
foreach (i; 0..N) {
int rr;
if (i > 0) rr += ws[i-1];
if (i < N-1) rr += es[i+1];
r = min(r, rr);
}
writeln(r);
}
|
D
|
import std.stdio;
import std.array;
import std.conv;
int gcd(int x, int y) {
if(x < y) {
int t = x;
x = y;
y = t;
}
if(y == 0) {
return x;
}
return gcd(y, x % y);
}
void main() {
int a, b;
while(true) {
string[] input = split(readln());
if(input.length == 0) break;
a = to!int(input[0]);
b = to!int(input[1]);
int gcd_ab = gcd(a, b);
int lcm_ab = a / gcd_ab * b;
writeln(gcd_ab, " ", lcm_ab);
}
}
|
D
|
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto ns = readln.split;
foreach (a; ns) {
foreach (b; ns) {
foreach (c; ns) {
foreach (d; ns) {
if (a~b~c~d == "1974") {
writeln("YES");
return;
}
}
}
}
}
writeln("NO");
return;
}
|
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 S = readln.chomp;
auto T = readln.chomp;
int r = 1000;
foreach (i; 0..S.length - T.length + 1) {
int rr;
foreach (j, t; T) if (S[i+j] != t) ++rr;
r = min(r, rr);
}
writeln(r);
}
|
D
|
void main() {
problem();
}
void problem() {
auto a = scan!long;
string solve() {
return a >= 30 ? "Yes" : "No";
}
solve().writeln;
}
// ----------------------------------------------
import std.stdio, std.conv, std.array, std.string, std.algorithm, std.container, std.range, core.stdc.stdlib, std.math, std.typecons, std.numeric;
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); }
string scan(){ static string[] ss; while(!ss.length) ss = readln.chomp.split; string res = ss[0]; ss.popFront; return res; }
T scan(T)(){ return scan.to!T; }
T[] scan(T)(int n){ return n.iota.map!(i => scan!T()).array; }
void deb(T ...)(T t){ debug writeln(t); }
alias Point = Tuple!(long, "x", long, "y");
// -----------------------------------------------
|
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.range;
import std.stdio;
import std.string;
import std.typecons;
void main()
{
foreach (i, c; readln.chomp) {
if (i % 2 == 1) {
continue;
}
c.write;
}
writeln;
}
|
D
|
import std.algorithm;
import std.conv;
import std.exception;
import std.stdio;
import std.string;
import std.typecons;
struct Queue(T){
T[900] content;
size_t head;
size_t tail;
T front(){
enforce(head != tail);
return content[head];
}
void popFront(){
enforce(head != tail);
++head;
}
void pushBack(T value){
content[tail] = value;
++tail;
}
void clear(){
head = 0;
tail = 0;
}
size_t length(){
return tail - head;
}
}
void main(){
bool[900][900] M;
Queue!int queue;
int[900] d;
while(true){
auto input = readln.split;
if(input[0] == "0" && input[1] == "0"){
break;
}
int w = input[0].to!int;
int h = input[1].to!int;
foreach(i; 0..h){
{
auto line = readln.split;
foreach(j; 0..w - 1){
if(line[j] == "0"){
M[i * w + j][i * w + j + 1] = true;
M[i * w + j + 1][i * w + j] = true;
}else{
M[i * w + j][i * w + j + 1] = false;
M[i * w + j + 1][i * w + j] = false;
}
}
}
{
if(i == h - 1){
break;
}
auto line = readln.split;
foreach(j; 0..w){
if(line[j] == "0"){
M[i * w + j][(i + 1) * w + j] = true;
M[(i + 1) * w + j][i * w + j] = true;
}else{
M[i * w + j][(i + 1) * w + j] = false;
M[(i + 1) * w + j][i * w + j] = false;
}
}
}
}
d[1..w * h] = 0;
d[0] = 1;
queue.clear;
queue.pushBack(0);
while(queue.length){
int v = queue.front;
queue.popFront;
if(v - w >= 0 && M[v][v - w] && !d[v - w]){
d[v - w] = d[v] + 1;
queue.pushBack(v - w);
}
if(v % w + 1 < w && M[v][v + 1] && !d[v + 1]){
d[v + 1] = d[v] + 1;
queue.pushBack(v + 1);
}
if(v + w < w * h && M[v][v + w] && !d[v + w]){
d[v + w] = d[v] + 1;
queue.pushBack(v + w);
}
if(v % w - 1 >= 0 && M[v][v - 1] && !d[v - 1]){
d[v - 1] = d[v] + 1;
queue.pushBack(v - 1);
}
}
d[w * h - 1].writeln;
}
}
|
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_000_000_000;
alias sread = () => readln.chomp();
void main()
{
auto n = lread();
bool check;
foreach (i; iota(1, 10))
check |= !(n % i) && (n / i < 10);
if (check)
writeln("Yes");
else
writeln("No");
}
T lread(T = long)()
{
return readln.chomp.to!T();
}
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].to!(T);
Args[i] = val;
}
}
|
D
|
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons;
void main()
{
writeln(readln.chomp.to!int / 3);
}
|
D
|
import std.algorithm;
import std.array;
import std.conv;
import std.stdio;
void main()
{
string n;
n = readln;
if (
n[0..1] == "7"
|| n[1..2] == "7"
|| n[2..3] == "7"
) {
writeln("Yes");
} else {
writeln("No");
}
}
|
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;
void main(){
string s = readln.chomp;
int n = s.length.to!int;
int ans = 0;
foreach(i; 0 .. n){
if(i % 2){ // 自分はp
if(s[i] == 'p') ans += 0; // pp
else ans += 1; // pg
}
else{ // 自分はg
if(s[i] == 'p') ans += -1; // gp
else ans += 0; // gg
}
}
ans.writeln;
}
|
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(){
string n = readln();
while(true){
char[5][8] s;
for(int i=0;i<5;i++){
s[0][i] = '*';
s[1][i] = ' ';
s[2][i] = '=';
s[3][i] = ' ';
s[4][i] = '*';
s[5][i] = '*';
s[6][i] = '*';
s[7][i] = '*';
}
n = n.chomp();
int si = to!int(n.length);
for(int i=si-1;i>=0;i--){
int m = to!int(n[i]-'0');
if(m >= 5){
s[0][5-si+i] = ' ';
s[1][5-si+i] = '*';
m -= 5;
}
s[3][5-si+i] = '*';
s[4][5-si+i] = '*';
s[5][5-si+i] = '*';
s[6][5-si+i] = '*';
s[7][5-si+i] = '*';
s[3+m][5-si+i] = ' ';
}
foreach(i;s){
foreach(j;i) write(j);
writeln();
}
n = readln();
if(stdin.eof()) break;
writeln();
}
}
|
D
|
void main()
{
long n = readln.chomp.to!long;
long[] a = readln.split.to!(long[]);
writeln(a.count!"a % 2 == 1" % 2 == 0 ? "YES" : "NO");
}
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.array, std.string, std.conv, std.algorithm;
import std.typecons, std.range, std.random, std.math, std.container;
import std.numeric, std.bigint, core.bitop, std.bitmanip;
void main() {
auto s = readln.split.map!(to!long);
auto A = s[0];
auto B = s[1];
auto C = s[2];
auto X = s[3];
auto Y = s[4];
long ans = 1L << 59;
for (long ab = 0; ab <= 2 * max(X, Y); ab += 2) {
long a = max(0, X - ab/2);
long b = max(0, Y - ab/2);
ans = min(ans, a * A + b * B + ab * C);
}
ans.writeln;
}
|
D
|
void main(){
import std.stdio, std.string, std.conv, std.algorithm;
int n; rd(n);
int sum=0;
for(int div=1; n/div>0; div*=10){
sum+=(n/div)%10;
}
assert(sum>0);
if(n%sum==0) writeln("Yes");
else writeln("No");
}
void rd(T...)(ref T x){
import std.stdio, std.string, std.conv;
auto l=readln.split;
assert(l.length==x.length);
foreach(i, ref e; x){
e=l[i].to!(typeof(e));
}
}
void wr(T...)(T x){
import std.stdio;
foreach(e; x) stderr.write(e, " ");
stderr.writeln;
}
|
D
|
import std.stdio, std.string, std.array, std.conv;
void main() {
int[] tmp = readln.chomp.split.to!(int[]);
int a = tmp[0] - 1, b = tmp[1] - 1;
writeln((a + b - 1) / a);
}
|
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.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].to!(T);Args[i] = val;}}
alias sread = () => readln.chomp();enum MOD = 10 ^^ 9 + 7;
alias PQueue(T, alias less = "a<b") = BinaryHeap!(Array!T, less);
// dfmt on
void main()
{
long N, M, Q;
scan(N, M, Q);
auto T = new long[][](N + 1, N + 1);
foreach (_; 0 .. M)
{
long L, R;
scan(L, R);
T[L][R]++;
}
foreach (i; 0 .. N)
T[i + 1][] += T[i][];
foreach (i; 0 .. N)
foreach (j; 0 .. N)
T[i + 1][j + 1] += T[i + 1][j];
foreach (_; 0 .. Q)
{
long p, q;
scan(p, q);
writeln(T[q][q] - T[q][p - 1] - T[p - 1][q] + T[p - 1][p - 1]);
}
}
|
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.max/3;
enum MOD = 10L^^9+7;
//辞書順順列はiota(1,N),nextPermituionを使う
void end(T)(T v)
if(isIntegral!T||isSomeString!T||isSomeChar!T)
{
import core.stdc.stdlib;
writeln(v);
exit(0);
}
T[] scanArray(T = long)()
{
static char[] scanBuf;
readln(scanBuf);
return scanBuf.split.to!(T[]);
}
dchar scanChar()
{
int c = ' ';
while (isWhite(c) && c != -1)
{
c = getchar;
}
return cast(dchar)c;
}
T scanElem(T = long)()
{
import core.stdc.stdlib;
static auto scanBuf = appender!(char[])([]);
scanBuf.clear;
int c = ' ';
while (isWhite(c) && c != -1)
{
c = getchar;
}
while (!isWhite(c) && c != -1)
{
scanBuf ~= cast(char) c;
c = getchar;
}
return scanBuf.data.to!T;
}
dchar[] scanString(){
return scanElem!(dchar[]);
}
void main()
{
auto S1 = scanString;
auto S2 = scanString;
foreach(i;0..3)if(S1[i]!=S2[2-i])end("NO");end("YES");
}
|
D
|
void main() {
int[] tmp = readln.split.to!(int[]);
int a = tmp[0], b = tmp[1], x = tmp[2];
writeln(a <= x && x <= a + b ? "YES" : "NO");
}
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.conv, std.array, std.string, std.math, std.typecons, std.numeric;
void main()
{
auto N = readln.chomp.to!int;
int[] e;
e.length = N+1;
foreach (i; 2..N+1) {
auto cur = i;
foreach (j; 2..i+1) {
while (cur % j == 0) {
++e[j];
cur /= j;
}
}
}
int num(int m) {
int cnt;
foreach (x; e) {
if (x >= m-1) ++cnt;
}
return cnt;
}
writeln(
num(75) +
num(25) * (num(3) - 1) +
num(15) * (num(5) - 1) +
num(5) * (num(5) - 1) * (num(3) - 2) / 2
);
}
|
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, std.datetime;
bool is_p(string s) {
int n = s.length.to!int;
foreach (i; 0..n/2) if (s[i] != s[n-i-1]) return false;
return true;
}
void main() {
auto S = readln.chomp;
auto N = S.length.to!int;
foreach_reverse (i; 1..N+1) {
foreach (j; 0..N-i+1) {
if (!is_p(S[j..j+i])) {
writeln(i);
return;
}
}
}
writeln(0);
}
|
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 : split;
import std.string;
import std.traits : isSomeString;
private File file;
private char[][] str;
private size_t idx;
this(File file = stdin)
{
this.file = file;
this.idx = 0;
}
this(StrType)(StrType s, File file = stdin) if (isSomeString!(StrType))
{
this.file = file;
this.idx = 0;
fromString(s);
}
private char[] next()
{
if (idx < str.length)
{
return str[idx++];
}
char[] s;
while (s.length == 0)
{
s = file.readln.strip.to!(char[]);
}
str = s.split;
idx = 0;
return str[idx++];
}
T next(T)()
{
return next.to!(T);
}
T[] nextArray(T)(size_t len)
{
T[] ret = new T[len];
foreach (ref c; ret)
{
c = next!(T);
}
return ret;
}
void scan()()
{
}
void scan(T, S...)(ref T x, ref S args)
{
x = next!(T);
scan(args);
}
void fromString(StrType)(StrType s) if (isSomeString!(StrType))
{
str ~= s.to!(char[]).strip.split;
}
}
//Digit count---{{{
int DigitNum(int num) {
int digit = 0;
while (num != 0) {
num /= 10;
digit++;
}
return digit;
}
//}}}
//}}}
void main() {
Scanner sc = new Scanner;
char b;
sc.scan(b);
if (b == 'A') {
writeln("T");
return;
} else if (b == 'T') {
writeln("A");
return;
} else if (b == 'C'){
writeln("G");
return;
} else if (b == 'G') {
writeln("C");
return;
}
}
|
D
|
import std.conv;
import std.stdio;
import std.string;
void main()
{
auto nk = readln.split.to!( int[] );
auto as = readln.split.to!( int[] );
writeln( solve( nk[ 1 ], as ) );
}
auto solve( in int k, in int[] as )
{
auto as_r = as.length - k;
auto k_r = k - 1;
auto c = 1 + as_r / k_r;
auto re = ( as_r % k_r == 0 ) ? 0 : 1;
return c + re;
}
unittest
{
assert( solve( 3, [ 2, 3, 1, 4 ] ) == 2 );
assert( solve( 3, [ 1, 2, 3 ] ) == 1 );
assert( solve( 3, [ 7, 3, 1, 8, 4, 6, 2, 5 ] ) == 4 );
assert( solve( 3, [ 7, 3, 6, 8, 4, 1, 2, 5 ] ) == 4 );
assert( solve( 3, [ 7, 3, 6, 1, 4, 8, 2, 5 ] ) == 4 );
assert( solve( 3, [ 7, 3, 6, 4, 1, 8, 2, 5 ] ) == 4 );
assert( solve( 3, [ 7, 3, 8, 1, 4, 6, 2, 5, 9 ] ) == 4 );
assert( solve( 3, [ 7, 3, 8, 4, 6, 1, 2, 5, 9 ] ) == 4 );
assert( solve( 3, [ 7, 3, 8, 4, 1, 6, 2, 5, 9 ] ) == 4 );
}
|
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.functional,
std.getopt,
std.json,
std.math,
std.mathspecial,
std.meta,
std.mmfile,
std.net.curl,
std.net.isemail,
std.numeric,
std.parallelism,
std.path,
std.process,
std.random,
std.range,
std.regex,
std.signals,
std.socket,
std.stdint,
std.stdio,
std.string,
std.system,
std.traits,
std.typecons,
std.uni,
std.uri,
std.utf,
std.uuid,
std.variant,
std.zip,
std.zlib;
/*}}}*/
/+---test
13
---+/
void main(string[] args) {
const N = readln.chomp.to!long;
(N*(N-1)/2).writeln;
}
|
D
|
import std.stdio;
import std.string;
import std.conv;
import std.math;
int main()
{
double x=0.0,y=0.0,angle=90;
while(true)
{
string[] s = readln.chomp.split(",");
if(s[0] == "0" && s[1] == "0") break;
int value = s[0].to!int;
int value_2 = s[1].to!int;
x += cos(angle*PI/180)*value;
y += sin(angle*PI/180)*value;
angle -= value_2;
}
writeln(cast(int)x);
writeln(cast(int)y);
return 0;
}
|
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() {
long N;
scan(N);
long ans = inf6;
for (long i = 1; i*i <= N; i++) {
if (N % i == 0) {
ans = min(ans, i + N / i - 2);
}
}
writeln(ans);
}
void scan(T...)(ref T args) {
import std.stdio : readln;
import std.algorithm : splitter;
import std.conv : to;
import std.range.primitives;
auto line = readln().splitter();
foreach (ref arg; args) {
arg = line.front.to!(typeof(arg));
line.popFront();
}
assert(line.empty);
}
void fillAll(R, T)(ref R arr, T value) {
static if (is(typeof(arr[] = value))) {
arr[] = value;
}
else {
foreach (ref e; arr) {
fillAll(e, value);
}
}
}
bool chmin(T, U...)(ref T x, U args) {
bool isChanged;
foreach (arg; args) {
if (x > arg) {
x = arg;
isChanged = true;
}
}
return isChanged;
}
bool chmax(T, U...)(ref T x, U args) {
bool isChanged;
foreach (arg; args) {
if (x < arg) {
x = arg;
isChanged = true;
}
}
return isChanged;
}
|
D
|
void main() {
problem();
}
void problem() {
auto X = scan!long;
long solve() {
return 8 - (X - 400) / 200;
}
solve().writeln;
}
// ----------------------------------------------
import std.stdio, std.conv, std.array, std.string, std.algorithm, std.container, std.range, core.stdc.stdlib, std.math, std.typecons, std.numeric;
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); }
string scan(){ static string[] ss; while(!ss.length) ss = readln.chomp.split; string res = ss[0]; ss.popFront; return res; }
T scan(T)(){ return scan.to!T; }
T[] scan(T)(int n){ return n.iota.map!(i => scan!T()).array; }
void deb(T ...)(T t){ debug writeln(t); }
alias Point = Tuple!(long, "x", long, "y");
// -----------------------------------------------
|
D
|
import std.stdio;
void main() {
int x;
scanf("%d", &x);
if ((x % 100 + 4) / 5 <= x / 100) {
1.write;
}
else {
0.write;
}
}
|
D
|
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
void main() {
while(true) {
auto NM = readln().split();
int N = to!int(NM[0]);
int M = to!int(NM[1]);
if(N == 0)
break;
const int INF = 200*1000*1000*2;
int[200][200] ldist;
int[200][200] sdist;
for(int i; i < N; ++i){
for(int j; j < N; ++j) {
if(i == j) {
ldist[i][j] = sdist[i][j] = 0;
} else {
ldist[i][j] = sdist[i][j] = INF;
}
}
}
for(int i; i < M; ++i) {
auto s = readln().split();
int x = to!int(s[0])-1;
int y = to!int(s[1])-1;
int t = to!int(s[2]);
auto sl = s[3];
if(sl == "L") {
ldist[x][y] = ldist[y][x] = min(ldist[x][y], t);
} else {
sdist[x][y] = sdist[y][x] = min(sdist[x][y], t);
}
}
for(int k; k < N; ++k){
for(int i; i < N; ++i){
for(int j; j < N; ++j){
ldist[i][j] = min(ldist[i][k] + ldist[k][j], ldist[i][j]);
sdist[i][j] = min(sdist[i][k] + sdist[k][j], sdist[i][j]);
}
}
}
int R = to!int(readln().chomp());
auto sz = readln().chomp().split();
int[1000] z;
for(int i; i < R; ++i){
z[i] = to!int(sz[i])-1;
}
long[200][1000] dp;
for(int i; i < R; ++i){
for(int j; j < N; ++j){
dp[i][j] = INF;
}
}
dp[0][z[0]] = 0;
for(int i = 1; i < R; ++i){
for(int j = 0; j < N; ++j){
for(int k = 0; k < N; ++k){
if(j == k) {
dp[i][j] = min(dp[i][j], dp[i-1][j] + ldist[z[i-1]][z[i]]);
} else {
dp[i][j] = min(dp[i][j], dp[i-1][k] + ldist[z[i-1]][k] + sdist[k][j] + ldist[j][z[i]]);
}
}
}
}
long ans = dp[R-1][0];
for(int i; i < N; ++i) {
ans = min(ans, dp[R-1][i]);
}
writeln(ans);
}
}
|
D
|
import std.stdio,
std.array,
std.conv,
std.string,
std.algorithm;
void main(){
int kane = 100000;
string s;
for(;;){
s=readln();
if(stdin.eof()) break;
int weeks = to!int(chomp(s));
for(int i = 0;i < weeks; ++i){
kane = kane + cast(int)(kane/100)*5;
if(kane > cast(int)(kane/1000)*1000){
kane = cast(int)(kane/1000)*1000 + 1000;
}
}
writeln(kane);
}
}
|
D
|
void main(){
import std.stdio, std.string, std.conv, std.algorithm;
int x; rd(x);
auto ushi="ai1333".to!(char[]);
while(x){
ushi~='3';
x-=100;
}
writeln(ushi);
}
void rd(T...)(ref T x){
import std.stdio, std.string, std.conv;
auto l=readln.split;
assert(l.length==x.length);
foreach(i, ref e; x){
e=l[i].to!(typeof(e));
}
}
|
D
|
void main() {
import std.stdio, std.string, std.conv, std.algorithm;
long n, m;
rd(n, m);
auto s = readln.chomp.to!(char[]);
auto t = readln.chomp.to!(char[]);
import std.numeric : gcd;
auto l = n * m / gcd(n, m);
char[long] ch;
foreach (i; 0 .. n) {
auto j = i * (l / n);
ch[j] = s[i];
}
foreach (i; 0 .. m) {
auto j = i * (l / m);
if (j in ch) {
if (ch[j] != t[i]) {
writeln(-1);
return;
}
}
}
writeln(l);
}
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);
foreach (i, ref e; x)
e = l[i].to!(typeof(e));
}
|
D
|
import std.algorithm, std.stdio, std.string;
void main() {
auto s = readln.chomp;
(cast(ubyte[])s).sort;
writeln(s == "abc" ? "Yes" : "No");
}
|
D
|
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.array;
void main(){
auto M=readln.chomp.to!int;
writeln(24+(24-M));
}
|
D
|
import std.string,
std.stdio,
std.conv,
std.math,
std.range,
std.algorithm;
void main(){
auto ps = readln.chomp.split.map!(to!double);
printf("%.8lf\r\n", sqrt(pow(ps[2]-ps[0], 2) + pow(ps[3]-ps[1], 2)));
}
|
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;
scan(n);
auto x = new int[](n);
auto y = new int[](n);
auto h = new int[](n);
int hm;
foreach (i ; 0 .. n) {
scan(x[i], y[i], h[i]);
hm = max(hm, h[i]);
}
int calcH(int cx, int cy, int x, int y, int h) {
return max(h - abs(x - cx) - abs(y - cy), 0);
}
foreach (cx ; 0 .. 100 + 1) {
foreach (cy ; 0 .. 100 + 1) {
foreach (hh ; hm .. hm + 201) {
bool ok = true;
foreach (i ; 0 .. n) {
if (calcH(cx, cy, x[i], y[i], hh) != h[i]) {
ok = false;
break;
}
}
if (ok) {
writeln(cx, " ", cy, " ", hh);
return;
}
}
}
}
}
void scan(T...)(ref T args) {
import std.stdio : readln;
import std.algorithm : splitter;
import std.conv : to;
import std.range.primitives;
auto line = readln().splitter();
foreach (ref arg; args) {
arg = line.front.to!(typeof(arg));
line.popFront();
}
assert(line.empty);
}
void fillAll(R, T)(ref R arr, T value) {
static if (is(typeof(arr[] = value))) {
arr[] = value;
}
else {
foreach (ref e; arr) {
fillAll(e, value);
}
}
}
|
D
|
import std.stdio,std.string,std.conv;
int[] value;
string dfs(int left,int right,int i)
{
if(i == 10) return "YES";
if(left < value[i])
{
return dfs(value[i],right,i+1);
}
if(right < value[i])
{
return dfs(left,value[i],i+1);
}
return "NO";
}
int main()
{
value.length = 10;
int n = readln.chomp.to!int;
foreach(i;0..n)
{
string[] s = readln.chomp.split(" ");
foreach(j;0..10)
{
value[j] = s[j].to!int;
}
writeln(dfs(0,0,0));
}
return 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;
alias Generator = std.concurrency.Generator;
void main() {
readln.chomp.canFind!"a=='9'".pipe!"a?\"Yes\":\"No\"".writeln;
}
// ----------------------------------------------
void scanln(Args...)(ref Args args) {
foreach(i, ref v; args) {
"%d".readf(&v);
(i==args.length-1 ? "\n" : " ").readf;
}
// ("%d".repeat(args.length).join(" ") ~ "\n").readf(args);
}
void times(alias fun)(int n) {
// n.iota.each!(i => fun());
foreach(i; 0..n) fun();
}
auto rep(alias fun, T = typeof(fun()))(int n) {
// return n.iota.map!(i => fun()).array;
T[] res = new T[n];
foreach(ref e; res) e = fun();
return res;
}
// fold was added in D 2.071.0
static if (__VERSION__ < 2071) {
template fold(fun...) if (fun.length >= 1) {
auto fold(R, S...)(R r, S seed) {
static if (S.length < 2) {
return reduce!fun(seed, r);
} else {
return reduce!fun(tuple(seed), r);
}
}
}
}
// cumulativeFold was added in D 2.072.0
static if (__VERSION__ < 2072) {
template cumulativeFold(fun...)
if (fun.length >= 1)
{
import std.meta : staticMap;
private alias binfuns = staticMap!(binaryFun, fun);
auto cumulativeFold(R)(R range)
if (isInputRange!(Unqual!R))
{
return cumulativeFoldImpl(range);
}
auto cumulativeFold(R, S)(R range, S seed)
if (isInputRange!(Unqual!R))
{
static if (fun.length == 1)
return cumulativeFoldImpl(range, seed);
else
return cumulativeFoldImpl(range, seed.expand);
}
private auto cumulativeFoldImpl(R, Args...)(R range, ref Args args)
{
import std.algorithm.internal : algoFormat;
static assert(Args.length == 0 || Args.length == fun.length,
algoFormat("Seed %s does not have the correct amount of fields (should be %s)",
Args.stringof, fun.length));
static if (args.length)
alias State = staticMap!(Unqual, Args);
else
alias State = staticMap!(ReduceSeedType!(ElementType!R), binfuns);
foreach (i, f; binfuns)
{
static assert(!__traits(compiles, f(args[i], e)) || __traits(compiles,
{ args[i] = f(args[i], e); }()),
algoFormat("Incompatible function/seed/element: %s/%s/%s",
fullyQualifiedName!f, Args[i].stringof, E.stringof));
}
static struct Result
{
private:
R source;
State state;
this(R range, ref Args args)
{
source = range;
if (source.empty)
return;
foreach (i, f; binfuns)
{
static if (args.length)
state[i] = f(args[i], source.front);
else
state[i] = source.front;
}
}
public:
@property bool empty()
{
return source.empty;
}
@property auto front()
{
assert(!empty, "Attempting to fetch the front of an empty cumulativeFold.");
static if (fun.length > 1)
{
import std.typecons : tuple;
return tuple(state);
}
else
{
return state[0];
}
}
void popFront()
{
assert(!empty, "Attempting to popFront an empty cumulativeFold.");
source.popFront;
if (source.empty)
return;
foreach (i, f; binfuns)
state[i] = f(state[i], source.front);
}
static if (isForwardRange!R)
{
@property auto save()
{
auto result = this;
result.source = source.save;
return result;
}
}
static if (hasLength!R)
{
@property size_t length()
{
return source.length;
}
}
}
return Result(range, args);
}
}
}
// minElement/maxElement was added in D 2.072.0
static if (__VERSION__ < 2072) {
auto minElement(alias map, Range)(Range r)
if (isInputRange!Range && !isInfinite!Range)
{
alias mapFun = unaryFun!map;
auto element = r.front;
auto minimum = mapFun(element);
r.popFront;
foreach(a; r) {
auto b = mapFun(a);
if (b < minimum) {
element = a;
minimum = b;
}
}
return element;
}
auto maxElement(alias map, Range)(Range r)
if (isInputRange!Range && !isInfinite!Range)
{
alias mapFun = unaryFun!map;
auto element = r.front;
auto maximum = mapFun(element);
r.popFront;
foreach(a; r) {
auto b = mapFun(a);
if (b > maximum) {
element = a;
maximum = b;
}
}
return element;
}
}
|
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.bigint;
void main()
{
auto inp = readln.split.map!(to!int).array;
int cnt;
auto num = [1, 1, 2, 7, 4];
while (1) {
foreach (i; 0..5) {
inp[i] -= num[i];
}
if (inp.count!(a => a <0)) break;
else cnt++;
}
cnt.writeln;
}
|
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 f = true;
foreach (i; 0..s.length/2) {
if (s[i] != s[$-i-1]) {
f = false;
}
}
foreach (i; 0..s.length/4) {
if (s[i] != s[$/2-1-i]) {
f = false;
}
if (s[$/2+1+i] != s[$-1-i]) {
f = false;
}
}
if (f) {
writeln("Yes");
} else {
writeln("No");
}
}
|
D
|
import std.stdio;
import std.conv;
import std.string;
void main()
{
auto a = readln.chomp.to!int;
auto b = readln.chomp.to!int;
auto h = readln.chomp.to!int;
writeln ((a + b ) * h / 2);
}
|
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;
import std.container;
void main()
{
int[char] pat;
pat['I'] = 1;
pat['V'] = 5;
pat['X'] = 10;
pat['L'] = 50;
pat['C'] = 100;
pat['D'] = 500;
pat['M'] = 1000;
foreach (line; stdin.byLine) {
int pre;
int sum;
foreach_reverse(c; line.chomp) {
auto v = pat[c];
if (pre <= v) {
sum += v;
} else {
sum -= v;
}
pre = v;
}
sum.writeln;
}
}
|
D
|
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.math;
import std.regex;
void main() {
auto N = readln.chomp.to!int;
foreach(i;1..10) {
if(pow(2, i) > N) {
pow(2, i-1).writeln;
break;
}
}
}
|
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;
int a;
int[] p = [1,4,10,20,35];
int[] dp,odp;
void main(){
for(int i=6;i<300;i++){
p ~= i * (i+1) * (i+2) / 6;
}
dp = new int[1000001];
odp = new int[1000001];
fill(dp,-1);
fill(odp,-1);
dp[0] = 0;
odp[0] = 0;
for(int i=to!int(p.length)-1;i>=0;i--){
for(int j=p[i];j<=1e6;j++){
if(dp[j-p[i]] > -1){
if(dp[j] > -1)
dp[j] = min(dp[j],1 + dp[j-p[i]]);
else dp[j] = 1 + dp[j-p[i]];
}
if(odp[j-p[i]] > -1){
if(p[i] % 2 == 1){
if(odp[j] > -1)
odp[j] = min(odp[j],1 + odp[j-p[i]]);
else odp[j] = 1 + odp[j-p[i]];
}
}
}
}
while(true){
int n = readln().chomp().to!int;
if(n == 0) break;
writeln(dp[n] , " " , odp[n]);
}
}
|
D
|
void main() {
int[] ab = readln.split.to!(int[]);
ab ~= ab[0] + ab[1];
writeln(ab.any!"a % 3 == 0" ? "Possible" : "Impossible");
}
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.range;
import std.array;
import std.algorithm;
import std.string;
import std.conv;
import std.typecons;
import std.math;
import std.numeric;
void main() {
int[] input;
foreach (i; 0 .. 5) {
input ~= readln().chomp().to!int;
}
immutable k = readln().chomp().to!int;
solve(input, k).writeln();
}
string solve(int[] antennas, int distance) {
auto result = true;
foreach (i, antenna; antennas) {
foreach (other; antennas[i + 1 .. $]) {
if (other - antenna > distance) {
result = false;
break;
}
if (!result) {
break;
}
}
}
if (result) {
return "Yay!";
}
else {
return ":(";
}
}
unittest {
assert(solve([1, 2, 4, 8, 9], 15) == "Yay!");
assert(solve([15, 18, 26, 35, 36], 18) == ":(");
}
|
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_rd[0]; s_rd.popFront; return res.to!T; }
string RDR()() { return readln.chomp; }
T[] ARR(T = long)(in string str, T fix = 0) { auto r = str.split.to!(T[]); r[] += fix; return r; }
T[] RDA(T = long)(T fix = 0) { auto r = readln.chomp.split.to!(T[]); r[] += fix; return r; }
T[][] RDA2(T = long)(size_t n, T[] fix = []) { auto r = new T[][](n); foreach (i; 0..n) { r[i] = readln.chomp.split.to!(T[]); foreach (j, e; fix) r[i][j] += e; } return r; }
size_t[] MAKE_IDX(alias less = "a < b", Range)(Range range) { auto idx = new size_t[](range.length); makeIndex!(less)(range, idx); return idx;}
size_t MIN_POS(alias less = "a < b", Range)(Range range) { auto r = minPos!(less)(range); return range.length - r.length; }
bool inside(T)(T x, T b, T e) { return x >= b && x < e; }
long lcm(long x, long y) { return x * (y / gcd(x, y)); }
long mod = 10^^9 + 7;
//long mod = 998244353;
//long mod = 1_000_003;
void moda(ref long x, long y) { x = (x + y) % mod; }
void mods(ref long x, long y) { x = ((x + mod) - (y % mod)) % mod; }
void modm(ref long x, long y) { x = (x * y) % mod; }
long[2][] primeFact(long x)
{
long[2][] ans;
for (long i = 2; i*i <= x; ++i)
{
if (x % i != 0) continue;
long r;
while (x % i == 0)
{
++r;
x /= i;
}
ans ~= [i, r];
}
if (x != 1)
ans ~= [x, 1];
return ans;
}
void main()
{
auto A = RD;
auto B = RD;
auto aa = primeFact(gcd(A, B));
debug writeln(aa);
writeln(aa.length+1);
stdout.flush();
debug readln();
}
|
D
|
void main(){
int n, a;
n = _scan();
a = _scan();
writeln(n%500 <= a?"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; readln().chomp().split()){
ln ~= elm.to!T();
}
return ln;
}
|
D
|
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
enum P = 10L^^9+7;
void main()
{
auto N = readln.chomp.to!long;
auto S = readln.chomp;
long x, r = 1;
foreach (c; S) {
if (c == 'B') {
if (x%2 == 0) {
x += 1;
} else {
(r *= x) %= P;
x -= 1;
}
} else {
if (x%2 == 0) {
(r *= x) %= P;
x -= 1;
} else {
x += 1;
}
}
}
if (x != 0) {
writeln(0);
return;
}
foreach (long n; 1..N+1) (r *= n) %= P;
writeln(r);
}
|
D
|
import std.stdio;
import std.string;
import std.conv;
import std.algorithm;
import std.math;
void main() {
auto S = readln.chomp.to!(dchar[]);
S[3] = '8';
writeln(S);
}
|
D
|
import std.stdio, std.string, std.conv, std.algorithm;
import std.range, std.array, std.math, std.typecons, std.container, core.bitop;
immutable mod = 10^^9 + 7;
void main() {
int a, b, c;
scan(a, b, c);
writeln(a ^ b ^ c);
}
void scan(T...)(ref T args) {
string[] line = readln.split;
foreach (ref arg; args) {
arg = line.front.to!(typeof(arg));
line.popFront();
}
assert(line.empty);
}
void fillAll(R, T)(ref R arr, T value) {
static if (is(typeof(arr[] = value))) {
arr[] = value;
}
else {
foreach (ref e; arr) {
fillAll(e, value);
}
}
}
|
D
|
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array, std.math;
void main() {
int n;
scan(n);
auto a = iota(n).map!(i => readln.chomp.to!int).array;
long ans;
foreach (i ; 0 .. n) {
ans += a[i] / 2;
a[i] %= 2;
if (i < n - 1 && a[i] && a[i+1]) {
ans++;
a[i+1]--;
}
}
writeln(ans);
}
void scan(T...)(ref T args) {
import std.stdio : readln;
import std.algorithm : splitter;
import std.conv : to;
import std.range.primitives;
auto line = readln().splitter();
foreach (ref arg; args) {
arg = line.front.to!(typeof(arg));
line.popFront();
}
assert(line.empty);
}
void fillAll(R, T)(ref R arr, T value) {
static if (is(typeof(arr[] = value))) {
arr[] = value;
}
else {
foreach (ref e; arr) {
fillAll(e, value);
}
}
}
|
D
|
import std.algorithm;
import std.array;
import std.container;
import std.conv;
import std.math;
import std.numeric;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
void scan(T...)(ref T a) {
string[] ss = readln.split;
foreach (i, t; T) a[i] = ss[i].to!t;
}
T read(T)() { return readln.chomp.to!T; }
T[] reads(T)() { return readln.split.to!(T[]); }
alias readint = read!int;
alias readints = reads!int;
void main() {
int n, k; scan(n, k);
string s = read!string;
foreach (i, c; s.enumerate(1)) {
write(i == k ? c.toLower() : c);
}
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, std.bitmanip;
immutable long MOD = 10^^9 + 7;
void main() {
auto N = readln.chomp.to!int;
auto G = new int[][](N);
foreach (i; 0..N-1) {
auto s = readln.split.map!(to!int);
G[s[0]-1] ~= s[1]-1;
G[s[1]-1] ~= s[0]-1;
}
auto mem = new long[][](N, 2);
auto used = new bool[][](N, 2);
long dfs(int n, int p, bool b) {
if (used[n][b]) return mem[n][b];
long bb = 1;
long ww = 1;
long retb = 1;
long retw = 1;
if (b) retb = 0;
foreach (m; G[n]) {
if (m == p) continue;
retw *= ww * dfs(m, n, false) % MOD;
retb *= bb * dfs(m, n, true) % MOD;
retw %= MOD;
retb %= MOD;
}
used[n][b] = true;
mem[n][b] = (retw + retb) % MOD;
return mem[n][b];
}
dfs(0, -1, 0).writeln;
}
|
D
|
import std.stdio, std.algorithm, std.string, std.conv, std.array, std.range;
void main() {
auto tmp = readln.split.to!(int[]);
foreach (i; tmp[0]..tmp[1]+1) {
if (i < tmp[0] + tmp[2] || i > tmp[1] - tmp[2]) {
writeln(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.to!int;
auto s = readln.chomp;
auto t = readln.chomp;
foreach (i; 0..N+1) {
if (s[i..$] == t[0..N-i]) {
writeln(N + i);
return;
}
}
}
|
D
|
void main()
{
int[] tmp = readln.split.to!(int[]);
int n = tmp[0], a = tmp[1], b = tmp[2];
writeln((b - a) & 1 ? "Borys" : "Alice");
}
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.algorithm;
import std.array;
import std.conv;
import std.math;
import std.stdio;
import std.string;
import std.range;
int readint() {
return readln.chomp.to!int;
}
int[] readints() {
return readln.split.map!(to!int).array;
}
void main() {
auto s = readln.chomp;
writeln(s[0] == s[2] ? "Yes" : "No");
}
|
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(DEBUG) write(t, " "), log(a); } bool DEBUG = 0;
string read(){ static string[] ss; while(!ss.length) ss = readln.chomp.split; string res = ss[0]; ss.popFront; return res; }
// ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- //
void solve(){
int n = read.to!int;
int k = read.to!int;
n -= (k - 1);
int ans;
if(k == 1) ans = 0;
else ans = n - 1;
ans.writeln;
}
|
D
|
import std.stdio;
import std.string;
import std.array;
import std.conv;
import std.algorithm;
void main(){
int[] change;
while(true){
int input = readln().chomp().to!int();
if(input != 0){ change ~= 1000 - input; }else{ break; }
}
foreach(int i; change){
int count = 0;
while(i - 500 >= 0){
i -= 500; count++;
}
while(i - 100 >= 0){
i -= 100; count++;
}
while(i - 50 >= 0){
i -= 50; count++;
}
while(i - 10 >= 0){
i -= 10; count++;
}
while(i - 5 >= 0){
i -= 5; count++;
}
while(i - 1 >= 0){
i -= 1; count++;
}
writeln(count);
}
}
|
D
|
import std.algorithm, std.container, std.conv, std.math, std.range, std.typecons, std.stdio, std.string;
import std.bitmanip;
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 r=rdsp;foreach(ref v;t)pick(r,v);}
void readM(T)(size_t r,size_t c,ref T[][]t){t=new T[][](r);foreach(ref v;t)readA(c,v);}
void main()
{
int n; readV(n);
int[][] a; readM(n, n, a);
auto dp = new long[](1<<n);
foreach (i; 1..1<<n) {
if (i.popcnt == 1) continue;
auto r = 0L;
foreach (j; 0..n)
foreach (k; j+1..n)
if (i.bitTest(j) && i.bitTest(k))
r += a[j][k];
for (auto j = i; ; j = (j-1)&i) {
r = max(r, dp[j]+dp[i^j]);
if (j == 0) break;
}
dp[i] = r;
}
writeln(dp[$-1]);
}
pragma(inline) {
pure bool bitTest(T)(T n, size_t i) { return (n & (T(1) << i)) != 0; }
pure T bitSet(T)(T n, size_t i) { return n | (T(1) << i); }
pure T bitReset(T)(T n, size_t i) { return n & ~(T(1) << i); }
pure T bitComp(T)(T n, size_t i) { return n ^ (T(1) << i); }
pure T bitSet(T)(T n, size_t s, size_t e) { return n | ((T(1) << e) - 1) & ~((T(1) << s) - 1); }
pure T bitReset(T)(T n, size_t s, size_t e) { return n & (~((T(1) << e) - 1) | ((T(1) << s) - 1)); }
pure T bitComp(T)(T n, size_t s, size_t e) { return n ^ ((T(1) << e) - 1) & ~((T(1) << s) - 1); }
import core.bitop;
pure int bsf(T)(T n) { return core.bitop.bsf(ulong(n)); }
pure int bsr(T)(T n) { return core.bitop.bsr(ulong(n)); }
pure int popcnt(T)(T n) { return core.bitop.popcnt(ulong(n)); }
}
|
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;
int n, m;
int[][] adj;
bool ok(int now, int depth)
{
if (depth == 2) {
return now == n;
}
bool flag = false;
foreach (next; adj[now]) {
flag |= ok(next, depth + 1);
}
return flag;
}
void main()
{
auto nm = readln.chomp.split.map!(to!int);
n = nm.front;
m = nm.back;
adj = new int[][](n + 1);
foreach (i; 0..m) {
auto ab = readln.chomp.split.map!(to!int);
int a = ab.front;
int b = ab.back;
adj[a] ~= b;
adj[b] ~= a;
}
writeln = ok(1, 0) ? "POSSIBLE" : "IMPOSSIBLE";
}
|
D
|
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
auto n = readln.chomp.to!long, ns = n.nsqrt;
foreach_reverse (a; 1..ns+1)
if (n % a == 0) {
writeln((n/a).digits);
break;
}
}
auto digits(long x)
{
foreach (i; 1..11)
if (x / 10L ^^ i == 0) return i;
assert(0);
}
pure T nsqrt(T)(T n)
{
import std.algorithm, std.conv, std.range, core.bitop;
if (n <= 1) return n;
T m = 1 << (n.bsr / 2 + 1);
return iota(1, m).map!"a * a".assumeSorted!"a <= b".lowerBound(n).length.to!T;
}
|
D
|
import std.algorithm;
import std.array;
import std.ascii;
import std.container;
import std.conv;
import std.format;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.typecons;
bool is_parindrome(string s)
{
ulong len = s.length;
for (int i = 0; i < len / 2; ++i) {
if (s[i] != s[len - 1 - i]) {
return false;
}
}
return true;
}
void main()
{
string str = readln.chomp;
string dst = "";
int[] index;
foreach (int i, c; str) {
if (c == 'x') {
continue;
}
dst ~= c;
index ~= i;
}
if (!dst.is_parindrome) {
writeln = -1;
return;
}
if (dst.length == 0) {
writeln = 0;
return;
}
int right;
int left;
if (dst.length % 2 == 1) {
right = index[dst.length / 2] + 1;
left = index[dst.length / 2] - 1;
} else {
right = index[dst.length / 2];
left = index[dst.length / 2 - 1];
}
// stderr.writeln(left, " ", right);
int cnt = 0;
while (0 <= left && right < str.length) {
if (str[left] == str[right]) {
--left;
++right;
continue;
}
if (str[left] == 'x') {
++cnt;
--left;
}
else if (str[right] == 'x') {
++cnt;
++right;
}
else {
writeln = -1;
return;
}
}
cnt += left + 1 + str.length - right;
bool dame = false;
for (; 0 <= left; --left) {
dame |= str[left] != 'x';
}
for (; right < str.length; ++right) {
dame |= str[right] != 'x';
}
if (dame) {
writeln = -1;
return;
}
cnt.writeln;
}
|
D
|
void main() {
import std.stdio, std.string, std.conv, std.algorithm;
int n;
rd(n);
int len = 0;
foreach (i; 0 .. n) {
int x, y;
rd(x, y);
len = max(len, x + y);
}
writeln(len);
}
void rd(T...)(ref T x) {
import std.stdio, std.string, std.conv;
auto l = readln.split;
assert(l.length == x.length);
foreach (i, ref e; x)
e = l[i].to!(typeof(e));
}
|
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.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].to!(T);Args[i] = val;}}
alias sread = () => readln.chomp();enum MOD = 10 ^^ 9 + 7;
alias PQueue(T, alias less = "a<b") = BinaryHeap!(Array!T, less);
// dfmt on
void main()
{
long N, A, B, C, D;
scan(N, A, B, C, D);
A--, B--, C--, D--;
auto S = sread();
auto safe = new bool[](N);
foreach (i; 0 .. N)
safe[i] = (S[i] == '.');
bool reachableA = true, reachableB = true, skippable;
foreach (i; 0 .. N)
{
if (A < i && i <= C && S[i] == '#' && S[i - 1] == '#')
reachableA = false;
if (B < i && i <= D && S[i] == '#' && S[i - 1] == '#')
reachableB = false;
if (B <= i && i <= D && i + 1 < N && S[i - 1] == '.' && S[i] == '.' && S[i + 1] == '.')
skippable = true;
}
if (!reachableA || !reachableB)
{
writeln("No");
return;
}
if (C < D)
{
writeln("Yes");
return;
}
writeln(skippable ? "Yes" : "No");
}
|
D
|
/+ dub.sdl:
name "B"
dependency "dcomp" version=">=0.6.0"
+/
import std.stdio, std.algorithm, std.range, std.conv;
// import dcomp.foundation, dcomp.scanner;
int main() {
auto sc = new Scanner(stdin);
string s;
sc.read(s);
long[26] cnt;
s.each!(c => cnt[c-'a']++);
long sm = 1;
foreach (i; 0..26) {
foreach (j; i+1..26) {
sm += cnt[i] * cnt[j];
}
}
writeln(sm);
return 0;
}
/* IMPORT /home/yosupo/Program/dcomp/source/dcomp/foundation.d */
// module dcomp.foundation;
static if (__VERSION__ <= 2070) {
template fold(fun...) if (fun.length >= 1) {
auto fold(R, S...)(R r, S seed) {
import std.algorithm : reduce;
static if (S.length < 2) {
return reduce!fun(seed, r);
} else {
import std.typecons : tuple;
return reduce!fun(tuple(seed), r);
}
}
}
}
version (X86) static if (__VERSION__ < 2071) {
import core.bitop : bsf, bsr, popcnt;
int bsf(ulong v) {
foreach (i; 0..64) {
if (v & (1UL << i)) return i;
}
return -1;
}
int bsr(ulong v) {
foreach_reverse (i; 0..64) {
if (v & (1UL << i)) return i;
}
return -1;
}
int popcnt(ulong v) {
int c = 0;
foreach (i; 0..64) {
if (v & (1UL << i)) c++;
}
return c;
}
}
/* IMPORT /home/yosupo/Program/dcomp/source/dcomp/scanner.d */
// module dcomp.scanner;
class Scanner {
import std.stdio : File;
import std.conv : to;
import std.range : front, popFront, array, ElementType;
import std.array : split;
import std.traits : isSomeChar, isStaticArray, isArray;
import std.algorithm : map;
File f;
this(File f) {
this.f = f;
}
char[512] lineBuf;
char[] line;
private bool succ() {
import std.range.primitives : empty, front, popFront;
import std.ascii : isWhite;
while (true) {
while (!line.empty && line.front.isWhite) {
line.popFront;
}
if (!line.empty) break;
if (f.eof) return false;
line = lineBuf[];
f.readln(line);
}
return true;
}
private bool readSingle(T)(ref T x) {
import std.algorithm : findSplitBefore;
import std.string : strip;
import std.conv : parse;
if (!succ()) return false;
static if (isArray!T) {
alias E = ElementType!T;
static if (isSomeChar!E) {
auto r = line.findSplitBefore(" ");
x = r[0].strip.dup;
line = r[1];
} else {
auto buf = line.split.map!(to!E).array;
static if (isStaticArray!T) {
assert(buf.length == T.length);
}
x = buf;
line.length = 0;
}
} else {
x = line.parse!T;
}
return true;
}
int read(T, Args...)(ref T x, auto ref Args args) {
if (!readSingle(x)) return 0;
static if (args.length == 0) {
return 1;
} else {
return 1 + read(args);
}
}
}
|
D
|
import std.stdio, std.algorithm, std.range, std.conv, std.string, std.math;
import core.stdc.stdio;
// foreach, foreach_reverse, writeln
void main() {
int[] a = new int[3];
foreach (i; 0..3) {
scanf("%d", &a[i]);
}
a.sort;
int ans = 0;
foreach (i; 0..3) {
ans += a[2]-a[i];
}
if (ans%2 == 1) ans += 3;
writeln(ans/2);
}
|
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.range;
import std.stdio;
import std.string;
import std.typecons;
void main()
{
string str = readln.chomp;
int n = cast(int) str.length;
int[] a = new int[](n + 1);
foreach (i; 0..n) {
a[i + 1] = a[i] ^ (1 << (str[i] - 'a'));
}
int[] dp = new int[](1 << 26);
dp[] = int.max >> 2;
dp[0] = 0;
foreach (i; 1..n + 1) {
int opt = dp[a[i]];
foreach (j; 0..26) {
opt = min(opt, dp[a[i] ^ (1 << j)]);
}
// stderr.writeln(format("%02d", i), " ", format("%026b", a[i]), " ", opt);
dp[a[i]] = min(dp[a[i]], opt + 1);
}
dp[a[n]].max(1).writeln;
}
|
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;
immutable int MED_N = 1_000_006;
immutable int MAX_N = MED_N * 2 + 1;
void main ()
{
int n, k;
while (scanf (" %d %d", &n, &k) > 0)
{
auto a = new int [MAX_N * 2];
int m = MED_N - 1;
foreach (i; 0..n)
{
int v;
scanf (" %d", &v);
a[v]++;
m = min (m, v);
}
auto s = new int [MAX_N];
s[0] = 0;
foreach (i; 1..MAX_N)
{
s[i] = s[i - 1] + a[i];
}
int res = 1;
foreach_reverse (d; 2..m + 1)
{
bool ok = true;
for (int i = d * 2; i < MAX_N; i += d)
{
int j = min (i - d + k, i);
if (s[i - 1] > s[j])
{
ok = false;
break;
}
}
if (ok)
{
res = d;
break;
}
}
writeln (res);
}
}
|
D
|
import std.stdio, std.string, std.conv, std.range, std.array, std.algorithm;
import std.uni, std.math, std.container, std.typecons, std.typetuple;
import core.bitop, std.datetime;
long ans = 1L<<60;
void main(){
long h, w;
readVars(h, w);
calc(h, w);
calc(w, h);
writeln(ans);
}
void calc(long h, long w){
long s0, s1, s2;
foreach (a ; 1 .. w) {
s0 = a * h;
s1 = h * ((w - a + 1) / 2);
s2 = h * ((w - a) / 2);
ans = min(ans, max(s0, s1, s2) - min(s0, s1, s2));
s1 = (w - a) * ((h + 1) / 2);
s2 = (w - a) * (h / 2);
ans = min(ans, max(s0, s1, s2) - min(s0, s1, s2));
}
}
void readVars(T...)(auto ref T args){
auto line = readln.split;
foreach(ref arg ; args){
arg = line.front.to!(typeof(arg));
line.popFront;
}
if(!line.empty){
throw new Exception("args num < input num");
}
}
|
D
|
import std;
void main() {
string s = read;
foreach (c; s) {
if (c == '?') write('D');
else write(c);
}
writeln();
}
void scan(T...)(ref T a) {
string[] ss = readln.split;
foreach (i, t; T) a[i] = ss[i].to!t;
}
T read(T=string)() { return readln.chomp.to!T; }
T[] reads(T)() { return readln.split.to!(T[]); }
alias readints = reads!int;
|
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 = 10^^9 + 7;
void main() {
int n;
scan(n);
auto a = new int[](n);
auto b = new int[](n);
auto c = new int[](n);
foreach (i ; 0 .. n) {
scan(a[i], b[i], c[i]);
}
auto dp = new int[][](n + 1, 4);
fillAll(dp, -inf);
dp[0][0] = 0;
foreach (i ; 0 .. n) {
foreach (j ; 0 .. 4) {
if (j != 1) {
dp[i+1][1] = max(dp[i+1][1], dp[i][j] + a[i]);
}
if (j != 2) {
dp[i+1][2] = max(dp[i+1][2], dp[i][j] + b[i]);
}
if (j != 3) {
dp[i+1][3] = max(dp[i+1][3], dp[i][j] + c[i]);
}
}
}
int ans = max(dp[n][1], dp[n][2], dp[n][3]);
writeln(ans);
}
void scan(T...)(ref T args) {
import std.stdio : readln;
import std.algorithm : splitter;
import std.conv : to;
import std.range.primitives;
auto line = readln().splitter();
foreach (ref arg; args) {
arg = line.front.to!(typeof(arg));
line.popFront();
}
assert(line.empty);
}
void fillAll(R, T)(ref R arr, T value) {
static if (is(typeof(arr[] = value))) {
arr[] = value;
}
else {
foreach (ref e; arr) {
fillAll(e, value);
}
}
}
|
D
|
import std.algorithm;
import std.conv;
import std.range;
import std.stdio;
import std.string;
immutable string alt = "!@#";
void main ()
{
auto tests = readln.strip.to !(int);
foreach (test; 0..tests)
{
auto s = readln.strip.dup;
auto n = s.length.to !(int);
int res = 0;
foreach (i; 1..n)
{
if (s[i] == s[i - 1] || (i >= 2 && s[i] == s[i - 2]))
{
s[i] = alt[i % 3];
res += 1;
}
}
writeln (res);
}
}
|
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()
{
(readln.chomp[0]+1).to!char.writeln;
}
|
D
|
void main()
{
string s = rdStr;
long n = 2019;
long len = s.length;
long[] dp1 = new long[n];
long[] dp2 = new long[n];
long result;
foreach (x; s)
{
long m = x - '0';
++dp1[m];
foreach (j; 0 .. n)
{
dp1[(10*j+m)%n] += dp2[j];
}
result += dp1[0];
dp2[] = dp1[];
dp1[] = 0;
}
result.writeln;
}
enum long mod = 10^^9 + 7;
enum long inf = 1L << 60;
enum double eps = 1.0e-9;
T rdElem(T = long)()
if (!is(T == struct))
{
return readln.chomp.to!T;
}
alias rdStr = rdElem!string;
alias rdDchar = rdElem!(dchar[]);
T rdElem(T)()
if (is(T == struct))
{
T result;
string[] input = rdRow!string;
assert(T.tupleof.length == input.length);
foreach (i, ref x; result.tupleof)
{
x = input[i].to!(typeof(x));
}
return result;
}
T[] rdRow(T = long)()
{
return readln.split.to!(T[]);
}
T[] rdCol(T = long)(long col)
{
return iota(col).map!(x => rdElem!T).array;
}
T[][] rdMat(T = long)(long col)
{
return iota(col).map!(x => rdRow!T).array;
}
void rdVals(T...)(ref T data)
{
string[] input = rdRow!string;
assert(data.length == input.length);
foreach (i, ref x; data)
{
x = input[i].to!(typeof(x));
}
}
void wrMat(T = long)(T[][] mat)
{
foreach (row; mat)
{
foreach (j, compo; row)
{
compo.write;
if (j == row.length - 1) writeln;
else " ".write;
}
}
}
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.mathspecial;
import std.traits;
import std.container;
import std.functional;
import std.typecons;
import std.ascii;
import std.uni;
import core.bitop;
|
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() {
auto table = readln.chomp;
auto cards = readln.split;
foreach (card ; cards) {
if (table[0] == card[0] || table[1] == card[1]) {
writeln("YES");
return;
}
}
writeln("NO");
}
void scan(T...)(ref T args) {
import std.stdio : readln;
import std.algorithm : splitter;
import std.conv : to;
import std.range.primitives;
auto line = readln().splitter();
foreach (ref arg; args) {
arg = line.front.to!(typeof(arg));
line.popFront();
}
assert(line.empty);
}
void fillAll(R, T)(ref R arr, T value) {
static if (is(typeof(arr[] = value))) {
arr[] = value;
}
else {
foreach (ref e; arr) {
fillAll(e, value);
}
}
}
|
D
|
import std.stdio,
std.range,
std.algorithm;
void main(){
readln();
readln().split().retro().join(" ").writeln();
}
|
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 s = readln.strip;
auto n = s.length.to !(int);
int p = 1;
foreach (i; 1..n)
{
if (s[i - 1] + s[i] > '0' + '9')
{
p = i;
}
}
writeln (s[0..p - 1], s[p - 1] + s[p] - '0' - '0',
s[p + 1..$]);
}
}
|
D
|
void main()
{
int[] tmp = readln.split.to!(int[]);
int n = tmp[0], m = tmp[1];
int[][] services = new int[][](n);
foreach (i; 0 .. m)
{
tmp = readln.split.to!(int[]);
int a = tmp[0] - 1, b = tmp[1] - 1;
services[a] ~= b;
services[b] ~= a;
}
bool ok;
foreach (x; services[0])
{
foreach (y; services[x])
{
if (y == n - 1)
{
ok = true;
}
}
}
writeln(ok ? "POSSIBLE" : "IMPOSSIBLE");
}
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 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 = Tuple!(long, "y", long, "x");
T lread(T = long)()
{
return readln.chomp.to!T();
}
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].to!(T);
Args[i] = val;
}
}
enum MOD = (10 ^^ 9) + 7;
void main()
{
long a, b, c, d;
scan(a, b, c, d);
long H = d - b;
long W = c - a;
string ans;
ans ~= repeat('R').take(W).array;
ans ~= repeat('U').take(H).array;
ans ~= repeat('L').take(W).array;
ans ~= repeat('D').take(H).array;
ans ~= "DR";
ans ~= repeat('R').take(W).array;
ans ~= repeat('U').take(H).array;
ans ~= "ULUL";
ans ~= repeat('L').take(W).array;
ans ~= repeat('D').take(H).array;
ans ~= "DR";
writeln(ans);
}
|
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!(long[]);
auto N = nk[0];
auto K = nk[1];
writeln(min(N - N/K*K, (N/K+1)*K - N));
}
|
D
|
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array;
void main() {
string N = readln.chomp;
int ans;
foreach (ch ; N) {
ans += ch - '0';
}
ans = max(ans, (N[0] - '0' - 1) + 9 * (N.length.to!int - 1));
writeln(ans);
}
void scan(T...)(ref T args) {
import std.stdio : readln;
import std.algorithm : splitter;
import std.conv : to;
import std.range.primitives;
auto line = readln().splitter();
foreach (ref arg; args) {
arg = line.front.to!(typeof(arg));
line.popFront();
}
assert(line.empty);
}
void fillAll(R, T)(ref R arr, T value) {
static if (is(typeof(arr[] = value))) {
arr[] = value;
}
else {
foreach (ref e; arr) {
fillAll(e, value);
}
}
}
|
D
|
import std.stdio, std.array, std.string, std.conv, std.algorithm;
import std.typecons, std.range, std.random, std.math, std.container;
import std.numeric, std.bigint, core.bitop, core.stdc.string;
immutable long MOD = 10^^9 + 7;
void main() {
auto N = readln.chomp.to!int;
auto A = N.iota.map!(_ => readln.chomp.to!int).array;
auto B = new long[](2*10^^5+10);
A = A.uniq.array;
N = A.length.to!int;
auto dp = new long[](N+1);
dp[0] = 1;
foreach (i; 1..N+1) {
(dp[i] += dp[i-1]) %= MOD;
(dp[i] += B[A[i-1]]) %= MOD;
(B[A[i-1]] += dp[i-1]) %= MOD;
}
dp[N].writeln;
}
|
D
|
import std.stdio;
import std.algorithm.sorting;
void main()
{
int[10] n;
foreach(i;0..10)
scanf("%d", &n[i]);
sort!("a>b")(n[]);
foreach(i;0..3)
writeln(n[i]);
}
|
D
|
import std.stdio;
void main()
{
int n = 0;
int m = 0;
scanf("%d %d", &n, &m);
printf("%d %d\n", n*m, 2*(n+m));
}
|
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[])();}
void scan(TList...)(ref TList Args){auto line = readln.split();
foreach (i, T; TList){T val = line[i].to!(T);Args[i] = val;}}
alias sread = () => readln.chomp();enum MOD = 10 ^^ 9 + 7;
alias PQueue(T, alias less = "a<b") = BinaryHeap!(Array!T, less);
// dfmt on
void main()
{
long A, B, C;
scan(A, B, C);
bool a = A == B && A != C;
bool b = A == C && A != B;
bool c = B == C && A != B;
if (a || b || c)
{
writeln("Yes");
return;
}
writeln("No");
}
|
D
|
void main() {
problem();
}
void problem() {
auto S = scan;
string solve() {
return S[0..3];
}
solve().writeln;
}
// ----------------------------------------------
import std.stdio, std.conv, std.array, std.string, std.algorithm, std.container, std.range, core.stdc.stdlib, std.math, std.typecons, std.numeric;
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); }
string scan(){ static string[] ss; while(!ss.length) ss = readln.chomp.split; string res = ss[0]; ss.popFront; return res; }
T scan(T)(){ return scan.to!T; }
T[] scan(T)(int n){ return n.iota.map!(i => scan!T()).array; }
void deb(T ...)(T t){ debug writeln(t); }
alias Point = Tuple!(long, "x", long, "y");
// -----------------------------------------------
|
D
|
import std.algorithm;
import std.conv;
import std.stdio;
import std.string;
void main()
{
auto ab = readln.split.map!( to!int );
writeln( solve( ab[ 0 ], ab[ 1 ] ) );
}
int solve( in int a, in int b )
{
return ( a <= b ) ? a : a - 1;
}
unittest
{
assert( solve( 5, 5 ) == 5 );
assert( solve( 2, 1 ) == 1 );
assert( solve( 11, 30 ) == 11 );
}
|
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;
enum MAX = 1_000_100;
ulong MOD = 1_000_000_007;
ulong INF = 1_000_000_000_000;
alias sread = () => readln.chomp();
alias INCOME = Tuple!(long, "after", long, "salary");
alias PQueue(T, alias less = "a<b") = BinaryHeap!(Array!T, less);
void main()
{
auto n = lread();
bool flag;
foreach (_; iota(n))
{
auto a = lread();
flag = flag || a % 2;
}
if (flag)
writeln("first");
else
writeln("second");
}
T lread(T = long)()
{
return readln.chomp.to!T();
}
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].to!(T);
Args[i] = val;
}
}
|
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 infl = 1_001_001_001_001_001_001L;
enum mod = 1_000_000_007L;
void main() {
string s;
scan(s);
auto n = s.length.to!int;
if (s == "keyence") {
writeln("YES");
return;
}
foreach (i ; 0 .. n) {
foreach (j ; i + 1 .. n + 1) {
string res;
foreach (k ; 0 .. n) {
if (i <= k && k < j) {
continue;
}
res ~= s[k];
}
if (res == "keyence") {
writeln("YES");
return;
}
}
}
writeln("NO");
}
void scan(T...)(ref T args) {
import std.stdio : readln;
import std.algorithm : splitter;
import std.conv : to;
import std.range.primitives;
auto line = readln().splitter();
foreach (ref arg; args) {
arg = line.front.to!(typeof(arg));
line.popFront();
}
assert(line.empty);
}
void fillAll(R, T)(ref R arr, T value) {
static if (is(typeof(arr[] = value))) {
arr[] = value;
}
else {
foreach (ref e; arr) {
fillAll(e, value);
}
}
}
bool chmin(T, U...)(ref T x, U args) {
bool isChanged;
foreach (arg ; args) {
if (x > arg) {
x = arg;
isChanged = true;
}
}
return isChanged;
}
bool chmax(T, U...)(ref T x, U args) {
bool isChanged;
foreach (arg ; args) {
if (x < arg) {
x = arg;
isChanged = true;
}
}
return isChanged;
}
long powmod(long x, long y, long mod = 1_000_000_007L) {
long res = 1L;
while (y > 0) {
if (y & 1) {
(res *= x) %= mod;
}
(x *= x) %= mod;
y >>= 1;
}
return res;
}
|
D
|
import std.stdio, std.string, std.range, std.conv, std.array, std.algorithm, std.math, std.typecons;
void main() {
const N = readln.chomp.to!long;
const xs = 5.iota.map!(_ => readln.chomp.to!long).array;
writeln(4 + cast(long)ceil(cast(double)N / xs.reduce!min));
}
|
D
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.