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: Accepted)

use std::collections::HashMap;
use std::io::BufRead;

fn main() {
    let stdin = std::io::stdin();
    let n = stdin.lock().gets().parse::<u32>().unwrap();

    let mut talist = Vec::new();
    let mut x = 1;
    while x <= n {
        talist.push(x);
        x *= 6;
    }
    let mut x = 1;
    while x <= n {
        talist.push(x);
        x *= 9;
    }
    talist.sort();

    // remaining amount --> min txn count
    let mut count = HashMap::new();
    count.insert(n, 0);
    for txn in talist.into_iter().rev() {
        let series = if txn % 2 == 0 { 6 } else { 9 };
        let prev = count;
        count = HashMap::new();
        for (r, c) in prev {
            for i in 0..std::cmp::min(r / txn + 1, series) {
                let p = count.entry(r - i * txn).or_insert(c + i);
                if c + i < *p {
                    *p = c + i;
                }
            }
        }
    }
    println!("{}", count.into_iter().map(|(r, c)| r + c).min().unwrap());
}

trait Gets { fn gets(&mut self) -> String; }
impl<T: std::io::BufRead> Gets for T {
    fn gets(&mut self) -> String { self.lines().next().unwrap().unwrap() } }