Problem:
病院の部屋番号
ウォーターデブンに住む建築家のデブンキーさんのもとに、古い大病院を改装する仕事の依頼が舞い込んできました。
国によっては忌み数(いみかず)として嫌われる数字を部屋番号に用いたくない人がいます(日本では 4 と 9 が有名です)。しかし、この病院の部屋番号は忌み数に関係なく、1 から順番に付けられていました。
それが気になったデブンキーさんは、機材やベッドの入れ替えが全て終わる前にウォーターデブンの忌み数である「4」と「6」を除いた数字で部屋番号を付けなおしてしまいました。しかし、入れ替え作業は旧部屋番号で計画していたので、残りの作業を確実に行うには旧部屋番号を新部屋番号に変換する必要があります。計算が苦手なデブンキーさんはこのことに気づいて愕然としています。
そんなデブンキーさんのために、旧部屋番号を入力とし対応する新部屋番号を出力するプログラムを作成してください。
15 番目までの部屋番号の対応表は以下のようになります。
旧部屋番号
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
新部屋番号
1
2
3
5
7
8
9
10
11
12
13
15
17
18
19
Input
複数のデータセットの並びが入力として与えられます。入力の終わりはゼロひとつの行で示されます。
各データセットとして、旧部屋番号を表す整数
n
(1 ≤
n
≤ 1,000,000,000) が１行に与えられます。
データセットの数は 30000 を超えません。
Output
入力データセットごとに、新部屋番号を１行に出力します。
Sample Input
15
100
1000000000
3
0
Output for the Sample Input
19
155
9358757000
3

Submitted solutions:

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

using ll = long long;

int main() {
    int n;
    while(cin >> n, n) {
        string res;
        while(n > 0) {
            int oct = n & 7;
            if(oct <= 3) {
                res += '0' + oct;
            } else if(4 == oct) {
                res += '0' + oct + 1;
            } else {
                res += '0' + oct + 2;
            }
            n >>= 3;
        }
        reverse(res.begin(), res.end());
        cout << res << endl;
    }
}
accuracy: 1
time_ms: 10
memory_kb: 3324
final_rank: 17

code_snippet: #include<bits/stdc++.h>
using namespace std;
int hassin(int x){
    if(x==4) return 5;
    return x<4?x:x+2;
}
void dfs(int n){
    if(n == 0) return;
    dfs(n/8);
    cout << hassin(n%8);
}
int main(){
    int n;
    while(cin >> n, n!=0){
        dfs(n);
        cout << endl;
    }
    return(0);
}
accuracy: 1
time_ms: 20
memory_kb: 3068
final_rank: 7

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

int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    ll n;
    auto f = [&](ll v){
        string s = to_string(v);
        int n = s.size();
        vector<vector<vector<ll>>> dp(n + 1, vector<vector<ll>>(2, vector<ll>(2)));
        dp[0][1][0] = 1;
        for(int i = 0; i < n; i++){
            for(int j = 0; j < 2; j++){
                for(int k = 0; k < 2; k++){
                    int r = j ? s[i] - '0': 9;
                    for(int l = 0; l <= r; l++){
                        dp[i + 1][j & (l == r)][k | (l == 4) | (l == 6)] += dp[i][j][k];
                    }
                }
            }
        }
        return dp[n][1][0] + dp[n][0][0] - 1;
    };
    while(cin >> n, n){
        ll ng = 0, ok = 1ll << 40, mid;
        while(ng + 1 < ok){
            mid = (ng + ok) / 2;
            if(f(mid) >= n)ok = mid;
            else ng = mid;
        }
        cout << ok << '\n';
    }
}
accuracy: 1
time_ms: 820
memory_kb: 3400
final_rank: 20

code_snippet: #include<bits/stdc++.h>
using namespace std;
using ll=long long;
int main(void){
    ll n;
    while(cin>>n,n){
        ll v[100]={0},c=0;
        while(n>0){
            v[c++]=n%8;
            n/=8;
        }
        while(c--){
            cout<<"01235789"[v[c]];
        }
        cout<<endl;
    }
    return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3320
final_rank: 16

code_snippet: #include <algorithm>
#include <iostream>
#include <vector>
void ToOctalNumber(int n) {
  if (!n)
    return;
  ToOctalNumber(n >> 3);
  std ::cout << ((n & 7) < 4 ? n & 7 : (n & 7) == 4 ? 5 : (n & 7) + 2);
}

int main() {
  int n;
  while (std::cin >> n, n) {
    ToOctalNumber(n);
    std::cout << "\n";
  }
}
accuracy: 1
time_ms: 20
memory_kb: 3008
final_rank: 4

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

int main() {
  int64_t dp[10];
  dp[0] = 1;
  for (int i = 1; i <= 9; i++)
    dp[i] = dp[i - 1] * 8;
  while (true) {
    int n;
    cin >> n;
    if (!n)
      return 0;
    int64_t ans = 0;
    while (n) {
      for (int i = 9; i >= 0; i--) {
        int d = n / dp[i];
        if (d >= 5)
          ans += (d + 2) * pow(10, i);
        else if (d >= 4)
          ans += (d + 1) * pow(10, i);
        else if (d >= 1)
          ans += d * pow(10, i);
        n -= dp[i] * d;
      }
    }
    cout << ans << endl;
  }
}
accuracy: 1
time_ms: 10
memory_kb: 3660
final_rank: 18

code_snippet: #define _USE_MATH_DEFINES
#include<iostream>
#include<string>
#include<sstream>
#include<regex>
#include<vector>
#include<stack>
#include<queue>
#include<set>
#include<map>
#include<list>
#include<algorithm>
#include<numeric>
#include<cmath>
#include<iomanip>
#include<random>
using namespace std;
#define int long long
#define uint unsigned long long
const int mod=1e9+7;
const int inf=mod*mod;
const double eps=1e-10;
signed main(){
	int n;
	while(cin>>n,n){
		stringstream ss;
		ss<<oct<<n;
		for(auto x:ss.str())
			cout<<"01235789"[x-'0'];
		cout<<endl;
	}
}
accuracy: 1
time_ms: 20
memory_kb: 3240
final_rank: 15

code_snippet: #include <iostream>
#include <string>
#include <cmath>
#include <algorithm>
#include <sstream>

int main() {

    while (true) {
        int n;
        std::cin >> n;

        if (n == 0) {
            break;
        }

        std::stringstream ss;
        ss << std::oct << n;
        std::string n_oct = ss.str();

        const int len = n_oct.length();

        std::string s = n_oct;
        std::replace(s.begin(), s.end(), '7', '9');
        std::replace(s.begin(), s.end(), '6', '8');
        std::replace(s.begin(), s.end(), '5', '7');
        std::replace(s.begin(), s.end(), '4', '5');

        std::cout << s << std::endl;
    }

    return 0;

}
accuracy: 1
time_ms: 20
memory_kb: 3160
final_rank: 12

code_snippet: #include <iostream>
#include <algorithm>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <numeric>
#include <bitset>
#include <cmath>

static const int MOD = 1000000007;
using ll = long long;
using u32 = unsigned;
using u64 = unsigned long long;
using namespace std;

template<class T> constexpr T INF = ::numeric_limits<T>::max()/32*15+208;

int main() {
    int n;
    string s = "01235789";
    while(cin >> n, n){
        string ans;
        while(n){
            ans += s[n%8];
            n /= 8;
        }
        reverse(ans.begin(),ans.end());
        cout << ans << "\n";
    }
    return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 3188
final_rank: 14

code_snippet: #include<iostream>
#include<algorithm>
#include <map>
#include <vector>
#include <stack>
#include<string>
#include<queue>
#include <regex>
#include<iomanip>

using namespace std;

int m[8] = { 0,1,2,3,5,7,8,9 };

int main()
{
	int n;
	cin >> n;
	while (n)
	{
		stack<int> nums;
		while (n)
		{
			nums.push(n % 8);
			n /= 8;
		}
		while (!nums.empty())
		{
			cout << m[nums.top()];
			nums.pop();
		}
		cout << endl;
		cin >> n;
	}
}
accuracy: 1
time_ms: 20
memory_kb: 2996
final_rank: 2

code_snippet: #include <iostream>
using namespace std;

long convert(long n);

int main(void){
  long n;
  while(true){
    cin>>n;
    if(n==0)break;
    cout<<convert(n)<<endl;
  }
  return 0;
}

long convert(long n){
  long order=1;
  long retval=0;
  while(n>0){
    int mod=n%8;
    if(mod>=5){
      mod+=2;
    }
    else if(mod>=4){
      mod+=1;
    }
    retval+=order*mod;
    n=n/8;
    order=order*10;
  }
  return retval;
}
accuracy: 1
time_ms: 10
memory_kb: 3068
final_rank: 6

code_snippet: #include<iostream>
#include<vector>

using namespace std;

int TableNewOctal[] = { 0,1,2,3,5,7,8,9 };
vector<int> Result;

int main() {
	int num;

	while (cin >> num, num) {
		while (num > 0) {
			Result.push_back(TableNewOctal[num % 8]);
			num /= 8;
		}
		while (!Result.empty()) {
			cout << Result.back();
			Result.pop_back();
		}
		cout << endl;
	}

	return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 3092
final_rank: 8

code_snippet: #include "bits/stdc++.h"

#define REP(i,num) for(int i=0;i<(num);++i)
#define LOOP(i) while(i--)
#define ALL(c) c.begin(),c.end()
#define PRINTALL(c) for(auto pitr=c.begin();pitr!=c.end();++pitr){cout<<*pitr;if(next(pitr,1)!=c.end())cout<<' ';}cout<<endl;
#define PAIRCOMP(c,comp) [](const pair<ll,ll>& lhs,const pair<ll,ll>& rhs){return lhs.c comp rhs.c;}

using namespace std;
using ll = long long;

constexpr ll atcoder_mod = 1e9+7;

template<typename T=int>
T in(){T x; cin >> x; return (x);}
template<typename T=int,typename C=vector<T>>
C vecin(int N){C x(N);REP(i,N){x[i]=in<T>();}return move(x);}

void vout(){cout << endl;}
template<typename Head,typename... Tail>
void vout(Head&& h,Tail&&... t){cout << ' ' << h;vout(forward<Tail>(t)...);}
void out(){cout << endl;}
template<typename Head,typename... Tail>
void out(Head&& h,Tail&&... t){cout << h;vout(forward<Tail>(t)...);}

int main(){
	cin.tie(0);
	ios::sync_with_stdio(false);
	cout<<fixed<<setprecision(10);

	char conv[8]={'0','1','2','3','5','7','8','9'};
	while(true){
		int X=in();
		if(!X) break;
		vector<int> V;
		while(X){
			V.push_back(X%8);
			X/=8;
		}
		reverse(ALL(V));
		for(auto& x:V) cout<<conv[x];
		out();
	}

	return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 3144
final_rank: 11

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

signed main() {
    while (true) {
        int n;
        cin >> n;
        
        if (n==0) {
            break;
        }
        
        map<int, int> mp{{0,0}, {1,1}, {2,2}, {3,3}, {4,5}, {5,7}, {6,8}, {7,9}};
        
        int ans = 0;
        int c = 1;
        
        while (!(n<8)) {
            ans += mp[n%8]*c;
            n /= 8;
            c *= 10;
        }
        
        ans += mp[n]*c;
        
        cout << ans << endl;
    }
}
accuracy: 1
time_ms: 20
memory_kb: 3004
final_rank: 3

code_snippet: #include <iostream>
using namespace std;

int main()
{
	unsigned long long n, m;

	cin >> n;

	while (n) {
		m = 0;
		unsigned long long i = 1;

		while (n > 0) {
			unsigned long long t = n % 8;
			if (t < 4)
				m += t * i;
			else if (t == 4)
				m += 5 * i;
			else
				m += (t + 2) * i;

			n /= 8;
			i *= 10;
		}

		cout << m << endl;

		cin >> n;
	}

	return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3000
final_rank: 1

code_snippet: #include <iostream>
#include <vector>
using namespace std;
int n[] = { 0,1,2,3,5,7,8,9 };

int main() {
	while(true){
	vector<int>v;
	long long num;
	cin >> num;
	if (num == 0) return 0;
	while (num >= 1) {
		v.push_back(n[num % 8]);
		num /= 8;
	}
	for (int i = v.size() - 1; i >= 0; i--) cout << v[i];
	cout << endl;
}
}
accuracy: 1
time_ms: 20
memory_kb: 3128
final_rank: 10

code_snippet: #include <iostream>
#include <string>
#define int long long
using namespace std;
signed main() {
	int a[10];
	a[0] = 0; a[1] = 1; a[2] = 2; a[3] = 3; a[4] = 5; a[5] = 7; a[6] = 8; a[7] = 9;
	int n;
	while (cin >> n, n) {
		string ans;
		int m = n;
		while (m > 0) {
			ans = (char)(a[m % 8] + '0') + ans;
			m /= 8;
		}
		cout << ans << endl;
	}
}
accuracy: 1
time_ms: 20
memory_kb: 3176
final_rank: 13

code_snippet: #define _CRT_SECURE_NO_WARNINGS
#include "bits/stdc++.h"
using namespace std;
#define rep(i, n) for(int i=0; i<(n); ++i)
#define FOR(i, m, n) for(int i=(m); i<(n); ++i)
#define sz(x) ((int)(x).size())
#define all(x) (x).begin(),(x).end()
#define mp make_pair
#define pb push_back
#define Cout(x) cout << (x) << endl
#define Cout2(x, y) cout << (x) << " " << (y) << endl
#define dump(x) cout << #x << " = " << (x) << endl;
#define forauto(i, a) for(auto i : a)cout << i << " "; puts("");
typedef long long LL;
typedef vector<int> VI;
typedef vector<LL> VL;
typedef vector<string> VS;
typedef vector<bool> VB;
typedef vector<vector<int>> VVI;
typedef pair<int, int> PII;
const int inf = 1e9;
const double pi = acos(-1.0);

string convi(string s) {
	char a[] = { '0','1','2','3','5','7','8','9' };
	string ret;
	for (auto c : s) {
		ret += a[c - '0'];
	}
	return ret;
}

int main() {
	int n;
	while (cin >> n && n) {
		stringstream ss;
		ss << oct << n;
		string s = ss.str();
		s = convi(s);
		Cout(s);
	}
}
accuracy: 1
time_ms: 30
memory_kb: 3112
final_rank: 9

code_snippet: #include<iostream>
#include<cstring>
using namespace std;
string s;
long dp[11][2][2];
main()
{
	long S;
	while(cin>>S,S)
	{
		long pre=0,ans=0;
		while(1)
		{
			s=to_string(S+=ans-pre);
			pre=ans;
			for(int i=0;i<=s.size();i++)for(int j=0;j<4;j++)dp[i][j/2][j%2]=0;
			dp[0][0][0]=1;
			for(int i=0;i<s.size();i++)
			{
				for(int j=0;j<2;j++)
				{
					for(int k=0;k<2;k++)
					{
						int lim=j?9:s[i]-'0';
						for(int l=0;l<=lim;l++)
						{
							dp[i+1][j||(l<lim)][k||(l==4||l==6)]+=dp[i][j][k];
						}
					}
				}
			}
			ans=dp[s.size()][0][1]+dp[s.size()][1][1];
			if(ans==pre)break;
		}
		cout<<S<<endl;
	}
}
accuracy: 1
time_ms: 660
memory_kb: 3232
final_rank: 19

code_snippet: // 0, 1, 2, 3, 5, 7, 8, 9を用いた8進表現に変換するだけ
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

int ref[8] = {0, 1, 2, 3, 5, 7, 8, 9};
int n;

int main(){
    while(cin >> n, n){
        vector<int> decode;
        while(n != 0){
            decode.push_back(ref[n%8]);
            n /= 8;
        }

        reverse(decode.begin(), decode.end());
        for(int x : decode)     cout << x;
        cout << endl;
    }
    return 0;
}
accuracy: 1
time_ms: 30
memory_kb: 3032
final_rank: 5