diff --git a/problem-set/SchoolGraphics.java b/problem-set/SchoolGraphics.java new file mode 100644 index 0000000..ca6fab9 --- /dev/null +++ b/problem-set/SchoolGraphics.java @@ -0,0 +1,154 @@ +/* + * File: SchoolGraphics.java + * ---------------------------- + * ამოცანის პირობა: + * ჩათვალეთ რომ წინა ამოცანაში აღწერილი School კლასი უკვე არსებობს და შეგიძლიათ + * გამოყენება. დაწერეთ გრაფიკული პროგრამა რომელიც მოგვცემს საშუალებას დავამატოთ + * სკოლის შესახებ მონაცემები და შემდეგ გავფილტროთ. სურათზე ნაჩვენებია თუ როგორ უნდა + * გამოიყურებოდეს გრაფიკული პროგრამა: + */ +import java.awt.event.ActionEvent; +import java.util.Iterator; + +import javax.swing.JButton; +import javax.swing.JLabel; +import javax.swing.JTextField; + +import acm.graphics.GLabel; +import acm.program.*; + +public class SchoolGraphics extends GraphicsProgram { + + private final int RESULT_X = 40; + private final int LINE_H = 30; + + private JTextField teachField = new JTextField(15); + private JTextField subjField = new JTextField(15); + private JTextField pupilField = new JTextField(15); + + private JButton addTeachButton = new JButton("Add Teach"); + private JButton addSubjButton = new JButton("Add Subj"); + private JButton addPupilButton = new JButton("Add Pupil"); + + private JButton displayPupilsButton = new JButton("Display Pupils"); + private JButton displayTeachersButton = new JButton("Display Teachers"); + + private School school = new School(); + + public void init() { + setSize(1300, 800); + + initFields(); + + addActionListeners(); + } + + + @Override + public void actionPerformed(ActionEvent e) { + + if (e.getSource() == addTeachButton) { + onAddTeachButtonCLicked(); + + } else if (e.getSource() == addSubjButton) { + onAddSubjButtonCLicked(); + + } else if (e.getSource() == addPupilButton) { + onAddPupilButtonCLicked(); + + } else if (e.getSource() == displayPupilsButton) { + onDisplayPupilsClicked(); + + } else if (e.getSource() == displayTeachersButton) { + onDisplayTeachersClicked(); + } + } + + private void onDisplayTeachersClicked() { + String pupil = pupilField.getText(); + Iterator it = school.getTeachers(pupil); + drawIterator(it); + clearFields(); + } + + private void onDisplayPupilsClicked() { + String teacher = teachField.getText(); + Iterator it = school.getPupils(teacher); + drawIterator(it); + clearFields(); + } + + private void onAddTeachButtonCLicked() { + String teacher = teachField.getText(); + if (!teacher.isEmpty()) { + school.addTeacher(teacher); + clearFields(); + } + } + + private void onAddSubjButtonCLicked() { + String teacher = teachField.getText(); + String subject = subjField.getText(); + + if (!teacher.isEmpty() && !subject.isEmpty()) { + school.addSubject(teacher, subject); + clearFields(); + } + } + + + private void onAddPupilButtonCLicked() { + String subject = subjField.getText(); + String pupil = pupilField.getText(); + + if (!subject.isEmpty() && !pupil.isEmpty()) { + school.addPupil(pupil, subject); + clearFields(); + } + + } + + private void initFields() { + JLabel teachLabel = new JLabel("Teach:"); + JLabel subjLabel = new JLabel("Subj:"); + JLabel pupilLabel = new JLabel("pupil:"); + + add(teachLabel, SOUTH); + add(teachField, SOUTH); + + add(subjLabel, SOUTH); + add(subjField, SOUTH); + + add(pupilLabel, SOUTH); + add(pupilField, SOUTH); + + add(addTeachButton, SOUTH); + add(addSubjButton, SOUTH); + add(addPupilButton, SOUTH); + + add(displayPupilsButton, SOUTH); + add(displayTeachersButton, SOUTH); + } + + private void clearFields() { + teachField.setText(""); + subjField.setText(""); + pupilField.setText(""); + } + + private void drawIterator(Iterator it) { + if (it == null) + return; + + removeAll(); + + GLabel result = new GLabel("Results: "); + int y = LINE_H; + add(result, RESULT_X,y); + while (it.hasNext()) { + GLabel label = new GLabel(it.next()); + y += LINE_H; + add(label, RESULT_X, y); + } + } +} \ No newline at end of file diff --git a/problem-set/SchoolGraphics.md b/problem-set/SchoolGraphics.md new file mode 100644 index 0000000..399cd39 --- /dev/null +++ b/problem-set/SchoolGraphics.md @@ -0,0 +1,34 @@ +# SchoolGraphics + +პრობლემა: +``` +ჩათვალეთ რომ წინა ამოცანაში აღწერილი School კლასი უკვე არსებობს და შეგიძლიათ +გამოყენება. დაწერეთ გრაფიკული პროგრამა რომელიც მოგვცემს საშუალებას დავამატოთ +სკოლის შესახებ მონაცემები და შემდეგ გავფილტროთ. სურათზე ნაჩვენებია თუ როგორ უნდა +გამოიყურებოდეს გრაფიკული პროგრამა: +``` + + + +## პრობლემის გადაჭრის გზა: +გრაფიკული მხარის დასამატებლად, საჭიროა, 3 ეტაპი: + *ინიციალიზაცია გავუკეთოთ ჩვენი პროგრამის ინტერფეისის კომპონენტებს; + *ინტერფეისი დავუკავშიროთ School ამოცანაში დაწერილ ლოგიკას. +--- + +### I. ინიციალიზაცია: + * თავდაპირველად ქვედა ბარის გასაკეთებლად (როგორც ეს სურათზეა ნაჩვენები) დაგვჭირდება : + ** 3 JLabel (Teach: Subj: Pupil:) + ** 3 JTextField - ლეიბლების შესაბამისად + ** 5 JButton. + Text Field-ებისა და Button-ების აღწერა ინსტანს ცვლადებად ჯობია, რადგან სხვა მეთოდებშიც (ინიტის გარდა) დაგვჭირდება მათი გამოყენება, ხოლო Label-ები შეგვიძლია ლოკალურად შევქმნათ ერთხელ. კომპონენტებს ინიციალიზაცია რომ გავუკეთოთ ამისათვის გავაკეთოთ ცალკე მეთოდი initFields() რომელშიც ჩვენს ლეიბლებს აღვწერთ და დავამატებთ, ასევე ტექსტურ ველებსა და ღილაკებს დავამატებთ SOUTH რეგიონში, სურათში მოცემული მიმდევრობის მიხედვით. (ანუ ჯერ teachLabel, შემდეგ teachField, შემდეგ subjLabel და ა.შ.) + +### II. დამატებულ ღილაკებზე მოსმენა: + * ღილაკებზე დაჭერისას ჩვენს პროგრამას რეაგირება რომ ჰქონდეს, გამოვიყენოთ actionPerformed მეთოდი და ვნახოთ event-ის source, რა არის (e.getSource() ) და შევამოწმოთ რომელიმე ღილაკს თუ ემთხვევა source, მაშინ გამოვიძახოთ მაგ ღილაკის შესაბამისი ლოგიკა, ხოლო საამისოდ ჯერ უნდა დავწეროთ ეს ლოგიკა. + +### III. დამხმარე მეთოდი drawIterator() : + * ყოველი ღილაკის დაჭერის შემდეგ ჩვენმა პროგრამამ გარკვეული სია უნდა დაბეჭდოს, იქნება ეს მოსწავლეების თუ მასწავლებლების, ამიტომ გავაკეთოთ დამხმარე მეთოდი, რომელსაც გადაეცემა String-ებზე iterator-ი (ჩვენ მხოლოდ ამ iterator-ზე გადაყოლა გვჭირდება, ამიტომ ვიყენებთ უფრო აბსტრაქტულ ტიპს ვიდრე ArrayList, ან მსგავსი სხვა ტიპია). თავდაპირველად ვამატებთ result ლეიბლს და შემდგომ LINE_H-ის დაშორებით ვერტიკალურად ვაჩენთ ეკრანზე ჩვენს შედეგს. + +### IV. ღილაკების ლოგიკა : + * display teachers-ზე დაჭერისას უბრალოდ სკოლიდან ვიძახებთ მეთოდს getTeachers და გადავცემთ ჩვენს დამხმარე მეთოდ drawIterator-ს პასუხს. ანალოგიურად ვიქცევით display pupils- ღილაკზე დაჭერისას. add teacher-ზე დაჭერისას ვამოწმებთ ჩვენს teach-ის შესაბამის ტექსტურ ველს ცარიელი არის თუ არა და მხოლოდ იმ შემთხვევაში თუკი არაა ცარიელი ვიძახებთ School ტიპის ობიექტზე მეთოდს addTeacher-ს და არ უნდა დაგვავიწყდეს ველების გასუფთავება. add subj ღილაკზე დაჭერისას გვჭირდება მასწავლებლის და საგნის ტექსტური ველების მნიშვნელობების ამოღება, შემდგომ შემოწმება ცარიელები არიან თუ არა და თუ არ არიან, ამ შემთხვევაში ვიძახებთ addSubject მეთოდს და ისევ ვასუფთავებთ field-ებს. ანალოგიურად, add pupil-ს შემთხვევაში ვიღებთ subject და pupil ველებს და ამჯერად ვიძახებთ addPupil() მეთოდს, ხოლო საბოლოოდ ვასუფთავებთ field-ებს. + diff --git a/problem-set/Sum1N.java b/problem-set/Sum1N.java new file mode 100644 index 0000000..9cd8ca8 --- /dev/null +++ b/problem-set/Sum1N.java @@ -0,0 +1,29 @@ +/* + * File: Sum1N.java + * ---------------------------- + * Sum1N დაბეჭდავს 1 დან მომხმარებლის რიცხვამდე ყველა ნატურალური რიცხვის ჯამს. + * + * ამოცანის პირობა: + * მომხმარებელს შეყავს მთელი რიცხვი n, პროგრამამ უნდა დაბეჭდოს 1 დან n მდე რიცხვების ჯამი + */ +import acm.program.*; + + +public class Sum1N extends ConsoleProgram { + + public void run() { + int sum = 0; + while(true){ + int num = readInt("Enter n: "); + if(num > 0){ + for(int i = 1; i < num;i++){ + sum = sum + i; + } + break; + } + } + + println( "Sum of natural numbers untill n is : " + sum); + } + +} diff --git a/problem-set/Sum1N.md b/problem-set/Sum1N.md new file mode 100644 index 0000000..21e516f --- /dev/null +++ b/problem-set/Sum1N.md @@ -0,0 +1,101 @@ +# Sum1N + +პრობლემა: +``` +მომხმარებელს შეყავს მთელი რიცხვი n, პროგრამამ უნდა დაბეჭდოს 1 დან n მდე რიცხვების +ჯამი + +``` + + + +## პრობლემის გადაჭრის გზა: +ამოცანის ამოსახსნელად, საჭიროა, 3 ეტაპი: + *მომხმარებელმა უნდა შემოიტანოს რიცხვი n; + *პროგრამამ უნდა დათვალოს ჯამი 1 დან n მდე ნატურალური რიცხვებისა. + *პროგრამამ უნდა დაპრინტოს ინფორმაცია კონსოლში. + +--- + +### I.მომხმარებლის მიერ შემოტანილი ინფორმაციის წაკითხვა: + * მომხმარებელმა კონსოლში უნდა შემოიტანოს რიცხვი n, რასაც ვაკეთებთ readInt() მეთოდის მეშვეობით. იმისათვის, რომ ჩვენს კონსოლის პროგრამას გასაგები ინტერფეისი ჰქონდეს, readInt()-მეთოდს ფრჩხილებში გადავცემთ არგუმენტს, ანუ იმას თუ რა უნდა დაპრინტოს პროგრამამ, ვიდრე მომხმარებელი შემოიყვანს რიცხვს (n-ს). საბოლოოდ მივიღებთ readInt("Enter n: "); სინტაქსს. readInt მეთოდი გვიბრუნებს იმ რიცხვის (int-ტიპის) მნიშვნელობას, რომელიც მომხმარებელმა შემოიტანა და, შესაბამისად, ვინახავთ მას num ცვლადში. შესაბამისად, მივიღეთ კოდი : int num = readInt("Enter n: "); + +### II.ჯამის დათვლა 1 დან n მდე ნატურალური რიცხვებისა: + + * შეგვიძლია პირდაპირ გადავუყვეთ თითოეულ რიცხვს 1 დან n-მდე და რიგ-რიგობით შევკრიბოთ, ანუ თავდაპირველად შევკრიბოთ პირველი და მეორე რიცხვი, შემდეგ ეს ჯამი სადმე შევინახოთ და ამის შემდეგ ამ ჯამს დავუმატოთ მესამე რიცხვი, შემდეგ მეოთხე და ა.შ. რიცხვებს გადავუყვებით 1 დან n-მდე for-ციკლის მეშვეობით, თუმცა შეგვიძლია იგივეს გაკეთება while-ციკლითაც, ცხადია. ამიტომ გვექნება შემდეგი კოდი: +```java +... + +int sum = 0; +for(int i = 1; i < num;i++){ + sum = sum + i; +} +... + +``` + + + +### III. მიღებული შედეგის დაპრინტვა კონსოლში: + * კონსოლში შედეგის დასაბეჭდად, ვიყენებთ მეთოდს println()-ს, ხოლო არგუმენტად გადავცემთ დასაპრინტ მესიჯს. როგორც ვხედავთ, მესიჯი არ შეიცავს მხოლოდ გამზადებულ ტექსტს (string-ს), არამედ ჩვენს მიერ გამოყოფილ ცვლადსაც (sum-ს), იმისათვის, რომ ეს მესიჯი გავაერთიანოთ და println-მა მიიღოს ჩვენი არგუმენტი, ვიყენებთ + ოპერატორს და ჯავას კომპილატორი თვითონ ხვდება, რომ sum, რომელიც int ტიპისაა, string-ში გადაიყვანოს. ამიტომ ჩვენი მიღებული მესიჯია: "Sum of natural numbers untill n is: " + sum. ხოლო საბოლოოდ ვიღებთ შემდეგ კოდს : println("Sum of natural numbers untill n is: " + sum); ამის შემდეგ პროგრამა დაბეჭდავს 1 დან მომხმარებლის შეყვანილ რიცხვამდე ნატურალურ რიცხვთა ჯამს. + +--- + +### პრობლემა N1: n-არ არის ნატურალური: + * შევნიშნოთ, რომ ჩვენ მომხმარებლის მიერ შემოტანილი რიცხვის წასაკითხად ვიყენებთ მეთოდს readInt()- რომელიც Int-რიცხვს კითხულობს და თუკი შემოტანილი რიცხვი Int ტიპის არ აღმოჩნდა, ამ შემთხვევაში კონსოლზე დაგვიპრინტავს გაწითლებულად [Illegal numeric format] და სთხოვს მომხმარებელს, რომ თავიდან შემოიტანოს ინფორმაცია. თუმცა გვრჩება კიდევ ერთი შემთხვევა, რომ n ნამდვილად ნატურალური იყოს, ამისათვის უნდა გამოვრიცხოთ არადადებითი რიცხვები, რომლებიც Int ტიპის range-ში (ინტერვალში) შედის. ამ პრობლემის აღმოსაფხვრელად, უნდა შევამოწმოთ თუ რა მნიშვნელობა ჩაიწერა num ცვალდში და მის მიხედვით ვიმოქმედოთ. + ერთი ვარიანტია, რომ if-ის მეშვეობით შევამოწმოთ დადებითია თუ არა num-ცვლადი და თუ არ არის თავიდან ვთხოვოთ მომხმარებელს შემოიტანოს რიცხვი, და გვექნებოდა შემდეგნაირი კოდი : +```java + +int num = readInt("Enter n: "); +if(num<=0){ + num = readInt("Enter n: "); +}... + +``` + შევნიშნოთ, რომ თუკი მომხმარებელმა ხელმეორედ შემოიტანა არადადებითი რიცხვი, მაშინ ჩვენი პროგრამა num-ს აღარ შეამოწმებს დადებითია, თუ არა, რადგან if- ერთჯერადად იშვება, შესაბამისად, თუ გვინდა, რომ ყოველ შემოტანილ რიცხვზე შემოწმდეს num-ცვლადი მანამ სანამ არადადებითი რიცხვი არ შემოვა, უნდა გამოვიყენოთ while-ციკლი და if-ის while-თი ჩანაცვლებით მივიღებთ შემდეგ კოდს: +```java + +int num = readInt("Enter n: "); +while(num<=0){ + num = readInt("Enter n: "); +}... + +``` + ამჯერად კოდი იმუშავებს სწორად, თუმცა რომ დავაკვირდეთ, readInt-მეთოდი ორჯერ გვიწერია იგივე დანიშნულებით, ხოლო ამის თავიდან ასაცილებლად, იმის მაგივრად, რომ readInt()-ით წავიკითხოთ მომხმარებლის მიერ შემოტანილი რიცხვი ორჯერ, შეგვიძლია, while(true) ციკლში ვიმუშაოთ და სასურველი შედეგის მიღების შემდგომ break გავუკეთოთ. საბოლოოდ გვექნება შემდეგი კოდი: +```java + +int sum = 0; +while(true){ + int num = readInt("Enter n: "); + if(num > 0){ + for(int i = 1; i < num;i++){ + sum = sum + i; + } + break; + } +}... + +``` + +### გაფრთხილება : + * უნდა აღვნიშნოთ, რომ n საკმარისად დიდი რიცხვი რომ შემოიყვანოს მომხმარებელმა, და ამასობაში ჩვენ ვკრიბოთ ყველა რიცხვი 1 დან n-მდე, რადგან sum ცვლადი int ტიპისაა და გააჩნია საკუთარი საზღვრები (ანუ მაქსიმალური და მინიმალური მნიშვნელობა), შესაძლოა, გადასცდეს int ტიპის ზღვარს და პასუხად არასწორი რიცხვი მივიღოთ, ამის თავიდან ასარიდებლად, შეგვიძლია, გამოვიყენოთ int ტიპის მაგივრად სხვა უფრო დიდი ინტერვალის მქონე ტიპი, მაგალითად, long , თუმცა ისიც უნდა აღვნიშნოთ, რომ long-საც გააჩნია საკუთარი ზღვარი და გარკვეული n-თვის უკვე არც long-ში არ ჩაეტევა ჩვენი ჯამის მნიშვნელობა. (აღსანიშნავია, რომ თუ n int-ტიპისაა, მაშინ ჯამი 1 დან n-ის მაქსიმალურ შესაძლო მნიშვნელობამდე ჩაეტევა long-ში, რისი დადასტურებაც შეგვიძლია პირდაპირ მაქსიმალური მნიშვნელობების ჩასმით და long-ის მაქსიმალურ მნიშვნელობასთან შედარებით, შესაბამისად, თუ n int-ტიპისაა, მსგავს პრობლემას ვერ შევხვდებით, თუკი sum-ცვლადი long-ტიპისაა). + +## პრობლემის გადაჭრის განსხვავებული ხერხი: + * ცხადია, ჯამის დათვლა რამდენიმენაირად შეგვიძლია, თუმცა ყველაზე მარტივი და ინტუიტიური მაინც ფორმულის გამოყენებაა მათემატიკიდან. 1 დან n-მდე რიცხვების ჯამი მოიცემა ფორმულით ( n*(n+1) ) / 2 -ს, რომლის გამოყვანაც შეგვიძლია არითმეტიკული პროგრესიის ჯამის ფორმულიდან -> (A(1)+A(n))*n /2. ხოლო ჩვენ შემთხვევაში n-ის მაგივრად გვქენება num-ცვლადი და შესაბამისად მიღებულ მნიშვნელობას შევინახავთ sumFormula ცვლადში: int sumFormula = (num*(num+1)) / 2; + +## რატომ იმუშავებს კოდი ნებისმიერი n-თვის? + * პირველ რიგში, როგორც უკვე ვთქვით,საკმარისად დიდი n-თვის კოდი არ იმუშავებს, რადგან მიღებულ ჯამს ვინახავთ int - ტიპის ცვლადში და int ტიპის მაქსიმალური მნიშვნელობის გადაცილების შემდგომ, ცხადია, მივიღებთ არასწორ ჯამს. ამ პრობლემას ვერ გადავჭრით, მაქსიმუმ რაც შეგვიძლია, რომ გავაკეთოთ, არის უფრო დიდი ინტერვალის მქონე ტიპში შევინახოთ, თუმცა ცხადია, ამ ტიპისთვისაც იარსებებს საკმარისად დიდი n-რომელიც გადააჭარბებს მის მაქსიმალურ მნიშვნელობასაც, ამიტომ სიმარტივისთვის ვინახავთ int ტიპში და მხოლოდ და მხოლოდ იმ შემთხვევაში გამოვიყენებთ სხვა ტიპს თუ მართლაც დიდ რიცხვებზე გვიწევს მუშაობა. თვითონ ფორმულის გამოყვანა, როგორც ვნახეთ, შეგვიძლია არითმეტიკული პროგრესიის ჯამის მიხედვით, (A(1)+A(n))*n/2 , ჩვენი არითმეტიკული პროგრესია შემდეგი ტიპისაა : 1,2,3....n, შესაბამისად, A(1)=1 და A(n) = n, ეს მნიშნველობები რომ ჩავსვათ არითმეტიკული პროგრესიის ჯამის ფორმულაში მივიღებთ, რომ ჯამი 1 დან n-მდე(ჩათვლით) ნატურალური რიცხვებისა უდრის (n*(n+1))/2, შესაბამისად ფორმულა მართებულია ნებისმიერი ნატურალური n-სთვის. + +### გაფრთხილება : + * რომ დავაკვირდეთ, while-ციკლის შემდგომ მე-13 ხაზზე გვიწერია შემდეგი კოდი ( num*(num+1) ) / 2; გარეთა ფრჩხილები მეტი გასაგებობისთვისაა გამოყენებული, მიუხედავად იმისა, რომ გარეთა ფრჩხილების მოცილებით კოდი მაინც სწორად იმუშავებს. თუმცა უნდა აღინიშნოს, რომ მათემატიკაში არ აქვს მნიშვნელობა 2-ზე გაყოფას სად დავწერდით და მთლიან ნამრალვს გავყოფდით 2-ზე, თუ ერთ-ერთ რომელიმე წევრს, თუმცა ჯავაში (და ბევრ სხვა ენაში თუ ყველაში არა) ამას მნიშვნელობა აქვს, რადგან რომ დაგვეწერა შემდეგი გამოსახულება num/2 * (num+1)-ზე კენტი num-თვის პროგრამა არ იმუშავებდა რადგან დავუშვათ num=11-ის შემთხვევაში num/2=5 5.5-ის მაგივრად, რადგან ხდება int ტიპზე ოპერაცია, პასუხადაც int ტიპს ვიღებთ, ანუ 5-ს, პროგრამა იმ შემთხვევაში იმუშავებდა სწორად, თუკი ათწილადებსაც შემოვიღებდით num-ის შესაძლო მნიშვნელობებში, მაგალითად double-ს, ხოლო რადგანაც int ტიპებში ვმუშაობთ, ამიტომ მთლიან ნამრავლს ვყოფთ 2-ზე (შევნიშნოთ, რომ num*(num+1) ორი მომდევნო ნატურალური რიცხვის ნამრავლია, ამიტომ აუცილებლად ლუწი იქნება და პასუხი int ტიპისაა). + +### რატომ არის მეორე გზა პირველზე უმჯობესი? + * იმიტომ, რომ პირველი ტიპის ამოხსნას რომ დავაკვირდეთ გვიწევს num ჯერ დავუმატოთ sum- ცვლადს i-ური რიცხვი, განსხვავებით ჩვენი მეორე ამოხსნისგან, სადაც მხოლოდ და მხოლოდ 1 ოპერაციაში (მათემატიკურად 3 ოპერაციაში, ჯამი, შემდეგ ნამრავლი და ბოლოს გაყოფა ორზე) ვიგებთ საბოლოო ჯამს და მიუხედავად იმისა, რომ პატარა num-თვის პროგრამა მაინც საკმაოდ სწრაფად მუშაობს, დაწყებული გარკვეული num-დან ჩვენს პროგრამას საგრძნობლად დიდი უპირატესობა ექნება დროში (ცხადია, თუ გავითვალისწინებთ იმას, რომ num არ გაცდეს შესაბამისი ტიპის საზღვრებს). + +### აღნიშვნა: + * ალბათ, შეამჩნევდით, რომ მიღებული ჯამის sumFormula-ცვლადში შენახვა არ არის საჭირო და შეგვეძლო პირდაპირ println() მეთოდში გადაგვეცა ის პლუსის შემდგომ, თუმცა იმისათვის, რომ კოდი უფრო წაკითხვადი იყოს, ვინახავთ sumFormula-ცვლადში, ამის შემდეგ, რომ დავხედოთ println()-მეთოდში ჩაწერილ არგუმენტს, ვხვდებით თუ რას აკეთებს ჩვენი პროგრამა, განსხვავებით იმ შემთხვევისგან, თუკი გვექნებოდა შემდეგი კოდი : +```java + +println("Sum of natural numbers untill n is: " + (num*(num+1))/2); + +``` \ No newline at end of file