Viết mã tự xác nhận


28

Viết mã lấy một chuỗi làm đầu vào và xuất ra giá trị trung thực hoặc falsey tùy thuộc vào việc chuỗi đó có tuân theo các quy tắc sau hay không:

Nếu bạn xếp chồng từng ký tự lên nhau, chuyển đổi thành nhị phân và tính tổng từng cột, thì tất cả các khoản tiền phải giống hệt nhau. Bạn có thể giả sử chuỗi đầu vào chỉ chứa các ký tự ASCII có thể in được (các điểm mã 32 - 126).

Ví dụ:

Đầu vào O5vy_+~sẽ trả về một giá trị trung thực, vì biểu diễn nhị phân của nó là:

1001111  | O
0110101  | 5
1110110  | v
1111001  | y
1011111  | _
0101011  | +
1111110  | ~
-------
5555555  <- Sum of bits in each column. Should give a truthy value.

Đầu vào PPCGsẽ trả về giá trị falsey, vì biểu diễn nhị phân của nó là:

1010000  | P
1010000  | P
1000011  | C
1000111  | G
-------
4020122  <- Should give a falsey value

Vòng xoắn là: Mã của bạn sẽ trả về giá trị trung thực nếu nó được sử dụng làm đầu vào cho chức năng / chương trình của bạn. Tức là mã phải tuân thủ các quy tắc như trên (mã của bạn có thể chứa các ký tự không phải là ASCII 32-126).

Chương trình / chức năng của bạn chỉ cần xử lý ASCII có thể in làm đầu vào. Nếu mã của bạn chứa một cái gì đó khác, mã hóa 8 bit, 16 bit, Unicode, một bộ ký tự được tạo tùy chỉnh (hoặc một thứ khác), thì biểu diễn nhị phân của nó phải tuân theo các quy tắc tương tự, nhưng mã của bạn không cần phải xử lý nó làm đầu vào.

Đây là , vì vậy các quy tắc tiêu chuẩn được áp dụng.


Chuỗi đầu vào sẽ kéo dài bao lâu? Chúng ta có thể giả sử tổng sẽ luôn dài 7 chữ số không?
Okx

Ngoài ra, nếu chương trình của chúng tôi sử dụng các ký tự khác với các ký tự ASCII, điều gì xảy ra?
Okx

Tôi đoán rằng "khi đó biểu diễn nhị phân của nó phải tuân thủ các quy tắc tương tự" nên loại trừ rõ ràng mệnh đề "chỉ cần xử lý ASCII có thể in thành đầu vào" (nếu không, người ta có thể viết mã chỉ bằng một byte ánh xạ tới ASCII không in được) .
Jonathan Allan

@Okx bạn có thể giả sử chuỗi đầu vào nhỏ hơn 1kB. Đầu vào sẽ chỉ có thể in ASCII có thể được biểu diễn bằng 7 bit, vì vậy có: Sẽ luôn có 7 tổng (không nhất thiết phải là chữ số).
Stewie Griffin

2
@StewieGriffin Đó không phải là một giải thích rõ ràng. Nếu tôi có câu trả lời không phải ASCII, và bạn thử và nhập chương trình vào chương trình, và nó không hoạt động vì nó chỉ hỗ trợ ASCII, điều gì xảy ra?
Okx

Câu trả lời:


10

JavaScript (ES6), 123 122 120 110 byte

S=>[...S].map(S=>R.map((_GSSSSSSVWWW,V)=>R[V]-=S.charCodeAt()>>V&1),R=[_=3^3,_,_,_,_,_,_])&&!R.some(S=>S^R[_])

Dưới đây là một hexdump với số tiền bit.

Addr. | Dump                                            | #6 #5 #4 #3 #2 #1 #0
------+-------------------------------------------------+---------------------
00-0F | 53 3D 3E 5B 2E 2E 2E 53 5D 2E 6D 61 70 28 53 3D |  8 11  9 11  9  9  9
10-1F | 3E 52 2E 6D 61 70 28 28 5F 47 53 53 53 53 53 53 | 20 18 19 17 14 20 19
20-2F | 56 57 57 57 2C 56 29 3D 3E 52 5B 56 5D 2D 3D 53 | 30 24 32 25 26 30 29
30-3F | 2E 63 68 61 72 43 6F 64 65 41 74 28 29 3E 3E 56 | 41 37 37 32 34 38 36
40-4F | 26 31 29 2C 52 3D 5B 5F 3D 33 5E 33 2C 5F 2C 5F | 47 47 48 43 44 47 46
50-5F | 2C 5F 2C 5F 2C 5F 2C 5F 5D 29 26 26 21 52 2E 73 | 54 57 55 54 56 56 54
60-6D | 6F 6D 65 28 53 3D 3E 53 5E 52 5B 5F 5D 29       | 64 64 64 64 64 64 64

Bản giới thiệu


10

MATL , 10 9 byte

BXs&=?I&]

Đầu vào là một chuỗi được bao quanh bởi các dấu ngoặc đơn (nếu đầu vào chứa các qout đơn, thoát chúng bằng cách nhân đôi).

Đầu ra là 3trung thực và không có gì (đầu ra trống) là giả.

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

Mã trong nhị phân như sau:

B     1 0 0 0 0 1 0
X     1 0 1 1 0 0 0
s     1 1 1 0 0 1 1
&     0 1 0 0 1 1 0
=     0 1 1 1 1 0 1
?     0 1 1 1 1 1 1
I     1 0 0 1 0 0 1
&     0 1 0 0 1 1 0
]     1 0 1 1 1 0 1

Sum   5 5 5 5 5 5 5

Giải trình

B      % Input string (implicit). Convert each char to its ASCII code, and 
       % then to binary. This gives a binary matrix, with each char of the 
       % input corresponding to a row
Xs     % Sum of each column. Gives a row vector
&=     % All pairwise equality comparisons
?      % If all are true
  I    %    Push 3
  &    %    Specify that the next function, namely implicit display, will 
       %    take one input, instead of the whole stack which is the default
]      % End
       % Display (implicit)

8

Thạch , 11 10 byte

OBUSE&889.

Dùng thử trực tuyến! Hoặc xem các bài kiểm tra và tự nhập (mã là tất cả ASCII có thể in được, có cùng giá trị trong trang mã của Jelly, như được thấy bên dưới).

Char -> Hex -> Decimal -> Binary
O       0x4F   79         0b1001111
B       0x42   66         0b1000010
U       0x55   85         0b1010101
S       0x53   83         0b1010011
E       0x45   69         0b1000101
&       0x26   38         0b0100110
8       0x38   56         0b0111000
8       0x38   56         0b0111000
9       0x39   57         0b0111001
.       0x2E   46         0b0101110
                            -------
                            5555555

Làm sao?

OBUSE&889. - Main link: string
O          - cast to ordinals
 B         - convert to binary
  U        - upend (reverses each to prepare for vectorised sum)
   S       - sum (vectorises)
    E      - all equal? (yields 1 if all bit-sums are equal and 0 if not)
      889. - 889.0
     &     - bitwise and (1 & 889.0 is 1; and 0 & 889.0 is 0)

Mã của bạn trông giống như của Dennis.
Erik the Outgolfer

Vâng, tôi đã thấy sau.
Jonathan Allan

6

Thạch , 11 10 byte

OBUSE$*8?8

Sử dụng không có ý kiến ​​hay bình luận.

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

Sự cố nhị phân

O  1 0 0 1 1 1 1
B  1 0 0 0 0 1 0
U  1 0 1 0 1 0 1
S  1 0 1 0 0 1 1
E  1 0 0 0 1 0 1
$  0 1 0 0 1 0 0
*  0 1 0 1 0 1 0
8  0 1 1 1 0 0 0
?  0 1 1 1 1 1 1
8  0 1 1 1 0 0 0
————————————————
∑  5 5 5 5 5 5 5

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

OBUSE$*8?8  Main link. Argument: s (string)

O           Ordinal; map all characters in s to their code points.
 B          Binary; convert each code point to base 2.
  U         Upend; reverse each binary array to right-align the digits.
       8?   If 8 is non-zero (it is):
   SE$          Sum the corresponding digits and test the the sums for equality.
            Else (never happens):
      *  8      Raise all binary digits to the eighth power.

Có phải Jelly TC chỉ sử dụng ASCII có thể in?
Pavel

Tôi không nghĩ vậy.
Dennis

1
Tôi thích mã này bắt đầu OBUSEbởi vì nó nghe như thế ABUSE.
Esolanging Fruit 27/2/2017

4

Toán học, 88 byte

Total@IntegerDigits[ToCharacterCode@#,2,7]~MatchQ~{"?";a_ ..}&

Chứa nhiều ký tự không thể in giữa các dấu ngoặc kép. Có 49 mỗi bit.

Đây là hexdump:

0000-0010:  54 6f 74 61-6c 40 49 6e-74 65 67 65-72 44 69 67  Total@In tegerDig
0000-0020:  69 74 73 5b-54 6f 43 68-61 72 61 63-74 65 72 43  its[ToCh aracterC
0000-0030:  6f 64 65 40-23 2c 32 2c-37 5d 7e 4d-61 74 63 68  ode@#,2, 7]~Match
0000-0040:  51 7e 7b 22-3f 1f 1f 1f-1f 1f 1f 1f-1f 1f 1f 1f  Q~{"?... ........
0000-0050:  1f 1f 1f 1f-1f 1a 1a 1a-1a 18 18 18-18 18 10 22  ........ ......."
0000-0058:  3b 61 5f 20-2e 2e 7d 26                          ;a_...}&

4

Octave, 53 52 byte

Việc viết lại hoàn chỉnh đã giúp tôi đánh mã 5 byte, nhưng tôi phải thêm nhiều lệnh không hoạt động, làm cho nó chỉ tiết kiệm ròng chỉ 1 byte.

@(_)~diff(sum(de2bi(+_)))%RRPPPVVVW?????????________

Tôi không thể thêm liên kết TIO, vì không có trình thông dịch trực tuyến nào đã triển khai hộp công cụ giao tiếp cần thiết cho de2bi . Thay đổi nó thành dec2binthay thế sẽ tốn 4 byte (2 cho mã làm việc và hai no-op).

Tôi không tìm ra cách nào để tránh bất kỳ ai trong số 27 người không. Tất cả các tên hàm và dấu ngoặc đơn nằm trong khoảng dưới 64 hoặc cao hơn 96, có nghĩa là tất cả các ký tự "cần thiết" có 1 ở vị trí thứ 6 (từ bên phải, 2 ^ 5). Tôi đã có một giải pháp chỉ với 23 no-op, nhưng bản thân mã đã dài hơn. Mã thực tế là 25 byte và có tổng cột sau khi đếm các bit của nhị phân tương đương:

15   22    6   15   10    9   13

Có 22 bit ở vị trí thứ 6 từ bên phải (2 ^ 5) và chỉ có 6 bit ở vị trí thứ 4 từ bên phải (2 ^ 3). Điều đó có nghĩa là, chúng ta phải thêm ít nhất 16 byte, để có được 6 đến 22. Bây giờ, ký tự nhận xét% thêm một chút vào vị trí thứ 6, tăng nó lên 23. Tất cả các ký tự ASCII có thể in cần ít nhất một trong hai bit đầu để được 1. Do đó, việc thêm 17 byte sẽ cung cấp cho chúng tôi ít nhất 27 bit trong mỗi hai "vị trí hàng đầu" (2 ^ 6 và 2 ^ 5). Bây giờ, chúng ta có 27 bit ở hai vị trí hàng đầu và 22 bit còn lại. Để đạt đến trạng thái cân bằng, chúng ta phải thêm 10 byte, để có được 32 bit chẵn ở mỗi vị trí.

Giải thích về mã mới (52 byte):

@(_)~diff(sum(de2bi(+_)))
@(_)      % An anonymous function that take a variable _ as input
          % We use underscore, instead of a character, since it has the
          % most suitable binary represetation
              de2bi(+_)    % Convert the input string to a binary matrix
          sum(de2bi(+_))   % Take the sum of each column
     diff(sum(de2bi(+_)))  % And calculate the difference between each sum
    ~diff(sum(de2bi(+_)))  % Negate the result, meaning 0 becomes true, 
                           % and everything else becomes false

Một vectơ chỉ chứa 1s (true) được ước tính là true trong Octave và một vectơ chứa ít nhất một số 0 được ước tính là false trong Octave.

Giải thích về mã cũ (53 byte):

@(_)!((_=sum(de2bi(+_)))-_(1))%RRRFVVVVVVVVV_____????

@(_)      % An anonymous function that take a variable _ as input
          % We use underscore, instead of a character, since it has the
          % most suitable binary represetation
    !     % Negate the result, meaning 0 becomes true, and everything else becomes false
        de2bi(+_)         % Convert the input string to a binary matrix
    sum(de2bi(+_))        % Take the sum of each column
 (_=sum(de2bi(+_)))       % Assign the result to a new variable, also called _
                          % It's not a problem that we use the same variable name, due
                          % to the order of evaluation
((_=sum(de2bi(+_)))-_(1)) % Subtract the first element of the new variable _
                          % If all elements of the new variable _ are identical, then this
                          % should give us a vector containing only zeros,
                          % otherwise, at least one element should be non-zero
!((_=sum(de2bi(+_)))-_(1))  % And finally, we negate this.

Một vectơ chỉ chứa 1s (true) được ước tính là true trong Octave và một vectơ chứa ít nhất một số 0 được ước tính là false trong Octave.


3

JavaScript (ES6), 139 111 107 byte

f=
S=>![...""+1E6].some((____________ABQWWWWWWWWW,P)=>P*=R^(R^=R,[...S].map(Q=>R+=Q.charCodeAt()>>P&1),R),R=0)
<textarea oninput=o.textContent=f(this.value) style=width:100% rows=10>S=>![...""+1E6].some((____________ABQWWWWWWWWW,P)=>P*=R^(R^=R,[...S].map(Q=>R+=Q.charCodeAt()>>P&1),R),R=0)</textarea><div id=o>true

Chứa 81 63 61 của mỗi bit.


2

Scala, 149 byte

_.map(C=>("0"*7++(BigInt(C)toString 2))takeRight 7 map(_-48)).transpose.map(_.sum).toSet.size==1//______________________________

Sử dụng:

val f:(String=>Any)=_.map(C=>("0"*7++(BigInt(C)toString 2))takeRight 7 map(_-48)).transpose.map(_.sum).toSet.size==1//______________________________
println(f("string here")

Hexdump:

00000000  5f 2e 6d 61 70 28 43 3d  3e 28 22 30 22 2a 37 2b  |_.map(C=>("0"*7+|
00000010  2b 28 42 69 67 49 6e 74  28 43 29 74 6f 53 74 72  |+(BigInt(C)toStr|
00000020  69 6e 67 20 32 29 29 74  61 6b 65 52 69 67 68 74  |ing 2))takeRight|
00000030  20 37 20 6d 61 70 28 5f  2d 34 38 29 29 2e 74 72  | 7 map(_-48)).tr|
00000040  61 6e 73 70 6f 73 65 2e  6d 61 70 28 5f 2e 73 75  |anspose.map(_.su|
00000050  6d 29 2e 74 6f 53 65 74  2e 73 69 7a 65 3d 3d 31  |m).toSet.size==1|
00000060  2f 2f 5f 5f 5f 5f 5f 5f  5f 5f 5f 5f 5f 5f 5f 5f  |//______________|
00000070  5f 5f 5f 5f 5f 5f 5f 5f  5f 5f 5f 5f 5f 5f 5f 5f  |________________|
00000080  1f 1f 1f 1f 1e 1e 1e 1e  16 16 16 16 16 12 12 10  |................|
00000090  10 10 10 10 10                                    |.....|

Ung dung:

string =>
  string.map(char =>
    (
      "0" * 7 ++ BigInt(char).toString(2)
    ).takeRight(7).map(n=>n-48)
  ).transpose
  .map(bits=>bits.sum)
  .toSet
  .size == 1
  //______________________________

Giải trình:

string =>                      //create an anonymous function with a parameter string
  string.map(char =>           //map each char in the string to
    (
      "0" * 7                  //a string of 7 zeroes
      ++                       //concatenated with
      BigInt(char).toString(2) //the ascii value as a binary string
    ).takeRight(7)             //the last 7 items from this sequence
    .map(n=>n-48)              //where each digit is mapped to its numerical value
  ).transpose                  //transpose, so the colums become rows and vice-versa
  .map(bits=>bits.sum)         //maps the bits in each column to their sum
  .toSet                       //and convert the sequence of sums to a set
  .size == 1                   //which has 1 element of the sums are the same
  //______________________________


1

Haskell , 118 byte

_R _S=mod _S 2:_R(div _S 2)
_Z _S|_V:_W<-take 7.foldl1(zipWith(+))$_R.fromEnum<$>_S=all(==_V)_W
--________

Hãy thử trực tuyến! Cách sử dụng: _Z "some string"trả về TruehoặcFalse .

Có một số ký tự không thể in được trong phần bình luận ở dòng cuối cùng, vì vậy đây là một chuỗi chương trình sử dụng ký tự thoát:

"_R _S=mod _S 2:_R(div _S 2)\n_Z _S|_V:_W<-take 7.foldl1(zipWith(+))$_R.fromEnum<$>_S=all(==_V)_W\n--___\US\US\US\ETB\DC3\DC3\DC3\DC3\DC3\DC3\DC2\DC2_____"

Mỗi bit xảy ra 68 lần.


Mã ngắn nhất tôi nghĩ ra là 82 byte:

b n=mod n 2:b(div n 2)
(all=<<(==).head).take 7.foldl1(zipWith(+)).map(b.fromEnum)

Tuy nhiên, tổng của các bit cho mã này là [33,28,41,48,20,79,46], do đó, 79 - 20 = 59không có op-cộng với 2 byte để bắt đầu một bình luận cũng sẽ cần thiết, tổng cộng là 143 byte.

Trong khi sắp xếp lại chương trình, tôi thấy rằng sử dụng chữ in hoa làm tên biến sẽ giúp cân bằng các khoản tiền vì chúng không có bit ở vị trí thứ 6. Bởi vì Haskell không cho phép các tên biến bắt đầu bằng chữ in hoa mà chúng cần được thêm vào trước _, nó cũng không đặt bit thứ 6.

Để làm như vậy, tôi đã kết thúc với giải pháp trên có 97 byte trước khi thêm no-op và tổng bist vào [50,47,56,56,48,68,60], vì vậy (68 - 47) = 21, chỉ cần thêm 21 byte trong bình luận.


1

PHP, 95 93 91 byte

Tôi rất vui vì tên hàm PHP không phân biệt chữ hoa chữ thường!

FOR(ZZSSSSQ__*;$W=ORD($argn[$T++]);)FOR($V=7;$V--;)$R[$V]+=$W>>$V&1;PRINT MIN($R)==MAX($R);

trong đó *phải được thay thế bằng ASCII 151 (0x97). (PHP sẽ phàn nàn về bất kỳ ký tự điều khiển nào trong mã - ngoài \r\n, nhưng tôi cần một cái gì đó với bit 4 được đặt, vì vậy tôi đã thêm 128.)

+1 byte cho ASCII có thể in thuần túy: _7Thay vào đó hãy sử dụng .

Chạy với echo '<input>' | php -nR '<code>'hoặc kiểm tra nó trực tuyến . Đầu ra là 1cho sự thật, trống rỗng cho giả.


0

Python 2, 117 byte

Tất cả "khoảng trắng" là các tab để giảm số lượng bit 0x20.

def Y(S):
    O=map(sorted,zip(*['{:07b}'.format(ord(W))for   W   in  S]))
    return  O[1:]==O[:-1]#V_____________

Chứa 66 của mỗi bit. (Không có '%07b'giải thích nào trong vấn đề này .)

Đổ lục giác:

00000000: 64 65 66 09 59 28 53 29 3a 0a 09 4f 3d 6d 61 70  def.Y(S):..O=map
00000010: 28 73 6f 72 74 65 64 2c 7a 69 70 28 2a 5b 27 7b  (sorted,zip(*['{
00000020: 3a 30 37 62 7d 27 2e 66 6f 72 6d 61 74 28 6f 72  :07b}'.format(or
00000030: 64 28 57 29 29 66 6f 72 09 57 09 69 6e 09 53 5d  d(W))for.W.in.S]
00000040: 29 29 0a 09 72 65 74 75 72 6e 09 4f 5b 31 3a 5d  ))..return.O[1:]
00000050: 3d 3d 4f 5b 3a 2d 31 5d 23 56 5f 5f 5f 5f 5f 5f  ==O[:-1]#V______
00000060: 5f 5f 5f 5f 5f 5f 5f 16 16 16 16 16 16 16 16 16  _______.........
00000070: 16 16 14 14 10                                   .....

Nếu bạn đọc mô tả về báo cáo lỗi ... "độ phân giải: không phải là lỗi".
mbomb007
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.