4 / 3'ün Doğru olduğunu test etmek için mantık

TrueSadece 4 boolean değerden 3'ü doğruysa geri dönmek istiyorum .

Aldığım en yakın şey (x ^ y) ^ (a ^ b):

Ne yapmalıyım?

Kodu ne demek istediğinizi belirtecek şekilde yazmanızı öneririm. 3 değerin doğru olmasını istiyorsanız, 3 değerinin bir yerde göründüğü doğal görünüyor.

Örneğin C++:

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

Bu da tanımlanır C++: standard (§4.7/4)dönüştürme belirtir booliçinint beklenen değerler, 0 ya da 1 verir.

Java ve C # 'da, aşağıdaki yapıyı kullanabilirsiniz:

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

# 1: Dallanma kullanımı?: 3 veya 4 işlem

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

# 2 Dallanmayan, 7 işlem

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

Her şeyi profillemek için kullandığımda, CPU kod yolunu daha iyi tahmin edebildiğinden ve daha fazla işlemi birlikte çalıştırabildiğinden, dallanmayan çözümlerin işlem için biraz daha hızlı çalıştığını gördüm . Yine de buradaki dallanma ifadesinde yaklaşık% 50 daha az çalışma var.

Eğer bu Python olsaydı,

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

Veya

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

Veya

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

Veya

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

Veya

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

Veya

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

Veya

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

Tüm bu işler, Boolean'lar Python'da tamsayıların alt sınıfları olduğundan.

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

Veya bu temiz numaradan esinlenerek ,

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

Uzun ama çok basit, (saygısız) normal form:

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

Basitleştirilmiş olabilir ama bu daha fazla düşünmeyi gerektirir: P

Daha basit olduğundan emin değilim ama belki de.

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

Bu mantığı bir programlama dilinde kullanmak istiyorsanız, önerim

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

İsterseniz, bunların tümünü tek bir satıra koyabilirsiniz:

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

Ayrıca bu sorunu şu şekilde genelleştirebilirsiniz 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;
}

Bu cevap temsil sistemine bağlıdır, ancak 0 yanlış olarak yorumlanan tek değerse ve not(false)her zaman aynı sayısal değeri döndürüyorsa not(a) + not(b) + not(c) + not(d) = not(0), hile yapmalıdır.

SO'nun mantıklı problemlerden ziyade programlama soruları için olduğu takdirde, cevabın açıkça bir programlama dili seçimine bağlı olduğunu unutmayın. Bazı diller diğerlerine özgü olmayan özellikleri destekler.

Örneğin, C ++ ile koşullarınızı aşağıdakilerle test edebilirsiniz:

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

Bu, boole'den tamsayı türlerine otomatik (düşük düzeyli) dönüştürmeyi destekleyen dillerde check-in yapmanın en hızlı yolu olmalıdır. Fakat yine de, bu sorunun genel bir cevabı yoktur.

Yapabileceğim en iyi şey ((x ^ y) ^ (a ^ b)) && ((a || x) && (b || y))

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

Yumruk ifadesi true4'ten 1 veya 3'ü arar . İkincisi 0 veya 1'i (ve bazen 2) 4'ü ortadan kaldırır true.

Java 8, yanlış değerleri filtreleyin ve kalan gerçek değerleri sayın:

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

Sonra aşağıdaki gibi kullanabilirsiniz:

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

Öğelerin doğru nolup olmadığını kolayca kontrol eder m.

En azından nhepsinin Booleandoğru olduğunu kontrol etmek için , (n toplam sayıdan küçük veya ona eşit olmalıdır Boolean: p)

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

Düzenleme : @ Cruncher'ın yorumundan sonra

boolean4 üzerinden 3 kontrol etmek için

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

Bir diğeri :

((c & d) & (a ^ b)) | ((a & b) & (c ^ d))( Ayrıntılar )

İşte LINQ ile C # ile çözmenin bir yolu:

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

Simetrik Boole işlevi S₃(4) . Simetrik bir Boolean işlevi, yalnızca ayarlanan giriş miktarına bağlı olan, ancak hangi girdilere bağlı olmayan bir boolean işlevidir. Knuth, Bilgisayar Programlama Sanatı Cilt 4'teki 7.1.2 bölümünde bu tür işlevlerden bahseder.

S₃(4) aşağıdaki gibi 7 işlemle hesaplanabilir:

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

Bu normal operatörleri kullanarak en fazla 7 operasyonlarında bunu yapamaz yani optimum olduğunu Knuth gösterileri: &&, || , ^, <,ve> .

Ancak bunu 1doğru ve 0yanlış için kullanılan bir dilde kullanmak istiyorsanız, eklemeyi de kolayca kullanabilirsiniz:

x + y + a + b == 3

bu da niyetinizi oldukça netleştirir.

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

Saf mantık açısından baktığım şey buydu.

Güvercin deliği prensibi ile, eğer tam olarak 3 doğruysa, ya a ve b doğrudur ya da c ve d doğrudur. O zaman bu davaların her birini tam olarak diğerinden biriyle ilişkilendirme meselesi 2.

Wolfram doğruluk tablosu

Karnaugh Maps gibi bir mantık görselleştirme aracı kullanıyorsanız, bunun bir if (...) satırına yazmak istiyorsanız, tam gelişmiş bir mantık teriminden kaçınamayacağınız bir sorun olduğunu görürsünüz. Lopina zaten gösterdi, daha basit yazmak mümkün değil. Biraz dışarı katlayabilirsiniz, ancak sizin için VE makine için okumak zor kalacaktır.

Sayma çözümleri fena değil ve gerçekten neyin peşinde olduğunuzu gösteriyor. Sayımı nasıl verimli bir şekilde yapacağınız programlama dilinize bağlıdır. Python oder LinQ ile dizi çözümleri bakmak güzel, ama dikkat, bu YAVAŞ. Wolf'un (a + b + x + y) == 3 güzel ve hızlı çalışır, ancak yalnızca diliniz "true" 1 ile eşitse. "True" -1 ile temsil ediliyorsa, -3 için test etmeniz gerekir: )

Diliniz gerçek boolean kullanıyorsa, bunu açıkça programlamayı deneyebilirsiniz (I kullanıyorum! = XOR testi olarak):

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" yalnızca x, y bir boole tipindeyse çalışır. 0'ın yanlış olduğu ve diğer her şeyin doğru olduğu başka bir türlerse, bu başarısız olabilir. Ardından, bir boole XOR veya ((bool) x! = (Bool) y) kullanın veya "x (return) (y == false) else return (y == true);" bilgisayar için çalışmak.

Programlama diliniz üçlü?: Operatörünü sağlıyorsa, dili kısaltabilirsiniz.

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

biraz okunabilirlik sağlar veya agresif bir şekilde keser.

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

Bu kod tam olarak üç mantık testi (a durumu, b durumu, x ve y karşılaştırması) yapar ve buradaki diğer cevapların çoğundan daha hızlı olmalıdır. Ama yorum yapmanız gerekiyor, ya da 3 ay sonra anlamayacaksınız :)

Burada birçok iyi cevap var; İşte henüz kimsenin göndermediği alternatif bir formülasyon:

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

İlk cevaba benzer, ancak saf Java:

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

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

Daha okunabilir kod için yapar çünkü onları tamsayı olarak saymayı tercih ederim.

In Python , elemanların bir iterable kaç tanesinin için vardır Doğru, kullanım sum(oldukça basittir):

Kurmak

import itertools

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

Gerçek Test

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

Çıktı

(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

Kağıt üzerinde (programlama dışı) çözümün peşindeyseniz, K-haritaları ve Quine-McCluskey algoritmaları peşindeyseniz, boolean işlevinizi en aza indirmenize yardımcı olurlar.

Sizin durumunuzda, sonuç

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

Bunu programlı olarak yapmak istiyorsanız, sabit olmayan değişken miktarı ve özel bir "eşik", o zaman basitçe bir boole değerleri listesi yinelemek ve "true" oluşumlarını saymak oldukça basit ve basittir.

Yalnızca 4 boole değerinden 3'ü doğruysa true döndürmek istiyorum.

A, b, x, y olmak üzere 4 boole değeri verildiğinde, bu görev aşağıdaki C ifadesine dönüşür:

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

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

istediğin şey bu. Temelde kodunuzu aldı ve aslında 3 doğru ve 3 yanlış olup olmadığını kontrol ekledi.

Cevap içermeyen bir programlama sorusu özyineleme? Düşünülemez!

Yeterli "4 gerçekte tam 3" yanıtı var, ancak burada "tam olarak n gerçek dışı m" için genelleştirilmiş (Java) bir sürüm (aksi takdirde özyineleme gerçekten buna değmez):

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

Bu, şöyle bir şeyle çağrılabilir:

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

geri dönmelidir true(çünkü 8 değerden 5'i beklendiği gibi doğrudur). "True" ve "false" kelimelerinden pek memnun değil, ama şu anda daha iyi bir isim düşünemiyorum .... Çok fazla true veya çok fazla falsedeğer bulunduğunda özyinelemenin durduğunu unutmayın .

Okunabilirlik büyük bir endişe kaynağı olduğundan, açıklayıcı bir işlev çağrısı kullanabilirsiniz (önerilen uygulamalardan herhangi birini sarma). Bu hesaplamanın birden fazla yerde yapılması gerekiyorsa, işlev çağrısı yeniden kullanımın en iyi yoludur ve tam olarak ne yaptığınızı netleştirir.

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

PHP'de, onu daha dinamik hale getirme (koşul sayısını değiştirmeniz durumunda vb.):

$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)))

Bunun iyi bir çözüm olduğunu gösterebilirken, Sam Hocevar'ın cevabını daha sonra yazmak ve anlamak kolaydır. Kitabımda bu daha iyi.

İşte bana ilham verdiğiniz için yazdığım bazı c # kodu:

Herhangi bir miktarda argüman alır ve size n doğru olup olmadığını söyler.

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

ve şöyle diyorsunuz:

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

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

Böylece 7/9 veya 15/100'ü istediğiniz gibi test edebilirsiniz.