Un bit de parité est l'une des formes les plus simples d'une somme de contrôle. Tout d'abord, vous devez choisir la parité, paire ou impaire. Disons que nous choisissons même. Maintenant, nous avons besoin d'un message à transmettre. Disons que notre message est "Foo". Ceci est écrit en binaire comme:

01000110 01101111 01101111

Maintenant, nous comptons le nombre total de 1's là-dedans, qui est 15. Puisque 15 est un nombre impair, nous devons ajouter un bit supplémentaire à la fin de notre message, et nous aurons maintenant un nombre pair de bits' on ' . Ce dernier bit ajouté est appelé "bit de parité". Si nous avions choisi une parité impaire pour notre somme de contrôle, nous aurions dû ajouter un «0» supplémentaire afin que le nombre de bits reste impair.

Le défi:

Vous devez écrire un programme ou une fonction qui détermine le bit de parité correct pour une chaîne. Votre programme doit prendre deux entrées:

• Une chaîne, s. C'est le message sur lequel la somme de contrôle sera calculée. Cela sera limité aux 95 caractères ASCII imprimables.

• Un caractère ou une chaîne de caractères unique p, qui sera soit epour la parité paire, soit opour la parité impaire.

et produire une valeur true-falsey représentant le bit de parité correct. Vérité si c'est un 1, et falsey si c'est un 0.

Les commandes internes qui comptent le nombre de bits "on" dans une chaîne ou un caractère ne sont pas autorisées. Par exemple, une fonction fqui fait cela: f('a') == 3ou f('foo') == 16est interdite. Tout le reste, comme la conversion de base, est un jeu équitable.

Test 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

Il s'agit de codegolf, donc les failles standard s'appliquent et la réponse la plus courte en octets l'emporte.

Classement

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 octets

8\hBz2\

Essayez-le en ligne! Ou vérifiez tous les cas de test à la fois .

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 octets

Parce que, tu sais, 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;}

Ceci est un lambda pour un BiFunction<String, Character, Boolean>.

eet osemblent être inversés dans la déclaration de retour, car apparemment ma logique était à l'envers.

Python 2, 51 octets

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

Ceci est basé sur une idée de Sp3000 pour compter 1 dans la représentation sous forme de chaîne de la liste des codes de caractères en binaire plutôt que de sommer pour chaque caractère.

La nouvelle astuce consiste à gérer eet odans ce domaine aussi. Si eétait impair et opair, nous pourrions simplement ajouter le bit de parité à la chaîne avant de faire le compte (en les retournant parce que «1» est vrai). Malheureusement, ils ne le sont pas. Mais, si nous supprimons tout sauf leurs deux derniers bits, c'est maintenant vrai.

e 0b11001|01
o 0b11011|11 

Cela se fait en supprimant le premier 9caractère de la représentation sous forme de chaîne.

['0b11001|01', 

Gelée, 9 8 octets

OBFSḂ⁼V}

Essayez-le en ligne!

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

Merci à Dennis pour un octet!

C, 62 octets

• 12 octets enregistrés grâce à @LevelRiverSt et @TonHospel.

XOR a la belle propriété qu'il peut être utilisé pour réduire les chaînes à un seul caractère, tout en préservant la parité.

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

Ideone.

Python, 58 57 octets

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

Pyth, 12 octets

q@"oe"sjCz2w

Suite de tests.

         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 octets

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

Le twiddling de bits s'est avéré plus court que la conversion en base 2 et en comptant 1s.

Perl, 29 octets

Comprend +2 pour -p

Exécuter avec l'entrée sur STDIN comme chaîne d'espace de caractères de parité, par exemple

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

parity.pl

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

J, 27 octets

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

Usage

   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 octets

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

PowerShell v2 +, 91 octets

_{/ moi pleure dans un coin}

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

Ouais ... donc, la conversion de base n'est pas un fort avantage pour PowerShell. La conversion de la chaîne d'entrée en représentation binaire $a|%{[convert]::toString(+$_,2)}est de 32 octets en soi ...

Prend des entrées $aet $btranstype explicitement en $atant que tableau de caractères dans le processus. Nous vérifions ensuite si $best -equel à o, et -xorque l'autre moitié du programme. Pour cette partie, nous prenons la chaîne d'entrée $a, la canalisons à travers une boucle pour convertir chaque lettre en binaire, -jointoutes celles-ci ensemble pour former une chaîne solide et -replacetous les 0s sans rien. Nous comptons ensuite le .lengthde cette chaîne et le prenons mod-2 pour déterminer s'il est pair ou impair, qui sera commodément soit 0ou 1, parfait pour le-xor .

Reviendra Trueou en Falseconséquence. Voir les cas de test ci-dessous:

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

Facteur, 85 octets

Pour une raison quelconque, je n'ai pas pu envelopper ma tête autour de celui-ci jusqu'à il y a quelques minutes, quand j'ai simplifié (et peut-être raccourci?) Le code.

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

?est comme un opérateur ternaire: il teste la véracité du troisième élément de pile et sélectionne la truevaleur ou la falsevaleur.

Il est à peu près équivalent au pséduocode de type C suivant:

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

Le reste du code est assez simple:

[                       ! 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.

Code machine IA-32, 15 octets

Hexdump:

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

Code d'assemblage:

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

Il s'agit d'une fonction qui reçoit son premier argument (chaîne) dans ecxet son deuxième argument (char) dans dl. Il renvoie le résultat dans eax, il est donc compatible avec la fastcallconvention d'appel.

Ce code contourne les règles lorsqu'il utilise l' setpoinstruction:

Les commandes internes qui comptent le nombre de bits "on" dans une chaîne ou un caractère ne sont pas autorisées

Cette instruction définit alle bit de parité calculé par l'instruction précédente - j'ai donc ces deux astuces sur les règles:

• Il ne compte pas le nombre de bits "on" - il calcule directement le bit de parité!
• Techniquement, c'est l'instruction précédente ( xor) qui calcule le bit de parité. L' setpoinstruction la déplace uniquement vers le alregistre.

Ces détails sémantiques à l'écart, voici l'explication de ce que fait le code.

Les représentations des personnages sont:

'e' = 01100101
'o' = 01101111

Si on leur ajoute 1, ils se trouvent avoir juste la bonne parité:

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

Nous avons donc XORtous les caractères de la chaîne, l'initialisation alà ces valeurs, ce qui donne la réponse.

La première instruction est movzx eax, dlau lieu de la plus évidente (et plus courte) mov al, dl, car je veux avoir le numéro 0 dans un registre ( ahdans ce cas) afin de pouvoir le comparer dans le bon ordre ( 0, [ecx]plutôt que [ecx], 0).

Julia, 58 47 45 40 octets

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

Il s'agit d'une fonction qui accepte une chaîne et un caractère et renvoie un entier.

Pour obtenir le nombre de uns dans la représentation binaire, nous appliquons d'abord la binfonction à chaque caractère de la chaîne, ce qui nous donne un tableau de chaînes binaires. Ensuite, réduisez-les en un en utilisant prod(car *c'est la concaténation de chaînes dans Julia) et prenez l'intersection définie de cette chaîne et le code de caractère pour 1, ce qui nous donne une chaîne de uns. Le dernier index de cette chaîne est le nombre de ceux. Nous XOR ceci avec 1 si le caractère fourni est o et 0 sinon, puis obtenir la parité en utilisant AND au niveau du bit 1.

Essayez-le en ligne! (inclut tous les cas de test)

Enregistré 18 octets grâce à Dennis!

05AB1E , 15 , 13 octets

Code:

€ÇbSOÈ„oe²k<^

Exemple d'entrée:

Programming Puzzles and Code-Golf
o

Exemple de sortie:

1

Explication:

€                 # 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 È

Merci à Adnan d'avoir économisé 2 octets.

Rubis, 57 octets

Si 0était falsey à Ruby, le ==pourrait probablement être basculé sur juste -, ou il pourrait y avoir d'autres optimisations, mais ce n'est pas le cas.

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

Rétine , 102 octets

Prend la chaîne sur la première ligne et la lettre sur la deuxième ligne. Utilise le codage ISO 8859-1.

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

Essayez-le en ligne

La classe de caractères sur la première ligne correspond à n'importe quel caractère avec un nombre impair de caractères dans la représentation binaire.

Description du fonctionnement de la détection paire / impaire avec l'expression régulière ici .

Octave, 56 octets

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

La bitunpackfonction, pour les caractères ASCII, les renvoie dans l'ordre petit-boutien. Donc, en mettant le drapeau de parité à la fin de notre chaîne, en déballant le tout et en supprimant les 5 derniers bits, nous pouvons ensuite résumer le tout mod 2 pour notre réponse ultime.

Usage:

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

 Lisp commun, 87

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

• Additionnez le nombre de log-codes de s.
• Le reste de ceci, lorsqu'il est divisé par 2, est comparé à la position de l'argument de parité pdans la chaîne "oe"(0 ou 1). Par exemple, s'il y en a 4, le reste est nul. Si p est o, alors aucun bit supplémentaire ne doit être ajouté et le test retourne faux.

Assez imprimé

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

Java, 91 octets

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

J'ai fait la même chose que @ CAT97, mais j'ai supprimé certains caractères en utilisant le modulo 8 et la concaténation de @Luis Mendo et l'utilisation de int au lieu de booléen.

Ceci est un lambda pour un BiFunction<String, Character, Boolean>.

Matlab, 49 octets

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

où:

• x est la chaîne d'entrée;
• p est «e» pour une parité paire et «o» pour une parité impaire.

Par exemple:

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

ans =

     0

Outils Bash et Unix (72 octets)

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

Excepte scomme premier et pcomme deuxième argument. Heureusement, les 3 derniers bits de oet eont respectivement une parité paire et impaire.

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

La fourniture de l'entrée via <<<ajoute un caractère de saut de ligne, mais la parité de \nest égale, donc ce n'est pas un problème.