შედარების ოპერატორი
                შედარების ოპერატორი გამოიყენება პროგრამაში განშტოებათა ორგანიზებისათვის (ამის გამო მას ხშირად განშტოების ოპერატორს უწოდებენ). მისი ფორმატია: 
if (გამოსახულება) ოპერატორი1; [else ოპერატორი2;]
if ოპერატორის შესრულება იწყება გამოსახულების მნიშვნელობის გამოთვლიდან, რომელსაც ორი შესაძლო პასუხი აქვს – ჭეშმარიტი (ანუ განსხვავებულია 0–საგან) და მცდარი (ანუ 0). შემდეგ შესრულება გრძელდება ამგვარი სქემით:
     თუ გამოსახულება ჭეშმარიტია, სრულდება ოპერატორი1. 
     თუ გამოსახულება მცდარია, სრულდება ოპერატორი2. 
   თუ გამოსახულება მცდარია და ოპერატორი2 არაა მოცემული, მაშინ სრულდება ოპერატორი , რომელიც უშუალოდ if–ის შემდეგაა.
     ერთდროულად ოპერატორი1–ის და ოპერატორი2–ის შესრულება შეუძლებელია.
დასაშვებია ერთმანეთში ჩადგმული if ოპერატორების გამოყენება. იგი შესაძლოა ჩადგმული იქნას სხვა if–ის (ან სხვა else–ს)  შიგნით. ასეთ დროს რეკომენდირებულია ფიგურული ფრჩხილების გამოყენება, რომელთა არარსებობის შემთხვევაში კომპილიატორი თავად აწყვილებს else–ებს უახლოეს if–ებთან, რომელსაც else არ აქვს. 

ოპერატორი	შედეგი
==	ტოლია
!=	არ უდრის
>	მეტია
<	ნაკლებია
>=	მეტია ან ტოლი
<=	ნაკლებია ან ტოლი

გამოსახულებაში დაუშვებელია ორმაგი უტოლობების გამოყენება (მაგ. 5<s<=276). ასეთი პირობების ჩაწერა ხორციელდება ე.წ. ლოგიკური ოპერატორებით, რომელთა ჩამონათვალი მოცემულია ცხრილში:

ოპერაცია	                სინტაქსი	        მაგალითი
უარყოფა(NOT)	          !	                if (a!=7) k=9
ლოგიკური და (AND)	  &&	                if (a>10)&&(a<100)
ლოგიკური ან   (OR)	  ||	                if (a>=b)||a(>=c)

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


switch (გამოსახულება) {
  case ჭდე1:
    ოპერატორთა მიმდევრობა;
    break;
  case ჭდე2:
    ოპერატორთა მიმდევრობა;
    break;
  case ჭდე3:
    ოპერატორთა მიმდევრობა;
    break;
  default:
    ოპერატორთა მიმდევრობა;
}
გამოსახულების მნიშვნელობა ოპერატორ switch–ში შეიძლება გამოისახოს მხოლოდ მთელი რიცხვით. სიმბოლური ჭდეების გამოყენების შემთხვევაში მხედველობაში მიიღება მათი რიცხვითი მნიშვნელობები. გამოსახულების მნიშვნელობა რიგრიგობით ედარება ჭდეებს და თუ რომელიმეს ტოლია, სრულდება ოპერატორების ჯგუფი შესაბამისი case–დან ოპერატორ break–მდე. თუკი case–ს  break–ი არ ახლავს, პროგრამა ასრულებს მომდევნო case–ების ოპერატორებს  ვიდრე არ შეხვდება break–ი ან არ დამთავრდება switch ოპერატორის ტანი. ოპერატორი default სრულდება მაშინ, თუ გამოსახულების მნიშვნელობა არ დაემთხვა არცერთ ჭდეს. default–ის გამოყენება switch–ში აუცილებელი არ არის და თუკი მისი არარსებობის შემთხვევაში გამოსახულების მნიშვნელობა არ დაემთხვა არცერთ ჭდეს, მაშინ არანაირი ოპერატორი არ სრულდება.
С++–ის სტანდარტის მიხედვით switch–ში შესაძლებელია 1023 ჭდის გამოყენება, რაც პრაქტიკულად შეუძლებელია, რომ პროგრამის წერის დროს დაგვჭირდეს. ორ ან მეტ ჭდეს არ შეიძლება ერთნაირი მნიშვნელობა ჰქონდეს. შესაძლებელია ერთ switch–ში მეორის ჩადგმა.


                                                                                      ამოცანა 21. აკვარიუმი
                                                   ბულგარეთის ეროვნული ოლიმპიადა (2010 წელი, საწყისი ეტაპი, 4-5 კლასი)
	აკვარიუმში ოქროს თევზების ნორმალურად გამრავლებისათვის აუცილებელია, რომ ერთ თევზზე 3 ლიტრი წყალი მოდიოდეს.	
	დაწერეთ პროგრამა, რომელიც V ლიტრი ტევადობის მქონე აკვარიუმისა და N ცალი ოქროს თევზისათვის დაადგენს, რამდენი თევზის გადაყვანაა საჭირო სხვა ადგილას, რომ მოცემულ აკვარიუმში თევზებს გამრავლების ნორმალური პირობა შეექმნათ. 
შესატანი მონაცემები: ერთადერთ სტრიქონში მოცემულია ჰარით გაყოფილი ორი მთელი რიცხვი V და N (1 ≤ V, N  ≤ 1018 ).
გამოსატანი მონაცემები: თუ აკვარიუმიდან საჭიროა ოქროს თევზების ნაწილის სხვა ადგილას გადაყვანა, პროგრამამ ერთ სტრიქონში გამოიტანოს ჰარით დაშორებული YES და გადასაყვანი თევზების მინიმალური რაოდენობა, ხოლო თუ არცერთი თევზის გადაყვანა არაა საჭირო, პროგრამამ გამოიტანის NO.

შემავალი მონაცემების მაგალითი	           შესაბამისი გამომავალი მონაცემი
12 5		                                                             YES 1
128 39 	                                                              NO

ანალიზი. გავყოთ აკვარიუმის ტევადობა 3–ზე და გამოვთვალოთ იმ თევზების რაოდენობა, რომელთათვისაც ეს ტევადობა საკმარისია. შემდეგ გამოვთვალოთ N–ისა და ამ რიცხვის სხვაობა. 

#include <iostream>
using namespace std;
long long v, n, b ;
main(){
    cin >> v >> n;
    b = v/3;
    if (b < n) cout << "YES " << n-b << endl;
    else cout << "NO";
}

                                                                               ამოცანა 22. სიმღერა
                                                 ბულგარეთის ეროვნული ოლიმპიადა (2009 წელი, საწყისი ეტაპი, 4-5 კლასი)
როზენმა საკუთარი კომპიუტერის მყარი დისკი თამაშებით აავსო და ახლა მას აინტერესებს, დაეტევა თუ არა მასზე მისი საყვარელი სიმღერა. სიმღერის ხანგრძლივობა n წუთი და m წამია, თავისუფალი ადგილი მყარ დისკზე – k მეგაბაიტი, ხოლო სიმღერის 1 წამის შესანახად მეხსიერებაში საჭიროა 16 კილობაიტი (1 მეგაბაიტი=1024 კილობაიტი). 
დაწერეთ პროგრამა, რომელიც  გამოიტანს YES , თუ დისკზე თავისუფალი ადგილი საკმარისია. იმ შემთხვევაში, თუ სიმღერის ჩასაწერად მეხსიერება არ გვყოფნის, პროგრამამ ცალ–ცალკე სტრიქონებში გამოიტანოს შეტყობინება NO და სიმღერის ჩასაწერად საჭირო მეხსიერების რაოდენობა კილობაიტებში.
შესატანი მონაცემები: ერთადერთ სტრიქონში მოცემულია სამი მთელი რიცხვი n, m და k  (1<= n, m, k <=1 000 000 000).
გამოსატანი მონაცემები: პროგრამამ პირველ სტრიქონში გამოიტანოს YES, თუ დისკზე თავისუფალი ადგილი საკმარისია და NO – წინააღმდეგ შემთხვევაში. უარყოფითი პასუხის შემთხვევაში მეორე სტრიქონში გამოიტანეთ სიმღერის ჩასაწერად საჭირო მეხსიერების რაოდენობა კილობაიტებში.
შემავალი მონაცემების მაგალითი	                შესაბამისი გამომავალი მონაცემი
36 5 6	                                                               NO 
                                                                               28496
2 2 65                                                       	       YES

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

#include <iostream>
using namespace std;
long long m,n,k,t,v,s;
main(){ 
    cin>>n>>m>>k;
    t=60*n+m;
    v=16*t;
    s=k*1024;
    if (v<=s) cout<<"YES\n";
    else cout<<"NO\n"<<v-s<<endl;
}




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

შემავალი მონაცემების მაგალითი	          შესაბამისი გამომავალი მონაცემი
358	                                                                    280
553	                                                                    265

ანალიზი. რადგან რიცხვი სამნიშნაა, გამრავლების ნიშნის ჩასასმელად სულ ორი ვარიანტი არსებობს: ა) პირველ და მეორე ციფრებს შორის; ბ) მეორე და მესამე ციფრებს შორის. გამოვთვალოთ ორივე შემთხვევის პასუხი და შევადაროთ ერთმანეთს.

#include<iostream>
using namespace std; 
int a,m1,n1,m2,n2,s,p;
main(){   
    cin >> a;
    m1 = a/10; n1 = a%10; s = m1*n1;
    m2 = a/100; n2 = a%100; p = m2*n2;
    if (s > p) cout << s << endl;
    else  cout << p << endl;
}

                                                                                   ამოცანა 24. საზამთრო
                                                                  http://codeforces.com/problemset/problem/4/A
ზაფხულის ერთ ცხელ დღეს პეტრემ და ვასომ საზამთრო იყიდეს. აწონვის შემდეგ აღმოჩნდა, რომ საზამთრო w კილოგრამია. ბავშვები აპირებენ მის გაყოფას ორ ნაწილად, მაგრამ ეს არც ისე იოლი აღმოჩნდა – ორივე მათგანი ლუწი რიცხვების მოყვარულია და სურს, რომ მის წილს ლუწი რიცხვით გამოსახული წონა ჰქონდეს. ამასთან, აუცილებელი არაა, რომ საზამთრო თანაბრად გაიყოს. დაეხმარეთ ბავშვებს პრობლემის გადაწყვეტაში. 
შესატანი მონაცემები: ერთადერთ სტრიქონში მოცემულია ერთი მთელი რიცხვი w (1 ≤ w ≤ 100), ბავშვების მიერ ნაყიდი საზამთროს წონა.
გამოსატანი მონაცემები: გამოიტანეთ YES, თუ საზამრთოს გაყოფა ხერხდება ორ ნაწილად ისე, რომ ორივე ნაწილის წონა დადებითი ლუწი რიცხვებით იყოს გამოსახული. თუ ასეთი გაყოფა შეუძლებელია, გამოიტანეთ NO.

შემავალი მონაცემების მაგალითი	         შესაბამისი გამომავალი მონაცემი
8	                                                                 YES
ანალიზი. კენტი რიცხვების გაყოფა ორ ლუწ ნაწილად შეუძლებელია. ლუწი რიცხვებიდან კი 2–ის გარდა ყველას გაყოფა შეიძლება აღნიშნული წესით. 
#include <iostream>
using namespace std;
int n;
main() {
    cin>>n;
      if  (n%2==0 && n>2) cout<<"YES"; else cout<<“NO”;
}

                                                                    ამოცანა 25. სამკუთხედის აგება
დაწერეთ პროგრამა, რომელიც მოცემული სამი A, B და C (0 <= A, B, C <= 30000) რიცხვებისათვის შეამოწმებს, შესაძლებელია თუ არა შესაბამისი სიგრძეების მონაკვეთებით სამკუთხედის აგება. დადებითი პასუხის შემთხვევაში პროგრამამ გამოიტანოს – “YES”, თუკი სამკუთხედი არ აიგება – “NO”.
შესატანი მონაცემები: ერთადერთ სტრიქონში მოცემულია სამი მთელი A, B და C.
გამოსატანი მონაცემები: გამოიტანეთ YES, თუ სამკუთხედის აგება შესაძლებელია და წინააღმდეგ შემთხვევაში გამოიტანეთ NO.

შემავალი მონაცემების მაგალითი	           შესაბამისი გამომავალი მონაცემი
12  19  14	                                                       YES
11  29  10	                                                       NO

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

#include <iostream>
int a,b,c;
main() {
cin>>a>>b>>c;
if ((a+b>c) && (a+c>b) && (b+c>a)) cout<<"YES"; else cout<<“NO”;
}


                                                               ამოცანა 26. პოზიციათა რაოდენობა
                                                        http://codeforces.com/problemset/problem/124/A
პეტრე დგას n ადამიანისაგან შედგენილ რიგში, მაგრამ ზუსტად არ იცის - რომელ ადდილას.  მას შეუძლია თქვას, რომ მის წინ დგას არანაკლებ a ადამიანი, ხოლო მის შემდეგ -  არაუმეტეს b ადამიანი. გამოთვალეთ პოზიციათა რაოდენობა, რომელზეც შეიძლება პეტრე იმყოფებოდეს. 
შესატანი მონაცემები: ერთ სტრიქონში მოცემულია სამი მთელი რიცხვი - n, a და b (0≤a,b<n≤100).
გამოსატანი მონაცემები: ერთი მთელი რიცხვი - შესაძლებელი პოზიციების რაოდენობა.

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

#include<iostream>
using namespace std;
int n,a,b;
int main(){
    cin>>n>>a>>b;
    b++;
    if(b>n-a) cout<<n-a; else cout<<b;
}

                                                                ამოცანა 27.  პეტრე და ჯავა
                                                 http://codeforces.com/problemset/problem/66/A
პატარა პეტრემ პროგრამირების შესწავლა დაიწყო და დიდი ფიქრის შემდეგ გადაწყვიტა, რომ არჩევანი ჯავაზე შეეჩერებინა.  მთავარ არგუმენტად ამ არჩევანის დროს იყო ის ფაქტი, რომ ჯავაში არის ძალიან დიდი მთელი ტიპი - BigInteger. თუმცა პროგრამირების წრეში პეტრემ გაიგო, რომ BigInteger-ის გამოყენება ყველა ამოცანაში არ არის საჭირო და ხშირად მოსახერხებელია უფრო ნაკლები დიაპაზონის მქონე ცვლადთა ტიპების გამოყენება. ამის გამო წარმოიშვა კითხვა: „რომელი მთელი ტიპი გამოვიყენოთ ნატურალური n რიცხვის შესანახად?“
პეტრემ იცის მხოლოდ 5 მთელი ტიპი:
1) byte – 1-ბაიტიანი მონაცემი დიაპაზონით  -128..127.
2) short – 2-ბაიტიანი მონაცემი დიაპაზონით  -32768..32767.
3) int – 4-ბაიტიანი მონაცემი დიაპაზონით  -2147483648..2147483647.
4) long– 8-ბაიტიანი მონაცემი დიაპაზონით -9223372036854775808..9223372036854775807.
5) BigInteger ინახავს ნებისმიერ მთელ რიცხვს, მაგრამ იმის გამო, რომ არ წარმოადგენს პრიმიტიულ ტიპს, გაცილებით ნელა მუშაობს.
დიაპაზონთა საზღვრები ეკუთვნიან ამავე დიაპაზონს. პეტრეს სურს, რომ მოცემული n რიცხვი შეინახოს რაც შეიძლება ნაკლები დიაპაზონის ტიპში.
შესატანი მონაცემები: ერთადერთ სტრიქონში მოცემულია ერთი მთელი დადებითი რიცხვი - n. ის შედგება არაუმეტეს 100 ციფრისაგან და არ იწყება 0–ებისაგან. n არ შეიძლება იყოს ცარიელი სტრიქონი.
გამოსატანი მონაცემები: გამოიტანეთ პირველივე ტიპი სიიდან "byte, short, int, long, BigInteger", რომელშიც შეიძლება შენახული იყოს n რიცხვი, ზემოთ მითითებული დიაპაზონების მიხედვით.

შემავალი მონაცემების მაგალითი	                  შესაბამისი გამომავალი მონაცემი
127	                                                                          byte
130	                                                                          short
123456789101112131415161718192021222324	  BigInteger

ანალიზი. ერთ-ერთი მთავარი პრობლემა ამოცანის ამოხსნისას მონაცემების სწორად წაკითხვაა. ცხადია, რომ ასნიშნა რიცხვს ვერცერთ მთელი ტიპის ცვლადში ვერ წავიკითხავთ. Char-სიმბოლოებად წაკითხვის შემთხვევაში გართულდება დიაპაზონების საზღვრების დადგენა. ყველაზე მარტივი გამოსავალია მონაცემების წაკითხვა long double-ში, რომელიც მართალია დიდ რიცხვებს გარკვეული ცდომილებით შეინახავს, მაგრამ ეს ცდომილება არანაირ როლს არ ითამაშებს ცვლადის ტიპთა დიაპაზონებთან შედარებისას.

  #include <iostream>
  using namespace std;
  int main()  {
  long double nb;
  cin>>nb;
  if(nb<=127)  cout<<"byte";
      else if(nb<=32767)   cout<<"short";
           else if(nb<=2147483647)   cout<<"int";
                else if(nb<=9223372036854775807LL)  cout<<"long";
                     else  cout<<"BigInteger";
 }




                                                                 ამოცანა 28.  მეოთხე წერტილი
                                      ხორვატიის ღია პირველობა ინფორმატიკაში (2007/08 წელი, შეჯიბრი 1)
მირკოს უნდა შეარჩიოს 4 წერტილი სიბრტყეზე ისე, რომ ისინი ჰქმნიდნენ მართკუთხედს, რომლის გვერდები საკოორდინატო ღერძების პარალელურია. მან უკვე შეარჩია 3 წერტილი და დარწმუნებულია, რომ შეცდომა არ დაუშვია. მეოთხე წერტილის შერჩევა კი გაუჭირდა. დაეხმარეთ მირკოს და დაწერეთ პროგრამა, რომელიც იპოვის მეოთხე წერტილის კოორდინატებს.
შესატანი მონაცემები: სამი სტრიქონიდან თითოეულში მოცემულია ორ-ორი მთელი რიცხვი – შესაბამის წერტილის კოორდინატები სიბრტყეზე. თითოეული კოორდინატი წარმოადგენს მთელ რიცხვს და მოთავსებულია დიაპაზონში 1-დან 1000-მდე.
გამოსატანი მონაცემები: ერთადერთ სტრიქონში გამოიტანეთ ორი მთელი რიცხვი – მეოთხე წერტილის კოორდინატები.

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

30 20
10 10
10 20	                                                    30 10


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

#include <iostream>
int x1, y1, x2, y2, x3, y3;
main( ) {
   cin>>x1>>y1>>x2>>y2>>x3>>y3;
   if( x1 == x2 ) cout<<x3<<” “;
   if( x1 == x3 ) cout<<x2<<” “;
   if( x2 == x3 ) cout<<x1<<” “;
   if( y1 == y2 ) cout<<y3<<endl;
   if( y1 == y3 ) cout<<y2<<endl;
   if( y2 == y3 ) cout<<y1<<endl;
}

                                                             ამოცანა 29.  განტოლებები
                                       ხორვატიის ღია პირველობა ინფორმატიკაში (2007/08 წელი, შეჯიბრი 5)
პატარა მირკომ საკუთარ ნოუთბუქში შეადგინა არითმეტიკული განტოლებები სამ-სამი რიცხვიდან, რომლებშიც გამოიყენა ტოლობის ნიშანი და ერთ-ერთი ოპერაცია ოთხი არითმეტიკული მოქმედებიდან – შეკრება, გამოკლება, გამრავლება და გაყოფა. საკმარისი იყო, რომ მირკოს რამდენიმე წუთით დაეტოვებინა ნოუთბუქი უყურადღებოდ, რომ სლავკომ წაშალა ყველა ოპერაციის და ტოლობის ნიშანი და მხოლოდ რიცხვები დატოვა. დაეხმარეთ მირკოს განტოლებების აღდგენაში. 
შესატანი მონაცემები: ერთადერთ სტრიქონში მოცემულია ჰარით დაშორებული სამი მთელი რიცხვი. თითოეული რიცხვი მოთავსებულია დიაპაზონში 1-დან 100-მდე.
გამოსატანი მონაცემები: ერთადერთ სტრიქონში გამოიტანეთ შემომავალი რიცხვებისაგან შედგენილი ჭეშმარიტი ტოლობა. რიცხვების თანმიმდევრობა დაცული უნდა იყოს. შემომავალი მონაცემები უზრუნველყოფენ პასუხის არსებობას. რამდენიმე პასუხის არსებობის შემთხვევაში გამოიტანეთ ერთ-ერთი.
შემავალი მონაცემების მაგალითი	შესაბამისი გამომავალი მონაცემი
5 3 8	5+3=8
5 15 3	5=15/3
ანალიზი. ტოლობის ნიშანი ნებისმიერ განტოლებაში უნდა ფიგურირებდეს. ის შეიძლება მოთავსებული იყოს პირველ და მეორე ან მეორე და მესამე რიცხვებს შორის. ამ ორი შემთხვევიდან თითოეულისათვის განვიხილოთ ოთხივე არითმეტიკული ოპერაცია. მაშასადამე, სულ განსახილველი იქნება 8 ვარიანტი. თითოეული შემთხვევისათვის ცალ-ცალკე შედარების დაწერის შემთხვევაში არსებობს საშიშროება, რომ პროგრამამ ერთის ნაცვლად რამდენიმე სწორი პასუხი გამოიტანოს (მაგ. 4-2=2 და 4/2=2 ), ამიტომ შედარების ოპერატორები ერთმანეთში ჩავსვათ და თუ რომელიმე მათგანი დაკმაყოფილდა, დანარჩენები აღარ შემოწმდება.
#include <cstdio>
int a, b, c;
main(  ) {
   scanf( "%d%d%d", &a, &b, &c );
   if( a == b+c ) printf( "%d=%d+%d\n", a, b, c );
   else if( a == b-c ) printf( "%d=%d-%d\n", a, b, c );
   else if( a == b*c ) printf( "%d=%d*%d\n", a, b, c );
   else if( a == b/c ) printf( "%d=%d/%d\n", a, b, c );
   else if( a+b == c ) printf( "%d+%d=%d\n", a, b, c );
   else if( a-b == c ) printf( "%d-%d=%d\n", a, b, c );
   else if( a*b == c ) printf( "%d*%d=%d\n", a, b, c );
   else if( a/b == c ) printf( "%d/%d=%d\n", a, b, c );
}

                                                                       ამოცანა 30.  სამი კენგურუ
                                    ხორვატიის ღია პირველობა ინფორმატიკაში (2008/09 წელი, შეჯიბრი 1)
სამი კენგურუ თამაშობს უდაბნოში. ისინი დგანან ერთ სწორ ხაზზე და სამივე მათგანის კოორდინატები განსხვავებულია. ყოველ სვლაზე ერთ-ერთი განაპირა კენგურუ ხტება დანარჩენ ორს შორის (აუცილებელი არაა ზუსტად შუაში ჩახტეს). არცერთ მომენტში ორი კენგურუ არ იმყოფება ერთ წერტილში. დაწერეთ პროგრამა, რომელიც გამოითვლის ნახტომების მაქსიმალურ რაოდენობას, რომლებიც შეიძლება კენგურუებმა გააკეთონ. 
შესატანი მონაცემები: ერთადერთ სტრიქონში მოცემულია ჰარით დაშორებული სამი მთელი რიცხვი A, B და C (0 < A < B < C < 100) – კენგურუთა საწყისი კოორდინატები.
გამოსატანი მონაცემები: ერთადერთ სტრიქონში გამოიტანეთ ერთი მთელი რიცხვი -ნახტომების მაქსიმალური რაოდენობა, რომლებიც შეიძლება კენგურუებმა გააკეთონ.
შესატანი მონაცემები	    გამოსატანი მონაცემები
2 3 5	                                1
3 5 9                                      	3
ანალიზი. კენგურუთა თითოეული ნახტომის შემდეგ მათ შორის მანძილების ჯამი მცირდება და ადრე თუ გვიან თამაში შეწყდება. თუ განვიხილავთ საწყის პოზიციაში ორი კენგურუს კოორდინატებს, იოლი შესამჩნევია, რომ კენგურუებს შეუძლიათ მათ შორის არსებულ თითოეულ წერტილში გააკეთონ ნახტომი. აქედან გამომდინარე, ამოცანა შეიძლება ასე ამოიხსნას: დავადგინოთ საწყის ორ შუალედს შორის უდიდესი და გამოვაკლოთ 1, რადგან კიდურა წერტილებში ნახტომების გაკეთება არ შეიძლება.
#include <iostream>
int a,b,c;
main(){
cin>>a>>b>>c);
 if (b-a>c-b) cout<<b-a-1; else cout<<c-b-1;
}