4 বিট সংযোগ বিচ্ছিন্ন করুন

Question

আপনার টাস্ক: একটি ইনপুট স্ট্রিং দেওয়া হয়েছে, নির্ধারণ করুন যে সেই স্ট্রিংয়ের বাইনারি উপস্থাপনাটি কোথাও কোথাও 4 1টি বা 0s নেই। তদ্ব্যতীত, আপনার কোডে নিজেই পর পর চারটি রান করা উচিত নয়।

পরীক্ষার মামলা

String      Binary              Result

U3          01010101 00110011   Truthy

48          00110100 00111000   Falsy

Foobar      01000110 01101111   Falsy
            01101111 01100010
            01100001 01110010

Feeber      01000110 01100101   Truthy
            01100101 01100010
            01100101 01110010

$H          00100100 01001000   Truthy

<Empty>     -                   Truthy

বিধি

• ইনপুট সর্বদা মুদ্রণযোগ্য ASCII এর পরিসরের মধ্যে থাকবে, হোয়াইটস্পেস অক্ষরগুলি সহ।
  • আপনার কোডটি যে কোনও এনকোডিং ব্যবহার করতে পারে, কারণ এটি কেবল বিট স্তরে গুরুত্বপূর্ণ।
• যেহেতু এই শর্তটি সাদা স্থান এবং অন্যান্য অনেক অক্ষরের ব্যবহারকে বাধা দেয়, আপনার কোডটি আসলে প্রতিটি রানের জন্য 10 বাইট পেনাল্টিতে পরপর চারটি রান সংগ্রহ করতে পারে।
  • একটি রান 5 1এস বা 0গুলি দুটি রান হিসাবে গণনা, পরপর 6 টি গণনা করে তিনটি রান, ইত্যাদি etc.
• ইনপুটটি স্ট্রিং বা চর অ্যারে হবে, অন্য কোনও ফর্ম নয়।
• আপনি একটি সম্পূর্ণ প্রোগ্রাম বা ফাংশন লিখতে পারেন।
• আপনাকে অবশ্যই আপনার উত্তরে আপনার কোডের বাইনারি উপস্থাপনা সরবরাহ করতে হবে।

শুভকামনা, সর্বনিম্ন স্কোর জয়!

এই স্ক্রিপ্টটি আপনাকে আপনার চ্যালেঞ্জের ক্ষেত্রে সহায়তা করতে পারে, আপনার কোডটিকে ইনপুটে রাখবে এবং আপনি যদি ইউটিএফ -8 ব্যবহার করেন তবে এটি আপনাকে আপনার কোডের বাইনারি উপস্থাপনা, দৈর্ঘ্য, আপনার পেনাল্টি এবং মোট স্কোর দেবে।

লিডারবোর্ড

নিয়মিত লিডারবোর্ড এবং ভাষার দ্বারা বিজয়ীদের একটি সংক্ষিপ্ত বিবরণ উভয়ই তৈরি করতে এখানে একটি স্ট্যাক স্নিপেট।

/* Configuration */

var QUESTION_ID = 111758; // Obtain this from the url
// It will be like https://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 60042; // 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 "https://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 "https://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,]*[^\s,]),.*?(\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,
      });
    
  });
  
  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;
    if (/<a/.test(lang)) lang = jQuery(lang).text();
    
    languages[lang] = languages[lang] || {lang: a.language, 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 > b.lang) return 1;
    if (a.lang < b.lang) 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="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>
<div id="language-list">
  <h2>Winners 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>
<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

আমি নিশ্চিত যে স্নিপেট বগি, উদাহরণস্বরূপ আমি ||তালিকাভুক্ত দেখতে পাচ্ছি এবং তা হ'ল 0111110001111100।

— janrjan জোহানসেন

ঠিক আছে, ভাল পয়েন্ট। এক সেকেন্ড.

— পাভেল

কাজটি যদি একটি স্ট্রিংয়ের স্কোর খুঁজে পাওয়া যায় তবে আরও মজাদার হত।

— অ্যাডাম

@ জোনাথন অ্যালান ভালভাবেই, আমি যেভাবে এটি করতে চেয়েছিলাম তা তা করে, তবে আরও প্রতিবিম্বিত হওয়ার পরে আমি আসলে এর কোনও কারণ দেখতে পাচ্ছি না, তাই আমি এটি পরিবর্তন করব।

— পাভেল

@ পাভেল যদি পেনাল্টি থাকে তবে স্কোরিং কেবলমাত্র বাইটের ভিত্তিতে নয়। এটি এটিকে [কোড-চ্যালেঞ্জ] করে তোলে, [কোড-গল্ফ] নয়। ট্যাগ উইকি থেকে: "যদি সোর্স কোডের দৈর্ঘ্য প্রাথমিক স্কোরিং মানদণ্ড না হয় তবে পরিবর্তে অন্য একটি ট্যাগ ব্যবহার করার বিষয়টি বিবেচনা করুন" " টিএল; ডিআর, যেহেতু প্রকৃত স্কোর = / = প্রোগ্রামের বাইট গণনা, এবং সবচেয়ে সংক্ষিপ্ত কোডটি সেরা স্কোর অর্জনের অর্থ নয়, এটি [কোড-গল্ফ] নয়।

— mbomb007

Answer 1

জেলি , 18 বাইট + 0 জরিমানা = 18

79Ọv2;$ḅ⁹b2+4\b4FẠ

রিটার্নস 1যদি দৈর্ঘ্য কোন সমান বিট স্ট্রিং হয় 4 হওয়া ASCII স্ট্রিং ইনপুটের 8-বিট শব্দ প্রতিনিধিত্ব বা তার বেশি, এবং 0অন্যথায়।

এটি অনলাইন চেষ্টা করুন! (কিছু অতিরিক্ত মামলা যুক্ত টেস্ট স্যুট)

জেলির কোডপেজ ব্যবহার করে সমান বিটের কোনও দৈর্ঘ্য 4 বা তার বেশি সাবস্ট্রিং নেই:

7    0x37    00110111
9    0x39    00111001
Ọ    0xB5    10110101
v    0x76    01110110
2    0x32    00110010
;    0x3B    00111011
$    0x24    00100100
ḅ    0xD4    11010100
⁹    0x89    10001001
b    0x62    01100010
2    0x32    00110010
+    0x2B    00101011
4    0x34    00110100
\    0x5C    01011100
b    0x62    01100010
4    0x34    00110100
F    0x46    01000110
Ạ    0xAB    10101011

সমান-বিট রান দৈর্ঘ্য সহ:

221323221211111312322133122121221111213121123132213111122211311332313211313211111112

কিভাবে?

শালীনতা এড়ানোর কৌশলগুলি হ'ল:

• " ইনপুট সহ জেলি কোডের মূল্যায়ন", এর পরে "অক্ষর থেকে অর্ডিনালে Oরূপান্তর " মোনাডকে 79একটি অক্ষরে রূপান্তরিত করে এড়ানোর জন্য ।Ọv

• ব্যবহার বাইনারি সরাসরি রূপান্তর এড়াতে B( 0x42, 1000010) সহজ দুই-বাইট বিকল্প দ্বারা b2জেনেরিক dyadic বেস রূপান্তর ব্যবহার করে।

• সমান বিটের রান গণনা করার জন্য কয়েকটি সাধারণ পছন্দ এড়াতে - প্রথম পছন্দটি "প্রদত্ত দৈর্ঘ্যের সমস্ত ওভারল্যাপিং স্লাইস", ṡ( 0xF5বা 11110101) হবে। দ্বিতীয় পছন্দ হতে পারে "সমস্ত সাবলিস্ট", Ẇ( 0xCFবা 11001111) ব্যবহার করা।
  বর্তমানের পূর্বে আমি যে কার্যকারিতাটি ব্যবহার করেছি তা হ'ল (ক্রমাগত উপাদানগুলির মধ্যে) দিয়ে I(শূন্য ও সমান পদক্ষেপে) রেখে, এবং পরপর তিনটি শূন্যের যে কোনও ঘটনা সন্ধান করতে। যে আমি সঙ্গে দ্বিপদ ফাংশন ব্যবহার দ্বারা জনকে সব zeros রূপান্তরিত করার জন্য 2cঅর্থাত 2Cx - উপার্জন -1পরিণত র 0গুলি 1গুলি পরিণত 2s, এবং 0গুলি পরিণত1; s এইভাবে কোডটি সাবলিস্টের [1,1,1]সাথে প্রথম উপস্থিতির সন্ধান করতে পারে w111।
  তবে একটি ছোট উপায় স্পষ্ট হয়ে উঠেছে - "প্রদত্ত দৈর্ঘ্যের সমস্ত ওভারল্যাপিং স্লাইস" এর ক্রিয়াকলাপের নকল ṡকরতে, কেউ কিছু ডায়াড দিয়ে 4- দিকের ওভারল্যাপিং হ্রাস ব্যবহার করতে পারে <dyad>4\। যদি +4\এটি সংযোজন সহ সঞ্চালিত হয় , তবে এটি গণনা করে 1, সুতরাং যে কোনও 0বা 4উপস্থিত থাকা সত্যবাদী মান ফেরত দেওয়ার জন্য সূচক। এখানে ইস্যু আগামী সুস্পষ্ট পদক্ষেপ মডিউল নিতে হবে হয় 4 যে লাগাতে 0এবং 4যখন অন্যান্য সম্ভাব্য মান (ছাড়ার একটি সমান পথ এন্ট্রি 1, 2এবং 3) অপরিবর্তিত কিন্তু +\%4হয়েছে\%ভিতরে, যা বিট-মান 010111 হয়েছে 0000 100100. যাতে শাস্তি এড়ানোর জন্য সংখ্যার সব বেস রূপান্তরিত হয় 4 সঙ্গে b4(ম্যাপিং 0করতে [0], 1করতে [1], 2করতে [2], 3করতে [3], এবং 4থেকে [1,0]) এবং পুরো তালিকা সঙ্গে চ্যাপ্টা হয় F। এখন শেষ পরীক্ষাটি কেবল 0তালিকায় কোনও এস আছে কিনা তা সরাসরি পরীক্ষা করে দেখানো হয়েছে, সরাসরি মোনাদের সাথে অর্জনযোগ্য Ạ।

79Ọv2;$ḅ⁹b2+4\b4FẠ - Main link: printable ASCII character list
79                 - 79
  Ọ                - character from ordinal : 'O'
   v               - evaluate as Jelly code : input -> 'O' converts the input to ordinals
      $            - last two links as a monad
    2              -     2
     ;             -     concatenate (why? see the note beneath the code block)
       ḅ⁹          - convert from base 256 : gets an integer representing the byte string
         b2        - convert to base 2 AKA binary
            4\     - 4-wise reduce with
           +       -     addition (sums all overlapping slices of length 4)
              b4   - convert to base 4 (vectorises)
                F  - flatten into a single list
                 Ạ - any falsy?

দ্রষ্টব্য: অর্ডিনাল তালিকার সাথে 2 টি সংশ্লেষিত হওয়ার কারণটি প্রান্তের মামলাগুলি মোকাবেলা করা হয় যেখানে ইনপুট স্ট্রিংয়ের 4 টির একমাত্র রান প্রথম অক্ষরের শীর্ষস্থানীয় জিরোগুলিতে থাকে - এই অক্ষরগুলি হ'ল: ট্যাব; লাইন ফিড; এবং গাড়ী চালনা। এটি ছাড়াই বেস 256 রূপান্তর কার্যকরভাবে (সম্পূর্ণরূপে) বাইনারি স্ট্রিং থেকে নেতৃস্থানীয় শূন্যগুলি কেটে ফেলেছে; শীর্ষস্থানীয় 2 সহ শীর্ষস্থানীয় জিরো থাকবে এবং তাদের আগে একটি অতিরিক্ত এবং শূন্য থাকবে। যেহেতু কোনও মুদ্রণযোগ্য এএসসিআইআইয়ের ঠিক তিনটি শীর্ষস্থানীয় শূন্য নেই, বাকি চেকের আগে এই অতিরিক্ত বিটগুলি ফেলে দেওয়ার দরকার নেই।

Comments

আমি ধরে নিচ্ছি আপনি মেনে চলার সাথে সাথে কেবল একটি অস্বীকৃতি বা অনুরূপ কিছু যোগ করতে পারেন সত্য এবং মিথ্যাচারের জন্য আপনার আউটপুট / প্রত্যাবর্তনের মানটি অবশ্যই সামঞ্জস্যপূর্ণ হতে হবে যা আমি "সত্যবাদীর জন্য প্রতিটি সময় একই মান" এবং মিথ্যাবাদের জন্য একই হিসাবে ব্যাখ্যা করি। এছাড়াও আপনার সত্য / মিথ্যা প্রশ্নটির বিপরীতে।

— এমিগনা

আমি কেবল সে সম্পর্কে অনুসন্ধান করেছি - যখন আমি মূলত এটি পড়েছিলাম (অনেক ঘন্টা আগে) আমি নিয়েছিলাম "সত্য এবং মিথ্যাচারের জন্য আপনি যে মান / আউটপুট / ফেরতের মান অবশ্যই সামঞ্জস্যপূর্ণ হতে হবে।" এর অর্থ দাঁড়ানোর জন্য আমরা এতক্ষণ উভয় পথেই আউটপুট বের করতে পারতাম যতক্ষণ না এটি রানের মাঝখানে একইভাবে থাকে ... একটি সরল ফরোয়ার্ড নেগেটের ক্ষতি হবে।

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

যদি আমার এটি না করতে হয় তবে আমি অবশ্যই কিছুটা সংরক্ষণ করতে পারি। আমি যে নতুন সংস্করণে কাজ করছি তা দিয়ে খুব কম স্কোর। আমি আশা করি আপনিই সেই যিনি সঠিকভাবে ব্যাখ্যা করেছেন :)

— এমিগিনা

ঠিক আছে, আমি একটি দুটি বাইট প্রত্যয় দিয়েছি যা কৌশলটি করে এবং এটি উভয়ের উদাহরণগুলির মতো একইভাবে প্রদান করে 0এবং 1যদি প্রয়োজন হয় তবে কঠোরভাবে সামঞ্জস্যপূর্ণ মানগুলি ।

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

খুশী হলাম। আপনি এটি কীভাবে করেছেন তা দেখার প্রত্যাশায় আমি কেবল 15 এ

— নামি

Answer 2

জাভা 7, 812 726 673 644 634 616 599 588 145 বাইট + 10 * 44 = 585

boolean
b(char[]b){String
g="";for(char
c:b)g+=g.format("%"+(1-1)+"8d",new
Integer(Integer.toString(c,2)));return!g.matches(".*(.)\\1\\1\\1.*");}

আমি পেনাল্টি হ্রাস করার চেষ্টা করার জন্য জায়গাগুলির পরিবর্তে নিউলাইনগুলি ব্যবহার করছি ...

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

বাইনারি

01100010011011110110111101101100011001010110000101101110000010100110001000101000011000110110100001100001011100100101101101011101011000100010100101111011010100110111010001110010011010010110111001100111000010100110011100111101001000100010001000111011011001100110111101110010001010000110001101101000011000010111001000001010011000110011101001100010001010010110011100101011001111010110011100101110011001100110111101110010011011010110000101110100001010000010001000100101001000100010101100101000001100010010110100110001001010010010101100100010001110000110010000100010001011000110111001100101011101110000101001001001011011100111010001100101011001110110010101110010001010000100100101101110011101000110010101100111011001010111001000101110011101000110111101010011011101000111001001101001011011100110011100101000011000110010110000110010001010010010100100101001001110110111001001100101011101000111010101110010011011100010000101100111001011100110110101100001011101000110001101101000011001010111001100101000001000100010111000101010001010000010111000101001010111000101110000110001010111000101110000110001010111000101110000110001001011100010101000100010001010010011101101111101

পুরানো বিটশিটিং সমাধান 141 বাইট + 10 * 101 = 1,151

boolean
b(char[]b){
int
o=0,p=0,i;
for(char
c:b){for(i=0;i<8;){if((c&(1<<i++))<1){o=0;p++;}else{p=0;o++;}if(3<o|3<p)return
6<5;}}return
5<6;}

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

বাইনারি

011000100110111101101111011011000110010101100001011011100000101001100010001010000110001101101000011000010111001001011011010111010110001000101001011110110000101001101001011011100111010000001010011011110011110100110000001011000111000000111101001100000010110001101001001110110000101001100110011011110111001000101000011000110110100001100001011100100000101001100011001110100110001000101001011110110110011001101111011100100010100001101001001111010011000000111011011010010011110000111000001110110010100101111011011010010110011000101000001010000110001100100110001010000011000100111100001111000110100100101011001010110010100100101001001111000011000100101001011110110110111100111101001100000011101101110000001010110010101100111011011111010110010101101100011100110110010101111011011100000011110100110000001110110110111100101011001010110011101101111101011010010110011000101000001100110011110001101111011111000011001100111100011100000010100101110010011001010111010001110101011100100110111000001010001101100011110000110101001110110111110101111101011100100110010101110100011101010111001001101110000010100011010100111100001101100011101101111101

Comments

নতুন লাইনের সাথে দুর্দান্ত কৌশল। গণনা 00000/ 11111দুই রান হিসাবে, 000000/ 111111হিসাবে তিন, ইত্যাদি। আমি মোট 101 রান গণনা।

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

@ ইথ প্রডাকশনগুলি স্থির করা হয়েছে

— পোকে

এটি কেবল জিততে হবে যেহেতু জাভা এর জন্য কখনই বোঝানো হয়নি

— ক্রিস্টোফার

Answer 3

এপিএল (ডায়ালগ ক্লাসিক) , 26 + 1 × 10 = 36 বাইট

নোট

1 এস এর 4-রান রয়েছে। প্রয়োজন ⎕IO←0অনেক সিস্টেমে পূর্বনির্ধারিত। নোট করুন যে এটি অবশ্যই একটি ক্লাসিক ইন্টারপ্রেটারে চালানো উচিত যাতে স্ট্রিংগুলি চরিত্র অনুসারে এক বাইট হয়।

নমন

1≠⊃⌽⌈\∊(×4\¨⍳≢⍬⍬)⍷¨⊂11⎕DR⍞

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

বাইনারি উত্স

_{^{00110001101011001001110010110010101010101110010111001001010001101111110100010111001010100010}} 1111 _{^{00101110101010101010100000100100101010101010001001010000000001100011000100010001000100010001 1000}}

ব্যাখ্যা

⍞ স্ট্রিং ইনপুট জন্য প্রম্পট

11 ⎕DR1- বিট বুলিয়ান ( 1 ) ডি আতা আর বর্ধনে  রূপান্তর করুন

⊂ সংযুক্ত করে রাখুন যাতে আমরা এতে একাধিক জিনিস প্রয়োগ করতে পারি

(… ) ⍷¨ বাইনারি সূচকগুলি যেখানে নিম্নলিখিত ক্রমগুলির প্রতিটি শুরু হয় ...

 × সাইন (বাইনারি ডেটাতে কোনও বিকল্প নেই, তবে রান বিভাজনে স্পেসার হিসাবে অন্তর্ভুক্ত)

 4 \¨ প্রতিটি দৈর্ঘ্যে প্রসারিত (অনুলিপি)

 ⍳ পূর্ণসংখ্যা পর্যন্ত

 ≢ এর ট্যালি

 ⍬⍬  দুটি খালি সংখ্যাসূচক তালিকা সমন্বিত তালিকা

∊ তালিকাভুক্ত (সমতল)

⌈\ মোটামুটি সর্বোচ্চ

⌽ বিপরীত

⊃ প্রথম বাছাই

1 ≠ এক থেকে আলাদা? (যেমন নয়)

হাঁটুন-থ্রু

আমরা "48" অবহেলিত অন-দে-চালিত সংস্করণে ইনপুট দেব ~ ∨/ ∊ (0 0 0 0)(1 1 1 1) ⍷¨ ⊂ 11 ⎕DR ⍞:

11 ⎕DR ⍞ "48" কে 0 0 1 1 0 1 0 0 0 1 1 1 0 0 0 (যেমন ডিসেম্বর 52 56, হেক্স 34 38) তে রূপান্তর করে

(0 0 0 0)(1 1 1 1) ⍷¨ ⊂0-রানের এবং 1-রানের সূচনা খুঁজে পায়; (0 0 0 0 0 0 1 1 0 0 0 0 0 0 0) (0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)

∨/ ∊সত্য আছে কিনা (যেমন কোনও রান) দেখায়; 1

~অবহেলা করে যে; 0

Answer 4

জেলি 28 + 140 গালি = 168

L8_0xṭ
OBUÇ€UFŒr<4FẠ

ব্যাখ্যা

OB

যুক্তিটিকে তাদের বাইনারি এনকোডিংগুলির তালিকায় রূপান্তর করে, যেমন

“U3”OB -> [[1, 0, 1, 0, 1, 0, 1], [1, 1, 0, 0, 1, 1]]

পরের অংশ

UÇ€U

উপরের তালিকাটি Bনেতৃস্থানীয় শূন্যগুলি অন্তর্ভুক্ত না করে অক্ষরগুলি হারিয়ে যেতে পারে এই বিষয়টি ঠিক করে । Ç€প্রতিটি উপাদানগুলির উপর পূর্বনির্ধারিত লিঙ্কটিকে কল করে যা এটি পুনরুদ্ধার করে

L8_0xṭ

এই লিঙ্কটি সমতুল্য

lambda x: x + repeat(0, 8 - len(x))

উদাহরণ স্বরূপ

[1, 1, 0, 0, 1, 1] L8_0xṭ -> [1, 1, 0, 0, 1, 1, [0, 0]]

এ্যাপেনডের পরিবর্তে প্রিপেন্ড হয়ে উঠার জন্য আমরা এই অপারেশনের আগে এবং পরে তালিকাকে আপলোড করি (সেই Uতালিকার দুটি কল)। পরের অংশ

FŒr

FASCII এনকোডিংয়ের মোট বাইনারি স্ট্রিং প্রদান করে তালিকাটি ( ) সমতল করে এবং রান-দৈর্ঘ্যের আউটপুট ( Œr) এনকোড করে । উদাহরণস্বরূপ

L8_0xṭ
“U3”OBUÇ€UF -> [1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0]

এবং

L8_0xṭ
“U3”OBUÇ€UFŒr -> [[1, 1], [0, 1], [1, 1], [0, 1], [1, 1], [0, 1], [1, 1], [0, 1], [1, 2], [0, 2], [1, 2], [0, 2]]

পরিশেষে আমরা প্রতিটি উপাদান <4 (শুকরিয়া এটি সর্বদা 0,1 এর জন্য সত্য) আছে কিনা তা যাচাই করি

<4F

উদাহরণ স্বরূপ

L8_0xṭ
“U3”OBUÇ€UFŒr<4F -> [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

পরিশেষে

Ạ

এর মধ্যে কেউ মিথ্যা বললে 0 প্রদান করে (এই ক্ষেত্রে 0)।

কোড পৃষ্ঠা

জেলির কোড পৃষ্ঠাতে এই কোডটি 20 বাইট, তবে নিয়ম লঙ্ঘনের জন্য 27 রান রয়েছে। ইউটিএফ -8 এ এটি 28 বাইট তবে লঙ্ঘনের মাত্র 14 রানের সাথে।

Answer 5

05 এ বি 1 ই , 22 + 3 * 10 = 52

জনাথন অ্যালানের জেলি উত্তর থেকে ডেল্টা ট্রিকের ধার নিয়ে 2 টি পেনাল্টি রক্ষা করা হয়েছে

$Ç256+bvy¦}J¥J6Ìb¦å2ÍQ

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

ব্যাখ্যা

$                       # push 1 and input (1 to handle the empty string)
 Ç                      # convert to list of ascii values
  256+                  # add 256 to each
      b                 # convert each to binary
       vy¦}             # chop off the leading digit of each
           J            # join to string
            ¥           # take delta's
             J          # join to string
              6Ìb¦      # push bin(6+2)[1:] = 000 
                  å     # check if this exists in the delta's string
                   2ÍQ  # compare to 2-2 = 0

কোড বাইনারি উপস্থাপনা

00100100 11000111 00110010 00110101 00110110 00101011 01100010 01110110
01111001 10100110 01111101 01001010 10100101 01001010 00110110 11001100
01100010 10100110 11100101 00110010 11001101 01010001

৩ টি পেনাল্টি রান আসে vy¦}যা থেকে প্রতিটি বাইনারি স্ট্রিংয়ের প্রথম বাইটটি কেটে ফেলার জন্য ব্যবহৃত হয়, তবে আমরা যে সংক্ষিপ্ততর হতে চাইছি তার চেয়ে 4 টি রানের তুলনায় এটি এখনও সস্তা €¦।

Comments

@ জোনাথান অ্যালান: আমি এটি শেষে কিছুটা উল্লেখ করেছি (তবে বিস্তারিতভাবে নয়), তবে দুর্ভাগ্যক্রমে €সিপি 10000000-১২২২ এর দ্বিপাক্ষিক উপস্থাপনা যা নিজেই চারটি জরিমানা আদায় করে।

— এমিগনা

আহ, তাই আপনি কি! ... এবং উপস্থাপনা পাওয়ার জন্য আমার পাইথন কোডটি ভুল ছিল যখন আমি # coding: cp1252শীর্ষে রেখেছিলাম _ _ <

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

Answer 6

পার্ল , 33 + 160 = 193

-nপতাকার জন্য 32 বাইট কোড + 1 বাইট ।

$_=unpack"B*";print!m+(.)\1\1\1+

(চূড়ান্ত নিউলাইন ছাড়াই ইনপুট সরবরাহ করা দরকার online এটি চেষ্টা করুন অনলাইন লিঙ্কে -lনতুন লাইনগুলি সরাতে পতাকা রয়েছে তবে একটি ইনপুটটির জন্য এটির দরকার নেই)।

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

এক্সএক্সডি ডাম্প:

00000000: 00100100 01011111 00111101 01110101 01101110 01110000  $_=unp
00000006: 01100001 01100011 01101011 00100010 01000010 00101010  ack"B*
0000000c: 00100010 00111011 01110000 01110010 01101001 01101110  ";prin
00000012: 01110100 00100001 01101101 00101011 00101000 00101110  t!m+(.
00000018: 00101001 01011100 00110001 01011100 00110001 01011100  )\1\1\
0000001e: 00110001 00101011                                      1+

কয়েকটি নোট:

• (.)\1\1\1কয়েক জরিমানা উপর সংরক্ষণ (.)\1{3}, 1111|0{4}বা অন্য কোন Regex কথা আমার মনে পড়েছে (ব্যবহার 0বা {}একটি ভারী খরচে আসে)।
• printব্যবহার করে points 8 পয়েন্ট সাশ্রয় করে -pএবং $_=কারণ p4 এর একটি রান রয়েছে 0যখন nনা হয়।
• +যেমন Regex জন্য বিভেদক সংরক্ষণ এর একটি রান 1যে হয় /।
• সঙ্গে এক পরিবর্তে দুই ধাপ করছেন !~দুই রান সংরক্ষণ ( ~হয় 01111110বাইনারি মধ্যে)।
• unpack"B*"বেশ ব্যয়বহুল (4 রান), তবে আমি সস্তা খুঁজে পেলাম না (সমাধান বেসগুলি ordআরও ব্যয়বহুল হবে)।

Answer 7

পিএইচপি, 98 + 270 = 368 বাইট

আমি তিতাস যে প্রস্তাব দিয়েছিল তার থেকে আলাদা পন্থা নিতে চেয়েছি , এবং কিছুটা দীর্ঘতর, তবুও কম শাস্তিপ্রাপ্ত কর্মসূচি দিয়ে শেষ হয়েছিল ended

$v=unpack('H*',$argv[1]);$e=base_convert($v[1],16,2);echo!stristr($e,'0000')&&!stristr($e,'1111');

1সত্যের জন্য ফলাফল , মিথ্যা জন্য কিছুই।

এখানে চেষ্টা করুন!

বাইনারি-এনকোডযুক্ত:

0010010001110110001111010111010101101110011100000110000101100011011010110010100
0001001110100100000101010001001110010110000100100011000010111001001100111011101
1001011011001100010101110100101001001110110010010001100101001111010110001001100
0010111001101100101010111110110001101101111011011100111011001100101011100100111
0100001010000010010001110110010110110011000101011101001011000011000100110110001
0110000110010001010010011101101100101011000110110100001101111001000010111001101
1101000111001001101001011100110111010001110010001010000010010001100101001011000
0100111001100000011000000110000001100000010011100101001001001100010011000100001
0111001101110100011100100110100101110011011101000111001000101000001001000110010
1001011000010011100110001001100010011000100110001001001110010100100111011

(22 0000টি ঘটনা এবং 5 টি ঘটনা 1111, অতএব জরিমানার 270 বাইট)

Answer 8

পিএইচপি, 86 বাইট + 370 = 456

for(;$c=ord($argn[$i++]);)$s.=sprintf("%08b",$c);echo!preg_match("#(.)\\1\\1\\1#",$s);

বাইনারি স্ট্রিং তৈরি করে এবং রেখাগুলি সনাক্ত করতে একটি রেজেক্স ব্যবহার করে। আউটপুট 1সত্যের জন্য; মিথ্যা জন্য খালি।

সাথে চালাও echo '<string>' | php -nR '<code>'।

সমন্বয়

• backreferences 3 বাইট জন্য 100 জরিমানা সংরক্ষণ করুন। (-97 স্কোর)

পরিত্যক্ত ধারণা

• join(array_map(str_split())) 31 বাইট এবং 90 পেনাল্টি লাগবে
• এবং <?=/ এর $argv[1]পরিবর্তে echo/ $argnআরও 2 + 40 খরচ হয়।
• str_pad(decbin())এর চেয়ে ব্যয়বহুল sprintf: 7 বাইট এবং 110 পেনাল্টি।
• strtr 13 টি অতিরিক্ত বাইটের জন্য 80 জরিমানা সাশ্রয় করে তবে পিছনে উল্লেখগুলি আরও ভাল।
• ব্যাকেরেফারেন্সগুলিকে গ্রুপিং করা #(.)\\1{3}3 বাইট সাশ্রয় করে তবে 10 টি পেনাল্টি যুক্ত করে।
• foreach 3 + 50 এর দাম।
• চলক নামগুলিতে কোনও সঞ্চয় সম্ভব নয়।
• আউটপুট বাফারিংয়ের জন্য 42 + 120 খরচ হয়।

Comments

জন্য একটি §যোগ for(§;করুন -9।

— ক্রিস্টোফ

Answer 9

এমএটিএল, 16 বাইট + 60 = 76 বাইট

8&B!1e&Y'tgw4<Z&

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

Answer 10

জাভাস্ক্রিপ্ট (ES8), 91 বাইট + 430 জরিমানা = 521 মোট

এই ইচ্ছার আউটপুট 1জন্য trueএবং 0জন্য false।

s=>1-/(.)\1\1\1/.test([...s].map(c=>c.charCodeAt().toString(2).padStart(3+5,1-1)).join(""))

01110011001111010011111000110001001011010010111100101000001011100010100101011100001100010101110000110001010111000011000100101111001011100111010001100101011100110111010000101000010110110010111000101110001011100111001101011101001011100110110101100001011100000010100001100011001111010011111001100011001011100110001101101000011000010111001001000011011011110110010001100101010000010111010000101000001010010010111001110100011011110101001101110100011100100110100101101110011001110010100000110010001010010010111001110000011000010110010001010011011101000110000101110010011101000010100000110011001010110011010100101100001100010010110100110001001010010010100100101110011010100110111101101001011011100010100000100010001000100010100100101001

---

চেষ্টা করে দেখুন

f=

s=>1-/(.)\1\1\1/.test([...s].map(c=>c.charCodeAt().toString(2).padStart(3+5,1-1)).join(""))

console.log(f("U3"))
console.log(f("48"))
console.log(f("Foobar"))
console.log(f("Feeber"))
console.log(f("$H"))
console.log(f(""))

Comments

padStartES6 এ নেই।

— নীল

ধুর! ছাই! আমি যখনই এটি ব্যবহার করি ES8 এ পরিবর্তন করতে ভুলে যাচ্ছি (ইএস 7 এবং একই Array.includes()) - ধন্যবাদ, @ নীল il

— শেগি

Answer 11

সিজেম , 23 বাইট

ডেল্টাসের সাথে কাজ করতে জোনাথন অ্যালানের ধারণা ব্যবহার করে ।

1q256b2b2ew::-[TTT]#)g-

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

বাইনারি প্রতিনিধিত্ব:

00110001011100010011001000110101
00110110011000100011001001100010
00110010011001010111011100111010
00111010001011010101101101010100
01010100010101000101110100100011
001010010110011100101101

ব্যাখ্যা:

1     e# Push a 1 for (much) later, because we can't use ! for logical NOT.
q     e# Read input.
256b  e# Treat characters as base 256 digits.
2b    e# Convert to binary. The last two steps together give us a flat binary
      e# representation of the input, avoiding both :~ and e_ for flattening.
2ew   e# Get all pairs of consecutive bits.
::-   e# Compute their differences.
[TTT] e# Push [0 0 0].
#     e# Find its index in the list of differences, or -1 if not found.
)g    e# Increment and take signum. We've now got the result we want but 
      e# with the wrong truth value.
-     e# Subtract it from the 1 we pushed earlier to negate the truth value.

Answer 12

পাইথ, 19 + 12 * 10 = 139

!|}*"0"4.BQ}*"1"4.B

বাইনারি

00100001 01111100 01111101 00101010
00100010 00110000 00100010 00110100
00101110 01000010 01010001 01111101
00101010 00100010 00110001 00100010
00110100 00101110 01000010         

ব্যাখ্যা

!|}*"0"4.BQ}*"1"4.B
            *"1"4     # Repeat  ; '1111'
                 .B   # Convert ; input as a binary string
           }          # In      ; '1111' in the binary repr
   *"0"4              # Repeat  ; '0000'
        .BQ           # Convert ; input as a binary string
  }                   # In      ; '0000' in the binary repr
 |                    # Or      ; 4 consequent idenical digits found
!                     # Negate  ; True if not found, False if found

Answer 13

জাভাস্ক্রিপ্ট, 173 + 89 * 10 = 1063

স্ট্রিংগুলিকে বাইনারি রূপান্তর করাতে জাভাস্ক্রিপ্টটি ভাল নয় তবে আমি অনুভব করেছি যে আমি এই চ্যালেঞ্জটিকে কেবল মজাদার জন্য একটি শট দেব।

কোড:

function(n){b="";for(var t=0;t<n.length;t++)c=[n.charCodeAt(t).toString(2)],c.unshift(Array(8-c[0].length+1).join(0)),b+=c.join("");return b.match(/[1]{4,}|[0]{4,}/g)?!1:!0}

বাইনারি:

0110011001110101011011100110001101110100011010010110111101101110001010000110111000101001011110110110001000111101001000100010001000111011011001100110111101110010001010000111011001100001011100100010000001110100001111010011000000111011011101000011110001101110001011100110110001100101011011100110011101110100011010000011101101110100001010110010101100101001011000110011110101011011011011100010111001100011011010000110000101110010010000110110111101100100011001010100000101110100001010000111010000101001001011100111010001101111010100110111010001110010011010010110111001100111001010000011001000101001010111010010110001100011001011100111010101101110011100110110100001101001011001100111010000101000010000010111001001110010011000010111100100101000001110000010110101100011010110110011000001011101001011100110110001100101011011100110011101110100011010000010101100110001001010010010111001101010011011110110100101101110001010000011000000101001001010010010110001100010001010110011110101100011001011100110101001101111011010010110111000101000001000100010001000101001001110110111001001100101011101000111010101110010011011100010000001100010001011100110110101100001011101000110001101101000001010000010111101011011001100010101110101111011001101000010110001111101011111000101101100110000010111010111101100110100001011000111110100101111011001110010100100111111001000010011000100111010001000010011000001111101

ব্যাখ্যা:

এর সাথে কাজ করার জন্য একটি স্ট্রিং তৈরি করুন:

b="";

স্ট্রিংয়ের প্রতিটি অক্ষরের উপরে লুপ করুন:

for(var t=0;t<n.length;t++)

একটি অ্যারে তৈরি করুন এবং অক্ষর কোড ব্যবহার করে স্ট্রিংটিকে বাইনারি রূপান্তর করুন:

c=[n.charCodeAt(t).toString(2)]

অ্যারেতে নেতৃস্থানীয় শূন্যগুলি যুক্ত করুন:

c.unshift(Array(8-c[0].length+1).join(0))

অ্যারেটিকে আবার স্ট্রিংয়ে যোগ দিন:

b+=c.join("")

নিয়মিত অভিব্যক্তি ব্যবহার করে বাইনারি ফলাফলে চার বা তার বেশি 1 বা 0 এর স্ট্রিং পাওয়া গিয়েছিল কিনা তা ফিরিয়ে দিন:

return b.match(/[1]{4,}|[0]{4,}/g)?!1:!0

বেহালার:

https://jsfiddle.net/vrtLh97c/

স্থিতি:

দৈর্ঘ্য: 173 বাইট পেনাল্টি: 890 মোট: 1063

কোড গল্ফ কঠিন :)

Comments

আপনি কি আপনার কোডের বাইনারি উপস্থাপনা প্রদান করতে পারেন এবং জরিমানার দলিলগুলি দিতে পারেন?

— পাভেল

এই 1063. মোট স্কোর জন্য 890 একটি শাস্তি আছে

— পাভেল

মূল পোস্টে মোট যোগ করা হয়েছে।

— স্টিফেনরিওস

কয়েকটি জায়গায় 1-1পরিবর্তে ব্যবহার করা 0আপনাকে কিছু অসুবিধা বাঁচাতে পারে।

— পোকে

Answer 14

পাইথ, 21 + 2 * 10 = 41

J-T2-4eS%2.nr.[dJ.BwJ

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

বাইনারি প্রতিনিধিত্ব:

01001010 00101101 010101[00 00]110010 00101101 00110100 01100101 01010011
00100101 00110010 00101110 01101110 01110010 00101110 01011011 01100100
01001010 00101110 01[0000]10 01110111 01001010

Answer 15

রেটিনা, 101 + 1390 = 1491

কোডটিতে অপ্রিন্টযোগ্য অক্ষর রয়েছে তবে আপনি পোস্টটি সম্পাদনা করলে তারা Chrome এ প্রদর্শিত হবে। -হয় \x01-\x7f।

¶
±
S_`
%(S`±
{2`
$`
}T01`-`_o
)Ms`.
.+
$*
+`(1+)\1
${1}0
01
1
m+`^(?!.{8})
0
0{8}|¶

M&`(.)\1{3}
0

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

এই কোড ব্যবহার এইord , বাইনারিতে রূপান্তর এবং চার ক্রমের সাথে ওভারল্যাপিং জন্য একটি সহজ চেকের মাধ্যমে অনুসরণ করে।

বাইনারি মধ্যে:

11000010101101100000101011000010101100010000101001010011010111110110000000001010001001010010100001010011011000001100001010110001000010100111101100110010011000000000101000100100011000000000101001111101010101000011000000110001011000000000000100101101011111110110000001011111011011110000101000101001010011010111001101100000001011100000101000101110001010110000101000100100001010100000101000101011011000000010100000110001001010110010100100000001000010100010010001111011001100010111110100110000000010100011000000110001000010100011000100001010011011010010101101100000010111100010100000111111001000010010111001111011001110000111110100101001000010100011000000001010001100000111101100111000011111010111110011000010101101100000101000001010010011010010011001100000001010000010111000101001000000010111101100110011011111010000101000110000

এই পাইথন প্রোগ্রামের সাথে জরিমানা গণনা করা হয়েছে ।

Comments

দয়া করে একটি হেক্সডাম্প এবং বাইনারি প্রতিনিধিত্ব করুন, যেহেতু এটিতে ছাপছাড়া রয়েছে।

— পাভেল

আমি ইতিমধ্যে বলেছি যে অ-প্রিন্টেবলগুলি কী / যেখানে বাইনারি স্ট্রিং (নীচে লাইনটি সংলগ্ন করে) মুদ্রণ করতে পারে এমন একটি প্রোগ্রাম সরবরাহ করার পাশাপাশি রয়েছে।

— mbomb007

ঠিক আছে, তাহলে ..

— পাভেল

Answer 16

পাইথন 2 , 74 (দৈর্ঘ্য) + 130 (জরিমানা) = 204

k,n=2*[1]
for[c]in(input(n)*2*2*2)[:1:-1]:n,k=k*ord(c[:n%16%15])+n/2,k*128

আউটপুট প্রস্থান কোড মাধ্যমে হয়; 0 সত্যবাদী, 1 টি মিথ্যা। STDOUT এবং STDERR এ বর্জ্য আউটপুট উত্পাদন করে।

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

বাইনারি ডাম্প

00000000: 01101011 00101100 01101110 00111101 00110010 00101010  k,n=2*
00000006: 01011011 00110001 01011101 00001010 01100110 01101111  [1].fo
0000000c: 01110010 01011011 01100011 01011101 01101001 01101110  r[c]in
00000012: 00101000 01101001 01101110 01110000 01110101 01110100  (input
00000018: 00101000 01101110 00101001 00101010 00110010 00101010  (n)*2*
0000001e: 00110010 00101010 00110010 00101001 01011011 00111010  2*2)[:
00000024: 00110001 00111010 00101101 00110001 01011101 00111010  1:-1]:
0000002a: 01101110 00101100 01101011 00111101 01101011 00101010  n,k=k*
00000030: 01101111 01110010 01100100 00101000 01100011 01011011  ord(c[
00000036: 00111010 01101110 00100101 00110001 00110110 00100101  :n%16%
0000003c: 00110001 00110101 01011101 00101001 00101011 01101110  15])+n
00000042: 00101111 00110010 00101100 01101011 00101010 00110001  /2,k*1
00000048: 00110010 00111000                                      28

Comments

আমি দেখতে পেয়েছি যে 0এটি অন্তর্ভুক্ত করা বেশ খারাপ। এটি ব্যবহার করা আরও ভাল1-1

— পোকে

@ পোকে আমি কেবল আমার ভুল বুঝতে পেরেছি ফলাফল অব্যবহৃত, সুতরাং আমি কেন 0প্রথম স্থানে উঠলাম তা নিশ্চিত নই ।

— ডেনিস

Answer 17

জাভাস্ক্রিপ্ট (ES6), 87 88 + 390 380 = 477 468 বাইট

s=>1-/(.)\1\1\1/.test(s.replace(/[\S\s]/g,c=>(256+c.charCodeAt()).toString(2).slice(1)))

বাইনারি মধ্যে:

01110011001111010011111000110001001011010010111100101000001011100010100101011100001100010101110000110001010111000011000100101111001011100111010001100101011100110111010000101000011100110010111001110010011001010111000001101100011000010110001101100101001010000010111101011011010111000101001101011100011100110101110100101111011001110010110001100011001111010011111000101000001100100011010100110110001010110110001100101110011000110110100001100001011100100100001101101111011001000110010101000001011101000010100000101001001010010010111001110100011011110101001101110100011100100110100101101110011001110010100000110010001010010010111001110011011011000110100101100011011001010010100000110001001010010010100100101001

দণ্ড ওভার অর্ধেক বাইট মধ্যে ওভারল্যাপ মধ্যে শূন্য থেকে নিচে, বরং নিম্নলিখিত অক্ষর রান চেয়ে: =>//pa//=>aCoAo।

যেহেতু /গুলি ( 00101111) একটি পেনাল্টি আমি চেষ্টা) থেকে সুইচিং দিতে testকরার matchখ) থেকে সুইচিং replaceকরতে mapকিন্তু স্কোর সর্বদা উচ্চ শেষ পর্যন্ত। তবে আমি এটি [\S\s]একটি উন্নতি ওভার ছিল খুঁজে পেয়েছি [^]। সম্পাদনা: 9 শে বাইট সামগ্রিকভাবে @ শ্যাগিকে ধন্যবাদ।

Comments

আমি মনে করি |চরিত্রের শ্রেণিতে সেখানে থাকার কথা নেই

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

@ ইথ প্রডাকশনগুলি আমি আমার ব্যাখ্যাটিতে ঠিক পেয়েছি ...

— নিল

আপনি প্রতিস্থাপন করে আপনার শাস্তি বন্ধ 10 শেভ পারে !সঙ্গে 1-468. মোট আর তুমি প্রতিস্থাপন 5 বাইটের আরও সংরক্ষণ করতে পারে [\S\s]সঙ্গে .এর 463. মোট

— রোমশ

@ শেগি ধন্যবাদ, যদিও আমি নিশ্চিত নই যে নিউলাইনগুলি মুদ্রণযোগ্য হিসাবে গণনা করা হচ্ছে, তাই আমি আপাতত এটি নিরাপদে খেলব।

— নীল

জেএসগুলি কোনও মাল্টলাইন রেজেক্স পতাকাটিকে সমর্থন করে? যদি তা হয় তবে আপনি শেগির পরামর্শটি মেনে নিতে এবং বাইটগুলি সংরক্ষণ করার জন্য পতাকাটি যুক্ত করতে পারেন।

— পাভেল

Answer 18

পাইথ , 16 + 1 x 10 = 26 বাইট

qZsm:.BQjk*4]dZ2
   m           2  for d being the natural numbers below 2
            ]d        [d]
          *4          [d,d,d,d]
        jk            "dddd"
    :         Z       search for the above in
     .BQ              the binary representation of the input
                      (true/false)
  s               sum the 2-element array generated above, 1 for True, 0 for False
qZ                is equal to 0

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

বাইনারি

01110001 01011010 01110011 01101101
00111010 00101110 01[0000]10 01010001
01101010 01101011 00101010 00110100
01011101 01100100 01011010 00110010

ঠাট

নিম্নবর্ণিত পদক্ষেপগুলি এড়াতে নিম্নলিখিত বিকল্পগুলি করা হয়:

• ব্যবহার qZ(শূন্য সমান) পরিবর্তে !(অস্বীকার)
• ব্যবহার :xy0(অনুসন্ধান) পরিবর্তে }xy(sublist হয়)
• ব্যবহার Z(পরিবর্তনশীল, শূন্য থেকে ডিফল্ট) পরিবর্তে 0(নিজেই শূন্য)

উন্নতি

আমি জরিমানা ঠেকানোর কোনও উপায় খুঁজে পাই না। আমাদের বাইনারি সম্পর্কিত এই কমান্ড রয়েছে:

• .Bবাইনারি ( 00101110 01[0000]10)
• Cচারকোড ( 01[0000]11)
• .Oঅষ্টমী ( 00101110 0100[1111])
• .Hহেক্সাডেসিমাল ( 00101110 01001[000)

নোট এটি .Hআমাদের একটি জরিমানাও দেবে, কারণ প্রতিটি মুদ্রণযোগ্য চরিত্রের বাইনারি উপস্থাপনা শুরু হয় 0। অতএব, আমি সর্বাধিক প্রত্যক্ষ ব্যবহার করেছি, যা.B সরাসরি বাইনারি রূপান্তরিত করে।

আমি .Hপেনাল্টি এড়াতে শেষ করতে পারি , তবে এটির জন্য আমার 27 বাইট ...

প্রজন্ম

আমি সমস্ত অনুমোদিত অক্ষর পেয়েছি, যা এমনগুলি রয়েছে যা ধারণ করে না 0000বা থাকে 1111এবং যা শেষ হয় না 000(কারণ পরবর্তী অক্ষরটি অবশ্যই শুরু করা উচিত 0):

• "#$%&')*+,-.12345679:;DEFGIJKLMNQRSTUVWYZ[\]bcdefgijklmnqrstuvw

এখানে অক্ষরগুলি শেষ হয় 1000। এগুলি কেবল শেষে ব্যবহার করা যেতে পারে:

• (8HXhx