On 11/19/21 7:04 AM, Salih Dincer wrote:

> Elbet daha zeki şekilde de programlanabilir!

İki kaptaki sıvıları azar azar karıştırarak sonuçta aynı ortalama sıvıyı elde etmeye çalışıyor.

Programı kendim için irdeleyeceğim. Söylediklerimin hiçbirisi önemli değil; yalnızca aklıma gelenleri yazıyorum.

> /* En hafifi 90 gram, en ağırı 120 gram olan ve
>   * 10 adet elma bulunduran 2 sepetimiz olsun:
>   */
> enum {       enAz = 90,
>               enÇok = 120,
>               adet = 10,
>               değişim = 2
> }

O şekilde tanımlanmaları, hepsi aynı gruba dahil olmadıklarından doğal gelmedi. (Örneğin, Renkler gibi bir ilişkileri yok.) Ben böyle durumlarda tek tek tanımıyorum:

enum enAz = 90;
enum enÇok = 120;
// ...

Adet bildiren kavramları açıkça size_t olarak tanımlıyorum. (Yukarıdakilerin türü int'tir.)

Ama bu konuda bana katılmayan çok programcı var: Onlar, dizilerin .length'inin bilen işaretli bir tür olması gerektiğini savunurlar (örneğin long). Bunun nedeni, iki uzunluğunun farkını aldıklarında negatif sayı görmek isterler ama iki size_t'nin farkı negatif olmaz ve hatalara neden olabilir. İki tarafın da haklı olduğu çözülmez bir konu... :)

> void main() {    // Sepetlerimizi öyle rasgele dolduruyoruz:
>      auto sepet1 = generate!(() => uniform(enAz, enÇok)).
>                                        takeExactly(adet).array;

Leziz! :) uniform sondaki değeri hiç seçmez; en büyük değer 119 olacak. Onu da seçmesi istendiğinde şöyle çağrılabiliyor:

  uniform!"[]"(enAz, enÇok);

Köşeli parantez dahil anlamına gelir. uniform, "[)" varsayar.

takeExactly'nin take'ten farkı, istenen adet eleman bulunmadığında hata atmasıdır. (Az eleman varsa take hiç sesini çıkartmaz.) Burada ikisi de kullanılabilir çünkü generate'in ürettiği sonsuz dizide 'adet' adet eleman bulunacağından eminiz. :)

>      auto sepet2 = generate!(() => uniform(enAz, enÇok)).
>                                        takeExactly(adet).array;

Kod tekrarı! ;)

>      /* Herhangi bir sepetten ikişer elma eksilten ve
>       * bunları döndüren işlevimiz: avuçla() ise şöyle:
>       */
>      auto avuçla(ref int[] sepet) {
>      size_t pos = uniform(0, sepet.length);
>
>      int ilk = sepet[pos];
>      sepet = remove(sepet, pos);

Burada önemli değil ama eğer

1) Dizi çok büyükse
2) ve elemanların sırası önemli değilse,

remove'a eleman sıralarını korumadan çıkartmasını söyleyebiliriz:

- SwapStrategy.stable (varsayılan): Ortadan eleman çıkartınca sonraki bütün elemanları bir kaydırır; ortalamada N/2 kere kopyalar.

- SwapStrategy.unstable (bizim kullanabileceğimiz): En sondaki elemanı çıkan elemanın yerine kopyalar; tek kopya.

- SwapStrategy.semistable (haberim yoktu; sonradan eklenmiş olmalı): Bazı algoritmalarda yalnızca soldaki grubun sırasını korur.

Bu programı kendim yazarken burada daha ileri bir eniyileştirme yapılabileceğini farkettim: Neden sonuç dizisine eleman ekleyelim (bazı eklemelerde yeni bellek ayrılır), sürekli olarak 'sepet = remove/* ... */' yapalım?

Aklıma, elemanları baştan seçelim ve onları sonuç olarak kullanabilelim diye bir fikir geldi, "kesin vardır" dedim, ve std.random.partialShuffle'ı buldum. Kendi programımda kullanıyorum.

>      pos = uniform(0, sepet.length);
>      scope(exit) sepet = remove(sepet, pos);

Yani, "bir elma seç, sonra bir elma daha seç" diyorsun. :) Ben bunu "iki elma seç"ten daha karmaşık bulduğumdan aklıma bile gelmez. "Code review" sırasında karşılaşsam yazan kişiden basitleştirmesini isterim çünkü bu tür akıllı durumlar daha sonradan sorunlara neden olabilir.

>      return [ ilk, sepet[pos] ];
>    }
>      // Sonsuz döngü için test ederiz ama şartlı*:
>      size_t loop = 1;
>      do {

// ...

>      } while(loop++);

O da yanıltıcı olmuş çünkü loop 0 olana kadar devam edecekmiş gibi görünüyor ama asıl çıkış koşulu içeride bir yerde. Bu koşulun da etkisi olabilir gibi görünüyor ama 64 bitlik bir sistemde üstelik giriş/çıkış yapan bu program o koşula evrenin sonundan önce gelebilir mi? ;)

Bu durumda en iyisi, koşulsuz döngü:

  // Benim sevdiğim
  while (true) {
    // ...
  }

veya

  // Başka bazı programcıların sevdiği
  for (;;) {
    // ...
  }

Ama sen loop'u da yazdırdığına göre ben de for'u yeğliyorum. Ama yine de loop'un döngü sonundaki while tarafından arttırılması, bana gizli kalıyor gibi geldi.

>        auto x = sepet1.sum; auto y = sepet2.sum;

Ben değişkenleri ayrı satırlarda tanımlamayı seviyorum. Yoksa sağdakiler gizleniyorlar gibi geliyor. Ayrıca, bir el alışkanlığı olarak öncelikle 'const'ı seçiyorum.

Bunları uygulayınca ben aşağıdaki gibi değiştirdim. Aklıma swapRanges'den yararlanmak da geldi:

import std.random, std.range, std.stdio;
import std.algorithm.mutation : remove, swapRanges;
import std.algorithm.iteration : sum;
import std.math : abs;

enum enAz = 90;
enum enÇok = 120;
enum size_t adet = 10;
enum size_t değişim = 2;

auto rasgeleSepet() {
  return generate!(() => uniform!"[]"(enAz, enÇok))
         .takeExactly(adet)
         .array;
}

auto avuçla(ref int[] sepet) {
  // 'değişim' adet rasgele sayıyı başa getirir.
  // Tam istediğimiz şey! :)
  partialShuffle(sepet, değişim);

  // Baş tarafı sonuçtur
  auto sonuç = sepet[0..değişim];

  // Son tarafı da sepetin yeni durumu
  // sepet = sepet[değişim..$];

  // Yukarıdaki satırı, main'in sonundaki açıklamalara uygun
  // olarak çıkarttım.

  // Aslında artık partialShuffle'dan farkımız da kalmadı! :D

  return sonuç;
}

void main() {
  auto sepet1 = rasgeleSepet();
  auto sepet2 = rasgeleSepet();

  for (size_t loop = 0; ; loop++) {
    const x = sepet1.sum;
    const y = sepet2.sum;
    const fark = abs (x - y);

    x.writeln(" gr. (sepet1)");
    y.writeln(" gr. (sepet2), fark:", fark);

    writefln("%s\n%s\n", sepet1, sepet2);

    if(fark < 4 ) {
      "Toplam rasgele değişim: ".writeln(loop);
      break;
    }

    auto birAvuç = avuçla(sepet2);
    auto başkaAvuç = avuçla(sepet1);

    // Bu iki satırın yerine daha iyisini yazacağım. Açıklaması
    // aşağıda...
    //
    // sepet2 ~= avuçla(sepet1);
    // sepet1 ~= birAvuçElma;

    // Eğer bu programı hızlandırmak gerekirse, yukarıdaki ~=
    // işleçlerinden kurtulmak gerekecektir çünkü o işleç yeni
    // bellek ayırmak ve sonucu oraya kopyalamak zorundadır.
    //
    // Onun yerine, belki de sepetleri partialShuffle yaptıktan
    // sonra baş taraflarını yer değiştirmek daha hızlı
    // olabilir. Ama bu, probleme daha farklı yaklaşmayı
    // gerektirir.
    //
    //  Hattaaa... :) 'avuçla' işlevinin belgesine "döndürdüğü
    //  elemanları asıl dizinin baş tarafıdır" eklediğimiz an,
    //  burada std.algorithm.swapRanges'den yararlanabiliriz.

    swapRanges(birAvuç, başkaAvuç);

    // Bu mantığın doğru çalışabilmesi için avuçla'nın içindeki
    // 'sepet = sepet[değişim..$]' ifedesini çıkartttım.
  }
}

Ali