ตรรกะในการทดสอบว่า 3 จาก 4 เป็นจริง

ฉันต้องการกลับTrueถ้าหากค่าบูลีน 3 ใน 4 เป็นจริง

สิ่งที่ฉันได้ใกล้เคียงที่สุดคือ(x ^ y) ^ (a ^ b):

ฉันควรทำอย่างไรดี?

ฉันขอแนะนำให้เขียนรหัสในลักษณะที่บ่งบอกความหมายของคุณ หากคุณต้องการให้ค่า 3 เป็นจริงดูเหมือนว่าเป็นเรื่องธรรมดาสำหรับฉันที่ค่า 3 จะปรากฏที่ใดที่หนึ่ง

ตัวอย่างเช่นในC++:

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

สิ่งนี้ถูกนิยามไว้อย่างดีในC++: การstandard (§4.7/4)บ่งชี้ว่าการแปลงboolเพื่อintให้ค่าที่คาดหวังเป็น 0 หรือ 1

ใน Java และ C # คุณสามารถใช้โครงสร้างต่อไปนี้:

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

# 1: ใช้การแบรนช์?: 3 หรือ 4 การทำงาน

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

# 2 Non-Branching, 7 การดำเนินงาน

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

ย้อนกลับไปเมื่อฉันใช้โพรไฟล์ทุกอย่างฉันพบว่าโซลูชันที่ไม่ได้แตกกิ่งค่อนข้างเร็วกว่าสำหรับการดำเนินการเนื่องจาก CPU สามารถทำนายเส้นทางของรหัสได้ดีขึ้นและดำเนินการเพิ่มเติมควบคู่ มีงานลดลงประมาณ 50% ในคำสั่งการแยกสาขาที่นี่

ถ้านี่เป็น Python ฉันก็คงจะเขียน

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:

งานทั้งหมดนี้เนื่องจาก Booleans เป็นคลาสย่อยของจำนวนเต็มใน Python

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

หรือแรงบันดาลใจจากนี้เคล็ดลับเรียบร้อย ,

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

รูปแบบปกติที่ยาว แต่ง่ายมาก (ไม่น่ารังเกียจ):

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

อาจลดความซับซ้อนลง แต่ต้องใช้การคิดเพิ่มเติม: หน้า

ไม่แน่ใจว่ามันง่ายกว่า แต่อาจเป็น

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

หากคุณต้องการใช้ตรรกะนี้ในภาษาการเขียนโปรแกรมคำแนะนำของฉันคือ

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;
}

คำตอบนี้ขึ้นอยู่กับระบบการเป็นตัวแทน แต่ถ้า 0 เป็นค่าเดียวที่ตีความว่าเป็นเท็จและnot(false)จะส่งกลับค่าตัวเลขเดียวกันเสมอดังนั้นnot(a) + not(b) + not(c) + not(d) = not(0)ควรทำเคล็ดลับ

โปรดทราบว่าดังนั้นหากคำถามการเขียนโปรแกรมไม่ใช่ปัญหาเชิงตรรกะเพียงอย่างเดียวคำตอบนั้นขึ้นอยู่กับการเลือกภาษาการเขียนโปรแกรม บางภาษารองรับคุณสมบัติที่ผิดปกติกับผู้อื่น

ตัวอย่างเช่นใน C ++ คุณสามารถทดสอบเงื่อนไขของคุณด้วย:

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

นี่เป็นวิธีที่เร็วที่สุดในการตรวจสอบภาษาที่รองรับการแปลงอัตโนมัติ (ระดับต่ำ) จากบูลีนเป็นประเภทจำนวนเต็ม แต่อีกครั้งไม่มีคำตอบทั่วไปสำหรับปัญหานั้น

สิ่งที่ดีที่สุดที่ฉันทำได้คือ ((x ^ y) ^ (a ^ b)) && ((a || x) && (b || y))

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

นิพจน์กำปั้นค้นหา 1 หรือ 3 trueจาก 4 อันที่สองกำจัด 0 หรือ 1 (และบางครั้ง 2) trueออกจาก 4

Java 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!");
}

ได้อย่างง่ายดาย generalizes เพื่อตรวจสอบสำหรับnของmรายการที่เป็นจริง

ในการตรวจสอบอย่างน้อยก็nให้Booleanเป็นจริง (n ต้องน้อยกว่าหรือเท่ากับจำนวนทั้งหมดBoolean: p)

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

แก้ไข : หลังจากความคิดเห็น @ Cruncher

วิธีตรวจสอบ 3 booleanจาก 4

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))( รายละเอียด )

นี่คือวิธีที่คุณสามารถแก้ไขได้ใน C # ด้วย LINQ:

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

นั่นคือฟังก์ชันบูลีนสมมาตร S₃(4)นั่นคือฟังก์ชั่นบูลีสมมาตรฟังก์ชั่นสมมาตรบูลีนเป็นฟังก์ชั่นบูลีนซึ่งขึ้นอยู่กับปริมาณของการตั้งค่าอินพุตเท่านั้น Knuth กล่าวถึงฟังก์ชั่นประเภทนี้ในหัวข้อ 7.1.2 ในเล่ม 4 ของศิลปะการเขียนโปรแกรมคอมพิวเตอร์

S₃(4) สามารถคำนวณได้ 7 การดำเนินการดังนี้:

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

Knuth แสดงให้เห็นว่าสิ่งนี้ดีที่สุดซึ่งหมายความว่าคุณไม่สามารถทำได้ในการปฏิบัติการน้อยกว่า 7 ครั้งโดยใช้ตัวดำเนินการปกติ: &&, || , ^, <,และ>และ

อย่างไรก็ตามหากคุณต้องการใช้สิ่งนี้ในภาษาที่ใช้1สำหรับจริงและ0เท็จคุณยังสามารถใช้การเพิ่มได้อย่างง่ายดาย:

x + y + a + b == 3

ซึ่งทำให้ความตั้งใจของคุณค่อนข้างชัดเจน

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

จากมุมมองตรรกะที่บริสุทธิ์นี่คือสิ่งที่ฉันคิดขึ้นมา

โดยหลักการของนกพิราบหากว่า 3 เป็นจริงจริงแล้วทั้ง a และ b เป็นจริงหรือ c และ d เป็นจริง ถ้าอย่างนั้นมันก็เป็นเรื่องของ anding แต่ละกรณีด้วยอีกหนึ่งในสอง

ตารางความจริงวุลแฟรม

หากคุณใช้เครื่องมือสร้างภาพเชิงตรรกะเช่นแผนที่ Karnaugh คุณจะเห็นว่านี่เป็นปัญหาที่คุณไม่สามารถหลีกเลี่ยงคำศัพท์ตรรกะแบบเต็มถ้าคุณต้องการที่จะเขียนในหนึ่งถ้า (... ) บรรทัด Lopina แสดงให้เห็นแล้วมันเป็นไปไม่ได้ที่จะเขียนมันง่ายขึ้น คุณสามารถแยกออกเล็กน้อย แต่มันจะยากที่จะอ่านสำหรับคุณและสำหรับเครื่อง

การแก้ปัญหาการนับไม่เลวและพวกเขาแสดงสิ่งที่คุณเป็นจริง วิธีการนับอย่างมีประสิทธิภาพขึ้นอยู่กับภาษาการเขียนโปรแกรมของคุณ โซลูชันอาเรย์ที่มี Python หรือ LinQ น่าใช้ดู แต่ระวังนี่คือช้า Wolf's (a + b + x + y) == 3 จะทำงานได้อย่างดีและรวดเร็ว แต่เฉพาะในกรณีที่ภาษาของคุณเท่ากับ "จริง" กับ 1 หาก "true" แทนด้วย -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 เป็นเท็จและทุกอย่างเป็นจริงสิ่งนี้อาจล้มเหลว จากนั้นใช้บูลีนแฮคเกอร์หรือ ((บูล) x! = (บูล) y) หรือเขียนว่า "if (x) return (y == false) อื่นกลับ (y == จริง);" ซึ่งเป็นอีกเล็กน้อย ทำงานกับคอมพิวเตอร์

หากภาษาการเขียนโปรแกรมของคุณมีผู้ประกอบการที่สาม?: คุณสามารถย่อให้สั้นลงได้

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 เดือน :)

มีคำตอบที่ดีมากมายที่นี่; นี่คือสูตรทางเลือกที่ยังไม่มีใครโพสต์:

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

คล้ายกับคำตอบแรก แต่จาวาบริสุทธิ์:

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

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

ฉันชอบนับพวกมันเป็นจำนวนเต็มเพราะมันจะทำให้อ่านง่ายขึ้น

ในPythonเพื่อดูว่าอิลิเมนต์ที่ทำซ้ำได้หลายรายการเป็น True ให้ใช้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

หากคุณอยู่หลังการแก้ปัญหาบนกระดาษ (ไม่ใช่การเขียนโปรแกรม) แล้ว K-maps และอัลกอริทึม Quine-McCluskey เป็นสิ่งที่คุณหลังจากที่พวกเขาช่วยให้คุณลดฟังก์ชั่นบูลีนของคุณ

ในกรณีของคุณผลที่ได้คือ

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

หากคุณต้องการทำสิ่งนี้โดยทางโปรแกรมจำนวนตัวแปรที่ไม่แน่นอนและ "เกณฑ์" ที่กำหนดเองจากนั้นเพียงแค่ทำซ้ำผ่านรายการของค่าบูลีนและการนับเหตุการณ์ที่เกิดขึ้นของ "ความจริง" นั้นค่อนข้างเรียบง่ายและตรงไปตรงมา

ฉันต้องการกลับจริงถ้าหากค่าบูลีน 3 ใน 4 เป็นจริง

รับค่าบูลีน 4 ค่า a, b, x, y งานนี้แปลเป็นคำสั่ง C ต่อไปนี้:

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

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

คือสิ่งที่คุณต้องการ โดยทั่วไปฉันใช้รหัสของคุณและเพิ่มการตรวจสอบว่า 3 จริงหรือไม่จริงไม่ใช่ 3

คำถามการเขียนโปรแกรมโดยไม่มีคำตอบที่เกี่ยวข้องกับการสอบถามซ้ำ? ไม่น่าเชื่อ!

มีคำตอบ "3 จาก 4 trues" เพียงพอ แต่นี่เป็นรุ่นทั่วไป (Java) สำหรับ "คำว่า m out of trues" (มิฉะนั้นการเรียกซ้ำไม่คุ้มค่าจริงๆ) เพียงเพราะคุณสามารถ:

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

เนื่องจากความสามารถในการอ่านเป็นเรื่องใหญ่คุณจึงสามารถใช้การเรียกฟังก์ชันที่มีความหมาย (ล้อมการปรับใช้ใด ๆ ที่แนะนำ) หากการคำนวณนี้จำเป็นต้องทำในหลาย ๆ ที่การเรียกใช้ฟังก์ชันเป็นวิธีที่ดีที่สุดในการนำมาใช้ซ้ำและทำให้ชัดเจนว่าคุณกำลังทำอะไรอยู่

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

ใน 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";

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

ในขณะที่ฉันสามารถแสดงให้เห็นว่านี่เป็นทางออกที่ดีคำตอบของ Sam Hocevar นั้นง่ายทั้งการเขียนและทำความเข้าใจในภายหลัง ในหนังสือของฉันที่ทำให้ดีขึ้น

นี่คือรหัส 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 ตามที่คุณต้องการ