Problem:
ヨセフのおイモ
昔、ヨセフのおイモというゲームがありました。
n
人が参加しているとしましょう。参加者は中心を向いて円陣を組み、1 から順番に番号が振られます。アツアツのおイモがひとつ、参加者
n
(左の図内側の大きい数字の 30 )に渡されます。おイモを渡された参加者は右隣の参加者にそのおイモを渡します。
m
回目に渡された人は右隣の人に渡して円陣から抜けます(左の図では
m
= 9 の場合を表しています) 。 回渡す毎に一人ずつぬけ、最後に残った人が勝者となり、おイモをいただきます。
n
,
m
が決まってから、実際におイモを渡し始める前にどこにいたら勝てるかわかるといいですよね。上の図は 30 人の参加者で 9 人ごとに抜けるというルールでこのゲームをした場合を書き表しています。内側の大きい数字が参加者に振られた番号、外側の小さい数字が抜ける順番です。それによると、9,18,27,6,16,26 という順番で円陣から抜け出し、最後には 21 が残ることになります。すなわち 21 が勝者となります(小さい数字が 30 になっています)。
ゲーム参加者数
n
と円陣から抜け出す参加者の間隔
m
を入力し、勝者の番号を出力するプログラムを作成してください。ただし、
m
,
n
< 1000 とします。
入力
複数のデータセットが与えられます。各データセットは以下の形式で与えられます。
n
m
ゲーム参加者数
n
（整数）と円陣から抜け出す参加者の間隔
m
（整数）が空白区切りで１行に与えられます。
入力は２つの 0 で終わります。データセットの数は 50 を超えません。
出力
各データセットに対して、勝者となりおイモをいただく人の番号（整数）を１行に出力してください。
Sample Input
41 3
30 9
0 0
Output for the Sample Input
31
21

Submitted solutions:

code_snippet: #include <iostream>
#include <stdio.h>
#include <string.h>

using namespace std;

int main(void)
{
	char done[1000];
	int m, n;

	while (cin >> n >> m) {
		if ((m + n) == 0) {
			break;
		}

		int tmpNum = 0;
		int totalNow = 0;

		memset(done, 0, sizeof(done));

		while (n != totalNow) {
			for (int i = 0; ; tmpNum = (tmpNum + 1) % n) {
				if (done[tmpNum] == 1) continue;
				if (++i >= m) break;
			}

			//printf("Now=%d, Num=%d\n", totalNow, tmpNum);
			done[tmpNum] = 1;
			totalNow++;
		}

		printf("%d\n", tmpNum + 1);
	}

	return 0;
}
accuracy: 1
time_ms: 30
memory_kb: 3208
final_rank: 19

code_snippet: #include<bits/stdc++.h>
using namespace std;
int main(){
    int n, m;
    while(cin >> n >> m, n!=0){
        bool nuke[1010]={false};
        int id = 0;
        for(int i=0;i<n-1;i++){
            int sum = 0;
            while(sum < m){
                if(!nuke[id]) sum++;
                if(sum < m) id = (id+1)%n;
            }
            nuke[id] = true;
        }
        for(int i=0;i<n;i++){
            if(!nuke[i]) cout << i+1 << endl;
        }
    }
}
accuracy: 1
time_ms: 20
memory_kb: 3072
final_rank: 11

code_snippet: #include<iostream>
#include<algorithm>
#include<map>
#include<queue>
#include<stack>
#include<set>
#include<bitset>
#include<vector>
#include<string>
#include <iomanip>
#include <deque>
#include<list>
#include<cmath>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
using ll=long long;
using P=pair<int,int>;
using P_S=pair<int,string>;
using P_D=pair<double,int>;
using T=tuple<int,int,char,ll,string>;

int main()
{
    int n,m;
    while(1)
    {
        cin>>n>>m;
        if(n==0) break;
        vector<bool> potato(n,true);
        int now=n-1;
        rep(i,n){
            rep(j,m){
                now=(now+1)%n;
                if(potato[now]==false) j--;
            }
            potato[now]=false;
        }
        cout<<now+1<<endl;
    }
}
accuracy: 1
time_ms: 30
memory_kb: 3036
final_rank: 16

code_snippet: #include<iostream>
using namespace std;
int n,m,d[1000];
main(){
	while(cin>>n>>m,n){
		for(int i=0;i<n;i++)d[i]=0;
		int cnt=0,pos=0;
		while(cnt<n){
			int now=0;
			while(now<m){
				if(!d[pos%n])now++;
				pos++;
			}d[(pos-1)%n]=1;cnt++;
		}cout<<(pos-1)%n+1<<endl;
	}
}
accuracy: 1
time_ms: 10
memory_kb: 3088
final_rank: 7

code_snippet: #include <iostream>

using namespace std;

int main(void){
  int n,m;
  while(1){
    cin>>n>>m;
    if(n==0 && m==0)break;

    int people[n];
    for(int i=0;i<n;i++){
      people[i]=1;
    }
    int count=0;
    int ind=n-1;
    int rest=n;
    while(rest>1){
      ind=(ind+1)%n;
      if(people[ind]==1){
        count+=1;
        if(count==m){
          rest-=1;
          count=0;
          people[ind]=0;
        }
      }
    }
    for(int i=0;i<n;i++){
      if(people[i]==1){
        cout<<i+1<<endl;
      }
    }
  }
  return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 2992
final_rank: 10

code_snippet: #define _USE_MATH_DEFINES
#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <string>
#include <sstream>
#include <iomanip>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <stack>
#include <queue>
#include <vector>
#include <list>
#include <set>
#include <map>
#include <bitset>
#include <utility>
#include <numeric>

using namespace std;

using ll = long long;
using ull = unsigned long long;

const ll inf = (ll)1e9;
const ll mod = (ll)1e9 + 7;

int main()
{
	int n, m;
	while (cin >> n >> m)
	{
		if (n == 0 && m == 0)
		{
			break;
		}

		set<int> p;

		for (int i = 0; i < n; i++)
		{
			p.insert(i);
		}

		int s = -1;
		while (p.size() > 1)
		{
			for (int j = 0; j < m;)
			{
				s = (s + 1) % n;
				if (p.count(s))
				{
					j++;
				}
			}
			p.erase(s);
		}

		for (int i = 0; i < n; i++)
		{
			if (p.count(i))
			{
				cout << i + 1 << endl;
			}
		}
	}
}
accuracy: 1
time_ms: 40
memory_kb: 3120
final_rank: 20

code_snippet: #include <bits/stdc++.h>
#define int long long
#define ll long long
#define rep(i,n) for(int i=0;i<n;i++)
#define INF LLONG_MAX/3
#define eps LDBL_EPSILON
#define moder (1000000007)
#define pie acos(-1)
#define P std::pair<int,int>
#define prique priority_queue
#define ggr getchar();getchar();return 0;
using namespace std;
int n,m;
signed main(){
    while(cin>>n>>m){
        if(!n&&!m)break;
        set<int> st;
        for(int i=1;i<=n;i++)st.insert(i);
        int cnt=0;
        for(int i=1;st.size()>1;i++){
            if(st.find(i)!=st.end()){
                cnt++;
                if(cnt%m==0)st.erase(i);
            }
            if(i==n)i=0;
        }
        cout<<*st.begin()<<endl;
    }
}
accuracy: 1
time_ms: 30
memory_kb: 3124
final_rank: 17

code_snippet: #include <iostream>
#include <vector>
#include <list>
#include <algorithm>
#include <string>
#include <sstream>
#include <stack>
#include <iomanip>
#include <numeric>
#include <queue>
#include <climits>
#include <set>
#include <complex>
#include <cmath>
#include <cstring>
#include <map>
using namespace std;
using ll = long long;
#define MOD 1000000007
#define INF 1LL << 59
using ld = long double;

bool operator<(const pair<int, int> &a, const pair<int, int> &b)
{
    if (a.first == b.first)
    {
        return b.second > a.second;
    }
    return a.first < b.first;
}

ll arr[1000010];
int main()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);
    //cout << fixed << setprecision(6);

    int n, m;
    while (cin >> n >> m)
    {
        if (n == 0 && m == 0)
            break;

        int arr[1010] = {0};

        vector<int> v;
        int cnt = 0;
        int idx = 0;
        while ((int)v.size() != n)
        {
            if (arr[idx] == 0)
            {
                cnt++;
            }
            if (cnt == m)
            {
                arr[idx] = 1;
                v.push_back(idx);
                cnt = 0;
            }
            idx++;
            idx %= n;
        }
        cout << v[v.size() - 1] + 1 << endl;
    }
    return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 3112
final_rank: 12

code_snippet: #include<iostream>
using namespace std;
int n,m;
int d[1000];
main()
{
	while(cin>>n>>m,n)
	{
		for(int i=0;i<n;i++)d[i]=0;
		int cnt=0,pos=0;
		while(cnt<n)
		{
			int now=0;
			while(now<m)
			{
				if(!d[pos%n])now++;
				pos++;
			}
			d[(pos-1)%n]=1;
			cnt++;
		}
		cout<<(pos-1)%n+1<<endl;
	}
}
accuracy: 1
time_ms: 10
memory_kb: 2996
final_rank: 4

code_snippet: #include<iostream>
#include<math.h>
#include<vector>
#include<algorithm>
#include<cstdio>
using namespace std;
 
int main(){
 
    int n,m,count,tmp;
 
    while(true){
        scanf("%d %d",&n,&m);
        if(n == 0 && m == 0)break;
 
        count = n;
        int array[n];
        for(int i=0; i < n; i++)array[i] = 1;
 
        tmp = 0;
        for(int i=0;count > 1;){
            if(array[i] == 1){
                tmp++;
                if(tmp == m){
                    array[i] = 0;
                    count--;
                    tmp = 0;
                    i = (i+1)%n;
                }else{
                    i = (i+1)%n;
                }
            }else{
                i = (i+1)%n;
            }
        }
 
        for(int i=0; i < n; i++){
            if(array[i] == 1)printf("%d\n",i+1);
        }
 
    }
 
    return 0;
}
accuracy: 1
time_ms: 30
memory_kb: 3188
final_rank: 18

code_snippet: #include <bits/stdc++.h>
using namespace std;

int main() {
  int n, m;
  while (cin >> n >> m, n) {
    bool used[1010] = {};
    int cnt = 0;
    vector<int> ans;
    for (int i = 0; ans.size() < n; ++i) {
      i %= n;
      if (used[i]) continue;
      cnt++;

      if (cnt == m) {
        used[i] = true;
        cnt = 0;
        ans.push_back(i + 1);
      }
    }

    cout << ans.back() << endl;
  }
}
accuracy: 1
time_ms: 30
memory_kb: 3024
final_rank: 14

code_snippet: #include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<vector>
#include<string>
#include<sstream>
#include<cmath>
#include<numeric>
#include<map>
#include<stack>
#include<queue>
#include<cassert>
using namespace std;
int inf = 1000000000;


int main(void) {

  int n, m;
  while(cin >> n >> m){
    if( n == 0||m==0 ) break;

    int cnt = 0;
    vector<bool> b(n, true);
    int a = n;
    int pos = 0;
    while(true){
      pos %= n;
      pos++;
      if( !b[pos] ) continue;
      cnt++;
      if( cnt == m ){
        b[pos] = false;
        a--;
        // cerr << pos << endl;
        if( a == 0 ){
          cout << pos << endl;
          break;
        }
        cnt = 0;
      }
    }

  }


  return 0;
}


// EOF
accuracy: 1
time_ms: 30
memory_kb: 3028
final_rank: 15

code_snippet: #include <iostream>

using namespace std;

int main()
{
	int n, m;
	bool* participant;
	
	while (true) {
		cin >> n >> m;
		if (n==0 && m==0) break;
		
		participant = new bool[n];
		for (int i=0; i<n; i++) participant[i] = true;
		
		int index = 0;
		for (int cnt = n; cnt > 0; cnt--) {
			for (int step = m-1; ; index = (index + 1) % n) {
				if (participant[index]) {
					if (step==0) break;
					else step--;
				}
			}
			participant[index] = false;
			// cout << index+1 << " ";
		}
		
		cout << index+1 << endl;
		
		delete[] participant;
	}
	
	return 0;
}
accuracy: 1
time_ms: 30
memory_kb: 3016
final_rank: 13

code_snippet: #include<iostream>
 #include<stdio.h>
 #include<string>
 #include<math.h>
 #include<iomanip>
 #include<algorithm>
 #include<string.h>
 #include<cctype>
 #include<map>
 #include<set>
 #include<vector>
 #include<sstream>
 #include<stack>
 #include<queue>
 #include<deque>
 #include<functional>
 #include<utility>
 #include<list>
 
 using namespace std;
 
 int main()
 {
   int n,m;
   while(cin>>n>>m&&(n||m))
   {
     list<int> mm;
     list<int>::iterator iter;
     list<int>::iterator iter2;
     for(int i=1;i<=n;i++) mm.push_back(i);
     while(mm.size()>1)
     {
       for(int i=1;i<=m-1;i++)
       {
         mm.push_back(mm.front());
         mm.pop_front();
       }   
       mm.pop_front(); 
       //cout<<mm.front()<<endl;            
     }
     iter=mm.begin();
     cout<<(*iter)<<endl;                
   }
   //while(1);
   return 0; 
 }
accuracy: 1
time_ms: 10
memory_kb: 3032
final_rank: 6

code_snippet: #include<iostream>
#include<cstdio>
using namespace std;

int main()
{
	int a, b;
	while (cin >> a >> b, a | b) {
		int c = a;
		bool flag[1000]{};
		int now = 0;
		for (; a != 1;a--) {
			int k = 0;
			for(;;now++) {
				if (!flag[now%c]) {
					k++; 
					if (k == b) {
						flag[now%c] = true;
						break;
					}
				}
			 }
		}
		for (int i = 0; i < c; i++) {
			if (!flag[i]) {
				cout << i + 1 << endl;
			}
		}
	}
}
accuracy: 1
time_ms: 10
memory_kb: 2976
final_rank: 3

code_snippet: #include <stdio.h>
#include<math.h>
#include <algorithm>
using namespace std;

int main(){

	int n,m,count,tmp_count;

	while(true){
		scanf("%d %d",&n,&m);
		if(n == 0 && m == 0)break;

		count = n;
		int array[n];
		for(int i=0; i < n; i++)array[i] = 1;

		tmp_count = 0;
		for(int i=0;count > 1;){
			if(array[i] == 1){
				tmp_count++;
				if(tmp_count == m){
					array[i] = 0;
					count--;
					tmp_count = 0;
					i = (i+1)%n;
				}else{
					i = (i+1)%n;
				}
			}else{
				i = (i+1)%n;
			}
		}

		for(int i=0; i < n; i++){
			if(array[i] == 1)printf("%d\n",i+1);
		}

	}

    return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 2620
final_rank: 9

code_snippet: #define _USE_MATH_DEFINES
#include<iostream>
#include<cstdio>
#include<vector>
#include<algorithm>
#include<string>
#include<cmath>
#include<list>
#include<stack>
#include<queue>
#include<cctype>
#include<iomanip>
#include<functional>
#include<numeric>
#include<map>
#include<set>
#include<complex>
#define EPS 1e-10
using namespace std;
typedef long long llong;
int main() {
	int n, m;
	while (cin >> n >> m&&n&&m) {
		vector<int>v(n);
		//for (int i = 1; i <= n; i++)printf("%3d", i); cout << endl;
		for (int i = 0; i < n; i++)v[i] = 0;
		int cnt = 1;
		int tom = 0;
		int index;
		for (int i = 0; cnt != n + 1; i++) {
			if (v[i%n] == 0) {
				tom++;
			}

			if (tom == m) {
				v[i%n] = cnt++;
				index = i%n + 1;
				tom = 0;
			}
			//for (int j = 0; j < n; j++)printf("%3d", v[j]);
			//cout << "index is " << index << endl;
		}
		cout << index << endl;
	}
	return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3024
final_rank: 5

code_snippet: #include<iostream>
#include<string.h>
#include<cstdio>
#include<algorithm>
#include<stack>
#include<queue>
#include<vector>
#include<cmath>
#include<utility>
#define ll long long int
#define ld long double
#define INF 1000000000
#define EPS 0.0000000001
#define rep(i,n) for(i=0;i<n;i++)
using namespace std;
typedef pair<int, int> P;

string str;

int main()
{
  while(1){
    int n,m;

    cin>>n>>m;
    if(n==0 &&m==0)break;
    int order[1000]={};
    int i;
    int cnt=1;
    int num=1;
    while(num>0){
      rep(i,n){
	if(order[i])continue;
	if(cnt==m){
	  order[i]=num;
	  cnt=0;
	  if(num==n){
	    num=-1;
	    break;
	  }
	  num++;
	}
	cnt++;
      }
    }
    rep(i,n)
      if(order[i]==n){
	cout<<i+1<<endl;
	break;
      }
  }
}
accuracy: 1
time_ms: 10
memory_kb: 1160
final_rank: 1

code_snippet: #define scanf_s scanf
//#define gets_s gets
#include <stdio.h>
#include <string>
#include <iostream>
#include <math.h>
using namespace std;
#define MAX 1000
#define MIN 2
int main(void)
{
	int n, m;
	while (scanf_s("%d %d",&n,&m) != EOF) {
		if (n == 0 && m == 0) break;
		int h[MAX + 1] = { 0 },ans = 0, cou = 0, k = 0;
		while(cou < n) {
			for (int i = ans + 1; k <= m; ++i) {
				if (i > n) { i = i - n; }
				if (h[i] == false) { ++k; }
				if (k >= m) {
					k = 0; ++cou;
					h[i] = true;
					ans = i;
					break;
				}
			}
		}
		printf("%d\n", ans);
	}
}
accuracy: 1
time_ms: 10
memory_kb: 1188
final_rank: 2

code_snippet: #include <iostream>
#include <cstdio>
#include <string>
#include <cstring>
#include <deque>
#include <list>
#include <queue>
#include <stack>
#include <vector>
#include <utility>
#include <algorithm>
#include <map>
#include <set>
#include <complex>
#include <cmath>
#include <limits>
#include <ctime>
using namespace std;
 
#define rep(i,a,n) for(int i=a; i<n; i++)
#define repr(i,a,n) for(int i=a; i>=n; i--)
#define pb(a) push_back(a)
#define fr first
#define sc second
#define INF 999999999
 
#define X real()
#define Y imag()
#define EPS (1e-10)
#define EQ(a,b) (abs((a) - (b)) < EPS)
#define EQV(a,b) ( EQ((a).X, (b).X) && EQ((a).Y, (b).Y) )
#define LE(n, m) ((n) < (m) + EPS)
#define GE(n, m) ((n) + EPS > (m))
 
typedef vector<int> VI;
typedef vector<VI> MAT;
typedef pair<int, int> pii;
typedef long long int ll;
 
typedef complex<double> P;
typedef pair<P, P> L;
typedef pair<P, double> C;
 
int dy[]={0, 0, 1, -1};
int dx[]={1, -1, 0, 0};
int const MOD = 1000000007;
 
namespace std {
    bool operator<(const P a, const P b) {
        return a.X != b.X ? a.X < b.X : a.Y < b.Y;
    }
}
 
int main() {
    int n, m;
    while(cin >> n >> m) {
        int a[1010];
        memset(a, 0, sizeof(a));
        if(n == 0 && m == 0) break;
        int p = 0, i = 0, cnt = 0;
        while(i < n) {
            //printf("%d %d %d\n",i, cnt, p);
            if(a[p] == 0) {
                cnt++;
                if(cnt % m == 0) {
                    // cout << p + 1 << endl;
                    a[p] = 1;
                    i++;
                    p = (p + 1) % n;
                }
                else {p = (p + 1) % n;}
            }
            else p = (p + 1) % n;
        }
        cout << (p == 0 ? n : p) << endl;
    }
    return 0;
}
accuracy: 1
time_ms: 40
memory_kb: 1164
final_rank: 8