Écrivez du code qui prend une chaîne en entrée et génère une valeur true ou falsey selon que la chaîne suit ou non ces règles:

Si vous empilez chaque caractère les uns sur les autres, convertissez en binaire et additionnez chaque colonne, alors toutes les sommes doivent être identiques. Vous pouvez supposer que la chaîne d'entrée ne contient que des caractères ASCII imprimables (points de code 32 à 126).

Par exemple:

L'entrée O5vy_+~doit renvoyer une valeur véridique, car sa représentation binaire est:

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

L'entrée PPCGdoit renvoyer une valeur de falsey, car sa représentation binaire est:

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

La torsion est la suivante: votre code doit retourner une valeur véridique s'il est utilisé comme entrée pour votre fonction / programme. C'est-à-dire que le code doit respecter les mêmes règles que ci-dessus (votre code peut contenir des caractères qui ne sont pas ASCII 32-126).

Votre programme / fonction n'a besoin que de gérer l'ASCII imprimable en entrée. Si votre code contient autre chose, un codage 8 bits, 16 bits, Unicode, un jeu de caractères personnalisé (ou quelque chose d'autre), alors sa représentation binaire doit respecter les mêmes règles, mais votre code n'a pas besoin de le gérer comme entrée.

Il s'agit de code-golf , donc les règles standard s'appliquent.

JavaScript (ES6), 123 122 120 110 octets

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

Ci-dessous se trouve un hexdump avec des sommes 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

Démo

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 octets

BXs&=?I&]

L'entrée est une chaîne entourée de guillemets simples (si l'entrée contient des qoutes simples, échappez-les en les dupliquant).

La sortie est 3aussi vraie et rien (sortie vide) que la fausse.

Essayez-le en ligne!

Le code en binaire est le suivant:

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

Explication

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)

Gelée , 11 10 octets

OBUSE&889.

Essayez-le en ligne! Ou consultez les tests et la saisie automatique (le code est entièrement ASCII imprimable, qui ont les mêmes valeurs dans la page de codes de Jelly, comme indiqué ci-dessous).

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

Comment?

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)

Gelée , 11 10 octets

OBUSE$*8?8

N'utilise aucun no-op ou commentaire.

Essayez-le en ligne!

Panne binaire

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

Comment ça marche

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 octets

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

Contient de nombreux caractères non imprimables entre les guillemets. A 49 de chaque bit.

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

Octave, 53 52 octets

Faire une réécriture complète m'a aidé à jouer au code 5 octets, mais j'ai dû ajouter plus d'opérations, ce qui en fait une sauvegarde nette de seulement 1 octet.

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

Je ne peux pas ajouter de lien TIO, car aucun des interprètes en ligne n'a implémenté la boîte à outils de communication nécessaire pour de2bi. Le dec2binremplacer à la place coûterait 4 octets (2 pour le code de travail et deux no-ops).

Je n'ai trouvé aucun moyen d'éviter l'un des 27 no-ops. Tous les noms de fonction et les parenthèses sont compris entre 64 et 96, ce qui signifie que tous les caractères "nécessaires" ont un 1 en 6ème position (à partir de la droite, 2 ^ 5). J'avais une solution avec seulement 23 no-ops, mais le code lui-même était plus long. Le code réel est de 25 octets et a la somme de colonnes suivante lors du comptage des bits de l'équivalent binaire:

15   22    6   15   10    9   13

Il y a 22 bits en 6ème position à partir de la droite (2 ^ 5), et seulement 6 bits en 4ème position à partir de la droite (2 ^ 3). Cela signifie que nous devons ajouter au moins 16 octets, pour obtenir le 6 jusqu'à 22. Maintenant, le caractère de commentaire %ajoute un peu à la 6e position, en l'augmentant à 23. Tous les caractères ASCII imprimables ont besoin d'au moins l'un des deux bits supérieurs à être 1. Par conséquent, l'ajout de 17 octets nous donnera au moins 27 bits dans chacun des deux "premiers spots" (2 ^ 6 et 2 ^ 5). Maintenant, nous avons 27 bits dans les deux premières places et 22 dans les autres. Afin d'arriver à un équilibre, nous devons ajouter 10 octets, pour arriver à un même 32 bits dans chaque position.

Une explication du nouveau code (52 octets):

@(_)~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 vecteur contenant seulement 1s (vrai) est évalué comme vrai en octave, et un vecteur contenant au moins un zéro est évalué comme faux en octave.

Une explication de l'ancien code (53 octets):

@(_)!((_=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 vecteur contenant seulement 1s (vrai) est évalué comme vrai en octave, et un vecteur contenant au moins un zéro est évalué comme faux en octave.

JavaScript (ES6), 139 111 107 octets

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

Contient 81 63 61 de chaque bit.

Scala, 149 octets

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

Usage:

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

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

Explication:

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 octets

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

Essayez-le en ligne! Comprend des cas de test pour la plupart des soumissions soumises, ainsi que le code source.

Haskell , 118 octets

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

Essayez-le en ligne! Utilisation: _Z "some string"renvoie soit Trueou False.

Il y a quelques caractères non imprimables dans le commentaire sur la dernière ligne, voici donc une chaîne du programme utilisant des caractères d'échappement:

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

Chaque bit se produit 68 fois.

Le code le plus court que j'ai trouvé était de 82 octets:

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

Cependant, les sommes des bits pour ce code sont [33,28,41,48,20,79,46], donc 79 - 20 = 59pas d'opérations plus 2 octets pour commencer un commentaire seraient en outre nécessaires, totalisant 143 octets.

En réorganisant le programme, j'ai trouvé que l'utilisation de lettres majuscules comme noms de variable aide à niveler les sommes car elles n'ont pas le bit en 6ème position. Parce que Haskell ne permet pas aux noms de variables de commencer par une lettre majuscule, ils doivent être ajoutés au début _, ce qui ne définit pas non plus le 6e bit.

Ce faisant, je me suis retrouvé avec la solution ci-dessus qui a 97 octets avant d'ajouter les no-ops et la somme des bist [50,47,56,56,48,68,60], donc (68 - 47) = 21, seulement 21 octets doivent être ajoutés dans le commentaire.

PHP, 95 93 91 octets

Je suis tellement content que les noms de fonction PHP ne respectent pas la casse!

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

où *doit être remplacé par ASCII 151 (0x97). (PHP se plaindrait de tout caractère de contrôle dans le code - à part \ret \n, mais j'ai besoin de quelque chose avec le bit 4 défini, j'ai donc ajouté 128.)

+1 octet pour ASCII imprimable pur: utilisez à la _7place.

Exécutez-le echo '<input>' | php -nR '<code>'ou testez-le en ligne . La sortie est 1pour la vérité, vide pour la fausse.

Python 2, 117 octets

Tous les "espaces" sont des onglets pour réduire le nombre de bits 0x20.

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

Contient 66 de chaque bit. (Il n'y en a pas '%07b'comme expliqué dans ce numéro .)

Vidage hexadécimal:

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