প্রাইম বিট-গণনা সহ পুরষ্কার

Question

কার্য

সমস্ত অ-নেতিবাচক পূর্ণসংখ্যার প্রয়োজন এবং একটি নন-জিরো ধনাত্মক পূর্ণসংখ্যা দেওয়া সহ খুঁজুন এন , এবং কাউন্ট মৌলিক হয় 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, ৪১, ]৯]

150
[17, 19, 37, 41, 79, 103, 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

আপনি প্রদত্ত এন এর অধীনে সমস্ত প্রাইম চাইবেন , তবে আপনি অন্তর্ভুক্তও বলবেন। আপনি কোনটি বোঝাতে চান?

— রিলে

@Riley কি আমি ... মানে কি all the numbers from 1....n। আমি কীভাবে এটি সহজ উপায়ে পুনঃব্যবহার করতে জানি না।

— গুরুপদ মামাদপুর

OEIS A144214

— mbomb007

@ mbomb007 স্পষ্টতই, মোট পূর্ণসংখ্যার ক্রমের ক্রমগুলির জন্য, ক্ষুদ্রতম উদ্বেগজনক পূর্ণসংখ্যার ক্রমটি নিজেই আকর্ষণীয় হবে এবং এটি OEIS এ অন্তর্ভুক্তির যোগ্য worthy এরগো,

— ওইআইএসে

আমি ভাবছি যে ম্যাথমেটিকায় রয়েছে ওইআইএসের ক্রমগুলির চেয়ে বেশি বিল্টিন রয়েছে ...

— নীল

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`​কৌশলটি অন্যরকম ...

— ETH প্রোডাকশনগুলি

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()

এটি অনলাইন চেষ্টা করুন!

পটভূমি

প্রাইমগুলি সনাক্ত করতে, আমরা উইলসনের উপপাদ্যের একটি বাস্তবায়ন ব্যবহার করি :

কিভাবে এটা কাজ করে

আমরা আরম্ভের করে শুরু ট এবং মি যেমন 1 এবং পি সেট হিসাবে {0} । নোট করুন যে মি = 1 = 0! ² = (কে - 1)! ² । অবিলম্বে পরে, নিম্নলিখিত কোড এক্সিকিউট করা হয় এন , যেখানে বার এন পূর্ণসংখ্যা মান ইনপুট থেকে পড়া হয়।

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

সম্পুরক দ্বারা, মি% ট হতে হবে 1 যদি ট মৌলিক এবং 0 অন্যথায়। সুতরাং, কে কে প্রাইম হলে {m%k*k,0}সেটটি {k, 0 return এবং অন্যথায় সেট {0 return প্রদান করবে ।

যদি (এবং কেবলমাত্র) কে প্রাইম হয়, যেহেতু পি এই মুহুর্তে কে ধারণ করতে পারে না , তাই স্থানটিতে প্রতিসাম্যগত পার্থক্য সেট পিতে কেp^={m%k*k,0} যোগ করবে । এছাড়াও, পি উপস্থিত থাকবে 0 আপডেটের পরে যদি এবং কেবল যদি এটা ধারণ করে না 0 সামনে, তাই 0 ε পি যদি এবং কেবল যদি ট এমনকি হল।

একই লাইনে, আমরা এর মাধ্যমে একটি ফাংশন সি সংজ্ঞায়িত করি c=bin(k).count, যা কে এর বাইনারি উপস্থাপনায় এর যুক্তির উপস্থিতিগুলি গণনা করবে ।

দ্বিতীয় লাইন প্রকৃত আউটপুট উত্পাদন করে। {k,c('1'),c('0')-1}সেট যা নিয়ে গঠিত ফেরৎ ট নিজে সেট বিট সংখ্যা ট , এবং সেট না বিট সংখ্যা ট । যেহেতু আউটপুট 0 বিbin(k) দিয়ে শুরু হয় , তাই আমাদের শীর্ষস্থানীয় 0 হিসাবে অ্যাকাউন্টে হ্রাস করতে হবে ।c('0')

যদি এগুলির সবগুলিই প্রধান হয় তবে তারা সমস্ত পি এর অন্তর্ভুক্ত হবে, যার মধ্যে এখন পর্যন্ত কে (এবং সম্ভাব্য 0 ) অবধি সমস্ত মৌলিক সংখ্যা রয়েছে । তাহলে ট একটি Mersenne সংখ্যা (অর্থাত, যদি এটা শুধুমাত্র বিট সেট করেছে), c('0')-1সমর্পণ করা হবে 0 । যেহেতু Mersenne সংখ্যার বিজোড় হয়, পৃ হবে না ধারণ 0 , তাই শর্ত ব্যর্থ হবে।

পরে (সম্ভাব্য) মুদ্রণ ট , আমরা সংখ্যাবৃদ্ধি আছি দ্বারা k² । যেহেতু মি = (কে -1)! Update আপডেটের আগে, এম = কে!। এর পরে। কে বাড়ানোর পরে , সম্পর্কযুক্ত মি = (কে -1)! ² আবার ধরে এবং আমরা পরবর্তী পুনরাবৃত্তির জন্য প্রস্তুত।

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

জাভাস্ক্রিপ্ট (ES6), 123 118 115 111 104 96 বাইট

@ আরনাউল্ডকে 4 টি বাইট সংরক্ষণ করা হয়েছে

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]

---

আমি যেটি দিয়ে শুরু করেছি তা এখানে: (@ অর্ণাড্ডকে ধন্যবাদ 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 বাইটে পরিচালনা করতে পেরেছি - তখন বুঝতে পেরেছি যে আমি ইতিমধ্যে সমাধানটি খুঁজে পেয়েছি (এটি উত্তরের নীচে রয়েছে)। আপনি যখন এটি ঘৃণা করবেন না? : P: P

মূল ফাংশনে একটি পুনরাবৃত্তি প্রচেষ্টা (আবার, একই বাইট গণনা):

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। (

— এটিতে

@ আর্নল্ড ওহ হ্যাঁ, ধন্যবাদ! এটি মজাদার :-)

— ইটিএইচ প্রোডাকশনগুলি

বাহ এটা অনেক হ্রাস পেয়েছে। দুর্দান্ত কাজ

— জর্জ রিথ

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

@ এমবম্ব ২০০7 হ্যাঁ, বিটটি LƵ;Pআমাকে সর্বদা বিভ্রান্ত করে।

— জোনাথন অ্যালান

Answer 6

05 এ বি 1 ই , 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

05 এ বি 1 ই , 17 15 বাইট

LDpÏvybSD_)OpP—

সিপি -1222 এনকোডিং ব্যবহার করে । এটি অনলাইন চেষ্টা করুন!

Comments

LDpÏvybSD_)OpP—15 বাইট জন্য কাজ করা উচিত।

— এমিগিনা

@ এমিগনা সত্যিই চালাক! ধন্যবাদ :)।

— আদনান

Answer 8

এমএটিএল , 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 বাইট

99 বাইট কোড + -nlপতাকা।

$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

ব্যাখ্যা করার জন্য ধন্যবাদ. মূলত

— রেইজেক্স

@ এমিগনা ধন্যবাদ! ব্যাখ্যাগুলি খুব বেশি বিস্তারিত নয় (দীর্ঘ বিবরণ লেখার জন্য আমার খুব কষ্ট হচ্ছে), তবে এটি আপনার পক্ষে যথেষ্ট ছিল বলে মনে হয় :) (আমি এখনও বিশ্বাস করি কোডটি কিছুটা দীর্ঘ, তবে কীভাবে পাবেন তা আমি দেখতে পাচ্ছি না) এটি সংক্ষিপ্ত, সুতরাং এটি এখানে)

— দাদা

পার্লকে চেনেন না এমন কেউ হিসাবে আমি পেতে পারে এমন প্রতিটি ব্যাখ্যাকে আমি প্রশংসা করি। এটি আমাকে পার্ল প্রোগ্রাম তৈরি করতে সহায়তা করবে না তবে আমি নিযুক্ত পদ্ধতিটির পিছনে কিছু যুক্তি বুঝতে পারি যা সর্বদা আকর্ষণীয়।

— এমিগিনা

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

সোজাভাবে অ্যালগরিদম, আরও গল্ফ হবে।

সম্পাদনা: ভুলে যাওয়া এন অন্তর্ভুক্ত ছিল।

এটি অনলাইন চেষ্টা করুন!

মজা করার জন্য, এটি খুব অনুরূপ এবং 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 টেরিনারি অপারেটর রাখতে পারি এবং হ্যাক্সও আপত্তি করে না।

সম্পাদনা: +২ কারণ 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 টি অতিরিক্ত বাইট সংরক্ষণ করার জন্য ডাব্লিউসি সহ গ্রেপ প্রতিস্থাপন করা হয়েছে।

একটি পরিবর্তনশীল (9 আরও বাইট বন্ধ) মুছে ফেলা হয়েছে।

ফ্যাক্টরটি যেভাবে ব্যবহৃত হচ্ছে তা পরিবর্তিত হয়েছে - আরও 3 বাইট।

এটি সিক (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

@ গুরুপদমমাদাপুর সম্পন্ন হয়েছে

— মালটিসেন

@ গুরুপাদমমাদাপুরeS

— মালতীসেন

@ গুরুপাদ মমাদপুর কিউজ আমরা চরিত্র থেকে বেরিয়ে এসেছি: পি পাইথ কেবল আসকি।

— মালটিসেন 16'17

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

জাভাস্ক্রিপ্ট (ES6), 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

সেই আঞ্চলিক পরীক্ষার ফাংশনটি হ'ল ... আশ্চর্যজনক :-) আপনি নিজে তৈরি করেছেন?

— ইটিএইচ প্রোডাকশনস

@ETH প্রোডাকশনগুলি আপনি এখান থেকে কোডগল্ফ.স্টাকেকেক্সচেঞ্জ . com/a/91309/11182 সংশোধিত হওয়ার আগে দেখেছেন । আমি আপনার 1 এবং 0 টি গণনা কোডও ধার করে নিয়েছি (আমি যে কোনও কিছু নিয়ে আসতে পারি) তবে হায় আমি আপনার বাইট গণনাটি হারাতে পারি না।

— জর্জ রিথ

পছন্দ করুন পূর্ববর্তী সংস্করণটির একটি

— জর্জ রিথ

Answer 23

ম্যাটল্যাব, 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..$_}

জংশন অপারেটরটি দুর্দান্তভাবে ব্যবহার করে, বি 2 গিলির উত্তরের বিভিন্নতা ।&

এটি অনলাইন চেষ্টা করুন!

কিভাবে এটা কাজ করে

{                                                }  # 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! :)