On 1/22/22 00:19, Salih Dincer wrote:
> Bir long sayısını, aralarında "bin, milyon, milyar"
> yazacak şekilde benden daha az satır kodla string'e çeviremezsiniz!

Ben uzunluğu önemsemedim (henüz?) ve biraz daha becerikli oldu:

- Kentilyon'a kadar destekliyor. (Daha fazlası ulong'a sığmıyor.)

- "sıfır" ve "eksi" de yazıyor.

- Aynı Appender'ın belleğini kullandığı için fazla bellek de ayırmaz.

struct Bölen {
  ulong değer;
  string söz;
}

static const(Bölen[]) bölenler;

static this() {
  import std.range : array, enumerate;
  import std.algorithm : map;

  bölenler = [ "", "bin", "milyon", "milyar",
               "trilyon", "katrilyon", "kentilyon", ]
             .enumerate
             .map!(t => Bölen(10^^(t.index * 3), t.value))
             .array;
}

import std.format : format;

void sözleImpl(T, Ç)(T sayı, ref Ç çıktı)
in (sayı > 0, format!"Geçersiz sayı: %s"(sayı)) {
  import std.range : retro;
  import std.format : formattedWrite;

  foreach (bölen; bölenler.retro) {
    const bölüm = sayı / bölen.değer;

    if (bölüm) {
      if ((bölen.değer != 1000) || (bölüm != 1)) {
        çıktı.formattedWrite!" %s"(bölüm);
      }

      çıktı.formattedWrite!" %s"(bölen.söz);
    }

    sayı %= bölen.değer;
  }
}

// Her çağrı bir önce döndürülen string'in üzerine
// yazar. Gerektiğinde dönüş değerini kopyalayın.
auto sözle(T)(T sayı) {
  import std.array : Appender;
  import std.string : strip;

  static Appender!(char[]) çıktı;
  çıktı.clear;

  if (sayı == 0) {
    çıktı ~= "sıfır";

  } else {
    if (sayı < 0) {
      çıktı ~= "eksi";
      sayı = -sayı;
    }

    sözleImpl(sayı, çıktı);
  }

  return çıktı.data.strip;
}

void main() {
  import std.stdio;
  import std.algorithm;

  long[] girdiler = [ 741, 1_500, 5_005, 1_250_000, -3_000_042, 10_000_000, 999_001_001_001, 0 ];
  writefln!"%-(%s\n%)"(girdiler.map!sözle);
}

Ali

Benim çözümde sorunlar var.

On 1/22/22 15:37, Ali Çehreli wrote:

> struct Bölen {
>    ulong değer;

Değer ulong seçilmiş olduğundan bu kod int ile çalışamaz çünkü int aşağıdaki bazı işlemler sırasında otomatik olarak ulong'a dönüştürülür.

>    bölenler = [ "", "bin", "milyon", "milyar",
>                 "trilyon", "katrilyon", "kentilyon", ]

short ile çalışırken "bin"den ötesi gerekmez ve hatta 'bölenler'in değerleri mecburen ulong olduğundan işlemler yanlış olur.

>        sayı = -sayı;

O işlem, int'ten küçük türlerle artık çalışmıyor(muş).

O hatalar nedeniyle program örneğin sıfırdan küçük bir int değerle çalışmıyordu.

Bu sorunları çözdüğümü sanıyorum ama henüz paylaşmıyorum. :) Buna rağmen, şimdiki çözüm de yukarıdaki '-sayı' işlemi nedeniyle işaretli türlerin .min değerleriyle çalışamıyor. Bunun nedeni, örneğin sayı int.min olduğunda -sayı'nın değeri yine int.min'dir! Bakınız:

  static assert(-int.min == int.min);  // Delilik! :)

Neyse ki, elimdeki çözüm hiç olmazsa bu durumun geçersiz olduğunu bildiriyor.

Ali

On 1/23/22 06:21, Salih Dincer wrote:

> Önce 2 işlevlik bir struct yaptım ama sonra beğenmedim

Sohbetlerde de bir kaç kere değindiğimiz gibi, ben artık hep işlevle başlıyorum; bir neden ortaya çıktıkça struct'a yöneliyorum. class çok az kullanılıyor.

>   sadece en baştaki boş karakteri halledemedim!*/

Ben sonucu string olarak üretip basitçe std.string.strip'i çağırdım. Aşağıdaki sözde koddaki gibi çok hızlı bir işlevdir:

  char[] dizgi = /* ... */;
  while (boşluk_mu(dizgi.front)) {
    dizgi = dizgi.popFront();
  }
  // Aynısı arka taraf için...

Benim son programım aşağıda. T.min ile ilgili sorunum var çünkü yalnızca pozitif sayılarla işleyen işlevi -sayı değeriyle çağırıyorum. İlginç olarak, '-sayı'nın türü otomatik olarak 'int' olabiliyor (sayı örneğin 'short' olsa bile). O yüzden bazı karmaşıklıklar da içeriyor.

Herşeyi açıklamalarda ve birkaç unittest ile anlatmaya çalıştım:

import std.traits : isSigned;

// Belirtilen sayıyı sözle ifade eder. Her çağrı bir önce döndürülen
// string'in üzerine yazar. Gerektiğinde dönüş değerini kopyalayın.
// T.min değeri ile çağrılamaz.
auto sözle(T)(T sayıParametre) {
  import std.array : Appender;
  import std.string : strip;
  import std.traits : Unqual;
  import std.exception : enforce;

  // Bu algoritma işaretli sayıların T.min değeriyle çalışamaz çünkü
  // basitçe '-T.min' yaparak onun değerini yazdırmaya çalışır. Ancak,
  // işaretli türlerde '-T.min == T.min' ilişkisi geçerli olduğundan o
  // amaca ulaşamayız. O yüzden bu değeri burada denetliyoruz.
  static if (isSigned!T) {
    enforce(sayıParametre != T.min, format!"Geçersiz sayı: %s"(sayıParametre));
  }

  // Giriş 'const' bile olsa onun const olmayan bir kopyasını
  // kullanacağız. (Unqual, 'const' gibi "qualifier"ları kaldırır.)
  auto sayı = cast(Unqual!T)sayıParametre;

  // Her sonuç için farklı bellek ayrılmasın diye hep bu ortak belleği
  // kullanacağız.
  static Appender!(char[]) çıktı;
  çıktı.clear;    // Belleği başa sarıyoruz.

  if (sayı == 0) {
    çıktı ~= "sıfır";

  } else {
    if (sayı < 0) {
      çıktı ~= "eksi";
      static if (T.sizeof < int.sizeof) {
        // Burada kısaca
        //
        //   sayı = -sayı
        //
        // yazmak isterdim ama ilginç bir otomatik dönüşüm konusu var:
        // 'sayı' int'ten küçük bir tür olduğunda, örneğin 'short'
        // olduğunda '-sayı'nın türü int midir, short mudur? Yeni
        // derleyiciler -preview=intpromote ile ilgili bir uyarı
        // veriyorlar. O yüzden kendim açıkça önce int'e sonra T'ye
        // dönüştürüyorum.
        sayı = cast(T)(-cast(int)sayı);

      } else {
        // int'ten büyük türlerde ise hiç de cast(int) diye değer
        // kaybetmek istemeyiz. Basit işlem doğru çalışır:
        sayı = -sayı;
      }
    }

    // Bu ön işlemlerden sonra asıl işlevi çağırabiliriz
    sözleImpl(sayı, çıktı);
  }

  // Baştaki ve sondaki boşlukları çıkartmayı unutmadan
  return çıktı.data.strip;
}

unittest {
  import std.exception : assertThrown;

  assertThrown(sözle(int.min));

  assert(1_001_500.sözle == "1 milyon bin 500");
  assert(1_002_500.sözle == "1 milyon 2 bin 500");
}

import std.format : format;
import std.range : isOutputRange;

// Sözleri üreten asıl işlev bu. Sonucu 'çıktı' akımına
// yazar. Kullanıcılar normalde bunu değil, sözle() işlevini
// çağırırlar. Eksi sayılar sözle() tarafından halledilirler.
void sözleImpl(T, Ç)(T sayı, ref Ç çıktı)
if (isOutputRange!(Ç, char))
in (sayı > 0, format!"Geçersiz sayı: %s"(sayı)) {
  import std.range : retro;
  import std.format : formattedWrite;

  foreach (bölen; bölenler!T.retro) {
    const bölüm = sayı / bölen.değer;

    if (bölüm) {
      // "1 bin" durumunda 1 yazmayalım
      if ((bölen.değer != 1000) || (bölüm != 1)) {
        çıktı.formattedWrite!" %s"(bölüm);
      }

      çıktı.formattedWrite!" %s"(bölen.söz);
    }

    sayı %= bölen.değer;
  }
}

// İşlemlerin otomatik tür dönüşümü nedeniyle istenmeyen türlere
// kaymasını önlemek için her tür sayı için farklı türde Bölen
// gerçekleştirmeleri olsun diye bunu şablon yaptım. Kodun geri
// kalanında şablon kullanmamın nedeni de oydu.
struct Bölen(T) {
  T değer;       // Bölme değeri; örneğin, 1_000
  string söz;    // Değere karşılık gelen söz; örneğin, "bin"
}

// Parametresi, türün kaç bayttan oluştuğunu bildirir. O türün
// ifade edebildiği sözlerden oluşan bir dizi döndürür. Örneğin,
// 2 bayttan oluşan short türü ancak "bin" sözünü kullanır.
auto sözler(size_t türBüyüklüğü) {
  // Burada yalnızca hoşuma gittiği için özyineleme (recursion)
  // kullandım. Yoksa, unittest'e yazdığım dizi gibi burada da
  // her büyüklük için bir dizi yazabilirdim. Olsun; hoş... :)
  final switch (türBüyüklüğü) {
  case 1: return [ "" ];
  case 2: return sözler(1) ~ [ "bin" ];
  case 4: return sözler(2) ~ [ "milyon", "milyar" ];
  case 8: return sözler(4) ~ [ "trilyon", "katrilyon", "kentilyon" ];
  }
}

unittest {
  assert(sözler(4) == [ "", "bin", "milyon", "milyar" ]);
}

// Belirtilen türle ilgili olan Bölen!T dizisi döndürür.
auto bölenler(T)() {
  import std.range : array, enumerate;
  import std.algorithm : map;

  static const(Bölen!T[]) b = sözler(T.sizeof)
                              .enumerate!T
                              .map!(t => Bölen!T(cast(T)(10^^(t.index * 3)), t.value))
                              .array;
  return b;
}

unittest {
  // Bir kaç tane deneme yetsin:
  assert(bölenler!int[1] == Bölen!int(1_000, "bin"));
  assert(bölenler!ulong[3] == Bölen!ulong(1_000_000_000, "milyar"));
}

void main() {
  import std.meta : AliasSeq;
  import std.stdio : writefln;

  static foreach (T; AliasSeq!(byte, ubyte, short, ushort, int, uint, long, ulong)) {{
    // Her tür için 2-3 adet örnek yazdıralım
    static if (isSigned!T) {
      // Burada da 'T.min + 1' otomatik olarak int'e dönüştüğünden
      // bu deneme kodunda yine cast(T) yapıyorum.
      göster(cast(T)(T.min + 1));
    }
    // Aynı nedenden cast(T)
    göster(cast(T)(T.max / 2));
    göster(T.max);
  }}
}

void göster(T)(T değer) {
  import std.stdio : writefln;
  writefln!"  %6s % ,s: %s"(T.stringof, değer, sözle(değer));
}

Ali

On 1/23/22 18:04, Ali Çehreli wrote:

> Benim son programım aşağıda. T.min ile ilgili sorunum var çünkü yalnızca
> pozitif sayılarla işleyen işlevi -sayı değeriyle çağırıyorum.

O sorunu çözdüm. Sorun yaşadığım toplam 4 adet değer için işlevin açıklamalarına "T.min ile işleyemez" demeye bile değmez. :) sözle() işlevinin içine, çıktı.clear()'den sonraya şunu yerleştirdim:

  // Aşağıdaki algoritma işaretli sayıların T.min değeriyle çalışamaz
  // çünkü basitçe '-T.min' yaparak onun değerini yazdırmaya
  // çalışır. Ancak, işaretli türlerde '-T.min == T.min' ilişkisi
  // geçerli olduğundan o amaca ulaşamayız. O yüzden sorunlu değerleri
  // burada hallediyorouz.

  alias sorunluDeğerler = AliasSeq!(
    byte, "eksi 128",
    short, "eksi 32 bin 768",
    int, "eksi 2 milyar 147 milyon 483 bin 648",
    long, "eksi 9 kentilyon 223 katrilyon 372 trilyon 36 milyar 854 milyon 775 bin 808");

  static foreach (i, SorunluTür; sorunluDeğerler) {
    static if (i % 2) {
      // Bu, dizgi değeri; atlıyoruz

    } else {
      // Bu, sorunlu bir tür
      static if (is (T == SorunluTür)) {
        // Ve T bu türdenmiş
        if (sayıParametre == T.min) {
          // Ve tam da sorunlu değer isteniyormuş; işimiz kolay
          çıktı ~= sorunluDeğerler[i + 1];
          return çıktı.data;
        }
      }
    }
  }

D sağolsun, bütün o kodun etkisi, sorunlu türlerin şablon gerçekleştirmesine iki satır eklemektir. Örneğin, T int olduğunda şu dört satır eklenir:

  if (sayıParametre == int.min) {
    çıktı ~= "eksi 2 milyar 147 milyon 483 bin 648";
    return çıktı.data;
  }

T orada bulunmayan bir tür (örneğin, uint) olduğunda ise hiçbir satır eklenmez. Harika! :)

Ali

On 1/29/22 04:27, Salih Dincer wrote:

> algoritma İngilizce ile uyumlu mu? Yani bazen A, bazen yazıyla ONE
> kullanırlar ya.

Hayır, İngilizce'yle uyumlu değil çünkü bu algoritmanın hiçbir tarafı İngilice'yle uyumlu değil. :) İngilizce'de "2 thousand" bile olmaz, "two thousand" olur.

Ama bu programı başka bir konu nedeniyle yine de İngilizce'ye çevirdim ("1 bin" düzeltmesini kaldırarak) çünkü genel kanının aksine, en hızlı program gdc çıktı:

  https://forum.dlang.org/thread/sspkdp$1m4n$1@digitalmars.com

Sonuçta, bunun nedeninin elma ile armudu karşılaştırmamdan kaynaklandığı anlaşıldı. Sistemde ne derleyici varsa onları kullanıyordum. (Manjaro Linux; Arch tabanlı.) gdc, 2.076 döneminden kalmaymış. 2.076'daki formattedWrite da daha yeteneksiz olduğundan daha az işlem yapıyormuş ve o yüzden ldc'yi geçiyormuş.

Sonuçta formattedWrite yenrine bütün derleyicilerde aynı olacaklarını varsaydığım C'nin sprintf'ini kullanınca evet, ldc en hızlı derleyici çıktı ama bu sefer de dmd bile gdc'yi geçti! Onun nedeni de, gdc'nin en hızlı derlemesi için -O3 yanında başka seçenekler de gerekiyormuş. Başkası denedi ve gdc dmd'den biraz daha hızlı çıktı.

>    // static // olmasının nedeni? kaldırdım bir şey olmadı!
>    Appender!(char[]) çıktı;

static olmazsa, bu işleve her girildiğinde yeni bir değişken yaşamaya başlar. static olursa, tek değişken bu işlev tarafından paylaştırılır. Hatta, bu değişkenden her işlev parçacığında (thread) bir adet farklı olur. (Yani, 4 iş parçacığı varsa 4 adet değişken olur.

Orada amaç, her işlevde tazeden dinamik bellekten yer ayırmayı önlemek.

>    çıktı.clear;

O satırın amacı, bir önceki çağrının sonucundan kurtulmak için zaten ayrılmış olan alanı başa sarmak. (Tek göstergenin değerini değiştirmek kadar hızlı bir işlemdir.)

Ben bu konudan, performansı arttırma amacıyla şurada bahsetmiştim:

  https://www.youtube.com/watch?v=dRORNQIB2wA&t=785s

Ama dediğim gibi, daha hızlı çalışması için Appender da gitti ve bir static bellek için sprintf kullanıldı. (Yukarıdaki forum konusunda.)

> eklenebilecek çok
> şey var: Örneğin virgüllü sayılar!

Ama galiba kullandığımız düzende virgüle yer kalmıyor: "123 milyon 456 bin".

Ali