Merhabalar :)
for döngüsünü bildiğime eminim daha doğrusu emindim ama derslerdeki baklava dilimi çizimi sorusu beni biraz zorladı.Acaba ben bu döngüyü mü bilmiyor dedim :) çok çaylakça birşeyler yazmaya çalıştım , asıl soru bundan başka nasıl çizilebilir daha kolay bir yol ?

import std.stdio;

void main () {
	for (int satır = 0 ; satır != 9 ; ++satır) {
		int uzunluk = satır + 1;
		for ( int i = satır ; i != 9 ; ++i) {
			write(" "); }
		for ( int yıldız = 0 ; yıldız != uzunluk ; ++yıldız ) {
			write("*"); }
		for ( int sag = 0 ; sag != uzunluk ; ++sag) {
			write("*");
			}writeln();}

	for (int satır = 0 ; satır != 9 ; ++satır) {
		int uzunluk = satır +1;
		for (int sol_alt = 0; sol_alt != uzunluk ; ++sol_alt) {
			write(" ");
		}
		for (int sol_alt_yıldız = 10 ; sol_alt_yıldız != uzunluk ; --sol_alt_yıldız) {
			write("*");
		}
		for (int sag_alt =10 ; sag_alt != uzunluk ; --sag_alt) {
			write("*");
		}writeln();}}

Çıktısı ise şöyle birşey oluyor :

        **
       ****
      ******
     ********
    **********
   ************
  **************
 ****************
******************
******************
 ****************
  **************
   ************
    **********
     ********
      ******
       ****
        **

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

Bana zor geldi. :) Yalnızca for döngüsünün kullanılabilmesi de olayı daha zorlaştırıyor.

Şu anda ilk aklıma gelen, satırı iki parça olarak düşünmek oldu: önce boşluk ve yıldızlar. Yıldızların uzunluğu artarken boşlukların uzunluğu azalıyor. Ne yazık ki pek temiz kod olmadı. Önce bu haliyle göstereyim sonra daha güzelleştiririz:

import std.stdio;

void main()
{
   int genişlik = 11;
   int boşlukUzunluğu = genişlik / 2;
   int yıldızUzunluğu = 1;
   bool ilkYarı_mı = true;

   for (int satır = 0; satır != genişlik; ++satır) {
       for (int i = 0; i != boşlukUzunluğu; ++i) {
           write(".");
       }

       for (int i = 0; i != yıldızUzunluğu; ++i) {
           write("*");
       }

       writeln();

       if (ilkYarı_mı) {
           --boşlukUzunluğu;
           yıldızUzunluğu += 2;

           if (boşlukUzunluğu == 0) {
               ilkYarı_mı = false;
           }

       } else {
           ++boşlukUzunluğu;
           yıldızUzunluğu -= 2;
       }
   }
}

Ali

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

Senin çözümünde ilk göze batan 9'un tekrarlanmış olması. Onun dışında bir sorun görünmüyor. :)

Ali

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

çok teşekkür ederim @acehreli , ikinci yazdığınız kodu yazmak için benim daha çok yolum var gibi :)

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

Bir tane de olabildiğince tembel aralıklarla yazmaya çalıştım:

import std.stdio;
import std.range;
import std.algorithm;
import std.conv;
import std.exception;
import std.string;

/*
* Boşluk ve yıldız uzunluklarını hesaplayan bu iki işlev ilginç bir biçimde
* birbirlerinden yararlanıyorlar. İlk yarıda yıldız uzunluğunu, ikinci yarıda
* da boşluk uzunluğunu hesaplamak kolay.
*/
size_t yıldızUzunluğu(size_t genişlik, size_t satır)
in {
   assert(genişlik % 2);
   assert(satır < genişlik);

} out(sonuç) {
   assert(sonuç <= genişlik);

} body {
   if (satır <= (genişlik / 2)) {
       return (2 * satır) + 1;

   } else {
       return genişlik - (2 * boşlukUzunluğu(genişlik, satır));
   }
}

unittest
{
   assert(yıldızUzunluğu(3, 0) == 1);
   assert(yıldızUzunluğu(3, 1) == 3);
   assert(yıldızUzunluğu(3, 2) == 1);
}

size_t boşlukUzunluğu(size_t genişlik, size_t satır)
in {
   assert(genişlik % 2);
   assert(satır < genişlik);

} out(sonuç) {
   assert(sonuç <= genişlik);

} body {
   if (satır <= (genişlik / 2)) {
       return (genişlik - yıldızUzunluğu(genişlik, satır)) / 2;

   } else {
       return satır - (genişlik / 2);
   }
}

unittest
{
   assert(boşlukUzunluğu(11, 0) == 5);
   assert(boşlukUzunluğu(11, 5) == 0);
   assert(boşlukUzunluğu(11, 10) == 5);
}

auto baklavaDilimi(size_t genişlik)
{
   /* Not: Bu denetim yerine 'genişlik' çift olduğunda değerini bir azaltarak
    *      kendimiz tek sayı da elde edebilirdik.
    */
   enforce(
       genişlik % 2,
       format("Baklava dilimi genişliği çift sayı olamaz. (%s)", genişlik));

   /* Baklava dilimini üç parça halinde oluşturacağız:
    *
    * 1) İlk yarısı olan üçgeni oluşturan aralık
    * 2) Ortasındaki uzun satır
    * 3) İlk yarısının tersi olan üçgeni oluşturan aralık
    *
    * Not: Aşağıda üç yerde text kullanmak zorunda kalmış olmak canımı
    *      sıkıyor. Onların yerine tembel aralıklar kullanmayı
    *      beceremedim. (?)
    */

   auto ilkYarı = iota(genişlik / 2)
                  .map!(satır =>
                        ' '.repeat(boşlukUzunluğu(genişlik, satır)).text ~
                        '*'.repeat(yıldızUzunluğu(genişlik, satır)).text);

   auto uzunSatır = '*'.repeat(genişlik).text.only;

   auto sonYarı = ilkYarı.retro;

   return chain(ilkYarı, uzunSatır, sonYarı).joiner("\n");
}

void main()
{
   writeln(baklavaDilimi(11));
}

Ali

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

Alıntı (acehreli):

Her zamanki gibi yine alçakgönüllüsünüz :)

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

Alıntı (hkntrt):

Ama öyle yazmaya hiç gerek yok ve zaten istediğim gibi de olamadı. (?) "print a diamond pattern" diye aratınca başka dillerde programlar da bulunuyor.

Ali

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

Dlang haber gruplarında sordum. Bakalım başka ne çözümler gelecek:

http://forum.dlang.org/thread/lgfmbf$v7c$1@digitalmars.com#post-lgfmbf:24v7c:241:40digitalmars.com

Ali

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

Dlang'de açtığınız konuya baktım.Son yazdığınız kod oldukça mantıklı, dilin olanaklarından yararlanılarak yazılabilecek en sade ve şık kod bu galiba :)

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

Dlang'daki konudan iki yöntem öğrendim:

1. Önce artan sonra azalan yıldız uzunluğunu sağlamak için chain ile birbirine bağlanmış iki iota aralığı kullanılabilir.

2. Boşlukları halletmek çok kolay: std.string modülündeki center verilen dizgiyi verilen genişlikte ortalıyor.

N genişliğindeki baklava dilimini şöyle oluşturabiliriz:

1. 1'den N'e kadar artan ve sonra N'den 1'e kadar azalan yıldız genişlikleri oluştur (iki iota'yı chain'le bağlayarak).

2. Her yıldız genişliği değeri için yıldız karakterini tekrarla (karakteri repeat ile tekrarlayarak).

3. Tekrarlanan karakterlerden dizgi oluştur (text ile).

4. Oluşturan dizgiyi satırda ortala (center ile).

Yukarıdaki işlemler bize tembel olarak işleyecek olan bir aralık verir. Bütün sonucu tek dizgi olarak baştan sunmamanın bir yararı hız başka bir yararı da satırları belki başka amaç için de kullanılabilmesidir.

Bu aralığı kendi amacımız için kullanmanın bir yolu, çıktı düzeninde "%(" ve "%)" gruplama belirteçlerini kullanmaktır.

Aşağıdaki programdaki import'ları da aslında daha temiz bir uygulama olduğundan hem kullanıldıkları işlevlerin içine yazdım hem de modüllerdeki bütün isimleri değil, yalnızca kullanılan isimleri import ettim.

auto baklavaDilimi(size_t N)
{
   import std.range : chain, iota, repeat;
   import std.algorithm : map;
   import std.conv : text;
   import std.string : center, format;
   import std.exception : enforce;

   enforce(N % 2, format("Baklava dilimi genişliği çift olamaz. (%s)", N));

   return
       chain(iota(1, N, 2),         // 1, 3, ..., N-2 değerleri
             iota(N, 0, -2))        // N, N-2, ..., 1 değerleri
                                    // (ve onların chain ile bağlanmaları)

       .map!(i => '*'.repeat(i))    // '*' karakterinin her değer için tekrarı

       .map!(s => s.text)           // Tekrarlanan karakterlerden dizgi
                                    // oluşturulması

       .map!(s => s.center(N));     // Dizginin satırda ortalanması
}

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

   writefln("%-(%s\n%)", baklavaDilimi(11));

   /*
    * Yukarıdaki düzen dizgisinin anlamı: Aralıktaki her elemanı %( ve %)
    * arasında belirtilen düzende yazdır. (Not: Bu aralığın her elemanı dizgi
    * olduğundan ve dizgiler normalde çift tırnaklar arasında
    * yazdırıldıklarından %( değil, %-( kullanılıyor. Yani, o aradaki tire
    * işareti "çift tırnak olmasın" anlamına geliyor.)
    *
    * Her eleman için kullanılan düzen de şu: %s\n. Yani, her birisinden
    * sonra yeni satıra geçiliyor.
    */
}

Ali

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