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。

我会让你自己编写代码，但这是算法解决它的一个想法。

SameEnds比较回文对象Java

1 个答案: