obrazek

Prezentowane materiały są przeznaczone dla uczniów szkół ponadgimnazjalnych.
Autor artykułu: mgr Jerzy Wałaszek, wersja1.0

obrazek

Pomoce:

Instalacja Code Blocks i tworzenie projektu aplikacji konsoli.
Struktura programu w języku C++
Zmienne i strumienie w języku C++
Instrukcja warunkowa w języku C++

Tworzenie pętli w języku C++

Pętla (ang. loop) jest instrukcją złożoną, która pozwala cyklicznie wykonywać zadaną instrukcję języka C++. Pętla warunkowa (ang. conditional loop) wykonuje powtarzanie w zależności od określonego warunku (takiego samego jak dla instrukcji warunkowej if). W języku C++ wyróżniamy dwie instrukcje pętli warunkowych:

while(warunek) instrukcja;

lub

while(warunek)

    {

ciąg instrukcji }

Instrukcja wewnątrz pętli jest wykonywana dopóki warunek kontynuacji w instrukcji while jest prawdziwy. Warunek ten jest sprawdzany na początku każdego obiegu. Jeśli będzie fałszywy, to obieg nie zostanie wykonany i program przejdzie do wykonywania dalszej części swojego kodu za instrukcją while. Wynika z tego wniosek, że jeżeli warunek jest fałszywy przy rozpoczęciu wykonywania pętli, to zawarta w niej instrukcja nie zostanie wykonana ani jeden raz.

do instrukcja; while(warunek);

lub

do { ciąg instrukcji } while(warunek); Działanie tej pętli jest podobne do powyższej pętli while. Różnica polega jedynie na tym, iż warunek jest tutaj sprawdzany na końcu obiegu. Jeśli będzie prawdziwy, to pętla wykona następny obieg - zostanie powtórzone wykonanie zawartej w niej instrukcji. Jeśli warunek będzie fałszywy, to wykonanie pętli zostanie przerwane i program przejdzie do instrukcji leżących pod pętlą do while. Wynika z tego wniosek, że pętla do while zawsze wykonuje co najmniej jeden obieg.

// Kolejne liczby naturalne
// od 1 do granicy g
// (C)2010 I LO w Tarnowie
//------------------------

#include <iostream>

using namespace std;

int main()
{
    unsigned int i,g;

    cin >> g;
    i = 1;

    while(i <= g) cout << i++ << " ";

    cout << endl;
    return 0;
}

// Kolejne liczby naturalne
// od 1 do granicy g
// (C)2010 I LO w Tarnowie
//------------------------

#include <iostream>

using namespace std;

int main()
{
    unsigned int i,g;

    cin >> g;
    i = 1;

    do cout << i++ << " "; while(i <= g); 

    cout << endl;
    return 0;
}

Ćwiczenia

Zmodyfikuj program (obie wersje), aby otrzymywać:

Liczby nieparzyste.
Liczby parzyste.
Liczby podzielne przez 3.
Kolejne potęgi 2.
Sumy kolejnych liczb naturalnych.
Kolejne liczby Fibonacciego.

Instrukcje break i continue

Instrukcja break natychmiast przerywa wykonywanie pętli. Wykorzystuje się ją w sytuacji, gdy dalsze powtarzanie wykonywania instrukcji w pętli jest z pewnych względów niepożądane.
Instrukcja continue przerywa bieżący obieg pętli i natychmiast rozpoczyna następny obieg. Wykorzystuje się ją w przypadku, gdy wykonywanie instrukcji w bieżącym obiegu jest niepożądane.

// Tajny kod autoryzacji
// (C)2010 I LO w Tarnowie
//------------------------

#include <iostream>

using namespace std;

const int kod = 831;

int main()
{
    int i,c;

    cout << "SYSTEM RG 2221/10F\n\n";

    i = 1;

    do
    {
        cout << "WPISZ KOD : ";
        cin >> c;
        if(c == kod) break;
        i++;
    } while(i <= 3);

    if(c == kod)
    {
        cout << "KOD ZAAKCEPTOWANY.\n\n";
        return 0;
    }
    else
    {
        cout << "BRAK AUTORYZACJI.\n\n";
        return 1;
    }
}

Instrukcja pętli iteracyjnej

Obiegi wykonywane przez pętlę można numerować. Obieg numerowany nazywamy iteracją. Iteracja wymaga dodatkowej zmiennej, która przechowuje numer wykonywanego przez pętlę obiegu. Zmienna ta nosi nazwę licznika pętli (ang. loop counter). Pętlę iteracyjną możemy utworzyć przy pomocy poznanych dotychczas pętli warunkowych.

Przykład:

Poniższe pętle wykonują 10 obiegów. Obiegi zliczane są przez zmienną i, która pełni tutaj rolę licznika pętli.

...
i = 1;
while(i <= 10)
{
    cout << i << endl;     
    i++;
}
...

...
i = 1;
do
{
    cout << i << endl;
    i++;
} while(i <= 10);
...

Ponieważ pętle iteracyjne pojawiają się w programach bardzo często, w języku C++ istnieje specjalna instrukcja do ich łatwej realizacji. Składnia tej instrukcji jest następująca:

for(prolog; kontynuacja; epilog) instrukcja;

lub z instrukcją złożoną:

for(prolog; kontynuacja; epilog) { Ciąg instrukcji; }

prolog	-	instrukcja wykonywana przed rozpoczęciem pierwszej iteracji. Najczęściej służy do inicjalizacji licznika pętli. Przykład: `for(i = 1;...`
kontynuacja	-	warunek kontynuacji pętli. Jeśli wyrażenie to ma wartość różną od 0, to pętla wykona obieg. Warunek jest sprawdzany na początku każdej iteracji. Przykład: `for(i = 1; i <= 10;...`
epilog	-	instrukcja wykonywana po zakończeniu każdej iteracji. Najczęściej wykorzystuje się ją do modyfikacji licznika pętli. Przykład: `for(i = 1; i <= 10; i++)...`
instrukcja	-	instrukcja powtarzana w każdej iteracji pętli. Przykład: `for(i = 1; i <= 10; i++) cout << i << endl;`

Przykłady różnych pętli iteracyjnych

W poniższych przykładach zakładamy, iż wszystkie niezbędne zmienne zostały wcześniej odpowiednio zadeklarowane.

Pętla wypisuje kolejne liczby całkowite od 1 do 10:

for(i = 1; i <= 10; i++) cout << i << endl;

Pętla wypisuje liczby od 10 do 1 w kierunku odwrotnym:

for(i = 10; i >= 1; i--) cout << i << endl;

Pętla wypisuje kolejne liczby parzyste od 4 do 26:

for(i = 4; i <= 26; i += 2) cout << i << endl;

Zagnieżdżone pętle iteracyjne

Poniższy fragment programu wypisuje wiersz zbudowany z 20 znaków X:

for(i = 0; i < 20; i++) cout << "X"; cout << endl;

Jeśli powtórzymy ten fragment programu 20 razy, to otrzymamy kwadrat z literek X. Instrukcją powtarzaną w pętli może być druga pętla - otrzymamy wtedy układ zagnieżdżony:

for(j = 0; j < 20; j++) { for(i = 0; i < 20; i++) cout << "X"; cout << endl; }

Pętla wewnętrzna jest sterowana zmienną i. Jej zadaniem jest wyświetlenie jednego wiersza 20 znaków X. Pętla ta jest powtarzana 20 razy przez pętlę zewnętrzną sterowaną zmienną j. W efekcie w oknie konsoli pojawia się 20 wierszy, każdy zbudowany z 20 literek X:

W pętlach zagnieżdżonych muszą być stosowane różne zmienne liczników pętli.

Jeśli ilość wykonań pętli wewnętrznej uzależnimy od numeru obiegu pętli zewnętrznej, to otrzymamy trójkąt:

for(j = 0; j < 20; j++) { for(i = 0; i <= j; i++) cout << "X"; cout << endl; }

Zastanów się, jak zmienić podane pętle, aby uzyskać następujące wydruki w oknie konsoli:

                   XX
                  XXXX
                 XXXXXX
                XXXXXXXX
               XXXXXXXXXX
              XXXXXXXXXXXX
             XXXXXXXXXXXXXX
            XXXXXXXXXXXXXXXX
           XXXXXXXXXXXXXXXXXX
          XXXXXXXXXXXXXXXXXXXX
         XXXXXXXXXXXXXXXXXXXXXX
        XXXXXXXXXXXXXXXXXXXXXXXX
       XXXXXXXXXXXXXXXXXXXXXXXXXX
      XXXXXXXXXXXXXXXXXXXXXXXXXXXX
     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
   XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Utwórz pętle, które tworzą następujące wydruki:

XXXXXXXXXXXXXXXX
X              X
X              X
X              X
X              X
X              X
X              X
X              X
X              X
X              X
X              X
X              X
X              X
X              X
X              X
XXXXXXXXXXXXXXXX

XXXXXXXXXXXXXXXX
XX             X
X X            X
X X           X
X   X          X
X    X         X
X     X        X
X      X       X
X       X      X
X        X     X
X         X    X
X          X   X
X           X X
X            X X
X             XX
XXXXXXXXXXXXXXXX

XXXXXXXXXXXXXXXX
X             XX
X            X X
X           X X
X          X   X
X         X    X
X        X     X
X       X      X
X      X       X
X     X        X
X    X         X
X   X          X
X X           X
X X            X
XX             X
XXXXXXXXXXXXXXXX

XXXXXXXXXXXXXXXX
XX            XX
X X          X X
X X        X X
X   X      X   X
X    X    X    X
X     X X     X
X      XX      X
X      XX      X
X     X X     X
X    X    X    X
X   X      X   X
X X        X X
X X          X X
XX            XX
XXXXXXXXXXXXXXXX

Trójka pitagorejska, to trzy liczby naturalne a, b i c, takie że:

a < b < c i a² + b² = c²

Słynnymi liczbami pitagorejskimi są na przykład liczby 3, 4 i 5. Zadanie sprowadza się do wygenerowania wszystkich trójek liczb a, b i c z przedziału od 1 do n, spełniających warunek

a < b < c:

a - generujemy od 1 do n - 2
b - generujemy od a + 1 do n - 1
c - generujemy od b + 1 do n

Zadanie generacji takich liczb spełnią trzy zagnieżdżone pętle iteracyjne, Następnie sprawdzamy w najbardziej wewnętrznej pętli, czy liczby te spełniają warunek trójki pitagorejskiej:

a² + b² = c²

Jeśli tak, to znalezioną trójkę wypisujemy.

// Trójki pitagorejskie
// (C)2010 I LO w Tarnowie
//------------------------

#include <iostream>

using namespace std;


int main()
{
    int a,b,c,n;

    cin >> n;  // odczytujemy zakres

    for(a = 1; a <= n - 2; a++)
        for(b = a + 1; b <= n - 1; b++)
            for(c = b + 1; c <= n; c++)
                if(a*a + b*b == c*c) cout << a << " " << b << " " << c << endl;
    return 0;
}

Z każdej trójki pitagorejskiej można utworzyć trójkę pochodną przemnażając tworzące je liczby przez liczbę naturalną k = 2,3...

Dowód jest bardzo prosty:

Jeśli a, b i c jest trójką pitagorejską, to zachodzi związek a² + b² = c². Przyjmijmy:

a' = ak, b' = bk, c' =ck

(a')² + (b')² = (ak)² + (bk)² = a²k² + b²k² = (a² + b²)k² = c²k² = (ck)² = (c')²

Czyli a', b' i c' również jest trójką pitagorejską. Trójkę pitagorejską będziemy nazywali pierwotną, jeśli nie jest wielokrotnością innej trójki pitagorejskiej. W tym przypadku wystarczy sprawdzić, czy NWD(a,b,c) = 1. Jeśli tak, to trójka jest pierwotna.

Zmodyfikuj powyższy program, tak aby wyświetlał jedynie pierwotne trójki pitagorejskie.

Dokument ten rozpowszechniany jest zgodnie z zasadami licencji
GNU Free Documentation License.

Pytania proszę przesyłać na adres email: i-lo@eduinf.waw.pl

W artykułach serwisu są używane cookies. Jeśli nie chcesz ich otrzymywać,
zablokuj je w swojej przeglądarce.
Informacje dodatkowe