ორმაგი ციკლი
            ორმაგი ციკლი, ანუ ერთი ციკლის შიგნით მეორე ციკლის ჩადგმა ხშირად არის საჭირო სხვადასხვა ტიპის ამოცანების ამოხსნისას. პირველ მათგანს გარე ციკლს უწოდებენ, ხოლო მეორეს (ჩადგმულს) – შიგა ციკლს. ასეთი კონსტრუქციის გამოყენებას რაიმე პრინციპული თავისებურება არ გააჩნია, მაგრამ გამოცდილების მიღებამდე არცთუ იშვიათად ხდება შეცდომების მიზეზი, ამიტომ ღირს ამ საკითხზე ყურადღების გამახვილება. განვიხილოთ ორმაგი ციკლის მარტივი კოდი:
	for (i = 1; i <= 2; i++){
		for ( j = 5; j <= 7; j++) {
			printf(“%d %d”,i,j);  }   }
პროგრამა ეკრანზე გამოიტანს:
1 5
1 6
1 7
2 5
2 6
2 7
 ზოგადად რომ ვთქვათ, გარე ციკლის თითო ბიჯზე (იტერაციაზე) შიგა ციკლი მთლიანად სრულდება. საბოლოოდ, გარე ციკლი მხოლოდ ერთხელ სრულდება, ხოლო შიგა ციკლი იმდენჯერ სრულდება, რამდენჯერაც შეიცვლის მნიშვნელობას გარე ციკლის ცვლადი.
ყველაზე ხშირად შეცდომებამდე მივყავართ გარე და შიგა ციკლებში ერთ და იმავე ციკლის ცვლადთა გამოყენებას.

ამოცანა 86. დახატეთ მართკუთხედი.
დაწერეთ პროგრამა, რომელიც მოცემული  ორი მთელი A და B (1 < A, B < 20) რიცხვისათვის “*” სიმბოლოს საშუალებით გამოიტანს A სიმაღლის და B სიგანის მართკუთხედს.
შესატანი მონაცემები: ჰარით გაყოფილი ორი მთელი რიცხვი – A და B. 
გამოსატანი მონაცემები: შესაბამისი მართკუთხედის გამოსახულება.

შესატანი მონაცემების მაგალითი	    შესაბამისი გამოსატანი მონაცემი
2  4	                                                        ****
                                                                ****

ანალიზი. B ცალი სიმბოლოს ერთ ხაზზე დაბეჭდვა for ციკლით სირთულეს არ წარმოადგენს და ის უნდა განხორციელდეს შიგა ციკლში. გარე ციკლმა შიგა ციკლი უნდა გაიმეოროს A–ჯერ და ამასთან, შიგა ციკლის დასრულების შემდეგ უნდა უზრუნველყოს ახალ სტრიქონზე გადასვლა, წინააღმდეგ შემთხვევაში ყველა სიმბოლო ერთ სტრიქონში დაიბეჭდება.

#include <iostream>
int A,B;
main() {
   cin>>A>> B;
	for (i = 1; i <= A; i++){
		for ( j = 1; j <= B; j++) {
			cout<<”*”;  }  
           cout<<endl; }
}



ამოცანა 87. დახატეთ მართკუთხა სამკუთხედი.
დაწერეთ პროგრამა, რომელიც მოცემული  მთელი N (1 < N < 20) რიცხვისათვის “*” სიმბოლოს საშუალებით გამოიტანს N კათეტის მქონე ტოლფერდა მართკუთხა სამკუთხედს.
შესატანი მონაცემები: ერთი მთელი რიცხვი – N. 
გამოსატანი მონაცემები: შესაბამისი მართკუთხა სამკუთხედის გამოსახულება.

შესატანი მონაცემების მაგალითი	
5	
შესაბამისი გამოსატანი მონაცემი
*
**
***
****
*****

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

#include <iostream>
int A;
main() {
   cin>>A;
	for (i = 1; i <= A; i++){
		for ( j = 1; j <= i; j++) {
			cout<<”*”;  }  
           cout<<endl; }
}

ამოცანა 90. ვახშამი ხუთისათვის
ხორვატიის ღია პირველობა ინფორმატიკაში (2008/09 წელი, შეჯიბრი 3)
პოპულარულ შოუში „ვახშამი ხუთისათვის“ ხუთი მონაწილე ეჯიბრება ერთმანეთს კულინარიულ ხელოვნებაში. ყოველ საღამოს ერთ–ერთი მათგანი ამზადებს ვახშამს, ხოლო დანარჩენი ოთხიდან თითოეული აფასებს მას ქულით 1–დან 5–მდე. მონაწილის საბოლოო შედეგი წარმოადგენს მიღებული ქულების ჯამს. შოუში გამარჯვებულად ითვლება ის მონაწილე, რომელიც ყველაზე მეტ ქულას მოაგროვებს.
დაწერეთ პროგრამა, რომელიც გაარკვევს შოუს გამარჯვებულს და მის მიერ დაგროვებულ ქულებს.
შესატანი მონაცემები: ხუთი სტრიქონიდან თითოეულში მოცემულია ოთხ–ოთხი მთელი რიცხვი. მონაწილეები გადანომრილი არიან 1–დან 5–მდე და თითოეულის ნომერი ემთხვევა სტრიქონის ნომერს. პასუხის ერთადერთობა გარანტირებულია.
გამოსატანი მონაცემები: ჰარით გაყოფილი ორი მთელი რიცხვი: გამარჯვებული მონაწილის ნომერი და მის მიერ მოგროვებული ქულების ჯამი.

შესატანი მონაცემების მაგალითი	       შესაბამისი გამოსატანი მონაცემი
5 4 4 5                                                     4 19
5 4 4 4
5 5 4 4
5 5 5 4
4 4 4 5	

4 4 3 3                                                    2 17
5 4 3 5
5 5 2 4
5 5 5 1
4 4 4 4	
                                 
ანალიზი. ორმაგი ციკლის გარე ციკლში ვცვალოთ მონაწილეთა ნომრები, ხოლო შიგა ციკლში გამოვთვალოთ შესაბამისი მონაწილის ქულათა ჯამი. შიგა ციკლის დასრულების შემდეგ ორ ცვლადში დავიმახსოვროთ საუკეთესო შედეგი და მისი შესაბამისი ნომერი.

#include <iostream>
using namespace std;
int main() {
   int max_score = 0, winner = 0;
   for ( int i=1; i<=5; ++i ) {
      int sum = 0;
      for ( int j=0; j<4; ++j ) {
         int x;
         cin>>x;
         sum += x;
      }
      if ( sum > max_score ) {
         max_score = sum;
         winner = i;
      }
   }
   cout<<winner<<” “<<max_score);
   return 0;
}

ამოცანა 91. ფიფქია და შვიდი ჯუჯა
ხორვატიის ღია პირველობა ინფორმატიკაში (2006/07 წელი, შეჯიბრი 3)
ყოველდღიურად, როდესაც ჯუჯები მაღაროში მუშაობენ, ფიფქია მათთვის ვახშამს ამზადებს:   7 სკამი, 7 თეფში, 7 ჩანგალი და 7 დანა 7 მშიერი ჯუჯისათვის.
ერთ მშვენიერ დღეს მაღაროდან შვიდი ჯუჯის ნაცვლად ცხრა დაბრუნდა (დღესაც კი არავინ იცის, როგორ ან რატომ). ცხრავე მათგანი თავგამოდებით ამტკიცებდა, რომ სწორედ ის იყო ფიფქიას შვიდი ჯუჯიდან ერთ–ერთი.
საბედნიეროდ, ყოველ ჯუჯას ქუდზე აწერია მთელი დადებითი რიცხვი 1–დან 100–მდე. ფიფქიამ კი, როგორც ეს ცნობილ მათემატიკოსს შეეფერება, იცის, რომ მისი ჯუჯების ქუდებზე აღნიშნულ რიცხვთა ჯამი ზუსტად 100–ს შეადგენს.
დაწერეთ პროგრამა, რომელიც დაადგენს ფიფქიას 7 ჯუჯის ვინაობას, ანუ ცხრიდან იმ შვიდ რიცხვს, რომელთა ჯამი 100–ის ტოლია.
შესატანი მონაცემები: ცხრა მთელი რიცხვი, რომელთაგან თითოეული მოთავსებულია დიაპაზონში 1–დან 99–მდე (ჩათვლით). ყველა რიცხვი განსხვავებულია.
შენიშვნა: შესატანი მონაცემები უზრუნველყოფენ პასუხის ერთადერთობას. 
გამოსატანი მონაცემები: ზუსტად შვიდი მთელი რიცხვი – ფიფქიას 7 ჯუჯის ქუდებზე აღნიშნული ნომრები. რიცხვები გამოიტანეთ ნებისმიერი მიმდევრობით.

შესატანი მონაცემების მაგალითი	        შესაბამისი გამოსატანი მონაცემი
7 8 10 13 15 19 20 23 25 	                          7 8 10 13 19 20 23
8 6 5 1 37 30 28 22 36	                                  8 6 5 1 30 28 22

ანალიზი. თუკი ვეცდებით იმ 7–7 რიცხვის გადარჩევას, რომელთა ჯამიც 100–ს იძლევა, მაშინ დაგვჭირდება შვიდმაგი ჩადგმული ციკლი. გაცილებით მარტივი იქნება დავადგინოთ ცხრავე რიცხვის ჯამი და ვცადოთ იმ 2–2 რიცხვის გადარჩევა, რომელთა გამოკლებითაც მიღებულ ჯამზე, 100–ს მივიღებთ. ამის ორგანიზება ორმაგი ციკლითაც შეიძლება.


#include <iostream>
using namespace std;
int main() {
   int broj[9], suma = 0;

   for( int i = 0; i < 9; ++i ) {
      cin>>broj[i];
      suma += broj[i];
   }

   for( int i = 0; i < 9; ++i )
      for( int j = i+1; j < 9; ++j )
         if( suma - broj[i] - broj[j] == 100 )
            for( int k = 0; k < 9; ++k )
               if( k != i && k != j )
                  cout<<broj[k];

}

ამოცანა 92.   ორი ამოცანა
http://codeforces.com/problemset/problem/203/A
პატარა ვალერი Codeforces–ის საიტზე დარეგისტრირდა Valera–ს ნიკით და პირველ შეჯიბრშიც მიიღო მონაწილეობა. მან დაწერა რაუნდი N300 და დაიტრაბახა თავის მეგობარ არკადისთან, რომ პირველივე შეჯიბრში x ქულა მოაგროვა. არკადიმ მას არ დაუჯერა და გადაწყვიტა შეემოწმებინა ვალერის შედეგი. მან იცოდა, რომ რაუნდი N300 განსხვავებული ფორმატით ჩატარდა და სულ 2 ამოცანა იყო ამოსახსნელი. შეჯიბრი გრძელდებოდა  t წუთი, ხოლო წუთები გადანომრილი იყო 0–დან. პირველი ამოცანის საწყისი ფასი იყო a ქულა, ხოლო ყოველი წუთის გასვლის შემდეგ მისი ფასი მცირდებოდა da ქულით. მეორე ამოცანის საწყისი ფასი იყო b ქულა და ყოველი წუთის გასვლის შემდეგ მისი ფასი მცირდებოდა db ქულით. ამრიგად, როცა შეჯიბრის ნულოვანი წუთი დამთავრდება, პირველი ამოცანის ფასი იქნება a-da ქულა, ხოლო მეორე ამოცანის ფასი – b-db ქულა. გარანტირებულია, რომ ამოცანის ფასი ყოველთვის არაუარყოფითი იქნება.
არკადი გთხოვთ თქვენ დაადგინოთ, შეეძლო თუ არა ვალერის აეღო შეჯიბრზე ზუსტად x ქულა. ჩათვალეთ, რომ ვალერის არცერთ ამოცანაზე არ დაუხარჯავს 1 ცდაზე მეტი. ამასთან, ორივე ამოცანისთვის ამოხსნის გაგზავნა მას შეეძლო ერთსა და იმავე წუთს, დაწყებული ნულოვანი წუთიდან და დამთავრებული t-1 წუთით. მიაქციეთ ყურადღება, რომ ამოცანის გაგზავნა შეჯიბრის დაწყებიდან ზუსტად t წუთის შემდეგ შეუძლებელია.
შესატანი მონაცემები: ერთადერთ სტრიქონში მოცემულია ექვსი მთელი რიცხვი, x, t, a, b, da, db (0≤x≤600; 1≤ t, a, b, da, db≤300)  – ვალერის შედეგი, შეჯიბრის ხანგრძლივობა, პირველი ამოცანის საწყისი ფასი, მეორე ამოცანის საწყისი ფასი, ქულების რაოდენობა, რომლითაც მცირდება შესაბამისად პირველი და მეორე ამოცანების ფასები ყოველი წუთის შემდეგ.
გამოსატანი მონაცემები: თუ ვალერის შეეძლო შეჯიბრში ზუსტად x ქულის მოგროვება, გამოიტანეთ YES, წინააღმდეგ შემთხვევაში   – NO.

შესატანი მონაცემების მაგალითი	    შესაბამისი გამოსატანი მონაცემი
30 5 20 20 3 5	                                       YES
10 4 100 5 5 1	                                       NO

განმარტება. პირველ მაგალითში ქულების მოგროვება ასე შეიძლებოდა: პირველი ამოცანა უნდა ჩაბარებულიყო 0 წუთზე, მეორე კი – მეორე წუთზე. მაშინ პირველ ამოცანაში ვალერი მიიღებდა 20 ქულას, მეორეში კი – 10–ს, რაც ჯამში 30 ქულას წარმოადგენს.                                                                                     

ანალიზი. ორმაგი ციკლის საშუალებით გადავარჩიოთ ქულების ყველა შესაძლო ჯამი.

#include <iostream>
using namespace std;
int main(){
int x,t,a,b,da,db;
cin>>x>>t>>a>>b>>da>>db;
for (int i=0;i<t;i++)
 for (int j=0;j<t;j++)
   if ((x==a-i*da+b-j*db)||x==a-i*da||x==b-j*db||x==0) {cout<<"YES";    
              return 0;}
 cout<<"NO";
}

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

შესატანი მონაცემების მაგალითი	  შესაბამისი გამოსატანი მონაცემი
20	                                                      1

ანალიზი. ორმაგი ციკლის საშუალებით გადავარჩიოთ ყველა შესაძლო კვადრატების ჯამი.

#include <iostream>
using namespace std;
int k=0,g,i,j,N;
int main(){
  cin>>N;
  for (i=1; i<N; i++)
    for (j=1; j<N; j++) 
    if (i*i+j*j==N) k++;
   cout<<k;
}