package main

import "fmt"

func main() {
    arr := []int{1, 2, 3, 4, 5, 6, 7, 8}
    shuffle(arr)
    fmt.Println(arr)
}

// 数组的长度为len，调整前的位置是i，返回调整之后的位置
// 下标不从0开始，从1开始
func modifyIndex1(i int, len2 int) int {
    if i <= len2/2 {
        return 2 * i
    } else {
        return 2*(i-(len2/2)) - 1
    }
}

// 数组的长度为len，调整前的位置是i，返回调整之后的位置
// 下标不从0开始，从1开始
func modifyIndex2(i int, len2 int) int {
    return (2 * i) % (len2 + 1)
}

// 主函数
// 数组必须不为空，且长度为偶数
func shuffle(arr []int) {
    if len(arr) != 0 && (len(arr)&1) == 0 {
        shuffle0(arr, 0, len(arr)-1)
    }
}

// 在arr[L..R]上做完美洗牌的调整（arr[L..R]范围上一定要是偶数个数字）
func shuffle0(arr []int, L int, R int) {
    for R-L+1 > 0 { // 切成一块一块的解决，每一块的长度满足(3^k)-1
        len2 := R - L + 1
        base := 3
        k := 1
        // 计算小于等于len并且是离len最近的，满足(3^k)-1的数
        // 也就是找到最大的k，满足3^k <= len+1
        for base <= (len2+1)/3 { // base > (N+1)/3
            base *= 3
            k++
        }
        // 3^k -1
        // 当前要解决长度为base-1的块，一半就是再除2
        half := (base - 1) / 2
        // [L..R]的中点位置
        mid := (L + R) / 2
        // 要旋转的左部分为[L+half...mid], 右部分为arr[mid+1..mid+half]
        // 注意在这里，arr下标是从0开始的
        rotate(arr, L+half, mid, mid+half)
        // 旋转完成后，从L开始算起，长度为base-1的部分进行下标连续推
        cycles(arr, L, base-1, k)
        // 解决了前base-1的部分，剩下的部分继续处理
        L = L + base - 1 // L ->     [] [+1...R]
    }
}

// 从start位置开始，往右len的长度这一段，做下标连续推
// 出发位置依次为1,3,9...
func cycles(arr []int, start int, len2 int, k int) {
    // 找到每一个出发位置trigger，一共k个
    // 每一个trigger都进行下标连续推
    // 出发位置是从1开始算的，而数组下标是从0开始算的。
    for i, trigger := 0, 1; i < k; i, trigger = i+1, trigger*3 {
        preValue := arr[trigger+start-1]
        cur := modifyIndex2(trigger, len2)
        for cur != trigger {
            tmp := arr[cur+start-1]
            arr[cur+start-1] = preValue
            preValue = tmp
            cur = modifyIndex2(cur, len2)
        }
        arr[cur+start-1] = preValue
    }
}

// [L..M]为左部分，[M+1..R]为右部分，左右两部分互换
func rotate(arr []int, L int, M int, R int) {
    reverse(arr, L, M)
    reverse(arr, M+1, R)
    reverse(arr, L, R)
}

// [L..R]做逆序调整
func reverse(arr []int, L int, R int) {
    for L < R {
        arr[L], arr[R] = arr[R], arr[L]
        L++
        R--
    }
}