Question

给定一串甚至大小，请说：

abcdef123456

我将如何交错两半，以便相同的字符串成为：

a1b2c3d4e5f6

我试图开发一种算法，但不能。有人会给我一些关于如何进行的提示吗？我需要这样做而不创建额外的字符串变量或数组。一个或两个变量很好。

我只是不想要一个有效的代码（或算法），我需要开发一个算法并用数学方法证明它是正确的。

Answer 1

你可以在O（N * log（N））时间内完成：

Want: abcdefgh12345678 -> a1b2c3d4e5f6g7h8

a b c d e f g h
  1 2 3 4 5 6 7 8

  4 1-sized swaps:

a 1 c 3 e 5 g 7
  b 2 d 4 f 6 h 8

a1  c3  e5  g7
    b2  d4  f6  h8

  2 2-sized swaps:

a1  b2  e5  f6
    c3  d4  g7  h8

a1b2  e5f6
      c3d4  g7h8

  1 4-sized swap:

a1b2  c3d4
      e5f6  g7h8

a1b2c3d4
        e5f6g7h8

在C中实施：

#include <stdio.h>
#include <string.h>

void swap(void* pa, void* pb, size_t sz)
{
  char *p1 = pa, *p2 = pb;
  while (sz--)
  {
    char tmp = *p1;
    *p1++ = *p2;
    *p2++ = tmp;
  }
}

void interleave(char* s, size_t len)
{
  size_t start, step, i, j;

  if (len <= 2)
    return;

  if (len & (len - 1))
    return; // only power of 2 lengths are supported

  for (start = 1, step = 2;
       step < len;
       start *= 2, step *= 2)
  {
    for (i = start, j = len / 2;
         i < len / 2;
         i += step, j += step)
    {
      swap(s + i,
           s + j,
           step / 2);
    }
  }
}

char testData[][64 + 1] =
{
  { "Aa" },
  { "ABab" },
  { "ABCDabcd" },
  { "ABCDEFGHabcdefgh" },
  { "ABCDEFGHIJKLMNOPabcdefghijklmnop" },
  { "ABCDEFGHIJKLMNOPQRSTUVWXYZ0<({[/abcdefghijklmnopqrstuvwxyz1>)}]\\" },
};

int main(void)
{
  unsigned i;

  for (i = 0; i < sizeof(testData) / sizeof(testData[0]); i++)
  {
    printf("%s -> ", testData[i]);
    interleave(testData[i], strlen(testData[i]));
    printf("%s\n", testData[i]);
  }

  return 0;
}

输出（ideone）：

Aa -> Aa
ABab -> AaBb
ABCDabcd -> AaBbCcDd
ABCDEFGHabcdefgh -> AaBbCcDdEeFfGgHh
ABCDEFGHIJKLMNOPabcdefghijklmnop -> AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPp
ABCDEFGHIJKLMNOPQRSTUVWXYZ0<({[/abcdefghijklmnopqrstuvwxyz1>)}]\ -> AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz01<>(){}[]/\

Answer 2

一般来说，这个问题非常困难 - 而且它会减少到找到排列周期。它们的数量和长度因长度而异。

Cycles for in-place interleaving for 10 and 12 entry arrays

第一个和最后一个周期总是退化; 10个入口数组有2个长度为6和2的循环，12个入口数组有一个长度为10的循环。

使用循环可以：

 for (i=j; next=get_next(i) != j; i=next) swap(i,next);

即使下一个函数可以作为N的一些相对简单的公式来实现，但问题被推迟到对已交换的索引进行书籍核算。在10个条目的左侧情况下，应该[快速]找到周期的起始位置（例如1和3）。

Answer 3

好的让我们重新开始。以下是我们要做的事情：

def interleave(string):
    i = (len(string)/2) - 1
    j = i+1

    while(i > 0):
        k = i
        while(k < j):
            tmp = string[k]
            string[k] = string[k+1]
            string[k+1] = tmp
            k+=2 #increment by 2 since were swapping every OTHER character
        i-=1 #move lower bound by one
        j+=1 #move upper bound by one

这是该计划将要做的一个例子。我们将使用变量i，j，k。 i和j将分别为下限和上限，其中k将成为我们交换的索引。

示例

`abcd1234` i = 3 //got this from (length(string)/2) -1 j = 4 //this is really i+1 to begin with k = 3 //k always starts off reset to whatever i is swap d and 1 increment k by 2 (k = 3 + 2 = 5), since k > j we stop swapping result `abc1d234` after the first swap i = 3 - 1 //decrement i j = 4 + 1 //increment j k= 2 //reset k to i swap c and 1, increment k (k = 2 + 2 = 4), we can swap again since k < j swap d and 2, increment k (k = 4 + 2 = 6), k > j so we stop //notice at EACH SWAP, the swap is occurring at index `k` and `k+1` result `ab1c2d34` i = 2 - 1 j = 5 + 1 k = 1 swap b and 1, increment k (k = 1 + 2 = 3), k < j so continue swap c and 2, increment k (k = 3 + 2 = 5), k < j so continue swap d and 3, increment k (k = 5 + 2 = 7), k > j so were done result `a1b2c3d4`

至于证明程序的正确性，请参阅此link。它解释了如何通过循环不变来证明这是正确的。

粗略证明如下：

初始化：在循环的第一次迭代之前，我们可以看到i被设置为 (length(string)/2) - 1。在进入循环之前，我们可以看到i＆lt; = length（字符串）。

维护。每次迭代后，i递减（i = i-1, i=i-2,...），并且i<length(string)必须有一个点。

终止：由于i是正整数的递减序列，因此循环不变i > 0最终将等于false，循环将退出。

Answer 4

解决方案是J. Ellis和M. Markov。原位，稳定的合并通过完美的shu ffl e。计算机杂志。 43（1）：40-53，（2000）。

另见这里的各种讨论：

Answer 5

好的，这是草稿。你说你不只是想要一个算法，但你正在提示，所以请考虑这个算法提示：

长度为N.

k = N / 2 - 1。

1）从中间开始，并移动（通过连续交换相邻的对元素）N / 2 k位置的元素向左（第一次：'1'到达位置1）。

2） - k。是k == 0？退出。

3）在N / 2处移动（通过交换）元素（第一次：'f'到达位置N-1）k位于右侧。

4）--k。

修改：上述算法正确无误，如下面的代码所示。实际上证明它是正确的是超出我的能力，但有趣的小问题。

#include <iostream>
#include <algorithm>

int main(void)
{
    std::string s("abcdefghij1234567890");
    int N = s.size();
    int k = N/2 - 1;
    while (true)
    {

        for (int j=0; j<k; ++j)
        {
            int i = N/2 - j;
            std::swap(s[i], s[i-1]);
        }

        --k;

        if (k==0) break;

        for (int j=0; j<k; ++j)
        {
            int i = N/2 + j;
            std::swap(s[i], s[i+1]);
        }

        --k;
    }

   std::cout << s << std::endl;

   return 0;
}

Answer 6

这是一个算法和工作代码。它就位，O（N），概念上很简单。

遍历数组的前半部分，将项目交换到位。
- 从左半部分开始的项目将被交换到右侧在我们需要它们之前，所以我们使用技巧来确定它们在哪里被交换到。
当我们到达中间点时，请对已交换到右侧的未放置的左侧物品进行整理。
- 使用相同技巧的变体来找到正确的解密顺序。
重复剩下的一半数组。

这遍历了阵列，进行的交换不超过N + N / 2，并且不需要临时存储。

诀窍是找到交换项目的索引。左侧项目被放置到右侧项目腾出的交换空间中。交换空间按以下顺序增长：

在末尾添加一个项目（在右侧项目腾出的空间中）
交换现有（最早）项目最早的项目。

依次添加项1..N给出：
1 2 23 43 435 465 4657 ...
每个步骤更改的索引是：
0 0 1 0 2 1 3 ...

此序列正好是OEIS A025480，可以在O（1）的摊销时间内进行计算：

def next_index(n):
    while n&1: n=n>>1
    return n>>1

一旦我们交换了N个项目到了中点，就需要解密。交换空间将包含N / 2个项目，其中应在i处偏移的项目的实际索引由next_index(N/2+i)给出。我们可以在交换空间中前进，将物品放回原处。唯一的麻烦是，随着我们的前进，我们最终可能会发现源索引位于目标索引的左侧，因此已经在其他位置进行了交换。但是我们可以通过再次查找上一个索引来找出问题所在。

def unscramble(start,i):
        j = next_index(start+i)
        while j<i: j = next_index(start+j)
        return j

请注意，这仅是索引计算，而不是数据移动。实际上，对于所有N，next_index的呼叫总数为<3N。

这就是我们完整实施所需要的：

def interleave(a, idx=0):
    if (len(a)<2): return
    midpt = len(a)//2 

    # the following line makes this an out-shuffle.
    # add a `not` to make an in-shuffle
    base = 1 if idx&1==0 else 0

    for i in range(base,midpt):
        j=next_index(i-base)
        swap(a,i,midpt+j)

    for i in range(larger_half(midpt)-1):
        j = unscramble( (midpt-base)//2, i);
        if (i!=j):
            swap(a, midpt+i, midpt+j)

    interleave(a[midpt:], idx+midpt)

结尾处的尾递归可以轻松地由循环代替。使用Python的数组语法，它显得不太优雅。还要注意，对于此递归版本，输入必须是numpy数组而不是python列表，因为标准列表切片会创建未传播回的索引副本。

这里是一项快速测试，以验证正确性。（52张卡片组的8次完美洗牌将其恢复为原始顺序）。

A = numpy.arange(52)
B = A.copy()
C =numpy.empty(52)

for _ in range(8):
    #manual interleave
    C[0::2]=numpy.array(A[:26])
    C[1::2]=numpy.array(A[26:])
    #our interleave
    interleave(A)
    print(A)
    assert(numpy.array_equal(A,C))

assert(numpy.array_equal(A, B))

两个字符串的就地交错

6 个答案: