Problem:
Score : 300 points

Problem Statement

To make it difficult to withdraw money, a certain bank allows its customers to withdraw only one of the following amounts in one operation:

1 yen (the currency of Japan)

6 yen, 6^2(=36) yen, 6^3(=216) yen, ...

9 yen, 9^2(=81) yen, 9^3(=729) yen, ...

At least how many operations are required to withdraw exactly N yen in total?

It is not allowed to re-deposit the money you withdrew.

Constraints

1 \leq N \leq 100000

N is an integer.

Input

Input is given from Standard Input in the following format:

N

Output

If at least x operations are required to withdraw exactly N yen in total, print x.

Sample Input 1

127

Sample Output 1

4

By withdrawing 1 yen, 9 yen, 36(=6^2) yen and 81(=9^2) yen, we can withdraw 127 yen in four operations.

Sample Input 2

3

Sample Output 2

3

By withdrawing 1 yen three times, we can withdraw 3 yen in three operations.

Sample Input 3

44852

Sample Output 3

16

Solution in Rust (1.15.1) (judge verdict: Wrong Answer)

use std::io::Read;

fn main() {
    let mut buf = String::new();

    // 標準入力から全部bufに読み込む
    std::io::stdin().read_to_string(&mut buf).unwrap();

    // 行ごとのiterが取れる
    let mut iter = buf.split_whitespace();
    let amount: u32 = iter.next().unwrap().parse().unwrap();
    let mut dp = vec![0; 100];

    let mut result = 0;
    for n in 1..dp.len() {
        let remaining = amount - dp[n - 1];
        println!("{}", remaining);
        if remaining == 0 {
            break;
        }
        if remaining >= 6 {
            dp[n] = if max_conins(9, remaining) > max_conins(6, remaining) {
                max_conins(9, remaining)
            } else {
                max_conins(6, remaining)
            } + dp[n - 1];
            result += 1;
            continue;
        } else {
            dp[n] = 1 + dp[n - 1];
            result += 1;
            continue;
        }
    }
    println!("{}", result);
}

fn max_conins(coin: u32, amount: u32) -> u32 {
    let mut vec = Vec::new();
    for n in 1..amount {
        let val = coin.pow(n);
        if val <= amount {
            vec.push(val);
        } else {
            break;
        }
    }
    match vec.iter().max() {
        Some(n) => *n,
        None => 0,
    }
}