From a8173fe9b9a11d2a0f142fadf70b2c131146ac5c Mon Sep 17 00:00:00 2001 From: levanshengelia Date: Mon, 3 Oct 2022 16:06:31 +0400 Subject: [PATCH 1/3] solution and explenation added --- problem-set/CountEvenNumbers.java | 32 +++++++++++++++ problem-set/CountEvenNumbers.md | 68 +++++++++++++++++++++++++++++++ 2 files changed, 100 insertions(+) create mode 100644 problem-set/CountEvenNumbers.java create mode 100644 problem-set/CountEvenNumbers.md diff --git a/problem-set/CountEvenNumbers.java b/problem-set/CountEvenNumbers.java new file mode 100644 index 0000000..5210d80 --- /dev/null +++ b/problem-set/CountEvenNumbers.java @@ -0,0 +1,32 @@ +import acm.program.ConsoleProgram; + +/* + * This program reads integers from user until he enters -1 and counts how many + * even numbers are among the entered numbers. + */ + +public class CountEvenNumbers extends ConsoleProgram { + + // This global variable is the indicator that we should stop reading integers + // form user and print the output + private final static int SENTINEL = -1; + + public void run() { + // The variable which stores total number of even numbers + int evens = 0; + // Reading integers from user and increment 'even' variable if the given number + // is even + while (true) { + int input = readInt("Enter the number or -1 for stop"); + // Check if the number is SENTINEL and stop reading if it is + if (input == SENTINEL) { + break; + } + if (input % 2 == 0) { + evens++; + } + } + // Printing the result + println("The total number of even numbers are: " + evens); + } +} diff --git a/problem-set/CountEvenNumbers.md b/problem-set/CountEvenNumbers.md new file mode 100644 index 0000000..a323356 --- /dev/null +++ b/problem-set/CountEvenNumbers.md @@ -0,0 +1,68 @@ + +ამოცანის პირობა: +მომხმარებელს შეყავს დადებითი რიცხვები, მანამ სანამ არ შეიყვანს -1 ს, დაბეჭდეთ რაოდენობა რამდენი ლუწი რიცხვი შეყვანა მომხმარებელმა. + +ამ ამოცანის ამოსახსნელად საჭიროა მოვიფიქროთ თუ როგორ წავიკითხავთ რიცხვებს მომხმარებლისგან. ვინაიდან დამოკიდებულები ვართ იმაზე თუ როდის შემოვა მონაცემებში -1 და არ ვიცით ზუსტი რაოდენობა წასაკითხი რიცხვებისა, ამიტომ გამოვიყენოთ while. ამის გარდა საჭიროა ყოველი რიცხვი შევამოწმოთ და გავიგოთ ლუწია თუ არა. + +ამოხსნის გზა (1): +პირველ რიგში შევქმნათ int ტიპის ცვლადი, სადაც შევინახავთ ლუწი რიცხვების რაოდენობას. წავიკითხოთ რიცხვები while ციკლით მანამ სანამ არ შემოვა -1 (რომელიც კონსტანტად გვექნება აღწერილი) და შემოსვლისთანავე შევამოწმოთ მისი ლუწობა. თუ ლუწია შემოსული რიცხვი მაშინ გავზარდოთ ლუწი რიცხვების მთვლელი int ცვლადი. როდესაც მომხმარებელი შემოიყვანს -1-ს დავბეჭდოთ ზემოთხსენებული ცვლადი. + +```java + public static final int SENTINEL = -1; + public void run() { + int evens = 0; + while(true) { + int input = readInt("Enter a number: "); + if(input == SENTINEL) { + break; + } + if(input % 2 == 0) { + evens++; + } + } + println("The total number of even numbers are: " + evens); + } +``` + +ამოხსნის გზა (2): +განსხვავებით პირველი მიდგომისგან , სადაც ერთდროულად ვკითხულობდით რიცხვს და თან ვამოწმებდით, შეგვიძლია ამოცანა ორ სხვადასხვა პუნქტად დავყოთ: 1) წავიკითხოთ while-ით ყველა რიცხვი და შევინახოთ ისინი სიაში (ArrayList ტიპის). 2) გადავუყვეთ სიას და დავითვალოთ მასში ლუწი რიცხვების რაოდენობა რაიმე int ტიპის მთვლელით. + +```java + public static final int SENTINEL = -1; + public void run() { + ArrayList numbers = new ArrayList<>(); + while(true) { + int input = readInt("Enter a number: "); + if(input == SENTINEL) { + break; + } + numbers.add(input); + } + int evens = 0; + for(int i = 0; i < numbers.size(); i++) { + if(numbers[i] % 2 == 0) { + evens++; + } + } + println("The total number of even numbers are: " + evens); + } +``` + +მიუხედავად სისწორისა ეს მიდგომა შედარებით არაოპტიმალურია, ვინაიდან ვინახავთ ყველა რიცხვს როცა ამის საჭიროება არ არის. შეგვეძლო შემოსვლისთანავე შეგვემოწმებინა და უბრალოდ დაგვევიწყებინა ის რიცხვი, როგორც ეს ვქენით პირველ ამოხსნაში + +*კოდის უნივერსალურობა: +ამოხსნა იმუშავებს ნებისმიერი შემოტანილი ინფორმაციისთვის (თუ შემოტანილი რიცხვები იქნება int-ის საზღვრებში), ვინაიდან კოდი არ არის დამოკიდებული რომელიმე კონკრეტული ცვლადის მნიშვნელობაზე გარდა. პირობაში ნახსენებია, რომ წაკითხვა -1-ის შემოსვლის შემდეგ უნდა დავასრულოთ და შეგვეძლო კოდში SENTINEL-ის მაგივრად -1 გამოგვეყენებინა. თუმცა უკეთესია ეს მნიშვნელობა კონსტანტად აღვწეროთ და კოდი ამ ცვლადზე დამოკიდებული გავხადოთ, რათა შემდგომში თუ მომხმარებელს მოუნდება, რომ მაგალითად -1-ის ნაცვლად 0-ზე შეწყდეს წაკითხვა, მხოლოდ ერთ ადგილას მოუწევს ამ ინფორმაციის ჩასწორება და კოდი სწორად იმშავებს. წინააღმდეგ შემთხვევაში მოუწევდა კოდში ყველა -1-ის 0-ად გადასწორება. ამ ყველაფერთან ერთად SENTINEL უფრო კითხვადია კოდის მნახველისთვის ვიდრე -1. + +*შესაძლო შეცდომა: +შესაძლო შეცდომა შეიძლება იყოს -1-ის შემოსვლის შემდეგ მისი შემოწმება არის თუ არა ის ლუწი. + +```java + int input = 0; + while(input != SENTINEL) { + input = readInt(); + if(input % 2 == 0) { + evens++; + } + } +``` +ჩვენს შემთხვევაში, როცა SENTINEL არის -1, პასუხი მაინც სწორი დაგვიბრუნდება, ვინაიდან ის კენტია და ლუწი რიცხვების რაოდენობა არ გაიზრდება, თუმცა თუ მომხმარებელმა შეცვალა SENTINEL რაიმე ლუწი რიცხვით, მაშინ პროგრამა ერთით ზედმეტ პასუხს მოგვცემს და გამოდის, რომ პროგრამის სისწორე დამოკიდებული ხდება შემოტანილ მონაცემებზე, რაც ცუდია. ამასთან პროგრამა ერთით მეტ რიცხვს განიხილავ ვიდრე უნდა განიხილავდეს. \ No newline at end of file From 69e03bc05ab5a27969231c3677b096422a89ff69 Mon Sep 17 00:00:00 2001 From: levanshengelia Date: Mon, 17 Oct 2022 16:16:37 +0400 Subject: [PATCH 2/3] implementations and explenatio of drawing robot problem --- .classpath | 12 +++++++ .gitignore | 1 + .project | 17 ++++++++++ problem-set/Robot.java | 73 ++++++++++++++++++++++++++++++++++++++++ problem-set/Robot.md | 76 ++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 179 insertions(+) create mode 100644 .classpath create mode 100644 .gitignore create mode 100644 .project create mode 100644 problem-set/Robot.java create mode 100644 problem-set/Robot.md diff --git a/.classpath b/.classpath new file mode 100644 index 0000000..5feb601 --- /dev/null +++ b/.classpath @@ -0,0 +1,12 @@ + + + + + + + + + + + + diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..ae3c172 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +/bin/ diff --git a/.project b/.project new file mode 100644 index 0000000..b93b8c0 --- /dev/null +++ b/.project @@ -0,0 +1,17 @@ + + + programming-methodology-java + + + + + + org.eclipse.jdt.core.javabuilder + + + + + + org.eclipse.jdt.core.javanature + + diff --git a/problem-set/Robot.java b/problem-set/Robot.java new file mode 100644 index 0000000..2f3fdce --- /dev/null +++ b/problem-set/Robot.java @@ -0,0 +1,73 @@ + +// Importing graphics program. +import acm.program.GraphicsProgram; +// Import for colours. +import java.awt.Color; +// Import for rectangles. +import acm.graphics.GRect; + +public class Robot extends GraphicsProgram { + + // Some useful constants + private static final int FACE_LENGTH = 300; + private static final int FACE_WIDTH = 400; + private static final int EYE_SIZE = 50; + private static final int NECK_WIDTH = 100; + private static final int NECK_HEIGHT = 300; + private static final int MOUTH_WIDTH = 100; + private static final int MOUTH_HEIGHT = 20; + private static final int MOUTH_OFFSET = 70; + + public void run() { + drawRobot(); + } + + // This problem can be divided into 4 sub-problems. + private void drawRobot() { + drawNeck(); + drawFace(); + drawEyes(); + drawMouth(); + } + + // This method draws the face of the robot. Robot has gray rectangle face. + private void drawFace() { + GRect face = new GRect(getWidth() / 2 - FACE_WIDTH / 2, getHeight() / 2 - FACE_LENGTH / 2, FACE_WIDTH, + FACE_LENGTH); + face.setFilled(true); + face.setFillColor(Color.LIGHT_GRAY); + add(face); + } + + // This method draws the eyes of the robot. Robot has round black eyes. + private void drawEyes() { + // Lets create one universal method in order to not repeat the code. + drawOneEye(getWidth() / 2 - FACE_WIDTH / 3); + drawOneEye(getWidth() / 2 + FACE_WIDTH / 3 - EYE_SIZE); + } + + // This method takes the eye width as a parameter and draws black eye with that width. + private void drawOneEye(int width) { + GRect eye = new GRect(width, getHeight() / 2 - FACE_LENGTH / 6, EYE_SIZE, EYE_SIZE); + eye.setFilled(true); + eye.setColor(Color.BLACK); + add(eye); + } + + // This method draws the mouth of the robot. Robot has black rectangle mouth. + private void drawMouth() { + GRect mouth = new GRect(getWidth() / 2 - MOUTH_WIDTH / 2, getHeight() / 2 + MOUTH_OFFSET, + MOUTH_WIDTH, MOUTH_HEIGHT); + mouth.setFilled(true); + mouth.setColor(Color.BLACK); + add(mouth); + } + + // This method draws the neck of the robot. Robot has gray rectangle neck. + private void drawNeck() { + GRect neck = new GRect(getWidth() / 2 - NECK_WIDTH / 2, getHeight() - NECK_HEIGHT, NECK_WIDTH, NECK_HEIGHT); + neck.setFilled(true); + neck.setFillColor(Color.LIGHT_GRAY); + add(neck); + } +} diff --git a/problem-set/Robot.md b/problem-set/Robot.md new file mode 100644 index 0000000..ada9086 --- /dev/null +++ b/problem-set/Robot.md @@ -0,0 +1,76 @@ +#Robot + +## ამოცანის პირობა: +დახატეთ რობოტის სახე კანვასზე. + +## ამოხსნა: +პირველი რიგში უნდა მოვიფიქროთ ამ ამოცანის კარგი დეკომპოზიცია. დეკომპოზიცია ძალიან გვეხმარება, განსაკუთრებით როცა საქმე გრაფიკულ პროგრამასთან გვაქვს, ვინაიდან დეკომპოზიციის გარეშე ხშირად მოგვიწევს ერთი და იმავე კოდის ბევრჯერ დაწერა. +ამ ამოცანისთვის გამოვიყენოთ შემდეგი დეკომპოზიცია: დავხატოთ კისერი, სახე, თვალები და პირი. + +მთავარი მეთოდი მიიღებს ამგვარ სახეს: + +private void drawRobot() { + drawNeck(); + drawFace(); + drawEyes(); + drawMouth(); +} + +მას შემდეგ, რაც ამოცანა დავყავით ქვეამოცანებად, ახლა ვიფიქროთ თითოეულის იმპლემენტაციაზე. + +### დავიწყოთ drawNeck() მეთოდით: + +private void drawNeck() { + GRect neck = new GRect(getWidth() / 2 - NECK_WIDTH / 2, getHeight() - NECK_HEIGHT, NECK_WIDTH, NECK_HEIGHT); + neck.setFilled(true); + neck.setFillColor(Color.LIGHT_GRAY); + add(neck); +} + +ამ მეთოდით კანვასზე დაიხატება მართკუთხედი. კისერი უნდა დავხატოთ კანვასზე ჰორიზონტალურად გათანაბრებულად, ანუ მარჯვენა და მარცხენა კანვასის კიდეებამდე დაშორება უნდა იყოს თანაბარი ნებისმიერი კანვასის ზომისათვის, ამიტომაც აუცილებელია, რომ მართკუთხედის მდებაორება დამოკიდებული გავხადოთ getWidth() ცვლადზე, რომელიც აღნიშნავს კანვასის სიგანეს. ასევე კოდის ადვილად შეცვლის შესაძლებლობის შესანარჩუნებლად კარგი იქნება თუ გამოვიყენებთ კონსტანტებს კისრის ზომებისთვის. ამ შემთხვევაში ეს კონსტანტებია NECK_WIDTH და NECK_HEIGHT, რომლებიც აღნიშნავენ კისრის სიგანესა და სიმაღლეს. GRect neck არის მართკუთხედის ობიექტი, რომელსაც გააჩნია ორნაირი კონსტრუქტორი (ანუ ორნაირად შეგვიძლია აღვწეროთ). პირველი ვარიანტი არის ის რაც წერია, ანუ გადავცეთ სიგრძე/სიგანე/x/y და ასევე შეგვეძლო აღწერისას მხოლოდ სიგრძე/სიგანე გადაგვეცა, თუმცა ამ შემთხვევაში add-ში მოგვიწევდა კოორდინატების გადაცემა add(neck, x, y), ხოლო თუ არ გადავცემდით, დეფოლტად 0,0 კოორდინატებზე დახატავდა მართკუთხედს. neck.setFilled(true) - ეს ხაზი უზრუნველყოფს, რომ მართკუთხედის ობიექტს ჰქონდეს შიგთავსი. neck.setFillColor(Color.LIGHT_GRAY - ხოლო ეს ხაზი კი მართკუთხედის შიგთავსს აფერადებს იმ ფრად, რომელსაც გადავცემთ (ჩვენს შემთხვევაში LIGHT_GRAY). add არის ობიექტის კანვასზე გამოსაჩენი ბრძანება, მის გარეშე ობიექტი კანვასზე არ დაიხატება. + +### drawFace() მეთოდი: + +private void drawFace() { + GRect face = new GRect(getWidth() / 2 - FACE_WIDTH / 2, getHeight() / 2 - FACE_LENGTH / 2, FACE_WIDTH, + FACE_LENGTH); + face.setFilled(true); + face.setFillColor(Color.LIGHT_GRAY); + add(face); +} + +ამ მეთოდით კანვასზე დაიხატება რობოტის სახე. სახე, ისევე როგორც კისერი, ჰორიზონტალურად უნდა იყოს გათანაბრებული, ამიტომ მისი x კოორდინატიც getWidth() ცვლადზე დამოკიდებული უნდა იყოს. ასევე აქაც უნდა გამოვიყენოთ შესაბამისი კონსტანტები, გავაფერადოთ და საბოლოოდ დავამატოთ კანვასზე. + +### drawEyes() მეთოდი: +private void drawEyes() { + drawOneEye(getWidth() / 2 - FACE_WIDTH / 3); + drawOneEye(getWidth() / 2 + FACE_WIDTH / 3 - EYE_SIZE); +} + +ეს მეთოდი ხატავს ორ თვალს რობიტის სახეზე, რომლებიც უნდა იყოს რობოტის სახის ზომებსა და კანვასის სიგანეზე დამოკიდებული. აქ მნიშვნელოვანი დეტალია უნივერსალური მეთოდის გაკეთება. ვინაიდან ორივე თვალის დახატვა თითქმის ერთი და იგივე კოდის, ჩვენ შეგვიძლია ცალკე მეთოდი გავაკეთოთ და ორჯერ გამოვიძახოთ ნაცვლად იმისა, რომ ერთიდაიგივე კოდი ორჯერ დავწეროთ. ჯერ უნდა დავფიქრდეთ იმაზე თუ რა განასხვავებს თვალებს. თვალები ზუსტად ერთიდაიგივეა გარდა მათი მდებარეობისა. განსხვავებული აქვთ მხოლო x კოორდინატი. ამიტომაც შევქმანთ მეთოდი რომელსაც გადავცემთ x კოორდინატს, როგორც ცვლადს, და ეს მეთოდის დახატავს თვალს ამ x კოორდინატზე. ეს მეთოდი გამოიყურება ასე: + +### drawOneEye(int x) მეთოდი: + +private void drawOneEye(int x) { + GRect eye = new GRect(width, getHeight() / 2 - FACE_LENGTH / 6, EYE_SIZE, EYE_SIZE); + eye.setFilled(true); + eye.setColor(Color.BLACK); + add(eye); +} + + +### და ბოლოს drawMouth() მეთოდი: + +private void drawMouth() { + GRect mouth = new GRect(getWidth() / 2 - MOUTH_WIDTH / 2, getHeight() / 2 + MOUTH_OFFSET, + MOUTH_WIDTH, MOUTH_HEIGHT); + mouth.setFilled(true); + mouth.setColor(Color.BLACK); + add(mouth); +} + +ეს მეთოდი კანვასზე ხატავს რობოტის პირს, მართკუთხედს. ისევე როგორ ყველა სხვა ობიექტი ესეც, უნდა იყოს ჰორიზონტალურად შუაშია კანვაზე და ასევე რობოტის სახის შუაში, ამიტომაც აქაც საჭიროა ამ ცვლადებზე დამოკიდებული მართკუხედის ობიექტის შექმნა. + +## შესაძლო ხარვეზები იმპლემენტაციისას: +1. კანვასის ზომების ცვლადების (getWidth() და getHeight()) გარეშე ობიექტების მდებარეობის განსაზღვრა, რაც გამოიწვევს იმას, რომ კოდის გამოვა ნაკლებად კითხვადი, მოგვიწევს ბევრი წვალება კოორდინატების ზუსტად შესარჩევად და სხვა ზომის კანვასზე რობოტის სახე არასწორად არ იქნება ისეთი პროპორცოული, როგორიც იყო თავდაპირველად. +2. დეკომპოზიციის გარეშე დაწერა. ამ შემთხვევაში მოგვიწევს მთლიანი კოდის ერთ მეთოდში დაწერა, რაც მას გახდის ძნელად წასაკითხსა და გასაგებს. ამასთან რთული იქნება კოდში შეცდომის პოვნა. \ No newline at end of file From 54f59bcb02aee96920c34c150ee33a226e5b6f68 Mon Sep 17 00:00:00 2001 From: levanshengelia Date: Mon, 14 Nov 2022 23:00:33 +0400 Subject: [PATCH 3/3] solution and explenation for Freindlist problem --- problem-set/CountEvenNumbers.java | 1 + problem-set/CountEvenNumbers.md | 68 ---------------------------- problem-set/Frendliest.java | 50 ++++++++++++++++++++ problem-set/Friendlist.md | Bin 0 -> 3564 bytes problem-set/MostFrequentSymbol.java | 65 ++++++++++++++++++++++++++ problem-set/MostFrequentSymbol.md | 0 6 files changed, 116 insertions(+), 68 deletions(-) delete mode 100644 problem-set/CountEvenNumbers.md create mode 100644 problem-set/Frendliest.java create mode 100644 problem-set/Friendlist.md create mode 100644 problem-set/MostFrequentSymbol.java create mode 100644 problem-set/MostFrequentSymbol.md diff --git a/problem-set/CountEvenNumbers.java b/problem-set/CountEvenNumbers.java index 5210d80..77d8d88 100644 --- a/problem-set/CountEvenNumbers.java +++ b/problem-set/CountEvenNumbers.java @@ -1,3 +1,4 @@ +// importing console program import acm.program.ConsoleProgram; /* diff --git a/problem-set/CountEvenNumbers.md b/problem-set/CountEvenNumbers.md deleted file mode 100644 index a323356..0000000 --- a/problem-set/CountEvenNumbers.md +++ /dev/null @@ -1,68 +0,0 @@ - -ამოცანის პირობა: -მომხმარებელს შეყავს დადებითი რიცხვები, მანამ სანამ არ შეიყვანს -1 ს, დაბეჭდეთ რაოდენობა რამდენი ლუწი რიცხვი შეყვანა მომხმარებელმა. - -ამ ამოცანის ამოსახსნელად საჭიროა მოვიფიქროთ თუ როგორ წავიკითხავთ რიცხვებს მომხმარებლისგან. ვინაიდან დამოკიდებულები ვართ იმაზე თუ როდის შემოვა მონაცემებში -1 და არ ვიცით ზუსტი რაოდენობა წასაკითხი რიცხვებისა, ამიტომ გამოვიყენოთ while. ამის გარდა საჭიროა ყოველი რიცხვი შევამოწმოთ და გავიგოთ ლუწია თუ არა. - -ამოხსნის გზა (1): -პირველ რიგში შევქმნათ int ტიპის ცვლადი, სადაც შევინახავთ ლუწი რიცხვების რაოდენობას. წავიკითხოთ რიცხვები while ციკლით მანამ სანამ არ შემოვა -1 (რომელიც კონსტანტად გვექნება აღწერილი) და შემოსვლისთანავე შევამოწმოთ მისი ლუწობა. თუ ლუწია შემოსული რიცხვი მაშინ გავზარდოთ ლუწი რიცხვების მთვლელი int ცვლადი. როდესაც მომხმარებელი შემოიყვანს -1-ს დავბეჭდოთ ზემოთხსენებული ცვლადი. - -```java - public static final int SENTINEL = -1; - public void run() { - int evens = 0; - while(true) { - int input = readInt("Enter a number: "); - if(input == SENTINEL) { - break; - } - if(input % 2 == 0) { - evens++; - } - } - println("The total number of even numbers are: " + evens); - } -``` - -ამოხსნის გზა (2): -განსხვავებით პირველი მიდგომისგან , სადაც ერთდროულად ვკითხულობდით რიცხვს და თან ვამოწმებდით, შეგვიძლია ამოცანა ორ სხვადასხვა პუნქტად დავყოთ: 1) წავიკითხოთ while-ით ყველა რიცხვი და შევინახოთ ისინი სიაში (ArrayList ტიპის). 2) გადავუყვეთ სიას და დავითვალოთ მასში ლუწი რიცხვების რაოდენობა რაიმე int ტიპის მთვლელით. - -```java - public static final int SENTINEL = -1; - public void run() { - ArrayList numbers = new ArrayList<>(); - while(true) { - int input = readInt("Enter a number: "); - if(input == SENTINEL) { - break; - } - numbers.add(input); - } - int evens = 0; - for(int i = 0; i < numbers.size(); i++) { - if(numbers[i] % 2 == 0) { - evens++; - } - } - println("The total number of even numbers are: " + evens); - } -``` - -მიუხედავად სისწორისა ეს მიდგომა შედარებით არაოპტიმალურია, ვინაიდან ვინახავთ ყველა რიცხვს როცა ამის საჭიროება არ არის. შეგვეძლო შემოსვლისთანავე შეგვემოწმებინა და უბრალოდ დაგვევიწყებინა ის რიცხვი, როგორც ეს ვქენით პირველ ამოხსნაში - -*კოდის უნივერსალურობა: -ამოხსნა იმუშავებს ნებისმიერი შემოტანილი ინფორმაციისთვის (თუ შემოტანილი რიცხვები იქნება int-ის საზღვრებში), ვინაიდან კოდი არ არის დამოკიდებული რომელიმე კონკრეტული ცვლადის მნიშვნელობაზე გარდა. პირობაში ნახსენებია, რომ წაკითხვა -1-ის შემოსვლის შემდეგ უნდა დავასრულოთ და შეგვეძლო კოდში SENTINEL-ის მაგივრად -1 გამოგვეყენებინა. თუმცა უკეთესია ეს მნიშვნელობა კონსტანტად აღვწეროთ და კოდი ამ ცვლადზე დამოკიდებული გავხადოთ, რათა შემდგომში თუ მომხმარებელს მოუნდება, რომ მაგალითად -1-ის ნაცვლად 0-ზე შეწყდეს წაკითხვა, მხოლოდ ერთ ადგილას მოუწევს ამ ინფორმაციის ჩასწორება და კოდი სწორად იმშავებს. წინააღმდეგ შემთხვევაში მოუწევდა კოდში ყველა -1-ის 0-ად გადასწორება. ამ ყველაფერთან ერთად SENTINEL უფრო კითხვადია კოდის მნახველისთვის ვიდრე -1. - -*შესაძლო შეცდომა: -შესაძლო შეცდომა შეიძლება იყოს -1-ის შემოსვლის შემდეგ მისი შემოწმება არის თუ არა ის ლუწი. - -```java - int input = 0; - while(input != SENTINEL) { - input = readInt(); - if(input % 2 == 0) { - evens++; - } - } -``` -ჩვენს შემთხვევაში, როცა SENTINEL არის -1, პასუხი მაინც სწორი დაგვიბრუნდება, ვინაიდან ის კენტია და ლუწი რიცხვების რაოდენობა არ გაიზრდება, თუმცა თუ მომხმარებელმა შეცვალა SENTINEL რაიმე ლუწი რიცხვით, მაშინ პროგრამა ერთით ზედმეტ პასუხს მოგვცემს და გამოდის, რომ პროგრამის სისწორე დამოკიდებული ხდება შემოტანილ მონაცემებზე, რაც ცუდია. ამასთან პროგრამა ერთით მეტ რიცხვს განიხილავ ვიდრე უნდა განიხილავდეს. \ No newline at end of file diff --git a/problem-set/Frendliest.java b/problem-set/Frendliest.java new file mode 100644 index 0000000..d7530a1 --- /dev/null +++ b/problem-set/Frendliest.java @@ -0,0 +1,50 @@ + +// Importing map and hashmap +import java.util.HashMap; +import java.util.Map; +//Importing console program +import acm.program.ConsoleProgram; + +public class Frendliest extends ConsoleProgram { + // This program prints the person who has the highest number of friends + public void run() { + setFont("-20"); + Map friendlist = new HashMap<>(); + readPairs(friendlist); + printMostPopularPerson(friendlist); + } + + // This method searches the most popular person in map and prints his/her name in console + private void printMostPopularPerson(Map friendlist) { + String person = ""; + int max = 0; + for(String key : friendlist.keySet()) { + if(friendlist.get(key) > max) { + max = friendlist.get(key); + person = key; + } + } + println(person + " has the highest number of friends!"); + } + + // This method reads string pairs from console and stores the number of friends for each person + // in map. Each pair contains two people's names. + private void readPairs(Map friendlist) { + while(true) { + String friend = readLine("Enter the first person's name or [enter] to end: "); + if(friend.equals("")) { + break; + } + String person = readLine("Enter the second person's name or [enter] to end: "); + if(person.equals("")) { + break; + } + if(friendlist.containsKey(person)) { + friendlist.put(person, friendlist.get(person) + 1); + } else { + friendlist.put(person, 1); + } + println(friend + " is a friend of " + person); + } + } +} diff --git a/problem-set/Friendlist.md b/problem-set/Friendlist.md new file mode 100644 index 0000000000000000000000000000000000000000..e939bbac79a535efdc415425fbd83691cae987a2 GIT binary patch literal 3564 zcmb7`-D+D$6ou!yP?$#$_@;rl;9Q1MNG?JG?Ny(k(2x{@DYld6l&y0tS%2ur2~{1( z$rB`5-`+E4j*gY!A|%cK-h1t}*UaZHVJ|!hN8#`AJRF93Va=v`iccva^^?jOX1-9_=O6^abSh0`a!+0Jm%@N-^vZF+5KFK~9 zmeG}PJQcPc%Ot)}(KA9^3qyv8rrLF5k;n^+V;nD)4XoV8VGte(cTiPKVGtf$4@4^) zCB6+=mFJBijVD4u`#=Kx8smZQyd6o-&Y9L)PGnzWf+viEA@6)#rJB!@&a;ZYoxOl$|oG6Lcmn4G>_fVr95A21v8titdqs;qcJq? zpBcZEY4!VPclm3a3=b@F>b({VsmghZ`&;&@1=Ww8->aR%D6N>bHFNhm>H3#AY}Hw} zmFqd7TAP%QtR7THN5!OLORZX^8U>9V97yW+y^M7-Zun3k=-ja7iBw1G?R>(P;!^xFtq-#dWYGym9u$nU~ z%V1Vl_BvD0O0RjVTRU}TJV(WtHGYMs^7uHs48QCDADuf9ZgZ`0+qZKmt4W;xjr3V$Afo+-An_CgSnEg?o3)1E_QV;IZ8oYJW7e{MG;o zDZNI?l~*FYuC{pP7Y!<$cRj9jhU;9;1-G=K3U8FfSK+m=7>Hr>6a!e-y0y^Dk@k)? z`$^U}rWnh_gah3kQbNt?&e88sOhCDWnDti56}%vmj*TPP@nOfgc+4G!ZNprB@(u%0 z#dY#0qswl>hyjp5stuJiAAHM;}B^L1PE_z>HPgF$TT2_GK6Do$qx3U3t z|6yBwqT8jI{dM_7YR@V{`@Gh9N0PfrwdYD)H11rOp!&utP}AD6dUMN#->;U_^zZ$ZPY1IbJDP@Y>-{pc=>#6#{ddW3X|pRVbs^o$Cs-?-T>I z?Pp}2xYCThEKuVuolIJ0s(B&{iG#iSTdLFEKe-xQGs#KI;q>~2Axp)B#g+Y20WG`L zF1k>-^}pF|xZSP~5Q9^~T)!o9^a*QyX7Dn+a878}-(jqSF>~QI)Q4(kKhb72%C$(2 tniMB%oR_ZP%M-MEGE`6k+3b#U2VaBxU3h_8NlLBIe2 literal 0 HcmV?d00001 diff --git a/problem-set/MostFrequentSymbol.java b/problem-set/MostFrequentSymbol.java new file mode 100644 index 0000000..733be86 --- /dev/null +++ b/problem-set/MostFrequentSymbol.java @@ -0,0 +1,65 @@ +// Importing console program +import acm.program.ConsoleProgram; + +public class MostFrequentSymbol extends ConsoleProgram { + + // This program reads string from console and prints the most frequent symbol in it + public void run() { + while(true) { + String input = readLine("Enter the string: "); + // Initialising array with 26 so that each index has frequency value of the corresponding + // character. + int[] frequencies = new int[26]; + countFrequencies(frequencies, input); + char result = findMostFrequentSymbol(frequencies, input); + println("The most frequent symbol is: " + result); + } + } + + // This method searches and returns the most frequent character + private char findMostFrequentSymbol(int[] frequencies, String input) { + int maxFreq = 0; + char result = 'a'; + for(int i = 0; i < frequencies.length; i++) { + if(maxFreq < frequencies[i]) { + result = (char)('a' + i); + maxFreq = frequencies[i]; + } + } + return result; + } + + // This method counts the frequencies of the characters and stores them in array + private void countFrequencies(int[] frequencies, String input) { + for(int i = 0; i < input.length(); i++) { + char curChar = input.charAt(i); + int index = -1; + if(isUpperCase(curChar)) { + index = curChar - 'A'; + } else if(isLowerCase(curChar)){ + index = curChar - 'a'; + } else { + continue; + } + frequencies[index]++; + } + } + + // This method checks if the character is lower case or not + private boolean isLowerCase(char curChar) { + if(curChar >= 'a' && curChar <= 'z') { + return true; + } else { + return false; + } + } + + // This method checks if the character is upper case or not + private boolean isUpperCase(char curChar) { + if(curChar >= 'A' && curChar <= 'Z') { + return true; + } else { + return false; + } + } +} diff --git a/problem-set/MostFrequentSymbol.md b/problem-set/MostFrequentSymbol.md new file mode 100644 index 0000000..e69de29