Digit Factorial Chains

#include <iostream>
#include <set>

int fact[10] = {1,1,2,6,24,120,720,5040,40320,362880};

int digit_fact_sum(int n)
{
    int sum = 0;
    while(n > 0){
        sum += fact[n % 10];
        n /= 10;
    }
    return sum;
}

int digit_factorial_chains()
{
    int count = 0;
    for(int i=1; i<1000000; i++){
        std::set<int> seen;
        int n = i;
        while(seen.find(n) == seen.end()){
            seen.insert(n);
            n = digit_fact_sum(n);
        }
        if(seen.size() == 60){
            count++;
        }
    }
    return count;
}

#if ! defined UNITTEST_MODE
int main(int argc, char const *argv[])
{
    std::cout << "Answer: " << digit_factorial_chains() << std::endl;
}
#endif // #if ! defined UNITTEST_MODE

package org.tvarley.euler.solutions;

import org.tvarley.euler.Solution;
import java.util.HashSet;
import java.util.Set;

public class Solution074 implements Solution {
  private static final int[] FACT = {1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880};

  private static int digitFactSum(int n) {
    int sum = 0;
    while (n > 0) {
      sum += FACT[n % 10];
      n /= 10;
    }
    return sum;
  }

  public String solve() {
    int count = 0;
    for (int i = 1; i < 1000000; i++) {
      Set<Integer> seen = new HashSet<>();
      int n = i;
      while (!seen.contains(n)) {
        seen.add(n);
        n = digitFactSum(n);
      }
      if (seen.size() == 60) {
        count++;
      }
    }
    return String.valueOf(count);
  }
}

const FACT = [1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880];

function digitFactSum(n) {
  let sum = 0;
  while (n > 0) {
    sum += FACT[n % 10];
    n = Math.floor(n / 10);
  }
  return sum;
}

function digitFactorialChains() {
  let count = 0;
  for (let i = 1; i < 1000000; i++) {
    const seen = new Set();
    let n = i;
    while (!seen.has(n)) {
      seen.add(n);
      n = digitFactSum(n);
    }
    if (seen.size === 60) {
      count++;
    }
  }
  return count;
}

module.exports = {
  answer: () => digitFactorialChains()
};

FACT = [1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880]

def digit_fact_sum(n):
    total = 0
    while n > 0:
        total += FACT[n % 10]
        n //= 10
    return total

def solve():
    count = 0
    for i in range(1, 1000000):
        seen = set()
        n = i
        while n not in seen:
            seen.add(n)
            n = digit_fact_sum(n)
        if len(seen) == 60:
            count += 1
    return count

package main

import (
  "fmt"
)

var fact = [10]int{1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880}

func digitFactSum(n int) int {
  sum := 0
  for n > 0 {
    sum += fact[n%10]
    n /= 10
  }
  return sum
}

func digitFactorialChains() int {
  count := 0
  for i := 1; i < 1000000; i++ {
    seen := make(map[int]bool)
    n := i
    for !seen[n] {
      seen[n] = true
      n = digitFactSum(n)
    }
    if len(seen) == 60 {
      count++
    }
  }
  return count
}

func main() {
  fmt.Println(digitFactorialChains())
}

static FACT: [u64; 10] = [1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880];

fn digit_fact_sum(mut n: u64) -> u64 {
    let mut sum = 0;
    while n > 0 {
        sum += FACT[(n % 10) as usize];
        n /= 10;
    }
    sum
}

pub fn digit_factorial_chains() -> u64 {
    let mut count = 0;
    for i in 1..1_000_000 {
        let mut seen = std::collections::HashSet::new();
        let mut n = i;
        while !seen.contains(&n) {
            seen.insert(n);
            n = digit_fact_sum(n);
        }
        if seen.len() == 60 {
            count += 1;
        }
    }
    count
}