'yap ... süre' vs 'süre'

Olası Yinelemeler:
While ve Do While
döngüleri yerine do-while kullanmalıyım?

Bir süredir programlama yapıyorum (2 yıl çalışma + 4.5 yıl derece + 1 yıl üniversite öncesi) ve Programlamaya Giriş kursunda asla zorlanmadan kısa bir süre kullanmadım. Hiç bu kadar temel bir şeyle karşılaşmazsam, programlamayı yanlış yaptığıma dair büyüyen bir his var.

Doğru koşullarla karşılaşmamış olabilir miyim?

Bir süre yerine do-while kullanmanın gerekli olduğu bazı örnekler nelerdir?

(Okul eğitimimin neredeyse tamamı C / C ++ içindeydi ve işim C # dilinde, yani do-whiles farklı çalıştığı için kesinlikle mantıklı olduğu başka bir dil varsa, bu sorular gerçekten geçerli değildir.)

Açıklığa kavuşturmak için ... a whileve a arasındaki farkı biliyorum do-while. Çıkış koşulunu kontrol eder ve ardından görevleri gerçekleştirir. do-whilegörevleri gerçekleştirir ve ardından çıkış koşulunu kontrol eder.

Döngünün her zaman en az bir kez yürütülmesini istiyorsanız. Yaygın değil ama ara sıra kullanıyorum. Kullanmak isteyebileceğiniz bir durum, yeniden deneme gerektirebilecek bir kaynağa erişmeye çalışmaktır, örn.

do
{
   try to access resource...
   put up message box with retry option

} while (user says retry);

derleyici optimizasyon konusunda yetkin değilse do-while daha iyidir. do-while, koşullu bir sıçrama ve koşulsuz bir sıçrama olan for ve while'ın aksine, yalnızca tek bir koşullu sıçrama içerir. Ardışık düzenlenmiş ve dallanma tahmini yapmayan CPU'lar için bu, sıkı bir döngünün performansında büyük bir fark yaratabilir.

Ayrıca, çoğu derleyici bu optimizasyonu gerçekleştirecek kadar akıllı olduğundan, derlenmiş kodda bulunan tüm döngüler genellikle yap-süre olacaktır (eğer derleyici geri yerel gotoslardan döngüleri yeniden yapılandırmayı bile zahmete katarsa).

Bunu bir TryDeleteDirectory işlevinde kullandım. Bunun gibi bir şeydi

do
{
    try
    {
        DisableReadOnly(directory);
        directory.Delete(true);
    }
    catch (Exception)
    {
        retryDeleteDirectoryCount++;
    }
} while (Directory.Exists(fullPath) && retryDeleteDirectoryCount < 4);

Do while, bir şeyi en az bir kez yürütmek istediğinizde kullanışlıdır. Do while vs while kullanımına iyi bir örnek olarak, şunu yapmak istediğinizi varsayalım: Bir hesap makinesi.

Buna bir döngü kullanarak ve her hesaplamadan sonra kişinin programdan çıkmak isteyip istemediğini kontrol ederek yaklaşabilirsiniz. Şimdi, muhtemelen program açıldıktan sonra kişinin bunu en az bir kez yapmak istediğini varsayabilirsiniz, böylece aşağıdakileri yapabilirsiniz:

do
{
    //do calculator logic here
    //prompt user for continue here
} while(cont==true);//cont is short for continue

Bu bir tür dolaylı cevap, ancak bu soru beni bunun arkasındaki mantığı düşündürdü ve bunun paylaşmaya değer olabileceğini düşündüm.

Herkesin söylediği gibi, do ... whilevücudu en az bir kez yürütmek istediğinizde bir döngü kullanırsınız. Ama hangi koşullarda bunu yapmak istersiniz?

Pekala, aklıma gelen en bariz durum sınıfı , kontrol koşulunun ilk ("primlenmemiş") değerinin, çıkmak istediğiniz zamanki ile aynı olması olabilir . Bu, koşulu çıkmayan bir değere hazırlamak için döngü gövdesini bir kez yürütmeniz ve ardından bu koşula göre gerçek tekrarı gerçekleştirmeniz gerektiği anlamına gelir. Programcılar bu kadar tembelken, birisi bunu bir kontrol yapısında toplamaya karar verdi.

Örneğin, bir zaman aşımına sahip bir seri bağlantı noktasından karakter okumak şu biçimi alabilir (Python'da):

response_buffer = []
char_read = port.read(1)

while char_read:
    response_buffer.append(char_read)
    char_read = port.read(1)

# When there's nothing to read after 1s, there is no more data

response = ''.join(response_buffer)

Kod tekrarını Not: char_read = port.read(1) . Python'da bir do ... whiledöngü olsaydı, şunu kullanmış olabilirdim:

do:
    char_read = port.read(1)
    response_buffer.append(char_read)
while char_read

Döngüler için yeni bir kapsam oluşturan diller için eklenen avantaj: char_readişlev ad alanını kirletmez. Ancak bunu yapmanın daha iyi bir yolu olduğunu ve bunun da Python'un Nonedeğerini kullanmak olduğunu unutmayın :

response_buffer = []
char_read = None

while char_read != '':
    char_read = port.read(1)
    response_buffer.append(char_read)

response = ''.join(response_buffer)

İşte benim açımdan en önemli nokta şudur : sıfırlanabilir türlere sahip dillerde, durum initial_value == exit_valueçok daha seyrek ortaya çıkar ve belki de bu yüzden onunla karşılaşmazsınız. Bunun asla olmadığını söylemiyorum, çünkü bir fonksiyonun geçerli bir koşulu belirtmek için döneceği zamanlar hala vardır . Ama aceleyle ve kısaca düşündüğüm görüşüme göre, kullandığınız diller şu anlama gelen bir değere izin vermediyse, bu çok daha fazla olur: bu değişken henüz başlatılmadı.None

Bu mükemmel bir akıl yürütme değildir: gerçekte, artık boş değerler yaygın olduğundan, bir değişkenin alabileceği geçerli değerler kümesinin bir unsurunu daha oluştururlar. Ancak pratik olarak, programcılar, duyarlı durumda olan bir değişkeni, döngü çıkış durumunu içerebilen ve başlatılmamış durumda olan bir değişkeni ayırt etmek için bir yola sahiptir.

Okuldayken onları biraz kullandım, ama o zamandan beri pek kullanmadım.

Teorik olarak, döngü gövdesinin çıkış koşulu kontrolünden önce bir kez çalışmasını istediğinizde kullanışlıdırlar. Sorun şu ki, ilk önce kontrolü istemediğim birkaç durum için, tipik olarak çıkış kontrolünü en sondan ziyade döngü gövdesinin ortasında istiyorum . Bu durumda, iyi bilinenleri vücudun herhangi for (;;)bir if (condition) exit;yerinde kullanmayı tercih ederim .

Aslında, döngüden çıkış koşulunda biraz titriyorsam, bazen döngüyü for (;;) {}gerektiğinde bir çıkış ifadesiyle yazmaya başlamayı yararlı buluyorum ve sonra bitirdiğimde bunun olup olmadığını görebilirim " başlatmaları, çıkış koşullarını taşıyarak ve / veya forparantez içindeki kodu artırarak temizlendi " .

Bir kod parçasını her zaman bir kez ve sonucuna bağlı olarak muhtemelen daha fazla çalıştırmanız gereken bir durum. whileAynısı normal bir döngü ile de üretilebilir .

rc = get_something();
while (rc == wrong_stuff)
{
    rc = get_something();
}

do
{
    rc = get_something();
}
while (rc == wrong_stuff);

do whilekod bloğunu en az bir kez çalıştırmak istiyorsanız. whileÖte yandan, belirtilen kriterlere bağlı olarak her zaman çalışmayacaktır.

Bu kadar basit:

ön koşul - son koşul

• while (koşul) {...} - ön koşul, kodu yalnızca kontrol ettikten sonra çalıştırır.
• do {...} while (koşul) - son koşul, kod en az bir kez çalıştırılır.

Artık sırrı bildiğinize göre .. bunları akıllıca kullanın :)

Bu sorunun yeterince yanıtlandığını görüyorum, ancak bu çok özel kullanım senaryosunu eklemek istiyorum. Do ... kullanmaya başlayabilirsiniz.

do
{
   ...
} while (0)

genellikle çok satırlı # tanımlar için kullanılır. Örneğin:

#define compute_values     \
   area = pi * r * r;      \
   volume = area * h

Bu, aşağıdakiler için uygundur:

r = 4;
h = 3;
compute_values;

-ama- şunun için bir gotcha var:

if (shape == circle)  compute_values;

bu genişledikçe:

if (shape == circle) area = pi *r * r;
volume = area * h;

Eğer onu bir do ... while (0) döngüsüne sararsanız, düzgün şekilde tek bir bloğa genişler:

if (shape == circle)
  do
  {
    area = pi * r * r;
    volume = area * h;
  } while (0);

Şimdiye kadarki cevaplar, "do-while" için genel kullanımı özetliyor. Ancak OP bir örnek istedi, işte bir tanesi: Kullanıcı girdisini alın. Ancak kullanıcının girdisi geçersiz olabilir - bu nedenle girdi istersiniz, onaylarsınız, geçerliyse devam edin, aksi takdirde tekrar edin.

Do-while ile girdi geçerli değilken girdiyi alırsınız. Normal bir while döngüsü ile girdiyi bir kez alırsınız, ancak geçersizse, geçerli olana kadar tekrar tekrar alırsınız. Döngünün gövdesi daha karmaşık hale gelirse, ilkinin daha kısa, daha zarif ve bakımı daha basit olduğunu görmek zor değil.

Aynı yapıyı birden çok kez okuyan bir okuyucu için kullandım.

using(IDataReader reader = connection.ExecuteReader())
{
    do
    {
        while(reader.Read())
        {
            //Read record
        }
    } while(reader.NextResult());
}

do whileBir dosyanın başında bir sentinel değeri okurken bir kullandım , ancak bunun dışında, bu yapının çok yaygın kullanılmamasının anormal olduğunu düşünmüyorum - do-whiles gerçekten durumsaldır.

-- file --
5
Joe
Bob
Jake
Sarah
Sue

-- code --
int MAX;
int count = 0;
do {
MAX = a.readLine();
k[count] = a.readLine();
count++;
} while(count <= MAX)

İşte teorim, çoğu insanın (ben dahil) neden while () {} döngüleriyle {} while () yapmayı tercih ettiğidir: Bir while () {} döngüsü, bir do.. while () döngüsü gibi performans gösterecek şekilde kolayca uyarlanabilirken tersi doğru değil. Bir while döngüsü belirli bir şekilde "daha genel" dir. Ayrıca programcılar kolay anlaşılır kalıpları severler. Bir while döngüsü başlangıçta değişmezinin ne olduğunu söylüyor ve bu güzel bir şey.

İşte "daha genel" şeyle ilgili kastettiğim şey. Bunu yapın ...

do {
 A;
 if (condition) INV=false; 
 B;
} while(INV);

Bunu bir while döngüsüne dönüştürmek basittir:

INV=true;
while(INV) {
 A;
 if (condition) INV=false; 
 B;
}

Şimdi, döngü sırasında bir model alıyoruz:

while(INV) {
     A;
     if (condition) INV=false; 
     B;
}

Ve bunu bir do.. while döngüsüne dönüştürürsek, bu canavarlığı ortaya çıkarır:

if (INV) {
 do
 {
         A;
         if (condition) INV=false; 
         B;

 } while(INV)
}

Şimdi zıt uçlarda iki kontrolümüz var ve eğer değişmezlik değişirse, iki yerde güncellemeniz gerekiyor. Belli bir şekilde, alet kutusundaki özel tornavidalar gibidir, asla kullanmazsınız, çünkü standart tornavida ihtiyacınız olan her şeyi yapar.

Yaklaşık 12 yıl boyunca programlama yapıyorum ve sadece 3 ay önce, bir koşulu kontrol etmeden önce tek bir yineleme her zaman gerekli olduğundan, do-while kullanmanın gerçekten uygun olduğu bir durumla karşılaştım. Öyleyse tahmin et büyük zamanın önde :).

Kullanmadan bu kadar uzun süre nasıl gittiğini hayal edemiyorum do...while döngü .

Şu anda başka bir monitörde bir tane var ve bu programda bu tür birden çok döngü var. Hepsi şu biçimdedir:

do
{
    GetProspectiveResult();
}
while (!ProspectIsGood());

Bir sunucuda / tüketicide oldukça yaygın bir yapıdır:

DOWHILE (no shutdown requested)
   determine timeout
   wait for work(timeout)
   IF (there is work)
      REPEAT
          process
      UNTIL(wait for work(0 timeout) indicates no work)
      do what is supposed to be done at end of busy period.
   ENDIF
ENDDO

REPEAT UNTIL(cond)olmakdo {...} while(!cond)

Bazen iş için bekleme (0) CPU açısından daha ucuz olabilir (hatta zaman aşımı hesaplamasını ortadan kaldırmak bile çok yüksek varış oranlarında bir gelişme olabilir). Dahası, yoğun bir dönemde servis edilen sayıyı önemli bir istatistik yapan birçok kuyruk teorisi sonucu vardır. (Örneğin Kleinrock - Cilt 1'e bakın.)

Benzer şekilde:

DOWHILE (no shutdown requested)
   determine timeout
   wait for work(timeout)
   IF (there is work)
      set throttle
      REPEAT
          process
      UNTIL(--throttle<0 **OR** wait for work(0 timeout) indicates no work)
   ENDIF
   check for and do other (perhaps polled) work.
ENDDO

burada check for and do other workana döngüye koymak aşırı derecede pahalı olabilir veya belki de verimli waitany(waitcontrol*,n)tipte bir işlemi desteklemeyen bir çekirdek veya belki de önceliklendirilmiş bir kuyruğun diğer işi aç bırakabileceği ve kısma açlık kontrolü olarak kullanıldığı bir durum olabilir.

Bu tür bir dengeleme bir hile gibi görünebilir, ancak gerekli olabilir. İş parçacığı havuzlarının kör kullanımı, bir bakıcı iş parçacığı yerine bir iş parçacığı havuzunun kullanılması iş parçacığı güvenli uygulama gerektireceğinden, yüksek güncelleme hızı karmaşık veri yapısı için özel bir kuyruğa sahip bir bekçi iş parçacığının kullanımının performans faydalarını tamamen ortadan kaldıracaktır.

Sözde kod (örneğin, talep edilen kapatmanın UNTIL'de test edilip edilmeyeceği) veya iş parçacığı havuzlarına karşı bakıcı iş parçacığı hakkında bir tartışmaya girmek istemiyorum - bu sadece belirli bir kullanım durumunun bir çeşidini vermek içindir: kontrol akış yapısı.

Bu benim kişisel görüşüm, ancak bu soru, deneyime dayanan bir cevabı gerektiriyor:

• 38 yıldır C ile programlama yapıyorum ve normal kodda asla do/ whiledöngü kullanmıyorum .

• Bu yapının tek zorlayıcı kullanımı, birden çok ifadeyi tek bir ifadeye sarmalayabildiği makrolardır. do { multiple statements } while (0)

• Sahte hata algılama veya gereksiz işlev çağrıları içeren sayısız do/ whiledöngü örneği gördüm .

• Bu gözlem için benim açıklamam, programcıların do/ whiledöngüleri açısından düşündüklerinde problemleri yanlış modelleme eğiliminde olmalarıdır . Ya önemli bir bitiş koşulunu kaçırırlar ya da sonuna kadar taşıdıkları başlangıç ​​koşulunun olası başarısızlığını kaçırırlar.

Bu nedenlerden dolayı, ben inanmak için gelmiş bir olduğu yerde do/ whiledöngü, bir hata var ve ben düzenli bana göstermek için acemi programcıları meydan do/ whileı Yakın bir hata fark edemiyorum döngü.

Bu tür döngüden kolayca kaçınılabilir: a kullanın for (;;) { ... }ve uygun olan yerlerde gerekli sonlandırma testlerini ekleyin. Böyle birden fazla teste ihtiyaç duyulması oldukça yaygındır.

İşte klasik bir örnek:

/* skip the line */
do {
    c = getc(fp);
} while (c != '\n');

Dosya bir satırsonu ile bitmezse bu başarısız olur. Böyle bir dosyanın önemsiz bir örneği boş dosyadır.

Daha iyi bir versiyon şudur:

int c;  // another classic bug is to define c as char.
while ((c = getc(fp)) != EOF && c != '\n')
    continue;

Alternatif olarak, bu sürüm cdeğişkeni de gizler :

for (;;) {
    int c = getc(fp);
    if (c == EOF || c == '\n')
        break;
}

while (c != '\n');Herhangi bir arama motorunda aramayı deneyin ve bunun gibi hataları bulacaksınız (24 Haziran 2017'de alındı):

Gelen ftp://ftp.dante.de/tex-archive/biblio/tib/src/streams.c , işlevi getword(stream,p,ignore), bir var do/ whileen az 2 böcek ve emin yeterli:

• cbir charve olarak tanımlanır
• potansiyel bir sonsuz döngü var while (c!='\n') c=getc(stream);

Sonuç: do/ whiledöngülerden kaçının ve bir tane gördüğünüzde böcek arayın.

whiledöngüler döngüden önceki koşulu, do...whiledöngüler döngüden sonraki koşulu kontrol eder. Bu yararlıdır, koşulu döngüden kaynaklanan yan etkilere dayandırmak veya diğer posterlerin söylediği gibi döngünün en az bir kez çalışmasını istiyorsanız.

Nereden geldiğinizi anlıyorum, ancak do-whilebu en çok nadiren kullanılan bir şey ve kendimi hiç kullanmadım. Yanlış yapmıyorsun.

Yanlış yapmıyorsun. Bu, byteilkel olanı hiç kullanmadıkları için birinin yanlış yaptığını söylemek gibidir . Sadece o kadar yaygın kullanılmıyor.

do/ whileDöngüsünü kullandığım en yaygın senaryo , bazı girdilere göre çalışan ve kullanıcının istediği kadar tekrar eden küçük bir konsol programıdır. Açıkçası, bir konsol programının hiç çalışmaması mantıklı değil; ancak ilk seferin ötesinde bu kullanıcıya bağlı - dolayısıyla do/ whilesadece yerine while.

Bu, kullanıcının istenirse bir dizi farklı girişi denemesine izin verir.

do
{
   int input = GetInt("Enter any integer");
   // Do something with input.
}
while (GetBool("Go again?"));

Yazılım geliştiricilerin bugünlerde do/ whiledaha az ve daha az kullandığından şüpheleniyorum , şimdi pratik olarak güneş altındaki her programın bir çeşit GUI'si var. Talimatlar sağlamak veya kullanıcıya yeni bilgiler sağlamak için çıktıyı sürekli olarak yenilemeye ihtiyaç duyulduğundan, konsol uygulamalarında daha mantıklıdır. Bir GUI ile, aksine, kullanıcıya bu bilgiyi sağlayan metin sadece bir formun üzerine oturabilir ve hiçbir zaman programlı olarak tekrarlanması gerekmez.

Dosyaları okurken her zaman do-while döngüleri kullanıyorum. Başlıkta yorum içeren birçok metin dosyasıyla çalışıyorum:

# some comments
# some more comments
column1 column2
  1.234   5.678
  9.012   3.456
    ...     ...

"column1 column2" satırını okumak için bir do-while döngüsü kullanacağım, böylece ilgilenilen sütunu arayabilirim. Sözde kod şu şekildedir:

do {
    line = read_line();
} while ( line[0] == '#');
/* parse line */

Sonra dosyanın geri kalanını okumak için bir süre döngü yapacağım.

Moruk bir programcı olarak, okul programlama projelerimin çoğu metin menüsü odaklı etkileşimler kullandı. Hemen hemen tümü, ana prosedür için aşağıdaki mantık gibi bir şey kullandı:

do
    display options
    get choice
    perform action appropriate to choice
while choice is something other than exit

Okul günlerinden beri while döngüsünü daha sık kullandığımı fark ettim.

Sonuç setlerine baktığımızda gördüğüm uygulamalardan biri Oracle'da.

Bir sonuç kümesine sahip olduğunuzda, önce ondan (do) ve o noktadan sonra getirme işleminin bir öğe döndürüp döndürmediğini kontrol edin (öğe bulunurken ..) .. Aynısı başka herhangi biri için de geçerli olabilir " getirme benzeri "uygulamalar.

Bunu bir utf-8 dizesinde sonraki karakter konumunu döndüren bir işlevde kullandım:

char *next_utf8_character(const char *txt)
{
    if (!txt || *txt == '\0')
        return txt;

    do {
        txt++;
    } while (((signed char) *txt) < 0 && (((unsigned char) *txt) & 0xc0) == 0xc0)

    return (char *)txt;
}

Bu işlevin akıldan yazıldığını ve test edilmediğini unutmayın. Mesele şu ki, yine de ilk adımı atmanız gerekiyor ve durumu değerlendirmeden önce bunu yapmanız gerekiyor.

Her tür konsol girdisi do-while ile iyi çalışır çünkü ilk seferinde uyarırsınız ve giriş doğrulaması başarısız olduğunda yeniden uyarı verir.

Burada pek çok cevap olmasına rağmen benim fikrim. Her şey, optimizasyona bağlı. Birinin diğerinden daha hızlı olduğu iki örnek göstereceğim.

Dava 1: while

string fileName = string.Empty, fullPath = string.Empty;

while (string.IsNullOrEmpty(fileName) || File.Exists(fullPath))
{
    fileName = Guid.NewGuid().ToString() + fileExtension;
    fullPath = Path.Combine(uploadDirectory, fileName);
}

Durum 2: do while

string fileName = string.Empty, fullPath = string.Empty;

do
{
    fileName = Guid.NewGuid().ToString() + fileExtension;
    fullPath = Path.Combine(uploadDirectory, fileName);
}
while (File.Exists(fullPath));

Yani ikisi aynı şeyi yapacak. Ancak temel bir fark var ve bu while'ın while'a girmek için fazladan bir ifade gerektirmesidir. Bu çirkin, çünkü diyelim ki Guidsınıfın olası her senaryosu, bir varyant dışında zaten alınmış. Bu, birkaç 5,316,911,983,139,663,491,615,228,241,121,400,000kez döngü yapmam gerektiği anlamına gelir . While ifademin sonuna her geldiğimde string.IsNullOrEmpty(fileName)kontrolü yapmam gerekecek . Yani bu biraz zaman alır, CPU işinin çok küçük bir kısmı. Ancak bu çok küçük görev, Guidsınıfın sahip olduğu olası kombinasyonları ve saatlerden, günlerden, aylardan veya fazladan zamandan bahsettiğimizle mi çarpıyor?

Elbette bu uç bir örnek çünkü muhtemelen bunu üretimde göremezsiniz. Ancak YouTube algoritması hakkında düşünecek olursak, bazı kimliklerin zaten alınmış olduğu bir kimliğin oluşturulmasıyla karşılaşmaları çok olasıdır. Bu yüzden büyük projeler ve optimizasyon söz konusudur.

Bu ikisini şu şekilde anlamayı seviyorum:
while-> 'kadar tekrarla',
do ... while-> 'eğer tekrarla'.

Sahip olduğum bir durumda kullanmak için uygun döngüyü araştırırken bununla karşılaştım. Bunun, bir do .. while döngüsünün bir while döngüsünden daha iyi bir uygulama olduğu yaygın bir durumu tamamen tatmin edeceğine inanıyorum (C # dili, çünkü bunun iş için birincil olduğunu belirttin).

Bir SQL sorgusunun sonuçlarına göre bir dizi listesi oluşturuyorum. Sorgum tarafından döndürülen nesne bir SQLDataReader. Bu nesne, nesneyi sonraki veri satırına ilerleten ve başka bir satır varsa true döndüren Read () adında bir işleve sahiptir. Başka bir satır yoksa yanlış döndürür.

Bu bilgiyi kullanarak, her satırı bir listeye döndürmek, ardından döndürülecek daha fazla veri kalmadığında durmak istiyorum. Bir Do ... While döngüsü bu durumda en iyi sonucu verir, çünkü listeye bir öğe eklemenin başka bir satır olup olmadığını kontrol etmeden ÖNCE gerçekleşmesini sağlar. Bunun while (koşul) 'u kontrol etmeden ÖNCE yapılması gerekmesinin nedeni, kontrol ettiğinde aynı zamanda ilerlemesidir. Bu durumda bir while döngüsünün kullanılması, söz konusu işlevin doğası gereği ilk satırı atlamasına neden olur.

Kısacası:

Bu benim durumumda işe yaramayacak.

    //This will skip the first row because Read() returns true after advancing.
    while (_read.NextResult())
           {
               list.Add(_read.GetValue(0).ToString());
           }

   return list;

Bu irade.

    //This will make sure the currently read row is added before advancing.
    do
        {
            list.Add(_read.GetValue(0).ToString());
        } 
        while (_read.NextResult());

    return list;

Console.WriteLine("hoeveel keer moet je de zin schrijven?");
        int aantal = Convert.ToInt32(Console.ReadLine());
        int counter = 0;

        while ( counter <= aantal)
        {
            Console.WriteLine("Ik mag geen stiften gooien");
            counter = counter + 1;