Question

/**
                Given an int array, return true if the array contains duplicate values.

                duplicateInts({3})  -> false
                duplicateInts({1, 2})  -> false
                duplicateInts({7, 7})  -> true
                duplicateInts({1, 2, 3, 4, 5})  -> false
                duplicateInts({1, 2, 3, 2, 4, 5})  -> true
        **/
        public static boolean duplicateInts(int[] numbers) {
                //your code here
                return false;
        }//end duplicateInts


        /**
                Given a String array, return true if the array contains duplicate values.
                Note: Capital letters count

                duplicateStrings({"a"}) -> false
                duplicateStrings({"a", "b", "c", "d"}) -> false
                duplicateStrings({"a", "a"})  -> true
                duplicateStrings({"A", "a"})  -> false
                duplicateStrings({"these", "are", "the", "times"}) -> false
                duplicateStrings({"these", "are", "the", "times", "they", "are"}) -> true
                duplicateStrings({"my", "dear"}, {"Aunt", "Sally"}) -> {"Aunt", "Sally", "dear", "my"}
                duplicateStrings({"Irving", "washington"}, {"Irving", "berlin"})  -> {"Irving", "Irving", "berlin", "washington"}
        **/
        public static boolean duplicateStrings(String[] strings) {
                //your code here
                return false;
        }//end duplicateStrings

        /**
                Given an int array, return an int array with duplicate ints removed if the array contains duplicate values.

                removeDuplicateInts({3})  -> {3}
                removeDuplicateInts({1, 2})  -> {1, 2}
                removeDuplicateInts({7, 7})  -> {7}
                removeDuplicateInts({1, 7, 1, 7, 1})  -> {1, 7}
                removeDuplicateInts({1, 2, 3, 4, 5})  -> {1, 2, 3, 4, 5})
                removeDuplicateInts({1, 2, 3, 2, 4, 2, 5, 2})  -> {1, 2, 3, 4, 5}
        **/
        public static int[] removeDuplicateInts(int[] numbers) {
                //your code here
                        return numbers;
                } // end removeDuplicateInts


        /**
                Given a String array, return an String array with duplicate Strings removed if the array contains duplicate values.
                Note: Capital letters count

                removeDuplicateStrings({"a"}) -> {"a"}
                removeDuplicateStrings({"a", "b", "c", "d"}) -> {"a", "b", "c", "d"}
                removeDuplicateStrings({"a", "a"})  -> {"a"}
                removeDuplicateStrings({"A", "a"})  -> {"A", "a"}
                removeDuplicateStrings({"these", "are", "the", "times"}) -> {"these", "are", "the", "times"}
                removeDuplicateStrings({"these", "times", "are", "the", "times", "they", "are"}) -> {"these", "times", "are", "the", "they"})
        **/
        public static String[] removeDuplicateStrings(String[] strings) {
                //your code here
                        return strings;
                }//end removeDuplicateStrings


        /**
                Given two int arrays return true if the arrays contain the same values in the same order.
                Note: Order matters, see the third example

                compare2IntArrays({3, 4}, {1}) -> false
                compare2IntArrays({1, 2}, {1, 2}) -> true
                compare2IntArrays({1, 2}, {2, 1}) -> false
                compare2IntArrays({1, 2, 3, 4}, {1, 2, 3, 4}) -> true
        **/
        public static boolean compare2IntArrays(int[] firstNumbers, int[] secondNumbers) {
                //your code here
                        return false;
                }//end compare2IntArrays


        /**
                Given two String arrays return true if the arrays contain the same values in the same order.
                Note: Order matters, see the forth example
                Note: Capatil letters matter, see the final example

                compare2StringArrays({"and"}, {"or"})  -> false
                compare2StringArrays({"and", "but"}, {"or"})  -> false
                compare2StringArrays({"a", "b", "c", "d"}, {"a", "b", "c", "d"})  -> true
                compare2StringArrays({"a", "b", "c", "d"}, {"d", "c", "b", "d"})  -> false
                compare2StringArrays({"a", "b", "c", "d"}, {"A", "b", "C", "d"})  -> false
                compare2StringArrays({"Aunt", "Sally"}, {"Aunt", "Sally"}) -> true
                compare2StringArrays({"Aunt", "Sally"}, {"Aunt", "sally"}) -> false
        **/
        public static boolean compare2StringArrays(String[] firstStrings, String[] secondStrings) {
                //your code here
                        return false;
                }//end TESTcompare2StringArrays


}//end Functions2

======================================================================================

PLEASE DO NOT USE SORT METHODE JUST SIMPLE CODING TO SOLVE THIS CODE

THANKS

=========================================================================================

Answer 1

import java.util.ArrayList;

public class Functions2 {

   /**
   * Given an int array, return true if the array contains duplicate values.
   *
   * duplicateInts({3}) -> false duplicateInts({1, 2}) -> false duplicateInts({7,
   * 7}) -> true duplicateInts({1, 2, 3, 4, 5}) -> false duplicateInts({1, 2, 3,
   * 2, 4, 5}) -> true
   **/
   public static boolean duplicateInts(int[] numbers) {
       // your code here

       for (int i = 0; i < numbers.length; i++) {
           for (int j = 0; j < numbers.length; j++) {

               if (i != j) {

                   if (numbers[i] == numbers[j])
                       return true;
               }
           }
       }
       return false;
   }// end duplicateInts

   /**
   * Given a String array, return true if the array contains duplicate values.
   * Note: Capital letters count
   *
   * duplicateStrings({"a"}) -> false duplicateStrings({"a", "b", "c", "d"}) ->
   * false duplicateStrings({"a", "a"}) -> true duplicateStrings({"A", "a"}) ->
   * false duplicateStrings({"these", "are", "the", "times"}) -> false
   * duplicateStrings({"these", "are", "the", "times", "they", "are"}) -> true
   * duplicateStrings({"my", "dear"}, {"Aunt", "Sally"}) -> {"Aunt", "Sally",
   * "dear", "my"} duplicateStrings({"Irving", "washington"}, {"Irving",
   * "berlin"}) -> {"Irving", "Irving", "berlin", "washington"}
   **/
   public static boolean duplicateStrings(String[] strings) {
       // your code here
       for (int i = 0; i < strings.length; i++) {
           for (int j = 0; j < strings.length; j++) {

               if (i != j) {

                   if (strings[i].compareTo(strings[j]) == 0)
                       return false;
               }
           }
       }
       return false;
   }// end duplicateStrings

   /**
   * Given an int array, return an int array with duplicate ints removed if the
   * array contains duplicate values.
   *
   * removeDuplicateInts({3}) -> {3} removeDuplicateInts({1, 2}) -> {1, 2}
   * removeDuplicateInts({7, 7}) -> {7} removeDuplicateInts({1, 7, 1, 7, 1}) ->
   * {1, 7} removeDuplicateInts({1, 2, 3, 4, 5}) -> {1, 2, 3, 4, 5})
   * removeDuplicateInts({1, 2, 3, 2, 4, 2, 5, 2}) -> {1, 2, 3, 4, 5}
   **/
   public static int[] removeDuplicateInts(int[] numbers) {
       // your code here

       if (duplicateInts(numbers)) {

           ArrayList<Integer> result = new ArrayList<>();

           for (int i = 0; i < numbers.length; i++) {

               if (result.size() > 0) {

                   boolean flag = true;
                   for (int j = 0; j < result.size(); j++) {

                       if (result.get(j) == numbers[i])
                           flag = false;
                   }

                   if (flag)
                       result.add(numbers[i]);
               } else
                   result.add(numbers[i]);
           }

           numbers = new int[result.size()];

           for (int i = 0; i < result.size(); i++)
               numbers[i] = result.get(i);

       }

       return numbers;
   } // end removeDuplicateInts

   /**
   * Given a String array, return an String array with duplicate Strings removed
   * if the array contains duplicate values. Note: Capital letters count
   *
   * removeDuplicateStrings({"a"}) -> {"a"} removeDuplicateStrings({"a", "b", "c",
   * "d"}) -> {"a", "b", "c", "d"} removeDuplicateStrings({"a", "a"}) -> {"a"}
   * removeDuplicateStrings({"A", "a"}) -> {"A", "a"}
   * removeDuplicateStrings({"these", "are", "the", "times"}) -> {"these", "are",
   * "the", "times"} removeDuplicateStrings({"these", "times", "are", "the",
   * "times", "they", "are"}) -> {"these", "times", "are", "the", "they"})
   **/
   public static String[] removeDuplicateStrings(String[] strings) {
       // your code here
       if (duplicateStrings(strings)) {

           ArrayList<String> result = new ArrayList<>();

           for (int i = 0; i < strings.length; i++) {

               if (result.size() > 0) {

                   boolean flag = true;
                   for (int j = 0; j < result.size(); j++) {

                       if (result.get(j).compareTo(strings[i]) == 0)
                           flag = false;
                   }

                   if (flag)
                       result.add(strings[i]);
               } else
                   result.add(strings[i]);
           }

           strings = new String[result.size()];

           for (int i = 0; i < result.size(); i++)
               strings[i] = result.get(i);

       }
       return strings;
   }// end removeDuplicateStrings

   /**
   * Given two int arrays return true if the arrays contain the same values in the
   * same order. Note: Order matters, see the third example
   *
   * compare2IntArrays({3, 4}, {1}) -> false compare2IntArrays({1, 2}, {1, 2}) ->
   * true compare2IntArrays({1, 2}, {2, 1}) -> false compare2IntArrays({1, 2, 3,
   * 4}, {1, 2, 3, 4}) -> true
   **/
   public static boolean compare2IntArrays(int[] firstNumbers, int[] secondNumbers) {
       // your code here

       if (firstNumbers.length == secondNumbers.length) {

           for (int i = 0; i < firstNumbers.length; i++) {

               if (firstNumbers[i] == secondNumbers[i])
                   continue;
               else
                   return false;
           }
       }

       else
           return false;
       return true;
   }// end compare2IntArrays

   /**
   * Given two String arrays return true if the arrays contain the same values in
   * the same order. Note: Order matters, see the forth example Note: Capatil
   * letters matter, see the final example
   *
   * compare2StringArrays({"and"}, {"or"}) -> false compare2StringArrays({"and",
   * "but"}, {"or"}) -> false compare2StringArrays({"a", "b", "c", "d"}, {"a",
   * "b", "c", "d"}) -> true compare2StringArrays({"a", "b", "c", "d"}, {"d", "c",
   * "b", "d"}) -> false compare2StringArrays({"a", "b", "c", "d"}, {"A", "b",
   * "C", "d"}) -> false compare2StringArrays({"Aunt", "Sally"}, {"Aunt",
   * "Sally"}) -> true compare2StringArrays({"Aunt", "Sally"}, {"Aunt", "sally"})
   * -> false
   **/
   public static boolean compare2StringArrays(String[] firstStrings, String[] secondStrings) {
       // your code here
       if (firstStrings.length == secondStrings.length) {

           for (int i = 0; i < firstStrings.length; i++) {

               if (firstStrings[i].compareTo(secondStrings[i]) == 0)
                   continue;
               else
                   return false;
           }
       }

       else
           return false;
       return true;

   }// end TESTcompare2StringArrays

  

}

Feel free to ask any doubts, if you face any difficulty in understanding.

Please upvote the answer if you find it helpful