import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class No10 {
//约瑟芬环 游戏：有n个人站成一个圈，标上号1-n：从第一个开始报数，数到m,就拖出去杀掉，下一位从一开始数，数到m杀掉，问最后一个人的标号是多少，
//下面有两个方法
//方法2是正确的，方法只能满足小数据，大一点的就异常了。求大神帮我改一下，看我的打印信息就知道我的思路了。
public static void main(String[] args) {
// TODO Auto-generated method stub
//经测试，输入： 6 3
//12 4都成功，输入大了就不行了，比如54 12就报错了，求帮我修改一下
Scanner scanner = new Scanner(System.in);
System.out.print("请输入总人数：");
int totalNum = scanner.nextInt();
System.out.print("请输入报数的大小：");
int cycleNum = scanner.nextInt();
yuesefu1(totalNum, cycleNum);
System.out.println("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
yuesefu2(totalNum, cycleNum);
}
public static void yuesefu1(int t ,int p)
{
//首先我把这些人给放到数组里面，方便操作
List l = new ArrayList();
for(int i=1;i<=t;i++)
{
l.add(i);
}
System.out.println(l.size());
int wei =p;
while(l.size()>1)
{
if(l.size()==p)
{
System.out.println("等于p");
System.out.println("删掉"+l.get(p-1));
l.remove(p-1);
}if(l.size()<p)
{
System.out.println("小于p");
System.out.println("删掉"+l.get(p-l.size()-1));
l.remove(l.get(p-l.size()-1));
System.out.println("---------------------------------");
for(int k = 0;k<l.size();k++)
{
System.out.print(l.get(k)+".");
}
System.out.println("---------------------------------");
}
else{
//先删除一个p位置的
l.remove(p-1);
//---------------------------------
System.out.println("---------------------------------");
for(int k = 0;k<l.size();k++)
{
System.out.print(l.get(k)+".");
}
System.out.println("---------------------------------");
//---------------------------------
for(int j=0;j<p-1;j++)
{
l.add(l.get(j));
}
//---------------------------------
System.out.println("---------------------------------");
for(int k = 0;k<l.size();k++)
{
System.out.print(l.get(k)+".");
}
System.out.println();
System.out.println("---------------------------------");
//---------------------------------
for(int j=0;j<p-1;j++)
{
l.remove(0);
}
//---------------------------------
System.out.println("---------------------------------");
for(int k = 0;k<l.size();k++)
{
System.out.print(l.get(k)+".");
}System.out.println();
System.out.println("---------------------------------");
}
}
System.out.println("最后的："+l.get(0));
}
public static void yuesefu2(int t,int p)
{
List list = new ArrayList();
for(int i=1;i<=t;i++)
{
list.add(i);
}
int k=0;
while(list.size()>0)
{
k = k+p;
k= k%(list.size())-1;
System.out.print("k="+k+"值为：");
if(k<0)
{
System.out.println(list.get(list.size()-1));
list.remove(list.size()-1);
k=0;
}else
{
System.out.println(list.get(k));
list.remove(k);
}
}
}
}
14 个解决方案
#1
求大神，新鲜出炉的面试题！~~！~！·
#2
该回复于2015-07-13 14:32:15被管理员删除
#3
if (l.size() < p) {
System.out.println("小于p");
System.out.println("删掉" + l.get(p - l.size() - 1));
l.remove(l.get(p - l.size() - 1));
System.out.println("--------------------------------[code=java]-");
for (int k = 0; k < l.size(); k++) {
System.out.print(l.get(k) + ".");
}
System.out.println("---------------------------------");
}[/code]
小于里面，如果删掉了人你没有重新排序。而且你这样如果剩两个人，进入等于分支，之后又会进小于分支，全删完了。
#4
那我该如何改这个代码呢？
#5
{
int index = 0;
for(int i=2;i<=n;i++){
index = (index+m)%n
}
sysout(index);
}
#6
没看你代码，自己写了个。。
public static void main(String[] args) {
int n = 5;
int m = 3;
List<Integer> list = new ArrayList<Integer>();
for (int i = 1; i < n + 1; i++) {
list.add(i);
}
int count = 0;
int index = 0;
int len = list.size();
while (len > 0) {
count++;
if (count >= m) {
System.out.println(list.get(index));
list.remove(index);
index--;
count = 0;
len--;
}
if (len > 0)
index = (++index) % len;
}
}
public static void main(String[] args) {
int n = 5;
int m = 3;
List<Integer> list = new ArrayList<Integer>();
for (int i = 1; i < n + 1; i++) {
list.add(i);
}
int count = 0;
int index = 0;
int len = list.size();
while (len > 0) {
count++;
if (count >= m) {
System.out.println(list.get(index));
list.remove(index);
index--;
count = 0;
len--;
}
if (len > 0)
index = (++index) % len;
}
}
#7
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
importjava.util.LinkedList;
*@authorLoveyali_dengforever
publicclassYuesefu{
*约瑟夫环是一个数学的应用问题：
*已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个
*人出列；
*他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。
*@paramargs
privatestaticStringBufferremovedStr=newStringBuffer("");//记录出列的数字
publicstaticvoidmain(String[]args){
longstartTime=System.currentTimeMillis();//获取开始时间
process（5000,10,1）；
System.out.println(removedStr.substring(0,removedStr.length-1））；
longendTime=System.currentTimeMillis;//获取结束时间
System.out.println("程序运行时间："+(endTime-startTime)+"ms");
publicstaticvoidprocess(intn,intk,intm)
//构建一个list，存放人数
LinkedList<Integer>list=newLinkedList<Integer>;
for(inti=0;i<n;i++)
if(i+k>n)
list.add(i+k-n);
}else{
list.add(i+k);
intcount=1;//记录数的人数
cycleCal(list,count,m);
publicstaticvoidcycleCal(LinkedList<Integer>list,intcount,intm)
intlen=list.size;
if(len>1）
for(inti=0;i<len;i++)
if(count==m){//第m个时，remove
removedStr.append(list.get(i)).append(",");
list.remove(i);
len=list.size;
i--;
count=0;
count++;
cycleCal(list,count,m);
}else{
if(len!=0)
removedStr.append(list.get(0)).append(",");
#8
importjava.util.LinkedList;
*@authorLoveyali_dengforever
publicclassYuesefu{
*约瑟夫环是一个数学的应用问题：
*已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个
*人出列；
*他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。
*@paramargs
privatestaticStringBufferremovedStr=newStringBuffer("");//记录出列的数字
publicstaticvoidmain(String[]args){
longstartTime=System.currentTimeMillis();//获取开始时间
process（5000,10,1）；
System.out.println(removedStr.substring(0,removedStr.length-1））；
longendTime=System.currentTimeMillis;//获取结束时间
System.out.println("程序运行时间："+(endTime-startTime)+"ms");
publicstaticvoidprocess(intn,intk,intm)
//构建一个list，存放人数
LinkedList<Integer>list=newLinkedList<Integer>;
for(inti=0;i<n;i++)
if(i+k>n)
list.add(i+k-n);
}else{
list.add(i+k);
intcount=1;//记录数的人数
cycleCal(list,count,m);
publicstaticvoidcycleCal(LinkedList<Integer>list,intcount,intm)
intlen=list.size;
if(len>1）
for(inti=0;i<len;i++)
if(count==m){//第m个时，remove
removedStr.append(list.get(i)).append(",");
list.remove(i);
len=list.size;
i--;
count=0;
count++;
cycleCal(list,count,m);
}else{
if(len!=0)
removedStr.append(list.get(0)).append(",");
#9
你的第一个方法,每次移除一个,又从第一个人开始报数,当你的t是u的倍数时,最终结果可能是对的,但过程绝对是不对的,你运行下面这个方法,可能会帮助你理解这个过程.
public static Integer yuesefu(int renshu,int num){
ArrayList<Integer> array = new ArrayList<Integer>();
for(int i=1;i<=renshu;i++) array.add(Integer.valueOf(i));
int qty=renshu;//剩余人数
int index=0;//下标
while(qty>1){
index=(index+num-1)%array.size();
int temp=array.remove(index);
qty--;
index=index==array.size()?0:index;
System.out.println("移除编号为"+temp+"的人--编号为"+array.get(index)+"的人开始报数");
System.out.println(array.toString());
System.out.println("-----------------------------------------------------------");
}
return array.get(0);
}
#10
public static void yuesefu3(int t, int p) {
// 首先我把这些人给放到数组里面，方便操作
List<Integer> l = new ArrayList<Integer>();
for (int i = 1; i <= t; i++) {
l.add(i);
}
System.out.println(l.size());
// 计数器
int count = 0;
// 下标，初始报数从第0个人开始
int index = 0;
outer: while (l.size() > 1) {
// 若报数超过一圈，则index大于size，则index还原为0
if (index >= l.size()) {
index = 0;
}
// 一圈以内的报数
for (; index < l.size(); index++) {
count++;
System.out.println("编号：" + l.get(index) + "报数：" + count);
if (p == count) {
System.out.println("编号：" + l.remove(index) + "的人被干掉了！");
// 报数还原
count = 0;
// 跳转到外循环判断当前人数
continue outer;
}
}
}
System.out.println("最后剩下" + l.size() + "个人，他的编号为：" + l.get(0));
}
LZ看看符合要求不
#11
没看你的，写了个，可能写的不太简洁
import java.util.ArrayList;
import java.util.List;
public class JosRing {
public static void main(String[] args) {
int m = 3;
int k = 3;
int index = -1;
List<Person> list = new ArrayList<Person>();
// 初始化小盆友
for (int i = 0; i < k; i++) {
Person p = new Person();
p.setId(i + 1);
list.add(p);
}
// 直到最后剩下一个人结束
for (int i = 1; i <= m; i++) {
if(list.size()==1){
break;
}
index++;
if (index > list.size() - 1) {
index = index - list.size();
}
System.out.println("current:" + list.get(index).getId());
if (i == m) {
if (index > list.size() - 1) {
index = index - list.size();
}
Person remove = list.get(index);
System.out.println("remove:" + remove.getId());
list.remove(index);
index--;
i = 0;
}
}
//输出最后剩余：
System.out.println("the last is :"+list.get(0).getId());
}
}
class Person {
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
private int id;
}
#12
import java.util.ArrayList;
import java.util.List;
public class JosRing {
public static void main(String[] args) {
int m = 3;
int k = 20;
int index = -1;
List<Person> list = new ArrayList<Person>();
// 初始化小盆友
for (int i = 0; i < k; i++) {
Person p = new Person();
p.setId(i + 1);
list.add(p);
}
// 直到最后剩下一个人结束
for (int i = 1; i <= m; i++) {
if(list.size()==1){
break;
}
index++;
if (index > list.size() - 1) {
index = index - list.size();
}
System.out.println("current:" + list.get(index).getId());
if (i == m) {
Person remove = list.get(index);
System.out.println("remove:" + remove.getId());
list.remove(index);
index--;
i = 0;
}
}
//输出最后剩余：
System.out.println("the last is :"+list.get(0).getId());
}
}
class Person {
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
private int id;
}
#13
刚进一家公司无聊也来做下,不知道有没有问题
import java.util.*;
public class Test {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int a = 200;//总人数
int b = 7;//数到b的人出列
int c = 3;//从编号为c的开始数
LinkedList<Long> list = new LinkedList<Long>();
for(long i=0; i<a; i++){
list.add(i+1);
}
long pos = getPos(list, a, b, c).get(0);
System.out.println("总共"+a+"人,从"+c+"开始数到"+b+"的那个人出列,直到剩下最后一个"+pos);
yuesefu3(a, b, c);
}
public static LinkedList<Long> getPos(LinkedList<Long> list, long n, long m, long k){
long na = -1;//游戏未开始,标记设为-1
long count = 0;//计数器,从0开始
count = k;//计数器设为指定的值
for(;count <= m;count++){
na++;//每次数数标记+1
if(na >= list.size()) //若标记超过现有队列的总人数,就把标记重置到队列第一个
na = 0;
if(count == m){//数到m时,剔除对应的人
count = 0;//重置计数器
int index = (int) na;//linkedlist的remove只能传int的角标
list.remove(index);
na -=1;//因为每次都踢出一个人,根据linkedlist的特性,角标需要-1
if(list.size()==1) //队列剩下最后一个游戏结束
break;
}
}
return list;
}
}
#14
刚进一家公司,看代码看的无聊了也来做下,不知道有没问题
import java.util.*;
public class Test {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int a = 200;//总人数
int b = 7;//数到b的人出列
int c = 3;//从编号为c的开始数
LinkedList<Long> list = new LinkedList<Long>();
for(long i=0; i<a; i++){
list.add(i+1);
}
long pos = getPos(list, a, b, c).get(0);
System.out.println("总共"+a+"人,从"+c+"开始数到"+b+"的那个人出列,直到剩下最后一个"+pos);
yuesefu3(a, b, c);
}
public static LinkedList<Long> getPos(LinkedList<Long> list, long n, long m, long k){
long na = -1;//游戏未开始,标记设为-1
long count = 0;//计数器,从0开始
count = k;//计数器设为指定的值
for(;count <= m;count++){
na++;//每次数数标记+1
if(na >= list.size()) //若标记超过现有队列的总人数,就把标记重置到队列第一个
na = 0;
if(count == m){//数到m时,剔除对应的人
count = 0;//重置计数器
int index = (int) na;//linkedlist的remove只能传int的角标
list.remove(index);
na -=1;//因为每次都踢出一个人,根据linkedlist的特性,角标需要-1
if(list.size()==1) //队列剩下最后一个游戏结束
break;
}
}
return list;
}
}
#1
求大神，新鲜出炉的面试题！~~！~！·
#2
该回复于2015-07-13 14:32:15被管理员删除
#3
if (l.size() < p) {
System.out.println("小于p");
System.out.println("删掉" + l.get(p - l.size() - 1));
l.remove(l.get(p - l.size() - 1));
System.out.println("--------------------------------[code=java]-");
for (int k = 0; k < l.size(); k++) {
System.out.print(l.get(k) + ".");
}
System.out.println("---------------------------------");
}[/code]
小于里面，如果删掉了人你没有重新排序。而且你这样如果剩两个人，进入等于分支，之后又会进小于分支，全删完了。
#4
那我该如何改这个代码呢？
#5
{
int index = 0;
for(int i=2;i<=n;i++){
index = (index+m)%n
}
sysout(index);
}
#6
没看你代码，自己写了个。。
public static void main(String[] args) {
int n = 5;
int m = 3;
List<Integer> list = new ArrayList<Integer>();
for (int i = 1; i < n + 1; i++) {
list.add(i);
}
int count = 0;
int index = 0;
int len = list.size();
while (len > 0) {
count++;
if (count >= m) {
System.out.println(list.get(index));
list.remove(index);
index--;
count = 0;
len--;
}
if (len > 0)
index = (++index) % len;
}
}
public static void main(String[] args) {
int n = 5;
int m = 3;
List<Integer> list = new ArrayList<Integer>();
for (int i = 1; i < n + 1; i++) {
list.add(i);
}
int count = 0;
int index = 0;
int len = list.size();
while (len > 0) {
count++;
if (count >= m) {
System.out.println(list.get(index));
list.remove(index);
index--;
count = 0;
len--;
}
if (len > 0)
index = (++index) % len;
}
}
#7
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
importjava.util.LinkedList;
*@authorLoveyali_dengforever
publicclassYuesefu{
*约瑟夫环是一个数学的应用问题：
*已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个
*人出列；
*他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。
*@paramargs
privatestaticStringBufferremovedStr=newStringBuffer("");//记录出列的数字
publicstaticvoidmain(String[]args){
longstartTime=System.currentTimeMillis();//获取开始时间
process（5000,10,1）；
System.out.println(removedStr.substring(0,removedStr.length-1））；
longendTime=System.currentTimeMillis;//获取结束时间
System.out.println("程序运行时间："+(endTime-startTime)+"ms");
publicstaticvoidprocess(intn,intk,intm)
//构建一个list，存放人数
LinkedList<Integer>list=newLinkedList<Integer>;
for(inti=0;i<n;i++)
if(i+k>n)
list.add(i+k-n);
}else{
list.add(i+k);
intcount=1;//记录数的人数
cycleCal(list,count,m);
publicstaticvoidcycleCal(LinkedList<Integer>list,intcount,intm)
intlen=list.size;
if(len>1）
for(inti=0;i<len;i++)
if(count==m){//第m个时，remove
removedStr.append(list.get(i)).append(",");
list.remove(i);
len=list.size;
i--;
count=0;
count++;
cycleCal(list,count,m);
}else{
if(len!=0)
removedStr.append(list.get(0)).append(",");
#8
importjava.util.LinkedList;
*@authorLoveyali_dengforever
publicclassYuesefu{
*约瑟夫环是一个数学的应用问题：
*已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个
*人出列；
*他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。
*@paramargs
privatestaticStringBufferremovedStr=newStringBuffer("");//记录出列的数字
publicstaticvoidmain(String[]args){
longstartTime=System.currentTimeMillis();//获取开始时间
process（5000,10,1）；
System.out.println(removedStr.substring(0,removedStr.length-1））；
longendTime=System.currentTimeMillis;//获取结束时间
System.out.println("程序运行时间："+(endTime-startTime)+"ms");
publicstaticvoidprocess(intn,intk,intm)
//构建一个list，存放人数
LinkedList<Integer>list=newLinkedList<Integer>;
for(inti=0;i<n;i++)
if(i+k>n)
list.add(i+k-n);
}else{
list.add(i+k);
intcount=1;//记录数的人数
cycleCal(list,count,m);
publicstaticvoidcycleCal(LinkedList<Integer>list,intcount,intm)
intlen=list.size;
if(len>1）
for(inti=0;i<len;i++)
if(count==m){//第m个时，remove
removedStr.append(list.get(i)).append(",");
list.remove(i);
len=list.size;
i--;
count=0;
count++;
cycleCal(list,count,m);
}else{
if(len!=0)
removedStr.append(list.get(0)).append(",");
#9
你的第一个方法,每次移除一个,又从第一个人开始报数,当你的t是u的倍数时,最终结果可能是对的,但过程绝对是不对的,你运行下面这个方法,可能会帮助你理解这个过程.
public static Integer yuesefu(int renshu,int num){
ArrayList<Integer> array = new ArrayList<Integer>();
for(int i=1;i<=renshu;i++) array.add(Integer.valueOf(i));
int qty=renshu;//剩余人数
int index=0;//下标
while(qty>1){
index=(index+num-1)%array.size();
int temp=array.remove(index);
qty--;
index=index==array.size()?0:index;
System.out.println("移除编号为"+temp+"的人--编号为"+array.get(index)+"的人开始报数");
System.out.println(array.toString());
System.out.println("-----------------------------------------------------------");
}
return array.get(0);
}
#10
public static void yuesefu3(int t, int p) {
// 首先我把这些人给放到数组里面，方便操作
List<Integer> l = new ArrayList<Integer>();
for (int i = 1; i <= t; i++) {
l.add(i);
}
System.out.println(l.size());
// 计数器
int count = 0;
// 下标，初始报数从第0个人开始
int index = 0;
outer: while (l.size() > 1) {
// 若报数超过一圈，则index大于size，则index还原为0
if (index >= l.size()) {
index = 0;
}
// 一圈以内的报数
for (; index < l.size(); index++) {
count++;
System.out.println("编号：" + l.get(index) + "报数：" + count);
if (p == count) {
System.out.println("编号：" + l.remove(index) + "的人被干掉了！");
// 报数还原
count = 0;
// 跳转到外循环判断当前人数
continue outer;
}
}
}
System.out.println("最后剩下" + l.size() + "个人，他的编号为：" + l.get(0));
}
LZ看看符合要求不
#11
没看你的，写了个，可能写的不太简洁
import java.util.ArrayList;
import java.util.List;
public class JosRing {
public static void main(String[] args) {
int m = 3;
int k = 3;
int index = -1;
List<Person> list = new ArrayList<Person>();
// 初始化小盆友
for (int i = 0; i < k; i++) {
Person p = new Person();
p.setId(i + 1);
list.add(p);
}
// 直到最后剩下一个人结束
for (int i = 1; i <= m; i++) {
if(list.size()==1){
break;
}
index++;
if (index > list.size() - 1) {
index = index - list.size();
}
System.out.println("current:" + list.get(index).getId());
if (i == m) {
if (index > list.size() - 1) {
index = index - list.size();
}
Person remove = list.get(index);
System.out.println("remove:" + remove.getId());
list.remove(index);
index--;
i = 0;
}
}
//输出最后剩余：
System.out.println("the last is :"+list.get(0).getId());
}
}
class Person {
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
private int id;
}
#12
import java.util.ArrayList;
import java.util.List;
public class JosRing {
public static void main(String[] args) {
int m = 3;
int k = 20;
int index = -1;
List<Person> list = new ArrayList<Person>();
// 初始化小盆友
for (int i = 0; i < k; i++) {
Person p = new Person();
p.setId(i + 1);
list.add(p);
}
// 直到最后剩下一个人结束
for (int i = 1; i <= m; i++) {
if(list.size()==1){
break;
}
index++;
if (index > list.size() - 1) {
index = index - list.size();
}
System.out.println("current:" + list.get(index).getId());
if (i == m) {
Person remove = list.get(index);
System.out.println("remove:" + remove.getId());
list.remove(index);
index--;
i = 0;
}
}
//输出最后剩余：
System.out.println("the last is :"+list.get(0).getId());
}
}
class Person {
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
private int id;
}
#13
刚进一家公司无聊也来做下,不知道有没有问题
import java.util.*;
public class Test {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int a = 200;//总人数
int b = 7;//数到b的人出列
int c = 3;//从编号为c的开始数
LinkedList<Long> list = new LinkedList<Long>();
for(long i=0; i<a; i++){
list.add(i+1);
}
long pos = getPos(list, a, b, c).get(0);
System.out.println("总共"+a+"人,从"+c+"开始数到"+b+"的那个人出列,直到剩下最后一个"+pos);
yuesefu3(a, b, c);
}
public static LinkedList<Long> getPos(LinkedList<Long> list, long n, long m, long k){
long na = -1;//游戏未开始,标记设为-1
long count = 0;//计数器,从0开始
count = k;//计数器设为指定的值
for(;count <= m;count++){
na++;//每次数数标记+1
if(na >= list.size()) //若标记超过现有队列的总人数,就把标记重置到队列第一个
na = 0;
if(count == m){//数到m时,剔除对应的人
count = 0;//重置计数器
int index = (int) na;//linkedlist的remove只能传int的角标
list.remove(index);
na -=1;//因为每次都踢出一个人,根据linkedlist的特性,角标需要-1
if(list.size()==1) //队列剩下最后一个游戏结束
break;
}
}
return list;
}
}
#14
刚进一家公司,看代码看的无聊了也来做下,不知道有没问题
import java.util.*;
public class Test {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int a = 200;//总人数
int b = 7;//数到b的人出列
int c = 3;//从编号为c的开始数
LinkedList<Long> list = new LinkedList<Long>();
for(long i=0; i<a; i++){
list.add(i+1);
}
long pos = getPos(list, a, b, c).get(0);
System.out.println("总共"+a+"人,从"+c+"开始数到"+b+"的那个人出列,直到剩下最后一个"+pos);
yuesefu3(a, b, c);
}
public static LinkedList<Long> getPos(LinkedList<Long> list, long n, long m, long k){
long na = -1;//游戏未开始,标记设为-1
long count = 0;//计数器,从0开始
count = k;//计数器设为指定的值
for(;count <= m;count++){
na++;//每次数数标记+1
if(na >= list.size()) //若标记超过现有队列的总人数,就把标记重置到队列第一个
na = 0;
if(count == m){//数到m时,剔除对应的人
count = 0;//重置计数器
int index = (int) na;//linkedlist的remove只能传int的角标
list.remove(index);
na -=1;//因为每次都踢出一个人,根据linkedlist的特性,角标需要-1
if(list.size()==1) //队列剩下最后一个游戏结束
break;
}
}
return list;
}
}