Das Szenario

In letzter Zeit haben Sie ein merkwürdiges Verhalten mit Ihrem bevorzugten Texteditor festgestellt. Zuerst schien es, dass es zufällige Zeichen in Ihrem Code ignorierte, wenn auf die Festplatte geschrieben wurde. Nach einer Weile bemerkten Sie ein Muster; Zeichen mit ungeraden ASCII-Werten wurden ignoriert. Bei weiterer Überprüfung haben Sie festgestellt, dass Sie nur dann richtig in Dateien schreiben können, wenn jedes achte Bit Null ist. Jetzt müssen Sie wissen, ob Ihre wertvollen Dateien von diesem seltsamen Fehler betroffen sind.

Die Aufgabe

Sie müssen ein vollständiges Programm schreiben, das feststellt, ob eine Datei ungerade Bytes enthält (um zu demonstrieren, dass sie nicht beschädigt ist). Aufgrund Ihres Texteditors können Sie jedoch keine ungeraden Bytes in Ihren Quellcode schreiben. Sie können eine bereits vorhandene Codierung für die Eingabe annehmen, müssen jedoch jedes einzelne Byte und nicht nur Zeichen überprüfen.

Eingang

Ihr Programm übernimmt den Inhalt oder den Pfad zu einer Datei entweder über die Standard- oder die Befehlszeile.

Ausgabe

Ihr Programm gibt entweder einen Wahrheitswert aus, wenn die angegebene Datei ein ungerades Byte enthält, oder einen Fehler, wenn jedes achte Bit Null ist.

Kriterien

Dies ist Codegolf, das kürzeste Programm, das die Aufgabe abschließt, gewinnt. Um eine gültige Übermittlung zu sein, muss jedes achte Bit im Quellcode der Datei eine Null sein. Ich würde empfehlen, Ihrer Einreichung eine Kopie der Binärdateien Ihres Quellcodes beizufügen.

Es gelten Standardlücken .

Testfälle

(In ASCII-Codierung) Eingabe:

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

Output:
falsy

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

Output:
truthy

Input:
LOREMIPSVMDOLORSITAMETCONSECTETVRADIPISCINGELITSEDDOEIVSMODTEMPORINCIDIDVNTVTLABOREETDOLOREMAGNAALIQVA
VTENIMADMINIMVENIAMQVISNOSTRVDEXERCITATIONVLLAMCOLABORISNISIVTALIQVIPEXEACOMMODOCONSEQVAT
DVISAVTEIRVREDOLORINREPREHENDERITINVOLVPTATEVELITESSECILLVMDOLOREEVFVGIATNVLLAPARIATVR
EXCEPTEVRSINTOCCAECATCVPIDATATNONPROIDENTSVNTINCVLPAQVIOFFICIADESERVNTMOLLITANIMIDESTLABORVM

Output:
truthy

Tipps

• Wähle die Sprache mit Bedacht Diese Herausforderung ist möglicherweise nicht in jeder Sprache möglich

• Der Unix-Befehl xxd -b <file name>druckt die Binärdateien einer Datei auf die Konsole (zusammen mit einigen zusätzlichen Formatierungselementen).

• Sie können andere Kodierungen als ASCII wie UTF-8 verwenden, solange alle anderen Regeln eingehalten werden

GS2 , 4 Bytes

dΦ("

Probieren Sie es online!

Hexdump

0000000: 64 e8 28 22                                      d.("

Wie es funktioniert

      (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 Bytes

Ich weiß, dass dies eine alte Frage ist, aber ich wollte es versuchen, weil ich dachte, dass es eine interessante Herausforderung in Befunge sein würde.

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

Probieren Sie es online!

Es wird ausgegeben, 1wenn die Eingabe beschädigt ist (dh ein ungerades Byte enthält) und 0wenn es in Ordnung ist.

Erläuterung

Das Problem ist, wie man ungerade Bytes ermittelt, ohne Zugriff auf die Befehle /(dividieren) oder %(modulo) zu haben. Die Lösung bestand darin, den Wert mit 128 (der Sequenz 28*8**) zu multiplizieren und das Ergebnis in das Spielfeld zu schreiben. Bei einem strengen Standardinterpreter sind die Spielfeldzellen mit 8-Bit-Werten vorzeichenbehaftet, sodass eine ungerade Zahl multipliziert mit 128 auf -1 abgeschnitten wird, während eine gerade Zahl zu 0 wird.

Der andere Trick bestand darin, die -1 oder 0 vom Spielfeld zurückzulesen, ohne Zugriff auf den gBefehl (get) zu haben. Die Problemumgehung hierfür bestand darin, den Wert in die Mitte einer vorhandenen Zeichenfolgensequenz ( " ") zu schreiben und dann diese Sequenz auszuführen, um den eingeschlossenen Wert auf den Stapel zu verschieben. Zu diesem Zeitpunkt ist die Bestimmung der Unregelmäßigkeit des Bytes ein einfacher Test, der kleiner als Null ist.

Ein letzter Aspekt, den es zu diskutieren gilt, ist die Ausgabe. Im falschen Fall erreichen wir die >$.Sequenz mit nur einem Wert auf dem Stapel, $löschen also den Stapel und .geben eine Null aus. Im wahren Fall folgen wir dem Pfad 20`:>$.. Da zwei größer als Null sind, legt der Vergleich eine Eins auf den Stapel und erstellt :eine doppelte Kopie, damit $sie nicht gelöscht wird, bevor sie ausgegeben wird.

CJam (11 Bytes)

"r2":(~f&2b

Online-Demo

Das Entfernen der Tricks, um ungerade Bytes zu vermeiden, reduziert sich auf

q1f&2b

Dieser liest die Eingabe, bildet ein bitweises UND mit ab 1und führt dann eine Basisumwandlung durch, wobei Null erhalten wird, wenn alle UNDs Null waren.

Druckbare .COM-Datei, 100 Bytes

^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

Verwenden einer sehr losen Definition der Quelle als etwas, das von einem Menschen angemessen getippt werden kann und von der EICAR-Standard-Antivirus-Testdatei inspiriert ist (weitere Informationen unter "Viel Spaß mit der EICAR-Testdatei" bei Bugtraq).

Verwendet nur druckbare, nicht ungerade ASCII-Bytes (Randnotiz: Opcodes, die Wörter betreffen, sind in der Regel ungerade, das W-Bit ist das lsb einiger Opcodes), erstellt es ein Codefragment in SP (das wir praktischerweise direkt nach unserem generierenden Code setzen). und die Ausführung endet damit, dass sie zum generierten Code durchfällt.

Es wird die Tatsache ausgenutzt, dass der Stapel anfänglich einen Near-Zeiger auf den Start des PSP enthält und dass der Start des PSP die INT 20hAnweisung enthält (weitere Informationen hierzu unter https://stackoverflow.com/questions/12591673/ ).

Echte Quelle:

; 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 Bytes

l$Z$2\z

Der Quellcode verwendet UTF-8-Codierung. Die Quellbytes sind also (in Dezimalzahl)

108    36    90    36    50    92   122

Die Eingabe ist ein Dateiname, der als Zeichenfolge in einfachen Anführungszeichen angegeben wird. Die Ausgabe ist die Anzahl der ungeraden Bytes in der Datei, die wahrheitsgemäß ungleich Null ist.

Erläuterung

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 Bytes

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

Nimmt an, dass das Gebietsschema auf Latin-1 festgelegt ist. Probieren Sie es online!

Wie es funktioniert

Die einfache Lösung lautet wie folgt.

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.

Leider können die Zeichen qund inicht im Quellcode erscheinen. Um dieses Problem zu umgehen, werden wir einen Teil des obigen Quellcodes dynamisch erstellen und dann die Zeichenfolge auswerten.

"<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 Bytes

vj0>LhZ.BRj.z

Oder binär:

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

Probieren Sie es online aus

Wie es funktioniert

           .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

Die resultierende Ganzzahl ist wahr (ungleich Null), wenn eines der Bytes ungerade war.

Gelee , 13 Bytes

24‘ịØBvF|\ṪBṪ

Erwartet die Eingabe in Anführungszeichen als Befehlszeilenargument. Probieren Sie es online!

Hexdump

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

Netzhaut , 106 Bytes

Entfernt alle zulässigen Zeichen und stimmt mit den verbleibenden Zeichen überein. Wahrheitswerte sind die Anzahl der gefundenen Zeichen. Falsche Werte werden sein 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|\||~

.

Probieren Sie es online aus

Da .die Zeilenumbrüche standardmäßig nicht übereinstimmen, muss ich sie nicht entfernen.

Perl 5+ -p0, 136 Bytes

Ähnlich wie bei anderen Antworten werden alle geraden Bytes entfernt und alle ungeraden Bytes (was wahr ist) zurückgelassen.

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

Probieren Sie es online!

Japt , 10 Bytes

ø0ôH² ®dZÄ

Probieren Sie es online!

Die Codepage von Japt ist ISO-8859-1. Der Code gibt an, falsewenn er selbst als Zeichenfolge eingegeben wird, daher eine gültige Übermittlung.

Ausgepackt und wie es funktioniert

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

Nicht zu haben String.c(Zeichencode oder Karte über Zeichencodes zu bekommen) war ein Schmerz, aber zum Glück gibt es Number.d(Zahl in Zeichen umwandeln).

Es stellt sich heraus, dass Japt CJam, Pyth und Jelly gewinnt :)

Ohne Einschränkung gibt es mehrere Möglichkeiten, dies in 6 Bytes zu tun (wieder mit CJam und Jelly gleichzusetzen):

®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"wird in die Zahl 0 (falsch) umgewandelt, unabhängig davon, wie lange es dauert. Auf der anderen Seite wird alles, was 1 enthält, in einen Wert ungleich Null konvertiert doubleoder Infinitywenn es zu groß ist (beides ist wahr).

¬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

Einfacherer Ansatz, der direkt trueoder ergibt false.

Oder 5-Byte- Lösung ist sogar mit Hilfe von -dflag möglich:

¨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