เขียนโค้ดที่รับสตริงเป็นอินพุทและเอาท์พุทค่าจริงหรือเท็จขึ้นอยู่กับว่าสตริงนั้นปฏิบัติตามกฎเหล่านี้หรือไม่:

หากคุณสแต็คอักขระแต่ละตัวอยู่ด้านบนของกันและกันให้แปลงเป็นไบนารีและผลรวมแต่ละคอลัมน์จากนั้นผลรวมทั้งหมดควรเหมือนกัน คุณอาจสันนิษฐานว่าสายป้อนมีอักขระ ASCII ที่พิมพ์ได้เท่านั้น (รหัสจุด 32 - 126)

ตัวอย่างเช่น:

อินพุตO5vy_+~ควรส่งคืนค่าความจริงเนื่องจากการแสดงไบนารีคือ:

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

อินพุตPPCGควรส่งคืนค่าเท็จเนื่องจากการแสดงไบนารีคือ:

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

การบิดคือ: รหัสของคุณควรคืนค่าความจริงถ้ามันถูกใช้เป็นข้อมูลเข้าสู่ฟังก์ชั่น / โปรแกรมของคุณ คือรหัสจะต้องเป็นไปตามกฎเดียวกันกับข้างต้น (รหัสของคุณสามารถมีตัวละครที่ไม่ใช่ ASCII 32-126)

โปรแกรม / ฟังก์ชั่นของคุณต้องการจัดการ ASCII ที่พิมพ์ได้เป็นอินพุตเท่านั้น หากรหัสของคุณมีอย่างอื่นการเข้ารหัส 8 บิต, 16 บิต, Unicode ชุดอักขระที่กำหนดเอง (หรืออย่างอื่น) จากนั้นการแสดงไบนารีของมันควรเป็นไปตามกฎเดียวกัน แต่รหัสของคุณไม่จำเป็นต้องจัดการกับมัน เป็นอินพุต

นี่คือรหัสกอล์ฟดังนั้นจึงใช้กฎมาตรฐาน

JavaScript (ES6), 123 122 120 110 ไบต์

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

ด้านล่างเป็น hexdump ที่มีผลรวมบิต

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

การสาธิต

let f =

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

console.log(f("O5vy_+~"))
console.log(f("Hello World!"))
console.log(f(`S=>[...S].map(S=>R.map((_GSSSSSSVWWW,V)=>R[V]-=S.charCodeAt()>>V&1),R=[_=3^3,_,_,_,_,_,_])&&!R.some(S=>S^R[_])`))

MATL , 10 9 ไบต์

BXs&=?I&]

อินพุตเป็นสตริงที่ล้อมรอบด้วยเครื่องหมายคำพูดเดี่ยว (หากอินพุตมี qoutes เดียวให้หลีกเลี่ยงโดยการทำซ้ำ)

เอาท์พุท3เป็นความจริงและไม่มีอะไร (เอาท์พุทที่ว่างเปล่า) เป็นเท็จ

ลองออนไลน์!

รหัสในไบนารีเป็นดังนี้:

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

คำอธิบาย

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)

เยลลี่ , 11 10 ไบต์

OBUSE&889.

ลองออนไลน์! หรือดูการทดสอบและการป้อนข้อมูลด้วยตนเอง (รหัสคือ ASCII ที่พิมพ์ได้ทั้งหมดซึ่งมีค่าเดียวกันในหน้ารหัสของ Jellyดังที่แสดงด้านล่าง)

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

อย่างไร?

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)

เจลลี่ , 11 10 ไบต์

OBUSE$*8?8

ไม่ใช้ตัวเลือกหรือความคิดเห็น

ลองออนไลน์!

รายละเอียดไบนารี

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

มันทำงานอย่างไร

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.

Mathematica, 88 ไบต์

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

มีอักขระที่ไม่สามารถพิมพ์ได้จำนวนมากระหว่างเครื่องหมายคำพูด มี 49 ของแต่ละบิต

นี่คือ 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_...}&

อ็อกเทฟ53 53ไบต์

การเขียนใหม่อย่างสมบูรณ์ช่วยให้ฉันตีกอล์ฟรหัส 5 ไบท์ได้ แต่ฉันต้องเพิ่ม no-ops มากขึ้นทำให้ประหยัดเพียง 1 ไบต์เท่านั้น

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

de2biฉันไม่สามารถเพิ่มติ้วลิงค์เนื่องจากไม่มีล่ามออนไลน์ได้ดำเนินการกล่องเครื่องมือการสื่อสารที่จำเป็นสำหรับ การเปลี่ยนเป็นdec2binแทนจะเสียค่าใช้จ่าย 4 ไบต์ (2 สำหรับรหัสการทำงานและไม่มีสองตัวเลือก)

ฉันไม่พบวิธีหลีกเลี่ยง 27-ops ใด ๆ ชื่อฟังก์ชันและวงเล็บทั้งหมดอยู่ระหว่าง 64 หรือต่ำกว่า 96 หมายถึงอักขระ "จำเป็น" ทั้งหมดมี 1 ในตำแหน่งที่ 6 (จากด้านขวา, 2 ^ 5) ฉันมีวิธีแก้ปัญหาโดยไม่มีเพียง 23-ops แต่รหัสตัวเองอีกต่อไป รหัสจริงคือ 25 ไบต์และมีผลรวมคอลัมน์ต่อไปนี้เมื่อนับจำนวนบิตของไบนารีเทียบเท่า:

15   22    6   15   10    9   13

มี 22 บิตในตำแหน่งที่ 6 จากด้านขวา (2 ^ 5) และมีเพียง 6 บิตในตำแหน่งที่ 4 จากด้านขวา (2 ^ 3) นั่นหมายความว่าเราต้องเพิ่มอย่างน้อย 16 ไบต์เพื่อให้ได้ 6 ถึง 22 ตอนนี้ตัวละครความคิดเห็น%เพิ่มขึ้นเล็กน้อยถึงอันดับที่ 6 เพิ่มขึ้นเป็น 23 ตัวอักษร ASCII ที่พิมพ์ได้ทั้งหมดต้องการอย่างน้อยหนึ่งในสอง 1บิตด้านบนจะเป็น ดังนั้นการเพิ่ม 17 ไบต์จะทำให้เรามีอย่างน้อย 27 บิตในแต่ละ "จุดสูงสุด" (2 ^ 6 และ 2 ^ 5) ตอนนี้เรามี 27 บิตในสองจุดบนสุดและ 22 ในส่วนที่เหลือ เพื่อให้ได้ดุลเราต้องเพิ่ม 10 ไบต์เพื่อให้ได้ 32 บิตในแต่ละตำแหน่ง

คำอธิบายของรหัสใหม่ (52 ไบต์):

@(_)~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

เวกเตอร์ที่มีเพียง 1s (true) จะถูกประเมินเป็นจริงใน Octave และเวกเตอร์ที่มีอย่างน้อยหนึ่งศูนย์จะถูกประเมินค่าเป็นเท็จใน Octave

คำอธิบายของรหัสเก่า (53 ไบต์):

@(_)!((_=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.

เวกเตอร์ที่มีเพียง 1s (true) จะถูกประเมินเป็นจริงใน Octave และเวกเตอร์ที่มีอย่างน้อยหนึ่งศูนย์จะถูกประเมินค่าเป็นเท็จใน Octave

JavaScript (ES6), 139 111 107 ไบต์

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

มี81 63 61 ของแต่ละบิต

สกาลา, 149 ไบต์

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

การใช้งาน:

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

Ungolfed:

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

คำอธิบาย:

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
  //______________________________

J , 45 ไบต์

[:(*/@:={.)[:+/2 #.inv 3 u:]NB.____UUUUUUUUDD

ลองออนไลน์! รวมถึงกรณีทดสอบสำหรับการส่งส่วนใหญ่พร้อมด้วยรหัสต้นฉบับ

Haskell , 118 ไบต์

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

ลองออนไลน์! การใช้งาน: _Z "some string"ผลตอบแทนอย่างใดอย่างหนึ่งหรือTrueFalse

มีตัวอักษรที่ไม่สามารถพิมพ์ได้ในความคิดเห็นในบรรทัดสุดท้ายดังนั้นนี่คือสตริงของโปรแกรมที่ใช้ตัวอักษรที่หลีกเลี่ยง:

"_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_____"

แต่ละบิตเกิดขึ้น 68 ครั้ง

รหัสที่สั้นที่สุดที่ฉันพบคือ 82 ไบต์:

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

อย่างไรก็ตามผลรวมของบิตสำหรับรหัสนี้[33,28,41,48,20,79,46]จึง79 - 20 = 59ไม่มี ops บวก 2 ไบต์สำหรับการเริ่มต้นความคิดเห็นจะต้องเพิ่มเติมนอกจากนี้รวมเป็น 143 ไบต์

ในขณะที่จัดเรียงโปรแกรมใหม่ฉันพบว่าการใช้ตัวอักษรตัวพิมพ์ใหญ่เป็นชื่อตัวแปรช่วยในการจัดระดับเงินก้อนเพราะพวกเขาไม่มีบิตในชุดอันดับที่ 6 เนื่องจาก Haskell ไม่อนุญาตให้ชื่อตัวแปรเริ่มต้นด้วยตัวอักษรตัวพิมพ์ใหญ่ที่พวกเขาต้องการที่จะเติมด้วย _ซึ่งยังไม่ได้ตั้งบิตที่ 6

ในการทำเช่นนั้นฉันลงเอยด้วยวิธีแก้ปัญหาข้างต้นซึ่งมี 97 ไบต์ก่อนเพิ่ม no-ops และผลรวม bist [50,47,56,56,48,68,60]ให้(68 - 47) = 21ดังนั้นจำเป็นต้องเพิ่ม 21 ไบต์เท่านั้นในข้อคิดเห็น

PHP, 95 93 91 ไบต์

ฉันมีความสุขมากที่ชื่อฟังก์ชัน PHP ไม่ตรงตามตัวพิมพ์ใหญ่และตัวพิมพ์เล็ก!

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

โดยที่*ต้องถูกแทนที่ด้วย ASCII 151 (0x97) (PHP จะบ่นเกี่ยวกับตัวควบคุมใด ๆ ในรหัส - นอกเหนือจาก\rและ\nแต่ฉันต้องการบางอย่างที่มีชุดบิต 4 ดังนั้นฉันจึงเพิ่ม 128)

+1 byte สำหรับ ASCII ที่พิมพ์บริสุทธิ์: ใช้_7แทน

ทำงานด้วยecho '<input>' | php -nR '<code>'หรือทดสอบออนไลน์ เอาท์พุท1สำหรับความจริงที่ว่างเปล่าสำหรับเท็จ

Python 2, 117 ไบต์

"ช่องว่าง" ทั้งหมดเป็นแท็บเพื่อลดจำนวน 0x20 บิต

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

มี 66 ของแต่ละบิต (ไม่มี'%07b'ตามที่อธิบายไว้ในปัญหานี้)

การถ่ายโอนข้อมูล Hex:

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