प्राइम बिट-काउंट्स के साथ प्राइम

Question

कार्य

सभी गैर नकारात्मक पूर्णांक के लिए और एक गैर शून्य सकारात्मक पूर्णांक दी सहित खोजें n , और की गिनती कि प्रधानमंत्री हैं 1'sऔर 0'sउनके द्विआधारी प्रतिनिधित्व में (कोई अग्रणी शून्य वाले) भी प्रधानमंत्री हैं।

यहां पहले ऐसे पांच अपराध हैं,

17, 19, 37, 41, 79

10001, 10011, 100101, 101001, 1001111

स्पष्टीकरण और नियम

• डिफ़ॉल्ट I / O विधियों को स्वीकार किया जाता है ।
• जवाब एक कार्यक्रम या एक समारोह हो सकता है।
• यदि इस तरह के प्राइम नहीं हैं तो आउटपुट कचरा या कुछ भी नहीं।
• मानक खामियों को मना किया जाता है।
• 2 3 5 7सूची में यह नहीं बनाया क्योंकि उनके द्विआधारी प्रतिनिधित्व की घटनाओं की संख्या 0'sऔर 1'sप्रमुख नहीं हैं। विचार करें कि 7द्विआधारी प्रतिनिधित्व किसका है 111, यहाँ 0शून्य काल होता है और शून्य अभाज्य नहीं है।

• बिल्ट-इन की अनुमति है।

• बाइट्स में सबसे छोटा कोड जीतता है!

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

10
[]

100
[१ 37, १ ९, ३ 37, ४१, 37 ९]

150
[17, 19, 37, 41, 79, 103, 107, 107, 109, 131, 137]

/* Configuration */

var QUESTION_ID = 107050; // Obtain this from the url
// It will be like http://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 47650; // This should be the user ID of the challenge author.

/* App */

var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;

function answersUrl(index) {
  return "http://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

function commentUrl(index, answers) {
  return "http://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}

function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}

function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      data.items.forEach(function(c) {
        if (c.owner.user_id === OVERRIDE_USER)
          answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });  
}

getAnswers();

var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;

var OVERRIDE_REG = /^Override\s*header:\s*/i;

function getAuthorName(a) {
  return a.owner.display_name;
}

function process() {
  var valid = [];
  
  answers.forEach(function(a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      if(OVERRIDE_REG.test(c.body))
        body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
    });
    
    var match = body.match(SCORE_REG);
    if (match)
      valid.push({
        user: getAuthorName(a),
        size: +match[2],
        language: match[1],
        link: a.share_link,
      });
    else console.log(body);
  });
  
  valid.sort(function (a, b) {
    var aB = a.size,
        bB = b.size;
    return aB - bB
  });

  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  valid.forEach(function (a) {
    if (a.size != lastSize)
      lastPlace = place;
    lastSize = a.size;
    ++place;
    
    var answer = jQuery("#answer-template").html();
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{LANGUAGE}}", a.language)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);

    var lang = a.language;
    lang = jQuery('<a>'+lang+'</a>').text();
    
    languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang, user: a.user, size: a.size, link: a.link};
  });

  var langs = [];
  for (var lang in languages)
    if (languages.hasOwnProperty(lang))
      langs.push(languages[lang]);

  langs.sort(function (a, b) {
    if (a.lang_raw.toLowerCase() > b.lang_raw.toLowerCase()) return 1;
    if (a.lang_raw.toLowerCase() < b.lang_raw.toLowerCase()) return -1;
    return 0;
  });

  for (var i = 0; i < langs.length; ++i)
  {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
                       .replace("{{NAME}}", lang.user)
                       .replace("{{SIZE}}", lang.size)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }

}

body { text-align: left !important}

#answer-list {
  padding: 10px;
  width: 290px;
  float: left;
}

#language-list {
  padding: 10px;
  width: 290px;
  float: left;
}

table thead {
  font-weight: bold;
}

table td {
  padding: 5px;
}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">
<div id="language-list">
  <h2>Shortest Solution by Language</h2>
  <table class="language-list">
    <thead>
      <tr><td>Language</td><td>User</td><td>Score</td></tr>
    </thead>
    <tbody id="languages">

    </tbody>
  </table>
</div>
<div id="answer-list">
  <h2>Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>
    </thead>
    <tbody id="answers">

    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="language-template">
    <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>

Comments

आप दिए गए n के तहत सभी primes मांगते हैं , लेकिन आप समावेशी भी कहते हैं। आपका क्या मतलब है?

— रिले

@Riley क्या मैं ... मतलब है all the numbers from 1....n। मुझे नहीं पता कि इसे सरल तरीके से कैसे फिर से लिखना है।

— गुरुपाद ममदापुर १६'१

OEIS A144214

— mbomb007

@ mbomb007 स्पष्ट रूप से पूर्णांक अनुक्रमों के किसी भी क्रम के लिए, सबसे छोटा निर्बाध पूर्णांक अनुक्रम स्वयं दिलचस्प होगा, और इस प्रकार OEIS में शामिल होने के योग्य होगा। एर्गो, OEIS में सभी पूर्णांक अनुक्रम शामिल हैं, किसी भी हित के वास्तविक या काल्पनिक :-)

— Iwillnotexist Idonotexist

मुझे आश्चर्य है कि क्या गणितज्ञों में OEIS के अनुक्रमों की तुलना में अधिक बिल्डिंग्स हैं ...

— नील

Answer 1

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

RBċþd`ÆPPTfÆR

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

यह काम किस प्रकार करता है

RBċþd`ÆPPTfÆR  Main link. Argument: n

R              Range; yield [1, ..., n].
 B             Binary; convert each integer to base 2.
    d`         Divmod self; yield [n : n, n % n], i.e., [1, 0].
  ċþ           Count table; count the occurrences of 1 and 0 in each binary
               representation, yielding a pair of lists of length n.
      ÆP       Test each count for primality.
        P      Product; multiply the corresponding Booleans.
         T     Truth; get all indices of 1, yielding the list of integers in
               [1, ..., n] that have a prime amount of 0's and 1's.
           ÆR  Prime range; yield all primes in [1, ..., n].
          f    Filter; intersect the lists.

Comments

यह d`​ट्रिक कुछ और है ...

— ETHproductions

Answer 2

पायथन 2 , 106 102 100 बाइट्स

k=m=1;p={0}
exec"p^={m%k*k,0};c=bin(k).count\nif{k,c('1'),c('0')-1}<p:print k\nm*=k*k;k+=1;"*input()

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

पृष्ठभूमि

Primes की पहचान करने के लिए, हम विल्सन के प्रमेय के एक कोरोलरी का उपयोग करते हैं :

यह काम किस प्रकार करता है

हम k और m को 1 और p को सेट {0} के रूप में शुरू करके शुरू करते हैं । ध्यान दें कि m = 1 = 0! ² = (k - 1)! = । इसके तुरंत बाद, निम्नलिखित कोड को n बार निष्पादित किया जाता है , जहां n मानक इनपुट से पूर्णांक पढ़ा जाता है।

p^={m%k*k,0};c=bin(k).count
if{k,c('1'),c('0')-1}<p:print k
m*=k*k;k+=1

कोरोलरी द्वारा, m% k 1 होगा यदि k अभाज्य है और 0 अन्यथा। इस प्रकार, यदि के प्राइम है तो {m%k*k,0}सेट {k, 0} को वापस दे देंगे और सेट {0} अन्यथा।

यदि (केवल और केवल अगर) k अभाज्य है, क्योंकि p में इस बिंदु पर k नहीं हो सकता है , तो जगह-जगह सममित अंतर k में p को p^={m%k*k,0}जोड़ देगा । इसके अलावा, पी में अपडेट के बाद 0 होगा यदि और केवल अगर इसमें 0 से पहले नहीं है , तो 0 if पी अगर और केवल अगर के भी है।

उसी पंक्ति में, हम एक फ़ंक्शन c को परिभाषित करते हैं c=bin(k).count, जो कि k के बाइनरी प्रतिनिधित्व में इसके तर्क की घटनाओं को गिनाएगा।

दूसरी पंक्ति वास्तविक आउटपुट का उत्पादन करती है। {k,c('1'),c('0')-1}सेट के होते हैं कि रिटर्न कश्मीर ही है, में सेट बिट्स की संख्या कश्मीर , और में सेट किए बिना बिट्स की संख्या कश्मीर । चूंकि आउटपुट 0 बी केbin(k) साथ शुरू होता है , इसलिए हमें अग्रणी 0 के लिए खाते में कमी करना होगा ।c('0')

यदि वे सभी प्रमुख हैं, तो वे सभी पी से संबंधित होंगे , जो अब तक के (और संभावित 0 ) तक सभी अभाज्य संख्याएँ हैं । यदि k एक Mersenne नंबर है (यानी, यदि यह केवल बिट्स सेट है), c('0')-1तो 0 मिलेगा । चूंकि मेर्सन संख्या विषम हैं, पी में 0 नहीं होंगे , इसलिए स्थिति विफल हो जाएगी।

बाद (संभावित) मुद्रण कश्मीर , हम गुणा मीटर से k² । चूंकि m = (k-1)! अपडेट से पहले- , इसके बाद m = k!- । K को बढ़ाने के बाद , संबंध m = (k-1)! We 're फिर से धारण करता है और हम अगले पुनरावृत्ति के लिए तैयार हैं।

Answer 3

मैथेमेटिका, 80 68 54 बाइट्स

Select[p=PrimeQ;Range@#,p@#&&And@@p/@#~DigitCount~2&]&

व्याख्या

Select[p=PrimeQ;Range@#,p@#&&And@@p/@#~DigitCount~2&]&

       p=PrimeQ                                        (* Store prime check func. in p *)
Select[                                             ]  (* Select *)
                Range@#                                (* from a list {1..n} *)
                        p@#                            (* numbers that are prime *)
                           &&                          (* And *)
                                     #~DigitCount~2    (* whose digit counts in binary *)
                             And@@p/@                  (* are prime as well *)

Answer 4

जावास्क्रिप्ट (ईएस 6), 123 118 115 111 104 96 बाइट्स

सहेजे गए 4 बाइट्स @Arnauld का धन्यवाद

G=n=>n?G(n>>1,++a[n%2]):a.some(n=>(P=x=>n%--x?P(x):x)(n)-1)
F=n=>F(n-1,G(n,a=[0,0,n])||alert(n))

तीन विशिष्ट पुनरावर्ती कार्यों का एक संयोजन। अनुक्रम को रिवर्स ऑर्डर में अलर्ट करता है और "बहुत अधिक पुनरावृत्ति" त्रुटि पर समाप्त होता है।

टेस्ट स्निपेट

(पृष्ठ के आउटपुट में संशोधित)

alert = s => O.textContent += s + "\n"

G=n=>n?G(n>>1,++a[n%2]):a.some(n=>(P=x=>n%--x?P(x):x)(n)-1)
F=n=>F(n-1,G(n,a=[0,0,n])||alert(n))

F(1000)

<pre id=O></pre>

मुख्य कार्य 104 बाइट्स के लिए एक सरणी लौटा सकता है:

G=n=>n?G(n>>1,++a[n%2]):a.some(n=>(P=x=>n%--x?P(x):x)(n)-1)
F=n=>n?F(n-1).concat(G(n,a=[0,0,n])?[]:n):[]

यह किसी अन्य बाइट की कीमत पर गैर-पुनरावर्ती भी हो सकता है:

G=n=>n?G(n>>1,++a[n%2]):a.some(n=>(P=x=>n%--x?P(x):x)(n)-1)
n=>[for(_ of Array(n))if(!G(--n,a=[0,0,n]))n]

---

यहाँ मैं एक के साथ शुरू कर दिया है: (@Arnauld के लिए 6 बाइट्स धन्यवाद)

P=(n,x=n)=>n>1&--x<2||n%x&&P(n,x)
G=n=>n?G(n>>1,o+=n%2,t++):P(o)&P(t-o)
F=n=>n?F(n-1).concat(P(n)&G(n,o=t=0)?n:[]):[]

मैंने इसे और आगे बढ़ाने की कोशिश की और इसे 104 बाइट्स में करने में कामयाब रहा- तब मुझे महसूस हुआ कि मुझे पहले ही इसका समाधान मिल गया है (यह जवाब के निचले भाग में है)। क्या ऐसा होने पर आपको इससे नफरत नहीं है? : पी

मुख्य समारोह में एक गैर-पुनरावर्ती प्रयास (फिर से, वही बाइट गिनती):

n=>[for(i of Array(n))if(P(--n)&G(n,o=t=0))n]

---

यह बाइनरी प्रतिनिधित्व में कितने 0 और 1 की गिनती का आसान मार्ग लेता है:

F=n=>n?F(n-1).concat([n,(G=x=>n.toString(2).split(x).length-1)(0),G(1)].some(n=>(P=x=>n%--x?P(x):x)(n)-1)?[]:n):[]

एक सरणी समझ के साथ एक ही बात:

n=>[for(_ of Array(n))if(![--n,(G=x=>n.toString(2).split(x).length-1)(0),G(1)].some(n=>(P=x=>n%--x?P(x):x)(n)-1))n]

यह एक ही काम करने के लिए थोड़ा कठिन मार्ग लेता है:

F=n=>n?F(n-1).concat([n,(G=(x,w=n)=>w&&G(x,w>>1)+(w%2==x))(0),G(1)].some(n=>(P=x=>n%--x?P(x):x)(n)-1)?[]:n):[]

और यह एक और संबंधित मार्ग लेता है जो मूल के रूप में छोटा है:

F=n=>n?F(n-1).concat([n,o=(G=x=>x&&x%2+G(n>>++t))(n,t=0),t-o].some(n=>(P=x=>n%--x?P(x):x)(n)-1)?[]:n):[]

फिर, आप 8 बाइट्स को रिवर्स ऑर्डर में अनुक्रम को सचेत करके गोल्फ कर सकते हैं:

F=n=>F(n-1,[n,o=(G=x=>x&&x%2+G(n>>++t))(n,t=0),t-o].some(n=>(P=x=>n%--x?P(x):x)(n)-1)||alert(n))

Comments

आपको वास्तव में पुनरावर्ती पास करने की आवश्यकता नहीं है a। अभी शुरुआती कॉल में इसे इनिशियलाइज़ करें G। (कि 4 बाइट्स बचाना चाहिए।)

— अर्नुलड

@Arnauld ओह हाँ, धन्यवाद! यह मजेदार है :-)

— ETHproductions

वाह यह तो बहुत गिर गया। अच्छा काम

— जॉर्ज रीथ

Answer 5

जेली , 17 16 बाइट्स

BĠL€µ;LÆPẠ
ÆRÇÐf

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

कैसे?

BĠL€µ;LÆPẠ - Link 1, hasPrimeBits: n  e.g. 7         or 13
B          - convert to binary        e.g. [1,1,1]  or [1,1,0,1]
 Ġ         - group indices            e.g. [1,2,3]  or [3,[1,2,4]]
  L€       - length of €ach           e.g. 3          or [1,3]
    µ      - monadic chain separation
     ;L    - concatenate length       e.g. [3,1]      or [1,3,2]
           -     this caters for the edge case of Mersenne primes (like 7), which have
           -     no zero bits, the length will be 1, which is not prime.
       ÆP  - isPrime?                 e.g. [1,0]      or [0,1,1]
         Ạ - All?                     e.g. 0          or 0

ÆRÇÐf - Main link: N
ÆR    - prime range (primes up to and including N)
   Ðf - filter keep those satisfying
  Ç   - last link (1) as a monad

Comments

आह धन्यवाद, मैं देख रहा हूँ कि तुम बदल दिया है, कि एक बाइट बचा लेंगे।

— जोनाथन एलन

आपको वर्णमाला मिल रही है, वहां। ẠBÇЀfĠ...

— mbomb007

@ mbomb007 हाँ, LƵ;Pबिट हमेशा मुझे भ्रमित करता है।

— जोनाथन एलन

Answer 6

05AB1E , 14 बाइट्स

ƒNpNbSD_‚OpP&–

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

व्याख्या

ƒ               # for N in [0 ... input]
 Np             # push N is prime
   Nb           # push N converted to binary
     S          # split into individual digits
      D_        # push an inverted copy
        ‚       # pair the 2 binary lists
         O      # sum them
          p     # elementwise check for primality
           P    # product of list
            &   # and with the primality of N
             –  # if true, print N

Comments

मुझे अभी भी इसके लिए कोई उपयोग नहीं मिल .¡रहा है, यह चुनौती इसके लिए अच्छी लग रही थी, लेकिन यह अधिक लंबी है:FNb{.¡€gpONp+3QiN}})

— मैजिक ऑक्टोपस उर

@ क्रूसोकोमपूतिंग: मेरे पास एक समान समाधान था जिसे मैंने भी माना था, लेकिन यह भी इससे थोड़ा लंबा था।

— एमिगा

Answer 7

05AB1E , 17 15 बाइट्स

LDpÏvybSD_)OpP—

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

Comments

LDpÏvybSD_)OpP—15 बाइट्स के लिए काम करना चाहिए।

— एमिगा

@Eigna कि वास्तव में चालाक है! धन्यवाद :)।

— अदनान

Answer 8

MATL , 16 15 बाइट्स

:"@tB!t~hshZp?@

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

:         % Input n (implicit). Push range [1 2 ... n]
"         % For each k in [1 2 ... n]
  @       %   Push k
  tB!     %   Duplicate. Binary expansion as an m×1 vector
  t~      %   Duplicate. Negate
  hs      %   Concatenate horizontally into an m×2 matrix. Sum of each column.
          %   This gives a 1×2 vector. However, for k==1 this gives the sum of
          %   the original 1×2 matrix (m==1). But fortunately it doesn't matter
          %   because 1 is not a prime anyway
  h       %   Concatenate horizontally into a 1×3 row vector
  Zp      %   Isprime function applied on each of those three numbers
  ?       %   If all gave true
    @     %     Push k
          %   End (implicit)
          % End (implicit)
          % Display (implicit)

Answer 9

पर्ल, 101 बाइट्स

कोड + -nlझंडे के 99 बाइट्स ।

$r=q/^1?$|^(11+)\1+$/;for$@(2..$_){$_=sprintf"%b",$@;print$@if(1x$@)!~$r&y/01/1/dr!~$r&s/0//gr!~$r}

इसे चलाने के लिए:

perl -lne '$r=q/^1?$|^(11+)\1+$/;for$@(2..$_){$_=sprintf"%b",$@;print$@if(1x$@)!~$r&y/01/1/dr!~$r&s/0//gr!~$r}' <<< 150

कुछ लघु स्पष्टीकरण
$r शास्त्रीय प्रधान जाँच रेगेक्स ( q/^1?$|^(11+)\1+$/) रखते हैं।
2 और इनपुट के बीच की सभी संख्याओं के लिए,
(1x$@)!~$rजाँच करें कि क्या संख्या अभाज्य है,
y/01/1/dr!~$rजाँच करें 0कि बाइनरी प्रतिनिधित्व
s/0//gr!~$rकी संख्या अभाज्य है या नहीं, बाइनरी प्रतिनिधित्व की संख्या 1अभाज्य है या नहीं।
(यदि 3 शर्तें पूरी होती हैं, तो print$@इसे प्रिंट करता है)।

Comments

स्पष्टीकरण के लिए धन्यवाद। काफी आश्चर्यजनक है कि आप मूल रूप से regex और कुछ तर्क के साथ क्या कर सकते हैं :)

— Emigna

@Emigna धन्यवाद! स्पष्टीकरण बहुत विस्तृत नहीं हैं (मुझे स्पष्टीकरण लिखने में कठिन समय लग रहा है), लेकिन ऐसा लगता है कि यह आपके लिए पर्याप्त था :) (मुझे अभी भी विश्वास है कि कोड थोड़ा बहुत लंबा है, लेकिन मुझे नहीं पता कि कैसे प्राप्त करें यह छोटा है, इसलिए यहाँ यह है)

— दादा

किसी के रूप में, जो पर्ल को नहीं जानता है, मैं हर स्पष्टीकरण की सराहना कर सकता हूँ जो मुझे मिल सकता है। यह मुझे एक पर्ल प्रोग्राम बनाने में मदद नहीं करेगा, लेकिन मैं नियोजित विधि के पीछे के कुछ तर्क को समझता हूं, जो हमेशा दिलचस्प होता है।

— एमिगा

Answer 10

पायथन, 129 125 123 बाइट्स

यदि केवल शून्य प्राइम थे ...

p=lambda n:all(n%m for m in range(2,n))*n>1
lambda n:[i for i in range(n+1)if p(i)*all(p(bin(i)[2:].count(x))for x in'01')]

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

फ़ंक्शन pप्राइम-चेकिंग फ़ंक्शन है, जिसके >0अंत में इतना है कि यह शून्य के लिए भी काम करता है, जो अन्यथा वापस आ जाएगा -1। अनाम लैम्ब्डा लंबोदर है जो आवश्यक सभी शर्तों की जांच करता है।

---

यहां एक सेट कॉम्प्रिहेंशन का उपयोग करके थोड़ा अलग तरीका है। परिणाम एक सेट होगा। ( 124 बाइट्स ):

p=lambda n:all(n%m for m in range(2,n))*n>1
lambda n:{i*p(i)*all(p(bin(i)[2:].count(x))for x in'01')for i in range(n+1)}-{0}

Answer 11

पर्ल 6 , 65 बाइट्स

{grep {all($^a,|map {+$a.base(2).comb(~$_)},0,1).is-prime},0..$_}

कोशिश करो

विस्तारित:

{           # bare block lambda with implicit parameter ｢$_｣

  grep      # find all of the values where

  {         # lambda with placeholder parameter ｢$a｣

    all(    # all junction ( treat multiple values as a single value )

      $^a,  # declare parameter to block

      |\    # slip the following list into the outer list

      # get the count of 0's and 1's in the binary representation
      map

      {             # bare block lambda with implicit parameter ｢$_｣

        +           # turn to numeric ( count the values in the list )
        $a          # the outer parameter
        .base(2)    # in base 2
        .comb(~$_)  # find the characters that are the same as
      },0,1         # 0 or 1

    # ask if $a, count of 0's, count of 1's are all prime
    ).is-prime

  },

  0 .. $_ # Range from 0 to the input inclusive

}

Answer 12

ऑक्टेव, 73 बाइट्स

@(n)(p=primes(n))(all(isprime([s=sum(dec2bin(p)'-48);fix(log2(p))+1-s])))

यह ऑनलाइन की कोशिश करो!

@(n)
    (p=primes(n))                           generate prime numbers
        (all(                               from them select those that
            isprime(                        are prime both
                [s=sum(dec2bin(p)'-48);     sum of 1s
                fix(log2(p))+1-s])))        and sum of 0s

Answer 13

सीजेएम , 26 27 बाइट्स

ri){mp},{2b_1-,mp\0-,mp&},p

सीधा एल्गोरिदम, आगे गोल्फ जाएगा।

संपादित करें: भूल गया n समावेशी था।

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

मज़े के लिए, यह बहुत समान है और 27 बाइट्स भी हैं:

ri){_mp\2b_1-,mp\0-,mp&&},p

व्याख्या

ri                          e# Take an int as input
  ){mp},                    e# Take the range up and including to the input, 
                            e#   including only prime numbers
       {                    e# For each prime...
        2b_                 e# Convert it to binary and copy it
           1-,mp            e# Take the top binary number, remove 1's, check if the length 
                            e#   is prime
                \           e# Swap top elements
                 0-,mp      e# Do the same but remove 0's
                      &     e# And
                       },   e# Filter out primes for which the above block was false
                         p  e# Print nicely

Answer 14

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

BċÆPðÐf
ÆRç0ç1

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

दुर्भाग्य से, मैं केवल @ डेनिस के साथ टाई कर सकता था, लेकिन एल्गोरिथ्म कुछ अलग लगता है इसलिए मैं इसे वैसे भी पोस्ट कर रहा हूं।

व्याख्या

हेल्पर फ़ंक्शन (सूची तत्वों को हटाता है, जिसमें किसी बिट की घटनाओं की एक प्रमुख संख्या नहीं होती है):

BċÆPðÐf
     Ðf   Filter {the first argument}, looking for truthy returns from
    ð     the preceding code, which takes two arguments:
B         Convert {the element being checked} to binary
 ċ        Count the number of occurrences of {the second argument}
  ÆP      Return true if prime, false if not prime

मुख्य कार्यक्रम:

ÆRç0ç1
ÆR        Generate all primes from 2 to the input
  ç0      Call the subroutine to require a prime 0 count
    ç1    Call the subroutine to require a prime 1 count

Answer 15

हेक्से, 169 171 बाइट्स

function f(n,?p)return[for(j in(p=[for(i in 0...++n)i<2?0:i]))if(j>0){var x=j*2,y=0,z=0,k=j;while(k<n)p[k+=j]=0;while((x>>=1)>0)x&1>0?y++:z++;p[y]<1||p[z]<1?continue:j;}];

पागल कुछ भी नहीं। अनिवार्य रूप से एराटोस्थनीज की एक संशोधित छलनी जो उच्चतर-गैर-अपराधों को पार करने के रूप में एक ही पुनरावृत्ति में 0/1 की गिनती की प्रधानता का मूल्यांकन करती है। कुछ व्हाट्सएप के साथ:

function f(n, ?p)
  return [ for (j in (p = [ for(i in 0...++n) i < 2 ? 0 : i ]))
    if (j > 0){
      var x = j * 2, y = 0, z = 0, k = j;
      while (k < n)
        p[k += j] = 0;
      while((x >>= 1) > 0)
        x & 1 > 0 ? y++ : z++;
      p[y] < 1 || p[z] < 1 ? continue : j;
    }
  ];

लेकिन आज मुझे पता चला कि मैं continueएक टर्नरी ऑपरेटर में रख सकता हूं और हेक्स का भी दिमाग नहीं है।

संपादित करें: +2 क्योंकि nएक समावेशी ऊपरी बाध्य है!

Comments

अरे, nसमावेशी है।

— गुरुपाद ममदापुर

@ गुरुपुरमदापुर आप ठीक कह रहे हैं, निश्चित!

— औरेल बेली

Answer 16

बैश + जीएनयू उपयोगिताओं, 129 126 123 114 111 109 बाइट्स

seq '-fp()([ `factor|wc -w` = 2 ]);g()(dc -e2o${n}n|tr -cd $1|wc -c|p);n=%.f;p<<<$n&&g 0&&g 1&&echo $n' $1|sh

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

टिप्पणी को ध्यान में रखते हुए कि आउटपुट को बढ़ते क्रम में नहीं होना है - 3 बाइट्स को बंद करने के बजाय नीचे गिनती करके मुंडा हुआ है।

3 अतिरिक्त बाइट को बचाने के लिए wc के साथ बदल गया grep।

एक चर (9 और बाइट्स बंद) को हटा दिया।

परिवर्तित कारक का उपयोग किया जाता है - 3 और बाइट्स।

इसे seq (2 बाइट्स) के साथ गोल्फर बनाया।

Answer 17

पायथन, 172 170 168 159 154 133 130 बाइट्स

p=lambda n:[i for i in range(1,n)if n%i==0]==[1]
lambda n:[i for i in range(n+1)if p(i)*all(p(bin(i)[2:].count(x))for x in'10')]

---

उपयोग: अनाम लंबन फ़ंक्शन को कॉल करें
विधि pजाँचता है कि कोई संख्या प्रधान है या नहीं

---

सहेजा गया 2 + 2 + 9 = 13 बाइट्स गुरुपद के लिए धन्यवाद ममदापुर ने
5 बाइट्स mbomb007 के लिए धन्यवाद

Comments

इसका उपयोग करके आप 2 और बचत कर सकते हैं v-def v(n):a=bin(n)[2:];return p(n)and(p(a.count('1'))and p(a.count('0')))

— गुरुपद ममदापुर

एक बहुत छोटा व्यक्ति -v=lambda a:p(a)and all(p(bin(a)[2:].count(x))for x in['1','0'])

— गुरुपद ममदापुर

स्ट्रिंग्स चलने योग्य हैं। तो आप उपयोग कर सकते हैं for x in'01'।

— mbomb007

Answer 18

पाइके, 21 बाइट्स

S#j_PI\0[jb2R/_P)I\1[

यहाँ यह कोशिश करो!

S#j                   - for j in filter(range(1, input+1))
   _PI                -  if is_prime(j):
        [jb2R/_P)     -   function_[(a) = V
         jb2          -      base_2(j)
            R/        -     ^.count(a)
      \0         I    -   if function_[("0"):
                  \1[ -    function_[("1")

Answer 19

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

p={x->(2..<x).every{x%it!=0}&x>1|x==2}
{x->(1..x).findAll({y->p(y)&'10'.every{p(Integer.toBinaryString(y).count(it))}})}

यह एक अनाम क्लोजर है।

यहाँ यह कोशिश करो!

Answer 20

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

f.APM_M+T/LSjT2U2S

इसे यहाँ ऑनलाइन आज़माएँ ।

Comments

@GurupadMamadapur srry बदल रहा Uकरने के लिएS

— Maltysen

@ गुरुपद्ममदापुर

— माल्टीसेन

@GurupadMamadapureS

— Maltysen

@ गुरुपुरमदापुर कूज हम चेरों से बाहर हैं: पी पायथ केवल अस्सी है।

— माल्टेन

Answer 21

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

def f(n,k=2,m=1,p={0}):f(n-1,k+1,m*k*k,p^{m%k*k,{*map(bin(m%k%n*k)[2:].count,'01')}<p==print(k)})

यह मेरे पायथन 2 उत्तर के समान ही एल्गोरिदम है , लेकिन कार्यान्वयन काफी अलग है। फ़ंक्शन STDOUT को प्रिंट करता है और एक त्रुटि के साथ समाप्त होता है।

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

Answer 22

जावास्क्रिप्ट (ईएस 6), 110 बाइट्स

B=n=>n?B(n>>1,v[n%2]++):v.every(n=>(P=i=>n%--i?P(i):1==i)(n))
F=(n,a=[])=>n?F(n-1,B(n,v=[0,0,n])?[n,...a]:a):a

B=n=>n?B(n>>1,v,v[n%2]++):v.every(n=>(P=i=>n%--i?P(i):1==i)(n))
F=(n,a=[])=>n?F(n-1,B(n,v=[0,0,n])?[n,...a]:a):a

const update = () => {
  console.clear();
  console.log(F(input.value))
}

input.oninput = update;
update();

<input id="input" type="number" min="1" value="100" />

Comments

यह प्रचंडता परीक्षण कार्य है ... बस अद्भुत :-) क्या आपने इसे स्वयं बनाया है?

— ETHproductions

@ETHproductions आपने इसे यहां से संशोधित कोडगॉल्फ.स्टैकएक्सचेंज . com/a/91309/11182 से पहले देखा है। मैंने आपका 1 और 0 काउंटिंग कोड भी लिया है (जो कुछ भी मैं अपने साथ ले सकता था) लेकिन अफसोस मैं आपकी बाइट की गिनती को नहीं हरा सकता था।

— जॉर्ज रीथ

@ETHproductions अच्छा पकड़ धन्यवाद! पिछले संस्करण का एक

— जॉर्ज रीथ

Answer 23

MATLAB, 50 बाइट्स

@(n)all(isprime([n,sum(de2bi(n)),sum(~de2bi(n))]))

Answer 24

हेक्से, 158 147 बाइट्स

function p(n,x=1)return n%++x<1||n<2?x==n:p(n,x);function f(n){var q=n,t=0,o=0;while(q>0){t++;o+=q%2;q>>=1;}p(n)&&p(o)&&p(t-o)?trace(n):0;f(n-1);};

STDOUT को आउटपुट और "बहुत अधिक पुनरावृत्ति" त्रुटि पर समाप्त होता है; उदाहरण के लिए कॉल करें f(1000);। आप while156 बाइट्स के लिए बिना किसी त्रुटि के लूप का उपयोग कर सकते हैं :

function p(n,x=1)return n%++x<1||n<2?x==n:p(n,x);function f(n){while(n>0){var q=n,t=0,o=0;while(q>0){t++;o+=q%2;q>>=1;}p(n)&&p(o)&&p(t-o)?trace(n):0;n--;}};

एक सीमा का उपयोग करके तीन बाइट्स लंबा हो गया:

function p(n,x=1)return n%++x<1||n<2?x==n:p(n,x);function f(n){for(i in 0...n+1){var q=i,t=0,o=0;while(q>0){t++;o+=q%2;q>>=1;}p(i)&&p(o)&&p(t-o)?trace(i):0;}};

इसे ऑनलाइन टेस्ट करें!

Answer 25

जंग, 147 बाइट्स

fn f(x:u32){let p=|n|n>1&&(2..n).all(|x|n%x!=0);for n in 9..x+1{if p(n)&&p(n.count_ones())&&p(n.count_zeros()-n.leading_zeros()){print!("{} ",n)}}}

खेल का मैदान लिंक

count_ones, count_zeros, और leading_zerosतरीकों काम में आया था।

स्वरूपित संस्करण

fn f(x: u32) {
    // primality test closure using trial division
    let p = |n| n > 1 && (2..n).all(|x| n % x != 0);

    for n in 9..x + 1 {
        if p(n) && p(n.count_ones()) && p(n.count_zeros() - n.leading_zeros()) {
            print!("{} ", n)
        }
    }
}

Answer 26

पर्ल 6 , 50 बाइट्स

{grep {($_&+.base(2).comb(~0&~1)).is-prime},0..$_}

जंक्शन ऑपरेटर के महान प्रभाव का उपयोग करते हुए, b2gills के उत्तर का परिवर्तन ।&

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

यह काम किस प्रकार करता है

{                                                }  # Lambda
                                            0..$_   # Range from 0 to the lambda argument.
 grep {                                   },        # Filter values satisfying:
       ($_                      ).is-prime          #  a) The Number itself is prime.
       (   +.base(2).comb(~0   )).is-prime          #  b) The count of 0's is prime.
       (   +.base(2).comb(   ~1)).is-prime          #  c) The count of 1's is prime.
          &                 &                       # Junction magic! :)