SameEnds сравнить палиндром Объект Java

Question

Напишите класс с именем SameEnds. Напишите SameEndsTester, чтобы проверить свой класс. SameEnds определяет, имеет ли array list одинаковую последовательность чисел слева и в конце, и если да, то какова длина этой последовательности. Вы не будете запрашивать у пользователя данные. Введите свои тестовые данные с помощью конструктора SameEnds из SameEndsTester.. Можно предположить, что все элементы в array list являются целыми числами.

For example, the array list
1 4 9 10 11 12 1 4 9

имеет одинаковую последовательность 1 4 9 слева и справа и имеет length 3. Следовательно, ваш SameEndsTester напечатает «Самая длинная последовательность - 1 4 9, а последовательность length is 3».

If the arraylist doesn't have a common sequence at the left and the right, such as
1 4 9 16 25

SameEndsTester должен распечатать “There are no common sequences”. Две последовательности не могут перекрываться.

For example, in the array
1 1 1 1     

последовательность 1 1 происходит слева и справа, и ваш метод должен вернуть “The longest sequence is 1 1, а последовательность length is 2”

public class SameEnds {
    // variables for each single different numbers to create
    private int first;
    private int second;
    private int third;
    private int fourth;
    private int fifth;
    private int sixth;
    private int seventh;

    public SameEnds(int first, int second, int third, int fourth, int fifth, int sixth, int seventh) {
        super();
        this.first = first;
        this.second = second;
        this.third = third;
        this.fourth = fourth;
        this.fifth = fifth;
        this.sixth = sixth;
        this.seventh = seventh;
    }

    public int getFirst() {
        return first;
    }

    public void setFirst(int first) {
        this.first = first;
    }

    public int getSecond() {
        return second;
    }

    public void setSecond(int second) {
        this.second = second;
    }

    public int getThird() {
        return third;
    }

    public void setThird(int third) {
        this.third = third;
    }

    public int getFourth() {
        return fourth;
    }

    public void setFourth(int fourth) {
        this.fourth = fourth;
    }

    public int getFifth() {
        return fifth;
    }

    public void setFifth(int fifth) {
        this.fifth = fifth;
    }

    public int getSixth() {
        return sixth;
    }

    public void setSixth(int sixth) {
        this.sixth = sixth;
    }

    public int getSeventh() {
        return seventh;
    }

    public void setSeventh(int seventh) {
        this.seventh = seventh;
    }

    @Override
    public String toString() {
        return "SameEnds [first=" + first + ", second=" + second + ", third=" + third + ", fourth=" + fourth
                + ", fifth=" + fifth + ", sixth=" + sixth + ", seventh=" + seventh + "]";
    }


}


import java.util.ArrayList;

public class SameEndsTester {

    public static void main(String[] args) {
        SameEnds same = new SameEnds(1, 2, 3, 4, 1, 2, 3);
        SameEnds same2 = new SameEnds(2, 2, 3, 5, 2, 2, 3);
        SameEnds same3 = new SameEnds(3, 4, 1, 5, 3, 4, 1);

        ArrayList<SameEnds> getArray = new ArrayList<SameEnds>();
        getArray.add(0, same);
        getArray.add(1, same);
        getArray.add(2, same);
        getArray.add(4, same);
        getArray.add(5, same);
        getArray.add(6, same);

        ArrayList<SameEnds> getArray2 = new ArrayList<SameEnds>();
        getArray2.add(0, same2);
        getArray2.add(1, same2);
        getArray2.add(2, same2);
        getArray2.add(4, same2);
        getArray2.add(5, same2);
        getArray2.add(6, same2);

        ArrayList<SameEnds> getArray3 = new ArrayList<SameEnds>();
        getArray3.add(0, same3);
        getArray3.add(1, same3);
        getArray3.add(2, same3);
        getArray3.add(4, same3);
        getArray3.add(5, same3);
        getArray3.add(6, same3);

        if (same.getFirst() == same.getFifth() && same.getSecond() == same.getSixth()
                && same.getThird() == same.getSeventh()) {
            System.out.print("The longest sequence is " + getArray.get(0) + getArray.get(1) + getArray.get(2));

        }
    }

}

Я пытался. Я думаю, что я "жестко запрограммирован".

Answer 1

Я думаю, что вы думаете об этом. Во-первых, не жестко кодируйте разные номера. Это вызовет проблемы, если размер больше, чем ваши семь переменных. Вместо этого просто имейте два List<Integer>. Один для хранения введенных чисел, а другой для получения результирующего списка:

List<Integer> list = ... //Inputted numbers
List<Integer> result = new ArrayList<>(); //Empty, will add common elements later

Если вы думаете об этом логически, самая большая последовательность может быть только вдвое меньше чисел. Поэтому все, что нам нужно сделать, это разделить числа пополам. Итак, учитывая пример с размером 9, мы начнем с элемента 4th, а первый:

1 4 9 10 11 12 1 4 9
^         ^--Start here
 \--- And here

Посмотрите на два элемента. Если они равны, добавьте единицу к результирующему List. Если нет, переместите счетчик на второй половине. В этом примере они не такие, как у нас:

//Result list: []
1 4 9 10 11 12 1 4 9
^           ^

Снова 1 и 12 не равны, поэтому мы перемещаем вторую часть вверх.

 //Result list: []
1 4 9 10 11 12 1 4 9
^              ^

Теперь они равны, поэтому мы добавим элемент в список и переместим оба счетчика вверх:

//Result list: [1]
1 4 9 10 11 12 1 4 9
  ^              ^

Опять они оба равны, поэтому мы добавляем и увеличиваем оба:

//Result list: [1, 4]
1 4 9 10 11 12 1 4 9
    ^              ^

Мы добавляем последний элемент, и затем мы достигли конца List, поэтому мы прекращаем итерацию. Мы остались с List:

[1, 4, 9]

Теперь нам просто нужно проверить, пусто ли List, и, если это так, вывести соответствующее сообщение. В противном случае мы можем просто напечатать размер списка и самого списка. Теперь еще один случай, если есть соответствующие элементы, но это не в конце. Примером может быть:

1, 4, 9, 11, 12, 1, 4, 9, 1

Вам нужно будет убедиться, что если два элемента не совпадают, очистите List.

Я позволю вам написать код самостоятельно, но это одна из идей алгоритма для его решения.