1
2
3
4
5
6
7
8
9
module test;
 
import std.algorithm;
import std.stdio;
import std.range;
import std.conv;
 
string assign(size_t len)
{
 ...

1
2
3
4
5
6
7
8
9
module test;
 
import std.algorithm;
import std.stdio;
import std.range;
import std.conv;
 
string assign(size_t len)
{
 ...

1
2
3
4
5
6
7
8
9
module test;
 
import std.algorithm;
import std.stdio;
import std.range;
import std.conv;
 
string assign(size_t len)
{
 ...

1
2
3
4
5
6
7
8
9
module test;
 
import std.algorithm;
import std.stdio;
import std.range;
import std.conv;
 
string assign(size_t len)
{
 ...

1
2
3
4
5
6
7
8
9
module test;
 
import std.algorithm;
import std.stdio;
import std.range;
import std.conv;
 
string assign(size_t len)
{
 ...

1
2
3
4
5
6
7
8
9
module test;
 
import std.algorithm;
import std.stdio;
import std.range;
import std.conv;
 
string assign(size_t len)
{
 ...

1
2
3
4
5
6
7
8
9
import std.algorithm;
import std.stdio;
import std.range;
 
auto makeArray(T...)(T vals) 
{
    int[T.length] arr = void;
    
    size_t i;
 ...

1
2
3
4
5
6
7
8
9
struct Foo 
{ 
    auto opIndex(T...)(T vals) 
    { 
        bool[int] AA;
        foreach (val; vals)
            AA[val] = true;
        
        return AA;
 ...

1
2
3
4
5
6
7
8
import std.algorithm;
 
struct A
{
    int[] t;
    static auto opAssign(T)(T t) { return A(t); }
    bool opIn_r(int val) { return t.canFind(val); }
}
 ...

1
2
3
4
5
6
7
8
9
int lim = 0x12345678; int pp = 256;
for (int i = 1; (lim-pp) / ((64 + i) + pp) != 0; i++) {
    if (atan(i - ((i / lim) * lim)) > 1.55) // > ~50
        lim = (lim / 50) * 40;
    int foo = lim; // bar
    for (int j = 0; j < 0x123456; j++)
        foo ^= (j >> 3) | (j << 29); // tidy
    pp &= foo; // in 42-0
    if (lim - ((lim / i) * i) == 0) {
 ...

1
2
3
4
5
6
7
8
import std.c.stdio;
 
int main() {
    int x,y,Z;
    scanf("Enter X value:%d", &x) ;scanf("Enter Y value:%d", &y) ;
    printf ("output:%d\n", x);
    return 0;
}

1
2
3
4
5
6
7
8
import std.c.stdio;
 
int main() {
    int x,y,Z;
    scanf("Enter X value:%d", &x) ;scanf("Enter Y value:%d", &y) ;
    printf ("%d\n", x);
    return 0;
}

1
2
3
4
5
6
7
import std.c.stdio;
 
int main() {
    int x;
    while (scanf("%d", &x) && x!=42) printf ("%d\n", x);
    return 0;
}

1
2
3
4
5
6
 
int main() {
    int x;
    while (scanf("%d", &x) && x!=42) printf ("%d\n", x);
    return 0;
}

1
2
3
4
5
6
7
8
9
module test;
 
import std.conv;
import std.traits;
import core.stdc.string;
import core.stdc.wchar_;
import std.c.windows.windows;
 
/// ditto
 ...

1
2
3
4
5
6
7
8
9
int lim = 0x12345678; int pp = 256;
for (int i = 1; (lim-pp) / ((64 + i) + pp) != 0; i++) {
    if (atan(i - ((i / lim) * lim)) > 1.55) // > ~50
        lim = (lim / 50) * 40;
    int foo = lim; // bar
    for (int j = 0; j < 0x123456; j++)
        foo ^= (j >> 3) | (j << 29); // tidy
    pp &= foo; // in 42-0
    if (lim - ((lim / i) * i) == 0) {
 ...

1
2
3
4
5
6
7
8
9
module test;
 
import std.conv;
import std.traits;
import core.stdc.wchar_;
import std.c.windows.windows;
 
/// ditto
T toImpl(T, S)(S s)
 ...

1
2
3
4
5
6
7
8
9
import std.conv;
import std.traits;
import core.stdc.wchar_;
 
/// ditto
T toImpl(T, S)(S s)
    if (isPointer!S && is(S : const(wchar)*) &&
        isSomeString!T)
{
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
import std.concurrency;
import core.time;
import core.thread;
 
void test()
{
    while (1)
    {
 ...

1
2
3
4
5
6
7
8
9
import std.traits;
 
auto toDelegate(T)(T fun) {
    return (ParameterTypeTuple!fun p) { fun(p); };
}
 
void bar(int x) {
    x += 2;
}
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
import std.concurrency;
import core.time;
import core.thread;
 
void test()
{
    writeln("thread 1");
    auto tid = spawn(&test2);
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
import std.concurrency;
import core.thread;
 
void main()
{
    auto workThread = spawn(&foo);
    int delay = 500;
    int val = 1;
 ...

1
2
3
4
5
6
import std.stdio;
 
int main(string[] args) {
    writeln("Hello world!");
    return 0;
}

1
2
3
4
5
6
import std.stdout;
 
int main(string[] args) {
    writeln("Hello world!");
    return 0;
}

1
2
3
4
5
6
7
8
9
---
void foo() {
    // Prints contents of file foo.txt
    $(V1 writefln( import("foo.txt") ); )
    $(V2 writeln( import("foo.txt") ); )
}
---
 
outputs:
 ...

1
2
3
4
5
6
7
8
9
(defn fibonacci-seq []
  ((fn rfib [a b] 
      (cons a (lazy-seq (rfib b (+ a b)))))
    0 1))
 
(defn reduced-fib-seq [a]
  (drop 2 (take (+ 2 a) (fibonacci-seq))))
 
(defn satz-von-zeckendorf [coll]
 ...

1
2
3
4
5
6
7
8
9
class Foobar
{
    void method()
    {
 
    }
};
 
void main()
 ...

1
2
3
4
5
6
7
8
9
module alice.arith.liner;
 
import std.algorithm;
import std.stdio;
import std.array;
import std.conv;
import std.math;
import std.typecons;
import std.range;
 ...

1
2
3
4
5
6
7
import std.stdio;
 
void main()
{       
        auto de = (a){return a;};
        writeln(de(1));
}

1
2
3
4
5
6
7
8
import std.stdio;
 
int foo(int){return 1;}
 
void main()
{       
        writeln(foo(1));
}