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

### 回答1：
这是一个经典的约瑟夫问题，可以用循环链表来解决。

具体思路是，先创建一个循环链表，将n个人依次加入链表中。然后从第一个人开始，每次数到3就将该节点从链表中删除。直到链表中只剩下一个节点，即为最后留下的人。

最后留下的人的原始编号可以通过在加入链表时记录每个人的编号来得到。

以下是C语言的代码实现：

#include <stdio.h>
#include <stdlib.h>

// 定义链表节点
typedef struct node {
    int num; // 编号
    struct node *next; // 指向下一个节点的指针
} Node;

// 创建循环链表
Node* createList(int n) {
    Node *head = NULL, *tail = NULL;
    for (int i = 1; i <= n; i++) {
        Node *p = (Node*)malloc(sizeof(Node));
        p->num = i;
        if (head == NULL) {
            head = p;
        } else {
            tail->next = p;
        }
        tail = p;
    }
    tail->next = head; // 将链表首尾相连，形成循环链表
    return head;
}

// 解决约瑟夫问题
int josephus(int n, int m) {
    Node *p = createList(n);
    int count = 0;
    while (p->next != p) { // 只要链表中不止一个节点，就继续循环
        count++;
        if (count == m) { // 数到3，删除该节点
            Node *q = p->next;
            p->next = q->next;
            printf("第%d个人出圈，编号为%d\n", q->num, q->num);
            free(q);
            count = 0;
        } else {
            p = p->next;
        }
    }
    int last = p->num; // 最后留下的人的编号
    free(p);
    return last;
}

int main() {
    int n = 10; // 10个人
    int m = 3; // 数到3退出
    int last = josephus(n, m);
    printf("最后留下的是原来第%d号的那位\n", last);
    return 0;
}

### 回答2：
这道题目是一个比较经典的约瑟夫问题，可以用递推来解决。具体步骤如下：

1. 首先，我们可以用一个bool型的数组来记录每个人是否还在圈子里，初始化都为true，表示所有人都在圈子中。

2. 接着，我们用一个循环来模拟“从第一个人开始报数（从1到3报数）”的过程，循环的初始值为1，表示从第一个人开始报数。当一个人报数为3时，我们将该人的状态设置为false，也就是从圈子中淘汰出去。

3. 我们继续用一个循环来模拟“留下最后一个人”的过程，每次循环都找到下一个在圈子中的人，直到只剩下一个人。具体做法是，我们用一个变量来记录当前的位置，初始值为0。每次循环，我们先找到下一个在圈子中的人，具体做法是将当前位置加1，然后一直加1直到找到一个在圈子中的人。最后，当圈子中只剩下一个人时，我们输出该人的编号即可。

下面是具体的代码实现：

#include <stdio.h>
#include <stdbool.h>

int main()
{
    int n, i, count, pos;
    bool a[100];

    // 输入n，表示有n个人围成一圈
    printf("请输入总人数n：");
    scanf("%d", &n);

    // 初始化数组，表示所有人都在圈子里
    for (i = 0; i < n; i++) {
        a[i] = true;
    }

    // 模拟“从第一个人开始报数”的过程
    count = 0;  // 计数器从1开始
    pos = 0;    // 当前位置从0开始
    while (count < n - 1) {
        // 如果当前位置上的人还在圈子中，则计数器加1
        if (a[pos]) {
            count++;
        }
        // 如果当前位置上的人需要淘汰出去，则将其状态设置为false
        if (count % 3 == 0) {
            a[pos] = false;
        }
        // 移动到下一个位置
        pos = (pos + 1) % n;
    }

    // 输出最后留下的人的编号
    for (i = 0; i < n; i++) {
        if (a[i]) {
            printf("最后留下的是原来第%d号的那位。\n", i + 1);
            break;
        }
    }

    return 0;
}

这样，我们就可以用递推的方式解决这个经典问题了。

### 回答3：
这是一道经典的约瑟夫问题，可以用数学递推的方式求解。

假设最终留下的人的编号为 f(n)，其中 n 为原来围成一圈的人数。

当 n=1 时，显然最后留下的人的编号为 1，即 f(1) = 1。

当 n>1 时，第一轮报数后，第三个人必定出圈，也就是说剩下了 n-1 个人围成一圈。此时，我们可以假设编号为 k 的人是第一个出圈的人，那么他报数时报到的数必定是 3 的倍数。

由于是围成一圈报数，按照顺时针方向数第三个人的编号为 (k+2)%n，因此，他报数时报到的数为：

1+[(k+2)%n-1]×3

其中，1 表示他前面已经出圈的人的个数，(k+2)%n-1 表示他前面还有几个人没出圈。如果这个数正好是 3 的倍数，那么编号为 k 的人出圈，剩下的人围成一圈继续进行报数。

根据这个递推公式，我们可以得到最后剩下的人的编号为：

f(n) = [f(n-1)+2]%n+1

其中，[x] 表示对 x 取整，例如 [5/2]=2。

因此，最后留下的人的编号只和原来围成一圈的人数有关，而与具体的报数顺序无关。