परीक्षण करने के लिए तर्क कि 4 में से 3 सत्य हैं

Question

मैं वापस आना चाहता हूँ True अगर 4 बूलियन मानों में से 3 सही हों, तो ही आऊंगा।

निकटतम मैं मिल गया है (x ^ y) ^ (a ^ b):

मुझे क्या करना चाहिए?

Comments

हम्म, एक ही तरीका है जो मैं गणितीय सूत्र के साथ सोच सकता हूं कि गिनती का उपयोग करना है। अच्छा प्रश्न! :)

— मैं

आपको लगता है कि बुरा नहीं है, लेकिन आपको नकारा होना चाहिए: not a ^ not b ^ not c ^ not dयह सच है जब वास्तव में नकारात्मक मूल्यों में से एक सच है। इसका मतलब है, मूल मूल्यों से, बिल्कुल एक गलत था।

— इंगो

इस विवरण के पीछे आपकी वास्तविक समस्या क्या है ?

— वुल्फ

@Ingo a ^ not b ^ not c ^ not d सच नहीं है जहाँ केवल एक झूठा है और जहाँ 3 झूठा है।

— नेमस्पेस

स्पष्ट गैर-गणना समाधान है (!a&&b&&c&&d) || (a&&!b&&c&&d) || (a&&b&&!c&&d) || (a&&b&&c&&!d)।

— जेसन सी

Answer 1

मेरा सुझाव है कि कोड को इस तरीके से लिखना चाहिए जो इंगित करता है कि आपका क्या मतलब है। यदि आप 3 मानों को सत्य बनाना चाहते हैं, तो मुझे स्वाभाविक लगता है कि मान 3 कहीं दिखाई देता है।

उदाहरण के लिए C++:

if ((int)a + (int)b + (int)c + (int)d == 3)
    ...

यह अच्छी तरह से परिभाषित किया गया है C++: यह standard (§4.7/4)दर्शाता है कि अपेक्षित मानों को 0 या 1 में परिवर्तित boolकरना int।

जावा और C # में, आप निम्नलिखित निर्माण का उपयोग कर सकते हैं:

if ((a?1:0) + (b?1:0) + (c?1:0) + (d?1:0) == 3)
    ...

Comments

यह एक अच्छा जवाब है। यह उस X / Y चीज़ के मामले जैसा दिखता है। "वह वाई का उपयोग करके एक्स करना चाहता है, लेकिन यह नहीं जानता कि वाई कैसे करना है। एक्स से पूछने के बजाय, वह वाई से पूछता है।" जब तक वह एक लॉजिक सर्किट या ऐसा कुछ (और फिर वह गलत साइट में होगा) डिज़ाइन कर रहा है, ऐसा करने का सबसे अच्छा तरीका एक तरह से पठनीय है ।

— NothingsImpossible

@NothingsImpossible प्रश्न के बारे में XY कुछ भी नहीं है। यह प्रोग्रामिंग में यथोचित सामान्य समस्या को हल करने के बारे में एक स्पष्ट और सीधा-सीधा सवाल है। Y अप्रासंगिक है।

— урослав Рахматуллин

धन्यवाद! यह वास्तव में मैं क्या करने का मतलब था , लेकिन मेरा विचार इतना अनाड़ी था कि मैं बूलियन तर्क के लिए पहुंच गया।

— साइमन कुआंग

if (!!a + !!b + !!c + !!d == 3)लिखना आसान है, हालाँकि मुझे नहीं पता कि कंपाइलर इसे ऑप्टिमाइज़ करते हैं या नहीं

— phuclv

ध्यान दें कि सी ++ में बूल से इंट तक कास्ट आवश्यक नहीं है।

— प्लाज़्मा एचएच

Answer 2

# 1: ब्रांचिंग का उपयोग ?: 3 या 4 ऑपरेशन

A ^ B ? C & D : ( C ^ D ) & A

# 2 नॉन-ब्रांचिंग, 7 ऑपरेशन

(A ^ B ^ C ^ D) & ((A & B) | (C & D))

जब मैं सब कुछ प्रोफाइल करने के लिए उपयोग करता हूं, तो मैंने पाया कि गैर-ब्रांचिंग समाधान काफी तेज ऑपरेशन-फॉर-ऑपरेशन थे क्योंकि सीपीयू कोड पथ को बेहतर ढंग से भविष्यवाणी कर सकता है, और अग्रानुक्रम में अधिक संचालन निष्पादित कर सकता है। हालांकि यहाँ शाखा विवरण में लगभग 50% कम काम है।

Comments

+1 - जबकि अन्य उत्तर अधिकांश प्रोग्रामिंग भाषाओं के लिए बेहतर हैं, आपका # 2 शुद्ध बूलियन तर्क में सबसे अच्छा उत्तर है।

— ब्रिलियनड

# 2 के लिए वुल्फरामलफा सत्य सारणी

— सवा

Answer 3

अगर यह पायथन होता, तो मैं लिखता

if [a, b, c, d].count(True) == 3:

या

if [a, b, c, d].count(False) == 1:

या

if [a, b, c, d].count(False) == True:
# In Python True == 1 and False == 0

या

print [a, b, c, d].count(0) == 1

या

print [a, b, c, d].count(1) == 3

या

if a + b + c + d == 3:

या

if sum([a, b, c, d]) == 3:

ये सभी कार्य, चूंकि बूलियन अजगर में पूर्णांक के उपवर्ग हैं।

if len(filter(bool, [a, b, c, d])) == 3:

या, इस स्वच्छ चाल से प्रेरित होकर ,

data = iter([a, b, c, d])
if not all(data) and all(data):

Comments

+1 यह समस्या को सही ढंग से पायथन में अनुवाद करके हल करता है।

— वुल्फ

यह थोड़ा खतरनाक है क्योंकि लोग अजगर में बूलियन संदर्भ में किसी भी गैर-शून्य पूर्णांक को वापस कर सकते हैं। पुरानी सी चाल अजगर में भी काम करती है a=5;not not a == 1:। असली बूलियन प्रकार न होने का नुकसान।

— वू

@Voo हमारे पास bool:)

— thefourtheye

@thefourtheye आह हाँ सच है, दोहरे नकार चाल / हैक की तुलना में बहुत अच्छा है।

— वू

या ... या .... या .... एक होना चाहिए - और अधिमानतः इसे करने के लिए केवल एक - स्पष्ट तरीका। : - / :-)

— rz

Answer 4

लंबा लेकिन बहुत सरल, (अप्रिय) सामान्य रूप:

 (~a & b & c & d) | (a & ~b & c & d) | (a & b & ~c & d) | (a & b & c & ~d)

यह सरलीकृत हो सकता है लेकिन इसके लिए अधिक सोच की आवश्यकता है: पी

Comments

@ आप इसे केवल इसके विभिन्न सामान्य रूप प्रदान करते हैं, जो पहले से ही (DNF) में है।

— रेकिंग

कैसे के बारे में (a & b & (c ^ d)) | ((a ^ b) & c & d)?

— user253751

हाँ, @immibis, वुल्फराम अल्फा के अनुसार इसका DNF सूत्र है जो मैंने लिखा है इसलिए यह एक ही बूलियन फ़ंक्शन है।

— गैस्टन बेंगोलिया

+1 क्योंकि मुझे लगता है कि कोड पढ़ने वाला कोई व्यक्ति यह समझ जाएगा कि अन्य उत्तरों की तुलना में क्या तेजी से प्रयास किया जा रहा है।

— बोलुक पपुकोग्लू

Answer 5

यकीन नहीं है कि यह सरल है, लेकिन शायद।

((x xor y) and (a and b)) or ((x and y) and (a xor b))

Comments

अरे नहीं! उन्हें विकल्प बहु अप-वोट का जवाब देना चाहिए था! विशेष रूप से अपने उत्तर को सही साबित करने के लिए वुल्फराम अल्फा का उपयोग करना बहुत अच्छी बात है!

— दुरई अमुथन

Answer 6

यदि आप प्रोग्रामिंग भाषा में इस तर्क का उपयोग करना चाहते हैं, तो मेरा सुझाव है

bool test(bool a, bool b, bool c, bool d){
    int n1 = a ? 1 : 0;
    int n2 = b ? 1 : 0;
    int n3 = c ? 1 : 0;
    int n4 = d ? 1 : 0;

    return n1 + n2 + n3 + n4 == 3;
}

या यदि आप चाहें, तो आप इन सभी को एक ही पंक्ति में रख सकते हैं:

return (a ? 1 : 0) + (b ? 1 : 0) + (C ? 1 : 0) + (d ? 1 : 0) == 3;

इसके अलावा आप इस समस्या को सामान्य कर सकते हैं n of m :

bool test(bool *values, int n, int m){
    int sum = 0;
    for(int i = 0; i < m; i += 1){
        sum += values[i] ? 1 : 0;
    }
    return sum == n;
}

Comments

मुझे इससे हराएं। पठनीयता हर बार चालाकी दिखाती है। +1

— माइकइलियार

Answer 7

यह उत्तर प्रतिनिधित्व प्रणाली पर निर्भर करता है, लेकिन यदि 0 को केवल एक ही मान लिया गया है कि वह गलत है, और not(false)हमेशा एक ही संख्यात्मक मान लौटाता है, तो not(a) + not(b) + not(c) + not(d) = not(0)चाल चलनी चाहिए।

Answer 8

यह ध्यान में रखते हुए कि एसओ यदि प्रोग्रामिंग प्रश्नों के लिए, केवल तार्किक समस्याओं के बजाय, उत्तर स्पष्ट रूप से एक प्रोग्रामिंग भाषा की पसंद पर निर्भर करता है। कुछ भाषाएं ऐसी विशेषताओं का समर्थन करती हैं जो दूसरों के लिए असामान्य हैं।

उदाहरण के लिए, C ++ में आप अपनी शर्तों का परीक्षण कर सकते हैं:

(a + b + c + d) == 3

यह उन भाषाओं में जांच करने का सबसे तेज़ तरीका होना चाहिए जो बूलियन से पूर्णांक प्रकारों में स्वचालित (निम्न-स्तरीय) रूपांतरण का समर्थन करते हैं। लेकिन फिर, उस समस्या के लिए कोई सामान्य जवाब नहीं है।

Comments

यह जवाब मैं पोस्ट करने जा रहा था। यद्यपि जोड़ने वाली एक चीज़, उपयोग की गई प्रोग्रामिंग भाषा के आधार पर, आप जो उत्तर चाहते हैं वह -3 होगा। VB में, True = -1।

— टॉम कोलिन्स

Answer 9

सबसे अच्छा मैं कर सकता हूँ ((x ^ y) ^ (a ^ b)) && ((a || x) && (b || y))

Comments

आपके लिए सबसे अच्छा क्या है ?

— वुल्फ

दिलचस्प। सेशन का हल निकाला और बुरे मामलों से पर्दा हटा दिया

— क्रंचर

Answer 10

((a xor b) xor (c xor d)) and ((a or b) and (c or d))

मुट्ठी की अभिव्यक्ति 4 में से 1 या 3 trueकी खोज करती है । दूसरा व्यक्ति 4 में से 0 या 1 (और कभी-कभी 2) को trueसमाप्त करता है।

Answer 11

जावा 8, गलत मानों को फ़िल्टर करें और शेष वास्तविक मानों की गणना करें:

public static long count(Boolean... values) {
    return Arrays.stream(values).filter(t -> t).count();
}

तो आप इसे निम्नानुसार उपयोग कर सकते हैं:

if (3 == count(a, b, c, d)) {
    System.out.println("There... are... THREE... lights!");
}

आसानी से सही होने वाली वस्तुओं nकी जाँच करने के लिए सामान्यीकृत करता mहै।

Answer 12

nसभी में से कम से कम जांचने के Booleanलिए सत्य हैं, (n कुल संख्या Boolean: p से कम या बराबर होना चाहिए )

if (((a ? 1:0) + (b ? 1:0 ) + (c ? 1:0) + (d ? 1:0 )) >= n) {
    // do the rest
}

संपादित करें : @ क्रंचर की टिप्पणी के बाद

boolean4 में से 3 की जांच करने के लिए

if (((a ? 1:0) + (b ? 1:0 ) + (c ? 1:0) + (d ? 1:0 )) == 3) {
    // do the rest
}

और एक :

((c & d) & (a ^ b)) | ((a & b) & (c ^ d))( विवरण )

Comments

ओपी बिल्कुल एन चाहता है, कम से कम एन नहीं। लेकिन इस समाधान से एक आसान बदलाव है

— क्रंचर

@ वो सवाल जो StackUnderflow.com के अंतर्गत आता है: p

— नहीं एक बग

Answer 13

यहाँ एक तरीका है जिसे आप LINQ के साथ C # में हल कर सकते हैं:

bool threeTrue = new[] { a, b, x, y }.Count(x => x) == 3;

Answer 14

यह सममित बूलियन फ़ंक्शन है S₃(4) । एक सममित बूलियन फ़ंक्शन एक बूलियन फ़ंक्शन है जो केवल इनपुट सेट की मात्रा पर निर्भर करता है, लेकिन यह निर्भर नहीं करता है कि वे कौन से इनपुट हैं। द नूथ ने कंप्यूटर प्रोग्रामिंग के वॉल्यूम 4 के खंड 7.1.2 में इस प्रकार के कार्यों का उल्लेख किया है।

S₃(4) निम्नानुसार 7 संचालन के साथ गणना की जा सकती है:

(x && y && (a || b)) ^ ((x || y) && a && b)

नुथ दिखाता है कि यह इष्टतम है, जिसका अर्थ है कि आप सामान्य ऑपरेटरों का उपयोग करके 7 से कम संचालन में ऐसा नहीं कर सकते हैं: &&, || , ^, <,और> ।

हालाँकि यदि आप इसका उपयोग किसी ऐसी भाषा में करना चाहते हैं जो 1सही और 0गलत के लिए उपयोग करती है, तो आप आसानी से जोड़ भी सकते हैं:

x + y + a + b == 3

जो आपके इरादे को स्पष्ट करता है।

Answer 15

(a && b && (c xor d)) || (c && d && (a xor b))

शुद्ध तर्क की दृष्टि से यह वही है जो मैं लेकर आया हूं।

कबूतर छेद सिद्धांत द्वारा, यदि वास्तव में 3 सच हैं, तो या तो ए और बी सच है, या सी और डी सच है। तो फिर यह उन मामलों में से प्रत्येक को ठीक करने की बात है जो अन्य 2 में से एक के साथ ठीक है।

वुल्फराम सच्चाई तालिका

Comments

यह नेमस्पेस के दूसरे समाधान के बराबर है।

— ब्रिलियनड

@ ब्रिलियनड मुझे अलग लगता है। सभी 3 या 1 या 1 प्राप्त करने के लिए सभी एक साथ उसके एक्सर्स, फिर 2 अलग-अलग समूहों में से कम से कम एक की आवश्यकता के साथ 1 को बाहर कर देते हैं। (1 या 3 और कम से कम 2 के रूप में संक्षेप)। मेरा एक अलग समूह से दोनों की आवश्यकता है, और फिर दूसरे समूह से बिल्कुल एक।

— क्रंचर

यदि आप इस अर्थ में समतुल्य हैं, mine <=> hisतो मुझे नहीं पता कि क्या कहना है क्योंकि यह अपेक्षित होगा।

— क्रंचर

मुझे लगता है कि मेरा मतलब है कि यह उत्तर ठीक उसी तरह से अच्छा है जिस तरह से नामस्पेस का दूसरा समाधान अच्छा है, बिना कुछ नया जोड़े जो नेमस्पेस के (पहले) उत्तर को कवर नहीं किया। खैर, मैं वैसे भी उत्थान करूंगा।

— ब्रिलियनड

Answer 16

यदि आप एक तर्क दृश्य उपकरण का उपयोग करते हैं जैसे कर्णघ मैप्स, तो आप देखते हैं कि यह एक समस्या है जहाँ आप पूर्ण विकसित तर्क शब्द से बच नहीं सकते यदि आप इसे एक (...) पंक्ति में लिखना चाहते हैं। लोपिना ने इसे पहले ही दिखाया था, इसे सरल लिखना संभव नहीं है। आप थोड़ा फैक्टर कर सकते हैं, लेकिन यह आपके लिए और मशीन के लिए पढ़ना कठिन रहेगा।

गिनती के समाधान खराब नहीं हैं और वे दिखाते हैं कि आप वास्तव में क्या हैं। आप कैसे कुशलता से गिनती करते हैं यह आपकी प्रोग्रामिंग भाषा पर निर्भर करता है। पायथन ओडर लाइनक्यू के साथ सरणी समाधान देखने में अच्छे हैं, लेकिन सावधान रहें, यह धीमी है। वुल्फ (ए + बी + एक्स + वाई) == 3 अच्छी तरह से और तेजी से काम करेगा, लेकिन केवल अगर आपकी भाषा 1 के साथ "सच" के बराबर है। यदि "सच" को -1 द्वारा दर्शाया गया है, तो आपको -3 का परीक्षण करना होगा: )

यदि आपकी भाषा सच्चे बूलियन का उपयोग करती है, तो आप इसे स्पष्ट रूप से प्रोग्राम करने की कोशिश कर सकते हैं (मैं उपयोग! = XOR परीक्षण के रूप में):

if (a)
{
    if (b)
        return (x != y);    // a,b=true, so either x or y must be true
    else
        return (x && y);     // a=true, b=false, so x AND y must be true
}
else
{
    if (b)
        return (x && y);    // a=false, b=true, so x and y must be true
    else
        return false;       // a,b false, can't get 3 of 4
}

"x! = y" केवल तभी काम करता है जब x, y एक बूलियन प्रकार का हो। यदि वे कुछ अन्य प्रकार हैं जहां 0 गलत है और बाकी सब कुछ सच है, तो यह विफल हो सकता है। फिर एक बूलियन XOR, या ((बूल) x! = (बूल) y) का उपयोग करें, या "if (x) return (y == false) और लौटाएं (y == true);", जो थोड़ा अधिक है कंप्यूटर के लिए काम करते हैं।

अगर आपकी प्रोग्रामिंग लैंग्वेज टर्नेरी ?: ऑपरेटर प्रदान करती है, तो आप इसे छोटा कर सकते हैं

if (a)
    return b ? (x != y) : (x && y);
else
    return b ? (x && y) : false;

जो थोड़ी पठनीयता रखता है, या इसे आक्रामक रूप से काटता है

return a ? (b ? (x != y) : (x && y)) : (b ? (x && y) : false);

यह कोड बिल्कुल तीन लॉजिक टेस्ट (a, b की अवस्था, x और y की तुलना) करता है और यहां अन्य अधिकांश उत्तरों की तुलना में तेज होना चाहिए। लेकिन आपको यह टिप्पणी करने की आवश्यकता है, या आप इसे 3 महीने बाद समझ नहीं पाएंगे :)

Answer 17

यहाँ बहुत सारे अच्छे उत्तर हैं; यहाँ एक वैकल्पिक सूत्रीकरण है जिसे किसी और ने अभी तक पोस्ट नहीं किया है:

 a ? (b ? (c ^ d) : (c && d)) : (b && c && d)

Comments

आपके उत्तर के लिए धन्यवाद, लेकिन क्या आप कृपया कुछ टिप्पणी जोड़ सकते हैं कि यह कैसे काम करता है? धन्यवाद।

— डीनना

(आप पर लेने के लिए क्षमा करें, मुझे यह समीक्षा ऑडिट के रूप में दी गई थी। कम से कम मैं पास हो गया :) :))

— डीनना

Answer 18

पहले उत्तर के समान, लेकिन शुद्ध जावा:

int t(boolean b) {
    return (b) ? 1 : 0;
}

if (t(x) + t(y) + t(a) + t(b) == 3) return true;
return false;

मैं उन्हें पूर्णांक के रूप में गिनना पसंद करता हूं क्योंकि यह अधिक पठनीय कोड के लिए बनाता है।

Answer 19

में अजगर , तत्वों की एक iterable में से कितने को देखने के लिए कर रहे हैं यह सच है, का उपयोग करें sum(यह काफी सीधा है):

सेट अप

import itertools

arrays = list(itertools.product(*[[True, False]]*4))

वास्तविक परीक्षण

for array in arrays:
    print(array, sum(array)==3)

उत्पादन

(True, True, True, True) False
(True, True, True, False) True
(True, True, False, True) True
(True, True, False, False) False
(True, False, True, True) True
(True, False, True, False) False
(True, False, False, True) False
(True, False, False, False) False
(False, True, True, True) True
(False, True, True, False) False
(False, True, False, True) False
(False, True, False, False) False
(False, False, True, True) False
(False, False, True, False) False
(False, False, False, True) False
(False, False, False, False) False

Answer 20

यदि आप ऑन-द-पेपर (गैर-प्रोग्रामिंग) समाधान के बाद हैं, तो के-मैप्स और क्वीन-मैकलुस्की एल्गोरिदम आपके बाद में हैं, वे आपके बूलियन फ़ंक्शन को छोटा करने में आपकी सहायता करते हैं।

आपके मामले में, परिणाम है

y = (x̄3 ^ x2 ^ x1 ^ x0) ∨ (x3 ^ x̄2 ^ x1 ^ x0) ∨ (x3 ^ x2 ^ x̄1 ^ x0) ∨ (x3 ^ x2 ^ x1 ^ x̄0)

यदि आप इस प्रोग्राम को गैर-निश्चित मात्रा में चर और एक कस्टम "थ्रेशोल्ड" करना चाहते हैं, तो बस बूलियन मूल्यों की सूची के माध्यम से पुनरावृत्ति करना और "सच" की गिनती की घटनाओं को बहुत सरल और सीधा है।

Comments

बार ओवरहेड का क्या अर्थ है? मैंने इसकी सूची नीचे जाने की सूचना दी।

— NameSpace

@NameSpace यह IMO में से एक है जिसे बहुत से लोग "नहीं" व्यक्त करने के लिए उपयोग करते हैं।

Answer 21

मैं सच लौटना चाहता हूं अगर और केवल 4 बूलियन मानों में से 3 सही हैं।

4 बूलियन मूल्यों को देखते हुए, ए, बी, एक्स, वाई, यह कार्य निम्नलिखित सी स्टेटमेंट में अनुवाद करता है:

return (a+b+x+y) == 3;

Comments

अच्छा जाल। यह मानता है कि यह trueबराबर है। यह सभी भाषाओं / मामलों में सही नहीं है। blogs.msdn.com/b/oldnewthing/archive/2004/12/22/329884.aspx

— JensG

@ जेन्स जी आप सही कह रहे हैं: मैं इस धारणा को स्पष्ट करता हूं। Thx :)

— वुल्फ

Answer 22

((a^b)^(x^y))&((a|b)&(x|y))

तुम क्या चाहते हो मूल रूप से मैंने आपका कोड लिया और जाँच की कि क्या वास्तव में 3 सच हैं और 3 झूठे नहीं हैं।

Answer 23

पुनरावृत्ति से जुड़े उत्तर के बिना एक प्रोग्रामिंग प्रश्न? समझ से बाहर!

पर्याप्त "बिल्कुल 4 ट्रूज़ में से 3" उत्तर हैं, लेकिन यहां "एन ट्रूज़ के बिल्कुल बाहर एम" के लिए एक सामान्यीकृत (जावा) संस्करण है (अन्यथा पुनरावृत्ति वास्तव में इसके लायक नहीं है) सिर्फ इसलिए कि आप कर सकते हैं:

public static boolean containsTrues(boolean[] someBooleans,
    int anIndex, int truesExpected, int truesFoundSoFar) {
  if (anIndex >= someBooleans.length) {
    return truesExpected == truesFoundSoFar; // reached end
  }
  int falsesExpected = someBooleans.length - truesExpected;
  boolean currentBoolean = someBooleans[anIndex];
  int truesFound = truesFoundSoFar + (currentBoolean ? 1 : 0);
  if (truesFound > truesExpected) {
    return false;
  }
  if (anIndex - truesFound > falsesExpected) {
    return false; // too many falses
  }
  return containsTrues(someBooleans, anIndex + 1, truesExpected,
      truesFound);
}

इसे कुछ इस तरह से बुलाया जा सकता है:

 boolean[] booleans = { true, false, true, true, false, true, true, false };
 containsTrues(booleans, 0, 5, 0);

जो लौटना चाहिए true(क्योंकि 5 में से 8 मूल्य सही थे, जैसा कि अपेक्षित था)। "Trues" और "falses" शब्दों से बिल्कुल खुश नहीं हैं, लेकिन अभी एक बेहतर नाम के बारे में सोच भी नहीं सकते .... ध्यान दें कि बहुत अधिक true या बहुत सारे falseमान मिलने पर पुनरावृत्ति रुक ​​जाती है ।

Comments

@ FélixSaparelli: यकीन नहीं कि "सत्य" यहां लागू होता है ... ऐसा लगता है कि आप सिर्फ एक के साथ खुश हैं true। शायद कुछ ऐसा containsNumberOfTrueValues()। एक तरफ के रूप में: स्मालटाक का नामकरण इसके लिए अधिक उपयुक्त होगा, हालांकि doesArray: someBooleans startingAt: anIndex containNumberOfTrueValues: anExpectedNumber foundSofar: aNumberFoundSoFar:। शायद कुछ जावा देवों के स्वाद के लिए बहुत लंबा है, लेकिन स्मॉलटालकर कभी भी उचित नामकरण से डरते नहीं हैं;;

— आमोस एम। बढ़ई

जो ज्यादातर हास्यप्रद था। और containsTruthइसका मतलब है "सच में कुछ अज्ञात राशि शामिल है", सचमुच, इसलिए मेरा मानना ​​है कि यह काफी ठीक है।

— फेलिक्स सपरेली

Answer 24

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

bool exactly_three_true_from(bool cond1, bool cond2, bool cond3, bool cond4)
{
    //...
}

Answer 25

PHP में, इसे और अधिक गतिशील बनाना (यदि आप स्थितियों की संख्या को बदलते हैं, आदि):

$min = 6;
$total = 10;

// create our boolean array values
$arr = array_map(function($a){return mt_rand(0,1)>0;},range(1,$total));

// the 'check'
$arrbools = array_map(function($a){return (int)$a;},$arr);
$conditionMet = array_sum($arrbools)>=$min;

echo $conditionMet ? "Passed" : "Failed";

Answer 26

(((a AND b) OR (x AND y)) AND ((a XOR b) OR (x XOR y)))

जबकि मैं दिखा सकता था कि यह एक अच्छा समाधान है, सैम होसेवर का जवाब बाद में लिखना और समझना दोनों आसान है। मेरी किताब में जो इसे बेहतर बनाता है।

Answer 27

यहाँ कुछ c # कोड है जो मैंने अभी लिखा है क्योंकि आपने मुझे प्रेरित किया है:

यह किसी भी राशि के तर्क लेता है और आपको बताएगा कि क्या उनमें से n सच है।

    static bool boolTester(int n, params bool[] values)
    {
        int sum = 0;           

        for (int i = 0; i < values.Length; i++)
        {
            if (values[i] == true)
            {
                sum += 1;
            }                
        }
        if( sum == n)
        {
            return true;
        }            
        return false;                
    }

और आप इसे ऐसे कहते हैं:

        bool a = true;
        bool b = true;
        bool c = true;
        bool d = false;            

        bool test = false;
        test = boolTester(3, a, b, c, d);

तो अब आप 7/9 या 15/100 का परीक्षण कर सकते हैं।