2진수

use std::io;
fn main(){
    let mut select=String::new();
    let _ = io::stdin().read_line(&mut select);
    let value=11;
    let base_n:u128=0b100101011;
    if select=="1\n"{
        println!("num_besmall");
        num_besmall_counts(base_n);
    }
    else{
        println!("Ncount");
        n_count_not_find(value, base_n);
    }
}
fn num_besmall_counts(base_n:u128){
    let mut value;
    let length=128-base_n.leading_zeros();
    let mut appear_count=[0;400];
    let mut caled_num:u128;
    for i in 1..100{
        caled_num=base_n+(i<<length);
        value=count(caled_num);
        appear_count[value]+=1;
    }
    for i in 0..400{
        if appear_count[i]!=0{
            println!("{} is appear {} count.",i,appear_count[i]);
        }
    }
}

fn n_count_not_find(value:usize,base_n:u128){
    let mut caled_num:u128;
    let length=128-base_n.leading_zeros();
    let mut flag:bool=true;
    for i in 1..100{
        caled_num=base_n+(i<<length);
        if count(caled_num) ==value{
            println!("{:16b}is{}",caled_num,value);
            flag=false;
        }
    }
    if flag{
        println!("all pass");
    }
    
}
fn count(mut n:u128)->usize{
    let first:u128=n;
    let mut count:usize=0;
    while n>=first{
        count=count+1;
        if n%2==0{
            n=n>>1;
        }
        else{
            n=(n<<1)+n+1;
        }
    }
    count
}

2진수로 바꿔봤다.

//const MAX:u128=340282366920938463463374607431768211455;
fn main(){
    let goal_num=100_000_000_000;
    let mut number:u128=1;
    while number<goal_num{
        number+=2;
        let mut one=0;
        let mut zero=0;
        let mut big_zero=0;
        let mut big_one=0;
        let mut iszero=false;
        let length=128-number.leading_zeros();
        for j in 0..length{
            if number&1<<j==0{
                zero+=1;
                one=0;
                if iszero{
                    zero+=1;
                    if zero>big_zero{
                        big_zero=zero;
                    }
                }
                iszero=true;
            }
            else{
                if !iszero{
                    one+=1;
                    zero=0;
                    if one>big_one{
                        big_one=one;
                    }
                }
                iszero=false;
            }
        } 
        //println!("number{:b} zero{} one{}",number,big_zero,big_one);
        if big_zero>big_one{
            continue;
        }
        count(number);
    }
    println!("{}",goal_num);
}
fn count(mut n:u128)->bool{
    let first:u128=n;
    let mut count:usize=0;
    while n>=first{
        count=count+1;
        if n%2==0{
            n=n>>1;
        }
        else{
            n=(n<<1)+n+1;
        }
    }
    true
}

0이 연속으로 많이 나오면 일정하게 계산량이 유지되는 규칙을 이용했다. 대략적으로 그런 규칙인거고 확실한 규칙은 아니다.