ReverseInts.md

ReverseInts

ამოცანა:

კონსოლიდან შეგვყავს რიცხვები მანამ სანამ არ შეიყვანთ -1-ს, დაბეჭდეთ შეყვანილი
რიცხვები შებრუნებული მიმდევრობით.

ამოცანის ამოხსნა

ამოცანა დავყოთ ორ კომპონენტად:

• მომხმარებლის ინფუთის წაკითხვა და შენახვა.
• რიცხვების შებრუნებული მიმდევრობით დაბეჭდვა. ორივე კომპონენტისთვის ცალკე მეთოდი დავწეროთ.

ინფუთის წაკითხვა და შენახვა

ინფუთის წასაკითხად გამოვიყენოთ ბრძანება readInt(). მომხმარებლისთვის ადვილად გასაგები რომ იყოს, readInt() ბრძანებას არგუმენტად გადავცეთ რაიმე სტრინგი. შემოსული რიცხვი კი ცვლადში შევინახოთ. ამოხსნის ეს ნაწილი კოდში შემდეგნაირად აისახება:

int n = readInt("Enter a number: ");

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

while(true) {
    int n = readInt("Enter a number: ");
    if(n == SENTINEL) break;
}

ინფუთის წაკითხვის გარდა გვჭირდება მისი შენახვა. რადგანაც წინასწარ არ ვიცით რიცხვების რაოდენობა, შეგვიძლია ArrayList კლასი გამოვიყენოთ. ამისათვის დაგვჭირდება java.util.*-ის დაომპორტება:

import java.util.*;

შევქმნათ ArrayList<Integer> list და ყოველი შემოსული რიცხვი შევინახოთ მასში (გარდა -1-ისა). როდესაც დავასრულებთ რიცხვების წაკითხვას, list დავაბრუნოთ. ეს ყველაფერი ერთი მეთოდის ნაწილი იქნება, რომელსაც კითხვადობისათვის დავარქვათ readArrayList(). მთლიანობაში კოდს ასეთი სახე ექნება:

private ArrayList<Integer> readArrayList() {
    ArrayList<Integer> list = new ArrayList<Integer>();
    while(true) {
        int n = readInt("Enter a number: ");
        if(n == SENTINEL) break;
        list.add(n);
    }
    return list;
}

რიცხვების შებრუნებული მიმდევრობით დაბეჭდვა

შემოყვანილი რიცხვები list-ში გვაქვს დამახსოვრებული და ახლა მათი შებრუნებული თანმიმდევრობით დაბეჭდვა გვინდა. ეს for() ციკლით გავაკეთოთ. თუკი list-ს ბოლოდან გადავუყვებით და ყოველ ელემენტს დავბეჭდავთ, რიცხვები შებრუნებული მიმდევრობით დაიბეჭდება. ამისათვის შევინახოთ list-ის ზომა რაიმე ცვლადში და for() ციკლს შემდეგი სახე მივცეთ:

int length = list.size();
for(int i=length-1;i>=0;i--) {
    println(list.get(i));
}

ამისთვისაც ცალკე მეთოდი გავაკეთოთ, რომელსაც არგუმენტად list-ს გადავცემთ.

რატომ იმუშავებს ამოხსნა ნებისმიერი შემოყვანილი მონაცემებისთვის?

რადგანაც მონაცემების წაკითხვა while() ციკლით გვიწერია, ამოხსნა იმუშავებს ნებისმიერი რაოდენობის ინფუთისთვის. while() ციკლი წაიკითხავს და შეინახავს რიცხვებს მანამ, სანამ მომხმარებელი -1-ს არ შემოიყვანს.

რატომ გამოვიყენეთ ArrayList და არა Array?

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

რატომ არის -1 კონსტანტა?

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