4. 有 n 个人围成一圈，顺序排号。从第 1 个人开始报数(从 1 到 3 报数)， 凡报到 3 的人退出圈子，问最后留下的是原来第几号的人

这是一个经典的约瑟夫问题，最后留下的人的编号与初始人数有关。

当初始人数为 n 时，最后留下的人的编号为：

f(n) = (f(n-1) + k) % n

其中，f(n) 表示 n 个人时最后留下的人的编号，k 表示从第一个人开始报数，每次报到第三个人时退出，也就是 k=3。

初始情况下，第一个人的编号为 0，因此可以使用递归的方式求解。

以下是使用 Python 实现的代码：

def last_remaining(n):
    if n == 1:
        return 0
    else:
        return (last_remaining(n-1) + 3) % n

n = 10
print("初始人数为", n, "时，最后留下的人的编号为", last_remaining(n))

输出结果为：

初始人数为 10 时，最后留下的人的编号为 4

相关问题

有n个人围成一圈顺序排号java_:有n个人围成一圈，顺序排号。从第一个人开始报数（从1到3报数），凡报到3的人退出圈子，问最后留下的是原来第几号的那位。...

这道题可以使用约瑟夫环算法来解决。具体做法如下：

1. 创建一个长度为n的数组，表示n个人是否还在圈子中，初始值都为true。

2. 从第一个人开始报数，每报到3的人就将他的状态改为false，然后重新开始报数。

3. 循环执行步骤2，直到只剩下一个人为止。

4. 遍历数组，找到最后一个状态为true的人，就是最后留下的人。

Java代码实现如下：

public static int lastRemaining(int n) {
    boolean[] people = new boolean[n];
    Arrays.fill(people, true);
    int count = 0, index = 0, left = n;
    while (left > 1) {
        if (people[index]) {
            count++;
            if (count == 3) { // 报到3
                people[index] = false;
                count = 0;
                left--;
            }
        }
        index++;
        if (index == n) { // 循环遍历
            index = 0;
        }
    }
    for (int i = 0; i < n; i++) { // 找到最后一个人
        if (people[i]) {
            return i + 1;
        }
    }
    return -1;
}

其中，n表示圈中的人数，返回最后留下的人的原来编号。

4.有n个人围成一圈，顺序排号。从第1个人开始报数(从1到3报数)， 凡报到3的人退出圈子，问最后留下的是原来第几号的人，用c++实现编写此程序

以下是用 C++ 编写的程序，可以求出最后留下的人原来的编号：

#include <iostream>
using namespace std;

int main() {
    int n;
    cout << "请输入总人数 n：";
    cin >> n;

    // 初始化数组，表示第 i 个人是否还在圈子里面
    bool *in_circle = new bool[n];
    for (int i = 0; i < n; i++) {
        in_circle[i] = true;
    }

    int count = 0; // 报数
    int left = n; // 剩下的人数
    int index = 0; // 当前报数的人的下标

    while (left > 1) {
        if (in_circle[index]) { // 如果这个人还在圈子里面
            count += 1;
            if (count == 3) { // 报到 3 了，这个人要退出圈子
                in_circle[index] = false;
                count = 0;
                left -= 1;
            }
        }
        index = (index + 1) % n; // 移动到下一个人
    }

    // 找到最后留下的人的编号
    int result = -1;
    for (int i = 0; i < n; i++) {
        if (in_circle[i]) {
            result = i + 1; // 编号从 1 开始
            break;
        }
    }

    cout << "最后留下的人原来的编号是：" << result << endl;

    delete[] in_circle; // 释放数组内存
    return 0;
}

这个程序中用了一个 bool 类型的数组 `in_circle`，表示第 i 个人是否还在圈子里面。一开始，所有人都在圈子里面。每次循环，我们先判断当前报数的人是否还在圈子里面，如果是，我们就让他报数，如果他报到 3 了，就让他退出圈子，并且剩下的人数减 1。最后，我们遍历一遍 `in_circle` 数组，找到最后留下的人的编号。

这个程序的时间复杂度是 O(n^2)，因为每次循环都需要遍历整个圈子。如果想要更快的算法，可以使用链表来模拟这个圈子。