स्व-सत्यापन कोड लिखें

Question

वह कोड लिखें जो एक स्ट्रिंग को इनपुट के रूप में लेता है, और यह इन नियमों का पालन करता है या नहीं, इसके आधार पर एक सत्य या गलत मूल्य को आउटपुट करता है:

यदि आप प्रत्येक चरित्र को एक-दूसरे के शीर्ष पर रखते हैं, तो बाइनरी में कनवर्ट करें और प्रत्येक कॉलम को सॉम्स करें, फिर सभी समरूप समान होना चाहिए। आप मान सकते हैं कि इनपुट स्ट्रिंग में केवल मुद्रण योग्य 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

---

मोड़ यह है: यदि आपके फ़ंक्शन / प्रोग्राम के इनपुट के रूप में इसका उपयोग किया जाता है, तो आपके कोड को एक सत्य मान वापस करना चाहिए। Ie कोड को ऊपर के समान नियमों का पालन करना चाहिए (आपके कोड में वर्ण शामिल हो सकते हैं जो ASCII 32-126 नहीं हैं)।

आपके प्रोग्राम / फ़ंक्शन को केवल इनपुट के रूप में मुद्रण योग्य ASCII को संभालने की आवश्यकता है। यदि आपके कोड में कुछ और है, 8 बिट, 16 बिट एन्कोडिंग, यूनिकोड, एक कस्टम मेड कैरेक्टर सेट (या कुछ और), तो इसका बाइनरी प्रतिनिधित्व समान नियमों का पालन करना चाहिए, लेकिन आपके कोड को इसे संभालने की आवश्यकता नहीं है इनपुट के रूप में।

यह कोड-गोल्फ है , इसलिए मानक नियम लागू होते हैं।

Comments

इनपुट स्ट्रिंग कब तक होगी? क्या हम मान सकते हैं कि योग हमेशा 7 अंक लंबा होगा?

— ओकेक्स

इसके अलावा, यदि हमारा कार्यक्रम ASCII वर्णों के अलावा अन्य वर्णों का उपयोग करता है, तो क्या होता है?

— 21

मुझे लगता है कि "तब इसका द्विआधारी प्रतिनिधित्व समान नियमों का पालन करना चाहिए" क्लॉज़ को स्पष्ट रूप से बाहर करना चाहिए "केवल इनपुट के रूप में मुद्रण योग्य एएससीआईआई को संभालने की आवश्यकता है" (अन्यथा कोई सिर्फ एक बाइट के साथ कोड लिख सकता है जो गैर-प्रिंट एएससीआईआई के लिए मैप करता है) ।

— जोनाथन एलन

@ ओके आप मान सकते हैं कि इनपुट स्ट्रिंग 1kB से कम है। इनपुट केवल मुद्रण योग्य ASCII होगा जिसे 7 बिट्स का उपयोग करके दर्शाया जा सकता है, इसलिए हां: हमेशा 7 पूर्णांक (जरूरी नहीं कि अंक) रकम होगी।

— स्टेवि ग्रिफिन

@StewieGriffin यह एक बहुत अच्छा स्पष्टीकरण नहीं है। अगर मेरे पास एक गैर-एएससीआईआई जवाब है, और आप कार्यक्रम में कार्यक्रम की कोशिश करते हैं और इनपुट करते हैं, और यह काम नहीं करता है क्योंकि यह केवल एएससीआईआई का समर्थन करता है, तो क्या होता है?

— 22

Answer 1

जावास्क्रिप्ट (ईएस 6), 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[_])

नीचे बिट्स के साथ एक हेक्सडंप है।

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[_])`))

Answer 2

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)

Answer 3

जेली , 11 10 बाइट्स

OBUSE&889.

यह ऑनलाइन की कोशिश करो! या परीक्षण और स्व-इनपुट देखें (कोड सभी मुद्रण योग्य ASCII है, जिसमें जेली के कोड पृष्ठ में समान मान हैं, जैसा कि नीचे देखा गया है)।

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)

Comments

आपका कोड बहुत हद तक डेनिस जैसा दिखता है।

— को आउटगोल्फ़र एरिक

हाँ, मैंने बाद में देखा।

— जोनाथन एलन

Answer 4

जेली , 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.

Comments

क्या जेली टीसी केवल मुद्रण योग्य ASCII का उपयोग कर रहा है?

— पावेल

मुझे ऐसा नहीं लगता।

— डेनिस

मुझे यह पसंद है कि यह कोड OBUSEइसलिए शुरू होता है क्योंकि यह लगता है ABUSE।

— फल

Answer 5

गणितज्ञ, 88 बाइट्स

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

उद्धरणों के बीच कई अनपेक्षित वर्ण शामिल हैं। प्रत्येक बिट के 49 है।

यहाँ हेक्सडम्प है:

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

Answer 6

ऑक्टेव, 53 52 बाइट्स

एक पूर्ण पुनर्लेखन करने से मुझे कोड 5 बाइट्स में मदद मिली, लेकिन मुझे अधिक नो-ऑप्स जोड़ना पड़ा, जिससे यह केवल 1 बाइट का शुद्ध-बचत हुआ।

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

मैं एक TIO- लिंक नहीं जोड़ सकता, क्योंकि किसी भी ऑनलाइन दुभाषिए ने संचार टूलबॉक्स को लागू नहीं किया है de2bi। dec2binइसके बजाय इसे बदलने पर 4 बाइट्स (काम करने वाले कोड के लिए 2, और दो नो-ऑप्स) खर्च होंगे।

मुझे 27 नो-ऑप्स में से किसी से बचने का कोई रास्ता नहीं मिला। सभी फ़ंक्शन नाम और कोष्ठक 64 से नीचे या 96 से अधिक के बीच हैं, जिसका अर्थ है कि सभी "आवश्यक" वर्णों में 6 वें स्थान पर 1 है (दाईं ओर, 2 ^ 5)। मेरे पास केवल 23 नो-ऑप्स के साथ एक समाधान था, लेकिन कोड स्वयं लंबा था। वास्तविक कोड 25 बाइट्स है, और बाइनरी समतुल्य के बिट्स की गिनती करते समय निम्नलिखित कॉलम राशि है:

15   22    6   15   10    9   13

दाएं (2 ^ 5) से 6 वें स्थान पर 22 बिट्स हैं, और दाईं ओर (2: 3) से 4 वीं स्थिति में केवल 6 बिट्स हैं। इसका मतलब है, हमें कम से कम 16 बाइट्स जोड़ने हैं, 6 को 22 तक लाने के लिए। अब, टिप्पणी चरित्र %6 वें स्थान पर थोड़ा जोड़ता है, इसे 23 तक बढ़ाता है। सभी मुद्रण योग्य ASCII- वर्णों को कम से कम दो में से एक की आवश्यकता होती है शीर्ष बिट्स होने के लिए 1। इसलिए, 17 बाइट्स जोड़ने से हमें दो "शीर्ष स्थानों" (2 ^ 6 और 2 ^ 5) में से प्रत्येक में कम से कम 27 बिट्स मिलेंगे। अब, हमारे पास शीर्ष दो स्थानों में 27 बिट हैं, और बाकी में 22 हैं। एक संतुलन प्राप्त करने के लिए, हमें प्रत्येक स्थिति में 32 बिट्स तक पहुंचने के लिए, 10 बाइट्स जोड़ना होगा।

नए कोड की एक व्याख्या (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) वाले वेक्टर का मूल्यांकन ऑक्टेव में सच करने के लिए किया जाता है, और ऑक्टेव में असत्य के लिए कम से कम एक शून्य वाले वेक्टर का मूल्यांकन किया जाता है।

पुराने कोड की व्याख्या (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) वाले वेक्टर का मूल्यांकन ऑक्टेव में सच करने के लिए किया जाता है, और ऑक्टेव में असत्य के लिए कम से कम एक शून्य वाले वेक्टर का मूल्यांकन किया जाता है।

Answer 7

जावास्क्रिप्ट (ईएस 6), 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।

Answer 8

स्काला, 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
  //______________________________

Answer 9

जे , 45 बाइट्स

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

इसे ऑनलाइन आज़माएं! स्रोत कोड के साथ जमा किए गए अधिकांश सबमिशन के लिए परीक्षण मामले शामिल हैं।

Answer 10

हास्केल , 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"तो Trueया False।

अंतिम पंक्ति पर टिप्पणी में कुछ अनपेक्षित वर्ण हैं, इसलिए यहां बच गए चार्ट का उपयोग करते हुए कार्यक्रम की एक स्ट्रिंग है:

"_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नो-ऑप्स प्लस 2 बाइट्स के लिए एक टिप्पणी शुरू करने के लिए इसके अतिरिक्त आवश्यकता होगी, कुल 143 बाइट्स में।

कार्यक्रम को पुनर्व्यवस्थित करते समय मैंने पाया कि ऊपरी नामों के अक्षरों को चर नामों के रूप में उपयोग करने से रकम को समतल करने में मदद मिलती है क्योंकि उनके पास छठवें सेट में बिट नहीं है। क्योंकि हास्केल चर नामों को एक ऊपरी मामले पत्र के साथ शुरू करने की अनुमति नहीं देता है _, जिनके साथ उन्हें पूर्वस्थापित करने की आवश्यकता होती है , जो 6 बिट भी सेट नहीं करता है।

ऐसा करने के बाद, मैंने उपरोक्त समाधान के साथ समाप्त कर दिया, जिसमें नो-ऑप और बीस्ट राशि को जोड़ने से पहले 97 बाइट्स हैं [50,47,56,56,48,68,60], इसलिए (68 - 47) = 21, टिप्पणी में केवल 21 बाइट्स जोड़ने की आवश्यकता है।

Answer 11

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- जोड़ा।)

शुद्ध मुद्रण योग्य ASCII के लिए +1 बाइट: _7इसके बजाय का उपयोग करें ।

इसे ऑनलाइन चलाएं echo '<input>' | php -nR '<code>'या परीक्षण करें । आउटपुट 1सत्य के लिए है, मिथ्या के लिए खाली है।

Answer 12

पायथन 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'व्याख्या नहीं की गई है ।)

हेक्स डंप:

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

Comments

यदि आप बग रिपोर्ट का विवरण पढ़ते हैं ... "रिज़ॉल्यूशन: बग नहीं"।

— mbomb007