তিনটি বুলিয়ানের মধ্যে কমপক্ষে দু'জন সত্য কিনা তা পরীক্ষা করে দেখুন


579

একজন সাক্ষাত্কারকারী সম্প্রতি আমাকে এই প্রশ্নটি করেছিলেন: তিনটি বুলিয়ান ভেরিয়েবল, ক, খ এবং সি দেওয়া, তিনটির মধ্যে কমপক্ষে দু'জন সত্য হলে সত্যটি প্রত্যাবর্তন করুন।

আমার সমাধান অনুসরণ:

boolean atLeastTwo(boolean a, boolean b, boolean c) {
    if ((a && b) || (b && c) || (a && c)) {
        return true;
    }
    else{
        return false;
    }
}

তিনি বলেছিলেন যে এটি আরও উন্নত করা যায়, তবে কীভাবে?


170
রিটার্নের স্টেটমেন্টটি ইনলাইন করুন।
ফিঙ্গলাস

45
"হু-হু-হ্যাস্ট-সর্বাধিক আইকিউ" সাক্ষাত্কারের মতো শোনাচ্ছে। আমি ব্যর্থ হবে।
ক্রিস ডাট্রো

79
atLeastTwo(iWantYou, iNeedYou, imEverGonnaLoveYou)
অ্যান্ড্রু গ্রিম

92
লোকেরা কেন সবচেয়ে তুচ্ছ প্রশ্ন উত্থাপন করে?
ব্লুরাজা - ড্যানি প্লে ফ্লুওফুট

46
যে প্রশ্নগুলি সাধারণ এবং সহজেই বোঝা যায় সেগুলি অনেক বেশি ভোট পায়। যে প্রশ্নগুলি খুব নির্দিষ্ট এবং প্রযুক্তিগত হয় না।
জে

উত্তর:


820

লেখার চেয়ে:

if (someExpression) {
    return true;
} else {
    return false;
}

লিখুন:

return someExpression;

নিজের মত প্রকাশের জন্য, এরকম কিছু:

boolean atLeastTwo(boolean a, boolean b, boolean c) {
    return a ? (b || c) : (b && c);
}

অথবা এটি (আপনি যেটি বুঝতে সহজ মনে করেন):

boolean atLeastTwo(boolean a, boolean b, boolean c) {
    return a && (b || c) || (b && c);
}

এটি পরীক্ষা করে aএবং bঠিক একবারে এবং cএকবারে।

তথ্যসূত্র


144
+1: ধাঁধার সুন্দর সমাধান, তবে আশা করি আমরা আসল বিশ্বে এর মতো কিছু দেখতে পাচ্ছি না :)
জুলিয়েট

124
@ জুলিয়েট: আমি জানি না, আমি মনে করি এটি যদি সত্য-বিশ্বের প্রয়োজন হয় (আসল পরিবর্তনশীল নাম সহ) এটি খুব ভালভাবে পড়ত। বিবেচনা করুন return hasGoodAttendance ? (passedCoursework || passed Exam) : (passedCoursework && passedExam), এটি আমার কাছে দুর্দান্ত দেখাচ্ছে।
আন্দ্রেজেজ ডয়েল

18
আমি মনে করি না যে কেমন লাগে খারাপ , কিন্তু যদি ডোমেইনে প্রয়োজন হতে "অন্তত দুটি" বোঝা যায়, আমার মনে হয় এটা পড়ার জন্য সহজ হতে চাই atLeastTwo(hasgoodAttendance, passedCoursework, passedExam)। "কমপক্ষে 2 টি সত্য সত্য" এর ধারণাটি তার নিজস্ব ক্রিয়াকলাপের পক্ষে প্রাপ্য যথেষ্ট জেনেরিক।
কেন

17
@ লিজ: সাক্ষাত্কারের মুখোমুখি হয়ে সর্বাধিক মাইক্রো-অপ্টিমাইজড কোড জিজ্ঞাসা করা অযৌক্তিক, এবং আমি সাহস করে বলি, অকেজো। মাইক্রো-অপ্টিমাইজেশন, যখন প্রয়োজন দ্বারা চালিত হয়, রানটাইম প্রোফাইলের ফলাফল দ্বারা পরিচালিত হয়, মানুষের প্রবৃত্তি নয় (যা ভয়ঙ্কর হিসাবে পরিচিত)। আপনি অবশ্যই ইন্টারভিউয়াদের যে প্রক্রিয়াটি দ্বারা আরও এটিকে আরও অনুকূল করে তুলতে চাইতে পারেন; এটি ফলাফলের চেয়ে বেশি গুরুত্বপূর্ণ।
বহুগ্লানিউব্রিকেন্টস

17
টার্নারি অপারেটর একটি সাধারণ প্রথা যা আপনাকে পড়তে সক্ষম হওয়া উচিত। আপনি যদি এটি পড়তে না পারেন তবে আপনি যতক্ষণ না পারছেন ততক্ষণ পড়া উচিত। টার্নারি অপারেটরের ব্যবহার এমন কিছু নয় যা আমি আপত্তিজনক অর্থে "চতুর" হিসাবে বিবেচনা করি। তবে হ্যাঁ, আপনি যদি সাধারণভাবে "কমপক্ষে দুটি" যুক্তি ব্যবহার করেন তবে আমি এটিকে একটি মেথড কলের মূল অংশ হিসাবে রাখতাম।
স্টিফেন পি

492

অপেক্ষাকৃত সরল-এগিয়ে যাওয়া সমস্যার উত্তর দেওয়ার জন্য কেবল এক্সওআর ব্যবহারের জন্য ...

return a ^ b ? c : a

158
বাহ, শীতল সমাধান। তবে আমার পক্ষে এর উল্টানো সংস্করণটি বোঝা আরও সহজ: a == খ? a: c
রোটসর

5
a ^ বি? c: a ^ b? c: a ^ b? সি: এ
আলেকজান্ডারপাস

4
হ্যাঁ, এক্সওর একটি খারাপ প্রেস পেয়েছে এবং আপনি খুব কমই এটি ব্যবহারের সুযোগ পাবেন।
এশিউইন iteক্যবদ্ধ

18
@ স্টিমুল 8 ডি কারণ সম্ভবত, বুলিয়ানদের পক্ষে এটি একই! = তবে কম পাঠযোগ্য?
অনুমান করা

2
আমি বিশুদ্ধরূপে বাইনারি ফর্মটিকে পছন্দ করি: রিটার্ন ((a ^ b) & c) | (একটি এবং খ) এটি শাখা-কম (দ্রুত) এবং পড়তে সহজ: (ক বা খ সত্য এবং গ সত্য) বা (ক এবং খ উভয় সত্য)। মনে রাখবেন যে (a | b) এবং (a ^ b) উভয়ই এই সূত্রটি নিয়ে কাজ করে।
ফ্ল্যাঙ্গলেট

217

আক্ষরিক অর্থে এটি বাস্তবায়ন হয় না কেন? :)

(a?1:0)+(b?1:0)+(c?1:0) >= 2

সিতে আপনি কেবল লিখতে পারেন a+b+c >= 2(বা !!a+!!b+!!c >= 2খুব নিরাপদ হতে)।

জাভা বাইটকোডের সাথে টফুবিয়ারের তুলনার জবাবে , এখানে একটি সহজ পারফরম্যান্স পরীক্ষা:

class Main
{
    static boolean majorityDEAD(boolean a,boolean b,boolean c)
    {
        return a;
    }

    static boolean majority1(boolean a,boolean b,boolean c)
    {
        return a&&b || b&&c || a&&c;
    }

    static boolean majority2(boolean a,boolean b,boolean c)
    {
        return a ? b||c : b&&c;
    }

    static boolean majority3(boolean a,boolean b,boolean c)
    {
        return a&b | b&c | c&a;
    }

    static boolean majority4(boolean a,boolean b,boolean c)
    {
        return (a?1:0)+(b?1:0)+(c?1:0) >= 2;
    }

    static int loop1(boolean[] data, int i, int sz1, int sz2)
    {
        int sum = 0;
        for(int j=i;j<i+sz1;j++)
        {
            for(int k=j;k<j+sz2;k++)
            {
                sum += majority1(data[i], data[j], data[k])?1:0; 
                sum += majority1(data[i], data[k], data[j])?1:0; 
                sum += majority1(data[j], data[k], data[i])?1:0; 
                sum += majority1(data[j], data[i], data[k])?1:0; 
                sum += majority1(data[k], data[i], data[j])?1:0; 
                sum += majority1(data[k], data[j], data[i])?1:0; 
            }
        }
        return sum;
    }

    static int loop2(boolean[] data, int i, int sz1, int sz2)
    {
        int sum = 0;
        for(int j=i;j<i+sz1;j++)
        {
            for(int k=j;k<j+sz2;k++)
            {
                sum += majority2(data[i], data[j], data[k])?1:0; 
                sum += majority2(data[i], data[k], data[j])?1:0; 
                sum += majority2(data[j], data[k], data[i])?1:0; 
                sum += majority2(data[j], data[i], data[k])?1:0; 
                sum += majority2(data[k], data[i], data[j])?1:0; 
                sum += majority2(data[k], data[j], data[i])?1:0; 
            }
        }
        return sum;
    }

    static int loop3(boolean[] data, int i, int sz1, int sz2)
    {
        int sum = 0;
        for(int j=i;j<i+sz1;j++)
        {
            for(int k=j;k<j+sz2;k++)
            {
                sum += majority3(data[i], data[j], data[k])?1:0; 
                sum += majority3(data[i], data[k], data[j])?1:0; 
                sum += majority3(data[j], data[k], data[i])?1:0; 
                sum += majority3(data[j], data[i], data[k])?1:0; 
                sum += majority3(data[k], data[i], data[j])?1:0; 
                sum += majority3(data[k], data[j], data[i])?1:0; 
            }
        }
        return sum;
    }

    static int loop4(boolean[] data, int i, int sz1, int sz2)
    {
        int sum = 0;
        for(int j=i;j<i+sz1;j++)
        {
            for(int k=j;k<j+sz2;k++)
            {
                sum += majority4(data[i], data[j], data[k])?1:0; 
                sum += majority4(data[i], data[k], data[j])?1:0; 
                sum += majority4(data[j], data[k], data[i])?1:0; 
                sum += majority4(data[j], data[i], data[k])?1:0; 
                sum += majority4(data[k], data[i], data[j])?1:0; 
                sum += majority4(data[k], data[j], data[i])?1:0; 
            }
        }
        return sum;
    }

    static int loopDEAD(boolean[] data, int i, int sz1, int sz2)
    {
        int sum = 0;
        for(int j=i;j<i+sz1;j++)
        {
            for(int k=j;k<j+sz2;k++)
            {
                sum += majorityDEAD(data[i], data[j], data[k])?1:0; 
                sum += majorityDEAD(data[i], data[k], data[j])?1:0; 
                sum += majorityDEAD(data[j], data[k], data[i])?1:0; 
                sum += majorityDEAD(data[j], data[i], data[k])?1:0; 
                sum += majorityDEAD(data[k], data[i], data[j])?1:0; 
                sum += majorityDEAD(data[k], data[j], data[i])?1:0; 
            }
        }
        return sum;
    }

    static void work()
    {
        boolean [] data = new boolean [10000];
        java.util.Random r = new java.util.Random(0);
        for(int i=0;i<data.length;i++)
            data[i] = r.nextInt(2) > 0;
        long t0,t1,t2,t3,t4,tDEAD;
        int sz1 = 100;
        int sz2 = 100;
        int sum = 0;

        t0 = System.currentTimeMillis();

        for(int i=0;i<data.length-sz1-sz2;i++)
            sum += loop1(data, i, sz1, sz2);

        t1 = System.currentTimeMillis();

        for(int i=0;i<data.length-sz1-sz2;i++)
            sum += loop2(data, i, sz1, sz2);

        t2 = System.currentTimeMillis();

        for(int i=0;i<data.length-sz1-sz2;i++)
            sum += loop3(data, i, sz1, sz2);

        t3 = System.currentTimeMillis();

        for(int i=0;i<data.length-sz1-sz2;i++)
            sum += loop4(data, i, sz1, sz2);

        t4 = System.currentTimeMillis();

        for(int i=0;i<data.length-sz1-sz2;i++)
            sum += loopDEAD(data, i, sz1, sz2);

        tDEAD = System.currentTimeMillis();

        System.out.println("a&&b || b&&c || a&&c : " + (t1-t0) + " ms");
        System.out.println("   a ? b||c : b&&c   : " + (t2-t1) + " ms");
        System.out.println("   a&b | b&c | c&a   : " + (t3-t2) + " ms");
        System.out.println("   a + b + c >= 2    : " + (t4-t3) + " ms");
        System.out.println("       DEAD          : " + (tDEAD-t4) + " ms");
        System.out.println("sum: "+sum);
    }

    public static void main(String[] args) throws InterruptedException
    {
        while(true)
        {
            work();
            Thread.sleep(1000);
        }
    }
}

এটি আমার মেশিনে নিম্নলিখিতটি মুদ্রণ করে (হটস্পট সার্ভার ভিএম (14.1-বি02, মিশ্র মোড) সহ ইনটেল কোর 2 + সান জাভা 1.6.0_15-বি03 তে উবুন্টু চলছে):

প্রথম এবং দ্বিতীয় পুনরাবৃত্তি:

a&&b || b&&c || a&&c : 1740 ms
   a ? b||c : b&&c   : 1690 ms
   a&b | b&c | c&a   : 835 ms
   a + b + c >= 2    : 348 ms
       DEAD          : 169 ms
sum: 1472612418

পরবর্তী পুনরাবৃত্তি:

a&&b || b&&c || a&&c : 1638 ms
   a ? b||c : b&&c   : 1612 ms
   a&b | b&c | c&a   : 779 ms
   a + b + c >= 2    : 905 ms
       DEAD          : 221 ms

আমি ভাবছি, জাভা ভিএম এমন কী করতে পারে যা সময়ের সাথে সাথে (এ + বি + সি> = ২) কেস কার্যক্ষমতা হ্রাস করে।

এবং আমি যদি -clientভিএম স্যুইচ দিয়ে জাভা চালাই তবে এখানে কী হবে :

a&&b || b&&c || a&&c : 4034 ms
   a ? b||c : b&&c   : 2215 ms
   a&b | b&c | c&a   : 1347 ms
   a + b + c >= 2    : 6589 ms
       DEAD          : 1016 ms

রহস্য ...

এবং যদি আমি এটি জিএনইউ জাভা ইন্টারপ্রেটারে চালিত করি তবে এটি প্রায় 100 গুণ ধীর হয়ে যায় তবে a&&b || b&&c || a&&cসংস্করণটি তখন জিতে যায়।

টোফিউয়ারের সর্বশেষতম কোড ওএস এক্স সহ ফলাফলগুলি:

a&&b || b&&c || a&&c : 1358 ms
   a ? b||c : b&&c   : 1187 ms
   a&b | b&c | c&a   : 410 ms
   a + b + c >= 2    : 602 ms
       DEAD          : 161 ms

ম্যাক জাভা 1.6.0_26-b03-383-11A511 সহ পল ওয়াগল্যান্ডের ফলাফল

a&&b || b&&c || a&&c : 394 ms 
   a ? b||c : b&&c   : 435 ms
   a&b | b&c | c&a   : 420 ms
   a + b + c >= 2    : 640 ms
   a ^ b ? c : a     : 571 ms
   a != b ? c : a    : 487 ms
       DEAD          : 170 ms

4
a+b+c >= 2: এই নেতিবাচক সঙ্গে কাজ করে না, তাই না? আপনাকে !!aজিনিসটি করতে হতে পারে , আমি নিশ্চিত নই।
পলিজেনুব্রিকেন্টস

8
<গুলি> -1। সি এর জন্য আপনার কখনই এটি করা উচিত নয় আপনি সত্যের মানটি কী তা জানেন না (এটি কেবল সহজেই -1 হতে পারে) </ আমি এখনও এই কাজ না।
মার্ক পিটারস

1
আপনার ইনপুটটি যদি বুলিয়ান অপারেশনের ফলাফল হয় তবে তা কি সম্ভব? এবং সি ++ তে "বুল" টাইপের পক্ষে কি এটি সম্ভব?
রোটসর

2
@ রোটসর: কেউই বলেনি যে ইনপুটটি বুলিয়ান অভিযানের ফলাফল হতে হবে। এমনকি নেতিবাচক ছাড়াও আপনি আগুন নিয়ে খেলছেন, আপনি যদি এটি 2 হিসাবে সংজ্ঞায়িত করেন তবে আপনার অবস্থার মিথ্যা ধনাত্মকতা রয়েছে। তবে আমি বুলিয়ানদের গাণিতিকের সাথে মিশ্রিত করার ধারণাটিকে ততটা অপছন্দ করি না I আপনার জাভা সমাধানটি পরিষ্কার যে এটি বুলিয়ান থেকে পূর্ণসংখ্যার ধরণের রূপান্তরগুলিতে নির্ভর করে না।
মার্ক পিটারস

7
মাইক্রোবেইনমার্কস সম্পর্কে সতর্ক থাকুন: java.sun.com/docs/hotspot/HotSpotFAQ.html#benchmarking_simple
বালুস সি

143

এই জাতীয় প্রশ্নগুলির সমাধান কর্ণহো ম্যাপের মাধ্যমে করা যেতে পারে :

      | C | !C
------|---|----
 A  B | 1 | 1 
 A !B | 1 | 0
!A !B | 0 | 0
!A  B | 1 | 0

যা থেকে আপনি অনুমান করেন যে আপনার প্রথম সারির জন্য একটি গ্রুপ এবং প্রথম কলামের জন্য দুটি গোষ্ঠী প্রয়োজন, পলিজেনুব্রিকেন্টগুলির সর্বোত্তম সমাধান পাওয়া:

(C && (A || B)) || (A && B)  <---- first row
       ^
       |
   first column without third case

10
@ জাস্টিন, কর্নোক মানচিত্র লজিক্যাল অপারেশনের সংখ্যা 3 টিআরএস এবং 2 ওআরএস থেকে কমিয়ে 2 অ্যান্ডস এবং 2 ওআরএস করেছে। @ জ্যাক, কর্নহো ম্যাপের অস্তিত্ব সম্পর্কে মনে করিয়ে দেওয়ার জন্য ধন্যবাদ Thanks
টাচি

14
নতুন কিছুর জন্য +1। আমার পরবর্তী ক্রিয়াকলাপে কোনও কে-ম্যাপ অন্তর্ভুক্ত থাকবে, এটির প্রয়োজন হয় বা এটি প্রয়োজন।
জাস্টিন আর।

2
হতে পারে দরিদ্র পাঠযোগ্যতার ক্ষতিপূরণ দেওয়া যেতে পারে (1) মন্তব্যে উপযুক্ত টেবিল এবং (2) স্কুলে দরকারী শেখার জন্য উপযুক্ত ইউনিট পরীক্ষা ... +1 দ্বারা।
মোয়ালা

140

পাঠযোগ্যতার লক্ষ্য হওয়া উচিত। কোডটি পড়ে এমন কাউকে অবশ্যই আপনার উদ্দেশ্যটি অবিলম্বে বুঝতে হবে। সুতরাং এখানে আমার সমাধান।

int howManyBooleansAreTrue =
      (a ? 1 : 0)
    + (b ? 1 : 0)
    + (c ? 1 : 0);

return howManyBooleansAreTrue >= 2;

21
আমি পূর্বসূরীর সাথে একমত, তবে (একটি এবং বি) || (খ && গ) || (একটি এবং& সি) আপনার সমাধান আইএমএইচওর চেয়ে অনেক বেশি পঠনযোগ্য।
এড্রিয়ান গ্রিগোর

62
হুম, এখন আমার একটি "চারটি বুলিয়ানগুলির মধ্যে দুটি" সংস্করণ দরকার ... ড্যানটেলের সংস্করণ এখন অনেক সহজ।
আরাফাঙ্গিয়ন

6
অথবা Scala মধ্যে:Seq(true, true, false).map(if (_) 1 else 0).sum >= 2
retronym

5
@ রেট্রোনিয়াম: হুম, না জাভা উপায় স্কালায় ঠিকঠাক কাজ করে এবং আরও পাঠযোগ্য এবং আরও দক্ষ।
Seun Osewa

134
return (a==b) ? a : c;

ব্যাখ্যা:

যদি a==b, তবে উভয়ই সত্য বা উভয়ই মিথ্যা। যদি উভয়ই সত্য হয় তবে আমরা আমাদের দুটি সত্য বুলিয়ান খুঁজে পেয়েছি এবং সত্যে ফিরে আসতে পারি a। যদি উভয়ই মিথ্যা হয় তবে দুটি সত্য বুলিয়ানও সত্য না হলেও থাকতে cপারে, সুতরাং আমরা মিথ্যা (ফিরে আসার মাধ্যমে a) ফিরে আসি । এই (a==b) ? aঅংশ। কি হবে : c? ভাল যদি a==bমিথ্যা হয়, তবে ঠিক একটি aবা bঅবশ্যই সত্য হতে হবে, তাই আমরা প্রথম সত্য বুলিয়ান খুঁজে পেয়েছি, এবং কেবলমাত্র যদি বাকী থাকে cতবে এটি সত্য হয়, তাই আমরা cউত্তর হিসাবে ফিরে আসি।


8
সি এমনকি কখনও পরীক্ষিত হয় না ... উজ্জ্বল!
কার্টেনডগ

সাম্যতার ট্রানজিটিভ রিলেশন এবং বুলিয়ান সত্য বা মিথ্যা +1 ব্যবহার করে
ক্রিস্টোফ রাউসি

3
অনেক মার্জিত! এটি বিশ্বাস করার জন্য আমাকে কলম এবং কাগজ দিয়ে চেক করতে হয়েছিল :) আপনাকে স্যার!
অ্যাড্রিয়ান

3
আমি এটি সম্পর্কে "যদি মনে করি aএবং যদি bতারা একমত হয় তবে তাদের সংখ্যাগরিষ্ঠ ভোট রয়েছে, তাই এটি যাই হোক না কেন তা নিয়ে যান, অন্যথায় তারা একমত নন, cসিদ্ধান্ত গ্রহণকারী ভোটও"
বেন মিলউড

34

আপনাকে অপারেটরগুলির সংক্ষিপ্ত সার্কিট ফর্মগুলি ব্যবহার করার দরকার নেই।

return (a & b) | (b & c) | (c & a);

এটি আপনার সংস্করণ হিসাবে একই সংখ্যক যুক্তিযুক্ত অপারেশন সম্পাদন করে, তবে সম্পূর্ণ শাখাবিহীন।


11
1 যখন করতে পারে তখন কেন আপনি 5 মূল্যায়নকে বাধ্য করতে চান? সত্যই এটি একই সংখ্যক লজিক অপারেশন করে না। আসলে, এটি সবসময় আরও বেশি পারফর্ম করে।
মার্ক পিটারস

2
আমি মনে করি বাইনারি পাটিগণিত এবং বুলিয়ান পাটিগণিত মিশ্রণ একটি খারাপ ধারণা। এটি একটি রেঞ্চ সঙ্গে প্রাচীর স্ক্রু ড্রাইভিং মত। সব থেকে খারাপ এটি বিভিন্ন শব্দার্থক আছে।
পিটার টিলেম্যানস

12
@ মার্ক - এটি দ্রুত হতে পারে ... সিপিইউ পাইপলাইনে একটি ভুল শাখার পূর্বাভাসের প্রভাবের উপর নির্ভর করে। তবে এ জাতীয় মাইক্রো-অপ্টিমাইজেশন জেআইটি সংকলককে রেখে দেওয়া ভাল।
স্টিফেন সি

4
জাভাতে (বা অন্য কোনও ভাষা) এই জাতীয় কিছু করা ভাল ... কয়েকটা সতর্কতার সাথে: 1) এটি দ্রুত হওয়া দরকার (এই ক্ষেত্রে, আমি বিশ্বাস করি এটি আমার দ্বিতীয় উত্তর দেখুন) 2) ভাল উল্লেখযোগ্যভাবে দ্রুত (এটি কিনা তা নিশ্চিত নয়), 3) এটি "বিজোড়" হওয়ার কারণে সবচেয়ে গুরুত্বপূর্ণভাবে ডকুমেন্টেড। যতক্ষণ না এটি কোনও উদ্দেশ্যে কাজ করে এবং এটি নথিভুক্ত হয় ততক্ষণে এটি "বিধিগুলি ভঙ্গ করা" ঠিক হবে যখন তা বোধগম্য হয়।
তোফুবিয়ার

11
@ পিটার টিলেম্যানস বাইনারি অপারেটরগুলির সাথে কোনও মিশ্রণ নেই, জাভাতে এগুলি বুলিয়ান অপারেটর।
স্টার ব্লু

27

এখানে একটি পরীক্ষা চালিত, সাধারণ পদ্ধতি। এখনও অবধি প্রস্তাবিত বেশিরভাগ সমাধানের মতো "দক্ষ" নয়, তবে পরিষ্কার, পরীক্ষিত, কর্মক্ষম এবং সাধারণীকরণ করা হয়েছে।

public class CountBooleansTest extends TestCase {
    public void testThreeFalse() throws Exception {
        assertFalse(atLeastTwoOutOfThree(false, false, false));
    }

    public void testThreeTrue() throws Exception {
        assertTrue(atLeastTwoOutOfThree(true, true, true));
    }

    public void testOnes() throws Exception {
        assertFalse(atLeastTwoOutOfThree(true, false, false));
        assertFalse(atLeastTwoOutOfThree(false, true, false));
        assertFalse(atLeastTwoOutOfThree(false, false, true));
    }

    public void testTwos() throws Exception {
        assertTrue(atLeastTwoOutOfThree(false, true, true));
        assertTrue(atLeastTwoOutOfThree(true, false, true));
        assertTrue(atLeastTwoOutOfThree(true, true, false));
    }

    private static boolean atLeastTwoOutOfThree(boolean b, boolean c, boolean d) {
        return countBooleans(b, c, d) >= 2;
    }

    private static int countBooleans(boolean... bs) {
        int count = 0;
        for (boolean b : bs)
            if (b)
                count++;
        return count;
    }
}

8
বাহ, আমি এটিকে দেখার আগে কখনও সম্পূর্ণ পরীক্ষিত পদ্ধতি দেখিনি।
রোটসর

51
আমি ব্যক্তিগতভাবে এই কোডটিকে ভয়াবহ মনে করি, অনেক কারণে। আমি ডাউনটাতে যাচ্ছি না, তবে আমি যদি কখনও প্রোডাকশন কোডে এটি দেখে থাকি তবে আমি অভিশাপ দেব। একটি অত্যন্ত সাধারণ বুলিয়ান অপারেশনটির মতো জটিল হওয়ার দরকার নেই।
ক্যাপ্টেনকেসি

10
আমি আপনার কারণগুলি জানতে খুব আগ্রহী হব, @ ক্যাপিটেনসি। আমি মনে করি এটি বেশ ভাল কোড। এখানে একটি দুর্দান্ত জেনারালাইজড ফাংশন রয়েছে যা বোঝা সহজ, যাচাই করা সহজ এবং একটি নির্দিষ্ট ফাংশন যা এর সুবিধা নেয়, তা বোঝা ও যাচাই করা সহজ। আসল বিশ্বে, আমি এগুলি জনসাধারণের কাছে তুলে ধরতাম এবং এগুলিকে অন্য শ্রেণিতে রাখতাম; তা ছাড়া অন্য - আমি আনন্দের সাথে এই কোডটি উত্পাদন করতে চাই। ওহ - হ্যাঁ - আমি countBooleans () এর নাম পরিবর্তন করে countTrue () করব।
কার্ল ম্যানাস্টার

5
যদি এটি কর্মক্ষমতা সম্পর্কে না হয় তবে এই সমাধানটি আমার জন্য প্রায় নিখুঁত দেখাচ্ছে: পড়তে খুব সহজ এবং প্রসারণযোগ্য। ঠিক কী ভার-আরোগুলি তৈরি করা হয়।
atamanroman

7
মানুষ কী? এটি পরিষ্কার এবং ভালভাবে পরীক্ষা করা কোড এবং এটি দেখতে অনেকগুলি দেখতে একমাত্র কারণ এটিতে পরীক্ষাগুলি অন্তর্ভুক্ত রয়েছে। A +++, আবার উপবিষ্ট হবে।
ক্রিস্টোফার হামারস্ট্রিম

24

সব যোগ করে ফেল. একে কারণ হিসাবে বুলিয়ান বীজগণিত বলা হয়:

  0 x 0 = 0
  1 x 0 = 0
  1 x 1 = 1

  0 + 0 = 0
  1 + 0 = 1
  1 + 1 = 0 (+ carry)

আপনি যদি সেখানে সত্যের টেবিলগুলিতে লক্ষ্য করেন তবে দেখতে পাবেন যে গুণটি বুলিয়ান এবং এবং কেবল সংযোজনটি হয় জোর।

আপনার প্রশ্নের উত্তর দিতে:

return (a + b + c) >= 2

2
এটি আমার মতে এটি সবচেয়ে মার্জিত সমাধান।
Torbjørn ক্রিস্টফারসন

9
রুকি ভুল হলেও, একটি বুলিয়ান মান 0 হয় না, এর অর্থ এটি সর্বদা 1।
tomdemuyt

13
পোস্টের ট্যাগটি বাদে "জাভা" বলে, এবং যখন আপনি জাভাতে বুলিয়ান হিসাবে সংজ্ঞায়িত হন আপনি "a + b + c" লিখতে পারবেন না।
জে

জাভাতে কাজ করার জন্য এটি হতে হবে return ((a?1:0) + (b?1:0) + (c?1:0)) >= 2
ডেভিড আর ট্রিবিলে

দুহ, আমি এটিকে ভোট দিয়েছি কারণ আমি ভেবেছিলাম এটি একটি সি ++ প্রশ্ন ... কেন আমি জাভা প্রশ্নগুলি পড়ছি? : /
কার্লো উড


15

এটি "উন্নত" দ্বারা আপনি কী বোঝাতে চেয়েছেন তা সত্যই নির্ভর করে:

পরিস্কার?

boolean twoOrMoreAreTrue(boolean a, boolean b, boolean c)
{
    return (a && b) || (a && c) || (b && c);
}

Terser?

boolean moreThanTwo(boolean a, boolean b, boolean c)
{
    return a == b ? a : c;
}

আরও সাধারণ?

boolean moreThanXTrue(int x, boolean[] bs)
{
    int count = 0;

    for(boolean b : bs)
    {
        count += b ? 1 : 0;

        if(count > x) return true;
    }

    return false;
}

আরও পরিমাপযোগ্য?

boolean moreThanXTrue(int x, boolean[] bs)
{
    int count = 0;

    for(int i < 0; i < bs.length; i++)
    {
        count += bs[i] ? 1 : 0;

        if(count > x) return true;

        int needed = x - count;
        int remaining = bs.length - i;

        if(needed >= remaining) return false;
    }

    return false;
}

দ্রুত?

// Only profiling can answer this.

কোনটি "উন্নত" পরিস্থিতির উপর নির্ভর করে।


14

মানচিত্র / হ্রাস ব্যবহার করে এখানে আরও একটি বাস্তবায়ন। এই ভাল করার দাঁড়িপাল্লা Booleans বিলিয়ান © বন্টিত পরিবেশে। মঙ্গোডিবি ব্যবহার:

একটি ডাটাবেস তৈরি করা হচ্ছে valuesবুলিয়ানগুলির :

db.values.insert({value: true});
db.values.insert({value: false});
db.values.insert({value: true});

মানচিত্র তৈরি করা, কার্যগুলি হ্রাস করুন:

সম্পাদনা : আমি কার্টেনডগের উত্তরটি পছন্দ করি জেনেরিক তালিকাগুলিতে মানচিত্র / কমিয়ে আনার বিষয়ে , সুতরাং এখানে একটি মানচিত্রের ফাংশন চলে যা একটি কলব্যাক নেয় যা একটি মান গণনা করা উচিত কিনা তা নির্ধারণ করে।

var mapper = function(shouldInclude) {
    return function() {
        emit(null, shouldInclude(this) ? 1 : 0);
    };
}

var reducer = function(key, values) {
    var sum = 0;
    for(var i = 0; i < values.length; i++) {
        sum += values[i];
    }
    return sum;
}

চলমান মানচিত্র / হ্রাস:

var result = db.values.mapReduce(mapper(isTrue), reducer).result;

containsMinimum(2, result); // true
containsMinimum(1, result); // false


function isTrue(object) {
    return object.value == true;
}

function containsMinimum(count, resultDoc) {
    var record = db[resultDoc].find().next();
    return record.value >= count;
}

@ আনুরাগ: আমি এম / আর যতটা ভালবাসি এবং গুগল সম্প্রতি এটিকে যে এক্সপোজার দিয়েছিল তা যতটা ভালবাসি (এটি এফপি থেকে সত্যিকারের এম / আর না হলেও), আমি আপনার উত্তরে বুলশকে ডাকব! রিয়েল-ওয়ার্ল্ড [টিএম] "স্টাফ" সম্পাদন করে বিলিয়ন এবং বিলিয়ন কোডের লাইন রয়েছে যেখানে মানচিত্রের একটি লাইন / ব্যবহার কমেনি reduce এর সাথে এই জাতীয় প্রশ্নের উত্তর দেওয়া কেউ আমার বইয়ে অবশ্যই পতাকাঙ্কিত করেছেন: "স্মার্ট বাজানোর চেষ্টা করছেন" । বেশিরভাগ সাক্ষাত্কারকারীর কথা না বলে আপনি তাদের বুলিশ চেষ্টা করছেন কিনা তা বলতে সক্ষম হবেন না বা না কারণ তারা তাদের ক্যারিয়ারে এম / আর ব্যবহার করে বাস্তবে কোনও প্রোগ্রাম লেখেনি wrote
SyntaxT3rr0r

2
@ সিনট্যাক্স - প্রত্যেকেই তাদের মতামতের অধিকারী। আমার উত্তর সমস্যাটি দেখার আরও একটি উপায়। অবশ্যই, এটি 3 বুলিয়ান মানগুলির জন্য অতিরঞ্জিত শোনায় তবে এর অর্থ এই নয় যে আমি এখানে স্মার্ট প্যান্ট হওয়ার চেষ্টা করছি। এটি সমস্যা সমাধানের একটি সাধারণ পন্থা যা প্রত্যেকে ব্যবহার করে - সমস্যাটিকে ছোট ছোট টুকরো টুকরো করে। এটি গাণিতিক আবেশন কীভাবে কাজ করে, সর্বাধিক পুনরাবৃত্ত অ্যালগরিদমগুলি কীভাবে কাজ করে এবং এইভাবে লোকেরা সাধারণভাবে সমস্যাগুলি সমাধান করে।
অনুরাগ

13

এখানে উত্তর (এখন অবধি):

public class X
{
    static boolean a(final boolean a, final boolean b, final boolean c)
    {
    return ((a && b) || (b && c) || (a && c));
    }

    static boolean b(final boolean a, final boolean b, final boolean c)
    {
    return a ? (b || c) : (b && c);
    }

    static boolean c(final boolean a, final boolean b, final boolean c)
    {
    return ((a & b) | (b & c) | (c & a));
    }

    static boolean d(final boolean a, final boolean b, final boolean c)
    {
    return ((a?1:0)+(b?1:0)+(c?1:0) >= 2);
    }
}

এবং ডিকম্পাইলার (জাভ্যাপ-সি এক্স> ফলাফল.txt) এর মাধ্যমে এগুলি চালাচ্ছেন:

Compiled from "X.java"
public class X extends java.lang.Object{
public X();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   return

static boolean a(boolean, boolean, boolean);
  Code:
   0:   iload_0
   1:   ifeq    8
   4:   iload_1
   5:   ifne    24
   8:   iload_1
   9:   ifeq    16
   12:  iload_2
   13:  ifne    24
   16:  iload_0
   17:  ifeq    28
   20:  iload_2
   21:  ifeq    28
   24:  iconst_1
   25:  goto    29
   28:  iconst_0
   29:  ireturn

static boolean b(boolean, boolean, boolean);
  Code:
   0:   iload_0
   1:   ifeq    20
   4:   iload_1
   5:   ifne    12
   8:   iload_2
   9:   ifeq    16
   12:  iconst_1
   13:  goto    33
   16:  iconst_0
   17:  goto    33
   20:  iload_1
   21:  ifeq    32
   24:  iload_2
   25:  ifeq    32
   28:  iconst_1
   29:  goto    33
   32:  iconst_0
   33:  ireturn

static boolean c(boolean, boolean, boolean);
  Code:
   0:   iload_0
   1:   iload_1
   2:   iand
   3:   iload_1
   4:   iload_2
   5:   iand
   6:   ior
   7:   iload_2
   8:   iload_0
   9:   iand
   10:  ior
   11:  ireturn

static boolean d(boolean, boolean, boolean);
  Code:
   0:   iload_0
   1:   ifeq    8
   4:   iconst_1
   5:   goto    9
   8:   iconst_0
   9:   iload_1
   10:  ifeq    17
   13:  iconst_1
   14:  goto    18
   17:  iconst_0
   18:  iadd
   19:  iload_2
   20:  ifeq    27
   23:  iconst_1
   24:  goto    28
   27:  iconst_0
   28:  iadd
   29:  iconst_2
   30:  if_icmplt   37
   33:  iconst_1
   34:  goto    38
   37:  iconst_0
   38:  ireturn
}

আপনি দেখতে পাচ্ছেন যে? :গুলি আপনার মূলটির ফিক্সড সংস্করণে কিছুটা ভাল better যেটি সবচেয়ে ভাল তা হ'ল যা পুরোপুরি শাখা প্রশস্ত করা এড়িয়ে যায়। এটি কম নির্দেশাবলীর দৃষ্টিকোণ থেকে ভাল (বেশিরভাগ ক্ষেত্রে) এবং সিপিইউর শাখার পূর্বাভাসের অংশগুলির জন্য ভাল, যেহেতু শাখার পূর্বাভাসে একটি ভুল অনুমান সিপিইউ স্টলিংয়ের কারণ হতে পারে।

আমি বলব যে সবচেয়ে দক্ষ একটাই সামগ্রিকভাবে চাঁদ থেকে নেওয়া। এটি গড়ে সর্বনিম্ন নির্দেশাবলী ব্যবহার করে এবং সিপিইউতে পাইপলাইন স্টলের সুযোগ হ্রাস করে।

100% নিশ্চিত হওয়ার জন্য আপনাকে প্রতিটি নির্দেশের জন্য ব্যয় (সিপিইউ চক্রের) সন্ধান করতে হবে, যা দুর্ভাগ্যক্রমে সহজেই সহজলভ্য নয় (হটস্পটের জন্য উত্সটি আপনাকে দেখতে হবে এবং তারপরে সেই সময়ের জন্য সিপিইউ বিক্রেতাদের স্পেকগুলি দেখতে হবে) প্রতিটি উত্পন্ন নির্দেশের জন্য নেওয়া)।

কোডটির রানটাইম বিশ্লেষণের জন্য রোটসারের আপডেট হওয়া উত্তরটি দেখুন।


5
আপনি কেবল বাইকোডের দিকে তাকিয়ে আছেন। আপনারা জানেন যে, জেআইটি বাইটকোডে শাখা সহ একটি সংস্করণ নেবে এবং এটিকে স্থানীয় কোডে শাখাবিহীন সংস্করণে রূপান্তরিত করবে। তবে কেউ ভাবেন যে বাইকোডে কম শাখা আরও ভাল হবে।
ডেভিড কনরাড

13

প্রত্যক্ষ কোডের আর একটি উদাহরণ:

int  n = 0;
if (a) n++;
if (b) n++;
if (c) n++;
return (n >= 2);

স্পষ্টতই এটি সর্বাধিক সংযুক্ত কোড নয়।

অভিযোজ্য বস্তু

এর আর একটি (সামান্য অনুকূলিতকরণ) সংস্করণ:

int  n = -2;
if (a) n++;
if (b) n++;
if (c) n++;
return (n >= 0);

এটি সামান্য দ্রুত চলতে পারে, ধরে নেওয়া ধরে যে 0 এর বিপরীতে তুলনা 2 এর তুলনায় তুলনায় দ্রুত (বা সম্ভবত কম) কোড ব্যবহার করবে।


+1 @ লোডমাস্টার, আমি দুঃখিত তবে আপনি ভুল! এটি এখানে সর্বাধিক সংক্ষিপ্ত উত্তর। (অর্থাত্ সংক্ষেপে এবং স্পষ্টভাবে প্রকাশিত);)
অ্যাশ


@ এম.মিম্পেন: কেবল শ্রেণীর বিষয়গুলির জন্য। আদিম ধরণের ( nউপরের মতো ) জন্য, যে কোনও শালীন সংকলক প্রতিটি ++অপারেশন একক সিপিইউ নির্দেশে সংকলন করবে , তা সে প্রাক বা পোস্ট হোক।
ডেভিড আর ট্রিবিলে

12

এটি করার আরেকটি উপায় তবে খুব ভাল উপায় নয়:

return (Boolean.valueOf(a).hashCode() + Boolean.valueOf(b).hashCode() + Boolean.valueOf(c).hashCode()) < 3705);

Booleanহ্যাশকোড মান সত্য এবং মিথ্যা তাই জন্য 1237 জন্য 1231 এ ঠিক করা হয়েছে সমানভাবে ব্যবহার করতে পারতেন<= 3699


1
বা (ক? 1: 0) + (খ? 1: 0) + (সি? 1: 0)> = 2
পিটার লরে

12

উন্নতির সবচেয়ে সুস্পষ্ট সেট হ'ল:

// There is no point in an else if you already returned.
boolean atLeastTwo(boolean a, boolean b, boolean c) {
    if ((a && b) || (b && c) || (a && c)) {
        return true;
    }
    return false;
}

এবং তারপর

// There is no point in an if(true) return true otherwise return false.
boolean atLeastTwo(boolean a, boolean b, boolean c) {
    return ((a && b) || (b && c) || (a && c));
}

তবে সেই উন্নতিগুলি সামান্যই।


10

আমি টার্নারি পছন্দ করি না ( return a ? (b || c) : (b && c);উপরের উত্তর থেকে) এবং আমি মনে করি না যে আমি এটির উল্লেখ কেউ দেখেছি। এটি এইভাবে লেখা হয়েছে:

boolean atLeastTwo(boolean a, boolean b, boolean c) {
    if (a) {
        return b||c;
    } 
    else {
        return b&&C;
    }

8

ইন Clojure :

(defn at-least [n & bools]
  (>= (count (filter true? bools)) n)

ব্যবহার:

(at-least 2 true false true)

2
+1 দুর্দান্ত জেনেরিক সংস্করণ লিসপ্সের শক্তি দেখায়। ধন্যবাদ,
dsmith

6

আমি মনে করি না আমি এই সমাধানটি এখনও দেখেছি:

boolean atLeast(int howMany, boolean[] boolValues) {
  // check params for valid values

  int counter = 0;
  for (boolean b : boolValues) {
    if (b) {
      counter++;

      if (counter == howMany) {
        return true;
      }
    }
  }
  return false;
}

এর সুবিধাটি হ'ল একবার আপনি যে সংখ্যাটি সন্ধান করছেন সেটিতে পৌঁছে গেলে এটি ভেঙে যায়। সুতরাং যদি এটি "এই 1,000,000 মানের মধ্যে কমপক্ষে 2 টি সত্য হয়" যেখানে প্রথম দুটি সত্যই সত্য, তবে এটি আরও কিছু "সাধারণ" সমাধানগুলির চেয়ে দ্রুততর হওয়া উচিত।


এটি সম্ভবত হওয়া উচিত: যদি (++ কাউন্টার == কিভাবে অনেক) বর্ধিতকরণের পরিবর্তে এবং তারপরে পৃথকভাবে চেক করা হয়।
জো এনোস

2
বা আরও ছোট: যদি (খ && & (++ কাউন্টার == কিভাবে অনেক))
জো এনোস

1
আমি এটি করতাম boolean ... boolValuesএটি কল করা সহজ, তবে তবুও একটি অ্যারে লাগে
স্টিফেন

আমি আমার জাভাতে আপ টু ডেট নই - জানি না যে এর অস্তিত্ব আছে। এক অদ্ভুত সিনট্যাক্সের মতো, তবে এটি দরকারী - একবারে একবারে আমি সি # (প্যারাম কীওয়ার্ড) এ এটি করব এবং এটি কলকে জিনিসগুলিকে আরও সুন্দর করে তুলবে। বা, আমি জাভা সম্পর্কে জানিনা, তবে নেট, অ্যারে এবং সমস্ত সংগ্রহগুলি আইয়ুনামেবল <T> প্রয়োগ করে, তাই আমি সম্ভবত জাভার সমতুল্য যা ব্যবহার করব তা ব্যবহার করব।
জো এনোস

কীভাবে এর পারফর্মেন্স তুলনা করে 2of3 উদাহরণের সাথে? ফিরে আসি? (খ || গ): (খ && গ);
আয়ান স্প্রোট

6

আমরা বুলগুলিকে পূর্ণসংখ্যায় রূপান্তর করতে পারি এবং এই সহজ চেকটি সম্পাদন করতে পারি:

(int(a) + int(b) + int(c)) >= 2

6

কোডটি কীভাবে উন্নত করা উচিত তা নির্দিষ্ট করা হয়নি, তাই কোডটি আরও মজাদার করে তৈরি করার চেষ্টা করব। এখানে আমার সমাধান:

boolean atLeastTwo(boolean t, boolean f, boolean True) {
    boolean False = True;
    if ((t || f) && (True || False)) 
        return "answer" != "42";
    if (t && f) 
        return !"France".contains("Paris");
    if (False == True) 
        return true == false;
    return Math.random() > 0.5;
}

যদি কেউ এই কোডটি কাজ করে কিনা তা ভেবে অবাক হয়, একই যুক্তিটি ব্যবহার করে এখানে একটি সরলীকরণ দেওয়া হয়েছে:

boolean atLeastTwo(boolean a, boolean b, boolean c) {
    if ((a || b) && (c)) 
        return true;
    if (a && b) 
        return true;
    if (true) 
        return false;
    // The last line is a red herring, as it will never be reached:
    return Math.random() > 0.5; 

}

এটি আরও নীচে সিদ্ধ করা যেতে পারে:

return ((a || b) && (c)) || (a && b);

তবে এখন আর মজার বিষয় নয়।


5
Function ReturnTrueIfTwoIsTrue(bool val1, val2, val3))
{
     return (System.Convert.ToInt16(val1) +
             System.Convert.ToInt16(val2) +
             System.Convert.ToInt16(val3)) > 1;
}

এটি করার অনেকগুলি উপায় ...


3
সি # এর মতো আরও দেখতে। এটি উত্তর হিসাবে যেমন উল্লেখ করা উচিত প্রশ্ন যেহেতু জাভা-লক্ষ্যযুক্ত :)
BalusC

5

এসি সমাধান।

int two(int a, int b, int c) {
  return !a + !b + !c < 2;
}

অথবা আপনি পছন্দ করতে পারেন:

int two(int a, int b, int c) {
  return !!a + !!b + !!c >= 2;
}

4
return 1 << $a << $b << $c >= 1 << 2;

এটি পোস্ট করার আগে সুভেগার উত্তরটি দেখেনি, প্রায় একই জিনিস।
কেভিন

এটি কি সত্যিই কাজ করে? আমি ধরে নিলাম এটি পিএইচপি, তবে এতে আমার অ্যাক্সেস নেই, তবে আমি আপনাকে কেবল জিজ্ঞাসা করব: $ এ 0 হলে কী হয়?
মার্ক এডগার

@ মার্ক এটি আসলে doesn't এ 0 হলে কার্যকর হয় না That এটি একটি তদারকি ছিল। যে ইশারা জন্য ধন্যবাদ। :)
কেভিন

4

বিভ্রান্তিকর এবং পড়তে সহজ নয় এমন সহজ উপায় (আইএমও):

// Three booleans, check if two or more are true

return ( a && ( b || c ) ) || ( b && c );

কার্যত, এটি একই। কৃত্রিমভাবে, প্রশ্ন চিহ্ন শর্তসাপেক্ষ অপারেটরের ব্যবহারে যারা বেআইনীভাবে পড়েন তাদের পক্ষে এটি পড়া সহজ করে তোলে। প্রশ্ন বা শর্তসাপেক্ষ শর্তসাপেক্ষ অপারেটরগুলি কীভাবে ব্যবহার করতে হয় এমন সংখ্যার তুলনায় আমি আরও লোকজন কীভাবে AND এবং অপারেটরগুলি ব্যবহার করতে জানি তা বাজি রাখতে আগ্রহী। মূল প্রশ্নটি একটি "উন্নত উত্তর" চেয়েছে .. স্বীকৃত উত্তরটি উত্তরটি সহজতর করে, তবে কী কী উন্নতি বিবেচনা করে তা একটি খুব আকর্ষণীয় প্রশ্ন উত্থাপন করে। আপনি সর্বজনীন পাঠযোগ্যতার জন্য বা সরলতার জন্য প্রোগ্রাম করেন? আমার কাছে, এটি গৃহীত উত্তরের চেয়ে উন্নতি :)
অ্যাবেলিটো

ব্যক্তিগত পছন্দ. আমার পক্ষে এই সমাধানের চেয়ে ক্লিনার ক্লিনারি অপারেটরটি বোঝার উপায় আরও সহজ।
নিকো

1
হ্যাঁ, আমি এই সমস্যাটি দেখেছি এবং ভাবছিলাম কেন অন্য কেউ এই সমাধানটির উল্লেখ করেনি। যদি আপনি বুপিয়ান বীজগণিত হিসাবে অপের যুক্তিটি লিখেন তবে আপনি A B + A C + B C পাবেন, যার পাঁচটি অপারেশন রয়েছে। সহযোগী সম্পত্তি দ্বারা, আপনি A * (B + C) + B C লিখতে পারেন , যার চারটি অপারেশন রয়েছে।
ভিভিয়ান নদী

এটি জ্যাকের জবাবের মতোই (জুন 19) (C && (A || B)) || (A && B)সবেমাত্র * পরিবর্তনশীল নামগুলি পরিবর্তন করেছে ...
ব্যবহারকারীর 85421

4

একটি আক্ষরিক ব্যাখ্যা সমস্ত প্রধান ভাষায় কাজ করবে:

return (a ? 1:0) + (b ? 1:0) + (c ? 1:0) >= 2;

তবে আমি সম্ভবত লোকদের পড়া সহজ করে তুলতে এবং তিনটিরও বেশি প্রসারিত করতে সক্ষম করেছিলাম - যা এমন কিছু প্রোগ্রামার দ্বারা ভুলে গেছে বলে মনে হয়:

boolean testBooleans(Array bools)
{
     int minTrue = ceil(bools.length * .5);
     int trueCount = 0;

     for(int i = 0; i < bools.length; i++)
     {
          if(bools[i])
          {
               trueCount++;
          }
     }
     return trueCount >= minTrue;
}

4

@ তোফু বিয়ার তোফুবিয়ারের দুর্দান্ত পোস্টের সংযোজন হিসাবে, @pdox পিডক্সের উত্তরটি বিবেচনা করুন:

static boolean five(final boolean a, final boolean b, final boolean c)
{
    return a == b ? a : c;
}

"জাভাপ-সি" দ্বারা প্রদত্ত হিসাবে এর বিচ্ছিন্ন সংস্করণটিও বিবেচনা করুন:

static boolean five(boolean, boolean, boolean);
  Code:
    0:    iload_0
    1:    iload_1
    2:    if_icmpne    9
    5:    iload_0
    6:    goto    10
    9:    iload_2
   10:    ireturn

পিডক্সের উত্তর আগের উত্তরগুলির তুলনায় কম বাইট কোডে সংকলন করে। এর কার্যকর করার সময় অন্যদের সাথে কীভাবে তুলনা করে?

one                5242 ms
two                6318 ms
three (moonshadow) 3806 ms
four               7192 ms
five  (pdox)       3650 ms

কমপক্ষে আমার কম্পিউটারে, পিডক্সের উত্তরটি @ মুনস্যাডো মুনশাদোর জবাবের চেয়ে সামান্য দ্রুত, পিডক্সের দ্রুততম সামগ্রিকভাবে তৈরি করেছে (আমার এইচপি / ইন্টেল ল্যাপটপে)।


3

রুবিতে:

[a, b, c].count { |x| x } >= 2

যা জাআরভিতে জেআরবিতে চালানো যেতে পারে। ;-)


3

তিনি সম্ভবত বিটওয়াইজ তুলনা অপারেটরগুলির মতো সংশ্লেষিত কিছু খুঁজছেন না (সাধারণত কনোলিউটেড নয় তবে বুলিয়ানদের সাথে, এটি বিটওয়াইস অপারেটরগুলি ব্যবহার করা অত্যন্ত বিজোড়) বা এমন কিছু যা আন্তঃরূপে রূপান্তরিত এবং সংমিশ্রণের মতো খুব চতুর্দিকে।

এটি সমাধানের সর্বাধিক প্রত্যক্ষ এবং প্রাকৃতিক উপায় হ'ল এর মত একটি অভিব্যক্তি সহ:

a ? (b || c): (b && c)

আপনি যদি চান তবে এটি কোনও ফাংশনে রাখুন তবে এটি খুব জটিল নয়। সমাধানটি যৌক্তিকভাবে সংক্ষিপ্ত এবং দক্ষ।


3

সি তে:

return !!a + !!b + !!c >= 2;

প্রকৃতপক্ষে, এই উত্তরটি ভুল ... এটি হওয়া উচিত> = 2, যেহেতু আপনার কমপক্ষে দুটি সত্য বুলিয়ান দরকার, ঠিক দুটি নয়।
পল ওয়াগল্যান্ড

@ পল ওয়াগল্যান্ড: ধরার জন্য ধন্যবাদ
ম্যাট যোগদানকারী

@ এরগোসিস: আমি কি দু'বার উত্তর দিয়েছি?
ম্যাট জেন্ডার
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.