как определить нечетные 1 в двоичном числе

Question

как идентифицировать нечетные 1 в двоичном числе, которыми являются мои двоичные числа, то есть каждый нечетный бит - это 1 в двоичном числе

1 1 0 0 1 0 0 0 1 0   1  0 1  0  1   1  1 1  1  1  0  1  1  0
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
11010101010101111110110
11101101010101100011011
11111100110101010111101

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

1 1 1  1  1 1  1  1  1
1 5 9 11 13 15 17 19 23

, как это я хочу получить вывод из каждой двоичной строки

Answer 1

Я интерпретировал вопрос как «обнаружение, содержит ли данное двоичное число нечетное число 1» **. Это регулярное выражение будет сопоставлять все двоичные числа с четным числом 1:

^0*(?:10*10*)*$

Отмените результат матча, чтобы получить желаемый результат.

** Я знаю, вероятно, не очень вероятно, но эй ....

Редактировать: проверяет входные данные OP следующим образом:

110010001010101111110110 - MATCH (even number of 1's)
11010101010101111110110  - NO MATCH (odd number of 1's)
11101101010101100011011  - MATCH (even number of 1's)
11111100110101010111101  - MATCH (even number of 1's)

Answer 2

Предполагая, что каждая строка представляет двоичное число в форме с прямым порядком байтов (биты нумеруются с нуля, что относится к последнему символу строки), определяя, все ли нечетные биты (т. Е. Бит № 1, бит № 3), бит № 5 и т. д.) в строке выполняется путем проверки соответствия строки этому регулярному выражению:

^[01]?(?:1[01])*$

Чтобы понять это, сначала давайте упростим, предположив, что мы уже знаем, что все символы либо0 или 1.Учитывая это (и игнорируя хитрость без захвата), мы могли бы написать (в развернутом виде):

^ .? (1.)* $
A BB CCCCC D <- the key

Это привязанное соответствие всей строки (A и D), которая являетсяпустая строка или любая цифра (B) или любое число из 1, за которым следует что-либо (C, которое ставит 1 в «нечетную» позицию) или цифру перед четным числом цифр с1 в «нечетном» положении (B, за которым следует C).Я только что преобразовал эту базовую форму в более эффективное и точное представление перед ней, ограничив алфавит символов ([01] для .) и используя не захватывающие скобки ((?:…) вместо (…)).

Если вы рассматриваете первый бит как бит № 1, вам нужен этот RE вместо:

^1?(?:[01]1)*$

Для битовых строк с младшим порядком байтов вам нужно "обратить RE"(или используйте обратная строка в строке для сопоставления и используйте один из других сопоставителей)."Обратное RE" для формы с прямым порядком байтов # 0 первой:

^(?:[01]1)*[01]?$

Для бита с прямым порядком # 1 первой:

^(?:1[01])*1?$

Помните, со всемииз этих регулярных выражений проще всего записать их в Tcl, заключив их в { фигурные } фигурные скобки.

---

Демонстрация:

foreach s {
    110010001010101111110110
    11010101010101111110110
    11101101010101100011011
    11111100110101010111101
    1110111011111010111010
} {
    set matches [regexp {^[01]?(?:1[01])*$} $s]
    puts "$s [lindex {{doesn't match} matches} $matches]"
}

Создает этот вывод:

110010001010101111110110 doesn't match
11010101010101111110110 doesn't match
11101101010101100011011 doesn't match
11111100110101010111101 doesn't match
1110111011111010111010 matches

Answer 3

Давайте сначала рассмотрим более простую проблему: использование регулярного выражения для сопоставления унарной строки (содержащей только 1), которая содержит нечетное число 1. Поэтому мы хотим сопоставить 1 (1), 111 (3), 11111 (5),…, но не пустую строку (0), 11 (2), 1111 (4) ,…

Для этого вам нужно сопоставить пары 1, оставив ровно один 1 непарным. Таким образом, шаблон ( также на рублевом ):

^(11)*1$

Теперь мы можем изменить этот базовый шаблон, чтобы приспособить 0. Мы наблюдаем, что:

• 0* может появляться до первого 1
• 0* может появиться после последнего 1
• 0* могут появляться в парах

То есть нам нужно вставить 0* в следующие 4 пункта:

  \/  \/
^(11)*1$
/\ /\

Таким образом, шаблон ( см. Совпадения на rubular.com ):

^0*(10*10*)*10*$

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

Ссылки

• регулярные-выражения.info / Якоря: ^ / $, Повторение: *

Answer 4

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

С регулярным выражением выражение:

1$

Или, если вы должны соответствовать всю строку, то:

^[10]+1$

Но вам не нужно регулярное выражение для этого ... в псевдокоде:

if right(string,1) == 1

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

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

Хорошо, синтаксис tcl для этого:

if {[string index $str end] eq 1}

Если это не то, что вы спрашиваете :

1. Добавьте в вопрос больше деталей о том, что именно вы хотите.
2. Отметьте принятые ответы на некоторые из ваших предыдущих вопросов.

Answer 5

Все, что вам нужно посмотреть, это последняя цифра.

Если это 1, соответствующее десятичное число нечетное.

Если это 0, это даже.

Answer 6

Преобразовать в серый код и проверить lsb.