ერთგანზომილებიანი მასივები
            ერთგანზომილებიანი მასივები
ვთქვათ, დასამუშავებლად მოგვცეს რომელიმე ქალაქის ტემპერატურული მონაცემები 5 წლის მანძილზე. ეს 1800 რიცხვზე მეტია. ცხადია, რომ მათ შესანახად და მითუმეტეს დასამუშავებლად ამდენივე ცვლადის აღწერა ძალზე მოუხერხებელია. ასეთ შემთხვევაში ეფექტურია სპეციალური სტრუქტურის – მასივის გამოყენება, რომელიც საშუალებას იძლევა ერთი სახელისა და სპეციალური ნომრის – ინდექსის საშუალებით ერთმანეთისაგან განვასხვავოთ ათასობით და ზოგჯერ მილიონობით მონაცემი.
მასივები, ცვლადების მსგავსად, პროგრამაში წინასწარ უნდა აღიწეროს. მასივის გამოცხადების ზოგადი ფორმა ასეთია:

          ტიპი მასივის_სახელი [მასივის_ზომა];
მასივის ტიპთან და სახელთან მიმართება ხორციელდება იმავე პრინციპებით, როგორც ეს ცვლადების მიმართ ხდება. მასივი ზომა კი ყოველთვის ცხადად უნდა იყოს გამოცხადებული, რათა კოპილატორმა შეძლოს შესაბამისი უწყვეტი ადგილის გამოყოფა მეხსიერებაში. მასივის ზომა პროგრამის მუშაობის განმავლობაში უცვლელი რჩება. აქ ხაზი უნდა გავუსვათ ერთ გარემოებას, რომელიც ხშირად ხდება შეცდომის მიზეზი დამწყები პროგრამისტებისათვის: მასივისათვის გამოსაყოფი მეხსიერება შეზღუდულია და ძალიან დიდი ზომის მასივების გამოცხადებისას პროგრამა საერთოდ არ კომპილირდება. მეხსიერების შეზღუდვა ზოგჯერ განპირობებულია სამუშაო გარემოს (რედაქტორის) მიერ, ზოგჯერ – კომპიუტერის ოპერატიული მეხსიერების მიერ. საოლიმპიადო ამოცანებს კი ყოველთვის მიეთითებათ მეხსიერების ლიმიტი. აქ გამოსავალი მარტივია: უნდა გამოვთვალოთ მასივის მიერ დაკავებული მეხსიერების სიდიდე. ამისათვის მასივის ზომა უნდა გადავამრავლოთ მასივის ტიპისათვის საჭირო ბაიტების რაოდენობაზე. მაგალითად, char a[1000];  მასივი მეხსიერებაში დაიკავებს  1000 ბაიტს, რადგან char ტიპი ერთბაიტიანი მონაცემია, ხოლო double temp[500000000] დაიკავებს 4 გიგაბაიტს, რადგან double ტიპი მეხსიერებაში 8 ბაიტს იკავებს.
მასივის ელემენტის წვდომა ხორციელდება მასივის სახელისა და ინდექსის საშუალებით. ჩანაწერი temp[5]=17.4732; ნიშნავს, რომ მასივის მეხუთე ელემენტს მიენიჭა 17.4732.
C++–ში მასივის პირველი ელემენტის ინდექსი ყოველთვის 0–ის ტოლია, ამიტომ ოპერატორი char a[100];  ნიშნავს, რომ შეიქმნა 100–ელემენტიანი მასივი a[0]–დან  a[99]–მდე, ხოლო ელემენტი a[100] არ არსებობს. ეს მომენტიც ხშირად ხდება შეცდომის მიზეზი საწყის ეტაპზე, ისევე როგორც მასივის ელემენტის ინდექსისა და ელემენტის მნიშვნელობის ურთიერთმიმართება.

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

შესატანი მონაცემები: პირველ სტრიქონში მოცემულია ერთი მთელი რიცხვი n (1≤n≤100) – ხეივანში ხეების რაოდენობა. მეორე სტრიქონი შეიცავს n ცალ მთელ რიცხვს s1, s2,...,sn (1≤si ≤100), სადაც si – i-ური ხის სიმაღლე ხეივანში.

გამოსატანი მონაცემები: ერთი მთელი რიცხვი – ყველაზე მაღალ ხესთან ხუთკუნჭულას მისვლის დრო. პასუხის ერთადერთობა გარანტირებულია.

შესატანი მონაცემების მაგალითი                                 შესაბამისი გამოსატანი მონაცემი
8                                                                                        6
129 341 86 209 532 61 600 98
	
 ანალიზი. ეს ამოცანა შეიძლება განვიხილოთ, როგორც მასივში მაქსიმუმის ძებნის ამოცანა, ოღონდ გამოსატანია არა უშუალოდ მაქსიმუმის მნიშვნელობა, არამედ მისი ინდექსი მასივში. მაქსიმუმის (და ანალოგიურად მინიმუმისაც) ძებნა მასივში ასე ხორციელდება: რაიმე ცვლადს მივანიჭოთ მასივის პირველი ელემენტის მნიშვნელობა. დაწყებული მეორედან, მასივის ყველა წევრი რიგრიგობით შევადაროთ ამ ცვლადს და თუ რომელიმე მათგანი მეტი იქნება ცვლადის მიმდინარე მნიშვნელობაზე – შევცვალოთ ცვლადის მნიშვნელობა მასივის ამ ელემენტის მნიშვნელობით.  გაითვალისწინეთ, რომ ამოცანაში ხეები გადანომრილია 1–დან, ხოლო მასივის ელემენტები 0–დან.


#include <cstdio>
int N,i, mx,indexi,a[100];
main() {
   scanf( "%d", &N);
      for (i=0; i<N; i++)
            scanf( "%d", &a[i]);
  mx=a[0]; indexi=0;
      for (i=1; i<N; i++){
            if (a[i]>mx)  {mx=a[i]; indexi=i;}
}
printf(“%d”,indexi);
}



ამოცანა 107. კამათელი
მოცემულია კამათლის N-ჯერ (0 < N < 30000) გაგორების შედეგები. დაწერეთ პროგრამა, რომელიც დაადგენს, თუ რომელი ქულა მოვიდა ყველაზე მეტჯერ.
შესატანი მონაცემები: პირველ სტრიქონში მოცემულია ერთი მთელი რიცხვი N – კამათლის გაგორების რაოდენობა. მეორე სტრიქონი შეიცავს N ცალ მთელ რიცხვს s1, s2,...,sn (1≤si≤6), სადაც si – i-ური გაგორების დროს მოსული ქულაა.
გამოსატანი მონაცემები: ერთი მთელი რიცხვი – ყველაზე მეტჯერ მოსული ქულა. თუ პასუხი რამდენიმეა, შესაბანისი ქულები გამოიტანეთ ზრდადობით დალაგებული.

შესატანი მონაცემების მაგალითი                                 შესაბამისი გამოსატანი მონაცემი
15                                                                                         4     5
3 1 5 2 2 6 5 4 1 4 5 6 5 4 4
	
ანალიზი. ეს ამოცანა გარკვეულწილად მოიცავს წინას (მასივში მაქსიმუმის მოძებნა). განსხვავება იმაშია, რომ მაქსიმუმი შეიძლება რამდენიმე იყოს. გარდა ამისა, ჯერ დასათვლელია თითოეული ქულის მოსვლის რაოდენობა, რისთვისაც ისეთ ხერხს გამოვიყენებთ, რომლიც სხვა ამოცანებშიც ბევრჯერ დაგვჭირდება. ავიღოთ 7–ელემენტიანი მასივი (სინამდვილეში ექვსელემენტიანი გვჭირდება და ნულოვან ინდექსზე მყოფ ელემენტს არ გამოვიყენებთ) და შემოსატანი რიცხვების შესაბამის ინდექსებზე მყოფ ელემენტებს რიგრიგობით დავუმატოთ 1. ამოცანის მაგალითის მიხედვით ჯერ მესამე ელემენტს დავუმატოთ 1, შემდეგ – პირველს, შემდეგ – მეხუთეს და ა.შ. პროგრამულ კოდში ეს ხორციელდება შემოსატანი მონაცემების წაკითხვასთან ერთად. საბოლოოდ, თითოეულ ინდექსზე მივიღებთ შესაბამისი ქულის მოსვლათა რაოდენობას.

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

#include <iostream>
using namespace std;
int N,i,k, mx,a[7];
main() {
   cin>>N;
   for (i=0; i<N; i++){
        cin>>k;
   a[k]++;}
   mx=a[1];
   for (i=2; i<=6; i++)
            if (a[i]>mx)  mx=a[i];
   for (i=1; i<=6; i++)
        if (a[i]==mx) cout<<i<<” ”;
}

ამოცანა 108. აღმართები
მოცემულია საავტომობილო გზის სიმაღლეთა აღწერა  გარკვეულ ტოლ მონაკვეთებში. დაადგინეთ რამდენი აღმართია ამ გზაზე.
შესატანი მონაცემები: პირველ სტრიქონში მოცემულია ერთი მთელი რიცხვი N (1≤ N ≤100)  - გზის მონაკვეთთა რაოდენობა. მომდევნო სტრიქონში ჩაწერილია თითოეული მონაკვეთის სიმაღლე (N ცალი მთელი დადებითი რიცხვი 1-დან 20-მდე დიაპაზონში).
გამოსატანი მონაცემები: ერთადერთ სტრიქონში გამოიტანეთ ერთი მთელი არაუარყოფითი  რიცხვი –  აღმართების რაოდენობა გზაზე.

შესატანი მონაცემების მაგალითი                                            შესაბამისი გამოსატანი მონაცემი
14                                                                                                4
5  3  7  9  9  8  6  7  7  5  6  8  6  7
	
ანალიზი. ამოცანის მაგალითზე დაკვირვებითაც შეიძლება შევამჩნიოთ ფაქტი, რომ აღმართი იწყება მაშინ, როდესაც რომელიმე რიცხვი მის მარცხენა მეზობელ რიცხვზე ნაკლები ან ტოლია, ხოლო მარჯვენა მეზობელზე – მკაცრად ნაკლებია. გამონაკლისი მხოლოდ პირველი რიცხვია, რომელსაც მარცხენა მეზობელი არ ჰყავს, მაგრამ მაინც შეიძლება იყოს აღმართის დასაწყისი. ამ შემთხვევის ზოგად სქემაში მოსაქცევად შემოსატანი რიცხვები მასივში ჩავწეროთ პირველი ინდექსიდან, ხოლო ნულოვან ინდექსზე ჩავწეროთ პირველი ელემენტის ტოლი რიცხვი.

#include <iostream>
using namespace std;
int N,i,ans,a[105];
main() {
   cin>>N;
   for (i=1; i<=N; i++){
        cin>>a[i];}
   a[0]=a[1];
   for (i=1; i< N; i++)
            if (a[i]<=a[i-1] && a[i]<a[i+1])  ans++;
cout<<ans;
}

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

შესატანი მონაცემები: პირველ სტრიქონში მოცემულია ერთი მთელი რიცხვი N (1≤ N ≤100)  - გზის მონაკვეთთა რაოდენობა. მომდევნო სტრიქონში ჩაწერილია თითოეული მონაკვეთის სიმაღლე (N ცალი მთელი დადებითი რიცხვი 1-დან 20-მდე დიაპაზონში).

გამოსატანი მონაცემები: ერთადერთ სტრიქონში გამოიტანეთ ერთი მთელი არაუარყოფითი  რიცხვი –  მწვერვალების რაოდენობა გზაზე.

შესატანი მონაცემების მაგალითი                                            შესაბამისი გამოსატანი მონაცემი
15                                                                                                   3
8  5  4  6  5  3  2  4  5  5  7  9  8  9  8
	
ანალიზი. ეს ამოცანა წინას მსგავსია. განსხვავება იმაშია, რომ პირველი და ბოლო ელემენტები მწვერვალები ვერ იქნებიან, ხოლო ელემენტი, რომელიც მწვერვალი იქნება მკაცრად მეტი უნდა იყოს ორივე მეზობელზე – მარცხნივაც და მარჯვნივაც.

 

#include <iostream>
using namespace std;
int N,i,ans,a[105];
main() {
   cin>>N;
   for (i=0; i<N; i++){
        cin>>a[i];}
   for (i=1; i<N–1; i++)
            if (a[i]>a[i-1] && a[i]>a[i+1])  ans++;
cout<<ans;
}

ამოცანა 110. გრძელი არითმეტიკა
გამოთვალეთ N! (N! იკითხება, როგორც „N–ის ფაქტორიალი“ და წარმოადგენს ყველა მთელი რიცხვის ნამრავლ 1–დან N–მდე).
შესატანი მონაცემები: მოცემულია ერთი მთელი რიცხვი N (1≤N≤1000).
გამოსატანი მონაცემები: ერთი მთელი რიცხვი –  N–ის ფაქტორიალი.

შესატანი მონაცემების მაგალითი                  შესაბამისი გამოსატანი მონაცემი
5                                                                                 120
37                                                                                13763753091226345046315979581580902400000000

 ანალიზი. ამოცანის სირთულე იმაში მდგომარეობს, რომ შემოსატანი რიცხვების უმეტესობის ფაქტორიალი არცერთი მთელი ტიპის დიაპაზონში არ თავსდება. სწორედ ასეთ შემთხვევაში იტყვიან, რომ საქმე გვაქვს ე.წ. „გრძელ არითმეტიკასთან“ (ზოგჯერ დიდი რიცხვების არითმეტიკასაც უწოდებენ) და ასეთი ამოცანების ამოსახსნელად მასივს იყენებენ. მთელი რიცხვის თანრიგები შევუსაბამოთ მასივის ელემენტებს. უხეში შეფასებითაც ჩანს, რომ ყველაზე დიდი შემოსატანი რიცხვის – 1000–ის ფაქტორიალი 3000–ნიშნაზე მეტი ვერ იქნება (ყველა გადასამრავლებელი რიცხვის თანრიგების რაოდენობა რომ შევკრიბოთ), ამიტომ ავიღოთ 3000–ელემენტიანი მასივი და ელემენტი ინდექსით 3000, ჩავთვალოთ პასუხის ერთეულთა თანრიგად, ელემენტი ინდექსით 2999, ჩავთვალოთ  ათეულთა თანრიგად და ა.შ.  ჩავწეროთ a[3000]–ში 1 (სხვებში თავიდან 0–ები წერია) და მასივის ყველა ელემენტი რიგრიგობით გადავამრავლოთ რიცხვებზე 2–დან  N–მდე. ყოველი გადამრავლების შემდეგ მასივის ზოგიერთ ელემენტში გაჩენილი „ზედმეტი“ თანრიგები (მომდევნო გადამრავლების წინ ყველა ელემენტი მკაცრად ერთთანრიგიანი უნდა გახდეს) გადავანაცვლოთ მეზობელ მარცხენა თანრიგში. 

#include<iostream>
using namespace std;
int a[3001],i,j,k,N;
int main(){
cin>>N;
a[3000]=1;
      for  (i=2; i<=N; i++) {
     for (j=1; j<=3000; j++) {
                 a[j]=a[j]*i; }
         for (j=3000; j>=1; j--) {
              a[j-1]+=a[j]/10; a[j]=a[j]%10;  }  }
     for (j=1; j<=3000; j++) if (a[j]!=0) break;
  for(i=j; i<=3000; i++)  cout<<a[i];
}

 

ამოცანა 111. თამაში
(IOI, მერვე საერთაშორისო ოლიმპიადა, უნგრეთი, 1996 წელი)
განვიხილოთ შემდეგი თამაში ორი მოთამაშისათვის: სათამაშო დაფაზე დაწერილია მთელი დადებითი რიცხვების მიმდევრობა. მოთამაშეები სვლებს აკეთებენ რიგ-რიგობით. სვლა მდგომარეობს შემდეგში: მოთამაშე ირჩევს მიმდევრობის რომელიმე კიდურა წევრს (მარცხენას ან მარჯვენას). არჩეული რიცხვი დაფიდან იშლება. თამაში დამთავრდება მაშინ, როცა დაფაზე ყველა რიცხვი წაიშლება. პირველი მოთამაშე იმ შემთხვევაში გაიმარჯვებს, თუ მეორე მოთამაშის მიერ არჩეული ჯამი მეტი არ იქნება მის მიერ არჩეული რიცხვების ჯამზე. გაითვალისწინეთ, რომ მეორე მოთამაშე საუკეთესო ალგორითმით თამაშობს.
თამაშს ყოველთვის პირველი მოთამაშე იწყებს.
ცნობილია, რომ თუ დაფაზე თავიდან დაწერილი მიმდევრობის წევრთა რაოდენობა ლუწია, მაშინ პირველ მოთამაშეს მოგების შანსი აქვს. დაწერეთ პროგრამა, რომელშიც რეალიზებული იქნება პირველი მოთამაშის მომგებიანი სტრატეგია. საწყისი მიმდევრობის წევრთა რაოდენობა N ყოველთვის ლუწია და 2<=N<=100.

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

 

ამოცანა 112. წილადის პერიოდი
განვიხილოთ m/n წესიერი წილადი, სადაც m და n ნატურალური რიცხვებია. თუკი m-ის n-ზე გაყოფისას გაყოფა შეწყდა, იტყვიან, რომ m/n წილადის პერიოდი არის 0, ხოლო თუ გაყოფის პროცესი უსასრულოდ გაგრძელდა, მაშინ განაყოფში აუცილებლად მოიძებნება რიცხვთა განმეორებადი მიმდევრობა, რომელსაც წილადის პერიოდს უწოდებენ.
დაწერეთ პროგრამა, რომელიც იპოვის წესიერი წილადის პერიოდს.
შესატანი მონაცემები: ორი მთელი რიცხვი m და n (2≤ m < n ≤1000).
გამოსატანი მონაცემები: ერთი მთელი რიცხვი –  წილადის პერიოდი.

შესატანი მონაცემების მაგალითი                                     შესაბამისი გამოსატანი მონაცემი
3 4                                                                                        0
19 28                                                                                     857142
22 23                                                                                     9565217391304347826086

 
ანალიზი.  შემოვიღოთ 1000-ელემენტიანი ერთგანზომილებიანი k მასივი და შევავსოთ 0-ებით. რადგან მოცემული წილადი წესიერია, თავიდან m რიცხვი, შემდეგში კი გაყოფის შედეგად დარჩენილი ნაშთი ციკლში გავამრავლოთ 10-ზე და გავყოთ n-ზე. თითოეულ ბიჯზე მიღებული ნაშთის შესაბამის ინდექსზე k მასივში ჩავწეროთ 1-იანი – თუკი იქ 0 დაგვხვდება, ხოლო თუკი 1-იანი დაგვხდება – პროცესი შევწყვიტოთ, რადგან ეს ნიშნავს, რომ ნაშთი განმეორდა და ყველაფერი თავიდან იწყება.

#include<iostream>
using namespace std;
int a[1001],i,j,k,m,n;
int main(){
   cin>>m>>n;
   k=m;
   for  (i=0; i<=2*n; i++) {
        m=k*10;       k=m%n;
        if (a[k]==2) break;
        if (a[k]==1) {cout<<m/n; a[k]++;}
        if (a[k]==0) a[k]++;
     }                          
}
 

 

ამოცანა 113. სრულყოფილი კრებული
ხორვატიის ღია პირველობა ინფორმატიკაში (2007/08 წელი, შეჯიბრი 2)
მირკომ სხვენზე ძველისძველი საჭადრაკო დაფა იპოვა ჭადრაკის ფიგურების კრებულთან ერთად. სამწუხაროდ, კრებულში მხოლოდ თეთრი ფერის ფიგურებია და ისინიც არ არიან სრულყოფილად დაკომპლექტებული. ერთი ფერის ფიგურების სრულყოფილი კრებული უნდა შეიცავდეს: 1 მეფეს, 1 ლაზიერს, 2 ეტლს, 2 კუს, 2 მხედარს და 8 პაიკს.
მირკოს სურს იცოდეს, რამდენი ფიგურის დამატება ან მოშორებაა საჭირო ფიგურათა თითოეული ტიპისათვის სრულყოფილი კრებულის მისაღებად.
შესატანი მონაცემები: ერთადერთ სტრიქონში მოცემულია ექვსი მთელი რიცხვი. ყოველი მათგანი მოთავსებულია 0–დან 10–მდე დიაპაზონში (ჩათვლით). რიცხვები თანმიმდევრულად აღნიშნავენ მეფის, ლაზიერის, ეტლის, კუს, მხედრისა და პაიკის იმ რაოდენობებს, რომელიც მირკომ იპოვა.

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

შემავალი მონაცემების მაგალითი                                          შესაბამისი გამომავალი მონაცემი
0 1 2 2 2 7                                                                                     1 0 0 0 0 1
2 1 2 1 2 1                                                                                     -1 0 0 1 0 7

 

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

 #include <cstdio>
main() {
   int x, target[] = { 1, 1, 2, 2, 2, 8 };
   for( int i = 0; i < 6; ++i ) {
      scanf( "%d", &x );
      if( i>0 ) printf( " " );
      printf( "%d", target[i] - x );
   }
      printf( "\n" );
}