არითმეტიკული და შეტანა-გამოტანის ოპერაციები
            C++-ში, ისევე როგორც პროგრამირების სხვა ენებში, პროგრამა წარმოადგენს ბრძანებების ერთობლიობას, რომელიც თანმიმდევრობით სრულდება. თანმიმდევრობის შეცვლა (მაგალითად, ზოგიერთი ბრძანების გამოტოვება, ან უკვე შესრულებულ ბრძანებაზე დაბრუნება) სპეციალური ბრძანებებით ხორციელდება. ბრძანებები იწერება წინასწარ განსაზღვრული სიტყვების საშუალებით, რომლებსაც რეზერვირებულ სიტყვებს უწოდებენ. პროგრამირების თითოეულ ენას რეზერვირებულ სიტყვათა საკუთარი სიმრავლე აქვს, თუმცა ასეთ სიტყვათა დიდი ნაწილი და ამ სიტყვებით შექმნილი კონსტრუქციები  პროგრამირების ბევრ ენაში საერთოა. პროგრამირების ენებს, განსხვავებით სალაპარაკო ენებისაგან, გააჩნია ძალზე მკაცრი სინტაქსი და მისი დაუცველობის შემთხვევაში კომპილატორი (ბრძანებების შემსრულებელი) ვერ გაიგებს ჩვენ მიერ ჩაწერილ ბრძანებას და ვერ შეასრულებს მას.
ყველაზე ხშირად პროგრამირების დროს მინიჭების ოპერაცია ხორციელდება. C++–ში ამ ოპერაციისათვის გამოიყენება ტოლობის ნიშანი („=“), მაგრამ, განსხვავებით მათემატიკისაგან, a=7 და 7=a ჩანაწერები არ არის ერთნაირი შინაარსის შემცველი. პროგრამირებაში გამოსახულების მხოლოდ მარცხენა მხარეს ენიჭება მარჯვნივ მდგომი გამოსახულების მნიშვნელობა და არა პირიქით. შესაბამისად, მარცხენა მხარეში მხოლოდ ერთი ცვლადი შეიძლება იმყოფებოდეს, ხოლო მარჯვენაში შესაძლებელია რთული გამოსახულების ჩაწერაც. მაგალითად: 
B = n + ( t1 * t1 - 20 ) - jami / 2.
მოყვანილ გამოსახულებაში B, n, t1 და jami ცვლადთა სახელებია. ცვლადთა სახელებს პროგრამისტი ირჩევს, თუმცა არსებობს გარკვეული შეზღუდვებიც (არ უნდა იწყებოდეს ციფრით, არ უნდა ემთხვეოდეს რეზერვირებულ სიტყვას, არ უნდა შეიცავდეს სასვენ ნიშნებს და ა.შ.). მარჯვენა მხარეში მდგომ ცვლადებს ამ გამოსახულების შესრულებამდე აუცილებლად უნდა ჰქონდეთ მინიჭებული რიცხვითი მნიშვნელობები, რადგან ოპერაციები C++–ში  მხოლოდ რეალურ რიცხვებზე სრულდება. მინიჭების ოპერატორს აქვს კიდევ ერთი „არამათემატიკური“ თვისება. მაგალითად:
X=8;
X=X+5;
ოპერაციების შემდეგ X–ის მნიშვნელობა 13 იქნება. მეორე სტრიქონში მოცემული ტოლობის მარცხენა და მარჯვენა მხარეებში გამოყენებული X–ები შინაარსობრივად განსხვავდება. მარჯვენა მხარეში X–ს აქვს ის მნიშვნელობა, რომელიც მიმდინარე სტრიქონამდე ჰქონდა მინიჭებული, ხოლო მარცხენა მხარეში ჩაწერილ X–ს მნიშვნელობა მიენიჭება მიმდინარე სტრიქონის შესრულების შემდეგ.
მინიჭების ოპერაციის არსში უკეთ გასარკვევად განვიხილოთ მაგალითი, რომელიც ხშირად გვხვდება პრაქტიკაში. ვთქვათ, საჭიროა ორი ცვლადისათვის მნიშვნელობების გაცვლა, ანუ თუ a=4 და b=9, ჩვენი მოქმედებების შედეგად a უნდა გახდეს 9 და b უნდა გახდეს 4 (ცხადია, რომ მოქმედებები უნდა შესრულდეს არა კონკრეტული რიცხვებისათვის, არამედ ზოგადად).  უშუალოდ a=b; b=a; ბრძანებები სასურველ შედეგამდე ვერ მიგვიყვანს, რადგან პირველი ბრძანების შემდეგ ორივე ცვლადის მნიშვნელობა b-ის ტოლი გახდება და ამავე მნიშვნელობებს შეინარჩუნებენ ცვლადები მეორე ბრძანების შემდეგაც. დამატებითი (ვთქვათ, c) ცვლადის გამოყენებით ამოცანის ამოხსნა მარტივია. დავუშვათ, პროგრამის შესრულების რაღაც მომენტში a=4,  b=9 და c=0. ქვემოთ, ცხრილში ნაჩვენებია, თუ რა მნიშვნელობას მიიღებენ ცვლადები თითოეული სტრიქონის შესრულების შემდეგ:

პროგრამის კოდი	ცვლადების მნიშვნელობები შესაბამის ბიჯზე
	a	b	c
c=a;	4	9	4
a=b;	9	9	4
b=c;	9	4	4
იგივე ამოცანა შეიძლება გადაიჭრას დამატებითი ცვლადის გამოყენების გარეშეც. მაშინ ანალოგიურ ცხრილს ექნება სახე: 

პროგრამის კოდი	ცვლადების მნიშვნელობები შესაბამის ბიჯზე
	        a	b
a=a-b;	–5	9
b=a+b;	 –5	4
a=b-a;	9	4

 ქვემოთ მოყვანილია არითმეტიკული ოპერაციების აღნიშვნათა ცხრილი:

+	შეკრება
–	გამოკლება
*	გამრავლება
/	გაყოფა (როგორც მთელი, ასევე მოძრავმძიმიანი)
%	ნაშთის გამოთვლა
++	 ინკრემენტი (1–ით გაზრდა)
– –	 დეკრემენტი (1–ით შემცირება)

შეტანა–გამოტანის ოპერაციები C++–ში რამდენიმე განსხვავებული გზით ხორციელდება. ბრძანებათა ნაწილი (მაგალითად, scanf და printf) C–ის თავდაპირველ ვერსიაშიც არსებობდა, ხოლო უფრო პოპულარული cin და cout კი C++–ის შექმნის მერე დაემატა. ჩვენ, შეძლებისდაგვარად, ყველა ბრძანებას გამოვიყენებთ, რადგან ყველას აქვს თავისი უპირატესობა. მაგალითად, დიდი რაოდენობით რიცხვითი მონაცემების კითხვის ან გამოტანისას scanf და printf გაცილებით სწრაფია, ვიდრე cin და cout.

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

შესატანი მონაცემები	გამოსატანი მონაცემები
61	                                  7
20	                                  2

ანალიზი. ჯერ გავერკვიოთ მთელი გაყოფის არსში. C++-ში ბრძანებების შესრულებამდე აუცილებელია განისაზღვროს პროგრამაში გამოყენებული თითოეული ცვლადის ტიპი. რიცხვითი ცვლადების ორი უმთავრესი ტიპია – მთელი და მოძრავმძიმიანი (ანუ ათწილადი). თუ გაყოფის შედეგი მთელი ტიპის ცვლადს ენიჭება, მაშინ სრულდება ე.წ. მთელი გაყოფა (მაგ. 19/5=3) და ათწილადი ნაწილი იკარგება, ხოლო თუ გაყოფის შედეგი მოძრავმძიმიანი ტიპის ცვლადს ენიჭება, მაშინ გამოითვლება ათწილადი ნაწილიც (მაგ. 19/5=3.8). ჩვენს ამოცანაში მოქმედებები მხოლოდ მთელი ტიპის ცვლადებზე ხდება, ამიტომ მხოლოდ მთელი გაყოფის ოპერაციები სრულდება. ორნიშნა რიცხვის ერთეულების თანრიგში მდგომი ციფრი შეიძლება დავადგინოთ ამ რიცხვის 10-ზე გაყოფის ნაშთით, ხოლო ათეულების თანრიგში მდგომი ციფრი – ამ რიცხვის 10-ზე მთელი გაყოფით. ნაშთის გამოთვლის ოპერაცია ხდება “%” სიმბოლოთი, ხოლო მთელი გაყოფა “/” სიმბოლოთი. აქედან გამომდინარე გამოსახულება k=N%10+N/10; გამოითვლის N რიცხვის ერთეულების და ათეულების თანრიგებში მდგომი ციფრების ჯამს. მიაქციეთ ყურადღება გამოსახულების ბოლოში დასმულ წერტილ-მძიმეს. C++-ში აუცილებელია ნებისმიერი ბრძანება წერტილ-მძიმეთი მთავრდებოდეს.                               
ჯამი შეიძლება გამოვთვალოთ უშუალოდ გამოტანის ოპერატორში ან შეგვიძლია გამოტანამდე სხვა ცვლადს მივანიჭოთ მისი მნიშვნელობა.
ახლა ვნახოთ როგორ გამოიყურება პროგრამა სრული სახით.

#include<iostream>
using namespace std;                          
int N;
main(){                                                 
    cin>>N; 
    cout<<N/10+N%10;
}	

#include<stdio.h>
int N,k;
main(){                                                 
    scanf("%d",&N);   
    k=N/10+N%10;                                
    printf("%d”,k);
}

"ორივე კოდი ჩვენს ამოცანაზე ერთსა და იმავე პასუხებს იძლევა. განსხვავება მხოლოდ ის არის, რომ პირველი მათგანი  C++-ის ბრძანებებითაა დაწერილი, ხოლო მეორე მხოლოდ C-ის საშუალებებსაც იყენებს. პირველ პროგრამაში 3 ბრძანებაა, ხოლო მეორეში – 2 . დანარჩენი სტრიქონები შეიძლება შაბლონად ჩავთვალოთ და ყველა პროგრამისთვისაა აუცილებელი. ორივე პროგრამის პირველ სტრიქონში მოცემულია ე.წ. დირექტივა, რომელიც განსაზღვრავს, თუ რომელი სტანდარტული ფაილები უნდა ჩაერთოს ჩვენ მიერ დაწერილი პროგრამის შესრულებაში. include-ში მითითებულია კონკრეტული ფაილების (ზოგჯერ მათ ბიბლიოთეკებსაც უწოდებენ) სახელები, რომლებიც უზრუნველყოფენ C-ის და C++-ის ამა თუ იმ ფუნქციის შესრულებას. 
სტრიქონები int N,k; და int N; წარმოადგენენ ცვლადთა აღწერის ინსტრუქციას. პირველ შემთხვევაში აღწერილია მთელი  ტიპის (ამას განსაზღვრავს სიტყვა int ) ორი ცვლადი, ხოლო მეორე შემთხვევაში – ერთი. ცვლადის აღწერა კომპილატორს სჭირდება მისთვის საკმარისი მეხსიერების გამოსაყოფად.
main() წარმოადგენს პროგრამის მთავარი ფუნქციის სახელს (პროგრამისტს შეუძლია თავადაც შექმნას ფუნქციები და დაარქვას მათ სახელები) და ყველა ბრძანება მოთავსებული უნდა იყოს მისთვის განკუთვნილ ფიგურულ ფრჩხილებს შორის.  
cin და cout ოპერატორების, ისევე როგორც C++-ის სხვა ოპერატორების, გამოყენებისას აუცილებელია პროგრამის დასაწყისში „using namespace std“–ს მითითება. პირდაპირ თარგმანში ეს ფრაზა ნიშნავს „გამოიყენე std–ს სახელთა სივრცე“. std–ს სახელთა სივრცეს კი გამოიყენებს პრაქტიკულად ყველა ბიბლიოთეკა, რომელიც C++-ში ფუნქციონირებს.
მიაქციეთ ყურადღება, რომ scanf–ის გამოყენებისას ცვლადის სახელის წინ აუცილებელია სიმბოლო „&“–ის გამოყენება, რაც აღნიშნავს შესაბამისი ცვლადის მისამართს მეხსიერებაში. printf–ის მუშაობისას გამოიყენება ე.წ. გამოტანის შაბლონი, რომელიც ბრჭყალებს შორის არის მოთავსებული, და გამოტანის სპეციფიკაცია (%d), რომელიც მიუთითებს გამოსატანი ცვლადის ფორმატს (ჩვენს ამოცანაში „%d“ მთელი რიცხვის ფორმატს აღნიშნავს). შედეგების გამოტანისას „%d“–ის ნაცვლად დაიბეჭდება k ცვლადის მნიშვნელობა. 

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

შემავალი მონაცემების მაგალითი	     შესაბამისი გამომავალი მონაცემი
35  81	                                                     58.0
14  29	                                                     22.5
ანალიზი. ამ ამოცანაში გამოსატანი მონაცემები მთელი ტიპის არ არის, ამიტომ უნდა გამოვიყენოთ რომელიმე მოძრავძიმიანი ტიპი float ან double, თუმცა სწორი პასუხის მისაღებად მხოლოდ აღწერა საკმარისი არ არის. რადგან (a+b)/2 გამოსახულებაში ორივე ცვლადი მთელი ტიპისაა, შესრულდება  მთელი გაყოფის ოპერაცია და რიგ შემთხვევაში პროგრამა არასწორ პასუხს გამოიტანს. მაგ. ამოცანის მეორე ტესტში 22.5-ის ნაცვლად მივიღებთ 22.0-ს. ასეთი უზუსტობის თავიდან ასაცილებლად საჭიროა გამოსათვლელი გამოსახულების წინ მივუთითოთ ჩვენთვის სასურველი ტიპი. 
ორი მთელი რიცხვის საშუალო არითმეტიკული მძიმის შემდეგ მხოლოდ ერთ რიცხვს შეიძლება შეიცავდეს. გარკვეული მოქმედებებია საჭირო იმისათვის, თუ გვინდა, რომ ათწილადში ზედმეტი 0-ები არ დაიბეჭდოს. მძიმის შემდეგ ციფრის რაოდენობა cout-სათვის რეგულირდება setprecision ბრძანებით (სჭირდება ბიბლიოთეკა <iomanip.h>). იგივე საკითხი printf-ის გამოყენებისას გამოსატანი რიცხვის სპეციფიკაციაში მიეთითება (“%.1f).

#include<stdio.h>
int a,b;
float c;
main(){                                                 
    scanf("%d%d",&a,&b);
    c=(float) (a+b)/2;                                    
    printf("%.1f",c);
}	

#include<iostream>
#include <iomanip.h>
using namespace std;                          
int a,b;
double x;
main(){                                                 
   cin>>a>>b; 
   x=(double) (a+b)/2;                                                                                                      
   cout<< setprecision(1)<<x<<endl;
}


ამოცანა 3. სიგრძის ერთეულები
დაწერეთ პროგრამა, რომელიც ფუტებსა და დიუმებში მოცემულ სიგრძეს გადაიყვანს სანტიმეტრებში. 1 ფუტი=30,48სმ, 1 დიუმი=2,54სმ.
შესატანი მონაცემები: ორი მთელი რიცხვი - შესაბამისად ფუტებისა და დიუმების რაოდენობა. ორივე რიცხვი მოთავსებულია დიაპაზონში 1..100. 
გამოსატანი მონაცემები: ერთი ნამდვილი რიცხვი - იგივე სიგრძე სანტიმეტრებში.  

შესატანი მონაცემების მაგალითი            	შესაბამისი გამოსატანი მონაცემი
2 3	                                                                68.58

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

#include <iostream>
using namespace std;
int a,b;
main(){
  cin>>a>>b;
  cout<<a*30.48+b*2.54;
}

ამოცანა 4. სამნიშნა რიცხვის შებრუნებული ჩანაწერი
მოცემულია სამნიშნა მთელი რიცხვი N (100 <= N <= 999), რომელიც არ მთავრდება 0-ით. დაწერეთ პროგრამა, რომელიც  გამოიტანს ამ რიცხვის შებრუნებულ ჩანაწერს. 
შესატანი მონაცემები:  ერთი მთელი სამნიშნა რიცხვი N .
გამოსატანი მონაცემები: ერთი მთელი რიცხვი – N-ის შებრუნებული ჩანაწერი.

შემავალი მონაცემების მაგალითი	      შესაბამისი გამომავალი მონაცემი
845	                                                              548
601	                                                              106

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

#include<stdio.h>
int n,a,b,c;
main(){                                                 
   scanf("%d",&n);
   a=n%10; 
   b=(n/10)%10; 
   c=n/100;                                    
   printf("%d%d%d",a,b,c);
}	

#include<iostream>
using namespace std;                          
int n,a,b,c;
main(){                                                 
    cin>>n; 
    a=n%10; 
    b=(n%100)/10; 
    c=n/100;
    n=a*100+b*10+c;                                                                    
    cout<<n<<endl;
}

ამოცანა 5. დროის ფორმატი
მოცემულია  მთელი N (0 < N < 30000) წამი. დაწერეთ პროგრამა, რომელიც დროის იგივე მონაკვეთს გამოიტანს ფორმატით “საათი:წუთი:წამი”. 
შესატანი მონაცემები: ერთადერთ სტრიქონში მოცემულია ერთი მთელი რიცხვი N.
გამოსატანი მონაცემები: დროის იგივე შუალედი ამოცანაში მითითებული ფორმატით.
შესატანი მონაცემების მაგალითი	შესაბამისი გამოსატანი მონაცემი
3676                                                      	1:1:16
37	                                                        0:0:37
60                                                            0:1:0

ანალიზი. მოცემული რიცხვისაგან საათების რაოდენობის გასაგებად საჭიროა ის მთელი გაყოფით გავყოთ 3600-ზე (წამთა რაოდენობა საათში) და ცალ-ცალკე ცვლადებში დავიმახსოვროთ როგორც მთელი გაყოფის შედეგი, ასევე ნაშთი. ანალოგიურად, წუთების რაოდენობის დასადგენად საჭიროა უკვე მიღებული ნაშთი გავყოთ 60-ზე. ამ მთელი გაყოფის შედეგი იქნება წუთების რაოდენობა, ხოლო ნაშთი – წამების რაოდენობა. 
გამოტანისას საჭიროა ორწერტილების დასმა რიცხვებს შორის. cout-ში ამის გაკეთება მარტივი აღსაქმელია. ბრჭყალებში მოთავსებული ნებისმიერი ტექსტი უცვლელად იბეჭდება. იმავე მიზნისათვის printf-იც ბრჭყალებს იყენებს, ოღონდ ორწერტილები სპეციფიკაციებს შორის თავსდება და არა ცვლადებს შორის. ამ შემთხვევაშიც ბრჭყალებში მოთავსებული ტესტი უცვლელად იბეჭდება სპეციფიკაციების გარდა.

#include<stdio.h>
int n,clo,minu, sec;
main(){                                                 
    scanf("%d",&n);                                    
    clo=n/3600;
    minu=(n%3600)/60;
    sec=n%60;
    printf("%d:%d:%d",clo,minu,sec);
}	

#include<iostream>
using namespace std;                          
int n,clo,minu, sec;
main(){                                                 
   cin>>n;                                  
   clo=n/3600;minu=(n%3600)/60;
   sec=n%60;
   cout<<clo<<":"<<minu<<":"<<sec;
}
ამოცანა 6.  დროის შუალედი
მეტეოროლოგმა ჩაიწერა მზის ამოსვლის და ჩასვლის დროები წამების სიზუსტით. თითოეული ჩანაწერი მოცემულია ჰარით გაყოფილი სამი მთელი A , B და C რიცხვებით, რომლებიც შესაბამისად აღნიშნავენ საათს, წუთსა და წამს (1 ≤ A ≤ 23; 0 ≤ B, C ≤ 59). დაწერეთ პროგრამა, რომელიც  გამოითვლის რამდენი წამი გავიდა დროის ამ ორ მომენტს შორის. 
შესატანი მონაცემები: ორი სტრიქონიდან თითოეულში მოცემულია სამ-სამი მთელი რიცხვი – შესაბამისად მზის ამოსვლის და ჩასვლის დროები.
გამოსატანი მონაცემები: ერთი მთელი რიცხვი – განსხვავება დროის ორ მომენტს შორის წამებში.

შემავალი მონაცემების მაგალითი	    შესაბამისი გამომავალი მონაცემი
7    14   35                                                    36639
17  25   14	

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

#include<iostream>
using namespace std;                          
int a1,b1,c1,a2,b2,c2,x,y;
main(){                
    cin>>a1>>b1>>c1;
    cin>>a2>>b2>>c2; 
    x=a1*3600+b1*60+c1;
    y=a2*3600+b2*60+c2;                                       
    cout<<y-x;
}


                                                                         ამოცანა 7. დომინოს დაწყობა
                                                             http://codeforces.com/problemset/problem/50/A
მოცემულია მართკუთხა უჯრედოვანი დაფა, რომელიც შედგება  M×N  უჯრედისაგან. მასთან ერთად მოცემულია 2×1 ზომის დომინოს ქვები შეუზღუდავი რაოდენობით. საჭიროა დაფის დაფარვა დომინოს ქვებით ისე, რომ შესრულდეს შემდეგი პირობები: 
1. დომინოს ყოველი ქვა მთლიანად ფარავს დაფის ორ უჯრას; 
2. ქვების არცერთი წყვილი არ ფარავს ერთმანეთს (თუნდაც ნაწილობრივ);
3. ყოველი ქვა მთლიანად დევს დაფის შიგნით. კიდესთან შეხება დასაშვებია.
დომინოს ქვების შეტრიალება შესაძლებელია. გამოთვალეთ ქვების მაქსიმალური რაოდენობა, რომელიც დაფაზე დაეტევა.
შესატანი მონაცემები: ერთადერთ სტრიქონში მოცემულია ჰარით გაყოფილი ორი მთელი რიცხვი M  და N    (1 ≤ M ≤ N ≤ 16).
გამოსატანი მონაცემები: ერთი მთელი რიცხვი – დომინოს ქვების მაქსიმალური რაოდენობა, რომელიც დაფაზე დაეტევა.

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

ანალიზი. რადგან ქვების შეტრიალება ნებადართულია და თითოეული ქვა ზუსტად ორ უჯრას ფარავს, ცხადია, რომ ნებისმიერი ლუწი სიგრძის სტრიქონის ან სვეტის დაფარვა სრულადაა შესაძლებელი. ამ ფაქტის გამო დაფა მთლიანად დაიფარება ქვებით, თუკი მისი ერთ–ერთი გვერდი მაინც არის ლუწი სიგრძის. თუ ორივე გვერდი კენტი სიგრძისაა, მაშინ შეუვსებელი დარჩება მხოლოდ ერთი უჯრა. 
#include<iostream>
using namespace std;                          
int m,n;
main(){                
   cin>>m>>n; 
   cout<<m*n/2;
}

                                                                             ამოცანა 8. თეატრალური მოედანი
                                                                     http://codeforces.com/problemset/problem/1/A
თეატრალური მოედანი ბერლანდიის დედაქალაქში წარმოადგენს n×m მეტრი ზომის მართკუთხედს. ქალაქის იუბილესთან დაკავშირებით გადაწყდა, რომ მოედანზე დააგონ გრანიტის ფილები. თითოეული ფილის ზომაა a×a მეტრი.
რა მინიმალური რაოდენობის ფილაა საჭირო მოედნის დასაფარავად? დაშვებულია თეატრალურ მოედანზე უფრო დიდი ფართობის დაფარვა, ოღონდ მოედანი უსათუოდ მთლიანად უნდა დაიფაროს. გრანიტის ფილების დანაწევრება არ შეიძლება. ფილათა გვერდები მოედნის გვერდების პარალელური უნდა იყოს.
შესატანი მონაცემები: ერთადერთ სტრიქონში მოცემულია ჰარით გაყოფილი სამი მთელი რიცხვი n, m და a (1 ≤ n,m,a ≤ 109). 
გამოსატანი მონაცემები: ერთი მთელი რიცხვი – ფილების საჭირო რაოდენობა. 

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

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

#include<iostream>
using namespace std;                          
int m,n,a;
main(){                
    cin>>m>>n>>a; 
    cout<<((m+a–1)/a)*((n+a–1)/a);
}

                                                                       ამოცანა 9. ქათამნახევარი
ფერმის ხელმძღვანელობამ გამოთვალა, რომ საშუალოდ ქათამნახევარი დღენახევარში კვერცხნახევარს დებს. გამოთვალეთ რამდენ კვერცხს დებს n ქათამი m დღეში?  
შესატანი მონაცემები: მოცემულია ორი მთელი რიცხვი – n და m (1<n,m≤1000). n და m ექვსის ჯერადები არიან.
გამოსატანი მონაცემები: ერთი მთელი რიცხვი – ქათმების მიერ დადებული კვერცხების რაოდენობა.

შესატანი მონაცემების მაგალითი            	შესაბამისი გამოსატანი მონაცემი
6 9	                                                                36

ანალიზი. დადებული კვერცხების რაოდენობა იმდენჯერ მეტი იქნება 1.5–ზე, რამდენჯერაც მეტი  იქნებიან n და m 1.5–ზე ცალ–ცალკე, ანუ პასუხი იქნება 1.5*(n/1.5)*(m/1.5)=n*m/1.5.

#include <iostream>
using namespace std;
int n,m;
main(){
   cin>>n>>m;
   cout<<n*m/1.5;
}

ამოცანა 10. ათწილადი ნაწილი
მოცემულია ჰარით გაყოფილი ორი მთელი რიცხვი A და B (1≤A, B≤999). დაწერეთ პროგრამა, რომელიც  გამოიტანს A-ს B-ზე განაყოფის ათწილადი ნაწილის პირველ 3 ციფრს. 
შესატანი მონაცემები: ერთადერთ სტრიქონში მოცემულია ორი მთელი რიცხვი A და B .
გამოსატანი მონაცემები: ერთი მთელი რიცხვი – N-ის ციფრთა ჯამი.

შემავალი მონაცემების მაგალითი	    შესაბამისი გამომავალი მონაცემი
15  13                                                          0.153
22  5                                                     	    0.400

ანალიზი. პირველ რიგში გამოსათვლელია a ცვლადის b-ზე ჩვეულებრივი განაყოფი. ამის შემდეგ საჭიროა მოვაშოროთ მას მთელი ნაწილი. ეს კი მიიღწევა განაყოფისათვის იმავე რიცხვების მთელი გაყოფის შედეგად მიღებული რიცხვის გამოკლებით. კიდევ ერთხელ აღვნიშნოთ C++-ის თავისებურება მთელ რიცხვებთან დამოკიდებულებაში. კერძოდ, თუ გაყოფის ოპერაცია მთელ რიცხვებზე სრულდება, მაშინ შედეგიც ფორმირდება როგორც მთელი გაყოფის ოპერაციის დროს. ამიტომ საჭიროა ტიპის განსაზღვრა ოპერაციის შედეგისათვის. პირველ კოდში ეს ხორციელდება (float) ინსტრუქციით c=(float) a/b; სტრიქონში, ხოლო მეორეში – (double) ინსტრუქციით.  მძიმის შემდეგ 3 ციფრის გამოტანა რეგულირდება შესაბამისად printf და setprecision ბრძანებებით. 

#include<stdio.h>
#include<stdlib.h>           
int n,a,b;
float c;
main(){                                                 
    scanf("%d%d",&a,&b);
    c=(float) a/b -(int) a/b;                                    
    printf("%.3f",c);
}	

#include<iostream>
#include<stdlib.h> 
#include <iomanip.h>          
using namespace std;                          
int a,b;
double x;
main(){                                                 
    cin>>a>>b; 
    x=(double) a/b-(int) a/b;                                                                                                      
    cout<<setprecision(3)<<x;
}





                                                                       ამოცანა 11. საახალწლო სანთლები
                                                             http://codeforces.com/problemset/problem/379/A
ვასოს რომანტიკა უყვარს, ამიტომ გადაწყვიტა საახალწლოდ ოთახი სანთლებით გაანათოს. მას აქვს a ცალი სანთელი. როცა ვასო ანთებს ახალ სანთელს, ის იწვის ზუსტად 1 საათი და შემდეგ ქრება.  b  ცალი ჩამქრალი სანთლიდან ვასო აკეთებს ერთ სანთელს, რომელიც შეუძლია ახალივით გამოიყენოს.
ახლა ვასოს აინტერესებს, რამდენ საათის განმავლობაში ეყოფა მას თავისი სანთლები, თუკი ოპტიმალურად იმოქმედებს. დაწერეთ პროგრამა, რომელიც გამოთვლის ამ რიცხვს.
შესატანი მონაცემები: ერთადერთ სტრიქონში მოცემულია ორი მთელი რიცხვი a და b (1≤a≤1000; 2≤b≤1000).
გამოსატანი მონაცემები: ერთი მთელი რიცხვი – საათების რაოდენობა, რომლის განმავლობაშიც ვასოს შეუძლია ოთახის განათება.

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

განმარტება. პირველ მაგალითში ვასო აანთებს სანთლებს 4 საათის განმავლობაში და 4 დამწვარი სანთლიდან გააკეთებს ორ ახალს და როცა ეს ორიც დაიწვება, მათი ნარჩენიდან გააკეთებს კიდევ 1 ახალს, რაც ჯამში 7 საათის განმავლობაში გაანათებს.

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

#include<iostream>
using namespace std;
int main(){
    int a,b;
    cin>>a>>b;
    cout<<(a*b-1)/(b-1)<<endl;
}