უპირობო ციკლის ოპერატორი FOR
            for ციკლს გააჩნია შემდეგ სინტაქსი: 
            for (ინიციალიზაციის გამოსახულება; პირობის გამოსახულება; ბიჯი) {
              ციკლის ტანი
            }
ციკლის მუშაობის დროს უპირველესად სრულდება ინიციალიზაციის გამოსახულება, ანუ ხორციელდება მნიშვნელობის მინიჭება ცვლადისათვის, რომელსაც ციკლის მთვლელს უწოდებენ. ეს ხდება მხოლოდ ერთხელ - ციკლის დაწყების წინ. ამის შემდეგ ანალიზი უკეთდება პირობის გამოსახულებას, რომელსაც ციკლის შეწყვეტის პირობასაც უწოდებენ. თუ ეს პირობა თავიდანვე მცდარია, ან ციკლის მუშაობის პროცესში გახდება მცდარი, ციკლი აღარ სრულდება და პროგრამა გადადის ციკლის მომდევნო პირველივე ოპერატორზე. თუ ციკლის პირობა ჭეშმარიტია, მაშინ სრულდება ციკლის ტანში ჩაწერილი ოპერატორები, ხოლო ამის შემდეგ ხდება ციკლის მთვლელის გაზრდა (ან შემცირება) ბიჯში მითითებული სიდიდით. თუ ციკლის მთვლელის შეცვლის შემდეგ პირობა ისევ ჭეშმარიტია, ციკლის ტანი კიდევ ერთხელ შესრულდება და ა.შ. პროგრამის მიერ ციკლის ტანის ერთხელ შესრულებას იტერაციას უწოდებენ.
თუ ციკლის ტანი მხოლოდ ერთ ოპერატორს შეიცავს, დასაშვებია, რომ ის არ მოათავსოთ ფიგურულ ფრჩხილებში, ხოლო თუ ციკლის ტანში ოპერატორების რაოდენობა 1-ზე მეტია, ფიგურული ფრჩხილების გამოყენება აუცილებელია. წინააღმდეგ შემთხვევაში ციკლის ტანად ჩაითვლება მხოლოდ ერთი – უახლოესი ოპერატორი.
მოვიყვანოთ for ციკლის ჩაწერის მაგალითი. ვთქვათ, გვინდა 7-ის ჯერადი ორნიშნა რიცხვების გამოტანა ეკრანზე. 7-ის ჯერადი უმცირესი ორნიშნა რიცხვი 14-ია. თუ რაიმე ცვლადს (პროგრმააში ციკლის მთვლელს) მივანიჭებთ 14-ს და შემდეგ მას ყოველ ბიჯზე გავზრდით 7-ით, ცხადია, მივიღებთ ჩვენთვის სასურველ რიცხვებს. ციკლის მთვლელმა არ უნდა გადააჭარბოს უდიდეს ორნიშნა რიცხვს - 99-ს.  პროგრამულ კოდს ექნება სახე :
for (i=14; i<=99; i=i+7)
cout<<i<<” “; 
იგი გამოიტანს: 14 21 28 35 42 49 56 63 70 77 84 91 98.
თუ პირობა ციკლის დაწყებისთანავე დარღვეულია, მაშინ ციკლი საერთოდ არ შესრულდება. მაგალითად, ციკლი 
x=10;
for(y=10; y>x; y++) 
printf("%d ", y);
ერთხელაც არ შესრულდება, რადგან პირობა y>x; თავიდანვე დარღვეულია. მოყვანილ კოდში x=10; ტოლობა საკმარისია შევცვალოთ x=9;–ით, რომ ციკლი მუშაობას დაიწყებს, თუმცა მოხდება მეორე უკიდურესობა: ციკლის შეწყვეტის პირობა აღარასოდეს შესრულდება და როგორც იტყვიან – პროგრამა „ჩაიციკლება“.
უპირობო ციკლის ზოგადი კონსტრუქცია პროგრამირების ყველა ენაში თითქმის ერთნაირია, მაგრამ C++–ში დამატებულია ზოგიერთი ისეთი შესაძლებლობა, რომელიც მას განსაკუთრებით მოქნილს ხდის. მაგალითად, for ციკლში დასაშვებია ერთდოულად რამდენიმე ცვლადის გამოყენება ციკლის ცვლადად. ასეთ შემთხვევაში ოპერატორების გამყოფად მძიმე გამოიყენება:
for(x=0, y=3; x+y<14; x++, y+=2)
მკაცრი შეზღუდვები არ ადევს ციკლის შესრულების პირობასასც. აქ შეიძლება გამოყენებულ იქნას ნებისმიერი სახის ლოგიკური გამოსახულება (რომელშიც შესაძლოა ციკლის ცვლადი საერთოდ არ ფიგურირებდეს). ზოგადად, for ციკლის სამი სექციიდან თითოეულში შესაძლოა განთავსდეს ნებისმიერი სახის სინტაქსურად სწორი გამოსახელება. უფრო მეტიც, ზოგიერთი ან ყველა სექცია შეიძლება საერთოდ ცარიელი იყოს. მაგალითად, ქვემოთ მოყვანილ კოდში ციკლი სრულდება მანამ, ვიდრე მომხმარებელი კლავიატურიდან არ შეიყვანს რიცხვს 16:
for(x=0; x!=16; ) 
scanf("%d", &x);
ბიჯის სექცია აქ უბრალოდ ცარიელია და ციკლის ცვლადის ზრდა არ ხდება. ყოველი იტერაციის წინ მოწმდება პირობა, უდრის თუ არა კლავიატურიდან შეყვანილი რიცხვი 16–ს და რადგან შემოწმება ხდება პირობით „არ უდრის“, 16–ის აკრების შემთხვევაში პირობა გახდება მცდარი და პროგრამა გამოვა ციკლიდან.
ციკლის ცვლადის ინიციალიზაცია შეიძლება for ციკლის დაწყებამდე მოხდეს. ეს განსაკუთრებით მაშინაა საჭირო, როცა ციკლის ცვლადის საწყისი მნიშვნელობა სხვა ცვლადზეა დამოკიდებული. მაგალითად,
if(k==1) x = 24; else x = 10;
for( ; x<10; ) {
  printf("%d", x);
  ++x;
}
უსასრულო ციკლის ორგანიზებისათვის საკმარისია for ოპერატორში სამივე სექცია ცარიელი დავტოვოთ. ცხადია, რომ ასეთი ციკლიდან გამოსასვლელად პროგრამამ გარკვეული მოქმედებები ციკლის ტანში უნდა შეასრულოს. ქვემოთ მოყვანილ კოდში უსასრულო ციკლი შესრულდება მანამ, ვიდრე მომხმრებელი კლავიატურაზე არ აკრებს სიმბოლო 'A'–ს.
for( ; ; ) {
  ch = getchar(); 
  if(ch=='A') break; 
} 
C++–ში შესაძლებელია ცვლადების გამოცხადება უშუალოდ for ციკლის ინიციალიზაციისას. ასეთ შემთხვევაში ცვლადი წარმოადგენს მოცემული ციკლის ლოკალურ ცვლადს და ციკლის გარეთ მისი გამოყენება შეუძლებელია. მაგალითად, კოდში
for(int i = 0; i<10; i++){
      int j = i * i;
  }
  int k=i+ 10;
ბოლო სტრიქონი გამოიწვევს შეცდომის შეტყობინებას, რადგან ციკლის ცვლადი ციკლის შიგნითაა აღწერილი და ციკლის გარე ნაწილი მას ვერ ხედავს.

 
ამოცანა 46. კენტი რიცხვების ჯამი
დაწერეთ პროგრამა, რომელიც  გამოითვლის A-დან  B-მდე ყველა კენტი რიცხვის ჯამს.
შესატანი მონაცემები: ერთადერთ სტრიქონში მოცემულია ჰარით დაშორებული ორი მთელი რიცხვი A და B (0 <= A, B <= 200) .
გამოსატანი მონაცემები: ერთადერთ სტრიქონში გამოიტანეთ ერთი მთელი რიცხვი – A-დან  B-მდე ყველა კენტი რიცხვის ჯამი.
შემავალი მონაცემების მაგალითი	                  შესაბამისი გამომავალი მონაცემი
22  29	                                                                  104

ანალიზი. შეგვიძლია დავწეროთ ციკლი A-დან  B-მდე და თითოეული რიცხვი ამ შუალედიდან შევამოწმოთ ლუწ–კენტობაზე. პროგრამა უფრო სწრაფად იმუშავებს თუ ციკლის ცვლადის საწყის მნიშვნელობად შევარჩევთ პირველ კენტ რიცხვს მოცემული შუალედიდან (ის ან a იქნება, ან a+1). ამის შემდეგ შეგვიძლია ციკლის ცვლადი ვზარდოთ 2-ის ტოლი ბიჯით.

#include <iostream>
int a,b,c,i;
main(){
 cin>>a>>b;
 for (i=a; i<=b; i++)
    if (i%2==1)c=c+i;
 cout<<c;
}	

#include <iostream>
int a,b,c,i,k;
main(){
 cin>>a>>b;
 if (a%2==1) k=a; else k=a+1;
 for (i=k; i<=b; i=i+2)
     c=c+i;
 cout<<c;
}

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

შემავალი მონაცემების მაგალითი	    შესაბამისი გამომავალი მონაცემი
36	                                                      9
13	                                                      2
25	                                                      3

განმარტება: 36-ის გამყოფებია - 1, 2, 3, 4, 6, 9, 12, 18, 36. სულ მათი რაოდენობაა 9.  25-ის გამყოფებია - 1, 5, 25.

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

#include <iostream>
int a,c,i;
main(){
 cin>>a;
 for (i=1; i<= a; i++)
     if (a%i==1)c++;
 cout<<c;
}

ამოცანა 48. Bedtime Reading - ძილის წინ საკითხავი
USACO 2006 წლის USA OPEN, “ბრინჯაოს” დივიზიონი
ფერმერი ჯონი ასრულებს თავის მოვალეობას: ძილის წინ წიგნები წაუკითხოს ბესის.
'ოჰ, ეს მე თავს მტკენს' - წუწუნებს ბესი. 'ეს ხომ უბრალო რიცხვთა თეორიაა' - პასუხობს ჯონი - 'მოდი გავიაროთ კიდევ ერთხელ. რიცხვის სიგმა ფუნქცია არის ამ რიცხვის გამყოფების ჯამი. მაგალითად, 12-ის გამყოფებია: 1, 2, 3, 4, 6 და 12. ამ რიცხვების შეკრებით მიიღება 28. სულ ეს არის' - კითხულობას ბესი – 'იქნებ ვინმემ დაწეროს პროგრამა, რომელიც იპოვის სიგმა ფუნქციას რიცხვისათვის  I (1 <= I <= 1,000,000).'
შესატანი მონაცემები: ერთადერთ სტრიქონში მოცემულია ერთი მთელი რიცხვი I .
გამოსატანი მონაცემები: ერთადერთ სტრიქონში გამოიტანეთ I-ს ყველა გამყოფის ჯამი.

შემავალი მონაცემების მაგალითი	        შესაბამისი გამომავალი მონაცემი
12	                                                                    28

ანალიზი.  ეს ამოცანა ძალიან წააგავს წინას, თუმცა მკვეთრად განსხვავდება შემოსატანი მონაცემების დიაპაზონები (ერთგან შემოსატანი რიცხვი 30 ათასამდეა, ხოლო  მეორეგან - მილიონამდე). ამის გამო უმჯობესია, რომ ციკლის მუშაობის დრო შევამციროთ. ნებისმიერ შედგენილ რიცხვს ერთი მაინც გამყოფი აქვს მის ფესვამდე (ანუ ისეთ რიცხვამდე, რომლის თავის თავზე ნამრავლი განსახილველ რიცხვის ტოლია ან მაქსიმალურად უახლოვდება ნაკლებობით). თუ ყველა გამყოფს ვიპოვით ფესვამდე, ცხადია, რომ მათი საშუალებით ვიპოვით დანარჩენ გამყოფებსაც, რომლებიც ფესვიდან თავად ამ რიცხვამდე. 
ქვემოთ იგივე და იგივე  კოდი მოცემულია ორნაირად: პირველი მონაცემებს ღებულობს სტანდარტულად (კლავიატურიდან) და შედეგი ეკრანზე გამოაქვს, მეორე კი ფაილიდან კითხულობს და სხვა ფაილში ჩაწერს შედეგს.

#include < iostream >
main () {
    int n, i, sum = 0;
    cin>>n;
    for (i = 1; i*i <= n; i++) {
	if (n % i == 0) {
           sum += i;
	    if (i*i<n) sum+= n/i;
	}
    }
    Cout<<sum;
    }
#include <stdio.h>
main () {
    int n, i, sum = 0;
    fin=fopen ("br1.in", "r");
    fout=fopen ("br1.out", "w");
    fscanf(fin, "%d", &n);
    for (i = 1; i*i <= n; i++) {
	if (n%i==0) {sum += i;
	    if (i*i<n) sum+=n/i;
	}
    }
    fprintf (fout, "%d\n", sum);
   }

ამოცანა 49. რიცხვების შებრუნება
მოცემულია ორნიშნა რიცხვებისაგან შედგენილი მიმდევრობა. თითოეული რიცხვი შეაბრუნეთ და იმავე თანმიმდევრობით დაბეჭდეთ. 
შესატანი მონაცემები: პირველ სტრიქონში მოცემულია ერთი მთელი რიცხვი n – მიმდევრობის წევრთა რაოდენობა.
გამოსატანი მონაცემები: ერთადერთ სტრიქონში იმავე თანმიმდევრობით რიცხვების შებრუნებული მნიშვნელობები. თუ ორნიშნა რიცხვი 0–ით ბოლოვდება, მისი შებრუნებული რიცხვი ერთნიშნა ჩანაწერით გამოიტანეთ.
შემავალი მონაცემების მაგალითი	     შესაბამისი გამომავალი მონაცემი
6                                                                 51 29 7 44 72 3
15 92 70 44 27 30	
ანალიზი.  მიმდევრობის რიცხვები წაკითხვისთანავე შევაბრუნოთ და დავბეჭდოთ. რადგან ყველა რიცხვი ორნიშნაა, შებრუნება მარტივად ხდება 10-ზე გაყოფის ნაშთით და 10-ზე მთელი გაყოფით.

#include <iostream>
int n,i,a;
main( ) {
cin>>n;
for (i=1; i<=n; i++){
          cin>>a;
          cout<<10*(a%10)+a/10;}
}

ამოცანა 50. კოლოფი
ხორვატიის ღია პირველობა ინფორმატიკაში (2006/07 წელი, შეჯიბრი 4)
პატარა მირკომ ასანთის ღერები იატაკზე მოფანტა. დედა ძალიან გაჯავრდა ამის გამო და მირკოს დაავალა, აეკრიფა ღერები და მართკუთხა ფორმის კოლოფში ჩაელაგებინა. მირკომ შეამჩნია ყველა ასანთის ღერი არ თავსდება კოლოფში და გადაწყვიტა ასეთი ღერები მეზობლის ნაგვის ყუთში ჩაეყარა, სადაც დედა ნამდვილად ვერ მიაგნებდა მათ.
დაეხმარეთ მირკოს  დაადგინოს, თუ რომელი ღერები თავსდება კოლოფში. ასანთის ღერი მხოლოდ მაშინ ითვლება კოლოფში მოთავსებულად, თუ მისი მთელი სიგრძე თავსდება კოლოფის ფსკერზე. მირკო განიხილავს ასანთის ღერებს თანმიმდევრულად.
შესატანი მონაცემები: პირველ სტრიქონში მოცემულია სამი მთელი რიცხვი N (1 ≤ N ≤ 50) -  იატაკზე დაყრილი ასანთის ღერების რაოდენობა, W და H (1 ≤ W ≤ 100, 1 ≤ H ≤ 100) - კოლოფის ზომები. მომდევნო N სტრიქონიდან თითოეულში მოცემულია მთელი რიცხვები 1-დან 100-მდე დიაპაზონში, შესაბამისი ასანთის ღერის სიგრძე.
გამოსატანი მონაცემები: ყოველი ასანთის ღერისათვის თითო სტრიქონში თანმიმდევრობით გამოიტანეთ სიტყვა  “DA“ , თუ ასანთის ღერი თავსდება კოლოფში. წინააღმდეგ შემთხვევაში გამოიტანეთ სიტყვა “NE”.
შესატანი მონაცემები	    გამოსატანი მონაცემი
5 3 4                                      DA 
3                                            DA 
4                                            DA 
5                                            NE 
6                                            NE
7 	

2 12 17 
21                                          NE
20 	                                      DA 

ანალიზი. ყველაზე გრძელი ასანთის ღერის სიგრძე, რომელიც შეიძლება მოთავსდეს მართკუთხა ფორმის კოლოფში, იქნება კოლოფის მთავარი დიაგონალის სიგრძის ტოლი. მთავარი დიაგონალის სიგრძის გამოსათვლელად გამოვიყენოთ პითაგორას თეორემა. პროგრამის კოდში გამოყენებულია შედარების ოპერატორის გამარტივებული კონსტრუქცია, რომელიც პირდაპირ printf ოპერატორშია ჩასმული.
#include <cstdio>
int main( ) {
   int n, w, h, k;
   scanf( "%d%d%d", &n, &w, &h );
   for( int i = 0; i < n; i++ ) {
      scanf( "%d", &k );
      printf( w*w+h*h >= k*k ? "DA\n": "NE\n" );
       }
}


ამოცანა 51. Ice Cream - ნაყინი [Burch, 2001]
USACO 2001 წლის გაზაფხულის შეჯიბრი, “ნარინჯისფერი” დივიზიონი
როცა ფერმერი ჯონი კვებავს საკუთარ ძროხებს, გასართობად ერთგვარ თამაშსაც თამაშობს. ის მიუყვება მწკრივში განლაგებულ ძროხებს და თანმიმდევრულად კითხულობს მათ ყურებზე დაწერილ ნომრებს. ჯონი ცდილობს გამოიცნოს ლუწი ნომრებისაგან შედგენილი ყველაზე გრძელი უწყვეტი მიმდევრობის სიგრძე და თუ ეს შეძლო, სადილის შემდეგ უგემრიელეს ნაყინს მიიღებს.
მოცემულია ძროხათა რაოდენობა N (1 <= N <= 100,000) და N ცალი ნომერი დიაპაზონში 1..1,000,000. იპოვეთ ლუწი ნომრებით შედგენილი უგრძელესი უწყვეტი მიმდევრობის სიგრძე.
შესატანი მონაცემები: პირველ სტრიქონში მოცემულია ერთი მთელი რიცხვი N. მომდევნო N სტრიქონიდან თითოეულში მოცემულია თითო მთელი რიცხვი - შესაბამისი ძროხის ნომერი.
გამოსატანი მონაცემები: ერთადერთ სტრიქონში გამოიტანეთ ერთი მთელი რიცხვი -  ლუწი ნომრებისაგან შედგენილი ყველაზე გრძელი უწყვეტი მიმდევრობის სიგრძე.
შესატანი მონაცემები	გამოსატანი მონაცემი
7                                         3
1
2
4
6
3
4
12 	

ანალიზი. შემოვიღოთ რაიმე მთვლელი, რომელიც ყოველი ლუწი რიცხვის წაკითხვისას 1-ით გაიზრდება, ხოლო ყოველი კენტი რიცხვის წაკითხვისას 0-ის ტოლი გახდება. რაიმე ცვლადში დავიმახსოვროთ ამ მთვლელის მაქსიმალური მნიშვნელობა, რომელიც ამოცანის პასუხიც იქნება.
#include <iostream>
using namespace std;
 int n, w=0, h=0, k;
 main() {
   cin>>n;
   for( int i = 0; i < n; i++ ) {
      cin>>k;
      if (k%2==0) h++; else h=0;
      if (h>w) w=h;
   }
   cout<<w<<endl;
}

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

შემავალი მონაცემების მაგალითი	     შესაბამისი გამომავალი მონაცემი
13                                                               4
5 5 6 7 7 7 7 6 6 5 4 4 4	

ანალიზი. საჭიროა ერთმანეთს შევადაროთ ყველა მეზობელი შემომავალი რიცხვი. ამისთვის საჭიროა ორი ცვლადი: ერთში (კოდში current ცვლადითაა აღნიშნული) ჩაიწერება მიმდინარე ნაწილის მნიშვნელობა, ხოლო მეორეში – წინა მეზობლის მნიშვნელობა (კოდში - old ცვლადი). თუ ისინი ტოლია, რაიმე მთვლელი გავზარდოთ 1-ით, წინააღმდეგ შემთხვევაში მთვლელს მივანიჭოთ 1. რაიმე ცვლადში დავიმახსოვროთ ამ მთვლელის მაქსიმალური მნიშვნელობა, რომელიც საბოლოოდ ამოცანის პასუხი იქნება. ციკლის ბოლოს old-ს მივანიჭოთ current.

#include <iostream>
using namespace std;
main() {
   int n, w=0, h=0,old=-1, current;
   cin>>n;
   for( int i = 0; i < n; i++ ) {
      cin>> current;
      if (current==old) h++; else h=1;
      if (h>w) w=h;
      old=current;
   }
   cout<<w<<endl;
}

ამოცანა 53 – ტრამვაი
http://codeforces.com/problemset/problem/116/A
წრფივ სახელმწიფოში ტრამვაის მხოლოდ ერთი მარშრუტია. ის შედგება n გაჩერებისაგან, რომლებიც გადანომრილია 1-დან n-მდე ტრამვაის მოძრაობის მიმართულებით. i-ურ გაჩერებაზე ai რაოდენობის ადამიანი ჩამოდის  ტრამვაიდან, ხოლო bi რაოდენობის - ამოდის. ტრამვაი პირველ გაჩერებაზე ცარიელი მოდის, ხოლო ბოლო გაჩერებაზე ყველა მგზავრი ჩამოდის.
თქვენი ამოცანაა დაადგინოთ ტრამვაის მინიმალური ტევადობა, რომელსაც არასდროს არ აღემატება ტრამვაიში მყოფ მგზავრთა რაოდენობა დროის ნებისმიერი მომენტისათვის. გაითვალისწინეთ, რომ ყოველ გაჩერებაზე მგზავრები ჯერ ჩადიან ტრამვაიდან და მხოლოდ ამის შემდეგ ამოდიან ახალი მგზავრები. 
შესატანი მონაცემები: პირველ სტრიქონში მოცემულია ერთი მთელი რიცხვი n (2≤n≤1000). მომდევნო n სტრიქონიდან თითოეულში მოცემულია ორ-ორი მთელი რიცხვი ai და bi (0≤ai,bi≤1000) – იმ მგზავრთა რაოდენობა, რომლებიც შესაბამის გაჩერებაზე ჩადიან და ამოდიან. გაჩერებები ჩამოთვლილია იმ მიმდევრობით, როგორც მათ ტრამვაი გაივლის.
გამოსატანი მონაცემები: ერთადერთ სტრიქონში გამოიტანეთ ერთი მთელი რიცხვი – ტრამვაის მინიმალური ტევადობა. დასაშვებია, რომ ის 0-იც იყოს.

შემავალი მონაცემების მაგალითი	      შესაბამისი გამომავალი მონაცემი
4                                                               6
0 3
2 5
4 2
4 0	

განმარტება. თავიდან ტრამვაი ცარიელია და პირველ გაჩერებაზე მასში ადის 3 მგზავრი. მეორე გაჩერებაზე ჩამოდის 2 და ადის 5 მგზავრი, ე.ი. ტრამვაი მოძრაობს 6 მგზავრით. მესამე გაჩერებაზე  ჩადის 4 და ამოდის 2 მგზავრი. ტრამვაი მიემგზავრება 4 მგზავრით, რომლებიც ბოლო გაჩერებაზე ჩამოდიან. დროის არცერთ მომენტში მგზავრთა რაოდენობა არ აღემატებოდა 6-ს.

ანალიზი. ციკლის საშუალებით წავიკითხოთ შემოსატანი მონაცემები და პარალელურად რაიმე ცვლადს გამოვაკლოთ ჩასულ მგზავრთა რაოდენობა და დავუმატოთ ამოსულთა რაოდენობა. ამ ცვლადის მაქსიმალური მნიშვნელობა დავიმახსოვროთ სხვა ცვლადის საშუალებით.

#include<iostream>
using namespace std;
int main(){
	int n, a, b, i, k=0, k1=0;
	cin>>n;
	for(i=0;i<n;i++)	{
		cin>>a>>b;
		k=k-a+b;
		if(k>=k1)k1=k;	}
	cout<<k1;
}

ამოცანა 54 – ნორჩი ფიზიკოსი
http://codeforces.com/problemset/problem/69/A
ფიზიკის მასწავლებელმა ვასოს მისცა ერთი შეხედვით მარტივი ამოცანა: მოცემულია სხეული სივრცეში და მასზე მოქმედი ძალები. სხეული შეიძლება ჩავთვალოთ მატერიალურ წერტილად (0,0,0) კოორდინატებით. ვასომ უნდა დაადგინოს იმყოფება თუ არა სხეული წონასწორობაში. 
ვასომ იცის, რომ საკმარისია შემოწმდეს, არის თუ არა ყველა ვექტორის ჯამი 0 და დაიწყო ამოცანის ამოხსნა, მაგრამ აღმოჩნდა, რომ მოქმედი ძალები ძალიან ბევრია. დაეხმარეთ ვასოს და დაწერეთ პროგრამა, რომელიც დაადგენს, არის თუ არა სხეული წონასწორობაში.
შესატანი მონაცემები: პირველ სტრიქონში მოცემულია ერთი მთელი რიცხვი n (1≤n≤100). მომდევნო n სტრიქონიდან თითოეულში მოცემულია სამ-სამი მთელი რიცხვი: xi, yi, zi – ძალები, რომელიც მოქმედებენ შესაბამისად x, y, და z ღერძების გასწვრივ (-100≤xi,yi,zi≤100). 
გამოსატანი მონაცემები: ერთადერთ სტრიქონში გამოიტანეთ სიტყვა "YES", თუ სხეული იმყოფება წონასწორობაში ან სიტყვა  "NO" – წინააღმდეგ შემთხვევაში.

შემავალი მონაცემების მაგალითი	           შესაბამისი გამომავალი მონაცემი
3                                                                   NO
4 1 7
-2 4 -1
1 -5 -3	

3                                                                   YES
3 -1 7
-5 2 -4
2 -1 -3	

ანალიზი. ეს ამოცანა წინა ამოცანის მსგავსია, ოღონდ აქ 3 სხვადასხვა ცვლადში უნდა დავიმახსოვროთ შესაბამისი ღერძების გასწვრივ მოქმედი ძალების ჯამები. 


#include <iostream>
using namespace std;
int n,x=0,y=0,z=0,s;
int main (){
cin>>n;
for (int i=0;i!=n;i++){
         cin>>s;x+=s;cin>>s;y+=s;cin>>s;z+=s;}
if (x==0 && y==0 && z==0)cout<<"YES"; else cout<<"NO";
}