约瑟夫环

#include <iostream>
using namespace std;
 
int main() {
    int n,k,m; // 人数，开始位置，报数步长
    cin>>n>>k>>m;  
    int a[n];  // 标记是否出列
    int count=n;
    int cnt,num=k;  // num = k，用于标记当前报数人的位置
    for(int i=0;i<n;i++){
        a[i]=i;         // 初始化数组，每个人都有自己的编号
    }
    cnt=0;          // 计数器，当前报数的步数
    while (count>=1) {       // 还有未出列的人就循环
        if(a[num]!=-1) {     // 若当前报数人未出列
            cnt++;           // 则报数计数器+1，表示有人报数
            if(cnt==m) {     // 若数到了m！
               a[num]=-1;    // 当前人出列
               count--;      // 剩余人数--
               cnt=0;        // 报数计数归零！
            }
        } 
        if(num==n) num=1;    //假设转了一圈，则从头开始再来
        else num++;          // 
    }
    cout<<num-1<<endl;
}

#include <iostream>
using namespace std;
#include <list>
#include <iterator>

int main() {
    int n,k,m;
    cin >> n >> k >> m;
    list<int> lst;
    int count = 0;
    for(int i = 0; i < n; ++i)
    {
        lst.push_back(i);
    }

    list<int>::iterator curr = lst.begin();
    advance(curr, k);   

    while(lst.size() > 1)
    {
        ++count;
        if(count == m) 
        {
            curr = lst.erase(curr);
            if(curr == lst.end()) {curr = lst.begin();}
            count = 0;
        }
        else 
        {
            ++curr;
            if(curr == lst.end()) {curr = lst.begin();}
        }
    }
    cout << *lst.begin() << endl;
}

n,k,m=map(int,input().split())
l=list(range(n))
while n>=2:
    k=(k+m-1)%n
    l.pop(k)
    n-=1
print(*l)

#include <stdio.h>
int main() 
{
    int n, k, m;
    scanf("%d %d %d", &n, &k, &m);
    int arr[n],a=0,p=k;//arr[]s数组标记0出队，a标记出队人数，p标记当前未出队的首个报数编号
    for(int i=0;i<n;i++) arr[i] = 1;
    while(n-1-a)
    {
        for(int j=0;j<m-1;j++)
        {
            do{
              if(++p==n) p=0;
            }while(!arr[p]);//找出出队编号
        }
        arr[p]=0;
        a++;
        do{
            if(++p==n) p=0;
        }while(!arr[p]);//找出出队后下个首个报数编号
    }
    printf("%d\n",p);
    return 0;
}

import java.util.Scanner;

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        //n个人
        int n = in.nextInt();
        //从编号为k的人开始报数(编号即数组下标)
        int k = in.nextInt();
        //报到m的人出队
        int m = in.nextInt();
        //初始化队列
        List<Integer> people = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            people.add(i);
        }
        int currentIndex =
            k; //每次开始报数的人的下标，动态的、变化的。
        while (people.size() > 1) {
            //这个公式很关键，当前坐标+步数m-1 即是要移除的数的下标。 %是为了避免下标越界同时保证到最后一个数的时候环形遍历【核心！取模具有天然的环形遍历特性】
            //比如5个人，m=6,k=1 那么removeIndex=1+6-1=6,下标越界！6%5=1 则刚好吻合从下标1开始走6步到1。
            int removeIndex = (currentIndex + m - 1) % people.size();
            people.remove(removeIndex);

            //分2种情况：1、如果移除的数在最后一个数左侧，那么currentIndex=removeIndex; 2、如果移除的数是最后一个数，那么currentIndex会下标越界。
            //比如 0 1 3 4 ==> 0 1 3的过程，4被移除后，此时currentIndex=removeIndex=3,那么3在0 1 3 里开始重新计数会越界？怎么办？也会靠取模
            currentIndex = removeIndex % people.size();
            // System.out.println("当前队列：" + JSON.toJSONString(people));

        }
        System.out.println(people.get(0));

    }
}

#include <iostream>
#include <vector>
using namespace std;

int main() {
    int n, k, m;
    cin >> n >> k >> m;
    
    vector<int> circle(n, 0);  // 0表示还在队列中
    int count = n;             // 剩余人数
    int current = k;           // 当前报数位置
    
    while (count > 1) {
        // 报数m次
        int step = 0;
        while (step < m) {
            // 如果当前人还在队列中，算一次报数
            if (circle[current] == 0) {
                step++;
                if (step == m) break;  // 报到m了
            }
            current = (current + 1) % n;  // 移动到下一个人（循环）
        }
        
        // 当前人出队
        circle[current] = 1;
        count--;
        
        // 找到下一个开始报数的人（下一个还在队列中的人）
        while (circle[current] == 1) {
            current = (current + 1) % n;
        }
    }
    
    // 找到最后剩下的人
    for (int i = 0; i < n; i++) {
        if (circle[i] == 0) {
            cout << i << endl;
            break;
        }
    }
    
    return 0;
}

#include<bits/stdc++.h>
using namespace std;
int main() {
    // 定义核心变量：n=总人数，k=报数初始起点，m=报数淘汰数
    int n, k, m;
    cin >> n >> k >> m;
    int a[105] = {0};    // 淘汰状态数组：0=未淘汰，1=已淘汰
    int cnt = 0;         // 淘汰人数计数器
    int i = k;
    int t = 0;           // 报数模拟,在i处报出的数字
    while (cnt != n - 1) {
        if (i > n - 1) {
            i = 0;
        }

        if (a[i] == 0) {
            t++;
            if (t == m) {
                a[i] = 1;
                cnt++;
                t = 0;
            }
        }
        i++;
    }
    for (int i = 0; i < n; i++) {
        if (a[i] == 0) {
            cout << i;
        }
    }
    return 0;
}

import java.util.*;
public class Main{
    public static void main(String[] args){
        int n,k,m;
        Scanner in = new Scanner(System.in);
        n = in.nextInt();
        k = in.nextInt();
        m = in.nextInt();
        List<Integer> list = new ArrayList<>();
        for(int i=0;i<n;i++)list.add(i);
        while(true){
            if(list.size()==1)break;
            if(k+m-1>list.size()-1){
                int len = list.size();
                list.remove((k+m-1)%list.size());
                k = (k+m-1)%len;
            }else{
                list.remove(k+m-1);
                k = k+m-1;
            }
        }
        System.out.println(list.get(0));
    }
}