Algorithm 写一个算法来返回一个数组，使得1..n中的每个数字k正好出现两次，并且与它的副本相距k距离

这个问题是在一次采访中提出的

对于给定的整数n>=3，返回一个大小为2n的数组，使得从1到n的每个数字k正好出现两次，并且每个数字及其重复部分之间的距离等于该数字

功能签名：

int* buildArray(int n)

例如，对于n=3：

3, 1, 2, 1, 3, 2

数字

2

：第一位置3和第二位置6，因此距离6-3-1=2。
编号

3

：第一个

3

位于位置1，第二个

3

位于位置5，因此距离5-1-1=3

对于n=4：

4, 1, 3, 1, 2, 4, 3, 2

这是一个问题，你可以用它来解决。（这是一个比数独更好、更简单的例子。）您有以下限制：

• 每个数字必须正确使用两次和两次
• 阵列中的每个插槽只能由一个数字占用

对于n=3的问题，可以得到以下矩阵：

     [0] [1] [2] [3] [4] [5]  1   2   3
     --- --- --- --- --- --- --- --- ---
#0    X       X               X
#1        X       X           X
#2            X       X       X
#3                X       X   X

#4    X           X               X
#5        X           X           X
#6            X           X       X

#7    X               X               X
#8        X               X           X          

列

[x]

表示使用插槽

x

；普通

x

表示数字

x

已放置。第0行到第3行描述了1的可能位置，第4行到第6行描述了2的位置，第7行和第8行描述了放置3的两种可能性。这将产生两个（镜像）解决方案：

2 3 1 2 1 3     (#2 + #4 + #8)
3 1 2 1 3 2     (#1 + #6 + #7)

---

不是所有的n都有解，例如5和6没有解。

这是NP完全问题

然而，它可以相当容易地使用递归和递归进行编码，使其适合于面试的解决方案。例如，它类似于回溯解决方案（这是我的灵感）

准备在Java中运行代码：

import java.util.Arrays;    
public class Test {   
    public static void main(String[] args) {
        for (int i = 3; i < 13; i++) {
            int[] answer = buildArray(i);
            if (answer[0] != 0) {
                System.out.println(i + " " + Arrays.toString(answer));
            }
        }
    }

    public static int[] buildArray(int n) {
        int[] answer = new int[2 * n];
        put(answer, n); // start with placing n, later (n - 1), (n - 2), ..., 1
        return answer;
    }

    private static boolean put(int[] answer, int k) {
        for (int i = 0; i + k + 1 < answer.length; i++) { // try every posiiton
            if (answer[i] == 0 && answer[i + k + 1] == 0) { 
                answer[i] = k;
                answer[i + k + 1] = k;
                if (k == 1) {
                    return true; // we found a solution, escape!
                }
                if (put(answer, k - 1)) {
                    return true; // we found a solution, escape!
                }
                answer[i] = 0;   // step back and erase this placement
                answer[i + k + 1] = 0;
            }
        }
        return false; // still not full solution, continue
    }    
}

---

这是朗福德的问题/顺序

关于同样的问题，已经有一个关于实现的话题了。

---

哪里没有编程谜题网站吗？@KevinDTimm向我推荐任何类似stackoverflow的东西，尽管我认为问算法问题“没问题”，过去也有人问过。如果需要，请尝试一下，或者干脆忽略.XOR所有元素，如果结果为0，则数组中的所有元素都出现两次。@user3请重新阅读问题，您需要构建大小为2n的数组，从1..n开始的数字都会重复两次，并且每k距离重复一次。@LalluMishra算法问题确实可以接受，在主题上，但是在StackOverflow上，还需要您证明您首先尝试解决问题，并指出你在哪里遇到困难，或者你的困惑或问题是什么。否则，很难确定一个人何时不仅仅是试图为他们完成工作。因为这个问题是关于编程的挑战，它可能更适合于。你确定它是NP完全的吗？“我发现很难想象，如果给你一个算法来解决这个问题，你将如何解决一个不同的NP完全问题？”彼得·里瓦兹表示怀疑。但是是的，它是NP完全的。“找到所有Langford序列相当于解决精确覆盖问题的一个实例，Knuth[Knu08]=>NP完全”。来自演示文稿的幻灯片13。

3 [3, 1, 2, 1, 3, 2]
4 [4, 1, 3, 1, 2, 4, 3, 2]
7 [7, 3, 6, 2, 5, 3, 2, 4, 7, 6, 5, 1, 4, 1]
8 [8, 3, 7, 2, 6, 3, 2, 4, 5, 8, 7, 6, 4, 1, 5, 1]
11 [11, 6, 10, 2, 9, 3, 2, 8, 6, 3, 7, 5, 11, 10, 9, 4, 8, 5, 7, 1, 4, 1]
12 [12, 10, 11, 6, 4, 5, 9, 7, 8, 4, 6, 5, 10, 12, 11, 7, 9, 8, 3, 1, 2, 1, 3, 2]