Question

在这个任务中你应该实现一些布尔操作：


“连词”表示x∧y，如果x = y = 1则满足x∧y= 1，否则x∧y= 0。

“disjunction”表示x∨y，如果x = y = 0则满足x∨y= 0，否则x∨y= 1。

“暗示”（材料暗示）表示为x→y，并且可以描述为¬x∨y。如果x为真，则x→y的值取y的值。但如果x为假，那么y的值可以忽略;但是操作必须返回一些真值，并且只有两个选择，所以返回值是那个需要更少的值，即true。

“不包括”（异或）表示为x⊕y，并且可以描述为（x∨y）∧¬（x∧y）。它排除了x和y的可能性。根据算术定义它是加法mod 2，其中1 + 1 = 0。

“等价”表示为x≡y并且可以描述为¬（x⊕y）。只有当x和y具有相同的值时才是真的。


您可以在此处查看这些操作的真值表：
    x | y | x∧y | x∨y | x→y | x⊕y | x≡y |
    --------------------------------------
    0 | 0 |  0  |  0  |  1  |  0  |  1  |
    1 | 0 |  0  |  1  |  0  |  1  |  0  |
    0 | 1 |  0  |  1  |  1  |  1  |  0  |
    1 | 1 |  1  |  1  |  1  |  0  |  1  |
    --------------------------------------
您将获得两个布尔值x和y作为1或0，并且您将获得一个操作名称，如前所述。您应该计算该值并将其返回为1或0.

到目前为止，这是我的代码：

OPERATION_NAMES = ("conjunction", "disjunction", "implication", "exclusive", "equivalence")

def boolean(x, y, operation):
if (x and y) == 0:
    return 0
elif (x or y) == 1:
    return 1 



if __name__ == '__main__':
    #These "asserts" using only for self-checking and not necessary for auto-testing
    assert boolean(1, 0, u"conjunction") == 0, "and"
    assert boolean(1, 0, u"disjunction") == 1, "or"
    assert boolean(1, 1, u"implication") == 1, "material"
    assert boolean(0, 1, u"exclusive") == 1, "xor"
    assert boolean(0, 1, u"equivalence") == 0, "same?"

第一个if是否正常工作我在完成拆分和其他操作时遇到了问题！some1能帮助我吗？

Answer 1

创建从名称到操作的字典映射。使用按位操作，因为操作数是整数值1和0：

ops = {
    'conjunction': lambda a, b: a & b,
    'disjunction': lambda a, b: a | b,
    # ... etc.
}
def boolean(a, b, operation):
    return ops[operation](a, b)

operator module也可以处理连接，析取和排他操作。等价只是平等，所以operator.eq可以处理：

import operator

ops = {
    'conjunction': operator.and_,
    'disjunction': operator.or_,
    'exclusive': operator.xor,
    'equivalence': operator.eq,
}

这使您不得不自己实施implication。但是，该文本已经为您提供了方便的实施指南：

可以描述为¬x∨y

所以lambda将是：

lambda a, b: (1 - a) | b

使用1 - a模拟NOT。

完整的解决方案：

import operator

ops = {
    'conjunction': operator.and_,
    'disjunction': operator.or_,
    'implication': lambda a, b: (1 - a) | b,
    'exclusive': operator.xor,
    'equivalence': operator.eq,
}
def boolean(a, b, operation):
    return ops[operation](a, b)

Answer 2

OPERATION_NAMES = ("conjunction", "disjunction", "implication", "exclusive", "equivalence")
import operator
ops = {
   'conjunction': lambda x, y: x & y,
   'disjunction': lambda x, y: x | y,
   'implication': lambda x, y: (1 - x) | y,
   'exclusive': operator.xor,
   'equivalence': operator.eq,
}
def boolean(x, y, operation):
return ops[operation](x, y)



if __name__ == '__main__':
#These "asserts" using only for self-checking and not necessary for auto-testing
assert boolean(1, 0, u"conjunction") == 0, "and"
assert boolean(1, 0, u"disjunction") == 1, "or"
assert boolean(1, 1, u"implication") == 1, "material"
assert boolean(0, 1, u"exclusive") == 1, "xor"
assert boolean(0, 1, u"equivalence") == 0, "same?"

这是此

的有效解决方案

Python操作

2 个答案: