如何摆脱打印线内的重复项

Question

ive been trying to solve this for the last 5 hours and i'm exhausted ..
i need to build a method that takes an array of numbers and determaines which right digit was shown the least times in an thr array. for example if the array is [134,12634,124,5667] the number that will be shown is 7 .. i hope i'm clear enough:(

anyways this is the code. i manged to get to the part where it show the number but it will show it as many times as the loop runs for.

please help

public static boolean QuestionD(int[] arr)
    {
        int counter = 0;
        int printNum = 0;
        String[] arr2 = new String[arr.length];
        int[] arr3 = new int[arr.length];
        for (int i = 0; i < arr.length; i++)
            if (arr[i] < 0)
                return false;//if the numbers are negative return false;
        for (int j = 0; j < arr.length; j++)
        {
            printNum = arr[j] % 10;// get the right digit of the number
            {
                for (int i = 0; i < arr.length; i++)
                    if (arr[i] % 10 == printNum)// if the right digit of the first index matches the other index then counter ++;
                        counter++;// to count how many times the right digit is shown
                arr2[j] = printNum + "" + counter;// to make the number as a string and will be 2 digits , the first digit from the left
                //will be the digit that appears on the right , and the second digit will be the times that the digit appeared
                arr3[j] = Integer.parseInt(arr2[j]);//make it back to an int
                counter = 0;// setting counter back to zero to check the other numbers
            }
        }
        
        for (int i = 0; i < arr.length; i++)
        {
            for (int j = i + 1; j < arr.length; j++)
                if (arr3[i] % 10 < arr3[j] % 10)
                    System.out.print((arr3[i] / 10 % 10) + " ");// here i take the digits that were shown the less but will duplicates 
            //as many times as the for loop runs for.
        
        }
        
        return true;
    }

Answer 1

Well, I think your solution can be much simpler.

If I understand correctly, you want:

• For each number, extract the rightmost digit;
• Record the frequency of each digit;
• Show the one occurring the least number of times.

Here's how you could do this. Since the number of options is fairly small – there are only 10 digits – you could simply create an array with size 10, to keep track of the number of all occurrences of each digit ¹ .

// First, we'll define an integer array with size 10 with indexes from 0 to
// 9. We can use the indexes to store the frequencies of each of the digits
// from 0 to 9.
int[] frequencies = new int[10];

// Then we collect the frequencies of all numbers. We walk over each element
// of the array
for (int number : numbers) {
    // We use the remainder operator to get the rightmost digit. This
    // guarantees that the result of the operation never exceeds 9.
    int digit = number % 10;

    // We increment the counter for that specific integer
    frequencies[digit]++;
}

// Now we have the frequencies of all digits. Now all we have to do is walk
// over our collected frequencies, and check which one has the lowest
// frequency.

// We initialize the digit and its frequency with -1, which means in our case
// that we have not yet recorded a least frequency.
int leastQuantity = -1;
int leastNumber = -1;

// Now we must check all digits
for (int i = 0; i < 10; i++) {
    // A composite if statement, doing some magic. How it works, see below.
    if (frequencies[i] > 0 && (frequencies[i] < leastQuantity || leastNumber == -1)) {
        leastQuantity = frequencies[i];
        leastNumber = i;
    }
}

System.out.println("The rightmost digit " + leastNumber + " occurs " + leastQuantity + " times");
// Or if you want to list all numbers with the least frequency:
for (int i = 0; i < frequencies.length; i++) {
    if (frequencies[i] == leastQuantity) {
        System.out.println(leastNumber);
    }
}

That if statement :

• frequencies[i] > 0 — The frequency must be greater than 0. If the frequency of a number is 0, then it doesn't occur at all, that is, it was never a rightmost digit of any number within the array. So we must only count frequencies greater than 0.

• Either of the following must be true:

  • leastNumber == -1 — Meaning we have not yet recorded a frequency, so if the frequency is greater than 0, we must record it.
  • frequencies[i] < leastQuantity — If the current frequency is lower than the last one recorded, update both the number and its frequency.

---

There are some assumptions here:

• numbers is not null . You may want to write Objects.requireNonNull(numbers) as the first statement of the method body, in order to fast-fail .

• numbers.length > 0 . You may want to write

  if (numbers.length == 0) { throw new IllegalArgumentException("Given array has no elements"); }

• None of the numbers within numbers is negative. If any of the numbers is, then the code tries to write at a negative array index, causing an ArrayIndexOutOfBoundsException to be thrown. We could allow negative numbers, but then we must make sure digit is absolute:

   int digit = Math.abs(number % 10);

---

¹ There may be digits which never occur as the rightmost digit, leaving unused array positions. In your specific example, that would be all digits except 4 and 7. For small values such as 10, this is entirely fine. However, if you were to extract the four rightmost digits and count the frequencies, then you ended up with a very large array, possibly with many unused positions. In such cases, you may be better off using a ( Hash ) Map to map a certain number to their frequency. With such a map, it'll no longer contain unused values, instead, it'll contain only numbers where the frequency is greater than 0. See Rohan Kumar's answer for an example.

Answer 2

In case you're interested in using Map for storing frequencies instead of an array(You won't need to deal with digits with zero frequencies in this case). You might find this solution helpful. Here I'm just populating frequency map and then getting the entry with minimum value:

private static int getLeastFrequentDigit(int[] array) {
    Map<Integer, Integer> digitFrequencyMap = new HashMap<>();

    for (int j : array) {
        int key = j % 10;
        digitFrequencyMap.merge(key, 1, Integer::sum);
    }

    Map.Entry<Integer, Integer> minEntry = digitFrequencyMap.entrySet().stream()
            .min(Comparator.comparingInt(Map.Entry::getValue))
            .orElse(null);
    return minEntry != null ? minEntry.getKey() : -1;
}