हास्केल - कार्यात्मक प्रोग्रामिंग सहायता

Question

हैकेल के लिए एक महसूस करने की कोशिश कर रहा है। PHP, जावा, वीबी और कई अन्य भाषाओं के साथ एक अनुभवी प्रोग्रामर हूं, लेकिन मुझे हैकेल को थोड़ा और मुश्किल करना है। किसी को भी मेरा पीछा haskell समारोह के लिए एक अंग्रेज़ी अनुवाद दे सकते हैं, मुझे शुरू करने के लिए ...

quicksort []  = [] 
quicksort (x:xs) = quicksort [y | y <- xs, y<x ] 
        ++ [x] 
        ++ quicksort [y | y <- xs, y>=x] 

अंग्रेज़ी अनुवाद का एक उदाहरण नीचे टिप्पणी में है:

// --- FOR_LOOP -> 
// --- $abc goes from 1 to 10 -> 
// --- If $abc is even - print $abc is even -> 
// --- else if $abc is odd - print $abc is odd -> 
// --- END_FOR_LOOP 

for($abc = 1 ; $abc <= 10 ; $abc++){ 

    if($abc % 2 == 0){ 
    echo $abc . " is even"; 
    } 
    else{ 
    echo $abc . " is odd"; 
    } 
} 

पहली पंक्ति काफी सरल है, पढ़ना: "एक खाली सूची पर फ़ंक्शन क्विकॉर्ट परिणाम के रूप में एक खाली सूची उत्पन्न करता है" ... यदि आप शेष हैकेल को अंग्रेज़ी टी में अनुवाद कर सकते हैं टोपी बहुत उपयोगी होगी।

Answer 1

खाली सूची त्वरित करने का परिणाम खाली सूची है।

एक गैर खाली सूची, जहां हम सूची x के पहले तत्व फोन quicksorting और शेष तत्व xs का परिणाम है: कि एक्स (*) से छोटे हैं xs के सभी तत्वों को quicksorting का परिणाम है, का पालन किया एक्स द्वारा, x के मुकाबले एक्सएस के सभी तत्वों को क्विकोर्ट करने के परिणामस्वरूप।

(*) थोड़ा विस्तार करने के लिए: [y | y <- xs, y<x ] "सभी वाई की सूची जहां y x में है और y<x" के रूप में पढ़ा जा सकता है।

Answer 2

यह सीधे आपके प्रश्न का उत्तर नहीं देता है, लेकिन hoogle सामान्य रूप से आपकी शिक्षा में मदद कर सकता है, तो आप मानक एपीआई पुस्तकालयों को या तो फ़ंक्शन नाम या अनुमानित प्रकार हस्ताक्षर द्वारा खोज सकते हैं।

यहां खोज शब्दों इसका समर्थन करता है का उदाहरण दिया गया है:

map 
(a -> b) -> [a] -> [b]` 
Ord a => [a] -> [a] 
Data.Map.insert 

Answer 3

इस कॉलेज के बाद से नहीं किया है ...

यह पुनरावर्ती है - पहली पंक्ति एक खाली सेट के लिए मामला है।

quicksort []  = [] 

अगली कुछ पंक्तियां एक गैर-खाली सेट पर संचालित होती हैं। (X: xs) वाक्यविन्यास इसे एक तत्व (x) और शेष तत्वों (xs) में विभाजित करता है।

quicksort (x:xs) = quicksort [y | y <- xs, y<x ] 
    ++ [x] 
    ++ quicksort [y | y <- xs, y>=x] 

पहली पंक्ति, quicksort [y | वाई < - एक्सएस, वाई < एक्स], एक्स से कम सभी तत्वों के सेट के खिलाफ क्विकॉर्ट को कॉल करता है जो कि x से कम होते हैं (यानी x से कम x प्रत्येक x)। यदि एक्सएस खाली सेट है, तो quicksort [] वापस आ जाएगा []।

मध्यम रेखा बस एक्स युक्त सेट है।

अंतिम पंक्ति, quicksort [y | y < - xs, y > = x], x से अधिक या उसके बराबर x के सभी तत्वों के सेट के खिलाफ क्विकॉर्ट को कॉल करता है (यानी x से प्रत्येक y जो x से अधिक या बराबर है)। यदि एक्सएस खाली सेट है, तो quicksort [] वापस आ जाएगा []।

अंतिम परिणाम एक आदेश दिया गया सेट है।

Answer 4

यह एक घोषणात्मक भाषा है, इसलिए आप जो देखते हैं उसे पढ़ लें। sepp2k ऊपर एक अच्छा उदाहरण है।

Answer 5

http://learnyouahaskell.com/recursion#quick-sort जांचें कि यह वास्तव में क्या त्वरित करता है।

Answer 6

मामले में आपकी समस्या में अपनेपन सूची comprehensions साथ, यहाँ कुछ वैकल्पिक संस्करण जो लगभग समान ही हैं था:

quicksort []  = [] 
quicksort (x:xs) = 
    quicksort (filter (< x) xs) ++ 
    [x] ++ 
    quicksort (filter (>= x) xs) 

quicksort []  = [] 
quicksort (x:xs) = 
    quicksort smaller ++ [x] ++ quicksort bigger 
    where 
    (smaller, bigger) = partition (< x) xs