Kịch bản

Gần đây bạn đã nhận thấy một số hành vi lạ với trình soạn thảo văn bản yêu thích của bạn. Lúc đầu, dường như nó đã bỏ qua các ký tự ngẫu nhiên trong mã của bạn khi ghi vào đĩa. Sau một thời gian bạn nhận thấy một mô hình; các ký tự có giá trị ASCII lẻ đã bị bỏ qua. Khi kiểm tra thêm, bạn phát hiện ra rằng bạn chỉ có thể ghi vào tệp đúng nếu mỗi bit thứ tám bằng không. Bây giờ bạn cần phải biết nếu các tập tin có giá trị của bạn đã bị ảnh hưởng bởi lỗi lạ này.

Nhiệm vụ

Bạn phải viết một chương trình hoàn chỉnh để xác định xem một tệp có chứa bất kỳ byte lẻ nào không (chứng minh rằng nó không được sửa chữa). Nhưng do trình soạn thảo văn bản của bạn, bạn không thể viết bất kỳ byte lẻ nào trong mã nguồn của mình. Bạn có thể giả sử bất kỳ mã hóa có sẵn nào cho đầu vào, tuy nhiên bạn vẫn phải kiểm tra từng byte riêng lẻ, không chỉ các ký tự.

Đầu vào

Chương trình của bạn sẽ lấy nội dung hoặc đường dẫn đến một tệp từ stdin hoặc dòng lệnh.

Đầu ra

Chương trình của bạn sẽ xuất ra thiết bị xuất chuẩn một giá trị trung thực nếu tệp đã cho chứa một byte lẻ hoặc sai lệch nếu mỗi bit thứ tám bằng không.

Tiêu chí

Đây là mã golf, chương trình ngắn nhất hoàn thành nhiệm vụ sẽ thắng. Để là một đệ trình hợp lệ, mỗi bit thứ tám trong mã nguồn tệp phải là một số không. Tôi muốn giới thiệu bao gồm một bản sao nhị phân của mã nguồn trong bài gửi của bạn.

Tiêu chuẩn áp dụng.

Các trường hợp thử nghiệm

(Trong mã hóa ASCII) Đầu vào:

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

Output:
falsy

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

Output:
truthy

Input:
LOREMIPSVMDOLORSITAMETCONSECTETVRADIPISCINGELITSEDDOEIVSMODTEMPORINCIDIDVNTVTLABOREETDOLOREMAGNAALIQVA
VTENIMADMINIMVENIAMQVISNOSTRVDEXERCITATIONVLLAMCOLABORISNISIVTALIQVIPEXEACOMMODOCONSEQVAT
DVISAVTEIRVREDOLORINREPREHENDERITINVOLVPTATEVELITESSECILLVMDOLOREEVFVGIATNVLLAPARIATVR
EXCEPTEVRSINTOCCAECATCVPIDATATNONPROIDENTSVNTINCVLPAQVIOFFICIADESERVNTMOLLITANIMIDESTLABORVM

Output:
truthy

Lời khuyên

• Chọn ngôn ngữ một cách khôn ngoan Thử thách này có thể không thể thực hiện được trong mọi ngôn ngữ

• Lệnh Unix xxd -b <file name>sẽ in các tệp nhị phân của tệp lên bàn điều khiển (cùng với một số công cụ định dạng bổ sung)

• Bạn có thể sử dụng các bảng mã khác ngoài ASCII, chẳng hạn như UTF-8 miễn là tuân theo tất cả các quy tắc khác

GS2 , 4 byte

dΦ("

Hãy thử trực tuyến!

Hexdump

0000000: 64 e8 28 22                                      d.("

Làm thế nào nó hoạt động

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

Tôi biết đây là một câu hỏi cũ, nhưng tôi muốn thử vì tôi nghĩ nó sẽ là một thử thách thú vị trong Befunge.

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

Hãy thử trực tuyến!

Nó xuất ra 1nếu đầu vào bị hỏng (tức là chứa một byte lẻ) và 0nếu nó ổn.

Giải trình

Vấn đề là làm thế nào để xác định các byte lẻ mà không có quyền truy cập vào các lệnh /(chia) hoặc %(modulo). Giải pháp là nhân giá trị với 128 (chuỗi 28*8**), sau đó viết kết quả đó vào sân chơi. Trên một trình thông dịch tiêu chuẩn nghiêm ngặt, các ô của sân chơi được ký các giá trị 8 bit, do đó, một số lẻ nhân với 128 sẽ bị cắt thành -1 trong khi một số chẵn trở thành 0.

Thủ thuật khác là đọc lại -1 hoặc 0 từ sân chơi mà không có quyền truy cập vào lệnh g(get). Cách giải quyết cho vấn đề này là ghi giá trị vào giữa chuỗi chuỗi hiện có ( " "), sau đó thực hiện chuỗi đó để đẩy giá trị kèm theo lên ngăn xếp. Tại thời điểm đó, việc xác định độ lẻ của byte là một phép thử nhỏ hơn 0.

Một khía cạnh cuối cùng đáng thảo luận là đầu ra. Trong trường hợp sai, chúng ta đạt được >$.chuỗi chỉ với một giá trị trên ngăn xếp, do đó $xóa ngăn xếp làm cho .đầu ra bằng không. Trong trường hợp thực sự, chúng tôi đi theo con đường 20`:>$.. Vì hai giá trị lớn hơn 0, phép so sánh đẩy một cái lên ngăn xếp và :tạo một bản sao trùng lặp để $không bỏ nó trước khi nó được xuất.

CJam (11 byte)

"r2":(~f&2b

Bản demo trực tuyến

Tước đi các thủ thuật để tránh các byte lẻ, điều này giảm xuống

q1f&2b

trong đó đọc đầu vào, ánh xạ một chút theo AND 1và sau đó thực hiện chuyển đổi cơ sở, cho ra không có tất cả các AND đều bằng không.

Tệp .COM có thể in, 100 byte

^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

Sử dụng một định nghĩa nguồn rất lỏng lẻo như một thứ gì đó có thể được gõ bởi con người một cách hợp lý và được lấy cảm hứng từ Tệp thử nghiệm chống vi rút tiêu chuẩn EICAR (thông tin thêm tại "Hãy vui vẻ với tệp thử nghiệm EICAR" tại Bugtraq).

Chỉ sử dụng các byte ASCII không lẻ có thể in được (ghi chú bên: các mã ảnh hưởng đến các từ có xu hướng là số lẻ, bit W là lsb của một số opcodes), nó xây dựng một đoạn mã tại SP (mà chúng ta thuận tiện đặt ngay qua mã tạo của chúng ta) và thực thi kết thúc rơi vào mã được tạo.

Nó sử dụng thực tế là ngăn xếp ban đầu chứa một con trỏ gần đầu PSP và bắt đầu PSP chứa INT 20hhướng dẫn (thông tin thêm về điều này tại https://stackoverflow.com/questions/12591673/ ).

Nguồn thực:

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

l$Z$2\z

Mã nguồn sử dụng mã hóa UTF-8. Vì vậy, các byte nguồn là (ở dạng thập phân)

108    36    90    36    50    92   122

Đầu vào là một tên tệp, được lấy dưới dạng một chuỗi được đặt trong dấu ngoặc đơn. Đầu ra là số byte lẻ trong tệp, đây là sự thật iff nonzero.

Giải trình

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 byte

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

Giả sử rằng miền địa phương được đặt thành Latin-1. Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Các giải pháp đơn giản đi như sau.

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.

Thật không may, các ký tự qvà ikhông thể xuất hiện trong mã nguồn. Để giải quyết vấn đề này, chúng tôi sẽ tự động tạo một phần của mã nguồn ở trên, sau đó đánh giá chuỗi.

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

Bình thường, 20 13 byte

vj0>LhZ.BRj.z

Hoặc ở dạng nhị phân:

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

Dùng thử trực tuyến

Làm thế nào nó hoạt động

           .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

Số nguyên kết quả là trung thực (không khác) nếu bất kỳ byte nào là số lẻ.

Thạch , 13 byte

24‘ịØBvF|\ṪBṪ

Yêu cầu đầu vào là một đối số dòng lệnh được trích dẫn. Hãy thử trực tuyến!

Hexdump

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

Võng mạc , 106 byte

Xóa mọi ký tự được phép, sau đó khớp với bất kỳ ký tự nào còn lại. Giá trị thật sẽ là số lượng ký tự được tìm thấy. Giá trị Falsey sẽ được 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|\||~

.

Dùng thử trực tuyến

Vì .không phù hợp với các dòng mới theo mặc định, tôi không phải xóa chúng.

Perl 5 + -p0, 136 byte

Tương tự như các câu trả lời khác, điều này loại bỏ tất cả các byte chẵn và để lại bất kỳ byte lẻ nào (đó là sự thật).

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

Hãy thử trực tuyến!

Japt , 10 byte

ø0ôH² ®dZÄ

Hãy thử trực tuyến!

Bảng mã của Japt là ISO-8859-1. Mã cho falsekhi chính nó được nhập dưới dạng một chuỗi, do đó, đệ trình hợp lệ.

Giải nén & Cách thức hoạt động

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

Không có String.c(lấy charcode, hoặc ánh xạ qua charcodes) là một điều khó khăn, nhưng may mắn thay là có Number.d(chuyển đổi số thành char).

Hóa ra là Japt chiến thắng trước CJam, Pyth và Jelly :)

Không có giới hạn, có một số cách để thực hiện trong 6 byte (tương đương với CJam và Jelly một lần nữa):

®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"được chuyển đổi thành số 0 (giả) bất kể nó dài bao nhiêu. Mặt khác, bất cứ thứ gì chứa 1 đều được chuyển đổi thành một số khác doublehoặc Infinitynếu nó quá lớn (cả hai sự thật).

¬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

Cách tiếp cận đơn giản hơn mà trực tiếp mang lại truehoặc false.

Hoặc, giải pháp 5 byte thậm chí có thể với sự trợ giúp của -dcờ:

¨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