0votos

Emulando a Dik T. Winter en Haskell

por josejuan hace 5 años

La transcripción directa de la de F# (q vino de javascript) a Haskell arroja (sin optimizar) tiempos similares a la de javascript. Es notablemente más concisa que las otras.

Un número de N dígitos es narcisista si la suma de las potencias N-ésimas de sus dígitos es él mismo.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
{-# LANGUAGE BangPatterns #-} 
import Data.List 
import System.Clock 
import System.Environment 
 
calculate n = nub $ sort $ filter (>=l) $ combinations 0 0 n 
  where powers = map (^n) [0..9] 
        l = 10^(n - 1) 
        isNarcissistic !m = m == sumDown m 0 
        sumDown !q !s = if q < 1 then s else sumDown d (powers!!r + s) where (d, r) = divMod q 10 
        combinations !acc !d !ds = if d == 10 then if isNarcissistic acc then [acc] else [] else rs 
                where p = powers!!d 
                      b = d + 1 
                      rs = concatMap (\i -> combinations (acc + i * p) b (ds - i)) [0..ds] 
 
 
 
 
 
main = do 
    n <- getArgs >>= return . read . head 
    t0 <- getTime ProcessCPUTime >>= return . nsec 
    print $ calculate n 
    t1 <- getTime ProcessCPUTime >>= return . nsec 
    putStrLn $ (show ((t1 - t0) `div` 1000000)) ++ " miliS" 
     
 
{- 
$ ./narc 9  
[146511208,472335975,534494836,912985153] 
47 miliS 
-} 

Comenta la solución

Tienes que identificarte para poder publicar tu comentario.