Escriba el código que toma una cadena como entrada y genera un valor verdadero o falso dependiendo de si la cadena sigue o no estas reglas:

Si apila cada carácter uno encima del otro, convierte a binario y suma cada columna, entonces todas las sumas deben ser idénticas. Puede suponer que la cadena de entrada contiene solo caracteres ASCII imprimibles (puntos de código 32 - 126).

Como ejemplo:

La entrada O5vy_+~debe devolver un valor verdadero, ya que su representación binaria es:

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

La entrada PPCGdebe devolver un valor falsey, ya que su representación binaria es:

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

El giro es: su código debe devolver un valor verdadero si se usa como entrada para su función / programa. Es decir, el código debe cumplir con las mismas reglas que anteriormente (su código puede contener caracteres que no son ASCII 32-126).

Su programa / función solo necesita manejar ASCII imprimible como entrada. Si su código contiene algo más, 8 bits, codificación de 16 bits, Unicode, un juego de caracteres personalizado (o algo más), entonces la representación binaria del mismo debe cumplir con las mismas reglas, pero su código no necesita manejarlo como entrada

Este es el código golf , por lo que se aplican reglas estándar.

JavaScript (ES6), 123 122 120 110 bytes

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

Debajo hay un hexdump con sumas de bits.

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

Manifestación

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 bytes

BXs&=?I&]

La entrada es una cadena encerrada entre comillas simples (si la entrada contiene qoutes simples, escapéalos duplicando).

La salida es 3tan verdadera y nada (salida vacía) como falsa.

Pruébalo en línea!

El código en binario es el siguiente:

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

Explicación

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)

Jalea , 11 10 bytes

OBUSE&889.

¡Pruébelo en línea! O vea las pruebas y la entrada automática (el código es ASCII imprimible, que tiene los mismos valores en la página de códigos de Jelly, como se ve a continuación).

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

¿Cómo?

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)

Jalea , 11 10 bytes

OBUSE$*8?8

No utiliza no-ops o comentarios.

Pruébalo en línea!

Desglose binario

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

Cómo funciona

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 bytes

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

Contiene muchos caracteres no imprimibles entre las comillas. Tiene 49 de cada bit.

Aquí está el 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_...}&

Octava, 53 52 bytes

Hacer una reescritura completa me ayudó a desarrollar el código de 5 bytes, pero tuve que agregar más operaciones no, lo que lo hizo un ahorro neto de solo 1 byte.

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

No puedo agregar un enlace TIO, ya que ninguno de los intérpretes en línea ha implementado la caja de herramientas de comunicación necesaria para de2bi. Cambiarlo a su dec2binlugar costaría 4 bytes (2 para el código de trabajo y dos no-ops).

No encontré ninguna forma de evitar ninguna de las 27 operaciones no operativas. Todos los nombres de funciones y paréntesis se encuentran entre 64 o menos de 96, lo que significa que todos los caracteres "necesarios" tienen un 1 en la sexta posición (desde la derecha, 2 ^ 5). Tenía una solución con solo 23 no-ops, pero el código en sí era más largo. El código real es de 25 bytes y tiene la siguiente suma de columnas al contar los bits del equivalente binario:

15   22    6   15   10    9   13

Hay 22 bits en la sexta posición desde la derecha (2 ^ 5), y solo 6 bits en la cuarta posición desde la derecha (2 ^ 3). Eso significa que tenemos que agregar al menos 16 bytes, para obtener el 6 hasta el 22. Ahora, el carácter de comentario %agrega un poco a la sexta posición, incrementándolo a 23. Todos los caracteres ASCII imprimibles necesitan al menos uno de los dos pedazos superiores para ser 1. Por lo tanto, agregar 17 bytes nos dará al menos 27 bits en cada uno de los dos "puntos principales" (2 ^ 6 y 2 ^ 5). Ahora, tenemos 27 bits en los dos primeros lugares, y 22 en el resto. Para llegar a un equilibrio, tenemos que agregar 10 bytes, para llegar a 32 bits en cada posición.

Una explicación del nuevo código (52 bytes):

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

Un vector que contiene solo 1s (verdadero) se evalúa como verdadero en Octave, y un vector que contiene al menos un cero se evalúa como falso en Octave.

Una explicación del código anterior (53 bytes):

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

Un vector que contiene solo 1s (verdadero) se evalúa como verdadero en Octave, y un vector que contiene al menos un cero se evalúa como falso en Octave.

JavaScript (ES6), 139 111 107 bytes

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

Contiene 81 63 61 de cada bit.

Scala, 149 bytes

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

Uso:

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

Sin golf:

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

Explicación:

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 bytes

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

Pruébalo en línea! Incluye casos de prueba para la mayoría de los envíos enviados, junto con el código fuente.

Haskell , 118 bytes

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

Pruébalo en línea! Uso: _Z "some string"devuelve Trueo False.

Hay algunos caracteres no imprimibles en el comentario en la última línea, así que aquí hay una cadena del programa que usa caracteres escapados:

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

Cada bit ocurre 68 veces.

El código más corto que se me ocurrió fue de 82 bytes:

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

Sin embargo, las sumas de los bits para este código son [33,28,41,48,20,79,46], por 79 - 20 = 59lo que, además, se necesitarían no-operaciones más 2 bytes para comenzar un comentario, totalizando 143 bytes.

Al reorganizar el programa, descubrí que usar letras mayúsculas como nombres de variables ayuda a nivelar las sumas porque no tienen el bit en la sexta posición establecida. Debido a que Haskell no permite que los nombres de variables comiencen con una letra mayúscula, deben anteponerse _, lo que tampoco establece el sexto bit.

Al hacerlo, terminé con la solución anterior que tiene 97 bytes antes de agregar los no-ops y la suma de bist a [50,47,56,56,48,68,60], por (68 - 47) = 21lo que solo se deben agregar 21 bytes en el comentario.

PHP, 95 93 91 bytes

¡Estoy tan feliz de que los nombres de funciones PHP no distingan entre mayúsculas y minúsculas!

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

donde *debe ser reemplazado por ASCII 151 (0x97). (PHP se quejaría de cualquier carácter de control en el código, aparte de \ry \n, pero necesito algo con el bit 4 establecido, así que agregué 128).

+1 byte para ASCII puro imprimible: utilice en su _7lugar.

Ejecutar echo '<input>' | php -nR '<code>'o probarlo en línea . La salida es 1para la verdad, vacía para la falsedad.

Python 2, 117 bytes

Todos los "espacios" son pestañas para reducir el número de 0x20 bits.

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

Contiene 66 de cada bit. (No hay '%07b'como se explica en este número ).

Volcado hexadecimal:

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