ოპერატორები WHILE, DO/WHILE - ციკლი პირობით
            პროგრამირებაში ხშირია შემთხვევები, როცა  ციკლის განმეორებათა რიცხვი წინაწარ უცნობია. ამ დროს for ციკლის გამოყენება არაეფექტურია და მის ნაცვლად გამოიყენება კონსტრუქცია while ან do/while. მათი ჩაწერის სინტაქსია:

while (პირობა) {
ციკლის ტანი
}	

do{
ციკლის ტანი
} while (პირობა);

ამ ორ კონსტრუქციას შორის ერთადერთი განსხვავებაა: while ციკლში ჯერ მოწმდება პირობა და მისი ჭეშმარიტების შემთხვევაში სრულდება ციკლის ტანი, ხოლო do/while ციკლში ციკლის ტანი ერთხელ მაინც სრულდება, თუნდაც პირობა მცდარი იყოს. სხვაგვარად რომ ვთქვათ, პირობა მოწმდება ციკლის ბოლოს და თუ ის მცდარია, პროგრამა გამოდის ციკლიდან და ასრულებს მის მომდევნო ოპერატორს.
სხვა ყველა თვისება ამ ციკლებს ერთნაირი აქვთ. ციკლის ტანში უნდა ხდებოდეს რაიმე ისეთი ქმედება, რომ პირობა გარკვეულ მომენტში დაირღვეს. წინააღმდეგ შემთხვევაში პროგრამა ჩაიციკლება. თუ ციკლის ტანი ერთზე მეტ ოპერატორს შეიცავს, აუცილებელია მისი მოთავსება ფიგურულ ფრჩხილებში.

ამოცანა 66. ციფრთა ჯამი
მოცემულია მთელი რიცხვი N (1<N<2,000,000,000). დაწერეთ პროგრამა, რომელიც გამოთვლის მის ციფრთა ჯამს.
შესატანი მონაცემები: ერთადერთ სტრიქონში მოცემულია ერთი მთელი რიცხვი N .
გამოსატანი მონაცემები: ერთადერთ სტრიქონში გამოიტანეთ ერთი მთელი რიცხვი – N–ის ციფრთა ჯამი.

შემავალი მონაცემების მაგალითი	    შესაბამისი გამომავალი მონაცემი
234543082                                               	31

ანალიზი. 10-ზე გაყოფის ნაშთით შეგვიძლია გავიგოთ რიცხვის ერთეულთა თანრიგში მდგომი ციფრი და დავუმატოთ ის რაიმე ცვლადს. ამის შემდეგ 10–ზე მთელი გაყოფით ეს ციფრი შეიძლება მოვაშოროთ რიცხვს და პროცესი გავიმეოროთ მანამ, ვიდრე საწყისი რიცხვი 0 არ გახდება. 
#include <iostream>
using namespace std;
int a,c,i;
main(){
 cin>>a;
  while(a>0){
      c=c+a%10;
      a=a/10;   }
  cout<<c;
}
ამოცანა 67. 3*N+1
ნატურალურ რიცხვ N-ისათვის აწარმოებენ შემდეგ ორ ოპერაციას: ა) თუ რიცხვი ლუწია, ჰყოფენ 2-ზე. ბ) თუ რიცხვი კენტია, ამრავლებენ 3-ზე და უმატებენ ერთს. შემდეგ იგივე ოპერაციას იმეორებენ მიღებულ რიცხვზე მანამ, ვიდრე რომელიმე ოპერაციის შემდეგ 1-ს არ მიიღებენ (მათემატიკურად დამტკიცებულია, რომ 1 ნებისმიერი ნატურალური რიცხვისაგან დაწყების შემთხვევაში მიიღება). დაწერეთ პროგრამა, რომელიც პირველ სტრიქონში გამოიტანს ზემოთ ნაჩვენები პროცესის დროს მიღებულ ყველა რიცხვს, ხოლო მეორეში - შესრულებულ  ოპერაციათა რაოდენობას.
შესატანი მონაცემები: ერთი მთელი რიცხვი N (0<N<30000).
გამოსატანი მონაცემები: პირველ სტრიქონში გამოიტანეთ იმ რიცხვთა მიმდევრობა, რომლებიც მიიღებიან ვიდრე საწყისი რიცხვი 1 არ გახდება. მეორე სტრიქონში გამოიტანეთ ერთი მთელი რიცხვი – პირველ სტრიქონში გამოტანილ რიცხვთა რაოდენობა.

შემავალი მონაცემების მაგალითი	               შესაბამისი გამომავალი მონაცემი
23	                                                                 70  35  106  53  160  80  40  20  10  5  16  8  4  2  1
                                                                         15

ანალიზი. სხვადასხვა რიცხვისათვის ჩასატარებელი ოპერაციების რაოდენობა სხვადასხვა იქნება. ამიტომ for ოპერატორით ამ ამოცანის ამოხსნა პრობლემებს შექმნის. შევასრულოთ ციკლი მანამ, ვიდრე შემომავალი რიცხვი 1–ის ტოლი არ გახდება. N–ის მიმდინარე მნიშვნელობები ციკლის შიგნით დავბეჭდოთ, ხოლო ჩატარებული ოპერაციების რაოდენობა, რომელსაც ამოცანაში k ცვლადი ითვლის, – ციკლის გარეთ.

#include <iostream> 
using namespace std;
int n,k=0;
int main (){
        cin>>n;
        while (n>1){
            k++;
            if(n%2==0)n=n/2; else n=3*n+1;
            cout<<n<<“ “;  }
        cout<<k;
}

ამოცანა 68. უახლოესი 2–ის ხარისხები
დაწერეთ პროგრამა, რომელიც  მოცემული მთელი N (0<N<30000) რიცხვისთვის გამოიტანს 2–ის უახლოეს ორ ხარისხს: ნაკლებობით და მეტობით.
შესატანი მონაცემები: ერთადერთ სტრიქონში მოცემულია ერთი მთელი რიცხვი N, რომელიც არ წარმოადგენს 2–ის ხარისხს.
გამოსატანი მონაცემები: ერთადერთ სტრიქონში გამოიტანეთ ორი მთელი რიცხვი – N–ის უახლოესი 2–ის ხარისხები ზრდადობით დალაგებული.

შემავალი მონაცემების მაგალითი	     შესაბამისი გამომავალი მონაცემი
27	                                                      16  32

ანალიზი. რაიმე ცვლადს (ვთქვათ, c–ს) მივანიჭოთ 1 და ციკლში მანამდე ვამრავლოთ 2–ზე, ვიდრე ის შემოსატან რიცხვზე მეტი არ გახდება. ციკლის დასრულების შემდეგ c–ს ექნება გამოსატანი ორი რიცხვიდან უდიდესის მნიშვნელობა. სიდიდით ნაკლები 2–ის ხარისხი კი მიიღება c–ს ორზე გაყოფით.

#include <iostream>
using namespace std;
int a,c=1;
main(){
 cin>>a;
  while(a>c){
       c=c*2; }
  cout<<c/2<<”  “<<c;
}

ამოცანა 69. 2–ის ხარისხების ჯამი
ცნობილია, რომ ნებისმიერი მთელი რიცხვი შეიძლება წარმოვადგინოთ როგორც 2–ის ხარისხების ჯამი. დაწერეთ პროგრამა, რომელიც  მოცემული მთელი N (0<N<30000) რიცხვისთვის გამოიტანს კლებადობით დალაგებულ შესაბამის 2–ის ხარისხებს.
შესატანი მონაცემები: ერთადერთ სტრიქონში მოცემულია ერთი მთელი რიცხვი N .
გამოსატანი მონაცემები: ერთადერთ სტრიქონში გამოიტანეთ შესაბამისი 2–ის ხარისხები.

შემავალი მონაცემების მაგალითი	     შესაბამისი გამომავალი მონაცემი
62	                                                       32  16  8  4  2
128	                                                       128
1057	                                                       1024  32  1
     
ანალიზი. ზოგადად ეს ამოცანა უკავშირდება მოცემული რიცხვის ორობით სისტემაში გადაყვანას (იხ. თავი „თვლის სისტემები“) და იგი ეფექტურად იხსნება რეკურსიული ალგორითმებით, თუმცა შესაძლებელია სხვაგვარი მიდგომის გამოყენებაც. ციკლით ვიპოვოთ მოცემულ რიცხვზე ნაკლები უახლოესი 2–ის ხარისხი. ამის შემდეგ გავხსნათ მეორე ციკლი და ვიდრე მოცემული რიცხვი 0 არ გახდება, გამოვაკლოთ მას 2–ის ის ხარისხები, რომლებიც ციკლის შესაბამის ბიჯზე მოცემულ რიცხვზე ნაკლები აღმოჩნდება.  
#include <iostream>
using namespace std;
int a,c=1;
main(){
 cin>>a;
  while(a>=c){ c=c*2;}
  c=c/2;
  while(a>0){
  if (a>=c) {a=a-c;  cout<<c/2;       }
}

ამოცანა 70.  სუპერკენგურუ
(საქართველოს მოსწავლეთა ოლიმპიადა, რეგიონული ტური)
ხელოვნური ინტელექტის პრობლემებზე მომუშავე მეცნიერებმა შექმნეს კენგურუს ინტელექტის დონის მქონე რობოტი, რომელსაც სახელად “სუპერკენგურუ” დაარქვეს. კენგურუს ანალოგიით მისი მოძრაობის ალგორითმი აგებულია ნახტომებზე. ამასთან, მიზნისაკენ მიმავალ გზას იგი განიხილავს რიცხვით ღერძად, რომლის ნულოვან წერტილში თავად დგას, ხოლო მიზანი განთავსებულია N-ურ წერტილში. სუპერკენგურუ მიზნისაკენ მოძრაობს წრფივად, წარმოსახვითი რიცხვითი ღერძის გასწვრივ. პირველი ნახტომის სიგრძე 1 ერთეულია, ხოლო ყოველი მომდევნო ნახტომის სიგრძე წინაზე ორჯერ მეტია. თუკი მორიგი ნახტომის დროს სუპერკენგურუ გადაახტა მიზანს, მაშინ ის იცვლის მიმართულებას 180 გრადუსით და თავიდან იწყებს ნახტომების კეთებას, ანუ ჯერ ხტება 1 ერთეულზე, მერე 2, 4, 8 და ა.შ. მიზანი მიღწეულად ითვლება მხოლოდ მაშინ, როდესაც სუპერკენგურუ მოხვდება N-ურ წერტილში.
დაწერეთ პროგრამა, რომელიც მოცემული N რიცხვისათვის (0<=N<=1,000,000,000), გამოთვლის მიზნამდე მისასვლელ ნახტომების რაოდენობას.
შესატანი მონაცემები: ერთადერთ სტრიქონში ერთი მთელი N რიცხვი – მანძილი სუპერკენგურუსა და მიზანს შორის. 
გამოსატანი მონაცემები: ერთადერთ სტრიქონში იწერება ერთადერთი რიცხვი – ნახტომების რაოდენობა. 
შემავალი მონაცემების მაგალითი	                შესაბამისი გამომავალი მონაცემი
11	                                                                    9
განმარტება. რიცხვით ღერძზე სუპერკენგურუს მიერ განვლილი წერტილებია:
0, 1, 3, 7, 15, 14, 12, 8, 9, 11 – სულ 9 ნახტომი.
ანალიზი. ამოცანაში ერთგვარ სირთულეს ჰქმნის ის ფაქტი, რომ ნახტომები ორი სხვადასხვა მიმართულებით სრულდება და კენგურუს მდებარეობის კოორდინატი ზოგჯერ იზრდება, ხოლო ზოგჯერ – მცირდება. რადგან კენგურუ მიზანზე გადახტომის შემთხვევაში ხტომებს კვლავ ერთეულოვანი ნახტომით იწყებს, შეგვიძლია ჩავთვალოთ მისი კოორდინატი კვლავ 0–ია, ხოლო დაშორება მიზნამდე ჩავთვალოთ ახალი მიზნის კოორდინატად. მეტი სიცხადისათვის განვიხილოთ ზემოთ მოყვანილი მაგალითი. მეოთხე ნახტომით კენგურუ გადაახტება მიზანს და აღმოჩნდება წერტილში კოორდინატით 15. მისი დაშორება მიზნამდე გახდა 4. ეს ნიშნავს, რომ შეგვიძლია კენგურუ შეგვიძლია წარმოვიდგინოთ ნულოვან წერტილში, ხოლო მიზანი წარმოვიდგინოთ  წერტილში 4 (უკვე შესრულებული ნახტომების რაოდენობა, ცხადია, დავიმახსოვროთ).
#include <iostream>
    using namespace std;
int a,c=1,x=0,ans;
main(){
cin>>a;
  while(a>0){
       ans++; x=x+c; c=c*2;
       if(x>=a) {a=x-a; x=0;c=1;}
  }
cout<<ans;
}

ამოცანა 71. მარტივი მამრავლები
დაწერეთ პროგრამა, რომელიც მოცემული  მთელი N (1 < N < 30000) რიცხვისათვის  გამოიტანს ზრდადობით დალაგებულ მის ყველა მარტივ მამრავლს.
შესატანი მონაცემები: ერთადერთ სტრიქონში ერთი მთელი რიცხვი – N.
გამოსატანი მონაცემები: ერთადერთ სტრიქონში გამოიტანეთ ზრდადობით დალაგებული  N–ის ყველა მარტივ მამრავლი, რომლებიც ჰარით იქნებიან გაყოფილი.  

შემავალი მონაცემების მაგალითი	           შესაბამისი გამომავალი მონაცემი
140	                                                                2  2  5  7
13	                                                                13
8	                                                                2  2  2

ანალიზი. დიდი რიცხვებისათვის ეს ამოცანა არცთუ ტრივიალურია, მაგრამ ჩვენს შემთხვევაში მითითებული დიაპაზონი საშუალებას იძლევა ასეთი ალგორითმი გამოვიყენოთ: დავიწყოთ უმცირესი შესაძლო გამყოფიდან – 2–დან და ვიდრე მოცემული რიცხვი 2–ზე იყოფა, დავბეჭდოთ 2, ხოლო მოცემული რიცხვი შევამციროთ 2–ჯერ. თუკი რიცხვი უნაშთოდ აღარ იყოფა 2–ზე, გამყოფი გავზარდოთ 1–ით და იგივე გავიმეოროთ ვიდრე შემომავალი რიცხვი ერთის ტოლი არ გახდება. 
#include <iostream>
using namespace std;
int a,c=2;
main(){
 cin>>a;
  while(a>1){
     if (a%c==0) {a=a/c;  cout<<c<<” “;}
     else c++;       
  }
}
ამოცანა 72. მიკრობები.
http://codeforces.com/problemset/problem/198/A
რეინჯერმა იცუკენმა მიიღო მორიგი სამთავრობო დავალება და გაემგზავრა პლანეტა მარსზე, სადაც უნდა ჩაატაროს ცდები იქაურ ბაქტერიებზე, რომლებსაც ფრიად უცნაური თვისებები აღმოაჩნდათ. პირველი ცდის დაწყებისას სინჯარაში მხოლოდ ერთი ბაქტერიაა. წამის განმავლობაში თითოეული ბაქტერია იყოფა k ბაქტერიად, რის შემდეგაც ანომალიური ეფექტების შედგად სინჯარაში ჩნდება კიდევ b ბაქტერია. ამრიგად, თუკი რომელიმე წამის დასაწყისში სინჯარაში იყო x ცალი ბაქტერია, ამ წამის დასრულებისას იარსებებს  k*x + b ცალი ბაქტერია. ცდებმა აჩვენეს, რომ n წამის შემდეგ ბაქტერიების რაოდენობა გახდება ზუსტად  z ცალი და ამით ცდა დასრულებულად ითვლება.
მეორე ცდის დაწყების წინ სინჯარას უტარდება დეზინფექცია და ამის შემდეგ მასში თავსდება t ცალი ბაქტერია. იცუკენს აინტერესებს, რამდენი წამის შემდეგ გახდება ბაქტერიების რაოდენობა z–ზე არანაკლები. ბაქტერიები მეორე ცდის დროსაც იმავე პრინციპით მრავლდებიან, როგორც პირველი ცდისას.
დაეხმარეთ იცუკენს და დაადგინეთ წამთა მინიმალური რაოდენობა, რომლის შემდეგაც  ბაქტერიების რაოდენობა გახდება z–ზე არანაკლები.
შესატანი მონაცემები: ერთადერთ სტრიქონში მოცემულია ოთხი მთელი რიცხვი – შესაბამისად, k, b, n და t (1 ≤ k, b, n, t ≤ 106)
გამოსატანი მონაცემები: ერთი მთელი რიცხვი: წამთა მინიმალური რაოდენობა, რომლის შემდეგაც  ბაქტერიების რაოდენობა გახდება z–ზე არანაკლები.
შემავალი მონაცემების მაგალითი	   შესაბამისი გამომავალი მონაცემი
3 1 3 5	                                               2
1 4 4 7	                                               3
2 2 4 100	                                               0
ანალიზი. რადგან  z მილიონს არ აღემატება, საკმარისია მოხდეს პროცესის სიმულაცია.
#include <iostream>
using namespace std;
main(){
    int n,t,k,b,j=0;
    cin>>k>>b>>n>>t;
    long long l=1;
    while (l<=t) {l*=k; l+=b; j++;    }
    j--;
    if (n>j) cout<<n-j; else cout<<0;
}