булевая логика

(val || mask) == mask ступил, на 0 надо ещё проверить

https://tproger.ru/articles/awesome-bits/

Но вообще моветон такое делать. ТС, а как у тебя сам флаг организован? Каждая цифра отвечает за какое-то независимое состояние и тебе грубо говоря надо проверять состояние некоторых разрядов в двоичной записи или там что-то более хитрое и тебе надо проверять заданные комбинации?

если я правильно понял табличку, то сначала ИЛИ по валидным флагам, если на выходе 1, то ИЛИ по невалидным, если 0, то ок

то ИЛИ по невалидным, если 0

Наверное, все же И имелось в виду?

Почему И? Вроде как если ни один из невалидных флагов не установлен, то pass.

X | Y != 0 <=> X != 0 || Y != 0

Так как Y – невалидные флаги, то Y != 0, следовательно с ИЛИ 0 не получится никогда.

Мы о разном. Я не про ИЛИ с маской из единиц, а про ИЛИ валидных/невалидных бит с маской из нулей )

ЯННП, по какому принципу у тебя 01010 | 00010 — это pass, а 11010 | 01010 — это not valid?

Почему это тру 01010 | 00010 | pass

а это уже не тру?11010 | 01010 | not valid

У тебя условия задачи противоречивые.

проще предположить ошибку и поменять местами, чем допустить такое условие )

Ну, если поменять, то тогда мой ответ подходит:

val >= mask && val & mask

есть значение, куда набиваются флаги
11010

к примеру
1000 status1
0010 status2
10000 error

и такой результат возвращает функция 11010
мне нужно проверять, есть ли в наборе status1 или status2 или они оба
если нет ни одного из status1, status2 - значит ошибка
но если в наборе есть что-то еще кроме status1, status2 - значит ошибка и неважно какая

потому что содержит 10000 что не входит в 01010

А почему тогда

11010 | 01010 | not valid

В наборе - статусы и ничего кроме них.

01010 содержит 01000, что не входит в 00010. Почему там pass?

Внимание. Правильный ответ.

If(val==0) ; // not valid

Else if(val & (~mask))

; // Not valid

Else ; // valid

Если статусы фиксированные и надо только их смотреть, без выделения отдельного смысла, то я бы как-то так делал:

enum States{
    State1 = 0x0001,
    State2 = 0x0010,
    State3 = 0x0101
};
if (value == State2){
//какой-то там код
}

ЗЫ

Вроде понял что ты хочешь глядя на другие комментарии, тебе надо проверить корректность по маске, сейчас напишу лучше.

Первая колонка это состояние, а вторая - маска? Или опять неверно?

ЗЫ

Таблицу истинности напиши, я не понимаю что у тебя в данных, они противоречивые

Погоди, не понял. Тебе достаточно проверять что второе число меньше первого что-ли? Или я ННП

что такое
«нужно проверить на совпадение одного или нескольких флагов»
совпадение с чем флагов вообще?

У вас в слове есть две группы битов - биты статуса и биты ошибки. Для pass нужно чтобы хотя бы один бит статуса был «1» и не было ни одного бита ошибки в «1». Так? Если нет - попробуйте объяснить словами. Если да , то вам уже предложили кучу способов

обновил пример
грубо говоря колонки местами нужно поменять
истинно когда:
- хоть один флаг совпал
- нет лишних флагов установленно

вижу что намудрено
я уже от булевой отказался, но итересно как с булевой решить)

А так:

res = 
(
      (data & flag) /* есть пересечения */
      && /* и */
      (
        !(data ^ flag) /* полное совпадение (xor == 0) */
        || /* или */
        ((data ^ flag) & flag) /* бит выпал из флага, а не из данных */
       )
)

#include <stdio.h>

int main()
{
    unsigned char d[] = {0b01010,0b01000,0b00010,0b00100,0b01011,0b00000,0b11010};
    unsigned char f[] = {0b01010,0b01010,0b01010,0b01010,0b01010,0b01010,0b01010};
    for(int i = 0; i < 7; i++)
    {
	printf("res: %d\n", (d[i] & f[i]) && (!(d[i] ^ f[i]) || (d[i] ^ f[i]) & f[i]));
    }
return 0;
}

? )

булевая логика (комментарий)

Тогда так (ну почти так). Понимается тем что ты пишешь таблицу истинности вида (второй столбец у тебя я считаю за значение, а первый за маску, иначе другая операция будет, а вот в табличке уже наоборот записано, я раньше написал её просто):

0|0|+
0|1|-
1|0|+
1|1|+

файл mask.py

def check_mask(mask, value):
    if int(mask, 2) == 0:
        print('not valid')
        return False
    if int(int(value, 2) | (~ int(mask, 2))) == -1:
        print('pass')
        return True
    else:
        print('not valid')
        return False


if __name__ == '__main__':
    check_mask('0b01010', '0b01010')

import unittest
from mask import *


class TestMask(unittest.TestCase):
    def test_check_mask(self):
        actual = check_mask('0b01010', '0b01010')
        expected = True
        self.assertEqual(actual, expected)
        actual = check_mask('0b01000', '0b01010')
        expected = True
        self.assertEqual(actual, expected)
        actual = check_mask('0b00010', '0b01010')
        expected = True
        self.assertEqual(actual, expected)
        actual = check_mask('0b00100', '0b01010')
        expected = False
        self.assertEqual(actual, expected)
        actual = check_mask('0b01011', '0b01010')
        expected = False
        self.assertEqual(actual, expected)
        actual = check_mask('0b00000', '0b01010')
        expected = False
        self.assertEqual(actual, expected)
        actual = check_mask('0b11010', '0b01010')
        expected = False
        self.assertEqual(actual, expected)


if __name__ == "__main__":
    unittest.main()

Идея правильная, а код не рабочий.

(a != 0) && (a & b == a)

И во-первых, булева, а не «булевая», во-вторых, это не булева логика, а битовые операции.

Что здесь a “а” что “b”? Говнокод какой-то

О, до сих пор обсуждают )

Поставьте элемент 2ИЛИ, элемент 3ИЛИ-НЕ, выходы объедините через элемент 2И )

мда, что-то долго вы обсуждаете

mask | flags

должно вернуть маску, если что-то другое, то в флагах что-то другое

блин, сам кучу исправлений сделал, а в итогде вообще одна операция над битами, ну или можно как в предыдущем варианте получить синдром.

и опять наврал, синдром через «или не»

зы: кофейку надо, не проснулся и порядок действий

(mask | flags) ^ mask

Идея правильная, а код не рабочий.

«абаснуй». только без придирок к синтаксису - писал с телефона на бегу, олимпиада же.

работает!
спасибо!

работает
мне кажется, что так даже понятней чем через ~ делатьа
спасибо!

работает!

огромное спасибо за помощь!

Тоже сначала так же написал как и у тебя, но заваливаются тесты вот на этом кусочке:

Else if(val & (~mask))

; // Not valid

Else ; // valid

А вот так все проходят

Else if(val & (~mask))

; // valid

Else ; // Not valid

Хотя, возможно ТС-а обновления это поменяли. Ну или я не помню к чему if приводится в C

инверсия при разборе флагов плохая практика, можно знатно стрельнуть в ногу со знаковыми беззнаковыми

Если статусы фиксированные и надо только их смотреть, без выделения отдельного смысла, то я бы как-то так делал:

Ты там hexadecimal с binary не попутал, не? :)

В C++, например, можно так

Степенями двойки можно в любом языке где есть операторы булевой алгебры (разница только в том, что кто-то помнит/предвычисляет эти степени и фигачит константы, а кто упарывается в макросы сдвигами)... и, внезапно, где их нет, просто нужно будет вспомнить некоторую несложную математику... но чаще не нужно, особенно не нужно развесистой лапши из длинных снейккейсов и россыпей шаблониума :)

булЁвая логика.

Ты там hexadecimal с binary не попутал, не? :)

наверное попутал, давно c++ не юзал

но заваливаются тесты вот на этом кусочке:

https://godbolt.org/z/rYbh3aETY

у меня все тесты прошли.

Значениями битовых флагов должны быть двойки в степени иначе работать не будет. Там все на двоичное представление завязано. Должны быть 0001, 0010, 0100. Сочетания этих флагов будут давать что-то типа 0101.

In [11]: (2 | 4 | 8) & 8
Out[11]: 8

In [12]: (2 | 4) & 8
Out[12]: 0

...

In [16]: CREATE = 1 << 1

In [17]: READ = 1 << 2

In [18]: UPDATE = 1 << 3

In [19]: DELETE = 1 << 4

In [20]: CREATE
Out[20]: 2

In [21]: DELETE
Out[21]: 16

In [22]: CREATE | READ | UPDATE
Out[22]: 14

In [23]: (CREATE | READ | UPDATE) & DELETE
Out[23]: 0

In [24]: (CREATE | READ | UPDATE) & UPDATE
Out[24]: 8

        actual = check_mask('0b01010', '0b01010')
        expected = True
        self.assertEqual(actual, expected)
        actual = check_mask('0b01000', '0b01010')
        expected = True
...

Кто вас заставляет так писать? Почему нельзя сделать

     // a         b         result
      ['0b01010','0b01010', True   ],
      ['0b01000','0b01010', True   ],
...

Можно. Лень просто было

То что в первых двух колонках в первом посте.

Не специально, чисто логикой, прогу лень было писать...

01010 | 01010 | pass      
01000 | 01010 | pass       
00010 | 01010 | pass
00100 | 01010 | not valid
01011 | 01010 | not valid
00000 | 01010 | not valid
11010 | 01010 | not valid

01010   01010
010-0   01010
0-010   01010

0-0-0   01010   pass