Le scénario

Dernièrement, vous avez remarqué un comportement étrange avec votre éditeur de texte préféré. Au début, il semblait ignorer des caractères aléatoires dans votre code lors de l'écriture sur le disque. Au bout d'un moment, vous avez remarqué un motif. les caractères avec des valeurs ASCII impaires étaient ignorés. Lors d'une inspection plus poussée, vous avez découvert que vous ne pouvez écrire correctement dans des fichiers que si chaque huitième bit est à zéro. Vous devez maintenant savoir si vos précieux fichiers ont été affectés par cet étrange bogue.

La tâche

Vous devez écrire un programme complet qui détermine si un fichier contient des octets impairs (démontrant qu'il n'est pas corrompu). Mais à cause de votre éditeur de texte, vous ne pouvez pas écrire d'octets impairs dans votre code source. Vous pouvez assumer tout codage préexistant pour la saisie, mais vous devez toujours vérifier chaque octet, pas seulement les caractères.

Contribution

Votre programme prendra le contenu de ou le chemin d'accès à un fichier à partir de stdin ou de la ligne de commande.

Sortie

Votre programme affichera sur stdout soit une valeur de vérité si le fichier donné contient un octet impair, soit une erreur si tous les huit bits sont nuls.

Critères

Ceci est le code de golf, le programme le plus court qui termine la tâche gagne. Pour être une soumission valide, chaque huitième bit du code source des fichiers doit être égal à zéro. Je recommanderais d'inclure une copie des fichiers binaires de votre code source dans votre soumission.

Les failles standard s'appliquent.

Cas de test

(En codage ASCII) Entrée:

"$&(*,.02468:<>@BDFHJLNPRTVXZ\^`bdfhjlnprtvxz|~

Output:
falsy

Input:
!#%')+-/13579;=?ACEGIKMOQSUWY[]_acegikmoqsuwy{}

Output:
truthy

Input:
LOREMIPSVMDOLORSITAMETCONSECTETVRADIPISCINGELITSEDDOEIVSMODTEMPORINCIDIDVNTVTLABOREETDOLOREMAGNAALIQVA
VTENIMADMINIMVENIAMQVISNOSTRVDEXERCITATIONVLLAMCOLABORISNISIVTALIQVIPEXEACOMMODOCONSEQVAT
DVISAVTEIRVREDOLORINREPREHENDERITINVOLVPTATEVELITESSECILLVMDOLOREEVFVGIATNVLLAPARIATVR
EXCEPTEVRSINTOCCAECATCVPIDATATNONPROIDENTSVNTINCVLPAQVIOFFICIADESERVNTMOLLITANIMIDESTLABORVM

Output:
truthy

Conseils

• Choisir la langue judicieusement, ce défi peut ne pas être possible dans toutes les langues

• La commande Unix xxd -b <file name>imprimera les fichiers binaires d’un fichier sur la console (avec quelques éléments de formatage supplémentaires).

• Vous pouvez utiliser d'autres codages que l'ASCII, tels que UTF-8, à condition que toutes les autres règles soient suivies.

GS2 , 4 octets

dΦ("

Essayez-le en ligne!

Hexdump

0000000: 64 e8 28 22                                      d.("

Comment ça fonctionne

      (implicit) Read all input and push it on the stack.
 Φ    Map the previous token over all characters in the string:
d       Even; push 1 for even characters, 0 for odd ones.
  (   Take the minimum of the resulting list of Booleans.
   "  Negate the minimum.

Befunge, 36 octets

Je sais que c'est une vieille question, mais je voulais essayer car je pensais que ce serait un défi intéressant à Befunge.

>~:0`|
>20`:>$.@
|` " "<
*8*82<^p24*

Essayez-le en ligne!

Il sort 1si l'entrée est corrompue (c'est-à-dire qu'elle contient un octet impair) et 0si elle est OK.

Explication

Le problème est de savoir comment déterminer les octets impairs sans avoir accès aux commandes /(divide) ou %(modulo). La solution consistait à multiplier la valeur par 128 (la séquence 28*8**), puis à écrire ce résultat dans le champ de lecture. Sur un interpréteur strictement standard, les cellules playfield sont signées 8 bits, ainsi un nombre impair multiplié par 128 est tronqué à -1 alors qu'un nombre pair devient 0.

L'autre astuce consistait à lire le retour -1 ou 0 du champ de lecture sans avoir accès à la gcommande (get). Pour contourner ce problème, écrivez la valeur au milieu d'une séquence de chaîne existante ( " "), puis exécutez cette séquence pour envoyer la valeur incluse dans la pile. À ce stade, déterminer l'étrangeté de l'octet est un simple test inférieur à zéro.

Un dernier aspect intéressant à discuter est le résultat. Dans le cas faux, nous atteignons la >$.séquence avec une seule valeur sur la pile, donc $efface la pile en rendant la .sortie égale à zéro. Dans le cas réel, nous suivons le chemin 20`:>$.. Etant donné que deux est supérieur à zéro, la comparaison place un un dans la pile et :crée une copie afin de $ne pas le laisser tomber avant la sortie.

CJam (11 octets)

"r2":(~f&2b

Démo en ligne

Dénuder les astuces pour éviter les octets impairs, cela réduit à

q1f&2b

qui lit l'entrée, mappe un ET bit par bit avec 1, puis effectue une conversion de base, donnant zéro si et seulement si tous les ET étaient nuls.

Fichier .COM imprimable, 100 octets

^FZjfDXVL\,LPXD$$4"PXD,lHPXDjJXDRDX@PXDjtXDH,nPXDj@XD4`@PXD,ZHPXD4,@PXD4:4"PXDH,\PXD4"PXD,hPXDRDX@P\

Hexdump:

00000000  5e 46 5a 6a 66 44 58 56  4c 5c 2c 4c 50 58 44 24  |^FZjfDXVL\,LPXD$|
00000010  24 34 22 50 58 44 2c 6c  48 50 58 44 6a 4a 58 44  |$4"PXD,lHPXDjJXD|
00000020  52 44 58 40 50 58 44 6a  74 58 44 48 2c 6e 50 58  |RDX@PXDjtXDH,nPX|
00000030  44 6a 40 58 44 34 60 40  50 58 44 2c 5a 48 50 58  |Dj@XD4`@PXD,ZHPX|
00000040  44 34 2c 40 50 58 44 34  3a 34 22 50 58 44 48 2c  |D4,@PXD4:4"PXDH,|
00000050  5c 50 58 44 34 22 50 58  44 2c 68 50 58 44 52 44  |\PXD4"PXD,hPXDRD|
00000060  58 40 50 5c                                       |X@P\|
00000064

Utiliser une définition très vague de source comme quelque chose qui peut être raisonnablement typé par un humain et inspiré du fichier de test antivirus standard EICAR (plus d’informations sur "Amusons-nous avec le fichier de test EICAR" chez Bugtraq).

En utilisant uniquement des octets ASCII non impairs imprimables (remarque: les opcodes affectant les mots tendent à être impairs, le bit W est le lsb de certains opcodes), il construit un fragment de code chez SP (que nous plaçons commodément juste après notre code de génération) , et l’exécution finit par tomber dans le code généré.

Il utilise le fait que la pile contient initialement un pointeur proche du début de la PSP et que le début de la PSP contient l' INT 20hinstruction (plus d'informations à ce sujet à l' adresse https://stackoverflow.com/questions/12591673/ ).

Source réelle:

; we want to generate the following fragment of code

;  5E                pop si             ; zero SI (pop near pointer to start of PSP)
;  46                inc si             ; set SI to 1
; loop:
;  B406              mov ah,0x6         ; \
;  99                cwd                ; >
;  4A                dec dx             ; > D-2106--DLFF
;  CD21              int 0x21           ; > DIRECT CONSOLE INPUT
;  7405              jz end             ; > jump if no more input
;  40                inc ax             ; > lsb 0/1 odd/even
;  21C6              and si,ax          ; > zero SI on first odd byte
;  EBF3              jmp short loop     ; /
; end:
;  96                xchg ax,si         ; return code
;  B44C              mov ah,0x4c        ; D-214C
;  CD21              int 0x21           ; TERMINATE WITH RETURN CODE

 pop si             ; this two opcodes don't need to be encoded
 inc si

 pop dx             ; DX = 20CD (int 0x20 at start of PSP)
 push byte +0x66
 inc sp
 pop ax
 push si
 dec sp
 pop sp             ; SP = 0x0166
 sub al,0x4c        ; B4
 push ax
 pop ax
 inc sp
 and al,0x24
 xor al,0x22        ; 06
 push ax
 pop ax
 inc sp
 sub al,0x6c
 dec ax             ; 99
 push ax
 pop ax
 inc sp
 push byte +0x4a    ; 4A
 pop ax
 inc sp
 push dx            ; [20]CD
 inc sp
 pop ax
 inc ax             ; 21
 push ax
 pop ax
 inc sp
 push byte +0x74    ; 74
 pop ax
 inc sp
 dec ax
 sub al,0x6e        ; 05
 push ax
 pop ax
 inc sp
 push byte +0x40    ; 40
 pop ax
 inc sp
 xor al,0x60
 inc ax             ; 21
 push ax
 pop ax
 inc sp
 sub al,0x5a
 dec ax             ; C6
 push ax
 pop ax
 inc sp
 xor al,0x2c
 inc ax             ; EB
 push ax
 pop ax
 inc sp
 xor al,0x3a
 xor al,0x22        ; F3
 push ax
 pop ax
 inc sp
 dec ax
 sub al,0x5c        ; 96
 push ax
 pop ax
 inc sp
 xor al,0x22        ; B4
 push ax
 pop ax
 inc sp
 sub al,0x68        ; 4C
 push ax
 pop ax
 inc sp
 push dx            ; [20]CD
 inc sp
 pop ax
 inc ax
 push ax            ; 21
 pop sp             ; now get the stack out of the way

MATL , 7 octets

l$Z$2\z

Le code source utilise le codage UTF-8. Donc, les octets source sont (en décimal)

108    36    90    36    50    92   122

L'entrée est un nom de fichier, pris comme une chaîne entre guillemets simples. La sortie est le nombre d'octets impairs dans le fichier, ce qui est vrai si et non nul.

Explication

l    % Push a 1. We use `l` instead of `1` to have an even value
$    % Input specificication. This indicates that the next function takes 1 input
Z$   % Input file name implicitly, read its raw bytes and push them as an array of chars
2\   % Modulo 2
z    % Number of nonzero values. This gives the number of odd bytes. Implicitly display

CJam, 18 17 15 octets

"<rj":(((*~:|X&

Suppose que les paramètres régionaux sont définis sur Latin-1. Essayez-le en ligne!

Comment ça fonctionne

La solution simple va comme suit.

q       e# Read all input from STDIN and push it as a string on the stack.
 :i     e# Cast each character to its code point.
   :|   e# Take the bitwise OR of all code points.
     X  e# Push 1.
      & e# Take the bitwise AND of the logical OR and 1.

Malheureusement, les caractères qet ine peuvent pas apparaître dans le code source. Pour contourner ce problème, nous allons créer une partie du code source ci-dessus de manière dynamique, puis évaluer la chaîne.

"<rj"         e# Push that string on the stack.
     :(       e# Decrement all characters, pushing ";qi".
       (      e# Shift out the first character, pushing "qi" and ';'.
        (     e# Decrement ';' to push ':'.
         *    e# Join "qi" with separator ':', pushing "q:i". 
          ~   e# Evaluate the string "q:i", which behaves as explained before.

Pyth, 20 à 13 octets

vj0>LhZ.BRj.z

Ou en binaire:

00000000: 01110110 01101010 00110000 00111110 01001100 01101000  vj0>Lh
00000006: 01011010 00101110 01000010 01010010 01101010 00101110  Z.BRj.
0000000c: 01111010                                               z

Essayez-le en ligne

Comment ça fonctionne

           .z   all lines of input
          j     join on newline
       .BR      convert each character to binary
   >LhZ         take the last (0 + 1) characters of each binary string
 j0             join on 0
v               evaluate as an integer

L'entier résultant est vérité (différent de zéro) si et seulement si l'un des octets était impair.

Gelée , 13 octets

24‘ịØBvF|\ṪBṪ

S'attend à l'entrée en tant qu'argument de ligne de commande cité. Essayez-le en ligne!

Hexdump

0000000: 32 34 fc d8 12 42 76 46 7c 5c ce 42 ce           24...BvF|\.B.

Retina , 106 octets

Supprime tous les caractères autorisés, puis fait correspondre les caractères restants. Les valeurs de vérité seront le nombre de caractères trouvés. Les valeurs de Falsey seront 0.

`"| |\$|&|\(|\*|,|\.|0|2|4|6|8|:|<|>|@|B|D|F|H|J|L|N|P|R|T|V|X|Z|\\|\^|`|b|d|f|h|j|l|n|p|r|t|v|x|z|\||~

.

Essayez-le en ligne

Puisque .ne correspond pas aux nouvelles lignes par défaut, je n'ai pas à les supprimer.

Perl 5+ -p0, 136 octets

Semblable à d'autres réponses, cela supprime tous les octets pairs et laisse tous les octets impairs (ce qui est la vérité).

tr<�
 "$&(*,.02468:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~€‚„†ˆŠŒŽ’”–˜šœž ¢¤¦¨ª¬®°²´¶¸º¼¾ÀÂÄÆÈÊÌÎÐÒÔÖØÚÜÞàâäæèêìîðòôöøúüþ><>d

Essayez-le en ligne!

Japt , 10 octets

ø0ôH² ®dZÄ

Essayez-le en ligne!

La page de codes de Japt est ISO-8859-1. Le code donne falsequand lui-même est entré comme une chaîne, donc une soumission valide.

Déballé et comment ça marche

Uø0ôHp2  mZ{ZdZ+1

Uø      Does input string contain any element in the following array...?
0ôHp2     Range of 0 to 32**2, inclusive
mZ{       Map...
ZdZ+1       Convert the number Z to a char having charcode 2*Z+1

Ne pas avoir String.c(obtenir charcode, ou mapper sur charcodes) était une douleur, mais heureusement il y a Number.d(convertir le nombre en char).

Il s'avère que Japt l'emporte sur CJam, Pyth et Jelly :)

Sans cette restriction, il y a deux façons de le faire sur 6 octets (en revenant à égalité avec CJam et Jelly):

®c uÃn

Unpacked: UmZ{Zc u} n

UmZ{   Map on each char...
Zc u     Convert to charcode modulo 2
}
n      Convert the resulting string to number

"000..000"est converti au nombre 0 (falsy) quelle que soit sa durée. D'un autre côté, tout ce qui contient 1 est converti en un non nul double, ou Infinitys'il est trop gros (les deux en vérité).

¬d_c u

Unpacked: q dZ{Zc u

q    Convert to array of chars
dZ{  Is something true when mapped with...
Zc u   Convert each char to charcode modulo 2

Une approche plus simple qui donne directement trueou false.

Ou, une solution de 5 octets est même possible avec l'aide de -dflag:

¨c u

Unpacked: q mZ{Zc u

q     Convert to array of chars
mZ{   Map...
Zc u    Convert to charcode modulo 2

      Result is array of zeros and ones
-d    Apply .some() on the resulting array