code stringlengths 4 1.01M | language stringclasses 2
values |
|---|---|
import std.stdio,std.array,std.conv,std.algorithm,std.range,std.string,std.math;
void main(string[] args) {
real a;
a = readln.chomp.to!real;
a.sqrt.floor.to!int.pow(2).writeln;
} | D |
import std.stdio,std.conv,std.string;
/*int lyca(int n){
if(n==0) return 2;
else if(n==1) return 1;
else return lyca(n-1)+lyca(n-2);
}*/
void main(){
int n=readln().chomp().to!int;
ulong k=2UL,l=1UL,ans=1UL;
for(int i=1;i<n;i++){
ans=k+l; //ansはl(i+1)に対応
k=l;
l=ans;
}
writeln(ans)... | D |
/+ dub.sdl:
name "C"
dependency "dunkelheit" version=">=0.9.0"
+/
import std.stdio, std.algorithm, std.range, std.conv;
// import dkh.foundation, dkh.scanner;
int main() {
Scanner sc = new Scanner(stdin);
scope(exit) sc.read!true;
int n; long l; long[] c;
sc.read(n, l, c);
foreach_revers... | D |
import std.stdio, std.conv, std.functional, std.string;
import std.algorithm, std.array, std.container, std.range, std.typecons;
import std.bigint, std.numeric, std.math, std.random;
import core.bitop;
string FMT_F = "%.10f";
static File _f;
void file_io(string fn) { _f = File(fn, "r"); }
static string[] s_rd;
T _RD(... | D |
//prewritten code: https://github.com/antma/algo
import std.algorithm;
import std.array;
import std.conv;
import std.math;
import std.range;
import std.stdio;
import std.traits;
import core.bitop;
import std.typecons;
class LazyPropagationSegmentTree(T = int, D = int, D init = D.init) {
immutable size_t n;
immutab... | D |
import std.algorithm, std.array, std.container, std.range, std.bitmanip;
import std.numeric, std.math, std.bigint, std.random, core.bitop;
import std.string, std.conv, std.stdio, std.typecons;
void main()
{
while (true) {
auto rd = readln.split.map!(to!int);
auto x = rd[0], y = rd[1];
if (x == 0 && y == ... | D |
import std.stdio;
immutable mod = 4294967311L;
long[] inv_;
void main(){
long x;
int n, y, op;
scanf("%d", &n);
inv_ = new long[1_000_001];
inv_[1] = 1;
foreach(i; 2..50) inv_[i]=mul(inv_[mod%i], mod-mod/i)%mod;
foreach(_; 0..n){
scanf("%d%d", &op, &y);
if(op >= 3 && y < 0) x = -x, y = -y;
if(op == 1) x ... | D |
import std.stdio, std.conv, std.string, std.array, std.range, std.algorithm, std.container;
import std.math, std.random, std.bigint, std.datetime, std.format;
void main(string[] args){ if(args.length > 1) if(args[1] == "-debug") DEBUG = 1; solve(); }
void log()(){ writeln(""); } void log(T, A ...)(T t, lazy A a){ if(DE... | D |
import std.stdio, 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.range;
import std.array;
import std.string;
import std.conv;
import std.typecons;
import std.algorithm;
import std.container;
import std.typecons;
import std.random;
import std.csv;
import std.regex;
import std.math;
import core.time;
import std.ascii;
import std.digest.sha;
import std.outb... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string;
void main()
{
auto sa = readln.chomp;
auto sb = readln.chomp;
auto sc = readln.chomp;
char t = 'a';
for (;;) {
switch (t) {
case 'a':
if (sa.empty) {
writeln("A");
... | D |
import std.stdio, std.array, std.conv, std.typecons, std.algorithm;
T diff(T)(const ref T a, const ref T b) { return a > b ? a - b : b - a; }
void main() {
immutable ip = readln.split.to!(ulong[]);
immutable a = ip[0], p = ip[1];
writeln((a*3+p)/2);
}
| 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;
T lread(T = long)()
{
return readln.chomp.to!T();
}
T[] aryread(T = long)()
{
ret... | D |
import std.stdio, std.string, std.conv;
import std.algorithm, std.array;
auto solve(string s_) {
immutable P = "Possible";
immutable I = "Impossible";
immutable N = s_.to!int();
immutable a = readln.split.map!(to!int).array();
auto c = new int[N];
foreach(v;a) {
if(v<1 || N<=v) return I;... | D |
import std.stdio, std.string, std.conv, std.algorithm;
void main() {
int[] tmp = readln.split.to!(int[]);
int n = tmp[0], a = tmp[1], b = tmp[2];
writeln(min(n*a, b));
} | D |
import std.stdio;
import std.string;
import std.format;
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.concurrency;
import std.traits;
import std.uni;
import c... | D |
import std.stdio, std.string, std.array, std.conv, std.algorithm, std.typecons, std.range;
void main(){
auto hwd=readln.split.map!(to!int).array;
auto H=hwd[0],W=hwd[1],d=hwd[2];
foreach(w;0..H){
foreach(h;0..W){
auto k=w+h;
auto j=w-h;
auto x=k.div(d);
... | D |
import std.stdio, std.conv, std.string;
void main()
{
auto D = readln().strip.to!int;
switch(D)
{
case 25:
writeln("Christmas");
break;
case 24:
writeln("Christmas Eve");
break;
case 23:
writeln("Christmas Eve Eve");
break;... | D |
import std.stdio, std.string, std.array, std.conv;
void main() {
while (true) {
int[] tmp = readln.chomp.split.to!(int[]);
int h = tmp[0], w = tmp[1];
if (h == 0 && w == 0) break;
foreach (i; 0 .. h) {
foreach (j; 0 .. w) {
write(i == 0 || i == h - 1 || j... | D |
import std.stdio, std.conv, std.string, std.array, std.math, std.regex, std.range, std.ascii;
import std.typecons, std.functional, std.traits;
import std.algorithm, std.container;
import core.stdc.stdlib;
//C
// void main()
// {
// auto N = scanElem;
// auto K = scanElem;
// auto k = K;
// long count=1;
// real r... | D |
import std.stdio, std.conv, std.functional, std.string;
import std.algorithm, std.array, std.container, std.range, std.typecons;
import std.numeric, std.math, std.random;
import core.bitop;
string FMT_F = "%.10f";
static string[] s_rd;
T RD(T = long)() { while(!s_rd.length) s_rd = readln.chomp.split; string res = s_r... | D |
import std.conv;
import std.stdio;
import std.string;
void main() {
int n = readln.chomp.to!int;
writeln(n % 2 == 0 ? n : 2 * n);
}
| D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
auto x = readln.chomp.to!int;
writeln(x ^^ 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.typecons;
int readint() {
return readln.chomp.to!int;
}
int[] readints() {
return readln.split.map!(to!int).array;
}
int calc(int[] xs) {
int rec(int p, int[] buf) ... | D |
import std.algorithm, std.container, std.conv, std.math, std.range, std.typecons, 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 main()
{
int n, m; readV(n, m);
auto t = 1900*m + 100*(n-m);
writeln(t*2^^m);
}
| D |
import std.stdio, std.conv, std.string, std.range, std.algorithm, std.array,
std.functional, std.container, std.typecons;
void main() {
string S = readln.chomp;
switch(S) {
case "SUN": 7.writeln; break;
case "MON": 6.writeln; break;
case "TUE": 5.writeln; break;
case "WED": 4.writeln; break;
... | D |
void main(){
string s = readln().chomp();
foreach(ch; s){
if( s.count(ch) != 2){
writeln("No");
return;
}
}
writeln("Yes");
}
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 =... | D |
import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;
int[][] MAX, MEMO;
void main()
{
auto s = readln.chomp.to!(wchar[]);
auto t = readln.chomp.to!(wchar[]);
MEMO.length = s.length;
MAX.length = s.length;
foreach (i; 0..s.length) {
MEMO[i]... | D |
import std.stdio;
import std.string;
import std.format;
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.concurrency;
import std.traits;
import std.uni;
import s... | D |
import std.algorithm, std.container, std.conv, std.math, std.range, std.typecons, 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 main()
{
string s; readV(s);
auto n = s.length;
auto t = new dchar[]((n+1)/2);
foreach (i; 0..(... | D |
// Vicfred
// https://atcoder.jp/contests/abc163/tasks/abc163_c
// map
import std.algorithm;
import std.array;
import std.conv;
import std.stdio;
import std.string;
void main() {
int n = readln.chomp.to!int;
int[] a = readln.split.map!(to!int).array;
int[] boss = new int[n+1];
foreach(person; a)
... | D |
import std.stdio;
import std.string;
import std.conv;
void main()
{
string[] input = split(readln());
int A = to!int(input[0]);
int B = to!int(input[1]);
if(A + B >= 10){
writeln("error");
}
else {
writeln(A + B);
}
} | D |
import std.stdio, std.conv, std.string, std.array, std.math, std.regex, std.range, std.ascii, std.numeric, std.random;
import std.typecons, std.functional, std.traits,std.concurrency;
import std.algorithm, std.container;
import core.bitop, core.time, core.memory;
import std.bitmanip;
import std.regex;
enum INF = long.... | D |
import std.algorithm;
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 calc(string[] g) {... | D |
import std.stdio, std.string, std.range, std.algorithm, std.math, std.typecons, std.conv;
void main() {
auto a = readln.split;
((a[0][$-1] == a[1][0] && a[1][$-1] == a[2][0]) ? "YES" : "NO").writeln;
}
| D |
//prewritten code: https://github.com/antma/algo
import std.algorithm;
import std.array;
import std.conv;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.traits;
final class InputReader {
private:
ubyte[] p, buffer;
bool eof;
bool rawRead () {
if (eof) {
return fals... | D |
void main() {
problem();
}
void problem() {
auto A = scan!int;
auto B = scan!int;
auto C = scan!int;
auto D = scan!int;
bool solve() {
while(true) {
C -= B;
if (C <= 0) return true;
A -= D;
if (A <= 0) return false;
}
}
writeln(solve() ? "Yes" : "No");
}
// ---------... | 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!int;
writeln(N/2);
}
} | D |
import core.bitop, std.algorithm, std.ascii, std.bigint, std.conv, std.math,
std.functional, std.numeric, std.range, std.stdio, std.string, std.random,
std.typecons, std.container, std.format;
// dfmt off
T lread(T = long)(){return readln.chomp.to!T();}
T[] lreads(T = long)(long n){return generate(()=>readln.c... | D |
import std.stdio, 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;
string d1 = "..##";
string d2 = ".#.#";
string r1 = "";
string r2 = "";
... | 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;
import core.bitop : popcnt;
alias Generator ... | D |
import std.stdio,std.conv,std.string,std.algorithm,std.array;
void main(){
auto s=readln().chomp().split().map!(to!int);
int a=s[0],b=s[1];
if(a<=8&&b<=8)
writeln("Yay!");
else
writeln(":(");
} | D |
// import chie template :) {{{
import std.stdio, std.algorithm, std.array, std.string, std.math, std.conv,
std.range, std.container, std.bigint, std.ascii, std.typecons;
// }}}
// nep.scanner {{{
class Scanner
{
import std.stdio : File, stdin;
import std.conv : to;
import std.array : split;
import ... | D |
import std.stdio;
import std.algorithm;
import std.string;
import std.conv;
import std.math;
void main(){
while(true){
int n = to!int(chomp(readln()));
if(n == 0) break;
int ans = 0;
int nf=8;
while(nf>0){
ans += n / pow(5,nf) ;
nf--;
}
writeln(ans);
}
} | D |
import std.stdio;
import std.algorithm;
import std.container;
import core.stdc.stdio;
import std.typecons;
int n,k;
int[][] sg;
int[][] graph;
int[2][] queue;
bool[] visited;
int gSize=0;
void buildGraph(int idx,int r){
visited[] = false;
int qc=0;
visited[idx]=true;
foreach(c;sg[idx]){
queue[qc++] = [1,c];
... | D |
import std.stdio;
import std.conv;
import std.string;
import std.typecons;
import std.algorithm;
import std.array;
import std.range;
import std.math;
import std.regex : regex;
import std.container;
import std.bigint;
void main()
{
auto s = readln.chomp;
auto cnt = s.count!(a=>a=='o');
auto d = 15 - s.length;
... | 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;
// dfmt off
T lread(T = long)(){return readln.chomp.to!T();}
T[] lreads(T = long)(long n){return generate(()=>readln.chomp.to!T()).take(n).array();}
T[] aryread(T = long)(){return readln.split.to!(T[])();}
void scan(TList...)(ref TList Args){auto line = readln.split();
foreach (i, T; TList){T val = line[i]... | D |
import std.stdio, std.conv, std.string, std.array, std.math, std.regex, std.range, std.ascii;
import std.typecons, std.functional, std.traits;
import std.algorithm, std.container;
import core.stdc.stdlib, core.bitop;
enum MOD=pow(10,9)+7;
void main()
{
auto S = scanString;
long[2][] dp;
dp.length = S.leng... | D |
import std.stdio;
import std.string;
import std.conv;
void main()
{
auto line = chomp(readln()).split(" ");
int H = to!int(line[0]),
W = to!int(line[1]);
while(H || W)
{
writeln(repeat("#", W));
foreach(int i; 2 .. H)
{
writeln("#" ~ repeat(".", W - 2) ~ "#")... | D |
import std.stdio, std.conv, std.string, std.array, std.math, std.regex, std.range, std.ascii, std.numeric, std.random;
import std.typecons, std.functional, std.traits,std.concurrency;
import std.algorithm, std.container;
import core.bitop, core.time, core.memory;
import std.bitmanip;
import std.regex;
enum INF = long.... | D |
import std.stdio, std.conv, std.array, std.string, std.algorithm, std.container, std.range, core.stdc.stdlib, std.math, std.typecons;
T[][] combinations(T)(T[] s, in int m) { if (!m) return [[]]; if (s.empty) return []; return s[1 .. $].combinations(m - 1).map!(x => s[0] ~ x).array ~ s[1 .. $].combinations(m); }
... | D |
import std.stdio;
import std.string;
import std.conv;
import std.range;
import std.algorithm;
void main() {
int count = 0;
string input;
while ((input = readln.chomp).length != 0) {
if (hantei(input)) count++;
}
writeln(count);
}
bool hantei(string input) {
for (int i = 0; i < (input... | D |
import std.stdio;
import std.conv;
import std.string;
import std.typecons;
import std.algorithm;
import std.array;
import std.range;
import std.math;
import std.regex : regex;
import std.container;
import std.bigint;
import std.ascii;
void main()
{
auto r = readln.chomp.to!int;
if (r < 1200) {
writeln("ABC");... | D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
auto s = readln.chomp.dup;
s.reverse();
writeln(s);
} | 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() {
long n, m;
scan(n, m);
auto s = readln.chomp;
auto t = readln.chomp;
auto l = lcm(n, m);
auto sg = l / m;
auto tg = l /... | D |
import std.stdio, std.string, std.conv;
void main()
{
auto x = readln.chomp.to!int;
int sum, i;
while (x > sum) sum += ++i;
writeln(i);
} | D |
import std.stdio;
import std.string;
import std.conv;
void main()
{
auto M = readln.chomp.to!int;
auto x = 48-M;
writeln(x);
} | 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() {
auto s = readln.chomp;
write(s);
if (s[$ - 1] == 's') {
writeln("es");
} else {
writeln("s");
}
}
| D |
import std.stdio, std.string, std.conv, std.algorithm;
void main()
{
int[string] memo;
foreach(str; ["A", "B", "AB", "O"])
{
memo[str] = 0;
}
while(true)
{
auto line = readln;
if(!line)break;
auto f = line.chomp.split(",");
++memo[f[1]];
}
foreach... | D |
import std.stdio, std.string, std.conv, std.regex;
void main()
{
auto n = readln.chomp;
if(n[0] == '9' || n[1] == '9'){
writeln("Yes");
} else {
writeln("No");
}
} | D |
// Vicfred
// https://atcoder.jp/contests/abc159/tasks/abc159_b
// string manipulation
import std.stdio;
import std.string;
bool palindrome(string s) {
long n = s.length;
for(long i = 0; i < n/2; i++)
if(s[i] != s[$-i-1])
return false;
return true;
}
void main() {
string s = readl... | D |
void main(){
import std.stdio, std.string, std.conv, std.algorithm, std.math;
long q, h, s, d; rd(q, h, s, d);
long n; rd(n);
s=min(s, 2*h, 4*q);
long c=n*s;
if(n%2==0){
c=min(c, n/2*d);
}else{
c=min(c, s+(n-1)/2*d);
}
writeln(c);
}
void rd(T...)(ref T x){
import std.stdio, std.string, s... | D |
long solve(long a, long b, long h){
return (a+b)*h/2;
}
void main(){
int a = inelm();
int b = inelm();
int h = inelm();
solve(a, b, h).writeln();
}
import std.stdio, std.conv, std.algorithm, std.numeric, std.string, std.math, std.range;
const long mod = 10^^9+7;
// 1要素のみの入力
T inelm(T= int)(){
return t... | D |
import std.stdio;
import std.string;
import std.conv;
int main()
{
int line = readln.chomp.to!int;
int n = readln.chomp.to!int;
int[31] values;
foreach(int i;0..line)
{
values[i] = i+1;
}
foreach(int i;0..n)
{
auto input = readln.chomp.split(",");
int a = to!int(input[0]);
int b = to!int(input[1]);
... | D |
import std.stdio, std.string, std.conv, std.range;
import std.algorithm, std.array, std.typecons, std.container;
import std.math, std.numeric, std.random, core.bitop;
enum inf = 1_001_001_001;
enum infl = 1_001_001_001_001_001_001L;
enum mod = 1_000_000_007L;
void main() {
int N, W;
scan(N, W);
auto w = ... | 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() {
while (1) {
auto s = readln.chomp;
if (s == ".") return;
writeln(isBalance(s) ? "yes" : "no");
}
}
bool isBalance(string ... | D |
import std.stdio;
import std.string;
import std.conv;
import std.typecons;
import std.algorithm;
import std.functional;
import std.bigint;
import std.numeric;
import std.array;
import std.math;
import std.range;
import std.container;
void main() {
int maxN = 10^^6;
int[] f, f_odd;
for(int n=1; ;n++) {
... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array;
void main() {
int a,b;
scan(a,b);
a %= 3, b %= 3;
writeln(a == b && a != 0 ? "Impossible" : "Possible");
}
void scan(T...)(ref T args) {
import std.stdio : readln;
import std.algorithm : splitter;
import... | D |
void main() {
int n = readln.chomp.to!int;
int a = readln.chomp.to!int;
writeln(n % 500 <= a ? "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;
imp... | 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 N = readln.chomp.to!int;
auto A = readln.chomp;
if (A.front == 'W' || A.back == 'W') {
... | D |
void main(){
import std.stdio, std.string, std.conv, std.algorithm;
auto s=readln.chomp.to!(char[]);
s[3]='8';
writeln(s);
}
void rd(T...)(ref T x){
import std.stdio, std.string, std.conv, std.exception;
auto l=readln.split;
enforce(l.length==x.length);
foreach(i, ref e; x){
e=l[i].to!(typeof(e))... | D |
import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array, std.typecons, std.container;
import std.math, std.numeric, core.bitop;
void main() {
int n, a, b, c;
scan(n, a, b, c);
int ans = n - (a + b - c);
writeln(ans);
}
void scan(T...)(ref T args) {
import std.stdio : r... | 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() {
auto xs = readints;
writeln(xs... | D |
import std.stdio;
import std.regex;
void main(){
auto io = new IO();
auto N = io.line()[0];
auto A = io.line(N);
size_t paired = 0;
size_t surplus = 0;
foreach( i,a ; A ){
if( surplus == 1 ){
paired += (a+1)/2;
surplus = ( (a+1)/2 ) ? (a+1)%2 : 0 ;
}else{
paired += a/2;
surplus = a%2;
}
... | D |
// dfmt off
T lread(T=long)(){return readln.chomp.to!T;}T[] lreads(T=long)(long n){return iota(n).map!((_)=>lread!T).array;}
T[] aryread(T=long)(){return readln.split.to!(T[]);}void arywrite(T)(T a){a.map!text.join(' ').writeln;}
void scan(L...)(ref L A){auto l=readln.split;foreach(i,T;L){A[i]=l[i].to!T;}}alias sread=(... | D |
import std.stdio;
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 s = readln.chomp.replace("C", "A").replace("G", "A").replace("T", "A");
int re... | D |
import std.stdio, std.conv, std.functional, std.string;
import std.algorithm, std.array, std.container, std.range, std.typecons;
import std.bigint, std.numeric, std.math, std.random;
import core.bitop;
string FMT_F = "%.10f";
static File _f;
void file_io(string fn) { _f = File(fn, "r"); }
static string[] s_rd;
T _RD(... | D |
import std.stdio;
import std.algorithm;
import std.conv;
import std.datetime;
import std.numeric;
import std.math;
import std.string;
string my_readln() { return chomp(readln()); }
void main()
{
auto tokens = split(my_readln());
auto S = to!string(tokens[0]);
if (S.length == 2)
writeln(S);
else
{
foreach_re... | D |
import std.stdio, std.conv, std.functional, std.string;
import std.algorithm, std.array, std.container, std.range, std.typecons;
import std.bigint, std.numeric, std.math, std.random;
import core.bitop;
string FMT_F = "%.10f";
static File _f;
void file_io(string fn) { _f = File(fn, "r"); }
static string[] s_rd;
T _RD(... | D |
import std.stdio, std.array, std.string, std.conv, std.algorithm;
import std.typecons, std.range, std.random, std.math, std.container;
import std.numeric, std.bigint, core.bitop, core.stdc.string;
void main() {
auto S = readln.chomp;
auto T = readln.chomp;
auto N = S.length.to!int;
auto M = T.length.t... | D |
import std.algorithm, std.conv, std.range, std.stdio, std.string;
void main()
{
auto s = readln.chomp;
writeln(s.replace(",", " "));
}
| D |
import std.stdio;
import std.string;
import std.conv;
import std.range;
import std.algorithm;
import std.math;
import std.regex;
void main() {
auto ip = readln.split.to!(int[]), a = ip[0], b = ip[1];
((a*b)&1 ? "Odd" : "Even").writeln;
}
| D |
import std.array : split;
import std.conv : to;
import std.stdio;
import std.string : strip;
private {
string[] temp;
}
void main() {
read();
int n = get!int(0);
int count = 0;
foreach (i; 1 .. n + 1) {
count += (n - (i - 1)) * i - i + 1;
}
stdout.write(count);
}
void read() {
temp = split(strip(stdin... | 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 N = readln.chomp.to!int;
auto A = readln.split.map!(to!long).array;
immutable long MOD = 10... | 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(){
long x = readln.chomp.to!long;
long i;
for(i = 0; i * (i + 1) / 2 < x; i ++){
}
i.writeln;
} | D |
// dfmt off
T lread(T=long)(){return readln.chomp.to!T;}T[] lreads(T=long)(long n){return iota(n).map!((_)=>lread!T).array;}
T[] aryread(T=long)(){return readln.split.to!(T[]);}void arywrite(T)(T a){a.map!text.join(' ').writeln;}
void scan(L...)(ref L A){auto l=readln.split;foreach(i,T;L){A[i]=l[i].to!T;}}alias sread=(... | D |
#!/usr/bin/rdmd
import std.stdio;
import std.conv: to;
import std.array: split;
import std.ascii: newline;
immutable greater = "a > b";
immutable less = "a < b";
immutable equa = "a == b";
void main()
{
int[2] a;
foreach (string line; lines(stdin))
{
if(line == newline) break;
else
{
... | 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 rs = new int[](10^^4+1);
foreach (x; 1..101) foreach (y; 1..101) foreach (z; 1..101) {
auto n = x^^2 + y^^2 + z^^2 + x*y + y*z + z*x;
if (n > 10^^4... | D |
import std.stdio, std.conv, std.functional, std.string;
import std.algorithm, std.array, std.container, std.range, std.typecons;
import std.numeric, std.math, std.random;
import core.bitop;
string FMT_F = "%.10f";
static string[] s_rd;
T RD(T = long)() { while(!s_rd.length) s_rd = readln.chomp.split; string res = s_r... | D |
import std.stdio, std.conv, std.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 |
//dlang template---{{{
import std.stdio;
import std.conv;
import std.string;
import std.array;
import std.algorithm;
import std.typecons;
import std.math;
import std.range;
// MIT-License https://github.com/kurokoji/nephele
class Scanner
{
import std.stdio : File, stdin;
import std.conv : to;
import std.array : ... | D |
import std.algorithm;
import std.conv;
import std.range;
import std.stdio;
import std.string;
void main ()
{
auto tests = readln.strip.to !(int);
foreach (test; 0..tests)
{
auto n = readln.strip.to !(int);
auto a = readln.splitter.map !(to !(int)).array;
bool [int] b;
foreach (i; 0..n)
{
foreach (j; i ... | 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;
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 s = readln.chomp;
auto res = int.max;
foreach (i; 0..s.length-2) {
res =... | 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() {
while (true) {
int x, y, s;
scan(x, y, s);
if (!x && !y && !s) return;
solve(x, y, s);
}
}
void solve(int x, int y... | D |
import std.stdio, std.string, std.array, std.conv;
void main() {
while (true) {
string[] tmp = readln.chomp.split;
int a = tmp[0].to!int, b = tmp[2].to!int;
string op = tmp[1];
if (op == "+") {
writeln(a + b);
} else if (op == "-") {
writeln(a - b);
... | D |
import std.stdio, std.ascii, std.string;
void main() {
readln.chomp.toUpper.writeln;
} | D |
import std.stdio;
import std.algorithm;
void main(){
string str = "Hello World";
for(int i=0;i<1000;i++){
writeln(str);
}
} | 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;
bool[string] s;
foreach (_; 0..N) {
auto t = readln.chomp;
s[t] = t... | D |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.