प्राइमरी स्ट्रिंग्स

27

एक प्राइमरी ( बाइनरी-प्राइम ) स्ट्रिंग वह है, जिसे बाइनरी ग्रिड के रूप में लिखा जाता है, प्रत्येक पंक्ति और कॉलम में एक कुल योग होता है।

यह काफी अस्पष्ट व्याख्या है, तो चलिए इसे एक उदाहरण के साथ तोड़ते हैं ...

इस उदाहरण के लिए हम स्ट्रिंग का उपयोग करेंगे bunny:

सबसे पहले, प्रत्येक वर्ण और उसके बाइनरी प्रतिनिधित्व के ASCII कोड बिंदु को खोजें:

Char | ASCII | Binary

b      98      1100010
u      117     1110101
n      110     1101110
n      110     1101110
y      121     1111001

इन बाइनरी मानों को ऊपर से नीचे तक ले जाएं, और उन्हें ग्रिड में व्यवस्थित करें (यदि आवश्यक हो तो अग्रणी शून्य जोड़ते हुए)

1 1 0 0 0 1 0
1 1 1 0 1 0 1
1 1 0 1 1 1 0
1 1 0 1 1 1 0
1 1 1 1 0 0 1

फिर, 1प्रत्येक पंक्ति और कॉलम में s की संख्या गिनें:

1 1 0 0 0 1 0   > 3
1 1 1 0 1 0 1   > 5
1 1 0 1 1 1 0   > 5
1 1 0 1 1 1 0   > 5
1 1 1 1 0 0 1   > 5

v v v v v v v

5 5 2 3 3 3 2

यदि, और केवल यदि, प्रत्येक एकल कुल प्रमुख है (जैसे कि यहाँ) तो स्ट्रिंग एक वैध बाइनरी-प्राइम है।

चुनौती

आपका कार्य एक फ़ंक्शन या प्रोग्राम बनाना है, जब एक स्ट्रिंग दी जाती है, तो रिटर्न / आउटपुट truthyयदि स्ट्रिंग प्राइमरी है, और falsyअन्यथा।

नियमों / विवरण

  • आप मान सकते हैं कि स्ट्रिंग के अक्षर हमेशा ASCII रेंज 33-126(समावेशी) में होंगे।
  • स्ट्रिंग खाली नहीं होगी।
  • एक primenary स्ट्रिंग है नहीं एक प्रमुख लंबाई होना चाहिए - उदाहरण के लिए, W1n*4 अक्षर होने के बावजूद, मान्य है।
  • यह कोड-गोल्फ है , इसलिए सबसे छोटा उत्तर (बाइट्स में) जीतता है - लेकिन सभी प्रस्तुतियाँ स्वागत योग्य हैं।
  • मानक खामियों पर रोक लगाई जाती है।

परीक्षण के मामलों

'husband'     -> True
'HOTJava'     -> True
'COmPaTIBILE' -> True
'AuT0HACk'    -> True

'PPCW'        -> False
'code-golf'   -> False
'C++'         -> False
'/kD'         -> False

'HI'          -> False
'A'           -> False

वहाँ भी एक काम कर रहा है, लेकिन अविश्वसनीय रूप से क्रिया पायथन उदाहरण पर repl.it है कि आप के खिलाफ अपने समाधान का परीक्षण कर सकते हैं।

code-golf  string  primes  binary  decision-problem 
— FlipTack
स्रोत
क्या मैं पूछ सकता हूं कि आपने कैसे खोजा जो husbandवैध था? या उनमें से कोई? बड़ी समस्या है, हालांकि!
— गैब्रियल बेनामी
3
@GabrielBenamy मुझे खुशी है कि किसी ने पूछा! मैंने एक ऑनलाइन डिक्शनरी फ़ाइल के माध्यम से लूप किया , प्रत्येक अक्षर के कुछ यादृच्छिक पूंजीकरणों की कोशिश की, कभी-कभी संख्याओं के लिए अक्षरों को स्विच करना, आदि। फिर मैंने
— आउटपुट
हर 1-2 वर्ण इनपुट को वापसी की गारंटी है False, सही है?
— mbomb007
... क्योंकि 0और 1प्राइम नहीं हैं, और हर 1-2 चार इनपुट स्ट्रिंग में दिए गए रेंज में केवल चार होते हैं, जिसमें कम से कम एक 0या 1एक ऊर्ध्वाधर राशि के रूप में शामिल होने की गारंटी होती है। आपको परीक्षण मामलों के रूप में कुछ 1 और 2 वर्ण तार जोड़ना चाहिए।
— mbomb007
@ mbomb007 1 चार इनपुट में प्राइम नंबर कॉलमवाइज़ नहीं हो सकते हैं, इसलिए वे वापस आ जाएंगे false। 2 चार इनपुट हो सकते हैं, लेकिन ASCII रेंज में नहीं जिसका हम उपयोग कर रहे हैं, इसलिए इस परिदृश्य के लिए आप सही हैं।
— FlipTack

जवाबों:

8

MATL, 10 बाइट्स

BtXsw!shZp

इसे ऑनलाइन आज़माएं!

यह नौकरी के लिए आदर्श भाषा है। यह चुनौती के विनिर्देशन का शाब्दिक लिप्यंतरण है।

Bt % Converts input to binary matrix, duplicate
Xs  % Sum columns (alternative X version to prevent defaulting to sum along first non-singleton dimension, thanks @Jonathan Allan)
w! % Get the duplicate to the top of the stack, transpose
s  % Sum again
h  % Concatenate horizontally
Zp % Check primality element-wise. Display implicitly.

चूंकि कोई शून्य मेटा के अनुसार MATL सरणी को गलत बनाता है , इसलिए और कुछ की आवश्यकता नहीं है - मूल रूप से, एक निहित (यदि) Aकहा जाता है ?।

— Sanchises
स्रोत
aमिथ्या होना चाहिए, लेकिन रिटर्न 1 1? (इसके कॉलम primes तक नहीं जोड़ते हैं)
— FlipTack
मुझे लगता है कि BtXsw!shZpइसे ठीक करें और के लिए 10 एक विजेता होगा
— एलन जोनाथन
@ Flp.Tck पूरी तरह से पंक्ति वैक्टर के साथ काम करते समय MATLAB के 'क्षमा करने' के व्यवहार के बारे में भूल गया। मुझे क्षमा करें, इसे अभी ठीक कर दिया गया है।
— Sanchises
अब काम करता है :) (हो सकता है कि इसे अपडेट करने की कोशिश करें ऑनलाइन लिंक थो)
— FlipTack
@ Flp.Tkc किया। एक अच्छी चुनौती के लिए धन्यवाद!
— Sanchises
4

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

OBUZ;$S€ÆPẠ

TryItOnline! या सभी परीक्षण मामलों

कैसे?

OBUZ;$S€ÆPẠ - Main link: word                  e.g. ha!
O           - cast to ordinals                 e.g. [104,97,33]
 B          - convert to binary                e.g. [[1,1,0,1,0,0,0],[1,1,0,0,0,0,1],[1,0,0,0,0,1]]
  U         - reverse each entry (say "b")     e.g. [[0,0,0,1,0,1,1],[1,0,0,0,0,1,1],[1,0,0,0,0,1]]
     $      - last two links as a monad
   Z        - transpose                        e.g. [[0,1,1],[0,0,0],[0,0,0],[1,0,0],[0,0,0],[1,1,1],[1,1]]
    ;       - concatenate with "b"             e.g. [[0,1,1],[0,0,0],[0,0,0],[1,0,0],[0,0,0],[1,1,1],[1,1],[0,0,0,1,0,1,1],[1,0,0,0,0,1,1],[1,0,0,0,0,1]]
      S€    - sum €ach                         e.g. [2,0,0,1,0,3,2,3,3,2]
        ÆP  - is prime (1 if prime, 0 if not)  e.g. [1,0,0,0,0,1,1,1,1,1]
          Ạ - all truthy?                      e.g. 0
— जोनाथन एलन
स्रोत
3

जेली , 15 बाइट्स

O+⁹Bṫ€3µS€;SÆPP

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें। ।

व्याख्या

O+⁹Bṫ€3µS€;SÆPP  Main link. Input: string z
O                Ordinal, get ASCII value of each char
  ⁹              Nilad representing 256
 +               Add 256 to each ordinal value
   B             Binary digits of each
    ṫ€3          Tail, take each list of digits from the 3rd value to the end
                 These are the last seven digits of each
       µ         Start a new monadic chain
        S€       Sum each list of digits by rows
           S     Sum by column
          ;      Concatenate
            ÆP   Test if each is prime, 1 if true else 0
              P  Product
— मील की दूरी पर
स्रोत
3

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

And@@Join@@PrimeQ@{+##&@@#,+##&@@@#}&@IntegerDigits[ToCharacterCode@#,2,7]&

इनपुट के रूप में एक स्ट्रिंग लेने और वापस लौटने Trueया False।

ToCharacterCode@#इनपुट को अपने ASCII मूल्यों की सूची में परिवर्तित करता है; IntegerDigits[...,2,7]यदि आवश्यक हो तो प्रत्येक मान को उसके बिट्स की सूची में बदल देता है, लंबाई 7 तक गद्देदार। तो अब हमारे पास एक 2D सरणी है और हम इसकी सभी पंक्ति रकम और कॉलम रकम चाहते हैं; लो और निहारना, चरित्र-ऐंठन {+##&@@#,+##&@@@#}&@...ठीक यही करता है (यह +##&"सभी तर्कों को लागू करता है", पहले समन्वय का उपयोग करते हुए वैक्टर की सूची पर कार्य करता है @@, और प्रत्येक वेक्टर के रूप में दूसरे समन्वय का उपयोग करते हुए पूर्णांक की अपनी सूची के रूप में @@@) । फिर हम सिर्फ यह PrimeQजांचते हैं कि क्या परिणाम हैं , सूची को समतल करें Join@@, और Andउन सभी मूल्यों का ध्यान रखें।

— ग्रेग मार्टिन
स्रोत
2

रूबी -rprime , 100 बाइट्स

->s{a=s.bytes.map{|b|b.digits 2}
a.all?{|r|r.sum.prime?}&([0]*7).zip(*a).all?{|c|c.count(1).prime?}}

इसे ऑनलाइन आज़माएं!

व्याख्या

->s{
    a=s.bytes                       # Get byte values from string
             .map{|b|b.digits 2}    # For each, map it to its binary digits
                                    #   (least significant digits first)
a.all?{|r|r.sum.prime?}             # Each character has a prime number of 1's?
    &                               # Bit-and (because it saves bytes here)
    ([0]*7).zip(*a)                 # Zip bit array with an all-zero array
                                    #   (If we don't, then uneven array lengths
                                    #   cause some columns to not be returned.)
    .all?{|c|c.count(1).prime?}     # All columns have a prime number of 1's?
                                    #   (We use count instead of sum here because
                                    #   zip pads columns with trailing nils, which
                                    #   can't be added to numbers via sum.)
}
— मूल्य स्याही
स्रोत
1

पर्ल, 151 121 111 + 3 = 114 बाइट्स

साथ चलाना -lF। कार्यक्रम केवल पहले इनपुट के लिए सही ढंग से कार्य करेगा। अपने अगले इनपुट के लिए प्रोग्राम और रेरुन को समाप्त करें।

@ के लिए धन्यवाद मुझे बताने के लिए के //बाद Fबेमानी थे। अतिरिक्त बाइट को (112 के लिए) इनपुट को पाइप के जरिए अंदर से हटाया जा सकता है echo -n, लेकिन मुझे लगता है कि यह तकनीकी रूप से अधिक कोड जोड़ रहा है, इसलिए YMMV।

for$c(@a=map{sprintf"%07b",ord}@F){$b[$_].=substr$c,$_,1 for 0..6}s/0//g,$d|=/^1?$|^(11+?)\1+$/ for@a,@b;say!$d

पठनीय:

                                     #Implicitly split input into characters in @F array
for$c(@a=map{sprintf"%07b",ord}@F)  #Convert @F to 7-bit binary as @a, then loop through it                        
    $b[$_].=substr$c,$_,1 for 0..6   #Transpose @a's bits into @b
}
s/0//g,$d|=/^1?$|^(11+?)\1+$/ for@a,@b; #Remove any zeros, then run through composite regex
say!$d                          #If all composite regex checks fail, then it's fully prime.
— गेब्रियल बेनामी
स्रोत
1
एक संस्करण जो केवल पहले इनपुट पर काम करता है वह पूरी तरह से ठीक है, इसलिए आप 141 बाइट्स संस्करण को मुख्य एक के रूप में रख सकते हैं, और दूसरे को कई इनपुट पर उपयोग करने का सुझाव दे सकते हैं।
— दादा
यह भी ध्यान दें कि आप //बाद में छोड़ सकते हैं -F, और झंडे से echo -nछुटकारा पाने के लिए अंतिम न्यूलाइन (साथ ) के बिना इनपुट ले सकते हैं -l।
— दादा
1

पायथन 3, 228 227 225 बाइट्स

एक महान जवाब नहीं है, मैं इसे पसंद नहीं कर सकता था जितना मुझे पसंद था, लेकिन मैंने इसे इतना लंबा समय दिया, मुझे लगता है कि मुझे इसे पोस्ट करना चाहिए। बाइट्स काटने पर सुझाव बहुत सराहना की जाएगी।

r=range
n=[format(ord(c),"08b")for c in input()]
n=map(lambda s:s.count("1"),n+["".join([f[1]for f in filter(lambda e:e[0]%8<1,enumerate("X"*-~i+"".join(n)))][1:])for i in r(8)])
print(all(all(s%d for d in r(2,s))for s in n))

संपादित 1: एक बाइट खोने के e[0]%8==0साथ बदल दिया e[0]%8<1। धन्यवाद Flp.Tkc!

2 संपादित करें: के साथ (i + 1) - ~ i, दो अतिरिक्त बाइट्स खोना। यह जानने के लिए धन्यवाद कि मेरे बिट-स्तरीय ज्ञान कितना बुरा है :) इस संशोधन का परीक्षण करते समय, मुझे पता चला कि kappaयह मान्य है ... इससे क्या होगा।

— FourOhFour
स्रोत
1
आप को बदल सकता है e[0]%8==0करने के लिए e[0]%8<1?
— FlipTack
@ Flp.Tkc अच्छा स्थान! वहाँ कोई कारण नहीं है कि क्यों नहीं किया जा सकता है।
— फोरऑफोर
1
@ Flp.Tkc मुझे नहीं लगता कि मैं इसे फंक्शन बनाकर बाइट्स बचा सकता हूं। मुझे पसंद है कि आपने 404 प्रतिनिधि btw कैसे प्राप्त किया है :)
— FourOhFour
यह माना जाता है <1, नहीं <0?
— विनाशकारी नींबू
@Destructible तरबूज हां मुझे सही है कि।
— FourOhFour
1

ग्रूवी, 151 137 बाइट्स

{p={x->x<3||(2..(x**0.5)).every{x%it}};y={it.every{p(it.count("1"))}};x=it.collect{0.toString((int)it,2) as List};y(x)&&y(x.transpose())}

ग्रूवी में कोई भी प्रायोगिक जाँच नहीं ...

p={x->x<3||(2..(x**0.5)).every{x%it}}; - प्राणिकता परीक्षण के लिए बंद होना।

y={it.every{p(it.count("1"))}}; - यह सुनिश्चित करने के लिए बंद कर दिया गया है कि एक पारित बाइनरी 2 डी सरणी के लिए "1" की सभी गिनती प्रमुख हैं।

x=it.collect{0.toString((int)it,2) as List}; - स्ट्रिंग से बाइनरी सरणी तक कोवर्जन।

y(x)&&y(x.transpose()) - मुख्य मैट्रिक्स और ट्रांसपोज़्ड मैट्रिक्स में सभी प्राइम-वैलिडेटेड रकम के लिए, यह सुनिश्चित करें कि वे सही लौटें।

— जादू ऑक्टोपस Urn
स्रोत
1

पायथ , 37 बाइट्स

L.AmP_sdb=sMM.[L\0lh.MlZQ=.BMQ&yZy.TZ

इसे ऑनलाइन आज़माएं!

                                 Code | Explanation
--------------------------------------+----------------------------------------------------------------
L.AmP_sdb=sMM.[L\0lh.MlZQ=.BMQ&yZy.TZ | Full code
L                                     | Define function y(b):
   m    b                             |   For each d in b:
    P_sd                              |     Is the sum of the elements of the list prime?
 .A                                   |   Return whether all elements of the resulting list are truthy
                         =   Q        | Assign the following to Q:
                          .BMQ        |   The list of binary strings for each character in the input
         =             Z              | Assign the following to Z:
               L             Q        |   For every element in Q:
             .[ \0                    |     Pad with 0 on the left
                  lh.MlZQ             |     To the length of the longest element in Q
            M                         |   For each element in the resulting list:
          sM                          |     Convert each character to an integer
                              &yZ     | Print y(Z) AND
                                 y.TZ |   y( <Transpose of Z> )
— hakr14
स्रोत
1

ब्रेकीलॉग , 14 बाइट्स

ạḃᵐB↔ᵐz₁,B+ᵐṗᵐ

इसे ऑनलाइन आज़माएं!

सफलता या असफलता के माध्यम से आउटपुट। (सफलता के मामले में, आउटपुट चर के माध्यम से सभी कॉलम और पंक्ति रकम की एक सूची उपलब्ध है।

   B              The variable B is
ạ                 the codepoints of the input
 ḃᵐ               converted to lists of binary digits,
    ↔ᵐ            which with each list reversed
      z₁          then zipped without cycling
        ,B        and concatenated with B
          +ᵐ      has elements which all sum to
            ṗᵐ    prime numbers.
— असंबंधित स्ट्रिंग
स्रोत
1

O5AB1E, 12 बाइट्स

Çžy+bø€SOp¦W

इसे ऑनलाइन आज़माएं!

यह मेरा पहला कोड गोल्फ है इसलिए आसान चलें :)

Ç              % Converts the implicit input into ascii values
 žy+           % Adds 128 to each value, inspired by Emigna as a way to pad zeros
    b          % Convert all values into bits
     ø         % Transpose
      €SO      % Sum each string of binary digits created
         p¦    % Check if each element is prime and cut the first element out (adding 128 makes it equal to the number of characters)
           W   % Take the minimum value to effectively "and" all the elements
— एलेक्स वेसे-पर्लमैन
स्रोत
यह एकल पत्र इनपुट के लिए एक खाली परिणाम देता है। मैं O5AB1E में अच्छी तरह से वाकिफ नहीं हूँ, लेकिन अगर यह एक गलत मूल्य है, तो यह ठीक है।
— Sanchises
1

पायथन 3 , 209 189 180 171 160 बाइट्स

-9 बाइट्स के लिए थैंक्स स्क्वॉयड :)

def p(s):n=s.count('1');return(n>1)*all(n%i for i in range(2,n))
def f(s):t=[f'{ord(c):07b}'for c in s];return all(map(p,t+[[u[j]for u in t]for j in range(7)]))

इसे ऑनलाइन आज़माएं!

— movatica
स्रोत
मुझे पसंद है कि आपने टेस्ट केस प्रिंट स्टेटमेंट को कैसे फिर से लिखा है :)
— चलन
हाँ, मैं f- स्ट्रिंग्स के बारे में एक आकर्षक जुनूनी बाध्यकारी हूँ ... इसके अलावा, यदि आप t+मैप स्टेटमेंट में इसे हटाते हैं तो क्या यह समतुल्य नहीं है ?
— मोनिका
नहीं, क्योंकि प्राइम चेक को बिट मैट्रिक्स में पंक्तियों और स्तंभों को कवर करने की आवश्यकता होती है। tसभी पंक्तियाँ हैं, जबकि [[t[i][j]..i..]..j..]ट्रांसपोज़्ड है t, यानी कॉलम। यदि मैट्रिक्स को स्थानांतरित करने का एक छोटा तरीका है, तो हम और अधिक बाइट्स बचा सकते हैं :)
— movatica
यह काम कर रहा है जब मैं इसे आज़माता हूं , तो क्या आप एक तार के बारे में जानते हैं जो इसे तोड़ता है?
— मोनिका
हाँ। beezzझूठे लौटना चाहिए, लेकिन नहीं। यह इसलिए है क्योंकि प्राइम चेक टूट गया है, यह True4 बिट्स के लिए लौटता है । कोशिश करो print(p('1111'))। अब निश्चित कर दिया। सभी परीक्षण मामलों को कवर नहीं किया गया था, क्योंकि सभी इस्तेमाल किए गए अक्षर प्राइमरी थे।
— 19
1

के (ओके) , 40 33 बाइट्स

समाधान:

&/{2=+/d=_d:x%!x}'+/'m,+m:(7#2)\'

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

आधा मैट्रिक्स का निर्माण कर रहा है, अन्य आधा primality check है।

&/{2=+/d=_d:x%!x}'+/'m,+m:(7#2)\' / the solution
                                ' / apply to each (')
                               \  / decode
                          (   )   / do this together
                           7#2    / 7#2 => 2 2 2 2 2 2 2
                        m:        / save as m
                       +          / transpose
                     m,           / append to m
                  +/'             / sum (+/) each (')
                 '                / apply to each
  {             }                 / lambda taking implicit x
              !x                  / range 0..x
            x%                    / x divided by ...
          d:                      / save as d
         _                        / floor
       d=                         / equal to d?
     +/                           / sum (+/)
   2=                             / equal to 2?
&/                                / minimum
— streetster
स्रोत
0

जावास्क्रिप्ट, 234 बाइट्स

f=z=>(z=[...z].map(v=>v.charCodeAt(0))).map(v=>v.toString(2).replace(/0/g,"").length).every((p=v=>{for(i=2;i<v;i++){if(v%i===0){return 0}};return v>1}))&&[...""+1e6].map((v,i)=>z.reduce((a,e)=>!!(e&Math.pow(2,i))+a,0)).every(v=>p(v))

हम संख्याओं को बाइनरी में परिवर्तित करके क्षैतिज मान प्राप्त करते हैं, स्ट्रिंग प्रतिस्थापन का उपयोग करके शून्य हटाते हैं, और फिर 1s की गिनती करते हैं। ऊर्ध्वाधर sums 1 से 7 लूपिंग और बिटवाइज़ का उपयोग करके प्राप्त किए जाते हैं और 2 एनटी पावर तक बढ़ाए जाते हैं।

— Grax32
स्रोत
Math.pow(2,i)(1<<i)यह मानकर छोटा किया जा सकता है i<32, शायद 7 बाइट्स की बचत हो सकती है, हालांकि नहीं।
— नारूयोको
0

क्लोजर, 180 बाइट्स

#(let[S(for[i %](for[j[1 2 4 8 16 32 64]](min(bit-and(int i)j)1)))A apply](not-any?(fn[i](or(= i 1)(seq(for[d(range 2 i):when(=(mod i d)0)]d))))(into(for[s S](A + s))(A map + S))))

बिट लिस्ट जनरेट करने का एक छोटा तरीका और प्राइमलिटी टेस्ट भी हो सकता है।

— NikoNyrh
स्रोत
0

पायथन 3, 164 बाइट्स

import numpy;a=numpy.array([list(f'{ord(_):07b}')for _ in input()]).astype(int);print(all([(v>1)*all(v%i for i in range(2,v))for v in set(a.sum(0))|set(a.sum(1))]))
— Zulfiqaar
स्रोत
0

रूबी 2.7 -rprime, 95 बाइट्स

->s{a=s.bytes.map{[*@1.digits(2),0][..6]}
(a.map(&:sum)+a.transpose.map(&:sum)).all?(&:prime?)}

कोई भी TiO लिंक नहीं क्योंकि TiO अभी भी रूबी 2.5.5 चलाता है। 😭

व्याख्या

बहुत साधारण। पहली पंक्ति में प्रत्येक वर्ण के द्विआधारी अंक को एक सरणी के रूप में सात अंकों में रखा जाता है, जिसे वास्तव में आसान होना चाहिए:

a = s.bytes.map { [*@1.digits(2), 0][..6] }

की जाँच करें कि गिने ब्लॉक पैरामीटर ( @1) और beginless रेंज ( ..6) hotness ।

दूसरी पंक्ति पंक्तियों और स्तंभों और परीक्षणों को बताती है यदि वे सभी प्रमुख हैं:

(a.map(&:sum) + a.transpose.map(&:sum)).all?(&:prime?)
— जॉर्डन
स्रोत
0

जावास्क्रिप्ट (Node.js) , 149 146 ... 134 130 129 बाइट्स

x=>[...x].map(y=>a=[...a.map(n=>y.charCodeAt()&2**i++?++z&&-~n:n,z=i=0),z],a=[...Array(7)])&&!a.some(n=>(P=r=>n%--r?P(r):~-r)(n))

इसे ऑनलाइन आज़माएं!

व्याख्या

x=>                        // Main function:
 [...x].map(               //  For each y in x:
  y=>
   a=[...a.map(            //   For each i in range(0, len(a)):
    n=>                   
     y.charCodeAt()&2**i++ //    If y AND 2**i is not zero:
     ?++z&&-~n:n,          //     z = z + 1; a[i] = a[i] + 1 (1 if a[i] is undefined)
    z=i=0                  //   Initially z = 0
   ),z],                   //   Then push z at the end of a
  a=[...Array(7)]          //  Initially a = [undefined] * 7
 )&&!a.some(               //  Then for each n in a:
  n=>(
   P=r=>                   //   Composite function:
    n%--r?                 //    If n % (r - 1) == 0 or r == 1:
     P(r)                  //     Return P(r - 1)
    :~-r                   //    Else: Return r - 2
  )(n)                     //   Starting from r = n
 )                         //  Return whether the composite function returns 0 for all n.

यह भी कैसे काम करता है?

  • y.charCodeAt()&2**i
    • हमें इस कोड की आवश्यकता है y.charCodeAt()अगर 0 <= i < 7, और 0 अन्यथा की इसी बिट को वापस करने के लिए ।
    • जब i < 7, कोड स्पष्ट रूप से हमेशा की तरह काम करता है।
    • जब भी 7 <= i <= 32, इसी तरह का बिट y.charCodeAt()0 होता है, तो परिणाम अपेक्षित रूप से 0 होता है।
    • जब 32 < i < 1024, तब से int32(2**i) == 0, परिणाम 0 अपेक्षित है।
    • जब 1024 <= i, हमारे पास 2**i == Infinity, और तब से int32(Infinity) == 0, परिणाम 0 के रूप में अपेक्षित है।
  • (P=r=>n%--r?P(r):~-r)(n)
    • सादगी के लिए हम करते हैं R = --r = r - 1।
    • यह सहायक कार्य समाप्त हो जाता है जब n % R == 0या n % R is NaN।
      • n % R == 0: Rका एक कारक है n।
        • यदि R == 1, तो nप्राइम है क्योंकि सभी 1 < R < nविभाजित नहीं कर सकते हैं n। वापसी ० (झूठा)।
        • अगर है R == -1तो n == 0। वापसी -2 (सत्य)।
        • अन्यथा, R - 1जहां R - 1 > 0(सत्य) वापस लौटें ।
      • n % R is NaN: अमान्य मॉड्यूलर गणना।
        • यदि R == 0: n == 1। रिटर्न -1 (सत्य)।
        • यदि n is NaN: R is NaN। रिटर्न -1 (सत्य)।
    • नतीजतन, केवल जब R == 1यह फ़ंक्शन एक मिथ्या मान लौटा सकता है, तो यह दर्शाता nहै कि यह प्रमुख है।
— शायरु असकोतो
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.