Anladığım kadrıyla gerekli değerleri hazırlamak için şöyle bişeyler geliştirdim. Oldukça kaba ve çözüm odaklı oldu, üzerinde iyileştirmeler yapılabilir. Eksiltme kısmını pek anlamadım doğrusu.

module main;

import std.stdio;
import std.random;

void main()
{
   int[] sayilar = [5, 1, 4, 2]; //RastgeleSayiUret(10);
   int[] dizi;

   foreach (sayi; sayilar)
   {
       dizi = sayi ~ dizi[0..$];
       dizi.sort;

       writeln(dizi);
   }

}

int[] RastgeleSayiUret(int adet)
{
   int[] donus;

   for (int i = 0; i < adet; ++i)
   {
       donus ~= uniform(0, 10);
   }

   return donus;
}

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Bence güzel :) Şu an için fazla vakit bulamadım. Ancak senin yazdığın sayı üret işlevini biraz değiştirdim. Rakamların tekrarlanamaz olduğunu düşünerek.

import std.stdio;
import std.random;

void main()
{
   int[] rakamlar = rastgeleRakamUret(4);
   foreach (rakam; rakamlar) {
       writeln(rakam);
   }
}

int[] rastgeleRakamUret (int adet)
{
   int[] sonuc;
   int[] rakamlar = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ];

   foreach (rakam; randomSample(rakamlar, adet)) {
       sonuc ~= rakam;
   }

   return sonuc;
}

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Sayıları yazdıralım.

import std.stdio;
import std.random;
import std.math;

void main()
{
   int[] rakamlar = rastgeleRakamUret(4);

   /* rakamlari sirala */
   rakamlar.sort;


   /* rakamlari yazdir */
   write("rakam : ");
   foreach(rakam; rakamlar) {
       write(rakam, " ");
   }
   writeln();


   int[] sayilar;

   for (int i = 0; i != rakamlar.length; ++i) {
       if (i == 0)
           sayilar ~= rakamlar[i] * pow(10, i);
       else
           sayilar ~= rakamlar[i] * pow(10, i) + sayilar[i - 1];
   }

   /* sayilari yazdir */
   writeln("sayilar : ");
   foreach (sayi; sayilar) {
       writeln(sayi);
   }
}

int[] rastgeleRakamUret (int adet)
{
   int[] sonuc;
   int[] rakamlar = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ];

   foreach (sayi; randomSample(rakamlar, adet)) {
       sonuc ~= sayi;
   }

   return sonuc;
}

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Alıntı (acehreli):

O zaman bunlar tekli sayılar anladığım kadarıyla ben de boşuna 'pow''la uğraşıyorum :)

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

import std.stdio;
import std.random;
import std.math;
import std.algorithm;


void main()
{
   int[] sayilar = [5, 1, 4, 2]; //rastgeleSayiUret(4);

   foreach (sayi; sayilar) {
       writeln(sayi);
   }

   // sayilari yazdir
   for (int i = 0; i != sayilar.length; ++i) {
       writeln(sayilar[0 .. i + 1].sort);
   }

   // konum olustur

   int[] konum = [1, 2, 0, 0];

   sayilar.sort;

   int cikarilacak = 0;

   // sayilari yazdir


   // burada bir hata var!
   for (int i = 0; i != sayilar.length; ++i) {
       writeln(sayilar);
       cikarilacak = konum[i];
       sayilar = remove(sayilar, cikarilacak);
   }

}

int[] rastgeleSayiUret(int adet)
{
   int[] sonuc;


   for (int i = 0; i < adet; ++i)
   {
       sonuc ~= uniform(0, 10);
   }

   return sonuc;
}

Tamam şimdi mantığı anladım. Ama 'remove' ile ilgili bir hata yapıyorum herhalde.

Teorik olarak çalışması lazımdı! :-D

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Bu başlık şuradan türemişti: http://ddili.org/forum/thread/719

Orada switch ve bir dizi OR'lu if örneği verilmişti:

   final switch (s[i]) {
       case ' ': case '\t': case '\f': case '\r': case '\n': case '\v':
           writeln("boşluk");
           break;
   }

   auto değer = s[i];
   if ((değer == ' ') || (değer == '\t') || (değer == '\f') ||
       (değer == '\r') || (değer == '\n') || (değer == '\v'))
       writeln("boşluk");

Ben az önce, farklı derlemelerde assembly koduna baktım, her ikisi de aynı şeyi üretiyor:

'cmp ECX,020h
je L6C
cmp ECX,9
je L6C
cmp ECX,0Ch
je L6C
cmp ECX,0Dh
je L6C
cmp ECX,0Ah
je L6C
cmp ECX,0Bh
je L6C
jmp short L81'

Sanırım aynı sonuca giden farklı denemeleri assembly olarak da incelemekte fayda var. Çünkü derleyici adeta tüm kontrolü ele almış ve ne yapmak istediğimizi anlıyor ve bir çözüme doğru kodu sadeleştiriyor. Bu hem iyi hem de kötü...:)

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Alıntı (erdem):

> ...
>     // burada bir hata var!
>     for (int i = 0; i != sayilar.length; ++i) {
>         writeln(sayilar);
>         cikarilacak = konum[i];
>         sayilar = remove(sayilar, cikarilacak);
>     }
> ...
> ```

>

Erdem, benim sorunun açıklamasından anladığım kadarıyla direk olarak ilgili konumdaki elemanı kaldırma söz konusu değil sanki bir azaltma var gibi örneğin 5, 4 olmuş 15, 14 olmuş diye düşünüyorum ama yani tam olarak anlamadığım için emin değilim.

Tuhaf array modülünde bir remove metodu yok (Bir açıklaması vardır elbet :)) Belkide bu remove metodunuda biz yazmalıyız. Şöyle basit bir deneme yapıyorum, yine kaba ve çok daha iyisi yapılabilir, ben sadece D'nin olanaklarından faydalanarak bir şeyler yazmaya çalışıyorum.

import std.stdio;

void main()
{
int[] test = [1, 2, 3, 4, 5, 6, 7, 8, 9];

writeln(test);

test = KonumdakiElemaniKaldir(test, 2);
writeln(test);

test = KonumdakiElemaniKaldir(test, 5);
writeln(test);
}

int[] KonumdakiElemaniKaldir(int[] dizi, int konum)
{
return (dizi[0 .. konum] ~ dizi[konum + 1 .. $]);
}

Alıntı (Salih Dinçer):
>
> Bu başlık şuradan türemişti: http://ddili.org/forum/thread/719
>
> Orada switch ve bir dizi OR'lu if örneği verilmişti:
>

Ordaki konu daha çok karşılaştırma işlemin arka plandaki çalışması ile ilgiliydi. Buradaki durum ise bir dizi ile liste arasındaki çalışmayı kıyaslamayı amaçlıyor gibi geldi bana. Aslında her şekilde buradaki bu küçük soru önemli bir seçimin anahtarı, basit gibi görünen önemli bir sorunun cevabını buradaki çözüm bize açıklayabilir. Dizi mi, liste mi?

-- 
[ Bu gönderi, <http://ddili.org/forum>'dan dönüştürülmüştür. ]

Alıntı (zafer):

> ...
>
> int[] KonumdakiElemaniKaldir(int[] dizi, int konum)
> {
>     return (dizi[0 .. konum] ~ dizi[konum + 1 .. $]);
> }
>
> ...
> ```

>

KonumdakiElemaniKaldir() metoduna şöyle tekrar bir baktımda, aslında önemli bir noktayı atlamışım, metodu tanımsız konum değerlerinden korumayı unutmuşum  :-D , bunun için şöyle bir çözüm iş görür gibi;

int[] KonumdakiElemaniKaldir(int[] dizi, int konum)
{
assert(konum <= dizi.length, "Konum sınır dışında!");

return (dizi[0 .. konum] ~ dizi[konum + 1 .. $]);
}

Bir an düşündümde sanki biraz Ali stili gibi oldu mesajlar  :-D , ama sorun yok Ali stili iyidir  ;-)

-- 
[ Bu gönderi, <http://ddili.org/forum>'dan dönüştürülmüştür. ]

Zaman buldukça GoingNative 2012'nin sunumlarını izliyorum:

http://channel9.msdn.com/Events/GoingNative/GoingNative-2012

Bjarne Stroustrup'un Keynote'unu bitirdim:

http://channel9.msdn.com/Events/GoingNative/GoingNative-2012/Keynote-Bjarne-Stroustrup-Cpp11-Style

Bir yerde verinin yerelliğinin önemini vurguluyor. Bütün sunumu izlemek istemiyorsanız yukarıdaki sayfada "Slides"a tıklayabilirsiniz. 44 numaralı slayt şu:

Alıntı:

Rasgele N adet int'i teker teker bir topluluğa ve doğur sırada yerleştirin. Örneğin 5 1 4 2 sayıları geldiğinde topluluk sırayla şöyle olsun:

5
15
145
1245

Hemen arkasından rasgele konumlar seçin ve o konumdaki elemanı topluluktan çıkartın. Örneğin 1 2 0 0 konumları geldiğinde topluluk şu biçimde eksiklerek boşalsın:

1245
145
14
4

Soru: Acaba böyle bir problemde topluluk olarak vector kullanmak mı hızlı olur yoksa bağlı liste mi? Belki de N'in belirli değerine kadar birisi daha hızlıdır ama daha büyük N'ler için diğeri hızlıdır. (?) Yanıtı yine slaytlarda var ama kendiniz denemek isterseniz diye, C++'taki vector D'deki dizilere karşılık gelir. Bağlı liste olarak da isterseniz kendiniz basit bir bağlı liste yazabilirsiniz, veya std.container.SList'i kullanabilirsiniz.

Ali

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Alıntı (zafer):

> int[] KonumdakiElemaniKaldir(int[] dizi, int konum)
> {
>     assert(konum <= dizi.length, "Konum sınır dışında!");
>
>     return (dizi[0 .. konum] ~ dizi[konum + 1 .. $]);
> }
> ```

>

Bu yöntemi denedim. Ama gene hata veriyor. Sanırım benim en son yazdığım kodda bir hata var. Ama bir iki gündür bir sayısal analog dönüştürücüyü çalıştırmaya çalışıyorum. O yüzden konuya tam yoğunlaşamadım  :rolleyes:

Alıntı (acehreli):
>
> Tamam, sort() yöntemi iyi ama sıralama algoritmaları normalde O(N log(N)) karmaşıklıkta işlerler. Burada ise elimizde zaten her zaman için sıralı bir dizi olacak.
>

İlk verilen

int[] sayilar = [5, 1, 4, 2];

dizisi sırasız değil mi. 'sort' ile sıraladıktan sonra elimizde zaten bir sıralı dizi olacak mı demek istediniz acaba.

Alıntı (acehreli):
>
> O yüzden sort()'u çağırmak yerine şu daha hızlı olabilir: elemanın dizide nerede bulunması gerektiğini bulalım ve o araya yerleştirelim. Bu daha hızlı olacaktır çünkü yerin bulunması için ikili arama kullanılırsa log(N) karşılaştırma yeter.
>

İkili arama için sanırım dizinin sıralı olması gerekiyordu.

İlk koddaki 'remove' işlevindeki hatayı bulamadım.

-- 
[ Bu gönderi, <http://ddili.org/forum>'dan dönüştürülmüştür. ]