Bir dizeyi girdi olarak alan ve dizginin bu kuralları izleyip izlememesine bağlı olarak bir gerçek veya falsey değeri veren bir kod yazın :

Her karakteri üst üste istiflerseniz, ikiliye dönüştürün ve her sütunu toplarsa, o zaman tüm toplamlar aynı olmalıdır. Giriş dizesinin yalnızca yazdırılabilir ASCII karakterleri içerdiğini varsayabilirsiniz (kod noktaları 32 - 126).

Örnek olarak:

O5vy_+~İkili gösterimi şu şekilde olduğundan giriş bir gerçek değer döndürmelidir:

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

PPCGİkili gösterimi şu şekilde olduğundan girdi bir falsey değeri döndürmelidir:

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

Büküm: Fonksiyonunuz / programınız için girdi olarak kullanılıyorsa, kodunuz bir gerçek değer döndürmelidir. Diğer bir deyişle, kod yukarıdakiyle aynı kurallara uymalıdır (kodunuz ASCII 32-126 olmayan karakterler içerebilir).

Programınızın / işlevinizin yalnızca yazdırılabilir ASCII'yi girdi olarak kullanması gerekir. Kodunuz başka bir şey içeriyorsa, 8 bit, 16 bit kodlama, Unicode, özel bir karakter kümesi (veya başka bir şey) varsa, bunun ikili gösterimi aynı kurallara uymalıdır, ancak kodunuzun onu işlemesi gerekmez giriş olarak.

Bu kod golf , yani standart kurallar geçerlidir.

JavaScript (ES6), 123 122 120 110 bayt

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

Aşağıda bit toplamı olan bir hexdump var.

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

gösteri

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 bayt

BXs&=?I&]

Giriş, tek tırnak işareti içine alınmış bir dizedir (giriş tek tırnak işaretleri içeriyorsa, çoğaltarak kaçış).

Çıktı 3aldatma kadar nahoş, hiçbir şey (boş çıktı) değildir.

Çevrimiçi deneyin!

İkili kod aşağıdaki gibidir:

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

açıklama

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)

Jöle , 11 10 bayt

OBUSE&889.

Çevrimiçi Deneyin! Veya testleri ve kendi kendine girişi görün (kodun tümü, aşağıda gösterildiği gibiJelly'in kod sayfasında aynı değerlere sahip olan yazdırılabilir ASCII'dir).

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

Nasıl?

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)

Jöle , 11 10 bayt

OBUSE$*8?8

No-ops veya yorum kullanmaz.

Çevrimiçi deneyin!

İkili arıza

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

Nasıl çalışır

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 bayt

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

Tırnaklar arasında yazdırılamayan birçok karakter var. Her bitin 49'u vardır.

İşte 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 bayt

Tam bir yeniden yazma yapmak bana kodu 5 byte'lık golf attı, ancak daha fazla no-op eklemek zorunda kaldım, sadece 1 byte'lık net tasarruf sağladım.

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

Bir TIO bağlantısı ekleyemiyorum, çünkü çevrimiçi tercümanların hiçbiri için gerekli olan iletişim araç kutusunu uygulamadı de2bi. Bunun dec2binyerine değiştirmek 4 bayta mal olur (çalışma kodu için 2 ve iki işlem dışı).

27 operasyondan hiçbirinden kaçınmanın bir yolunu bulamadım. Tüm fonksiyon isimleri ve parantezler 64'ün altında ya da 96'dan büyüktür, yani tüm "gerekli" karakterlerin 6. sırada bir 1'i vardır (sağdan 2 ^ 5). Sadece 23 tane ameliyat dışı olan bir çözüm buldum ama kodun kendisi daha uzundu. Gerçek kod 25 bayttır ve ikili eşdeğerin bitlerini sayarken aşağıdaki sütun toplamına sahiptir:

15   22    6   15   10    9   13

Sağda 6. sırada 22 bit (2 ^ 5) ve sağda 4. konumda sadece 6 bit (2 ^ 3) vardır. Bunun anlamı, 6'dan 22'ye kadar elde etmek için en az 16 bayt eklemek zorundayız . Şimdi, yorum karakteri %6. konuma biraz ekleyerek 23'e yükseltir. Tüm yazdırılabilir ASCII karakterlerinin ikisinden en az birine ihtiyacı vardır. olmak için en iyi bit 1. Bu nedenle, 17 bayt eklemek iki "en iyi nokta" nın her birinde en az 27 bit (2 ^ 6 ve 2 ^ 5) verecektir. Şimdi, ilk iki sırada 27, diğerlerinde 22 tane var. Bir dengeye ulaşmak için, her pozisyonda 32 bite eşit olmak için 10 bayt eklemek zorundayız.

Yeni kodun açıklaması (52 bayt):

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

Yalnızca 1'ler içeren bir gerçek (gerçek) Octave dilinde true olarak değerlendirilir ve en az bir sıfır içeren bir vektör Octave dilinde false olarak değerlendirilir.

Eski kodun açıklaması (53 bayt):

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

Yalnızca 1'ler içeren bir gerçek (gerçek) Octave dilinde true olarak değerlendirilir ve en az bir sıfır içeren bir vektör Octave dilinde false olarak değerlendirilir.

JavaScript (ES6), 139 111 107 bayt

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

İçeriyor 81 63 her bir bitin 61.

Scala, 149 bayt

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

Kullanımı:

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

Açıklama:

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 bayt

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

Çevrimiçi deneyin! Kaynak kodla birlikte gönderilen çoğu başvuru için sınama durumlarını içerir.

Haskell , 118 bayt

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

Çevrimiçi deneyin! Kullanımı: veya _Z "some string"birini döndürür .TrueFalse

Son satırdaki yorumda bazı yazdırılamayan karakterler var, bu yüzden kaçan karakterleri kullanan programın bir dizesi:

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

Her bit 68 kez gerçekleşir.

En kısa kod, 82 bayttı:

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

Bununla birlikte, bu kod için bitlerin toplamıdır [33,28,41,48,20,79,46], bu nedenle 79 - 20 = 59no-ops artı bir yorumu başlatmak için 2 bayt, ayrıca 143 bayt olmak üzere ek olarak gerekli olacaktır.

Programı yeniden düzenlerken büyük harfleri değişken isimler olarak kullanmanın toplamları dengelemeye yardımcı olduğunu buldum çünkü 6. pozisyonda bitleri yok. Çünkü Haskell değişken isimlerinin önceden hazırlanmaları gereken büyük harfle başlamasına izin vermiyor _, ki bu da 6. biti ayarlamıyor.

Bunu yaparken no-op'ları ve bist toplamını eklemeden önce 97 byte'a sahip olan yukarıdaki çözüme ulaştım [50,47,56,56,48,68,60], bu (68 - 47) = 21yüzden yoruma sadece 21 byte eklemem gerekiyor.

PHP, 95 93 91 bayt

PHP işlev adlarının büyük / küçük harf duyarsız olduğu için çok mutluyum!

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

burada *ASCII 151 (0x97) ile değiştirilmelidir. (PHP koddaki herhangi bir kontrol karakteri hakkında şikayet eder - dışında \rve\n , ancak bit 4 setli bir şeye ihtiyacım var, bu yüzden 128 ekledim.)

Yazdırılabilir ASCII için +1 bayt: Kullanım _7 Bunun yerine .

Çevrimiçi olarak çalıştırın echo '<input>' | php -nR '<code>'veya test edin . Çıktı 1gerçeğe uygun, sahte için boş.

Python 2, 117 bayt

Tüm "boşluklar", 0x20 bit sayısını azaltmak için kullanılan sekmelerdir.

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

Her bitin 66'sını içerir. ( Bu konuda'%07b' açıklandığı gibi bir şey yok . .)

Hex dökümü:

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