हास्केल - एल्गोरिदम पूरा करने के लिए अधिक कुशल तरीका?

Question

मैंने एक एल्गोरिदम बनाया है जो एक गैर-नकारात्मक इंट मान लेता है, जो कुल संख्या का प्रतिनिधित्व करता है, और एक ट्रिपल देता है जो (दिन, घंटे, मिनट) देता है जो इससे मेल खाता है। ,

calcdays :: Int -> Int 
calcdays x = x `div` (24*60) 

calchours :: Int -> Int 
calchours x = (x - ((calcdays x)*24*60)) `div` 60 

calcmins :: Int -> Int 
calcmins x = (x - ((calcdays x)*24*60) - ((calchours x)*60)) 

dayshoursmins :: Int -> (Int,Int,Int) 
dayshoursmins x = (calcdays x, calchours x, calcmins x) 

केवल बुनियादी हास्केल परिचालन (गार्ड, divs, Mods आदि) का उपयोग करते हुए वहाँ प्रोग्रामिंग का एक और अधिक सरल तरीका यह समारोह है:

यहाँ मेरी कोड है?

संपादित करें:

मैं एक सुझाव नीचे का इस्तेमाल किया है इस कोड को सरल बनाने के लिए है, जबकि qoutRem समाधान के रूप में सरल नहीं, मैंने सोचा कि मैं इसे पोस्ट कर सकता है:

calcdays :: Int -> Int 
calcdays x = x `div` (24*60) 

calchours :: Int -> Int 
calchours x = (x `mod` (24*60)) `div` 60 

calcmins :: Int -> Int 
calcmins x = (x `mod` (24*60)) `mod` 60 

dayshoursmins :: Int -> (Int,Int,Int) 
dayshoursmins x = (calcdays x, calchours x, calcmins x) 

Answer 1

मुझे लगता है कि इस

dayshoursmins x = (d,hr,mr) where 
(h,mr) = quotRem x 60 
(d,hr) = quotRem h 24 

Answer 2

आप

उपयोग कर सकते हैं

a `mod` b 

सीधे शेष प्राप्त करने के लिए।

और आप उप-अभिव्यक्ति की गणना करने के लिए let or where का उपयोग कर सकते हैं।