5

तो मैं आज कंप्यूटर साइंस टेस्ट ले रहा था, और मुझे बयान के दौरान लगातार बड़ी संख्या में लिखना पड़ा। उनमें से सभी के पास समान मूल तर्क थे, बस हालात अलग थे। पूरी बात ने मुझे आश्चर्यचकित कर दिया कि अगर कहीं बाहर एक बहस स्विच स्टेटमेंट था। मैं क्या सोच रहा हूँ यह है का एक उदाहरण:एकाधिक तर्क स्विच स्टेटमेंट

int i = 7; 

switch(i > 4, i < 10) { 
    case T, T: 
     return "between 4 and 10"; 

    case T, F: 
     return "greater than 10"; 

    case F, T: 
     return "less than 4"; 

    case F, F: 
     return "your computer's thinking is very odd"; 
} 

इस मामले में, तर्क i > 4 और i > 10 हैं, और T और F हैं कि क्या तर्क सच है या नहीं।

मुझे पता है कि यह उदाहरण आसानी से अन्य तरीकों से किया जा सकता है, लेकिन मैं बस इसका उपयोग दिखाने की कोशिश कर रहा हूं। और क्या होगा यदि 4 तर्क थे, तो यह 20 की तरह कुछ होगा यदि प्रत्येक शर्त आपको शर्तों को दोबारा टाइप करने की आवश्यकता होती है।

तो मेरा सवाल यह है कि क्या कोई ऐसी भाषा है जो यह करती है? या क्या यह भविष्य की भाषा के लिए योजनाबद्ध है? या एक बेहतर तरीका भी मौजूद है?

उत्तर

5

यह कहना मुश्किल है कि "कोई भाषा यह नहीं करती है" क्योंकि लगभग निश्चित रूप से कोई प्रयोगात्मक भाषा या दो जो काम करता है। हालांकि, अधिकांश प्रक्रियात्मक भाषाओं में इस तरह की सुविधा नहीं होती है।

अपने उदाहरण में, मुझे लगता है कि आप T, F मतलब है, आदि मतलब "पहली अभिव्यक्ति सच और दूसरा गलत का आकलन करने के लिए मूल्यांकन करता है" (जो है, , तार्किक और है)। यह कुछ निर्णय तालिका भाषाओं की याद दिलाता है, जहां प्रसंस्करण में उस निर्णय तालिका की पहली पंक्ति को शामिल करना शामिल है जो उस पंक्ति की कार्रवाई को संतुष्ट और निष्पादित करता है। इसके अलावा, मुझे किसी भी भाषा की जानकारी नहीं है जिसमें इस तरह कुछ भी है।

+0

प्रायोगिक, अजगर की तरह (tuples)। –

+1

पायथन के पास कोई स्विच नहीं है। कई कार्यात्मक languges में पैटर्न मिलान बहुत करीब होना चाहिए (कम से कम Haskell 'सही (सही, सही) के मामले (पी, क्यू) की अनुमति देता है -> एक्स ...')। – delnan

+0

हां, आप सही हैं, केवल एक if-elif-else संरचना जो बराबर है। मुझे लगता है कि स्विच करने वाले और अगर बयानों में टुपल्स का समर्थन करने वाले अन्य लोग हैं। –

0

मैं निश्चित रूप से टेड से सहमत हूं - यह कहना मुश्किल है कि कौन सी भाषाएं मौजूद हो सकती हैं। लेकिन आपके तर्क को कई में संभाला जा सकता है।

आपका स्विच केवल पहले से एक अनुवाद करता है (कुछ भाषाओं में if ((i > 4) && (i < 10)) जैसा कुछ)।

स्विच मामलों को कुछ डोमेन-विशिष्ट तरीके से व्यक्त किए गए फ़ंक्शन रिटर्न मानों के रूप में मॉडलिंग किया जा सकता है, फिर भी, कई भाषाओं में, यहां तक ​​कि सबसे अधिक।

1
अजगर में

:

i = 7 

test = (i > 4, i < 10) 

print test 

if test == (True, True): 
    print "between 4 and 10" 

elif test == (True, False): 
    print "greater than 10" 

elif test == (False, True): 
    print "less than 4" 

elif test == (False, False): 
    print "your computer's thinking is very odd" 
1

आप लगभग ठीक इस कई भाषाओं पहले से ही कर सकते हैं किसी विशेष भाषा के समर्थन के बिना,। उदाहरण के लिए, माणिक में:

i = 7 
case ([i > 4, i < 10]) 
when [true, true]: 
    puts "between 4 and 10" 
when [true, false]: 
    puts "greater than 10" 
... 
end 

या ग्रूवी में:

i = 7 
switch([i > 4, i < 10]) { 
case [[true, true]]: 
    println "between 4 and 10" 
    break; 
case [[true, false]]: 
    println "greater than 10" 
    break; 
... 
} 
3

कम से कम जिन भाषाओं में int करने के लिए bool से रूपांतरण की अनुमति में, आप इस सुंदर आसानी से संभाल सकते हैं। आप मूल रूप से बस दो बूलियन को थोड़ा-मैप किए गए पूर्णांक मान में परिवर्तित करते हैं। चूंकि आपके पास दो बूलियन हैं, इसलिए आप सीधे अपने परिणाम के बिट 0 के रूप में उपयोग कर सकते हैं, और दूसरे को आपके परिणाम के दूसरे बिट के रूप में दो गुणा किया जा सकता है।

int i = 7; 

int range = (i>4) | (i<10)*2; 

switch(range) { 
    case 3: return "between 4 and 10"; 
    case 2: return "greater than 10"; 
    case 1: return "less than 4"; 
    case 0: return "your computer's thinking is very odd"; 
} 
+0

मुझे लगता है कि मैं समझता हूं कि आप यह कैसे कर रहे हैं, लेकिन आप 4 तर्कों की तरह कुछ कैसे करेंगे? क्योंकि यदि आपने उपयोग किए गए पैटर्न में प्रत्येक मान को गुणा किया है, तो क्या परिणाम गलत नहीं होंगे, जिससे गलतता का मौका निकल जाएगा? – Jon

+0

@ जोन: आप केवल दो की लगातार शक्तियों का उपयोग करते हैं, इसलिए: 'cond1 * 1 | cond2 * 2 | cond3 * 4 | cond4 * 8'। शायद इसे phrasing के रूप में: 'cond1 | cond2 << 1 | cond3 << 2 | cond4 << 3; 'इसे स्पष्ट कर देगा। –

+0

ठीक है, मैंने सोचा था कि आप बिजली के बजाय गुणा कर रहे थे। स्पष्टीकरण के लिए धन्यवाद। – Jon

3

में मेथेमेटिका:

Switch[{i > 4, i < 10}, 
    {True, True}, "between 4 and 10", 
    {True, False}, "greater than 10", 
    {False, True}, "less than 4", 
    {False, False}, "your computer's thinking is very odd" 
] 

बेशक, इस प्रिंट कि 4 4 से कम है, और 10 10 से अधिक है, लेकिन यह है कि आपके स्यूडोकोड में है।

इस विशेष मामले के एक हो सकता है बेहतर लिखने के लिए:

Which[ 
    i < 4,  "less than 4", 
    4 <= i <= 10, "between 4 and 10", 
    i > 10,  "greater than 10", 
    True,   "your computer's thinking is very odd" 
] 
+1

+1 हां, 'कौन सा' विशेष रूप से एक ही आयाम में एक साथ हथियार नहीं लगाए गए कई मानदंडों को जॉगलिंग के लिए आसान है। – DavidC

संबंधित मुद्दे