Question

The goal of this assignment is to use loop patterns to solve a variety of problems Starting 1. In Eclipse, create a new project or use an assignments one. Add a package a4, and a class SearchAndOptimizingLoops to that package. Copy and paste Picture.java and an image file from prior work into this package (Picture.java should update itself to the a4 package) 2. In your class, implement the static methods specified below 3. All methods you write should have a Javadoc comment with a description of what the method does and a @param for each parameter and a @return describing what information is returned 4. Add a main method with tests for each method. Your tests should cover possible return values (such as true or false) as well as special cases (for example, empty strings). Your tests should print what was expected as well as the actual result from the method in a neatly formatted way 5. You do not need to test for cases that are prohibited in the description. If the description says that there is at least X in the parameter, then you do not need to test for the truth of that constraint. 6. None of your methods except for main may print anything to the console 7. Ensure you have consistent spacing and indenting in your file, proper and consistent indenting, and a Javadoc comment about the start of the class definition with your name, assignment number and class Required Methods You must implement each of the described methods with method name, return type and parameters carefully checked against the specification. When parameters are specified you must use the order they are listed in. You may implement additional methods if they aid your problem-solving 1. Method name: findSmallestPositiveNumber Parameter(s): A String containing integer numbers separated by spaces. There must be at least one positive number in the String Return value: An int value that is the smallest number greater than 0 in the input string Example: findSmallestPositiveNumber("2 -4 5") should return 2 Note: Even though I put this first, I would consider working on this later. The other methods are basically just applying the patterns we looked at in class. This one is similar but requires a little more working out the logic of the problem 2. Method name: lowestAlphabetically Parameter(s): A String of lower-case words separated by spaces and made up of the letters a-z. The String will have at least one word Return value: A String containing the lowest alphabetical word. The String method compareTo0 does a lexicographic comparison between two strings, which allows you to test for the lowest alphabetical word Read documentation on compareTo) in order to understand how to use it. Example: lowestAlphabetically("cat dog apple fish") would return "apple".

Answer 1

import java.awt.Color;

public class SearchAnOptimizingLoops {
   /*
   * 1. method to find out the smallest positive number in a String
   *
   * @param: A String of integer numbers separated by spaces
   *
   * @return: An int of smallest positive integer in the String
   */
   public static int findSmallestPositiveNumber(String intStr) {
       // Read each number in the String
       String[] numbers = intStr.split(" ");

       // Loop through each value in numbers
       int numArray[] = new int[numbers.length];
       for (int i = 0; i < numbers.length; i++) {
           // Convert and store the numbers in numArray
           numArray[i] = Integer.parseInt(numbers[i]);
       }

       // Find the smallest positve number
       for (int i = 0; i < numArray.length; i++) {
           for (int j = i + 1; j < numArray.length; j++) {
               // Check for positive number
               if (numArray[i] > 0 && numArray[j] > 0) {
                   if (numArray[i] > numArray[j]) {
                       // Swap the elements
                       int temp = numArray[i];
                       numArray[i] = numArray[j];
                       numArray[j] = temp;
                   }
               }
           }
       }

       // Return the smallest number found at the index 0
       return numArray[0];
   }

   /*
   * 2. Method that compares the words and return the lowest alphabetical word
   *
   * @param: String of words separated by spaces
   *
   * @return: Smallest alphabetical word in the String
   */
   public static String lowestAlphabetically(String wordStr) {
       // Find each word in the String
       String words[] = wordStr.split(" ");

       // Store the first word in the smallest word String
       String smallest = words[0];

       // Loop through each word and find the smallest
       for (int i = 1; i < words.length; i++) {
           // Compare the word at index i with in the smallest, if returns negative update
           // the
           // smallest variable
           if (words[i].compareTo(smallest) < 0)
               smallest = words[i];
       }

       // Return the smallest word
       return smallest;
   }

   /*
   * 3. Method to find the smallest number in two strings
   *
   * @param: Two sStrings with numbers separated by spaces
   *
   * @return: An int having smallest number found
   */
   public static int findSmallestnumberinTwoStrings(String intStr1, String intStr2) {
       // Separate the numbers in two Strings
       String numbers1[] = intStr1.split(" ");
       String numbers2[] = intStr2.split(" ");

       // Create a Single array of numbers
       int numArray[] = new int[numbers1.length + numbers2.length];

       // Store the numbers in numArray
       for (int i = 0; i < numbers1.length; i++)
           numArray[i] = Integer.parseInt(numbers1[i]);

       for (int j = numbers1.length, i = 0; i < numbers2.length; j++, i++)
           numArray[j] = Integer.parseInt(numbers2[i]);

       // find the smallest number
       // Store the first number in numArray in smallest variable
       int smallest = numArray[0];

       // Loop through values in numArray and find the smallest number by comparing to
       // number in smallest variable
       for (int i = 1; i < numArray.length; i++) {
           if (numArray[i] < smallest)
               smallest = numArray[i];
       }

       // Return the smallest number
       return smallest;
   }

   /*
   * 4. Method for scaling the numbers by a factor of 100
   *
   * @param: A String containing numbers from 0 to 100, separated by spaces
   *
   * @return: A String with scaled numbers for the factor of 100 with respect to
   * the largest number
   */
   public static String curveScores(String intStr) {
       // Read each number in the String
       String[] numbers = intStr.split(" ");

       // Loop through each value in numbers
       int numArray[] = new int[numbers.length];
       for (int i = 0; i < numbers.length; i++) {
           // Convert and store the numbers in numArray
           numArray[i] = Integer.parseInt(numbers[i]);
       }

       // Find the largest number
       // Store the number at index 0 as the largest
       int largest = numArray[0];

       // Loop through each value of numArray
       for (int i = 1; i < numArray.length; i++) {
           if (numArray[i] > largest)
               largest = numArray[i];
       }

       // Calculate the scale factor
       int sFactor = 100 - largest;

       // Update each number in numArray with he scale factor
       String num = "";
       for (int i = 0; i < numArray.length; i++) {
           numArray[i] = numArray[i] + sFactor;

           // Create the String with the Scaled numbers
           num += numArray[i] + " ";
       }

       // Return the num String
       return num;
   }

   /*
   * 5. Method to determine if the color is contained in the Picture object
   *
   * @param: Picture Object and Color Object
   *
   * @return boolean value, true if the color is contained in the picture object,
   * otherwise false
   */
   public static boolean containsThisColor(Color pObj, Color cObj) {
       // Compare the picture object with color object
       if (pObj.equals(cObj))
           return true;

       else
           return false;
   }

   // Driver method main
   public static void main(String args[]) {
       System.out.println(findSmallestPositiveNumber("2 -4 5"));
       System.out.println(lowestAlphabetically("cat dog apple fish"));
       System.out.println(findSmallestnumberinTwoStrings("12 3 5", "2 -1 10"));
       System.out.println(curveScores("45 85 90"));
       System.out.println(containsThisColor(new Color(100, 200, 50), new Color(100, 100, 100)));
   }

}

Screenshot of Output:

e eclipse-workspace Chegg/src/SearchAnOptimizingLoops.java - Eclipse File Edit Source RefactorNavigate Seh Project Run Window Help Quick Access| | R Problem s @Javadoc 다 Declaration貝Console X | Progress <terminated SearchAnOptimizingLoops [Java Applicationl C:Program FilesJavaire1.8.0 171 bin javaw.exe (05-F 2 apple 55 95 100 false A ENG 0431 05-02-2019 19