Napisz kod, który pobiera ciąg jako dane wejściowe i wyprowadza wartość true lub falsey w zależności od tego, czy ciąg spełnia następujące zasady:

Jeśli ustawisz jeden znak jeden na drugim, przekonwertuj na binarny i zsumuje każdą kolumnę, wówczas wszystkie sumy powinny być identyczne. Możesz założyć, że ciąg wejściowy zawiera tylko drukowalne znaki ASCII (punkty kodowe 32–126).

Jako przykład:

Dane wejściowe O5vy_+~powinny zwracać prawdziwą wartość, ponieważ ich reprezentacja binarna to:

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

Dane wejściowe PPCGpowinny zwracać wartość falsey, ponieważ jej reprezentacja binarna to:

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

Rzecz w tym, że: Twój kod powinien zwrócić prawdziwą wartość, jeśli zostanie użyty jako dane wejściowe do twojej funkcji / programu. Oznacza to, że kod musi być zgodny z tymi samymi regułami, co powyżej (twój kod może zawierać znaki, które nie są ASCII 32-126).

Twój program / funkcja musi jedynie obsługiwać ASCII do wydruku jako dane wejściowe. Jeśli kod zawiera coś innego, kodowanie 8-bitowe, 16-bitowe, Unicode, niestandardowy zestaw znaków (lub coś innego), to jego binarna reprezentacja powinna być zgodna z tymi samymi regułami, ale kod nie musi się z tym obchodzić jako dane wejściowe.

To jest golf golfowy , więc obowiązują standardowe zasady.

JavaScript (ES6), 123 122 120 110 bajtów

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

Poniżej znajduje się zrzut heksowy z sumami bitów.

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

Próbny

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 bajtów

BXs&=?I&]

Dane wejściowe są łańcuchem zamkniętym pojedynczymi cudzysłowami (jeśli dane wejściowe zawierają pojedyncze kwanty, unikaj ich przez duplikowanie).

Wyjście jest 3tak prawdziwe i nic (puste wyjście) jak fałsz.

Wypróbuj online!

Kod binarny wygląda następująco:

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

Wyjaśnienie

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)

Galaretka , 11 10 bajtów

OBUSE&889.

Wypróbuj online! Lub zobacz testy i samodzielne wprowadzanie (cały kod to ASCII do wydruku, które mają takie same wartości na stronie kodowej Jelly, jak pokazano poniżej).

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

W jaki sposób?

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)

Galaretka , 11 10 bajtów

OBUSE$*8?8

Nie używa żadnych operacji ani komentarzy.

Wypróbuj online!

Podział binarny

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

Jak to działa

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 bajtów

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

Zawiera wiele niedrukowalnych znaków między cytatami. Ma 49 każdego bitu.

Oto zrzut heksowy:

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_...}&

Oktawa, 53 52 bajty

Dokonanie kompletnego przepisania pomogło mi w golfa w kodzie 5 bajtów, ale musiałem dodać więcej no-ops, dzięki czemu zaoszczędziłem tylko 1 bajt.

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

Nie mogę dodać łącza TIO, ponieważ żaden z tłumaczy internetowych nie wdrożył niezbędnego zestawu narzędzi komunikacji de2bi. Zmiana go na dec2binzamiast tego kosztowałaby 4 bajty (2 dla działającego kodu i dwa no-ops).

Nie znalazłem sposobu na uniknięcie żadnego z 27 zakazów. Wszystkie nazwy funkcji i nawiasy znajdują się między 64 lub powyżej 96, co oznacza, że ​​wszystkie „niezbędne” znaki mają 1 na 6. pozycji (od prawej 2 ^ 5). Miałem rozwiązanie z 23 brakami operacji, ale sam kod był dłuższy. Rzeczywisty kod ma 25 bajtów i ma następującą sumę kolumny przy zliczaniu bitów binarnego odpowiednika:

15   22    6   15   10    9   13

22 bity znajdują się na 6. pozycji z prawej strony (2 ^ 5), a tylko 6 bitów na 4. pozycji z prawej strony (2 ^ 3). Oznacza to, że musimy dodać co najmniej 16 bajtów, aby uzyskać liczbę 6 do 22. Teraz znak komentarza %dodaje nieco do 6. pozycji, zwiększając ją do 23. Wszystkie drukowane znaki ASCII potrzebują co najmniej jednego z dwóch najlepsze bity 1. Dlatego dodanie 17 bajtów da nam co najmniej 27 bitów w każdym z dwóch „górnych punktów” (2 ^ 6 i 2 ^ 5). Teraz mamy 27 bitów w dwóch najwyższych punktach, a 22 w pozostałych. Aby osiągnąć równowagę, musimy dodać 10 bajtów, aby uzyskać nawet 32 ​​bity w każdej pozycji.

Objaśnienie nowego kodu (52 bajty):

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

Wektor zawierający tylko 1s (prawda) jest oceniany na true w oktawie, a wektor zawierający co najmniej jedno zero jest oceniany na fałsz w oktawie.

Wyjaśnienie starego kodu (53 bajty):

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

Wektor zawierający tylko 1s (prawda) jest oceniany na true w oktawie, a wektor zawierający co najmniej jedno zero jest oceniany na fałsz w oktawie.

JavaScript (ES6), 139 111 107 bajtów

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

Zawiera 81 63 61 każdego bitu.

Scala, 149 bajtów

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

Stosowanie:

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

Nie golfowany:

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

Wyjaśnienie:

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 bajtów

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

Wypróbuj online! Obejmuje przypadki testowe dla większości przesłanych zgłoszeń wraz z kodem źródłowym.

Haskell , 118 bajtów

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

Wypróbuj online! Użycie: _Z "some string"zwraca albo Truealbo False.

W komentarzu do ostatniego wiersza jest kilka znaków niedrukowalnych, więc oto ciąg programu używającego znaków ucieczki:

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

Każdy bit występuje 68 razy.

Najkrótszy kod, jaki wymyśliłem, to 82 bajty:

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

Jednak sumy bitów dla tego kodu są [33,28,41,48,20,79,46], więc 79 - 20 = 59dodatkowe operacje i 2 bajty na początek komentarza byłyby dodatkowo potrzebne, łącznie w 143 bajtach.

Podczas przestawiania programu odkryłem, że użycie wielkich liter jako nazw zmiennych pomaga wyrównać sumy, ponieważ nie mają one bitu na 6. pozycji. Ponieważ Haskell nie pozwala, aby nazwy zmiennych zaczynały się od dużej litery, należy je poprzedzić _, co również nie ustawia szóstego bitu.

W ten sposób skończyłem z powyższym rozwiązaniem, które ma 97 bajtów przed dodaniem no-ops i sumy bist do [50,47,56,56,48,68,60], więc (68 - 47) = 21więc w komentarzu należy dodać tylko 21 bajtów.

PHP, 95 93 91 bajtów

Cieszę się, że nazwy funkcji PHP nie rozróżniają wielkości liter!

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

gdzie *należy zastąpić ASCII 151 (0x97). (PHP narzekałoby na dowolny znak kontrolny w kodzie - oprócz \ri \n, ale potrzebuję czegoś z ustawionym bitem 4, więc dodałem 128.)

+1 bajt dla czystego ASCII do wydruku: użyj _7zamiast tego.

Uruchom go echo '<input>' | php -nR '<code>'lub przetestuj online . Wyjście jest 1zgodne z prawdą, puste dla fałszu.

Python 2, 117 bajtów

Wszystkie „spacje” to tabulatory zmniejszające liczbę 0x20 bitów.

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

Zawiera 66 każdego bitu. (Nie ma, '%07b'jak wyjaśniono w tym numerze ).

Zrzut szesnastkowy:

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