Julia Language => जबकि लूप्स

वाक्य - विन्यास

निंदा करते हुए; तन; समाप्त
टूटना
जारी रखें

टिप्पणियों

while लूप का कोई मूल्य नहीं है; हालांकि इसका उपयोग अभिव्यक्ति की स्थिति में किया जा सकता है, इसका प्रकार Void और प्राप्त मूल्य nothing होगा।

Collatz अनुक्रम

while लूप अपने शरीर को तब तक चलाता है जब तक स्थिति धारण करती है। उदाहरण के लिए, निम्नलिखित कोड किसी दिए गए नंबर से Collatz अनुक्रम की गणना और प्रिंट करता है:

function collatz(n)
    while n ≠ 1
        println(n)
        n = iseven(n) ? n ÷ 2 : 3n + 1
    end
    println("1... and 4, 2, 1, 4, 2, 1 and so on")
end

उपयोग:

julia> collatz(10)
10
5
16
8
4
2
1... and 4, 2, 1, 4, 2, 1 and so on

किसी भी लूप को पुनरावर्ती रूप से लिखना संभव है, और लूप के while जटिल के लिए, कभी-कभी पुनरावर्ती संस्करण अधिक स्पष्ट होता है। हालांकि, जूलिया में, लूप को पुनरावृत्ति पर कुछ अलग फायदे हैं:

जूलिया टेल कॉल उन्मूलन की गारंटी नहीं देता है, इसलिए पुनरावृत्ति अतिरिक्त मेमोरी का उपयोग करता है और स्टैक ओवरफ्लो त्रुटियों का कारण हो सकता है।
और आगे, उसी कारण से, एक लूप ओवरहेड को कम कर सकता है और तेजी से चला सकता है।

परीक्षण की स्थिति से पहले एक बार चलाएं

कभी-कभी, कोई शर्त का परीक्षण करने से पहले एक बार कुछ इनिशियलाइज़ेशन कोड चलाना चाहता है। कुछ अन्य भाषाओं में, इस प्रकार के लूप में विशेष वाक्य do - while वाक्य रचना। हालांकि, इस वाक्य रचना एक नियमित रूप से साथ बदला जा सकता while पाश और break , बयान इसलिए जूलिया विशेष है नहीं करता do - while वाक्य रचना। इसके बजाय, एक लिखते हैं:

local name

# continue asking for input until satisfied
while true
    # read user input
    println("Type your name, without lowercase letters:")
    name = readline()

    # if there are no lowercase letters, we have our result!
    !any(islower, name) && break
end

ध्यान दें कि कुछ स्थितियों में, ऐसे लूप पुनरावृत्ति के साथ अधिक स्पष्ट हो सकते हैं:

function getname()
    println("Type your name, without lowercase letters:")
    name = readline()
    if any(islower, name)
        getname()  # this name is unacceptable; try again
    else
        name       # this name is good, return it
    end
end

पहले चौड़ाई खोजो

0.5.0

(हालांकि यह उदाहरण संस्करण v0.5 में प्रस्तुत सिंटैक्स का उपयोग करके लिखा गया है, यह पुराने संस्करणों पर भी कुछ संशोधनों के साथ काम कर सकता है।)

इस कार्यान्वयन चौड़ाई-पहले खोज एक ग्राफ पर (BFS) निकटता सूचियों का उपयोग करता है के साथ प्रतिनिधित्व किया while छोरों और return बयान। हम जिस कार्य को हल करेंगे, वह इस प्रकार है: हमारे पास लोगों का एक क्रम है, और मित्रता का क्रम (मित्रता परस्पर है)। हम दो लोगों के बीच संबंध की डिग्री निर्धारित करना चाहते हैं। यही है, अगर दो लोग दोस्त हैं, तो हम 1 वापस आएंगे; यदि कोई दूसरे के मित्र का मित्र है, तो हम 2 लौटाएंगे, इत्यादि।

पहले, मान लें कि हमारे पास पहले से ही एक समीपवर्ती सूची है: एक Dict मैपिंग T से Array{T, 1} , जहां चाबियाँ लोग हैं और मूल्य उस व्यक्ति के सभी दोस्त हैं। यहां हम जो कुछ भी T चुनते हैं, हम लोगों का प्रतिनिधित्व कर सकते हैं; इस उदाहरण में, हम Symbol उपयोग करेंगे। बीएफएस एल्गोरिथ्म में, हम "नोड" पर जाने के लिए लोगों की एक कतार रखते हैं, और मूल नोड से उनकी दूरी को चिह्नित करते हैं।

function degree(adjlist, source, dest)
    distances = Dict(source => 0)
    queue = [source]

    # until the queue is empty, get elements and inspect their neighbours
    while !isempty(queue)
        # shift the first element off the queue
        current = shift!(queue)

        # base case: if this is the destination, just return the distance
        if current == dest
            return distances[dest]
        end

        # go through all the neighbours
        for neighbour in adjlist[current]
            # if their distance is not already known...
            if !haskey(distances, neighbour)
                # then set the distance
                distances[neighbour] = distances[current] + 1

                # and put into queue for later inspection
                push!(queue, neighbour)
            end
        end
    end

    # we could not find a valid path
    error("$source and $dest are not connected.")
end

अब, हम लोगों के अनुक्रम को देखते हुए एक आसन्न सूची बनाने के लिए एक फ़ंक्शन लिखेंगे, और (person, person) अनुक्रम का एक क्रम:

function makeadjlist(people, friendships)
    # dictionary comprehension (with generator expression)
    result = Dict(p => eltype(people)[] for p in people)

    # deconstructing for; friendship is mutual
    for (a, b) in friendships
        push!(result[a], b)
        push!(result[b], a)
    end

    result
end

अब हम मूल फ़ंक्शन को परिभाषित कर सकते हैं:

degree(people, friendships, source, dest) =
    degree(makeadjlist(people, friendships), source, dest)

अब कुछ डेटा पर हमारे फ़ंक्शन का परीक्षण करते हैं।

const people = [:jean, :javert, :cosette, :gavroche, :éponine, :marius]
const friendships = [
    (:jean, :cosette),
    (:jean, :marius),
    (:cosette, :éponine),
    (:cosette, :marius),
    (:gavroche, :éponine)
]

जीन 0 चरणों में खुद से जुड़ा है:

julia> degree(people, friendships, :jean, :jean)
0

जीन और कॉस्सेट दोस्त हैं, और इसलिए डिग्री 1 :

julia> degree(people, friendships, :jean, :cosette)
1

जीन और गैवरोच कोरेसेट और फिर मारियस के माध्यम से अप्रत्यक्ष रूप से जुड़े हुए हैं, इसलिए उनकी डिग्री 3 :

julia> degree(people, friendships, :jean, :gavroche)
3

Javert और Marius किसी भी श्रृंखला से जुड़े नहीं हैं, इसलिए एक त्रुटि उठाई गई है:

julia> degree(people, friendships, :javert, :marius)
ERROR: javert and marius are not connected.
 in degree(::Dict{Symbol,Array{Symbol,1}}, ::Symbol, ::Symbol) at ./REPL[28]:27
 in degree(::Array{Symbol,1}, ::Array{Tuple{Symbol,Symbol},1}, ::Symbol, ::Symbol) at ./REPL[30]:1

Modified text is an extract of the original Stack Overflow Documentation

के तहत लाइसेंस प्राप्त है CC BY-SA 3.0

से संबद्ध नहीं है Stack Overflow

Julia Language
जबकि लूप्स

खोज…

वाक्य - विन्यास

टिप्पणियों

Collatz अनुक्रम

परीक्षण की स्थिति से पहले एक बार चलाएं

पहले चौड़ाई खोजो