हास्केल: एफ :: हेक्स स्ट्रिंग -> पूंछ रिकर्सन का उपयोग करके पूर्णांक

Question

मैं पूंछ रिकर्सन का उपयोग करके हेक्स को एक पूर्णांक में बदलने का एक तरीका ढूंढ रहा हूं। अब तक मैंने केवल नियमित आदिम पुनरावर्तन के भयानक कार्यान्वयन की कोशिश की है और मुझे भी करीब नहीं मिला है। बहुत निराश पूंछ रिकर्सन के उदाहरण भी मदद करेंगे और उनकी सराहना की जाएगी। मैं इस कार्यान्वयन के लिए काफी समझ में नहीं आता हूं।

उदाहरण:

• "005" -> 5
• "1E" -> 30

प्रतिबंध: है, तो, बाकी आदि आयात उपयोग नहीं कर सकते या, प्रत्यावर्तन यदि संभव हो तो या पूंछ प्रत्यावर्तन के साथ किया जाना चाहिए।

रिकर्सन पर मेरा प्रयास।

hexToInteger :: String -> Integer 
     |(x:xs) = []  = [] 
     |x == 0    = hexToInteger xs 
     |otherwise   = addition x + hexToInteger xs 

    addition :: String -> Integer 
    addition x 
     |--something to check what position we're dealing with and what hex value. 
     |--Return the Integer value 

Answer 1

आम तौर पर, पूंछ पुनरावर्ती कार्यों के लिए, आप एक संचायक तर्क की जरूरत है - शुद्धता के साथ, परिणाम अन्यथा केवल आधार मामले में पहुँच पर निर्भर कर सकता है। तो तुम एक सहायक समारोह भी एक संचायक तर्क लेने की आवश्यकता होगी, और कॉल कि संचायक के लिए एक प्रारंभिक मूल्य के साथ,

hexToInteger :: String -> Integer 
hexToInteger string = hexToIntegerHelper initialAccumulator string 

और आप

• क्या प्रारंभिक मूल्य आप के लिए पास करना चाहिए पता लगाना चाहिए accumulator
• प्रत्येक चरण में जमाकर्ता को कैसे अपडेट किया जाना है।

उदाहरण के लिए, reverse की पूंछ पुनरावर्ती कार्यान्वयन

reverse :: [a] -> [a] 
reverse xs = reverseHelper [] xs 

reverseHelper :: [a] -> [a] -> [a] 
reverseHelper accumulator [] = accumulator 
reverseHelper accumulator (x:xs) = reverseHelper (x:accumulator) xs 

और एक पूंछ पुनरावर्ती भाज्य (एक नकारात्मक तर्क के मामले fudging) है

factorial :: Integer -> Integer 
factorial n = factorialHelper 1 n 

factorialHelper :: Integer -> Integer -> Integer 
factorialHelper accumulator n 
    | n < 2  = accumulator 
    | otherwise = factorialHelper (n*accumulator) (n-1) 

तो आप देख सकते hexToIntegerHelper की सामान्य संरचना,

hexToIntegerHelper :: Integer -> String -> Integer 
hexToIntegerHelper accumulator "" = accumulator 
hexToIntegerHelper accumulator (d:ds) = hexToIntegerHelper (newAccumulatorFrom accumulator d) ds 

और सवाल यह है कि नए संचयक को पुराने और हेक्साडेसिमल अंक (और प्रारंभिक संचयक क्या होना चाहिए) से गणना की जानी चाहिए।

संचायक को अद्यतन करने के लिए,

digitToInt :: Char -> Int 

Data.Char से उपयोगी हो सकता है, वह सब हेक्साडेसिमल अंक संभालती है। लेकिन, यह वांछित प्रकार नहीं लौटाता है, इसलिए Int से Integer में कनवर्ट करने के लिए आपको fromIntegral या toInteger का उपयोग करने की आवश्यकता होगी।

Answer 2

यहां दो पुनरावर्ती कार्य हैं, हालांकि यह मुझे बताया गया है कि वे पूंछ रिकर्सिव नहीं हैं। हो सकता है कि वे वहां पहुंचने में आपकी मदद कर सकें, हालांकि।

hexToInteger :: String -> Integer 
hexToInteger [] = 0 
hexToInteger str = 
    fromIntegral z + 16 * hexToInteger (init str) 
    where z = let y = last str 
       in if y >= 'A' && y <= 'Z' 
        then fromEnum y - 55 
        else if y >= 'a' && y <= 'z' 
          then fromEnum y - 87 
          else fromEnum y - 48 



hexToInteger :: String -> Integer 
hexToInteger [] = 0 
hexToInteger str = 
    z + 16 * hexToInteger (init str) 
    where z = case last str of 
       '0' -> 0 
       '1' -> 1 
       '2' -> 2 
       '3' -> 3 
       '4' -> 4 
       '5' -> 5 
       '6' -> 6 
       '7' -> 7 
       '8' -> 8 
       '9' -> 9 
       'A' -> 10 
       'B' -> 11 
       'C' -> 12 
       'D' -> 13 
       'E' -> 14 
       'F' -> 15 
       'a' -> 10 
       'b' -> 11 
       'c' -> 12 
       'd' -> 13 
       'e' -> 14 
       'f' -> 15 
       otherwise -> 0