फ़्लिप-फ्लॉप ऑपरेटर की दूसरी स्थिति क्यों शामिल है?

Question

निम्न कोड फ्लिप-फ्लॉप ऑपरेटर का उपयोग कर रहा है।

(1..10).each {|x| print "#{x}," if x==3..x==5 } 

परिणाम 3,4,5 क्यों हैं?

मुझे लगता है कि यह 3,4 होना चाहिए।

जैसा कि एक ट्यूटोरियल में उल्लिखित है, यह अभिव्यक्ति सच होती है जब x == 3, और x == 5 तक सत्य साबित होता है। अगर यह गलत साबित होता है तो '5' मुद्रित कैसे किया जा सकता है? क्या कोई मेरे लिए यह स्पष्ट कर सकता है?

Answer 1

क्या आप एक विशेष सीमा की तलाश में हैं? आप तीन बिंदुओं और cover? विधि का उपयोग कर सकते हैं।

(1..10).each { |x| print "#{x}," if (3...5).cover?(x) } 

कारण यह प्रिंट 3,4,5, अपने उदाहरण में है, क्योंकि यह कहते हैं यदि एक्स से 3 करने के लिए 5 प्रिंट यह सीमा में है।

Answer 2

@MurifoX द्वारा टिप्पणी को स्पष्ट करने के लिए, फ्लिप फ्लॉप x==5 जब तक सच है, और इस तरह सच विशेष रूप से जब x==5, लेकिन हर बार अभिव्यक्ति है कि के बाद मूल्यांकन किया जाता है गलत है। इस प्रकार आप अभी भी 5 मुद्रित देख रहे हैं।

Answer 3

महत्वपूर्ण लिंक, से "रूबी प्रोग्रामिंग भाषा" है:

4.6.9.1 Boolean flip-flops

जब .. और ... ऑपरेटरों अगर बयान इस तरह के एक के रूप में, एक सशर्त में किया जाता है, या एक लूप में , जैसे कि थोड़ी देर लूप (सशर्त और लूप के बारे में अधिक के लिए अध्याय 5 देखें), वे रेंज ऑब्जेक्ट्स नहीं बनाते हैं। इसके बजाए, वे फ्लिप-फ्लॉप नामक एक विशेष प्रकार की बूलियन अभिव्यक्ति बनाते हैं। एक फ्लिप-फ्लॉप अभिव्यक्ति वास्तविक या गलत का मूल्यांकन करती है, जैसे कि तुलना और समानता अभिव्यक्तियां होती हैं। फ्लिप-फ्लॉप अभिव्यक्ति के बारे में असाधारण असामान्य बात यह है कि इसका मान पिछले मूल्यांकन के मान पर निर्भर करता है- एयनियंस। इसका मतलब है कि एक फ्लिप-फ्लॉप अभिव्यक्ति के साथ जुड़े राज्य हैं; यह पिछले मूल्यांकन के बारे में जानकारी याद रखना चाहिए। क्योंकि इसमें राज्य है, आप की अपेक्षा करेंगे कि फ्लिप-फ्लॉप किसी प्रकार का ऑब्जेक्ट हो। लेकिन यह एक रूबी अभिव्यक्ति नहीं है, और रूबी दुभाषिया राज्य को संग्रहीत करता है (केवल एक ही बूलियन मान) जिसे अभिव्यक्ति के आंतरिक विश्लेषण में इसकी आवश्यकता होती है।

उस पृष्ठभूमि को ध्यान में रखते हुए, निम्न कोड में फ्लिप-फ्लॉप पर विचार करें। ध्यान दें कि पहले .. कोड में एक रेंज ऑब्जेक्ट बनाता है। ,

(1..10).each {|x| print x if x==3..x==5 } 

फ्लिप फ्लॉप दो बूलियन भाव के होते हैं .. ऑपरेटर के साथ शामिल हो गए एक सशर्त या पाश की संदर्भ में: दूसरा एक फ्लिप फ्लॉप अभिव्यक्ति पैदा करता है। एक फ्लिप-फ्लॉप अभिव्यक्ति तब तक झूठी है जब तक कि लेफथैंड अभिव्यक्ति सत्य तक मूल्यांकन न करे। एक बार यह अभिव्यक्ति सच हो जाने के बाद, पूर्व- दबाव एक सतत सत्य स्थिति में "फ़्लिप" करता है। यह उस राज्य में बनी हुई है, और बाद में मूल्यांकन तब तक सही हो जाते हैं जब तक कि राउंडथैंड अभिव्यक्ति का मूल्यांकन सही न हो।जब होता है, तो फ्लिप-फ्लॉप "लगातार" झूठी स्थिति में "फ्लॉप" होता है। अभिव्यक्ति के बाद के मूल्यांकन झूठी वापसी तब तक झूठी झूठी अभिव्यक्ति सच हो जाती है। कोड उदाहरण में, फ्लिप-फ्लॉप का मूल्यांकन बार-बार मूल्यांकन किया जाता है, एक्स के मान 1 से 10. यह झूठी स्थिति में शुरू होता है, और जब x 1 और 2 होता है तो झूठी मूल्यांकन करता है। जब x == 3, फ्लिप-फ्लॉप सच हो जाता है और सच हो जाता है। जब x 4 और 5 है, तो x == 5, हालांकि, फ्लिप-फ्लॉप वापस झूठ बोलता है, और x के शेष मानों के लिए झूठा लौटाता है। नतीजा यह है कि इस कोड को प्रिंट 345.

Answer 4

.. या फ्लिप फ्लॉप पर्ल जो यह AWK से मिला है और * nix में sed से विरासत में मिली है। यह बहुत शक्तिशाली है, लेकिन आपके विशेष उपयोग में यह काफी अस्पष्ट है और विशेष रूप से रूबी में आपके इच्छित तर्क के लिए एक अच्छा विकल्प नहीं है। इसके बजाय का उपयोग करें:

(1..10).each {|x| puts x if (3..5) === x } 

कौन सा आउटपुट:

3 
4 
5 

कहा यही कारण है, यह अत्यंत शक्तिशाली है जब आप किसी फ़ाइल से लाइनों की एक श्रृंखला को निकालने के लिए की जरूरत है:

File.foreach('/usr/share/dict/propernames') { |li| puts li if ($. == 5 .. $. == 7) } 

कौन सा आउटपुट:

Agatha 
Ahmed 
Ahmet 

पे आरएल वर्तमान में पढ़ने वाली लाइन (AKA $.) की केवल लाइन संख्याओं का उपयोग करके एक और अधिक terse अभिव्यक्ति की अनुमति देता है लेकिन रूबी इसका समर्थन नहीं करता है।

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

File.foreach('/usr/share/dict/propernames') { |li| puts li if (li[/^Wa/] .. li[/^We/]) } 

कौन सा आउटपुट:

Wade 
Walt 
Walter 
Warren 
Wayne 
Wendell 

regex काम वजह से, यह करने के लिए एक जटिल पैटर्न बनाने के लिए संभव है मैचों के आधार पर फ़ाइल से लाइनें पुनर्प्राप्त करें। पहले के रूप में, फिर दूसरा पैटर्न ट्रिगर, लाइनों पर कब्जा कर लिया जाता है। यदि, बाद में फ़ाइल में, एक और पंक्ति पहले पैटर्न को ट्रिगर करती है, तो दूसरे पैटर्न मिलान तक कैप्चरिंग फिर से होती है। यह अद्भुत शक्तिशाली है:

File.foreach('/usr/share/dict/propernames') { |li| puts li if (
    li[/^Am/] .. li[/^An/] or 
    li[/^Wa/] .. li[/^We/] 
) 
} 

कौन सा आउटपुट:

Amanda 
Amarth 
Amedeo 
Ami 
Amigo 
Amir 
Amos 
Amy 
Anatole 
Wade 
Walt 
Walter 
Warren 
Wayne 
Wendell 

या वैकल्पिक रूप से, हमारे अस्पष्ट-कोड बोल दोस्तों के लिए:

File.foreach('/usr/share/dict/propernames') { |li| puts li if (li[/^(?:Am|Wa)/] .. li[/^(?:An|We)/]) } 

Answer 5

मैं कैसे वर्णन करने के लिए कोड का एक टुकड़ा लगता है फ्लिप-फ्लॉप काम करता है (बस उसी पुस्तक में जहां कोड का यह टुकड़ा दिखाई देता है, उम्मीद है कि यह मेरे जैसे प्रश्न वाले लोगों के लिए मदद करता है)

$state = false # Global storage for flip-flop state 
    def flipflop(x) # Test value of x against flip-flop 
     if !$state # If saved state is false 
      result = (x == 3) # Result is value of lefthand operand 
      if result # If that result is true 
       $state = !(x == 5) # Then saved state is not of the righthand operand 
      end 
      result # Return result 
     else # Otherwise, if saved state is true 
      $state = !(x == 5) # Then save the inverse of the righthand operand 
      true # And return true without testing lefthand 
     end 
    end 

Answer 6

एक फ्लिप फ्लॉप अभिव्यक्ति सही या गलत का मूल्यांकन करता है, तुलना और समानता का भाव करते हैं। फ्लिप-फ्लॉप अभिव्यक्ति के बारे में असाधारण असामान्य बात यह है कि इसका मान पिछले मूल्यांकन के मूल्य पर निर्भर करता है। इसका मतलब है कि एक फ्लिप-फ्लॉप अभिव्यक्ति के साथ जुड़े राज्य हैं; इसे पिछले मूल्यांकन के बारे में जानकारी याद रखना चाहिए।क्योंकि इसमें राज्य है, आप की अपेक्षा करेंगे कि फ्लिप-फ्लॉप किसी प्रकार का ऑब्जेक्ट हो। लेकिन यह एक रूबी अभिव्यक्ति नहीं है, और रूबी दुभाषिया राज्य को संग्रहीत करता है (केवल एक ही बूलियन मान) जिसे अभिव्यक्ति के आंतरिक विश्लेषण में इसकी आवश्यकता होती है। उस पृष्ठभूमि को ध्यान में रखते हुए, निम्न कोड में फ्लिप-फ्लॉप पर विचार करें। ध्यान दें कि कोड में पहला ".." एक रेंज ऑब्जेक्ट बनाता है। एक सशर्त या पाश की संदर्भ में,

(1..10).each {|x| print x if x==3..x==5 } 

फ्लिप फ्लॉप दो बूलियन .. ऑपरेटर के साथ शामिल हो गए भाव के होते हैं: एक दूसरे के फ्लिप फ्लॉप अभिव्यक्ति पैदा करता है। एक फ्लिप-फ्लॉप अभिव्यक्ति तब तक झूठी है जब तक कि लेफथैंड अभिव्यक्ति सत्य तक मूल्यांकन न करे। एक बार यह अभिव्यक्ति सच हो जाने के बाद, अभिव्यक्ति एक सतत सत्य स्थिति में "फ़्लिप" हो जाती है। यह उस राज्य में बनी हुई है, और बाद में मूल्यांकन तब तक सही हो जाते हैं जब तक कि राउंडथैंड अभिव्यक्ति का मूल्यांकन सही न हो। जब होता है, तो फ्लिप-फ्लॉप "लगातार" झूठी स्थिति में "फ्लॉप" होता है। अभिव्यक्ति के बाद के मूल्यांकन झूठी वापसी तब तक झूठी झूठी अभिव्यक्ति सच हो जाती है। कोड उदाहरण में, फ्लिप-फ्लॉप का मूल्यांकन बार-बार मूल्यांकन किया जाता है, एक्स के मान 1 से 10. यह झूठी स्थिति में शुरू होता है, और जब x 1 और 2 होता है तो झूठी मूल्यांकन करता है। जब x == 3, फ्लिप-फ्लॉप सत्य पर फ़्लिप करता है और सत्य लौटाता है। एक्स 4 और 5 होने पर यह सच हो रहा है। जब x == 5, हालांकि, फ्लिप-फ्लॉप वापस झूठ बोलता है, और x के शेष मानों के लिए झूठा रिटर्न देता है। नतीजा यह है कि यह कोड 345 प्रिंट करता है।