1

我一直在试图弄清楚我是否可以使用其他类型的数据结构来解决这个问题。我设法以某种方式解决了它，但仍然缺乏很多高质量的代码。

前几天我在一次采访中被问到：给定一个输入字符串，例如：

String[] inputString = { "a1", "a2", "a3", "a4", "a5", "b1", "b2", "b3", "b4", "b5"};

将其转换为输出字符串：

String[] outputString = { "a1", "b1", "a2", "b2", "a3", "b3", "a4", "b4", "a5", "b5" };

我尝试了以下方法，到目前为止，我觉得这需要一些改进：

public class ArrayApp {
    public static void main(String[] args) {

        String[] inputString = { "a1", "a2", "a3", "a4", "a5", "b1", "b2",
                "b3", "b4", "b5" };
        // String[] outputString = { "a1", "b1", "a2", "b2", "a3", "b3", "a4",
        // "b4", "a5", "b5" };

        String[] str1 = new String[5];
        System.arraycopy(inputString, 0, str1, 0, 5);
        System.out.println("String Array str1");
        for (int i = 0; i < str1.length; i++) {
            System.out.print(str1[i]);
        }
        System.out.println();
        String[] str2 = new String[5];
        System.arraycopy(inputString, 5, str2, 0, 5);
        // System.out.println(str2.length);
        System.out.println("String Array str2");

        for (int i = 0; i < str2.length; i++) {
            System.out.print(str2[i]);
        }

        String temp = "";
        int i = 0, j = 0;

        for (i = 0; i < str1.length; i++) {
            temp = temp + str1[i];
            for (j = i; j < str2.length; j++) {
                if (j > i) {
                    break;
                }
                temp = temp + str2[j];
            }
        }
        System.out.println("\nFinal String " + temp);

        System.out.println();

    } // end main()
} // end class ArrayApp

问题是 - 这可以通过使用集合来改进吗？我尝试迭代集合，但这对我不起作用。我需要在这里使用任何其他集合类吗？

谢谢你的时间。

顺便说一句，这里是 O/P

字符串数组 str1 a1a2a3a4a5 字符串数组 str2 b1b2b3b4b5 最终字符串 a1b1a2b2a3b3a4b4a5b5

4

4 回答 4

1

您必须告诉我们转换背后的理由：

它只是通过拾取每第 5 个元素重新排列数组，直到结束，然后从下一个元素重新开始，重复 5 次？即重新排列为arr[0], arr[5], arr[10]..., arr[1], arr[6], arr[11], .... arr[2], arr[7], arr[12]...

或者它是通过按第二个字符然后第一个排序来重新排列？

例如，如果给你一个数组 ["z9", "y2", "a2", "b1", "c4", "t7", "s6"]

最终结果应该是什么？

["z9", "t7", "y2", "s6", "a2", "b1", "c4"]

或者

[ "b1", "a2", "y2", "c4", "s6", "t7", "z9"]?

这可能会导致一种非常不同的“优化”方式

第一个可以简单地完成为

for (int i = 0; i < 5; ++i) {
  for (int j = i; j < arr.length; j+=5) {
    resultArrayList.add(arr[j]);
  }
}

第二个简直

Arrays.sort(arr, new Comparator<String> {
  int compare(String s1, String s2) {
    return ("" + s1.charAt(1) + s1.charAt(0)).compareTo("" + s1.charAt(1) + s1.charAt(0));
  }
}

对于后一种情况，您可以通过提供更有效的比较功能来进一步优化。

于 2013-09-26T08:27:38.167 回答
1

听起来你只是想要：

String[] outputString = new String[inputString.length];
for (int i = 0; i < inputString.length / 2; i++) {
    outputString[i * 2] = inputString[i];
    outputString[i * 2 + 1] = inputString[i + inputString.length / 2];
}

但目前尚不清楚它是否真的只是你想要的这种交错......

（对于微优化，您可以尝试i * 2每次迭代只计算一次，然后inputString.length / 2退出循环。我怀疑 JIT 编译器会为您完成所有这些工作......）

无论如何，这已将其从 O(n 2 ) 减少到 O(n)。请注意，目前尚不清楚为什么您当前的代码会以 aString而不是 aString[]开头。（这个问题也不清楚，当你谈论一个字符串时，然后提供一个字符串数组......）

完整代码：

import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        String[] inputString = { "a1", "a2", "a3", "a4", "a5", 
            "b1", "b2", "b3", "b4", "b5"};
        String[] outputString = new String[inputString.length];
        for (int i = 0; i < inputString.length / 2; i++) {
            outputString[i * 2] = inputString[i];
            outputString[i * 2 + 1] = inputString[i + inputString.length / 2];
        }

        System.out.println(Arrays.toString(inputString));
        System.out.println(Arrays.toString(outputString));
    }
}

输出：

[a1, a2, a3, a4, a5, b1, b2, b3, b4, b5]
[a1, b1, a2, b2, a3, b3, a4, b4, a5, b5]

这看起来完全像你的规格......

于 2013-09-25T22:46:23.067 回答
1

一个明显的方法是简单地对数组进行排序（可能使用插入排序，因为它的长度——或者只是Arrays.sort()为了重用 API 代码）。

或者，您可以使用具有两个索引i和的循环，分别j从0和开始5，只需将第ith 个元素放入一个新数组中，然后将jth 放入一个新数组中，依此类推，每次递增每个索引，直到填满整个结果数组。后者的计算效率可能更高（因为在最坏的情况下它是 O(n)），但它应该做什么可能不太明显。

或者，您甚至可以完全展开循环，然后执行以下操作：

String[] newArray = new String[]
{
    inputString[0], inputString[5],
    inputString[1], inputString[6],
    inputString[2], inputString[7],
    inputString[3], inputString[8],
    inputString[4], inputString[9]
}

这实际上是计算效率最高的方法——尽管是最不通用的。

于 2013-09-25T22:44:08.543 回答
0

也许类似于以下内容，它将为您提供所需的输出。

public class Test {
    public static void main(String[] args) {

        String[] inputString = { "a1", "a2", "a3", "a4", "a5", "b1", "b2",
                "b3", "b4", "b5" };

        Arrays.sort(inputString, new Comparator<String>() {

            private String reverse(String s) {
                return new StringBuilder(s).reverse().toString();
            }

            @Override
            public int compare(String arg0, String arg1) {
                return reverse(arg0).compareTo(reverse(arg1));
            }
        });

        System.out.println(Arrays.toString(inputString));
    }

}
于 2013-09-25T22:59:51.167 回答