Исправление 2 методов, которые должны удалить пары дубликатов и обратный порядок

Question

Просто учусь и надеюсь сменить профессию ... Мне нужна помощь в исправлении 2-го и 3-го методов, чтобы они печатались правильно! Я смог взломать это вместе (что заняло очень много времени), Какой код мне нужен, чтобы исправить 2-й и 3-й методы?

Я хотел бы, чтобы это работало и затем go вернитесь и научите себя, как это мой стиль обучения!

И 2-й, и 3-й методы неправильно печатают эти пары: (5,5) (5,5) (6,4) (9, 1)

import java.util.*;

public class TenPairs {

    public static void main(String[] args) {
        int a[] = { 1, 1, 2, 4, 4, 5, 5, 5, 6, 7, 9 };
        findAllPairs(a, 10);
        findUniquePairs(a, 10);
        findComboPairs(a, 10);
    }

    // Method 1 - output all pairs would output: [1,9], [1,9], [4,6], [4,6], [5,5],
    // [5,5], [5,5], [5,5], [5,5],[5,5],[6,4],[6,4][9,1],[9,1]

    static void findAllPairs(int[] array, int sum) {

        System.out.println("All pairs(including duplicates and reverse order pairs) whose sum is " + sum + ":");

        for (int i = 0; i < array.length; i++) {
            for (int j = i + 1; j < array.length; j++) {
                if (array[i] + array[j] == sum) {
                    System.out.println("(" + array[i] + "," + array[j] + ")" + "(" + array[j] + "," + array[i] + ")");
                }
            }
        }
    }

    // Method2 - output unique pairs only once would output: [1,9], [4,6], [5,5],
    // [6,4], [9,1]
    static void findUniquePairs(int[] array, int sum) {

        System.out.println("All pairs only once(including reverse order pairs but excluding duplicates) whose sum is "
                + sum + ":");

        Map<Integer, Integer> pairs = new HashMap<Integer, Integer>();
        for (int i = 0; i < array.length; i++) {
            if (pairs.containsKey(sum - array[i]))
                System.out.println("(" + array[i] + "," + (sum - array[i]) + ")");
            else
                pairs.put(array[i], 0);
        }
    }

    // Method3 - output the same combo pair only once would output: [1,9], [4,6],
    // [5,5]
    static void findComboPairs(int[] array, int sum) {

        System.out
                .println("All pairs only once(excluding reverse order pairs and duplicates) whose sum is " + sum + ":");

        Map<Integer, Integer> pairs = new HashMap<Integer, Integer>();
        for (int i = 0; i < array.length; i++) {
            if (pairs.containsKey(sum - array[i]))
                System.out.println("(" + array[i] + "," + (sum - array[i]) + ")");
            else
                pairs.put(array[i], 0);
        }
    }
}

Answer 1

Там может быть много способов сделать это. Один из способов - создать List из массива, а затем установить используемые элементы на null при обработке списка.

Сделайте это следующим образом:

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class TenPairs {

    public static void main(String[] args) {
        int a[] = { 1, 1, 2, 4, 4, 5, 5, 5, 6, 7, 9 };
        findAllPairs(a, 10);
        findUniquePairs(a, 10);
        findComboPairs(a, 10);
    }

    static void findAllPairs(int[] array, int sum) {

        System.out.println("All pairs(including duplicates and reverse order pairs) whose sum is " + sum + ":");

        for (int i = 0; i < array.length; i++) {
            for (int j = i + 1; j < array.length; j++) {
                if (array[i] + array[j] == sum) {
                    System.out.println("(" + array[i] + "," + array[j] + ")" + "(" + array[j] + "," + array[i] + ")");
                }
            }
        }
    }

    static void findUniquePairs(int[] array, int sum) {

        System.out.println("All pairs only once(including reverse order pairs but excluding duplicates) whose sum is "
                + sum + ":");
        List<Integer> list = Arrays.stream(array).boxed().collect(Collectors.toList());
        int x = 0, y = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = i + 1; j < array.length; j++) {
                if (list.get(i) != null) {
                    x = list.get(i);
                }
                if (list.get(j) != null) {
                    y = list.get(j);
                }
                if (x + y == sum) {
                    if (x != y) {
                        System.out.println("(" + x + "," + y + ")");
                    }
                    System.out.println("(" + y + "," + x + ")");
                    list.set(i, null);
                    list.set(j, null);
                    x = 0;
                    y = 0;
                }
            }
        }
    }

    static void findComboPairs(int[] array, int sum) {

        System.out.println(
                "All pairs only once(excluding reverse order pairs and duplicates) whose sum is " + sum + ": ");
        List<Integer> list = Arrays.stream(array).boxed().collect(Collectors.toList());
        int x = 0, y = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = i + 1; j < array.length; j++) {
                if (list.get(i) != null) {
                    x = list.get(i);
                }
                if (list.get(j) != null) {
                    y = list.get(j);
                }
                if (x + y == sum) {
                    System.out.println("(" + x + "," + y + ")");
                    list.set(i, null);
                    list.set(j, null);
                    x = 0;
                    y = 0;
                }
            }
        }
    }
}

Вывод:

All pairs(including duplicates and reverse order pairs) whose sum is 10:
(1,9)(9,1)
(1,9)(9,1)
(4,6)(6,4)
(4,6)(6,4)
(5,5)(5,5)
(5,5)(5,5)
(5,5)(5,5)
All pairs only once(including reverse order pairs but excluding duplicates) whose sum is 10:
(1,9)
(9,1)
(4,6)
(6,4)
(5,5)
All pairs only once(excluding reverse order pairs and duplicates) whose sum is 10: 
(1,9)
(4,6)
(5,5)

Основное различие между 2-м и 3-м методом состоит в том, сколько раз вы печатаете пары. Во втором методе вы должны напечатать пары дважды (один в порядке появления, а другой в обратном порядке), за исключением случаев, когда пара имеет одинаковые элементы. Не стесняйтесь комментировать в случае каких-либо сомнений / проблем.