扭蛋机

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
            while(sc.hasNext()){
                int num = sc.nextInt();
                StringBuilder res = new StringBuilder();
                while(num != 0){
                    if(num % 2 == 0){
                        num = (num - 2) / 2;
                        res.insert(0, "3");
                    }else{
                        num = (num - 1) / 2;
                        res.insert(0, "2");
                    }
                }
                System.out.println(res);
            }
    }
}

n = int(input())
o = []
while n:
    o.append('3' if n%2 == 0 else '2')
    n = (n-1)//2
print(''.join(o[::-1]))

def helper(num):
    res = ""
    while num>0:
        if ((num-2)/2)%1==0:
            res = '3'+res
            num = (num-2)/2
        if ((num-1)/2)%1==0:
            res =  '2'+res
            num = (num-1)/2
    return res
if __name__ == "__main__":
    obj = int(input())
    ans = helper(obj)
    print(ans)

x = eval(input())
ls = []
while(x):#从后往前逆推
    if(x%2==0):#若x为偶数，则最后一步肯定是扭蛋机3
        ls.append(3)
        x = (x-2)/2
    else:#若x为奇数，则最后一步肯定是扭蛋机2
        ls.append(2)
        x = (x-1)/2
for i in ls[::-1]:
    print(i, end='')

#include <iostream>
#include <stack>
#include <string>

using namespace std;

int N;
stack<string> s_sta, t_sta;

bool dfs(int, int);

int main(int argc, char **argv) {
    cin >> N;
    if (dfs(0, 0)) {
        for (; !s_sta.empty(); t_sta.push(s_sta.top()), s_sta.pop());
        for (; !t_sta.empty(); cout << t_sta.top(), t_sta.pop());
    }
    cout << endl;
    return 0;
}

bool dfs(int i, int sum) {
    if (sum == N) return true;
    if (sum > N) return false;
    for (int j = sum; j >= 0; j--) {
        s_sta.push("3");
        if (dfs(i + 1, sum - j + (2 * j + 2))) return true;
        s_sta.pop();
    }
    for (int j = sum; j >= 0; j--) {
        s_sta.push("2");
        if (dfs(i + 1, sum - j + (2 * j + 1))) return true;
        s_sta.pop();
    }
    return false;
}

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

int main(){
    int n,i;
    int a[2000];   //存放得出的扭蛋机号码
    while(scanf("%d",&n)!=-1){
        i=0;
        while(n>0){   //n>0时，都在while循环内运算
            if(n%2==0){
                //除以2余0，则知道是3号机扭的
                n=(n-2)/2;
                a[i]=3;  //最后的扭蛋机为3号
                i++; //i加1，a[2000]存放倒数第二个数据
            }
            else{
                n=(n-1)/2;
                a[i]=2;
                i++;
            }
        }
        i--; //正序输出扭蛋机顺序
        for(;i>=0;--i)
            cout<<("%d",a[i]);
    }
}

import java.util.*;
public class bili23 {
	public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        StringBuffer str = new StringBuffer();
        while(n > 0) {
            if(n%2 == 0) {
            	n = (n - 2)/2;
            	str.append("3");
            }else {
            	n = (n - 1)/2;
            	str.append("2");
            }
        }
        str.reverse();
        System.out.println(str);
        sc.close();
    }
}

#include <bits/stdc++.h>
using namespace std;
int main()
{
    int n,x=0;
    cin>>n;
    string s="";
    while(n)
    {
        if(n%2==0)
        {
            n=(n-2)/2;
            s+='3';
        }
        else
        {
            n=(n-1)/2;
            s+='2';
        }
    }
    reverse(s.begin(),s.end());
    cout<<s<<endl;
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <errno.h>
// 宏定义 -- 用来定义各种符号常量
#define not !
#define INIT_CAPACITY 8
#define InitStack(S) __InitStack(S, INIT_CAPACITY);

// 宏函数
#define SWAP(a, b) { typeof(a) t = a; a = b; b = t; }

typedef enum { OK = 1, ERROR = -1, OVERFLOW = -2 } Status;

// -------------------- 顺序栈的存储表示与实现 --------------------
typedef char SElemType;

typedef struct {
  SElemType* base;
  SElemType* top;
  size_t capacity;
} SqStack;

Status __InitStack(SqStack* S, int initialCapacity) {
  if (initialCapacity < 1) {
    fprintf(stdout,
            "InitStack ERROR: The initialCapacity %d Must be > 0!", initialCapacity);
    return ERROR;
  }
  if (!((*S).base = (SElemType*) malloc(initialCapacity * sizeof(SElemType)))) {
    fprintf(stdout, "InitStack Memory Overflow: %s\n", strerror(errno));
    exit(OVERFLOW); // abort
  }
  (*S).top = (*S).base;
  (*S).capacity = initialCapacity;
  return OK;
}

bool StackEmpty(SqStack* S) {
  return (*S).top == (*S).base;
}

bool StackFull(SqStack* S) {
  return (*S).top - (*S).base == (*S).capacity;
}

size_t StackLength(SqStack* S) {
  return (*S).top - (*S).base;
}

void __large_capacity(SqStack* S, float factor) { // factor == 倍增因子
  if (!((*S).base = (SElemType*)
        realloc((*S).base, (S->capacity * factor) * sizeof(SElemType)))) {
    fprintf(stdout, "__large_capacity Memory Overflow: %s\n", strerror(errno));
    exit(OVERFLOW);
  }  
  (*S).top = (*S).base + (*S).capacity;
  (*S).capacity *= factor;
}

Status Push(SqStack* S, SElemType e) {
  if (StackFull(S))
    __large_capacity(S, 1.5); // 弹性扩容
  
  *(*S).top++ = e;
  return OK;
}

Status Pop(SqStack* S, SElemType* e) {
  if (StackEmpty(S)) {
    fputs("InitStack ERROR: The stack is empty!\n", stdout);
    return ERROR;
  }
  *e = *--(*S).top;
  return OK;
}

Status DestroyStack(SqStack* S) {
  free((*S).base);
  (*S).top = NULL;
  return OK;
}
// -------------------- 顺序栈的存储表示与实现 --------------------

int main(const int argc, const char* const argv[]) {
  int n;
  fscanf(stdin, "%d", &n);
  
  SqStack S;
  InitStack(&S);
  
  while (n) {
    Push(&S, n & 1 ? '2' : '3');
    n = n & 1 ? (n - 1) >> 1 : (n - 2) >> 1;
  }
  
  char ch;
  while (not StackEmpty(&S)) {
    Pop(&S, &ch);
    fprintf(stdout, "%c", ch);
  }
  
  return DestroyStack(&S), 0;
}