Бит четности , является одним из простейших форм контрольной суммы. Во-первых, вы должны выбрать паритет, четный или нечетный. Допустим, мы выбираем даже. Теперь нам нужно сообщение для передачи. Допустим, наше сообщение "Foo". Это записано в двоичном виде как:

01000110 01101111 01101111

Теперь мы посчитаем общее число 1's там, которое составляет 15. Поскольку 15 - нечетное число, мы должны добавить один дополнительный бит в конец нашего сообщения, и теперь у нас будет четное число битов' on ' , Этот последний добавленный бит известен как «бит четности». Если бы мы выбрали нечетную четность для нашей контрольной суммы, нам пришлось бы добавить дополнительный «0», чтобы число битов оставалось нечетным.

Соревнование:

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

• Строка, s. Это сообщение, на которое будет рассчитана контрольная сумма. Это будет ограничено 95 печатными символами ASCII.

• Символьная или односимвольная строка p, которая будет либо eдля четной четности, либо oдля нечетной четности.

и получить значение truey-falsey, представляющее правильный бит четности. Правда, если это 1, и ложь, если это 0.

Встроенные функции, которые считают количество включенных битов в строке или символе, не допускаются. Например, функция, fкоторая делает это: f('a') == 3или f('foo') == 16запрещена. Все остальное, например базовое преобразование, является честной игрой.

Тест IO:

(without the quotes)
s: "0"
p: 'e'
output: 0

s: "Foo"
p: 'e'
output: 1

s: "Hello World!"
p: 'o'
output: 0

s: "Alex is right"
p: 'e'
output: 1

s: "Programming Puzzles and Code-Golf" 
p: 'e'
output: 0

s: "Programming Puzzles and Code-Golf" 
p: 'o'
output: 1

Это Codegolf, поэтому применяются стандартные лазейки, и выигрывает самый короткий ответ в байтах.

Leaderboard

var QUESTION_ID=78569,OVERRIDE_USER=31716;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

MATL , 8 7 байт

8\hBz2\

Попробуйте онлайн! Или проверьте все тестовые случаи одновременно .

8\    % Implicitly take first input ('e' or 'o'), and compute modulo 8. Inputs 'e' and 'o' 
      % give 5 or 7 respectively, which have an even or odd number of `1` bits resp.
h     % Implicitly take second input, and concatenate
B     % Convert to binary. Gives 2D array, with one row for each original entry 
z     % Number of nonzero values in that 2D array
2\    % Modulo 2, i.e. compute parity

Java, 97 байт

Потому что, вы знаете, Java.

(s,c)->{boolean e=1>0;for(int i:s.getBytes())while(i>0){if(i%2==1)e=!e;i/=2;}return c=='o'?e:!e;}

Это лямбда для BiFunction<String, Character, Boolean>.

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

Python 2, 51 байт

lambda s,p:`map(bin,map(ord,p+s))`[9:].count('1')%2

Это основано на идее Sp3000 подсчитывать 1 в строковом представлении списка кодов символов в двоичном формате, а не суммировать для каждого символа.

Новый трюк - справиться eи oс этим тоже. Если бы это eбыло нечетно и oчетно, мы могли бы просто добавить бит четности в строку перед выполнением подсчета (переключая их, потому что «1» - это Истина). К сожалению, это не так. Но если мы удалим все, кроме последних двух битов, то это правда.

e 0b11001|01
o 0b11011|11 

Это делается путем удаления первого 9символа строкового представления.

['0b11001|01', 

Желе, 9 8 байт

OBFSḂ⁼V}

Попробуйте онлайн!

O         convert each character in argument 1 (left arg) to its codepoint (ord)
 B        convert to binary (list of 0s and 1s)
  F       flatten
   S      sum the entire list, giving the number of 1s in the entire string
    Ḃ     mod 2 (take the last bit)
       }  now, with the second (right) argument...
      V   eval with no arguments. This returns...
            1 for e because it expands to 0e0 (i.e., does 0 exist in [0])
            0 for o because it expands to 0o0 (0 OR 0, false OR false, false)
     ⁼    test equality between the two results

Спасибо Денису за байт!

C, 62 байта

• 12 байтов сохранено благодаря @LevelRiverSt и @TonHospel.

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

f(s,p)char*s;{for(p/=8;*s;)p^=*s>>4^*s++;p^=p/4;return p%4%3;}

Ideone.

Python, 58 57 байт

lambda s,p:sum(bin(ord(c)).count("1")for c in s)&1!=p>'e'

Pyth, 12 байт

q@"oe"sjCz2w

Тестирование.

         z    take a line of input
        C     convert to int
       j  2   convert to base 2, array-wise (so, array of 0s and 1s)
      s       sum (count the number of ones)
 @"oe"        modular index into the string to get either "o" or "e"
q          w  test equality to second line of input

JavaScript (ES6), 84 72 байта

(s,p)=>(t=p>'e',[...s].map(c=>t^=c.charCodeAt()),t^=t/16,t^=t/4,t^t/2)&1

Битовое чередование оказалось короче, чем преобразование в базу 2 и подсчет 1s.

Perl, 29 байт

Включает +2 для -p

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

parity.pl <<< "p Programming Puzzles and Code-Golf"

parity.pl

#!/usr/bin/perl -p
$_=unpack"B*",$_|b;$_=1&y;1;

J, 27 байт

'oe'&i.@[=[:~:/^:2@#:3&u:@]

использование

   f =: 'oe'&i.@[=[:~:/^:2@#:3&u:@]
   'e' f '0'
0
   'e' f 'Foo'
1
   'o' f 'Hello World!'
0
   'e' f 'Alex is right'
1
   'e' f 'Programming Puzzles and Code-Golf'
0
   'o' f 'Programming Puzzles and Code-Golf'
1

JavaScript (ES6), 69 байт

(s,p)=>[...s].map(c=>{for(n=c.charCodeAt();n;n>>=1)r^=n&1},r=p>"e")|r

PowerShell v2 +, 91 байт

_{/ я плачу в углу}

param([char[]]$a,$b)$b-eq'o'-xor(-join($a|%{[convert]::toString(+$_,2)})-replace0).length%2

Да ... итак, базовая конверсия не подходит для PowerShell. Преобразование из входной строки в двоичное представление $a|%{[convert]::toString(+$_,2)}само по себе составляет 32 байта ...

Принимает ввод $aи $b, явно приводя $aкак char-массив в процессе. Затем мы проверяем, $bявляется ли это -eqUAL oи -xorдругой половиной программы. Для этой части мы берем входную строку $a, пропускаем ее через цикл, чтобы преобразовать каждую букву в двоичную, -joinвсе вместе, чтобы сформировать одну сплошную строку, и -replaceвсе 0без нуля. Затем мы посчитаем .lengthэту строку и возьмем ее mod-2, чтобы определить, является ли она четной или нечетной, что будет удобно либо, 0либо 1, идеально подходит для -xor.

Вернется Trueили Falseсоответственно. Смотрите тестовые случаи ниже:

PS C:\Tools\Scripts\golfing> .\generate-parity-bit.ps1 "0" e
False

PS C:\Tools\Scripts\golfing> .\generate-parity-bit.ps1 "Foo" e
True

PS C:\Tools\Scripts\golfing> .\generate-parity-bit.ps1 "Hello World!" o
False

PS C:\Tools\Scripts\golfing> .\generate-parity-bit.ps1 "Alex is right" e
True

PS C:\Tools\Scripts\golfing> .\generate-parity-bit.ps1 "Programming Puzzles and Code-Golf" e
False

PS C:\Tools\Scripts\golfing> .\generate-parity-bit.ps1 "Programming Puzzles and Code-Golf" o
True

Фактор, 85 байт

По какой-то причине я не мог обернуть голову вокруг этого до тех пор, пока несколько минут назад я не упростил (и, возможно, сократил?) Код.

[ "e" = [ even? ] [ odd? ] ? [ [ >bin ] { } map-as concat [ 49 = ] count ] dip call ]

?похож на троичный оператор: он проверяет достоверность третьего элемента стека и выбирает либо trueзначение, либо falseзначение.

Это примерно эквивалентно следующему C-подобному псевдокоду:

void* parity_tester_function = strcmp(p, "e") ? (void *) even?  // it's a function pointer (I think)
                                              : (void *) odd? ;

Остальная часть кода довольно проста:

[                       ! to count a string's set bits:
    [ >bin ] { } map-as ! get the binary of each character, and map as an array, because you can't have stringy data nested in another string (that's called a type error)
    concat              ! { "a" "B" } concat -> "aB"
    [ 49 = ] count      ! count items in the resulting string which match this condition (in this case, the condition we're testing is whether the character has the same code point as "1")
] dip                   ! take the above function pointer off the stack, apply this anonymous function to the now-top of the stack, then restore the value after the quotation finishes.
                        ! in other words, apply this quotation to the second-to-top item on the stack
call                    ! remember that conditionally chosen function pointer? it's on the top of the stack, and the number of sets bits is second.
                        ! we're gonna call either odd? or even? on the number of set bits, and return the same thing it does.

Машинный код IA-32, 15 байтов

HexDump:

0f b6 c2 40 32 01 0f 9b c0 3a 21 41 72 f6 c3

Код сборки:

    movzx eax, dl;
    inc eax;
repeat:
    xor al, [ecx];
    setpo al;
    cmp ah, [ecx];
    inc ecx;
    jb repeat;
    ret;

Это функция, которая получает свой первый аргумент (строку) в ecxи второй аргумент (символ) в dl. Он возвращает результат eax, поэтому он совместим с fastcallсоглашением о вызовах.

Этот код изменяет правила, когда он использует setpoинструкцию:

Встроенные функции, которые считают количество включенных битов в строке или символе, не допускаются.

Эта инструкция устанавливает alбит четности, вычисленный предыдущей инструкцией, поэтому в правилах у меня есть два куска:

• Он не считает количество включенных бит - он вычисляет бит четности напрямую!
• Технически, это предыдущая инструкция ( xor), которая вычисляет бит четности. setpoИнструкция только перемещает его в alрегистр.

Этим семантическим деталям нет пути, вот объяснение того, что делает код.

Представления персонажей:

'e' = 01100101
'o' = 01101111

Если мы добавим 1 к ним, они получат правильное соотношение:

'e' + 1 = 01100110 (odd parity)
'o' + 1 = 01110000 (even parity)

Таким образом, мы XORвсе символы строки, инициализирующие alэти значения, что дает ответ.

Первая инструкция movzx eax, dlвместо более очевидной (и более короткой) mov al, dl, потому что я хочу иметь номер 0 в регистре ( ahв данном случае), чтобы иметь возможность сравнивать его в правильном порядке ( 0, [ecx]а не [ecx], 0).

Юлия, 58 47 45 40 байт

f(s,p)=(p>'e')$endof(prod(bin,s)∩49)&1

Это функция, которая принимает строку и символ и возвращает целое число.

Чтобы получить число единиц в двоичном представлении, мы сначала применяем binфункцию к каждому символу в строке, которая дает нам массив двоичных строк. Затем сведите их к одному использованию prod(поскольку *в Julia используется конкатенация строк) и возьмите пересечение множества этой строки и код символа для 1, что дает нам строку единиц. Последний индекс этой строки - это число единиц. Мы XOR это с 1, если предоставленный символ o и 0 в противном случае, затем получить четность, используя побитовое И 1.

Попробуйте онлайн! (включает все тестовые случаи)

Благодаря Деннису сэкономлено 18 байт!

05AB1E , 15 , 13 байтов

Код:

€ÇbSOÈ„oe²k<^

Пример ввода:

Programming Puzzles and Code-Golf
o

Пример вывода:

1

Объяснение:

€                 # for each char in string
 Ç                # get ascii value
  b               # convert to binary
   S              # split to single chars (ex: '1101' to '1','1','0','1')
    O             # sum
     È            # check if even
      „oe         # push string "oe"
         ²        # push 2nd input (p)
          k       # get 1-based index of p in "oe"
           <      # decrease (to get either 0-based index)
            ^     # xor with result of È

Спасибо Аднану за сохранение 2 байта.

Рубин, 57 байт

Если 0бы в Ruby была ложь, то, ==вероятно, можно было бы переключиться на просто -, или могли бы быть другие оптимизации, но это не так.

->s,b{s.gsub(/./){$&.ord.to_s 2}.count(?1)%2==(b>?i?0:1)}

Сетчатка , 102 байта

Принимает строку в первой строке и букву во второй строке. Использует кодировку ISO 8859-1.

[12478abdghkmnpsuvyzCEFIJLOQRTWX#%&)*,/;=>@[\]^| ](?=.*¶)
1
[^1](?=.*¶)
0
^(0|10*1)*¶o|^0*1(0|10*1)*¶e

Попробуйте онлайн

Класс символов в первой строке соответствует любому символу с нечетным числом единиц в двоичном представлении.

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

Октава, 56 байт

f=@(s,p) mod(sum((i=bitunpack([s p]))(1:length(i)-5)),2)

bitunpackФункция, для ASCII символов, возвращает их в прямом порядке байт порядка. Таким образом, поместив флаг четности в конец нашей строки, распаковав все это и отбросив последние 5 битов, мы можем затем суммировать все значение mod 2 для нашего окончательного ответа.

Использование:

octave:137> f('Hello World!', 'o')
ans = 0
octave:138> f('Hello World!', 'e')
ans =  1

 Обыкновенный Лисп, 87

(lambda(s p)(=(mod(reduce'+(mapcar'logcount(map'list'char-code s)))2)(position p"oe")))

• Сумма логарифма char-кодов s.
• Остальная часть этого при делении на 2 сравнивается с положением аргумента четности pв строке "oe"(0 или 1). Например, если их 4, остаток равен нулю. Если p есть o, то дополнительный бит не должен быть добавлен, и тест возвращает false.

Довольно отпечатанных

(lambda (s p)
  (= (mod (reduce '+ (mapcar 'logcount (map 'list 'char-code s))) 2)
     (position p "oe")))

Java, 91 байт

(s,c)->{s+=c%8;int e=1;for(int i:s.getBytes())while(i>0){if(i%2==1)e^=1;i/=2;}return e==0;}

Я сделал то же самое, что и @ CAT97, но удалил некоторые символы, используя модуль 8 и конкатенацию @Luis Mendo и используя int вместо логического.

Это лямбда для BiFunction<String, Character, Boolean>.

Matlab, 49 байт

f=@(x,p)mod(sum(sum(dec2bin(x)-'0'))+(p-'e'>0),2)

где:

• х - входная строка;
• р - «е» для четной четности и «о» для нечетной.

Например:

>> f('Programming Puzzles and Code-Golf','e')

ans =

     0

Инструменты Bash и Unix (72 байта)

f(){ bc<<<"$(xxd -b<<<"$2$1"|cut -b9-64|tail -c +7|tr -dc 1|wc -c)%2" }

Исключает sкак первый и pкак второй аргумент. К счастью, последние 3 бита oи eимеет нечетную и четность соответственно.

xxd -b        print the concatenation of `p` and `s` in binary
cut -b9-64    parse xxd output
tail -c +7    keep only the last 3 bits of `p`
tr -dc 1      keep only the `1`s
wc -c         count them
bc ...%2      modulo two

Предоставление ввода через <<<добавляет символ перевода строки, но четность \nчетна, так что это не проблема.