Перенос страниц

book/04-массивы-ассоциативные-массивы-и-строки/src/chapter-4-1-1/app.d

@@ -0,0 +1,13 @@
+import std.stdio;
+
+void main()
+{
+    auto array1 = new short[55];
+    assert(array1.length == 55);
+    writeln(array1);
+
+    auto array2 = new int[10];
+    array2[9] = 42;
+    assert(array2[$ - 1] == 42);
+    writeln(array2);
+}

book/04-массивы-ассоциативные-массивы-и-строки/src/chapter-4-1-10/app.d

@@ -0,0 +1,8 @@
+void main()
+{
+    auto array = new int[10];
+    array.length += 1000;           // Расширяется
+    assert(array.length == 1010);
+    array.length /= 10;             // Су­жа­ет­ся
+    assert(array.length == 101);
+}

book/04-массивы-ассоциативные-массивы-и-строки/src/chapter-4-1-3/app.d

@@ -0,0 +1,8 @@
+import std.stdio;
+
+void main()
+{
+    auto array = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+    // На­пе­ча­тать толь­ко вто­рую по­ло­ви­ну
+    writeln(array[$ / 2 .. $]);
+}

book/04-массивы-ассоциативные-массивы-и-строки/src/chapter-4-1-4/app.d

@@ -0,0 +1,8 @@
+void main()
+{
+    int[] array = [0, 1, 2];
+    int[] subarray = array[1 .. $];
+    assert(subarray.length == 2);
+    subarray[1] = 33;
+    assert(array[2] == 33);
+}

book/04-массивы-ассоциативные-массивы-и-строки/src/chapter-4-1-5/app.d

@@ -0,0 +1,10 @@
+void main()
+{
+    auto a = ["hello", "world"];
+    auto b = a;
+    assert(a is b); // Тест прой­ден, у a и b од­ни те же гра­ни­цы
+    assert(a == b); // Ес­те­ст­вен­но, тест прой­ден
+    b = a.dup;
+    assert(a == b); // Тест прой­ден, a и b рав­ны, хо­тя за­ни­ма­ют раз­ные об­лас­ти па­мя­ти
+    assert(a !is b); // Тест прой­ден, a и b раз­лич­ны, хо­тя име­ют оди­на­ко­вое со­дер­жи­мое
+}

book/04-массивы-ассоциативные-массивы-и-строки/src/chapter-4-1-6/app.d

@@ -0,0 +1,8 @@
+void main()
+{
+    int[] a = [0, 10, 20];
+    int[] b = a ~ 42;
+    assert(b == [0, 10, 20, 42]);
+    a = b ~ a ~ 15;
+    assert(a.length == 8);
+}

book/04-массивы-ассоциативные-массивы-и-строки/src/chapter-4-1-7/app.d

@@ -0,0 +1,22 @@
+import std.stdio;
+
+void main()
+{
+    auto a = [ 0.5, -0.5, 1.5, 2 ];
+    auto b = [ 3.5, 5.5, 4.5, -1 ];
+    auto c = new double[4]; // Па­мять под мас­сив долж­на быть уже вы­де­ле­на
+    c[] = (a[] + b[]) / 2;  // Рас­счи­тать сред­нее ариф­ме­ти­че­ское a и b
+    assert(c == [ 2.0, 2.5, 3.0, 0.5 ]);
+
+    auto d = [1.0, 2.5, 3.6];
+    auto e = [4.5, 5.5, 1.4];
+    auto f = new double[3];
+    f[] += 4 * d[] + e[];
+
+    int[] g = new int[5];
+    int[] h = new int[5];
+    g[] = -1;  // За­пол­нить все ячей­ки b зна­че­ни­ем -1
+    h[] = g[]; // Ско­пи­ро­вать все дан­ные из b в a
+    writeln(g);
+    writeln(h);
+}

book/04-массивы-ассоциативные-массивы-и-строки/src/chapter-4-1-8/app.d

@@ -0,0 +1,15 @@
+import std.stdio;
+
+void main()
+{
+    auto array = [0, 2, 4, 6, 8, 10];
+    array = array[0 .. $ - 2];
+    // Су­же­ние спра­ва на два эле­мен­та
+    assert(array == [0, 2, 4, 6]);
+    array = array[1 .. $];
+    // Су­же­ние сле­ва на один эле­мент
+    assert(array == [2, 4, 6]);
+    array = array[1 .. $ - 1];
+    // Су­же­ние с обе­их сто­рон
+    assert(array == [4]);
+}

book/04-массивы-ассоциативные-массивы-и-строки/src/chapter-4-1-8/palindrome.d

@@ -0,0 +1,18 @@
+import std.conv, std.stdio;
+
+int main(string[] args)
+{
+    // Избавиться от имени программы
+    args = args[1 .. $];
+    while (args.length >= 2)
+    {
+        if (to!int(args[0]) != to!int(args[$ - 1]))
+        {
+            writeln("не палиндром");
+            return 1;
+        }
+        args = args[1 .. $ - 1];
+    }
+    writeln("палиндром");
+    return 0;
+}

book/04-массивы-ассоциативные-массивы-и-строки/src/chapter-4-1-9/app.d

@@ -0,0 +1,9 @@
+void main()
+{
+    int[] a = [0, 10, 20, 30, 40, 50, 60, 70];
+    auto b = a[4 .. $];
+    a = a[0 .. 4];
+    // Сей­час a и b при­мы­ка­ют друг к дру­гу
+    a ~= [0, 0, 0, 0];
+    assert(b == [40, 50, 60, 70]); // Тест прой­ден; мас­сив a был пе­ре­не­сен в но­вую об­ласть па­мя­ти
+}

book/04-массивы-ассоциативные-массивы-и-строки/src/chapter-4-1/app.d

@@ -0,0 +1,26 @@
+import std.random;
+import std.stdio;
+
+void main()
+{
+    // От 1 до 127 эле­мен­тов
+    auto array = new double[uniform(1, 128)];
+
+    foreach (i; 0 .. array.length)
+    {
+        array[i] = uniform(0.0, 1.0);
+    }
+
+    writeln(array);
+
+    foreach (ref element; array)
+    {
+        element = uniform(0.0, 1.0);
+    }
+
+    writeln(array);
+
+    auto copy = array.dup;
+    assert(array !is copy);
+    assert(array == copy);
+}

book/04-массивы-ассоциативные-массивы-и-строки/src/chapter-4-2-3/app.d

@@ -0,0 +1,15 @@
+import std.stdio;
+
+void main()
+{
+    int[5] array = [40, 30, 20, 10, 0];
+    auto slice1 = array[2 .. $];    // slice1 име­ет тип int[]
+    assert(slice1 == [20, 10, 0]);
+    auto slice2 = array[];          // Та­кой же, как array[0 .. $]
+    assert(slice2 == array);
+
+    int[10] a;
+    int[] b = a[1 .. 7];  // Все в по­ряд­ке
+    auto c = a[1 .. 7];   // Все в по­ряд­ке, c так­же име­ет тип int[]
+    int[6] d = a[1 .. 7]; // Все в по­ряд­ке, срез a[1 .. 7] ско­пи­ро­ван в d
+}

book/04-массивы-ассоциативные-массивы-и-строки/src/chapter-4-2-4/app.d

@@ -0,0 +1,34 @@
+import std.stdio;
+
+int[3] fun(int[3] x, int[3] y)
+{
+    // x и y – ко­пии пе­ре­дан­ных ар­гу­мен­тов
+    x[0] = y[0] = 100;
+    return x;
+}
+
+double[3] fun2(double[] x)
+{
+    double[3] result;
+    result[] = 2 * x[];         // Опе­ра­ция над мас­си­вом в це­лом
+    return result;
+}
+
+void main()
+{
+    int[3] a = [1, 2, 3];
+    int[3] b = a;
+    a[1] = 42;
+    assert(b[1] == 2);          // b – не­за­ви­си­мая ко­пия a
+
+    auto c = fun(a, b);         // c име­ет тип int[3]
+
+    assert(c == [100, 42, 3]);
+    writeln(c);
+    assert(b == [1, 2, 3]);     // Вы­зов fun ни­как на от­ра­зил­ся на b
+    writeln(b);
+
+    double[3] point = [0, 0, 0];
+    double[] test = point;          // Все в по­ряд­ке
+    auto r = fun2(point);            // Все в по­ряд­ке, те­перь r име­ет тип double[3]
+}

book/04-массивы-ассоциативные-массивы-и-строки/src/chapter-4-2-5/app.d

@@ -0,0 +1,15 @@
+import std.stdio;
+
+void main()
+{
+    int[4] fixed = [1, 2, 3, 4];
+    auto anotherFixed = fixed;
+    assert(anotherFixed !is fixed); // Не то же са­мое (ко­пи­ро­ва­ние по зна­че­нию)
+    assert(anotherFixed == fixed);  // Те же дан­ные
+    auto dynamic = fixed[];         // По­лу­ча­ет гра­ни­цы мас­си­ва fixed
+    assert(dynamic is fixed);
+    assert(dynamic == fixed);       // Ес­те­ст­вен­но
+    dynamic = dynamic.dup;          // Соз­да­ет ко­пию
+    assert(dynamic !is fixed);
+    assert(dynamic == fixed);
+}

book/04-массивы-ассоциативные-массивы-и-строки/src/chapter-4-2-6/app.d

@@ -0,0 +1,10 @@
+import std.stdio;
+
+void main()
+{
+    double[2] a;
+    double[] b = a ~ 0.5;   // При­сое­ди­нить к double[2] зна­че­ние, по­лу­чить double[]
+    auto c = a ~ 0.5;       // То же са­мое
+    double[3] d = a ~ 1.5;  // Все в по­ряд­ке, яв­ный за­прос мас­си­ва фик­си­ро­ван­ной дли­ны
+    double[5] e = a ~ d;    // Все в по­ряд­ке, яв­ный за­прос мас­си­ва фик­си­ро­ван­ной дли­ны
+}

book/04-массивы-ассоциативные-массивы-и-строки/src/chapter-4-2/app.d

@@ -0,0 +1,29 @@
+import std.stdio, std.random;
+
+void main()
+{
+    int[128] someInts;
+
+    int[3] a;
+    assert(a == [0, 0, 0]);
+
+    int[3] b = [1, 2, 3];
+    assert(b == [1, 2, 3]);
+
+    int[4] c = -1;
+    assert(c == [-1, -1, -1, -1]);
+
+    int[1024] d = void;
+
+    double[10] array;
+    foreach (i; 0 .. array.length)
+    {
+        array[i] = uniform(0.0, 1.0);
+    }
+    writeln(array);
+    foreach (ref element; array)
+    {
+        element = uniform(0.0, 1.0);
+    }
+    writeln(array);
+}

book/04-массивы-ассоциативные-массивы-и-строки/src/chapter-4-4-1/app.d

@@ -0,0 +1,10 @@
+import std.stdio;
+
+void main()
+{
+    string[int] aa;
+    assert(aa == null);
+    assert(aa.length == 0);
+    aa = [0:"zero", 1:"not zero"];
+    assert(aa.length == 2);
+}

book/04-массивы-ассоциативные-массивы-и-строки/src/chapter-4-4-2/app.d

@@ -0,0 +1,21 @@
+import std.stdio;
+
+void main()
+{
+    // Создать ассоциативный массив с соответствием строка/строка
+    auto aa = [ "здравствуй":"salve", "мир":"mundi" ];
+    // Перезаписать значения
+    aa["здравствуй"] = "ciao";
+    aa["мир"] = "mondo";
+    // Создать несколько новых пар ключ–значение
+    aa["капуста"] = "cavolo";
+    aa["моцарелла"] = "mozzarella";
+
+    writeln(aa);
+
+    assert(aa["здравствуй"] == "ciao");
+    // Ключ "здравствуй" существует, поэтому второй аргумент игнорируется
+    assert(aa.get("здравствуй", "salute") == "ciao");
+    // Ключ "здорово" не существует, возвратить второй аргумент
+    assert(aa.get("здорово", "buongiorno") == "buongiorno");
+}

book/04-массивы-ассоциативные-массивы-и-строки/src/chapter-4-4-3/app.d

@@ -0,0 +1,11 @@
+import std.stdio;
+
+void main()
+{
+    auto a1 = [ "Jane":10.0, "Jack":20, "Bob":15 ];
+    auto a2 = a1;               // a1 и a2 ссылаются на одни данные
+    a1["Bob"] = 100;            // Изменяя a1,...
+    assert(a2["Bob"] == 100);   // ...мы изменяем a2...
+    a2["Sam"] = 3.5;            // ...и
+    assert(a1["Sam"] == 3.5);   // наоборот
+}

book/04-массивы-ассоциативные-массивы-и-строки/src/chapter-4-4-4/app.d

@@ -0,0 +1,11 @@
+import std.stdio;
+
+void main()
+{
+    auto a1 = [ "Jane":10.0, "Jack":20, "Bob":15 ];
+    auto a2 = [ "Jane":10.0, "Jack":20, "Bob":15 ];
+    assert(a1 !is a2);
+    assert(a1 == a2);
+    a2["Bob"] = 18;
+    assert(a1 != a2);
+}

book/04-массивы-ассоциативные-массивы-и-строки/src/chapter-4-4-6/app.d

@@ -0,0 +1,26 @@
+import std.stdio;
+
+void main()
+{
+    auto coffeePrices = [
+        "французская ваниль" : 262,
+        "ява" : 239,
+        "французская обжарка" : 224
+    ];
+
+    foreach (kind, price; coffeePrices)
+    {
+        writefln("%s стоит %s руб. за 100 г", kind, price);
+    }
+
+    auto gammaFunc = [-1.5:2.363, -0.5:-3.545, 0.5:1.772];
+    double[] keys = gammaFunc.keys;
+    assert(keys == [ -1.5, -0.5, 0.5 ]);
+
+    writeln(keys);
+
+    foreach (k; gammaFunc.byKey())
+    {
+        writeln(k);
+    }
+}

book/04-массивы-ассоциативные-массивы-и-строки/src/chapter-4-4/app.d

@@ -0,0 +1,9 @@
+import std.stdio;
+
+void main()
+{
+    int[string] aa = ["здравсвтуй":42, "мир":75];
+    writeln(aa);
+    auto bb = ["здравсвтуй":42, "мир":75];
+    writeln(bb);
+}

book/04-массивы-ассоциативные-массивы-и-строки/src/chapter-4-5-4-1/app.d

@@ -0,0 +1,20 @@
+import std.stdio;
+
+void main()
+{
+    string str = "Hall\u00E5, V\u00E4rld!";
+
+    foreach (c; str)
+    {
+        write('[', c, ']');
+    }
+
+    writeln();
+
+    foreach (dchar c; str)
+    {
+        write('[', c, ']');
+    }
+
+    writeln();
+}

book/04-массивы-ассоциативные-массивы-и-строки/src/chapter-4-5-4/app.d

@@ -0,0 +1,23 @@
+import std.stdio;
+import std.utf;
+
+void main()
+{
+    {
+        string a = "hello";
+        string b = a;           // Переменная b теперь тоже указывает на значение "hello"
+        string c = b[0 .. 4];   // Переменная c указывает на строку "hell"
+                                // Если бы такое присваивание было разрешено, это изменило бы a, b, и c:
+                                // a[0] = 'H';
+                                // Конкатенация оставляет переменные b и c нетронутыми:
+        a = 'H' ~ a[stride(a, 0) .. $];
+        assert(a == "Hello" && b == "hello" && c == "hell");
+    }
+
+    {
+        string a = "Независимо от представления \u03bb стоит \u20AC20.";
+        wstring b = "Независимо от представления \u03bb стоит \u20AC20.";
+        dstring c = "Независимо от представления \u03bb стоит \u20AC20.";
+        writeln(a, '\n', b, '\n', c);
+    }
+}

book/04-массивы-ассоциативные-массивы-и-строки/src/chapter-4-6/app.d

@@ -0,0 +1,15 @@
+import std.stdio;
+
+void main()
+{
+    auto arr = [ 5, 10, 20, 30 ];
+    auto p = arr.ptr;
+    assert(*p == 5);
+    ++p;
+    assert(*p == 10);
+    ++*p;
+    assert(*p == 11);
+    p += 2;
+    assert(*p == 30);
+    assert(p - arr.ptr == 3);
+}